Analisi del testo

Questo documento fornisce una panoramica dell'analisi del testo, nota anche come text mining, in GoogleSQL per BigQuery.

GoogleSQL supporta l'analisi del testo, una tecnica che puoi utilizzare per identificare i termini (token) nel testo non strutturato e quindi utilizzarli per ottenere informazioni strategiche, come l'indicizzazione e la ricerca, o come input per le vettoriazioni da utilizzare nelle pipeline di addestramento ML. Puoi utilizzare uno strumento di analisi del testo per analizzare le informazioni in un modo specifico e opzioni di analisi del testo per applicare le tue personalizzazioni di analisi.

L'analisi del testo è supportata nelle seguenti funzioni e istruzioni GoogleSQL:

Analizzatori di testo

GoogleSQL per BigQuery supporta diversi tipi di analizzatori di testo, che puoi utilizzare per estrarre dati da testo non strutturato. Puoi passare un analizzatore in alcune funzioni e istruzioni con l'argomento analyzer. Ogni analizzatore di testo ha un modo unico di estrarre le informazioni. Le opzioni disponibili sono:

NO_OP_ANALYZER: estrae l'input come singolo termine (token).
LOG_ANALYZER: suddivide l'input in termini quando vengono rilevati i delimitatori.
PATTERN_ANALYZER: suddivide l'input in termini che corrispondono a un'espressione regolare.

Analizzatore `NO_OP_ANALYZER`

L'analizzatore NO_OP_ANALYZER è un analizzatore senza operazioni che estrae il testo di input come singolo termine (token). Nessuna formattazione viene applicata al termine risultante.

Questo analizzatore non supporta opzioni di analisi del testo o filtri token.

Esempio

La seguente query utilizza NO_OP_ANALYZER come analizzatore di testo:

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

Analizzatore `LOG_ANALYZER`

Lo strumento di analisi LOG_ANALYZER estrae il testo di input come termini (token) quando viene rilevato un delimitatore, ignora i delimitatori e poi modifica le lettere maiuscole in lettere minuscole nei risultati.

Dettagli:

Una lettera maiuscola in un termine viene resa minuscola, ma i valori ASCII superiori a 127 vengono mantenuti invariati.
Il testo viene suddiviso in singoli termini quando viene rilevato uno dei seguenti delimitatori, come uno spazio, un punto o un altro carattere non costituito da una lettera:
```
[ ] < > ( ) { } | ! ; , ' " * & ? + / : = @ . - $ % \ _ \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 non vuoi utilizzare questi delimitatori predefiniti, puoi specificare i delimitatori specifici da utilizzare come opzioni di analisi del testo. Per ulteriori informazioni, vedi l'opzione delimiters.

Questo analizzatore supporta i filtri dei token. Per maggiori informazioni, vedi l'opzione token_filters. Se l'opzione token_filters non è specificata, per impostazione predefinita viene utilizzata la normalizzazione delle lettere minuscole ASCII.

Esempio

La seguente query utilizza LOG_ANALYZER come analizzatore di testo:

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

Poiché LOG_ANALYZER è l'analizzatore di testo predefinito, non è necessario specificarlo nella query. Ad esempio, la seguente query produce gli stessi risultati della query precedente:

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

Analizzatore `PATTERN_ANALYZER`

L'analizzatore PATTERN_ANALYZER estrae termini (token) da testo non strutturato utilizzando un'espressione regolare re2.

Questo analizzatore trova il primo termine sul lato sinistro del testo di input che corrisponde all'espressione regolare e lo aggiunge all'output. Quindi, rimuove il prefisso nel testo di input fino al termine appena trovato. Questo processo viene ripetuto fino a quando il testo di input è vuoto.

Per impostazione predefinita, viene utilizzata l'espressione regolare \b\w{2,}\b. Questa espressione regolare trova parole non Unicode con almeno due caratteri. Se vuoi utilizzare un'altra espressione regolare, consulta l'opzione patterns.

Esempio

La seguente query utilizza PATTERN_ANALYZER come analizzatore di testo. Poiché viene utilizzata l'espressione regolare predefinita, vengono incluse come termini solo le parole con due o più caratteri. Inoltre, i risultati sono in minuscolo. Tieni presente che i e 2 non compaiono nei risultati.

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

Opzioni di analisi del testo

Gli analizzatori di testo supportano opzioni personalizzate che determinano in che modo viene analizzato il testo di input. Puoi passare le opzioni dell'analizzatore in alcune funzioni e istruzioni con l'argomento analyzer_options. Questo argomento assume un valore STRING in formato JSON.

Le opzioni disponibili sono:

delimiters: suddivide l'input in termini quando vengono rilevati questi delimitatori.
patterns: suddivide l'input in termini che corrispondono a un'espressione regolare.
token_filters: dopo che il testo di input è stato tokenizzato in termini, applica i filtri ai termini.

Opzione di analisi `delimiters`

'{
  "delimiters": array_of_delimiters
}'

Description

Se usi lo strumento di analisi del testo LOG_ANALYZER e non vuoi utilizzare i delimitatori predefiniti, puoi specificare quelli specifici da utilizzare per filtrare il testo di input.

Definizioni

delimiters: un array JSON contenente stringhe che rappresentano i delimitatori da utilizzare per tokenizzare il testo di input.

Dettagli

Quando sono presenti due delimitatori con lo stesso prefisso, ad esempio % e %2, il delimitatore più lungo ha la precedenza e viene analizzato per primo.

Puoi aggiungere qualsiasi stringa ASCII come delimitatore. La lunghezza di un delimitatore deve essere inferiore o uguale a 16 caratteri. Alcuni delimitatori comuni che potresti voler includere sono:

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

Esempio

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

Opzione di analisi `patterns`

'{
  "patterns": array_of_regex_patterns
}'

Description

Se utilizzi lo strumento di analisi del testo PATTERN_ANALYZER e non vuoi utilizzare l'espressione regolare predefinita, puoi specificare l'espressione regolare che vuoi utilizzare per filtrare il testo di input.

Definizioni

patterns: un array JSON contenente una stringa che rappresenta l'espressione regolare.

Dettagli

Se questa opzione di analisi non viene fornita per l'analizzatore di testo PATTERN_ANALYZER, per impostazione predefinita viene utilizzata l'espressione regolare \b\w{2,}\b per trovare corrispondenze con parole non Unicode che hanno almeno due caratteri.

Esempio

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

Opzione di analisi `token_filters`

'{
  "token_filters": array_of_token_filters
}'

Description

Se utilizzi lo strumento di analisi di testo LOG_ANALYZER o PATTERN_ANALYZER, puoi applicare in sequenza uno o più filtri token al testo di input dopo che il testo di input è stato tokenizzato.

Definizioni

array_of_token_filters: un array JSON contenente oggetti che rappresentano i filtri token.

Dettagli

Per ulteriori informazioni sui filtri token specifici che puoi aggiungere, consulta Filtri token.

Esempio

Ad esempio, questa query contiene entrambe le opzioni 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' ] |
 *----------------------------------------------*/

Filtri token

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

I filtri dei token possono modificare o eliminare i termini (token) estratti dal testo di input. Se non vengono specificati filtri dei token per un analizzatore di testo che supporta i filtri dei token, per impostazione predefinita viene applicato il filtro del token Normalizzazione delle lettere minuscole ASCII. Se vengono aggiunti più filtri token, questi vengono applicati nell'ordine in cui sono specificati. Lo stesso filtro token può essere incluso più volte nell'array token_filters. Per informazioni dettagliate, consulta gli esempi in questa sezione.

Definizioni

Ogni filtro token ha una sintassi JSON univoca che contiene alcune di queste coppie chiave-valore JSON, a seconda del tipo di filtro dei token che vuoi utilizzare:

token_filters: array JSON di oggetti che contengono filtri dei token. Lo stesso tipo di filtro token può essere incluso più volte in questo array.
- stop_words: array JSON di stringhe che rappresentano le parole da rimuovere dall'elenco dei termini.
- normalizer: oggetto JSON contenente le impostazioni di normalizzazione per un filtro token. Le impostazioni includono:
  - mode: stringa JSON che rappresenta la modalità di normalizzazione. Le opzioni disponibili sono:
    - NONE: non applicare la modalità di normalizzazione ai termini.
    - LOWER: termini ASCII minuscoli. Se non vengono specificati filtri dei token per un analizzatore di testo che supporta i filtri dei token, questo campo viene utilizzato per impostazione predefinita.
    - ICU_NORMALIZE: T.I. normalizza i termini.
  - icu_normalize_mode: stringa JSON che rappresenta la modalità di normalizzazione T.I.. Le opzioni disponibili sono:
    - NFC: applica la normalizzazione NFC ICU ai termini.
    - NFKC: applica la normalizzazione NFKC ICU ai termini.
    - NFD: applica la normalizzazione NFD ICU ai termini.
    - NFKD: applica la normalizzazione NFKD ICU ai termini.
    Puoi utilizzarlo se mode è ICU_NORMALIZE. Se mode è ICU_NORMALIZE e questa coppia chiave-valore non è impostata, icu_normalize_mode è NFKC per impostazione predefinita.
  - icu_case_folding: JSON booleano che determina se applicare il folding del caso di T.I. ai termini. true per applicare la chiusura dei casi di T.I. ai termini. Altrimenti, false.
    
    Puoi utilizzarlo se mode è ICU_NORMALIZE. Se mode è ICU_NORMALIZE e questo valore non viene utilizzato, icu_case_folding è true per impostazione predefinita.

Dettagli

I filtri dei token possono essere utilizzati con tutti gli analizzatori di testo tranne NO_OP_ANALYZER nella stessa query. I filtri dei token vengono applicati dopo che l'analizzatore di testo suddivide il testo inserito in termini.

Se token_filters non è specificato per un analizzatore che supporta i filtri dei token, la normalizzazione delle lettere minuscole ASCII viene applicata per impostazione predefinita.

Puoi aggiungere più filtri token all'array dei filtri token (token_filters). Se vengono aggiunti più filtri token, questi vengono applicati ai termini nell'ordine in cui sono specificati. Per ulteriori informazioni, consulta gli esempi in questa sezione.

Puoi aggiungere più volte lo stesso filtro di token all'array di filtri di token. Per ulteriori informazioni, consulta gli esempi in questa sezione.

Di seguito sono riportati alcuni dei filtri che puoi applicare ai termini utilizzando la sintassi JSON del filtro token:

Nessuna normalizzazione
Converti in lettere minuscole (ASCII)
Convertire in lettere minuscole (pieghevole in caso di T.I.)
Conserva maiuscole
ICU si normalizza con NFC
ICU normalizzazione con NFKC
ICU normalizzazione con NFD
ICU normalizzazione con NFKD
Rimuovere parole

Esempi

Nell'esempio seguente, i termini sono normalizzati in NFKC e, poiché il ripiegamento del caso di T.I. è true, i termini vengono convertiti in minuscolo. Infine, le parole minuscole pies e 2 vengono rimosse dalla query.

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 seguente query è simile alla precedente, ma l'ordine dei filtri dei token viene riordinato e ciò influisce sul risultato della query. Nei risultati, 2 e PIEs vengono conservati perché ② è normalizzato in 2 e PIEs è normalizzato in pies dopo l'applicazione del filtro del token delle stop word:

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

Puoi utilizzare lo stesso filtro token tutte le volte che vuoi in una query. Nella seguente query, stop_words viene utilizzato due volte:

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

Nessuna normalizzazione

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

Description

La normalizzazione non viene applicata ai termini.

Esempio

Nella query seguente, la normalizzazione non viene applicata ai risultati:

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

Converti in lettere minuscole (ASCII)

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

Description

Esegue l'uso delle maiuscole ASCII sui termini risultanti.

Esempio

Nella seguente query, ai risultati vengono applicate le maiuscole ASCII:

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

Converti in lettere minuscole (pieghevole in caso di T.I.)

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

Description

Esegue il folding dei casi in T.I., che converte i termini risultanti in lettere minuscole.

Esempio

Nella query seguente, la piegatura di casi in T.I. viene applicata ai risultati:

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

Mantieni maiuscole

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

Description

Non convertire i caratteri maiuscoli in caratteri minuscoli nei termini risultanti.

Esempio

Nella query seguente, la piegatura del caso in T.I. non viene applicata ai risultati:

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

T.I. normalizzazione con NFC

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

Description

Normalizza il testo con la normalizzazione NFC in ICU, che scompone e ricompone i caratteri in base alle equivalenze canoniche.

Esempio

Nella query seguente, la normalizzazione NFC viene applicata ai risultati:

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

T.I. normalizzazione con NFKC

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

Description

Normalizza il testo con la normalizzazione NFKC ICU, che scompone i caratteri in base alla compatibilità e poi ricompone i caratteri per le equivalenze canoniche.

Esempio

Nella query seguente, la normalizzazione NFKC viene applicata ai risultati:

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

T.I. normalizzazione con NFD

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

Description

Normalizza il testo con la normalizzazione NFD ICU, che scompone i caratteri in base all'equivalenza canonica e organizza più caratteri di combinazione in un ordine specifico.

Esempio

Nella query seguente, sebbene l'input e l'output di ñ abbiano lo stesso aspetto, i byte sono diversi (l'input è \u00f1, l'output è \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' ] |
 *---------------------------------------------------------------*/

T.I. normalizzazione con NFKD

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

Description

Normalizza il testo con la normalizzazione NFKD ICU, che scompone i caratteri in base alla compatibilità e organizza più caratteri di combinazione in un ordine specifico.

Esempio

Nella query seguente, sebbene l'input e l'output di ñ abbiano lo stesso aspetto, i byte sono diversi (l'input è \u00f1, l'output è \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' ] |
 *---------------------------------------------------------------*/

Rimuovere parole

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

Description

Escludi un elenco di termini (token) dai risultati.

Definizioni

array_of_stop_words: un array JSON contenente stringhe che rappresentano i termini. Questi termini non devono essere inclusi nei risultati. L'array deve contenere almeno un elemento. Una stringa vuota è un elemento array valido.

Esempio

Nella seguente query, le parole they e pie sono escluse dai risultati:

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

Analisi del testo

Analizzatori di testo

Analizzatore NO_OP_ANALYZER

Analizzatore LOG_ANALYZER

Analizzatore PATTERN_ANALYZER

Opzioni di analisi del testo

Opzione di analisi delimiters

Opzione di analisi patterns

Opzione di analisi token_filters

Filtri token

Nessuna normalizzazione

Converti in lettere minuscole (ASCII)

Converti in lettere minuscole (pieghevole in caso di T.I.)

Mantieni maiuscole

T.I. normalizzazione con NFC

T.I. normalizzazione con NFKC

T.I. normalizzazione con NFD

T.I. normalizzazione con NFKD

Rimuovere parole

Analizzatore `NO_OP_ANALYZER`

Analizzatore `LOG_ANALYZER`

Analizzatore `PATTERN_ANALYZER`

Opzione di analisi `delimiters`

Opzione di analisi `patterns`

Opzione di analisi `token_filters`