2010-09-20 22:08:53 +02:00
|
|
|
<!-- doc/src/sgml/pgtrgm.sgml -->
|
2007-12-10 06:32:51 +01:00
|
|
|
|
2011-05-08 04:29:20 +02:00
|
|
|
<sect1 id="pgtrgm" xreflabel="pg_trgm">
|
2007-11-11 00:30:46 +01:00
|
|
|
<title>pg_trgm</title>
|
2007-12-10 06:32:51 +01:00
|
|
|
|
2007-11-11 00:30:46 +01:00
|
|
|
<indexterm zone="pgtrgm">
|
2007-12-02 23:33:20 +01:00
|
|
|
<primary>pg_trgm</primary>
|
2007-11-11 00:30:46 +01:00
|
|
|
</indexterm>
|
|
|
|
|
|
|
|
<para>
|
2007-12-10 06:32:51 +01:00
|
|
|
The <filename>pg_trgm</filename> module provides functions and operators
|
2013-04-09 07:05:55 +02:00
|
|
|
for determining the similarity of
|
2011-09-05 19:24:45 +02:00
|
|
|
alphanumeric text based on trigram matching, as
|
2007-12-10 06:32:51 +01:00
|
|
|
well as index operator classes that support fast searching for similar
|
|
|
|
strings.
|
2007-11-11 00:30:46 +01:00
|
|
|
</para>
|
|
|
|
|
|
|
|
<sect2>
|
2007-12-10 06:32:51 +01:00
|
|
|
<title>Trigram (or Trigraph) Concepts</title>
|
|
|
|
|
2007-11-11 00:30:46 +01:00
|
|
|
<para>
|
2007-12-10 06:32:51 +01:00
|
|
|
A trigram is a group of three consecutive characters taken
|
|
|
|
from a string. We can measure the similarity of two strings by
|
|
|
|
counting the number of trigrams they share. This simple idea
|
|
|
|
turns out to be very effective for measuring the similarity of
|
|
|
|
words in many natural languages.
|
2007-11-11 00:30:46 +01:00
|
|
|
</para>
|
2007-12-10 06:32:51 +01:00
|
|
|
|
|
|
|
<note>
|
|
|
|
<para>
|
2013-04-09 07:05:55 +02:00
|
|
|
<filename>pg_trgm</filename> ignores non-word characters
|
|
|
|
(non-alphanumerics) when extracting trigrams from a string.
|
|
|
|
Each word is considered to have two spaces
|
2007-12-10 06:32:51 +01:00
|
|
|
prefixed and one space suffixed when determining the set
|
|
|
|
of trigrams contained in the string.
|
|
|
|
For example, the set of trigrams in the string
|
|
|
|
<quote><literal>cat</literal></quote> is
|
|
|
|
<quote><literal> c</literal></quote>,
|
|
|
|
<quote><literal> ca</literal></quote>,
|
|
|
|
<quote><literal>cat</literal></quote>, and
|
|
|
|
<quote><literal>at </literal></quote>.
|
2013-04-09 07:05:55 +02:00
|
|
|
The set of trigrams in the string
|
|
|
|
<quote><literal>foo|bar</literal></quote> is
|
|
|
|
<quote><literal> f</literal></quote>,
|
|
|
|
<quote><literal> fo</literal></quote>,
|
|
|
|
<quote><literal>foo</literal></quote>,
|
|
|
|
<quote><literal>oo </literal></quote>,
|
|
|
|
<quote><literal> b</literal></quote>,
|
|
|
|
<quote><literal> ba</literal></quote>,
|
|
|
|
<quote><literal>bar</literal></quote>, and
|
|
|
|
<quote><literal>ar </literal></quote>.
|
2007-12-10 06:32:51 +01:00
|
|
|
</para>
|
|
|
|
</note>
|
2007-11-11 00:30:46 +01:00
|
|
|
</sect2>
|
|
|
|
|
|
|
|
<sect2>
|
2007-12-10 06:32:51 +01:00
|
|
|
<title>Functions and Operators</title>
|
|
|
|
|
2011-05-04 19:24:07 +02:00
|
|
|
<para>
|
|
|
|
The functions provided by the <filename>pg_trgm</filename> module
|
|
|
|
are shown in <xref linkend="pgtrgm-func-table">, the operators
|
|
|
|
in <xref linkend="pgtrgm-op-table">.
|
|
|
|
</para>
|
|
|
|
|
2007-12-10 06:32:51 +01:00
|
|
|
<table id="pgtrgm-func-table">
|
2011-01-29 19:00:18 +01:00
|
|
|
<title><filename>pg_trgm</filename> Functions</title>
|
2007-12-10 06:32:51 +01:00
|
|
|
<tgroup cols="3">
|
2007-11-11 00:30:46 +01:00
|
|
|
<thead>
|
|
|
|
<row>
|
|
|
|
<entry>Function</entry>
|
2007-12-10 06:32:51 +01:00
|
|
|
<entry>Returns</entry>
|
2007-11-11 00:30:46 +01:00
|
|
|
<entry>Description</entry>
|
|
|
|
</row>
|
|
|
|
</thead>
|
2007-12-10 06:32:51 +01:00
|
|
|
|
2007-11-11 00:30:46 +01:00
|
|
|
<tbody>
|
|
|
|
<row>
|
2013-07-04 17:33:08 +02:00
|
|
|
<entry><function>similarity(text, text)</function><indexterm><primary>similarity</primary></indexterm></entry>
|
2007-12-10 06:32:51 +01:00
|
|
|
<entry><type>real</type></entry>
|
2007-11-11 00:30:46 +01:00
|
|
|
<entry>
|
2007-12-10 06:32:51 +01:00
|
|
|
Returns a number that indicates how similar the two arguments are.
|
|
|
|
The range of the result is zero (indicating that the two strings are
|
|
|
|
completely dissimilar) to one (indicating that the two strings are
|
|
|
|
identical).
|
2007-11-11 00:30:46 +01:00
|
|
|
</entry>
|
|
|
|
</row>
|
|
|
|
<row>
|
2013-07-04 17:33:08 +02:00
|
|
|
<entry><function>show_trgm(text)</function><indexterm><primary>show_trgm</primary></indexterm></entry>
|
2007-12-10 06:32:51 +01:00
|
|
|
<entry><type>text[]</type></entry>
|
2007-11-11 00:30:46 +01:00
|
|
|
<entry>
|
2007-12-10 06:32:51 +01:00
|
|
|
Returns an array of all the trigrams in the given string.
|
|
|
|
(In practice this is seldom useful except for debugging.)
|
2007-11-11 00:30:46 +01:00
|
|
|
</entry>
|
|
|
|
</row>
|
2016-03-16 16:59:21 +01:00
|
|
|
<row>
|
|
|
|
<entry>
|
|
|
|
<function>word_similarity(text, text)</function>
|
|
|
|
<indexterm><primary>word_similarity</primary></indexterm>
|
|
|
|
</entry>
|
|
|
|
<entry><type>real</type></entry>
|
|
|
|
<entry>
|
|
|
|
Returns a number that indicates how similar the first string
|
|
|
|
to the most similar word of the second string. The function searches in
|
|
|
|
the second string a most similar word not a most similar substring. The
|
|
|
|
range of the result is zero (indicating that the two strings are
|
|
|
|
completely dissimilar) to one (indicating that the first string is
|
|
|
|
identical to one of the word of the second string).
|
|
|
|
</entry>
|
|
|
|
</row>
|
2007-11-11 00:30:46 +01:00
|
|
|
<row>
|
2013-07-04 17:33:08 +02:00
|
|
|
<entry><function>show_limit()</function><indexterm><primary>show_limit</primary></indexterm></entry>
|
2007-12-10 06:32:51 +01:00
|
|
|
<entry><type>real</type></entry>
|
2007-11-11 00:30:46 +01:00
|
|
|
<entry>
|
2007-12-10 06:32:51 +01:00
|
|
|
Returns the current similarity threshold used by the <literal>%</>
|
|
|
|
operator. This sets the minimum similarity between
|
|
|
|
two words for them to be considered similar enough to
|
2016-03-16 15:44:58 +01:00
|
|
|
be misspellings of each other, for example
|
|
|
|
(<emphasis>deprecated</emphasis>).
|
2007-11-11 00:30:46 +01:00
|
|
|
</entry>
|
|
|
|
</row>
|
|
|
|
<row>
|
2013-07-04 17:33:08 +02:00
|
|
|
<entry><function>set_limit(real)</function><indexterm><primary>set_limit</primary></indexterm></entry>
|
2007-12-10 06:32:51 +01:00
|
|
|
<entry><type>real</type></entry>
|
2007-11-11 00:30:46 +01:00
|
|
|
<entry>
|
2007-12-10 06:32:51 +01:00
|
|
|
Sets the current similarity threshold that is used by the <literal>%</>
|
|
|
|
operator. The threshold must be between 0 and 1 (default is 0.3).
|
2016-03-16 15:44:58 +01:00
|
|
|
Returns the same value passed in (<emphasis>deprecated</emphasis>).
|
2007-11-11 00:30:46 +01:00
|
|
|
</entry>
|
|
|
|
</row>
|
2007-12-10 06:32:51 +01:00
|
|
|
</tbody>
|
|
|
|
</tgroup>
|
|
|
|
</table>
|
|
|
|
|
|
|
|
<table id="pgtrgm-op-table">
|
2011-01-29 19:00:18 +01:00
|
|
|
<title><filename>pg_trgm</filename> Operators</title>
|
2007-12-10 06:32:51 +01:00
|
|
|
<tgroup cols="3">
|
|
|
|
<thead>
|
2007-11-11 00:30:46 +01:00
|
|
|
<row>
|
2007-12-10 06:32:51 +01:00
|
|
|
<entry>Operator</entry>
|
|
|
|
<entry>Returns</entry>
|
|
|
|
<entry>Description</entry>
|
|
|
|
</row>
|
|
|
|
</thead>
|
|
|
|
|
|
|
|
<tbody>
|
|
|
|
<row>
|
|
|
|
<entry><type>text</> <literal>%</literal> <type>text</></entry>
|
|
|
|
<entry><type>boolean</type></entry>
|
2007-11-11 00:30:46 +01:00
|
|
|
<entry>
|
2007-12-10 06:32:51 +01:00
|
|
|
Returns <literal>true</> if its arguments have a similarity that is
|
|
|
|
greater than the current similarity threshold set by
|
2016-03-16 15:44:58 +01:00
|
|
|
<varname>pg_trgm.similarity_threshold</>.
|
2007-11-11 00:30:46 +01:00
|
|
|
</entry>
|
|
|
|
</row>
|
2016-03-16 16:59:21 +01:00
|
|
|
<row>
|
|
|
|
<entry><type>text</> <literal>%></literal> <type>text</></entry>
|
|
|
|
<entry><type>boolean</type></entry>
|
|
|
|
<entry>
|
|
|
|
Returns <literal>true</> if its first argument has the similar word in
|
|
|
|
the second argument and they have a similarity that is greater than the
|
|
|
|
current word similarity threshold set by
|
|
|
|
<varname>pg_trgm.word_similarity_threshold</> parameter.
|
|
|
|
</entry>
|
|
|
|
</row>
|
2010-12-04 06:16:21 +01:00
|
|
|
<row>
|
|
|
|
<entry><type>text</> <literal><-></literal> <type>text</></entry>
|
|
|
|
<entry><type>real</type></entry>
|
|
|
|
<entry>
|
|
|
|
Returns the <quote>distance</> between the arguments, that is
|
|
|
|
one minus the <function>similarity()</> value.
|
|
|
|
</entry>
|
|
|
|
</row>
|
2016-03-16 16:59:21 +01:00
|
|
|
<row>
|
|
|
|
<entry>
|
|
|
|
<type>text</> <literal><->></literal> <type>text</>
|
|
|
|
</entry>
|
|
|
|
<entry><type>real</type></entry>
|
|
|
|
<entry>
|
|
|
|
Returns the <quote>distance</> between the arguments, that is
|
|
|
|
one minus the <function>word_similarity()</> value.
|
|
|
|
</entry>
|
|
|
|
</row>
|
2007-11-11 00:30:46 +01:00
|
|
|
</tbody>
|
|
|
|
</tgroup>
|
|
|
|
</table>
|
|
|
|
</sect2>
|
|
|
|
|
2016-03-16 15:44:58 +01:00
|
|
|
<sect2>
|
|
|
|
<title>GUC Parameters</title>
|
|
|
|
|
|
|
|
<variablelist>
|
|
|
|
<varlistentry id="guc-pgtrgm-similarity-threshold" xreflabel="pg_trgm.similarity_threshold">
|
|
|
|
<term>
|
|
|
|
<varname>pg_trgm.similarity_threshold</> (<type>real</type>)
|
|
|
|
<indexterm>
|
|
|
|
<primary><varname>pg_trgm.similarity_threshold</> configuration parameter</primary>
|
|
|
|
</indexterm>
|
|
|
|
</term>
|
|
|
|
<listitem>
|
|
|
|
<para>
|
|
|
|
Sets the current similarity threshold that is used by the <literal>%</>
|
|
|
|
operator. The threshold must be between 0 and 1 (default is 0.3).
|
|
|
|
</para>
|
|
|
|
</listitem>
|
|
|
|
</varlistentry>
|
2016-03-16 16:59:21 +01:00
|
|
|
<varlistentry id="guc-pgtrgm-word-similarity-threshold" xreflabel="pg_trgm.word_similarity_threshold">
|
|
|
|
<term>
|
|
|
|
<varname>pg_trgm.word_similarity_threshold</> (<type>real</type>)
|
|
|
|
<indexterm>
|
|
|
|
<primary>
|
|
|
|
<varname>pg_trgm.word_similarity_threshold</> configuration parameter
|
|
|
|
</primary>
|
|
|
|
</indexterm>
|
|
|
|
</term>
|
|
|
|
<listitem>
|
|
|
|
<para>
|
|
|
|
Sets the current word similarity threshold that is used by
|
|
|
|
the <literal>%></> operator. The threshold must be between
|
|
|
|
0 and 1 (default is 0.6).
|
|
|
|
</para>
|
|
|
|
</listitem>
|
|
|
|
</varlistentry>
|
2016-03-16 15:44:58 +01:00
|
|
|
</variablelist>
|
|
|
|
</sect2>
|
|
|
|
|
2007-11-11 00:30:46 +01:00
|
|
|
<sect2>
|
2007-12-10 06:32:51 +01:00
|
|
|
<title>Index Support</title>
|
|
|
|
|
2007-11-11 00:30:46 +01:00
|
|
|
<para>
|
2007-12-10 06:32:51 +01:00
|
|
|
The <filename>pg_trgm</filename> module provides GiST and GIN index
|
|
|
|
operator classes that allow you to create an index over a text column for
|
|
|
|
the purpose of very fast similarity searches. These index types support
|
2011-02-01 03:33:55 +01:00
|
|
|
the above-described similarity operators, and additionally support
|
2013-04-09 07:05:55 +02:00
|
|
|
trigram-based index searches for <literal>LIKE</>, <literal>ILIKE</>,
|
|
|
|
<literal>~</> and <literal>~*</> queries. (These indexes do not
|
|
|
|
support equality nor simple comparison operators, so you may need a
|
|
|
|
regular B-tree index too.)
|
2007-11-11 00:30:46 +01:00
|
|
|
</para>
|
2007-12-10 06:32:51 +01:00
|
|
|
|
2007-11-11 00:30:46 +01:00
|
|
|
<para>
|
2007-12-10 06:32:51 +01:00
|
|
|
Example:
|
|
|
|
|
2010-07-29 21:34:41 +02:00
|
|
|
<programlisting>
|
2007-11-11 00:30:46 +01:00
|
|
|
CREATE TABLE test_trgm (t text);
|
2015-05-15 17:42:29 +02:00
|
|
|
CREATE INDEX trgm_idx ON test_trgm USING GIST (t gist_trgm_ops);
|
2010-07-29 21:34:41 +02:00
|
|
|
</programlisting>
|
2007-12-10 06:32:51 +01:00
|
|
|
or
|
2010-07-29 21:34:41 +02:00
|
|
|
<programlisting>
|
2015-05-15 17:42:29 +02:00
|
|
|
CREATE INDEX trgm_idx ON test_trgm USING GIN (t gin_trgm_ops);
|
2010-07-29 21:34:41 +02:00
|
|
|
</programlisting>
|
2007-12-10 06:32:51 +01:00
|
|
|
</para>
|
|
|
|
|
2007-11-11 15:23:18 +01:00
|
|
|
<para>
|
2007-12-10 06:32:51 +01:00
|
|
|
At this point, you will have an index on the <structfield>t</> column that
|
|
|
|
you can use for similarity searching. A typical query is
|
2010-07-29 21:34:41 +02:00
|
|
|
<programlisting>
|
2007-12-10 06:32:51 +01:00
|
|
|
SELECT t, similarity(t, '<replaceable>word</>') AS sml
|
|
|
|
FROM test_trgm
|
|
|
|
WHERE t % '<replaceable>word</>'
|
|
|
|
ORDER BY sml DESC, t;
|
2010-07-29 21:34:41 +02:00
|
|
|
</programlisting>
|
2007-11-11 00:30:46 +01:00
|
|
|
This will return all values in the text column that are sufficiently
|
2007-12-10 06:32:51 +01:00
|
|
|
similar to <replaceable>word</>, sorted from best match to worst. The
|
|
|
|
index will be used to make this a fast operation even over very large data
|
|
|
|
sets.
|
|
|
|
</para>
|
|
|
|
|
2010-12-04 06:16:21 +01:00
|
|
|
<para>
|
|
|
|
A variant of the above query is
|
|
|
|
<programlisting>
|
|
|
|
SELECT t, t <-> '<replaceable>word</>' AS dist
|
|
|
|
FROM test_trgm
|
|
|
|
ORDER BY dist LIMIT 10;
|
|
|
|
</programlisting>
|
|
|
|
This can be implemented quite efficiently by GiST indexes, but not
|
|
|
|
by GIN indexes. It will usually beat the first formulation when only
|
|
|
|
a small number of the closest matches is wanted.
|
|
|
|
</para>
|
|
|
|
|
2016-03-16 16:59:21 +01:00
|
|
|
<para>
|
|
|
|
Also you can use an index on the <structfield>t</> column for word
|
|
|
|
similarity. For example:
|
|
|
|
<programlisting>
|
|
|
|
SELECT t, word_similarity('<replaceable>word</>', t) AS sml
|
|
|
|
FROM test_trgm
|
|
|
|
WHERE t %> '<replaceable>word</>'
|
|
|
|
ORDER BY sml DESC, t;
|
|
|
|
</programlisting>
|
|
|
|
This will return all values in the text column that have a word
|
|
|
|
which sufficiently similar to <replaceable>word</>, sorted from best
|
|
|
|
match to worst. The index will be used to make this a fast operation
|
|
|
|
even over very large data sets.
|
|
|
|
</para>
|
|
|
|
|
|
|
|
<para>
|
|
|
|
A variant of the above query is
|
|
|
|
<programlisting>
|
|
|
|
SELECT t, t <->> '<replaceable>word</>' AS dist
|
|
|
|
FROM test_trgm
|
|
|
|
ORDER BY dist LIMIT 10;
|
|
|
|
</programlisting>
|
|
|
|
This can be implemented quite efficiently by GiST indexes, but not
|
|
|
|
by GIN indexes.
|
|
|
|
</para>
|
|
|
|
|
|
|
|
|
2011-02-01 03:33:55 +01:00
|
|
|
<para>
|
|
|
|
Beginning in <productname>PostgreSQL</> 9.1, these index types also support
|
|
|
|
index searches for <literal>LIKE</> and <literal>ILIKE</>, for example
|
|
|
|
<programlisting>
|
|
|
|
SELECT * FROM test_trgm WHERE t LIKE '%foo%bar';
|
|
|
|
</programlisting>
|
|
|
|
The index search works by extracting trigrams from the search string
|
|
|
|
and then looking these up in the index. The more trigrams in the search
|
|
|
|
string, the more effective the index search is. Unlike B-tree based
|
|
|
|
searches, the search string need not be left-anchored.
|
|
|
|
</para>
|
|
|
|
|
2013-04-09 07:05:55 +02:00
|
|
|
<para>
|
2013-04-10 19:30:14 +02:00
|
|
|
Beginning in <productname>PostgreSQL</> 9.3, these index types also support
|
|
|
|
index searches for regular-expression matches
|
2013-04-09 07:05:55 +02:00
|
|
|
(<literal>~</> and <literal>~*</> operators), for example
|
|
|
|
<programlisting>
|
|
|
|
SELECT * FROM test_trgm WHERE t ~ '(foo|bar)';
|
|
|
|
</programlisting>
|
|
|
|
The index search works by extracting trigrams from the regular expression
|
|
|
|
and then looking these up in the index. The more trigrams that can be
|
|
|
|
extracted from the regular expression, the more effective the index search
|
|
|
|
is. Unlike B-tree based searches, the search string need not be
|
|
|
|
left-anchored.
|
|
|
|
</para>
|
|
|
|
|
|
|
|
<para>
|
|
|
|
For both <literal>LIKE</> and regular-expression searches, keep in mind
|
|
|
|
that a pattern with no extractable trigrams will degenerate to a full-index
|
|
|
|
scan.
|
|
|
|
</para>
|
|
|
|
|
2007-12-10 06:32:51 +01:00
|
|
|
<para>
|
|
|
|
The choice between GiST and GIN indexing depends on the relative
|
|
|
|
performance characteristics of GiST and GIN, which are discussed elsewhere.
|
|
|
|
As a rule of thumb, a GIN index is faster to search than a GiST index, but
|
|
|
|
slower to build or update; so GIN is better suited for static data and GiST
|
|
|
|
for often-updated data.
|
2007-11-11 00:30:46 +01:00
|
|
|
</para>
|
|
|
|
</sect2>
|
|
|
|
|
|
|
|
<sect2>
|
2007-11-14 00:36:26 +01:00
|
|
|
<title>Text Search Integration</title>
|
2007-12-10 06:32:51 +01:00
|
|
|
|
2007-11-11 00:30:46 +01:00
|
|
|
<para>
|
|
|
|
Trigram matching is a very useful tool when used in conjunction
|
2007-12-10 06:32:51 +01:00
|
|
|
with a full text index. In particular it can help to recognize
|
|
|
|
misspelled input words that will not be matched directly by the
|
|
|
|
full text search mechanism.
|
2007-11-11 00:30:46 +01:00
|
|
|
</para>
|
2007-12-10 06:32:51 +01:00
|
|
|
|
2007-11-11 00:30:46 +01:00
|
|
|
<para>
|
|
|
|
The first step is to generate an auxiliary table containing all
|
2007-11-14 00:36:26 +01:00
|
|
|
the unique words in the documents:
|
2007-12-10 06:32:51 +01:00
|
|
|
|
2010-07-29 21:34:41 +02:00
|
|
|
<programlisting>
|
2007-12-10 06:32:51 +01:00
|
|
|
CREATE TABLE words AS SELECT word FROM
|
|
|
|
ts_stat('SELECT to_tsvector(''simple'', bodytext) FROM documents');
|
2010-07-29 21:34:41 +02:00
|
|
|
</programlisting>
|
2007-12-10 06:32:51 +01:00
|
|
|
|
2007-11-14 00:36:26 +01:00
|
|
|
where <structname>documents</> is a table that has a text field
|
2007-12-10 06:32:51 +01:00
|
|
|
<structfield>bodytext</> that we wish to search. The reason for using
|
|
|
|
the <literal>simple</> configuration with the <function>to_tsvector</>
|
|
|
|
function, instead of using a language-specific configuration,
|
|
|
|
is that we want a list of the original (unstemmed) words.
|
2007-11-11 00:30:46 +01:00
|
|
|
</para>
|
2007-12-10 06:32:51 +01:00
|
|
|
|
2007-11-11 00:30:46 +01:00
|
|
|
<para>
|
|
|
|
Next, create a trigram index on the word column:
|
2007-12-10 06:32:51 +01:00
|
|
|
|
2010-07-29 21:34:41 +02:00
|
|
|
<programlisting>
|
2015-05-15 17:42:29 +02:00
|
|
|
CREATE INDEX words_idx ON words USING GIN (word gin_trgm_ops);
|
2010-07-29 21:34:41 +02:00
|
|
|
</programlisting>
|
2007-12-10 06:32:51 +01:00
|
|
|
|
|
|
|
Now, a <command>SELECT</command> query similar to the previous example can
|
|
|
|
be used to suggest spellings for misspelled words in user search terms.
|
|
|
|
A useful extra test is to require that the selected words are also of
|
|
|
|
similar length to the misspelled word.
|
2007-11-11 00:30:46 +01:00
|
|
|
</para>
|
2007-12-10 06:32:51 +01:00
|
|
|
|
|
|
|
<note>
|
|
|
|
<para>
|
|
|
|
Since the <structname>words</> table has been generated as a separate,
|
|
|
|
static table, it will need to be periodically regenerated so that
|
|
|
|
it remains reasonably up-to-date with the document collection.
|
|
|
|
Keeping it exactly current is usually unnecessary.
|
|
|
|
</para>
|
|
|
|
</note>
|
2007-11-11 00:30:46 +01:00
|
|
|
</sect2>
|
|
|
|
|
|
|
|
<sect2>
|
|
|
|
<title>References</title>
|
2007-12-10 06:32:51 +01:00
|
|
|
|
2007-11-11 00:30:46 +01:00
|
|
|
<para>
|
|
|
|
GiST Development Site
|
|
|
|
<ulink url="http://www.sai.msu.su/~megera/postgres/gist/"></ulink>
|
|
|
|
</para>
|
2007-11-14 00:36:26 +01:00
|
|
|
<para>
|
|
|
|
Tsearch2 Development Site
|
|
|
|
<ulink url="http://www.sai.msu.su/~megera/postgres/gist/tsearch/V2/"></ulink>
|
|
|
|
</para>
|
2007-11-11 00:30:46 +01:00
|
|
|
</sect2>
|
|
|
|
|
|
|
|
<sect2>
|
|
|
|
<title>Authors</title>
|
2007-12-10 06:32:51 +01:00
|
|
|
|
2007-11-11 00:30:46 +01:00
|
|
|
<para>
|
|
|
|
Oleg Bartunov <email>oleg@sai.msu.su</email>, Moscow, Moscow University, Russia
|
|
|
|
</para>
|
|
|
|
<para>
|
|
|
|
Teodor Sigaev <email>teodor@sigaev.ru</email>, Moscow, Delta-Soft Ltd.,Russia
|
|
|
|
</para>
|
|
|
|
<para>
|
2007-12-10 06:32:51 +01:00
|
|
|
Documentation: Christopher Kings-Lynne
|
2007-11-11 00:30:46 +01:00
|
|
|
</para>
|
|
|
|
<para>
|
|
|
|
This module is sponsored by Delta-Soft Ltd., Moscow, Russia.
|
|
|
|
</para>
|
|
|
|
</sect2>
|
|
|
|
|
|
|
|
</sect1>
|