문자열 함수
문자열 함수 (String Functions)
문자열 안에서 검색하는 함수와 문자열을 치환하는 함수는 별도 문서에서 다루어요.
출처: 문서
본문
참고: 아래 문서는
system.functions시스템 테이블에서 생성된 것이에요.
CRC32
도입: v20.1.0
CRC-32-IEEE 802.3 다항식과 초기값 0xffffffff(zlib 구현)를 사용해 문자열의 CRC32 체크섬을 계산해요.
구문 (Syntax)
CRC32(s)
인자 (Arguments)
s— CRC32를 계산할 문자열.String
반환 값 (Returned value)
문자열의 CRC32 체크섬. UInt32
예시 (Examples)
SELECT CRC32('ClickHouse')
┌─CRC32('ClickHouse')─┐
│ 1538217360 │
└─────────────────────┘
CRC32IEEE
도입: v20.1.0
CRC-32-IEEE 802.3 다항식을 사용해 문자열의 CRC32 체크섬을 계산해요.
구문 (Syntax)
CRC32IEEE(s)
인자 (Arguments)
s— CRC32를 계산할 문자열.String
반환 값 (Returned value)
문자열의 CRC32 체크섬. UInt32
예시 (Examples)
SELECT CRC32IEEE('ClickHouse');
┌─CRC32IEEE('ClickHouse')─┐
│ 3089448422 │
└─────────────────────────┘
CRC64
도입: v20.1.0
CRC-64-ECMA 다항식을 사용해 문자열의 CRC64 체크섬을 계산해요.
구문 (Syntax)
CRC64(s)
인자 (Arguments)
s— CRC64를 계산할 문자열.String
반환 값 (Returned value)
문자열의 CRC64 체크섬. UInt64
예시 (Examples)
SELECT CRC64('ClickHouse');
┌──CRC64('ClickHouse')─┐
│ 12126588151325169346 │
└──────────────────────┘
appendTrailingCharIfAbsent
도입: v1.1.0
c가 비어 있지 않고 c로 끝나지 않으면 문자열 s에 문자 c를 추가해요.
구문 (Syntax)
appendTrailingCharIfAbsent(s, c)
인자 (Arguments)
s— 입력 문자열.Stringc— 없을 때 추가할 문자.String
반환 값 (Returned value)
s가 c로 끝나지 않을 때 문자 c가 추가된 문자열 s. String
예시 (Examples)
SELECT appendTrailingCharIfAbsent('https://example.com', '/');
┌─appendTrailingCharIfAbsent('https://example.com', '/')─┐
│ https://example.com/ │
└────────────────────────────────────────────────────────┘
ascii
도입: v22.11.0
문자열 s의 첫 문자에 대한 ASCII 코드포인트를 Int32로 반환해요.
구문 (Syntax)
ascii(s)
인자 (Arguments)
s— 문자열 입력.String
반환 값 (Returned value)
첫 문자의 ASCII 코드포인트. s가 비어 있으면 결과는 0. 첫 문자가 ASCII 문자도 아니고 UTF-16의 Latin-1 보충 범위의 일부도 아니면 결과는 정의되지 않아요. Int32
예시 (Examples)
SELECT ascii('234')
┌─ascii('234')─┐
│ 50 │
└──────────────┘
base32Decode
도입: v25.6.0
Base32(RFC 4648) 문자열을 디코딩해요. 문자열이 유효한 Base32 인코딩이 아니면 예외를 던져요.
구문 (Syntax)
base32Decode(encoded)
인자 (Arguments)
encoded— 문자열 컬럼 또는 상수.String
반환 값 (Returned value)
인자의 디코딩된 값을 담은 문자열. String
예시 (Examples)
SELECT base32Decode('IVXGG33EMVSA====');
┌─base32Decode('IVXGG33EMVSA====')─┐
│ Encoded │
└──────────────────────────────────┘
base32Encode
도입: v25.6.0
Base32를 사용해 문자열을 인코딩해요.
구문 (Syntax)
base32Encode(plaintext)
인자 (Arguments)
plaintext— 인코딩할 평문.String
반환 값 (Returned value)
인자의 인코딩된 값을 담은 문자열. String 또는 FixedString
예시 (Examples)
SELECT base32Encode('Encoded')
┌─base32Encode('Encoded')─┐
│ IVXGG33EMVSA==== │
└─────────────────────────┘
base58Decode
도입: v22.7.0
Base58 문자열을 디코딩해요. 문자열이 유효한 Base58 인코딩이 아니면 예외를 던져요. 선택 사항 두 번째 인자 expected_size를 제공해 디코딩된 크기를 요구할 수 있어요: 정확히 그 바이트 수로 디코딩되지 않는 입력은 거부되고 함수가 예외를 던져요(tryBase58Decode에서는 빈 문자열 반환). 이 요구 사항은 모든 크기에 적용되며, 0은 요구 사항이 없음을 뜻해요.
구문 (Syntax)
base58Decode(encoded[, expected_size])
인자 (Arguments)
encoded— 디코딩할 문자열 컬럼 또는 상수.Stringexpected_size— 선택 사항. 요구되는 디코딩 크기(바이트): 다른 크기로 디코딩되는 입력은 거부돼요.0은 요구 없음.UInt8, UInt16, UInt32, or UInt64
반환 값 (Returned value)
인자의 디코딩된 값을 담은 문자열. String
예시 (Examples)
SELECT base58Decode('JxF12TrwUP45BMd');
┌─base58Decode('JxF12TrwUP45BMd')─┐
│ Hello World │
└─────────────────────────────────┘
base58Encode
도입: v22.7.0
Base58 인코딩을 사용해 문자열을 인코딩해요.
구문 (Syntax)
base58Encode(plaintext)
인자 (Arguments)
plaintext— 인코딩할 평문.String
반환 값 (Returned value)
인자의 인코딩된 값을 담은 문자열. String
예시 (Examples)
SELECT base58Encode('ClickHouse');
┌─base58Encode('ClickHouse')─┐
│ 4nhk8K7GHXf6zx │
└────────────────────────────┘
base64Decode
도입: v18.16.0
RFC 4648에 따라 Base64 표현에서 문자열을 디코딩해요. 26.7 버전부터 공백 문자(space, tab(\t), line feed(\n), carriage return(\r), form feed(\f))는 입력에서 무시돼요(이전 버전은 그런 입력을 거부). 세로 탭(\v)과 Base64 알파벳 밖의 다른 모든 문자는 거부돼요. 오류가 있으면 예외를 던져요.
구문 (Syntax)
base64Decode(encoded)
별칭 (Aliases): FROM_BASE64
인자 (Arguments)
encoded— 디코딩할 문자열 컬럼 또는 상수. 문자열이 유효한 Base64 인코딩이 아니면 예외가 발생해요.String
반환 값 (Returned value)
디코딩된 문자열. String
예시 (Examples)
SELECT base64Decode('Y2xpY2tob3VzZQ==')
┌─base64Decode('Y2xpY2tob3VzZQ==')─┐
│ clickhouse │
└──────────────────────────────────┘
base64Encode
도입: v18.16.0
RFC 4648에 따라 Base64 표현을 사용해 문자열을 인코딩해요.
구문 (Syntax)
base64Encode(plaintext)
별칭 (Aliases): TO_BASE64
인자 (Arguments)
plaintext— 인코딩할 평문 컬럼 또는 상수.String
반환 값 (Returned value)
인자의 인코딩된 값을 담은 문자열. String
예시 (Examples)
SELECT base64Encode('clickhouse')
┌─base64Encode('clickhouse')─┐
│ Y2xpY2tob3VzZQ== │
└────────────────────────────┘
base64URLDecode
도입: v24.6.0
RFC 4648에 따라 URL-안전 알파벳을 사용해 Base64 표현에서 문자열을 디코딩해요. 디코딩에서는 표준 알파벳(+와 /)도 허용돼요. 26.7 버전부터 공백 문자들(space, tab(\t), line feed(\n), carriage return(\r), form feed(\f))은 입력에서 무시돼요(이전 버전은 그런 입력을 거부). 세로 탭(\v)과 Base64 알파벳 밖의 다른 모든 문자는 거부돼요. 오류가 있으면 예외를 던져요.
구문 (Syntax)
base64URLDecode(encoded)
인자 (Arguments)
encoded— 인코딩할 문자열 컬럼 또는 상수. 문자열이 유효한 Base64 인코딩이 아니면 예외가 발생해요.String
반환 값 (Returned value)
인자의 디코딩된 값을 담은 문자열. String
예시 (Examples)
SELECT base64URLDecode('aHR0cHM6Ly9jbGlja2hvdXNlLmNvbQ')
┌─base64URLDecode('aHR0cHM6Ly9jbGlja2hvdXNlLmNvbQ')─┐
│ https://clickhouse.com │
└───────────────────────────────────────────────────┘
base64URLEncode
도입: v18.16.0
URL-안전 알파벳을 사용해 Base64(RFC 4648) 표현으로 문자열을 인코딩해요.
구문 (Syntax)
base64URLEncode(plaintext)
인자 (Arguments)
plaintext— 인코딩할 평문 컬럼 또는 상수.String
반환 값 (Returned value)
인자의 인코딩된 값을 담은 문자열. String
예시 (Examples)
SELECT base64URLEncode('https://clickhouse.com')
┌─base64URLEncode('https://clickhouse.com')─┐
│ aHR0cHM6Ly9jbGlja2hvdXNlLmNvbQ │
└───────────────────────────────────────────┘
basename
도입: v20.1.0
문자열의 마지막 슬래시나 백슬래시 뒤의 꼬리(tail) 부분을 추출해요. 이 함수는 경로에서 파일명을 추출할 때 자주 쓰여요.
구문 (Syntax)
basename(expr)
인자 (Arguments)
expr— 문자열 표현식. 백슬래시는 이스케이프되어야 해요.String
반환 값 (Returned value)
마지막 슬래시나 백슬래시 뒤의 입력 문자열 꼬리. 입력 문자열이 슬래시나 백슬래시로 끝나면 빈 문자열을 반환해요. 슬래시나 백슬래시가 없으면 원래 문자열을 반환해요. String
예시 (Examples)
Unix 경로에서 파일명 추출
SELECT 'some/long/path/to/file' AS a, basename(a)
┌─a──────────────────────┬─basename(a)─┐
│ some/long/path/to/file │ file │
└────────────────────────┴─────────────┘
Windows 경로에서 파일명 추출
SELECT 'some\\long\\path\\to\\file' AS a, basename(a)
┌─a──────────────────────┬─basename(a)─┐
│ some\long\path\to\file │ file │
└────────────────────────┴─────────────┘
경로 구분자가 없는 문자열
SELECT 'some-file-name' AS a, basename(a)
┌─a──────────────┬─basename(a)────┐
│ some-file-name │ some-file-name │
└────────────────┴────────────────┘
byteHammingDistance
도입: v23.9.0
두 바이트 문자열 사이의 해밍 거리(Hamming distance)를 계산해요.
구문 (Syntax)
byteHammingDistance(s1, s2)
별칭 (Aliases): mismatches
인자 (Arguments)
s1— 첫 번째 입력 문자열.Strings2— 두 번째 입력 문자열.String
반환 값 (Returned value)
두 문자열 사이의 해밍 거리. UInt64
예시 (Examples)
SELECT byteHammingDistance('karolin', 'kathrin')
┌─byteHammingDistance('karolin', 'kathrin')─┐
│ 3 │
└───────────────────────────────────────────┘
caseFoldUTF8
도입: v26.3.0
UTF-8 문자열에 유니코드 케이스 폴딩을 적용해 대소문자 구분 없는 비교에 적합한 소문자형 정규화 형태로 변환해요.
표준 유니코드 케이스 폴딩을 적용해요. 케이스 폴딩 영향을 받지 않는 호환 문자(예: 로마 숫자, 동그라미 숫자)는 보존하지만, ffi 같은 일부 리가처는 유니코드 케이스 폴딩 자체가 그것을 확장하기 때문에 여전히 분해된다는 점을 주의하세요.
구문 (Syntax)
caseFoldUTF8(str)
인자 (Arguments)
str— UTF-8 인코딩 입력 문자열.String
반환 값 (Returned value)
케이스 폴딩된 UTF-8 문자열. String
예시 (Examples)
기본 케이스 폴딩
SELECT caseFoldUTF8('Straße')
┌─caseFoldUTF8('Straße')─┐
│ strasse │
└────────────────────────┘
compareSubstrings
도입: v25.2.0
두 문자열을 사전식으로 비교해요.
구문 (Syntax)
compareSubstrings(s1, s2, s1_offset, s2_offset, num_bytes)
인자 (Arguments)
s1— 비교할 첫 번째 문자열.Strings2— 비교할 두 번째 문자열.Strings1_offset—s1에서 비교가 시작되는 위치(0부터 시작).UInt*s2_offset—s2에서 비교가 시작되는 위치(0부터 시작).UInt*num_bytes— 두 문자열 모두에서 비교할 최대 바이트 수.s1_offset(또는s2_offset) +num_bytes가 입력 문자열의 끝을 넘으면num_bytes가 그에 맞게 줄어들어요.UInt*
반환 값 (Returned value)
다음을 반환해요:
s1[s1_offset:s1_offset+num_bytes] <s2[s2_offset:s2_offset+num_bytes]면-1.s1[s1_offset:s1_offset+num_bytes] =s2[s2_offset:s2_offset+num_bytes]면0.s1[s1_offset:s1_offset+num_bytes] >s2[s2_offset:s2_offset+num_bytes]면1.Int8
예시 (Examples)
SELECT compareSubstrings('Saxony', 'Anglo-Saxon', 0, 6, 5) AS result
┌─result─┐
│ 0 │
└────────┘
concat
도입: v1.1.0
주어진 인자들을 연결해요.
String 또는 FixedString 타입이 아닌 인자는 기본 직렬화를 사용해 문자열로 변환돼요. 이는 성능을 떨어뜨리므로 String/FixedString이 아닌 인자는 사용하지 않는 것이 좋아요.
구문 (Syntax)
concat([s1, s2, ...])
인자 (Arguments)
s1, s2, ...— 임의 타입의 값. 개수 제한 없음.Any
반환 값 (Returned value)
인자들을 연결해 만든 String. 인자 중 하나라도 NULL이면 NULL을 반환해요. 인자가 없으면 빈 문자열을 반환해요. Nullable(String)
예시 (Examples)
문자열 연결
SELECT concat('Hello, ', 'World!')
┌─concat('Hello, ', 'World!')─┐
│ Hello, World! │
└─────────────────────────────┘
숫자 연결
SELECT concat(42, 144)
┌─concat(42, 144)─┐
│ 42144 │
└─────────────────┘
concatAssumeInjective
도입: v1.1.0
concat와 같지만 concat(s1, s2, ...) → sn이 단사(injective)라고 가정해요. 즉 서로 다른 인자에 대해 서로 다른 결과를 반환한다고 가정해요.
GROUP BY 최적화에 사용할 수 있어요.
구문 (Syntax)
concatAssumeInjective([s1, s2, ...])
인자 (Arguments)
s1, s2, ...— 임의 타입의 값. 개수 제한 없음.String또는FixedString
반환 값 (Returned value)
인자들을 연결해 만든 문자열. 인자 값 중 하나라도 NULL이면 NULL을 반환해요. 인자가 전달되지 않으면 빈 문자열을 반환해요. String
예시 (Examples)
GROUP BY 최적화
CREATE TABLE key_val (key1 String, key2 String, value UInt32) ENGINE = Memory;
INSERT INTO key_val VALUES ('Hello, ', 'World!', 1), ('Hello, ', 'World!', 2), ('Hello, ', 'World', 3);
SELECT concatAssumeInjective(key1, key2) AS key, sum(value) FROM key_val GROUP BY key ORDER BY key;
┌─key───────────┬─sum(value)─┐
│ Hello, World │ 3 │
│ Hello, World! │ 3 │
└───────────────┴────────────┘
concatWithSeparator
도입: v22.12.0
제공된 문자열들을 지정된 구분자로 구분해 연결해요.
구문 (Syntax)
concatWithSeparator(sep[, exp1, exp2, ...])
별칭 (Aliases): concat_ws
인자 (Arguments)
sep— 사용할 구분자.const String또는const FixedStringexp1, exp2, ...— 연결할 표현식.String또는FixedString타입이 아닌 인자는 기본 직렬화를 사용해 문자열로 변환돼요. 이는 성능을 떨어뜨리므로 String/FixedString이 아닌 인자는 사용하지 않는 것이 좋아요.Any
반환 값 (Returned value)
인자들을 연결해 만든 String. 인자 값 중 하나라도 NULL이면 NULL을 반환해요. String
예시 (Examples)
SELECT concatWithSeparator('a', '1', '2', '3', '4')
┌─concatWithSeparator('a', '1', '2', '3', '4')─┐
│ 1a2a3a4 │
└──────────────────────────────────────────────┘
concatWithSeparatorAssumeInjective
도입: v22.12.0
concatWithSeparator와 같지만 concatWithSeparator(sep[,exp1, exp2, ...]) → result가 단사라고 가정해요. 서로 다른 인자에 대해 서로 다른 결과를 반환하면 함수를 단사라고 불러요.
GROUP BY 최적화에 사용할 수 있어요.
구문 (Syntax)
concatWithSeparatorAssumeInjective(sep[, exp1, exp2, ...])
인자 (Arguments)
sep— 사용할 구분자.const String또는const FixedStringexp1, exp2, ...— 연결할 표현식.String또는FixedString타입이 아닌 인자는 기본 직렬화를 사용해 문자열로 변환돼요.String또는FixedString
반환 값 (Returned value)
인자들을 연결해 만든 String. 인자 값 중 하나라도 NULL이면 NULL을 반환해요. String
예시 (Examples)
CREATE TABLE user_data (
user_id UInt32,
first_name String,
last_name String,
score UInt32
)
ENGINE = MergeTree
ORDER BY tuple();
INSERT INTO user_data VALUES
(1, 'John', 'Doe', 100),
(2, 'Jane', 'Smith', 150),
(3, 'John', 'Wilson', 120),
(4, 'Jane', 'Smith', 90);
SELECT
concatWithSeparatorAssumeInjective('-', first_name, last_name) as full_name,
sum(score) as total_score
FROM user_data
GROUP BY concatWithSeparatorAssumeInjective('-', first_name, last_name);
┌─full_name───┬─total_score─┐
│ Jane-Smith │ 240 │
│ John-Doe │ 100 │
│ John-Wilson │ 120 │
└─────────────┴─────────────┘
conv
도입: v25.10.0
숫자를 서로 다른 진법으로 변환해요.
이 함수는 숫자를 한 진법에서 다른 진법으로 변환해요. 2부터 36까지의 진법을 지원해요. 10보다 큰 진법에는 문자 A-Z(대소문자 구분 없음)를 사용해 숫자 10-35를 나타내요.
이 함수는 MySQL의 CONV() 함수와 호환돼요.
구문 (Syntax)
conv(number, from_base, to_base)
인자 (Arguments)
number— 변환할 숫자. 문자열 또는 숫자 타입 가능. -from_base— 원본 진법(2-36). 정수여야 해요. -to_base— 대상 진법(2-36). 정수여야 해요.
반환 값 (Returned value)
대상 진법에서의 숫자 문자열 표현.
예시 (Examples)
십진수를 이진수로 변환
SELECT conv('10', 10, 2)
1010
십육진수를 십진수로 변환
SELECT conv('FF', 16, 10)
255
음수와 함께 변환
SELECT conv('-1', 10, 16)
FFFFFFFFFFFFFFFF
이진수를 팔진수로 변환
SELECT conv('1010', 2, 8)
12
convertCharset
도입: v1.1.0
인코딩 from에서 인코딩 to로 변환된 문자열 s를 반환해요.
구문 (Syntax)
convertCharset(s, from, to)
인자 (Arguments)
s— 입력 문자열.Stringfrom— 원본 문자 인코딩.Stringto— 대상 문자 인코딩.String
반환 값 (Returned value)
인코딩 from에서 인코딩 to로 변환된 문자열 s. String
예시 (Examples)
SELECT convertCharset('Café', 'UTF-8', 'ISO-8859-1');
┌─convertCharset('Café', 'UTF-8', 'ISO-8859-1')─┐
│ Caf� │
└───────────────────────────────────────────────┘
damerauLevenshteinDistance
도입: v24.1.0
두 바이트 문자열 사이의 다메라우-레벤슈타인 거리(Damerau-Levenshtein distance)를 계산해요.
구문 (Syntax)
damerauLevenshteinDistance(s1, s2)
인자 (Arguments)
s1— 첫 번째 입력 문자열.Strings2— 두 번째 입력 문자열.String
반환 값 (Returned value)
두 문자열 사이의 다메라우-레벤슈타인 거리. UInt64
예시 (Examples)
SELECT damerauLevenshteinDistance('clickhouse', 'mouse')
┌─damerauLevenshteinDistance('clickhouse', 'mouse')─┐
│ 6 │
└───────────────────────────────────────────────────┘
decodeHTMLComponent
도입: v23.9.0
문자열의 HTML 엔티티를 해당 문자로 디코딩해요.
구문 (Syntax)
decodeHTMLComponent(s)
인자 (Arguments)
s— 디코딩할 HTML 엔티티를 담은 문자열.String
반환 값 (Returned value)
HTML 엔티티가 디코딩된 문자열. String
예시 (Examples)
SELECT decodeHTMLComponent('<div>Hello & "World"</div>')
┌─decodeHTMLComponent('<div>Hello & "World"</div>')─┐
│ <div>Hello & "World"</div> │
└─────────────────────────────────────────────────────────────────────────────┘
decodeXMLComponent
도입: v21.2.0
문자열의 XML 엔티티를 해당 문자로 디코딩해요.
구문 (Syntax)
decodeXMLComponent(s)
인자 (Arguments)
s— 디코딩할 XML 엔티티를 담은 문자열.String
반환 값 (Returned value)
XML 엔티티가 디코딩된 문자열. String
예시 (Examples)
SELECT decodeXMLComponent('<tag>Hello & World</tag>')
┌─decodeXMLComponent('<tag>Hello & World</tag>')─┐
│ <tag>Hello & World</tag> │
└────────────────────────────────────────────────────────────────┘
editDistance
도입: v23.9.0
두 바이트 문자열 사이의 편집 거리(edit distance)를 계산해요.
구문 (Syntax)
editDistance(s1, s2)
별칭 (Aliases): levenshteinDistance
인자 (Arguments)
s1— 첫 번째 입력 문자열.Strings2— 두 번째 입력 문자열.String
반환 값 (Returned value)
두 문자열 사이의 편집 거리. UInt64
예시 (Examples)
SELECT editDistance('clickhouse', 'mouse')
┌─editDistance('clickhouse', 'mouse')─┐
│ 6 │
└─────────────────────────────────────┘
editDistanceUTF8
도입: v24.6.0
두 UTF8 문자열 사이의 편집 거리를 계산해요.
구문 (Syntax)
editDistanceUTF8(s1, s2)
별칭 (Aliases): levenshteinDistanceUTF8
인자 (Arguments)
s1— 첫 번째 입력 문자열.Strings2— 두 번째 입력 문자열.String
반환 값 (Returned value)
두 UTF8 문자열 사이의 편집 거리. UInt64
예시 (Examples)
SELECT editDistanceUTF8('我是谁', '我是我') AS distance
┌─distance─┐
│ 1 │
└──────────┘
encodeXMLComponent
도입: v21.1.0
문자열을 XML 텍스트 노드나 속성에 넣기 위해 문자들을 이스케이프해요.
구문 (Syntax)
encodeXMLComponent(s)
인자 (Arguments)
s— 이스케이프할 문자열.String
반환 값 (Returned value)
이스케이프된 문자열. String
예시 (Examples)
SELECT
'<tag>Hello & "World"</tag>' AS original,
encodeXMLComponent('<tag>Hello & "World"</tag>') AS xml_encoded;
┌─original───────────────────┬─xml_encoded──────────────────────────────┐
│ <tag>Hello & "World"</tag> │ <tag>Hello & "World"</tag> │
└────────────────────────────┴──────────────────────────────────────────┘
endsWith
도입: v1.1.0
문자열이 제공된 접미사로 끝나는지 확인해요.
구문 (Syntax)
endsWith(s, suffix)
인자 (Arguments)
s— 확인할 문자열.Stringsuffix— 확인할 접미사.String
반환 값 (Returned value)
s가 suffix로 끝나면 1, 아니면 0. UInt8
예시 (Examples)
SELECT endsWith('ClickHouse', 'House');
┌─endsWith('ClickHouse', 'House')─┐
│ 1 │
└─────────────────────────────────┘
endsWithCaseInsensitive
도입: v25.10.0
문자열이 제공된 대소문자 구분 없는 접미사로 끝나는지 확인해요.
구문 (Syntax)
endsWithCaseInsensitive(s, suffix)
인자 (Arguments)
s— 확인할 문자열.Stringsuffix— 확인할 대소문자 구분 없는 접미사.String
반환 값 (Returned value)
s가 대소문자 구분 없는 suffix로 끝나면 1, 아니면 0. UInt8
예시 (Examples)
SELECT endsWithCaseInsensitive('ClickHouse', 'HOUSE');
┌─endsWithCaseInsensitive('ClickHouse', 'HOUSE')─┐
│ 1 │
└────────────────────────────────────────────────┘
endsWithCaseInsensitiveUTF8
도입: v25.10.0
문자열 s가 대소문자 구분 없는 suffix로 끝나는지 여부를 반환해요. 문자열이 유효한 UTF-8 인코딩 텍스트라고 가정해요. 이 가정이 어긋나면 예외를 던지지 않고 결과는 정의되지 않아요.
구문 (Syntax)
endsWithCaseInsensitiveUTF8(s, suffix)
인자 (Arguments)
s— 확인할 문자열.Stringsuffix— 확인할 대소문자 구분 없는 접미사.String
반환 값 (Returned value)
s가 대소문자 구분 없는 suffix로 끝나면 1, 아니면 0. UInt8
예시 (Examples)
SELECT endsWithCaseInsensitiveUTF8('данных', 'ых');
┌─endsWithCaseInsensitiveUTF8('данных', 'ых')─┐
│ 1 │
└─────────────────────────────────────────────┘
endsWithUTF8
도입: v23.8.0
문자열 s가 suffix로 끝나는지 여부를 반환해요. 문자열이 유효한 UTF-8 인코딩 텍스트라고 가정해요. 이 가정이 어긋나면 예외를 던지지 않고 결과는 정의되지 않아요.
구문 (Syntax)
endsWithUTF8(s, suffix)
인자 (Arguments)
s— 확인할 문자열.Stringsuffix— 확인할 접미사.String
반환 값 (Returned value)
s가 suffix로 끝나면 1, 아니면 0. UInt8
예시 (Examples)
SELECT endsWithUTF8('данных', 'ых');
┌─endsWithUTF8('данных', 'ых')─┐
│ 1 │
└──────────────────────────────┘
extractTextFromHTML
도입: v21.3.0
HTML 또는 XHTML에서 텍스트 내용을 추출해요.
이 함수는 HTML 태그, 주석, script/style 요소를 제거하고 텍스트 내용만 남겨요. 처리 내용:
- 모든 HTML/XML 태그 제거
- 주석(
{/* */}) 제거 - 내용을 포함한 script 및 style 요소 제거
- CDATA 섹션 처리(있는 그대로 복사)
- 적절한 공백 처리와 정규화
참고: HTML 엔티티는 디코딩되지 않으며, 필요하면 별도 함수로 처리해야 해요.
구문 (Syntax)
extractTextFromHTML(html)
인자 (Arguments)
html— 텍스트를 추출할 HTML 내용을 담은 문자열.String
반환 값 (Returned value)
공백이 정규화된 추출된 텍스트 내용. String
예시 (Examples)
SELECT extractTextFromHTML('
<html>
<head><title>Page Title</title></head>
<body>
<p>Hello <b>World</b>!</p>
<script>alert("test");</script>
<!-- comment -->
</body>
</html>
');
┌─extractTextFromHTML('...')─┐
│ Page Title Hello World ! │
└────────────────────────────┘
firstLine
도입: v23.7.0
여러 줄 문자열의 첫 번째 줄을 반환해요.
구문 (Syntax)
firstLine(s)
인자 (Arguments)
s— 입력 문자열.String
반환 값 (Returned value)
입력 문자열의 첫 번째 줄 또는 줄 구분자가 없으면 전체 문자열. String
예시 (Examples)
SELECT firstLine('foo\nbar\nbaz')
┌─firstLine('foo\nbar\nbaz')─┐
│ foo │
└────────────────────────────┘
idnaDecode
도입: v24.1.0
IDNA(Internationalized Domain Names in Applications) 메커니즘에 따라 도메인 이름의 유니코드(UTF-8) 표현(ToUnicode 알고리즘)을 반환해요. 오류가 있으면(예: 입력이 잘못된 경우) 입력 문자열을 반환해요. 케이스 정규화 때문에 idnaEncode와 idnaDecode를 반복 적용해도 반드시 원래 문자열을 반환하지는 않는 점을 주의하세요.
구문 (Syntax)
idnaDecode(s)
인자 (Arguments)
s— 입력 문자열.String
반환 값 (Returned value)
입력 값의 IDNA 메커니즘에 따른 입력 문자열의 유니코드(UTF-8) 표현. String
예시 (Examples)
SELECT idnaDecode('xn--strae-oqa.xn--mnchen-3ya.de')
┌─idnaDecode('xn--strae-oqa.xn--mnchen-3ya.de')─┐
│ straße.münchen.de │
└───────────────────────────────────────────────┘
idnaEncode
도입: v24.1.0
IDNA 메커니즘에 따라 도메인 이름의 ASCII 표현(ToASCII 알고리즘)을 반환해요. 입력 문자열은 UTF-인코딩되어 있고 ASCII 문자열로 변환 가능해야 하며, 그렇지 않으면 예외가 발생해요.
참고: 퍼센트 디코딩이나 탭·공백·제어 문자의 트리밍은 수행되지 않아요.
구문 (Syntax)
idnaEncode(s)
인자 (Arguments)
s— 입력 문자열.String
반환 값 (Returned value)
입력 값의 IDNA 메커니즘에 따른 입력 문자열의 ASCII 표현. String
예시 (Examples)
SELECT idnaEncode('straße.münchen.de')
┌─idnaEncode('straße.münchen.de')─┐
│ xn--strae-oqa.xn--mnchen-3ya.de │
└─────────────────────────────────┘
initcap
도입: v23.7.0
각 단어의 첫 글자를 대문자로, 나머지를 소문자로 변환해요. 단어는 비알파뉴메릭 문자로 구분된 알파뉴메릭 문자들로 이뤄진 시퀀스예요.
참고:
initcap은 각 단어의 첫 글자만 대문자로 변환하므로, 아포스트로피나 대문자를 포함하는 단어에서 의외의 동작이 발생할 수 있어요. 이는 알려진 동작이며 현재 수정 계획은 없어요.
구문 (Syntax)
initcap(s)
인자 (Arguments)
s— 입력 문자열.String
반환 값 (Returned value)
각 단어의 첫 글자가 대문자로 변환된 s. String
예시 (Examples)
SELECT initcap('building for fast')
┌─initcap('building for fast')─┐
│ Building For Fast │
└──────────────────────────────┘
아포스트로피나 대문자를 포함하는 단어의 알려진 동작 예시
SELECT initcap('John''s cat won''t eat.');
┌─initcap('John\'s cat won\'t eat.')─┐
│ John'S Cat Won'T Eat. │
└────────────────────────────────────┘
initcapUTF8
도입: v23.7.0
initcap과 마찬가지로 각 단어의 첫 글자를 대문자로, 나머지를 소문자로 변환해요. 문자열이 유효한 UTF-8 인코딩 텍스트라고 가정해요. 이 가정이 어긋나면 예외를 던지지 않고 결과는 정의되지 않아요.
참고: 이 함수는 언어를 감지하지 않아요. 예를 들어 터키어에서는 결과가 정확하지 않을 수 있어요(i/İ 대 i/I). 코드포인트의 대문자와 소문자의 UTF-8 바이트 시퀀스 길이가 다르면 해당 코드포인트에 대해 결과가 틀릴 수 있어요.
구문 (Syntax)
initcapUTF8(s)
인자 (Arguments)
s— 입력 문자열.String
반환 값 (Returned value)
각 단어의 첫 글자가 대문자로 변환된 s. String
예시 (Examples)
SELECT initcapUTF8('не тормозит')
┌─initcapUTF8('не тормозит')─┐
│ Не Тормозит │
└────────────────────────────┘
isValidASCII
도입: v25.9.0
입력 String 또는 FixedString이 ASCII 바이트(0x00–0x7F)만 담고 있으면 1, 아니면 0을 반환해요. 양수 케이스(입력이 유효한 ASCII)에 최적화되어 있어요.
구문 (Syntax)
isValidASCII(str)
별칭 (Aliases): isASCII
인자 (Arguments)
- 없음.
반환 값 (Returned value)
예시 (Examples)
SELECT isValidASCII('hello') AS is_ascii, isValidASCII('你好') AS is_not_ascii
┌─is_ascii─┬─is_not_ascii─┐
│ 1 │ 0 │
└──────────┴──────────────┘
isValidUTF8
도입: v20.1.0
바이트 집합이 유효한 UTF-8 인코딩 텍스트를 이루는지 확인해요.
구문 (Syntax)
isValidUTF8(s)
인자 (Arguments)
s— UTF-8 인코딩 유효성을 확인할 문자열.String
반환 값 (Returned value)
바이트 집합이 유효한 UTF-8 인코딩 텍스트를 이루면 1, 아니면 0. UInt8
예시 (Examples)
SELECT isValidUTF8('\xc3\xb1') AS valid, isValidUTF8('\xc3\x28') AS invalid
┌─valid─┬─invalid─┐
│ 1 │ 1 │
└───────┴─────────┘
jaroSimilarity
도입: v24.1.0
두 바이트 문자열 사이의 자로 유사도(Jaro similarity)를 계산해요.
구문 (Syntax)
jaroSimilarity(s1, s2)
인자 (Arguments)
s1— 첫 번째 입력 문자열.Strings2— 두 번째 입력 문자열.String
반환 값 (Returned value)
두 문자열 사이의 자로 유사도. Float64
예시 (Examples)
SELECT jaroSimilarity('clickhouse', 'click')
┌─jaroSimilarity('clickhouse', 'click')─┐
│ 0.8333333333333333 │
└───────────────────────────────────────┘
jaroWinklerSimilarity
도입: v24.1.0
두 바이트 문자열 사이의 자로-윙클러 유사도(Jaro-Winkler similarity)를 계산해요.
구문 (Syntax)
jaroWinklerSimilarity(s1, s2)
인자 (Arguments)
s1— 첫 번째 입력 문자열.Strings2— 두 번째 입력 문자열.String
반환 값 (Returned value)
두 문자열 사이의 자로-윙클러 유사도. Float64
예시 (Examples)
SELECT jaroWinklerSimilarity('clickhouse', 'click')
┌─jaroWinklerSimilarity('clickhouse', 'click')─┐
│ 0.8999999999999999 │
└──────────────────────────────────────────────┘
left
도입: v22.1.0
왼쪽에서부터 시작하는 지정된 offset만큼의 문자열 s의 부분 문자열을 반환해요.
구문 (Syntax)
left(s, offset)
인자 (Arguments)
s— 부분 문자열을 계산할 문자열.String또는FixedStringoffset— 오프셋의 바이트 수.(U)Int*
반환 값 (Returned value)
다음을 반환해요:
- 양수
offset이면, 문자열의 왼쪽에서 시작하는offset바이트만큼의s부분 문자열. - 음수
offset이면, 문자열의 왼쪽에서 시작하는length(s) - |offset|바이트만큼의s부분 문자열. length가0이면 빈 문자열.String
예시 (Examples)
양수 오프셋
SELECT left('Hello World', 5)
Hello
음수 오프셋
SELECT left('Hello World', -6)
Hello
leftPad
도입: v21.8.0
결과 문자열이 지정된 length에 도달할 때까지 왼쪽에 공백 또는 지정된 문자열로(필요하면 여러 번) 채워요.
구문 (Syntax)
leftPad(string, length[, pad_string])
별칭 (Aliases): lpad
인자 (Arguments)
string— 패딩할 입력 문자열.Stringlength— 결과 문자열의 길이. 값이 입력 문자열 길이보다 작으면 입력 문자열이length문자로 줄어들어요.(U)Int*pad_string— 선택 사항. 입력 문자열을 채울 문자열. 지정하지 않으면 공백으로 채워요.String
반환 값 (Returned value)
주어진 길이의 왼쪽 패딩된 문자열. String
예시 (Examples)
SELECT leftPad('abc', 7, '*'), leftPad('def', 7)
┌─leftPad('abc', 7, '*')─┬─leftPad('def', 7)─┐
│ ****abc │ def │
└────────────────────────┴───────────────────┘
leftPadUTF8
도입: v21.8.0
결과 문자열이 주어진 길이에 도달할 때까지 UTF8 문자열을 왼쪽에 공백 또는 지정된 문자열로(필요하면 여러 번) 채워요. 문자열 길이를 바이트로 재는 leftPad와 달리, 문자열 길이는 코드포인트 단위로 재요.
구문 (Syntax)
leftPadUTF8(string, length[, pad_string])
인자 (Arguments)
string— 패딩할 입력 문자열.Stringlength— 결과 문자열의 길이. 값이 입력 문자열 길이보다 작으면 입력 문자열이length문자로 줄어들어요.(U)Int*pad_string— 선택 사항. 입력 문자열을 채울 문자열. 지정하지 않으면 공백으로 채워요.String
반환 값 (Returned value)
주어진 길이의 왼쪽 패딩된 문자열. String
예시 (Examples)
SELECT leftPadUTF8('абвг', 7, '*'), leftPadUTF8('дежз', 7)
┌─leftPadUTF8('абвг', 7, '*')─┬─leftPadUTF8('дежз', 7)─┐
│ ***абвг │ дежз │
└─────────────────────────────┴────────────────────────┘
leftUTF8
도입: v22.1.0
왼쪽에서부터 시작하는 지정된 offset만큼의 UTF-8 인코딩 문자열 s의 부분 문자열을 반환해요.
구문 (Syntax)
leftUTF8(s, offset)
인자 (Arguments)
s— 부분 문자열을 계산할 UTF-8 인코딩 문자열.String또는FixedStringoffset— 오프셋의 바이트 수.(U)Int*
반환 값 (Returned value)
다음을 반환해요:
- 양수
offset이면, 문자열 왼쪽에서 시작하는offset바이트만큼의s부분 문자열. - 음수
offset이면, 문자열 왼쪽에서 시작하는length(s) - |offset|바이트만큼의s부분 문자열. length가 0이면 빈 문자열.String
예시 (Examples)
양수 오프셋
SELECT leftUTF8('Привет', 4)
Прив
음수 오프셋
SELECT leftUTF8('Привет', -4)
Пр
lengthUTF8
도입: v1.1.0
문자열의 길이를 바이트나 문자 단위가 아닌 유니코드 코드포인트 수로 반환해요. 문자열의 길이를 바이트 단위로 계산하려면 length 함수를 사용하세요. 문자열이 유효한 UTF-8 인코딩 텍스트라고 가정해요. 이 가정이 어긋나면 예외를 던지지 않고 결과는 정의되지 않아요.
구문 (Syntax)
lengthUTF8(s)
별칭 (Aliases): CHARACTER_LENGTH, CHAR_LENGTH
인자 (Arguments)
s— 유효한 UTF-8 인코딩 텍스트를 담은 문자열.String
반환 값 (Returned value)
유니코드 코드포인트 수로 나타낸 문자열 s의 길이. UInt64
예시 (Examples)
SELECT lengthUTF8('Здравствуй, мир!')
┌─lengthUTF8('Здравствуй, мир!')─┐
│ 16 │
└────────────────────────────────┘
lower
도입: v1.1.0
ASCII 문자열을 소문자로 변환해요.
구문 (Syntax)
lower(s)
별칭 (Aliases): lcase
인자 (Arguments)
s— 소문자로 변환할 문자열.String
반환 값 (Returned value)
s에서 만든 소문자 문자열. String
예시 (Examples)
SELECT lower('CLICKHOUSE')
┌─lower('CLICKHOUSE')─┐
│ clickhouse │
└─────────────────────┘
lowerUTF8
도입: v1.1.0
문자열이 유효한 UTF-8 인코딩 텍스트라고 가정하고 문자열을 소문자로 변환해요. 이 가정이 어긋나면 예외를 던지지 않고 결과는 정의되지 않아요.
구문 (Syntax)
lowerUTF8(input)
인자 (Arguments)
input— 소문자로 변환할 입력 문자열.String
반환 값 (Returned value)
소문자 문자열. String
예시 (Examples)
SELECT lowerUTF8('München') as Lowerutf8;
münchen
naturalSortKey
도입: v26.3.0
자연어 정렬(natural sorting)에 사용되는 함수예요.
구문 (Syntax)
naturalSortKey(s)
별칭 (Aliases): NATURAL_SORT_KEY
인자 (Arguments)
s— 자연어 정렬 키로 변환할 문자열.String
반환 값 (Returned value)
s에서 만든 자연어 정렬 키 문자열. String
예시 (Examples)
CREATE TABLE t (s String) ENGINE = Memory;
INSERT INTO t VALUES ('a1'), ('a02');
SELECT s FROM t ORDER BY naturalSortKey(s);
┌─s───┐
│ a1 │
│ a02 │
└─────┘
normalizeUTF8NFC
도입: v21.11.0
NFC 정규화 형식에 따라 UTF-8 문자열을 정규화해요.
구문 (Syntax)
normalizeUTF8NFC(str)
인자 (Arguments)
str— UTF-8 인코딩 입력 문자열.String
반환 값 (Returned value)
UTF-8 문자열의 NFC 정규화 형식. String
예시 (Examples)
SELECT
'é' AS original, -- e + combining acute accent (U+0065 + U+0301)
length(original),
normalizeUTF8NFC('é') AS nfc_normalized, -- é (U+00E9)
length(nfc_normalized);
┌─original─┬─length(original)─┬─nfc_normalized─┬─length(nfc_normalized)─┐
│ é │ 2 │ é │ 2 │
└──────────┴──────────────────┴────────────────┴────────────────────────┘
normalizeUTF8NFD
도입: v21.11.0
NFD 정규화 형식에 따라 UTF-8 문자열을 정규화해요.
구문 (Syntax)
normalizeUTF8NFD(str)
인자 (Arguments)
str— UTF-8 인코딩 입력 문자열.String
반환 값 (Returned value)
UTF-8 문자열의 NFD 정규화 형식. String
예시 (Examples)
SELECT
'é' AS original, -- é (U+00E9)
length(original),
normalizeUTF8NFD('é') AS nfd_normalized, -- e + combining acute (U+0065 + U+0301)
length(nfd_normalized);
┌─original─┬─length(original)─┬─nfd_normalized─┬─length(nfd_normalized)─┐
│ é │ 2 │ é │ 3 │
└──────────┴──────────────────┴────────────────┴────────────────────────┘
normalizeUTF8NFKC
도입: v21.11.0
NFKC 정규화 형식에 따라 UTF-8 문자열을 정규화해요.
구문 (Syntax)
normalizeUTF8NFKC(str)
인자 (Arguments)
str— UTF-8 인코딩 입력 문자열.String
반환 값 (Returned value)
UTF-8 문자열의 NFKC 정규화 형식. String
예시 (Examples)
SELECT
'① ② ③' AS original, -- Circled number characters
normalizeUTF8NFKC('① ② ③') AS nfkc_normalized -- Converts to 1 2 3
┌─original─┬─nfkc_normalized─┐
│ ① ② ③ │ 1 2 3 │
└──────────┴─────────────────┘
normalizeUTF8NFKCCasefold
도입: v26.3.0
NFKC_Casefold 정규화 형식에 따라 UTF-8 문자열을 정규화해요. 이는 NFKC 정규화를 적용한 뒤 케이스 폴딩을 적용하는 것이에요. 식별자의 대소문자 구분 없는 매칭에 유용해요.
구문 (Syntax)
normalizeUTF8NFKCCasefold(str)
인자 (Arguments)
str— UTF-8 인코딩 입력 문자열.String
반환 값 (Returned value)
UTF-8 문자열의 NFKC_Casefold 정규화 형식. String
예시 (Examples)
SELECT
'Ä ① Hello' AS original,
normalizeUTF8NFKCCasefold('Ä ① Hello') AS nfkc_cf_normalized;
┌─original──┬─nfkc_cf_normalized─┐
│ Ä ① Hello │ ä 1 hello │
└───────────┴────────────────────┘
normalizeUTF8NFKD
도입: v21.11.0
NFKD 정규화 형식에 따라 UTF-8 문자열을 정규화해요.
구문 (Syntax)
normalizeUTF8NFKD(str)
인자 (Arguments)
str— UTF-8 인코딩 입력 문자열.String
반환 값 (Returned value)
UTF-8 문자열의 NFKD 정규화 형식. String
예시 (Examples)
SELECT
'H₂O²' AS original, -- H + subscript 2 + O + superscript 2
normalizeUTF8NFKD('H₂O²') AS nfkd_normalized -- Converts to H 2 O 2
┌─original─┬─nfkd_normalized─┐
│ H₂O² │ H2O2 │
└──────────┴─────────────────┘
punycodeDecode
도입: v24.1.0
Punycode 인코딩 문자열의 UTF8 인코딩 평문을 반환해요. 유효한 Punycode 인코딩 문자열이 주어지지 않으면 예외가 발생해요.
구문 (Syntax)
punycodeDecode(s)
인자 (Arguments)
s— Punycode 인코딩 문자열.String
반환 값 (Returned value)
입력 값의 평문. String
예시 (Examples)
SELECT punycodeDecode('Mnchen-3ya')
┌─punycodeDecode('Mnchen-3ya')─┐
│ München │
└──────────────────────────────┘
punycodeEncode
도입: v24.1.0
문자열의 Punycode 표현을 반환해요. 문자열은 UTF8 인코딩이어야 하며, 그렇지 않으면 동작이 정의되지 않아요.
구문 (Syntax)
punycodeEncode(s)
인자 (Arguments)
s— 입력 값.String
반환 값 (Returned value)
입력 값의 Punycode 표현. String
예시 (Examples)
SELECT punycodeEncode('München')
┌─punycodeEncode('München')─┐
│ Mnchen-3ya │
└───────────────────────────┘
regexpExtract
도입: v23.2.0
haystack에서 regexp 패턴과 일치하고 regex 그룹 인덱스에 해당하는 첫 번째 문자열을 추출해요.
구문 (Syntax)
regexpExtract(haystack, pattern[, index])
별칭 (Aliases): REGEXP_EXTRACT, REGEXP_SUBSTR
인자 (Arguments)
haystack— regexp 패턴을 매치할 문자열.Stringpattern— 문자열, regexp 표현식.pattern은 여러 regexp 그룹을 담을 수 있고,index는 어떤 regex 그룹을 추출할지 나타내요. 인덱스0은 전체 정규식을 매치함을 뜻해요.const Stringindex— 선택 사항. 추출할 regex 그룹을 나타내는 음이 아닌 정수.pattern에 캡처 그룹이 하나 이상 있으면 기본값은1, 캡처 그룹이 없으면0(전체 매치)이에요.(U)Int*
반환 값 (Returned value)
문자열 매치. String
예시 (Examples)
SELECT
regexpExtract('100-200', '(\\d+)-(\\d+)', 1),
regexpExtract('100-200', '(\\d+)-(\\d+)', 2),
regexpExtract('100-200', '(\\d+)-(\\d+)', 0),
regexpExtract('100-200', '(\\d+)-(\\d+)'),
regexpExtract('100-200', '\\d+');
┌─regexpExtract('100-200', '(\\d+)-(\\d+)', 1)─┬─regexpExtract('100-200', '(\\d+)-(\\d+)', 2)─┬─...─┐
│ 100 │ 200 │ │
└──────────────────────────────────────────────┴──────────────────────────────────────────────┴─────┘
regexpPosition
도입: v26.5.0
바이트 위치 position부터 검색을 시작해 haystack에서 pattern의 occurrence번째 매치의 바이트 위치(1부터 시작)를 반환해요.
return_option이 0(기본값)이면 매치의 첫 바이트 위치를 반환해요. 1이면 매치 다음의 첫 바이트 위치를 반환해요.
subexpression이 0보다 크면 전체 매치 대신 해당 캡처 그룹의 위치를 반환해요.
매치가 없거나 요청한 캡처 그룹이 매치에 참여하지 않았으면 0을 반환해요.
PostgreSQL의 regexp_instr(그 별칭으로도 노출)와의 호환을 위해 제공돼요. 위치는 바이트 기반으로, 다른 ClickHouse regex 함수와 일치한다는 점을 주의하세요. PostgreSQL의 regexp_instr는 문자 기반이에요.
구문 (Syntax)
regexpPosition(haystack, pattern[, position[, occurrence[, return_option[, flags[, subexpression]]]]])
별칭 (Aliases): regexpInstr, regexp_instr
인자 (Arguments)
haystack— 검색할 문자열.Stringpattern— 정규식 패턴.const Stringposition— 선택 사항. 검색을 시작할 1부터 시작하는 바이트 위치. 기본값: 1.(U)Int*occurrence— 선택 사항. 반환할 매치. 기본값: 1.(U)Int*return_option— 선택 사항. 0은 매치 시작 위치, 1은 매치 바로 뒤 위치. 기본값: 0.(U)Int*flags— 선택 사항. regex 플래그. 지원:i(대소문자 구분 없음),c(대소문자 구분),m/n(멀티라인 앵커),s(점이 줄바꿈 매치). 기본값: 빈 문자열.const Stringsubexpression— 선택 사항. 위치를 반환할 캡처 그룹의 인덱스. 0은 전체 매치. 기본값: 0.(U)Int*
반환 값 (Returned value)
매치의 바이트 위치, 또는 찾지 못하면 0. UInt64
예시 (Examples)
기본 사용
SELECT
regexpPosition('hello world', 'world'),
regexpPosition('aXbXcXd', 'X', 1, 2),
regexpPosition('aXbXcXd', 'X', 1, 2, 1),
regexpPosition('Hello WORLD', 'world', 1, 1, 0, 'i'),
regexpPosition('foo123bar456', '([a-z]+)([0-9]+)', 1, 2, 0, '', 2);
┌─regexpPosition('hello world', 'world')─┬─regexpPosition('aXbXcXd', 'X', 1, 2)─┬─...─┐
│ 7 │ 4 │ ... │
└────────────────────────────────────────┴──────────────────────────────────────┴─────┘
removeDiacriticsUTF8
도입: v26.3.0
NFD로 문자를 분해하고, 결합 기호(유니코드 카테고리 Mn)를 제거한 뒤 NFC로 다시 결합해 UTF-8 문자열에서 분음 부호(억양)를 제거해요.
구문 (Syntax)
removeDiacriticsUTF8(str)
별칭 (Aliases): removeAccentsUTF8
인자 (Arguments)
str— UTF-8 인코딩 입력 문자열.String
반환 값 (Returned value)
분음 부호가 제거된 UTF-8 문자열. String
예시 (Examples)
기본 억양 제거
SELECT removeDiacriticsUTF8('café résumé naïve')
┌─removeDiacriticsUTF8('café résumé naïve')─┐
│ cafe resume naive │
└───────────────────────────────────────────┘
repeat
도입: v20.1.0
문자열을 지정된 횟수만큼 반복해 자기 자신과 연결해요.
구문 (Syntax)
repeat(s, n)
인자 (Arguments)
s— 반복할 문자열.Stringn— 문자열을 반복할 횟수.(U)Int*
반환 값 (Returned value)
문자열 s를 n번 반복해 담은 문자열. n이 음수면 빈 문자열을 반환해요. String
예시 (Examples)
SELECT repeat('abc', 10)
┌─repeat('abc', 10)──────────────┐
│ abcabcabcabcabcabcabcabcabcabc │
└────────────────────────────────┘
reverseUTF8
도입: v1.1.0
문자열의 유니코드 코드포인트 시퀀스를 뒤집어요. 문자열이 유효한 UTF-8 인코딩 텍스트라고 가정해요. 이 가정이 어긋나면 예외를 던지지 않고 결과는 정의되지 않아요.
구문 (Syntax)
reverseUTF8(s)
인자 (Arguments)
s— 유효한 UTF-8 인코딩 텍스트를 담은 문자열.String
반환 값 (Returned value)
유니코드 코드포인트 시퀀스가 뒤집힌 문자열. String
예시 (Examples)
SELECT reverseUTF8('ClickHouse')
esuoHkcilC
right
도입: v22.1.0
오른쪽에서부터 시작하는 지정된 offset만큼의 문자열 s의 부분 문자열을 반환해요.
구문 (Syntax)
right(s, offset)
인자 (Arguments)
s— 부분 문자열을 계산할 문자열.String또는FixedStringoffset— 오프셋의 바이트 수.(U)Int*
반환 값 (Returned value)
다음을 반환해요:
- 양수
offset이면, 문자열 오른쪽에서 시작하는offset바이트만큼의s부분 문자열. - 음수
offset이면, 문자열 오른쪽에서 시작하는length(s) - |offset|바이트만큼의s부분 문자열. length가0이면 빈 문자열.String
예시 (Examples)
양수 오프셋
SELECT right('Hello', 3)
llo
음수 오프셋
SELECT right('Hello', -3)
lo
rightPad
도입: v21.8.0
결과 문자열이 지정된 length에 도달할 때까지 오른쪽에 공백 또는 지정된 문자열로(필요하면 여러 번) 채워요.
구문 (Syntax)
rightPad(string, length[, pad_string])
별칭 (Aliases): rpad
인자 (Arguments)
string— 패딩할 입력 문자열.Stringlength— 결과 문자열의 길이. 값이 입력 문자열 길이보다 작으면 입력 문자열이length문자로 줄어들어요.(U)Int*pad_string— 선택 사항. 입력 문자열을 채울 문자열. 지정하지 않으면 공백으로 채워요.String
반환 값 (Returned value)
주어진 길이의 오른쪽 패딩된 문자열. String
예시 (Examples)
SELECT rightPad('abc', 7, '*'), rightPad('abc', 7)
┌─rightPad('abc', 7, '*')─┬─rightPad('abc', 7)─┐
│ abc**** │ abc │
└─────────────────────────┴────────────────────┘
rightPadUTF8
도입: v21.8.0
결과 문자열이 주어진 길이에 도달할 때까지 오른쪽에 공백 또는 지정된 문자열로(필요하면 여러 번) 채워요. 문자열 길이를 바이트로 재는 rightPad와 달리, 문자열 길이는 코드포인트 단위로 재요.
구문 (Syntax)
rightPadUTF8(string, length[, pad_string])
인자 (Arguments)
string— 패딩할 입력 문자열.Stringlength— 결과 문자열의 길이. 값이 입력 문자열 길이보다 작으면 입력 문자열이length문자로 줄어들어요.(U)Int*pad_string— 선택 사항. 입력 문자열을 채울 문자열. 지정하지 않으면 공백으로 채워요.String
반환 값 (Returned value)
주어진 길이의 오른쪽 패딩된 문자열. String
예시 (Examples)
SELECT rightPadUTF8('абвг', 7, '*'), rightPadUTF8('абвг', 7)
┌─rightPadUTF8('абвг', 7, '*')─┬─rightPadUTF8('абвг', 7)─┐
│ абвг*** │ абвг │
└──────────────────────────────┴─────────────────────────┘
rightUTF8
도입: v22.1.0
오른쪽에서부터 시작하는 지정된 offset만큼의 UTF-8 인코딩 문자열 s의 부분 문자열을 반환해요.
구문 (Syntax)
rightUTF8(s, offset)
인자 (Arguments)
s— 부분 문자열을 계산할 UTF-8 인코딩 문자열.String또는FixedStringoffset— 오프셋의 바이트 수.(U)Int*
반환 값 (Returned value)
다음을 반환해요:
- 양수
offset이면, 문자열 오른쪽에서 시작하는offset바이트만큼의s부분 문자열. - 음수
offset이면, 문자열 오른쪽에서 시작하는length(s) - |offset|바이트만큼의s부분 문자열. length가0이면 빈 문자열.String
예시 (Examples)
양수 오프셋
SELECT rightUTF8('Привет', 4)
ивет
음수 오프셋
SELECT rightUTF8('Привет', -4)
ет
soundex
도입: v23.4.0
문자열의 Soundex 코드를 반환해요.
구문 (Syntax)
soundex(s)
인자 (Arguments)
s— 입력 문자열.String
반환 값 (Returned value)
입력 문자열의 Soundex 코드. String
예시 (Examples)
SELECT soundex('aksel')
┌─soundex('aksel')─┐
│ A240 │
└──────────────────┘
space
도입: v23.5.0
공백( )을 지정된 횟수만큼 반복해 연결해요.
구문 (Syntax)
space(n)
인자 (Arguments)
n— 공백을 반복할 횟수.(U)Int*
반환 값 (Returned value)
공백을 n번 반복해 담은 문자열. n <= 0이면 빈 문자열을 반환해요. String
예시 (Examples)
SELECT space(3) AS res, length(res);
┌─res─┬─length(res)─┐
│ │ 3 │
└─────┴─────────────┘
sparseGrams
도입: v25.5.0
문자열에서 길이가 최소 n인 모든 하위 문자열을 찾아요. 이때 하위 문자열의 경계에 있는 (n-1)-gram의 해시가 하위 문자열 안의 모든 (n-1)-gram의 해시보다 엄격히 커야 해요. 해시 함수로 CRC32를 사용해요.
구문 (Syntax)
sparseGrams(s[, min_ngram_length[, max_ngram_length[, min_cutoff_length]]])
인자 (Arguments)
s— 입력 문자열.Stringmin_ngram_length— 선택 사항. 추출된 ngram의 최소 길이. 기본값 및 최소값은 3.UInt*max_ngram_length— 선택 사항. 추출된 ngram의 최대 길이. 기본값은 100.min_ngram_length보다 작으면 안 돼요.UInt*min_cutoff_length— 선택 사항. 지정하면 길이가min_cutoff_length이상인 n-gram만 반환해요. 기본값은min_ngram_length과 같아요.min_ngram_length보다 작지 않고max_ngram_length보다 크면 안 돼요.UInt*
반환 값 (Returned value)
선택된 하위 문자열 배열. Array(String)
예시 (Examples)
SELECT sparseGrams('alice', 3)
┌─sparseGrams('alice', 3)────┐
│ ['ali','lic','ice','lice'] │
└────────────────────────────┘
sparseGramsHashes
도입: v25.5.0
문자열에서 길이가 최소 n인 모든 하위 문자열의 해시를 찾아요. 이때 하위 문자열의 경계에 있는 (n-1)-gram의 해시가 하위 문자열 안의 모든 (n-1)-gram의 해시보다 엄격히 커야 해요. 해시 함수로 CRC32를 사용해요.
구문 (Syntax)
sparseGramsHashes(s[, min_ngram_length, max_ngram_length])
인자 (Arguments)
s— 입력 문자열.Stringmin_ngram_length— 선택 사항. 추출된 ngram의 최소 길이. 기본값 및 최소값은 3.UInt*max_ngram_length— 선택 사항. 추출된 ngram의 최대 길이. 기본값은 100.min_ngram_length보다 작으면 안 돼요.UInt*min_cutoff_length— 선택 사항. 지정하면 길이가min_cutoff_length이상인 n-gram만 반환해요. 기본값은min_ngram_length과 같아요.UInt*
반환 값 (Returned value)
선택된 하위 문자열의 CRC32 해시 배열. Array(UInt32)
예시 (Examples)
SELECT sparseGramsHashes('alice', 3)
┌─sparseGramsHashes('alice', 3)────────────────┐
│ [3851133533,3120039944,646693941,2577359366] │
└──────────────────────────────────────────────┘
sparseGramsHashesUTF8
도입: v25.5.0
UTF-8 문자열에서 길이가 최소 n인 모든 하위 문자열의 해시를 찾아요. 이때 하위 문자열 경계의 (n-1)-gram 해시가 하위 문자열 안의 모든 (n-1)-gram 해시보다 엄격히 커야 해요. UTF-8 문자열을 기대하며, 잘못된 UTF-8 시퀀스면 예외를 던져요. 해시 함수로 CRC32를 사용해요.
구문 (Syntax)
sparseGramsHashesUTF8(s[, min_ngram_length, max_ngram_length])
인자 (Arguments)
s— 입력 문자열.Stringmin_ngram_length— 선택 사항. 추출된 ngram의 최소 길이. 기본값 및 최소값은 3.UInt*max_ngram_length— 선택 사항. 추출된 ngram의 최대 길이. 기본값은 100.min_ngram_length보다 작으면 안 돼요.UInt*min_cutoff_length— 선택 사항. 지정하면 길이가min_cutoff_length이상인 n-gram만 반환해요. 기본값은min_ngram_length과 같아요.UInt*
반환 값 (Returned value)
선택된 UTF-8 하위 문자열의 CRC32 해시 배열. Array(UInt32)
예시 (Examples)
SELECT sparseGramsHashesUTF8('алиса', 3)
┌─sparseGramsHashesUTF8('алиса', 3)───────────────────────┐
│ [1328958118,547287748,4155892324,2403052185,1673399070] │
└─────────────────────────────────────────────────────────┘
sparseGramsUTF8
도입: v25.5.0
UTF-8 문자열에서 길이가 최소 n인 모든 하위 문자열을 찾아요. 이때 하위 문자열 경계의 (n-1)-gram 해시가 하위 문자열 안의 모든 (n-1)-gram 해시보다 엄격히 커야 해요. UTF-8 문자열을 기대하며, 잘못된 UTF-8 시퀀스면 예외를 던져요. 해시 함수로 CRC32를 사용해요.
구문 (Syntax)
sparseGramsUTF8(s[, min_ngram_length[, max_ngram_length[, min_cutoff_length]]])
인자 (Arguments)
s— 입력 문자열.Stringmin_ngram_length— 선택 사항. 추출된 ngram의 최소 길이. 기본값 및 최소값은 3.UInt*max_ngram_length— 선택 사항. 추출된 ngram의 최대 길이. 기본값은 100.min_ngram_length보다 작으면 안 돼요.UInt*min_cutoff_length— 선택 사항. 지정하면 길이가min_cutoff_length이상인 n-gram만 반환해요. 기본값은min_ngram_length과 같아요.UInt*
반환 값 (Returned value)
선택된 UTF-8 하위 문자열 배열. Array(String)
예시 (Examples)
SELECT sparseGramsUTF8('алиса', 3)
┌─sparseGramsUTF8('алиса', 3)────────┐
│ ['али','лис','иса','лиса','алиса'] │
└────────────────────────────────────┘
startsWith
도입: v1.1.0
문자열이 제공된 문자열로 시작하는지 확인해요.
구문 (Syntax)
startsWith(s, prefix)
인자 (Arguments)
s— 확인할 문자열.Stringprefix— 확인할 프리픽스.String
반환 값 (Returned value)
s가 prefix로 시작하면 1, 아니면 0. UInt8
예시 (Examples)
SELECT startsWith('ClickHouse', 'Click');
┌─startsWith('ClickHouse', 'Click')─┐
│ 1 │
└───────────────────────────────────┘
startsWithCaseInsensitive
도입: v25.10.0
문자열이 제공된 대소문자 구분 없는 문자열로 시작하는지 확인해요.
구문 (Syntax)
startsWithCaseInsensitive(s, prefix)
인자 (Arguments)
s— 확인할 문자열.Stringprefix— 확인할 대소문자 구분 없는 프리픽스.String
반환 값 (Returned value)
s가 대소문자 구분 없는 prefix로 시작하면 1, 아니면 0. UInt8
예시 (Examples)
SELECT startsWithCaseInsensitive('ClickHouse', 'CLICK');
┌─startsWithCaseInsensitive('ClickHouse', 'CLICK')─┐
│ 1 │
└──────────────────────────────────────────────────┘
startsWithCaseInsensitiveUTF8
도입: v25.10.0
문자열이 제공된 대소문자 구분 없는 프리픽스로 시작하는지 확인해요. 문자열이 유효한 UTF-8 인코딩 텍스트라고 가정해요. 이 가정이 어긋나면 예외를 던지지 않고 결과는 정의되지 않아요.
구문 (Syntax)
startsWithCaseInsensitiveUTF8(s, prefix)
인자 (Arguments)
s— 확인할 문자열.Stringprefix— 확인할 대소문자 구분 없는 프리픽스.String
반환 값 (Returned value)
s가 대소문자 구분 없는 prefix로 시작하면 1, 아니면 0. UInt8
예시 (Examples)
SELECT startsWithCaseInsensitiveUTF8('приставка', 'при')
┌─startsWithCaseInsensitiveUTF8('приставка', 'при')─┐
│ 1 │
└───────────────────────────────────────────────────┘
startsWithUTF8
도입: v23.8.0
문자열이 제공된 프리픽스로 시작하는지 확인해요. 문자열이 유효한 UTF-8 인코딩 텍스트라고 가정해요. 이 가정이 어긋나면 예외를 던지지 않고 결과는 정의되지 않아요.
구문 (Syntax)
startsWithUTF8(s, prefix)
인자 (Arguments)
s— 확인할 문자열.Stringprefix— 확인할 프리픽스.String
반환 값 (Returned value)
s가 prefix로 시작하면 1, 아니면 0. UInt8
예시 (Examples)
SELECT startsWithUTF8('приставка', 'при')
┌─startsWithUTF8('приставка', 'при')─┐
│ 1 │
└────────────────────────────────────┘
stringBytesEntropy
도입: v25.6.0
문자열의 바이트 분포에 대한 섀넌 엔트로피를 계산해요.
구문 (Syntax)
stringBytesEntropy(s)
인자 (Arguments)
s— 분석할 문자열.String
반환 값 (Returned value)
문자열의 바이트 분포에 대한 섀넌 엔트로피. Float64
예시 (Examples)
SELECT stringBytesEntropy('Hello, world!')
┌─stringBytesEntropy('Hello, world!')─┐
│ 3.180832987205441 │
└─────────────────────────────────────┘
stringBytesUniq
도입: v25.6.0
문자열 안의 서로 다른 바이트 수를 세요.
구문 (Syntax)
stringBytesUniq(s)
인자 (Arguments)
s— 분석할 문자열.String
반환 값 (Returned value)
문자열 안의 서로 다른 바이트 수. UInt16
예시 (Examples)
SELECT stringBytesUniq('Hello')
┌─stringBytesUniq('Hello')─┐
│ 4 │
└──────────────────────────┘
stringJaccardIndex
도입: v23.11.0
두 바이트 문자열 사이의 자카드 유사도 지수(Jaccard similarity index)를 계산해요.
구문 (Syntax)
stringJaccardIndex(s1, s2)
인자 (Arguments)
s1— 첫 번째 입력 문자열.Strings2— 두 번째 입력 문자열.String
반환 값 (Returned value)
두 문자열 사이의 자카드 유사도 지수. Float64
예시 (Examples)
SELECT stringJaccardIndex('clickhouse', 'mouse')
┌─stringJaccardIndex('clickhouse', 'mouse')─┐
│ 0.4 │
└───────────────────────────────────────────┘
stringJaccardIndexUTF8
도입: v23.11.0
stringJaccardIndex와 같지만 UTF8 인코딩 문자열용이에요.
구문 (Syntax)
stringJaccardIndexUTF8(s1, s2)
인자 (Arguments)
s1— 첫 번째 입력 UTF8 문자열.Strings2— 두 번째 입력 UTF8 문자열.String
반환 값 (Returned value)
두 UTF8 문자열 사이의 자카드 유사도 지수. Float64
예시 (Examples)
SELECT stringJaccardIndexUTF8('我爱你', '我也爱你') AS jaccard_index
┌─jaccard_index─┐
│ 0.75 │
└───────────────┘
substring
도입: v1.1.0
지정된 바이트 인덱스 offset에서 시작하는 문자열 s의 부분 문자열을 반환해요. 바이트 세기는 1부터 시작하며 다음 로직을 따름:
offset이0이면 빈 문자열이 반환돼요.offset이 음수면 부분 문자열이 문자열 끝에서offset문자만큼 앞에서 시작해요(시작점부터가 아니라).
선택 사항 인자 length는 반환되는 부분 문자열이 가질 수 있는 최대 바이트 수를 지정해요.
숫자의 자릿수에 대해 유사한 연산을 수행하는 digits 함수도 참고하세요.
구문 (Syntax)
substring(s, offset[, length])
별칭 (Aliases): byteSlice, mid, substr
인자 (Arguments)
s— 부분 문자열을 계산할 문자열.String또는FixedString또는Enumoffset—s에서 부분 문자열의 시작 위치.(U)Int*length— 선택 사항. 부분 문자열의 최대 길이.(U)Int*
반환 값 (Returned value)
인덱스 offset에서 시작하는 length 바이트만큼의 s 부분 문자열. String
예시 (Examples)
기본 사용
SELECT 'database' AS db, substr(db, 5), substr(db, 5, 1)
┌─db───────┬─substr(db, 5)─┬─substr(db, 5, 1)─┐
│ database │ base │ b │
└──────────┴───────────────┴──────────────────┘
substringIndex
도입: v23.7.0
Spark 또는 MySQL에서처럼 구분자 delim이 count번 나타나기 전의 s의 부분 문자열을 반환해요.
구문 (Syntax)
substringIndex(s, delim, count)
별칭 (Aliases): SUBSTRING_INDEX
인자 (Arguments)
s— 부분 문자열을 추출할 문자열.Stringdelim— 분리할 문자.Stringcount— 부분 문자열을 추출하기 전에 세는 구분자 출현 횟수. count가 양수면(왼쪽부터 세어) 마지막 구분자의 왼쪽에 있는 모든 것이 반환돼요. count가 음수면(오른쪽부터 세어) 마지막 구분자의 오른쪽에 있는 모든 것이 반환돼요.UInt또는Int
반환 값 (Returned value)
delim이 count번 나타나기 전의 s 부분 문자열. String
예시 (Examples)
SELECT substringIndex('www.clickhouse.com', '.', 2)
┌─substringIndex('www.clickhouse.com', '.', 2)─┐
│ www.clickhouse │
└──────────────────────────────────────────────┘
substringIndexUTF8
도입: v23.7.0
구분자 delim이 count번 나타나기 전의 s 부분 문자열을 반환해요. 특히 유니코드 코드포인트 기준이에요. 문자열이 유효한 UTF-8 인코딩 텍스트라고 가정해요. 이 가정이 어긋나면 예외를 던지지 않고 결과는 정의되지 않아요.
구문 (Syntax)
substringIndexUTF8(s, delim, count)
인자 (Arguments)
s— 부분 문자열을 추출할 문자열.Stringdelim— 분리할 문자.Stringcount— 부분 문자열을 추출하기 전에 세는 구분자 출현 횟수. count가 양수면(왼쪽부터 세어) 마지막 구분자의 왼쪽에 있는 모든 것이 반환돼요. count가 음수면(오른쪽부터 세어) 마지막 구분자의 오른쪽에 있는 모든 것이 반환돼요.UInt또는Int
반환 값 (Returned value)
delim이 count번 나타나기 전의 s 부분 문자열. String
예시 (Examples)
UTF8 예시
SELECT substringIndexUTF8('www.straßen-in-europa.de', '.', 2)
www.straßen-in-europa
substringUTF8
도입: v1.1.0
지정된 코드포인트 인덱스 offset에서 시작하는 문자열 s의 부분 문자열을 반환해요. 코드포인트 세기는 1부터 시작하며 다음 로직을 따름:
offset이0이면 빈 문자열이 반환돼요.offset이 음수면 부분 문자열이 문자열 끝에서offset코드포인트 앞에서 시작해요(시작점부터가 아니라).
선택 사항 인자 length는 반환되는 부분 문자열이 가질 수 있는 최대 코드포인트 수를 지정해요.
참고: 이 함수는 문자열이 유효한 UTF-8 인코딩 텍스트라고 가정해요. 이 가정이 어긋나면 예외를 던지지 않고 결과는 정의되지 않아요.
구문 (Syntax)
substringUTF8(s, offset[, length])
인자 (Arguments)
s— 부분 문자열을 계산할 문자열.String또는FixedString또는Enumoffset—s에서 부분 문자열의 시작 위치.Int또는UIntlength— 부분 문자열의 최대 길이. 선택 사항.Int또는UInt
반환 값 (Returned value)
코드포인트 인덱스 offset에서 시작하는 length 코드포인트만큼의 s 부분 문자열. String
예시 (Examples)
SELECT 'Täglich grüßt das Murmeltier.' AS str, substringUTF8(str, 9), substringUTF8(str, 9, 5)
Täglich grüßt das Murmeltier. grüßt das Murmeltier. grüßt
toValidUTF8
도입: v20.1.0
잘못된 UTF-8 문자를 모두 대체 문자 �(U+FFFD)로 바꿔 문자열을 유효한 UTF-8 인코딩으로 변환해요. 연속된 잘못된 문자가 여러 개 발견되면 단일 대체 문자로 합쳐져요.
구문 (Syntax)
toValidUTF8(s)
인자 (Arguments)
s— String 데이터 타입 객체로 표현된 임의의 바이트 집합.String
반환 값 (Returned value)
유효한 UTF-8 문자열. String
예시 (Examples)
SELECT toValidUTF8('\x61\xF0\x80\x80\x80b')
\x61\xF0\x80\x80\x80b
trimBoth
도입: v20.1.0
문자열의 시작과 끝에서 지정된 문자를 제거해요. 기본적으로 일반 공백(ASCII) 문자를 제거해요.
구문 (Syntax)
trimBoth(s[, trim_characters])
별칭 (Aliases): trim
인자 (Arguments)
s— 트리밍할 문자열.Stringtrim_characters— 선택 사항. 트리밍할 문자. 지정하지 않으면 일반 공백 문자를 제거해요.String
반환 값 (Returned value)
양 끝에서 지정된 문자가 트리밍된 문자열. String
예시 (Examples)
SELECT trimBoth('$$ClickHouse$$', '$')
┌─trimBoth('$$ClickHouse$$', '$')─┐
│ ClickHouse │
└─────────────────────────────────┘
trimLeft
도입: v20.1.0
문자열의 시작에서 지정된 문자를 제거해요. 기본적으로 일반 공백(ASCII) 문자를 제거해요.
구문 (Syntax)
trimLeft(input[, trim_characters])
별칭 (Aliases): ltrim
인자 (Arguments)
input— 트리밍할 문자열.Stringtrim_characters— 선택 사항. 트리밍할 문자. 지정하지 않으면 일반 공백 문자를 제거해요.String
반환 값 (Returned value)
왼쪽에서 지정된 문자가 트리밍된 문자열. String
예시 (Examples)
SELECT trimLeft('ClickHouse', 'Click');
┌─trimLeft('ClickHouse', 'Click')─┐
│ House │
└─────────────────────────────────┘
trimRight
도입: v20.1.0
문자열의 끝에서 지정된 문자를 제거해요. 기본적으로 일반 공백(ASCII) 문자를 제거해요.
구문 (Syntax)
trimRight(s[, trim_characters])
별칭 (Aliases): rtrim
인자 (Arguments)
s— 트리밍할 문자열.Stringtrim_characters— 선택 사항. 트리밍할 문자. 지정하지 않으면 일반 공백 문자를 제거해요.String
반환 값 (Returned value)
오른쪽에서 지정된 문자가 트리밍된 문자열. String
예시 (Examples)
SELECT trimRight('ClickHouse','House');
┌─trimRight('ClickHouse', 'House')─┐
│ Click │
└──────────────────────────────────┘
tryBase32Decode
도입: v25.6.0
문자열을 받아 Base32 인코딩 체계로 디코딩해요.
구문 (Syntax)
tryBase32Decode(encoded)
인자 (Arguments)
encoded— 디코딩할 문자열 컬럼 또는 상수. 문자열이 유효한 Base32 인코딩이 아니면 오류 시 빈 문자열을 반환해요.String
반환 값 (Returned value)
인자의 디코딩된 값을 담은 문자열. String
예시 (Examples)
SELECT tryBase32Decode('IVXGG33EMVSA====');
┌─tryBase32Decode('IVXGG33EMVSA====')─┐
│ Encoded │
└─────────────────────────────────────┘
tryBase58Decode
도입: v22.10.0
base58Decode와 같지만 오류 시 빈 문자열을 반환해요.
구문 (Syntax)
tryBase58Decode(encoded[, expected_size])
인자 (Arguments)
encoded— 문자열 컬럼 또는 상수. 문자열이 유효한 Base58 인코딩이 아니면 오류 시 빈 문자열을 반환해요.Stringexpected_size— 선택 사항. 요구되는 디코딩 크기(바이트): 다른 크기로 디코딩되는 입력은 거부돼요.0은 요구 없음.UInt8, UInt16, UInt32, or UInt64
반환 값 (Returned value)
인자의 디코딩된 값을 담은 문자열. String
예시 (Examples)
SELECT tryBase58Decode('3dc8KtHrwM') AS res, tryBase58Decode('invalid') AS res_invalid;
┌─res─────┬─res_invalid─┐
│ Encoded │ │
└─────────┴─────────────┘
tryBase64Decode
도입: v18.16.0
base64Decode와 같지만 오류 시 빈 문자열을 반환해요.
구문 (Syntax)
tryBase64Decode(encoded)
인자 (Arguments)
encoded— 디코딩할 문자열 컬럼 또는 상수. 문자열이 유효한 Base64 인코딩이 아니면 오류 시 빈 문자열을 반환해요.String
반환 값 (Returned value)
인자의 디코딩된 값을 담은 문자열. String
예시 (Examples)
SELECT tryBase64Decode('Y2xpY2tob3VzZQ==')
┌─tryBase64Decode('Y2xpY2tob3VzZQ==')─┐
│ clickhouse │
└─────────────────────────────────────┘
tryBase64URLDecode
도입: v18.16.0
base64URLDecode와 같지만 오류 시 빈 문자열을 반환해요.
구문 (Syntax)
tryBase64URLDecode(encoded)
인자 (Arguments)
encoded— 디코딩할 문자열 컬럼 또는 상수. 문자열이 유효한 Base64 인코딩이 아니면 오류 시 빈 문자열을 반환해요.String
반환 값 (Returned value)
인자의 디코딩된 값을 담은 문자열. String
예시 (Examples)
SELECT tryBase64URLDecode('aHR0cHM6Ly9jbGlja2hvdXNlLmNvbQ')
┌─tryBase64URLDecode('aHR0cHM6Ly9jbGlja2hvdXNlLmNvbQ')─┐
│ https://clickhouse.com │
└──────────────────────────────────────────────────────┘
tryIdnaEncode
도입: v24.1.0
IDNA 메커니즘에 따라 도메인 이름의 유니코드(UTF-8) 표현(ToUnicode 알고리즘)을 반환해요. 오류가 있으면 예외를 던지는 대신 빈 문자열을 반환해요.
구문 (Syntax)
tryIdnaEncode(s)
인자 (Arguments)
s— 입력 문자열.String
반환 값 (Returned value)
입력 값의 IDNA 메커니즘에 따른 입력 문자열의 ASCII 표현, 또는 입력이 유효하지 않으면 빈 문자열. String
예시 (Examples)
SELECT tryIdnaEncode('straße.münchen.de')
┌─tryIdnaEncode('straße.münchen.de')─┐
│ xn--strae-oqa.xn--mnchen-3ya.de │
└────────────────────────────────────┘
tryPunycodeDecode
도입: v24.1.0
punycodeDecode와 같지만 유효한 Punycode 인코딩 문자열이 주어지지 않으면 빈 문자열을 반환해요.
구문 (Syntax)
tryPunycodeDecode(s)
인자 (Arguments)
s— Punycode 인코딩 문자열.String
반환 값 (Returned value)
입력 값의 평문, 또는 입력이 유효하지 않으면 빈 문자열. String
예시 (Examples)
SELECT tryPunycodeDecode('Mnchen-3ya')
┌─tryPunycodeDecode('Mnchen-3ya')─┐
│ München │
└─────────────────────────────────┘
upper
도입: v1.1.0
문자열의 ASCII 라틴 기호를 대문자로 변환해요.
구문 (Syntax)
upper(s)
별칭 (Aliases): ucase
인자 (Arguments)
s— 대문자로 변환할 문자열.String
반환 값 (Returned value)
s에서 만든 대문자 문자열. String
예시 (Examples)
SELECT upper('clickhouse')
┌─upper('clickhouse')─┐
│ CLICKHOUSE │
└─────────────────────┘
upperUTF8
도입: v1.1.0
문자열이 유효한 UTF-8 인코딩 텍스트라고 가정하고 문자열을 대문자로 변환해요. 이 가정이 어긋나면 예외를 던지지 않고 결과는 정의되지 않아요.
참고: 이 함수는 언어를 감지하지 않아요. 예를 들어 터키어에서는 결과가 정확하지 않을 수 있어요(i/İ 대 i/I). 코드포인트의 대소문자의 UTF-8 바이트 시퀀스 길이가 다르면(예:
ẞ와ß) 해당 코드포인트에 대해 결과가 틀릴 수 있어요.
구문 (Syntax)
upperUTF8(s)
인자 (Arguments)
s— 문자열 타입.String
반환 값 (Returned value)
String 데이터 타입 값. String
예시 (Examples)
SELECT upperUTF8('München') AS Upperutf8
┌─Upperutf8─┐
│ MÜNCHEN │
└───────────┘