Documentation PostgreSQL 15.15 » Langage SQL » Fonctions et opérateurs » Fonctions et opérateurs de recherche plein texte

Précédent | Niveau supérieur | Suivant
9.12. Fonctions et opérateurs pour les adresses réseau | Sommaire | 9.14. Fonctions UUID

## 9.13. Fonctions et opérateurs de recherche plein texte

Tableau 9.42, Tableau 9.43 et Tableau 9.44 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.42. Opérateurs de recherche plein texte

Opérateur Description Exemple(s)
`tsvector` `@@` `tsquery` → `boolean` `tsquery` `@@` `tsvector` → `boolean` 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` `@@` `tsquery` → `boolean` 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` `@@@` `tsquery` → `boolean` `tsquery` `@@@` `tsvector` → `boolean` Synonyme obsolète pour `@@`. `to_tsvector('fat cats ate rats') @@@ to_tsquery('cat & rat')` → `t`
`tsvector` `||` `tsvector` → `tsvector` 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` `&&` `tsquery` → `tsquery` 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` `||` `tsquery` → `tsquery` 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'`
`!!` `tsquery` → `tsquery` Inverse la `tsquery`, produisant une requête qui établit une correspondance avec les documents qui ne correspondent pas à la requête en entrée. `!! 'cat'::tsquery` → `!'cat'`
`tsquery` `<->` `tsquery` → `tsquery` 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` `@>` `tsquery` → `boolean` 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'::tsquery` → `f`
`tsquery` `<@` `tsquery` → `boolean` 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'::tsquery` → `t` `'cat'::tsquery <@ '!cat & rat'::tsquery` → `t`

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.43. Fonctions de recherche plein texte

Fonction Description Exemple(s)
`array_to_tsvector` ( `text[]` ) → `tsvector` Convertit un tableau de chaînes de texte vers un `tsvector`. Les chaînes données sont utilisées comme lexemes, sans autre traitement. Les éléments du tableau ne doivent pas être des chaînes vides ou or `NULL`. `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`. Les chaînes dans `lexemes` sont prises ainsi, sans autre traitement. Les chaînes qui ne correspondent à aucun lexeme dans `vector` sont ignorées. `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`. La chaîne dans `lexeme` est prise ainsi, sans autre traitement. `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`. Les chaînes dans `lexemes` sont prises ainsi, sans autre traitement. Les chaînes qui ne correspondent à aucun lexeme dans `vector` sont ignorées. `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.44 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.44. 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) ...`