Skip to content
ClickHouse Docs
ClickHouse DocsClickHouse Docs
49.6kGet Started

文字列検索関数

View as MarkdownEdit this pageReport an issueSet up docs MCP

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

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

一般的な文字列関数 と 文字列内置換関数 については、別途説明しています。

countMatches

導入バージョン: v21.1.0

文字列内で正規表現に一致する回数を返します。

構文

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.0

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.0

文字列 haystack に部分文字列 needle が含まれる回数を返します。

構文

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.0

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

構文

countSubstringsCaseInsensitive(haystack, needle[, start_pos])

引数

  • haystack — 検索対象の文字列。String または Enum
  • needle — 検索する部分文字列。String
  • start_pos — 任意。haystack 内で検索を開始する位置 (1始まり) 。UInt*

戻り値

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

例

使用例

SELECT countSubstringsCaseInsensitive('AAAA', 'aa');
┌─countSubstringsCaseInsensitive('AAAA', 'aa')─┐
│                                            2 │
└──────────────────────────────────────────────┘

start_pos 引数を指定した場合

SELECT countSubstringsCaseInsensitive('abc___ABC___abc', 'abc', 4);
┌─countSubstringsCaseInsensitive('abc___ABC___abc', 'abc', 4)─┐
│                                                           2 │
└─────────────────────────────────────────────────────────────┘

countSubstringsCaseInsensitiveUTF8

導入バージョン: v21.1.0

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('ложка, кошка, картошка', 'КА');
┌─countSubstringsCaseInsensitiveUTF8('ложка, кошка, картошка', 'КА')─┐
│                                                                  4 │
└────────────────────────────────────────────────────────────────────┘

start_pos 引数を使用する場合

SELECT countSubstringsCaseInsensitiveUTF8('ложка, кошка, картошка', 'КА', 13);
┌─countSubstringsCaseInsensitiveUTF8('ложка, кошка, картошка', 'КА', 13)─┐
│                                                                      2 │
└────────────────────────────────────────────────────────────────────────┘

extract

導入バージョン: v1.1.0

文字列内で、正規表現に最初に一致した部分文字列を抽出します。 'haystack' が 'pattern' に一致しない場合は、空文字列が返されます。

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

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

構文

extract(haystack, pattern)

引数

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

戻り値

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

例

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

SELECT extract('test@clickhouse.com', '.*@(.*)$')
┌─extract('test@clickhouse.com', '.*@(.*)$')─┐
│ clickhouse.com                             │
└────────────────────────────────────────────┘

一致しない場合は空文字列を返す

SELECT extract('test@clickhouse.com', 'no_match')
┌─extract('test@clickhouse.com', 'no_match')─┐
│                                            │
└────────────────────────────────────────────┘

extractAll

導入バージョン: v1.1.0

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('test@example.com, user@domain.org', '([a-zA-Z0-9]+)@')
┌─extractAll('test@example.com, user@domain.org', '([a-zA-Z0-9]+)@')─┐
│ ['test','user']                                                    │
└────────────────────────────────────────────────────────────────────┘

extractAllGroupsHorizontal

導入バージョン: v20.5.0

指定した正規表現を使って文字列内のすべてのグループにマッチし、配列の配列を返します。各配列には、同じキャプチャグループで取得されたすべてのキャプチャが、グループ番号順に格納されます。

構文

extractAllGroupsHorizontal(s, regexp)

引数

戻り値

配列の配列を返します。各内部配列には、すべての一致にわたる1つのキャプチャグループのすべてのキャプチャが含まれます。最初の内部配列にはグループ 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.0

正規表現に一致した最初の部分文字列からキャプチャリンググループを抽出します。すべての一致からグループを抽出するには、extractAllGroupsHorizontal または extractAllGroupsVertical を使用します。

構文

extractGroups(s, regexp)

引数

戻り値

正規表現に一致した場合、最初の一致におけるキャプチャグループ (1 から N。N は regexp 内のキャプチャグループ数) の配列を返します。一致しない場合は、空の配列を返します。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 extractGroups(s, '< ([\\w\\-]+): ([^\\r\\n]+)');
['Server','nginx']

hasAllTokens

導入バージョン: v25.10.0

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

検索前に、この関数はトークン化を行い、

  • input 引数 (常に) と
  • needle 引数 (String として指定された場合) は、 テキスト索引で指定されたトークナイザーを使用して処理されます。 カラムにテキスト索引が定義されていない場合は、代わりに splitByNonAlpha トークナイザーが使用されます。 needle 引数の型が Array(String) の場合、配列の各要素はトークンとして扱われ、追加のトークン化は行われません。 テキスト索引に プリプロセッサ 式が設定されている場合、needle (String として指定された場合) にはトークン化の前にプリプロセッサが適用されます。 テキスト索引に ポストプロセッサ 式が設定されている場合、needle のトークンと input のトークンの両方 (つまり、どちらもトークン化後) にポストプロセッサが適用されます。

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

構文

hasAllTokens(input, needles[, tokenizer])

別名: hasAllToken

引数

戻り値

すべてのneedleが一致する場合は1を返します。そうでない場合は0を返します。UInt8

例

文字列のニードルを使った基本的な使い方

DROP TABLE IF EXISTS doc;

CREATE TABLE doc (
    id UInt32,
    msg String,
    INDEX idx(msg) TYPE text(tokenizer = splitByString(['()', '\\']))
)
ENGINE = MergeTree
ORDER BY id;

INSERT INTO doc VALUES (1, '()a,\\bc()d'), (2, '()\\a()bc\\d'), (3, ',()a\\,bc,(),d,');

SELECT count() FROM doc WHERE hasAllTokens(msg, 'a\\d()');
┌─count()─┐
│       1 │
└─────────┘

Array内で AS-IS (トークン化なし) で検索する needles を指定する

DROP TABLE IF EXISTS doc;

CREATE TABLE doc (
    id UInt32,
    msg String,
    INDEX idx(msg) TYPE text(tokenizer = splitByString(['()', '\\']))
)
ENGINE = MergeTree
ORDER BY id;

INSERT INTO doc VALUES (1, '()a,\\bc()d'), (2, '()\\a()bc\\d'), (3, ',()a\\,bc,(),d,');

SELECT count() FROM doc WHERE hasAllTokens(msg, ['a', 'd']);
┌─count()─┐
│       1 │
└─────────┘

tokens 関数を使って needles を生成する

DROP TABLE IF EXISTS doc;

CREATE TABLE doc (
    id UInt32,
    msg String,
    INDEX idx(msg) TYPE text(tokenizer = splitByString(['()', '\\']))
)
ENGINE = MergeTree
ORDER BY id;

INSERT INTO doc VALUES (1, '()a,\\bc()d'), (2, '()\\a()bc\\d'), (3, ',()a\\,bc,(),d,');

SELECT count() FROM doc WHERE hasAllTokens(msg, tokens('a()d', 'splitByString', ['()', '\\']));
┌─count()─┐
│       1 │
└─────────┘

第3引数でカスタムトークナイザーを使用する

SELECT hasAllTokens('abcdef', 'abc', 'ngrams(3)');
┌─hasAllTokens('abcdef', 'abc', 'ngrams(3)')─┐
│                                          1 │
└────────────────────────────────────────────┘

Array と Map カラムの使用例

DROP TABLE IF EXISTS log;

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

Array型のカラムの例

DROP TABLE IF EXISTS log;

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の使用例

DROP TABLE IF EXISTS log;

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(mapKeys(attributes), ['address', 'log_level']);
┌─count()─┐
│       1 │
└─────────┘

mapValues の例

DROP TABLE IF EXISTS log;

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(mapValues(attributes), ['192.0.0.1', 'DEBUG']);
┌─count()─┐
│       0 │
└─────────┘

hasAnyTokens

導入バージョン: v25.10.0

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

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

  • input 引数 (常に必要) と
  • needle 引数 (String として指定された場合) は、 テキスト索引で指定されたトークナイザーを使用して処理されます。 カラムにテキスト索引が定義されていない場合は、代わりに splitByNonAlpha トークナイザーが使用されます。 needle 引数の型が Array(String) の場合、配列の各要素はトークンとして扱われ、追加のトークン化は行われません。 テキスト索引に プリプロセッサ の式が設定されている場合、needle (String として指定された場合) には、トークン化の前にプリプロセッサが適用されます。 テキスト索引に ポストプロセッサ の式が設定されている場合、トークン化の後にポストプロセッサが needle のトークンと input のトークンの両方に適用されます。

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

構文

hasAnyTokens(input, needles[, tokenizer])

別名: hasAnyToken

引数

戻り値

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

例

文字列のneedleを使った基本的な使い方

DROP TABLE IF EXISTS doc;

CREATE TABLE doc (
    id UInt32,
    msg String,
    INDEX idx(msg) TYPE text(tokenizer = splitByString(['()', '\\']))
)
ENGINE = MergeTree
ORDER BY id;

INSERT INTO doc VALUES (1, '()a,\\bc()d'), (2, '()\\a()bc\\d'), (3, ',()a\\,bc,(),d,');

SELECT count() FROM doc WHERE hasAnyTokens(msg, 'a\\d()');
┌─count()─┐
│       3 │
└─────────┘

配列内でAS-IS (トークン化なし) として検索する検索語を指定する

DROP TABLE IF EXISTS doc;

CREATE TABLE doc (
    id UInt32,
    msg String,
    INDEX idx(msg) TYPE text(tokenizer = splitByString(['()', '\\']))
)
ENGINE = MergeTree
ORDER BY id;

INSERT INTO doc VALUES (1, '()a,\\bc()d'), (2, '()\\a()bc\\d'), (3, ',()a\\,bc,(),d,');

SELECT count() FROM doc WHERE hasAnyTokens(msg, ['a', 'd']);
┌─count()─┐
│       3 │
└─────────┘

tokens 関数で needle を生成する

DROP TABLE IF EXISTS doc;

CREATE TABLE doc (
    id UInt32,
    msg String,
    INDEX idx(msg) TYPE text(tokenizer = splitByString(['()', '\\']))
)
ENGINE = MergeTree
ORDER BY id;

INSERT INTO doc VALUES (1, '()a,\\bc()d'), (2, '()\\a()bc\\d'), (3, ',()a\\,bc,(),d,');

SELECT count() FROM doc WHERE hasAnyTokens(msg, tokens('a()d', 'splitByString', ['()', '\\']));
┌─count()─┐
│       3 │
└─────────┘

ArrayカラムとMapカラムの使用例

DROP TABLE IF EXISTS log;

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

Arrayカラムを使った例

DROP TABLE IF EXISTS log;

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を使った例

DROP TABLE IF EXISTS log;

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(mapKeys(attributes), ['address', 'log_level']);
┌─count()─┐
│       2 │
└─────────┘

mapValuesを使った例

DROP TABLE IF EXISTS log;

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(mapValues(attributes), ['192.0.0.1', 'DEBUG']);
┌─count()─┐
│       2 │
└─────────┘

hasPhrase

導入バージョン: v26.4.0

input に、phrase 内のすべての トークン が連続した順序で含まれているかどうかを確認します。

検索を行う前に、この関数はテキスト索引に指定されたトークナイザーを使用して、input 引数と phrase 引数の両方をトークン化します。 カラムにテキスト索引が定義されていない場合は、省略可能な第 3 引数としてトークナイザーが指定されていない限り、代わりに splitByNonAlpha トークナイザーが使用されます。 トークナイザー引数には、splitByNonAlpha、splitByString、splitByRegexp、ngrams、asciiCJK、icu のいずれかを指定する必要があります。 テキスト索引でもポストプロセッサが定義されている場合、hasPhrase では splitByRegexp がサポートされないことに注意してください。

hasToken、hasAnyTokens、hasAllTokens とは異なり、hasPhrase では トークン が同じ順序で現れ、 その間に別の トークン が挟まらないことが必要です。たとえば、hasPhrase('the quick brown fox', 'quick fox') は 0 を返します。 これは、"quick" と "fox" の間に "brown" があるためです。

構文

hasPhrase(input, phrase[, tokenizer])

別名: matchPhrase

引数

  • input — 入力カラム。String または FixedString
  • phrase — 検索対象のフレーズ。const String
  • tokenizer — 使用するトークナイザー。省略可能で、デフォルト値は splitByNonAlpha です。const String

戻り値

フレーズが連続したトークン列として見つかった場合は 1、それ以外の場合は 0 を返します。UInt8

例

フレーズマッチ

SELECT hasPhrase('the quick brown fox jumps', 'quick brown')
┌─hasPhrase('the quick brown fox jumps', 'quick brown')─┐
│                                                     1 │
└───────────────────────────────────────────────────────┘

非連続のトークン

SELECT hasPhrase('the quick brown fox jumps', 'quick fox')
┌─hasPhrase('the quick brown fox jumps', 'quick fox')─┐
│                                                   0 │
└─────────────────────────────────────────────────────┘

hasSubsequence

導入バージョン: v23.7.0

needle が haystack の部分列であるかどうかを判定します。 文字列の部分列とは、残っている文字の順序を変えずに、一部の文字、またはまったく文字を削除せずに別の文字列から得られる列のことです。

構文

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.0

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

構文

hasSubsequenceCaseInsensitive(haystack, needle)

引数

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

戻り値

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

例

使用例

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

hasSubsequenceCaseInsensitiveUTF8

導入バージョン: v23.7.0

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

構文

hasSubsequenceCaseInsensitiveUTF8(haystack, needle)

引数

  • haystack — 検索対象の UTF8 でエンコードされた文字列。String
  • needle — 検索する UTF8 でエンコードされた部分列。String

戻り値

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

例

使用例

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

hasSubsequenceUTF8

導入バージョン: v23.7.0

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

構文

hasSubsequenceUTF8(haystack, needle)

引数

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

戻り値

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

例

使用例

SELECT hasSubsequenceUTF8('картошка', 'кошка');
┌─hasSubsequenceUTF8('картошка', 'кошка')─┐
│                                       1 │
└─────────────────────────────────────────┘

不一致の部分列

SELECT hasSubsequenceUTF8('картошка', 'апельсин');
┌─hasSubsequenceUTF8('картошка', 'апельсин')─┐
│                                          0 │
└────────────────────────────────────────────┘

hasToken

導入バージョン: v20.1.0

指定されたトークンが検索対象文字列内に存在するかどうかを確認します。

トークナイザーとして 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

導入バージョン: v20.1.0

tokenbf_v1 索引を使用して、haystack 内の needle の大文字と小文字を区別しないルックアップを実行します。

構文

hasTokenCaseInsensitive(haystack, needle)

引数

  • なし。

戻り値

例

hasTokenCaseInsensitiveOrNull

導入バージョン: v23.1.0

tokenbf_v1 索引を使用して、haystack 内の needle の大文字と小文字を区別しないルックアップを実行します。needle の形式が不正な場合は null を返します。

構文

hasTokenCaseInsensitiveOrNull(haystack, needle)

引数

  • なし。

戻り値

例

hasTokenOrNull

導入バージョン: v20.1.0

hasToken と同様ですが、token の形式が不正な場合は NULL を返します。

構文

hasTokenOrNull(haystack, token)

引数

  • haystack — 検索対象の文字列。定数である必要があります。String
  • token — 検索するトークン。const String

戻り値

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

例

使用例

SELECT hasTokenOrNull('apple banana cherry', 'ban ana');
┌─hasTokenOrNull('apple banana cherry', 'ban ana')─┐
│                                             ᴺᵁᴸᴸ │
└──────────────────────────────────────────────────┘

highlight

導入バージョン: v26.4.0

テキスト文字列内で検索語が出現した箇所を HTML タグで囲み、強調表示します。

この関数は、ASCII の大文字と小文字を区別しない照合を行います。複数の検索語がテキスト内で重なっている場合や隣接している場合、マッチした領域は 1 つの強調表示された span にまとめられます。

構文

highlight(haystack, needles[, open_tag, close_tag])

引数

  • haystack — 検索対象のテキストです。String または FixedString
  • needles — 強調表示する検索語の配列です。const Array(String)
  • open_tag — 各一致箇所の前に挿入する開始タグです。既定値: <em>。const String
  • close_tag — 各一致箇所の後に挿入する終了タグです。既定値: </em>。const String

戻り値

一致した語句を指定したタグで囲んだ入力テキストを返します。String

例

基本的なハイライト

SELECT highlight('The quick brown fox', ['quick', 'fox'])
┌─highlight('The quick brown fox', ['quick', 'fox'])─┐
│ The <em>quick</em> brown <em>fox</em>              │
└────────────────────────────────────────────────────┘

カスタムタグ

SELECT highlight('Hello World', ['hello'], '<b>', '</b>')
┌─highlight('Hello World', ['hello'], '<b>', '</b>')─┐
│ <b>Hello</b> World                                 │
└────────────────────────────────────────────────────┘

ilike

導入バージョン: v20.6.0

like と同様ですが、大文字と小文字を区別せずに検索します。オプションの ESCAPE 句にも対応しています (like を参照) 。

構文

ilike(haystack, pattern[, escape_character])
-- haystack ILIKE pattern [ESCAPE 'escape_character']

引数

  • haystack — 検索対象の文字列。String または FixedString
  • pattern — 照合する LIKE パターン。String
  • escape_character — \ の代わりにエスケープ文字として使用する、省略可能な1文字の文字列。デフォルト: \。String

戻り値

文字列が LIKE パターンに一致する場合 (大文字と小文字を区別しない) は 1、それ以外の場合は 0 を返します。UInt8

例

使用例

SELECT ilike('ClickHouse', '%house%');
┌─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 のメタ文字です) に一致させるには、それぞれの前にバックスラッシュを付けます: \%、\_、\\。 バックスラッシュの直後の文字が %、_、\ 以外の場合、バックスラッシュは特別な意味を失い、リテラルとして解釈されます。

%needle% 形式の LIKE 式では、この関数は position 関数と同程度の速度で動作します。 それ以外の LIKE 式はすべて内部的に正規表現へ変換され、match 関数と同程度の性能で実行されます。

ESCAPE 句

省略可能な ESCAPE 句では、カスタムのエスケープ文字を指定します (ASCII 1 文字である必要があります)。 指定した場合、このカスタムのエスケープ文字は、% と _ のメタ文字をエスケープするためのデフォルトのバックスラッシュの代わりに使用されます。 エスケープ文字でエスケープできるものは 3 つあります: % (リテラルのパーセント記号)、_ (リテラルのアンダースコア)、およびそれ自身 (リテラルのエスケープ文字) です。 カスタムのエスケープ文字を使用する場合、バックスラッシュには特別な意味はなく、リテラル文字として扱われます。

構文

like(haystack, pattern[, escape_character])
-- haystack LIKE pattern [ESCAPE 'escape_character']

引数

  • haystack — 検索対象の文字列。String または FixedString
  • pattern — 照合する LIKE パターン。% (任意の文字数に一致) 、_ (任意の1文字に一致) 、およびエスケープ用の \ を含めることができます。String
  • escape_character — \ の代わりにエスケープ文字として使用する、省略可能な 1 文字の文字列。デフォルト: \。String

戻り値

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

例

使用例

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

単一文字のワイルドカード

SELECT like('ClickHouse', 'Click_ouse');
┌─like('ClickHouse', 'Click_ouse')─┐
│                                1 │
└──────────────────────────────────┘

マッチしないパターン

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

ESCAPE 句

SELECT '50%off' LIKE '50#%off' ESCAPE '#';
┌─like('50%off', '50#%off', '#')─┐
│                              1 │
└────────────────────────────────┘

locate

導入バージョン: v18.16.0

position と似ていますが、引数 haystack と locate の順序が逆になっています。

Syntax

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.0

指定した文字列が、指定した正規表現パターンに一致するかどうかを判定します。

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

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

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

このパターンはアンカーされません。文字列全体に一致させるには、^ と $ を使って自分でパターンをアンカーしてください。

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

代替の演算子構文: haystack REGEXP pattern または haystack ~ pattern (PostgreSQL スタイル) 。

構文

match(haystack, pattern)

別名: REGEXP_MATCHES

引数

  • haystack — パターンを検索する対象の文字列。 String
  • pattern — 正規表現のパターン。定数にすることも、カラムから取得することもできます。 String

戻り値

パターンに一致する場合は 1、そうでない場合は 0 を返します。 UInt8

例

基本的なパターン照合

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

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

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

部分文字列との一致

SELECT match('abcde', 'b.*d'), match('abcde', '^b.*d$')
┌─match('abcde', 'b.*d')─┬─match('abcde', '^b.*d$')─┐
│                      1 │                        0 │
└────────────────────────┴──────────────────────────┘

matchCaseInsensitive

導入バージョン: v26.8.0

match と似ていますが、大文字と小文字を区別せずに一致を判定します。

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

代替の演算子構文: haystack ~* pattern (PostgreSQL スタイル) 。

構文

matchCaseInsensitive(haystack, pattern)
-- haystack ~* pattern

引数

  • haystack — パターンを検索する対象の文字列。 String
  • pattern — 正規表現のパターン。定数にすることも、カラムから取得することもできます。 String

戻り値

大文字と小文字を区別せずにパターンに一致する場合は 1、そうでない場合は 0 を返します。 UInt8

例

使用例

SELECT matchCaseInsensitive('Hello World', 'hello.*'), 'Hello World' ~
┌─matchCaseInsensitive('Hello World', 'hello.*')─┬─matchCaseInsensitive('Hello World', 'HELLO.*')─┐
│                                              1 │                                              1 │
└────────────────────────────────────────────────┴────────────────────────────────────────────────┘

multiFuzzyMatchAllIndices

導入バージョン: v20.1.0

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

構文

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

Arguments

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

戻り値

指定した編集距離以内で、任意の順序で haystack に一致するすべてのインデックス (1 から始まる) の配列を返します。一致するものが見つからない場合は空の配列を返します。Array(UInt64)

Examples

Usage example

SELECT multiFuzzyMatchAllIndices('ClickHouse', 2, ['ClickHouse', 'ClckHouse', 'ClickHose', 'House']);
┌─multiFuzzyMatchAllIndices('ClickHouse', 2, ['ClickHouse', 'ClckHouse', 'ClickHose', 'House'])─┐
│ [3,1,4,2]                                                                                     │
└───────────────────────────────────────────────────────────────────────────────────────────────┘

multiFuzzyMatchAny

導入バージョン: v20.1.0

multiMatchAny と同様ですが、一定の編集距離内で、いずれかのパターンが対象文字列に一致した場合に 1 を返します。 この関数は hyperscan ライブラリの実験的機能に依存しているため、一部のエッジケースでは低速になることがあります。 パフォーマンスは編集距離の値や使用するパターンに依存しますが、非あいまい一致のバリアントと比べると常にコストが高くなります。

構文

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

引数

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

戻り値

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

例

使用例

SELECT multiFuzzyMatchAny('ClickHouse', 2, ['ClickHouse', 'ClckHouse', 'ClickHose']);
┌─multiFuzzyMatchAny('ClickHouse', 2, ['ClickHouse', 'ClckHouse', 'ClickHose'])─┐
│                                                                             1 │
└───────────────────────────────────────────────────────────────────────────────┘

multiFuzzyMatchAnyIndex

導入バージョン: v20.1.0

multiFuzzyMatchAny と同様ですが、一定の編集距離内で検索対象文字列に一致する任意の索引を返します。

構文

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

引数

  • haystack — 検索対象の String。String
  • distance — あいまい一致で許容される最大編集距離。UInt8
  • pattern — 照合するパターンの Array。Array(String)

戻り値

指定した編集距離以内で haystack に一致するパターンのいずれかの索引 (1 から始まる) を返します。一致するものがない場合は 0 を返します。UInt64

例

使用例

SELECT multiFuzzyMatchAnyIndex('ClickHouse', 2, ['ClckHouse', 'ClickHose', 'ClickHouse']);
┌─multiFuzzyMatchAnyIndex('ClickHouse', 2, ['ClckHouse', 'ClickHose', 'ClickHouse'])─┐
│                                                                                  2 │
└────────────────────────────────────────────────────────────────────────────────────┘

multiMatchAllIndices

導入バージョン: v20.1.0

multiMatchAny と同様ですが、検索対象文字列に一致したすべてのインデックスを、順不同の配列で返します。

構文

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

引数

  • haystack — 検索対象の文字列。String
  • pattern — 一致に使用する正規表現。String

戻り値

haystack に対して任意の順序で一致した、すべてのインデックス (1 から始まる) を格納した配列。一致が見つからない場合は空の配列を返します。Array(UInt64)

例

使用例

SELECT multiMatchAllIndices('ClickHouse', ['[0-9]', 'House', 'Click', 'ouse']);
┌─multiMatchAllIndices('ClickHouse', ['[0-9]', 'House', 'Click', 'ouse'])─┐
│ [3,2,4]                                                                 │
└─────────────────────────────────────────────────────────────────────────┘

multiMatchAny

導入バージョン: v20.1.0

複数の正規表現パターンのうち、少なくとも 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.0

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

構文

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

引数

  • haystack — 検索対象の文字列です。String
  • pattern — 照合する正規表現の配列です。Array(String)

戻り値

最初に一致したパターンの索引 (1 から始まる) を返します。どのパターンにも一致しない場合は 0 を返します。UInt64

例

使用例

SELECT multiMatchAnyIndex('ClickHouse', ['[0-9]', 'House', 'Click']);
┌─multiMatchAnyIndex('ClickHouse', ['[0-9]', 'House', 'Click'])─┐
│                                                             3 │
└───────────────────────────────────────────────────────────────┘

multiSearchAllPositions

導入バージョン: v20.1.0

position と同様ですが、haystack 文字列内の複数の needle 部分文字列それぞれの位置 (バイト単位、1 から開始) を配列で返します。

すべての multiSearch*() 関数でサポートされる needle の数は最大 2^8 個です。

構文

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

引数

  • haystack — 検索対象のString。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.0

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

構文

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

引数

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

戻り値

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

例

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

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

multiSearchAllPositionsCaseInsensitiveUTF8

導入バージョン: v20.1.0

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

構文

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

引数

  • haystack — 検索対象の UTF-8 でエンコードされた文字列。String
  • needle — 検索する UTF-8 でエンコードされた部分文字列の配列。Array(String)

戻り値

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

例

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

SELECT multiSearchAllPositionsCaseInsensitiveUTF8('Здравствуй, мир!', ['здравствуй', 'МИР']);
┌─multiSearchAllPositionsCaseInsensitiveUTF8('Здравствуй, мир!', ['здравствуй', 'МИР'])─┐
│ [1,13]                                                                                │
└───────────────────────────────────────────────────────────────────────────────────────┘

multiSearchAllPositionsUTF8

導入バージョン: v20.1.0

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.0

複数の needle 文字列のうち、少なくとも 1 つが haystack 文字列にマッチするかどうかを確認します。

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

構文

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

引数

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

戻り値

1 件以上一致した場合は 1、一致しなかった場合は 0 を返します。UInt8

例

いずれかに一致する検索

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

multiSearchAnyCaseInsensitive

導入バージョン: v20.1.0

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

構文

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

引数

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

戻り値

大文字と小文字を区別しない一致が 1 つ以上ある場合は 1、ない場合は 0 を返します。UInt8

例

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

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

multiSearchAnyCaseInsensitiveUTF8

導入バージョン: v20.1.0

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

構文

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

引数

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

戻り値

大文字と小文字を区別しない一致が少なくとも1つある場合は 1、ない場合は 0 を返します。 UInt8

例

UTF-8文字列 'Здравствуйте' に文字 'з' (小文字) が含まれているかを確認する

SELECT multiSearchAnyCaseInsensitiveUTF8('Здравствуйте',['з'])
┌─multiSearchAnyCaseInsensitiveUTF8('Здравствуйте', ['з'])─┐
│                                                        1 │
└──────────────────────────────────────────────────────────┘

multiSearchAnyUTF8

導入バージョン: v20.1.0

haystack と needle の部分文字列が UTF-8 でエンコードされた文字列であることを前提としている点を除き、multiSearchAny と同じです。

構文

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

引数

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

戻り値

少なくとも1件一致した場合は 1 を返し、一致しなかった場合は 0 を返します。 UInt8

例

UTF-8文字列 '你好，世界' ('Hello, world') について、文字列内に 你 または 界 が含まれているかを確認する例

SELECT multiSearchAnyUTF8('你好，世界', ['你', '界']) AS result
┌─result─┐
│      1 │
└────────┘

multiSearchFirstIndex

導入バージョン: v20.1.0

haystack 文字列内で複数の needle 文字列を検索し (大文字と小文字を区別) 、最初に見つかった needle の 1 から始まる位置を返します。

構文

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

引数

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

戻り値

haystack 内で最初に見つかった needle について、needles Array 内での 1 始まりの索引 (位置) を返します。needle が 1 つも見つからない場合は 0 を返します。検索では大文字と小文字を区別します。UInt64

例

使用例

SELECT multiSearchFirstIndex('ClickHouse Database', ['Click', 'Database', 'Server']);
┌─multiSearchFirstIndex('ClickHouse Database', ['Click', 'Database', 'Server'])─┐
│                                                                             1 │
└───────────────────────────────────────────────────────────────────────────────┘

大文字と小文字を区別する挙動

SELECT multiSearchFirstIndex('ClickHouse Database', ['CLICK', 'Database', 'Server']);
┌─multiSearchFirstIndex('ClickHouse Database', ['CLICK', 'Database', 'Server'])─┐
│                                                                             2 │
└───────────────────────────────────────────────────────────────────────────────┘

一致する項目が見つかりません

SELECT multiSearchFirstIndex('Hello World', ['goodbye', 'test']);
┌─multiSearchFirstIndex('Hello World', ['goodbye', 'test'])─┐
│                                                         0 │
└───────────────────────────────────────────────────────────┘

multiSearchFirstIndexCaseInsensitive

導入バージョン: v20.1.0

文字列 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']);
┌─multiSearchFirstIndexCaseInsensitive('hElLo WoRlD', ['World', 'Hello'])─┐
│                                                                       1 │
└─────────────────────────────────────────────────────────────────────────┘

multiSearchFirstIndexCaseInsensitiveUTF8

導入バージョン: v20.1.0

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

構文

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

引数

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

戻り値

haystack 内で最初に見つかった needle の 1 始まりの索引 (needles 配列内の位置) を返します。needle が 1 つも見つからない場合は 0 を返します。検索では大文字と小文字を区別せず、UTF-8 文字エンコーディングを考慮します。UInt64

例

使用例

SELECT multiSearchFirstIndexCaseInsensitiveUTF8('ClickHouse Database', ['CLICK', 'data', 'server']);
┌─multiSearchFirstIndexCaseInsensitiveUTF8('ClickHouse Database', ['CLICK', 'data', 'server'])─┐
│                                                                                            1 │
└──────────────────────────────────────────────────────────────────────────────────────────────┘

UTF-8の大文字・小文字の扱い

SELECT multiSearchFirstIndexCaseInsensitiveUTF8('Привет Мир', ['мир', 'ПРИВЕТ']);
┌─multiSearchFirstIndexCaseInsensitiveUTF8('Привет Мир', ['мир', 'ПРИВЕТ'])─┐
│                                                                         1 │
└───────────────────────────────────────────────────────────────────────────┘

一致する項目が見つかりません

SELECT multiSearchFirstIndexCaseInsensitiveUTF8('Hello World', ['goodbye', 'test']);
┌─multiSearchFirstIndexCaseInsensitiveUTF8('Hello World', ['goodbye', 'test'])─┐
│                                                                            0 │
└──────────────────────────────────────────────────────────────────────────────┘

multiSearchFirstIndexUTF8

導入バージョン: v20.1.0

文字列 haystack 内で最も左側に見つかった needle_i の索引 i (1 から始まる) を返し、見つからない場合は 0 を返します。 haystack と needle は UTF-8 でエンコードされた文字列であることを前提とします。

構文

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

引数

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

戻り値

見つかった最も左にある needle の索引 (1 から始まります) を返します。一致するものがない場合は 0 を返します。UInt8

例

使用例

SELECT multiSearchFirstIndexUTF8('Здравствуйте мир', ['мир', 'здравствуйте']);
┌─multiSearchFirstIndexUTF8('Здравствуйте мир', ['мир', 'здравствуйте'])─┐
│                                                                      1 │
└────────────────────────────────────────────────────────────────────────┘

multiSearchFirstPosition

導入バージョン: v20.1.0

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

関数 multiSearchFirstPositionCaseInsensitive、multiSearchFirstPositionUTF8、multiSearchFirstPositionCaseInsensitiveUTF8 は、この関数の大文字と小文字を区別しない版、UTF-8 版、またはその両方を提供します。

構文

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

引数

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

戻り値

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

例

最初の位置を検索

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

multiSearchFirstPositionCaseInsensitive

導入バージョン: v20.1.0

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

構文

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

引数

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

戻り値

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

例

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

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

multiSearchFirstPositionCaseInsensitiveUTF8

導入バージョン: v20.1.0

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

構文

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

引数

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

戻り値

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

例

指定したいずれかの needle に一致する UTF-8 文字列 'Здравствуй, мир' ('Hello, world') 内の最も左のオフセットを見つけます

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

multiSearchFirstPositionUTF8

導入バージョン: v20.1.0

multiSearchFirstPosition と同様ですが、haystack と needle は UTF-8 文字列であることを前提としています。

構文

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

引数

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

戻り値

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

例

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

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

ngramDistance

導入バージョン: v20.1.0

2つの文字列間の4-gram距離を計算します。 この距離は、2つの4-gramマルチセットの対称差を求め、その値をそれぞれの要素数の合計で正規化して算出します。 戻り値が小さいほど、文字列同士の類似度は高くなります。

大文字と小文字を区別しない検索や、UTF8 フォーマットで使用する場合は、ngramDistanceCaseInsensitive、ngramDistanceUTF8、ngramDistanceCaseInsensitiveUTF8 関数を使用してください。

構文

ngramDistance(haystack, needle)

引数

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

戻り値

0 から 1 までの Float32 型の数値を返します。戻り値が小さいほど、文字列の類似度は高くなります。Float32

例

4-gram 距離を計算

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

ngramDistanceCaseInsensitive

導入バージョン: v20.1.0

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.0

ngramDistance の、大文字と小文字を区別しない UTF-8 バリアントです。 needle および haystack は UTF-8 でエンコードされた文字列であることを前提とし、大文字と小文字は区別されません。 大文字と小文字を区別せずに、2 つの UTF-8 文字列間の 3-gram 距離を計算します。 戻り値が小さいほど、文字列同士の類似度は高くなります。

構文

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.0

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.0

2 つの文字列間の 4-gram 距離が、指定した閾値以下かどうかを判定します。

大文字と小文字を区別しない検索や、UTF8 フォーマットで使用する場合は、関数 ngramSearchCaseInsensitive、ngramSearchUTF8、ngramSearchCaseInsensitiveUTF8 を使用してください。

構文

ngramSearch(haystack, needle)

引数

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

戻り値

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

例

4-gramによる検索

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

ngramSearchCaseInsensitive

導入バージョン: v20.1.0

ngramSearch の大文字と小文字を区別しないバリアントを提供します。 needle 文字列と haystack 文字列の非対称差、つまり needle の N-gram 数から、共通する N-gram 数を needle の N-gram 数で正規化した値を差し引いた数を計算します。 2 つの文字列間の 4-gram 距離が、指定した閾値以下かどうかを、大文字と小文字を区別せずに判定します。

構文

ngramSearchCaseInsensitive(haystack, needle)

引数

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

戻り値

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

例

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

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

ngramSearchCaseInsensitiveUTF8

導入バージョン: v20.1.0

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('абвГДЕёжз', 'АбвгдЕЁжз')─┐
│                                               0.57142854 │
└──────────────────────────────────────────────────────────┘

ngramSearchUTF8

導入バージョン: v20.1.0

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('абвгдеёжз', 'гдеёзд')─┐
│                                    0.5 │
└────────────────────────────────────────┘

notILike

導入バージョン: v20.6.0

文字列がパターンに一致しないかどうかを、大文字と小文字を区別せずに判定します。パターンには、SQL の LIKE マッチングで使用する特殊文字 % と _ を含めることができます。省略可能な ESCAPE 句もサポートしています (like を参照)。

構文

notILike(haystack, pattern[, escape_character])
-- haystack NOT ILIKE pattern [ESCAPE 'escape_character']

引数

  • haystack — 検索対象の入力文字列です。String または FixedString
  • pattern — 照合する SQL の LIKE パターンです。% は任意の文字数 (0 文字を含む) に一致し、_ はちょうど 1 文字に一致します。String
  • escape_character — \ の代わりにエスケープ文字として使用する、省略可能な 1 文字の文字列です。デフォルトは \ です。String

戻り値

文字列がパターンに一致しない場合 (大文字と小文字を区別せずに照合) は 1 を返し、それ以外の場合は 0 を返します。UInt8

例

使用例

SELECT notILike('ClickHouse', '%house%');
┌─notILike('ClickHouse', '%house%')─┐
│                                 0 │
└───────────────────────────────────┘

notLike

導入バージョン: v1.1.0

like に似ていますが、結果を反転します。オプションの ESCAPE 句をサポートしています (like を参照) 。

構文

notLike(haystack, pattern[, escape_character])
-- haystack NOT LIKE pattern [ESCAPE 'escape_character']

引数

  • haystack — 検索対象の文字列。String または FixedString
  • pattern — 照合する LIKE パターン。String
  • escape_character — \ の代わりにエスケープ文字として使用する、省略可能な1文字の文字列。デフォルト: \。String

戻り値

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

例

使用例

SELECT notLike('ClickHouse', '%House%');
┌─notLike('ClickHouse', '%House%')─┐
│                                0 │
└──────────────────────────────────┘

マッチしないパターン

SELECT notLike('ClickHouse', '%SQL%');
┌─notLike('ClickHouse', '%SQL%')─┐
│                              1 │
└────────────────────────────────┘

notMatch

導入バージョン: v26.8.0

match と似ていますが、結果を否定します。文字列が正規表現パターンに一致しないことを確認します。

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

代替の演算子構文: haystack !~ pattern (PostgreSQL 形式) 。

構文

notMatch(haystack, pattern)
-- haystack !~ pattern

引数

  • haystack — パターンを検索する対象の文字列。 String
  • pattern — 正規表現のパターン。定数にすることも、カラムから取得することもできます。 String

戻り値

パターンに一致する場合は 0、そうでない場合は 1 を返します。 UInt8

例

使用例

SELECT notMatch('Hello World', 'Hello.*'), 'Hello World' !
┌─notMatch('Hello World', 'Hello.*')─┬─notMatch('Hello World', 'goodbye.*')─┐
│                                  0 │                                    1 │
└────────────────────────────────────┴──────────────────────────────────────┘

notMatchCaseInsensitive

導入バージョン: v26.8.0

matchCaseInsensitive と似ていますが、結果を否定します。文字列が正規表現パターンに大文字と小文字を区別せずに一致しないことを確認します。

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

代替の演算子構文: haystack !~* pattern (PostgreSQL 形式) 。

構文

notMatchCaseInsensitive(haystack, pattern)
-- haystack !~* pattern

引数

  • haystack — パターンを検索する対象の文字列。 String
  • pattern — 正規表現のパターン。定数にすることも、カラムから取得することもできます。 String

戻り値

大文字と小文字を区別せずにパターンに一致する場合は 0、そうでない場合は 1 を返します。 UInt8

例

使用例

SELECT notMatchCaseInsensitive('Hello World', 'hello.*'), 'Hello World' !
┌─notMatchCaseInsensitive('Hello World', 'hello.*')─┬─notMatchCaseInsensitive('Hello World', 'GOODBYE.*')─┐
│                                                 0 │                                                   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、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 が haystack 内にある場合の構文

SELECT 6 = position('/' IN s) FROM (SELECT 'Hello/World' AS s)
┌─equals(6, position(s, '/'))─┐
│                           1 │
└─────────────────────────────┘

needle 部分文字列が空の場合

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.0

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.0

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.0

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')
┌─positionUTF8('Motörhead', 'r')─┐
│                              5 │
└────────────────────────────────┘
Navigation