select 'a | f' < 'b & c'::tsquery;

?column?

----------

(1 row)

select 'a | ff' < 'b & c'::tsquery;

select rewrite('foo & bar & qq & new & york', 'new & york'::tsquery, 'big & apple | nyc | new & york & city');

rewrite

------------------------------------------------------------------------------

'foo' & 'bar' & 'qq' & ( 'nyc' | 'big' & 'apple' | 'city' & 'new' & 'york' )

'foo' & 'bar' & 'qq' & ( 'city' & 'new' & 'york' | 'nyc' | 'big' & 'apple' )

(1 row)

select rewrite('moscow', 'select keyword, sample from test_tsquery'::text );

select rewrite('bar & new & qq & foo & york', 'select keyword, sample from test_tsquery'::text );

rewrite

---------------------------------------------------------------------------------

( 'nyc' | 'big' &'appl' | 'new' & 'york' ) & 'citi' & 'foo' & ( 'bar' | 'qq' )

'citi' & 'foo' &( 'bar' | 'qq' ) & ( 'nyc' | 'big' & 'appl' | 'new' & 'york' )

(1 row)

select rewrite( ARRAY['moscow', keyword, sample] ) from test_tsquery;

select rewrite( ARRAY['bar & new & qq & foo & york', keyword, sample] ) from test_tsquery;

rewrite

---------------------------------------------------------------------------------

( 'nyc' | 'big' &'appl' | 'new' & 'york' ) & 'citi' & 'foo' & ( 'bar' | 'qq' )

'citi' & 'foo' &( 'bar' | 'qq' ) & ( 'nyc' | 'big' & 'appl' | 'new' & 'york' )

(1 row)

select keyword from test_tsquery where keyword @> 'new';

select rewrite( ARRAY[query, keyword, sample] ) from test_tsquery, to_tsquery('english', 'bar & new & qq & foo & york') as query where keyword <@ query;

rewrite

---------------------------------------------------------------------------------

( 'nyc' | 'big' &'appl' | 'new' & 'york' ) & 'citi' & 'foo' & ( 'bar' | 'qq' )

'citi' & 'foo' &( 'bar' | 'qq' ) & ( 'nyc' | 'big' & 'appl' | 'new' & 'york' )

(1 row)

select rewrite( ARRAY[query, keyword, sample] ) from test_tsquery, to_tsquery('english', 'moscow') as query where query @> keyword;

select rewrite( ARRAY[query, keyword, sample] ) from test_tsquery, to_tsquery('english', 'bar & new & qq & foo & york') as query where query @> keyword;

rewrite

---------------------------------------------------------------------------------

( 'nyc' | 'big' &'appl' | 'new' & 'york' ) & 'citi' & 'foo' & ( 'bar' | 'qq' )

'citi' & 'foo' &( 'bar' | 'qq' ) & ( 'nyc' | 'big' & 'appl' | 'new' & 'york' )

(1 row)

create index qq on test_tsquery using gist (keyword gist_tp_tsquery_ops);

select rewrite( ARRAY[query, keyword, sample] ) from test_tsquery, to_tsquery('english', 'bar & new & qq & foo & york') as query where keyword <@ query;

rewrite

---------------------------------------------------------------------------------

( 'nyc' | 'big' &'appl' | 'new' & 'york' ) & 'citi' & 'foo' & ( 'bar' | 'qq' )

'citi' & 'foo' &( 'bar' | 'qq' ) & ( 'nyc' | 'big' & 'appl' | 'new' & 'york' )

(1 row)

select rewrite( ARRAY[query, keyword, sample] ) from test_tsquery, to_tsquery('english', 'moscow') as query where query @> keyword;

select rewrite( ARRAY[query, keyword, sample] ) from test_tsquery, to_tsquery('english', 'bar & new & qq & foo & york') as query where query @> keyword;

rewrite

---------------------------------------------------------------------------------

( 'nyc' | 'big' &'appl' | 'new' & 'york' ) & 'citi' & 'foo' & ( 'bar' | 'qq' )

'citi' & 'foo' &( 'bar' | 'qq' ) & ( 'nyc' | 'big' & 'appl' | 'new' & 'york' )

(1 row)

set enable_seqscan='on';

A <type>tsquery</type> value stores lexemes that are to be

searched for, and combines them honoring the Boolean operators

<literal>&amp;</literal> (AND), <literal>|</literal> (OR),

<literal>!</> (NOT) and <literal>?</> (FOLLOWED BY) phrase search

<literal>!</> (NOT) and <literal>&lt;-&gt;</> (FOLLOWED BY) phrase search

operator. Parentheses can be used to enforce grouping

of the operators:

</programlisting>

In the absence of parentheses, <literal>!</> (NOT) binds most tightly,

and <literal>&amp;</literal> (AND) and <literal>?</literal> (FOLLOWED BY)

and <literal>&amp;</literal> (AND) and <literal>&lt;-&gt;</literal> (FOLLOWED BY)

both bind more tightly than <literal>|</literal> (OR).

</para>

<entry><literal>!'cat'</literal></entry>

</row>

<row>

<entry> <literal>??</literal> </entry>

<entry> <literal>&lt;-&gt;</literal> </entry>

<entry><type>tsquery</> followed by <type>tsquery</></entry>

<entry><literal>to_tsquery('fat')?? to_tsquery('rat')</literal></entry>

<entry><literal>'fat'? 'rat'</literal></entry>

<entry><literal>to_tsquery('fat')&lt;-&gt; to_tsquery('rat')</literal></entry>

<entry><literal>'fat'&lt;-&gt; 'rat'</literal></entry>

</row>

<row>

<entry> <literal>@&gt;</literal> </entry>

<entry><type>tsquery</type></entry>

<entry>produce <type>tsquery</> ignoring punctuation</entry>

<entry><literal>phraseto_tsquery('english', 'The Fat Rats')</literal></entry>

<entry><literal>'fat'? 'rat'</literal></entry>

<entry><literal>'fat'&lt;-&gt; 'rat'</literal></entry>

</row>

<row>

<entry>

<literal><function>tsquery_phrase(<replaceable class="PARAMETER">query1</replaceable> <type>tsquery</>, <replaceable class="PARAMETER">query2</replaceable> <type>tsquery</>)</function></literal>

</entry>

<entry><type>tsquery</type></entry>

<entry>implementation of <literal>??</> (FOLLOWED BY) operator</entry>

<entry>implementation of <literal>&lt;-&gt;</> (FOLLOWED BY) operator</entry>

<entry><literal>tsquery_phrase(to_tsquery('fat'), to_tsquery('cat'))</literal></entry>

<entry><literal>'fat'? 'cat'</literal></entry>

<entry><literal>'fat'&lt;-&gt; 'cat'</literal></entry>

</row>

<row>

<entry>

<entry><type>tsquery</type></entry>

<entry>phrase-concatenate with distance</entry>

<entry><literal>tsquery_phrase(to_tsquery('fat'), to_tsquery('cat'), 10)</literal></entry>

<entry><literal>'fat'?[10] 'cat'</literal></entry>

<entry><literal>'fat'&lt;10&gt; 'cat'</literal></entry>

</row>

<row>

<entry>

As the above example suggests, a <type>tsquery</type> is not just raw

text, any more than a <type>tsvector</type> is. A <type>tsquery</type>

contains search terms, which must be already-normalized lexemes, and

may combine multiple terms using AND, OR, andNOT operators.

may combine multiple terms using AND, OR,NOTandFOLLOWED BY operators.

(For details see <xref linkend="datatype-textsearch">.) There are

functions <function>to_tsquery</> and <function>plainto_tsquery</>

functions <function>to_tsquery</>, <function>plainto_tsquery</>

and <function>phraseto_tsquery</>

that are helpful in converting user-written text into a proper

<type>tsquery</type>, for example by normalizing words appearing in

the text. Similarly, <function>to_tsvector</> is used to parse and

already normalized, so <literal>rats</> does not match <literal>rat</>.

</para>

<para>

Phrase search is made possible with the help of the <literal>&lt;-&gt;</>

(FOLLOWED BY) operator, which enforces lexeme order. This allows you

to discard strings not containing the desired phrase, for example:

<programlisting>

SELECT q @@ to_tsquery('fatal &lt;-&gt; error')

FROM unnest(array[to_tsvector('fatal error'),

to_tsvector('error is not fatal')]) AS q;

?column?

----------

t

f

</programlisting>

A more generic version of the FOLLOWED BY operator takes form of

<literal>&lt;N&gt;</>, where N stands for the greatest allowed distance

between the specified lexemes. The <literal>phraseto_tsquery</>

function makes use of this behavior in order to construct a

<literal>tsquery</> capable of matching the provided phrase:

<programlisting>

SELECT phraseto_tsquery('cat ate some rats');

phraseto_tsquery

-------------------------------

( 'cat' &lt;-&gt; 'ate' ) &lt;2&gt; 'rat'

</programlisting>

</para>

<para>

The <literal>@@</literal> operator also

supports <type>text</type> input, allowing explicit conversion of a text

<replaceable>querytext</replaceable>, which must consist of single tokens

separated by the Boolean operators <literal>&amp;</literal> (AND),

<literal>|</literal> (OR), <literal>!</literal> (NOT), and also the

<literal>?</literal> (FOLLOWED BY) phrase search operator. These operators

<literal>&lt;-&gt;</literal> (FOLLOWED BY) phrase search operator. These operators

can be grouped using parentheses. In other words, the input to

<function>to_tsquery</function> must already follow the general rules for

<type>tsquery</> input, as described in <xref

<para>

<function>phraseto_tsquery</> behaves much like

<function>plainto_tsquery</>, with the exception

that it utilizes the <literal>?</literal> (FOLLOWED BY) phrase search

that it utilizes the <literal>&lt;-&gt;</literal> (FOLLOWED BY) phrase search

operator instead of the <literal>&amp;</literal> (AND) Boolean operator.

This is particularly useful when searching for exact lexeme sequences,

since the phrase search operator helps to maintain lexeme order.

<screen>

SELECT phraseto_tsquery('english', 'The Fat Rats');

phraseto_tsquery

phraseto_tsquery

------------------

'fat'? 'rat'

'fat'&lt;-&gt; 'rat'

</screen>

Just like the <function>plainto_tsquery</>, the

<screen>

SELECT phraseto_tsquery('english', 'The Fat &amp; Rats:C');

phraseto_tsquery

-------------------------

( 'fat' ? 'rat' ) ? 'c'

phraseto_tsquery

-----------------------------

( 'fat' &lt;-&gt; 'rat' ) &lt;-&gt; 'c'

</screen>

It is possible to specify the configuration to be used to parse the document,

for example, we could create a new one using the hunspell dictionary

(namely 'eng_hunspell') in order to match phrases with different word forms:

<screen>

SELECT phraseto_tsquery('eng_hunspell', 'developer of the building which collapsed');

phraseto_tsquery

--------------------------------------------------------------------------------------------

( 'developer' &lt;3&gt; 'building' ) &lt;2&gt; 'collapse' | ( 'developer' &lt;3&gt; 'build' ) &lt;2&gt; 'collapse'

</screen>

</para>

<varlistentry>

<term>

<literal><type>tsquery</>?? <type>tsquery</></literal>

<literal><type>tsquery</>&lt;-&gt; <type>tsquery</></literal>

</term>

<listitem>

<para>

Returns the phrase-concatenation of the two given queries.

<screen>

SELECT to_tsquery('fat')?? to_tsquery('cat | rat');

?column?

-------------------------------

'fat'? 'cat' | 'fat'? 'rat'

SELECT to_tsquery('fat')&lt;-&gt; to_tsquery('cat | rat');

?column?

-----------------------------------

'fat'&lt;-&gt; 'cat' | 'fat'&lt;-&gt; 'rat'

</screen>

</para>

</listitem>

<listitem>

<para>

Returns the distanced phrase-concatenation of the two given queries.

This function lies in the implementation of the <literal>??</> operator.

This function lies in the implementation of the <literal>&lt;-&gt;</> operator.

<screen>

SELECT tsquery_phrase(to_tsquery('fat'), to_tsquery('cat'), 10);

tsquery_phrase

-------------------

'fat'?[10] 'cat'

tsquery_phrase

------------------

'fat'&lt;10&gt; 'cat'

</screen>

</para>

</listitem>

<listitem>

<para>

<function>setweight</> returns a copy of the input query in which every

position has been labeled with the given <replaceable>weight</>, either

<literal>A</literal>, <literal>B</literal>, <literal>C</literal>, or

<literal>D</literal>. These labels are retained when queries are

concatenated, allowing words from different parts of a document

position has been labeled with the given <replaceable>weight</>(s), either

<literal>A</literal>, <literal>B</literal>, <literal>C</literal>,

<literal>D</literal> or their combination. These labels are retained when

queries areconcatenated, allowing words from different parts of a document

to be weighted differently by ranking functions.

</para>

{

Oidcfg_id;

intqoperator;/* query operator */

}MorphOpaque;

get_current_ts_config(PG_FUNCTION_ARGS)

{

{

Oidcfg_id;

intqoperator;/* query operator */

}MorphOpaque;

pushval_morph(Datumopaque,TSQueryParserStatestate,char*strval,intlenval,int16weight,boolprefix)

{

while (count<prs.curwords)

{

if (pos>0&&pos+1<prs.words[count].pos.pos)

{

while (pos+1<prs.words[count].pos.pos)

{

pushStop(state);

if (cntpos)

pushOperator(state,data->qoperator,1);

}

}

pos=prs.words[count].pos.pos;

pos=prs.words[count].pos.pos;/* save current word's position */

cntvar=0;

while (count<prs.curwords&&pos==prs.words[count].pos.pos)

{

variant=prs.words[count].nvariant;

cnt=0;

while (count<prs.curwords&&

pos==prs.words[count].pos.pos&&

variant==prs.words[count].nvariant)

{

pushValue(state,

prs.words[count].word,

prs.words[count].len,

weight,

((prs.words[count].flags&TSL_PREFIX)||prefix) ?

true :

false);

((prs.words[count].flags&TSL_PREFIX)||prefix));

pfree(prs.words[count].word);

if (cnt)

pushOperator(state,OP_AND,0);

}

if (cntpos)

pushOperator(state,data->qoperator,1);

pushOperator(state,data->qoperator,1);/* distance may be useful */

cntpos++;

}

pfree(prs.words);

}

pushStop(state);

while (lexs)

{

if (lexs->type>0)

hladdword(prs,lexs->lemm,lexs->lenlemm,lexs->type);