메인 콘텐츠로 건너뛰기
이 섹션의 모든 함수는 기본적으로 대소문자를 구분하여 검색합니다. 대소문자를 구분하지 않는 검색은 일반적으로 별도의 함수 변형으로 제공됩니다.
대소문자를 구분하지 않는 검색은 영어의 소문자-대문자 규칙을 따릅니다. 예를 들어 영어에서 대문자 i는 I이지만, 터키어에서는 İ입니다. 따라서 영어 이외의 언어에서는 예상과 다른 결과가 나올 수 있습니다.
이 섹션의 함수는 검색 대상 문자열(이 섹션에서는 haystack이라고 함)과 검색 문자열(이 섹션에서는 needle이라고 함)이 모두 단일 바이트로 인코딩된 텍스트라고 가정합니다. 이 가정이 위반되어도 예외는 발생하지 않으며 결과는 정의되지 않습니다. UTF-8로 인코딩된 문자열 검색은 일반적으로 별도의 함수 변형으로 제공됩니다. 마찬가지로 UTF-8 함수 변형을 사용하더라도 입력 문자열이 UTF-8로 인코딩된 텍스트가 아니면 예외는 발생하지 않으며 결과는 정의되지 않습니다. 또한 자동 유니코드 정규화는 수행되지 않지만, 이를 위해 normalizeUTF8*() 함수를 사용할 수 있습니다. 일반 문자열 함수와 문자열 내 치환 함수는 별도로 설명합니다.
아래 문서는 system.functions 시스템 테이블에서 생성되었습니다.

​
countMatches

도입 버전: v21.1.0 문자열에서 정규식과 일치하는 횟수를 반환합니다.
버전별 동작 차이이 함수의 동작은 ClickHouse 버전에 따라 달라집니다.
  • 버전 < v25.6에서는 패턴이 빈 문자열과 일치할 수 있더라도 첫 번째 빈 일치에서 개수 계산을 중단합니다.
  • 버전 >= 25.6에서는 빈 일치가 발생해도 함수 실행을 계속합니다. 기존 동작은 설정 count_matches_stop_at_empty_match = true를 사용해 복원할 수 있습니다;
구문 
countMatches(haystack, pattern)
인수
  • haystack — 검색 대상 문자열입니다. String
  • pattern — 정규식 패턴입니다. String
반환 값 찾은 일치 항목의 개수를 반환합니다. UInt64 예시 연속된 숫자 개수 세기
Query
SELECT countMatches('hello 123 world 456 test', '[0-9]+')
Response
┌─countMatches('hello 123 world 456 test', '[0-9]+')─┐
│                                                   2 │
└─────────────────────────────────────────────────────┘

​
countMatchesCaseInsensitive

도입 버전: v21.1.0 countMatches와 비슷하지만 대소문자를 구분하지 않고 일치를 수행합니다. 구문 
countMatchesCaseInsensitive(haystack, pattern)
인수
  • haystack — 검색할 문자열입니다. String
  • pattern — 정규식 패턴입니다. const String
반환 값 찾은 일치 항목의 개수를 반환합니다. UInt64 예시 대소문자를 구분하지 않고 개수 세기
Query
SELECT countMatchesCaseInsensitive('Hello HELLO world', 'hello')
Response
┌─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 예시 사용 예시
Query
SELECT countSubstrings('aaaa', 'aa');
Response
┌─countSubstrings('aaaa', 'aa')─┐
│                             2 │
└───────────────────────────────┘
start_pos 인수를 사용하는 경우
Query
SELECT countSubstrings('abc___abc', 'abc', 4);
Response
┌─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 예시 사용 예시
Query
SELECT countSubstringsCaseInsensitive('AAAA', 'aa');
Response
┌─countSubstri⋯AAA', 'aa')─┐
│                        2 │
└──────────────────────────┘
start_pos 인수를 사용하는 경우
Query
SELECT countSubstringsCaseInsensitive('abc___ABC___abc', 'abc', 4);
Response
┌─countSubstri⋯, '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 예시 사용 예시
Query
SELECT countSubstringsCaseInsensitiveUTF8('ложка, кошка, картошка', 'КА');
Response
┌─countSubstri⋯шка', 'КА')─┐
│                        4 │
└──────────────────────────┘
start_pos 인수를 사용하는 경우
Query
SELECT countSubstringsCaseInsensitiveUTF8('ложка, кошка, картошка', 'КА', 13);
Response
┌─countSubstri⋯, 'КА', 13)─┐
│                        2 │
└──────────────────────────┘

​
extract

도입 버전: v1.1.0 문자열에서 정규식의 첫 번째 일치 항목을 추출합니다. ‘haystack’이 ‘pattern’과 일치하지 않으면 빈 문자열을 반환합니다. 이 함수는 RE2 정규식 라이브러리를 사용합니다. 지원되는 구문은 re2를 참조하십시오. 정규식에 캡처 그룹(하위 패턴)이 있으면 이 함수는 첫 번째 캡처 그룹을 기준으로 입력 문자열을 일치시킵니다. 구문 
extract(haystack, pattern)
인수
  • haystack — 추출할 문자열입니다. String
  • pattern — 일반적으로 캡처 그룹을 포함하는 정규식입니다. const String
반환 값 추출된 부분 문자열을 반환합니다. String 예시 이메일에서 도메인 추출
Query
SELECT extract('test@clickhouse.com', '.*@(.*)$')
Response
┌─extract('test@clickhouse.com', '.*@(.*)$')─┐
│ clickhouse.com                            │
└───────────────────────────────────────────┘
일치하는 항목이 없으면 빈 문자열을 반환합니다
Query
SELECT extract('test@clickhouse.com', 'no_match')
Response
┌─extract('test@clickhouse.com', 'no_match')─┐
│                                            │
└────────────────────────────────────────────┘

​
extractAll

도입 버전: v1.1.0 extract와 비슷하지만, 문자열에서 정규식과 일치하는 모든 항목을 배열로 반환합니다. ‘haystack’이 ‘pattern’ 정규식과 일치하지 않으면 빈 배열을 반환합니다. 정규식에 캡처 그룹(하위 패턴)이 있으면, 이 함수는 입력 문자열에서 첫 번째 캡처 그룹과 일치하는 내용을 찾습니다. 구문 
extractAll(haystack, pattern)
인수
  • haystack — 조각을 추출할 원본 문자열입니다. String
  • pattern — 필요에 따라 캡처 그룹을 포함할 수 있는 정규식입니다. const String
반환 값 추출된 조각으로 이루어진 배열을 반환합니다. Array(String) 예시 모든 숫자 추출
Query
SELECT extractAll('hello 123 world 456', '[0-9]+')
Response
┌─extractAll('hello 123 world 456', '[0-9]+')─┐
│ ['123','456']                               │
└─────────────────────────────────────────────┘
캡처 그룹으로 추출
Query
SELECT extractAll('test@example.com, user@domain.org', '([a-zA-Z0-9]+)@')
Response
┌─extractAll('test@example.com, user@domain.org', '([a-zA-Z0-9]+)@')─┐
│ ['test','user']                                                    │
└────────────────────────────────────────────────────────────────────┘

​
extractAllGroupsHorizontal

도입 버전: v20.5.0 제공된 정규식을 사용해 문자열에서 모든 그룹 일치를 찾고, 각 배열에 동일한 캡처 그룹의 모든 캡처가 그룹 번호 순서대로 들어 있는 배열의 배열을 반환합니다. 구문 
extractAllGroupsHorizontal(s, regexp)
인수 반환 값 배열의 배열을 반환합니다. 각 내부 배열에는 모든 매치에서 동일한 캡처 그룹으로 추출된 값이 모두 포함됩니다. 첫 번째 내부 배열에는 그룹 1의 모든 캡처가, 두 번째 내부 배열에는 그룹 2의 모든 캡처가 포함되는 방식입니다. 일치하는 항목이 없으면 빈 배열을 반환합니다. Array(Array(String)) 예시 사용 예시
Query
WITH '< Server: nginx
< Date: Tue, 22 Jan 2019 00:26:14 GMT
< Content-Type: text/html; charset=UTF-8
< Connection: keep-alive
' AS s
SELECT extractAllGroupsHorizontal(s, '< ([\\w\\-]+): ([^\\r\\n]+)');
Response
[['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) 예시 사용 예시
Query
WITH '< Server: nginx
< Date: Tue, 22 Jan 2019 00:26:14 GMT
< Content-Type: text/html; charset=UTF-8
< Connection: keep-alive
' AS s
SELECT extractGroups(s, '< ([\\w\\-]+): ([^\\r\\n]+)');
Response
['Server','nginx']

​
hasAllTokens

도입 버전: v25.10.0 hasAnyTokens와 유사하지만, needle 문자열 또는 배열의 모든 토큰이 input 문자열과 일치하면 1을, 그렇지 않으면 0을 반환합니다. input이 컬럼인 경우, 해당 조건을 만족하는 모든 행을 반환합니다.
최적의 성능을 위해 컬럼 input에는 텍스트 인덱스가 정의되어 있어야 합니다. 텍스트 인덱스가 정의되어 있지 않으면 함수는 브루트 포스(전체 스캔) 방식으로 컬럼을 스캔하며, 이는 인덱스 조회보다 훨씬 느립니다.
검색 전에 함수가 토큰화를 수행합니다
  • input 인수(항상), 그리고
  • needle 인수(String로 지정된 경우)는 텍스트 인덱스에 지정된 토크나이저를 사용해 처리됩니다. 컬럼에 텍스트 인덱스가 정의되어 있지 않으면 대신 splitByNonAlpha 토크나이저가 사용됩니다. needle 인수가 Array(String) 타입이면 각 배열 요소가 토큰으로 간주되며, 추가 토큰화는 수행되지 않습니다.
중복된 토큰(token)은 무시됩니다. 예시: needles = [‘ClickHouse’, ‘ClickHouse’]는 [‘ClickHouse’]와 동일하게 처리됩니다. 구문 
hasAllTokens(input, needles)
별칭(Aliases): hasAllToken 인수
  • input — 입력 컬럼. String 또는 FixedString 또는 Array(String) 또는 Array(FixedString)
  • needles — 검색할 토큰. String 또는 Array(String)
  • tokenizer — 사용할 토크나이저입니다. 유효한 인수는 splitByNonAlpha, splitByString, asciiCJK, ngrams, sparseGrams, array입니다. 선택 사항이며, 명시적으로 설정하지 않으면 기본값으로 splitByNonAlpha가 사용됩니다. const String
반환 값 모든 needle이 일치하면 1을, 그렇지 않으면 0을 반환합니다. UInt8 예시 문자열 needle을 사용한 기본 사용법
Query
CREATE TABLE table (
    id UInt32,
    msg String,
    INDEX idx(msg) TYPE text(tokenizer = splitByString(['()', '\\']))
)
ENGINE = MergeTree
ORDER BY id;

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

SELECT count() FROM table WHERE hasAllTokens(msg, 'a\\d()');
Response
┌─count()─┐
│       1 │
└─────────┘
배열에서 있는 그대로(토큰화 없이) 검색할 needle을 지정합니다
Query
SELECT count() FROM table WHERE hasAllTokens(msg, ['a', 'd']);
Response
┌─count()─┐
│       1 │
└─────────┘
tokens 함수를 사용하여 needle 생성
Query
SELECT count() FROM table WHERE hasAllTokens(msg, tokens('a()d', 'splitByString', ['()', '\\']));
Response
┌─count()─┐
│       1 │
└─────────┘
3번째 인수로 사용자 정의 토크나이저 사용
Query
SELECT hasAllTokens('abcdef', 'abc', 'ngrams(3)');
Response
┌─hasAllTokens('abcdef', 'abc', 'ngrams(3)')─┐
│                                            1 │
└──────────────────────────────────────────────┘
배열 및 맵 컬럼의 사용 예시
Query
CREATE TABLE log (
    id UInt32,
    tags Array(String),
    attributes Map(String, String),
    INDEX idx_tags (tags) TYPE text(tokenizer = splitByNonAlpha),
    INDEX idx_attributes_keys mapKeys(attributes) TYPE text(tokenizer = array),
    INDEX idx_attributes_vals mapValues(attributes) TYPE text(tokenizer = array)
)
ENGINE = MergeTree
ORDER BY id;

INSERT INTO log VALUES
    (1, ['clickhouse', 'clickhouse cloud'], {'address': '192.0.0.1', 'log_level': 'INFO'}),
    (2, ['chdb'], {'embedded': 'true', 'log_level': 'DEBUG'});
Response
배열 컬럼 예시
Query
SELECT count() FROM log WHERE hasAllTokens(tags, 'clickhouse');
Response
┌─count()─┐
│       1 │
└─────────┘
mapKeys 사용 예시
Query
SELECT count() FROM log WHERE hasAllTokens(mapKeys(attributes), ['address', 'log_level']);
Response
┌─count()─┐
│       1 │
└─────────┘
mapValues를 사용한 예시
Query
SELECT count() FROM log WHERE hasAllTokens(mapValues(attributes), ['192.0.0.1', 'DEBUG']);
Response
┌─count()─┐
│       0 │
└─────────┘

​
hasAnyTokens

도입 버전: v25.10.0 needle 문자열 또는 배열의 토큰 중 하나 이상이 input 문자열과 일치하면 1을, 그렇지 않으면 0을 반환합니다. input이 컬럼인 경우 해당 조건을 만족하는 모든 행을 반환합니다.
최적의 성능을 위해 컬럼(column) input에는 텍스트 인덱스(text index)가 정의되어 있어야 합니다. 텍스트 인덱스가 정의되어 있지 않으면 이 함수는 컬럼에 대해 브루트 포스(전체 스캔)를 수행하며, 이는 인덱스 조회보다 몇 자릿수나 더 느립니다.
검색 전에 함수가 토큰화를 수행합니다
  • input 인수(항상)와
  • needle 인수(String로 지정된 경우)는 텍스트 인덱스에 지정된 토크나이저를 사용해 처리합니다. 컬럼에 텍스트 인덱스가 정의되어 있지 않으면 splitByNonAlpha 토크나이저를 대신 사용합니다. needle 인수가 Array(String) 타입이면 각 배열 요소를 토큰으로 간주하며, 추가 토큰화는 수행되지 않습니다.
중복된 토큰은 무시됩니다. 예시: [‘ClickHouse’, ‘ClickHouse’]는 [‘ClickHouse’]와 동일하게 처리됩니다. 구문 
hasAnyTokens(input, needles)
별칭(Aliases): hasAnyToken 인수 반환 값 일치하는 항목이 하나 이상 있으면 1을, 없으면 0을 반환합니다. UInt8 예시 문자열 needle을 사용한 기본 사용법
Query
CREATE TABLE table (
    id UInt32,
    msg String,
    INDEX idx(msg) TYPE text(tokenizer = splitByString(['()', '\\']))
)
ENGINE = MergeTree
ORDER BY id;

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

SELECT count() FROM table WHERE hasAnyTokens(msg, 'a\\d()');
Response
┌─count()─┐
│       3 │
└─────────┘
배열에서 검색할 needle을 토큰화 없이 있는 그대로 지정합니다
Query
SELECT count() FROM table WHERE hasAnyTokens(msg, ['a', 'd']);
Response
┌─count()─┐
│       3 │
└─────────┘
tokens 함수를 사용하여 needle 생성
Query
SELECT count() FROM table WHERE hasAnyTokens(msg, tokens('a()d', 'splitByString', ['()', '\\']));
Response
┌─count()─┐
│       3 │
└─────────┘
배열 및 맵 컬럼의 사용 예시
Query
CREATE TABLE log (
    id UInt32,
    tags Array(String),
    attributes Map(String, String),
    INDEX idx_tags (tags) TYPE text(tokenizer = splitByNonAlpha),
    INDEX idx_attributes_keys mapKeys(attributes) TYPE text(tokenizer = array),
    INDEX idx_attributes_vals mapValues(attributes) TYPE text(tokenizer = array)
)
ENGINE = MergeTree
ORDER BY id;

INSERT INTO log VALUES
    (1, ['clickhouse', 'clickhouse cloud'], {'address': '192.0.0.1', 'log_level': 'INFO'}),
    (2, ['chdb'], {'embedded': 'true', 'log_level': 'DEBUG'});
Response
배열 컬럼을 사용한 예시
Query
SELECT count() FROM log WHERE hasAnyTokens(tags, 'clickhouse');
Response
┌─count()─┐
│       1 │
└─────────┘
mapKeys 사용 예시
Query
SELECT count() FROM log WHERE hasAnyTokens(mapKeys(attributes), ['address', 'log_level']);
Response
┌─count()─┐
│       2 │
└─────────┘
mapValues를 사용한 예시
Query
SELECT count() FROM log WHERE hasAnyTokens(mapValues(attributes), ['192.0.0.1', 'DEBUG']);
Response
┌─count()─┐
│       2 │
└─────────┘

​
hasPhrase

도입 버전: v26.4.0 haystack에 phrase의 모든 토큰이 연속된 순서로 포함되어 있는지 확인합니다. 검색 전에 이 함수는 선택적 세 번째 인수로 지정한 토크나이저를 사용해 input 인수와 phrase 인수를 모두 토큰화합니다. 토크나이저 인수는 splitByNonAlpha, splitByString, ngrams, asciiCJK 중 하나여야 합니다. 토크나이저를 지정하지 않으면 기본적으로 splitByNonAlpha 토크나이저를 사용합니다. 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 예시 구문 일치
Query
SELECT hasPhrase('the quick brown fox jumps', 'quick brown')
Response
┌─hasPhrase('the quick brown fox jumps', 'quick brown')─┐
│                                                      1 │
└────────────────────────────────────────────────────────┘
연속되지 않는 토큰
Query
SELECT hasPhrase('the quick brown fox jumps', 'quick fox')
Response
┌─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 예시 기본 부분 수열 확인
Query
SELECT hasSubsequence('Hello World', 'HlWrd')
Response
┌─hasSubsequence('Hello World', 'HlWrd')─┐
│                                      1 │
└────────────────────────────────────────┘
부분 수열을 찾을 수 없습니다
Query
SELECT hasSubsequence('Hello World', 'xyz')
Response
┌─hasSubsequence('Hello World', 'xyz')─┐
│                                    0 │
└──────────────────────────────────────┘

​
hasSubsequenceCaseInsensitive

도입 버전: v23.7.0 hasSubsequence와 같지만 대소문자를 구분하지 않고 검색합니다. 구문 
hasSubsequenceCaseInsensitive(haystack, needle)
인수
  • haystack — 검색을 수행할 String입니다. String
  • needle — 검색할 부분 수열입니다. String
반환 값 needle이 haystack의 부분 수열이면 1을 반환하고, 그렇지 않으면 0을 반환합니다. UInt8 예시 사용 예시
Query
SELECT hasSubsequenceCaseInsensitive('garbage', 'ARG');
Response
┌─hasSubsequenceCaseInsensitive('garbage', 'ARG')─┐
│                                               1 │
└─────────────────────────────────────────────────┘

​
hasSubsequenceCaseInsensitiveUTF8

도입 버전: v23.7.0 hasSubsequenceUTF8와 동일하지만 대소문자를 구분하지 않고 검색합니다. 구문 
hasSubsequenceCaseInsensitiveUTF8(haystack, needle)
인수
  • haystack — 검색이 수행되는 UTF-8 인코딩 문자열입니다. String
  • needle — 검색할 UTF-8 인코딩 부분 수열 문자열입니다. String
반환 값 needle이 haystack의 부분 수열이면 1을, 그렇지 않으면 0을 반환합니다. UInt8 예시 사용 예시
Query
SELECT hasSubsequenceCaseInsensitiveUTF8('ClickHouse - столбцовая система управления базами данных', 'СИСТЕМА');
Response
┌─hasSubsequen⋯ 'СИСТЕМА')─┐
│                        1 │
└──────────────────────────┘

​
hasSubsequenceUTF8

도입 버전: v23.7.0 hasSubsequence와 유사하지만, 검색 대상 문자열과 needle이 UTF-8로 인코딩된 문자열이라고 가정합니다. 구문 
hasSubsequenceUTF8(haystack, needle)
인수
  • haystack — 검색할 대상 문자열입니다. String
  • needle — 검색할 부분수열입니다. String
반환 값 needle이 검색 대상 문자열의 부분수열이면 1을 반환하고, 그렇지 않으면 0을 반환합니다. UInt8 예시 사용 예시
Query
SELECT hasSubsequenceUTF8('картошка', 'кошка');
Response
┌─hasSubsequen⋯', 'кошка')─┐
│                        1 │
└──────────────────────────┘
일치하지 않는 부분수열
Query
SELECT hasSubsequenceUTF8('картошка', 'апельсин');
Response
┌─hasSubsequen⋯'апельсин')─┐
│                        0 │
└──────────────────────────┘

​
hasToken

도입 버전: v20.1.0 지정된 토큰이 검색 대상 문자열에 존재하는지 확인합니다. 토크나이저로 splitByNonAlpha를 사용합니다. 즉, 토큰은 연속된 문자 [0-9A-Za-z_](숫자, ASCII 문자, 밑줄)로 이루어진 가능한 가장 긴 부분 문자열로 정의됩니다. 구문 
hasToken(haystack, token)
인수
  • haystack — 검색 대상 문자열입니다. String
  • token — 찾을 토큰입니다. const String
반환 값 토큰을 찾으면 1을, 그렇지 않으면 0을 반환합니다. UInt8 예시 토큰 검색
Query
SELECT hasToken('clickhouse test', 'test')
Response
┌─hasToken('clickhouse test', 'test')─┐
│                                   1 │
└─────────────────────────────────────┘

​
hasTokenCaseInsensitive

도입 버전: v20.1.0 tokenbf_v1 인덱스를 사용하여 검색 대상 문자열에서 needle을 대소문자를 구분하지 않고 조회합니다. 구문 
hasTokenCaseInsensitive(haystack, needle)
인수
  • 없음.
반환 값 예시

​
hasTokenCaseInsensitiveOrNull

도입 버전: v23.1.0 tokenbf_v1 인덱스를 사용해 검색 대상 문자열에서 needle을 대소문자를 구분하지 않고 검색합니다. needle 형식이 올바르지 않으면 NULL을 반환합니다. 구문 
hasTokenCaseInsensitiveOrNull(haystack, needle)
인수
  • 없음.
반환 값 예시

​
hasTokenOrNull

도입 버전: v20.1.0 hasToken과 비슷하지만, token 형식이 올바르지 않으면 NULL을 반환합니다. 구문 
hasTokenOrNull(haystack, token)
인수
  • haystack — 검색 대상 문자열입니다. 상수여야 합니다. String
  • token — 검색할 토큰입니다. const String
반환 값 토큰을 찾으면 1, 찾지 못하면 0을 반환하며, 토큰 형식이 올바르지 않으면 NULL을 반환합니다. Nullable(UInt8) 예시 사용 예시
Query
SELECT hasTokenOrNull('apple banana cherry', 'ban ana');
Response
┌─hasTokenOrNu⋯ 'ban ana')─┐
│                     ᴺᵁᴸᴸ │
└──────────────────────────┘

​
highlight

도입 버전: v26.4.0 텍스트 문자열에서 검색어가 나타난 부분을 HTML 태그로 감싸 강조합니다. 이 함수는 ASCII 기준의 대소문자 비구분 일치를 수행합니다. 여러 검색어가 텍스트에서 서로 겹치거나 인접해 있으면, 일치한 영역은 하나의 강조 구간으로 머지됩니다. 구문 
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 예시 기본 강조
Query
SELECT highlight('The quick brown fox', ['quick', 'fox'])
Response
┌─highlight('The quick brown fox', ['quick', 'fox'])─┐
│ The <em>quick</em> brown <em>fox</em>              │
└────────────────────────────────────────────────────┘
사용자 지정 태그
Query
SELECT highlight('Hello World', ['hello'], '<b>', '</b>')
Response
┌─highlight('Hello World', ['hello'], '<b>', '</b>')─┐
│ <b>Hello</b> World                                 │
└────────────────────────────────────────────────────┘

​
ilike

도입 버전: v20.6.0 like와 같지만 대소문자를 구분하지 않고 검색합니다. 구문 
ilike(haystack, pattern)
-- haystack ILIKE pattern
인수
  • haystack — 검색을 수행할 String입니다. String 또는 FixedString
  • pattern — 일치 여부를 판단할 LIKE 패턴입니다. String
반환 값 문자열이 LIKE 패턴과 일치하면 1을, 그렇지 않으면 0을 반환합니다(대소문자를 구분하지 않음). UInt8 예시 사용 예시
Query
SELECT ilike('ClickHouse', '%house%');
Response
┌─ilike('ClickHouse', '%house%')─┐
│                              1 │
└────────────────────────────────┘

​
like

도입 버전: v1.1.0 문자열 haystack가 LIKE 표현식 pattern과 일치하는지 여부를 반환합니다. LIKE 표현식에는 일반 문자와 다음 메타기호를 포함할 수 있습니다.
  • %는 임의 개수의 임의 문자(0개 포함)를 나타냅니다.
  • _는 임의의 단일 문자를 나타냅니다.
  • \는 리터럴 %, _, \를 이스케이프하는 데 사용됩니다.
매칭은 UTF-8을 기준으로 수행됩니다. 예를 들어 _는 UTF-8에서 2바이트로 표현되는 유니코드 코드 포인트 ¥와 일치합니다. haystack 또는 LIKE 표현식이 올바른 UTF-8이 아니면 동작은 정의되지 않습니다. 유니코드 정규화는 자동으로 수행되지 않으므로, 필요하면 normalizeUTF8* 함수를 사용할 수 있습니다. 리터럴 %, _, \(LIKE 메타문자)과 일치시키려면 앞에 백슬래시를 붙이십시오: \%, \_, \\. 백슬래시는 %, _, \가 아닌 다른 문자 앞에 오면 특별한 의미를 잃고(즉, 리터럴로 해석되고) 처리됩니다.
ClickHouse에서는 문자열 안의 백슬래시도 따옴표로 묶어야 하므로, 실제로는 \\%, \\_, \\\\라고 작성해야 합니다.
%needle% 형태의 LIKE 표현식에서는 이 함수가 position 함수만큼 빠릅니다. 그 외의 모든 LIKE 표현식은 내부적으로 정규식으로 변환되며, match 함수와 비슷한 성능으로 실행됩니다. 구문 
like(haystack, pattern)
-- haystack LIKE pattern
인수
  • haystack — 검색할 문자열입니다. String 또는 FixedString
  • pattern — 매칭할 LIKE 패턴입니다. %(임의 개수의 문자와 일치), _(단일 문자와 일치), 이스케이프용 \를 포함할 수 있습니다. String
반환 값 문자열이 LIKE 패턴과 일치하면 1을, 그렇지 않으면 0을 반환합니다. UInt8 예시 사용 예시
Query
SELECT like('ClickHouse', '%House');
Response
┌─like('ClickHouse', '%House')─┐
│                            1 │
└──────────────────────────────┘
단일 문자 와일드카드
Query
SELECT like('ClickHouse', 'Click_ouse');
Response
┌─like('ClickH⋯lick_ouse')─┐
│                        1 │
└──────────────────────────┘
일치하지 않는 패턴
Query
SELECT like('ClickHouse', '%SQL%');
Response
┌─like('ClickHouse', '%SQL%')─┐
│                           0 │
└─────────────────────────────┘

​
locate

도입 버전: v18.16.0 position과 같지만 인수 haystack와 locate의 순서만 서로 바뀝니다.
버전에 따라 달라지는 동작이 함수의 동작은 ClickHouse 버전에 따라 달라집니다.
  • 버전 < v24.3에서는 locate가 함수 position의 별칭이었으며, 인수 (haystack, needle[, start_pos])를 받았습니다.
  • 버전 >= 24.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 예시 기본 사용법
Query
SELECT locate('ca', 'abcabc')
Response
┌─locate('ca', 'abcabc')─┐
│                      3 │
└────────────────────────┘

​
match

도입 버전: v1.1.0 주어진 문자열이 지정된 정규식 패턴과 일치하는지 확인합니다. 이 함수는 RE2 정규식 라이브러리를 사용합니다. 지원되는 구문은 re2를 참조하십시오. 매칭은 UTF-8을 전제로 동작합니다. 예를 들어 ¥는 내부적으로 2바이트를 사용하지만, 매칭 시에는 단일 코드포인트로 처리됩니다. 정규식에는 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 예시 기본 패턴 매칭
Query
SELECT match('Hello World', 'Hello.*')
Response
┌─match('Hello World', 'Hello.*')─┐
│                               1 │
└─────────────────────────────────┘
패턴이 일치하지 않음
Query
SELECT match('Hello World', 'goodbye.*')
Response
┌─match('Hello World', 'goodbye.*')─┐
│                                 0 │
└───────────────────────────────────┘
부분 문자열 매칭
Query
SELECT match('abcde', 'b.*d'), match('abcde', '^b.*d$')
Response
┌─match('abcde', 'b.*d')─┬─match('abcde', '^b.*d$')─┐
│                       1 │                         0 │
└─────────────────────────┴───────────────────────────┘

​
multiFuzzyMatchAllIndices

도입 버전: v20.1.0 multiFuzzyMatchAny와 비슷하지만, 상수 편집 거리 내에서 입력 문자열과 일치하는 모든 인덱스의 배열을 임의의 순서로 반환합니다. 구문 
multiFuzzyMatchAllIndices(haystack, distance, [pattern1, pattern2, ..., patternN])
인수
  • haystack — 검색을 수행할 String입니다. String
  • distance — 퍼지 매칭의 최대 편집 거리입니다. UInt8
  • pattern — 일치 여부를 확인할 패턴의 배열입니다. Array(String)
반환 값 지정된 편집 거리 내에서 검색 대상 문자열과 임의의 순서로 일치하는 모든 패턴의 인덱스(1부터 시작) 배열을 반환합니다. 일치하는 항목이 없으면 빈 배열을 반환합니다. Array(UInt64) 예시 사용 예시
Query
SELECT multiFuzzyMatchAllIndices('ClickHouse', 2, ['ClickHouse', 'ClckHouse', 'ClickHose', 'House']);
Response
┌─multiFuzzyMa⋯, 'House'])─┐
│ [3,1,4,2]                │
└──────────────────────────┘

​
multiFuzzyMatchAny

도입 버전: v20.1.0 multiMatchAny와 유사하지만, 고정된 편집 거리 내에서 패턴 중 하나라도 검색 대상 문자열과 일치하면 1을 반환합니다. 이 함수는 hyperscan 라이브러리의 실험적 기능에 의존하므로, 일부 예외적인 경우에는 느릴 수 있습니다. 성능은 편집 거리 값과 사용된 패턴에 따라 달라지지만, 비퍼지 변형과 비교하면 항상 더 많은 비용이 듭니다.
hyperscan의 제한으로 인해 multiFuzzyMatch*() 함수 계열은 UTF-8 정규식을 지원하지 않습니다(UTF-8 정규식을 바이트 시퀀스로 처리합니다).
구문 
multiFuzzyMatchAny(haystack, distance, [pattern1, pattern2, ..., patternN])
인수
  • haystack — 검색 대상 문자열입니다. String
  • distance — fuzzy matching의 최대 편집 거리입니다. UInt8
  • pattern — 선택 사항입니다. 일치 여부를 확인할 패턴 배열입니다. Array(String)
반환 값 지정된 편집 거리 이내에서 패턴 중 하나라도 검색 대상 문자열과 일치하면 1을, 그렇지 않으면 0을 반환합니다. UInt8 예시 사용 예시
Query
SELECT multiFuzzyMatchAny('ClickHouse', 2, ['ClickHouse', 'ClckHouse', 'ClickHose']);
Response
┌─multiFuzzyMa⋯lickHose'])─┐
│                        1 │
└──────────────────────────┘

​
multiFuzzyMatchAnyIndex

도입 버전: v20.1.0 multiFuzzyMatchAny와 비슷하지만, 고정된 편집 거리 내에서 검색 대상 문자열과 일치하는 임의의 인덱스를 반환합니다. 구문 
multiFuzzyMatchAnyIndex(haystack, distance, [pattern1, pattern2, ..., patternn])
인수
  • haystack — 검색이 수행되는 String입니다. String
  • distance — 퍼지 매칭의 최대 편집 거리입니다. UInt8
  • pattern — 매칭할 패턴의 배열입니다. Array(String)
반환 값 지정된 편집 거리 내에서 haystack과 일치하는 패턴이 있으면 해당 패턴의 인덱스(1부터 시작)를 반환하고, 없으면 0을 반환합니다. UInt64 예시 사용 예시
Query
SELECT multiFuzzyMatchAnyIndex('ClickHouse', 2, ['ClckHouse', 'ClickHose', 'ClickHouse']);
Response
┌─multiFuzzyMa⋯ickHouse'])─┐
│                        2 │
└──────────────────────────┘

​
multiMatchAllIndices

v20.1.0에서 도입됨 multiMatchAny와 비슷하지만, 검색 대상 문자열과 임의의 순서로 일치하는 모든 인덱스의 배열을 반환합니다. 구문 
multiMatchAllIndices(haystack, [pattern1, pattern2, ..., patternn])
인수
  • haystack — 검색을 수행할 String입니다. String
  • pattern — 매칭에 사용할 정규식입니다. String
반환 값 haystack와 임의의 순서로 매칭되는 모든 인덱스(1부터 시작)의 배열입니다. 일치하는 항목이 없으면 빈 배열을 반환합니다. Array(UInt64) 예시 사용 예시
Query
SELECT multiMatchAllIndices('ClickHouse', ['[0-9]', 'House', 'Click', 'ouse']);
Response
┌─multiMatchAl⋯', 'ouse'])─┐
│ [3, 2, 4]                │
└──────────────────────────┘

​
multiMatchAny

도입 버전: v20.1.0 여러 정규식 패턴 중 하나 이상이 입력 문자열과 일치하는지 확인합니다. 문자열에서 여러 부분 문자열만 검색하려는 경우에는 multiSearchAny 함수를 대신 사용할 수 있습니다. 이 함수가 훨씬 더 빠르게 동작합니다. 구문 
multiMatchAny(haystack, pattern1[, pattern2, ...])
인수
  • haystack — 패턴을 검색할 대상 String. String
  • pattern1[, pattern2, ...] — 하나 이상의 정규식 패턴으로 구성된 배열. Array(String)
반환 값 하나라도 패턴과 일치하면 1, 그렇지 않으면 0을 반환합니다. UInt8 예시 여러 패턴 매칭
Query
SELECT multiMatchAny('Hello World', ['Hello.*', 'foo.*'])
Response
┌─multiMatchAny('Hello World', ['Hello.*', 'foo.*'])─┐
│                                                  1 │
└────────────────────────────────────────────────────┘
일치하는 패턴이 없습니다
Query
SELECT multiMatchAny('Hello World', ['goodbye.*', 'foo.*'])
Response
┌─multiMatchAny('Hello World', ['goodbye.*', 'foo.*'])─┐
│                                                    0 │
└──────────────────────────────────────────────────────┘

​
multiMatchAnyIndex

도입 버전: v20.1.0 multiMatchAny와 비슷하지만, haystack에서 일치하는 임의의 인덱스를 반환합니다. 구문 
multiMatchAnyIndex(haystack, [pattern1, pattern2, ..., patternn])
인수
  • haystack — 검색을 수행할 String입니다. String
  • pattern — 매칭할 정규식입니다. Array(String)
반환 값 처음으로 일치하는 패턴의 인덱스(1부터 시작)를 반환합니다. 일치하는 패턴이 없으면 0을 반환합니다. UInt64 예시 사용 예시
Query
SELECT multiMatchAnyIndex('ClickHouse', ['[0-9]', 'House', 'Click']);
Response
┌─multiMatchAn⋯, 'Click'])─┐
│                        3 │
└──────────────────────────┘

​
multiSearchAllPositions

도입 버전: v20.1.0 position과 유사하지만, haystack 문자열에서 여러 needle 부분 문자열의 위치(바이트 단위, 1부터 시작)를 배열로 반환합니다. 모든 multiSearch*() 함수는 최대 2^8개의 needle만 지원합니다. 구문 
multiSearchAllPositions(haystack, needle1[, needle2, ...])
인수
  • haystack — 검색을 수행할 String입니다. String
  • needle1[, needle2, ...] — 검색할 하나 이상의 부분 문자열로 이루어진 배열입니다. Array(String)
반환 값 부분 문자열을 찾은 경우 시작 위치를 바이트 단위로 1부터 세어 배열로 반환하고, 찾지 못한 경우 0을 반환합니다. Array(UInt64) 예시 여러 needle 검색
Query
SELECT multiSearchAllPositions('Hello, World!', ['hello', '!', 'world'])
Response
┌─multiSearchAllPositions('Hello, World!', ['hello', '!', 'world'])─┐
│ [0,13,0]                                                          │
└───────────────────────────────────────────────────────────────────┘

​
multiSearchAllPositionsCaseInsensitive

도입 버전: v20.1.0 multiSearchAllPositions와 같지만 대소문자를 구분하지 않습니다. 구문 
multiSearchAllPositionsCaseInsensitive(haystack, needle1[, needle2, ...])
인수
  • haystack — 검색을 수행할 haystack입니다. String
  • needle1[, needle2, ...] — 검색할 하나 이상의 부분 문자열로 이루어진 배열입니다. Array(String)
반환 값 부분 문자열을 찾은 경우 바이트 단위 시작 위치를 담은 배열을 반환하며, 위치는 1부터 계산합니다. 부분 문자열을 찾지 못한 경우 0을 반환합니다. Array(UInt64) 예시 대소문자를 구분하지 않는 다중 검색
Query
SELECT multiSearchAllPositionsCaseInsensitive('ClickHouse',['c','h'])
Response
┌─multiSearchA⋯['c', 'h'])─┐
│ [1,6]                    │
└──────────────────────────┘

​
multiSearchAllPositionsCaseInsensitiveUTF8

도입 버전: v20.1.0 multiSearchAllPositionsUTF8와 같지만 대소문자를 구분하지 않습니다. 구문 
multiSearchAllPositionsCaseInsensitiveUTF8(haystack, [needle1, needle2, ..., needleN])
인수
  • haystack — 검색을 수행할 UTF-8 인코딩 문자열입니다. String
  • needle — 검색할 UTF-8 인코딩 needle입니다. Array(String)
반환 값 부분 문자열을 찾은 경우, 각 부분 문자열의 시작 위치를 바이트 단위의 1부터 시작하는 배열로 반환합니다. 부분 문자열을 찾지 못한 경우 0을 반환합니다. Array 예시 대소문자를 구분하지 않는 UTF-8 검색
Query
SELECT multiSearchAllPositionsCaseInsensitiveUTF8('Здравствуй, мир!', ['здравствуй', 'МИР']);
Response
┌─multiSearchA⋯й', 'МИР'])─┐
│ [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 다중 검색
Query
SELECT multiSearchAllPositionsUTF8('ClickHouse',['C','H'])
Response
┌─multiSearchAllPositionsUTF8('ClickHouse', ['C', 'H'])─┐
│ [1,6]                                                 │
└───────────────────────────────────────────────────────┘

​
multiSearchAny

도입 버전: v20.1.0 여러 needle 문자열 중 하나 이상이 haystack 문자열에서 일치하는지 확인합니다. 함수 multiSearchAnyCaseInsensitive, multiSearchAnyUTF8 및 multiSearchAnyCaseInsensitiveUTF8는 이 함수의 대소문자를 구분하지 않는 변형 및/또는 UTF-8 변형을 제공합니다. 구문 
multiSearchAny(haystack, needle1[, needle2, ...])
인수
  • haystack — 검색을 수행할 String입니다. String
  • needle1[, needle2, ...] — 검색할 하위 문자열의 배열입니다. Array(String)
반환 값 하나 이상 일치하면 1을, 그렇지 않으면 0을 반환합니다. UInt8 예시 하나 이상 일치 검색
Query
SELECT multiSearchAny('ClickHouse',['C','H'])
Response
┌─multiSearchAny('ClickHouse', ['C', 'H'])─┐
│                                        1 │
└──────────────────────────────────────────┘

​
multiSearchAnyCaseInsensitive

도입 버전: v20.1.0 multiSearchAny와 같지만 대소문자를 구분하지 않습니다. 구문 
multiSearchAnyCaseInsensitive(haystack, [needle1, needle2, ..., needleN])
인수
  • haystack — 검색을 수행할 String입니다. String
  • needle — 검색할 부분 문자열들입니다. Array(String)
반환 값 대소문자를 구분하지 않는 일치 항목이 하나 이상 있으면 1을, 그렇지 않으면 0을 반환합니다. UInt8 예시 대소문자를 구분하지 않는 검색
Query
SELECT multiSearchAnyCaseInsensitive('ClickHouse',['c','h'])
Response
┌─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을, 그렇지 않으면 0을 반환합니다. UInt8 예시 UTF-8 문자열 ‘Здравствуйте’가 주어졌을 때 소문자 ‘з’가 포함되어 있는지 확인합니다
Query
SELECT multiSearchAnyCaseInsensitiveUTF8('Здравствуйте',['з'])
Response
┌─multiSearchA⋯те', ['з'])─┐
│                        1 │
└──────────────────────────┘

​
multiSearchAnyUTF8

도입 버전: v20.1.0 multiSearchAny와 비슷하지만 haystack과 needle 부분 문자열은 UTF-8로 인코딩된 문자열이라고 가정합니다. 구문 
multiSearchAnyUTF8(haystack, [needle1, needle2, ..., needleN])
인수
  • haystack — 검색이 수행되는 UTF-8 문자열입니다. String
  • needle — 검색할 UTF-8 부분 문자열들입니다. Array(String)
반환 값 일치하는 항목이 하나 이상 있으면 1을, 없으면 0을 반환합니다. UInt8 예시 UTF-8 문자열 ‘你好，世界’ (‘Hello, world’)가 주어졌을 때, 문자열에 你 또는 界 문자가 포함되어 있는지 확인합니다
Query
SELECT multiSearchAnyUTF8('你好，世界', ['你', '界'])
Response
┌─multiSearchA⋯你', '界'])─┐
│                        1 │
└──────────────────────────┘

​
multiSearchFirstIndex

도입 버전: v20.1.0 haystack 문자열에서 여러 needle 문자열을 검색하고(대소문자 구분), 가장 먼저 발견된 needle의 1부터 시작하는 인덱스를 반환합니다. 구문 
multiSearchFirstIndex(haystack, [needle1, needle2, ..., needleN])
인수
  • haystack — 검색할 대상 문자열입니다. String
  • needles — 검색할 문자열 배열입니다. Array(String)
반환 값 haystack에서 처음 발견된 needle의 1부터 시작하는 인덱스(needles 배열 내 위치)를 반환합니다. 발견된 needle이 없으면 0을 반환합니다. 검색은 대소문자를 구분합니다. UInt64 예시 사용 예시
Query
SELECT multiSearchFirstIndex('ClickHouse Database', ['Click', 'Database', 'Server']);
Response
┌─multiSearchF⋯ 'Server'])─┐
│                        1 │
└──────────────────────────┘
대소문자 구분 동작
Query
SELECT multiSearchFirstIndex('ClickHouse Database', ['CLICK', 'Database', 'Server']);
Response
┌─multiSearchF⋯ 'Server'])─┐
│                        2 │
└──────────────────────────┘
일치하는 항목을 찾을 수 없습니다
Query
SELECT multiSearchFirstIndex('Hello World', ['goodbye', 'test']);
Response
┌─multiSearchF⋯', 'test'])─┐
│                        0 │
└──────────────────────────┘

​
multiSearchFirstIndexCaseInsensitive

도입 버전: v20.1.0 문자열 haystack에서 가장 왼쪽에 있는 needle_i가 발견되면 그 인덱스 i(1부터 시작)를 반환하고, 그렇지 않으면 0을 반환합니다. 대소문자를 구분하지 않습니다. 구문 
multiSearchFirstIndexCaseInsensitive(haystack, [needle1, needle2, ..., needleN]
인수
  • haystack — 검색이 수행되는 haystack입니다. String
  • needle — 검색할 부분 문자열들입니다. Array(String)
반환 값 가장 왼쪽에서 처음 발견된 needle의 인덱스(1부터 시작)를 반환합니다. 일치하는 항목이 없으면 0을 반환합니다. UInt8 예시 사용 예시
Query
SELECT multiSearchFirstIndexCaseInsensitive('hElLo WoRlD', ['World', 'Hello']);
Response
┌─multiSearchF⋯, 'Hello'])─┐
│                        1 │
└──────────────────────────┘

​
multiSearchFirstIndexCaseInsensitiveUTF8

도입 버전: v20.1.0 UTF-8 인코딩을 지원하며, haystack 문자열에서 여러 needle 문자열을 대소문자를 구분하지 않고 검색하여 가장 먼저 찾은 needle의 1부터 시작하는 인덱스를 반환합니다. 구문 
multiSearchFirstIndexCaseInsensitiveUTF8(haystack, [needle1, needle2, ..., needleN])
인수
  • haystack — 검색 대상 문자열입니다. String
  • needles — 검색할 문자열 배열입니다. Array(String)
반환 값 haystack에서 처음 발견된 needle의 1부터 시작하는 인덱스(needles 배열 내 위치)를 반환합니다. 어떤 needle도 발견되지 않으면 0을 반환합니다. 검색은 대소문자를 구분하지 않으며 UTF-8 문자 인코딩을 지원합니다. UInt64 예시 사용 예시
Query
SELECT multiSearchFirstIndexCaseInsensitiveUTF8('ClickHouse Database', ['CLICK', 'data', 'server']);
Response
┌─multiSearchF⋯ 'server'])─┐
│                        1 │
└──────────────────────────┘
UTF-8 대소문자 처리
Query
SELECT multiSearchFirstIndexCaseInsensitiveUTF8('Привет Мир', ['мир', 'ПРИВЕТ']);
Response
┌─multiSearchF⋯ 'ПРИВЕТ'])─┐
│                        1 │
└──────────────────────────┘
일치하는 항목이 없습니다
Query
SELECT multiSearchFirstIndexCaseInsensitiveUTF8('Hello World', ['goodbye', 'test']);
Response
┌─multiSearchF⋯', '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(String)
반환 값 needle 중 가장 먼저 발견된 항목의 인덱스(1부터 시작)를 반환합니다. 일치하는 항목이 없으면 0을 반환합니다. UInt8 예시 사용 예시
Query
SELECT multiSearchFirstIndexUTF8('Здравствуйте мир', ['мир', 'здравствуйте']);
Response
┌─multiSearchF⋯вствуйте'])─┐
│                        1 │
└──────────────────────────┘

​
multiSearchFirstPosition

도입 버전: v20.1.0 position과 유사하지만, 여러 needle 문자열 중 하나와 일치하는 haystack 문자열에서 가장 앞쪽 일치 위치의 오프셋(leftmost offset)을 반환합니다. 함수 multiSearchFirstPositionCaseInsensitive, multiSearchFirstPositionUTF8, multiSearchFirstPositionCaseInsensitiveUTF8는 이 함수의 대소문자 비구분 및/또는 UTF-8 변형을 제공합니다. 구문 
multiSearchFirstPosition(haystack, needle1[, needle2, ...])
인수
  • haystack — 검색을 수행할 String입니다. String
  • needle1[, needle2, ...] — 검색할 하나 이상의 부분 문자열로 이루어진 배열입니다. Array(String)
반환 값 haystack 문자열에서 여러 needle 문자열 중 하나와 일치하는 가장 왼쪽 오프셋을 반환합니다. 일치하는 항목이 없으면 0을 반환합니다. UInt64 예시 첫 번째 위치 검색
Query
SELECT multiSearchFirstPosition('Hello World',['llo', 'Wor', 'ld'])
Response
┌─multiSearchFirstPosition('Hello World', ['llo', 'Wor', 'ld'])─┐
│                                                             3 │
└───────────────────────────────────────────────────────────────┘

​
multiSearchFirstPositionCaseInsensitive

도입 버전: v20.1.0 multiSearchFirstPosition와 같지만 대소문자를 구분하지 않습니다. 구문 
multiSearchFirstPositionCaseInsensitive(haystack, [needle1, needle2, ..., needleN])
인수
  • haystack — 검색이 수행되는 String입니다. String
  • needle — 검색할 needle의 배열입니다. Array(String)
반환 값 여러 needle 문자열 중 하나와 일치하는 haystack 문자열에서 가장 먼저 일치하는 위치의 오프셋을 반환합니다. 일치하는 항목이 없으면 0을 반환합니다. UInt64 예시 대소문자를 구분하지 않는 첫 번째 위치
Query
SELECT multiSearchFirstPositionCaseInsensitive('HELLO WORLD',['wor', 'ld', 'ello'])
Response
┌─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 needle의 배열입니다. Array(String)
반환 값 대소문자를 구분하지 않고, 여러 needle 문자열 중 하나와 일치하는 haystack 문자열에서 가장 왼쪽에 있는 일치 위치의 오프셋을 반환합니다. 일치하는 항목이 없으면 0을 반환합니다. UInt64 예시 주어진 needle 중 하나와 일치하는 UTF-8 문자열 ‘Здравствуй, мир’ (‘Hello, world’)에서 가장 왼쪽 일치 위치의 오프셋 찾기
Query
SELECT multiSearchFirstPositionCaseInsensitiveUTF8('Здравствуй, мир', ['МИР', 'вст', 'Здра'])
Response
┌─multiSearchFirstPositionCaseInsensitiveUTF8('Здравствуй, мир', ['мир', 'вст', 'Здра'])─┐
│                                                                                      3 │
└────────────────────────────────────────────────────────────────────────────────────────┘

​
multiSearchFirstPositionUTF8

도입 버전: v20.1.0 multiSearchFirstPosition와 유사하지만 haystack과 needle이 UTF-8 문자열이라고 가정합니다. 구문 
multiSearchFirstPositionUTF8(haystack, [needle1, needle2, ..., needleN])
인수
  • haystack — 검색을 수행할 UTF-8 문자열입니다. String
  • needle — 검색할 UTF-8 부분 문자열 배열입니다. Array(String)
반환 값 여러 needle 문자열 중 하나와 일치하는 haystack 문자열 내 가장 왼쪽 오프셋입니다. 일치하는 항목이 없으면 0을 반환합니다. UInt64 예시 주어진 needle 중 하나와 일치하는 UTF-8 문자열 ‘Здравствуй, мир’ (‘Hello, world’)에서 가장 왼쪽 오프셋 찾기
Query
SELECT multiSearchFirstPositionUTF8('Здравствуй, мир',['мир', 'вст', 'авст'])
Response
┌─multiSearchFirstPositionUTF8('Здравствуй, мир', ['мир', 'вст', 'авст'])─┐
│                                                                       3 │
└─────────────────────────────────────────────────────────────────────────┘

​
ngramDistance

도입 버전: v20.1.0 두 문자열 간의 4-그램 거리를 계산합니다. 이를 위해 두 4-그램 멀티셋의 대칭 차집합을 구한 뒤, 각 멀티셋의 원소 수 합으로 정규화합니다. 반환 값이 작을수록 두 문자열은 더 유사합니다. 대소문자를 구분하지 않는 검색을 수행하거나 UTF8 포맷을 사용하는 경우 ngramDistanceCaseInsensitive, ngramDistanceUTF8, ngramDistanceCaseInsensitiveUTF8 함수를 사용하십시오. 구문 
ngramDistance(haystack, needle)
인수
  • haystack — 비교할 문자열입니다. String
  • needle — 비교할 문자열입니다. String
반환 값 0과 1 사이의 Float32 값을 반환합니다. 반환 값이 작을수록 두 문자열의 유사도가 높습니다. Float32 예시 4-그램 거리 계산
Query
SELECT ngramDistance('ClickHouse', 'ClickHouses')
Response
┌─ngramDistance('ClickHouse', 'ClickHouses')─┐
│                                        0.1 │
└────────────────────────────────────────────┘

​
ngramDistanceCaseInsensitive

도입 버전: v20.1.0 ngramDistance의 대소문자 비구분 버전을 제공합니다. 대소문자를 구분하지 않고 두 문자열 사이의 4-그램 거리를 계산합니다. 반환 값이 작을수록 두 문자열의 유사도가 높습니다. 구문 
ngramDistanceCaseInsensitive(haystack, needle)
인수
  • haystack — 첫 번째 비교 대상 문자열입니다. String
  • needle — 두 번째 비교 대상 문자열입니다. String
반환 값 0과 1 사이의 Float32 값을 반환합니다. Float32 예시 대소문자를 구분하지 않는 4-그램 거리
Query
SELECT ngramDistanceCaseInsensitive('ClickHouse','clickhouse')
Response
┌─ngramDistanceCaseInsensitive('ClickHouse','clickhouse')─┐
│                                                       0 │
└─────────────────────────────────────────────────────────┘

​
ngramDistanceCaseInsensitiveUTF8

도입 버전: v20.1.0 ngramDistance의 대소문자를 구분하지 않는 UTF-8 변형을 제공합니다. needle 및 haystack 문자열은 UTF-8로 인코딩된 문자열이라고 가정하며, 대소문자를 구분하지 않습니다. 대소문자를 구분하지 않고 두 UTF-8 문자열 사이의 3-그램 거리를 계산합니다. 반환 값이 작을수록 두 문자열의 유사도가 높습니다. 구문 
ngramDistanceCaseInsensitiveUTF8(haystack, needle)
인수
  • haystack — 첫 번째 UTF-8 인코딩 비교 문자열입니다. String
  • needle — 두 번째 UTF-8 인코딩 비교 문자열입니다. String
반환 값 0과 1 사이의 Float32 값을 반환합니다. Float32 예시 대소문자를 구분하지 않는 UTF-8 3-그램 거리
Query
SELECT ngramDistanceCaseInsensitiveUTF8('abcde','CDE')
Response
┌─ngramDistanceCaseInsensitiveUTF8('abcde','CDE')─┐
│                                             0.5 │
└─────────────────────────────────────────────────┘

​
ngramDistanceUTF8

도입 버전: v20.1.0 ngramDistance의 UTF-8 변형을 제공합니다. needle 및 haystack 문자열이 UTF-8로 인코딩된 문자열이라고 가정합니다. 두 UTF-8 문자열 간의 3-그램 거리를 계산합니다. 반환 값이 작을수록 두 문자열은 더 유사합니다. 구문 
ngramDistanceUTF8(haystack, needle)
인수
  • haystack — 첫 번째 UTF-8 인코딩 비교 문자열입니다. String
  • needle — 두 번째 UTF-8 인코딩 비교 문자열입니다. String
반환 값 0과 1 사이의 Float32 값을 반환합니다. Float32 예시 UTF-8 3-그램 거리
Query
SELECT ngramDistanceUTF8('abcde','cde')
Response
┌─ngramDistanceUTF8('abcde','cde')─┐
│                               0.5 │
└───────────────────────────────────┘

​
ngramSearch

도입 버전: v20.1.0 두 문자열 간의 4-그램 거리가 지정된 임계값 이하인지 확인합니다. 대소문자를 구분하지 않는 검색을 수행하거나 UTF8 포맷을 사용하는 경우 ngramSearchCaseInsensitive, ngramSearchUTF8, ngramSearchCaseInsensitiveUTF8 함수를 사용하십시오. 구문 
ngramSearch(haystack, needle)
인수
  • haystack — 비교할 문자열입니다. String
  • needle — 비교할 문자열입니다. String
반환 값 문자열 사이의 4-그램 거리가 임계값(기본값 1.0) 이하이면 1을 반환하고, 그렇지 않으면 0을 반환합니다. UInt8 예시 4-그램을 사용한 검색
Query
SELECT ngramSearch('ClickHouse', 'Click')
Response
┌─ngramSearch('ClickHouse', 'Click')─┐
│                                  1 │
└────────────────────────────────────┘

​
ngramSearchCaseInsensitive

도입 버전: v20.1.0 ngramSearch의 대소문자를 구분하지 않는 변형을 제공합니다. needle 문자열과 haystack 문자열 사이의 비대칭 차이를 계산합니다. 즉, needle의 n-그램 수에서 공통 n-그램 수를 뺀 뒤 이를 needle n-그램 수로 정규화한 값입니다. 대소문자를 무시하고 두 문자열 사이의 4-그램 거리가 지정된 임계값 이하인지 확인합니다. 구문 
ngramSearchCaseInsensitive(haystack, needle)
인수
  • haystack — 비교 대상 문자열입니다. String
  • needle — 비교 대상 문자열입니다. String
반환 값 문자열 간 4-그램 거리가 임계값(기본값은 1.0) 이하이면 1을, 그렇지 않으면 0을 반환합니다. UInt8 예시 4-그램을 사용한 대소문자 비구분 검색
Query
SELECT ngramSearchCaseInsensitive('Hello World','hello')
Response
┌─ngramSearchCaseInsensitive('Hello World','hello')─┐
│                                                  1 │
└────────────────────────────────────────────────────┘

​
ngramSearchCaseInsensitiveUTF8

도입 버전: v20.1.0 ngramSearch의 대소문자를 구분하지 않는 UTF-8 버전을 제공합니다. haystack과 needle은 UTF-8 문자열이라고 가정하며, 대소문자를 구분하지 않습니다. 대소문자를 구분하지 않고 두 UTF-8 문자열 사이의 3-그램 거리가 지정된 임계값 이하인지 확인합니다. 구문 
ngramSearchCaseInsensitiveUTF8(haystack, needle)
인수
  • haystack — 비교용 UTF-8 문자열입니다. String
  • needle — 비교용 UTF-8 문자열입니다. String
반환 값 문자열 간 3-그램 거리가 임계값(기본값 1.0) 이하이면 1을, 그렇지 않으면 0을 반환합니다. UInt8 예시 3-그램을 사용한 대소문자를 구분하지 않는 UTF-8 검색
Query
SELECT ngramSearchCaseInsensitiveUTF8('абвГДЕёжз', 'АбвгдЕЁжз')
Response
┌─ngramSearchCaseInsensitiveUTF8('абвГДЕёжз', 'АбвгдЕЁжз')─┐
│                                                        1 │
└──────────────────────────────────────────────────────────┘

​
ngramSearchUTF8

도입 버전: v20.1.0 ngramSearch의 UTF-8 버전을 제공합니다. haystack과 needle이 UTF-8 문자열이라고 가정합니다. 두 UTF-8 문자열 사이의 3-그램 거리가 지정된 임계값 이하인지 확인합니다. 구문 
ngramSearchUTF8(haystack, needle)
인수
  • haystack — 비교할 UTF-8 문자열입니다. String
  • needle — 비교할 UTF-8 문자열입니다. String
반환 값 문자열 간의 3-그램 거리가 임계값(기본값은 1.0)보다 작거나 같으면 1을 반환하고, 그렇지 않으면 0을 반환합니다. UInt8 예시 3-그램을 사용한 UTF-8 검색
Query
SELECT ngramSearchUTF8('абвгдеёжз', 'гдеёзд')
Response
┌─ngramSearchUTF8('абвгдеёжз', 'гдеёзд')─┐
│                                      1 │
└────────────────────────────────────────┘

​
notILike

도입 버전: v20.6.0 문자열이 패턴과 일치하지 않는지 대소문자를 구분하지 않고 확인합니다. 패턴에는 SQL LIKE 매칭을 위한 특수 문자 % 및 _를 사용할 수 있습니다. 구문 
notILike(haystack, pattern)
인수
  • haystack — 검색 대상 문자열입니다. String 또는 FixedString
  • pattern — 매칭할 SQL LIKE 패턴입니다. %는 0개를 포함한 임의 개수의 문자와 일치하고, _는 정확히 1개의 문자와 일치합니다. String
반환 값 문자열이 패턴과 일치하지 않으면(대소문자를 구분하지 않음) 1을 반환하고, 그렇지 않으면 0을 반환합니다. UInt8 예시 사용 예시
Query
SELECT notILike('ClickHouse', '%house%');
Response
┌─notILike('Cl⋯ '%house%')─┐
│                        0 │
└──────────────────────────┘

​
notLike

도입 버전: v1.1.0 like와 유사하지만 결과를 반대로 반환합니다. 구문 
notLike(haystack, pattern)
-- haystack NOT LIKE pattern
인수
  • haystack — 검색이 수행되는 문자열입니다. String 또는 FixedString
  • pattern — 매칭할 LIKE 패턴입니다. String
반환 값 문자열이 LIKE 패턴과 일치하지 않으면 1을, 그렇지 않으면 0을 반환합니다. UInt8 예시 사용 예시
Query
SELECT notLike('ClickHouse', '%House%');
Response
┌─notLike('Cli⋯ '%House%')─┐
│                        0 │
└──────────────────────────┘
일치하지 않는 패턴
Query
SELECT notLike('ClickHouse', '%SQL%');
Response
┌─notLike('Cli⋯', '%SQL%')─┐
│                        1 │
└──────────────────────────┘

​
position

도입 버전: v1.1.0 문자열 haystack에서 부분 문자열 needle이 시작되는 위치를 반환합니다(바이트 기준, 1부터 시작). 부분 문자열 needle이 비어 있으면 다음 규칙이 적용됩니다:
  • start_pos가 지정되지 않은 경우: 1을 반환합니다
  • start_pos = 0인 경우: 1을 반환합니다
  • start_pos >= 1이고 start_pos <= length(haystack) + 1인 경우: start_pos를 반환합니다
  • 그 밖의 경우: 0을 반환합니다
같은 규칙이 locate, positionCaseInsensitive, positionUTF8, positionCaseInsensitiveUTF8 함수에도 적용됩니다. 구문 
position(haystack, needle[, start_pos])
인수
  • haystack — 검색을 수행할 문자열입니다. String 또는 Enum
  • needle — 검색할 부분 문자열입니다. String
  • start_pos — haystack에서 검색을 시작할 위치(1부터 시작)입니다. 선택 사항입니다. UInt
반환 값 부분 문자열을 찾으면 1부터 세는 바이트 기준의 시작 위치를 반환하고, 찾지 못하면 0을 반환합니다. UInt64 예시 기본 사용법
Query
SELECT position('Hello, world!', '!')
Response
┌─position('Hello, world!', '!')─┐
│                             13 │
└────────────────────────────────┘
start_pos 인수 사용 시
Query
SELECT position('Hello, world!', 'o', 1), position('Hello, world!', 'o', 7)
Response
┌─position('Hello, world!', 'o', 1)─┬─position('Hello, world!', 'o', 7)─┐
│                                 5 │                                 9 │
└───────────────────────────────────┴───────────────────────────────────┘
needle IN haystack 구문
Query
SELECT 6 = position('/' IN s) FROM (SELECT 'Hello/World' AS s)
Response
┌─equals(6, position(s, '/'))─┐
│                           1 │
└─────────────────────────────┘
빈 needle의 부분 문자열
Query
SELECT position('abc', ''), position('abc', '', 0), position('abc', '', 1), position('abc', '', 2), position('abc', '', 3), position('abc', '', 4), position('abc', '', 5)
Response
┌─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 예시 대소문자를 구분하지 않는 검색
Query
SELECT positionCaseInsensitive('Hello, world!', 'hello')
Response
┌─positionCaseInsensitive('Hello, world!', 'hello')─┐
│                                                 1 │
└───────────────────────────────────────────────────┘

​
positionCaseInsensitiveUTF8

도입 버전: v1.1.0 positionUTF8와 같지만 대소문자를 구분하지 않고 검색합니다. 구문 
positionCaseInsensitiveUTF8(haystack, needle[, start_pos])
인수
  • haystack — 검색을 수행할 String입니다. String 또는 Enum
  • needle — 검색할 부분 문자열입니다. String
  • start_pos — 선택 사항입니다. 검색을 시작할 haystack 내 위치(1부터 시작)입니다. UInt*
반환 값 부분 문자열을 찾으면 1부터 세는 시작 바이트 위치를 반환하고, 찾지 못하면 0을 반환합니다. UInt64 예시 대소문자를 구분하지 않는 UTF-8 검색
Query
SELECT positionCaseInsensitiveUTF8('Привет мир', 'МИР')
Response
┌─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 문자 수 계산
Query
SELECT positionUTF8('Motörhead', 'r')
Response
┌─position('Motörhead', 'r')─┐
│                          5 │
└────────────────────────────┘
마지막 수정일 2026년 6월 10일