array_to_tsvector ( text[] )
→ tsvector
Converte uma matriz de lexemas em um tsvector.
As cadeias de caracteres fornecidas são usadas como estão,
sem processamento adicional.
Os elementos da matriz não podem ser cadeias de caracteres
vazias ou NULL.
array_to_tsvector('{fat,cat,rat}'::text[])
→ 'cat' 'fat' 'rat'
array_to_tsvector('{gord,gat,rat}'::text[])
→ 'gat' 'gord' 'rat'
|
get_current_ts_config ( )
→ regconfig
Retorna o OID da configuração de procura de texto padrão corrente
(conforme definido por
default_text_search_config
→ pg_catalog.portuguese).
get_current_ts_config()
→ portuguese
|
length ( tsvector )
→ integer
Retorna o número de lexemas no tsvector.
length('fat:2,4 cat:3 rat:5A'::tsvector)
→ 3
length('gord:2,4 gat:3 rat:5A'::tsvector)
→ 3
|
numnode ( tsquery )
→ integer
Retorna o número de lexemas mais operadores no tsquery.
numnode('(fat & rat) | cat'::tsquery)
→ 5
numnode('(gord & rat) | gat'::tsquery)
→ 5
|
plainto_tsquery (
[ config regconfig, ]
consulta text )
→ tsquery
Converte texto em tsquery, normalizando as
palavras segundo a configuração especificada ou padrão.
Qualquer pontuação na cadeia de caracteres é ignorada
(não determina os operadores da consulta).
A consulta resultante corresponde a documentos que contêm todas
as palavras do texto que não são palavras a serem ignoradas
.
plainto_tsquery('english', 'The Fat Rats')
→ 'fat' & 'rat'
plainto_tsquery('portuguese', 'Os ratos gordos')
→ 'rat' & 'gord'
|
phraseto_tsquery (
[ config regconfig, ]
consulta text )
→ tsquery
Converte texto em tsquery, normalizando as
palavras segundo a configuração especificada ou padrão.
Qualquer pontuação na cadeia de caracteres é ignorada
(não determina os operadores da consulta).
A consulta resultante corresponde a frases que contêm todas
as palavras do texto que não são palavras a serem ignoradas.
phraseto_tsquery('english', 'The Fat Rats')
→ 'fat' <-> 'rat'
phraseto_tsquery('english', 'The Cat and Rats')
→ 'cat' <2> 'rat'
phraseto_tsquery('portuguese', 'Os ratos gordos')
→ 'rat' <-> 'gord'
phraseto_tsquery('portuguese', 'O Gato e os Ratos')
→ 'gat' <3> 'rat'
|
websearch_to_tsquery (
[ config regconfig, ]
consulta text )
→ tsquery
Converte texto em tsquery, normalizando as
palavras segundo a configuração especificada ou padrão.
As sequências de palavras entre aspas são convertidas em testes de frase.
A palavra “or”
(mesmo em português)
é entendida como produzindo o operador OR,
e um hífen produz o operador NOT; as demais
pontuações são ignoradas.
Isto se aproxima ao comportamento de algumas ferramentas comuns
de busca na Web.
websearch_to_tsquery('english', '"fat rat" or cat dog')
→ 'fat' <-> 'rat' | 'cat' & 'dog'
websearch_to_tsquery('portuguese', '"rato gordo" or gato cachorro')
→ 'rat' <-> 'gord' | 'gat' & 'cachorr'
|
querytree ( tsquery )
→ text
Produz a representação da parte indexável de uma
tsquery. Um resultado vazio, ou apenas a letra
T, indica uma consulta não indexável.
querytree('foo & ! bar'::tsquery)
→ 'foo'
|
setweight ( vetor tsvector, peso "char" )
→ tsvector
Atribui o peso especificado para cada
elemento do vetor.
setweight('fat:2,4 cat:3 rat:5B'::tsvector, 'A')
→ 'cat':3A 'fat':2A,4A 'rat':5A
setweight('gord:2,4 gat:3 rat:5B'::tsvector, 'A')
→ 'gat':3A 'gord':2A,4A 'rat':5A
|
setweight ( vetor tsvector, peso "char", lexemas text[] )
→ tsvector
Atribui o peso especificado para os
elementos do vetor listados no
parâmetro lexemas.
As cadeias de caracteres no parâmetro lexemes
são considerados lexemas tal como estão, sem processamento adicional.
As cadeias de caracteres que não correspondem a nenhum lexema em
vector são ignoradas.
setweight('fat:2,4 cat:3 rat:5,6B'::tsvector, 'A', '{cat,rat}')
→ 'cat':3A 'fat':2,4 'rat':5A,6A
setweight('gord:2,4 gat:3 rat:5,6B'::tsvector, 'A', '{gat,rat}')
→ 'gat':3A 'gord':2,4 'rat':5A,6A
|
strip ( tsvector )
→ tsvector
Remove posições e pesos do tsvector.
strip('fat:2,4 cat:3 rat:5A'::tsvector)
→ 'cat' 'fat' 'rat'
strip('gord:2,4 gat:3 rat:5A'::tsvector)
→ 'gat' 'gord' 'rat'
|
to_tsquery (
[ config regconfig, ]
consulta text )
→ tsquery
Converte texto em tsquery, normalizando as
palavras segundo a configuração especificada ou padrão.
As palavras devem ser combinadas por operadores
tsquery válidos.
to_tsquery('english', 'The & Fat & Rats')
→ 'fat' & 'rat'
to_tsquery('portuguese', 'Os & Ratos & Gordos')
→ 'rat' & 'gord'
|
to_tsvector (
[ config regconfig, ]
documento text )
→ tsvector
Converte texto em tsvector, normalizando as
palavras segundo a configuração especificada ou padrão.
As informações de posição estão incluídas no resultado.
to_tsvector('english', 'The Fat Rats')
→ 'fat':2 'rat':3
to_tsvector('portuguese', 'Os Ratos Gordos')
→ 'gord':3 'rat':2
|
to_tsvector (
[ config regconfig, ]
documento json )
→ tsvector
to_tsvector (
[ config regconfig, ]
documento jsonb )
→ tsvector
Converte cada valor cadeia de caracteres no documento JSON em um
tsvector, normalizando as palavras segundo a
configuração especificada ou padrão.
Os resultados são então concatenados na ordem do documento para
produzir a saída.
As informações de posição são geradas como se existisse uma
palavra irrelevante (stopword) entre cada par
de valores cadeia de caracteres.
(Atente para que a “ordem do documento” dos campos
de um objeto JSON depende da implementação quando a entrada é do
tipo de dados jsonb; observe a diferença nos exemplos.)
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
to_tsvector('portuguese', '{"aa": "Os Ratos Gordos", "b": "cachorro"}'::json)
→ 'cachorr':5 'gord':3 'rat':2
to_tsvector('portuguese', '{"aa": "Os Ratos Gordos", "b": "cachorro"}'::jsonb)
→ ''cachorr':1 'gord':5 'rat':4
|
json_to_tsvector (
[ config regconfig, ]
documento json,
filtro jsonb )
→ tsvector
jsonb_to_tsvector (
[ config regconfig, ]
documento jsonb,
filtro jsonb )
→ tsvector
Seleciona cada item no documento JSON que é solicitado pelo
filtro e converte cada um deles em um
tsvector, normalizando palavras segundo a
configuração especificada ou padrão.
Os resultados são então concatenados na ordem do documento para
produzir a saída.
As informações de posição são geradas como se existisse uma
palavra irrelevante (stopword) entre cada par
de itens selecionados.
(Atente para que a “ordem do documento” dos campos
de um objeto JSON depende da implementação quando a entrada é
do tipo de dados jsonb.)
O filtro deve ser uma matriz do tipo de dados
jsonb contendo zero ou mais destas palavras-chave:
"string" (para incluir todos os valores cadeia de caracteres),
"numeric" (para incluir todos os valores numéricos),
"boolean" (para incluir todos os valores booleanos),
"key" (para incluir todas as chaves), ou
"all" (para incluir todos os itens acima).
Como um caso especial, o filtro também
pode ser um valor JSON simples que é uma destas palavras-chave.
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
json_to_tsvector('portuguese', '{"a": "Os Ratos Gordos", "b": 123}'::json, '["string", "numeric"]')
→ '123':5 'gord':3 'rat':2
json_to_tsvector('portuguese', '{"gat": "Os Ratos Gordos", "cachorr": 123}'::json, '"all"')
→ '123':9 'cachorr':7 'gat':1 'gord':5 'rat':4
|
ts_delete ( vetor tsvector, lexema text )
→ tsvector
Remove do vetor qualquer ocorrência de um
dado lexema.
A cadeia de caracteres lexeme é tratada
como um lexema tal como está, sem processamento adicional
ts_delete('fat:2,4 cat:3 rat:5A'::tsvector, 'fat')
→ 'cat':3 'rat':5A
|
ts_delete ( vetor tsvector, lexemas text[] )
→ tsvector
As cadeias de caracteres em lexemes são
tratadas como lexemas tal como estão, sem processamento adicional
As cadeias de caracteres que não correspondem a nenhum lexema
em vector são ignoradas.
Remove do vetor qualquer ocorrência dos
lexemas.
ts_delete('fat:2,4 cat:3 rat:5A'::tsvector, ARRAY['fat','rat'])
→ 'cat':3
|
ts_filter ( vetor tsvector, pesos "char"[] )
→ tsvector
Seleciona no vetor apenas os elementos
com os pesos especificados.
ts_filter('fat:2,4 cat:3b,7c rat:5A'::tsvector, '{a,b}')
→ 'cat':3B 'rat':5A
|
ts_headline (
[ config regconfig, ]
documento text,
consulta tsquery
[, opções text ] )
→ text
Mostra, de forma abreviada, a(s) correspondência(s) para a
consulta no documento,
que deve ser um texto puro e não um tsvector.
As palavras no documento são normalizadas segundo a
configuração especificada ou padrão, antes da correspondência com
a consulta. O uso desta função está discutido na
Seção 12.3.4, que também descreve as
opções disponíveis.
ts_headline('english', 'The fat cat ate the rat.'::text, 'cat')
→ The fat <b>cat</b> ate the rat.
SELECT ts_headline('portuguese', 'O gato gordo comeu o rato.'::text, 'gat')
→ O <b>gato</b> gordo comeu o rato.
|
ts_headline (
[ config regconfig, ]
documento json,
consulta tsquery
[, opções text ] )
→ text
ts_headline (
[ config regconfig, ]
documento jsonb,
consulta tsquery
[, opções text ] )
→ text
Mostra, de forma abreviada, as correspondências para a
consulta que ocorrem em valores
cadeia de caracteres no documento JSON.
Veja a Seção 12.3.4 para obter mais
detalhes.
ts_headline('english', '{"cat":"raining cats and dogs"}'::jsonb, 'cat')
→ {"cat": "raining <b>cats</b> and dogs"}
ts_headline('portuguese', '{"gato":"chovendo gatos e cachorros"}'::jsonb, 'gat')
→ {"gato": "chovendo <b>gatos</b> e cachorros"}
|
ts_rank (
[ pesos real[], ]
vetor tsvector,
consulta tsquery
[, normalization integer ] )
→ real
Calcula uma pontuação mostrando quão bem o
vetor corresponde à
consulta. Veja a
Seção 12.3.3 para obter mais detalhes.
ts_rank(to_tsvector('english', 'raining cats and dogs'), 'cat')
→ 0.06079271
ts_rank(to_tsvector('portuguese', 'chovendo gatos e cachorros'), 'gat')
→ 0.06079271
|
ts_rank_cd (
[ pesos real[], ]
vetor tsvector,
consulta tsquery
[, normalization integer ] )
→ real
Calcula a pontuação mostrando quão bem o
vetor corresponde à
consulta,
usando um algoritmo de densidade de cobertura. Veja a
Seção 12.3.3 para obter mais detalhes.
ts_rank_cd(to_tsvector('english', 'raining cats and dogs'), 'cat')
→ 0.1
ts_rank_cd(to_tsvector('portuguese', 'chovendo gatos e cachorros'), 'gat')
→ 0.1
|
ts_rewrite ( consulta tsquery,
alvo tsquery,
substituto tsquery )
→ tsquery
Substitui as ocorrências no alvo
pelo substituto
dentro da consulta.
Veja a Seção 12.4.2.1
para obter mais detalhes.
ts_rewrite('a & b'::tsquery, 'a'::tsquery, 'foo|bar'::tsquery)
→ 'b' & ( 'foo' | 'bar' )
|
ts_rewrite ( consulta tsquery,
SELECT text )
→ tsquery
Substitui as porções da consulta
conforme o(s) destino(s) e substituto(s) obtidos executando
um comando SELECT.
Veja a Seção 12.4.2.1
para obter mais detalhes.
SELECT ts_rewrite('a & b'::tsquery, 'SELECT t,s FROM aliases')
→ 'b' & ( 'foo' | 'bar' )
|
tsquery_phrase ( consulta1 tsquery, consulta2 tsquery )
→ tsquery
Constrói uma consulta de frase que procura correspondências de
consulta1 e consulta2
em lexemas sucessivos
(idêntico ao operador <->).
tsquery_phrase(to_tsquery('fat'), to_tsquery('cat'))
→ 'fat' <-> 'cat'
tsquery_phrase(to_tsquery('gordo'), to_tsquery('gato'))
→ 'gord' <-> 'gat'
|
tsquery_phrase ( consulta1 tsquery, consulta2 tsquery, distância integer )
→ tsquery
Constrói uma consulta de frase que procura correspondências de
consulta1 e consulta2
que ocorrem separadas pela distância
exata de lexemas uma da outra.
tsquery_phrase(to_tsquery('english', 'fat'), to_tsquery('english', 'cat'), 10)
→ 'fat' <10> 'cat'
tsquery_phrase(to_tsquery('portuguese', 'gato'), to_tsquery('portuguese', 'gordo'), 10)
→ 'gat' <10> 'gord'
|
tsvector_to_array ( tsvector )
→ text[]
Converte um tsvector em uma matriz de lexemas.
tsvector_to_array('fat:2,4 cat:3 rat:5A'::tsvector)
→ {cat,fat,rat}
tsvector_to_array('gord:2,4 gat:3 rat:5A'::tsvector)
→ {gat,gord,rat}
|
unnest ( tsvector )
→ setof record
( lexema text,
posições smallint[],
pesos text )
Expande um tsvector em um conjunto de linhas, uma
por lexema.
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}
SELECT * FROM unnest('gat:3 gord:2,4 rat:5A'::tsvector)
→
lexeme | positions | weights
--------+-----------+---------
gat | {3} | {D}
gord | {2,4} | {D,D}
rat | {5} | {A}
|