> ## Documentation Index
> Fetch the complete documentation index at: https://private-7c7dfe99-mintlify-3a82795f.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.
> 문자열 검색 함수에 대한 문서
# 문자열 검색 함수
이 섹션의 모든 함수는 기본적으로 대소문자를 구분하여 검색합니다. 대소문자를 구분하지 않는 검색은 일반적으로 별도의 함수 변형으로 제공됩니다.
대소문자를 구분하지 않는 검색은 영어의 소문자-대문자 규칙을 따릅니다. 예를 들어 영어에서 대문자 `i`는
`I`이지만, 터키어에서는 `İ`입니다. 따라서 영어 이외의 언어에서는 예상과 다른 결과가 나올 수 있습니다.
이 섹션의 함수는 검색 대상 문자열(이 섹션에서는 `haystack`이라고 함)과 검색 문자열(이 섹션에서는 `needle`이라고 함)이 모두 단일 바이트로 인코딩된 텍스트라고 가정합니다. 이 가정이
위반되어도 예외는 발생하지 않으며 결과는 정의되지 않습니다. UTF-8로 인코딩된 문자열 검색은 일반적으로 별도의 함수
변형으로 제공됩니다. 마찬가지로 UTF-8 함수 변형을 사용하더라도 입력 문자열이 UTF-8로 인코딩된 텍스트가 아니면 예외는 발생하지 않으며
결과는 정의되지 않습니다. 또한 자동 유니코드 정규화는 수행되지 않지만, 이를 위해
[normalizeUTF8\*()](/ko/reference/functions/regular-functions/string-functions#normalizeUTF8NFC) 함수를 사용할 수 있습니다.
[일반 문자열 함수](/ko/reference/functions/regular-functions/string-functions)와 [문자열 내 치환 함수](/ko/reference/functions/regular-functions/string-replace-functions)는 별도로 설명합니다.
아래 문서는 `system.functions` 시스템 테이블에서 생성되었습니다.
{/*AUTOGENERATED_START*/}
## countMatches
도입 버전: v21.1.0
문자열에서 정규식과 일치하는 횟수를 반환합니다.
**버전별 동작 차이**
이 함수의 동작은 ClickHouse 버전에 따라 달라집니다.
* 버전 \< v25.6에서는 패턴이 빈 문자열과 일치할 수 있더라도 첫 번째 빈 일치에서 개수 계산을 중단합니다.
* 버전 >= 25.6에서는 빈 일치가 발생해도 함수 실행을 계속합니다. 기존 동작은 설정 `count_matches_stop_at_empty_match = true`를 사용해 복원할 수 있습니다;
**구문**
```sql theme={null}
countMatches(haystack, pattern)
```
**인수**
* `haystack` — 검색 대상 문자열입니다. [`String`](/ko/reference/data-types/string)
* `pattern` — 정규식 패턴입니다. [`String`](/ko/reference/data-types/string)
**반환 값**
찾은 일치 항목의 개수를 반환합니다. [`UInt64`](/ko/reference/data-types/int-uint)
**예시**
**연속된 숫자 개수 세기**
```sql title=Query theme={null}
SELECT countMatches('hello 123 world 456 test', '[0-9]+')
```
```response title=Response theme={null}
┌─countMatches('hello 123 world 456 test', '[0-9]+')─┐
│ 2 │
└─────────────────────────────────────────────────────┘
```
## countMatchesCaseInsensitive
도입 버전: v21.1.0
[`countMatches`](#countMatches)와 비슷하지만 대소문자를 구분하지 않고 일치를 수행합니다.
**구문**
```sql theme={null}
countMatchesCaseInsensitive(haystack, pattern)
```
**인수**
* `haystack` — 검색할 문자열입니다. [`String`](/ko/reference/data-types/string)
* `pattern` — 정규식 패턴입니다. [`const String`](/ko/reference/data-types/string)
**반환 값**
찾은 일치 항목의 개수를 반환합니다. [`UInt64`](/ko/reference/data-types/int-uint)
**예시**
**대소문자를 구분하지 않고 개수 세기**
```sql title=Query theme={null}
SELECT countMatchesCaseInsensitive('Hello HELLO world', 'hello')
```
```response title=Response theme={null}
┌─countMatchesCaseInsensitive('Hello HELLO world', 'hello')─┐
│ 2 │
└───────────────────────────────────────────────────────────┘
```
## countSubstrings
도입 버전: v21.1.0
문자열 `haystack`에서 부분 문자열 `needle`이 나타나는 횟수를 반환합니다.
**구문**
```sql theme={null}
countSubstrings(haystack, needle[, start_pos])
```
**인수**
* `haystack` — 검색이 수행되는 문자열입니다. [String](/ko/reference/data-types/string) 또는 [Enum](/ko/reference/data-types/enum)입니다. - `needle` — 검색할 부분 문자열입니다. [String](/ko/reference/data-types/string). - `start_pos` — `haystack`에서 검색을 시작할 위치(1부터 시작)입니다. [UInt](/ko/reference/data-types/int-uint). 선택 사항입니다.
**반환 값**
발생 횟수입니다. [`UInt64`](/ko/reference/data-types/int-uint)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT countSubstrings('aaaa', 'aa');
```
```response title=Response theme={null}
┌─countSubstrings('aaaa', 'aa')─┐
│ 2 │
└───────────────────────────────┘
```
**start\_pos 인수를 사용하는 경우**
```sql title=Query theme={null}
SELECT countSubstrings('abc___abc', 'abc', 4);
```
```response title=Response theme={null}
┌─countSubstrings('abc___abc', 'abc', 4)─┐
│ 1 │
└────────────────────────────────────────┘
```
## countSubstringsCaseInsensitive
도입 버전: v21.1.0
[`countSubstrings`](#countSubstrings)와 같지만 대소문자를 구분하지 않고 개수를 셉니다.
**구문**
```sql theme={null}
countSubstringsCaseInsensitive(haystack, needle[, start_pos])
```
**인수**
* `haystack` — 검색이 수행되는 문자열입니다. [`String`](/ko/reference/data-types/string) 또는 [`Enum`](/ko/reference/data-types/enum)
* `needle` — 검색할 부분 문자열입니다. [`String`](/ko/reference/data-types/string)
* `start_pos` — 선택 사항입니다. 검색을 시작할 `haystack` 내 위치(1부터 시작)입니다. [`UInt*`](/ko/reference/data-types/int-uint)
**반환 값**
`haystack`에서 `needle`가 나타나는 횟수를 반환합니다. [`UInt64`](/ko/reference/data-types/int-uint)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT countSubstringsCaseInsensitive('AAAA', 'aa');
```
```response title=Response theme={null}
┌─countSubstri⋯AAA', 'aa')─┐
│ 2 │
└──────────────────────────┘
```
**start\_pos 인수를 사용하는 경우**
```sql title=Query theme={null}
SELECT countSubstringsCaseInsensitive('abc___ABC___abc', 'abc', 4);
```
```response title=Response theme={null}
┌─countSubstri⋯, 'abc', 4)─┐
│ 2 │
└──────────────────────────┘
```
## countSubstringsCaseInsensitiveUTF8
도입 버전: v21.1.0
[`countSubstrings`](#countSubstrings)와 동일하지만, 대소문자를 구분하지 않고 개수를 세며 haystack가 UTF-8 문자열이라고 가정합니다.
**구문**
```sql theme={null}
countSubstringsCaseInsensitiveUTF8(haystack, needle[, start_pos])
```
**인수**
* `haystack` — 검색이 수행되는 UTF-8 문자열입니다. [`String`](/ko/reference/data-types/string) 또는 [`Enum`](/ko/reference/data-types/enum)
* `needle` — 검색할 부분 문자열입니다. [`String`](/ko/reference/data-types/string)
* `start_pos` — 선택 사항입니다. `haystack`에서 검색을 시작할 위치(1부터 시작)입니다. [`UInt*`](/ko/reference/data-types/int-uint)
**반환 값**
`haystack`에서 `needle`이 나타나는 횟수를 반환합니다. [`UInt64`](/ko/reference/data-types/int-uint)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT countSubstringsCaseInsensitiveUTF8('ложка, кошка, картошка', 'КА');
```
```response title=Response theme={null}
┌─countSubstri⋯шка', 'КА')─┐
│ 4 │
└──────────────────────────┘
```
**start\_pos 인수를 사용하는 경우**
```sql title=Query theme={null}
SELECT countSubstringsCaseInsensitiveUTF8('ложка, кошка, картошка', 'КА', 13);
```
```response title=Response theme={null}
┌─countSubstri⋯, 'КА', 13)─┐
│ 2 │
└──────────────────────────┘
```
도입 버전: v1.1.0
문자열에서 정규식의 첫 번째 일치 항목을 추출합니다.
'haystack'이 'pattern'과 일치하지 않으면 빈 문자열을 반환합니다.
이 함수는 RE2 정규식 라이브러리를 사용합니다. 지원되는 구문은 [re2](https://github.com/google/re2/wiki/Syntax)를 참조하십시오.
정규식에 캡처 그룹(하위 패턴)이 있으면 이 함수는 첫 번째 캡처 그룹을 기준으로 입력 문자열을 일치시킵니다.
**구문**
```sql theme={null}
extract(haystack, pattern)
```
**인수**
* `haystack` — 추출할 문자열입니다. [`String`](/ko/reference/data-types/string)
* `pattern` — 일반적으로 캡처 그룹을 포함하는 정규식입니다. [`const String`](/ko/reference/data-types/string)
**반환 값**
추출된 부분 문자열을 반환합니다. [`String`](/ko/reference/data-types/string)
**예시**
**이메일에서 도메인 추출**
```sql title=Query theme={null}
SELECT extract('test@clickhouse.com', '.*@(.*)$')
```
```response title=Response theme={null}
┌─extract('test@clickhouse.com', '.*@(.*)$')─┐
│ clickhouse.com │
└───────────────────────────────────────────┘
```
**일치하는 항목이 없으면 빈 문자열을 반환합니다**
```sql title=Query theme={null}
SELECT extract('test@clickhouse.com', 'no_match')
```
```response title=Response theme={null}
┌─extract('test@clickhouse.com', 'no_match')─┐
│ │
└────────────────────────────────────────────┘
```
도입 버전: v1.1.0
[`extract`](#extract)와 비슷하지만, 문자열에서 정규식과 일치하는 모든 항목을 배열로 반환합니다.
'haystack'이 'pattern' 정규식과 일치하지 않으면 빈 배열을 반환합니다.
정규식에 캡처 그룹(하위 패턴)이 있으면, 이 함수는 입력 문자열에서 첫 번째 캡처 그룹과 일치하는 내용을 찾습니다.
**구문**
```sql theme={null}
extractAll(haystack, pattern)
```
**인수**
* `haystack` — 조각을 추출할 원본 문자열입니다. [`String`](/ko/reference/data-types/string)
* `pattern` — 필요에 따라 캡처 그룹을 포함할 수 있는 정규식입니다. [`const String`](/ko/reference/data-types/string)
**반환 값**
추출된 조각으로 이루어진 배열을 반환합니다. [`Array(String)`](/ko/reference/data-types/array)
**예시**
**모든 숫자 추출**
```sql title=Query theme={null}
SELECT extractAll('hello 123 world 456', '[0-9]+')
```
```response title=Response theme={null}
┌─extractAll('hello 123 world 456', '[0-9]+')─┐
│ ['123','456'] │
└─────────────────────────────────────────────┘
```
**캡처 그룹으로 추출**
```sql title=Query theme={null}
SELECT extractAll('test@example.com, user@domain.org', '([a-zA-Z0-9]+)@')
```
```response title=Response theme={null}
┌─extractAll('test@example.com, user@domain.org', '([a-zA-Z0-9]+)@')─┐
│ ['test','user'] │
└────────────────────────────────────────────────────────────────────┘
```
도입 버전: v20.5.0
제공된 정규식을 사용해 문자열에서 모든 그룹 일치를 찾고, 각 배열에 동일한 캡처 그룹의 모든 캡처가 그룹 번호 순서대로 들어 있는 배열의 배열을 반환합니다.
**구문**
```sql theme={null}
extractAllGroupsHorizontal(s, regexp)
```
**인수**
* `s` — 추출 대상 입력 문자열입니다. [`String`](/ko/reference/data-types/string) 또는 [`FixedString`](/ko/reference/data-types/fixedstring)
* `regexp` — 매칭에 사용할 정규식입니다. [`const String`](/ko/reference/data-types/string) 또는 [`const FixedString`](/ko/reference/data-types/fixedstring)
**반환 값**
배열의 배열을 반환합니다. 각 내부 배열에는 모든 매치에서 동일한 캡처 그룹으로 추출된 값이 모두 포함됩니다. 첫 번째 내부 배열에는 그룹 1의 모든 캡처가, 두 번째 내부 배열에는 그룹 2의 모든 캡처가 포함되는 방식입니다. 일치하는 항목이 없으면 빈 배열을 반환합니다. [`Array(Array(String))`](/ko/reference/data-types/array)
**예시**
**사용 예시**
```sql title=Query theme={null}
WITH '< Server: nginx
< Date: Tue, 22 Jan 2019 00:26:14 GMT
< Content-Type: text/html; charset=UTF-8
< Connection: keep-alive
' AS s
SELECT extractAllGroupsHorizontal(s, '< ([\\w\\-]+): ([^\\r\\n]+)');
```
```response title=Response theme={null}
[['Server','Date','Content-Type','Connection'],['nginx','Tue, 22 Jan 2019 00:26:14 GMT','text/html; charset=UTF-8','keep-alive']]
```
도입된 버전: v20.5.0
정규식에 처음으로 일치한 부분 문자열에서 캡처 그룹을 추출합니다. 모든 일치 항목에서 그룹을 추출하려면 [`extractAllGroupsHorizontal`](#extractAllGroupsHorizontal) 또는 [`extractAllGroupsVertical`](/ko/reference/functions/regular-functions/splitting-merging-functions#extractAllGroupsVertical)을 사용하십시오.
**구문**
```sql theme={null}
extractGroups(s, regexp)
```
**인수**
* `s` — 추출할 대상 입력 문자열입니다. [`String`](/ko/reference/data-types/string) 또는 [`FixedString`](/ko/reference/data-types/fixedstring)
* `regexp` — 정규식입니다. 캡처 그룹을 하나 이상 포함해야 합니다. 상수여야 합니다. [`const String`](/ko/reference/data-types/string) 또는 [`const FixedString`](/ko/reference/data-types/fixedstring)
**반환 값**
정규식이 일치하면 첫 번째 일치 결과의 캡처 그룹(`1`부터 `N`까지, 여기서 `N`은 `regexp`의 캡처 그룹 수)을 담은 배열을 반환합니다. 일치하는 항목이 없으면 빈 배열을 반환합니다. [`Array(String)`](/ko/reference/data-types/array)
**예시**
**사용 예시**
```sql title=Query theme={null}
WITH '< Server: nginx
< Date: Tue, 22 Jan 2019 00:26:14 GMT
< Content-Type: text/html; charset=UTF-8
< Connection: keep-alive
' AS s
SELECT extractGroups(s, '< ([\\w\\-]+): ([^\\r\\n]+)');
```
```response title=Response theme={null}
['Server','nginx']
```
## hasAllTokens
도입 버전: v25.10.0
[`hasAnyTokens`](#hasAnyTokens)와 유사하지만, `needle` 문자열 또는 배열의 모든 토큰이 `input` 문자열과 일치하면 1을, 그렇지 않으면 0을 반환합니다. `input`이 컬럼인 경우, 해당 조건을 만족하는 모든 행을 반환합니다.
최적의 성능을 위해 컬럼 `input`에는 [텍스트 인덱스](/ko/reference/engines/table-engines/mergetree-family/textindexes)가 정의되어 있어야 합니다.
텍스트 인덱스가 정의되어 있지 않으면 함수는 브루트 포스(전체 스캔) 방식으로 컬럼을 스캔하며, 이는 인덱스 조회보다 훨씬 느립니다.
검색 전에 함수가 토큰화를 수행합니다
* `input` 인수(항상), 그리고
* `needle` 인수([String](/ko/reference/data-types/string)로 지정된 경우)는
텍스트 인덱스에 지정된 토크나이저를 사용해 처리됩니다.
컬럼에 텍스트 인덱스가 정의되어 있지 않으면 대신 `splitByNonAlpha` 토크나이저가 사용됩니다.
`needle` 인수가 [Array(String)](/ko/reference/data-types/array) 타입이면 각 배열 요소가 토큰으로 간주되며, 추가 토큰화는 수행되지 않습니다.
중복된 토큰(token)은 무시됩니다.
예시: needles = \['ClickHouse', 'ClickHouse']는 \['ClickHouse']와 동일하게 처리됩니다.
**구문**
```sql theme={null}
hasAllTokens(input, needles)
```
**별칭(Aliases)**: `hasAllToken`
**인수**
* `input` — 입력 컬럼. [`String`](/ko/reference/data-types/string) 또는 [`FixedString`](/ko/reference/data-types/fixedstring) 또는 [`Array(String)`](/ko/reference/data-types/array) 또는 [`Array(FixedString)`](/ko/reference/data-types/array)
* `needles` — 검색할 토큰. [`String`](/ko/reference/data-types/string) 또는 [`Array(String)`](/ko/reference/data-types/array)
* `tokenizer` — 사용할 토크나이저입니다. 유효한 인수는 `splitByNonAlpha`, `splitByString`, `asciiCJK`, `ngrams`, `sparseGrams`, `array`입니다. 선택 사항이며, 명시적으로 설정하지 않으면 기본값으로 `splitByNonAlpha`가 사용됩니다. [`const String`](/ko/reference/data-types/string)
**반환 값**
모든 needle이 일치하면 1을, 그렇지 않으면 0을 반환합니다. [`UInt8`](/ko/reference/data-types/int-uint)
**예시**
**문자열 needle을 사용한 기본 사용법**
```sql title=Query theme={null}
CREATE TABLE table (
id UInt32,
msg String,
INDEX idx(msg) TYPE text(tokenizer = splitByString(['()', '\\']))
)
ENGINE = MergeTree
ORDER BY id;
INSERT INTO table VALUES (1, '()a,\\bc()d'), (2, '()\\a()bc\\d'), (3, ',()a\\,bc,(),d,');
SELECT count() FROM table WHERE hasAllTokens(msg, 'a\\d()');
```
```response title=Response theme={null}
┌─count()─┐
│ 1 │
└─────────┘
```
**배열에서 있는 그대로(토큰화 없이) 검색할 needle을 지정합니다**
```sql title=Query theme={null}
SELECT count() FROM table WHERE hasAllTokens(msg, ['a', 'd']);
```
```response title=Response theme={null}
┌─count()─┐
│ 1 │
└─────────┘
```
**`tokens` 함수를 사용하여 needle 생성**
```sql title=Query theme={null}
SELECT count() FROM table WHERE hasAllTokens(msg, tokens('a()d', 'splitByString', ['()', '\\']));
```
```response title=Response theme={null}
┌─count()─┐
│ 1 │
└─────────┘
```
**3번째 인수로 사용자 정의 토크나이저 사용**
```sql title=Query theme={null}
SELECT hasAllTokens('abcdef', 'abc', 'ngrams(3)');
```
```response title=Response theme={null}
┌─hasAllTokens('abcdef', 'abc', 'ngrams(3)')─┐
│ 1 │
└──────────────────────────────────────────────┘
```
**배열 및 맵 컬럼의 사용 예시**
```sql title=Query theme={null}
CREATE TABLE log (
id UInt32,
tags Array(String),
attributes Map(String, String),
INDEX idx_tags (tags) TYPE text(tokenizer = splitByNonAlpha),
INDEX idx_attributes_keys mapKeys(attributes) TYPE text(tokenizer = array),
INDEX idx_attributes_vals mapValues(attributes) TYPE text(tokenizer = array)
)
ENGINE = MergeTree
ORDER BY id;
INSERT INTO log VALUES
(1, ['clickhouse', 'clickhouse cloud'], {'address': '192.0.0.1', 'log_level': 'INFO'}),
(2, ['chdb'], {'embedded': 'true', 'log_level': 'DEBUG'});
```
```response title=Response theme={null}
```
**배열 컬럼 예시**
```sql title=Query theme={null}
SELECT count() FROM log WHERE hasAllTokens(tags, 'clickhouse');
```
```response title=Response theme={null}
┌─count()─┐
│ 1 │
└─────────┘
```
**mapKeys 사용 예시**
```sql title=Query theme={null}
SELECT count() FROM log WHERE hasAllTokens(mapKeys(attributes), ['address', 'log_level']);
```
```response title=Response theme={null}
┌─count()─┐
│ 1 │
└─────────┘
```
**mapValues를 사용한 예시**
```sql title=Query theme={null}
SELECT count() FROM log WHERE hasAllTokens(mapValues(attributes), ['192.0.0.1', 'DEBUG']);
```
```response title=Response theme={null}
┌─count()─┐
│ 0 │
└─────────┘
```
## hasAnyTokens
도입 버전: v25.10.0
`needle` 문자열 또는 배열의 토큰 중 하나 이상이 `input` 문자열과 일치하면 1을, 그렇지 않으면 0을 반환합니다. `input`이 컬럼인 경우 해당 조건을 만족하는 모든 행을 반환합니다.
최적의 성능을 위해 컬럼(column) `input`에는 [텍스트 인덱스(text index)](/ko/reference/engines/table-engines/mergetree-family/textindexes)가 정의되어 있어야 합니다.
텍스트 인덱스가 정의되어 있지 않으면 이 함수는 컬럼에 대해 브루트 포스(전체 스캔)를 수행하며, 이는 인덱스 조회보다 몇 자릿수나 더 느립니다.
검색 전에 함수가 토큰화를 수행합니다
* `input` 인수(항상)와
* `needle` 인수([String](/ko/reference/data-types/string)로 지정된 경우)는
텍스트 인덱스에 지정된 토크나이저를 사용해 처리합니다.
컬럼에 텍스트 인덱스가 정의되어 있지 않으면 `splitByNonAlpha` 토크나이저를 대신 사용합니다.
`needle` 인수가 [Array(String)](/ko/reference/data-types/array) 타입이면 각 배열 요소를 토큰으로 간주하며, 추가 토큰화는 수행되지 않습니다.
중복된 토큰은 무시됩니다.
예시: \['ClickHouse', 'ClickHouse']는 \['ClickHouse']와 동일하게 처리됩니다.
**구문**
```sql theme={null}
hasAnyTokens(input, needles)
```
**별칭(Aliases)**: `hasAnyToken`
**인수**
* `input` — 입력 컬럼입니다. [`String`](/ko/reference/data-types/string) 또는 [`FixedString`](/ko/reference/data-types/fixedstring) 또는 [`Nullable(String)`](/ko/reference/data-types/nullable) 또는 [`Nullable(FixedString)`](/ko/reference/data-types/nullable) 또는 [`Array(String)`](/ko/reference/data-types/array) 또는 [`Array(FixedString)`](/ko/reference/data-types/array) 또는 [`Array(Nullable(String))`](/ko/reference/data-types/array) 또는 [`Array(Nullable(FixedString))`](/ko/reference/data-types/array)
* `needles` — 검색 대상 토큰입니다. [`String`](/ko/reference/data-types/string) 또는 [`Array(String)`](/ko/reference/data-types/array)
* `tokenizer` — 사용할 토크나이저입니다. 유효한 인수는 `splitByNonAlpha`, `splitByString`, `asciiCJK`, `ngrams`, `sparseGrams`, `array`입니다. 선택 사항이며, 명시적으로 설정하지 않으면 `splitByNonAlpha`가 기본값으로 사용됩니다. [`const String`](/ko/reference/data-types/string)
**반환 값**
일치하는 항목이 하나 이상 있으면 `1`을, 없으면 `0`을 반환합니다. [`UInt8`](/ko/reference/data-types/int-uint)
**예시**
**문자열 needle을 사용한 기본 사용법**
```sql title=Query theme={null}
CREATE TABLE table (
id UInt32,
msg String,
INDEX idx(msg) TYPE text(tokenizer = splitByString(['()', '\\']))
)
ENGINE = MergeTree
ORDER BY id;
INSERT INTO table VALUES (1, '()a,\\bc()d'), (2, '()\\a()bc\\d'), (3, ',()a\\,bc,(),d,');
SELECT count() FROM table WHERE hasAnyTokens(msg, 'a\\d()');
```
```response title=Response theme={null}
┌─count()─┐
│ 3 │
└─────────┘
```
**배열에서 검색할 needle을 토큰화 없이 있는 그대로 지정합니다**
```sql title=Query theme={null}
SELECT count() FROM table WHERE hasAnyTokens(msg, ['a', 'd']);
```
```response title=Response theme={null}
┌─count()─┐
│ 3 │
└─────────┘
```
**`tokens` 함수를 사용하여 needle 생성**
```sql title=Query theme={null}
SELECT count() FROM table WHERE hasAnyTokens(msg, tokens('a()d', 'splitByString', ['()', '\\']));
```
```response title=Response theme={null}
┌─count()─┐
│ 3 │
└─────────┘
```
**배열 및 맵 컬럼의 사용 예시**
```sql title=Query theme={null}
CREATE TABLE log (
id UInt32,
tags Array(String),
attributes Map(String, String),
INDEX idx_tags (tags) TYPE text(tokenizer = splitByNonAlpha),
INDEX idx_attributes_keys mapKeys(attributes) TYPE text(tokenizer = array),
INDEX idx_attributes_vals mapValues(attributes) TYPE text(tokenizer = array)
)
ENGINE = MergeTree
ORDER BY id;
INSERT INTO log VALUES
(1, ['clickhouse', 'clickhouse cloud'], {'address': '192.0.0.1', 'log_level': 'INFO'}),
(2, ['chdb'], {'embedded': 'true', 'log_level': 'DEBUG'});
```
```response title=Response theme={null}
```
**배열 컬럼을 사용한 예시**
```sql title=Query theme={null}
SELECT count() FROM log WHERE hasAnyTokens(tags, 'clickhouse');
```
```response title=Response theme={null}
┌─count()─┐
│ 1 │
└─────────┘
```
**mapKeys 사용 예시**
```sql title=Query theme={null}
SELECT count() FROM log WHERE hasAnyTokens(mapKeys(attributes), ['address', 'log_level']);
```
```response title=Response theme={null}
┌─count()─┐
│ 2 │
└─────────┘
```
**mapValues를 사용한 예시**
```sql title=Query theme={null}
SELECT count() FROM log WHERE hasAnyTokens(mapValues(attributes), ['192.0.0.1', 'DEBUG']);
```
```response title=Response theme={null}
┌─count()─┐
│ 2 │
└─────────┘
```
## hasPhrase
도입 버전: v26.4.0
haystack에 phrase의 모든 토큰이 연속된 순서로 포함되어 있는지 확인합니다.
검색 전에 이 함수는 선택적 세 번째 인수로 지정한 토크나이저를 사용해 `input` 인수와 `phrase` 인수를 모두 토큰화합니다.
토크나이저 인수는 `splitByNonAlpha`, `splitByString`, `ngrams`, `asciiCJK` 중 하나여야 합니다.
토크나이저를 지정하지 않으면 기본적으로 `splitByNonAlpha` 토크나이저를 사용합니다.
[`hasToken`](#hasToken), [`hasAnyTokens`](#hasAnyTokens), [`hasAllTokens`](#hasAllTokens)와 달리 `hasPhrase`는 토큰이 같은 순서로 나타나야 하며,
그 사이에 다른 토큰이 끼어들어서는 안 됩니다. 예를 들어 `hasPhrase('the quick brown fox', 'quick fox')`는 0을 반환합니다.
이는 "quick"와 "fox" 사이에 "brown"이 있기 때문입니다.
**구문**
```sql theme={null}
hasPhrase(input, phrase[, tokenizer])
```
**별칭**: `matchPhrase`
**인수**
* `input` — 입력 컬럼입니다. [`String`](/ko/reference/data-types/string) 또는 [`FixedString`](/ko/reference/data-types/fixedstring)
* `phrase` — 검색할 구문입니다. [`const String`](/ko/reference/data-types/string)
* `tokenizer` — 사용할 토크나이저입니다. 선택 사항이며, 기본값은 `splitByNonAlpha`입니다. [`const String`](/ko/reference/data-types/string)
**반환 값**
구문이 연속된 토큰 시퀀스로 발견되면 `1`을, 그렇지 않으면 `0`을 반환합니다. [`UInt8`](/ko/reference/data-types/int-uint)
**예시**
**구문 일치**
```sql title=Query theme={null}
SELECT hasPhrase('the quick brown fox jumps', 'quick brown')
```
```response title=Response theme={null}
┌─hasPhrase('the quick brown fox jumps', 'quick brown')─┐
│ 1 │
└────────────────────────────────────────────────────────┘
```
**연속되지 않는 토큰**
```sql title=Query theme={null}
SELECT hasPhrase('the quick brown fox jumps', 'quick fox')
```
```response title=Response theme={null}
┌─hasPhrase('the quick brown fox jumps', 'quick fox')─┐
│ 0 │
└──────────────────────────────────────────────────────┘
```
## hasSubsequence
도입 버전: v23.7.0
needle이 haystack의 부분수열인지 확인합니다.
문자열의 부분수열은 남아 있는 문자의 순서를 바꾸지 않은 채 일부 문자를 삭제하거나 아무 문자도 삭제하지 않아 원래 문자열에서 만들 수 있는 문자열입니다.
**구문**
```sql theme={null}
hasSubsequence(haystack, needle)
```
**인수**
* `haystack` — 부분 수열을 검색할 대상 문자열입니다. [`String`](/ko/reference/data-types/string)
* `needle` — 검색할 부분 수열입니다. [`String`](/ko/reference/data-types/string)
**반환 값**
`needle`이 `haystack`의 부분 수열이면 `1`을 반환하고, 그렇지 않으면 `0`을 반환합니다. [`UInt8`](/ko/reference/data-types/int-uint)
**예시**
**기본 부분 수열 확인**
```sql title=Query theme={null}
SELECT hasSubsequence('Hello World', 'HlWrd')
```
```response title=Response theme={null}
┌─hasSubsequence('Hello World', 'HlWrd')─┐
│ 1 │
└────────────────────────────────────────┘
```
**부분 수열을 찾을 수 없습니다**
```sql title=Query theme={null}
SELECT hasSubsequence('Hello World', 'xyz')
```
```response title=Response theme={null}
┌─hasSubsequence('Hello World', 'xyz')─┐
│ 0 │
└──────────────────────────────────────┘
```
## hasSubsequenceCaseInsensitive
도입 버전: v23.7.0
[`hasSubsequence`](#hasSubsequence)와 같지만 대소문자를 구분하지 않고 검색합니다.
**구문**
```sql theme={null}
hasSubsequenceCaseInsensitive(haystack, needle)
```
**인수**
* `haystack` — 검색을 수행할 String입니다. [`String`](/ko/reference/data-types/string)
* `needle` — 검색할 부분 수열입니다. [`String`](/ko/reference/data-types/string)
**반환 값**
`needle`이 `haystack`의 부분 수열이면 1을 반환하고, 그렇지 않으면 0을 반환합니다. [`UInt8`](/ko/reference/data-types/int-uint)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT hasSubsequenceCaseInsensitive('garbage', 'ARG');
```
```response title=Response theme={null}
┌─hasSubsequenceCaseInsensitive('garbage', 'ARG')─┐
│ 1 │
└─────────────────────────────────────────────────┘
```
## hasSubsequenceCaseInsensitiveUTF8
도입 버전: v23.7.0
[`hasSubsequenceUTF8`](#hasSubsequenceUTF8)와 동일하지만 대소문자를 구분하지 않고 검색합니다.
**구문**
```sql theme={null}
hasSubsequenceCaseInsensitiveUTF8(haystack, needle)
```
**인수**
* `haystack` — 검색이 수행되는 UTF-8 인코딩 문자열입니다. [`String`](/ko/reference/data-types/string)
* `needle` — 검색할 UTF-8 인코딩 부분 수열 문자열입니다. [`String`](/ko/reference/data-types/string)
**반환 값**
`needle`이 `haystack`의 부분 수열이면 1을, 그렇지 않으면 0을 반환합니다. [`UInt8`](/ko/reference/data-types/int-uint)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT hasSubsequenceCaseInsensitiveUTF8('ClickHouse - столбцовая система управления базами данных', 'СИСТЕМА');
```
```response title=Response theme={null}
┌─hasSubsequen⋯ 'СИСТЕМА')─┐
│ 1 │
└──────────────────────────┘
```
## hasSubsequenceUTF8
도입 버전: v23.7.0
[`hasSubsequence`](/ko/reference/functions/regular-functions/string-search-functions#hasSubsequence)와 유사하지만, 검색 대상 문자열과 needle이 UTF-8로 인코딩된 문자열이라고 가정합니다.
**구문**
```sql theme={null}
hasSubsequenceUTF8(haystack, needle)
```
**인수**
* `haystack` — 검색할 대상 문자열입니다. [`String`](/ko/reference/data-types/string)
* `needle` — 검색할 부분수열입니다. [`String`](/ko/reference/data-types/string)
**반환 값**
`needle`이 `검색 대상 문자열`의 부분수열이면 `1`을 반환하고, 그렇지 않으면 `0`을 반환합니다. [`UInt8`](/ko/reference/data-types/int-uint)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT hasSubsequenceUTF8('картошка', 'кошка');
```
```response title=Response theme={null}
┌─hasSubsequen⋯', 'кошка')─┐
│ 1 │
└──────────────────────────┘
```
**일치하지 않는 부분수열**
```sql title=Query theme={null}
SELECT hasSubsequenceUTF8('картошка', 'апельсин');
```
```response title=Response theme={null}
┌─hasSubsequen⋯'апельсин')─┐
│ 0 │
└──────────────────────────┘
```
## hasToken
도입 버전: v20.1.0
지정된 토큰이 검색 대상 문자열에 존재하는지 확인합니다.
토크나이저로 [splitByNonAlpha](/ko/reference/functions/regular-functions/splitting-merging-functions#splitByNonAlpha)를 사용합니다. 즉, 토큰은 연속된 문자 `[0-9A-Za-z_]`(숫자, ASCII 문자, 밑줄)로 이루어진 가능한 가장 긴 부분 문자열로 정의됩니다.
**구문**
```sql theme={null}
hasToken(haystack, token)
```
**인수**
* `haystack` — 검색 대상 문자열입니다. [`String`](/ko/reference/data-types/string)
* `token` — 찾을 토큰입니다. [`const String`](/ko/reference/data-types/string)
**반환 값**
토큰을 찾으면 `1`을, 그렇지 않으면 `0`을 반환합니다. [`UInt8`](/ko/reference/data-types/int-uint)
**예시**
**토큰 검색**
```sql title=Query theme={null}
SELECT hasToken('clickhouse test', 'test')
```
```response title=Response theme={null}
┌─hasToken('clickhouse test', 'test')─┐
│ 1 │
└─────────────────────────────────────┘
```
## hasTokenCaseInsensitive
도입 버전: v20.1.0
tokenbf\_v1 인덱스를 사용하여 검색 대상 문자열에서 needle을 대소문자를 구분하지 않고 조회합니다.
**구문**
```sql theme={null}
hasTokenCaseInsensitive(haystack, needle)
```
**인수**
* 없음.
**반환 값**
**예시**
## hasTokenCaseInsensitiveOrNull
도입 버전: v23.1.0
tokenbf\_v1 인덱스를 사용해 검색 대상 문자열에서 needle을 대소문자를 구분하지 않고 검색합니다. needle 형식이 올바르지 않으면 NULL을 반환합니다.
**구문**
```sql theme={null}
hasTokenCaseInsensitiveOrNull(haystack, needle)
```
**인수**
* 없음.
**반환 값**
**예시**
## hasTokenOrNull
도입 버전: v20.1.0
[`hasToken`](#hasToken)과 비슷하지만, token 형식이 올바르지 않으면 NULL을 반환합니다.
**구문**
```sql theme={null}
hasTokenOrNull(haystack, token)
```
**인수**
* `haystack` — 검색 대상 문자열입니다. 상수여야 합니다. [`String`](/ko/reference/data-types/string)
* `token` — 검색할 토큰입니다. [`const String`](/ko/reference/data-types/string)
**반환 값**
토큰을 찾으면 `1`, 찾지 못하면 `0`을 반환하며, 토큰 형식이 올바르지 않으면 NULL을 반환합니다. [`Nullable(UInt8)`](/ko/reference/data-types/nullable)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT hasTokenOrNull('apple banana cherry', 'ban ana');
```
```response title=Response theme={null}
┌─hasTokenOrNu⋯ 'ban ana')─┐
│ ᴺᵁᴸᴸ │
└──────────────────────────┘
```
## highlight
도입 버전: v26.4.0
텍스트 문자열에서 검색어가 나타난 부분을 HTML 태그로 감싸 강조합니다.
이 함수는 ASCII 기준의 대소문자 비구분 일치를 수행합니다. 여러 검색어가 텍스트에서 서로 겹치거나 인접해 있으면, 일치한 영역은 하나의 강조 구간으로 머지됩니다.
**구문**
```sql theme={null}
highlight(haystack, needles[, open_tag, close_tag])
```
**인수**
* `haystack` — 검색 대상 텍스트입니다. [`String`](/ko/reference/data-types/string) 또는 [`FixedString`](/ko/reference/data-types/fixedstring)
* `needles` — 강조 표시할 검색어 배열입니다. [`const Array(String)`](/ko/reference/data-types/array)
* `open_tag` — 각 일치 항목 앞에 삽입할 여는 태그입니다. 기본값: ``. [`const String`](/ko/reference/data-types/string)
* `close_tag` — 각 일치 항목 뒤에 삽입할 닫는 태그입니다. 기본값: ``. [`const String`](/ko/reference/data-types/string)
**반환 값**
일치한 용어가 지정된 태그로 감싸진 입력 텍스트를 반환합니다. [`String`](/ko/reference/data-types/string)
**예시**
**기본 강조**
```sql title=Query theme={null}
SELECT highlight('The quick brown fox', ['quick', 'fox'])
```
```response title=Response theme={null}
┌─highlight('The quick brown fox', ['quick', 'fox'])─┐
│ The quick brown fox │
└────────────────────────────────────────────────────┘
```
**사용자 지정 태그**
```sql title=Query theme={null}
SELECT highlight('Hello World', ['hello'], '', '')
```
```response title=Response theme={null}
┌─highlight('Hello World', ['hello'], '', '')─┐
│ Hello World │
└────────────────────────────────────────────────────┘
```
## ilike
도입 버전: v20.6.0
[`like`](#like)와 같지만 대소문자를 구분하지 않고 검색합니다.
**구문**
```sql theme={null}
ilike(haystack, pattern)
-- haystack ILIKE pattern
```
**인수**
* `haystack` — 검색을 수행할 String입니다. [`String`](/ko/reference/data-types/string) 또는 [`FixedString`](/ko/reference/data-types/fixedstring)
* `pattern` — 일치 여부를 판단할 LIKE 패턴입니다. [`String`](/ko/reference/data-types/string)
**반환 값**
문자열이 LIKE 패턴과 일치하면 `1`을, 그렇지 않으면 `0`을 반환합니다(대소문자를 구분하지 않음). [`UInt8`](/ko/reference/data-types/int-uint)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT ilike('ClickHouse', '%house%');
```
```response title=Response theme={null}
┌─ilike('ClickHouse', '%house%')─┐
│ 1 │
└────────────────────────────────┘
```
## like
도입 버전: v1.1.0
문자열 `haystack`가 `LIKE` 표현식 `pattern`과 일치하는지 여부를 반환합니다.
`LIKE` 표현식에는 일반 문자와 다음 메타기호를 포함할 수 있습니다.
* `%`는 임의 개수의 임의 문자(0개 포함)를 나타냅니다.
* `_`는 임의의 단일 문자를 나타냅니다.
* `\`는 리터럴 `%`, `_`, `\`를 이스케이프하는 데 사용됩니다.
매칭은 UTF-8을 기준으로 수행됩니다. 예를 들어 `_`는 UTF-8에서 2바이트로 표현되는 유니코드 코드 포인트 `¥`와 일치합니다.
haystack 또는 `LIKE` 표현식이 올바른 UTF-8이 아니면 동작은 정의되지 않습니다.
유니코드 정규화는 자동으로 수행되지 않으므로, 필요하면 `normalizeUTF8*` 함수를 사용할 수 있습니다.
리터럴 `%`, `_`, `\`(`LIKE` 메타문자)과 일치시키려면 앞에 백슬래시를 붙이십시오: `\%`, `\_`, `\\`.
백슬래시는 `%`, `_`, `\`가 아닌 다른 문자 앞에 오면 특별한 의미를 잃고(즉, 리터럴로 해석되고) 처리됩니다.
ClickHouse에서는 문자열 안의 백슬래시도 [따옴표로 묶어야 하므로](/ko/reference/syntax#string), 실제로는 `\\%`, `\\_`, `\\\\`라고 작성해야 합니다.
`%needle%` 형태의 `LIKE` 표현식에서는 이 함수가 `position` 함수만큼 빠릅니다.
그 외의 모든 `LIKE` 표현식은 내부적으로 정규식으로 변환되며, `match` 함수와 비슷한 성능으로 실행됩니다.
**구문**
```sql theme={null}
like(haystack, pattern)
-- haystack LIKE pattern
```
**인수**
* `haystack` — 검색할 문자열입니다. [`String`](/ko/reference/data-types/string) 또는 [`FixedString`](/ko/reference/data-types/fixedstring)
* `pattern` — 매칭할 `LIKE` 패턴입니다. `%`(임의 개수의 문자와 일치), `_`(단일 문자와 일치), 이스케이프용 `\`를 포함할 수 있습니다. [`String`](/ko/reference/data-types/string)
**반환 값**
문자열이 `LIKE` 패턴과 일치하면 `1`을, 그렇지 않으면 `0`을 반환합니다. [`UInt8`](/ko/reference/data-types/int-uint)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT like('ClickHouse', '%House');
```
```response title=Response theme={null}
┌─like('ClickHouse', '%House')─┐
│ 1 │
└──────────────────────────────┘
```
**단일 문자 와일드카드**
```sql title=Query theme={null}
SELECT like('ClickHouse', 'Click_ouse');
```
```response title=Response theme={null}
┌─like('ClickH⋯lick_ouse')─┐
│ 1 │
└──────────────────────────┘
```
**일치하지 않는 패턴**
```sql title=Query theme={null}
SELECT like('ClickHouse', '%SQL%');
```
```response title=Response theme={null}
┌─like('ClickHouse', '%SQL%')─┐
│ 0 │
└─────────────────────────────┘
```
## locate
도입 버전: v18.16.0
[`position`](#position)과 같지만 인수 `haystack`와 `locate`의 순서만 서로 바뀝니다.
**버전에 따라 달라지는 동작**
이 함수의 동작은 ClickHouse 버전에 따라 달라집니다.
* 버전 \< v24.3에서는 `locate`가 함수 `position`의 별칭이었으며, 인수 `(haystack, needle[, start_pos])`를 받았습니다.
* 버전 >= 24.3에서는 `locate`가 별도의 함수이며(MySQL과의 호환성을 높이기 위해), 인수 `(needle, haystack[, start_pos])`를 받습니다.
이전 동작은 설정 `function_locate_has_mysql_compatible_argument_order = false`를 사용해 복원할 수 있습니다.
**구문**
```sql theme={null}
locate(needle, haystack[, start_pos])
```
**인수**
* `needle` — 검색할 부분 문자열입니다. [`String`](/ko/reference/data-types/string)
* `haystack` — 검색이 수행되는 문자열입니다. [`String`](/ko/reference/data-types/string) 또는 [`Enum`](/ko/reference/data-types/enum)
* `start_pos` — 선택 사항입니다. `haystack`에서 검색을 시작할 위치(1부터 시작)입니다. [`UInt`](/ko/reference/data-types/int-uint)
**반환 값**
부분 문자열을 찾은 경우 1부터 세는 시작 바이트 위치를 반환하고, 찾지 못한 경우에는 `0`을 반환합니다. [`UInt64`](/ko/reference/data-types/int-uint)
**예시**
**기본 사용법**
```sql title=Query theme={null}
SELECT locate('ca', 'abcabc')
```
```response title=Response theme={null}
┌─locate('ca', 'abcabc')─┐
│ 3 │
└────────────────────────┘
```
## match
도입 버전: v1.1.0
주어진 문자열이 지정된 정규식 패턴과 일치하는지 확인합니다.
이 함수는 RE2 정규식 라이브러리를 사용합니다. 지원되는 구문은 [re2](https://github.com/google/re2/wiki/Syntax)를 참조하십시오.
매칭은 UTF-8을 전제로 동작합니다. 예를 들어 `¥`는 내부적으로 2바이트를 사용하지만, 매칭 시에는 단일 코드포인트로 처리됩니다.
정규식에는 NULL 바이트가 포함되어서는 안 됩니다.
`haystack` 또는 `pattern`이 올바른 UTF-8이 아니면 동작은 정의되지 않습니다.
re2의 기본 동작과 달리 `.`은 줄바꿈과도 일치합니다. 이를 비활성화하려면 패턴 앞에 `(?-s)`를 추가하십시오.
패턴은 앵커링되지 않습니다. 전체 문자열과 일치시키려면 `^`와 `$`를 사용해 패턴에 직접 앵커를 지정하십시오.
부분 문자열을 검색하기만 하면 되는 경우에는 [`like`](#like) 또는 [`position`](#position) 함수를 대신 사용할 수 있으며, 이 함수들이 이 함수보다 훨씬 빠르게 동작합니다.
대체 연산자 구문: `haystack REGEXP pattern`.
**구문**
```sql theme={null}
match(haystack, pattern)
```
**별칭**: `REGEXP_MATCHES`
**인수**
* `haystack` — 패턴을 검색할 문자열입니다. [`String`](/ko/reference/data-types/string)
* `pattern` — 정규식 패턴입니다. [`const String`](/ko/reference/data-types/string)
**반환 값**
패턴이 일치하면 `1`을 반환하고, 그렇지 않으면 `0`을 반환합니다. [`UInt8`](/ko/reference/data-types/int-uint)
**예시**
**기본 패턴 매칭**
```sql title=Query theme={null}
SELECT match('Hello World', 'Hello.*')
```
```response title=Response theme={null}
┌─match('Hello World', 'Hello.*')─┐
│ 1 │
└─────────────────────────────────┘
```
**패턴이 일치하지 않음**
```sql title=Query theme={null}
SELECT match('Hello World', 'goodbye.*')
```
```response title=Response theme={null}
┌─match('Hello World', 'goodbye.*')─┐
│ 0 │
└───────────────────────────────────┘
```
**부분 문자열 매칭**
```sql title=Query theme={null}
SELECT match('abcde', 'b.*d'), match('abcde', '^b.*d$')
```
```response title=Response theme={null}
┌─match('abcde', 'b.*d')─┬─match('abcde', '^b.*d$')─┐
│ 1 │ 0 │
└─────────────────────────┴───────────────────────────┘
```
## multiFuzzyMatchAllIndices
도입 버전: v20.1.0
[`multiFuzzyMatchAny`](#multiFuzzyMatchAny)와 비슷하지만, 상수 [편집 거리](https://en.wikipedia.org/wiki/Edit_distance) 내에서 입력 문자열과 일치하는 모든 인덱스의 배열을 임의의 순서로 반환합니다.
**구문**
```sql theme={null}
multiFuzzyMatchAllIndices(haystack, distance, [pattern1, pattern2, ..., patternN])
```
**인수**
* `haystack` — 검색을 수행할 `String`입니다. [`String`](/ko/reference/data-types/string)
* `distance` — 퍼지 매칭의 최대 편집 거리입니다. [`UInt8`](/ko/reference/data-types/int-uint)
* `pattern` — 일치 여부를 확인할 패턴의 배열입니다. [`Array(String)`](/ko/reference/data-types/array)
**반환 값**
지정된 편집 거리 내에서 `검색 대상 문자열`과 임의의 순서로 일치하는 모든 패턴의 인덱스(1부터 시작) 배열을 반환합니다. 일치하는 항목이 없으면 빈 배열을 반환합니다. [`Array(UInt64)`](/ko/reference/data-types/array)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT multiFuzzyMatchAllIndices('ClickHouse', 2, ['ClickHouse', 'ClckHouse', 'ClickHose', 'House']);
```
```response title=Response theme={null}
┌─multiFuzzyMa⋯, 'House'])─┐
│ [3,1,4,2] │
└──────────────────────────┘
```
## multiFuzzyMatchAny
도입 버전: v20.1.0
[`multiMatchAny`](#multiMatchAny)와 유사하지만, 고정된 [편집 거리](https://en.wikipedia.org/wiki/Edit_distance) 내에서 패턴 중 하나라도 검색 대상 문자열과 일치하면 1을 반환합니다.
이 함수는 [hyperscan](https://intel.github.io/hyperscan/dev-reference/compilation.html#approximate-matching) 라이브러리의 실험적 기능에 의존하므로, 일부 예외적인 경우에는 느릴 수 있습니다.
성능은 편집 거리 값과 사용된 패턴에 따라 달라지지만, 비퍼지 변형과 비교하면 항상 더 많은 비용이 듭니다.
hyperscan의 제한으로 인해 `multiFuzzyMatch*()` 함수 계열은 UTF-8 정규식을 지원하지 않습니다(UTF-8 정규식을 바이트 시퀀스로 처리합니다).
**구문**
```sql theme={null}
multiFuzzyMatchAny(haystack, distance, [pattern1, pattern2, ..., patternN])
```
**인수**
* `haystack` — 검색 대상 문자열입니다. [`String`](/ko/reference/data-types/string)
* `distance` — fuzzy matching의 최대 편집 거리입니다. [`UInt8`](/ko/reference/data-types/int-uint)
* `pattern` — 선택 사항입니다. 일치 여부를 확인할 패턴 배열입니다. [`Array(String)`](/ko/reference/data-types/array)
**반환 값**
지정된 편집 거리 이내에서 패턴 중 하나라도 `검색 대상 문자열`과 일치하면 `1`을, 그렇지 않으면 `0`을 반환합니다. [`UInt8`](/ko/reference/data-types/int-uint)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT multiFuzzyMatchAny('ClickHouse', 2, ['ClickHouse', 'ClckHouse', 'ClickHose']);
```
```response title=Response theme={null}
┌─multiFuzzyMa⋯lickHose'])─┐
│ 1 │
└──────────────────────────┘
```
## multiFuzzyMatchAnyIndex
도입 버전: v20.1.0
[`multiFuzzyMatchAny`](#multiFuzzyMatchAny)와 비슷하지만, 고정된 [편집 거리](https://en.wikipedia.org/wiki/Edit_distance) 내에서 검색 대상 문자열과 일치하는 임의의 인덱스를 반환합니다.
**구문**
```sql theme={null}
multiFuzzyMatchAnyIndex(haystack, distance, [pattern1, pattern2, ..., patternn])
```
**인수**
* `haystack` — 검색이 수행되는 String입니다. [`String`](/ko/reference/data-types/string)
* `distance` — 퍼지 매칭의 최대 편집 거리입니다. [`UInt8`](/ko/reference/data-types/int-uint)
* `pattern` — 매칭할 패턴의 배열입니다. [`Array(String)`](/ko/reference/data-types/array)
**반환 값**
지정된 편집 거리 내에서 `haystack`과 일치하는 패턴이 있으면 해당 패턴의 인덱스(1부터 시작)를 반환하고, 없으면 `0`을 반환합니다. [`UInt64`](/ko/reference/data-types/int-uint)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT multiFuzzyMatchAnyIndex('ClickHouse', 2, ['ClckHouse', 'ClickHose', 'ClickHouse']);
```
```response title=Response theme={null}
┌─multiFuzzyMa⋯ickHouse'])─┐
│ 2 │
└──────────────────────────┘
```
## multiMatchAllIndices
v20.1.0에서 도입됨
[`multiMatchAny`](#multiMatchAny)와 비슷하지만, 검색 대상 문자열과 임의의 순서로 일치하는 모든 인덱스의 배열을 반환합니다.
**구문**
```sql theme={null}
multiMatchAllIndices(haystack, [pattern1, pattern2, ..., patternn])
```
**인수**
* `haystack` — 검색을 수행할 String입니다. [`String`](/ko/reference/data-types/string)
* `pattern` — 매칭에 사용할 정규식입니다. [`String`](/ko/reference/data-types/string)
**반환 값**
haystack와 임의의 순서로 매칭되는 모든 인덱스(1부터 시작)의 배열입니다. 일치하는 항목이 없으면 빈 배열을 반환합니다. [`Array(UInt64)`](/ko/reference/data-types/array)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT multiMatchAllIndices('ClickHouse', ['[0-9]', 'House', 'Click', 'ouse']);
```
```response title=Response theme={null}
┌─multiMatchAl⋯', 'ouse'])─┐
│ [3, 2, 4] │
└──────────────────────────┘
```
## multiMatchAny
도입 버전: v20.1.0
여러 정규식 패턴 중 하나 이상이 입력 문자열과 일치하는지 확인합니다.
문자열에서 여러 부분 문자열만 검색하려는 경우에는 [`multiSearchAny`](#multiSearchAny) 함수를 대신 사용할 수 있습니다. 이 함수가 훨씬 더 빠르게 동작합니다.
**구문**
```sql theme={null}
multiMatchAny(haystack, pattern1[, pattern2, ...])
```
**인수**
* `haystack` — 패턴을 검색할 대상 `String`. [`String`](/ko/reference/data-types/string)
* `pattern1[, pattern2, ...]` — 하나 이상의 정규식 패턴으로 구성된 배열. [`Array(String)`](/ko/reference/data-types/array)
**반환 값**
하나라도 패턴과 일치하면 `1`, 그렇지 않으면 `0`을 반환합니다. [`UInt8`](/ko/reference/data-types/int-uint)
**예시**
**여러 패턴 매칭**
```sql title=Query theme={null}
SELECT multiMatchAny('Hello World', ['Hello.*', 'foo.*'])
```
```response title=Response theme={null}
┌─multiMatchAny('Hello World', ['Hello.*', 'foo.*'])─┐
│ 1 │
└────────────────────────────────────────────────────┘
```
**일치하는 패턴이 없습니다**
```sql title=Query theme={null}
SELECT multiMatchAny('Hello World', ['goodbye.*', 'foo.*'])
```
```response title=Response theme={null}
┌─multiMatchAny('Hello World', ['goodbye.*', 'foo.*'])─┐
│ 0 │
└──────────────────────────────────────────────────────┘
```
## multiMatchAnyIndex
도입 버전: v20.1.0
[`multiMatchAny`](#multiMatchAny)와 비슷하지만, haystack에서 일치하는 임의의 인덱스를 반환합니다.
**구문**
```sql theme={null}
multiMatchAnyIndex(haystack, [pattern1, pattern2, ..., patternn])
```
**인수**
* `haystack` — 검색을 수행할 String입니다. [`String`](/ko/reference/data-types/string)
* `pattern` — 매칭할 정규식입니다. [`Array(String)`](/ko/reference/data-types/array)
**반환 값**
처음으로 일치하는 패턴의 인덱스(1부터 시작)를 반환합니다. 일치하는 패턴이 없으면 0을 반환합니다. [`UInt64`](/ko/reference/data-types/int-uint)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT multiMatchAnyIndex('ClickHouse', ['[0-9]', 'House', 'Click']);
```
```response title=Response theme={null}
┌─multiMatchAn⋯, 'Click'])─┐
│ 3 │
└──────────────────────────┘
```
## multiSearchAllPositions
도입 버전: v20.1.0
[`position`](#position)과 유사하지만, `haystack` 문자열에서 여러 `needle` 부분 문자열의 위치(바이트 단위, 1부터 시작)를 배열로 반환합니다.
모든 `multiSearch*()` 함수는 최대 2^8개의 `needle`만 지원합니다.
**구문**
```sql theme={null}
multiSearchAllPositions(haystack, needle1[, needle2, ...])
```
**인수**
* `haystack` — 검색을 수행할 String입니다. [`String`](/ko/reference/data-types/string)
* `needle1[, needle2, ...]` — 검색할 하나 이상의 부분 문자열로 이루어진 배열입니다. [`Array(String)`](/ko/reference/data-types/array)
**반환 값**
부분 문자열을 찾은 경우 시작 위치를 바이트 단위로 1부터 세어 배열로 반환하고, 찾지 못한 경우 `0`을 반환합니다. [`Array(UInt64)`](/ko/reference/data-types/array)
**예시**
**여러 needle 검색**
```sql title=Query theme={null}
SELECT multiSearchAllPositions('Hello, World!', ['hello', '!', 'world'])
```
```response title=Response theme={null}
┌─multiSearchAllPositions('Hello, World!', ['hello', '!', 'world'])─┐
│ [0,13,0] │
└───────────────────────────────────────────────────────────────────┘
```
## multiSearchAllPositionsCaseInsensitive
도입 버전: v20.1.0
[`multiSearchAllPositions`](#multiSearchAllPositions)와 같지만 대소문자를 구분하지 않습니다.
**구문**
```sql theme={null}
multiSearchAllPositionsCaseInsensitive(haystack, needle1[, needle2, ...])
```
**인수**
* `haystack` — 검색을 수행할 haystack입니다. [`String`](/ko/reference/data-types/string)
* `needle1[, needle2, ...]` — 검색할 하나 이상의 부분 문자열로 이루어진 배열입니다. [`Array(String)`](/ko/reference/data-types/array)
**반환 값**
부분 문자열을 찾은 경우 바이트 단위 시작 위치를 담은 배열을 반환하며, 위치는 1부터 계산합니다. 부분 문자열을 찾지 못한 경우 `0`을 반환합니다. [`Array(UInt64)`](/ko/reference/data-types/array)
**예시**
**대소문자를 구분하지 않는 다중 검색**
```sql title=Query theme={null}
SELECT multiSearchAllPositionsCaseInsensitive('ClickHouse',['c','h'])
```
```response title=Response theme={null}
┌─multiSearchA⋯['c', 'h'])─┐
│ [1,6] │
└──────────────────────────┘
```
## multiSearchAllPositionsCaseInsensitiveUTF8
도입 버전: v20.1.0
[`multiSearchAllPositionsUTF8`](#multiSearchAllPositionsUTF8)와 같지만 대소문자를 구분하지 않습니다.
**구문**
```sql theme={null}
multiSearchAllPositionsCaseInsensitiveUTF8(haystack, [needle1, needle2, ..., needleN])
```
**인수**
* `haystack` — 검색을 수행할 UTF-8 인코딩 문자열입니다. [`String`](/ko/reference/data-types/string)
* `needle` — 검색할 UTF-8 인코딩 needle입니다. [`Array(String)`](/ko/reference/data-types/array)
**반환 값**
부분 문자열을 찾은 경우, 각 부분 문자열의 시작 위치를 바이트 단위의 1부터 시작하는 배열로 반환합니다. 부분 문자열을 찾지 못한 경우 0을 반환합니다. [`Array`](/ko/reference/data-types/array)
**예시**
**대소문자를 구분하지 않는 UTF-8 검색**
```sql title=Query theme={null}
SELECT multiSearchAllPositionsCaseInsensitiveUTF8('Здравствуй, мир!', ['здравствуй', 'МИР']);
```
```response title=Response theme={null}
┌─multiSearchA⋯й', 'МИР'])─┐
│ [1, 13] │
└──────────────────────────┘
```
## multiSearchAllPositionsUTF8
도입 버전: v20.1.0
[`multiSearchAllPositions`](#multiSearchAllPositions)와 같지만 `haystack`과 `needle` 부분 문자열을 UTF-8로 인코딩된 문자열로 가정합니다.
**구문**
```sql theme={null}
multiSearchAllPositionsUTF8(haystack, needle1[, needle2, ...])
```
**인수**
* `haystack` — 검색이 수행되는 UTF-8 인코딩 문자열입니다. [`String`](/ko/reference/data-types/string)
* `needle1[, needle2, ...]` — 검색할 UTF-8 인코딩 부분 문자열의 배열입니다. [`Array(String)`](/ko/reference/data-types/array)
**반환 값**
각 부분 문자열의 시작 위치를 바이트 단위로 담은 배열을 반환합니다. 위치는 1부터 셉니다(부분 문자열을 찾은 경우). 부분 문자열을 찾지 못한 경우 `0`을 반환합니다. [`Array`](/ko/reference/data-types/array)
**예시**
**UTF-8 다중 검색**
```sql title=Query theme={null}
SELECT multiSearchAllPositionsUTF8('ClickHouse',['C','H'])
```
```response title=Response theme={null}
┌─multiSearchAllPositionsUTF8('ClickHouse', ['C', 'H'])─┐
│ [1,6] │
└───────────────────────────────────────────────────────┘
```
## multiSearchAny
도입 버전: v20.1.0
여러 needle 문자열 중 하나 이상이 haystack 문자열에서 일치하는지 확인합니다.
함수 [`multiSearchAnyCaseInsensitive`](#multiSearchAnyCaseInsensitive), [`multiSearchAnyUTF8`](#multiSearchAnyUTF8) 및 [`multiSearchAnyCaseInsensitiveUTF8`](#multiSearchAnyCaseInsensitiveUTF8)는 이 함수의 대소문자를 구분하지 않는 변형 및/또는 UTF-8 변형을 제공합니다.
**구문**
```sql theme={null}
multiSearchAny(haystack, needle1[, needle2, ...])
```
**인수**
* `haystack` — 검색을 수행할 String입니다. [`String`](/ko/reference/data-types/string)
* `needle1[, needle2, ...]` — 검색할 하위 문자열의 배열입니다. [`Array(String)`](/ko/reference/data-types/array)
**반환 값**
하나 이상 일치하면 `1`을, 그렇지 않으면 `0`을 반환합니다. [`UInt8`](/ko/reference/data-types/int-uint)
**예시**
**하나 이상 일치 검색**
```sql title=Query theme={null}
SELECT multiSearchAny('ClickHouse',['C','H'])
```
```response title=Response theme={null}
┌─multiSearchAny('ClickHouse', ['C', 'H'])─┐
│ 1 │
└──────────────────────────────────────────┘
```
## multiSearchAnyCaseInsensitive
도입 버전: v20.1.0
[multiSearchAny](#multiSearchAny)와 같지만 대소문자를 구분하지 않습니다.
**구문**
```sql theme={null}
multiSearchAnyCaseInsensitive(haystack, [needle1, needle2, ..., needleN])
```
**인수**
* `haystack` — 검색을 수행할 `String`입니다. [`String`](/ko/reference/data-types/string)
* `needle` — 검색할 부분 문자열들입니다. [`Array(String)`](/ko/reference/data-types/array)
**반환 값**
대소문자를 구분하지 않는 일치 항목이 하나 이상 있으면 `1`을, 그렇지 않으면 `0`을 반환합니다. [`UInt8`](/ko/reference/data-types/int-uint)
**예시**
**대소문자를 구분하지 않는 검색**
```sql title=Query theme={null}
SELECT multiSearchAnyCaseInsensitive('ClickHouse',['c','h'])
```
```response title=Response theme={null}
┌─multiSearchAnyCaseInsensitive('ClickHouse', ['c', 'h'])─┐
│ 1 │
└─────────────────────────────────────────────────────────┘
```
## multiSearchAnyCaseInsensitiveUTF8
도입된 버전: v20.1.0
[multiSearchAnyUTF8](#multiSearchAnyUTF8)와 같지만 대소문자를 구분하지 않습니다.
**구문**
```sql theme={null}
multiSearchAnyCaseInsensitiveUTF8(haystack, [needle1, needle2, ..., needleN])
```
**인수**
* `haystack` — 검색이 수행되는 UTF-8 문자열입니다. [`String`](/ko/reference/data-types/string)
* `needle` — 검색할 UTF-8 부분 문자열들입니다. [`Array(String)`](/ko/reference/data-types/array)
**반환 값**
대소문자를 구분하지 않는 일치 항목이 하나 이상 있으면 `1`을, 그렇지 않으면 `0`을 반환합니다. [`UInt8`](/ko/reference/data-types/int-uint)
**예시**
**UTF-8 문자열 'Здравствуйте'가 주어졌을 때 소문자 'з'가 포함되어 있는지 확인합니다**
```sql title=Query theme={null}
SELECT multiSearchAnyCaseInsensitiveUTF8('Здравствуйте',['з'])
```
```response title=Response theme={null}
┌─multiSearchA⋯те', ['з'])─┐
│ 1 │
└──────────────────────────┘
```
## multiSearchAnyUTF8
도입 버전: v20.1.0
[multiSearchAny](#multiSearchAny)와 비슷하지만 `haystack`과 `needle` 부분 문자열은 UTF-8로 인코딩된 문자열이라고 가정합니다.
**구문**
```sql theme={null}
multiSearchAnyUTF8(haystack, [needle1, needle2, ..., needleN])
```
**인수**
* `haystack` — 검색이 수행되는 UTF-8 문자열입니다. [`String`](/ko/reference/data-types/string)
* `needle` — 검색할 UTF-8 부분 문자열들입니다. [`Array(String)`](/ko/reference/data-types/array)
**반환 값**
일치하는 항목이 하나 이상 있으면 `1`을, 없으면 `0`을 반환합니다. [`UInt8`](/ko/reference/data-types/int-uint)
**예시**
**UTF-8 문자열 '你好，世界' ('Hello, world')가 주어졌을 때, 문자열에 你 또는 界 문자가 포함되어 있는지 확인합니다**
```sql title=Query theme={null}
SELECT multiSearchAnyUTF8('你好，世界', ['你', '界'])
```
```response title=Response theme={null}
┌─multiSearchA⋯你', '界'])─┐
│ 1 │
└──────────────────────────┘
```
## multiSearchFirstIndex
도입 버전: v20.1.0
haystack 문자열에서 여러 needle 문자열을 검색하고(대소문자 구분), 가장 먼저 발견된 needle의 1부터 시작하는 인덱스를 반환합니다.
**구문**
```sql theme={null}
multiSearchFirstIndex(haystack, [needle1, needle2, ..., needleN])
```
**인수**
* `haystack` — 검색할 대상 문자열입니다. [`String`](/ko/reference/data-types/string)
* `needles` — 검색할 문자열 배열입니다. [`Array(String)`](/ko/reference/data-types/array)
**반환 값**
`haystack`에서 처음 발견된 `needle`의 1부터 시작하는 인덱스(`needles` 배열 내 위치)를 반환합니다. 발견된 `needle`이 없으면 0을 반환합니다. 검색은 대소문자를 구분합니다. [`UInt64`](/ko/reference/data-types/int-uint)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT multiSearchFirstIndex('ClickHouse Database', ['Click', 'Database', 'Server']);
```
```response title=Response theme={null}
┌─multiSearchF⋯ 'Server'])─┐
│ 1 │
└──────────────────────────┘
```
**대소문자 구분 동작**
```sql title=Query theme={null}
SELECT multiSearchFirstIndex('ClickHouse Database', ['CLICK', 'Database', 'Server']);
```
```response title=Response theme={null}
┌─multiSearchF⋯ 'Server'])─┐
│ 2 │
└──────────────────────────┘
```
**일치하는 항목을 찾을 수 없습니다**
```sql title=Query theme={null}
SELECT multiSearchFirstIndex('Hello World', ['goodbye', 'test']);
```
```response title=Response theme={null}
┌─multiSearchF⋯', 'test'])─┐
│ 0 │
└──────────────────────────┘
```
## multiSearchFirstIndexCaseInsensitive
도입 버전: v20.1.0
문자열 `haystack`에서 가장 왼쪽에 있는 needle\_i가 발견되면 그 인덱스 `i`(1부터 시작)를 반환하고, 그렇지 않으면 0을 반환합니다.
대소문자를 구분하지 않습니다.
**구문**
```sql theme={null}
multiSearchFirstIndexCaseInsensitive(haystack, [needle1, needle2, ..., needleN]
```
**인수**
* `haystack` — 검색이 수행되는 haystack입니다. [`String`](/ko/reference/data-types/string)
* `needle` — 검색할 부분 문자열들입니다. [`Array(String)`](/ko/reference/data-types/array)
**반환 값**
가장 왼쪽에서 처음 발견된 `needle`의 인덱스(1부터 시작)를 반환합니다. 일치하는 항목이 없으면 `0`을 반환합니다. [`UInt8`](/ko/reference/data-types/int-uint)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT multiSearchFirstIndexCaseInsensitive('hElLo WoRlD', ['World', 'Hello']);
```
```response title=Response theme={null}
┌─multiSearchF⋯, 'Hello'])─┐
│ 1 │
└──────────────────────────┘
```
## multiSearchFirstIndexCaseInsensitiveUTF8
도입 버전: v20.1.0
UTF-8 인코딩을 지원하며, haystack 문자열에서 여러 needle 문자열을 대소문자를 구분하지 않고 검색하여 가장 먼저 찾은 needle의 1부터 시작하는 인덱스를 반환합니다.
**구문**
```sql theme={null}
multiSearchFirstIndexCaseInsensitiveUTF8(haystack, [needle1, needle2, ..., needleN])
```
**인수**
* `haystack` — 검색 대상 문자열입니다. [`String`](/ko/reference/data-types/string)
* `needles` — 검색할 문자열 배열입니다. [`Array(String)`](/ko/reference/data-types/array)
**반환 값**
`haystack`에서 처음 발견된 `needle`의 1부터 시작하는 인덱스(`needles` 배열 내 위치)를 반환합니다. 어떤 `needle`도 발견되지 않으면 0을 반환합니다. 검색은 대소문자를 구분하지 않으며 UTF-8 문자 인코딩을 지원합니다. [`UInt64`](/ko/reference/data-types/int-uint)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT multiSearchFirstIndexCaseInsensitiveUTF8('ClickHouse Database', ['CLICK', 'data', 'server']);
```
```response title=Response theme={null}
┌─multiSearchF⋯ 'server'])─┐
│ 1 │
└──────────────────────────┘
```
**UTF-8 대소문자 처리**
```sql title=Query theme={null}
SELECT multiSearchFirstIndexCaseInsensitiveUTF8('Привет Мир', ['мир', 'ПРИВЕТ']);
```
```response title=Response theme={null}
┌─multiSearchF⋯ 'ПРИВЕТ'])─┐
│ 1 │
└──────────────────────────┘
```
**일치하는 항목이 없습니다**
```sql title=Query theme={null}
SELECT multiSearchFirstIndexCaseInsensitiveUTF8('Hello World', ['goodbye', 'test']);
```
```response title=Response theme={null}
┌─multiSearchF⋯', 'test'])─┐
│ 0 │
└──────────────────────────┘
```
## multiSearchFirstIndexUTF8
도입 버전: v20.1.0
문자열 `haystack`에서 가장 왼쪽에서 찾은 needle\_i의 인덱스 `i`(1부터 시작)를 반환하며, 찾지 못하면 0을 반환합니다.
`haystack`와 `needle`은 UTF-8로 인코딩된 문자열이라고 가정합니다.
**구문**
```sql theme={null}
multiSearchFirstIndexUTF8(haystack, [needle1, needle2, ..., needleN])
```
**인수**
* `haystack` — 검색할 UTF-8 문자열입니다. [`String`](/ko/reference/data-types/string)
* `needle` — 검색할 UTF-8 부분 문자열의 배열입니다. [`Array(String)`](/ko/reference/data-types/array)
**반환 값**
`needle` 중 가장 먼저 발견된 항목의 인덱스(1부터 시작)를 반환합니다. 일치하는 항목이 없으면 0을 반환합니다. [`UInt8`](/ko/reference/data-types/int-uint)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT multiSearchFirstIndexUTF8('Здравствуйте мир', ['мир', 'здравствуйте']);
```
```response title=Response theme={null}
┌─multiSearchF⋯вствуйте'])─┐
│ 1 │
└──────────────────────────┘
```
## multiSearchFirstPosition
도입 버전: v20.1.0
[`position`](#position)과 유사하지만, 여러 `needle` 문자열 중 하나와 일치하는 `haystack` 문자열에서 가장 앞쪽 일치 위치의 오프셋(leftmost offset)을 반환합니다.
함수 [`multiSearchFirstPositionCaseInsensitive`](#multiSearchFirstPositionCaseInsensitive), [`multiSearchFirstPositionUTF8`](#multiSearchFirstPositionUTF8), [`multiSearchFirstPositionCaseInsensitiveUTF8`](#multiSearchFirstPositionCaseInsensitiveUTF8)는 이 함수의 대소문자 비구분 및/또는 UTF-8 변형을 제공합니다.
**구문**
```sql theme={null}
multiSearchFirstPosition(haystack, needle1[, needle2, ...])
```
**인수**
* `haystack` — 검색을 수행할 String입니다. [`String`](/ko/reference/data-types/string)
* `needle1[, needle2, ...]` — 검색할 하나 이상의 부분 문자열로 이루어진 배열입니다. [`Array(String)`](/ko/reference/data-types/array)
**반환 값**
`haystack` 문자열에서 여러 `needle` 문자열 중 하나와 일치하는 가장 왼쪽 오프셋을 반환합니다. 일치하는 항목이 없으면 `0`을 반환합니다. [`UInt64`](/ko/reference/data-types/int-uint)
**예시**
**첫 번째 위치 검색**
```sql title=Query theme={null}
SELECT multiSearchFirstPosition('Hello World',['llo', 'Wor', 'ld'])
```
```response title=Response theme={null}
┌─multiSearchFirstPosition('Hello World', ['llo', 'Wor', 'ld'])─┐
│ 3 │
└───────────────────────────────────────────────────────────────┘
```
## multiSearchFirstPositionCaseInsensitive
도입 버전: v20.1.0
[multiSearchFirstPosition](#multiSearchFirstPosition)와 같지만 대소문자를 구분하지 않습니다.
**구문**
```sql theme={null}
multiSearchFirstPositionCaseInsensitive(haystack, [needle1, needle2, ..., needleN])
```
**인수**
* `haystack` — 검색이 수행되는 String입니다. [`String`](/ko/reference/data-types/string)
* `needle` — 검색할 needle의 배열입니다. [`Array(String)`](/ko/reference/data-types/array)
**반환 값**
여러 `needle` 문자열 중 하나와 일치하는 `haystack` 문자열에서 가장 먼저 일치하는 위치의 오프셋을 반환합니다. 일치하는 항목이 없으면 `0`을 반환합니다. [`UInt64`](/ko/reference/data-types/int-uint)
**예시**
**대소문자를 구분하지 않는 첫 번째 위치**
```sql title=Query theme={null}
SELECT multiSearchFirstPositionCaseInsensitive('HELLO WORLD',['wor', 'ld', 'ello'])
```
```response title=Response theme={null}
┌─multiSearchFirstPositionCaseInsensitive('HELLO WORLD', ['wor', 'ld', 'ello'])─┐
│ 2 │
└───────────────────────────────────────────────────────────────────────────────┘
```
## multiSearchFirstPositionCaseInsensitiveUTF8
도입 버전: v20.1.0
[multiSearchFirstPosition](#multiSearchFirstPosition)와 유사하지만, `haystack`과 `needle`이 UTF-8 문자열이라고 가정하고 대소문자를 구분하지 않습니다.
**구문**
```sql theme={null}
multiSearchFirstPositionCaseInsensitiveUTF8(haystack, [needle1, needle2, ..., needleN])
```
**인수**
* `haystack` — 검색을 수행할 UTF-8 문자열입니다. [`String`](/ko/reference/data-types/string)
* `needle` — 검색할 UTF-8 needle의 배열입니다. [`Array(String)`](/ko/reference/data-types/array)
**반환 값**
대소문자를 구분하지 않고, 여러 `needle` 문자열 중 하나와 일치하는 `haystack` 문자열에서 가장 왼쪽에 있는 일치 위치의 오프셋을 반환합니다. 일치하는 항목이 없으면 `0`을 반환합니다. [`UInt64`](/ko/reference/data-types/int-uint)
**예시**
**주어진 `needle` 중 하나와 일치하는 UTF-8 문자열 'Здравствуй, мир' ('Hello, world')에서 가장 왼쪽 일치 위치의 오프셋 찾기**
```sql title=Query theme={null}
SELECT multiSearchFirstPositionCaseInsensitiveUTF8('Здравствуй, мир', ['МИР', 'вст', 'Здра'])
```
```response title=Response theme={null}
┌─multiSearchFirstPositionCaseInsensitiveUTF8('Здравствуй, мир', ['мир', 'вст', 'Здра'])─┐
│ 3 │
└────────────────────────────────────────────────────────────────────────────────────────┘
```
## multiSearchFirstPositionUTF8
도입 버전: v20.1.0
[multiSearchFirstPosition](#multiSearchFirstPosition)와 유사하지만 `haystack`과 `needle`이 UTF-8 문자열이라고 가정합니다.
**구문**
```sql theme={null}
multiSearchFirstPositionUTF8(haystack, [needle1, needle2, ..., needleN])
```
**인수**
* `haystack` — 검색을 수행할 UTF-8 문자열입니다. [`String`](/ko/reference/data-types/string)
* `needle` — 검색할 UTF-8 부분 문자열 배열입니다. [`Array(String)`](/ko/reference/data-types/array)
**반환 값**
여러 `needle` 문자열 중 하나와 일치하는 `haystack` 문자열 내 가장 왼쪽 오프셋입니다. 일치하는 항목이 없으면 `0`을 반환합니다. [`UInt64`](/ko/reference/data-types/int-uint)
**예시**
**주어진 needle 중 하나와 일치하는 UTF-8 문자열 'Здравствуй, мир' ('Hello, world')에서 가장 왼쪽 오프셋 찾기**
```sql title=Query theme={null}
SELECT multiSearchFirstPositionUTF8('Здравствуй, мир',['мир', 'вст', 'авст'])
```
```response title=Response theme={null}
┌─multiSearchFirstPositionUTF8('Здравствуй, мир', ['мир', 'вст', 'авст'])─┐
│ 3 │
└─────────────────────────────────────────────────────────────────────────┘
```
## ngramDistance
도입 버전: v20.1.0
두 문자열 간의 4-그램 거리를 계산합니다.
이를 위해 두 4-그램 멀티셋의 대칭 차집합을 구한 뒤, 각 멀티셋의 원소 수 합으로 정규화합니다.
반환 값이 작을수록 두 문자열은 더 유사합니다.
대소문자를 구분하지 않는 검색을 수행하거나 UTF8 포맷을 사용하는 경우 [`ngramDistanceCaseInsensitive`](#ngramDistanceCaseInsensitive), [`ngramDistanceUTF8`](#ngramDistanceUTF8), [`ngramDistanceCaseInsensitiveUTF8`](#ngramDistanceCaseInsensitiveUTF8) 함수를 사용하십시오.
**구문**
```sql theme={null}
ngramDistance(haystack, needle)
```
**인수**
* `haystack` — 비교할 문자열입니다. [`String`](/ko/reference/data-types/string)
* `needle` — 비교할 문자열입니다. [`String`](/ko/reference/data-types/string)
**반환 값**
`0`과 `1` 사이의 Float32 값을 반환합니다. 반환 값이 작을수록 두 문자열의 유사도가 높습니다. [`Float32`](/ko/reference/data-types/float)
**예시**
**4-그램 거리 계산**
```sql title=Query theme={null}
SELECT ngramDistance('ClickHouse', 'ClickHouses')
```
```response title=Response theme={null}
┌─ngramDistance('ClickHouse', 'ClickHouses')─┐
│ 0.1 │
└────────────────────────────────────────────┘
```
## ngramDistanceCaseInsensitive
도입 버전: v20.1.0
[`ngramDistance`](#ngramDistance)의 대소문자 비구분 버전을 제공합니다.
대소문자를 구분하지 않고 두 문자열 사이의 4-그램 거리를 계산합니다.
반환 값이 작을수록 두 문자열의 유사도가 높습니다.
**구문**
```sql theme={null}
ngramDistanceCaseInsensitive(haystack, needle)
```
**인수**
* `haystack` — 첫 번째 비교 대상 문자열입니다. [`String`](/ko/reference/data-types/string)
* `needle` — 두 번째 비교 대상 문자열입니다. [`String`](/ko/reference/data-types/string)
**반환 값**
`0`과 `1` 사이의 `Float32` 값을 반환합니다. [`Float32`](/ko/reference/data-types/float)
**예시**
**대소문자를 구분하지 않는 4-그램 거리**
```sql title=Query theme={null}
SELECT ngramDistanceCaseInsensitive('ClickHouse','clickhouse')
```
```response title=Response theme={null}
┌─ngramDistanceCaseInsensitive('ClickHouse','clickhouse')─┐
│ 0 │
└─────────────────────────────────────────────────────────┘
```
## ngramDistanceCaseInsensitiveUTF8
도입 버전: v20.1.0
[`ngramDistance`](#ngramDistance)의 대소문자를 구분하지 않는 UTF-8 변형을 제공합니다.
`needle` 및 `haystack` 문자열은 UTF-8로 인코딩된 문자열이라고 가정하며, 대소문자를 구분하지 않습니다.
대소문자를 구분하지 않고 두 UTF-8 문자열 사이의 3-그램 거리를 계산합니다.
반환 값이 작을수록 두 문자열의 유사도가 높습니다.
**구문**
```sql theme={null}
ngramDistanceCaseInsensitiveUTF8(haystack, needle)
```
**인수**
* `haystack` — 첫 번째 UTF-8 인코딩 비교 문자열입니다. [`String`](/ko/reference/data-types/string)
* `needle` — 두 번째 UTF-8 인코딩 비교 문자열입니다. [`String`](/ko/reference/data-types/string)
**반환 값**
`0`과 `1` 사이의 `Float32` 값을 반환합니다. [`Float32`](/ko/reference/data-types/float)
**예시**
**대소문자를 구분하지 않는 UTF-8 3-그램 거리**
```sql title=Query theme={null}
SELECT ngramDistanceCaseInsensitiveUTF8('abcde','CDE')
```
```response title=Response theme={null}
┌─ngramDistanceCaseInsensitiveUTF8('abcde','CDE')─┐
│ 0.5 │
└─────────────────────────────────────────────────┘
```
## ngramDistanceUTF8
도입 버전: v20.1.0
[`ngramDistance`](#ngramDistance)의 UTF-8 변형을 제공합니다.
`needle` 및 `haystack` 문자열이 UTF-8로 인코딩된 문자열이라고 가정합니다.
두 UTF-8 문자열 간의 3-그램 거리를 계산합니다.
반환 값이 작을수록 두 문자열은 더 유사합니다.
**구문**
```sql theme={null}
ngramDistanceUTF8(haystack, needle)
```
**인수**
* `haystack` — 첫 번째 UTF-8 인코딩 비교 문자열입니다. [`String`](/ko/reference/data-types/string)
* `needle` — 두 번째 UTF-8 인코딩 비교 문자열입니다. [`String`](/ko/reference/data-types/string)
**반환 값**
`0`과 `1` 사이의 `Float32` 값을 반환합니다. [`Float32`](/ko/reference/data-types/float)
**예시**
**UTF-8 3-그램 거리**
```sql title=Query theme={null}
SELECT ngramDistanceUTF8('abcde','cde')
```
```response title=Response theme={null}
┌─ngramDistanceUTF8('abcde','cde')─┐
│ 0.5 │
└───────────────────────────────────┘
```
## ngramSearch
도입 버전: v20.1.0
두 문자열 간의 4-그램 거리가 지정된 임계값 이하인지 확인합니다.
대소문자를 구분하지 않는 검색을 수행하거나 UTF8 포맷을 사용하는 경우 `ngramSearchCaseInsensitive`, `ngramSearchUTF8`, `ngramSearchCaseInsensitiveUTF8` 함수를 사용하십시오.
**구문**
```sql theme={null}
ngramSearch(haystack, needle)
```
**인수**
* `haystack` — 비교할 문자열입니다. [`String`](/ko/reference/data-types/string)
* `needle` — 비교할 문자열입니다. [`String`](/ko/reference/data-types/string)
**반환 값**
문자열 사이의 4-그램 거리가 임계값(기본값 `1.0`) 이하이면 `1`을 반환하고, 그렇지 않으면 `0`을 반환합니다. [`UInt8`](/ko/reference/data-types/int-uint)
**예시**
**4-그램을 사용한 검색**
```sql title=Query theme={null}
SELECT ngramSearch('ClickHouse', 'Click')
```
```response title=Response theme={null}
┌─ngramSearch('ClickHouse', 'Click')─┐
│ 1 │
└────────────────────────────────────┘
```
## ngramSearchCaseInsensitive
도입 버전: v20.1.0
[`ngramSearch`](#ngramSearch)의 대소문자를 구분하지 않는 변형을 제공합니다.
needle 문자열과 haystack 문자열 사이의 비대칭 차이를 계산합니다. 즉, needle의 n-그램 수에서 공통 n-그램 수를 뺀 뒤 이를 needle n-그램 수로 정규화한 값입니다.
대소문자를 무시하고 두 문자열 사이의 4-그램 거리가 지정된 임계값 이하인지 확인합니다.
**구문**
```sql theme={null}
ngramSearchCaseInsensitive(haystack, needle)
```
**인수**
* `haystack` — 비교 대상 문자열입니다. [`String`](/ko/reference/data-types/string)
* `needle` — 비교 대상 문자열입니다. [`String`](/ko/reference/data-types/string)
**반환 값**
문자열 간 4-그램 거리가 임계값(기본값은 `1.0`) 이하이면 `1`을, 그렇지 않으면 `0`을 반환합니다. [`UInt8`](/ko/reference/data-types/int-uint)
**예시**
**4-그램을 사용한 대소문자 비구분 검색**
```sql title=Query theme={null}
SELECT ngramSearchCaseInsensitive('Hello World','hello')
```
```response title=Response theme={null}
┌─ngramSearchCaseInsensitive('Hello World','hello')─┐
│ 1 │
└────────────────────────────────────────────────────┘
```
## ngramSearchCaseInsensitiveUTF8
도입 버전: v20.1.0
[`ngramSearch`](#ngramSearch)의 대소문자를 구분하지 않는 UTF-8 버전을 제공합니다.
`haystack`과 `needle`은 UTF-8 문자열이라고 가정하며, 대소문자를 구분하지 않습니다.
대소문자를 구분하지 않고 두 UTF-8 문자열 사이의 3-그램 거리가 지정된 임계값 이하인지 확인합니다.
**구문**
```sql theme={null}
ngramSearchCaseInsensitiveUTF8(haystack, needle)
```
**인수**
* `haystack` — 비교용 UTF-8 문자열입니다. [`String`](/ko/reference/data-types/string)
* `needle` — 비교용 UTF-8 문자열입니다. [`String`](/ko/reference/data-types/string)
**반환 값**
문자열 간 3-그램 거리가 임계값(기본값 `1.0`) 이하이면 `1`을, 그렇지 않으면 `0`을 반환합니다. [`UInt8`](/ko/reference/data-types/int-uint)
**예시**
**3-그램을 사용한 대소문자를 구분하지 않는 UTF-8 검색**
```sql title=Query theme={null}
SELECT ngramSearchCaseInsensitiveUTF8('абвГДЕёжз', 'АбвгдЕЁжз')
```
```response title=Response theme={null}
┌─ngramSearchCaseInsensitiveUTF8('абвГДЕёжз', 'АбвгдЕЁжз')─┐
│ 1 │
└──────────────────────────────────────────────────────────┘
```
## ngramSearchUTF8
도입 버전: v20.1.0
`ngramSearch`의 UTF-8 버전을 제공합니다.
`haystack`과 `needle`이 UTF-8 문자열이라고 가정합니다.
두 UTF-8 문자열 사이의 3-그램 거리가 지정된 임계값 이하인지 확인합니다.
**구문**
```sql theme={null}
ngramSearchUTF8(haystack, needle)
```
**인수**
* `haystack` — 비교할 UTF-8 문자열입니다. [`String`](/ko/reference/data-types/string)
* `needle` — 비교할 UTF-8 문자열입니다. [`String`](/ko/reference/data-types/string)
**반환 값**
문자열 간의 3-그램 거리가 임계값(기본값은 `1.0`)보다 작거나 같으면 `1`을 반환하고, 그렇지 않으면 `0`을 반환합니다. [`UInt8`](/ko/reference/data-types/int-uint)
**예시**
**3-그램을 사용한 UTF-8 검색**
```sql title=Query theme={null}
SELECT ngramSearchUTF8('абвгдеёжз', 'гдеёзд')
```
```response title=Response theme={null}
┌─ngramSearchUTF8('абвгдеёжз', 'гдеёзд')─┐
│ 1 │
└────────────────────────────────────────┘
```
## notILike
도입 버전: v20.6.0
문자열이 패턴과 일치하지 않는지 대소문자를 구분하지 않고 확인합니다. 패턴에는 SQL LIKE 매칭을 위한 특수 문자 `%` 및 `_`를 사용할 수 있습니다.
**구문**
```sql theme={null}
notILike(haystack, pattern)
```
**인수**
* `haystack` — 검색 대상 문자열입니다. [`String`](/ko/reference/data-types/string) 또는 [`FixedString`](/ko/reference/data-types/fixedstring)
* `pattern` — 매칭할 SQL LIKE 패턴입니다. `%`는 0개를 포함한 임의 개수의 문자와 일치하고, `_`는 정확히 1개의 문자와 일치합니다. [`String`](/ko/reference/data-types/string)
**반환 값**
문자열이 패턴과 일치하지 않으면(대소문자를 구분하지 않음) `1`을 반환하고, 그렇지 않으면 `0`을 반환합니다. [`UInt8`](/ko/reference/data-types/int-uint)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT notILike('ClickHouse', '%house%');
```
```response title=Response theme={null}
┌─notILike('Cl⋯ '%house%')─┐
│ 0 │
└──────────────────────────┘
```
## notLike
도입 버전: v1.1.0
[`like`](#like)와 유사하지만 결과를 반대로 반환합니다.
**구문**
```sql theme={null}
notLike(haystack, pattern)
-- haystack NOT LIKE pattern
```
**인수**
* `haystack` — 검색이 수행되는 문자열입니다. [`String`](/ko/reference/data-types/string) 또는 [`FixedString`](/ko/reference/data-types/fixedstring)
* `pattern` — 매칭할 LIKE 패턴입니다. [`String`](/ko/reference/data-types/string)
**반환 값**
문자열이 `LIKE` 패턴과 일치하지 않으면 `1`을, 그렇지 않으면 `0`을 반환합니다. [`UInt8`](/ko/reference/data-types/int-uint)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT notLike('ClickHouse', '%House%');
```
```response title=Response theme={null}
┌─notLike('Cli⋯ '%House%')─┐
│ 0 │
└──────────────────────────┘
```
**일치하지 않는 패턴**
```sql title=Query theme={null}
SELECT notLike('ClickHouse', '%SQL%');
```
```response title=Response theme={null}
┌─notLike('Cli⋯', '%SQL%')─┐
│ 1 │
└──────────────────────────┘
```
## position
도입 버전: v1.1.0
문자열 `haystack`에서 부분 문자열 `needle`이 시작되는 위치를 반환합니다(바이트 기준, 1부터 시작).
부분 문자열 `needle`이 비어 있으면 다음 규칙이 적용됩니다:
* `start_pos`가 지정되지 않은 경우: `1`을 반환합니다
* `start_pos = 0`인 경우: `1`을 반환합니다
* `start_pos >= 1`이고 `start_pos <= length(haystack) + 1`인 경우: `start_pos`를 반환합니다
* 그 밖의 경우: `0`을 반환합니다
같은 규칙이 [`locate`](#locate), [`positionCaseInsensitive`](#positionCaseInsensitive), [`positionUTF8`](#positionUTF8), [`positionCaseInsensitiveUTF8`](#positionCaseInsensitiveUTF8) 함수에도 적용됩니다.
**구문**
```sql theme={null}
position(haystack, needle[, start_pos])
```
**인수**
* `haystack` — 검색을 수행할 문자열입니다. [`String`](/ko/reference/data-types/string) 또는 [`Enum`](/ko/reference/data-types/enum)
* `needle` — 검색할 부분 문자열입니다. [`String`](/ko/reference/data-types/string)
* `start_pos` — `haystack`에서 검색을 시작할 위치(1부터 시작)입니다. 선택 사항입니다. [`UInt`](/ko/reference/data-types/int-uint)
**반환 값**
부분 문자열을 찾으면 1부터 세는 바이트 기준의 시작 위치를 반환하고, 찾지 못하면 `0`을 반환합니다. [`UInt64`](/ko/reference/data-types/int-uint)
**예시**
**기본 사용법**
```sql title=Query theme={null}
SELECT position('Hello, world!', '!')
```
```response title=Response theme={null}
┌─position('Hello, world!', '!')─┐
│ 13 │
└────────────────────────────────┘
```
**start\_pos 인수 사용 시**
```sql title=Query theme={null}
SELECT position('Hello, world!', 'o', 1), position('Hello, world!', 'o', 7)
```
```response title=Response theme={null}
┌─position('Hello, world!', 'o', 1)─┬─position('Hello, world!', 'o', 7)─┐
│ 5 │ 9 │
└───────────────────────────────────┴───────────────────────────────────┘
```
**needle IN haystack 구문**
```sql title=Query theme={null}
SELECT 6 = position('/' IN s) FROM (SELECT 'Hello/World' AS s)
```
```response title=Response theme={null}
┌─equals(6, position(s, '/'))─┐
│ 1 │
└─────────────────────────────┘
```
**빈 needle의 부분 문자열**
```sql title=Query theme={null}
SELECT position('abc', ''), position('abc', '', 0), position('abc', '', 1), position('abc', '', 2), position('abc', '', 3), position('abc', '', 4), position('abc', '', 5)
```
```response title=Response theme={null}
┌─position('abc', '')─┬─position('abc', '', 0)─┬─position('abc', '', 1)─┬─position('abc', '', 2)─┬─position('abc', '', 3)─┬─position('abc', '', 4)─┬─position('abc', '', 5)─┐
│ 1 │ 1 │ 1 │ 2 │ 3 │ 4 │ 0 │
└─────────────────────┴────────────────────────┴────────────────────────┴────────────────────────┴────────────────────────┴────────────────────────┴────────────────────────┘
```
## positionCaseInsensitive
도입된 버전: v1.1.0
[`position`](#position)과 같지만 대소문자를 구분하지 않습니다.
**구문**
```sql theme={null}
positionCaseInsensitive(haystack, needle[, start_pos])
```
**별칭**: `instr`
**인수**
* `haystack` — 검색이 수행되는 문자열입니다. [`String`](/ko/reference/data-types/string) 또는 [`Enum`](/ko/reference/data-types/enum)
* `needle` — 검색할 부분 문자열입니다. [`String`](/ko/reference/data-types/string)
* `start_pos` — 선택 사항입니다. `haystack`에서 검색을 시작할 위치(1부터 시작)입니다. [`UInt*`](/ko/reference/data-types/int-uint)
**반환 값**
부분 문자열을 찾으면 바이트 단위의 시작 위치를 1부터 계산해 반환하고, 찾지 못하면 `0`을 반환합니다. [`UInt64`](/ko/reference/data-types/int-uint)
**예시**
**대소문자를 구분하지 않는 검색**
```sql title=Query theme={null}
SELECT positionCaseInsensitive('Hello, world!', 'hello')
```
```response title=Response theme={null}
┌─positionCaseInsensitive('Hello, world!', 'hello')─┐
│ 1 │
└───────────────────────────────────────────────────┘
```
## positionCaseInsensitiveUTF8
도입 버전: v1.1.0
[`positionUTF8`](#positionUTF8)와 같지만 대소문자를 구분하지 않고 검색합니다.
**구문**
```sql theme={null}
positionCaseInsensitiveUTF8(haystack, needle[, start_pos])
```
**인수**
* `haystack` — 검색을 수행할 `String`입니다. [`String`](/ko/reference/data-types/string) 또는 [`Enum`](/ko/reference/data-types/enum)
* `needle` — 검색할 부분 문자열입니다. [`String`](/ko/reference/data-types/string)
* `start_pos` — 선택 사항입니다. 검색을 시작할 `haystack` 내 위치(1부터 시작)입니다. [`UInt*`](/ko/reference/data-types/int-uint)
**반환 값**
부분 문자열을 찾으면 1부터 세는 시작 바이트 위치를 반환하고, 찾지 못하면 `0`을 반환합니다. [`UInt64`](/ko/reference/data-types/int-uint)
**예시**
**대소문자를 구분하지 않는 UTF-8 검색**
```sql title=Query theme={null}
SELECT positionCaseInsensitiveUTF8('Привет мир', 'МИР')
```
```response title=Response theme={null}
┌─positionCaseInsensitiveUTF8('Привет мир', 'МИР')─┐
│ 8 │
└──────────────────────────────────────────────────┘
```
## positionUTF8
도입 버전: v1.1.0
[`position`](#position)과 유사하지만, `haystack`과 `needle`은 UTF-8로 인코딩된 문자열이라고 가정합니다.
**구문**
```sql theme={null}
positionUTF8(haystack, needle[, start_pos])
```
**인수**
* `haystack` — 검색이 수행되는 문자열입니다. [`String`](/ko/reference/data-types/string) 또는 [`Enum`](/ko/reference/data-types/enum)
* `needle` — 검색할 부분 문자열입니다. [`String`](/ko/reference/data-types/string)
* `start_pos` — 선택 사항입니다. 검색을 시작할 `haystack` 내 위치(1부터 시작)입니다. [`UInt*`](/ko/reference/data-types/int-uint)
**반환 값**
부분 문자열을 찾으면 바이트 단위의 시작 위치를 1부터 계산해 반환하고, 찾지 못하면 `0`을 반환합니다. [`UInt64`](/ko/reference/data-types/int-uint)
**예시**
**UTF-8 문자 수 계산**
```sql title=Query theme={null}
SELECT positionUTF8('Motörhead', 'r')
```
```response title=Response theme={null}
┌─position('Motörhead', 'r')─┐
│ 5 │
└────────────────────────────┘
```