문자열 검색 함수
문자열 검색 함수 (String Search Functions)
이 섹션의 모든 함수는 기본적으로 대소문자를 구분해서(case-sensitive) 검색해요. 대소문자를 구분하지 않는 검색은 보통 별도의 함수 변형으로 제공돼요.
참고: 대소문자 무시 검색은 영어의 소문자-대문자 규칙을 따릅니다. 예를 들어 영어에서 대문자
i는I인데, 터키어에서는İ입니다. 영어 외 언어에서는 결과가 예상과 다를 수 있어요.
이 섹션의 함수는 검색 대상 문자열(여기서는 haystack)과 검색 문자열(여기서는 needle)이 싱글바이트 인코딩 텍스트라고 가정해요. 이 가정이 깨지면 예외가 발생하지 않고 결과도 정의되지 않습니다. UTF-8 인코딩 문자열 검색은 보통 별도의 함수 변형으로 제공돼요. 마찬가지로 UTF-8 함수 변형을 쓰는데 입력 문자열이 UTF-8 인코딩 텍스트가 아니면 예외가 발생하지 않고 결과도 정의되지 않습니다. 자동 유니코드 정규화는 수행되지 않지만, normalizeUTF8*() 함수를 사용할 수 있어요.
일반 문자열 함수와 문자열 치환 함수는 별도로 설명돼요.
참고: 아래 문서는
system.functions시스템 테이블에서 생성된 것이에요.
출처: 문서
본문
countMatches
도입: v21.1.0
문자열에서 정규식이 매칭된 횟수를 반환해요.
참고: 이 함수의 동작은 ClickHouse 버전에 따라 달라요:
- v25.6 미만 버전에서는 패턴이 빈 매칭을 허용해도 첫 번째 빈 매칭에서 카운트를 멈춰요.
- v25.6 이상에서는 빈 매칭이 발생해도 계속 실행돼요. 이전 동작은
count_matches_stop_at_empty_match = true설정으로 복원할 수 있어요.
구문 (Syntax)
countMatches(haystack, pattern)
인자 (Arguments)
haystack— 검색할 문자열.Stringpattern— 정규식 패턴.String
반환 값 (Returned value)
찾은 매칭 수를 반환해요. UInt64
예시 (Examples)
숫자 시퀀스 세기
SELECT countMatches('hello 123 world 456 test', '[0-9]+')
┌─countMatches('hello 123 world 456 test', '[0-9]+')─┐
│ 2 │
└────────────────────────────────────────────────────┘
countMatchesCaseInsensitive
도입: v21.1.0
countMatches와 같지만 대소문자를 구분하지 않고 매칭해요.
구문 (Syntax)
countMatchesCaseInsensitive(haystack, pattern)
인자 (Arguments)
haystack— 검색할 문자열.Stringpattern— 정규식 패턴.const String
반환 값 (Returned value)
찾은 매칭 수를 반환해요. UInt64
예시 (Examples)
대소문자 무시 카운트
SELECT countMatchesCaseInsensitive('Hello HELLO world', 'hello')
┌─countMatchesCaseInsensitive('Hello HELLO world', 'hello')─┐
│ 2 │
└───────────────────────────────────────────────────────────┘
countSubstrings
도입: v21.1.0
문자열 haystack에서 부분 문자열 needle이 몇 번 나타나는지 반환해요.
구문 (Syntax)
countSubstrings(haystack, needle[, start_pos])
인자 (Arguments)
haystack— 검색이 수행되는 문자열. String 또는 Enum.needle— 검색할 부분 문자열. String.start_pos— 검색이 시작되는haystack내 위치(1부터 시작). UInt. 선택 사항.
반환 값 (Returned value)
발생 횟수. UInt64
예시 (Examples)
사용 예시
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와 같지만 대소문자를 구분하지 않고 카운트해요.
구문 (Syntax)
countSubstringsCaseInsensitive(haystack, needle[, start_pos])
인자 (Arguments)
haystack— 검색이 수행되는 문자열.String또는Enumneedle— 검색할 부분 문자열.Stringstart_pos— 선택 사항. 검색이 시작되는haystack내 위치(1부터 시작).UInt*
반환 값 (Returned value)
haystack에서 needle이 발생한 횟수를 반환해요. UInt64
예시 (Examples)
사용 예시
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 문자열이라고 가정해요.
구문 (Syntax)
countSubstringsCaseInsensitiveUTF8(haystack, needle[, start_pos])
인자 (Arguments)
haystack— 검색이 수행되는 UTF-8 문자열.String또는Enumneedle— 검색할 부분 문자열.Stringstart_pos— 선택 사항. 검색이 시작되는haystack내 위치(1부터 시작).UInt*
반환 값 (Returned value)
haystack에서 needle이 발생한 횟수를 반환해요. UInt64
예시 (Examples)
사용 예시
SELECT countSubstringsCaseInsensitiveUTF8('ложка, кошка, картошка', 'КА');
┌─countSubstringsCaseInsensitiveUTF8('ложка, кошка, картошка', 'КА')─┐
│ 4 │
└────────────────────────────────────────────────────────────────────┘
start_pos 인자 포함
SELECT countSubstringsCaseInsensitiveUTF8('ложка, кошка, картошка', 'КА', 13);
┌─countSubstringsCaseInsensitiveUTF8('ложка, кошка, картошка', 'КА', 13)─┐
│ 2 │
└────────────────────────────────────────────────────────────────────────┘
extract
도입: v1.1.0
문자열에서 정규식의 첫 번째 매칭을 추출해요. haystack이 pattern과 매칭되지 않으면 빈 문자열을 반환해요.
이 함수는 RE2 정규식 라이브러리를 사용해요. 지원되는 문법은 re2를 참고하세요.
정규식에 캡처 그룹(부분 패턴)이 있으면 함수는 첫 번째 캡처 그룹에 대해 입력 문자열을 매칭해요.
구문 (Syntax)
extract(haystack, pattern)
인자 (Arguments)
haystack— 추출할 문자열.Stringpattern— 보통 캡처 그룹을 포함한 정규식.const String
반환 값 (Returned value)
추출된 조각을 문자열로 반환해요. String
예시 (Examples)
이메일에서 도메인 추출
SELECT extract('[email protected]', '.*@(.*)$')
┌─extract('[email protected]', '.*@(.*)$')─┐
│ clickhouse.com │
└────────────────────────────────────────────┘
매칭 없으면 빈 문자열 반환
SELECT extract('[email protected]', 'no_match')
┌─extract('[email protected]', 'no_match')─┐
│ │
└────────────────────────────────────────────┘
extractAll
도입: v1.1.0
extract와 같지만 문자열에서 정규식의 모든 매칭 배열을 반환해요. haystack이 pattern 정규식과 매칭되지 않으면 빈 배열을 반환해요.
정규식에 캡처 그룹(부분 패턴)이 있으면 함수는 첫 번째 캡처 그룹에 대해 입력 문자열을 매칭해요.
구문 (Syntax)
extractAll(haystack, pattern)
인자 (Arguments)
haystack— 조각을 추출할 문자열.Stringpattern— 선택적으로 캡처 그룹을 포함한 정규식.const String
반환 값 (Returned value)
추출된 조각 배열을 반환해요. Array(String)
예시 (Examples)
모든 숫자 추출
SELECT extractAll('hello 123 world 456', '[0-9]+')
┌─extractAll('hello 123 world 456', '[0-9]+')─┐
│ ['123','456'] │
└─────────────────────────────────────────────┘
캡처 그룹 사용 추출
SELECT extractAll('[email protected], [email protected]', '([a-zA-Z0-9]+)@')
┌─extractAll('[email protected], [email protected]', '([a-zA-Z0-9]+)@')─┐
│ ['test','user'] │
└────────────────────────────────────────────────────────────────────┘
extractAllGroupsHorizontal
도입: v20.5.0
제공된 정규식으로 문자열의 모든 그룹을 매칭하고, 각 배열이 같은 캡처 그룹의 모든 캡처를 포함하는 배열의 배열을 반환해요(그룹 번호별로 구성).
구문 (Syntax)
extractAllGroupsHorizontal(s, regexp)
인자 (Arguments)
s— 추출할 입력 문자열.String또는FixedStringregexp— 매칭할 정규식.const String또는const FixedString
반환 값 (Returned value)
각 내부 배열이 한 캡처 그룹의 모든 매칭 캡처를 담는 배열의 배열을 반환해요. 첫 번째 내부 배열은 그룹 1의 모든 캡처, 두 번째는 그룹 2 등. 매칭이 없으면 빈 배열을 반환해요. Array(Array(String))
예시 (Examples)
사용 예시
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을 사용하세요.
구문 (Syntax)
extractGroups(s, regexp)
인자 (Arguments)
s— 추출할 입력 문자열.String또는FixedStringregexp— 정규식. 최소 하나의 캡처 그룹을 포함해야 해요. 상수.const String또는const FixedString
반환 값 (Returned value)
정규식이 매칭하면, 첫 번째 매칭의 캡처 그룹(1부터 N까지, 여기서 N은 regexp의 캡처 그룹 수)을 담은 배열을 반환해요. 매칭이 없으면 빈 배열을 반환해요. Array(String)
예시 (Examples)
사용 예시
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컬럼에는 텍스트 인덱스가 정의되어 있어야 해요. 텍스트 인덱스가 없으면 함수는 전수(brute-force) 컬럼 스캔을 수행하는데, 인덱스 조회보다 몇 배나 느려요.
검색 전에 함수는 다음을 토크나이즈해요:
input인자(항상), 그리고needle인자(String으로 주어진 경우) 텍스트 인덱스에 지정된 토크나이저를 사용해서요. 컬럼에 텍스트 인덱스가 정의되어 있지 않으면splitByNonAlpha토크나이저를 대신 사용해요.needle인자가Array(String)타입이면 각 배열 요소를 토큰으로 취급하고 추가 토크나이제이션은 없어요. 텍스트 인덱스에 전처리기(preprocessor) 표현식이 구성되어 있으면 토크나이제이션 전에 preprocessor가 needle(String으로 주어진 경우)에 적용돼요. 후처리기(postprocessor) 표현식이 구성되어 있으면 postprocessor가 needle 토큰과 input 토큰(둘 다, 즉 토크나이제이션 후)에 적용돼요.
중복 토큰은 무시돼요. 예를 들어 needles = ['ClickHouse', 'ClickHouse']는 ['ClickHouse']와 동일하게 취급돼요.
참고: 텍스트 인덱스가 preprocessor(예:
lowerUTF8)를 정의하면hasAllTokens는 토크나이제이션 전에input에, 그리고needles가 String이면needles에도 적용해요.needles가 Array(String)이면 요소가 그대로 전달되고 preprocessor가 적용되지 않아요. preprocessor는 텍스트 인덱스 경로에서만 적용되므로, 텍스트 인덱스를 사용하는 쿼리와 사용하지 않는 쿼리(예:SETTINGS use_skip_indexes = 0) 간에 결과가 다를 수 있어요. 이 불일치는 전문(full-text) 검색의 사용성을 위해 허용된 것이에요.
구문 (Syntax)
hasAllTokens(input, needles[, tokenizer])
별칭 (Aliases): hasAllToken
인자 (Arguments)
input— 입력 컬럼.String또는FixedString또는Nullable(String)또는Nullable(FixedString)또는Array(String)또는Array(FixedString)또는Array(Nullable(String))또는Array(Nullable(FixedString))needles— 검색할 토큰.String또는Array(String)tokenizer— 사용할 토크나이저. 유효한 인자는splitByNonAlpha,splitByString,splitByRegexp,asciiCJK,chinese,icu('<locale>'),japanese,ngrams,sparseGrams,array예요. 선택 사항이며 명시하지 않으면 기본값은splitByNonAlpha예요.const String
반환 값 (Returned value)
모든 needle이 매칭되면 1, 그렇지 않으면 0을 반환해요. UInt8
예시 (Examples)
(원문 문서의 다양한 예시가 관련됩니다 — CONCATENATED)
#### hasAnyTokens 도입: v25.10.0
needle 문자열이나 배열의 토큰 중 하나라도 input 문자열과 매칭되면 1, 그렇지 않으면 0을 반환해요. input이 컬럼이면 이 조건을 만족하는 모든 행을 반환해요. 토크나이제이션·preprocessor·postprocessor 동작은 hasAllTokens와 동일해요.
구문 (Syntax)
hasAnyTokens(input, needles[, tokenizer])
별칭 (Aliases): hasAnyToken
반환 값 (Returned value)
매칭이 하나라도 있으면 1, 그렇지 않으면 0을 반환해요. UInt8
hasPhrase
도입: v26.4.0
input이 phrase의 모든 토큰을 연속된 순서로 포함하는지 확인해요.
참고: 최적 성능을 위해
input컬럼에 텍스트 인덱스가 정의되어 있어야 해요.
검색 전에 함수는 텍스트 인덱스에 지정된 토크나이저로 input과 phrase 인자를 모두 토크나이즈해요. 컬럼에 텍스트 인덱스가 정의되어 있지 않으면 선택적 세 번째 인자로 토크나이저를 제공하지 않는 한 splitByNonAlpha 토크나이저를 대신 사용해요. 토크나이저 인자는 splitByNonAlpha, splitByString, splitByRegexp, ngrams, asciiCJK, icu 중 하나여야 해요. 텍스트 인덱스가 postprocessor도 정의할 때 hasPhrase에서는 splitByRegexp가 지원되지 않아요.
hasAnyTokens, hasAllTokens, hasToken과 달리 hasPhrase는 토큰이 같은 순서이면서 사이에 다른 토큰이 없이 나타나야 해요. 예를 들어 hasPhrase('the quick brown fox', 'quick fox')는 "brown"이 "quick"과 "fox" 사이에 있으므로 0을 반환해요.
구문 (Syntax)
hasPhrase(input, phrase[, tokenizer])
별칭 (Aliases): matchPhrase
반환 값 (Returned value)
문구가 연속 토큰 시퀀스로 발견되면 1, 그렇지 않으면 0을 반환해요. UInt8
hasSubsequence
도입: v23.7.0
needle이 haystack의 부분 수열(subsequence)인지 확인해요. 문자열의 부분 수열은 나머지 문자의 순서를 바꾸지 않고 일부 문자(또는 없음)를 삭제해 다른 문자열에서 유도할 수 있는 수열이에요.
구문 (Syntax)
hasSubsequence(haystack, needle)
인자 (Arguments)
haystack— 부분 수열을 검색할 문자열.Stringneedle— 검색할 부분 수열.String
반환 값 (Returned value)
needle이 haystack의 부분 수열이면 1, 그렇지 않으면 0을 반환해요. UInt8
예시 (Examples)
기본 부분 수열 확인
SELECT hasSubsequence('Hello World', 'HlWrd')
┌─hasSubsequence('Hello World', 'HlWrd')─┐
│ 1 │
└────────────────────────────────────────┘
hasSubsequenceCaseInsensitive / hasSubsequenceCaseInsensitiveUTF8 / hasSubsequenceUTF8
도입: v23.7.0
hasSubsequence와 같지만 대소문자를 구분하지 않거나(각각), UTF-8 인코딩 문자열이라고 가정하거나, 둘 다에 해당하는 변형이에요.
구문 (Syntax)
hasSubsequenceCaseInsensitive(haystack, needle)
hasSubsequenceCaseInsensitiveUTF8(haystack, needle)
hasSubsequenceUTF8(haystack, needle)
반환 값 (Returned value)
needle이 haystack의 부분 수열이면 1, 그렇지 않으면 0을 반환해요. UInt8
hasToken
도입: v20.1.0
참고:
hasToken은splitByNonAlpha가 아닌 토크나이저나 preprocessor/postprocessor 표현식이 있는 텍스트 인덱스 조회에서 사용할 때 몇 가지 함정이 있어요.hasAnyTokens와hasAllTokens를 사용하는 걸 권장해요.
주어진 토큰이 haystack에 있는지 확인해요.
토크나이저로 splitByNonAlpha를 사용해요. 즉 토큰은 [0-9A-Za-z_](숫자, ASCII 문자, 밑줄) 연속 문자로 구성되는 가장 긴 가능한 부분 수열로 정의돼요.
구문 (Syntax)
hasToken(haystack, token)
인자 (Arguments)
haystack— 검색할 문자열.Stringtoken— 검색할 토큰.const String
반환 값 (Returned value)
토큰이 발견되면 1, 그렇지 않으면 0을 반환해요. UInt8
hasTokenCaseInsensitive / hasTokenOrNull / hasTokenCaseInsensitiveOrNull
도입: v20.1.0 / v20.1.0 / v23.1.0
hasToken의 변형들이에요. hasTokenCaseInsensitive는 tokenbf_v1 인덱스로 대소문자 무시 조회를 수행하고, hasTokenOrNull은 토큰이 잘못 구성되면 null을 반환하며, hasTokenCaseInsensitiveOrNull은 대소문자 무시 조회에서 needle이 잘못 구성되면 null을 반환해요.
참고: 이 함수들은 기본이 아닌 토크나이저와 preprocessor/postprocessor 표현식에서 함정이 있어요.
hasAnyTokens와hasAllTokens를 사용하는 걸 권장해요.
구문 (Syntax)
hasTokenCaseInsensitive(haystack, needle)
hasTokenOrNull(haystack, token)
hasTokenCaseInsensitiveOrNull(haystack, needle)
반환 값 (Returned value)
토큰이 발견되면 1, 그렇지 않으면 0, 토큰이 잘못 구성되면 null을 반환해요. Nullable(UInt8)
highlight
도입: v26.4.0
텍스트 문자열에서 검색어의 발생을 HTML 태그로 감싸서 강조해요.
이 함수는 ASCII 대소문자 무시 매칭을 수행해요. 여러 검색어가 텍스트에서 겹치거나 인접하면, 매칭 영역을 하나의 강조 스팬으로 병합해요.
구문 (Syntax)
highlight(haystack, needles[, open_tag, close_tag])
인자 (Arguments)
haystack— 검색할 텍스트.String또는FixedStringneedles— 강조할 검색어 배열.const Array(String)open_tag— 각 매칭 앞에 삽입할 여는 태그. 기본값:<em>.const Stringclose_tag— 각 매칭 뒤에 삽입할 닫는 태그. 기본값:</em>.const String
반환 값 (Returned value)
매칭된 용어를 지정 태그로 감싼 입력 텍스트를 반환해요. String
예시 (Examples)
SELECT highlight('The quick brown fox', ['quick', 'fox'])
┌─highlight('The quick brown fox', ['quick', 'fox'])─┐
│ The <em>quick</em> brown <em>fox</em> │
└────────────────────────────────────────────────────┘
ilike
도입: v20.6.0
like와 같지만 대소문자를 구분하지 않고 검색해요. 선택적 ESCAPE 절을 지원해요(like 참고).
구문 (Syntax)
ilike(haystack, pattern[, escape_character])
-- haystack ILIKE pattern [ESCAPE 'escape_character']
인자 (Arguments)
haystack— 검색이 수행되는 문자열.String또는FixedStringpattern— 매칭할 LIKE 패턴.Stringescape_character—\\대신 이스케이프 문자로 쓸 선택적 단일 문자 문자열. 기본값:\\.String
반환 값 (Returned value)
문자열이 LIKE 패턴(대소문자 무시)과 매칭되면 1, 그렇지 않으면 0. UInt8
예시 (Examples)
SELECT ilike('ClickHouse', '%house%');
┌─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 함수와 비슷한 성능으로 실행돼요.
ESCAPE 절
선택적 ESCAPE 절은 사용자 정의 이스케이프 문자(단일 ASCII 문자여야 함)를 지정해요. 제공되면 %와 _ 메타 문자를 이스케이프하는 기본 백슬래시를 대체해요. 이스케이프 문자는 %(리터럴 퍼센트), _(리터럴 밑줄), 그리고 자기 자신(리터럴 이스케이프 문자) 세 가지를 이스케이프할 수 있어요. 사용자 정의 이스케이프 문자를 쓰면 백슬래시는 특별한 의미가 없고 리터럴 문자로 취급돼요.
구문 (Syntax)
like(haystack, pattern[, escape_character])
-- haystack LIKE pattern [ESCAPE 'escape_character']
인자 (Arguments)
haystack— 검색이 수행되는 문자열.String또는FixedStringpattern— 매칭할LIKE패턴.%(임의 개수 문자 매칭),_(단일 문자 매칭),\를 이스케이프에 포함할 수 있어요.Stringescape_character—\\대신 이스케이프 문자로 쓸 선택적 단일 문자 문자열. 기본값:\\.String
반환 값 (Returned value)
문자열이 LIKE 패턴과 매칭되면 1, 그렇지 않으면 0. UInt8
예시 (Examples)
SELECT like('ClickHouse', '%House');
┌─like('ClickHouse', '%House')─┐
│ 1 │
└──────────────────────────────┘
ESCAPE 절
SELECT '50%off' LIKE '50#%off' ESCAPE '#';
┌─like('50%off', '50#%off', '#')─┐
│ 1 │
└────────────────────────────────┘
locate
도입: v18.16.0
position과 같지만 인자 haystack와 needle의 순서가 바뀐 함수예요.
참고: 이 함수의 동작은 ClickHouse 버전에 따라 달라요:
- v24.3 미만에서는
locate는position함수의 별칭이었고 인자(haystack, needle[, start_pos])를 받았어요.- v24.3 이상에서는
locate는 독립 함수(MySQL과의 호환성 향상)며 인자(needle, haystack[, start_pos])를 받아요. 이전 동작은function_locate_has_mysql_compatible_argument_order = false설정으로 복원할 수 있어요.
구문 (Syntax)
locate(needle, haystack[, start_pos])
인자 (Arguments)
needle— 검색할 부분 문자열.Stringhaystack— 검색이 수행되는 문자열.String또는Enumstart_pos— 선택 사항. 검색이 시작되는haystack내 위치(1부터 시작).UInt
반환 값 (Returned value)
부분 문자열이 발견되면 바이트 단위이자 1부터 세는 시작 위치, 발견되지 않으면 0을 반환해요. UInt64
예시 (Examples)
SELECT locate('ca', 'abcabc')
┌─locate('ca', 'abcabc')─┐
│ 3 │
└────────────────────────┘
match
도입: v1.1.0
제공된 문자열이 제공된 정규식 패턴과 매칭되는지 확인해요.
이 함수는 RE2 정규식 라이브러리를 사용해요. 지원 문법은 re2를 참고하세요.
매칭은 UTF-8 가정 하에 동작해요. 예를 들어 ¥는 내부에서 두 바이트를 쓰지만 매칭은 단일 코드 포인트로 취급해요. 정규식은 NULL 바이트를 포함하면 안 돼요. haystack이나 패턴이 유효한 UTF-8이 아니면 동작은 정의되지 않아요.
re2의 기본 동작과 달리 .는 줄바꿈과 매칭돼요. 이를 비활성화하려면 패턴 앞에 (?-s)를 붙이세요.
패턴은 앵커링되지 않아요. 전체 문자열을 매칭하려면 ^와 $로 직접 앵커링하세요.
부분 문자열만 검색하려면 position이나 locate 함수를 대신 사용할 수 있는데, 이 함수보다 훨씬 빠르게 동작해요.
대체 연산자 문법: haystack REGEXP pattern 또는 haystack ~ pattern(PostgreSQL 스타일).
구문 (Syntax)
match(haystack, pattern)
별칭 (Aliases): REGEXP_MATCHES
인자 (Arguments)
haystack— 패턴이 검색되는 문자열.Stringpattern— 정규식 패턴. 상수이거나 컬럼에서 올 수 있어요.String
반환 값 (Returned value)
패턴이 매칭되면 1, 그렇지 않으면 0. UInt8
예시 (Examples)
SELECT match('Hello World', 'Hello.*')
┌─match('Hello World', 'Hello.*')─┐
│ 1 │
└─────────────────────────────────┘
matchCaseInsensitive
도입: v26.8.0
match와 비슷하지만 대소문자를 구분하지 않고 매칭해요.
이 함수는 RE2 정규식 라이브러리를 사용해요. 대체 연산자 문법: haystack ~* pattern(PostgreSQL 스타일).
구문 (Syntax)
matchCaseInsensitive(haystack, pattern)
-- haystack ~* pattern
반환 값 (Returned value)
패턴이 대소문자 무시로 매칭되면 1, 그렇지 않으면 0. UInt8
multiFuzzyMatchAllIndices
도입: v20.1.0
multiMatchAllIndices와 같지만 상수 편집 거리 내에서 haystack과 매칭되는 모든 인덱스를 임의 순서로 반환해요.
구문 (Syntax)
multiFuzzyMatchAllIndices(haystack, distance, [pattern1, pattern2, ..., patternN])
인자 (Arguments)
haystack— 검색이 수행되는 문자열.Stringdistance— 퍼지 매칭의 최대 편집 거리.UInt8pattern— 매칭할 패턴 배열.Array(String)
반환 값 (Returned value)
지정 편집 거리 내에서 haystack과 매칭되는 모든 인덱스(1부터 시작)를 임의 순서로 담은 배열을 반환해요. 매칭이 없으면 빈 배열을 반환해요. Array(UInt64)
multiFuzzyMatchAny / multiFuzzyMatchAnyIndex
도입: v20.1.0
multiMatchAny와 같지만 상수 편집 거리 내에서 어떤 패턴이 haystack과 매칭되면 1을 반환해요(multiFuzzyMatchAny). multiFuzzyMatchAnyIndex는 상수 편집 거리 내에서 haystack과 매칭되는 임의 인덱스를 반환해요.
이 함수는 hyperscan 라이브러리의 실험 기능에 의존하며, 일부 경계 사례에서는 느릴 수 있어요. 성능은 편집 거리 값과 사용 패턴에 따라 달라지지만, 항상 비퍼지 변형보다 비싸요.
참고:
multiFuzzyMatch*()함수군은 hyperscan의 제약으로 UTF-8 정규식을 지원하지 않아요(바이트 시퀀스로 취급).
구문 (Syntax)
multiFuzzyMatchAny(haystack, distance, [pattern1, pattern2, ..., patternN])
multiFuzzyMatchAnyIndex(haystack, distance, [pattern1, pattern2, ..., patternn])
반환 값 (Returned value)
multiFuzzyMatchAny: 어떤 패턴이 지정 편집 거리 내에서 haystack과 매칭되면 1, 아니면 0. UInt8
multiFuzzyMatchAnyIndex: 지정 편집 거리 내에서 haystack과 매칭되는 임의 패턴의 인덱스(1부터 시작), 아니면 0. UInt64
multiMatchAllIndices
도입: v20.1.0
multiMatchAny와 같지만 임의 순서로 haystack과 매칭되는 모든 인덱스 배열을 반환해요.
구문 (Syntax)
multiMatchAllIndices(haystack, [pattern1, pattern2, ..., patternn])
반환 값 (Returned value)
임의 순서로 haystack과 매칭되는 모든 인덱스(1부터 시작) 배열. 매칭이 없으면 빈 배열. Array(UInt64)
multiMatchAny
도입: v20.1.0
여러 정규식 패턴 중 하나 이상이 haystack과 매칭되는지 확인해요.
문자열에서 여러 부분 문자열만 검색하려면 multiSearchAny 함수를 대신 사용할 수 있는데, 이 함수보다 훨씬 빠르게 동작해요.
구문 (Syntax)
multiMatchAny(haystack, pattern1[, pattern2, ...])
인자 (Arguments)
haystack— 패턴이 검색되는 문자열.Stringpattern1[, pattern2, ...]— 하나 이상의 정규식 패턴 배열.Array(String)
반환 값 (Returned value)
어떤 패턴이 매칭되면 1, 그렇지 않으면 0. UInt8
multiMatchAnyIndex
도입: v20.1.0
multiMatchAny와 같지만 haystack과 매칭되는 임의 인덱스를 반환해요.
구문 (Syntax)
multiMatchAnyIndex(haystack, [pattern1, pattern2, ..., patternn])
반환 값 (Returned value)
첫 번째로 매칭된 패턴의 인덱스(1부터 시작), 매칭이 없으면 0. UInt64
multiSearchAllPositions
도입: v20.1.0
position과 같지만 haystack 문자열에서 여러 needle 부분 문자열에 대한 위치(바이트 단위, 1부터 시작) 배열을 반환해요.
모든 multiSearch*() 함수는 최대 2^8개의 needle만 지원해요.
구문 (Syntax)
multiSearchAllPositions(haystack, needle1[, needle2, ...])
인자 (Arguments)
haystack— 검색이 수행되는 문자열.Stringneedle1[, needle2, ...]— 검색할 하나 이상의 부분 문자열 배열.Array(String)
반환 값 (Returned value)
부분 문자열이 발견되면 바이트 단위이자 1부터 세는 시작 위치 배열, 발견되지 않으면 0. Array(UInt64)
multiSearchAllPositionsCaseInsensitive / multiSearchAllPositionsUTF8 / multiSearchAllPositionsCaseInsensitiveUTF8
도입: v20.1.0
multiSearchAllPositions의 변형들로, 대소문자를 무시하거나, haystack과 needle이 UTF-8 인코딩임을 가정하거나, 둘 다에 해당해요.
구문 (Syntax)
multiSearchAllPositionsCaseInsensitive(haystack, needle1[, needle2, ...])
multiSearchAllPositionsUTF8(haystack, needle1[, needle2, ...])
multiSearchAllPositionsCaseInsensitiveUTF8(haystack, [needle1, needle2, ..., needleN])
반환 값 (Returned value)
부분 문자열이 발견되면 바이트 단위이자 1부터 세는 시작 위치 배열, 발견되지 않으면 0. Array(UInt64) / Array
multiSearchAny
도입: v20.1.0
여러 needle 문자열 중 하나 이상이 haystack 문자열과 매칭되는지 확인해요.
multiSearchAnyCaseInsensitive, multiSearchAnyUTF8, multiSearchAnyCaseInsensitiveUTF8 함수가 이 함수의 대소문자 무시 및/또는 UTF-8 변형을 제공해요.
구문 (Syntax)
multiSearchAny(haystack, needle1[, needle2, ...])
인자 (Arguments)
haystack— 검색이 수행되는 문자열.Stringneedle1[, needle2, ...]— 검색할 부분 문자열 배열.Array(String)
반환 값 (Returned value)
매칭이 하나라도 있으면 1, 매칭이 없으면 0. UInt8
multiSearchAnyCaseInsensitive / multiSearchAnyUTF8 / multiSearchAnyCaseInsensitiveUTF8
도입: v20.1.0
multiSearchAny의 변형들이에요.
구문 (Syntax)
multiSearchAnyCaseInsensitive(haystack, [needle1, needle2, ..., needleN])
multiSearchAnyUTF8(haystack, [needle1, needle2, ..., needleN])
multiSearchAnyCaseInsensitiveUTF8(haystack, [needle1, needle2, ..., needleN])
반환 값 (Returned value)
매칭이 하나라도 있으면 1, 없으면 0. UInt8
multiSearchFirstIndex / multiSearchFirstIndexCaseInsensitive / multiSearchFirstIndexUTF8 / multiSearchFirstIndexCaseInsensitiveUTF8
도입: v20.1.0
haystack 문자열에서 여러 needle 문자열을 검색(대소문자 구분)하고 첫 번째로 발견된 needle의 1부터 시작하는 인덱스를 반환해요.
구문 (Syntax)
multiSearchFirstIndex(haystack, [needle1, needle2, ..., needleN])
multiSearchFirstIndexCaseInsensitive(haystack, [needle1, needle2, ..., needleN])
multiSearchFirstIndexUTF8(haystack, [needle1, needle2, ..., needleN])
multiSearchFirstIndexCaseInsensitiveUTF8(haystack, [needle1, needle2, ..., needleN])
반환 값 (Returned value)
haystack에서 발견된 첫 needle의 1부터 시작하는 인덱스(needles 배열 내 위치). needle이 발견되지 않으면 0. UInt64 / UInt8
multiSearchFirstPosition / multiSearchFirstPositionCaseInsensitive / multiSearchFirstPositionUTF8 / multiSearchFirstPositionCaseInsensitiveUTF8
도입: v20.1.0
position과 같지만 여러 needle 문자열 중 어느 것과도 매칭되는 haystack 문자열의 가장 왼쪽 오프셋을 반환해요.
구문 (Syntax)
multiSearchFirstPosition(haystack, needle1[, needle2, ...])
multiSearchFirstPositionCaseInsensitive(haystack, [needle1, needle2, ..., needleN])
multiSearchFirstPositionUTF8(haystack, [needle1, needle2, ..., needleN])
multiSearchFirstPositionCaseInsensitiveUTF8(haystack, [needle1, needle2, ..., needleN])
반환 값 (Returned value)
여러 needle 문자열 중 어느 것과도 매칭되는 haystack 문자열의 가장 왼쪽 오프셋, 매칭이 없으면 0. UInt64
ngramDistance / ngramDistanceCaseInsensitive / ngramDistanceUTF8 / ngramDistanceCaseInsensitiveUTF8
도입: v20.1.0
두 문자열 사이의 4-그램 거리(ngramDistance), 또는 UTF-8 변형에서는 3-그램 거리를 계산해요. 이를 위해 두 4-그램(3-그램) 멀티셋의 대칭 차집합을 세고, 카디널리티 합으로 정규화해요. 반환 값이 작을수록 문자열이 더 비슷한 거예요.
구문 (Syntax)
ngramDistance(haystack, needle)
ngramDistanceCaseInsensitive(haystack, needle)
ngramDistanceUTF8(haystack, needle)
ngramDistanceCaseInsensitiveUTF8(haystack, needle)
인자 (Arguments)
haystack— 비교할 문자열.Stringneedle— 비교할 문자열.String
반환 값 (Returned value)
0과 1 사이의 Float32 숫자. 값이 작을수록 문자열이 더 비슷해요. Float32
ngramSearch / ngramSearchCaseInsensitive / ngramSearchUTF8 / ngramSearchCaseInsensitiveUTF8
도입: v20.1.0
두 문자열 사이의 4-그램 거리(ngramSearch), 또는 UTF-8 변형에서는 3-그램 거리가 주어진 임계값보다 작거나 같은지 확인해요.
구문 (Syntax)
ngramSearch(haystack, needle)
ngramSearchCaseInsensitive(haystack, needle)
ngramSearchUTF8(haystack, needle)
ngramSearchCaseInsensitiveUTF8(haystack, needle)
인자 (Arguments)
haystack— 비교할 문자열.Stringneedle— 비교할 문자열.String
반환 값 (Returned value)
문자열 사이의 4-그램(또는 3-그램) 거리가 임계값(기본 1.0)보다 작거나 같으면 1, 그렇지 않으면 0. UInt8
notILike
도입: v20.6.0
문자열이 패턴과 매칭되지 않는지 대소문자 무시로 확인해요. 패턴은 SQL LIKE 매칭을 위해 특수 문자 %와 _를 포함할 수 있어요. 선택적 ESCAPE 절을 지원해요(like 참고).
구문 (Syntax)
notILike(haystack, pattern[, escape_character])
-- haystack NOT ILIKE pattern [ESCAPE 'escape_character']
반환 값 (Returned value)
문자열이 패턴(대소문자 무시)과 매칭되지 않으면 1, 그렇지 않으면 0. UInt8
notLike
도입: v1.1.0
like와 비슷하지만 결과를 부정해요. 선택적 ESCAPE 절을 지원해요(like 참고).
구문 (Syntax)
notLike(haystack, pattern[, escape_character])
-- haystack NOT LIKE pattern [ESCAPE 'escape_character']
반환 값 (Returned value)
문자열이 LIKE 패턴과 매칭되지 않으면 1, 그렇지 않으면 0. UInt8
notMatch
도입: v26.8.0
match와 비슷하지만 결과를 부정해요: 문자열이 정규식 패턴과 매칭되지 않는지 확인해요.
이 함수는 RE2 정규식 라이브러리를 사용해요. 대체 연산자 문법: haystack !~ pattern(PostgreSQL 스타일).
구문 (Syntax)
notMatch(haystack, pattern)
-- haystack !~ pattern
반환 값 (Returned value)
패턴이 매칭되면 0, 그렇지 않으면 1. UInt8
notMatchCaseInsensitive
도입: v26.8.0
notMatch와 비슷하지만 대소문자 무시로 매칭되는지 확인해요. 대체 연산자 문법: haystack !~* pattern(PostgreSQL 스타일).
구문 (Syntax)
notMatchCaseInsensitive(haystack, pattern)
-- haystack !~* pattern
반환 값 (Returned value)
패턴이 대소문자 무시로 매칭되면 0, 그렇지 않으면 1. UInt8
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반환
같은 규칙이 countSubstrings, positionCaseInsensitive, positionUTF8, positionCaseInsensitiveUTF8 함수에도 적용돼요.
구문 (Syntax)
position(haystack, needle[, start_pos])
인자 (Arguments)
haystack— 검색이 수행되는 문자열.String또는Enumneedle— 검색할 부분 문자열.Stringstart_pos— 검색이 시작되는haystack내 위치(1부터 시작). 선택 사항.UInt
반환 값 (Returned value)
부분 문자열이 발견되면 바이트 단위이자 1부터 세는 시작 위치, 발견되지 않으면 0. UInt64
예시 (Examples)
SELECT position('Hello, world!', '!')
┌─position('Hello, world!', '!')─┐
│ 13 │
└────────────────────────────────┘
needle IN 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 / positionUTF8 / positionCaseInsensitiveUTF8
도입: v1.1.0
position의 변형들이에요. positionCaseInsensitive는 대소문자를 무시하고(별칭 instr), positionUTF8은 haystack과 needle이 UTF-8 인코딩 문자열이라고 가정하며, positionCaseInsensitiveUTF8은 둘 다에 해당해요.
구문 (Syntax)
positionCaseInsensitive(haystack, needle[, start_pos])
positionUTF8(haystack, needle[, start_pos])
positionCaseInsensitiveUTF8(haystack, needle[, start_pos])
반환 값 (Returned value)
부분 문자열이 발견되면 바이트 단위이자 1부터 세는 시작 위치, 발견되지 않으면 0. UInt64
instr (별칭)
positionCaseInsensitive의 별칭이에요.