Análise de texto

Neste documento, você terá uma visão geral da análise de texto, também conhecida como mineração de texto, no GoogleSQL para BigQuery.

O GoogleSQL oferece suporte à análise de texto, que é uma técnica que pode ser usada para identificar termos (tokens) em texto não estruturado e usar esses termos para insights acionáveis, como indexação e pesquisa, ou como entradas para{101 }Vectorizations para serem usados em pipelines de treinamento de ML. Você pode usar um analisador de texto para analisar informações de uma maneira específica e opções de análise de texto para aplicar suas próprias personalizações de análise.

A análise de texto é compatível com as seguintes funções e declarações do GoogleSQL:

Analisadores de texto

O GoogleSQL para BigQuery oferece suporte a vários tipos de analisadores de texto, que podem ser usados para extrair dados de textos não estruturados. Você pode transmitir um analisador para algumas funções e instruções com o argumento analyzer. Cada analisador de texto tem uma forma única de extrair informações. Suas opções são:

NO_OP_ANALYZER: extrai a entrada como um único termo (token).
LOG_ANALYZER: divide a entrada em termos quando delimitadores são encontrados.
PATTERN_ANALYZER: divide a entrada em termos que correspondem a uma expressão regular.

`NO_OP_ANALYZER` analisador

O analisador NO_OP_ANALYZER é um analisador sem operação, que extrai o texto de entrada como um único termo (token). Nenhuma formatação é aplicada ao termo resultante.

Esse analisador não é compatível com nenhuma opção do analisador de texto nem com filtros de token.

Exemplo

A consulta a seguir usa NO_OP_ANALYZER como o analisador de texto:

SELECT TEXT_ANALYZE(
  'I like pie, you like-pie, they like 2 PIEs.',
  analyzer=>'NO_OP_ANALYZER'
) AS results

/*-----------------------------------------------*
 | results                                       |
 +-----------------------------------------------+
 | 'I like pie, you like-pie, they like 2 PIEs.' |
 *-----------------------------------------------*/

`LOG_ANALYZER` analisador

O analisador LOG_ANALYZER extrai o texto de entrada como termos (tokens) quando um delimitador é encontrado, descarta os delimitadores e, em seguida, muda quaisquer letras maiúsculas para minúsculas nos resultados.

Detalhes:

Uma letra maiúscula em um termo fica em minúscula, mas os valores ASCII superiores a 127 são mantidos como estão.
O texto é dividido em termos individuais quando um dos seguintes delimitadores, como espaço, ponto ou outro caractere que não é letra, é encontrado:
```
[ ] < > ( ) { } | ! ; , ' " * & ? + / : = @ . - $ % \ _ \n \r \s \t %21 %26
%2526 %3B %3b %7C %7c %20 %2B %2b %3D %3d %2520 %5D %5d %5B %5b %3A %3a %0A
%0a %2C %2c %28 %29
```
Se você não quiser usar esses delimitadores padrão, poderá especificar os delimitadores específicos que quer usar como opções do analisador de texto. Para mais informações, consulte a opção delimiters.

Este analisador é compatível com filtros de token. Para mais informações, consulte a opção token_filters. Se a opção token_filters não for especificada, a normalização de letras minúsculas ASCII será usada por padrão.

Exemplo

A consulta a seguir usa LOG_ANALYZER como o analisador de texto:

SELECT TEXT_ANALYZE(
  'I like pie, you like-pie, they like 2 PIEs.',
  analyzer=>'LOG_ANALYZER'
) AS results

/*---------------------------------------------------------------------------*
 | results                                                                   |
 +---------------------------------------------------------------------------+
 | [ 'i', 'like', 'pie', 'you', 'like', 'pie', 'they', 'like', '2', 'pies' ] |
 *---------------------------------------------------------------------------*/

Como LOG_ANALYZER é o analisador de texto padrão, não é necessário especificar na consulta. Por exemplo, a consulta a seguir produz os mesmos resultados que a consulta anterior:

SELECT TEXT_ANALYZE(
  'I like pie, you like-pie, they like 2 PIEs.'
) AS results

`PATTERN_ANALYZER` analisador

O analisador PATTERN_ANALYZER extrai termos (tokens) de textos não estruturados, usando uma expressão regular re2.

Esse analisador encontra o primeiro termo do lado esquerdo do texto de entrada que corresponde à expressão regular e adiciona esse termo à saída. Em seguida, ele remove o prefixo do texto de entrada até o termo recém-encontrado. Esse processo é repetido até que o texto de entrada esteja vazio.

Por padrão, a expressão regular \b\w{2,}\b é usada. Essa expressão regular corresponde a palavras não Unicode que tenham pelo menos dois caracteres. Se você quiser usar outra expressão regular, consulte a opção patterns.

Exemplo

A consulta abaixo usa PATTERN_ANALYZER como o analisador de texto. Como a expressão regular padrão é usada, apenas palavras com dois ou mais caracteres são incluídas como termos. Além disso, os resultados estão em letras minúsculas. i e 2 não aparecem nos resultados.

SELECT TEXT_ANALYZE(
  'I like pie, you like-pie, they like 2 PIEs.',
  analyzer=>'PATTERN_ANALYZER'
) AS results

/*----------------------------------------------------------------*
 | results                                                        |
 +----------------------------------------------------------------+
 | ['like', 'pie', 'you', 'like', 'pie', 'they', 'like', 'pies' ] |
 *----------------------------------------------------------------*/

Opções do analisador de texto

Os analisadores de texto oferecem suporte a opções personalizadas que determinam como o texto de entrada é analisado. Você pode transmitir opções do analisador para algumas funções e instruções com o argumento analyzer_options. Esse argumento usa um valor STRING formatado em JSON.

Suas opções são:

delimiters: divide a entrada em termos quando esses delimitadores são encontrados.
patterns: divide a entrada em termos que correspondem a uma expressão regular.
token_filters: depois que o texto de entrada for tokenizado em termos, aplique filtros aos termos.

Opção do analisador `delimiters`

'{
  "delimiters": array_of_delimiters
}'

Descrição

Se você estiver usando o analisador de texto LOG_ANALYZER e não quiser usar os delimitadores padrão, poderá especificar os delimitadores específicos que quer usar para filtrar o texto de entrada.

Definições

delimiters: uma matriz JSON contendo strings que representam os delimitadores a serem usados para tokenizar o texto de entrada.

Detalhes

Quando há dois delimitadores com o mesmo prefixo, por exemplo: % e %2, o delimitador mais longo tem precedência maior e é analisado primeiro.

Você pode adicionar qualquer string ASCII como um delimitador. O comprimento de um delimitador precisa ser menor ou igual a 16 caracteres. Alguns delimitadores comuns que você pode querer incluir são:

[ ] < > ( ) { } | ! ; , ' " * & ? + / : = @ . - $ % \ _ \n \r \s \t %21 %26
%2526 %3B %3b %7C %7c %20 %2B %2b %3D %3d %2520 %5D %5d %5B %5b %3A %3a %0A
%0a %2C %2c %28 %29

Exemplo

SELECT TEXT_ANALYZE(
  'I like pie, you like-pie, they like 2 PIEs.',
  analyzer=>'LOG_ANALYZER',
  analyzer_options=>'{"delimiters": [",", ".", "-"]}'
) AS results

/*-------------------------------------------------------*
 | results                                               |
 +-------------------------------------------------------+
 | ['i like pie', 'you like', 'pie', 'they like 2 pies]' |
 *-------------------------------------------------------*/

Opção do analisador `patterns`

'{
  "patterns": array_of_regex_patterns
}'

Descrição

Se você estiver usando o analisador de texto PATTERN_ANALYZER e não quiser usar a expressão regular padrão, especifique a expressão regular que quer usar para filtrar. o texto de entrada.

Definições

patterns: uma matriz JSON contendo uma string que representa a expressão regular.

Detalhes

Se essa opção não for fornecida para o analisador de texto PATTERN_ANALYZER, a expressão regular \b\w{2,}\b será usada por padrão para corresponder a palavras não Unicode que tenham pelo menos dois caracteres.

Exemplo

SELECT TEXT_ANALYZE(
  'I like pie, you like-pie, they like 2 PIEs.',
  analyzer=>'PATTERN_ANALYZER',
  analyzer_options=>'{"patterns": ["[a-zA-Z]*"]}'
) AS results

/*----------------------------------------------------------------*
 | results                                                        |
 +----------------------------------------------------------------+
 | ['like', 'pie', 'you', 'like', 'pie', 'they', 'like', 'pies' ] |
 *----------------------------------------------------------------*/

Opção do analisador `token_filters`

'{
  "token_filters": array_of_token_filters
}'

Descrição

Se você estiver usando o analisador de texto LOG_ANALYZER ou PATTERN_ANALYZER, será possível aplicar sequencialmente um ou mais filtros de token ao texto de entrada após o texto de entrada ter sido tokenizado.

Definições

array_of_token_filters: uma matriz JSON contendo objetos que representam filtros de token.

Detalhes

Para mais informações sobre os filtros de token específicos que podem ser adicionados, consulte Filtros de token.

Exemplo

Por exemplo, esta consulta contém as opções patterns e token_filters:

SELECT TEXT_ANALYZE(
  'I like pie, you like-pie, they like 2 PIEs.',
  analyzer=>'PATTERN_ANALYZER',
  analyzer_options=>'''
  {
    "patterns": ["[a-zA-Z]*"],
    "token_filters": [
      {
        "normalizer": {
          "mode": "LOWER"
        }
      },
      {
        "stop_words": ["they", "pie"]
      }
    ]
  }
  '''
) AS results

/*----------------------------------------------*
 | results                                      |
 +----------------------------------------------+
 | ['i', 'like', 'you', 'like', 'like, 'PIEs' ] |
 *----------------------------------------------*/

Filtros de token

'{
  "token_filters": [
    {
      "normalizer": {
        "mode": json_string,
        "icu_normalize_mode": json_string,
        "icu_case_folding": json_boolean
      }
    },
    {
      "stop_words": json_string_array
    }
  ]
}'

Os filtros de token podem modificar ou excluir termos (tokens) que são extraídos do texto de entrada. Se nenhum filtro de token for especificado para um analisador de texto compatível com filtros de token, o filtro de token de normalização de letras minúsculas ASCII será aplicado por padrão. Se vários filtros de token forem adicionados, eles serão aplicados na ordem em que forem especificados. O mesmo filtro de token pode ser incluído várias vezes na matriz token_filters. Veja os exemplos nesta seção para mais detalhes.

Definições

Cada filtro de token tem uma sintaxe JSON exclusiva que contém alguns destes pares de chave-valor JSON, dependendo do tipo de filtro de token que você quer usar:

token_filters: matriz JSON de objetos que contêm filtros de token. O mesmo tipo de filtro de token pode ser incluído várias vezes nessa matriz.
- stop_words: matriz JSON de strings que representam as palavras a serem removidas da lista de termos.
- normalizer: objeto JSON que contém as configurações de normalização para um filtro de token. As configurações incluem:
  - mode: string JSON que representa o modo de normalização. Suas opções são:
    - NONE: não aplica o modo de normalização aos termos.
    - LOWER: termos em letras minúsculas ASCII. Se nenhum filtro de token for especificado para um analisador de texto compatível com filtros de token, isso será usado por padrão.
    - ICU_NORMALIZE: termos de normalização da ICU.
  - icu_normalize_mode: string JSON que representa o modo de normalização da ICU. Suas opções são:
    - NFC: aplica a normalização de NFC ICU aos termos.
    - NFKC: aplica a normalização de NFKC do ICU aos termos.
    - NFD: aplica a normalização de NFD do ICU aos termos.
    - NFKD: aplica a normalização de NFKD do ICU aos termos.
    Você pode usar isso se mode for ICU_NORMALIZE. Se mode for ICU_NORMALIZE e esse par de chave-valor não estiver definido, icu_normalize_mode será NFKC por padrão.
  - icu_case_folding: booleano JSON que determina se o caso de dobramento da ICU será aplicado aos termos. true para aplicar o dobramento de casos de ICU a termos. Se esse não for seu caso, false.
    
    Você pode usar isso se mode for ICU_NORMALIZE. Se mode for ICU_NORMALIZE e esse valor não for usado, icu_case_folding será true por padrão.

Detalhes

Os filtros de token podem ser usados com todos, exceto o analisador de texto NO_OP_ANALYZER na mesma consulta. Os filtros de token são aplicados depois que o analisador de texto divide o texto de entrada em termos.

Se token_filters não for especificado para um analisador compatível com filtros de token, a normalização de letras minúsculas ASCII será aplicada por padrão.

É possível adicionar vários filtros de token à matriz de filtros de token (token_filters). Se vários filtros de token forem adicionados, eles serão aplicados aos termos na ordem em que forem especificados. Para mais informações, consulte os exemplos nesta seção.

É possível adicionar o mesmo filtro de token várias vezes à matriz de filtros de token. Para mais informações, consulte os exemplos nesta seção.

Veja a seguir alguns dos filtros que podem ser aplicados a termos usando a sintaxe JSON de filtro de token:

Sem normalização
Converter para letras minúsculas (ASCII)
Converter para letras minúsculas (caso dobrável da ICU)
Manter letras maiúsculas
Normalização da ICU com NFC
ICU normalizada com NFKC
ICU normalizada com NFD
ICU normalizada com NFKD
Remover palavras

Exemplos

No exemplo abaixo, os termos são normalizados por NFKC e, como a dobra do caso da ICU é true, os termos são convertidos para letras minúsculas. Por fim, as palavras minúsculas pies e 2 são removidas da consulta.

SELECT TEXT_ANALYZE(
  'I like ❶ ② pies, you like Ño PIEs',
  analyzer=>'LOG_ANALYZER',
  analyzer_options=>'''
  {
    "token_filters": [
      {
        "normalizer": {
          "mode": "ICU_NORMALIZE",
          "icu_normalize_mode": "NFKC",
          "icu_case_folding": true
        }
      },
      {
        "stop_words": ["pies", "2"]
      }
    ]
  }
  '''
) AS results

/*------------------------------------------*
 | results                                  |
 +------------------------------------------+
 | ['i', 'like', '❶', 'you', 'like', 'ño' ] |
 *------------------------------------------*/

A consulta a seguir é semelhante à anterior, mas a ordem dos filtros de token é reordenada, e isso afeta o resultado. Nos resultados, 2 e PIEs são mantidos porque ② é normalizado como 2, e PIEs é normalizado para pies após o token de palavras de parada. filtro for aplicado:

SELECT TEXT_ANALYZE(
  'I like ❶ ② pies, you like Ño PIEs',
  analyzer=>'LOG_ANALYZER',
  analyzer_options=>'''
  {
    "token_filters": [
      {
        "stop_words": ["pies", "2"]
      },
      {
        "normalizer": {
          "mode": "ICU_NORMALIZE",
          "icu_normalize_mode": "NFKC",
          "icu_case_folding": true
        }
      }
    ]
  }
  '''
) AS results

/*-------------------------------------------------------*
 | results                                               |
 +-------------------------------------------------------+
 | ['i', 'like', '❶', '2', 'you', 'like', 'ño', 'pies' ] |
 *-------------------------------------------------------*/

É possível usar o mesmo filtro de token quantas vezes você quiser em uma consulta. Na consulta a seguir, stop_words é usado duas vezes:

SELECT TEXT_ANALYZE(
  'I like ❶ ② pies, you like Ño PIEs',
  analyzer=>'LOG_ANALYZER',
  analyzer_options=>'''
  {
    "token_filters": [
      {
        "stop_words": ["like", "you"]
      },
      {
        "normalizer": {
          "mode": "ICU_NORMALIZE",
          "icu_normalize_mode": "NFKC",
          "icu_case_folding": true
        }
      },
      {
        "stop_words": ["ño"]
      }
    ]
  }
  '''
) AS results

/*----------------------------------*
 | results                          |
 +----------------------------------+
 | ['i', '❶', '2', 'pies', 'pies' ] |
 *----------------------------------*/

Sem normalização

'{
  "token_filters": [
    "normalizer": {
      "mode": "NONE"
    }
  ]
}'

Descrição

A normalização não é aplicada a termos.

Exemplo

Na consulta a seguir, a normalização não é aplicada aos resultados:

SELECT TEXT_ANALYZE(
  'I like ❶ ② pies, you like Ño PIEs',
  analyzer=>'LOG_ANALYZER',
  analyzer_options=>'''
  {
    "token_filters": [
      {
        "normalizer": {
          "mode": "NONE"
        }
      }
    ]
  }
  '''
) AS results

/*----------------------------------------------------------------*
 | results                                                        |
 +----------------------------------------------------------------+
 | ['I', 'like', '❶', '②', 'pies', 'you', 'like', 'Ño', 'PIEs' ] |
 *----------------------------------------------------------------*/

Converter para letras minúsculas (ASCII)

'{
  "token_filters": [
    "normalizer": {
      "mode": "LOWER"
    }
  ]
}'

Descrição

Executa letras minúsculas em ASCII nos termos resultantes.

Exemplo

Na consulta a seguir, a letra minúscula em ASCII é aplicada aos resultados:

SELECT TEXT_ANALYZE(
  'I like ❶ ② pies, you like Ño PIEs',
  analyzer=>'LOG_ANALYZER',
  analyzer_options=>'''
  {
    "token_filters": [
      {
        "normalizer": {
          "mode": "LOWER"
        }
      }
    ]
  }
  '''
) AS results

/*----------------------------------------------------------------*
 | results                                                        |
 +----------------------------------------------------------------+
 | ['i', 'like', '❶', '②', 'pies', 'you', 'like', 'Ño', 'pies' ] |
 *----------------------------------------------------------------*/

Converter para letras minúsculas (caso dobrável da ICU)

'{
  "token_filters": [
    "normalizer": {
      "mode": "ICU_NORMALIZE",
      "icu_case_folding": true
    }
  ]
}'

Descrição

Realiza a dobra de maiúsculas e minúsculas da ICU, que converte os termos resultantes em letras minúsculas.

Exemplo

Na consulta a seguir, o dobramento de casos de ICU é aplicado aos resultados:

SELECT TEXT_ANALYZE(
  'I like ❶ ② pies, you like Ño PIEs',
  analyzer=>'LOG_ANALYZER',
  analyzer_options=>'''
  {
    "token_filters": [
      {
        "normalizer": {
          "mode": "ICU_NORMALIZE",
          "icu_case_folding": true
        }
      }
    ]
  }
  '''
) AS results

/*--------------------------------------------------------------*
 | results                                                      |
 +--------------------------------------------------------------+
 | ['i', 'like', '❶', '2' 'pies', 'you', 'like', 'ño', 'pies' ] |
 *--------------------------------------------------------------*/

Preservar letras maiúsculas

'{
  "token_filters": [
    "normalizer": {
      "mode": "ICU_NORMALIZE",
      "icu_case_folding": false
    }
  ]
}'

Descrição

Não converta caracteres maiúsculos em minúsculos nos termos resultantes.

Exemplo

Na consulta a seguir, o dobramento de casos de ICU não é aplicado aos resultados:

SELECT TEXT_ANALYZE(
  'I like ❶ ② pies, you like Ño PIEs',
  analyzer=>'LOG_ANALYZER',
  analyzer_options=>'''
  {
    "token_filters": [
      {
        "normalizer": {
          "mode": "ICU_NORMALIZE",
          "icu_case_folding": false
        }
      }
    ]
  }
  '''
) AS results

/*---------------------------------------------------------------*
 | results                                                       |
 +---------------------------------------------------------------+
 | ['I', 'like', '❶', '2' 'pies', 'you', 'like',  'Ño', 'PIEs' ] |
 *---------------------------------------------------------------*/

Normalização da ICU com NFC

'{
  "token_filters": [
    "normalizer": {
      "mode": "ICU_NORMALIZE",
      "icu_normalize_mode": "NFC"
    }
  ]
}'

Descrição

Normaliza o texto com a normalização NFC ICU, que decompõe e recompõe caracteres por equivalência canônica.

Exemplo

Na consulta a seguir, a normalização NFC é aplicada aos resultados:

SELECT TEXT_ANALYZE(
  'I like ❶ ② pies, you like Ño PIEs',
  analyzer=>'LOG_ANALYZER',
  analyzer_options=>'''
  {
    "token_filters": [
      {
        "normalizer": {
          "mode": "ICU_NORMALIZE",
          "icu_normalize_mode": "NFC"
        }
      }
    ]
  }
  '''
) AS results

/*---------------------------------------------------------------*
 | results                                                       |
 +---------------------------------------------------------------+
 | ['i', 'like', '❶', '②' 'pies', 'you', 'like',  'ño', 'pies' ] |
 *---------------------------------------------------------------*/

Normalização da UTI com NFKC

'{
  "token_filters": [
    "normalizer": {
      "mode": "ICU_NORMALIZE",
      "icu_normalize_mode": "NFKC"
    }
  ]
}'

Descrição

Normaliza o texto com a normalização ICU NFKC, que decompõe caracteres por compatibilidade e, em seguida, recompõe os caracteres por equivalência canônica.

Exemplo

Na consulta a seguir, a normalização NFKC é aplicada aos resultados:

SELECT TEXT_ANALYZE(
  'I like ❶ ② pies, you like Ño PIEs',
  analyzer=>'LOG_ANALYZER',
  analyzer_options=>'''
  {
    "token_filters": [
      {
        "normalizer": {
          "mode": "ICU_NORMALIZE",
          "icu_normalize_mode": "NFKC"
        }
      }
    ]
  }'''
) AS results

/*---------------------------------------------------------------*
 | results                                                       |
 +---------------------------------------------------------------+
 | ['i', 'like', '❶', '2' 'pies', 'you', 'like',  'ño', 'pies' ] |
 *---------------------------------------------------------------*/

Normalização da ICU com NFD

'{
  "token_filters": [
    "normalizer": {
      "mode": "ICU_NORMALIZE",
      "icu_normalize_mode": "NFD"
    }
  ]
}'

Descrição

Normaliza o texto com a normalização ICU NFD, que decompõe caracteres por equivalência canônica e, em seguida, organiza vários caracteres combinados em uma ordem específica.

Exemplo

Na consulta a seguir, embora a entrada e a saída de ñ pareçam iguais, os bytes são diferentes (a entrada é \u00f1, a saída é \u006e \u0303).

SELECT TEXT_ANALYZE(
  'I like ❶ ② pies, you like Ño PIEs',
  analyzer=>'LOG_ANALYZER',
  analyzer_options=>'''
  {
    "token_filters": [
      {
        "normalizer": {
          "mode": "ICU_NORMALIZE",
          "icu_normalize_mode": "NFD"
        }
      }
    ]
  }
  '''
) AS results

/*---------------------------------------------------------------*
 | results                                                       |
 +---------------------------------------------------------------+
 | ['i', 'like', '❶', '2' 'pies', 'you', 'like',  'ño', 'pies' ] |
 *---------------------------------------------------------------*/

Normalização da UTI com NFKD

'{
  "token_filters": [
    "normalizer": {
      "mode": "ICU_NORMALIZE",
      "icu_normalize_mode": "NFKD"
    }
  ]
}'

Descrição

Normaliza o texto com a normalização ICU NFKD, que decompõe caracteres por compatibilidade e organiza vários caracteres combinados em uma ordem específica.

Exemplo

Na consulta a seguir, embora a entrada e a saída de ñ pareçam iguais, os bytes são diferentes (a entrada é \u00f1, a saída é \u006e \u0303).

SELECT TEXT_ANALYZE(
  'I like ❶ ② pies, you like Ño PIEs',
  analyzer=>'LOG_ANALYZER',
  analyzer_options=>'''
  {
    "token_filters": [
      {"normalizer": {
        "mode": "ICU_NORMALIZE",
        "icu_normalize_mode": "NFKD"
        }
      }
    ]
  }'''
) AS results

/*---------------------------------------------------------------*
 | results                                                       |
 +---------------------------------------------------------------+
 | ['i', 'like', '❶', '2' 'pies', 'you', 'like',  'ño', 'pies' ] |
 *---------------------------------------------------------------*/

Remover palavras

'{
  "token_filters": [
    "stop_words": array_of_stop_words
  ]
}'

Descrição

Exclui uma lista de termos (tokens) dos resultados.

Definições

array_of_stop_words: uma matriz JSON contendo strings que representam termos. Esses termos não devem ser incluídos nos resultados. A matriz precisa ter pelo menos um elemento. Uma string vazia é um elemento de matriz válido.

Exemplo

Na consulta a seguir, as palavras they e pie são excluídas dos resultados:

SELECT TEXT_ANALYZE(
  'I like pie, you like-pie, they like 2 PIEs.',
  analyzer=>'LOG_ANALYZER',
  analyzer_options=>'''
  {
    "token_filters": [
      {
        "stop_words": ["they", "pie"]
      }
    ]
  }
  '''
) AS results

/*---------------------------------------------------*
 | results                                           |
 +---------------------------------------------------+
 | ['I', 'like', 'you', 'like', 'like, '2', 'PIEs' ] |
 *---------------------------------------------------*/

Análise de texto

Analisadores de texto

NO_OP_ANALYZER analisador

LOG_ANALYZER analisador

PATTERN_ANALYZER analisador

Opções do analisador de texto

Opção do analisador delimiters

Opção do analisador patterns

Opção do analisador token_filters

Filtros de token

Sem normalização

Converter para letras minúsculas (ASCII)

Converter para letras minúsculas (caso dobrável da ICU)

Preservar letras maiúsculas

Normalização da ICU com NFC

Normalização da UTI com NFKC

Normalização da ICU com NFD

Normalização da UTI com NFKD

Remover palavras

`NO_OP_ANALYZER` analisador

`LOG_ANALYZER` analisador

`PATTERN_ANALYZER` analisador

Opção do analisador `delimiters`

Opção do analisador `patterns`

Opção do analisador `token_filters`