텍스트 함수

이 섹션은 STRING 값을 검사하고 조작하기 위한 함수와 연산자를 설명해요. 문자열을 다루는 거의 모든 것을 포함하니, 필요한 함수를 표에서 찾아 활용하면 좋아요.

출처: 문서

본문

텍스트 함수와 연산자

함수	설명
`string[index]`	(1 기반) `index`를 사용해 단일 문자 추출.
`string[begin:end]`	Python과 비슷한 slice 관례를 사용해 문자열 추출. `begin` 또는 `end` 인자가 없으면 각각 리스트의 시작 또는 끝으로 해석. 음수 값 허용.
`string LIKE target`	`string`이 like 지정자와 일치하면 `true` 반환 (패턴 매칭 참고).
`string SIMILAR TO regex`	`string`이 `regex`와 일치하면 `true` 반환 (패턴 매칭 참고).
`string ^@ search_string`	`starts_with`의 별칭.
`arg1 \|\| arg2`	두 문자열, 리스트 또는 blob 연결. 어떤 `NULL` 입력도 `NULL` 결과. `concat(arg1, arg2, ...)`와 `list_concat(list1, list2, ...)` 참고.
`array_extract(string, index)`	(1 기반) `index`를 사용해 `string`에서 단일 문자 추출.
`array_slice(list, begin, end)`	slice 관례를 사용해 하위 리스트 또는 하위 문자열 추출. 음수 값 허용.
`ascii(string)`	`string`의 첫 문자의 유니코드 코드 포인트를 나타내는 정수 반환.
`bar(x, min, max[, width])`	(`x - min`)에 비례하고 `x` = `max`일 때 `width` 문자와 같은 너비의 밴드를 그림. `width` 기본값 80.
`base64(blob)`	`to_base64`의 별칭.
`bin(string)`	`string`을 이진 표현으로 변환.
`bit_length(string)`	`string`의 비트 수.
`char_length(string)`	`length`의 별칭.
`character_length(string)`	`length`의 별칭.
`chr(code_point)`	ASCII 코드 값 또는 유니코드 코드 포인트에 해당하는 문자 반환.
`concat(value, ...)`	여러 문자열 또는 리스트 연결. `NULL` 입력은 건너뜀. 연산자 `\|\|` 참고.
`concat_ws(separator, string, ...)`	`separator`로 구분해 여러 문자열 연결. `NULL` 입력은 건너뜀.
`contains(string, search_string)`	`string` 안에서 `search_string`이 발견되면 `true` 반환. 콜레이션은 지원되지 않음.
`ends_with(string, search_string)`	`suffix`의 별칭.
`format(format, ...)`	fmt 문법을 사용해 문자열 형식화.
`formatReadableDecimalSize(integer)`	10의 거듭제곱 기반 단위(KB, MB, GB 등)를 사용해 `integer`를 사람이 읽기 쉬운 표현으로 변환.
`format_bytes(integer)`	2의 거듭제곱 기반 단위(KiB, MiB, GiB 등)를 사용해 `integer`를 사람이 읽기 쉬운 표현으로 변환.
`from_base64(string)`	base64로 인코딩된 `string`을 문자 문자열(`BLOB`)로 변환.
`from_binary(value)`	`unbin`의 별칭.
`from_hex(value)`	`unhex`의 별칭.
`greatest(arg1, ...)`	사전식 순서로 가장 큰 값 반환. 소문자가 대문자보다 크게 간주되고 콜레이션은 지원되지 않음에 유의.
`hash(value, ...)`	`value`의 해시를 담은 `UBIGINT` 반환. 암호화 해시가 아님에 유의.
`hex(string)`	`string`을 16진수 표현으로 변환.
`ilike_escape(string, like_specifier, escape_character)`	대소문자 구분 없는 매칭을 사용해 `string`이 `like_specifier`와 일치하면 `true` 반환 (패턴 매칭 참고). `escape_character`는 `string`에서 와일드카드 문자를 검색하는 데 사용.
`instr(string, search_string)`	`string`에서 `search_string`의 첫 발생 위치를 1부터 세어 반환. 일치가 없으면 0 반환.
`lcase(string)`	`lower`의 별칭.
`least(arg1, ...)`	사전식 순서로 가장 작은 값 반환. 대문자가 소문자보다 작게 간주되고 콜레이션은 지원되지 않음에 유의.
`left(string, count)`	가장 왼쪽의 `count` 문자 추출.
`left_grapheme(string, count)`	가장 왼쪽의 `count` 글리프 클러스터 추출.
`len(string)`	`length`의 별칭.
`length(string)`	`string`의 문자 수.
`length_grapheme(string)`	`string`의 글리프 클러스터 수.
`like_escape(string, like_specifier, escape_character)`	대소문자 구분 매칭을 사용해 `string`이 `like_specifier`와 일치하면 `true` 반환 (패턴 매칭 참고). `escape_character`는 `string`에서 와일드카드 문자를 검색하는 데 사용.
`lower(string)`	`string`을 소문자로 변환.
`lpad(string, count, character)`	`string`이 `count` 문자를 가질 때까지 `character`로 왼쪽에 패딩. `string`이 `count` 문자보다 많으면 오른쪽에서 잘라냄.
`ltrim(string[, characters])`	`string`의 왼쪽에서 `characters` 중 어느 것의 발생도 제거. `characters` 기본값은 `space`.
`md5(string)`	`string`의 MD5 해시를 `VARCHAR`로 반환.
`md5_number(string)`	`string`의 MD5 해시를 `HUGEINT`로 반환.
`md5_number_lower(string)`	`string`의 MD5 해시의 하위 64비트 세그먼트를 `UBIGINT`로 반환.
`md5_number_upper(string)`	`string`의 MD5 해시의 상위 64비트 세그먼트를 `UBIGINT`로 반환.
`nfc_normalize(string)`	`string`을 유니코드 NFC 정규화 문자열로 변환. 텍스트 데이터가 NFC 정규화된 것과 아닌 것이 섞여 있을 때 비교·정렬에 유용.
`not_ilike_escape(string, like_specifier, escape_character)`	대소문자 구분 없는 매칭을 사용해 `string`이 `like_specifier`와 일치하면 `false` 반환 (패턴 매칭 참고). `escape_character`는 `string`에서 와일드카드 문자를 검색하는 데 사용.
`not_like_escape(string, like_specifier, escape_character)`	대소문자 구분 매칭을 사용해 `string`이 `like_specifier`와 일치하면 `false` 반환 (패턴 매칭 참고). `escape_character`는 `string`에서 와일드카드 문자를 검색하는 데 사용.
`ord(string)`	`unicode`의 별칭.
`parse_dirname(path[, separator])`	주어진 `path`에서 최상위 디렉토리 이름 반환. `separator` 옵션: `system`, `both_slash`(기본), `forward_slash`, `backslash`.
`parse_dirpath(path[, separator])`	Python의 `os.path.dirname`과 비슷하게 `path`의 헤드(마지막 슬래시까지의 경로 이름) 반환. `separator` 옵션: `system`, `both_slash`(기본), `forward_slash`, `backslash`.
`parse_filename(string[, trim_extension][, separator])`	Python의 `os.path.basename` 함수와 비슷하게 `path`의 마지막 구성 요소 반환. `trim_extension`이 `true`면 파일 확장자를 제거 (기본 `false`). `separator` 옵션: `system`, `both_slash`(기본), `forward_slash`, `backslash`.
`parse_path(path[, separator])`	Python의 `pathlib.parts` 함수와 비슷하게 `path` 안의 구성 요소(디렉토리와 파일명) 목록 반환. `separator` 옵션: `system`, `both_slash`(기본), `forward_slash`, `backslash`.
`position(search_string IN string)`	`string`에서 `search_string`의 첫 발생 위치를 1부터 세어 반환. 일치가 없으면 0 반환.
`position(string, search_string)`	`instr`의 별칭.
`prefix(string, search_string)`	`string`이 `search_string`으로 시작하면 `true` 반환.
`printf(format, ...)`	printf 문법을 사용해 `string` 형식화.
`read_text(source)`	`source`(파일 이름, 파일 이름 목록, 또는 glob 패턴)의 내용을 `VARCHAR`로 반환. 파일 내용이 유효한 UTF-8인지 먼저 검증됨. `read_text`가 유효하지 않은 UTF-8 파일을 읽으려 하면 대신 `read_blob`을 쓰라는 오류가 발생.
`regexp_escape(string)`	Python의 `re.escape` 함수와 비슷하게 특수 패턴을 이스케이프해 `string`을 정규식으로 만듦.
`regexp_extract(string, regex[, group][, options])`	`string`이 `regex` 패턴을 포함하면 선택 파라미터 `group`이 지정하는 캡처 그룹을 반환; 그렇지 않으면 빈 문자열 반환. `group`은 상수 값이어야 함. `group`이 없으면 기본값 0. 선택적 regex 옵션 세트 설정 가능.
`regexp_extract(string, regex, name_list[, options])`	`string`이 `regex` 패턴을 포함하면 `name_list`의 해당 이름을 가진 struct로 캡처 그룹 반환; 그렇지 않으면 같은 키와 빈 문자열 값을 가진 struct 반환. 선택적 regex 옵션 세트 설정 가능.
`regexp_extract_all(string, regex[, group][, options])`	`string`에서 `regex`의 겹치지 않는 발생을 찾아 캡처 `group`의 해당 값 반환. 선택적 regex 옵션 세트 설정 가능.
`regexp_extract_all(string, regex, name_list[, options])`	`string`에서 `regex`의 겹치지 않는 발생을 찾아 `name_list`의 해당 이름을 가진 struct 목록으로 캡처 그룹 반환. 선택적 regex 옵션 세트 설정 가능.
`regexp_full_match(string, regex[, col2])`	전체 `string`이 `regex`와 일치하면 `true` 반환. 선택적 regex 옵션 세트 설정 가능.
`regexp_matches(string, regex[, options])`	`string`이 `regex`를 포함하면 `true`, 그렇지 않으면 `false` 반환. 선택적 regex 옵션 세트 설정 가능.
`regexp_replace(string, regex, replacement[, options])`	`string`이 `regex`를 포함하면 일치하는 부분을 `replacement`로 교체. 선택적 regex 옵션 세트 설정 가능.
`regexp_split_to_array(string, regex[, options])`	`string_split_regex`의 별칭.
`regexp_split_to_table(string, regex)`	`string`을 `regex`를 따라 나누고 각 부분에 대해 행 반환.
`repeat(string, count)`	`string`을 `count`번 반복.
`replace(string, source, target)`	`string`에서 `source`의 모든 발생을 `target`으로 교체.
`reverse(string)`	`string`을 뒤집음.
`right(string, count)`	가장 오른쪽 `count` 문자 추출.
`right_grapheme(string, count)`	가장 오른쪽 `count` 글리프 클러스터 추출.
`rpad(string, count, character)`	`string`이 `count` 문자를 가질 때까지 `character`로 오른쪽에 패딩. `string`이 `count` 문자보다 많으면 오른쪽에서 잘라냄.
`rtrim(string[, characters])`	`string`의 오른쪽에서 `characters` 중 어느 것의 발생도 제거. `characters` 기본값은 `space`.
`sha1(value)`	`value`의 SHA-1 해시를 담은 `VARCHAR` 반환.
`sha256(value)`	`value`의 SHA-256 해시를 담은 `VARCHAR` 반환.
`split(string, separator)`	`string_split`의 별칭.
`split_part(string, separator, index)`	`string`을 `separator`를 따라 나누고 리스트의 (1 기반) `index`에 있는 데이터 반환. `index`가 리스트 범위 밖이면 빈 문자열 반환 (PostgreSQL 동작과 일치).
`starts_with(string, search_string)`	`string`이 `search_string`으로 시작하면 `true` 반환.
`str_split(string, separator)`	`string_split`의 별칭.
`str_split_regex(string, regex[, options])`	`string_split_regex`의 별칭.
`string_split(string, separator)`	`string`을 `separator`를 따라 나눔.
`string_split_regex(string, regex[, options])`	`string`을 `regex`를 따라 나눔. 선택적 regex 옵션 세트 설정 가능.
`string_to_array(string, separator)`	`string_split`의 별칭.
`strip_accents(string)`	`string`에서 악센트 제거.
`strlen(string)`	`string`의 바이트 수.
`strpos(string, search_string)`	`instr`의 별칭.
`substr(string, start[, length])`	`substring`의 별칭.
`substring(string, start[, length])`	문자 `start`부터 문자열 끝까지 하위 문자열 추출. 선택 인자 `length`가 설정되면 `length` 문자 길이의 하위 문자열 추출. `start` 값 `1`은 `string`의 첫 문자를 가리킴에 유의.
`substring_grapheme(string, start[, length])`	글리프 클러스터 `start`부터 문자열 끝까지 하위 문자열 추출. 선택 인자 `length`가 설정되면 `length` 글리프 클러스터 길이의 하위 문자열 추출. `start` 값 `1`은 `string`의 `first` 문자를 가리킴에 유의.
`suffix(string, search_string)`	`string`이 `search_string`으로 끝나면 `true` 반환. 콜레이션은 지원되지 않음.
`to_base(number, radix[, min_length])`	`number`를 주어진 밑수 `radix`의 문자열로 변환, 선택적으로 선행 0으로 `min_length`까지 패딩.
`to_base64(blob)`	`blob`을 base64로 인코딩된 문자열로 변환.
`to_binary(string)`	`bin`의 별칭.
`to_hex(string)`	`hex`의 별칭.
`translate(string, from, to)`	`string`에서 `from` 집합의 문자와 일치하는 각 문자를 `to` 집합의 해당 문자로 교체. `from`이 `to`보다 길면 `from`의 추가 문자의 발생은 삭제.
`trim(string[, characters])`	`string`의 양쪽에서 `characters` 중 어느 것의 발생도 제거. `characters` 기본값은 `space`.
`ucase(string)`	`upper`의 별칭.
`unbin(value)`	`value`를 이진 표현에서 blob으로 변환.
`unhex(value)`	`value`를 16진수 표현에서 blob으로 변환.
`unicode(string)`	`string`의 첫 문자의 `unicode` 코드 포인트를 나타내는 `INTEGER` 반환.
`upper(string)`	`string`을 대문자로 변환.
`url_decode(string)`	Percent-Encoding을 사용한 표현에서 URL 디코딩.
`url_encode(string)`	Percent-Encoding을 사용한 표현으로 URL 인코딩.

`string[index]`

| 설명 | (1 기반) index를 사용해 단일 문자 추출 | | 예시 | 'DuckDB'[4] | | 결과 | k | | 별칭 | array_extract |

`string[begin:end]`

| 설명 | Python과 비슷한 slice 관례를 사용해 문자열 추출. begin 또는 end 인자가 없으면 각각 리스트의 시작 또는 끝으로 해석. 음수 값 허용 | | 예시 | 'DuckDB'[:4] | | 결과 | Duck | | 별칭 | array_slice |

`string LIKE target`

| 설명 | string이 like 지정자와 일치하면 true 반환 (패턴 매칭 참고) | | 예시 | 'hello' LIKE '%lo' | | 결과 | true |

`string SIMILAR TO regex`

| 설명 | string이 regex와 일치하면 true 반환 (패턴 매칭 참고) | | 예시 | 'hello' SIMILAR TO 'l+' | | 결과 | false | | 별칭 | regexp_full_match |

`arg1 || arg2`

| 설명 | 두 문자열, 리스트 또는 blob 연결. 어떤 NULL 입력도 NULL 결과. concat(arg1, arg2, ...)와 list_concat(list1, list2, ...) 참고 | | 예시 1 | 'Duck' \|\| 'DB' | | 결과 | DuckDB | | 예시 2 | [1, 2, 3] \|\| [4, 5, 6] | | 결과 | [1, 2, 3, 4, 5, 6] | | 예시 3 | '\xAA'::BLOB \|\| '\xBB'::BLOB | | 결과 | \xAA\xBB |

`array_extract(string, index)`

| 설명 | (1 기반) index를 사용해 string에서 단일 문자 추출 | | 예시 | array_extract('DuckDB', 2) | | 결과 | u |

`array_slice(list, begin, end)`

| 설명 | slice 관례를 사용해 하위 리스트 또는 하위 문자열 추출. 음수 값 허용 | | 예시 1 | array_slice('DuckDB', 3, 4) | | 결과 | ck | | 예시 2 | array_slice('DuckDB', 3, NULL) | | 결과 | NULL | | 예시 3 | array_slice('DuckDB', 0, -3) | | 결과 | Duck | | 별칭 | list_slice |

`ascii(string)`

| 설명 | string의 첫 문자의 유니코드 코드 포인트를 나타내는 정수 반환 | | 예시 | ascii('Ω') | | 결과 | 937 |

`bar(x, min, max[, width])`

| 설명 | (x - min)에 비례하고 x = max일 때 width 문자와 같은 너비의 밴드를 그림. width 기본값 80 | | 예시 | bar(5, 0, 20, 10) | | 결과 | ██▌ |

`bin(string)`

| 설명 | string을 이진 표현으로 변환 | | 예시 | bin('Aa') | | 결과 | 0100000101100001 | | 별칭 | to_binary |

`bit_length(string)`

| 설명 | string의 비트 수 | | 예시 | bit_length('abc') | | 결과 | 24 |

`chr(code_point)`

| 설명 | ASCII 코드 값 또는 유니코드 코드 포인트에 해당하는 문자 반환 | | 예시 | chr(65) | | 결과 | A |

`concat(value, ...)`

| 설명 | 여러 문자열 또는 리스트 연결. NULL 입력은 건너뜀. 연산자 \|\| 참고 | | 예시 1 | concat('Hello', ' ', 'World') | | 결과 | Hello World | | 예시 2 | concat([1, 2, 3], NULL, [4, 5, 6]) | | 결과 | [1, 2, 3, 4, 5, 6] |

`concat_ws(separator, string, ...)`

| 설명 | separator로 구분해 여러 문자열 연결. NULL 입력은 건너뜀 | | 예시 | concat_ws(', ', 'Banana', 'Apple', 'Melon') | | 결과 | Banana, Apple, Melon |

`contains(string, search_string)`

| 설명 | string 안에서 search_string이 발견되면 true 반환 | | 예시 | contains('abc', 'a') | | 결과 | true |

`format(format, ...)`

| 설명 | fmt 문법을 사용해 문자열 형식화 | | 예시 | format('Benchmark "{}" took {} seconds', 'CSV', 42) | | 결과 | Benchmark "CSV" took 42 seconds |

`formatReadableDecimalSize(integer)`

| 설명 | 10의 거듭제곱 기반 단위(KB, MB, GB 등)를 사용해 integer를 사람이 읽기 쉬운 표현으로 변환 | | 예시 | formatReadableDecimalSize(16000) | | 결과 | 16.0 kB |

`format_bytes(integer)`

| 설명 | 2의 거듭제곱 기반 단위(KiB, MiB, GiB 등)를 사용해 integer를 사람이 읽기 쉬운 표현으로 변환 | | 예시 | format_bytes(16_000) | | 결과 | 15.6 KiB | | 별칭 | formatReadableSize, pg_size_pretty |

`from_base64(string)`

| 설명 | base64로 인코딩된 string을 문자 문자열(BLOB)로 변환 | | 예시 | from_base64('QQ==') | | 결과 | A |

`greatest(arg1, ...)`

| 설명 | 사전식 순서로 가장 큰 값 반환. 소문자가 대문자보다 크게 간주되고 콜레이션은 지원되지 않음에 유의 | | 예시 1 | greatest(42, 84) | | 결과 | 84 | | 예시 2 | greatest('abc', 'bcd', 'cde', 'EFG') | | 결과 | cde |

`hash(value, ...)`

| 설명 | value의 해시를 담은 UBIGINT 반환. 암호화 해시가 아님에 유의 | | 예시 | hash('🦆') | | 결과 | 4164431626903154684 |

`hex(string)`

| 설명 | string을 16진수 표현으로 변환 | | 예시 | hex('Hello') | | 결과 | 48656C6C6F | | 별칭 | to_hex |

`ilike_escape(string, like_specifier, escape_character)`

| 설명 | 대소문자 구분 없는 매칭을 사용해 string이 like_specifier와 일치하면 true 반환 (패턴 매칭 참고). escape_character는 string에서 와일드카드 문자를 검색하는 데 사용 | | 예시 | ilike_escape('A%c', 'a$%C', '$') | | 결과 | true |

`instr(string, search_string)`

| 설명 | string에서 search_string의 첫 발생 위치를 1부터 세어 반환. 일치가 없으면 0 반환 | | 예시 | instr('test test', 'es') | | 결과 | 2 | | 별칭 | position, strpos |

`least(arg1, ...)`

| 설명 | 사전식 순서로 가장 작은 값 반환. 대문자가 소문자보다 작게 간주되고 콜레이션은 지원되지 않음에 유의 | | 예시 1 | least(42, 84) | | 결과 | 42 | | 예시 2 | least('abc', 'bcd', 'cde', 'EFG') | | 결과 | EFG |

`left(string, count)`

| 설명 | 가장 왼쪽의 count 문자 추출 | | 예시 | left('Hello🦆', 2) | | 결과 | He |

`left_grapheme(string, count)`

| 설명 | 가장 왼쪽의 count 글리프 클러스터 추출 | | 예시 | left_grapheme('🤦🏼‍♂️🤦🏽‍♀️', 1) | | 결과 | 🤦🏼‍♂️ |

`length(string)`

| 설명 | string의 문자 수 | | 예시 | length('Hello🦆') | | 결과 | 6 | | 별칭 | char_length, character_length, len |

`length_grapheme(string)`

| 설명 | string의 글리프 클러스터 수 | | 예시 | length_grapheme('🤦🏼‍♂️🤦🏽‍♀️') | | 결과 | 2 |

`like_escape(string, like_specifier, escape_character)`

| 설명 | 대소문자 구분 매칭을 사용해 string이 like_specifier와 일치하면 true 반환 (패턴 매칭 참고). escape_character는 string에서 와일드카드 문자를 검색하는 데 사용 | | 예시 | like_escape('a%c', 'a$%c', '$') | | 결과 | true |

`lower(string)`

| 설명 | string을 소문자로 변환 | | 예시 | lower('Hello') | | 결과 | hello | | 별칭 | lcase |

`lpad(string, count, character)`

| 설명 | string이 count 문자를 가질 때까지 character로 왼쪽에 패딩. string이 count 문자보다 많으면 오른쪽에서 잘라냄 | | 예시 | lpad('hello', 8, '>') | | 결과 | >>>hello |

`ltrim(string[, characters])`

| 설명 | string의 왼쪽에서 characters 중 어느 것의 발생도 제거. characters 기본값은 space | | 예시 1 | ltrim(' test ') | | 결과 | test | | 예시 2 | ltrim('>>>>test<<', '><') | | 결과 | test<< |

`md5(string)`

| 설명 | string의 MD5 해시를 VARCHAR로 반환 | | 예시 | md5('abc') | | 결과 | 900150983cd24fb0d6963f7d28e17f72 |

`md5_number(string)`

| 설명 | string의 MD5 해시를 HUGEINT로 반환 | | 예시 | md5_number('abc') | | 결과 | 152195979970564155685860391459828531600 |

`md5_number_lower(string)`

| 설명 | string의 MD5 해시의 하위 64비트 세그먼트를 UBIGINT로 반환 | | 예시 | md5_number_lower('abc') | | 결과 | 8250560606382298838 |

`md5_number_upper(string)`

| 설명 | string의 MD5 해시의 상위 64비트 세그먼트를 UBIGINT로 반환 | | 예시 | md5_number_upper('abc') | | 결과 | 12704604231530709392 |

`nfc_normalize(string)`

| 설명 | string을 유니코드 NFC 정규화 문자열로 변환. 텍스트 데이터가 NFC 정규화된 것과 아닌 것이 섞여 있을 때 비교·정렬에 유용 | | 예시 | nfc_normalize('ardèch') | | 결과 | ardèch |

`not_ilike_escape(string, like_specifier, escape_character)`

| 설명 | 대소문자 구분 없는 매칭을 사용해 string이 like_specifier와 일치하면 false 반환 (패턴 매칭 참고). escape_character는 string에서 와일드카드 문자를 검색하는 데 사용 | | 예시 | not_ilike_escape('A%c', 'a$%C', '$') | | 결과 | false |

`not_like_escape(string, like_specifier, escape_character)`

| 설명 | 대소문자 구분 매칭을 사용해 string이 like_specifier와 일치하면 false 반환 (패턴 매칭 참고). escape_character는 string에서 와일드카드 문자를 검색하는 데 사용 | | 예시 | not_like_escape('a%c', 'a$%c', '$') | | 결과 | false |

`parse_dirname(path[, separator])`

| 설명 | 주어진 path에서 최상위 디렉토리 이름 반환. separator 옵션: system, both_slash(기본), forward_slash, backslash | | 예시 | parse_dirname('path/to/file.csv', 'system') | | 결과 | path |

`parse_dirpath(path[, separator])`

| 설명 | Python의 os.path.dirname과 비슷하게 path의 헤드(마지막 슬래시까지의 경로 이름) 반환. separator 옵션: system, both_slash(기본), forward_slash, backslash | | 예시 | parse_dirpath('path/to/file.csv', 'forward_slash') | | 결과 | path/to |

`parse_filename(string[, trim_extension][, separator])`

| 설명 | Python의 os.path.basename 함수와 비슷하게 path의 마지막 구성 요소 반환. trim_extension이 true면 파일 확장자를 제거 (기본 false). separator 옵션: system, both_slash(기본), forward_slash, backslash | | 예시 | parse_filename('path/to/file.csv', true, 'forward_slash') | | 결과 | file |

`parse_path(path[, separator])`

| 설명 | Python의 pathlib.parts 함수와 비슷하게 path 안의 구성 요소(디렉토리와 파일명) 목록 반환. separator 옵션: system, both_slash(기본), forward_slash, backslash | | 예시 | parse_path('path/to/file.csv', 'system') | | 결과 | [path, to, file.csv] |

`position(search_string IN string)`

| 설명 | string에서 search_string의 첫 발생 위치를 1부터 세어 반환. 일치가 없으면 0 반환 | | 예시 | position('b' IN 'abc') | | 결과 | 2 | | 별칭 | instr, strpos |

`prefix(string, search_string)`

| 설명 | string이 search_string으로 시작하면 true 반환 | | 예시 | prefix('abc', 'ab') | | 결과 | true |

`printf(format, ...)`

| 설명 | printf 문법을 사용해 string 형식화 | | 예시 | printf('Benchmark "%s" took %d seconds', 'CSV', 42) | | 결과 | Benchmark "CSV" took 42 seconds |

`read_text(source)`

| 설명 | source(파일 이름, 파일 이름 목록, 또는 glob 패턴)의 내용을 VARCHAR로 반환. 파일 내용이 유효한 UTF-8인지 먼저 검증됨. 유효하지 않은 UTF-8 파일을 읽으려 하면 대신 read_blob을 쓰라는 오류 발생. 자세한 내용은 read_text 가이드 참고 | | 예시 | read_text('hello.txt') | | 결과 | hello\n |

`regexp_escape(string)`

| 설명 | Python의 re.escape 함수와 비슷하게 특수 패턴을 이스케이프해 string을 정규식으로 만듦 | | 예시 | regexp_escape('https://duckdb.org') | | 결과 | https\:\/\/duckdb\.org |

`regexp_extract(string, regex[, group][, options])`

| 설명 | string이 regex 패턴을 포함하면 선택 파라미터 group이 지정하는 캡처 그룹을 반환; 그렇지 않으면 빈 문자열 반환. group은 상수 값이어야 함. group이 없으면 기본값 0. 선택적 regex 옵션 세트 설정 가능 | | 예시 | regexp_extract('ABC', '([a-z])(b)', 1, 'i') | | 결과 | A |

`regexp_extract(string, regex, name_list[, options])`

| 설명 | string이 regex 패턴을 포함하면 name_list의 해당 이름을 가진 struct로 캡처 그룹 반환; 그렇지 않으면 같은 키와 빈 문자열 값을 가진 struct 반환. 선택적 regex 옵션 세트 설정 가능 | | 예시 | regexp_extract('John Doe', '([a-z]+) ([a-z]+)', ['first_name', 'last_name'], 'i') | | 결과 | {'first_name': John, 'last_name': Doe} |

`regexp_extract_all(string, regex[, group][, options])`

| 설명 | string에서 regex의 겹치지 않는 발생을 찾아 캡처 group의 해당 값 반환. 선택적 regex 옵션 세트 설정 가능 | | 예시 | regexp_extract_all('Peter: 33, Paul:14', '(\w+):\s*(\d+)', 2) | | 결과 | [33, 14] |

`regexp_extract_all(string, regex, name_list[, options])`

| 설명 | string에서 regex의 겹치지 않는 발생을 찾아 name_list의 해당 이름을 가진 struct 목록으로 캡처 그룹 반환. 선택적 regex 옵션 세트 설정 가능 | | 예시 | regexp_extract_all('Peter: 33, Paul: 14', '(\w+):\s*(\d+)', ['name', 'age']) | | 결과 | [{'name': Peter, 'age': 33}, {'name': Paul, 'age': 14}] |

`regexp_full_match(string, regex[, col2])`

| 설명 | 전체 string이 regex와 일치하면 true 반환. 선택적 regex 옵션 세트 설정 가능 | | 예시 | regexp_full_match('anabanana', '(an)*') | | 결과 | false |

`regexp_matches(string, regex[, options])`

| 설명 | string이 regex를 포함하면 true, 그렇지 않으면 false 반환. 선택적 regex 옵션 세트 설정 가능 | | 예시 | regexp_matches('anabanana', '(an)*') | | 결과 | true |

`regexp_replace(string, regex, replacement[, options])`

| 설명 | string이 regex를 포함하면 일치하는 부분을 replacement로 교체. 선택적 regex 옵션 세트 설정 가능 | | 예시 | regexp_replace('hello', '[lo]', '-') | | 결과 | he-lo |

`regexp_split_to_table(string, regex)`

| 설명 | string을 regex를 따라 나누고 각 부분에 대해 행 반환 | | 예시 | regexp_split_to_table('hello world; 42', ';? ') | | 결과 | 여러 행: 'hello', 'world', '42' |

`repeat(string, count)`

| 설명 | string을 count번 반복 | | 예시 | repeat('A', 5) | | 결과 | AAAAA |

`replace(string, source, target)`

| 설명 | string에서 source의 모든 발생을 target으로 교체 | | 예시 | replace('hello', 'l', '-') | | 결과 | he--o |

`reverse(string)`

| 설명 | string을 뒤집음 | | 예시 | reverse('hello') | | 결과 | olleh |

`right(string, count)`

| 설명 | 가장 오른쪽 count 문자 추출 | | 예시 | right('Hello🦆', 3) | | 결과 | lo🦆 |

`right_grapheme(string, count)`

| 설명 | 가장 오른쪽 count 글리프 클러스터 추출 | | 예시 | right_grapheme('🤦🏼‍♂️🤦🏽‍♀️', 1) | | 결과 | 🤦🏽‍♀️ |

`rpad(string, count, character)`

| 설명 | string이 count 문자를 가질 때까지 character로 오른쪽에 패딩. string이 count 문자보다 많으면 오른쪽에서 잘라냄 | | 예시 | rpad('hello', 10, '<') | | 결과 | hello<<<<< |

`rtrim(string[, characters])`

| 설명 | string의 오른쪽에서 characters 중 어느 것의 발생도 제거. characters 기본값은 space | | 예시 1 | rtrim(' test ') | | 결과 | test | | 예시 2 | rtrim('>>>>test<<', '><') | | 결과 | >>>>test |

`sha1(value)`

| 설명 | value의 SHA-1 해시를 담은 VARCHAR 반환 | | 예시 | sha1('🦆') | | 결과 | 949bf843dc338be348fb9525d1eb535d31241d76 |

`sha256(value)`

| 설명 | value의 SHA-256 해시를 담은 VARCHAR 반환 | | 예시 | sha256('🦆') | | 결과 | d7a5c5e0d1d94c32218539e7e47d4ba9c3c7b77d61332fb60d633dde89e473fb |

`split_part(string, separator, index)`

| 설명 | string을 separator를 따라 나누고 리스트의 (1 기반) index에 있는 데이터 반환. index가 리스트 범위 밖이면 빈 문자열 반환 (PostgreSQL 동작과 일치) | | 예시 | split_part('a;b;c', ';', 2) | | 결과 | b |

`starts_with(string, search_string)`

| 설명 | string이 search_string으로 시작하면 true 반환 | | 예시 | starts_with('abc', 'a') | | 결과 | true | | 별칭 | ^@ |

`string_split(string, separator)`

| 설명 | string을 separator를 따라 나눔 | | 예시 | string_split('hello-world', '-') | | 결과 | [hello, world] | | 별칭 | split, str_split, string_to_array |

`string_split_regex(string, regex[, options])`

| 설명 | string을 regex를 따라 나눔. 선택적 regex 옵션 세트 설정 가능 | | 예시 | string_split_regex('hello world; 42', ';? ') | | 결과 | [hello, world, 42] | | 별칭 | regexp_split_to_array, str_split_regex |

`strip_accents(string)`

| 설명 | string에서 악센트 제거 | | 예시 | strip_accents('mühleisen') | | 결과 | muhleisen |

`strlen(string)`

| 설명 | string의 바이트 수 | | 예시 | strlen('🦆') | | 결과 | 4 |

`substring(string, start[, length])`

| 설명 | 문자 start부터 문자열 끝까지 하위 문자열 추출. 선택 인자 length가 설정되면 length 문자 길이의 하위 문자열 추출. start 값 1은 string의 첫 문자를 가리킴에 유의 | | 예시 1 | substring('Hello', 2) | | 결과 | ello | | 예시 2 | substring('Hello', 2, 2) | | 결과 | el | | 별칭 | substr |

`substring_grapheme(string, start[, length])`

| 설명 | 글리프 클러스터 start부터 문자열 끝까지 하위 문자열 추출. 선택 인자 length가 설정되면 length 글리프 클러스터 길이의 하위 문자열 추출. start 값 1은 string의 first 문자를 가리킴에 유의 | | 예시 1 | substring_grapheme('🦆🤦🏼‍♂️🤦🏽‍♀️🦆', 3) | | 결과 | 🤦🏽‍♀️🦆 | | 예시 2 | substring_grapheme('🦆🤦🏼‍♂️🤦🏽‍♀️🦆', 3, 2) | | 결과 | 🤦🏽‍♀️🦆 |

`suffix(string, search_string)`

| 설명 | string이 search_string으로 끝나면 true 반환. 콜레이션은 지원되지 않음 | | 예시 | suffix('abc', 'bc') | | 결과 | true | | 별칭 | ends_with |

`to_base(number, radix[, min_length])`

| 설명 | number를 주어진 밑수 radix의 문자열로 변환, 선택적으로 선행 0으로 min_length까지 패딩 | | 예시 | to_base(42, 16, 5) | | 결과 | 0002A |

`to_base64(blob)`

| 설명 | blob을 base64로 인코딩된 문자열로 변환 | | 예시 | to_base64('A'::BLOB) | | 결과 | QQ== | | 별칭 | base64 |

`translate(string, from, to)`

| 설명 | string에서 from 집합의 문자와 일치하는 각 문자를 to 집합의 해당 문자로 교체. from이 to보다 길면 from의 추가 문자의 발생은 삭제 | | 예시 | translate('12345', '143', 'ax') | | 결과 | a2x5 |

`trim(string[, characters])`

| 설명 | string의 양쪽에서 characters 중 어느 것의 발생도 제거. characters 기본값은 space | | 예시 1 | trim(' test ') | | 결과 | test | | 예시 2 | trim('>>>>test<<', '><') | | 결과 | test |

`unbin(value)`

| 설명 | value를 이진 표현에서 blob으로 변환 | | 예시 | unbin('0110') | | 결과 | \x06 | | 별칭 | from_binary |

`unhex(value)`

| 설명 | value를 16진수 표현에서 blob으로 변환 | | 예시 | unhex('2A') | | 결과 | * | | 별칭 | from_hex |

`unicode(string)`

| 설명 | string의 첫 문자의 unicode 코드 포인트를 나타내는 INTEGER 반환 | | 예시 | [unicode('âbcd'), unicode('â'), unicode(''), unicode(NULL)] | | 결과 | [226, 226, -1, NULL] | | 별칭 | ord |

`upper(string)`

| 설명 | string을 대문자로 변환 | | 예시 | upper('Hello') | | 결과 | HELLO | | 별칭 | ucase |

`url_decode(string)`

| 설명 | Percent-Encoding을 사용한 표현에서 URL 디코딩 | | 예시 | url_decode('https%3A%2F%2Fduckdb.org%2Fwhy_duckdb%23portable') | | 결과 | https://duckdb.org/why_duckdb#portable |

`url_encode(string)`

| 설명 | Percent-Encoding을 사용한 표현으로 URL 인코딩 | | 예시 | url_encode('this string has/ special+ characters>') | | 결과 | this%20string%20has%2F%20special%2B%20characters%3E |

텍스트 유사도 함수

이 함수들은 다양한 유사도 측정을 사용해 두 문자열의 유사도를 측정하는 데 쓰여요.

함수	설명
`damerau_levenshtein(s1, s2)`	Levenshtein 거리를 확장해 인접 문자 전치도 허용된 편집 연산으로 포함. 즉, 한 문자열을 다른 것으로 바꾸는 데 필요한 최소 편집 연산 수(삽입, 삭제, 대체 또는 전치). 다른 대소문자의 문자(예: `a`와 `A`)는 다르게 간주.
`editdist3(s1, s2)`	`levenshtein`의 별칭.
`hamming(s1, s2)`	두 문자열 사이의 Hamming 거리, 즉 같은 길이의 두 문자열에서 다른 문자가 있는 위치 수. 문자열은 같은 길이여야 함. 다른 대소문자의 문자는 다르게 간주.
`jaccard(s1, s2)`	두 문자열 사이의 Jaccard 유사도. 다른 대소문자의 문자는 다르게 간주. 0과 1 사이의 숫자 반환.
`jaro_similarity(s1, s2[, score_cutoff])`	두 문자열 사이의 Jaro 유사도. 다른 대소문자의 문자는 다르게 간주. 0과 1 사이의 숫자 반환. 유사도 < `score_cutoff`면 대신 0 반환. `score_cutoff` 기본값 0.
`jaro_winkler_similarity(s1, s2[, score_cutoff])`	두 문자열 사이의 Jaro-Winkler 유사도. 다른 대소문자의 문자는 다르게 간주. 0과 1 사이의 숫자 반환. 유사도 < `score_cutoff`면 대신 0 반환. `score_cutoff` 기본값 0.
`levenshtein(s1, s2)`	한 문자열을 다른 문자열로 바꾸는 데 필요한 최소 단일 문자 편집 수(삽입, 삭제 또는 대체). 다른 대소문자의 문자는 다르게 간주.
`mismatches(s1, s2)`	`hamming`의 별칭.

`damerau_levenshtein(s1, s2)`

| 설명 | Levenshtein 거리를 확장해 인접 문자 전치도 허용된 편집 연산으로 포함. 즉, 한 문자열을 다른 것으로 바꾸는 데 필요한 최소 편집 연산 수(삽입, 삭제, 대체 또는 전치). 다른 대소문자의 문자는 다르게 간주 | | 예시 | damerau_levenshtein('duckdb', 'udckbd') | | 결과 | 2 |

`hamming(s1, s2)`

| 설명 | 두 문자열 사이의 Hamming 거리, 즉 같은 길이의 두 문자열에서 다른 문자가 있는 위치 수. 문자열은 같은 길이여야 함. 다른 대소문자의 문자는 다르게 간주 | | 예시 | hamming('duck', 'luck') | | 결과 | 1 | | 별칭 | mismatches |

`jaccard(s1, s2)`

| 설명 | 두 문자열 사이의 Jaccard 유사도. 다른 대소문자의 문자는 다르게 간주. 0과 1 사이의 숫자 반환 | | 예시 | jaccard('duck', 'luck') | | 결과 | 0.6 |

`jaro_similarity(s1, s2[, score_cutoff])`

| 설명 | 두 문자열 사이의 Jaro 유사도. 다른 대소문자의 문자는 다르게 간주. 0과 1 사이의 숫자 반환. 유사도 < score_cutoff면 대신 0 반환. score_cutoff 기본값 0 | | 예시 | jaro_similarity('duck', 'duckdb') | | 결과 | 0.8888888888888888 |

`jaro_winkler_similarity(s1, s2[, score_cutoff])`

| 설명 | 두 문자열 사이의 Jaro-Winkler 유사도. 다른 대소문자의 문자는 다르게 간주. 0과 1 사이의 숫자 반환. 유사도 < score_cutoff면 대신 0 반환. score_cutoff 기본값 0 | | 예시 | jaro_winkler_similarity('duck', 'duckdb') | | 결과 | 0.9333333333333333 |

`levenshtein(s1, s2)`

| 설명 | 한 문자열을 다른 문자열로 바꾸는 데 필요한 최소 단일 문자 편집 수(삽입, 삭제 또는 대체). 다른 대소문자의 문자는 다르게 간주 | | 예시 | levenshtein('duck', 'db') | | 결과 | 3 | | 별칭 | editdist3 |

포매터

`fmt` 문법

format(format, parameters...) 함수는 {fmt} 오픈소스 형식화 라이브러리의 문법을 대략적으로 따르며 문자열을 형식화해요.

추가 파라미터 없이 형식화:

SELECT format('Hello world'); -- Hello world

{}를 사용해 문자열 형식화:

SELECT format('The answer is {}', 42); -- The answer is 42

위치 인자를 사용해 문자열 형식화:

SELECT format('I''d rather be {1} than {0}.', 'right', 'happy'); -- I'd rather be happy than right.

형식 지정자

지정자	설명	예시
`{:d}`	정수	`654321`
`{:E}`	과학적 표기	`3.141593E+00`
`{:f}`	부동소수점	`4.560000`
`{:o}`	8진수	`2375761`
`{:s}`	문자열	`asd`
`{:x}`	16진수	`9fbf1`
`{:tX}`	정수, `X`는 천 단위 구분자	`654 321`

형식화 타입

정수:

SELECT format('{} + {} = {}', 3, 5, 3 + 5); -- 3 + 5 = 8

불리언:

SELECT format('{} != {}', true, false); -- true != false

날짜/시간 값 형식화:

SELECT format('{}', DATE '1992-01-01'); -- 1992-01-01
SELECT format('{}', TIME '12:01:00'); -- 12:01:00
SELECT format('{}', TIMESTAMP '1992-01-01 12:01:00'); -- 1992-01-01 12:01:00

BLOB 형식화:

SELECT format('{}', BLOB '\x00hello'); -- \x00hello

정수를 0으로 패딩:

SELECT format('{:04d}', 33); -- 0033

패딩은 현재 천 단위 구분자 지정과 결합할 수 없어요.

정수로 타임스탬프 만들기:

SELECT format('{:02d}:{:02d}:{:02d} {}', 12, 3, 16, 'AM'); -- 12:03:16 AM

16진수로 변환:

SELECT format('{:x}', 123_456_789); -- 75bcd15

이진수로 변환:

SELECT format('{:b}', 123_456_789); -- 111010110111100110100010101

천 단위 구분자로 숫자 출력

정수:

SELECT format('{:,}',  123_456_789); -- 123,456,789
SELECT format('{:t.}', 123_456_789); -- 123.456.789
SELECT format('{:''}', 123_456_789); -- 123'456'789
SELECT format('{:_}',  123_456_789); -- 123_456_789
SELECT format('{:t }', 123_456_789); -- 123 456 789
SELECT format('{:tX}', 123_456_789); -- 123X456X789

부동소수점, double, decimal:

SELECT format('{:,f}',    123456.789); -- 123,456.78900
SELECT format('{:,.2f}',  123456.789); -- 123,456.79
SELECT format('{:t..2f}', 123456.789); -- 123.456,79

`printf` 문법

printf(format, parameters...) 함수는 printf 문법을 사용해 문자열을 형식화해요.