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
.
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 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
forICU_NORMALIZE
. Semode
forICU_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
forICU_NORMALIZE
. Semode
forICU_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' ] |
*---------------------------------------------------*/