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}
|