Textanalyse

Dieses Dokument bietet einen Überblick über die Textanalyse, auch als Text-Mining bezeichnet, in Google SQL for BigQuery.

Google SQL unterstützt Textanalysen. Damit können Sie Begriffe (Tokens) in unstrukturiertem Text identifizieren und diese Begriffe dann für umsetzbare Informationen wie Indexierung und Suche oder für Eingaben für Vektorisierungen nutzen können, die in ML-Trainingspipelines verwendet werden sollen. Sie können einen Textanalysator verwenden, um Informationen auf eine bestimmte Weise zu analysieren, und Textanalyseoptionen, um Ihre eigenen Analyseanpassungen anzuwenden.

Die Textanalyse wird in den folgenden GoogleSQL-Funktionen und -Anweisungen unterstützt:

Textanalysatoren

Google SQL for BigQuery unterstützt verschiedene Arten von Textanalysatoren, mit denen Sie Daten aus unstrukturiertem Text extrahieren können. Mit dem Argument analyzer können Sie einen Analyseer an einige Funktionen und Anweisungen übergeben. Jeder Textanalysator hat eine einzigartige Möglichkeit, Informationen zu extrahieren. Sie haben folgende Optionen:

NO_OP_ANALYZER: Extrahiert die Eingabe als einzelnen Begriff (Token).
LOG_ANALYZER: Zerlegt die Eingabe in Begriffe, wenn Trennzeichen auftreten.
PATTERN_ANALYZER: Zerlegt die Eingabe in Begriffe, die mit einem regulären Ausdruck übereinstimmen.

`NO_OP_ANALYZER`-Analysator

Der NO_OP_ANALYZER-Analysator ist ein operatives Analysetool, der den Eingabetext als einzelnen Begriff (Token) extrahiert. Es wird keine Formatierung auf den resultierenden Begriff angewendet.

Dieses Analysetool unterstützt keine Textanalysatoroptionen oder Tokenfilter.

Beispiel

Die folgende Abfrage verwendet NO_OP_ANALYZER als Textanalysator:

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`-Analysator

Der LOG_ANALYZER-Analysator extrahiert den Eingabetext als Begriffe (Tokens), wenn ein Trennzeichen gefunden wird, verwirft die Trennzeichen und ändert dann alle Großbuchstaben in die Ergebnisse in Kleinbuchstaben.

Details:

Ein Großbuchstabe in einem Begriff wird in Kleinbuchstaben geschrieben, ASCII-Werte größer als 127 werden jedoch beibehalten.
Text wird in einzelne Begriffe unterteilt, wenn eines der folgenden Trennzeichen, z. B. ein Leerzeichen, ein Punkt oder ein anderes Zeichen, nicht enthalten ist:
```
[ ] < > ( ) { } | ! ; , ' " * & ? + / : = @ . - $ % \ _ \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
```
Wenn Sie diese Standardtrennzeichen nicht verwenden möchten, können Sie die spezifischen Trennzeichen angeben, die Sie als Textanalysatoroptionen verwenden möchten. Weitere Informationen finden Sie unter Option delimiters.

Dieser Analysetool unterstützt Tokenfilter. Weitere Informationen finden Sie unter Option token_filters. Wenn die Option token_filters nicht angegeben ist, wird standardmäßig die ASCII-Kleinisierungsnormalisierung verwendet.

Beispiel

Die folgende Abfrage verwendet LOG_ANALYZER als Textanalysator:

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

Da LOG_ANALYZER der Standardtextanalysator ist, müssen Sie ihn nicht in der Abfrage angeben. Die folgende Abfrage führt beispielsweise zu denselben Ergebnissen wie die vorherige Abfrage:

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

`PATTERN_ANALYZER`-Analysator

Der PATTERN_ANALYZER-Analysator extrahiert Begriffe (Tokens) mithilfe eines regulären Ausdrucks re2 aus unstrukturiertem Text.

Dieser Analysetool ermittelt den ersten Begriff auf der linken Seite des Eingabetexts, der mit dem regulären Ausdruck übereinstimmt, und fügt diesen Begriff der Ausgabe hinzu. Anschließend wird das Präfix im Eingabetext bis zum neu gefundenen Begriff entfernt. Dieser Vorgang wird wiederholt, bis der Eingabetext leer ist.

Standardmäßig wird der reguläre Ausdruck \b\w{2,}\b verwendet. Dieser reguläre Ausdruck entspricht Nicht-Unicode-Wörtern mit mindestens zwei Zeichen. Wenn Sie einen anderen regulären Ausdruck verwenden möchten, finden Sie weitere Informationen unter Option patterns.

Beispiel

Die folgende Abfrage verwendet PATTERN_ANALYZER als Textanalysator. Da der standardmäßige reguläre Ausdruck verwendet wird, werden nur Wörter mit zwei oder mehr Zeichen als Begriffe berücksichtigt. Außerdem werden die Ergebnisse in Kleinbuchstaben geschrieben. Beachten Sie, dass i und 2 nicht in den Ergebnissen angezeigt werden.

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

Optionen des Textanalysators

Textanalysatoren unterstützen benutzerdefinierte Optionen, die bestimmen, wie Eingabetext analysiert wird. Mit dem Argument analyzer_options können Sie Analyseoptionen an einige Funktionen und Anweisungen übergeben. Dieses Argument verwendet einen STRING-Wert im JSON-Format.

Sie haben folgende Optionen:

delimiters: Zerlegt die Eingabe in Begriffe, wenn diese Trennzeichen gefunden werden.
patterns: Zerlegt die Eingabe in Begriffe, die mit einem regulären Ausdruck übereinstimmen.
token_filters: Nachdem der Eingabetext in Begriffe umgewandelt wurde, wenden Sie Filter auf die Begriffe an.

`delimiters`-Analysetool

'{
  "delimiters": array_of_delimiters
}'

Beschreibung

Wenn Sie das LOG_ANALYZER-Textanalysator-Tool verwenden und nicht die Standardtrennzeichen verwenden möchten, können Sie die spezifischen Trennzeichen angeben, die Sie zum Filtern verwenden möchten: Eingabetext.

Definitionen

delimiters: Ein JSON-Array mit Strings, die die Trennzeichen darstellen, die zum Tokenisieren des Eingabetexts verwendet werden sollen.

Details

Wenn zwei Trennzeichen mit demselben Präfix vorhanden sind, z. B. % und %2, hat das längere Trennzeichen eine höhere Priorität und wird zuerst analysiert.

Sie können einen beliebigen ASCII-String als Trennzeichen hinzufügen. Die Länge eines Trennzeichens darf maximal 16 Zeichen betragen. Hier einige gängige Trennzeichen, die Sie angeben können:

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

Beispiel

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

`patterns`-Analysetool

'{
  "patterns": array_of_regex_patterns
}'

Beschreibung

Wenn Sie den PATTERN_ANALYZER-Textanalysator verwenden und nicht den standardmäßigen regulären Ausdruck verwenden möchten, können Sie den regulären Ausdruck angeben, um den Eingabetext zu filtern.

Definitionen

patterns: Ein JSON-Array, das einen String enthält, der den regulären Ausdruck darstellt.

Details

Wenn diese Analysetools für den PATTERN_ANALYZER-Textanalysator nicht angegeben werden, wird standardmäßig der reguläre Ausdruck \b\w{2,}\b verwendet, um Nicht-Unicode-Wörter mit mindestens zwei Zeichen abzugleichen.

Beispiel

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

`token_filters`-Analysetool

'{
  "token_filters": array_of_token_filters
}'

Beschreibung

Wenn Sie den Textanalysator LOG_ANALYZER oder PATTERN_ANALYZER verwenden, können Sie einen oder mehrere Tokenfilter nacheinander auf den Eingabetext anwenden, nachdem der Eingabetext tokenisiert wurde.

Definitionen

array_of_token_filters: Ein JSON-Array mit Objekten, die Tokenfilter darstellen.

Details

Weitere Informationen zu den spezifischen Tokenfiltern, die Sie hinzufügen können, finden Sie unter Tokenfilter.

Beispiel

Diese Abfrage enthält beispielsweise die Optionen patterns und 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' ] |
 *----------------------------------------------*/

Tokenfilter

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

Tokenfilter können Begriffe (Tokens) ändern oder löschen, die aus Eingabetext extrahiert werden. Wenn für einen Textanalysator, der Tokenfilter unterstützt, keine Tokenfilter angegeben sind, wird standardmäßig der Tokenfilter ASCII-Kleinisierungsnormalisierung angewendet. Wenn mehrere Tokenfilter hinzugefügt werden, werden sie in der Reihenfolge angewendet, in der sie angegeben sind. Derselbe Tokenfilter kann mehrmals in das Array token_filters aufgenommen werden. Weitere Informationen finden Sie in den Beispielen in diesem Abschnitt.

Definitionen

Jeder Tokenfilter hat eine eindeutige JSON-Syntax, die einige dieser JSON-Schlüssel/Wert-Paare enthält, je nach Art des zu verwendenden Tokenfilters.

token_filters: JSON-Array von Objekten, die Tokenfilter enthalten. Derselbe Tokenfiltertyp kann mehrmals in dieses Array aufgenommen werden.
- stop_words: JSON-Array von Strings, die die zu entfernenden Wörter aus der Liste der Begriffe darstellen.
- normalizer: JSON-Objekt, das die Normalisierungseinstellungen für einen Tokenfilter enthält. Zu den Einstellungen gehören:
  - mode: JSON-String, der den Normalisierungsmodus darstellt. Sie haben folgende Optionen:
    - NONE: Wenden Sie den Normalisierungsmodus nicht auf die Begriffe an.
    - LOWER: Kleinbuchstaben-ASCII-Begriffe. Wenn für einen Textanalysator, der Tokenfilter unterstützt, keine Tokenfilter angegeben sind, wird dies standardmäßig verwendet.
    - ICU_NORMALIZE: ICU-Normalisierungen.
  - icu_normalize_mode: JSON-String, der den ICU-Normalisierungsmodus darstellt. Sie haben folgende Optionen:
    - NFC: Wenden Sie die ICU NFC-Normalisierung auf die Begriffe an.
    - NFKC: Wenden Sie die ICU NFKC-Normalisierung auf die Begriffe an.
    - NFD: Wenden Sie die ICU NFD-Normalisierung auf die Begriffe an.
    - NFKD: Wenden Sie die ICU NFKD-Normalisierung auf die Begriffe an.
    Sie können diesen verwenden, wenn mode ICU_NORMALIZE ist. Wenn mode den Wert ICU_NORMALIZE hat und dieses Schlüssel/Wert-Paar nicht festgelegt ist, ist icu_normalize_mode standardmäßig NFKC.
  - icu_case_folding: Boolescher JSON-Wert, der bestimmt, ob die ICU-Umwandlung in einheitliche Groß- oder Kleinschreibung auf Begriffe angewendet wird.f true, um die ICU-Fälschung auf die Begriffe anzuwenden. Andernfalls false.
    
    Sie können diesen verwenden, wenn mode ICU_NORMALIZE ist. Wenn mode den Wert ICU_NORMALIZE hat und dieser Wert nicht verwendet wird, ist icu_case_folding standardmäßig true.

Details

Tokenfilter können mit allen außer dem Textanalysator NO_OP_ANALYZER in derselben Abfrage verwendet werden. Tokenfilter werden angewendet, nachdem der Textanalysator Eingabetext in Begriffe unterteilt hat.

Wenn token_filters für ein Analysetool, das Tokenfilter unterstützt, nicht angegeben ist, wird standardmäßig die ASCII-Normalisierung in Kleinbuchstaben angewendet.

Sie können dem Tokenfilter-Array (token_filters) mehrere Tokenfilter hinzufügen. Wenn mehrere Tokenfilter hinzugefügt werden, werden sie auf die Begriffe in der Reihenfolge angewendet, in der sie angegeben sind. Weitere Informationen finden Sie in den Beispielen in diesem Abschnitt.

Sie können denselben Tokenfilter mehrmals zum Array für Tokenfilter hinzufügen. Weitere Informationen finden Sie in den Beispielen in diesem Abschnitt.

Im Folgenden finden Sie einige Filter, die Sie mithilfe der JSON-Syntax des Tokenfilters auf Begriffe anwenden können:

Keine Normalisierung
Umwandlung in Kleinbuchstaben (ASCII)
Umwandlung in Kleinbuchstaben (ICU Umwandlung in einheitliche Groß- oder Kleinschreibung)
Beibehalten von Großbuchstaben
ICU mit NFC normalisieren
ICU mit NFKC normalisieren
ICU mit NFD normalisieren
ICU mit NFKD normalisieren
Wörter entfernen

Beispiele

Im folgenden Beispiel werden die Begriffe NFKC normalisiert. Da die ICU-Faltung true lautet, werden die Begriffe in Kleinbuchstaben umgewandelt. Schließlich werden die Kleinbuchstaben pies und 2 aus der Abfrage entfernt.

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

Die folgende Abfrage ähnelt der vorherigen, aber die Reihenfolge der Tokenfilter wird neu angeordnet. Dies wirkt sich auf das Ergebnis der Abfrage aus. In den Ergebnissen wird 2 und PIEs beibehalten, da ② zu 2 normalisiert und PIEs zu pies nach Anwendung des Stoppwort-Tokenfilters:

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

Sie können denselben Tokenfilter in einer Abfrage beliebig oft verwenden. In der folgenden Abfrage wird stop_words zweimal verwendet:

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

Keine Normalisierung

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

Beschreibung

Normalisierung wird nicht auf Begriffe angewendet.

Beispiel

In der folgenden Abfrage wird die Normalisierung nicht auf die Ergebnisse angewendet:

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

Umwandlung in Kleinbuchstaben (ASCII)

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

Beschreibung

Führt ASCII-Kleinbuchstaben in den resultierenden Begriffen durch.

Beispiel

In der folgenden Abfrage wird ASCII-Kleinbuchstaben auf die Ergebnisse angewendet:

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

Umwandlung in Kleinbuchstaben (ICU Umwandlung in einheitliche Groß- oder Kleinschreibung)

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

Beschreibung

Führt eine ICU-Faltung durch, bei der die resultierenden Begriffe in Kleinbuchstaben umgewandelt werden.

Beispiel

In der folgenden Abfrage wird die ICU-Faltung auf die Ergebnisse angewendet:

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

Beibehalten von Großbuchstaben

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

Beschreibung

Wandeln Sie in den resultierenden Begriffen keine Großbuchstaben in Kleinbuchstaben um.

Beispiel

In der folgenden Abfrage wird die ICU-Faltung nicht auf die Ergebnisse angewendet:

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 mit NFC normalisieren

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

Beschreibung

Normalisiert Text mit der ICU-NFC-Normalisierung, wodurch Zeichen nach kanonischer Äquivalenz zerlegt und wieder zusammengesetzt werden.

Beispiel

In der folgenden Abfrage wird die NFC-Normalisierung auf die Ergebnisse angewendet:

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 mit NFKC normalisieren

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

Beschreibung

Normalisiert Text mit der ICU NFKC-Normalisierung, wodurch Zeichen nach Kompatibilität zerlegt werden und dann die Zeichen nach kanonischer Äquivalenz wieder zusammengesetzt werden.

Beispiel

In der folgenden Abfrage wird die NFKC-Normalisierung auf die Ergebnisse angewendet:

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 mit NFD normalisieren

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

Beschreibung

Normalisiert Text mit der ICU NFD-Normalisierung, bei der Zeichen nach kanonischer Äquivalenz zerlegt und dann mehrere Kombinationszeichen in einer bestimmten Reihenfolge angeordnet werden.

Beispiel

In der folgenden Abfrage unterscheiden sich die Eingaben und Ausgaben für ñ zwar, die Byte unterscheiden sich jedoch (Eingabe ist \u00f1, Ausgabe ist \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 mit NFKD normalisieren

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

Beschreibung

Normalisiert Text mit der ICU NFKD-Normalisierung, wodurch Zeichen nach Kompatibilität zerlegt werden und dann mehrere Kombinationszeichen in einer bestimmten Reihenfolge angeordnet werden.

Beispiel

In der folgenden Abfrage unterscheiden sich die Eingaben und Ausgaben für ñ zwar, die Byte unterscheiden sich jedoch (Eingabe ist \u00f1, Ausgabe ist \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' ] |
 *---------------------------------------------------------------*/

Wörter entfernen

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

Beschreibung

Schließen Sie eine Liste der Begriffe (Tokens) aus den Ergebnissen aus.

Definitionen

array_of_stop_words: Ein JSON-Array mit Strings, die Begriffe darstellen. Diese Begriffe sollten nicht in den Ergebnissen enthalten sein. Das Array muss mindestens ein Element enthalten. Ein leerer String ist ein gültiges Array-Element.

Beispiel

In der folgenden Abfrage werden die Wörter they und pie aus den Ergebnissen ausgeschlossen:

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

Textanalyse

Textanalysatoren

NO_OP_ANALYZER-Analysator

LOG_ANALYZER-Analysator

PATTERN_ANALYZER-Analysator

Optionen des Textanalysators

delimiters-Analysetool

patterns-Analysetool

token_filters-Analysetool

Tokenfilter

Keine Normalisierung

Umwandlung in Kleinbuchstaben (ASCII)

Umwandlung in Kleinbuchstaben (ICU Umwandlung in einheitliche Groß- oder Kleinschreibung)

Beibehalten von Großbuchstaben

ICU mit NFC normalisieren

ICU mit NFKC normalisieren

ICU mit NFD normalisieren

ICU mit NFKD normalisieren

Wörter entfernen

`NO_OP_ANALYZER`-Analysator

`LOG_ANALYZER`-Analysator

`PATTERN_ANALYZER`-Analysator

`delimiters`-Analysetool

`patterns`-Analysetool

`token_filters`-Analysetool