Analyse de texte

Ce document présente l'analyse de texte, également appelée text mining, en GoogleSQL pour BigQuery.

GoogleSQL est compatible avec l'analyse de texte, une technique qui vous permet d'identifier des termes (jetons) dans du texte non structuré, puis de les utiliser pour obtenir des insights exploitables (indexation et recherche, par exemple) ou en tant qu'entrées pour les vectorisations à utiliser dans les pipelines d'entraînement de ML. Vous pouvez utiliser un analyseur de texte pour analyser des informations d'une manière spécifique et des options d'analyse de texte pour appliquer vos propres personnalisations d'analyse.

L'analyse de texte est compatible avec les fonctions et les instructions GoogleSQL suivantes :

Analyseurs de texte

GoogleSQL pour BigQuery est compatible avec plusieurs types d'analyseurs de texte qui vous permettent d'extraire les données de textes non structurés. Vous pouvez transmettre un analyseur à certaines fonctions et instructions avec l'argument analyzer. Chaque analyseur de texte offre un moyen unique d'extraire des informations. Vous disposez des options suivantes :

NO_OP_ANALYZER : extrait l'entrée en tant que terme unique (jeton).
LOG_ANALYZER : divise l'entrée en termes lorsque des délimiteurs sont présents.
PATTERN_ANALYZER : divise l'entrée en termes correspondant à une expression régulière.

Analyseur `NO_OP_ANALYZER`

L'analyseur NO_OP_ANALYZER est un analyseur sans opération, qui extrait le texte d'entrée en tant que terme unique (jeton). Aucune mise en forme n'est appliquée au terme obtenu.

Cet analyseur n'accepte aucune option d'analyse de texte ni filtre de jeton.

Exemple

La requête suivante utilise NO_OP_ANALYZER comme analyseur de texte :

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

Analyseur `LOG_ANALYZER`

L'analyseur LOG_ANALYZER extrait le texte d'entrée en tant que termes (jetons) lorsqu'un délimiteur est présent, supprime les délimiteurs, puis convertit les majuscules en minuscules dans les résultats.

Détails :

Une lettre majuscule dans un terme est mise en minuscules, mais les valeurs ASCII supérieures à 127 sont conservées telles quelles.
Le texte est divisé en termes individuels lorsque l'un des délimiteurs suivants (par exemple, un espace, un point ou un caractère autre qu'une lettre) est présent :
```
[ ] < > ( ) { } | ! ; , ' " * & ? + / : = @ . - $ % \ _ \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 vous ne souhaitez pas utiliser ces délimiteurs par défaut, vous pouvez spécifier les délimiteurs spécifiques que vous souhaitez utiliser comme options d'analyse de texte. Pour en savoir plus, consultez la section Option delimiters.

Cet analyseur accepte les filtres de jetons. Pour en savoir plus, consultez la section Option token_filters. Si l'option token_filters n'est pas spécifiée, la normalisation en minuscules ASCII est utilisée par défaut.

Exemple

La requête suivante utilise LOG_ANALYZER comme analyseur de texte :

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

Comme LOG_ANALYZER est l'analyseur de texte par défaut, vous n'avez pas besoin de le spécifier dans la requête. Par exemple, la requête suivante produit les mêmes résultats que la requête précédente :

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

Analyseur `PATTERN_ANALYZER`

L'analyseur PATTERN_ANALYZER extrait les termes (jetons) de textes non structurés, à l'aide d'une expression régulière re2.

Cet analyseur recherche le premier terme à gauche du texte d'entrée correspondant à l'expression régulière et l'ajoute à la sortie. Ensuite, il supprime le préfixe du texte d'entrée jusqu'au terme qui vient d'être trouvé. Ce processus est répété jusqu'à ce que le texte d'entrée soit vide.

Par défaut, l'expression régulière \b\w{2,}\b est utilisée. Cette expression régulière correspond aux mots non Unicode comportant au moins deux caractères. Si vous souhaitez utiliser une autre expression régulière, consultez la section sur l'option patterns.

Exemple

La requête suivante utilise PATTERN_ANALYZER comme analyseur de texte. Étant donné que l'expression régulière par défaut est utilisée, seuls les mots comportant au moins deux caractères sont inclus en tant que termes. Les résultats sont également en minuscules. Notez que i et 2 n'apparaissent pas dans les résultats.

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

Options des analyseurs de texte

Les analyseurs de texte acceptent des options personnalisées qui déterminent la manière dont le texte d'entrée est analysé. Vous pouvez transmettre des options d'analyse à certaines fonctions et instructions avec l'argument analyzer_options. Cet argument utilise une valeur STRING au format JSON.

Vous disposez des options suivantes :

delimiters : divise l'entrée en termes lorsque ces délimiteurs sont présents.
patterns : divise l'entrée en termes correspondant à une expression régulière.
token_filters : une fois le texte d'entrée segmenté en termes, applique des filtres aux termes.

Option d'analyseur `delimiters`

'{
  "delimiters": array_of_delimiters
}'

Description

Si vous utilisez l'analyseur de texte LOG_ANALYZER et que vous ne souhaitez pas utiliser les délimiteurs par défaut, vous pouvez spécifier les délimiteurs spécifiques que vous souhaitez utiliser pour filtrer le texte d'entrée.

Définitions

delimiters : tableau JSON contenant des chaînes représentant les délimiteurs à utiliser pour segmenter le texte d'entrée.

Détails

Lorsque deux délimiteurs possèdent le même préfixe (par exemple, % et %2), le délimiteur le plus long a une priorité plus élevée et est analysé en premier.

Vous pouvez ajouter n'importe quelle chaîne ASCII en tant que délimiteur. La longueur d'un délimiteur doit être inférieure ou égale à 16 caractères. Voici des délimiteurs courants que vous pouvez inclure :

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

Exemple

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

Option d'analyseur `patterns`

'{
  "patterns": array_of_regex_patterns
}'

Description

Si vous utilisez l'analyseur de texte PATTERN_ANALYZER et que vous ne souhaitez pas utiliser l'expression régulière par défaut, vous pouvez spécifier l'expression régulière que vous souhaitez utiliser pour filtrer le texte d'entrée.

Définitions

patterns : tableau JSON contenant une chaîne représentant l'expression régulière.

Détails

Si cette option d'analyse n'est pas fournie pour l'analyseur de texte PATTERN_ANALYZER, l'expression régulière \b\w{2,}\b est utilisée par défaut pour mettre en correspondance les mots non Unicode comportant au moins deux caractères.

Exemple

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

Option d'analyseur `token_filters`

'{
  "token_filters": array_of_token_filters
}'

Description

Si vous utilisez l'analyseur de texte LOG_ANALYZER ou PATTERN_ANALYZER, vous pouvez appliquer un ou plusieurs filtres de jetons de manière séquentielle au texte d'entrée une fois ce dernier segmenté.

Définitions

array_of_token_filters : tableau JSON contenant des objets représentant des filtres de jetons.

Détails

Pour en savoir plus sur les filtres de jetons spécifiques que vous pouvez ajouter, consultez la section Filtres de jetons.

Exemple

Par exemple, cette requête contient à la fois les options patterns et 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' ] |
 *----------------------------------------------*/

Filtres de jetons

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

Les filtres de jetons peuvent modifier ou supprimer des termes (jetons) extraits du texte d'entrée. Si aucun filtre de jeton n'est spécifié pour un analyseur de texte compatible avec les filtres de jetons, le filtre de jeton de normalisation en minuscules ASCII est appliqué par défaut. Si plusieurs filtres de jetons sont ajoutés, ils sont appliqués dans l'ordre dans lequel ils sont spécifiés. Le même filtre de jeton peut être inclus plusieurs fois dans le tableau token_filters. Pour en savoir plus, consultez les exemples de cette section.

Définitions

Chaque filtre de jeton possède une syntaxe JSON unique contenant certaines de ces paires clé/valeur JSON, en fonction du type de filtre de jeton que vous souhaitez utiliser :

token_filters : tableau JSON d'objets contenant des filtres de jetons. Le même type de filtre de jeton peut être inclus plusieurs fois dans ce tableau.
- stop_words : tableau JSON de chaînes représentant les mots à supprimer de la liste des termes.
- normalizer : objet JSON contenant les paramètres de normalisation pour un filtre de jeton. Fonctionnalités concernées :
  - mode : chaîne JSON représentant le mode de normalisation. Vous disposez des options suivantes :
    - NONE : n'applique pas le mode de normalisation aux termes.
    - LOWER : termes en minuscules ASCII. Si aucun filtre de jeton n'est spécifié pour un analyseur de texte compatible avec les filtres de jetons, il est utilisé par défaut.
    - ICU_NORMALIZE : termes de normalisation ICU.
  - icu_normalize_mode : chaîne JSON représentant le mode de normalisation ICU. Vous disposez des options suivantes :
    - NFC : appliquez la normalisation NFC ICU aux termes.
    - NFKC : appliquez la normalisation NFKC ICU aux termes.
    - NFD : appliquez la normalisation NFD ICU aux termes.
    - NFKD : appliquez la normalisation NFKD ICU aux termes.
    Vous pouvez l'utiliser si le mode est défini sur ICU_NORMALIZE. Si le mode est défini sur ICU_NORMALIZE et que cette paire clé/valeur n'est pas définie, icu_normalize_mode est défini sur NFKC par défaut.
  - icu_case_folding : valeur booléenne JSON qui détermine si la normalisation ICU doit être appliquée aux termes. true pour appliquer la normalisation ICU aux termes. Sinon, il est défini sur false.
    
    Vous pouvez l'utiliser si le mode est défini sur ICU_NORMALIZE. Si le mode est défini sur ICU_NORMALIZE et que cette valeur n'est pas utilisée, icu_case_folding est défini sur true par défaut.

Détails

Les filtres de jetons peuvent être utilisés avec tous les analyseurs de texte, sauf NO_OP_ANALYZER, dans la même requête. Les filtres de jetons sont appliqués une fois que l'analyseur de texte a divisé le texte d'entrée en termes.

Si token_filters n'est pas spécifié pour un analyseur compatible avec les filtres de jetons, la normalisation en minuscules ASCII est appliquée par défaut.

Vous pouvez ajouter plusieurs filtres de jetons au tableau de filtres de jetons (token_filters). Si plusieurs filtres de jetons sont ajoutés, ils sont appliqués aux termes dans l'ordre dans lequel ils sont spécifiés. Pour en savoir plus, consultez les exemples de cette section.

Vous pouvez ajouter le même filtre de jeton plusieurs fois au tableau de filtres de jetons. Pour en savoir plus, consultez les exemples de cette section.

Voici quelques-uns des filtres que vous pouvez appliquer aux termes, à l'aide de la syntaxe JSON des filtres de jetons :

Aucune normalisation
Convertir en minuscules (ASCII)
Convertir en minuscules (normalisation ICU)
Conserver les majuscules
Normalisation ICU avec NFC
Normalisation ICU avec NFKC
Normalisation ICU avec NFD
Normalisation ICU avec NFKD
Exclure des mots

Exemples

Dans l'exemple suivant, les termes sont normalisés avec NFKC. Comme la normalisation ICU est définie sur true, les termes sont convertis en minuscules. Enfin, les mots en minuscules pies et 2 sont supprimés de la requête.

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 requête suivante est semblable à la précédente, mais l'ordre des filtres de jetons est réorganisé, ce qui affecte le résultat de la requête. Dans les résultats, 2 et PIEs sont conservés, car ② est normalisé en 2 et PIEs est normalisé en pies après que le filtre de jeton de mot vide soit appliqué :

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

Vous pouvez utiliser le même filtre de jeton autant de fois que vous le souhaitez dans une requête. Dans la requête suivante, stop_words est utilisé deux fois :

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

Aucune normalisation

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

Description

La normalisation n'est pas appliquée aux termes.

Exemple

Dans la requête suivante, la normalisation n'est pas appliquée aux résultats :

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 minuscules (ASCII)

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

Description

Met les caractères ASCII en minuscules dans les termes obtenus.

Exemple

Dans la requête suivante, la mise en minuscules des caractères ASCII est appliquée aux résultats :

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 en minuscules (normalisation ICU)

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

Description

Effectue une normalisation ICU, qui convertit les termes obtenus en minuscules.

Exemple

Dans la requête suivante, la normalisation ICU est appliquée aux résultats :

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

Conserver les majuscules

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

Description

Ne convertit pas les majuscules en minuscules dans les termes obtenus.

Exemple

Dans la requête suivante, la normalisation ICU n'est pas appliquée aux résultats :

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

Normalisation ICU avec NFC

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

Description

Normalise le texte à l'aide de la normalisation NFC ICU, qui décompose et recompose les caractères par équivalence canonique.

Exemple

Dans la requête suivante, la normalisation NFC est appliquée aux résultats :

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

Normalisation ICU avec NFKC

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

Description

Normalise le texte à l'aide de la normalisation NFKC ICU, qui décompose les caractères par compatibilité, puis les recompose par équivalence canonique.

Exemple

Dans la requête suivante, la normalisation NFKC est appliquée aux résultats :

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

Normalisation ICU avec NFD

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

Description

Normalise le texte à l'aide de la normalisation NFD ICU, qui décompose les caractères par équivalence canonique, puis organise plusieurs caractères combinés dans un ordre spécifique.

Exemple

Dans la requête suivante, bien que les entrées et les sorties de ñ soient identiques, les octets sont différents (l'entrée est \u00f1, la sortie est \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' ] |
 *---------------------------------------------------------------*/

Normalisation ICU avec NFKD

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

Description

Normalise le texte à l'aide de la normalisation NFKD ICU, qui décompose les caractères par compatibilité, puis organise plusieurs caractères combinés dans un ordre spécifique.

Exemple

Dans la requête suivante, bien que les entrées et les sorties de ñ soient identiques, les octets sont différents (l'entrée est \u00f1, la sortie est \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' ] |
 *---------------------------------------------------------------*/

Exclure des mots

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

Description

Exclut une liste de termes (jetons) des résultats.

Définitions

array_of_stop_words : tableau JSON contenant des chaînes représentant des termes. Ces termes ne doivent pas être inclus dans les résultats. Le tableau doit comporter au moins un élément. Une chaîne vide est un élément de tableau valide.

Exemple

Dans la requête suivante, les mots they et pie sont exclus des résultats :

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

Analyse de texte

Analyseurs de texte

Analyseur NO_OP_ANALYZER

Analyseur LOG_ANALYZER

Analyseur PATTERN_ANALYZER

Options des analyseurs de texte

Option d'analyseur delimiters

Option d'analyseur patterns

Option d'analyseur token_filters

Filtres de jetons

Aucune normalisation

Convertir en minuscules (ASCII)

Convertir en minuscules (normalisation ICU)

Conserver les majuscules

Normalisation ICU avec NFC

Normalisation ICU avec NFKC

Normalisation ICU avec NFD

Normalisation ICU avec NFKD

Exclure des mots

Analyseur `NO_OP_ANALYZER`

Analyseur `LOG_ANALYZER`

Analyseur `PATTERN_ANALYZER`

Option d'analyseur `delimiters`

Option d'analyseur `patterns`

Option d'analyseur `token_filters`