PostgreSQLLa base de données la plus sophistiquée au monde.
Documentation PostgreSQL 13.0 » Langage SQL » Fonctions et opérateurs » Fonctions et opérateurs de recherche plein texte

9.13. Fonctions et opérateurs de recherche plein texte

Tableau 9.41, Tableau 9.42 et Tableau 9.43 résument les fonctions et opérateurs fournis par la recherche plein texte. Voir Chapitre 12 pour une explication détaillée de la fonctionnalité de recherche de texte de PostgreSQL.

Tableau 9.41. Opérateurs de recherche plein texte

Opérateur

Description

Exemple(s)

tsvector @@ tsqueryboolean

tsquery @@ tsvectorboolean

Est-ce que le tsvector correspond au tsquery ? (Les arguments peuvent être donnés dans n'importe quel ordre.)

to_tsvector('fat cats ate rats') @@ to_tsquery('cat & rat')t

text @@ tsqueryboolean

Est-ce que la chaîne de texte, après appel implicite à to_tsvector(), correspond au tsquery ?

'fat cats ate rats' @@ to_tsquery('cat & rat')t

tsvector @@@ tsqueryboolean

tsquery @@@ tsvectorboolean

Synonyme obsolète pour @@.

to_tsvector('fat cats ate rats') @@@ to_tsquery('cat & rat')t

tsvector || tsvectortsvector

Concatène deux tsvector. Si les deux entrées contiennent des positions de lexème, les positions de la deuxième entrée sont ajustées.

'a:1 b:2'::tsvector || 'c:1 d:2 b:3'::tsvector'a':1 'b':2,5 'c':3 'd':4

tsquery && tsquerytsquery

Calcule un AND des deux tsquery, produisant une requête qui établit une correspondance avec les documents correspondant aux deux requêtes.

'fat | rat'::tsquery && 'cat'::tsquery( 'fat' | 'rat' ) & 'cat'

tsquery || tsquerytsquery

Calcule un OR des deux tsquery, produisant une requête qui établit une correspondance avec les documents correspondant à au moins une des deux requêtes.

'fat | rat'::tsquery || 'cat'::tsquery'fat' | 'rat' | 'cat'

!! tsquerytsquery

Inverse la tsquery, produisant une requpete qui établit une correspondance avec les documents qui ne correspondent pas à la requête en entrée.

!! 'cat'::tsquery!'cat'

tsquery <-> tsquerytsquery

Construit une requête de phrase, qui établit une correspondance si les deux requêtes en entrée correspondent aux lexèmes successifs.

to_tsquery('fat') <-> to_tsquery('rat')'fat' <-> 'rat'

tsquery @> tsqueryboolean

Est-ce que le premier tsquery contient le second ? (Ceci considère seulement si tous les lexèmes apparaissant dans une requêtes apparaissent dans l'autre, ignorant les opérateurs combinés.)

'cat'::tsquery @> 'cat & rat'::tsqueryf

tsquery <@ tsqueryboolean

Est-ce que le premier tsquery est contenu dans le second ? (Ceci considère seulement si tous les lexèmes apparaissant dans une requête apparaissent aussi dans l'autre, ignorant les opérateurs combinés.)

'cat'::tsquery <@ 'cat & rat'::tsqueryt

'cat'::tsquery <@ '!cat & rat'::tsqueryt


En plus de ces opérateurs spécialisés, les opérateurs de comparaison habituels indiqués dans Tableau 9.1 sont disponibles pour les types tsvector et tsquery. Ils ne sont pas très utiles pour la recherche de texte mais permettent, par exemple, de construire des index d'unicité sur des colonnes de ce type.

Tableau 9.42. Fonctions de recherche plein texte

Fonction

Description

Exemple(s)

array_to_tsvector ( text[] ) → tsvector

Convertit un tableau de lexèmes en un tsvector. Les chaînes données sont utilisées directement sans autre traitement.

array_to_tsvector('{fat,cat,rat}'::text[])'cat' 'fat' 'rat'

get_current_ts_config ( ) → regconfig

Renvoie l'OID de la configuration actuelle de recherche plein texte (comme elle est configurée par default_text_search_config).

get_current_ts_config()english

length ( tsvector ) → integer

Renvoie le nombre de lexèmes dans le tsvector.

length('fat:2,4 cat:3 rat:5A'::tsvector)3

numnode ( tsquery ) → integer

Renvoie le nombre de lexèmes plus les opérateurs dans le tsquery.

numnode('(fat & rat) | cat'::tsquery)5

plainto_tsquery ( [ config regconfig, ] query text ) → tsquery

Convertit le texte en un tsquery, normalisant les mots suivant la configuration spécifiée ou par défaut. Toute ponctuation dans la chaîne est ignorée (elle ne détermine pas les opérateurs de la requête). La requête résultante correspond aux documents contenant tous les mots du texte qui ne sont pas des mots à ignorer.

plainto_tsquery('english', 'The Fat Rats')'fat' & 'rat'

phraseto_tsquery ( [ config regconfig, ] query text ) → tsquery

Convertit du texte en tsquery, normalisant les mots suivant la configuration spécifiée ou par défaut. Toute ponctuation dans la chaîne est ignorée (elle ne détermine pas les opérateurs de requête). La requête résultante correspond aux phrases contenant tous les mots du texte qui ne sont pas des mots à ignorer.

phraseto_tsquery('english', 'The Fat Rats')'fat' <-> 'rat'

phraseto_tsquery('english', 'The Cat and Rats')'cat' <2> 'rat'

websearch_to_tsquery ( [ config regconfig, ] query text ) → tsquery

Convertit du texte en un tsquery, normalisant des mots suivant la configuration spécifiée ou par défaut. Les séquences de mots entre guillemets sont converties pour phraser des tests. Le mot « or » est compris comme produisant un opérateur OR, et un tiret produit un opérateur NOT ; les autres ponctuations sont ignorées. Ceci ressemble au comportement des outils de recherche web.

websearch_to_tsquery('english', '"fat rat" or cat dog')'fat' <-> 'rat' | 'cat' & 'dog'

querytree ( tsquery ) → text

Produit une représentation de portion indexable d'un tsquery. Un résultat qui est vide ou juste T indique une requête non indexable.

querytree('foo & ! bar'::tsquery)'foo'

setweight ( vector tsvector, weight "char" ) → tsvector

Assigne un poids (weight) spécifié pour chaque élément d'un vector.

setweight('fat:2,4 cat:3 rat:5B'::tsvector, 'A')'cat':3A 'fat':2A,4A 'rat':5A

setweight ( vector tsvector, weight "char", lexemes text[] ) → tsvector

Assigne le poids (weight) spécifié aux éléments des vector qui sont listés dans les lexemes.

setweight('fat:2,4 cat:3 rat:5,6B'::tsvector, 'A', '{cat,rat}')'cat':3A 'fat':2,4 'rat':5A,6A

strip ( tsvector ) → tsvector

Supprime les positions et les poids à partir d'un tsvector.

strip('fat:2,4 cat:3 rat:5A'::tsvector)'cat' 'fat' 'rat'

to_tsquery ( [ config regconfig, ] query text ) → tsquery

Convertit le texte en tsquery, normalisant les mots suivant la configuration spécifiée ou par défaut. Les mots doivent être combinés par des opérateurs tsquery valides.

to_tsquery('english', 'The & Fat & Rats')'fat' & 'rat'

to_tsvector ( [ config regconfig, ] document text ) → tsvector

Convertit du texte en un tsvector, normalisant les mots suivant la configuration spécifiée ou par défaut. L'information de position est inclus dans le résultat.

to_tsvector('english', 'The Fat Rats')'fat':2 'rat':3

to_tsvector ( [ config regconfig, ] document json ) → tsvector

to_tsvector ( [ config regconfig, ] document jsonb ) → tsvector

Convertit chaque valeur chaîne du document JSON en un tsvector, normalisant les mots suivant la configuration spécifiée ou par défaut. Les résultats sont ensuite concaténées dans l'ordre du document pour produire la sortie. L'information de position est générée comme si un mot d'arrêt existe chaque paire de valeurs chaînes. (Attention que l'« ordre du document » des champs d'un objet JSON est dépendant de l'implémentation quand l'entrée est de type jsonb ; observez la difference dans les exemples.)

to_tsvector('english', '{"aa": "The Fat Rats", "b": "dog"}'::json)'dog':5 'fat':2 'rat':3

to_tsvector('english', '{"aa": "The Fat Rats", "b": "dog"}'::jsonb)'dog':1 'fat':4 'rat':5

json_to_tsvector ( [ config regconfig, ] document json, filter jsonb ) → tsvector

jsonb_to_tsvector ( [ config regconfig, ] document jsonb, filter jsonb ) → tsvector

Sélectionne chaque élément du document JSON qui est réclamé par le filter et convertit chacun en un tsvector, normalisant les mots suivant la configuration spécifiée ou par défaut. Les résultats sont ensuite concaténées dans l'ordre du document pour produire la sortie. L'information de position est générée comme si un mot d'arrêt existe entre chaque paire d'éléments sélectionnés. (Attention que l'« ordre du document » des champs d'un objet JSON est dépendant de l'implémentation quand l'entrée est de type jsonb.) Le filter doit être un tableau jsonb contenant zéro ou plusieurs de ces mots-clés : "string" (pour inclure toutes les valeurs chaînes), "numeric" (pour inclure toutes les valeurs numériques), "boolean" (pour inclure toutes les valeurs booléennes), "key" (pour inclure toutes les clés) ou "all" (pour tous ces mots-clés). Comme exception, filter peut aussi être une simple valeur JSON qui est un de ces mots-clés.

json_to_tsvector('english', '{"a": "The Fat Rats", "b": 123}'::json, '["string", "numeric"]')'123':5 'fat':2 'rat':3

json_to_tsvector('english', '{"cat": "The Fat Rats", "dog": 123}'::json, '"all"')'123':9 'cat':1 'dog':7 'fat':4 'rat':5

ts_delete ( vector tsvector, lexeme text ) → tsvector

Supprime toute occurrence du lexeme donné à partir de vector.

ts_delete('fat:2,4 cat:3 rat:5A'::tsvector, 'fat')'cat':3 'rat':5A

ts_delete ( vector tsvector, lexemes text[] ) → tsvector

Supprime toute occurrence des lexèmes dans lexemes à partir de vector.

ts_delete('fat:2,4 cat:3 rat:5A'::tsvector, ARRAY['fat','rat'])'cat':3

ts_filter ( vector tsvector, weights "char"[] ) → tsvector

Sélectionne seulement les éléments avec le weights donné à partir de vector.

ts_filter('fat:2,4 cat:3b,7c rat:5A'::tsvector, '{a,b}')'cat':3B 'rat':5A

ts_headline ( [ config regconfig, ] document text, query tsquery [, options text ] ) → text

Affiche, dans sa forme abréviée, les correspondances de la query dans le document, qui doit être un texte brut, et non pas un tsvector. Les mots dans le document sont normalisés suivant la configuration spécifiée ou par défaut avant d'établir les correspondances avec la requête. L'utilisation de cette fonction est discutée dans Section 12.3.4, quid écrit aussi les options disponibles.

ts_headline('The fat cat ate the rat.', 'cat')The fat <b>cat</b> ate the rat.

ts_headline ( [ config regconfig, ] document json, query tsquery [, options text ] ) → text

ts_headline ( [ config regconfig, ] document jsonb, query tsquery [, options text ] ) → text

Affiche, dans une forme abréviée, les correspondances pour la query qui surviennent dans les valeurs de type chaîne dans le document JSON. Voir Section 12.3.4 pour plus de détails.

ts_headline('{"cat":"raining cats and dogs"}'::jsonb, 'cat'){"cat": "raining <b>cats</b> and dogs"}

ts_rank ( [ weights real[], ] vector tsvector, query tsquery [, normalization integer ] ) → real

Calcule un score indiquant le niveau de correspondance du vector avec la query. Voir Section 12.3.3 pour plus de détails.

ts_rank(to_tsvector('raining cats and dogs'), 'cat')0.06079271

ts_rank_cd ( [ weights real[], ] vector tsvector, query tsquery [, normalization integer ] ) → real

Calcule un score indiquant le niveau de correspondance du vector avec la query, en utilisant un algorithme de densité de couverture. Voir Section 12.3.3 pour les détails.

ts_rank_cd(to_tsvector('raining cats and dogs'), 'cat')0.1

ts_rewrite ( query tsquery, target tsquery, substitute tsquery ) → tsquery

Remplace les occurrences de target avec substitute dans query. Voir Section 12.4.2.1 pour les détails.

ts_rewrite('a & b'::tsquery, 'a'::tsquery, 'foo|bar'::tsquery)'b' & ( 'foo' | 'bar' )

ts_rewrite ( query tsquery, select text ) → tsquery

Remplace les portions de la query suivant les cibles et substituts obtenus en exécutant une commande SELECT. Voir Section 12.4.2.1 pour les détails.

SELECT ts_rewrite('a & b'::tsquery, 'SELECT t,s FROM aliases')'b' & ( 'foo' | 'bar' )

tsquery_phrase ( query1 tsquery, query2 tsquery ) → tsquery

Construit une requête de phrases pour rechercher les correspondances de query1 et query2 sur des lexèmes successifs (identique à l'opérateur <->).

tsquery_phrase(to_tsquery('fat'), to_tsquery('cat'))'fat' <-> 'cat'

tsquery_phrase ( query1 tsquery, query2 tsquery, distance integer ) → tsquery

Construit une requête de phrases pour rechercher les correspondances de query1 et query2 qui surviennent exactement entre distance lexèmes.

tsquery_phrase(to_tsquery('fat'), to_tsquery('cat'), 10)'fat' <10> 'cat'

tsvector_to_array ( tsvector ) → text[]

Convertit un tsvector en un tableau de lexèmes.

tsvector_to_array('fat:2,4 cat:3 rat:5A'::tsvector){cat,fat,rat}

unnest ( tsvector ) → setof record ( lexeme text, positions smallint[], weights text )

Étend un tsvector en un ensemble de lignes, une par lexème.

select * from unnest('cat:3 fat:2,4 rat:5A'::tsvector)

 lexeme | positions | weights
--------+-----------+---------
 cat    | {3}       | {D}
 fat    | {2,4}     | {D,D}
 rat    | {5}       | {A}


Note

Toutes les fonctions de recherche plein texte qui acceptent un argument regconfig optionnel utiliseront la configuration indiquée par default_text_search_config quand cet argument est omis.

Les fonctions de Tableau 9.43 sont listées séparément parce qu'elles ne sont habituellement pas utilisées dans les opérations standard de recherche de texte. Elles sont principalement utiles pour le développement et le débogage des nouvelles configurations de recherche plein texte.

Tableau 9.43. Fonctions de débogage de recherche plein texte

Fonction

Description

Exemple(s)

ts_debug ( [ config regconfig, ] document text ) → setof record ( alias text, description text, token text, dictionaries regdictionary[], dictionary regdictionary, lexemes text[] )

Extrait et normalise les jetons d'un document suivant la configuration de recherche plein texte spécifié ou par défaut, et renvoie l'information sur la façon dont chaque jeton a été traité. Voir Section 12.8.1 pour plus de détails.

ts_debug('english', 'The Brightest supernovaes')(asciiword,"Word, all ASCII",The,{english_stem},english_stem,{}) ...

ts_lexize ( dict regdictionary, token text ) → text[]

Renvoie un tableau de lexèmes de remplacement si le jeton en entrée est connu par le dictionnaire ou un tableau suivant si le jeton est connu du dictionnaire mais est un mot vide, ou NULL si ce n'est pas un mot connu. Voir Section 12.8.3 pour les détails.

ts_lexize('english_stem', 'stars'){star}

ts_parse ( parser_name text, document text ) → setof record ( tokid integer, token text )

Extrait les jetons du document en utilisant l'analyseur nommé. Voir Section 12.8.2 pour les détails.

ts_parse('default', 'foo - bar')(1,foo) ...

ts_parse ( parser_oid oid, document text ) → setof record ( tokid integer, token text )

Extrait les jetons du document en utilisant un analyseur spécifié par OID. Voir Section 12.8.2 pour les détails.

ts_parse(3722, 'foo - bar')(1,foo) ...

ts_token_type ( parser_name text ) → setof record ( tokid integer, alias text, description text )

Renvoie une table qui décrit chaque type de jeton que l'analyseur nommé peut reconnaître. Voir Section 12.8.2 pour les détails.

ts_token_type('default')(1,asciiword,"Word, all ASCII") ...

ts_token_type ( parser_oid oid ) → setof record ( tokid integer, alias text, description text )

Renvoie une table qui décrit chaque type de jeton qu'un analyseur spécifié par OID peut reconnaître. Voir Section 12.8.2 pour les détails.

ts_token_type(3722)(1,asciiword,"Word, all ASCII") ...

ts_stat ( sqlquery text [, weights text ] ) → setof record ( word text, ndoc integer, nentry integer )

Exécute la sqlquery, qui doit renvoyer une seule colonne tsvector, et renvoyer des statistiques sur chaque lexème distinct contenu dans la donnée. Voir Section 12.4.4 pour les détails.

ts_stat('SELECT vector FROM apod')(foo,10,15) ...