Análisis de texto

Este documento proporciona una descripción general del análisis de texto, también conocido como extracción de texto, en Google SQL para BigQuery.

GoogleSQL admite el análisis de texto, que es una técnica que puedes usar para identificar términos (tokens) en texto no estructurado y, luego, usarlos para obtener estadísticas prácticas, como la indexación y búsqueda, o como entradas para{101 }Las vectorizaciones que se usarán en las canalizaciones de entrenamiento de AA. Puedes usar un analizador de texto para analizar información de una manera específica y opciones de análisis de texto a fin de aplicar tus propias personalizaciones de análisis.

El análisis de texto es compatible con las siguientes funciones y declaraciones de Google SQL:

Analizadores de texto

GoogleSQL para BigQuery es compatible con varios tipos de analizadores de texto, que puedes usar a fin de extraer datos de texto no estructurado. Puedes pasar un analizador a algunas funciones y declaraciones con el argumento analyzer. Cada analizador de texto tiene una forma única de extraer información. Tus opciones son las siguientes:

NO_OP_ANALYZER: Extrae la entrada como un término único (token).
LOG_ANALYZER: Divide la entrada en términos cuando se encuentran delimitadores.
PATTERN_ANALYZER: Divide la entrada en términos que coinciden con una expresión regular.

Analyzer `NO_OP_ANALYZER`

El analizador NO_OP_ANALYZER es un analizador sin operaciones, que extrae el texto de entrada como un término único (token). No se aplica formato al término resultante.

Este analizador no admite opciones de analizador de texto ni filtros de tokens.

Ejemplo

La siguiente consulta usa NO_OP_ANALYZER como analizador 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.' |
 *-----------------------------------------------*/

Analyzer `LOG_ANALYZER`

El analizador LOG_ANALYZER extrae el texto de entrada como términos (tokens) cuando se encuentra un delimitador, descarta los delimitadores y, luego, cambia las letras mayúsculas a letras minúsculas en los resultados.

Detalles:

Una letra mayúscula en un término está en minúscula, pero los valores ASCII mayores que 127 se conservan como están.
El texto se divide en términos individuales cuando se encuentra uno de los siguientes delimitadores, como un espacio, un punto o algún otro carácter que no sea letra:
```
[ ] < > ( ) { } | ! ; , ' " * & ? + / : = @ . - $ % \ _ \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
```
Si no deseas usar estos delimitadores predeterminados, puedes especificar los delimitadores específicos que deseas usar como opciones del analizador de texto. Para obtener más información, consulta la opción delimiters.

Este analizador admite filtros de token. Para obtener más información, consulta la opción token_filters. Si no se especifica la opción token_filters, se usa la normalización de minúsculas ASCII de forma predeterminada.

Ejemplo

La siguiente consulta usa LOG_ANALYZER como analizador 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' ] |
 *---------------------------------------------------------------------------*/

Debido a que LOG_ANALYZER es el analizador de texto predeterminado, no es necesario especificarlo en la consulta. Por ejemplo, la siguiente consulta genera los mismos resultados que la consulta anterior:

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

Analyzer `PATTERN_ANALYZER`

El analizador PATTERN_ANALYZER extrae términos (tokens) de texto no estructurado, mediante una expresión regular re2.

Este analizador encuentra el primer término del lado izquierdo del texto de entrada que coincide con la expresión regular y agrega este término al resultado. Luego, quita el prefijo del texto de entrada hasta el término que se acaba de encontrar. Este proceso se repite hasta que el texto de entrada esté vacío.

De forma predeterminada, se usa la expresión regular \b\w{2,}\b. Esta expresión regular coincide con palabras que no son Unicode que tienen al menos dos caracteres. Si deseas usar otra expresión regular, consulta opción patterns.

Ejemplo

La siguiente consulta usa PATTERN_ANALYZER como el analizador de texto. Debido a que se usa la expresión regular predeterminada, solo se incluyen las palabras que tienen dos o más caracteres como términos. Además, los resultados están en minúsculas. Ten en cuenta que i y 2 no aparecen en los 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' ] |
 *----------------------------------------------------------------*/

Opciones del analizador de texto

Los analizadores de texto admiten opciones personalizadas que determinan cómo se analiza el texto de entrada. Puedes pasar opciones de analizador a algunas funciones y declaraciones con el argumento analyzer_options. Este argumento toma un valor STRING con formato JSON.

Tus opciones son las siguientes:

delimiters: Divide la entrada en términos cuando se encuentran estos delimitadores.
patterns: Divide la entrada en términos que coinciden con una expresión regular.
token_filters: Después de asignar tokens a la palabra de entrada en términos, aplica filtros a los términos.

Opción del analizador `delimiters`

'{
  "delimiters": array_of_delimiters
}'

Descripción

Si usas el analizador de texto LOG_ANALYZER y no quieres usar los delimitadores predeterminados, puedes especificar los delimitadores específicos que deseas usar para filtrar. texto de entrada.

Definiciones

delimiters: un arreglo JSON que contiene strings que representan los delimitadores que se usarán para asignar un token al texto de entrada.

Detalles

Cuando hay dos delimitadores con el mismo prefijo, por ejemplo: % y %2, el delimitador más largo tiene mayor prioridad y se analiza primero.

Puedes agregar cualquier string ASCII como delimitador. La longitud de un delimitador debe ser menor o igual que 16 caracteres. Estos son algunos delimitadores comunes que puedes incluir:

[ ] < > ( ) { } | ! ; , ' " * & ? + / : = @ . - $ % \ _ \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

Ejemplo

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]' |
 *-------------------------------------------------------*/

Opción del analizador `patterns`

'{
  "patterns": array_of_regex_patterns
}'

Descripción

Si usas el analizador de texto PATTERN_ANALYZER y no deseas usar la expresión regular predeterminada, puedes especificar la expresión regular que deseas usar para filtrar. el texto de entrada.

Definiciones

patterns: Es un arreglo JSON que contiene una string que representa la expresión regular.

Detalles

Si esta opción de analizador no se proporciona para el analizador de texto PATTERN_ANALYZER, la expresión regular \b\w{2,}\b se usa de forma predeterminada a fin de hacer coincidir palabras que no sean Unicode que tengan al menos dos caracteres.

Ejemplo

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' ] |
 *----------------------------------------------------------------*/

Opción del analizador `token_filters`

'{
  "token_filters": array_of_token_filters
}'

Descripción

Si usas el analizador de texto LOG_ANALYZER o PATTERN_ANALYZER, puedes aplicar uno o más filtros de token al texto de entrada de forma secuencial. después de que se haya asignado un token al texto de entrada.

Definiciones

array_of_token_filters: Un arreglo JSON que contiene objetos que representan filtros de token.

Detalles

Para obtener más información sobre los filtros de token específicos que puedes agregar, consulta Filtros de tokens.

Ejemplo

Por ejemplo, esta consulta contiene las opciones patterns y 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 tokens

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

Los filtros de token pueden modificar o borrar los términos (tokens) que se extraen del texto de entrada. Si no se especifican filtros de token para un analizador de texto que admite filtros de token, se aplicará el filtro de token de normalización de minúsculas ASCII de forma predeterminada. Si se agregan varios filtros de token, se aplicarán en el orden en que se especifiquen. El mismo filtro de token se puede incluir varias veces en el array token_filters. Consulta los ejemplos de esta sección para obtener más detalles.

Definiciones

Cada filtro de token tiene una sintaxis JSON única que contiene algunos de estos pares clave-valor JSON, según el tipo de filtro de token que desees usar:

token_filters: Es el arreglo JSON de objetos que contienen filtros de token. Se puede incluir el mismo tipo de filtro de tokens varias veces en este array.
- stop_words: arreglo JSON de strings que representan las palabras que se quitarán de la lista de términos.
- normalizer: Es un objeto JSON que contiene la configuración de normalización para un filtro de token. La configuración incluye lo siguiente:
  - mode: string JSON que representa el modo de normalización. Tus opciones son las siguientes:
    - NONE: No apliques el modo de normalización a los términos.
    - LOWER: Términos ASCII en minúscula. Si no se especifican filtros de token para un analizador de texto que admite filtros de token, se usará de forma predeterminada.
    - ICU_NORMALIZE: ICU normaliza términos.
  - icu_normalize_mode: string JSON que representa el modo de normalización de ICU. Tus opciones son las siguientes:
    - NFC: Aplica la Normalización de CUDA de ICU a los términos.
    - NFKC: Aplica la normalización de ICU NFKC a los términos.
    - NFD: Aplica la normalización de NCUD de ICU a los términos.
    - NFKD: Aplica la normalización de ICU NFKD a los términos.
    Puedes usar esto si mode es ICU_NORMALIZE. Si mode es ICU_NORMALIZE y este par clave-valor no se configura, icu_normalize_mode es NFKC de forma predeterminada.
  - icu_case_folding: booleano que determina si se debe aplicar el caso de ICU a los términos. true para aplicar la combinación de mayúsculas y minúsculas de ICU a los términos. En caso contrario false.
    
    Puedes usar esto si mode es ICU_NORMALIZE. Si mode es ICU_NORMALIZE y este valor no se usa, icu_case_folding es true de forma predeterminada.

Detalles

Los filtros de token se pueden usar con todos los analizadores, excepto el de texto NO_OP_ANALYZER, en la misma consulta. Los filtros de tokens se aplican después de que el analizador de texto divide el texto de entrada en términos.

Si no se especifica token_filters para un analizador que admite filtros de token, se aplica la normalización de minúsculas ASCII de forma predeterminada.

Puedes agregar varios filtros de token al array de filtros de tokens (token_filters). Si se agregan varios filtros de tokens, se aplicarán a los términos en el orden en que se especifican. Para obtener más información, consulta los ejemplos de esta sección.

Puedes agregar el mismo filtro de tokens varias veces al arreglo de filtros de tokens. Para obtener más información, consulta los ejemplos de esta sección.

Estos son algunos de los filtros que puedes aplicar a los términos mediante la sintaxis JSON del filtro de tokens:

Sin normalización
Convertir a minúsculas (ASCII)
Convertir a minúsculas (plegado de casos ICU)
Preserva mayúscula
ICU normaliza con Bluetooth
ICU normaliza con NFKC
ICU normaliza con NFD
ICU normaliza con NFKD
Eliminar palabras

Ejemplos

En el siguiente ejemplo, los términos son normalizados de NFKC y, luego, porque la combinación de mayúsculas y minúsculas de ICU es true, los términos se convierten en minúsculas. Por último, las palabras en minúscula pies y 2 se quitan de la 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' ] |
 *------------------------------------------*/

La siguiente consulta es similar a la anterior, pero el orden de los filtros de tokens se vuelve a ordenar y esto afecta el resultado de la consulta. En los resultados, se conservan 2 y PIEs porque ② se normaliza en 2 y PIEs se normaliza en pies después del token de palabras de detención. filtro 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' ] |
 *-------------------------------------------------------*/

Puedes usar el mismo filtro de tokens tantas veces como desees en una consulta. En la siguiente consulta, stop_words se usa dos veces:

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' ] |
 *----------------------------------*/

Sin normalización

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

Descripción

La normalización no se aplica a los términos.

Ejemplo

En la siguiente consulta, la normalización no se aplica a los 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' ] |
 *----------------------------------------------------------------*/

Convertir en minúsculas (ASCII)

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

Descripción

Realiza minúsculas ASCII en los términos resultantes.

Ejemplo

En la siguiente consulta, se aplican las minúsculas a ASCII a los 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' ] |
 *----------------------------------------------------------------*/

Convertir a minúsculas (mayúsculas de minúsculas de ICU)

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

Descripción

Realiza el plegado de mayúsculas y minúsculas de la ICU, que convierte los términos resultantes en minúsculas.

Ejemplo

En la siguiente consulta, se aplica la combinación de casos de ICU a los 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' ] |
 *--------------------------------------------------------------*/

Preservación en mayúsculas

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

Descripción

No conviertas los caracteres en mayúscula a caracteres en minúsculas en los términos resultantes.

Ejemplo

En la siguiente consulta, no se aplica el plegado de casos ICU a los 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' ] |
 *---------------------------------------------------------------*/

ICU normaliza con Bluetooth

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

Descripción

Normaliza el texto con la normalización de CUDA de ICU, que descompone y recompone los caracteres por equivalencia canónica.

Ejemplo

En la siguiente consulta, se aplica la normalización de HTML a los 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' ] |
 *---------------------------------------------------------------*/

ICU normaliza con NFKC

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

Descripción

Normaliza texto con Normalización NFKC, que descompone los caracteres por compatibilidad y, luego, los recompone por equivalencia canónica.

Ejemplo

En la siguiente consulta, se aplica la normalización de NFKC a los 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' ] |
 *---------------------------------------------------------------*/

ICU normaliza con NFD

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

Descripción

Normaliza texto con normalización de NFD de ICU, que descompone los caracteres por equivalencia canónica y, luego, organiza varios caracteres de combinación en un orden específico.

Ejemplo

En la siguiente consulta, aunque la entrada y la salida para ñ se ven iguales, los bytes son diferentes (la entrada es \u00f1, la salida es \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' ] |
 *---------------------------------------------------------------*/

ICU normaliza con NFKD

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

Descripción

Normaliza texto con normalización de NFKD de ICU, que descompone los caracteres por compatibilidad y, luego, organiza varios caracteres de combinación en un orden específico.

Ejemplo

En la siguiente consulta, aunque la entrada y la salida para ñ se ven iguales, los bytes son diferentes (la entrada es \u00f1, la salida es \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' ] |
 *---------------------------------------------------------------*/

Eliminar palabras

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

Descripción

Excluye una lista de términos (tokens) de los resultados.

Definiciones

array_of_stop_words: Un arreglo JSON que contiene strings que representan términos. Estos términos no se deben incluir en los resultados. El arreglo debe tener al menos un elemento. Una string vacía es un elemento de array válido.

Ejemplo

En la siguiente consulta, las palabras they y pie se excluyen de los 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álisis de texto

Analizadores de texto

Analyzer NO_OP_ANALYZER

Analyzer LOG_ANALYZER

Analyzer PATTERN_ANALYZER

Opciones del analizador de texto

Opción del analizador delimiters

Opción del analizador patterns

Opción del analizador token_filters

Filtros de tokens

Sin normalización

Convertir en minúsculas (ASCII)

Convertir a minúsculas (mayúsculas de minúsculas de ICU)

Preservación en mayúsculas

ICU normaliza con Bluetooth

ICU normaliza con NFKC

ICU normaliza con NFD

ICU normaliza con NFKD

Eliminar palabras

Analyzer `NO_OP_ANALYZER`

Analyzer `LOG_ANALYZER`

Analyzer `PATTERN_ANALYZER`

Opción del analizador `delimiters`

Opción del analizador `patterns`

Opción del analizador `token_filters`