> ## Documentation Index > Fetch the complete documentation index at: https://private-7c7dfe99-mintlify-3a82795f.mintlify.site/llms.txt > Use this file to discover all available pages before exploring further. > 文字列検索関数のドキュメント # 文字列検索関数 このセクションのすべての関数は、デフォルトで大文字と小文字を区別して検索を行います。大文字と小文字を区別しない検索は、通常、別の関数バリアントとして提供されます。 大文字と小文字を区別しない検索は、英語の小文字・大文字の規則に従います。たとえば、英語では小文字の `i` を大文字にすると `I` になりますが、トルコ語では `İ` になります。そのため、英語以外の言語では期待どおりの結果にならない場合があります。 このセクションの関数は、検索対象の文字列 (このセクションでは `haystack` と呼びます) と検索文字列 (このセクションでは `needle` と呼びます) が単一バイトでエンコードされたテキストであることも前提としています。この前提が 満たされていない場合でも、例外はスローされず、結果は未定義です。UTF-8 でエンコードされた文字列の検索は、通常、別の関数 バリアントとして提供されます。同様に、UTF-8 関数バリアントを使用していても、入力文字列が UTF-8 でエンコードされたテキストでない場合、例外はスローされず、 結果は未定義です。なお、自動的な Unicode 正規化は行われませんが、必要に応じて [normalizeUTF8\*()](/ja/reference/functions/regular-functions/string-functions#normalizeUTF8NFC) 関数を使用できます。 [一般的な文字列関数](/ja/reference/functions/regular-functions/string-functions) と [文字列内置換関数](/ja/reference/functions/regular-functions/string-replace-functions) については、別途説明しています。 以下のドキュメントは、`system.functions` システムテーブルから生成されています。 {/*AUTOGENERATED_START*/}
## countMatches
導入バージョン: v21.1.0 文字列内で正規表現に一致する回数を返します。 **バージョン依存の動作** この関数の動作は、ClickHouse のバージョンによって異なります。 * バージョン \< v25.6 では、pattern が受理される場合でも、最初の空一致でカウントを停止します。 * バージョン >= 25.6 では、空一致が発生しても関数は実行を継続します。従来の動作は、setting `count_matches_stop_at_empty_match = true` を使用して復元できます。 **構文** ```sql theme={null} countMatches(haystack, pattern) ``` **引数** * `haystack` — 検索対象の文字列です。[`String`](/ja/reference/data-types/string) * `pattern` — 正規表現パターンです。[`String`](/ja/reference/data-types/string) **戻り値** 見つかった一致の数を返します。[`UInt64`](/ja/reference/data-types/int-uint) **例** **数字の並びの数を数える** ```sql title=Query theme={null} SELECT countMatches('hello 123 world 456 test', '[0-9]+') ``` ```response title=Response theme={null} ┌─countMatches('hello 123 world 456 test', '[0-9]+')─┐ │ 2 │ └─────────────────────────────────────────────────────┘ ```
## countMatchesCaseInsensitive
導入バージョン: v21.1.0 [`countMatches`](#countMatches) と同様ですが、大文字と小文字を区別しないマッチングを実行します。 **構文** ```sql theme={null} countMatchesCaseInsensitive(haystack, pattern) ``` **引数** * `haystack` — 検索対象の文字列です。 [`String`](/ja/reference/data-types/string) * `pattern` — 正規表現パターンです。 [`const String`](/ja/reference/data-types/string) **戻り値** 見つかった一致の数を返します。 [`UInt64`](/ja/reference/data-types/int-uint) **例** **大文字と小文字を区別しない場合のカウント** ```sql title=Query theme={null} SELECT countMatchesCaseInsensitive('Hello HELLO world', 'hello') ``` ```response title=Response theme={null} ┌─countMatchesCaseInsensitive('Hello HELLO world', 'hello')─┐ │ 2 │ └───────────────────────────────────────────────────────────┘ ```
## countSubstrings
導入バージョン: v21.1.0 文字列 `haystack` に部分文字列 `needle` が含まれる回数を返します。 **構文** ```sql theme={null} countSubstrings(haystack, needle[, start_pos]) ``` **引数** * `haystack` — 検索対象の文字列。[String](/ja/reference/data-types/string) または [Enum](/ja/reference/data-types/enum)。 - `needle` — 検索する部分文字列。[String](/ja/reference/data-types/string)。 - `start_pos` — `haystack` 内で検索を開始する位置 (1始まり) 。[UInt](/ja/reference/data-types/int-uint)。省略可能。 **戻り値** 出現回数。[`UInt64`](/ja/reference/data-types/int-uint) **例** **使用例** ```sql title=Query theme={null} SELECT countSubstrings('aaaa', 'aa'); ``` ```response title=Response theme={null} ┌─countSubstrings('aaaa', 'aa')─┐ │ 2 │ └───────────────────────────────┘ ``` **start\_pos 引数を指定した場合** ```sql title=Query theme={null} SELECT countSubstrings('abc___abc', 'abc', 4); ``` ```response title=Response theme={null} ┌─countSubstrings('abc___abc', 'abc', 4)─┐ │ 1 │ └────────────────────────────────────────┘ ```
## countSubstringsCaseInsensitive
導入バージョン: v21.1.0 [`countSubstrings`](#countSubstrings) と同様ですが、大文字と小文字を区別せずにカウントします。 **構文** ```sql theme={null} countSubstringsCaseInsensitive(haystack, needle[, start_pos]) ``` **引数** * `haystack` — 検索対象の文字列。[`String`](/ja/reference/data-types/string) または [`Enum`](/ja/reference/data-types/enum) * `needle` — 検索する部分文字列。[`String`](/ja/reference/data-types/string) * `start_pos` — 任意。`haystack` 内で検索を開始する位置 (1始まり) 。[`UInt*`](/ja/reference/data-types/int-uint) **戻り値** haystack 内に needle が出現する回数を返します。[`UInt64`](/ja/reference/data-types/int-uint) **例** **使用例** ```sql title=Query theme={null} SELECT countSubstringsCaseInsensitive('AAAA', 'aa'); ``` ```response title=Response theme={null} ┌─countSubstri⋯AAA', 'aa')─┐ │ 2 │ └──────────────────────────┘ ``` **start\_pos 引数を指定した場合** ```sql title=Query theme={null} SELECT countSubstringsCaseInsensitive('abc___ABC___abc', 'abc', 4); ``` ```response title=Response theme={null} ┌─countSubstri⋯, 'abc', 4)─┐ │ 2 │ └──────────────────────────┘ ```
## countSubstringsCaseInsensitiveUTF8
導入バージョン: v21.1.0 [`countSubstrings`](#countSubstrings) と同様ですが、大文字と小文字を区別せずにカウントし、`haystack` は UTF-8 文字列であることを前提とします。 **構文** ```sql theme={null} countSubstringsCaseInsensitiveUTF8(haystack, needle[, start_pos]) ``` **引数** * `haystack` — 検索対象の UTF-8 文字列。[`String`](/ja/reference/data-types/string) または [`Enum`](/ja/reference/data-types/enum) * `needle` — 検索する部分文字列。[`String`](/ja/reference/data-types/string) * `start_pos` — 任意。`haystack` 内で検索を開始する位置 (1始まり) 。[`UInt*`](/ja/reference/data-types/int-uint) **戻り値** `haystack` 内に `needle` が出現する回数を返します。[`UInt64`](/ja/reference/data-types/int-uint) **例** **使用例** ```sql title=Query theme={null} SELECT countSubstringsCaseInsensitiveUTF8('ложка, кошка, картошка', 'КА'); ``` ```response title=Response theme={null} ┌─countSubstri⋯шка', 'КА')─┐ │ 4 │ └──────────────────────────┘ ``` **start\_pos 引数を使用する場合** ```sql title=Query theme={null} SELECT countSubstringsCaseInsensitiveUTF8('ложка, кошка, картошка', 'КА', 13); ``` ```response title=Response theme={null} ┌─countSubstri⋯, 'КА', 13)─┐ │ 2 │ └──────────────────────────┘ ```
## extract
導入バージョン: v1.1.0 文字列内で、正規表現に最初に一致した部分文字列を抽出します。 'haystack' が 'pattern' に一致しない場合は、空文字列が返されます。 この関数は RE2 正規表現ライブラリを使用します。サポートされている構文については、[re2](https://github.com/google/re2/wiki/Syntax) を参照してください。 正規表現にキャプチャグループ (サブパターン) がある場合、この関数は入力文字列を最初のキャプチャグループに対して照合します。 **構文** ```sql theme={null} extract(haystack, pattern) ``` **引数** * `haystack` — 抽出元の文字列。[`String`](/ja/reference/data-types/string) * `pattern` — 通常はキャプチャグループを含む正規表現。[`const String`](/ja/reference/data-types/string) **戻り値** 抽出された部分を文字列として返します。[`String`](/ja/reference/data-types/string) **例** **メールアドレスからドメインを抽出** ```sql title=Query theme={null} SELECT extract('test@clickhouse.com', '.*@(.*)$') ``` ```response title=Response theme={null} ┌─extract('test@clickhouse.com', '.*@(.*)$')─┐ │ clickhouse.com │ └───────────────────────────────────────────┘ ``` **一致しない場合は空文字列を返す** ```sql title=Query theme={null} SELECT extract('test@clickhouse.com', 'no_match') ``` ```response title=Response theme={null} ┌─extract('test@clickhouse.com', 'no_match')─┐ │ │ └────────────────────────────────────────────┘ ```
## extractAll
導入バージョン: v1.1.0 [`extract`](#extract) と似ていますが、文字列内で正規表現に一致するすべての部分を配列として返します。 'haystack' が 'pattern' の正規表現に一致しない場合は、空の配列を返します。 正規表現にキャプチャグループ (サブパターン) がある場合、この関数は入力文字列に対して最初のキャプチャグループを照合します。 **構文** ```sql theme={null} extractAll(haystack, pattern) ``` **引数** * `haystack` — 断片を抽出する対象の文字列です。[`String`](/ja/reference/data-types/string) * `pattern` — 正規表現です。キャプチャグループを含めることもできます。[`const String`](/ja/reference/data-types/string) **戻り値** 抽出された断片の配列を返します。[`Array(String)`](/ja/reference/data-types/array) **例** **すべての数値を抽出** ```sql title=Query theme={null} SELECT extractAll('hello 123 world 456', '[0-9]+') ``` ```response title=Response theme={null} ┌─extractAll('hello 123 world 456', '[0-9]+')─┐ │ ['123','456'] │ └─────────────────────────────────────────────┘ ``` **キャプチャグループを使った抽出** ```sql title=Query theme={null} SELECT extractAll('test@example.com, user@domain.org', '([a-zA-Z0-9]+)@') ``` ```response title=Response theme={null} ┌─extractAll('test@example.com, user@domain.org', '([a-zA-Z0-9]+)@')─┐ │ ['test','user'] │ └────────────────────────────────────────────────────────────────────┘ ```
## extractAllGroupsHorizontal
導入バージョン: v20.5.0 指定した正規表現を使って文字列内のすべてのグループにマッチし、配列の配列を返します。各配列には、同じキャプチャグループで取得されたすべてのキャプチャが、グループ番号順に格納されます。 **構文** ```sql theme={null} extractAllGroupsHorizontal(s, regexp) ``` **引数** * `s` — 抽出元の入力文字列。[`String`](/ja/reference/data-types/string) または [`FixedString`](/ja/reference/data-types/fixedstring) * `regexp` — マッチに使用する正規表現。[`const String`](/ja/reference/data-types/string) または [`const FixedString`](/ja/reference/data-types/fixedstring) **戻り値** 配列の配列を返します。各内部配列には、すべての一致にわたる1つのキャプチャグループのすべてのキャプチャが含まれます。最初の内部配列にはグループ 1 のすべてのキャプチャ、2 番目の内部配列にはグループ 2 のすべてのキャプチャ、というように格納されます。一致が見つからない場合は、空の配列を返します。[`Array(Array(String))`](/ja/reference/data-types/array) **例** **使用例** ```sql title=Query theme={null} WITH '< Server: nginx < Date: Tue, 22 Jan 2019 00:26:14 GMT < Content-Type: text/html; charset=UTF-8 < Connection: keep-alive ' AS s SELECT extractAllGroupsHorizontal(s, '< ([\\w\\-]+): ([^\\r\\n]+)'); ``` ```response title=Response theme={null} [['Server','Date','Content-Type','Connection'],['nginx','Tue, 22 Jan 2019 00:26:14 GMT','text/html; charset=UTF-8','keep-alive']] ```
## extractGroups
導入バージョン: v20.5.0 正規表現に一致した最初の部分文字列からキャプチャリンググループを抽出します。すべての一致からグループを抽出するには、[`extractAllGroupsHorizontal`](#extractAllGroupsHorizontal) または [`extractAllGroupsVertical`](/ja/reference/functions/regular-functions/splitting-merging-functions#extractAllGroupsVertical) を使用します。 **構文** ```sql theme={null} extractGroups(s, regexp) ``` **引数** * `s` — 抽出元の入力文字列。[`String`](/ja/reference/data-types/string) または [`FixedString`](/ja/reference/data-types/fixedstring) * `regexp` — 正規表現。少なくとも 1 つのキャプチャグループを含む必要があります。定数。[`const String`](/ja/reference/data-types/string) または [`const FixedString`](/ja/reference/data-types/fixedstring) **戻り値** 正規表現に一致した場合、最初の一致におけるキャプチャグループ (`1` から `N`。`N` は `regexp` 内のキャプチャグループ数) の配列を返します。一致しない場合は、空の配列を返します。[`Array(String)`](/ja/reference/data-types/array) **例** **使用例** ```sql title=Query theme={null} WITH '< Server: nginx < Date: Tue, 22 Jan 2019 00:26:14 GMT < Content-Type: text/html; charset=UTF-8 < Connection: keep-alive ' AS s SELECT extractGroups(s, '< ([\\w\\-]+): ([^\\r\\n]+)'); ``` ```response title=Response theme={null} ['Server','nginx'] ```
## hasAllTokens
導入バージョン: v25.10.0 [`hasAnyTokens`](#hasAnyTokens) と同様ですが、`needle` 文字列またはArrayに含まれるすべてのトークンが `input` 文字列と一致する場合は1を、それ以外の場合は0を返します。`input` がカラムの場合、この条件を満たすすべての行を返します。 最適なパフォーマンスを得るには、カラム `input` に [テキスト索引](/ja/reference/engines/table-engines/mergetree-family/textindexes) を定義しておく必要があります。 テキスト索引が定義されていない場合、この関数はカラム全体を総当たりでスキャンするため、索引ルックアップと比べて桁違いに低速になります。 検索前に、この関数はトークン化を行い、 * `input` 引数 (必須) と * `needle` 引数 ([String](/ja/reference/data-types/string) として指定された場合) は、 テキスト索引で指定されたトークナイザーを使用して処理されます。 カラムにテキスト索引が定義されていない場合は、代わりに `splitByNonAlpha` トークナイザーが使用されます。 `needle` 引数の型が [Array(String)](/ja/reference/data-types/array) の場合、配列の各要素はトークンとして扱われ、追加のトークン化は行われません。 重複するトークンは無視されます。 例えば、needles = \['ClickHouse', 'ClickHouse'] は \['ClickHouse'] と同じように扱われます。 **構文** ```sql theme={null} hasAllTokens(input, needles) ``` **別名**: `hasAllToken` **引数** * `input` — 入力カラムです。[`String`](/ja/reference/data-types/string) または [`FixedString`](/ja/reference/data-types/fixedstring) または [`Array(String)`](/ja/reference/data-types/array) または [`Array(FixedString)`](/ja/reference/data-types/array) * `needles` — 検索するトークン。[`String`](/ja/reference/data-types/string) または [`Array(String)`](/ja/reference/data-types/array) * `tokenizer` — 使用するトークナイザー。有効な引数は `splitByNonAlpha`、`splitByString`、`asciiCJK`、`ngrams`、`sparseGrams`、`array` です。省略可能で、明示的に設定されていない場合のデフォルト値は `splitByNonAlpha` です。[`const String`](/ja/reference/data-types/string) **戻り値** すべてのneedleが一致する場合は1、それ以外の場合は0を返します。[`UInt8`](/ja/reference/data-types/int-uint) **例** **文字列のneedleを使った基本的な使い方** ```sql title=Query theme={null} CREATE TABLE table ( id UInt32, msg String, INDEX idx(msg) TYPE text(tokenizer = splitByString(['()', '\\'])) ) ENGINE = MergeTree ORDER BY id; INSERT INTO table VALUES (1, '()a,\\bc()d'), (2, '()\\a()bc\\d'), (3, ',()a\\,bc,(),d,'); SELECT count() FROM table WHERE hasAllTokens(msg, 'a\\d()'); ``` ```response title=Response theme={null} ┌─count()─┐ │ 1 │ └─────────┘ ``` **Array内で検索するneedleをAS-IS (トークン化なし) で指定する** ```sql title=Query theme={null} SELECT count() FROM table WHERE hasAllTokens(msg, ['a', 'd']); ``` ```response title=Response theme={null} ┌─count()─┐ │ 1 │ └─────────┘ ``` **`tokens` 関数を使用してneedleを生成する** ```sql title=Query theme={null} SELECT count() FROM table WHERE hasAllTokens(msg, tokens('a()d', 'splitByString', ['()', '\\'])); ``` ```response title=Response theme={null} ┌─count()─┐ │ 1 │ └─────────┘ ``` **第3引数でカスタムトークナイザーを使用する** ```sql title=Query theme={null} SELECT hasAllTokens('abcdef', 'abc', 'ngrams(3)'); ``` ```response title=Response theme={null} ┌─hasAllTokens('abcdef', 'abc', 'ngrams(3)')─┐ │ 1 │ └──────────────────────────────────────────────┘ ``` **ArrayおよびMapカラムの使用例** ```sql title=Query theme={null} CREATE TABLE log ( id UInt32, tags Array(String), attributes Map(String, String), INDEX idx_tags (tags) TYPE text(tokenizer = splitByNonAlpha), INDEX idx_attributes_keys mapKeys(attributes) TYPE text(tokenizer = array), INDEX idx_attributes_vals mapValues(attributes) TYPE text(tokenizer = array) ) ENGINE = MergeTree ORDER BY id; INSERT INTO log VALUES (1, ['clickhouse', 'clickhouse cloud'], {'address': '192.0.0.1', 'log_level': 'INFO'}), (2, ['chdb'], {'embedded': 'true', 'log_level': 'DEBUG'}); ``` ```response title=Response theme={null} ``` **Array 型カラムの例** ```sql title=Query theme={null} SELECT count() FROM log WHERE hasAllTokens(tags, 'clickhouse'); ``` ```response title=Response theme={null} ┌─count()─┐ │ 1 │ └─────────┘ ``` **mapKeys を使った例** ```sql title=Query theme={null} SELECT count() FROM log WHERE hasAllTokens(mapKeys(attributes), ['address', 'log_level']); ``` ```response title=Response theme={null} ┌─count()─┐ │ 1 │ └─────────┘ ``` **mapValues を使った例** ```sql title=Query theme={null} SELECT count() FROM log WHERE hasAllTokens(mapValues(attributes), ['192.0.0.1', 'DEBUG']); ``` ```response title=Response theme={null} ┌─count()─┐ │ 0 │ └─────────┘ ```
## hasAnyTokens
導入バージョン: v25.10.0 `needle` の文字列またはArrayの中に少なくとも1つのtokenが `input` 文字列と一致する場合は1を、それ以外の場合は0を返します。`input` がカラムの場合、この条件を満たすすべての行を返します。 最適なパフォーマンスを得るには、カラム `input` に [テキスト索引](/ja/reference/engines/table-engines/mergetree-family/textindexes) を定義する必要があります。 テキスト索引が定義されていない場合、この関数はカラム全体を総当たりでスキャンします。これは索引ルックアップに比べて桁違いに低速です。 検索前に、この関数はトークン化します * `input` 引数 (常に必要) と * `needle` 引数 ([String](/ja/reference/data-types/string) として指定された場合) は、 テキスト索引で指定されたトークナイザーを使用して処理されます。 カラムにテキスト索引が定義されていない場合は、代わりに `splitByNonAlpha` トークナイザーが使用されます。 `needle` 引数の型が [Array(String)](/ja/reference/data-types/array) の場合、配列の各要素はトークンとして扱われ、追加のトークン化は行われません。 重複するトークンは無視されます。 例えば、\['ClickHouse', 'ClickHouse'] は \['ClickHouse'] と同じように扱われます。 **構文** ```sql theme={null} hasAnyTokens(input, needles) ``` **別名**: `hasAnyToken` **引数** * `input` — 入力カラムです。[`String`](/ja/reference/data-types/string) or [`FixedString`](/ja/reference/data-types/fixedstring) or [`Nullable(String)`](/ja/reference/data-types/nullable) or [`Nullable(FixedString)`](/ja/reference/data-types/nullable) or [`Array(String)`](/ja/reference/data-types/array) or [`Array(FixedString)`](/ja/reference/data-types/array) or [`Array(Nullable(String))`](/ja/reference/data-types/array) or [`Array(Nullable(FixedString))`](/ja/reference/data-types/array) * `needles` — 検索対象のトークン。[`String`](/ja/reference/data-types/string) または [`Array(String)`](/ja/reference/data-types/array) * `tokenizer` — 使用するトークナイザーです。有効な引数は `splitByNonAlpha`、`splitByString`、`asciiCJK`、`ngrams`、`sparseGrams`、`array` です。省略可能で、明示的に設定しない場合のデフォルトは `splitByNonAlpha` です。[`const String`](/ja/reference/data-types/string) **戻り値** 少なくとも1つの一致があった場合は`1`を、それ以外の場合は`0`を返します。[`UInt8`](/ja/reference/data-types/int-uint) **例** **文字列のneedleを使った基本的な使い方** ```sql title=Query theme={null} CREATE TABLE table ( id UInt32, msg String, INDEX idx(msg) TYPE text(tokenizer = splitByString(['()', '\\'])) ) ENGINE = MergeTree ORDER BY id; INSERT INTO table VALUES (1, '()a,\\bc()d'), (2, '()\\a()bc\\d'), (3, ',()a\\,bc,(),d,'); SELECT count() FROM table WHERE hasAnyTokens(msg, 'a\\d()'); ``` ```response title=Response theme={null} ┌─count()─┐ │ 3 │ └─────────┘ ``` **Array内でAS-IS (トークン化なし) で検索するneedleを指定する** ```sql title=Query theme={null} SELECT count() FROM table WHERE hasAnyTokens(msg, ['a', 'd']); ``` ```response title=Response theme={null} ┌─count()─┐ │ 3 │ └─────────┘ ``` **`tokens` 関数を使用してneedleを生成する** ```sql title=Query theme={null} SELECT count() FROM table WHERE hasAnyTokens(msg, tokens('a()d', 'splitByString', ['()', '\\'])); ``` ```response title=Response theme={null} ┌─count()─┐ │ 3 │ └─────────┘ ``` **ArrayおよびMapカラムの使用例** ```sql title=Query theme={null} CREATE TABLE log ( id UInt32, tags Array(String), attributes Map(String, String), INDEX idx_tags (tags) TYPE text(tokenizer = splitByNonAlpha), INDEX idx_attributes_keys mapKeys(attributes) TYPE text(tokenizer = array), INDEX idx_attributes_vals mapValues(attributes) TYPE text(tokenizer = array) ) ENGINE = MergeTree ORDER BY id; INSERT INTO log VALUES (1, ['clickhouse', 'clickhouse cloud'], {'address': '192.0.0.1', 'log_level': 'INFO'}), (2, ['chdb'], {'embedded': 'true', 'log_level': 'DEBUG'}); ``` ```response title=Response theme={null} ``` **Arrayカラムを使った例** ```sql title=Query theme={null} SELECT count() FROM log WHERE hasAnyTokens(tags, 'clickhouse'); ``` ```response title=Response theme={null} ┌─count()─┐ │ 1 │ └─────────┘ ``` **mapKeys の例** ```sql title=Query theme={null} SELECT count() FROM log WHERE hasAnyTokens(mapKeys(attributes), ['address', 'log_level']); ``` ```response title=Response theme={null} ┌─count()─┐ │ 2 │ └─────────┘ ``` **mapValues の使用例** ```sql title=Query theme={null} SELECT count() FROM log WHERE hasAnyTokens(mapValues(attributes), ['192.0.0.1', 'DEBUG']); ``` ```response title=Response theme={null} ┌─count()─┐ │ 2 │ └─────────┘ ```
## hasPhrase
導入バージョン: v26.4.0 haystack に、phrase 内のすべての token が連続した順序で含まれているかどうかを確認します。 検索を行う前に、この関数は省略可能な第 3 引数で指定されたトークナイザーを使用して、`input` 引数と `phrase` 引数の両方をトークン化します。 トークナイザー引数には、`splitByNonAlpha`、`splitByString`、`ngrams`、`asciiCJK` のいずれかを指定する必要があります。 トークナイザーが指定されていない場合は、デフォルトで `splitByNonAlpha` トークナイザーが使用されます。 [`hasToken`](#hasToken)、[`hasAnyTokens`](#hasAnyTokens)、[`hasAllTokens`](#hasAllTokens) とは異なり、`hasPhrase` では token が同じ順序で現れ、 その間に別の token が挟まらないことが必要です。たとえば、`hasPhrase('the quick brown fox', 'quick fox')` は 0 を返します。 これは、"quick" と "fox" の間に "brown" があるためです。 **構文** ```sql theme={null} hasPhrase(input, phrase[, tokenizer]) ``` **別名**: `matchPhrase` **引数** * `input` — 入力カラム。[`String`](/ja/reference/data-types/string) または [`FixedString`](/ja/reference/data-types/fixedstring) * `phrase` — 検索対象のフレーズ。[`const String`](/ja/reference/data-types/string) * `tokenizer` — 使用するトークナイザー。省略可能で、デフォルト値は `splitByNonAlpha` です。[`const String`](/ja/reference/data-types/string) **戻り値** フレーズが連続したトークン列として見つかった場合は `1`、それ以外の場合は `0` を返します。[`UInt8`](/ja/reference/data-types/int-uint) **例** **フレーズマッチ** ```sql title=Query theme={null} SELECT hasPhrase('the quick brown fox jumps', 'quick brown') ``` ```response title=Response theme={null} ┌─hasPhrase('the quick brown fox jumps', 'quick brown')─┐ │ 1 │ └────────────────────────────────────────────────────────┘ ``` **非連続のトークン** ```sql title=Query theme={null} SELECT hasPhrase('the quick brown fox jumps', 'quick fox') ``` ```response title=Response theme={null} ┌─hasPhrase('the quick brown fox jumps', 'quick fox')─┐ │ 0 │ └──────────────────────────────────────────────────────┘ ```
## hasSubsequence
導入バージョン: v23.7.0 needle が haystack の部分列であるかどうかを判定します。 文字列の部分列とは、残っている文字の順序を変えずに、一部の文字、またはまったく文字を削除せずに別の文字列から得られる列のことです。 **構文** ```sql theme={null} hasSubsequence(haystack, needle) ``` **引数** * `haystack` — 部分列を検索する対象の文字列。[`String`](/ja/reference/data-types/string) * `needle` — 検索する部分列。[`String`](/ja/reference/data-types/string) **戻り値** `needle` が `haystack` の部分列であれば `1`、そうでなければ `0` を返します。[`UInt8`](/ja/reference/data-types/int-uint) **例** **基本的な部分列チェック** ```sql title=Query theme={null} SELECT hasSubsequence('Hello World', 'HlWrd') ``` ```response title=Response theme={null} ┌─hasSubsequence('Hello World', 'HlWrd')─┐ │ 1 │ └────────────────────────────────────────┘ ``` **部分列が見つかりません** ```sql title=Query theme={null} SELECT hasSubsequence('Hello World', 'xyz') ``` ```response title=Response theme={null} ┌─hasSubsequence('Hello World', 'xyz')─┐ │ 0 │ └──────────────────────────────────────┘ ```
## hasSubsequenceCaseInsensitive
導入バージョン: v23.7.0 [`hasSubsequence`](#hasSubsequence) と同様ですが、大文字と小文字を区別せずに検索します。 **構文** ```sql theme={null} hasSubsequenceCaseInsensitive(haystack, needle) ``` **引数** * `haystack` — 検索対象の文字列。[`String`](/ja/reference/data-types/string) * `needle` — 検索する部分列。[`String`](/ja/reference/data-types/string) **戻り値** `needle` が `haystack` の部分列である場合は 1、そうでない場合は 0 を返します。[`UInt8`](/ja/reference/data-types/int-uint) **例** **使用例** ```sql title=Query theme={null} SELECT hasSubsequenceCaseInsensitive('garbage', 'ARG'); ``` ```response title=Response theme={null} ┌─hasSubsequenceCaseInsensitive('garbage', 'ARG')─┐ │ 1 │ └─────────────────────────────────────────────────┘ ```
## hasSubsequenceCaseInsensitiveUTF8
導入バージョン: v23.7.0 [`hasSubsequenceUTF8`](#hasSubsequenceUTF8) と同様ですが、大文字と小文字を区別せずに検索します。 **構文** ```sql theme={null} hasSubsequenceCaseInsensitiveUTF8(haystack, needle) ``` **引数** * `haystack` — 検索対象の UTF8 でエンコードされた文字列。[`String`](/ja/reference/data-types/string) * `needle` — 検索する UTF8 でエンコードされた部分列。[`String`](/ja/reference/data-types/string) **戻り値** `needle` が `haystack` の部分列であれば 1、そうでなければ 0 を返します。[`UInt8`](/ja/reference/data-types/int-uint) **例** **使用例** ```sql title=Query theme={null} SELECT hasSubsequenceCaseInsensitiveUTF8('ClickHouse - столбцовая система управления базами данных', 'СИСТЕМА'); ``` ```response title=Response theme={null} ┌─hasSubsequen⋯ 'СИСТЕМА')─┐ │ 1 │ └──────────────────────────┘ ```
## hasSubsequenceUTF8
導入バージョン: v23.7.0 [`hasSubsequence`](/ja/reference/functions/regular-functions/string-search-functions#hasSubsequence) と同様ですが、haystack と needle は UTF-8 でエンコードされた文字列であることを前提としています。 **構文** ```sql theme={null} hasSubsequenceUTF8(haystack, needle) ``` **引数** * `haystack` — 検索対象の文字列です。[`String`](/ja/reference/data-types/string) * `needle` — 検索する部分列です。[`String`](/ja/reference/data-types/string) **戻り値** `needle` が `haystack` の部分列であれば `1`、そうでなければ `0` を返します。[`UInt8`](/ja/reference/data-types/int-uint) **例** **使用例** ```sql title=Query theme={null} SELECT hasSubsequenceUTF8('картошка', 'кошка'); ``` ```response title=Response theme={null} ┌─hasSubsequen⋯', 'кошка')─┐ │ 1 │ └──────────────────────────┘ ``` **不一致の部分列** ```sql title=Query theme={null} SELECT hasSubsequenceUTF8('картошка', 'апельсин'); ``` ```response title=Response theme={null} ┌─hasSubsequen⋯'апельсин')─┐ │ 0 │ └──────────────────────────┘ ```
## hasToken
導入バージョン: v20.1.0 指定されたトークンが検索対象文字列内に存在するかどうかを確認します。 トークナイザーとして [splitByNonAlpha](/ja/reference/functions/regular-functions/splitting-merging-functions#splitByNonAlpha) を使用します。つまり、トークンは連続する文字 `[0-9A-Za-z_]` (数字、ASCII 文字、アンダースコア) からなる、可能な限り最長の部分列として定義されます。 **構文** ```sql theme={null} hasToken(haystack, token) ``` **引数** * `haystack` — 検索対象の文字列。[`String`](/ja/reference/data-types/string) * `token` — 検索するトークン。[`const String`](/ja/reference/data-types/string) **戻り値** トークンが見つかった場合は `1`、見つからなかった場合は `0` を返します。[`UInt8`](/ja/reference/data-types/int-uint) **例** **トークン検索** ```sql title=Query theme={null} SELECT hasToken('clickhouse test', 'test') ``` ```response title=Response theme={null} ┌─hasToken('clickhouse test', 'test')─┐ │ 1 │ └─────────────────────────────────────┘ ```
## hasTokenCaseInsensitive
導入バージョン: v20.1.0 tokenbf\_v1 索引を使用して、haystack 内の needle の大文字と小文字を区別しないルックアップを実行します。 **構文** ```sql theme={null} hasTokenCaseInsensitive(haystack, needle) ``` **引数** * なし。 **戻り値** **例**
## hasTokenCaseInsensitiveOrNull
導入バージョン: v23.1.0 tokenbf\_v1 索引を使用して、haystack 内の needle を大文字と小文字を区別せずにルックアップします。needle の形式が不正な場合は null を返します。 **構文** ```sql theme={null} hasTokenCaseInsensitiveOrNull(haystack, needle) ``` **引数** * なし。 **戻り値** **例**
## hasTokenOrNull
導入バージョン: v20.1.0 [`hasToken`](#hasToken) と同様ですが、token の形式が不正な場合は NULL を返します。 **構文** ```sql theme={null} hasTokenOrNull(haystack, token) ``` **引数** * `haystack` — 検索対象の文字列。定数である必要があります。[`String`](/ja/reference/data-types/string) * `token` — 検索するトークン。[`const String`](/ja/reference/data-types/string) **戻り値** トークンが見つかった場合は `1`、見つからない場合は `0`、`token` の形式が不正な場合は `NULL` を返します。[`Nullable(UInt8)`](/ja/reference/data-types/nullable) **例** **使用例** ```sql title=Query theme={null} SELECT hasTokenOrNull('apple banana cherry', 'ban ana'); ``` ```response title=Response theme={null} ┌─hasTokenOrNu⋯ 'ban ana')─┐ │ ᴺᵁᴸᴸ │ └──────────────────────────┘ ```
## highlight
導入バージョン: v26.4.0 テキスト文字列内で検索語が出現した箇所を HTML タグで囲み、強調表示します。 この関数は、ASCII の大文字と小文字を区別しない照合を行います。複数の検索語がテキスト内で重なっている場合や隣接している場合、マッチした領域は 1 つの強調表示された span にまとめられます。 **構文** ```sql theme={null} highlight(haystack, needles[, open_tag, close_tag]) ``` **引数** * `haystack` — 検索対象のテキストです。[`String`](/ja/reference/data-types/string) または [`FixedString`](/ja/reference/data-types/fixedstring) * `needles` — 強調表示する検索語の配列です。[`const Array(String)`](/ja/reference/data-types/array) * `open_tag` — 各一致箇所の前に挿入する開始タグです。既定値: ``。[`const String`](/ja/reference/data-types/string) * `close_tag` — 各一致箇所の後に挿入する終了タグです。既定値: ``。[`const String`](/ja/reference/data-types/string) **戻り値** 一致した語句を指定したタグで囲んだ入力テキストを返します。[`String`](/ja/reference/data-types/string) **例** **基本的なハイライト** ```sql title=Query theme={null} SELECT highlight('The quick brown fox', ['quick', 'fox']) ``` ```response title=Response theme={null} ┌─highlight('The quick brown fox', ['quick', 'fox'])─┐ │ The quick brown fox │ └────────────────────────────────────────────────────┘ ``` **カスタムタグ** ```sql title=Query theme={null} SELECT highlight('Hello World', ['hello'], '', '') ``` ```response title=Response theme={null} ┌─highlight('Hello World', ['hello'], '', '')─┐ │ Hello World │ └────────────────────────────────────────────────────┘ ```
## ilike
導入バージョン: v20.6.0 [`like`](#like) と同様ですが、大文字と小文字を区別せずに検索します。 **構文** ```sql theme={null} ilike(haystack, pattern) -- haystack ILIKE pattern（大文字小文字を区別しない） ``` **引数** * `haystack` — 検索対象の文字列。[`String`](/ja/reference/data-types/string) または [`FixedString`](/ja/reference/data-types/fixedstring) * `pattern` — 照合する LIKE パターン。[`String`](/ja/reference/data-types/string) **戻り値** 文字列が LIKE パターンに一致する場合 (大文字と小文字を区別しない) は `1`、それ以外の場合は `0` を返します。[`UInt8`](/ja/reference/data-types/int-uint) **例** **使用例** ```sql title=Query theme={null} SELECT ilike('ClickHouse', '%house%'); ``` ```response title=Response theme={null} ┌─ilike('ClickHouse', '%house%')─┐ │ 1 │ └────────────────────────────────┘ ```
## like
導入バージョン: v1.1.0 文字列 `haystack` が `LIKE` 式 `pattern` に一致するかどうかを返します。 `LIKE` 式には、通常の文字に加えて、次のメタ記号を含めることができます。 * `%` は、任意の文字列 (0 文字を含む) を表します。 * `_` は、任意の 1 文字を表します。 * `\` は、`%`、`_`、`\` をリテラルとして扱うためのエスケープ文字です。 照合は UTF-8 に基づいて行われます。たとえば、`_` は UTF-8 では 2 バイトで表現される Unicode コードポイント `¥` に一致します。 `haystack` または `LIKE` 式が有効な UTF-8 でない場合の動作は未定義です。 Unicode の正規化は自動では行われないため、必要に応じて `normalizeUTF8*` 関数を使用してください。 リテラルの `%`、`_`、`\` (これらは `LIKE` のメタ文字です) に一致させるには、それぞれの前にバックスラッシュを付けます: `\%`、`\_`、`\\`。 バックスラッシュの直後の文字が `%`、`_`、`\` 以外の場合、バックスラッシュは特別な意味を失い、リテラルとして解釈されます。 ClickHouse では、文字列内のバックスラッシュ自体も[エスケープする必要がある](/ja/reference/syntax#string)ため、実際には `\\%`、`\\_`、`\\\\` と記述する必要があります。 `%needle%` 形式の `LIKE` 式では、この関数は `position` 関数と同程度の速度で動作します。 それ以外の `LIKE` 式はすべて内部的に正規表現へ変換され、`match` 関数と同程度の性能で実行されます。 **構文** ```sql theme={null} like(haystack, pattern) -- haystack LIKE pattern ``` **引数** * `haystack` — 検索対象の文字列。[`String`](/ja/reference/data-types/string) または [`FixedString`](/ja/reference/data-types/fixedstring) * `pattern` — 照合する `LIKE` パターン。`%` (任意の文字数に一致) 、`_` (任意の1文字に一致) 、およびエスケープ用の `\` を含めることができます。[`String`](/ja/reference/data-types/string) **戻り値** 文字列が `LIKE` パターンに一致する場合は `1`、一致しない場合は `0` を返します。[`UInt8`](/ja/reference/data-types/int-uint) **例** **使用例** ```sql title=Query theme={null} SELECT like('ClickHouse', '%House'); ``` ```response title=Response theme={null} ┌─like('ClickHouse', '%House')─┐ │ 1 │ └──────────────────────────────┘ ``` **単一文字のワイルドカード** ```sql title=Query theme={null} SELECT like('ClickHouse', 'Click_ouse'); ``` ```response title=Response theme={null} ┌─like('ClickH⋯lick_ouse')─┐ │ 1 │ └──────────────────────────┘ ``` **マッチしないパターン** ```sql title=Query theme={null} SELECT like('ClickHouse', '%SQL%'); ``` ```response title=Response theme={null} ┌─like('ClickHouse', '%SQL%')─┐ │ 0 │ └─────────────────────────────┘ ```
## locate
導入バージョン: v18.16.0 [`position`](#position) と似ていますが、引数 `haystack` と `locate` の順序が逆になっています。 **バージョン依存の動作** この関数の動作は、ClickHouse のバージョンによって異なります。 * バージョン \< v24.3 では、`locate` は関数 `position` のエイリアスであり、引数 `(haystack, needle[, start_pos])` を受け付けます。 * バージョン >= 24.3 では、`locate` は独立した関数となり (MySQL との互換性向上のため) 、引数 `(needle, haystack[, start_pos])` を受け付けます。 以前の動作は、setting `function_locate_has_mysql_compatible_argument_order = false` を使用して復元できます。 **Syntax** ```sql theme={null} locate(needle, haystack[, start_pos]) ``` **引数** * `needle` — 検索する部分文字列。[`String`](/ja/reference/data-types/string) * `haystack` — 検索対象の文字列。[`String`](/ja/reference/data-types/string) または [`Enum`](/ja/reference/data-types/enum) * `start_pos` — 任意。検索を開始する `haystack` 内の位置 (1始まり) 。[`UInt`](/ja/reference/data-types/int-uint) **戻り値** 部分文字列が見つかった場合は、1から数えたバイト単位の開始位置を返します。見つからなかった場合は `0` を返します。[`UInt64`](/ja/reference/data-types/int-uint) **例** **基本的な使い方** ```sql title=Query theme={null} SELECT locate('ca', 'abcabc') ``` ```response title=Response theme={null} ┌─locate('ca', 'abcabc')─┐ │ 3 │ └────────────────────────┘ ```
## match
導入バージョン: v1.1.0 指定した文字列が、指定した正規表現パターンに一致するかどうかを判定します。 この関数は RE2 正規表現ライブラリを使用します。サポートされている構文については、[re2](https://github.com/google/re2/wiki/Syntax) を参照してください。 マッチングは UTF-8 を前提に動作します。たとえば `¥` は内部的には 2 バイトを使用しますが、マッチングでは 1 つのコードポイントとして扱われます。 正規表現に NULL バイトを含めることはできません。 haystack または pattern が有効な UTF-8 でない場合の動作は未定義です。 RE2 のデフォルトの動作とは異なり、`.` は改行にも一致します。これを無効にするには、パターンの先頭に `(?-s)` を付けてください。 このパターンはアンカーされません。文字列全体に一致させるには、`^` と `$` を使って自分でパターンをアンカーしてください。 単に部分文字列を検索したいだけであれば、代わりに [`like`](#like) または [`position`](#position) 関数を使用できます。これらはこの関数よりも大幅に高速です。 代替の演算子構文: `haystack REGEXP pattern`。 **構文** ```sql theme={null} match(haystack, pattern) ``` **別名**: `REGEXP_MATCHES` **引数** * `haystack` — パターンを検索する対象の文字列。 [`String`](/ja/reference/data-types/string) * `pattern` — 正規表現のパターン。 [`const String`](/ja/reference/data-types/string) **戻り値** パターンに一致する場合は `1`、そうでない場合は `0` を返します。 [`UInt8`](/ja/reference/data-types/int-uint) **例** **基本的なパターン照合** ```sql title=Query theme={null} SELECT match('Hello World', 'Hello.*') ``` ```response title=Response theme={null} ┌─match('Hello World', 'Hello.*')─┐ │ 1 │ └─────────────────────────────────┘ ``` **パターンが一致しない場合** ```sql title=Query theme={null} SELECT match('Hello World', 'goodbye.*') ``` ```response title=Response theme={null} ┌─match('Hello World', 'goodbye.*')─┐ │ 0 │ └───────────────────────────────────┘ ``` **部分文字列との一致** ```sql title=Query theme={null} SELECT match('abcde', 'b.*d'), match('abcde', '^b.*d$') ``` ```response title=Response theme={null} ┌─match('abcde', 'b.*d')─┬─match('abcde', '^b.*d$')─┐ │ 1 │ 0 │ └─────────────────────────┴───────────────────────────┘ ```
## multiFuzzyMatchAllIndices
導入バージョン: v20.1.0 [`multiFuzzyMatchAny`](#multiFuzzyMatchAny) と同様ですが、一定の[編集距離](https://en.wikipedia.org/wiki/Edit_distance)以内で haystack に一致するすべてのインデックスを、順不同の配列として返します。 **構文** ```sql theme={null} multiFuzzyMatchAllIndices(haystack, distance, [pattern1, pattern2, ..., patternN]) ``` **Arguments** * `haystack` — 検索対象の文字列。[`String`](/ja/reference/data-types/string) * `distance` — あいまい一致 の最大編集距離。[`UInt8`](/ja/reference/data-types/int-uint) * `pattern` — 照合する パターン の Array。[`Array(String)`](/ja/reference/data-types/array) **戻り値** 指定した編集距離以内で、任意の順序で haystack に一致するすべてのインデックス (1 から始まる) の配列を返します。一致するものが見つからない場合は空の配列を返します。[`Array(UInt64)`](/ja/reference/data-types/array) **Examples** **Usage example** ```sql title=Query theme={null} SELECT multiFuzzyMatchAllIndices('ClickHouse', 2, ['ClickHouse', 'ClckHouse', 'ClickHose', 'House']); ``` ```response title=Response theme={null} ┌─multiFuzzyMa⋯, 'House'])─┐ │ [3,1,4,2] │ └──────────────────────────┘ ```
## multiFuzzyMatchAny
導入バージョン: v20.1.0 [`multiMatchAny`](#multiMatchAny) と同様ですが、一定の[編集距離](https://en.wikipedia.org/wiki/Edit_distance)内で、いずれかのパターンが対象文字列に一致した場合に 1 を返します。 この関数は [hyperscan](https://intel.github.io/hyperscan/dev-reference/compilation.html#approximate-matching) ライブラリの実験的機能に依存しているため、一部のエッジケースでは低速になることがあります。 パフォーマンスは編集距離の値や使用するパターンに依存しますが、非あいまい一致のバリアントと比べると常にコストが高くなります。 hyperscan の制約により、`multiFuzzyMatch*()` 関数ファミリーは UTF-8 正規表現をサポートしていません (UTF-8 正規表現はバイト列として扱われます) 。 **構文** ```sql theme={null} multiFuzzyMatchAny(haystack, distance, [pattern1, pattern2, ..., patternN]) ``` **引数** * `haystack` — 検索対象の文字列。[`String`](/ja/reference/data-types/string) * `distance` — あいまい一致における最大編集距離。[`UInt8`](/ja/reference/data-types/int-uint) * `pattern` — 省略可能。一致対象とするパターンの配列。[`Array(String)`](/ja/reference/data-types/array) **戻り値** 指定した編集距離以内でいずれかのパターンが `haystack` に一致する場合は `1`、それ以外の場合は `0` を返します。[`UInt8`](/ja/reference/data-types/int-uint) **例** **使用例** ```sql title=Query theme={null} SELECT multiFuzzyMatchAny('ClickHouse', 2, ['ClickHouse', 'ClckHouse', 'ClickHose']); ``` ```response title=Response theme={null} ┌─multiFuzzyMa⋯lickHose'])─┐ │ 1 │ └──────────────────────────┘ ```
## multiFuzzyMatchAnyIndex
導入バージョン: v20.1.0 [`multiFuzzyMatchAny`](#multiFuzzyMatchAny) と同様ですが、一定の[編集距離](https://en.wikipedia.org/wiki/Edit_distance)内で検索対象文字列に一致する任意のインデックスを返します。 **構文** ```sql theme={null} multiFuzzyMatchAnyIndex(haystack, distance, [pattern1, pattern2, ..., patternn]) ``` **引数** * `haystack` — 検索対象の String。[`String`](/ja/reference/data-types/string) * `distance` — あいまい一致で許容される最大編集距離。[`UInt8`](/ja/reference/data-types/int-uint) * `pattern` — 照合するパターンの Array。[`Array(String)`](/ja/reference/data-types/array) **戻り値** 指定した編集距離以内で `haystack` に一致するパターンのいずれかの索引 (1 から始まる) を返します。一致するものがない場合は `0` を返します。[`UInt64`](/ja/reference/data-types/int-uint) **例** **使用例** ```sql title=Query theme={null} SELECT multiFuzzyMatchAnyIndex('ClickHouse', 2, ['ClckHouse', 'ClickHose', 'ClickHouse']); ``` ```response title=Response theme={null} ┌─multiFuzzyMa⋯ickHouse'])─┐ │ 2 │ └──────────────────────────┘ ```
## multiMatchAllIndices
導入バージョン: v20.1.0 [`multiMatchAny`](#multiMatchAny) と同様ですが、検索対象文字列に一致したすべてのインデックスを、順不同の配列で返します。 **構文** ```sql theme={null} multiMatchAllIndices(haystack, [pattern1, pattern2, ..., patternn]) ``` **引数** * `haystack` — 検索対象の文字列。[`String`](/ja/reference/data-types/string) * `pattern` — 一致に使用する正規表現。[`String`](/ja/reference/data-types/string) **戻り値** haystack に対して任意の順序で一致した、すべてのインデックス (1 から始まる) を格納した配列。一致が見つからない場合は空の配列を返します。[`Array(UInt64)`](/ja/reference/data-types/array) **例** **使用例** ```sql title=Query theme={null} SELECT multiMatchAllIndices('ClickHouse', ['[0-9]', 'House', 'Click', 'ouse']); ``` ```response title=Response theme={null} ┌─multiMatchAl⋯', 'ouse'])─┐ │ [3, 2, 4] │ └──────────────────────────┘ ```
## multiMatchAny
導入バージョン: v20.1.0 複数の正規表現パターンのうち、少なくとも 1 つが haystack に一致するかどうかを確認します。 文字列内で複数の部分文字列だけを検索したい場合は、代わりに関数 [`multiSearchAny`](#multiSearchAny) を使用できます。この関数よりも大幅に高速に動作します。 **構文** ```sql theme={null} multiMatchAny(haystack, pattern1[, pattern2, ...]) ``` **引数** * `haystack` — パターンを検索する対象の文字列です。 [`String`](/ja/reference/data-types/string) * `pattern1[, pattern2, ...]` — 1つ以上の正規表現パターンからなる配列です。 [`Array(String)`](/ja/reference/data-types/array) **戻り値** いずれかのパターンに一致した場合は `1`、それ以外は `0` を返します。 [`UInt8`](/ja/reference/data-types/int-uint) **例** **複数パターンのマッチング** ```sql title=Query theme={null} SELECT multiMatchAny('Hello World', ['Hello.*', 'foo.*']) ``` ```response title=Response theme={null} ┌─multiMatchAny('Hello World', ['Hello.*', 'foo.*'])─┐ │ 1 │ └────────────────────────────────────────────────────┘ ``` **一致するパターンがありません** ```sql title=Query theme={null} SELECT multiMatchAny('Hello World', ['goodbye.*', 'foo.*']) ``` ```response title=Response theme={null} ┌─multiMatchAny('Hello World', ['goodbye.*', 'foo.*'])─┐ │ 0 │ └──────────────────────────────────────────────────────┘ ```
## multiMatchAnyIndex
導入バージョン: v20.1.0 [`multiMatchAny`](#multiMatchAny) と同様ですが、haystack に一致する任意の索引を返します。 **構文** ```sql theme={null} multiMatchAnyIndex(haystack, [pattern1, pattern2, ..., patternn]) ``` **引数** * `haystack` — 検索対象の文字列です。[`String`](/ja/reference/data-types/string) * `pattern` — 照合する正規表現の配列です。[`Array(String)`](/ja/reference/data-types/array) **戻り値** 最初に一致したパターンのインデックス (1 から始まる) を返します。どのパターンにも一致しない場合は 0 を返します。[`UInt64`](/ja/reference/data-types/int-uint) **例** **使用例** ```sql title=Query theme={null} SELECT multiMatchAnyIndex('ClickHouse', ['[0-9]', 'House', 'Click']); ``` ```response title=Response theme={null} ┌─multiMatchAn⋯, 'Click'])─┐ │ 3 │ └──────────────────────────┘ ```
## multiSearchAllPositions
導入バージョン: v20.1.0 [`position`](#position) と同様ですが、`haystack` 文字列内の複数の `needle` 部分文字列それぞれの位置 (バイト単位、1 から開始) を配列で返します。 すべての `multiSearch*()` 関数でサポートされる `needle` の数は最大 2^8 個です。 **構文** ```sql theme={null} multiSearchAllPositions(haystack, needle1[, needle2, ...]) ``` **引数** * `haystack` — 検索対象のString。[`String`](/ja/reference/data-types/string) * `needle1[, needle2, ...]` — 検索する1つ以上の部分文字列の配列。[`Array(String)`](/ja/reference/data-types/array) **戻り値** 各部分文字列について、見つかった場合は 1 から始まるバイト単位の開始位置を、見つからなかった場合は `0` を要素とする配列を返します。[`Array(UInt64)`](/ja/reference/data-types/array) **例** **複数の needle の検索** ```sql title=Query theme={null} SELECT multiSearchAllPositions('Hello, World!', ['hello', '!', 'world']) ``` ```response title=Response theme={null} ┌─multiSearchAllPositions('Hello, World!', ['hello', '!', 'world'])─┐ │ [0,13,0] │ └───────────────────────────────────────────────────────────────────┘ ```
## multiSearchAllPositionsCaseInsensitive
導入バージョン: v20.1.0 [`multiSearchAllPositions`](#multiSearchAllPositions) と同様ですが、大文字と小文字を区別せずに検索します。 **構文** ```sql theme={null} multiSearchAllPositionsCaseInsensitive(haystack, needle1[, needle2, ...]) ``` **引数** * `haystack` — 検索対象の文字列。[`String`](/ja/reference/data-types/string) * `needle1[, needle2, ...]` — 検索する 1 つ以上の部分文字列の配列。[`Array(String)`](/ja/reference/data-types/array) **戻り値** 各部分文字列について、見つかった場合は開始位置をバイト単位の 1 始まりで、見つからなかった場合は `0` とする配列を返します。[`Array(UInt64)`](/ja/reference/data-types/array) **例** **大文字と小文字を区別しない複数検索** ```sql title=Query theme={null} SELECT multiSearchAllPositionsCaseInsensitive('ClickHouse',['c','h']) ``` ```response title=Response theme={null} ┌─multiSearchA⋯['c', 'h'])─┐ │ [1,6] │ └──────────────────────────┘ ```
## multiSearchAllPositionsCaseInsensitiveUTF8
導入バージョン: v20.1.0 [`multiSearchAllPositionsUTF8`](#multiSearchAllPositionsUTF8) と同様ですが、大文字と小文字を区別しません。 **構文** ```sql theme={null} multiSearchAllPositionsCaseInsensitiveUTF8(haystack, [needle1, needle2, ..., needleN]) ``` **引数** * `haystack` — 検索対象の UTF-8 でエンコードされた文字列。[`String`](/ja/reference/data-types/string) * `needle` — 検索する UTF-8 でエンコードされた部分文字列の配列。[`Array(String)`](/ja/reference/data-types/array) **戻り値** 開始位置をバイト単位の 1 始まりで格納した配列を返します (部分文字列が見つかった場合) 。見つからなかった場合は 0 を返します。[`Array`](/ja/reference/data-types/array) **例** **大文字と小文字を区別しない UTF-8 検索** ```sql title=Query theme={null} SELECT multiSearchAllPositionsCaseInsensitiveUTF8('Здравствуй, мир!', ['здравствуй', 'МИР']); ``` ```response title=Response theme={null} ┌─multiSearchA⋯й', 'МИР'])─┐ │ [1, 13] │ └──────────────────────────┘ ```
## multiSearchAllPositionsUTF8
導入バージョン: v20.1.0 [`multiSearchAllPositions`](#multiSearchAllPositions) と同様ですが、`haystack` と `needle` の部分文字列は UTF-8 でエンコードされた文字列であることを前提とします。 **構文** ```sql theme={null} multiSearchAllPositionsUTF8(haystack, needle1[, needle2, ...]) ``` **引数** * `haystack` — 検索対象の UTF-8 でエンコードされた文字列。[`String`](/ja/reference/data-types/string) * `needle1[, needle2, ...]` — 検索する UTF-8 でエンコードされた部分文字列の配列。[`Array(String)`](/ja/reference/data-types/array) **戻り値** 部分文字列ごとに、見つかった場合は先頭から 1 始まりで数えた開始位置 (バイト単位) を、見つからなかった場合は `0` を格納した配列を返します。[`Array`](/ja/reference/data-types/array) **例** **UTF-8 マルチサーチ** ```sql title=Query theme={null} SELECT multiSearchAllPositionsUTF8('ClickHouse',['C','H']) ``` ```response title=Response theme={null} ┌─multiSearchAllPositionsUTF8('ClickHouse', ['C', 'H'])─┐ │ [1,6] │ └───────────────────────────────────────────────────────┘ ```
## multiSearchAny
導入バージョン: v20.1.0 複数の needle 文字列のうち、少なくとも 1 つが haystack 文字列にマッチするかどうかを確認します。 関数 [`multiSearchAnyCaseInsensitive`](#multiSearchAnyCaseInsensitive)、[`multiSearchAnyUTF8`](#multiSearchAnyUTF8)、および [`multiSearchAnyCaseInsensitiveUTF8`](#multiSearchAnyCaseInsensitiveUTF8) は、この関数の大文字と小文字を区別しないバリアント、UTF-8 バリアント、またはその両方を提供します。 **構文** ```sql theme={null} multiSearchAny(haystack, needle1[, needle2, ...]) ``` **引数** * `haystack` — 検索対象の文字列。[`String`](/ja/reference/data-types/string) * `needle1[, needle2, ...]` — 検索する部分文字列の配列。[`Array(String)`](/ja/reference/data-types/array) **戻り値** 1 件以上一致した場合は `1`、一致しなかった場合は `0` を返します。[`UInt8`](/ja/reference/data-types/int-uint) **例** **いずれかに一致する検索** ```sql title=Query theme={null} SELECT multiSearchAny('ClickHouse',['C','H']) ``` ```response title=Response theme={null} ┌─multiSearchAny('ClickHouse', ['C', 'H'])─┐ │ 1 │ └──────────────────────────────────────────┘ ```
## multiSearchAnyCaseInsensitive
導入バージョン: v20.1.0 [multiSearchAny](#multiSearchAny) と同様ですが、英字の大文字と小文字を区別しません。 **構文** ```sql theme={null} multiSearchAnyCaseInsensitive(haystack, [needle1, needle2, ..., needleN]) ``` **引数** * `haystack` — 検索対象の文字列。[`String`](/ja/reference/data-types/string) * `needle` — 検索する部分文字列。[`Array(String)`](/ja/reference/data-types/array) **戻り値** 大文字と小文字を区別しない一致が 1 つ以上ある場合は `1`、ない場合は `0` を返します。[`UInt8`](/ja/reference/data-types/int-uint) **例** **大文字と小文字を区別しない検索** ```sql title=Query theme={null} SELECT multiSearchAnyCaseInsensitive('ClickHouse',['c','h']) ``` ```response title=Response theme={null} ┌─multiSearchAnyCaseInsensitive('ClickHouse', ['c', 'h'])─┐ │ 1 │ └─────────────────────────────────────────────────────────┘ ```
## multiSearchAnyCaseInsensitiveUTF8
導入バージョン: v20.1.0 [multiSearchAnyUTF8](#multiSearchAnyUTF8) と同様ですが、大文字と小文字を区別せずに検索します。 **構文** ```sql theme={null} multiSearchAnyCaseInsensitiveUTF8(haystack, [needle1, needle2, ..., needleN]) ``` **引数** * `haystack` — 検索対象のUTF-8文字列。 [`String`](/ja/reference/data-types/string) * `needle` — 検索するUTF-8部分文字列。 [`Array(String)`](/ja/reference/data-types/array) **戻り値** 大文字と小文字を区別しない一致が少なくとも1つある場合は `1`、ない場合は `0` を返します。 [`UInt8`](/ja/reference/data-types/int-uint) **例** **UTF-8文字列 'Здравствуйте' に文字 'з' (小文字) が含まれているかを確認する** ```sql title=Query theme={null} SELECT multiSearchAnyCaseInsensitiveUTF8('Здравствуйте',['з']) ``` ```response title=Response theme={null} ┌─multiSearchA⋯те', ['з'])─┐ │ 1 │ └──────────────────────────┘ ```
## multiSearchAnyUTF8
導入バージョン: v20.1.0 `haystack` と `needle` の部分文字列が UTF-8 でエンコードされた文字列であることを前提としている点を除き、[multiSearchAny](#multiSearchAny) と同じです。 **構文** ```sql theme={null} multiSearchAnyUTF8(haystack, [needle1, needle2, ..., needleN]) ``` **引数** * `haystack` — 検索対象のUTF-8文字列。 [`String`](/ja/reference/data-types/string) * `needle` — 検索するUTF-8部分文字列。 [`Array(String)`](/ja/reference/data-types/array) **戻り値** 少なくとも1件一致した場合は `1` を返し、一致しなかった場合は `0` を返します。 [`UInt8`](/ja/reference/data-types/int-uint) **例** **UTF-8文字列 '你好，世界' ('Hello, world') について、文字列内に 你 または 界 が含まれているかを確認する例** ```sql title=Query theme={null} SELECT multiSearchAnyUTF8('你好，世界', ['你', '界']) ``` ```response title=Response theme={null} ┌─multiSearchA⋯你', '界'])─┐ │ 1 │ └──────────────────────────┘ ```
## multiSearchFirstIndex
導入バージョン: v20.1.0 haystack 文字列内で複数の needle 文字列を検索し (大文字と小文字を区別) 、最初に見つかった needle の 1 から始まる位置を返します。 **構文** ```sql theme={null} multiSearchFirstIndex(haystack, [needle1, needle2, ..., needleN]) ``` **引数** * `haystack` — 検索対象の文字列。[`String`](/ja/reference/data-types/string) * `needles` — 検索する文字列の配列。[`Array(String)`](/ja/reference/data-types/array) **戻り値** haystack 内で最初に見つかった needle について、needles 配列内での 1 始まりの索引 (位置) を返します。needle が 1 つも見つからない場合は 0 を返します。検索では大文字と小文字を区別します。[`UInt64`](/ja/reference/data-types/int-uint) **例** **使用例** ```sql title=Query theme={null} SELECT multiSearchFirstIndex('ClickHouse Database', ['Click', 'Database', 'Server']); ``` ```response title=Response theme={null} ┌─multiSearchF⋯ 'Server'])─┐ │ 1 │ └──────────────────────────┘ ``` **大文字と小文字を区別する挙動** ```sql title=Query theme={null} SELECT multiSearchFirstIndex('ClickHouse Database', ['CLICK', 'Database', 'Server']); ``` ```response title=Response theme={null} ┌─multiSearchF⋯ 'Server'])─┐ │ 2 │ └──────────────────────────┘ ``` **一致する索引が見つかりません** ```sql title=Query theme={null} SELECT multiSearchFirstIndex('Hello World', ['goodbye', 'test']); ``` ```response title=Response theme={null} ┌─multiSearchF⋯', 'test'])─┐ │ 0 │ └──────────────────────────┘ ```
## multiSearchFirstIndexCaseInsensitive
導入バージョン: v20.1.0 文字列 `haystack` 内で最も左側で見つかった needle\_i のインデックス `i` (1始まり) を返し、見つからない場合は 0 を返します。 大文字と小文字を区別しません。 **構文** ```sql theme={null} multiSearchFirstIndexCaseInsensitive(haystack, [needle1, needle2, ..., needleN] ``` **引数** * `haystack` — 検索対象の文字列です。[`String`](/ja/reference/data-types/string) * `needle` — 検索する部分文字列の配列です。[`Array(String)`](/ja/reference/data-types/array) **戻り値** 最も左にある、一致した `needle` の索引 (1 から始まる) を返します。一致しない場合は `0` を返します。[`UInt8`](/ja/reference/data-types/int-uint) **例** **使用例** ```sql title=Query theme={null} SELECT multiSearchFirstIndexCaseInsensitive('hElLo WoRlD', ['World', 'Hello']); ``` ```response title=Response theme={null} ┌─multiSearchF⋯, 'Hello'])─┐ │ 1 │ └──────────────────────────┘ ```
## multiSearchFirstIndexCaseInsensitiveUTF8
導入バージョン: v20.1.0 UTF-8 エンコーディングをサポートし、大文字と小文字を区別せずに haystack 文字列内の複数の needle 文字列を検索し、最初に見つかった needle の 1 始まりの索引を返します。 **構文** ```sql theme={null} multiSearchFirstIndexCaseInsensitiveUTF8(haystack, [needle1, needle2, ..., needleN]) ``` **引数** * `haystack` — 検索対象の文字列です。[`String`](/ja/reference/data-types/string) * `needles` — 検索する文字列の Array です。[`Array(String)`](/ja/reference/data-types/array) **戻り値** haystack 内で最初に見つかった needle の 1 始まりの索引 (needles 配列内の位置) を返します。needle が 1 つも見つからない場合は 0 を返します。検索では大文字と小文字を区別せず、UTF-8 文字エンコーディングを考慮します。[`UInt64`](/ja/reference/data-types/int-uint) **例** **使用例** ```sql title=Query theme={null} SELECT multiSearchFirstIndexCaseInsensitiveUTF8('ClickHouse Database', ['CLICK', 'data', 'server']); ``` ```response title=Response theme={null} ┌─multiSearchF⋯ 'server'])─┐ │ 1 │ └──────────────────────────┘ ``` **UTF-8の大文字・小文字の扱い** ```sql title=Query theme={null} SELECT multiSearchFirstIndexCaseInsensitiveUTF8('Привет Мир', ['мир', 'ПРИВЕТ']); ``` ```response title=Response theme={null} ┌─multiSearchF⋯ 'ПРИВЕТ'])─┐ │ 1 │ └──────────────────────────┘ ``` **一致する索引が見つかりません** ```sql title=Query theme={null} SELECT multiSearchFirstIndexCaseInsensitiveUTF8('Hello World', ['goodbye', 'test']); ``` ```response title=Response theme={null} ┌─multiSearchF⋯', 'test'])─┐ │ 0 │ └──────────────────────────┘ ```
## multiSearchFirstIndexUTF8
導入バージョン: v20.1.0 文字列 `haystack` 内で最も左側に見つかった needle\_i の索引 `i` (1 から始まる) を返し、見つからない場合は 0 を返します。 `haystack` と `needle` は UTF-8 でエンコードされた文字列であることを前提とします。 **構文** ```sql theme={null} multiSearchFirstIndexUTF8(haystack, [needle1, needle2, ..., needleN]) ``` **引数** * `haystack` — 検索対象の UTF-8 文字列です。[`String`](/ja/reference/data-types/string) * `needle` — 検索する UTF-8 部分文字列の Array です。[`Array(String)`](/ja/reference/data-types/array) **戻り値** 見つかった最も左にある needle の索引 (1 から始まります) を返します。一致するものがない場合は 0 を返します。[`UInt8`](/ja/reference/data-types/int-uint) **例** **使用例** ```sql title=Query theme={null} SELECT multiSearchFirstIndexUTF8('Здравствуйте мир', ['мир', 'здравствуйте']); ``` ```response title=Response theme={null} ┌─multiSearchF⋯вствуйте'])─┐ │ 1 │ └──────────────────────────┘ ```
## multiSearchFirstPosition
導入バージョン: v20.1.0 [`position`](#position) と同様ですが、複数の `needle` 文字列のいずれかに一致する `haystack` 文字列内の最も左のオフセットを返します。 関数 [`multiSearchFirstPositionCaseInsensitive`](#multiSearchFirstPositionCaseInsensitive)、[`multiSearchFirstPositionUTF8`](#multiSearchFirstPositionUTF8)、[`multiSearchFirstPositionCaseInsensitiveUTF8`](#multiSearchFirstPositionCaseInsensitiveUTF8) は、この関数の大文字と小文字を区別しない版、UTF-8 版、またはその両方を提供します。 **構文** ```sql theme={null} multiSearchFirstPosition(haystack, needle1[, needle2, ...]) ``` **引数** * `haystack` — 検索対象の文字列です。[`String`](/ja/reference/data-types/string) * `needle1[, needle2, ...]` — 検索する1つ以上の部分文字列の配列です。[`Array(String)`](/ja/reference/data-types/array) **戻り値** 複数の `needle` 文字列のいずれかに一致する、`haystack` 文字列内の最も左のオフセットを返します。一致しない場合は `0` を返します。[`UInt64`](/ja/reference/data-types/int-uint) **例** **最初の位置を検索** ```sql title=Query theme={null} SELECT multiSearchFirstPosition('Hello World',['llo', 'Wor', 'ld']) ``` ```response title=Response theme={null} ┌─multiSearchFirstPosition('Hello World', ['llo', 'Wor', 'ld'])─┐ │ 3 │ └───────────────────────────────────────────────────────────────┘ ```
## multiSearchFirstPositionCaseInsensitive
導入バージョン: v20.1.0 [multiSearchFirstPosition](#multiSearchFirstPosition) と同様ですが、大文字と小文字を区別しません。 **構文** ```sql theme={null} multiSearchFirstPositionCaseInsensitive(haystack, [needle1, needle2, ..., needleN]) ``` **引数** * `haystack` — 検索対象の文字列。[`String`](/ja/reference/data-types/string) * `needle` — 検索する部分文字列の Array。[`Array(String)`](/ja/reference/data-types/array) **戻り値** 複数の `needle` 文字列のいずれかに一致する `haystack` 文字列内の最も左のオフセットを返します。一致しない場合は `0` を返します。[`UInt64`](/ja/reference/data-types/int-uint) **例** **大文字と小文字を区別しない最初の位置** ```sql title=Query theme={null} SELECT multiSearchFirstPositionCaseInsensitive('HELLO WORLD',['wor', 'ld', 'ello']) ``` ```response title=Response theme={null} ┌─multiSearchFirstPositionCaseInsensitive('HELLO WORLD', ['wor', 'ld', 'ello'])─┐ │ 2 │ └───────────────────────────────────────────────────────────────────────────────┘ ```
## multiSearchFirstPositionCaseInsensitiveUTF8
導入バージョン: v20.1.0 [multiSearchFirstPosition](#multiSearchFirstPosition) と同様ですが、`haystack` と `needle` を UTF-8 文字列として扱い、大文字と小文字を区別しません。 **構文** ```sql theme={null} multiSearchFirstPositionCaseInsensitiveUTF8(haystack, [needle1, needle2, ..., needleN]) ``` **引数** * `haystack` — 検索対象の UTF-8 文字列。[`String`](/ja/reference/data-types/string) * `needle` — 検索する UTF-8 部分文字列の Array。[`Array(String)`](/ja/reference/data-types/array) **戻り値** 大文字と小文字を区別せず、複数の `needle` 文字列のいずれかに一致する `haystack` 文字列内の最も左のオフセットを返します。一致しない場合は `0` を返します。[`UInt64`](/ja/reference/data-types/int-uint) **例** **指定したいずれかの needle に一致する UTF-8 文字列 'Здравствуй, мир' ('Hello, world') 内の最も左のオフセットを見つけます** ```sql title=Query theme={null} SELECT multiSearchFirstPositionCaseInsensitiveUTF8('Здравствуй, мир', ['МИР', 'вст', 'Здра']) ``` ```response title=Response theme={null} ┌─multiSearchFirstPositionCaseInsensitiveUTF8('Здравствуй, мир', ['мир', 'вст', 'Здра'])─┐ │ 3 │ └────────────────────────────────────────────────────────────────────────────────────────┘ ```
## multiSearchFirstPositionUTF8
導入バージョン: v20.1.0 [multiSearchFirstPosition](#multiSearchFirstPosition) と同様ですが、`haystack` と `needle` は UTF-8 文字列であることを前提としています。 **構文** ```sql theme={null} multiSearchFirstPositionUTF8(haystack, [needle1, needle2, ..., needleN]) ``` **引数** * `haystack` — 検索対象の UTF-8 文字列。[`String`](/ja/reference/data-types/string) * `needle` — 検索する UTF-8 部分文字列の Array。[`Array(String)`](/ja/reference/data-types/array) **戻り値** 複数の `needle` 文字列のいずれかに一致する、`haystack` 文字列内の最も左側のオフセット。一致しない場合は `0` を返します。[`UInt64`](/ja/reference/data-types/int-uint) **例** **指定したいずれかの needle に一致する UTF-8 文字列 'Здравствуй, мир' ('Hello, world') 内の最も左側のオフセットを求めます** ```sql title=Query theme={null} SELECT multiSearchFirstPositionUTF8('Здравствуй, мир',['мир', 'вст', 'авст']) ``` ```response title=Response theme={null} ┌─multiSearchFirstPositionUTF8('Здравствуй, мир', ['мир', 'вст', 'авст'])─┐ │ 3 │ └─────────────────────────────────────────────────────────────────────────┘ ```
## ngramDistance
導入バージョン: v20.1.0 2つの文字列間の4-gram距離を計算します。 この距離は、2つの4-gramマルチセットの対称差を求め、その値をそれぞれの要素数の合計で正規化して算出します。 戻り値が小さいほど、文字列同士の類似度は高くなります。 大文字と小文字を区別しない検索や、UTF8 フォーマットで使用する場合は、[`ngramDistanceCaseInsensitive`](#ngramDistanceCaseInsensitive)、[`ngramDistanceUTF8`](#ngramDistanceUTF8)、[`ngramDistanceCaseInsensitiveUTF8`](#ngramDistanceCaseInsensitiveUTF8) 関数を使用してください。 **構文** ```sql theme={null} ngramDistance(haystack, needle) ``` **引数** * `haystack` — 比較する文字列。[`String`](/ja/reference/data-types/string) * `needle` — 比較する文字列。[`String`](/ja/reference/data-types/string) **戻り値** `0` から `1` までの Float32 の数値を返します。戻り値が小さいほど、文字列の類似度は高くなります。[`Float32`](/ja/reference/data-types/float) **例** **4-gram 距離を計算** ```sql title=Query theme={null} SELECT ngramDistance('ClickHouse', 'ClickHouses') ``` ```response title=Response theme={null} ┌─ngramDistance('ClickHouse', 'ClickHouses')─┐ │ 0.1 │ └────────────────────────────────────────────┘ ```
## ngramDistanceCaseInsensitive
導入バージョン: v20.1.0 [`ngramDistance`](#ngramDistance) の大文字と小文字を区別しないバリアントです。 大文字と小文字を無視して、2つの文字列間の 4-gram 距離を計算します。 戻り値が小さいほど、文字列同士の類似度は高くなります。 **構文** ```sql theme={null} ngramDistanceCaseInsensitive(haystack, needle) ``` **引数** * `haystack` — 1 つ目の比較文字列。[`String`](/ja/reference/data-types/string) * `needle` — 2 つ目の比較文字列。[`String`](/ja/reference/data-types/string) **戻り値** `0` から `1` までの `Float32` 型の数値を返します。[`Float32`](/ja/reference/data-types/float) **例** **大文字と小文字を区別しない 4-gram 距離** ```sql title=Query theme={null} SELECT ngramDistanceCaseInsensitive('ClickHouse','clickhouse') ``` ```response title=Response theme={null} ┌─ngramDistanceCaseInsensitive('ClickHouse','clickhouse')─┐ │ 0 │ └─────────────────────────────────────────────────────────┘ ```
## ngramDistanceCaseInsensitiveUTF8
導入バージョン: v20.1.0 [`ngramDistance`](#ngramDistance) の、UTF-8 に対応した大文字と小文字を区別しないバリアントです。 `needle` および `haystack` は UTF-8 でエンコードされた文字列であることを前提とし、大文字と小文字は区別されません。 大文字と小文字を区別せずに、2 つの UTF-8 文字列間の 3-gram 距離を計算します。 戻り値が小さいほど、文字列同士の類似度は高くなります。 **構文** ```sql theme={null} ngramDistanceCaseInsensitiveUTF8(haystack, needle) ``` **引数** * `haystack` — 1つ目の UTF-8 でエンコードされた比較対象文字列。[`String`](/ja/reference/data-types/string) * `needle` — 2つ目の UTF-8 でエンコードされた比較対象文字列。[`String`](/ja/reference/data-types/string) **戻り値** `0` から `1` までの Float32 値を返します。[`Float32`](/ja/reference/data-types/float) **例** **UTF-8 の大文字と小文字を区別しない 3-gram 距離** ```sql title=Query theme={null} SELECT ngramDistanceCaseInsensitiveUTF8('abcde','CDE') ``` ```response title=Response theme={null} ┌─ngramDistanceCaseInsensitiveUTF8('abcde','CDE')─┐ │ 0.5 │ └─────────────────────────────────────────────────┘ ```
## ngramDistanceUTF8
導入バージョン: v20.1.0 [`ngramDistance`](#ngramDistance) の UTF-8 版です。 `needle` と `haystack` は、UTF-8 でエンコードされた文字列であることを前提としています。 2 つの UTF-8 文字列間の 3-gram 距離を計算します。 戻り値が小さいほど、文字列の類似度は高くなります。 **構文** ```sql theme={null} ngramDistanceUTF8(haystack, needle) ``` **引数** * `haystack` — 1 つ目の UTF-8 でエンコードされた比較対象文字列。[`String`](/ja/reference/data-types/string) * `needle` — 2 つ目の UTF-8 でエンコードされた比較対象文字列。[`String`](/ja/reference/data-types/string) **戻り値** `0` から `1` の範囲の `Float32` 型の数値を返します。[`Float32`](/ja/reference/data-types/float) **例** **UTF-8 3-gram距離** ```sql title=Query theme={null} SELECT ngramDistanceUTF8('abcde','cde') ``` ```response title=Response theme={null} ┌─ngramDistanceUTF8('abcde','cde')─┐ │ 0.5 │ └───────────────────────────────────┘ ```
## ngramSearch
導入バージョン: v20.1.0 2 つの文字列間の 4-gram 距離が、指定した閾値以下かどうかを判定します。 大文字と小文字を区別しない検索や、UTF8 フォーマットで使用する場合は、関数 `ngramSearchCaseInsensitive`、`ngramSearchUTF8`、`ngramSearchCaseInsensitiveUTF8` を使用してください。 **構文** ```sql theme={null} ngramSearch(haystack, needle) ``` **引数** * `haystack` — 比較対象の文字列。[`String`](/ja/reference/data-types/string) * `needle` — 比較対象の文字列。[`String`](/ja/reference/data-types/string) **戻り値** 文字列間の4-gram距離がしきい値 (デフォルトは`1.0`) 以下の場合は`1`、それ以外の場合は`0`を返します。[`UInt8`](/ja/reference/data-types/int-uint) **例** **4-gramによる検索** ```sql title=Query theme={null} SELECT ngramSearch('ClickHouse', 'Click') ``` ```response title=Response theme={null} ┌─ngramSearch('ClickHouse', 'Click')─┐ │ 1 │ └────────────────────────────────────┘ ```
## ngramSearchCaseInsensitive
導入バージョン: v20.1.0 [`ngramSearch`](#ngramSearch) の大文字と小文字を区別しないバリアントを提供します。 needle 文字列と haystack 文字列の非対称差、つまり needle の N-gram 数から、共通する N-gram 数を needle の N-gram 数で正規化した値を差し引いた数を計算します。 2 つの文字列間の 4-gram 距離が、指定した閾値以下かどうかを、大文字と小文字を区別せずに判定します。 **構文** ```sql theme={null} ngramSearchCaseInsensitive(haystack, needle) ``` **引数** * `haystack` — 比較する文字列。[`String`](/ja/reference/data-types/string) * `needle` — 比較する文字列。[`String`](/ja/reference/data-types/string) **戻り値** 文字列間の 4-gram 距離がしきい値 (デフォルトは `1.0`) 以下の場合は `1` を返し、それ以外の場合は `0` を返します。[`UInt8`](/ja/reference/data-types/int-uint) **例** **4-gram を使用した大文字と小文字を区別しない検索** ```sql title=Query theme={null} SELECT ngramSearchCaseInsensitive('Hello World','hello') ``` ```response title=Response theme={null} ┌─ngramSearchCaseInsensitive('Hello World','hello')─┐ │ 1 │ └────────────────────────────────────────────────────┘ ```
## ngramSearchCaseInsensitiveUTF8
導入バージョン: v20.1.0 [`ngramSearch`](#ngramSearch) の、大文字と小文字を区別しない UTF-8 バリアントです。 `haystack` と `needle` は UTF-8文字列であることを前提とし、大文字と小文字を区別せずに処理します。 2 つの UTF-8文字列間の 3-gram 距離が、指定したしきい値以下かどうかを、大文字と小文字を区別せずに判定します。 **構文** ```sql theme={null} ngramSearchCaseInsensitiveUTF8(haystack, needle) ``` **引数** * `haystack` — 比較用の UTF-8 文字列。[`String`](/ja/reference/data-types/string) * `needle` — 比較用の UTF-8 文字列。[`String`](/ja/reference/data-types/string) **戻り値** 文字列間の 3-gram 距離がしきい値 (デフォルトは `1.0`) 以下の場合は `1`、それ以外の場合は `0` を返します。[`UInt8`](/ja/reference/data-types/int-uint) **例** **3-gram を使用した大文字・小文字を区別しない UTF-8 検索** ```sql title=Query theme={null} SELECT ngramSearchCaseInsensitiveUTF8('абвГДЕёжз', 'АбвгдЕЁжз') ``` ```response title=Response theme={null} ┌─ngramSearchCaseInsensitiveUTF8('абвГДЕёжз', 'АбвгдЕЁжз')─┐ │ 1 │ └──────────────────────────────────────────────────────────┘ ```
## ngramSearchUTF8
導入バージョン: v20.1.0 `ngramSearch` の UTF-8 対応版です。 `haystack` と `needle` は UTF-8 文字列であることを前提とします。 2 つの UTF-8 文字列間の 3-gram 距離が、指定されたしきい値以下かどうかを判定します。 **構文** ```sql theme={null} ngramSearchUTF8(haystack, needle) ``` **引数** * `haystack` — 比較対象のUTF-8文字列。[`String`](/ja/reference/data-types/string) * `needle` — 比較対象のUTF-8文字列。[`String`](/ja/reference/data-types/string) **戻り値** 文字列間の3-gram距離がしきい値 (デフォルトは `1.0`) 以下の場合は `1`、それ以外の場合は `0` を返します。[`UInt8`](/ja/reference/data-types/int-uint) **例** **3-gramを使ったUTF-8検索** ```sql title=Query theme={null} SELECT ngramSearchUTF8('абвгдеёжз', 'гдеёзд') ``` ```response title=Response theme={null} ┌─ngramSearchUTF8('абвгдеёжз', 'гдеёзд')─┐ │ 1 │ └────────────────────────────────────────┘ ```
## notILike
導入バージョン: v20.6.0 文字列がパターンに一致しないかどうかを、大文字と小文字を区別せずに判定します。パターンには、SQL の LIKE マッチングで使用する特殊文字 `%` と `_` を含めることができます。 **構文** ```sql theme={null} notILike(haystack, pattern) ``` **引数** * `haystack` — 検索対象の入力文字列です。[`String`](/ja/reference/data-types/string) または [`FixedString`](/ja/reference/data-types/fixedstring) * `pattern` — 照合する SQL の LIKE パターンです。`%` は任意の文字数 (0 文字を含む) に一致し、`_` はちょうど 1 文字に一致します。[`String`](/ja/reference/data-types/string) **戻り値** 文字列がパターンに一致しない場合 (大文字と小文字を区別せずに照合) は `1` を返し、それ以外の場合は `0` を返します。[`UInt8`](/ja/reference/data-types/int-uint) **例** **使用例** ```sql title=Query theme={null} SELECT notILike('ClickHouse', '%house%'); ``` ```response title=Response theme={null} ┌─notILike('Cl⋯ '%house%')─┐ │ 0 │ └──────────────────────────┘ ```
## notLike
導入バージョン: v1.1.0 [`like`](#like) に似ていますが、結果を反転します。 **構文** ```sql theme={null} notLike(haystack, pattern) -- haystack NOT LIKE pattern ``` **引数** * `haystack` — 検索対象の文字列。[`String`](/ja/reference/data-types/string) または [`FixedString`](/ja/reference/data-types/fixedstring) * `pattern` — 照合する `LIKE` パターン。[`String`](/ja/reference/data-types/string) **戻り値** 文字列が `LIKE` パターンに一致しない場合は `1`、一致する場合は `0` を返します。[`UInt8`](/ja/reference/data-types/int-uint) **例** **使用例** ```sql title=Query theme={null} SELECT notLike('ClickHouse', '%House%'); ``` ```response title=Response theme={null} ┌─notLike('Cli⋯ '%House%')─┐ │ 0 │ └──────────────────────────┘ ``` **マッチしないパターン** ```sql title=Query theme={null} SELECT notLike('ClickHouse', '%SQL%'); ``` ```response title=Response theme={null} ┌─notLike('Cli⋯', '%SQL%')─┐ │ 1 │ └──────────────────────────┘ ```
## position
導入バージョン: v1.1.0 文字列 `haystack` 内で部分文字列 `needle` が現れる位置を返します (バイト単位、位置は 1 から始まります) 。 部分文字列 `needle` が空の場合は、次のルールが適用されます。 * `start_pos` が指定されていない場合: `1` を返します * `start_pos = 0` の場合: `1` を返します * `start_pos >= 1` かつ `start_pos <= length(haystack) + 1` の場合: `start_pos` を返します * それ以外の場合: `0` を返します 同じルールは、関数 [`locate`](#locate)、[`positionCaseInsensitive`](#positionCaseInsensitive)、[`positionUTF8`](#positionUTF8)、[`positionCaseInsensitiveUTF8`](#positionCaseInsensitiveUTF8) にも適用されます。 **構文** ```sql theme={null} position(haystack, needle[, start_pos]) ``` **引数** * `haystack` — 検索対象の文字列です。[`String`](/ja/reference/data-types/string) または [`Enum`](/ja/reference/data-types/enum) * `needle` — 検索する部分文字列です。[`String`](/ja/reference/data-types/string) * `start_pos` — `haystack` 内で検索を開始する位置 (1始まり) です。省略可能です。[`UInt`](/ja/reference/data-types/int-uint) **戻り値** 部分文字列が見つかった場合は、1から数えたバイト単位の開始位置を返します。見つからなかった場合は `0` を返します。[`UInt64`](/ja/reference/data-types/int-uint) **例** **基本的な使い方** ```sql title=Query theme={null} SELECT position('Hello, world!', '!') ``` ```response title=Response theme={null} ┌─position('Hello, world!', '!')─┐ │ 13 │ └────────────────────────────────┘ ``` **start\_pos 引数を指定した場合** ```sql title=Query theme={null} SELECT position('Hello, world!', 'o', 1), position('Hello, world!', 'o', 7) ``` ```response title=Response theme={null} ┌─position('Hello, world!', 'o', 1)─┬─position('Hello, world!', 'o', 7)─┐ │ 5 │ 9 │ └───────────────────────────────────┴───────────────────────────────────┘ ``` **needle が haystack 内にある場合の構文** ```sql title=Query theme={null} SELECT 6 = position('/' IN s) FROM (SELECT 'Hello/World' AS s) ``` ```response title=Response theme={null} ┌─equals(6, position(s, '/'))─┐ │ 1 │ └─────────────────────────────┘ ``` **needle 部分文字列が空の場合** ```sql title=Query theme={null} SELECT position('abc', ''), position('abc', '', 0), position('abc', '', 1), position('abc', '', 2), position('abc', '', 3), position('abc', '', 4), position('abc', '', 5) ``` ```response title=Response theme={null} ┌─position('abc', '')─┬─position('abc', '', 0)─┬─position('abc', '', 1)─┬─position('abc', '', 2)─┬─position('abc', '', 3)─┬─position('abc', '', 4)─┬─position('abc', '', 5)─┐ │ 1 │ 1 │ 1 │ 2 │ 3 │ 4 │ 0 │ └─────────────────────┴────────────────────────┴────────────────────────┴────────────────────────┴────────────────────────┴────────────────────────┴────────────────────────┘ ```
## positionCaseInsensitive
導入バージョン: v1.1.0 [`position`](#position) と同様ですが、大文字と小文字を区別せずに処理します。 **構文** ```sql theme={null} positionCaseInsensitive(haystack, needle[, start_pos]) ``` **別名**: `instr` **引数** * `haystack` — 検索対象の文字列。[`String`](/ja/reference/data-types/string) または [`Enum`](/ja/reference/data-types/enum) * `needle` — 検索する部分文字列。[`String`](/ja/reference/data-types/string) * `start_pos` — 省略可能。`haystack` 内で検索を開始する位置 (1 始まり) 。[`UInt*`](/ja/reference/data-types/int-uint) **戻り値** 部分文字列が見つかった場合は、その開始位置をバイト単位で 1 から数えて返します。見つからなかった場合は `0` を返します。[`UInt64`](/ja/reference/data-types/int-uint) **例** **大文字と小文字を区別しない検索** ```sql title=Query theme={null} SELECT positionCaseInsensitive('Hello, world!', 'hello') ``` ```response title=Response theme={null} ┌─positionCaseInsensitive('Hello, world!', 'hello')─┐ │ 1 │ └───────────────────────────────────────────────────┘ ```
## positionCaseInsensitiveUTF8
導入バージョン: v1.1.0 [`positionUTF8`](#positionUTF8) と同様ですが、大文字と小文字を区別せずに検索します。 **構文** ```sql theme={null} positionCaseInsensitiveUTF8(haystack, needle[, start_pos]) ``` **引数** * `haystack` — 検索対象の文字列。[`String`](/ja/reference/data-types/string) または [`Enum`](/ja/reference/data-types/enum) * `needle` — 検索する部分文字列。[`String`](/ja/reference/data-types/string) * `start_pos` — 任意。`haystack` 内で検索を開始する位置 (1始まり) 。[`UInt*`](/ja/reference/data-types/int-uint) **戻り値** 部分文字列が見つかった場合は、その開始位置をバイト単位で 1 から数えて返します。見つからなかった場合は `0` を返します。[`UInt64`](/ja/reference/data-types/int-uint) **例** **UTF-8 の大文字と小文字を区別しない検索** ```sql title=Query theme={null} SELECT positionCaseInsensitiveUTF8('Привет мир', 'МИР') ``` ```response title=Response theme={null} ┌─positionCaseInsensitiveUTF8('Привет мир', 'МИР')─┐ │ 8 │ └──────────────────────────────────────────────────┘ ```
## positionUTF8
導入バージョン: v1.1.0 [`position`](#position) と同様ですが、`haystack` と `needle` は UTF-8 でエンコードされた文字列であることを前提としています。 **構文** ```sql theme={null} positionUTF8(haystack, needle[, start_pos]) ``` **引数** * `haystack` — 検索対象の文字列。[`String`](/ja/reference/data-types/string) または [`Enum`](/ja/reference/data-types/enum) * `needle` — 検索する部分文字列。[`String`](/ja/reference/data-types/string) * `start_pos` — 省略可能。検索を開始する `haystack` 内の位置 (1始まり) 。[`UInt*`](/ja/reference/data-types/int-uint) **戻り値** 部分文字列が見つかった場合は、1から数えたバイト単位の開始位置を返します。見つからなかった場合は `0` を返します。[`UInt64`](/ja/reference/data-types/int-uint) **例** **UTF-8文字数のカウント** ```sql title=Query theme={null} SELECT positionUTF8('Motörhead', 'r') ``` ```response title=Response theme={null} ┌─position('Motörhead', 'r')─┐ │ 5 │ └────────────────────────────┘ ```