Analisis teks

Dokumen ini memberikan ringkasan tentang analisis teks, yang juga dikenal sebagai penambangan teks, di GoogleSQL untuk BigQuery.

GoogleSQL mendukung analisis teks, yang merupakan teknik yang dapat Anda gunakan untuk mengidentifikasi istilah (token) dalam teks tidak terstruktur, lalu menggunakan istilah tersebut untuk hasil analisis yang bisa ditindaklanjuti, seperti pengindeksan dan penelusuran, atau sebagai input vektorisasi yang akan digunakan dalam pipeline pelatihan ML. Anda dapat menggunakan penganalisis teks untuk menganalisis informasi dengan cara tertentu dan opsi analisis teks untuk menerapkan penyesuaian analisis Anda sendiri.

Analisis teks didukung dalam fungsi dan pernyataan GoogleSQL berikut:

Penganalisis teks

GoogleSQL untuk BigQuery mendukung beberapa jenis penganalisis teks yang dapat Anda gunakan untuk mengekstrak data dari teks yang tidak terstruktur. Anda dapat meneruskan analyzer ke beberapa fungsi dan pernyataan dengan argumen analyzer. Setiap penganalisis teks memiliki cara unik untuk mengekstrak informasi. Pilihan untuk Anda adalah:

NO_OP_ANALYZER: Mengekstrak input sebagai satu istilah (token).
LOG_ANALYZER: Memecah input menjadi istilah saat pembatas ditemukan.
PATTERN_ANALYZER: Memecah input menjadi istilah yang cocok dengan ekspresi reguler.

Penganalisis `NO_OP_ANALYZER`

NO_OP_ANALYZER Analyzer adalah penganalisis tanpa operasi, yang mengekstrak teks input sebagai satu istilah (token). Tidak ada pemformatan yang diterapkan ke istilah yang dihasilkan.

Penganalisis ini tidak mendukung opsi analyzer teks atau filter token.

Contoh

Kueri berikut menggunakan NO_OP_ANALYZER sebagai penganalisis teks:

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

Penganalisis `LOG_ANALYZER`

Penganalisis LOG_ANALYZER mengekstrak teks input sebagai istilah (token) saat pembatas ditemukan, menghapus pembatas, lalu mengubah huruf besar menjadi huruf kecil dalam hasil.

Detail:

Huruf besar dalam suatu istilah dibuat menjadi huruf kecil, tetapi nilai ASCII yang lebih besar dari 127 akan dipertahankan apa adanya.
Teks dibagi menjadi masing-masing istilah jika menemukan salah satu pemisah berikut, seperti spasi, titik, atau karakter non-huruf lainnya:
```
[ ] < > ( ) { } | ! ; , ' " * & ? + / : = @ . - $ % \ _ \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
```
Jika tidak ingin menggunakan pemisah default ini, Anda dapat menentukan pembatas tertentu yang ingin digunakan sebagai opsi analyzer teks. Untuk mengetahui informasi selengkapnya, lihat opsi delimiters.

Penganalisis ini mendukung filter token. Untuk mengetahui informasi selengkapnya, lihat opsi token_filters. Jika opsi token_filters tidak ditentukan, normalisasi huruf kecil ASCII akan digunakan secara default.

Contoh

Kueri berikut menggunakan LOG_ANALYZER sebagai penganalisis teks:

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

Karena LOG_ANALYZER adalah penganalisis teks default, Anda tidak perlu menentukannya dalam kueri. Misalnya, kueri berikut memberikan hasil yang sama dengan kueri sebelumnya:

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

Penganalisis `PATTERN_ANALYZER`

Penganalisis PATTERN_ANALYZER mengekstrak istilah (token) dari teks tidak terstruktur, menggunakan ekspresi reguler re2.

Penganalisis ini menemukan istilah pertama dari sisi kiri teks input yang cocok dengan ekspresi reguler dan menambahkan istilah ini ke output. Kemudian, perintah ini akan menghapus awalan dalam teks input hingga istilah yang baru ditemukan. Proses ini diulang sampai teks input kosong.

Secara default, ekspresi reguler \b\w{2,}\b digunakan. Ekspresi reguler ini cocok dengan kata non-Unicode yang memiliki setidaknya dua karakter. Jika Anda ingin menggunakan ekspresi reguler lainnya, lihat opsi patterns.

Contoh

Kueri berikut menggunakan PATTERN_ANALYZER sebagai penganalisis teks. Karena ekspresi reguler default digunakan, hanya kata yang memiliki dua karakter atau lebih yang disertakan sebagai istilah. Selain itu, hasilnya menggunakan huruf kecil. Perhatikan bahwa i dan 2 tidak muncul dalam hasil.

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

Opsi penganalisis teks

Penganalisis teks mendukung opsi kustom yang menentukan cara teks input dianalisis. Anda dapat meneruskan opsi analyzer ke beberapa fungsi dan pernyataan dengan argumen analyzer_options. Argumen ini mengambil nilai STRING berformat JSON.

Pilihan untuk Anda adalah:

delimiters: Memecah input menjadi istilah saat pembatas ini ditemukan.
patterns: Memecah input menjadi istilah yang cocok dengan ekspresi reguler.
token_filters: Setelah teks input ditokenkan menjadi istilah, terapkan filter pada istilah.

Opsi analyzer `delimiters`

'{
  "delimiters": array_of_delimiters
}'

Deskripsi

Jika menggunakan penganalisis teks LOG_ANALYZER dan tidak ingin menggunakan pemisah default, Anda dapat menentukan pemisah tertentu yang ingin digunakan untuk memfilter teks input.

Definisi

delimiters: Array JSON yang berisi string yang mewakili pemisah yang akan digunakan untuk membuat token teks input.

Detail

Jika ada dua pembatas dengan awalan yang sama, misalnya: % dan %2, pembatas yang lebih panjang memiliki prioritas lebih tinggi dan dianalisis terlebih dahulu.

Anda dapat menambahkan string ASCII sebagai pembatas. Panjang pembatas harus kurang dari atau sama dengan 16 karakter. Beberapa {i>delimiter<i} umum yang mungkin ingin Anda sertakan adalah:

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

Contoh

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

Opsi analyzer `patterns`

'{
  "patterns": array_of_regex_patterns
}'

Deskripsi

Jika menggunakan penganalisis teks PATTERN_ANALYZER dan tidak ingin menggunakan ekspresi reguler default, Anda dapat menentukan ekspresi reguler yang ingin digunakan untuk memfilter teks input.

Definisi

patterns: Array JSON yang berisi satu string yang mewakili ekspresi reguler.

Detail

Jika opsi penganalisis ini tidak disediakan untuk penganalisis teks PATTERN_ANALYZER, ekspresi reguler \b\w{2,}\b akan digunakan secara default untuk mencocokkan kata non-Unicode yang memiliki setidaknya dua karakter.

Contoh

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

Opsi analyzer `token_filters`

'{
  "token_filters": array_of_token_filters
}'

Deskripsi

Jika menggunakan penganalisis teks LOG_ANALYZER atau PATTERN_ANALYZER, Anda dapat secara berurutan menerapkan satu atau beberapa filter token ke teks input setelah teks input ditokenkan.

Definisi

array_of_token_filters: Array JSON yang berisi objek yang mewakili filter token.

Detail

Untuk mengetahui informasi selengkapnya tentang filter token tertentu yang dapat Anda tambahkan, lihat Filter token.

Contoh

Misalnya, kueri ini berisi opsi patterns dan 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' ] |
 *----------------------------------------------*/

Filter token

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

Filter token dapat mengubah atau menghapus istilah (token) yang diekstrak dari teks input. Jika tidak ada filter token yang ditentukan untuk analyzer teks yang mendukung filter token, filter token ASCII huruf kecil normalization akan diterapkan secara default. Jika beberapa filter token ditambahkan, filter tersebut akan diterapkan sesuai urutan yang ditetapkan. Filter token yang sama dapat disertakan beberapa kali dalam array token_filters. Lihat contoh di bagian ini untuk detailnya.

Definisi

Setiap filter token memiliki sintaksis JSON unik yang berisi beberapa key-value pair JSON ini, bergantung pada jenis filter token yang ingin Anda gunakan:

token_filters: Array JSON objek yang berisi filter token. Jenis filter token yang sama dapat disertakan beberapa kali dalam array ini.
- stop_words: Array JSON string yang mewakili kata yang akan dihapus dari daftar istilah.
- normalizer: Objek JSON yang berisi setelan normalisasi untuk filter token. Setelan ini meliputi:
  - mode: String JSON yang mewakili mode normalisasi. Pilihan untuk Anda adalah:
    - NONE: Jangan terapkan mode normalisasi ke istilah.
    - LOWER: Istilah huruf kecil ASCII. Jika tidak ada filter token yang ditentukan untuk analyzer teks yang mendukung filter token, filter ini akan digunakan secara default.
    - ICU_NORMALIZE: ICU menormalisasi persyaratan.
  - icu_normalize_mode: String JSON yang mewakili mode normalisasi ICU. Pilihan untuk Anda adalah:
    - NFC: Menerapkan normalisasi ICU NFC ke persyaratan.
    - NFKC: Terapkan normalisasi ICU NFKC ke persyaratan.
    - NFD: Terapkan normalisasi NFD ICU ke suku akhir.
    - NFKD: Terapkan normalisasi ICU NFKD ke suku akhir.
    Anda dapat menggunakan ini jika mode adalah ICU_NORMALIZE. Jika mode adalah ICU_NORMALIZE dan pasangan nilai kunci ini tidak ditetapkan, icu_normalize_mode adalah NFKC secara default.
  - icu_case_folding: Boolean JSON yang menentukan apakah akan menerapkan folding kasus ICU ke istilah. true untuk menerapkan pelipatan kasus ICU ke persyaratan. Atau false.
    
    Anda dapat menggunakan ini jika mode adalah ICU_NORMALIZE. Jika mode adalah ICU_NORMALIZE dan nilai ini tidak digunakan, icu_case_folding adalah true secara default.

Detail

Filter token dapat digunakan dengan semua kecuali penganalisis teks NO_OP_ANALYZER dalam kueri yang sama. Filter token diterapkan setelah penganalisis teks membagi teks input menjadi istilah.

Jika token_filters tidak ditentukan untuk analyzer yang mendukung filter token, normalisasi huruf kecil ASCII akan diterapkan secara default.

Anda dapat menambahkan beberapa filter token ke array filter token (token_filters). Jika beberapa filter token ditambahkan, filter tersebut akan diterapkan ke persyaratan sesuai urutan yang ditetapkan. Untuk mengetahui informasi selengkapnya, lihat contoh di bagian ini.

Anda dapat menambahkan filter token yang sama beberapa kali ke array filter token. Untuk mengetahui informasi selengkapnya, lihat contoh di bagian ini.

Berikut adalah beberapa filter yang dapat Anda terapkan pada istilah, menggunakan sintaksis JSON filter token:

Tidak ada normalisasi
Mengonversi ke huruf kecil (ASCII)
Mengonversi ke huruf kecil (lipatan huruf besar/kecil ICU)
Pertahankan huruf besar
ICU menormalisasi dengan NFC
ICU melakukan normalisasi dengan NFKC
ICU melakukan normalisasi dengan NFD
ICU melakukan normalisasi dengan NFKD
Menghapus kata

Contoh

Dalam contoh berikut, istilah dinormalisasi NFKC, lalu karena lipatan huruf besar ICU adalah true, istilah dikonversi menjadi huruf kecil. Terakhir, kata huruf kecil pies dan 2 akan dihapus dari kueri.

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

Kueri berikut mirip dengan kueri sebelumnya, tetapi urutan filter token diurutkan ulang, dan hal ini memengaruhi hasil kueri. Hasilnya, 2 dan PIEs dipertahankan karena ② dinormalisasi ke 2 dan PIEs dinormalkan ke pies setelah filter token kata perhentian diterapkan:

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

Anda dapat menggunakan filter token yang sama sebanyak yang Anda inginkan dalam kueri. Dalam kueri berikut, stop_words digunakan dua kali:

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

Tidak ada normalisasi

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

Deskripsi

Normalisasi tidak diterapkan pada suku.

Contoh

Dalam kueri berikut, normalisasi tidak diterapkan ke hasil:

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

Konversikan ke huruf kecil (ASCII)

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

Deskripsi

Melakukan penggunaan huruf kecil ASCII pada istilah yang dihasilkan.

Contoh

Pada kueri berikut, huruf kecil ASCII diterapkan pada hasil:

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

Konversikan ke huruf kecil (lipatan huruf besar/kecil ICU)

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

Deskripsi

Melakukan pelipatan huruf besar/kecil ICU, yang mengubah istilah yang dihasilkan menjadi huruf kecil.

Contoh

Dalam kueri berikut, folding kasus ICU diterapkan ke hasil:

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

Pertahankan huruf besar

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

Deskripsi

Jangan konversi karakter huruf besar menjadi karakter huruf kecil pada istilah yang dihasilkan.

Contoh

Dalam kueri berikut, folding kasus ICU tidak diterapkan ke hasil:

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 normalkan dengan NFC

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

Deskripsi

Menormalisasi teks dengan normalisasi ICU NFC, yang mengurai dan merekomposisi karakter berdasarkan padanan kanonis.

Contoh

Dalam kueri berikut, normalisasi NFC diterapkan ke hasil:

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 menormalisasi dengan NFKC

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

Deskripsi

Menormalisasi teks dengan normalisasi NFKC ICU, yang mengurai karakter berdasarkan kompatibilitas, lalu merekomposisi karakter berdasarkan padanan kanonis.

Contoh

Dalam kueri berikut, normalisasi NFKC diterapkan pada hasil:

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 menormalisasi dengan NFD

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

Deskripsi

Menormalisasi teks dengan normalisasi NFD ICU, yang mengurai karakter berdasarkan padanan kanonis, lalu mengatur beberapa kombinasi karakter dalam urutan tertentu.

Contoh

Pada kueri berikut, meskipun input dan output untuk ñ terlihat sama, byte-nya berbeda (inputnya \u00f1, output-nya adalah \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 menormalisasi dengan NFKD

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

Deskripsi

Menormalisasi teks dengan normalisasi NFKD ICU, yang mengurai karakter berdasarkan kompatibilitas, lalu mengatur beberapa kombinasi karakter dalam urutan tertentu.

Contoh

Pada kueri berikut, meskipun input dan output untuk ñ terlihat sama, byte-nya berbeda (inputnya \u00f1, output-nya adalah \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' ] |
 *---------------------------------------------------------------*/

Menghapus kata

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

Deskripsi

Mengecualikan daftar istilah (token) dari hasil.

Definisi

array_of_stop_words: Array JSON yang berisi string yang mewakili istilah. Istilah ini tidak boleh disertakan dalam hasil. Array harus memiliki setidaknya satu elemen. String kosong adalah elemen array yang valid.

Contoh

Dalam kueri berikut, kata they dan pie dikecualikan dari hasil:

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

Analisis teks

Penganalisis teks

Penganalisis NO_OP_ANALYZER

Penganalisis LOG_ANALYZER

Penganalisis PATTERN_ANALYZER

Opsi penganalisis teks

Opsi analyzer delimiters

Opsi analyzer patterns

Opsi analyzer token_filters

Filter token

Tidak ada normalisasi

Konversikan ke huruf kecil (ASCII)

Konversikan ke huruf kecil (lipatan huruf besar/kecil ICU)

Pertahankan huruf besar

ICU normalkan dengan NFC

ICU menormalisasi dengan NFKC

ICU menormalisasi dengan NFD

ICU menormalisasi dengan NFKD

Menghapus kata

Penganalisis `NO_OP_ANALYZER`

Penganalisis `LOG_ANALYZER`

Penganalisis `PATTERN_ANALYZER`

Opsi analyzer `delimiters`

Opsi analyzer `patterns`

Opsi analyzer `token_filters`