メインコンテンツへスキップ
メインコンテンツへスキップ

文字列検索用関数

このセクションのすべての関数は、デフォルトでは大文字小文字を区別して検索します。大文字小文字を区別しない検索は、通常は別の関数バリアントとして提供されます。

注記

大文字小文字を区別しない検索は、英語の小文字・大文字の規則に従います。例えば、英語では小文字の i の大文字は I ですが、トルコ語では İ となります。そのため、英語以外の言語では想定外の結果になる可能性があります。

このセクションの関数は、検索対象の文字列（このセクションでは haystack と呼びます）および検索文字列（このセクションでは needle と呼びます）がシングルバイトエンコードされたテキストであることを前提としています。この前提が 満たされていない場合でも、例外はスローされず、結果は未定義となります。UTF-8 エンコードされた文字列での検索は、通常は別の関数バリアントとして提供されます。同様に、UTF-8 用の関数バリアントを使用し、入力文字列が UTF-8 エンコードされたテキストでない場合も、例外はスローされず、 結果は未定義となります。なお、自動的な Unicode 正規化は行われませんが、そのためには normalizeUTF8*() 関数を使用できます。

一般的な文字列関数 および 文字列置換用関数 は別途説明されています。

注記

以下のドキュメントは、system.functions システムテーブルから生成されています。

countMatches​

導入バージョン: v21.1

文字列内で正規表現にマッチする回数を返します。

Version dependent behavior

この関数の動作は ClickHouse のバージョンに依存します:

  • v25.6 より前のバージョンでは、パターンが空文字列にマッチし得る場合であっても、最初の空マッチが発生した時点でカウントを停止します。
  • v25.6 以降のバージョンでは、空マッチが発生しても処理を継続します。従来の動作は、count_matches_stop_at_empty_match = true の設定を使用して復元できます。

構文

countMatches(haystack, pattern)

引数

  • haystack — 検索対象の文字列。String
  • pattern — 正規表現パターン。String

返される値

見つかった一致の数を返します。UInt64

使用例

数字列をカウントする

SELECT countMatches('hello 123 world 456 test', '[0-9]+')

┌─countMatches('hello 123 world 456 test', '[0-9]+')─┐
│                                                   2 │
└─────────────────────────────────────────────────────┘

countMatchesCaseInsensitive​

導入バージョン: v21.1

countMatches と同様ですが、大文字と小文字を区別せずにマッチングを行います。

構文

countMatchesCaseInsensitive(haystack, pattern)

引数

  • haystack — 検索対象の文字列。String
  • pattern — 正規表現パターン。const String

返り値

見つかった一致件数を返します。UInt64

使用例

大文字小文字を区別しないカウント

SELECT countMatchesCaseInsensitive('Hello HELLO world', 'hello')

┌─countMatchesCaseInsensitive('Hello HELLO world', 'hello')─┐
│                                                         2 │
└───────────────────────────────────────────────────────────┘

countSubstrings​

導入バージョン: v21.1

部分文字列 needle が文字列 haystack の中に何回出現するかの回数を返します。

構文

countSubstrings(haystack, needle[, start_pos])

引数

  • haystack — 検索を行う対象の文字列。String または Enum。 - needle — 検索する部分文字列。String。 - start_pos — 検索を開始する haystack 内の位置（1 始まり）。UInt。省略可能。

戻り値

出現回数。UInt64

例

使用例

SELECT countSubstrings('aaaa', 'aa');

┌─countSubstrings('aaaa', 'aa')─┐
│                             2 │
└───────────────────────────────┘

start_pos 引数を指定する場合

SELECT countSubstrings('abc___abc', 'abc', 4);

┌─countSubstrings('abc___abc', 'abc', 4)─┐
│                                      1 │
└────────────────────────────────────────┘

countSubstringsCaseInsensitive​

導入バージョン: v21.1

countSubstrings と同様ですが、大文字・小文字を区別せずにカウントします。

構文

countSubstringsCaseInsensitive(haystack, needle[, start_pos])

引数

  • haystack — 検索対象となる文字列。String または Enum
  • needle — 検索する部分文字列。String
  • start_pos — 省略可能。検索を開始する haystack 内の位置（1 始まり）。UInt*

戻り値

haystack 内での needle の出現回数を返します。UInt64

例

使用例

SELECT countSubstringsCaseInsensitive('AAAA', 'aa');

┌─countSubstri⋯AAA', 'aa')─┐
│                        2 │
└──────────────────────────┘

start_pos 引数あり

SELECT countSubstringsCaseInsensitive('abc___ABC___abc', 'abc', 4);

┌─countSubstri⋯, 'abc', 4)─┐
│                        2 │
└──────────────────────────┘

countSubstringsCaseInsensitiveUTF8​

導入バージョン: v21.1

countSubstrings と同様ですが、大文字小文字を区別せずにカウントし、haystack が UTF-8 文字列であることを前提とします。

構文

countSubstringsCaseInsensitiveUTF8(haystack, needle[, start_pos])

引数

  • haystack — 検索対象となる UTF-8 文字列。String または Enum
  • needle — 検索する部分文字列。String
  • start_pos — 省略可能。検索を開始する haystack 内の位置（1始まり）。UInt*

戻り値

haystack 内に出現する needle の回数を返します。UInt64

例

使用例

SELECT countSubstringsCaseInsensitiveUTF8('ложка, кошка, картошка', 'КА');

┌─countSubstri⋯шка', 'КА')─┐
│                        4 │
└──────────────────────────┘

start_pos 引数を指定する場合

SELECT countSubstringsCaseInsensitiveUTF8('ложка, кошка, картошка', 'КА', 13);

┌─countSubstri⋯, 'КА', 13)─┐
│                        2 │
└──────────────────────────┘

extract​

導入バージョン: v1.1

文字列から正規表現に一致する最初の部分文字列を抽出します。 'haystack' が 'pattern' にマッチしない場合は、空文字列を返します。

この関数は RE2 正規表現ライブラリを使用します。サポートされている構文については re2 を参照してください。

正規表現にキャプチャグループ（サブパターン）が含まれている場合、関数は入力文字列に対して最初のキャプチャグループを照合します。

構文

extract(haystack, pattern)

引数

  • haystack — 抽出元となる文字列。String
  • pattern — 通常はキャプチャグループを含む正規表現。const String

返り値

抽出された部分文字列を文字列として返します。String

例

メールアドレスからドメインを抽出

SELECT extract('[email protected]', '.*@(.*)$')

┌─extract('[email protected]', '.*@(.*)$')─┐
│ clickhouse.com                            │
└───────────────────────────────────────────┘

一致がない場合、空文字列を返す

SELECT extract('[email protected]', 'no_match')

┌─extract('[email protected]', 'no_match')─┐
│                                            │
└────────────────────────────────────────────┘

extractAll​

導入バージョン: v1.1

extract と同様ですが、文字列内で正規表現にマッチしたすべての一致を配列として返します。 'haystack' が 'pattern' の正規表現にマッチしない場合は、空配列が返されます。

正規表現にキャプチャグループ（サブパターン）が含まれている場合、この関数は入力文字列を最初のキャプチャグループに対して照合します。

構文

extractAll(haystack, pattern)

引数

  • haystack — 部分文字列を抽出する対象の文字列。String
  • pattern — 任意でキャプチャグループを含む正規表現。const String

戻り値

抽出された部分文字列の配列を返します。Array(String)

使用例

すべての数値を抽出する

SELECT extractAll('hello 123 world 456', '[0-9]+')

┌─extractAll('hello 123 world 456', '[0-9]+')─┐
│ ['123','456']                               │
└─────────────────────────────────────────────┘

キャプチャグループを使用して抽出

SELECT extractAll('[email protected], [email protected]', '([a-zA-Z0-9]+)@')

┌─extractAll('[email protected], [email protected]', '([a-zA-Z0-9]+)@')─┐
│ ['test','user']                                                    │
└────────────────────────────────────────────────────────────────────┘

extractAllGroupsHorizontal​

導入: v20.5

指定された正規表現を使用して文字列内のすべてのグループに一致させ、配列の配列を返します。各配列には、同一のキャプチャグループに属するすべてのキャプチャがグループ番号ごとに整理されて格納されます。

構文

extractAllGroupsHorizontal(s, regexp)

引数

返される値

配列の配列を返します。各内側の配列には、すべてのマッチに対して、同一のキャプチャグループから取得されたすべてのキャプチャが含まれます。最初の内側の配列にはグループ 1 からのすべてのキャプチャ、2 番目の配列にはグループ 2 からのすべてのキャプチャ、という形式になります。マッチが見つからない場合は空の配列を返します。Array(Array(String))

例

使用例

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]+)');

[['Server','Date','Content-Type','Connection'],['nginx','Tue, 22 Jan 2019 00:26:14 GMT','text/html; charset=UTF-8','keep-alive']]

extractGroups​

導入バージョン: v20.5

正規表現にマッチした、重なりのない部分文字列に含まれるすべてのグループを抽出します。

構文

extractAllGroups(s, regexp)

引数

戻り値

関数が少なくとも 1 つのマッチするグループを見つけた場合、group_id（1 から N。ここで N は regexp 内のキャプチャグループの数）ごとにまとめられた Array(Array(String)) カラムを返します。一致するグループがない場合は、空の配列を返します。Array(Array(String))

例

使用例

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 extractAllGroups(s, '< ([\\w\\-]+): ([^\\r\\n]+)');

[['Server','nginx'],['Date','Tue, 22 Jan 2019 00:26:14 GMT'],['Content-Type','text/html; charset=UTF-8'],['Connection','keep-alive']]

hasAllTokens​

導入バージョン: v25.10

hasAnyTokens と同様に動作しますが、needle 文字列または配列内のすべてのトークンが input 文字列にマッチする場合に 1 を返し、それ以外の場合は 0 を返します。input がカラムの場合、この条件を満たすすべての行を返します。

注記

最適なパフォーマンスのためには、カラム input に テキスト索引 が定義されている必要があります。 テキスト索引が定義されていない場合、この関数は総当たりのカラム走査を実行し、これは索引検索よりも桁違いに遅くなります。

検索の前に、この関数は次をトークン化します:

  • input 引数（常に）、および
  • needle 引数（String として与えられた場合） に対して、テキスト索引に指定されたトークナイザを使用します。 カラムにテキスト索引が定義されていない場合は、代わりに splitByNonAlpha トークナイザが使用されます。 needle 引数が Array(String) 型の場合、各配列要素は 1 つのトークンとして扱われ、追加のトークン化は行われません。

重複するトークンは無視されます。 例えば、needles = ['ClickHouse', 'ClickHouse'] は ['ClickHouse'] と同様に扱われます。

構文

hasAllTokens(input, needles)

エイリアス: hasAllToken

引数

戻り値

指定したすべてのトークンが一致する場合は 1、それ以外の場合は 0 を返します。UInt8

例

文字列カラムに対する使用例

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()');

┌─count()─┐
│       1 │
└─────────┘

配列内で、トークナイズせず AS-IS のまま検索する文字列（needle）を指定する

SELECT count() FROM table WHERE hasAllTokens(msg, ['a', 'd']);

┌─count()─┐
│       1 │
└─────────┘

tokens 関数を使ってニードルを生成する

SELECT count() FROM table WHERE hasAllTokens(msg, tokens('a()d', 'splitByString', ['()', '\\']));

┌─count()─┐
│       1 │
└─────────┘

配列カラムとマップカラムの使用例

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'});

配列カラムの例

SELECT count() FROM log WHERE hasAllTokens(tags, 'clickhouse');

┌─count()─┐
│       1 │
└─────────┘

mapKeys の例

SELECT count() FROM log WHERE hasAllTokens(mapKeys(attributes), ['address', 'log_level']);

┌─count()─┐
│       1 │
└─────────┘

mapValues を使った例

SELECT count() FROM log WHERE hasAllTokens(mapValues(attributes), ['192.0.0.1', 'DEBUG']);

┌─count()─┐
│       0 │
└─────────┘

hasAnyTokens​

導入バージョン: v25.10

needle 文字列または配列内のトークンのうち少なくとも 1 つが input 文字列にマッチする場合は 1 を返し、それ以外の場合は 0 を返します。input がカラムの場合、この条件を満たすすべての行を返します。

注記

最適なパフォーマンスのため、カラム input には text index が定義されている必要があります。 text index が定義されていない場合、この関数はブルートフォースによるカラムスキャンを実行し、INDEX ルックアップと比べて桁違いに遅くなります。

検索を行う前に、この関数は次をトークン化します。

  • input 引数（常に）

  • needle 引数（String として指定された場合）

    これらには、text index に対して指定された tokenizer が使用されます。 カラムに text index が定義されていない場合は、代わりに splitByNonAlpha tokenizer が使用されます。 needle 引数が Array(String) 型の場合、各配列要素はそれ自体がトークンとして扱われ、追加のトークン化は行われません。

重複するトークンは無視されます。 たとえば、['ClickHouse', 'ClickHouse'] は ['ClickHouse'] と同じように扱われます。

構文

hasAnyTokens(input, needles)

別名: hasAnyToken

引数

戻り値

少なくとも 1 つ一致がある場合は 1 を返し、それ以外の場合は 0 を返します。UInt8

例

文字列カラムに対する使用例

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()');

┌─count()─┐
│       3 │
└─────────┘

トークナイズせずに文字列をそのまま検索するための検索対象文字列を配列で指定します

SELECT count() FROM table WHERE hasAnyTokens(msg, ['a', 'd']);

┌─count()─┐
│       3 │
└─────────┘

tokens 関数で needle を生成する

SELECT count() FROM table WHERE hasAnyTokens(msg, tokens('a()d', 'splitByString', ['()', '\\']));

┌─count()─┐
│       3 │
└─────────┘

配列およびマップ型カラムの使用例

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'});

配列カラムの例

SELECT count() FROM log WHERE hasAnyTokens(tags, 'clickhouse');

┌─count()─┐
│       1 │
└─────────┘

mapKeys の使用例

SELECT count() FROM log WHERE hasAnyTokens(mapKeys(attributes), ['address', 'log_level']);

┌─count()─┐
│       2 │
└─────────┘

mapValues の例

SELECT count() FROM log WHERE hasAnyTokens(mapValues(attributes), ['192.0.0.1', 'DEBUG']);

┌─count()─┐
│       2 │
└─────────┘

hasSubsequence​

導入バージョン: v23.7

needle が haystack の部分列かどうかを判定します。 文字列の部分列とは、ある文字列から 0 個以上の文字を削除し、残りの文字の順序を変えずに得られる文字列の並びのことです。

構文

hasSubsequence(haystack, needle)

引数

  • haystack — 部分文字列を検索する対象の文字列。String
  • needle — 検索する部分文字列。String

返り値

needle が haystack の部分文字列であれば 1 を、そうでなければ 0 を返します。UInt8

例

基本的な部分文字列チェック

SELECT hasSubsequence('Hello World', 'HlWrd')

┌─hasSubsequence('Hello World', 'HlWrd')─┐
│                                      1 │
└────────────────────────────────────────┘

部分文字列が見つかりません

SELECT hasSubsequence('Hello World', 'xyz')

┌─hasSubsequence('Hello World', 'xyz')─┐
│                                    0 │
└──────────────────────────────────────┘

hasSubsequenceCaseInsensitive​

導入バージョン: v23.7

hasSubsequence と同様に動作しますが、検索時に大文字と小文字を区別しません。

構文

hasSubsequenceCaseInsensitive(haystack, needle)

引数

  • haystack — 検索対象の文字列。String
  • needle — 検索する部分列。String

戻り値

needle が haystack の部分列である場合は 1 を、そうでない場合は 0 を返します。UInt8

例

使用例

SELECT hasSubsequenceCaseInsensitive('garbage', 'ARG');

┌─hasSubsequenceCaseInsensitive('garbage', 'ARG')─┐
│                                               1 │
└─────────────────────────────────────────────────┘

hasSubsequenceCaseInsensitiveUTF8​

導入バージョン: v23.7

hasSubsequenceUTF8 と同様ですが、大文字・小文字を区別せずに検索します。

構文

hasSubsequenceCaseInsensitiveUTF8(haystack, needle)

引数

  • haystack — 検索を実行する UTF-8 エンコード済みの文字列。String
  • needle — 検索する UTF-8 エンコード済みの部分シーケンスとなる文字列。String

返される値

needle が haystack の部分シーケンスである場合は 1、それ以外の場合は 0 を返します。UInt8

例

使用例

SELECT hasSubsequenceCaseInsensitiveUTF8('ClickHouse - столбцовая система управления базами данных', 'СИСТЕМА');

┌─hasSubsequen⋯ 'СИСТЕМА')─┐
│                        1 │
└──────────────────────────┘

hasSubsequenceUTF8​

導入バージョン: v23.7

hasSubsequence と同様ですが、haystack と needle が UTF-8 エンコードされた文字列であることを前提とします。

構文

hasSubsequenceUTF8(haystack, needle)

引数

  • haystack — 検索対象となる文字列。String
  • needle — 検索する部分列。String

戻り値

needle が haystack の部分列であれば 1 を返し、それ以外の場合は 0 を返します。 UInt8

例

使用例

SELECT hasSubsequenceUTF8('картошка', 'кошка');

┌─hasSubsequen⋯', 'кошка')─┐
│                        1 │
└──────────────────────────┘

一致しない部分列

SELECT hasSubsequenceUTF8('картошка', 'апельсин');

┌─hasSubsequen⋯'апельсин')─┐
│                        0 │
└──────────────────────────┘

hasToken​

導入バージョン: v20.1

指定したトークンが検索対象文字列（haystack）に含まれているかどうかを確認します。

トークナイザとして splitByNonAlpha を使用します。つまり、トークンは [0-9A-Za-z_]（数字、ASCII 文字、およびアンダースコア）からなる連続した文字列のうち、可能な限り長い部分列として定義されます。

構文

hasToken(haystack, token)

引数

  • haystack — 検索対象の文字列。String
  • token — 検索するトークン。const String

戻り値

トークンが見つかった場合は 1 を返し、見つからなかった場合は 0 を返します。UInt8

使用例

トークン検索

SELECT hasToken('clickhouse test', 'test')

┌─hasToken('clickhouse test', 'test')─┐
│                                   1 │
└─────────────────────────────────────┘

hasTokenCaseInsensitive​

導入バージョン: v

tokenbf_v1 索引を使用して、haystack 内の needle を大文字小文字を区別せずに検索します。

構文

引数

  • なし

戻り値

例

hasTokenCaseInsensitiveOrNull​

導入バージョン: v

tokenbf_v1 索引を使用して、haystack 内で needle を大文字小文字を区別せずに検索します。needle が不正な形式の場合は null を返します。

構文

引数

  • なし。

戻り値

例

hasTokenOrNull​

導入バージョン: v20.1

hasToken と同様ですが、トークンが不正形式の場合は null を返します。

構文

hasTokenOrNull(haystack, token)

引数

  • haystack — 検索対象の文字列。定数でなければなりません。String
  • token — 検索するトークン。const String

返される値

トークンが見つかった場合は 1、見つからない場合は 0 を返します。トークンが不正な形式の場合は null を返します。Nullable(UInt8)

例

使用例

SELECT hasTokenOrNull('apple banana cherry', 'ban ana');

┌─hasTokenOrNu⋯ 'ban ana')─┐
│                     ᴺᵁᴸᴸ │
└──────────────────────────┘

ilike​

導入されたバージョン: v20.6

like と同様ですが、大文字と小文字を区別せずに検索します。

構文

ilike(haystack, pattern)
-- haystack ILIKE pattern

引数

  • haystack — 検索を行う文字列。String または FixedString
  • pattern — 照合対象の LIKE パターン。String

戻り値

文字列が LIKE パターンに一致した場合は 1（大文字小文字を区別せずに比較）、それ以外の場合は 0 を返します。UInt8

例

使用例

SELECT ilike('ClickHouse', '%house%');

┌─ilike('ClickHouse', '%house%')─┐
│                              1 │
└────────────────────────────────┘

like​

導入バージョン: v1.1

文字列 haystack が LIKE 式 pattern にマッチするかどうかを返します。

LIKE 式には通常の文字に加えて、次のメタ文字を含めることができます。

  • % は任意の数の任意の文字（0 文字も可）を表します。
  • _ は 1 文字の任意の文字を表します。
  • \ はリテラルの %、_、\ をエスケープするために使用します。

マッチングは UTF-8 に基づいて行われます。たとえば、_ は UTF-8 では 2 バイトで表現される Unicode コードポイント ¥ にマッチします。

haystack または LIKE 式が有効な UTF-8 でない場合、その動作は未定義です。

Unicode の正規化は自動では行われません。必要に応じて normalizeUTF8* 関数を使用してください。

リテラルの %、_ および \（これらは LIKE のメタ文字です）とマッチさせるには、先頭にバックスラッシュを付けて \%、\_、\\ と記述します。 バックスラッシュが %、_、\ 以外の文字の前に付く場合、その特別な意味は失われ（すなわちリテラルとして解釈され）ます。

注記

ClickHouse では、文字列内のバックスラッシュもクオートする必要があるため、実際には \\%、\\_、\\\\ と記述する必要があります。

%needle% という形式の LIKE 式の場合、この関数は position 関数と同等の速度で動作します。 それ以外の LIKE 式は内部的に正規表現へ変換され、関数 match と同程度のパフォーマンスで実行されます。

構文

like(haystack, pattern)
-- haystack LIKE pattern

引数

  • haystack — 検索対象の文字列。String または FixedString
  • pattern — 照合に使用する LIKE パターン。%（任意の長さの文字列にマッチ）、_（任意の1文字にマッチ）、およびエスケープ用の \ を含めることができます。String

戻り値

文字列が LIKE パターンにマッチした場合は 1、それ以外の場合は 0 を返します。UInt8

例

使用例

SELECT like('ClickHouse', '%House');

┌─like('ClickHouse', '%House')─┐
│                            1 │
└──────────────────────────────┘

1文字ワイルドカード

SELECT like('ClickHouse', 'Click_ouse');

┌─like('ClickH⋯lick_ouse')─┐
│                        1 │
└──────────────────────────┘

マッチしないパターン

SELECT like('ClickHouse', '%SQL%');

┌─like('ClickHouse', '%SQL%')─┐
│                           0 │
└─────────────────────────────┘

locate​

導入バージョン: v18.16

position と同様ですが、引数 haystack と needle の順序が逆になっています。

Version dependent behavior

この関数の動作は ClickHouse のバージョンによって異なります:

  • v24.3 未満のバージョンでは、locate は関数 position のエイリアスであり、引数 (haystack, needle[, start_pos]) を受け取っていました。
  • v24.3 以上のバージョンでは、locate は個別の関数（MySQL との互換性向上のため）となり、引数 (needle, haystack[, start_pos]) を受け取ります。 以前の動作は、設定 function_locate_has_mysql_compatible_argument_order = false を使用することで復元できます。

構文

locate(needle, haystack[, start_pos])

引数

  • needle — 検索対象となる部分文字列。String
  • haystack — 検索を実行する文字列。String または Enum
  • start_pos — 省略可能。検索を開始する haystack 内の位置 (1 始まり)。UInt

戻り値

部分文字列が見つかった場合は、1 から数えるバイト単位での開始位置を返し、見つからなかった場合は 0 を返す。UInt64

例

基本的な使用方法

SELECT locate('ca', 'abcabc')

┌─locate('ca', 'abcabc')─┐
│                      3 │
└────────────────────────┘

match​

導入バージョン: v1.1

指定された文字列が、指定された正規表現パターンにマッチするかを判定します。

この関数は RE2 正規表現ライブラリを使用します。サポートされている構文については re2 を参照してください。

マッチングは UTF-8 を前提として動作します。例えば ¥ は内部的には 2 バイトを使用しますが、マッチング時には 1 つのコードポイントとして扱われます。 正規表現には NULL バイトを含めることはできません。 haystack または pattern が不正な UTF-8 の場合、その挙動は未定義です。

re2 のデフォルト動作と異なり、. は改行にもマッチします。これを無効にするには、パターンの先頭に (?-s) を付けてください。

パターンは両端で自動的にアンカーされます（パターンが先頭に ^ を、末尾に $ を付けたかのように扱われます）。

部分文字列を検索したいだけであれば、代わりに like や position 関数を使用できます。これらはこの関数よりもはるかに高速に動作します。

代替の演算子構文: haystack REGEXP pattern。

構文

match(haystack, pattern)

別名: REGEXP_MATCHES

引数

  • haystack — パターンを検索する対象の文字列。String
  • pattern — 正規表現パターン。const String

返される値

パターンが一致する場合は 1、それ以外の場合は 0 を返します。UInt8

例

基本的なパターンマッチ

SELECT match('Hello World', 'Hello.*')

┌─match('Hello World', 'Hello.*')─┐
│                               1 │
└─────────────────────────────────┘

パターンが一致しない場合

SELECT match('Hello World', 'goodbye.*')

┌─match('Hello World', 'goodbye.*')─┐
│                                 0 │
└───────────────────────────────────┘

multiFuzzyMatchAllIndices​

導入バージョン: v20.1

multiFuzzyMatchAny と同様ですが、一定の 編集距離 以内で haystack にマッチするすべてのインデックスを、任意の順序の配列として返します。

構文

multiFuzzyMatchAllIndices(haystack, distance, [pattern1, pattern2, ..., patternN])

引数

  • haystack — 検索対象となる文字列。String
  • distance — あいまい一致における最大編集距離。UInt8
  • pattern — 照合対象となるパターンの配列。Array(String)

返される値

haystack に対して、指定した編集距離以内でマッチするすべてのインデックス（1 から始まる）を、順不同で要素とする配列を返します。マッチが見つからない場合は空配列を返します。Array(UInt64)

例

使用例

SELECT multiFuzzyMatchAllIndices('ClickHouse', 2, ['ClickHouse', 'ClckHouse', 'ClickHose', 'House']);

┌─multiFuzzyMa⋯, 'House'])─┐
│ [3,1,4,2]                │
└──────────────────────────┘

multiFuzzyMatchAny​

導入バージョン: v20.1

multiMatchAny と同様ですが、一定の 編集距離 以内でパターンのいずれかが haystack にマッチした場合に 1 を返します。 この関数は hyperscan ライブラリの実験的機能に依存しており、特定のエッジケースでは低速になる可能性があります。 パフォーマンスは編集距離の値と使用するパターンに依存しますが、常に非ファジー版と比べて計算コストが高くなります。

注記

multiFuzzyMatch*() 関数ファミリーは、hyperscan の制約により UTF-8 正規表現をサポートしていません（バイト列として扱われます）。

構文

multiFuzzyMatchAny(haystack, distance, [pattern1, pattern2, ..., patternN])

引数

  • haystack — 検索対象となる文字列。String
  • distance — ファジーマッチングにおける最大編集距離。UInt8
  • pattern — 省略可能。一致判定に使用するパターンの配列。Array(String)

返り値

指定した編集距離以内で、いずれかのパターンが haystack に一致した場合は 1、それ以外の場合は 0 を返します。UInt8

例

使用例

SELECT multiFuzzyMatchAny('ClickHouse', 2, ['ClickHouse', 'ClckHouse', 'ClickHose']);

┌─multiFuzzyMa⋯lickHose'])─┐
│                        1 │
└──────────────────────────┘

multiFuzzyMatchAnyIndex​

導入バージョン: v20.1

multiFuzzyMatchAny と同様ですが、検索対象文字列に対して、定数の編集距離以内で一致する任意のインデックスを返します。

構文

multiFuzzyMatchAnyIndex(haystack, distance, [pattern1, pattern2, ..., patternn])

引数

  • haystack — 検索対象の文字列。String
  • distance — ファジーマッチングにおける最大編集距離。UInt8
  • pattern — 照合対象となるパターンの配列。Array(String)

戻り値

指定された編集距離の範囲内で haystack に一致する任意のパターンのインデックス（1 から始まる）を返し、一致するパターンがない場合は 0 を返します。UInt64

例

使用例

SELECT multiFuzzyMatchAnyIndex('ClickHouse', 2, ['ClckHouse', 'ClickHose', 'ClickHouse']);

┌─multiFuzzyMa⋯ickHouse'])─┐
│                        2 │
└──────────────────────────┘

multiMatchAllIndices​

導入バージョン: v20.1

multiMatchAny と似ていますが、haystack にマッチするすべてのインデックスを要素とする配列を、任意の順序で返します。

構文

multiMatchAllIndices(haystack, [pattern1, pattern2, ..., patternn])

引数

  • haystack — 検索対象の文字列。String
  • pattern — 照合に使用する正規表現パターン。String

戻り値

haystack 内で一致したすべてのインデックス（1 起算）を、順不同で含む配列。一致が見つからない場合は空配列を返します。Array(UInt64)

例

使用例

SELECT multiMatchAllIndices('ClickHouse', ['[0-9]', 'House', 'Click', 'ouse']);

┌─multiMatchAl⋯', 'ouse'])─┐
│ [3, 2, 4]                │
└──────────────────────────┘

multiMatchAny​

導入バージョン: v20.1

複数の正規表現パターンのうち、少なくとも 1 つが haystack（検索対象の文字列）にマッチするかどうかを判定します。

文字列内で複数の部分文字列を検索したいだけの場合は、代わりに関数 multiSearchAny を使用してください。この関数よりもはるかに高速に動作します。

構文

multiMatchAny(haystack, pattern1[, pattern2, ...])

引数

  • haystack — パターンを検索する対象の文字列。String
  • pattern1[, pattern2, ...] — 1 つ以上の正規表現パターンからなる配列。Array(String)

返り値

いずれかのパターンにマッチした場合は 1、それ以外は 0 を返します。UInt8

使用例

複数パターンでのマッチング

SELECT multiMatchAny('Hello World', ['Hello.*', 'foo.*'])

┌─multiMatchAny('Hello World', ['Hello.*', 'foo.*'])─┐
│                                                  1 │
└────────────────────────────────────────────────────┘

どのパターンにも一致しません

SELECT multiMatchAny('Hello World', ['goodbye.*', 'foo.*'])

┌─multiMatchAny('Hello World', ['goodbye.*', 'foo.*'])─┐
│                                                    0 │
└──────────────────────────────────────────────────────┘

multiMatchAnyIndex​

導入バージョン: v20.1

multiMatchAny と同様ですが、haystack にマッチする任意の索引を返します。

構文

multiMatchAnyIndex(haystack, [pattern1, pattern2, ..., patternn])

引数

  • haystack — 検索を実行する対象の文字列。String
  • pattern — 照合に使用する正規表現。Array(String)

戻り値

最初にマッチしたパターンの位置（1 から始まる）を返します。マッチが見つからない場合は 0 を返します。UInt64

例

使用例

SELECT multiMatchAnyIndex('ClickHouse', ['[0-9]', 'House', 'Click']);

┌─multiMatchAn⋯, 'Click'])─┐
│                        3 │
└──────────────────────────┘

multiSearchAllPositions​

導入バージョン: v20.1

position と似ていますが、haystack 文字列内の複数の needle となる部分文字列について、位置（バイト単位、1 起算）の配列を返します。

すべての multiSearch*() 関数は、needle を最大 2^8 個までしかサポートしません。

構文

multiSearchAllPositions(haystack, needle1[, needle2, ...])

引数

  • haystack — 検索を実行する対象の文字列。String
  • needle1[, needle2, ...] — 検索対象となる 1 つ以上の部分文字列の配列。Array(String)

戻り値

部分文字列が見つかった場合は、バイト単位かつ 1 起算の開始位置を、見つからなかった場合は 0 を要素とする配列を返します。Array(UInt64)

使用例

複数 needle の検索

SELECT multiSearchAllPositions('Hello, World!', ['hello', '!', 'world'])

┌─multiSearchAllPositions('Hello, World!', ['hello', '!', 'world'])─┐
│ [0,13,0]                                                          │
└───────────────────────────────────────────────────────────────────┘

multiSearchAllPositionsCaseInsensitive​

導入バージョン: v20.1

multiSearchAllPositions と同様ですが、大文字と小文字を区別しません。

構文

multiSearchAllPositionsCaseInsensitive(haystack, needle1[, needle2, ...])

引数

  • haystack — 検索を実行する対象の文字列。String
  • needle1[, needle2, ...] — 検索対象となる 1 つ以上の部分文字列の配列。Array(String)

返される値

各部分文字列に対して、見つかった場合はバイト単位かつ 1 始まりの開始位置、見つからなかった場合は 0 を要素とする配列を返します。Array(UInt64)

例

大文字小文字を区別しない複数検索

SELECT multiSearchAllPositionsCaseInsensitive('ClickHouse',['c','h'])

┌─multiSearchA⋯['c', 'h'])─┐
│ [1,6]                    │
└──────────────────────────┘

multiSearchAllPositionsCaseInsensitiveUTF8​

導入バージョン: v20.1

multiSearchAllPositionsUTF8 と同様ですが、大文字と小文字を区別しません。

構文

multiSearchAllPositionsCaseInsensitiveUTF8(haystack, [needle1, needle2, ..., needleN])

引数

  • haystack — 検索を行う UTF-8 エンコード文字列。String
  • needle — 検索する UTF-8 エンコード部分文字列の配列。Array(String)

戻り値

部分文字列が見つかった場合の、1 から数えたバイト単位での開始位置の配列。部分文字列が見つからなかった場合は 0 を返します。Array

例

大文字・小文字を区別しない UTF-8 検索

SELECT multiSearchAllPositionsCaseInsensitiveUTF8('Здравствуй, мир!', ['здравствуй', 'МИР']);

┌─multiSearchA⋯й', 'МИР'])─┐
│ [1, 13]                  │
└──────────────────────────┘

multiSearchAllPositionsUTF8​

導入バージョン: v20.1

multiSearchAllPositions と同様ですが、haystack および needle の部分文字列が UTF-8 でエンコードされた文字列であることを前提とします。

構文

multiSearchAllPositionsUTF8(haystack, needle1[, needle2, ...])

引数

  • haystack — 検索を行う UTF-8 エンコード済み文字列。String
  • needle1[, needle2, ...] — 検索対象となる UTF-8 エンコード済み部分文字列の配列。Array(String)

返される値

部分文字列が見つかった場合、その開始位置（バイト単位、1 起算）の配列を返し、見つからなかった場合は 0 を返します。Array

例

UTF-8 マルチ検索

SELECT multiSearchAllPositionsUTF8('ClickHouse',['C','H'])

┌─multiSearchAllPositionsUTF8('ClickHouse', ['C', 'H'])─┐
│ [1,6]                                                 │
└───────────────────────────────────────────────────────┘

multiSearchAny​

導入バージョン: v20.1

指定された複数の needle 文字列のうち少なくとも 1 つが、haystack 文字列にマッチするかどうかを判定します。

関数 multiSearchAnyCaseInsensitive、multiSearchAnyUTF8、multiSearchAnyCaseInsensitiveUTF8 は、この関数の大文字小文字を区別しないおよび/または UTF-8 対応のバリアントを提供します。

構文

multiSearchAny(haystack, needle1[, needle2, ...])

引数

  • haystack — 検索を実行する文字列。String
  • needle1[, needle2, ...] — 検索対象となる部分文字列の配列。Array(String)

戻り値

少なくとも 1 件一致があれば 1 を返し、一致が 1 件もなければ 0 を返します。UInt8

例

いずれかへの一致検索

SELECT multiSearchAny('ClickHouse',['C','H'])

┌─multiSearchAny('ClickHouse', ['C', 'H'])─┐
│                                        1 │
└──────────────────────────────────────────┘

multiSearchAnyCaseInsensitive​

導入バージョン: v20.1

multiSearchAny と同様ですが、大文字・小文字を区別しません。

構文

multiSearchAnyCaseInsensitive(haystack, [needle1, needle2, ..., needleN])

引数

  • haystack — 検索を実行する対象の文字列。String
  • needle — 検索対象の部分文字列。Array(String)

戻り値

大文字小文字を区別しない一致が少なくとも 1 つあれば 1、1 つもなければ 0 を返します。UInt8

使用例

大文字小文字を区別しない検索

SELECT multiSearchAnyCaseInsensitive('ClickHouse',['c','h'])

┌─multiSearchAnyCaseInsensitive('ClickHouse', ['c', 'h'])─┐
│                                                       1 │
└─────────────────────────────────────────────────────────┘

multiSearchAnyCaseInsensitiveUTF8​

導入されたバージョン: v20.1

multiSearchAnyUTF8 と同様ですが、大文字と小文字を区別しません。

構文

multiSearchAnyCaseInsensitiveUTF8(haystack, [needle1, needle2, ..., needleN])

引数

  • haystack — 検索対象の UTF-8 文字列。String
  • needle — 検索する UTF-8 部分文字列の配列。Array(String)

戻り値

大文字小文字を区別しない一致が少なくとも 1 つあれば 1 を返し、1 つもなければ 0 を返します。UInt8

使用例

UTF-8 文字列 'Здравствуйте' が与えられたときに、小文字の文字 'з' が含まれているかを確認する

SELECT multiSearchAnyCaseInsensitiveUTF8('Здравствуйте',['з'])

┌─multiSearchA⋯те', ['з'])─┐
│                        1 │
└──────────────────────────┘

multiSearchAnyUTF8​

導入バージョン: v20.1

multiSearchAny と同様ですが、haystack 文字列および needle 部分文字列が UTF-8 エンコードされた文字列であると仮定します。

構文

multiSearchAnyUTF8(haystack, [needle1, needle2, ..., needleN])

引数

  • haystack — 検索対象の UTF-8 文字列。String
  • needle — 検索する UTF-8 文字列の部分文字列。Array(String)

返される値

少なくとも 1 件一致があれば 1 を返し、一致が 1 件もなければ 0 を返します。UInt8

例

UTF-8 文字列 '你好，世界'（'Hello, world'）が与えられたとき、その文字列内に 你 または 界 の文字が含まれているかを確認します。

SELECT multiSearchAnyUTF8('你好，世界', ['你', '界'])

┌─multiSearchA⋯你', '界'])─┐
│                        1 │
└──────────────────────────┘

multiSearchFirstIndex​

導入バージョン: v20.1

複数の needle 文字列を haystack 文字列内で検索し（大文字と小文字は区別）、最初に見つかった needle のインデックス（1 から数えた位置）を返します。

構文

multiSearchFirstIndex(haystack, [needle1, needle2, ..., needleN])

引数

  • haystack — 検索対象の文字列。String
  • needles — 検索する文字列の配列。Array(String)

戻り値

haystack 内で最初に見つかった needle の、1 始まりのインデックス（needles 配列内での位置）を返します。needle が 1 つも見つからない場合は 0 を返します。検索は大文字と小文字を区別します。UInt64

例

使用例

SELECT multiSearchFirstIndex('ClickHouse Database', ['Click', 'Database', 'Server']);

┌─multiSearchF⋯ 'Server'])─┐
│                        1 │
└──────────────────────────┘

大文字小文字を区別する場合の挙動

SELECT multiSearchFirstIndex('ClickHouse Database', ['CLICK', 'Database', 'Server']);

┌─multiSearchF⋯ 'Server'])─┐
│                        2 │
└──────────────────────────┘

一致が見つかりません

SELECT multiSearchFirstIndex('Hello World', ['goodbye', 'test']);

┌─multiSearchF⋯', 'test'])─┐
│                        0 │
└──────────────────────────┘

multiSearchFirstIndexCaseInsensitive​

導入バージョン: v20.1

文字列 haystack 内で最も左側に見つかった needle_i のインデックス i（1 から始まる）を返し、見つからない場合は 0 を返します。 大文字小文字を区別せずに検索します。

構文

multiSearchFirstIndexCaseInsensitive(haystack, [needle1, needle2, ..., needleN]

引数

  • haystack — 検索対象の文字列。String
  • needle — 検索する部分文字列。Array(String)

戻り値

最も左側で見つかった needle のインデックス（1 から始まる）を返します。一致がない場合は 0 を返します。UInt8

例

使用例

SELECT multiSearchFirstIndexCaseInsensitive('hElLo WoRlD', ['World', 'Hello']);

┌─multiSearchF⋯, 'Hello'])─┐
│                        1 │
└──────────────────────────┘

multiSearchFirstIndexCaseInsensitiveUTF8​

導入バージョン: v20.1

UTF-8 エンコーディングをサポートしつつ、大文字小文字を区別せずに、haystack 文字列内で複数の needle 文字列を検索し、最初に見つかった needle の 1 始まりのインデックスを返します。

構文

multiSearchFirstIndexCaseInsensitiveUTF8(haystack, [needle1, needle2, ..., needleN])

引数

  • haystack — 検索対象の文字列。String
  • needles — 検索する文字列の配列。Array(String)

返される値

haystack 内で最初に見つかった要素の、1 から始まるインデックス（needles 配列内の位置）を返します。どれも見つからなかった場合は 0 を返します。検索は大文字と小文字を区別せず、UTF-8 文字エンコーディングに対応しています。UInt64

例

使用例

SELECT multiSearchFirstIndexCaseInsensitiveUTF8('ClickHouse Database', ['CLICK', 'data', 'server']);

┌─multiSearchF⋯ 'server'])─┐
│                        1 │
└──────────────────────────┘

UTF-8 における大文字・小文字の扱い

SELECT multiSearchFirstIndexCaseInsensitiveUTF8('Привет Мир', ['мир', 'ПРИВЕТ']);

┌─multiSearchF⋯ 'ПРИВЕТ'])─┐
│                        1 │
└──────────────────────────┘

一致するものが見つかりません

SELECT multiSearchFirstIndexCaseInsensitiveUTF8('Hello World', ['goodbye', 'test']);

┌─multiSearchF⋯', 'test'])─┐
│                        0 │
└──────────────────────────┘

multiSearchFirstIndexUTF8​

導入バージョン: v20.1

文字列 haystack の中で、最も左側で最初に見つかった needle_i に対応するインデックス i（1 から始まる）を返し、該当するものがない場合は 0 を返します。 haystack および needle は UTF-8 でエンコードされた文字列であると仮定します。

構文

multiSearchFirstIndexUTF8(haystack, [needle1, needle2, ..., needleN])

引数

  • haystack — 検索を行う UTF-8 文字列。String
  • needle — 検索対象となる UTF-8 部分文字列の配列。Array(String)

戻り値

最も左側で見つかった needle のインデックス（1 から始まる）を返します。一致がない場合は 0 を返します。UInt8

例

使用例

SELECT multiSearchFirstIndexUTF8('Здравствуйте мир', ['мир', 'здравствуйте']);

┌─multiSearchF⋯вствуйте'])─┐
│                        1 │
└──────────────────────────┘

multiSearchFirstPosition​

導入バージョン: v20.1

position と同様ですが、複数の needle 文字列のいずれかと一致する haystack 文字列内の最も左端のオフセットを返します。

multiSearchFirstPositionCaseInsensitive、multiSearchFirstPositionUTF8、multiSearchFirstPositionCaseInsensitiveUTF8 は、この関数の大文字小文字を区別しない、または UTF-8 対応のバリアントを提供します。

構文

multiSearchFirstPosition(haystack, needle1[, needle2, ...])

引数

  • haystack — 検索対象の文字列。String
  • needle1[, needle2, ...] — 検索する 1 つ以上の部分文字列からなる配列。Array(String)

返される値

haystack 文字列中で、複数の needle 文字列のいずれかに一致する最も左側のオフセットを返します。一致がなかった場合は 0 を返します。UInt64

例

先頭位置の検索

SELECT multiSearchFirstPosition('Hello World',['llo', 'Wor', 'ld'])

┌─multiSearchFirstPosition('Hello World', ['llo', 'Wor', 'ld'])─┐
│                                                             3 │
└───────────────────────────────────────────────────────────────┘

multiSearchFirstPositionCaseInsensitive​

導入バージョン: v20.1

multiSearchFirstPosition と同様ですが、大文字・小文字を区別しません。

構文

multiSearchFirstPositionCaseInsensitive(haystack, [needle1, needle2, ..., needleN])

引数

  • haystack — 検索を行う対象の文字列。String
  • needle — 検索する部分文字列の配列。Array(String)

戻り値

複数の needle 文字列のいずれかに一致する、haystack 文字列内の最も左側のオフセットを返します。一致がない場合は 0 を返します。UInt64

例

大文字小文字を区別しない最初の位置

SELECT multiSearchFirstPositionCaseInsensitive('HELLO WORLD',['wor', 'ld', 'ello'])

┌─multiSearchFirstPositionCaseInsensitive('HELLO WORLD', ['wor', 'ld', 'ello'])─┐
│                                                                             2 │
└───────────────────────────────────────────────────────────────────────────────┘

multiSearchFirstPositionCaseInsensitiveUTF8​

導入バージョン: v20.1

multiSearchFirstPosition と同様ですが、haystack と needle を UTF-8 文字列として扱い、大文字小文字を区別しません。

構文

multiSearchFirstPositionCaseInsensitiveUTF8(haystack, [needle1, needle2, ..., needleN])

引数

  • haystack — 検索を実行する UTF-8 文字列。String
  • needle — 検索対象となる UTF-8 部分文字列の配列。Array(String)

戻り値

複数の needle 文字列のいずれかと大文字小文字を区別せずに一致する、haystack 文字列内の最も左側のオフセットを返します。一致がない場合は 0 を返します。UInt64

例

与えられた needle のいずれかに一致する、UTF-8 文字列 'Здравствуй, мир'（'Hello, world'）内の最も左側のオフセットを検索する

SELECT multiSearchFirstPositionCaseInsensitiveUTF8('Здравствуй, мир', ['МИР', 'вст', 'Здра'])

┌─multiSearchFirstPositionCaseInsensitiveUTF8('Здравствуй, мир', ['мир', 'вст', 'Здра'])─┐
│                                                                                      3 │
└────────────────────────────────────────────────────────────────────────────────────────┘

multiSearchFirstPositionUTF8​

導入バージョン: v20.1

multiSearchFirstPosition と同様ですが、haystack と needle が UTF-8 文字列であると仮定します。

構文

multiSearchFirstPositionUTF8(haystack, [needle1, needle2, ..., needleN])

引数

  • haystack — 検索を実行する UTF-8 文字列。String
  • needle — 検索する UTF-8 部分文字列の配列。Array(String)

戻り値

複数の needle 文字列のいずれかに一致する haystack 文字列内の最も左側のオフセット。一致がない場合は 0 を返す。UInt64

使用例

UTF-8 文字列 'Здравствуй, мир'（'Hello, world'）に対して、指定された needle のいずれかに一致する最も左側のオフセットを求めます

SELECT multiSearchFirstPositionUTF8('Здравствуй, мир',['мир', 'вст', 'авст'])

┌─multiSearchFirstPositionUTF8('Здравствуй, мир', ['мир', 'вст', 'авст'])─┐
│                                                                       3 │
└─────────────────────────────────────────────────────────────────────────┘

ngramDistance​

導入バージョン: v20.1

2 つの文字列間の 4-gram 距離を計算します。 そのために、2 つの 4-gram の多重集合間の対称差を数え、その値をそれぞれの要素数の合計で正規化します。 返される値が小さいほど、文字列同士はより類似しています。

大文字と小文字を区別しない検索や UTF-8 形式での使用には、関数 ngramDistanceCaseInsensitive、ngramDistanceUTF8、ngramDistanceCaseInsensitiveUTF8 を使用してください。

構文

ngramDistance(haystack, needle)

引数

  • haystack — 比較に用いる文字列。String
  • needle — 比較に用いる文字列。String

戻り値

0 から 1 の範囲の Float32 値を返します。返される値が小さいほど、文字列同士がより類似していることを示します。Float32

例

4-gram 距離を計算する

SELECT ngramDistance('ClickHouse', 'ClickHouses')

┌─ngramDistance('ClickHouse', 'ClickHouses')─┐
│                                        0.1 │
└────────────────────────────────────────────┘

ngramDistanceCaseInsensitive​

導入バージョン: v20.1

ngramDistance の大文字小文字を区別しないバリアントです。 大文字小文字を無視して、2つの文字列間の 4-gram 距離を計算します。 返される値が小さいほど、文字列同士はより類似しています。

構文

ngramDistanceCaseInsensitive(haystack, needle)

引数

  • haystack — 1 番目の比較文字列。String
  • needle — 2 番目の比較文字列。String

返り値

0 から 1 の間の Float32 型の数値を返します。Float32

例

大文字小文字を区別しない 4-gram の距離

SELECT ngramDistanceCaseInsensitive('ClickHouse','clickhouse')

┌─ngramDistanceCaseInsensitive('ClickHouse','clickhouse')─┐
│                                                       0 │
└─────────────────────────────────────────────────────────┘

ngramDistanceCaseInsensitiveUTF8​

導入バージョン: v20.1

ngramDistance の大文字小文字を区別しない UTF-8 版を提供します。 needle と haystack の文字列が UTF-8 エンコードされた文字列であることを前提とし、大文字小文字を無視します。 2 つの UTF-8 文字列間の 3-gram 距離を、大文字小文字を無視して計算します。 返される値が小さいほど、2 つの文字列はより類似しています。

構文

ngramDistanceCaseInsensitiveUTF8(haystack, needle)

引数

  • haystack — 1 番目の UTF-8 エンコードされた比較文字列。String
  • needle — 2 番目の UTF-8 エンコードされた比較文字列。String

戻り値

0 から 1 の間の Float32 型の数値を返します。Float32

使用例

大文字小文字を区別しない UTF-8 3-gram 距離

SELECT ngramDistanceCaseInsensitiveUTF8('abcde','CDE')

┌─ngramDistanceCaseInsensitiveUTF8('abcde','CDE')─┐
│                                             0.5 │
└─────────────────────────────────────────────────┘

ngramDistanceUTF8​

導入バージョン: v20.1

ngramDistance の UTF-8 版を提供します。 needle と haystack の文字列が UTF-8 でエンコードされていると仮定します。 2 つの UTF-8 文字列間の 3-gram 距離を計算します。 返される値が小さいほど、文字列同士の類似度は高くなります。

構文

ngramDistanceUTF8(haystack, needle)

引数

  • haystack — 1 番目の UTF-8 でエンコードされた比較用文字列。String
  • needle — 2 番目の UTF-8 でエンコードされた比較用文字列。String

返り値

0 から 1 の間の Float32 型の値を返します。Float32

例

UTF-8 3-gram 距離

SELECT ngramDistanceUTF8('abcde','cde')

┌─ngramDistanceUTF8('abcde','cde')─┐
│                               0.5 │
└───────────────────────────────────┘

ngramSearch​

導入バージョン: v20.1

2 つの文字列間の 4-gram 距離が指定された閾値以下かどうかをチェックします。

大文字小文字を区別しない検索や UTF-8 形式での検索を行う場合は、ngramSearchCaseInsensitive、ngramSearchUTF8、ngramSearchCaseInsensitiveUTF8 関数を使用します。

構文

ngramSearch(haystack, needle)

引数

  • haystack — 比較される文字列。String
  • needle — 比較される文字列。String

戻り値

2つの文字列間の 4-gram 距離がしきい値（デフォルトは 1.0）以下であれば 1、それ以外の場合は 0 を返します。UInt8

使用例

4-gram を使った検索

SELECT ngramSearch('ClickHouse', 'Click')

┌─ngramSearch('ClickHouse', 'Click')─┐
│                                  1 │
└────────────────────────────────────┘

ngramSearchCaseInsensitive​

導入バージョン: v20.1

ngramSearch の大文字小文字を区別しないバリアントを提供します。 needle 文字列と haystack 文字列の非対称な差分を計算します。具体的には、needle の n-gram 数から共通する n-gram の数を引いたものを、needle の n-gram 数で正規化した値です。 大文字小文字を無視して、2 つの文字列間の 4-gram の距離が指定されたしきい値以下かどうかをチェックします。

構文

ngramSearchCaseInsensitive(haystack, needle)

引数

  • haystack — 検索対象の文字列。String
  • needle — 検索する文字列。String

返り値

2 つの文字列間の 4-gram 距離がしきい値（デフォルトでは 1.0）以下であれば 1、それ以外の場合は 0 を返します（UInt8）。

例

4-gram を用いた大文字小文字を区別しない検索

SELECT ngramSearchCaseInsensitive('Hello World','hello')

┌─ngramSearchCaseInsensitive('Hello World','hello')─┐
│                                                  1 │
└────────────────────────────────────────────────────┘

ngramSearchCaseInsensitiveUTF8​

導入バージョン: v20.1

ngramSearch の大文字小文字を区別しない UTF-8 版を提供します。 haystack と needle が UTF-8 文字列であることを前提とし、大文字小文字を無視します。 大文字小文字を無視して、2 つの UTF-8 文字列間の 3-gram 距離が指定されたしきい値以下かどうかを判定します。

構文

ngramSearchCaseInsensitiveUTF8(haystack, needle)

引数

  • haystack — 比較に使用する UTF-8 文字列。String
  • needle — 比較に使用する UTF-8 文字列。String

戻り値

文字列間の 3-gram 距離が閾値（デフォルトは 1.0）以下の場合は 1 を、それ以外の場合は 0 を返します。UInt8

例

3-gram を使用した UTF-8 の大文字小文字を区別しない検索

SELECT ngramSearchCaseInsensitiveUTF8('абвГДЕёжз', 'АбвгдЕЁжз')

┌─ngramSearchCaseInsensitiveUTF8('абвГДЕёжз', 'АбвгдЕЁжз')─┐
│                                                        1 │
└──────────────────────────────────────────────────────────┘

ngramSearchUTF8​

導入バージョン: v20.1

ngramSearch の UTF-8 版を提供します。 haystack と needle が UTF-8 エンコードされた文字列であると仮定します。 2 つの UTF-8 文字列間の 3-gram 距離が、指定されたしきい値以下であるかどうかを判定します。

構文

ngramSearchUTF8(haystack, needle)

引数

  • haystack — 比較対象の UTF-8 文字列。String
  • needle — 比較対象の UTF-8 文字列。String

戻り値

文字列間の 3-gram 距離がしきい値（デフォルトは 1.0）以下の場合は 1、それ以外の場合は 0 を返します。UInt8

使用例

3-gram を使用した UTF-8 検索

SELECT ngramSearchUTF8('абвгдеёжз', 'гдеёзд')

┌─ngramSearchUTF8('абвгдеёжз', 'гдеёзд')─┐
│                                      1 │
└────────────────────────────────────────┘

notILike​

導入バージョン: v20.6

文字列がパターンに一致しないかどうかを、大文字小文字を区別せずにチェックします。パターンには、SQL の LIKE 照合用の特殊文字 % と _ を含めることができます。

構文

notILike(haystack, pattern)

引数

  • haystack — 検索対象の入力文字列。String または FixedString
  • pattern — 照合に使用する SQL の LIKE パターン。% は任意の文字列（長さ 0 を含む）に一致し、_ はちょうど 1 文字に一致する。String

戻り値

文字列がパターンと一致しない場合は 1 を返し（一致判定は大文字小文字を区別しない）、それ以外の場合は 0 を返す。UInt8

使用例

使用方法の例

SELECT notILike('ClickHouse', '%house%');

┌─notILike('Cl⋯ '%house%')─┐
│                        0 │
└──────────────────────────┘

notLike​

導入: v1.1

like と同様ですが、結果を否定します。

構文

notLike(haystack, pattern)
-- haystack NOT LIKE pattern

引数

  • haystack — 検索を実行する対象の文字列。String または FixedString
  • pattern — 照合に使用する LIKE パターン文字列。String

戻り値

文字列が LIKE パターンに一致しない場合は 1、それ以外は 0 を返します。UInt8

例

使用例

SELECT notLike('ClickHouse', '%House%');

┌─notLike('Cli⋯ '%House%')─┐
│                        0 │
└──────────────────────────┘

マッチしないパターン

SELECT notLike('ClickHouse', '%SQL%');

┌─notLike('Cli⋯', '%SQL%')─┐
│                        1 │
└──────────────────────────┘

position​

導入バージョン: v1.1

文字列 haystack の中で、部分文字列 needle が現れる位置（バイト単位、1 始まり）を返します。

部分文字列 needle が空文字の場合、次のルールが適用されます:

  • start_pos が指定されていない場合: 1 を返す
  • start_pos = 0 の場合: 1 を返す
  • start_pos >= 1 かつ start_pos <= length(haystack) + 1 の場合: start_pos を返す
  • それ以外の場合: 0 を返す

同じルールは、関数 locate、positionCaseInsensitive、positionUTF8、positionCaseInsensitiveUTF8 にも適用されます。

構文

position(haystack, needle[, start_pos])

引数

  • haystack — 検索を実行する文字列。String または Enum
  • needle — 検索対象の部分文字列。String
  • start_pos — 検索を開始する haystack 内の位置 (1 始まり)。省略可能。UInt

戻り値

部分文字列が見つかった場合、その開始位置をバイト単位で 1 から数えた値として返し、見つからなかった場合は 0 を返します。UInt64

例

基本的な使用例

SELECT position('Hello, world!', '!')

┌─position('Hello, world!', '!')─┐
│                             13 │
└────────────────────────────────┘

start_pos 引数ありの場合

SELECT position('Hello, world!', 'o', 1), position('Hello, world!', 'o', 7)

┌─position('Hello, world!', 'o', 1)─┬─position('Hello, world!', 'o', 7)─┐
│                                 5 │                                 9 │
└───────────────────────────────────┴───────────────────────────────────┘

needle IN haystack 構文

SELECT 6 = position('/' IN s) FROM (SELECT 'Hello/World' AS s)

┌─equals(6, position(s, '/'))─┐
│                           1 │
└─────────────────────────────┘

空の検索文字列

SELECT position('abc', ''), position('abc', '', 0), position('abc', '', 1), position('abc', '', 2), position('abc', '', 3), position('abc', '', 4), position('abc', '', 5)

┌─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

position と同様で、比較時に大文字と小文字を区別しません。

構文

positionCaseInsensitive(haystack, needle[, start_pos])

別名: instr

引数

  • haystack — 検索を行う文字列。String または Enum
  • needle — 検索対象の部分文字列。String
  • start_pos — 省略可。検索を開始する haystack 内の位置 (1 を起点とする)。UInt*

戻り値

部分文字列が見つかった場合は、1 を起点とするバイト単位の開始位置を返し、見つからなかった場合は 0 を返します。UInt64

例

大文字と小文字を区別しない検索

SELECT positionCaseInsensitive('Hello, world!', 'hello')

┌─positionCaseInsensitive('Hello, world!', 'hello')─┐
│                                                 1 │
└───────────────────────────────────────────────────┘

positionCaseInsensitiveUTF8​

導入バージョン: v1.1

positionUTF8 と同様ですが、大文字小文字を区別せずに検索します。

構文

positionCaseInsensitiveUTF8(haystack, needle[, start_pos])

引数

  • haystack — 検索対象となる文字列。String または Enum
  • needle — 検索する部分文字列。String
  • start_pos — 省略可能。検索を開始する haystack 内の位置 (1 起算)。UInt*

返される値

部分文字列が見つかった場合は、1 起算のバイトオフセットを返し、見つからなかった場合は 0 を返します。UInt64

例

大文字・小文字を区別しない UTF-8 検索

SELECT positionCaseInsensitiveUTF8('Привет мир', 'МИР')

┌─positionCaseInsensitiveUTF8('Привет мир', 'МИР')─┐
│                                                8 │
└──────────────────────────────────────────────────┘

positionUTF8​

導入: v1.1

position と同様ですが、haystack および needle が UTF-8 でエンコードされた文字列であることを前提とします。

構文

positionUTF8(haystack, needle[, start_pos])

引数

  • haystack — 検索を行う文字列。String または Enum
  • needle — 検索対象の部分文字列。String
  • start_pos — 省略可能。検索を開始する haystack 内の位置（1 始まり）。UInt*

戻り値

部分文字列が見つかった場合は、1 から数えたバイト単位の開始位置を返し、見つからなかった場合は 0 を返します。UInt64

例

UTF-8 文字数のカウント

SELECT positionUTF8('Motörhead', 'r')

┌─position('Motörhead', 'r')─┐
│                          5 │
└────────────────────────────┘