As palavras de parada são palavras muito comuns, que aparecem em quase todos os documentos, e não têm valor de diferenciação. Portanto, podem ser ignoradas no contexto de procura de texto completo. Por exemplo, todo texto em inglês contém palavras como a e the, então é inútil armazená-las em um índice. Entretanto, as palavras de parada afetam as posições em tsvector, que por sua vez afetam a pontuação:

SELECT to_tsvector('english', 'in the list of stop words');

        to_tsvector
----------------------------
 'list':3 'stop':5 'word':6

-- Exemplo do tradutor abaixo

SELECT to_tsvector('portuguese', 'na lista de palavras de parada');

         to_tsvector
-----------------------------
 'list':2 'palavr':4 'par':6

As posições faltantes 1, 2 e 4 no exemplo em inglês, e 1, 3 e 5 no exemplo em português, se deve às palavras de parada. As pontuações calculadas para documentos “com e sem” palavras de parada são bem diferentes:

SELECT ts_rank_cd (
    to_tsvector('english', 'in the list of stop words'),
    to_tsquery('list & stop'));

 ts_rank_cd
------------
       0.05

SELECT ts_rank_cd (
    to_tsvector('english', 'list stop words'),
    to_tsquery('list & stop'));

 ts_rank_cd
------------
        0.1

-- Exemplos do tradutor abaixo

SELECT ts_rank_cd (
    to_tsvector('portuguese', 'na lista de palavras de parada'),
    to_tsquery('lista & parada'));

 ts_rank_cd
------------
      0.025

SELECT ts_rank_cd (
    to_tsvector('portuguese', 'lista palavras parada'),
    to_tsquery('lista & parada'));

 ts_rank_cd
------------
       0.05

Cabe ao dicionário específico determinar como as palavras de parada são tratadas. Por exemplo, os dicionários Ispell primeiro normalizam as palavras, e depois examinam a lista de palavras de parada, enquanto os lematizadores Snowball primeiro verificam a lista de palavras de parada. A razão para o comportamento diferente é uma tentativa de diminuir o ruído.

O modelo de dicionário simple opera convertendo o token de entrada em letras minúsculas, e verificando-o em um arquivo de palavras de parada. Se for encontrado no arquivo, é retornada uma matriz vazia, fazendo com que o token seja descartado. Caso contrário, é retornada a forma em letras minúsculas da palavra como o lexema normalizado. Como alternativa, o dicionário pode ser configurado para relatar palavras que não são palavras de parada como não reconhecidas, permitindo que sejam passadas para o próximo dicionário na lista.

Abaixo está um exemplo de definição de dicionário usando o modelo simple:

CREATE TEXT SEARCH DICTIONARY public.simple_dict (
    TEMPLATE = pg_catalog.simple,
    STOPWORDS = english
);

Nesta definição, english é o nome base do arquivo de palavras de parada. O nome completo do arquivo será $SHAREDIR/tsearch_data/english.stop, onde $SHAREDIR representa o diretório de dados compartilhados da instalação do PostgreSQL, que é nesta versão /usr/share/postgresql/18 (use o comando pg_config --sharedir para conhecer o valor a ser atribuído a $SHAREDIR, se for outra versão ou não tiver sido atribuído ainda). O formato do arquivo é apenas uma lista de palavras, uma por linha. As linhas em branco e os espaços à direita são ignorados, e as letras maiúsculas são convertidas em minúsculas, mas nenhum outro processamento é feito no conteúdo do arquivo. (Veja o Exemplo 12.3.)

Agora podemos testar o nosso dicionário:

SELECT ts_lexize('public.simple_dict', 'YeS');

 ts_lexize
-----------
 {yes}

SELECT ts_lexize('public.simple_dict', 'The');

 ts_lexize
-----------
 {}

Também podemos optar por retornar NULL, em vez de retornar a palavra em letras minúsculas, se a palavra não for encontrada no arquivo de palavras de parada. Esse comportamento é selecionado definindo o parâmetro Accept do dicionário como false. Continuando o exemplo:

ALTER TEXT SEARCH DICTIONARY public.simple_dict ( Accept = false );
ALTER TEXT SEARCH DICTIONARY
\pset null "(nulo)"
A exibição de nulos é ""(nulo)"".
SELECT ts_lexize('public.simple_dict', 'YeS');

 ts_lexize
-----------
 "(nulo)"

SELECT ts_lexize('public.simple_dict', 'The');

 ts_lexize
-----------
 {}

Com a configuração padrão Accept = true, só é útil colocar o dicionário simple no final da lista de dicionários, porque nunca passará nenhum token para o dicionário seguinte. Ao contrário, Accept = false só é útil quando existe pelo menos um dicionário depois.

Este modelo de dicionário é usado para criar dicionários que substituem uma palavra por um sinônimo. Não há suporte para frases (deve ser usado o modelo thesaurus para isso, veja a Seção 12.6.4). O dicionário de sinônimos pode ser usado para superar problemas linguísticos, como, por exemplo, evitar que um dicionário lematizador de inglês reduza a palavra “Paris” para “pari”. Para isso, basta haver a linha Paris paris no dicionário de sinônimos, e colocá-lo antes do dicionário english_stem. (Veja o Exemplo 12.4.) Por exemplo:

SELECT * FROM ts_debug('english', 'Paris');

   alias   |   description   | token |  dictionaries  |  dictionary  | lexemes
-----------+-----------------+-------+----------------+--------------+---------
 asciiword | Word, all ASCII | Paris | {english_stem} | english_stem | {pari}

-- Primeiro o arquivo 'my_synonyms.syn' precisa ser criado e editado,
-- sudo nano  $SHAREDIR/tsearch_data/my_synonyms.syn"
-- adicionando a linha “paris tabulação paris”
-- para, depois, ser executado o comando abaixo. (N. T.)

postgres=# CREATE TEXT SEARCH DICTIONARY my_synonym (
    TEMPLATE = synonym,
    SYNONYMS = my_synonyms
);

-- É necessário ser um superusuário para executar o comando abaixo.
-- Esta alteração só atinge o banco de dados onde é executada,
-- não se aplicando aos demais bancos de dados (N. T.)

postgres=# ALTER TEXT SEARCH CONFIGURATION english
    ALTER MAPPING FOR asciiword
    WITH my_synonym, english_stem;
ALTER TEXT SEARCH CONFIGURATION
postgres=# SELECT * FROM ts_debug('english', 'Paris');

   alias   |   description   | token |       dictionaries        | dictionary | lexemes
-----------+-----------------+-------+---------------------------+------------+---------
 asciiword | Word, all ASCII | Paris | {my_synonym,english_stem} | my_synonym | {paris}

O único parâmetro requerido pelo modelo synonym é SYNONYMS, que é o nome base do arquivo de configuração — my_synonyms no exemplo acima. O nome completo do arquivo será $SHAREDIR/tsearch_data/my_synonyms.syn (onde $SHAREDIR representa o diretório de dados compartilhados da instalação do PostgreSQL). O formato do arquivo é apenas uma linha por palavra a ser substituída, com a palavra seguida de seu sinônimo, separada por espaço em branco. Linhas em branco e espaços à direita são ignorados.

O modelo synonym também tem o parâmetro opcional CaseSensitive, que o padrão é false. Quando CaseSensitive for false, as palavras no arquivo de sinônimos serão convertidas para letras minúsculas, assim como os tokens de entrada. Quando for true, as palavras e os tokens não serão convertidos para letras minúsculas, e serão comparados como estão.

Pode ser colocado um asterisco (*) no final de um sinônimo no arquivo de configuração. Isto indica que o sinônimo é um prefixo. O asterisco é ignorado quando a entrada é usada em to_tsvector(), mas quando é usada em to_tsquery() o resultado será um item de consulta com o marcador de correspondência de prefixo (veja a Seção 12.3.2). Por exemplo, suponha que temos estas entradas em $SHAREDIR/tsearch_data​/synonym_sample.syn:

postgres        pgsql
postgresql      pgsql
postgre pgsql
gogle   googl
indices index*

Então vamos obter estes resultados:

CREATE TEXT SEARCH DICTIONARY syn (template=synonym, synonyms='synonym_sample');
CREATE TEXT SEARCH DICTIONARY
SELECT ts_lexize('syn', 'indices');

 ts_lexize
-----------
 {index}

CREATE TEXT SEARCH CONFIGURATION tst (copy=simple);
ALTER TEXT SEARCH CONFIGURATION tst ALTER MAPPING FOR asciiword WITH syn;
ALTER TEXT SEARCH CONFIGURATION
SELECT to_tsvector('tst', 'indices');

 to_tsvector
-------------
 'index':1

SELECT to_tsquery('tst', 'indices');

 to_tsquery
------------
 'index':*

SELECT 'indexes are very useful'::tsvector;

            tsvector
---------------------------------
 'are' 'indexes' 'useful' 'very'

SELECT 'indexes are very useful'::tsvector @@ to_tsquery('tst', 'indices');

 ?column?
----------
 t

O dicionário thesaurus (às vezes abreviado como TZ), é uma coleção de palavras que inclui informações sobre as relações entre palavras e frases, ou seja, termos mais amplos ( broader terms, BT), termos mais restritos (narrower terms, NT), termos preferidos, termos não preferidos, termos relacionados, etc.

Basicamente, o dicionário thesaurus substitui todos os termos não preferidos por um termo preferido e, opcionalmente, preserva os termos originais para serem indexados também. A implementação corrente do dicionário thesaurus no PostgreSQL, é uma extensão do dicionário de sinônimos com suporte adicionado a frase. O dicionário thesaurus requer um arquivo de configuração com o seguinte formato:

# Isto é um comentário
palavra(s) de amostra: palavra(s) indexada(s)
mais palavra(s) de amostra: mais palavra(s) indexada(s)
...

onde o caractere dois pontos (:) atua como delimitador entre a frase e sua substituição.

O dicionário thesaurus usa um sub-dicionário (especificado na configuração do dicionário) para normalizar o texto de entrada antes de verificar as correspondências de frase. Só é possível selecionar um sub-dicionário. Se o sub-dicionário não reconhecer a palavra, é informado erro. Nesse caso, o uso da palavra deve ser suprimido, ou ser informado ao sub-dicionário sobre ela. Pode ser colocado um asterisco (*) no início de uma palavra indexada, para suprimir a aplicação do sub-dicionário nela, mas todas as palavras de amostra devem ser conhecidas pelo sub-dicionário.

O dicionário thesaurus escolhe a correspondência mais longa, se houver várias frases que correspondam à entrada, e os empates são resolvidos usando a última definição.

Não podem ser especificadas palavras de parada reconhecidas pelo sub-dicionário; no lugar delas, deve ser usado o ponto de interrogação (?) para marcar o local onde alguma palavra de parada possa aparecer. Por exemplo, assumindo que a e the são palavras de parada segundo o sub-dicionário:

? one ? two : swsw

corresponde a “a one the two” e a “the one a two”; os dois seriam substituídos por swsw.

Como o dicionário thesaurus consegue reconhecer frases, ele deve lembrar seu estado e interagir com o analisador. O dicionário thesaurus usa essas atribuições para verificar se deve lidar com a próxima palavra, ou parar a acumulação. O dicionário thesaurus deve ser configurado com cuidado. Por exemplo, se o dicionário thesaurus for destinado a lidar apenas com token asciiword, uma definição de dicionário thesaurus como “um 7” não vai funcionar, porque o tipo de token uint não está atribuído ao dicionário thesaurus.

CREATE TEXT SEARCH DICTIONARY thesaurus_simple (
    TEMPLATE = thesaurus,
    DictFile = thesaurus_sample,
    Dictionary = pg_catalog.english_stem
);

ALTER TEXT SEARCH CONFIGURATION danish
    ALTER MAPPING FOR asciiword, asciihword, hword_asciipart
    WITH thesaurus_simple;

supernovae stars : sn
crab nebulae : crab

postgres=# CREATE TEXT SEARCH DICTIONARY thesaurus_astro (
    TEMPLATE = thesaurus,
    DictFile = thesaurus_astro,
    Dictionary = english_stem
);
CREATE TEXT SEARCH DICTIONARY
postgres=# ALTER TEXT SEARCH CONFIGURATION danish
    ALTER MAPPING FOR asciiword, asciihword, hword_asciipart
    WITH thesaurus_astro, english_stem;
ALTER TEXT SEARCH CONFIGURATION

postgres=# SELECT plainto_tsquery('danish', 'supernova star');

 plainto_tsquery
-----------------
 'sn'

postgres=# SELECT to_tsvector('danish', 'supernova star');

 to_tsvector
-------------
 'sn':1

postgres=# SELECT to_tsquery('danish', '''supernova star''');

 to_tsquery
------------
 'sn'

postgres=# SELECT to_tsquery('danish', $$'supernova star'$$);

 to_tsquery
------------
 'sn'

supernovae stars : sn supernovae stars

-- Recarregar thesaurus_astro

postgres=# ALTER TEXT SEARCH DICTIONARY thesaurus_astro ( dummy );
ALTER TEXT SEARCH DICTIONARY
postgres=# SELECT plainto_tsquery('danish', 'supernova star');

       plainto_tsquery
-----------------------------
 'sn' & 'supernova' & 'star'

O modelo de dicionário Ispell oferece suporte a dicionários morfológicos, que podem normalizar muitas formas linguísticas diferentes de uma palavra no mesmo lexema. Por exemplo, o dicionário Ispell em inglês pode corresponder a todas as declinações e conjugações do termo de procura bank, ou seja, banking, banked, banks, banks' e bank's.

A distribuição padrão do PostgreSQL não inclui nenhum arquivo de configuração do Ispell. Dicionários para um grande número de idiomas estão disponíveis em Ispell. Além disso, há suporte para alguns formatos de arquivo de dicionário mais modernos — MySpell (OO < 2.0.1) e Hunspell (OO >= 2.0.2). Uma grande lista de dicionários está disponível no OpenOffice Wiki.

Para criar o dicionário Ispell devem ser executadas as seguintes etapas:

No comando acima, DictFile, AffFile e StopWords especificam os nomes base dos arquivos de dicionário, afixos e palavras de parada. O arquivo de palavras de parada tem o mesmo formato explicado acima para o tipo de dicionário simple. O formato dos outros arquivos não é especificado aqui, mas está disponível nos sites mencionados acima.

Os dicionários Ispell geralmente reconhecem um conjunto limitado de palavras, e por isso devem ser seguidos por outro dicionário mais amplo; por exemplo, um dicionário Snowball, que reconhece tudo.

O arquivo .affix do Ispell possui a seguinte estrutura:

prefixes
flag *A:
    .           >   RE      # As in enter > reenter
suffixes
flag T:
    E           >   ST      # As in late > latest
    [^AEIOU]Y   >   -Y,IEST # As in dirty > dirtiest
    [AEIOU]Y    >   EST     # As in gray > grayest
    [^EY]       >   EST     # As in small > smallest

E o arquivo .dict possui a seguinte estrutura:

lapse/ADGRS
lard/DGRS
large/PRTY
lark/MRS

O formato do arquivo .dict é:

basic_form/affix_class_name

No arquivo .affix, cada sinalizador de afixo é descrito no seguinte formato:

condition > [-stripping_letters,] adding_affix

Aqui, a condição tem um formato semelhante ao formato das expressões regulares. Pode usar agrupamentos [...] e [^...]. Por exemplo, [AEIOU]Y significa que a última letra da palavra é "y" e a penúltima letra é "a", "e", "i", "o" ou "u". [^EY] significa que a última letra não é nem "e" nem "y".

Os dicionários Ispell dão suporte para dividir palavras compostas; uma funcionalidade útil. Note que o arquivo de afixo deve especificar um sinalizador especial usando a instrução compoundwords controlled, que marca as palavras do dicionário que podem participar da formação composta:

compoundwords  controlled z

Aqui estão alguns exemplos para o idioma norueguês:

SELECT ts_lexize('norwegian_ispell', 'overbuljongterningpakkmesterassistent');
   {over,buljong,terning,pakk,mester,assistent}
SELECT ts_lexize('norwegian_ispell', 'sjokoladefabrikk');
   {sjokoladefabrikk,sjokolade,fabrikk}

O formato MySpell é um subconjunto de Hunspell. O arquivo .affix do Hunspell possui a seguinte estrutura:

PFX A Y 1
PFX A   0     re         .
SFX T N 4
SFX T   0     st         e
SFX T   y     iest       [^aeiou]y
SFX T   0     est        [aeiou]y
SFX T   0     est        [^ey]

A primeira linha de uma classe de afixo é o cabeçalho. Os campos de uma regra de afixo são listados após o cabeçalho:

O arquivo .dict se parece com o arquivo .dict do Ispell:

larder/M
lardy/RT
large/RSPMYT
largehearted

O modelo de dicionário Snowball é baseado em um projeto de Martin Porter, inventor do popular algoritmo de derivação de Porter para o idioma inglês. O Snowball agora fornece algoritmos de lematização para muitos idiomas (veja o site do Snowball para obter mais informações). Cada algoritmo sabe como reduzir as formas variantes comuns das palavras a uma base, ou radical, relativa ao idioma. O dicionário Snowball requer o parâmetro language para identificar o lematizador a ser usado e, opcionalmente, um nome de arquivo stopword que fornece a lista de palavras a serem eliminadas. (As listas de palavras de parada padrão do PostgreSQL também são fornecidas pelo projeto Snowball.) Por exemplo, existe uma definição nativa equivalente a

CREATE TEXT SEARCH DICTIONARY english_stem (
    TEMPLATE = snowball,
    Language = english,
    StopWords = english
);

O formato do arquivo de palavras de parada é o mesmo já explicado.

O dicionário Snowball reconhece tudo, consiga ou não simplificar a palavra, devendo por isso ser colocado no final da lista de dicionários. É inútil tê-lo antes de qualquer outro dicionário, porque ele nunca passará um token para o próximo dicionário.