> ## 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.
> 해시 함수 문서
# 해시 함수
해시 함수는 요소를 결정론적 의사 난수 방식으로 섞는 데 사용할 수 있습니다.
Simhash는 서로 유사한 인수에 대해 유사한 해시 값을 반환하는 해시 함수입니다.
대부분의 해시 함수는 어떤 타입이든 인수를 임의 개수로 받을 수 있습니다.
NULL의 해시는 NULL입니다. 널 허용 컬럼에서 NULL이 아닌 해시 값을 얻으려면 `tuple`로 감싸십시오:
```sql theme={null}
SELECT cityHash64(tuple(NULL))
```
테이블 전체 내용의 해시를 계산하려면 `sum(cityHash64(tuple(*)))`(또는 다른 해시 함수)를 사용하십시오. `tuple`은 NULL 값을 가진 행이 건너뛰어지지 않도록 합니다. `sum`은 행의 순서가 결과에 영향을 주지 않도록 합니다.
{/*AUTOGENERATED_START*/}
## BLAKE3
도입 버전: v22.10.0
BLAKE3 해시 문자열을 계산하고, 결과 바이트 집합을 FixedString으로 반환합니다.
이 암호학적 해시 함수는 BLAKE3 Rust 라이브러리를 통해 ClickHouse에 통합되어 있습니다.
이 함수는 상당히 빠르며, SHA-256과 같은 길이의 해시를 생성하면서도 SHA-2보다 대략 2배 빠른 성능을 보입니다.
BLAKE3 해시를 FixedString(32) 유형의 바이트 배열로 반환합니다.
**구문**
```sql theme={null}
BLAKE3(message)
```
**인수**
* `message` — 해시할 입력 문자열입니다. [`String`](/ko/reference/data-types/string)
**반환 값**
입력 문자열의 32바이트 BLAKE3 해시를 고정 길이 문자열로 반환합니다. [`FixedString(32)`](/ko/reference/data-types/fixedstring)
**예시**
**hash**
```sql title=Query theme={null}
SELECT hex(BLAKE3('ABC'))
```
```response title=Response theme={null}
┌─hex(BLAKE3('ABC'))───────────────────────────────────────────────┐
│ D1717274597CF0289694F75D96D444B992A096F1AFD8E7BBFA6EBB1D360FEDFC │
└──────────────────────────────────────────────────────────────────┘
```
## MD4
도입 버전: v21.11.0
주어진 문자열의 MD4 해시를 계산합니다.
**구문**
```sql theme={null}
MD4(s)
```
**인수**
* `s` — 해시할 입력 문자열입니다. [`String`](/ko/reference/data-types/string)
**반환 값**
주어진 입력 문자열의 MD4 해시를 고정 길이 문자열로 반환합니다. [`FixedString(16)`](/ko/reference/data-types/fixedstring)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT HEX(MD4('abc'));
```
```response title=Response theme={null}
┌─hex(MD4('abc'))──────────────────┐
│ A448017AAF21D8525FC10AE87AA6729D │
└──────────────────────────────────┘
```
## MD5
도입 버전: v1.1.0
주어진 문자열의 MD5 해시를 계산합니다.
**구문**
```sql theme={null}
MD5(s)
```
**인수**
* `s` — 해시할 입력 문자열입니다. [`String`](/ko/reference/data-types/string)
**반환 값**
주어진 입력 문자열의 MD5 해시를 고정 길이 문자열로 반환합니다. [`FixedString(16)`](/ko/reference/data-types/fixedstring)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT HEX(MD5('abc'));
```
```response title=Response theme={null}
┌─hex(MD5('abc'))──────────────────┐
│ 900150983CD24FB0D6963F7D28E17F72 │
└──────────────────────────────────┘
```
## RIPEMD160
도입 버전: v24.10.0
주어진 문자열의 RIPEMD-160 해시를 계산합니다.
**구문**
```sql theme={null}
RIPEMD160(s)
```
**인수**
* `s` — 해시할 입력 문자열입니다. [`String`](/ko/reference/data-types/string)
**반환 값**
주어진 입력 문자열의 RIPEMD160 해시를 고정 길이 문자열로 반환합니다. [`FixedString(20)`](/ko/reference/data-types/fixedstring)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT HEX(RIPEMD160('The quick brown fox jumps over the lazy dog'));
```
```response title=Response theme={null}
┌─HEX(RIPEMD160('The quick brown fox jumps over the lazy dog'))─┐
│ 37F332F68DB77BD9D7EDD4969571AD671CF9DD3B │
└───────────────────────────────────────────────────────────────┘
```
## SHA1
도입 버전: v1.1.0
지정된 문자열의 SHA1 해시를 계산합니다.
**구문**
```sql theme={null}
SHA1(s)
```
**인수**
* `s` — 해시할 입력 문자열 [`String`](/ko/reference/data-types/string)
**반환 값**
주어진 입력 문자열의 SHA1 해시를 고정 길이 문자열로 반환합니다. [`FixedString(20)`](/ko/reference/data-types/fixedstring)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT HEX(SHA1('abc'));
```
```response title=Response theme={null}
┌─hex(SHA1('abc'))─────────────────────────┐
│ A9993E364706816ABA3E25717850C26C9CD0D89D │
└──────────────────────────────────────────┘
```
## SHA224
도입 버전: v1.1.0
지정된 문자열의 SHA224 해시를 계산합니다.
**구문**
```sql theme={null}
SHA224(s)
```
**인수**
* `s` — 해시할 입력값입니다. [`String`](/ko/reference/data-types/string)
**반환 값**
지정된 입력 문자열의 SHA224 해시를 고정 길이 문자열로 반환합니다. [`FixedString(28)`](/ko/reference/data-types/fixedstring)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT HEX(SHA224('abc'));
```
```response title=Response theme={null}
┌─hex(SHA224('abc'))───────────────────────────────────────┐
│ 23097D223405D8228642A477BDA255B32AADBCE4BDA0B3F7E36C9DA7 │
└──────────────────────────────────────────────────────────┘
```
## SHA256
도입 버전: v1.1.0
지정된 문자열의 SHA256 해시를 계산합니다.
**구문**
```sql theme={null}
SHA256(s)
```
**인수**
* `s` — 해시할 입력 문자열입니다. [`String`](/ko/reference/data-types/string)
**반환 값**
지정된 입력 문자열의 SHA256 해시를 고정 길이 문자열로 반환합니다. [`FixedString(32)`](/ko/reference/data-types/fixedstring)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT HEX(SHA256('abc'));
```
```response title=Response theme={null}
┌─hex(SHA256('abc'))───────────────────────────────────────────────┐
│ BA7816BF8F01CFEA414140DE5DAE2223B00361A396177A9CB410FF61F20015AD │
└──────────────────────────────────────────────────────────────────┘
```
## SHA384
도입된 버전: v1.1.0
주어진 문자열의 SHA384 해시를 계산합니다.
**구문**
```sql theme={null}
SHA384(s)
```
**인수**
* `s` — 해시할 입력 문자열입니다. [`String`](/ko/reference/data-types/string)
**반환 값**
주어진 입력 문자열의 SHA384 해시를 고정 길이 문자열로 반환합니다. [`FixedString(48)`](/ko/reference/data-types/fixedstring)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT HEX(SHA384('abc'));
```
```response title=Response theme={null}
┌─hex(SHA384('abc'))───────────────────────────────────────────────────────────────────────────────┐
│ CB00753F45A35E8BB5A03D699AC65007272C32AB0EDED1631A8B605A43FF5BED8086072BA1E7CC2358BAECA134C825A7 │
└──────────────────────────────────────────────────────────────────────────────────────────────────┘
```
## SHA512
도입된 버전: v1.1.0
주어진 문자열의 SHA512 해시를 계산합니다.
**구문**
```sql theme={null}
SHA512(s)
```
**인수**
* `s` — 해시할 입력 문자열 [`String`](/ko/reference/data-types/string)
**반환 값**
주어진 입력 문자열의 SHA512 해시를 고정 길이 문자열로 반환합니다. [`FixedString(64)`](/ko/reference/data-types/fixedstring)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT HEX(SHA512('abc'));
```
```response title=Response theme={null}
┌─hex(SHA512('abc'))───────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
│ DDAF35A193617ABACC417349AE20413112E6FA4E89A97EA20A9EEEE64B55D39A2192992A274FC1A836BA3C23A3FEEBBD454D4423643CE80E2A9AC94FA54CA49F │
└──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
```
## SHA512\_256
도입됨: v1.1.0
주어진 문자열의 SHA512\_256 해시를 계산합니다.
**구문**
```sql theme={null}
SHA512_256(s)
```
**인수**
* `s` — 해시할 입력 문자열입니다. [`String`](/ko/reference/data-types/string)
**반환 값**
주어진 입력 문자열의 SHA512\_256 해시를 고정 길이 문자열로 반환합니다. [`FixedString(32)`](/ko/reference/data-types/fixedstring)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT HEX(SHA512_256('abc'));
```
```response title=Response theme={null}
┌─hex(SHA512_256('abc'))───────────────────────────────────────────┐
│ 53048E2681941EF99B2E29B76B4C7DABE4C2D0C634FC6D46E0E2F13107E7AF23 │
└──────────────────────────────────────────────────────────────────┘
```
## URLHash
도입 버전: v1.1.0
일종의 정규화를 거쳐 URL에서 얻은 문자열에 대해 계산하는, 빠르고 성능이 괜찮은 비암호학적 해시 함수입니다.
이 해시 함수에는 두 가지 모드가 있습니다:
| Mode | Description |
| ----------------- | ----------------------------------------------------------------------------------------------------- |
| `URLHash(url)` | 끝에 `/`, `?`, `#` 중 하나가 있으면 이를 제외한 문자열의 해시를 계산합니다. |
| `URLHash(url, N)` | 끝에 `/`, `?`, `#` 중 하나가 있으면 이를 제외하고, URL 계층 구조에서 N 레벨까지의 문자열에 대한 해시를 계산합니다. 레벨은 `URLHierarchy`와 동일합니다. |
**구문**
```sql theme={null}
URLHash(url[, N])
```
**인수**
* `url` — 해시할 URL 문자열입니다. [`String`](/ko/reference/data-types/string)
* `N` — 선택 사항입니다. URL 계층의 수준입니다. [`(U)Int*`](/ko/reference/data-types/int-uint)
**반환 값**
`url`의 해시 값을 반환합니다. [`UInt64`](/ko/reference/data-types/int-uint)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT URLHash('https://www.clickhouse.com')
```
```response title=Response theme={null}
┌─URLHash('htt⋯house.com')─┐
│ 13614512636072854701 │
└──────────────────────────┘
```
**지정한 수준의 URL 해시**
```sql title=Query theme={null}
SELECT URLHash('https://www.clickhouse.com/docs', 0);
SELECT URLHash('https://www.clickhouse.com/docs', 1);
```
```response title=Response theme={null}
-- https://www.clickhouse.com 의 해시
┌─URLHash('htt⋯m/docs', 0)─┐
│ 13614512636072854701 │
└──────────────────────────┘
-- https://www.clickhouse.com/docs 의 해시
┌─URLHash('htt⋯m/docs', 1)─┐
│ 13167253331440520598 │
└──────────────────────────┘
```
## cityHash64
도입된 버전: v1.1.0
64비트 [CityHash](https://github.com/google/cityhash) 해시 값을 생성합니다.
빠른 비암호화 해시 함수입니다.
문자열 매개변수에는 CityHash 알고리즘을 사용하고, 다른 데이터 타입의 매개변수에는 구현별 빠른 비암호화 해시 함수를 사용합니다.
이 함수는 최종 결과를 얻기 위해 CityHash combinator를 사용합니다.
Google은 CityHash가 ClickHouse에 추가된 후 CityHash 알고리즘을 변경했습니다.
다시 말해, ClickHouse의 cityHash64와 Google의 원본 CityHash는 이제 서로 다른 결과를 생성합니다.
ClickHouse의 cityHash64는 CityHash v1.0.2에 해당합니다.
계산된 해시 값은 인수 타입이 다르더라도 입력값이 같으면 동일할 수 있습니다.
예를 들어 크기가 다른 정수 타입, 동일한 데이터를 가진 이름 있는 `Tuple`과 이름 없는 `Tuple`, 그리고 동일한 데이터를 가진 `Map`과 이에 대응하는 `Array(Tuple(key, value))` 타입에 이런 현상이 발생할 수 있습니다.
**구문**
```sql theme={null}
cityHash64(arg1[, arg2, ...])
```
**인수**
* `arg1[, arg2, ...]` — 해시를 계산할 입력 인수입니다. 개수는 가변적입니다. [`Any`](/ko/reference/data-types)
**반환 값**
입력 인수에 대해 계산된 해시를 반환합니다. [`UInt64`](/ko/reference/data-types/int-uint)
**예시**
**호출 예시**
```sql title=Query theme={null}
SELECT cityHash64(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS CityHash, toTypeName(CityHash) AS type;
```
```response title=Response theme={null}
┌─────────────CityHash─┬─type───┐
│ 12072650598913549138 │ UInt64 │
└──────────────────────┴────────┘
```
**행 순서까지 정확히 반영한 전체 테이블의 체크섬 계산**
```sql title=Query theme={null}
CREATE TABLE users (
id UInt32,
name String,
age UInt8,
city String
)
ENGINE = MergeTree
ORDER BY tuple();
INSERT INTO users VALUES
(1, 'Alice', 25, 'New York'),
(2, 'Bob', 30, 'London'),
(3, 'Charlie', 35, 'Tokyo');
SELECT groupBitXor(cityHash64(*)) FROM users;
```
```response title=Response theme={null}
┌─groupBitXor(⋯age, city))─┐
│ 11639977218258521182 │
└──────────────────────────┘
```
## farmFingerprint64
도입 버전: v20.12.0
`Fingerprint64` 메서드를 사용해 64비트 [FarmHash](https://github.com/google/farmhash) 값을 생성합니다.
더 안정적이고 이식성 있는 값이 필요하다면 [`farmHash64`](#farmHash64)보다 `farmFingerprint64`를 사용하는 것이 좋습니다.
계산된 해시 값은 인수 타입이 서로 달라도 동일한 입력 값에 대해 같을 수 있습니다.
예를 들어 크기가 다른 정수 타입, 동일한 데이터를 가진 이름 있는 `Tuple`과 이름 없는 `Tuple`, 동일한 데이터를 가진 `Map`과 이에 대응하는 `Array(Tuple(key, value))` 타입이 여기에 해당합니다.
**구문**
```sql theme={null}
farmFingerprint64(arg1[, arg2, ...])
```
**인수**
* `arg1[, arg2, ...]` — 해시를 계산할 가변 개수의 입력 인수입니다. [`Any`](/ko/reference/data-types)
**반환 값**
입력 인수의 계산된 해시 값을 반환합니다. [`UInt64`](/ko/reference/data-types/int-uint)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT farmFingerprint64(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS FarmFingerprint, toTypeName(FarmFingerprint) AS type;
```
```response title=Response theme={null}
┌─────FarmFingerprint─┬─type───┐
│ 5752020380710916328 │ UInt64 │
└─────────────────────┴────────┘
```
## farmHash64
도입 버전: v1.1.0
`Hash64` 메서드를 사용해 64비트 [FarmHash](https://github.com/google/farmhash)를 생성합니다.
안정적이고 이식성 있는 값을 위해서는 [`farmFingerprint64`](#farmFingerprint64)를 사용하는 것이 좋습니다.
계산된 해시 값은 인수 타입이 서로 달라도 입력 값이 같으면 동일할 수 있습니다.
예를 들면 크기가 다른 정수 타입, 동일한 데이터를 가진 이름 있는 `Tuple`과 이름 없는 `Tuple`, 그리고 동일한 데이터를 가진 `Map`과 이에 대응하는 `Array(Tuple(key, value))` 타입이 여기에 해당합니다.
**구문**
```sql theme={null}
farmHash64(arg1[, arg2, ...])
```
**인수**
* `arg1[, arg2, ...]` — 해시를 계산할 입력 인수를 가변 개수로 받습니다. [`Any`](/ko/reference/data-types)
**반환 값**
입력 인수의 해시 값을 반환합니다. [`UInt64`](/ko/reference/data-types/int-uint)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT farmHash64(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS FarmHash, toTypeName(FarmHash) AS type;
```
```response title=Response theme={null}
┌─────────────FarmHash─┬─type───┐
│ 18125596431186471178 │ UInt64 │
└──────────────────────┴────────┘
```
## gccMurmurHash
도입 버전: v20.1.0
[GCC](https://github.com/gcc-mirror/gcc/blob/41d6b10e96a1de98e90a7c0378437c3255814b16/libstdc%2B%2B-v3/include/bits/functional_hash.h#L191)에서 사용하는 것과 동일한 seed를 사용해 입력 값의 64비트 [MurmurHash2](https://github.com/aappleby/smhasher) 해시를 계산합니다.
Clang build와 GCC build 간에 이식성이 있습니다.
**구문**
```sql theme={null}
gccMurmurHash(arg1[, arg2, ...])
```
**인수**
* `arg1[, arg2, ...]` — 해시를 계산할 가변 개수의 인수입니다. [`Any`](/ko/reference/data-types)
**반환 값**
입력 인수의 해시 값을 반환합니다. [`UInt64`](/ko/reference/data-types/int-uint)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT
gccMurmurHash(1, 2, 3) AS res1,
gccMurmurHash(('a', [1, 2, 3], 4, (4, ['foo', 'bar'], 1, (1, 2)))) AS res2
```
```response title=Response theme={null}
┌─────────────────res1─┬────────────────res2─┐
│ 12384823029245979431 │ 1188926775431157506 │
└──────────────────────┴─────────────────────┘
```
## halfMD5
도입 버전: v1.1.0
모든 입력
매개변수를 문자열로 [해석하여](/ko/reference/functions/regular-functions/type-conversion-functions#reinterpretAsString) 각 매개변수의 MD5 해시 값을 계산합니다. 그런 다음 이 해시들을 결합한 뒤, 결과 문자열의 해시에서 처음 8바이트를 가져와
빅 엔디언 바이트 순서의 [UInt64](/ko/reference/data-types/int-uint)로 해석합니다. 이 함수는
비교적 느립니다(프로세서 코어당 초당 500만 개의 짧은 문자열).
대신 [`sipHash64`](#sipHash64) 함수를 사용하는 것이 좋습니다.
이 함수는 가변 개수의 입력 매개변수를 받습니다.
인수는 지원되는 모든 데이터 타입이 될 수 있습니다.
일부 데이터 타입에서는 인수의 타입이 서로 달라도 값이 같으면 계산된 해시 값이 같을 수 있습니다(크기가 다른 정수, 동일한 데이터를 가진 기명 Tuple과 비기명 Tuple, 동일한 데이터를 가진 Map과 이에 대응하는 Array(Tuple(key, value)) 타입).
**구문**
```sql theme={null}
halfMD5(arg1[, arg2, ..., argN])
```
**인수**
* `arg1[, arg2, ..., argN]` — 해시를 계산할 가변 개수의 인수입니다. [`Any`](/ko/reference/data-types)
**반환 값**
주어진 입력 인수에 대해 계산된 half MD5 해시를 big-endian 바이트 순서의 `UInt64`로 반환합니다. [`UInt64`](/ko/reference/data-types/int-uint)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT HEX(halfMD5('abc', 'cde', 'fgh'));
```
```response title=Response theme={null}
┌─hex(halfMD5('abc', 'cde', 'fgh'))─┐
│ 2C9506B7374CFAF4 │
└───────────────────────────────────┘
```
## hiveHash
도입 버전: v20.1.0
문자열에서 "HiveHash"를 계산합니다.
이는 부호 비트를 0으로 설정한 [`JavaHash`](#javaHash)와 동일합니다.
이 함수는 3.0 이전 버전의 [Apache Hive](https://en.wikipedia.org/wiki/Apache_Hive)에서 사용됩니다.
이 해시 함수는 성능이 좋지 않습니다.
이 알고리즘이 이미 다른 시스템에서 사용되고 있어 동일한 결과를 계산해야 할 때만 사용하십시오.
**구문**
```sql theme={null}
hiveHash(arg)
```
**인수**
* `arg` — 해시할 입력 문자열입니다. [`String`](/ko/reference/data-types/string)
**반환 값**
입력 문자열의 계산된 "hive hash"를 반환합니다. [`Int32`](/ko/reference/data-types/int-uint)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT hiveHash('Hello, world!');
```
```response title=Response theme={null}
┌─hiveHash('Hello, world!')─┐
│ 267439093 │
└───────────────────────────┘
```
## icebergHash
도입된 버전: v25.5.0
Iceberg [해싱 변환](https://iceberg.apache.org/spec/#appendix-b-32-bit-hash-requirements)의 로직을 구현합니다.
**구문**
```sql theme={null}
icebergHash(value)
```
**인수**
* `value` — 해시를 계산할 원본 값입니다. [`Integer`](/ko/reference/data-types/int-uint), [`Bool`](/ko/reference/data-types/boolean), [`Decimal`](/ko/reference/data-types/decimal), [`Float*`](/ko/reference/data-types/float), [`String`](/ko/reference/data-types/string), [`FixedString`](/ko/reference/data-types/fixedstring), [`UUID`](/ko/reference/data-types/uuid), [`Date`](/ko/reference/data-types/date), [`Time`](/ko/reference/data-types/time) 또는 [`DateTime`](/ko/reference/data-types/datetime)입니다.
**반환 값**
시드가 0인 32비트 Murmur3 해시(x86 변형)를 반환합니다. [`Int32`](/ko/reference/data-types/int-uint)
**예시**
**예시**
```sql title=Query theme={null}
SELECT icebergHash(1.0 :: Float32)
```
```response title=Response theme={null}
-142385009
```
## intHash32
도입 버전: v1.1.0
정수의 32비트 해시를 계산합니다.
이 해시 함수는 비교적 빠르지만, 암호학적 해시 함수는 아닙니다.
**구문**
```sql theme={null}
intHash32(arg)
```
**인수**
* `arg` — 해시할 정수입니다. [`(U)Int*`](/ko/reference/data-types/int-uint)
**반환 값**
입력 정수의 32비트 해시 코드를 반환합니다. [`UInt32`](/ko/reference/data-types/int-uint)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT intHash32(42);
```
```response title=Response theme={null}
┌─intHash32(42)─┐
│ 1228623923 │
└───────────────┘
```
## intHash64
도입 버전: v1.1.0
정수의 64비트 해시를 계산합니다.
이 해시 함수는 비교적 빠르며([`intHash32`](#intHash32)보다도 더 빠름), 암호학적 해시 함수는 아닙니다.
**구문**
```sql theme={null}
intHash64(int)
```
**인수**
* `int` — 해시할 정숫값. [`(U)Int*`](/ko/reference/data-types/int-uint)
**반환 값**
64비트 해시값입니다. [`UInt64`](/ko/reference/data-types/int-uint)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT intHash64(42);
```
```response title=Response theme={null}
┌────────intHash64(42)─┐
│ 11490350930367293593 │
└──────────────────────┘
```
## javaHash
도입 버전: v20.1.0
다음 값에 대한 JavaHash를 계산합니다:
* [문자열](http://hg.openjdk.java.net/jdk8u/jdk8u/jdk/file/478a4add975b/src/share/classes/java/lang/String.java#l1452),
* [Byte](https://hg.openjdk.java.net/jdk8u/jdk8u/jdk/file/478a4add975b/src/share/classes/java/lang/Byte.java#l405),
* [Short](https://hg.openjdk.java.net/jdk8u/jdk8u/jdk/file/478a4add975b/src/share/classes/java/lang/Short.java#l410),
* [Integer](https://hg.openjdk.java.net/jdk8u/jdk8u/jdk/file/478a4add975b/src/share/classes/java/lang/Integer.java#l959),
* [Long](https://hg.openjdk.java.net/jdk8u/jdk8u/jdk/file/478a4add975b/src/share/classes/java/lang/Long.java#l1060).
이 해시 함수는 성능이 좋지 않습니다.
이 알고리즘이 이미 다른 시스템에서 사용 중이고 동일한 결과를 계산해야 할 때에만 사용하십시오.
Java는 부호 있는 정수의 해시 계산만 지원합니다.
따라서 부호 없는 정수의 해시를 계산하려면 적절한 부호 있는 ClickHouse 타입으로 캐스팅해야 합니다.
**구문**
```sql theme={null}
javaHash(arg)
```
**인수**
* `arg` — 해시를 계산할 입력 값입니다. [`Any`](/ko/reference/data-types)
**반환 값**
`arg`의 해시 계산 결과를 반환합니다. [`Int32`](/ko/reference/data-types/int-uint)
**예시**
**사용 예시 1**
```sql title=Query theme={null}
SELECT javaHash(toInt32(123));
```
```response title=Response theme={null}
┌─javaHash(toInt32(123))─┐
│ 123 │
└────────────────────────┘
```
**사용 예시 2**
```sql title=Query theme={null}
SELECT javaHash('Hello, world!');
```
```response title=Response theme={null}
┌─javaHash('Hello, world!')─┐
│ -1880044555 │
└───────────────────────────┘
```
## javaHashUTF16LE
도입 버전: v20.1.0
UTF-16LE로 인코딩된 문자열을 나타내는 바이트가 포함되어 있다고 가정하고, 문자열로부터 [JavaHash](http://hg.openjdk.java.net/jdk8u/jdk8u/jdk/file/478a4add975b/src/share/classes/java/lang/String.java#l1452)를 계산합니다.
**구문**
```sql theme={null}
javaHashUTF16LE(arg)
```
**인수**
* `arg` — UTF-16LE로 인코딩된 문자열입니다. [`String`](/ko/reference/data-types/string)
**반환 값**
UTF-16LE로 인코딩된 문자열의 해시값을 반환합니다. [`Int32`](/ko/reference/data-types/int-uint)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT javaHashUTF16LE(convertCharset('test', 'utf-8', 'utf-16le'));
```
```response title=Response theme={null}
┌─javaHashUTF16LE(convertCharset('test', 'utf-8', 'utf-16le'))─┐
│ 3556498 │
└──────────────────────────────────────────────────────────────┘
```
## jumpConsistentHash
도입 버전: v1.1.0
정수의 [jump consistent hash](https://arxiv.org/pdf/1406.2294.pdf)를 계산합니다.
**구문**
```sql theme={null}
jumpConsistentHash(key, buckets)
```
**인수**
* `key` — 입력 키입니다. [`UInt64`](/ko/reference/data-types/int-uint)
* `buckets` — 버킷의 수입니다. [`Int32`](/ko/reference/data-types/int-uint)
**반환 값**
계산된 해시 값을 반환합니다. [`Int32`](/ko/reference/data-types/int-uint)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT jumpConsistentHash(256, 4)
```
```response title=Response theme={null}
┌─jumpConsistentHash(256, 4)─┐
│ 3 │
└────────────────────────────┘
```
## kafkaMurmurHash
도입 버전: v23.4.0
[Kafka](https://github.com/apache/kafka/blob/461c5cfe056db0951d9b74f5adc45973670404d7/clients/src/main/java/org/apache/kafka/common/utils/Utils.java#L482)에서 사용하는 것과 동일한 seed를 사용하고, [Default Partitioner](https://github.com/apache/kafka/blob/139f7709bd3f5926901a21e55043388728ccca78/clients/src/main/java/org/apache/kafka/clients/producer/internals/BuiltInPartitioner.java#L328)와의 호환성을 위해 최상위 비트를 제외한 입력값의 32비트 [MurmurHash2](https://github.com/aappleby/smhasher) hash를 계산합니다.
**구문**
```sql theme={null}
kafkaMurmurHash(arg1[, arg2, ...])
```
**인수**
* `arg1[, arg2, ...]` — 해시를 계산할 가변 개수의 인수입니다. [`Any`](/ko/reference/data-types)
**반환 값**
입력 인수의 해시 값을 반환합니다. [`UInt32`](/ko/reference/data-types/int-uint)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT
kafkaMurmurHash('foobar') AS res1,
kafkaMurmurHash(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS res2
```
```response title=Response theme={null}
┌───────res1─┬─────res2─┐
│ 1357151166 │ 85479775 │
└────────────┴──────────┘
```
## keccak256
도입 버전: v25.4.0
주어진 문자열의 Keccak-256 암호학적 해시를 계산합니다.
이 해시 함수는 블록체인 애플리케이션, 특히 Ethereum에서 널리 사용됩니다.
**구문**
```sql theme={null}
keccak256(message)
```
**인수**
* `message` — 해시할 입력 문자열. [`String`](/ko/reference/data-types/string)
**반환 값**
입력 문자열의 32바이트 Keccak-256 해시를 고정 길이 문자열로 반환합니다. [`FixedString(32)`](/ko/reference/data-types/fixedstring)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT hex(keccak256('hello'))
```
```response title=Response theme={null}
┌─hex(keccak256('hello'))──────────────────────────────────────────┐
│ 1C8AFF950685C2ED4BC3174F3472287B56D9517B9C948127319A09A7A36DEAC8 │
└──────────────────────────────────────────────────────────────────┘
```
## kostikConsistentHash
도입 버전: v22.6.0
Konstantin 'Kostik' Oblakov가 개발한 시간 및 공간 복잡도가 O(1)인 consistent hash 알고리즘입니다.
`n <= 32768`인 경우에만 효율적입니다.
**구문**
```sql theme={null}
kostikConsistentHash(input, n)
```
**별칭**: `yandexConsistentHash`
**인수**
* `input` — 정수형 키입니다. [`UInt64`](/ko/reference/data-types/int-uint)
* `n` — 버킷 수입니다. [`UInt16`](/ko/reference/data-types/int-uint)
**반환 값**
계산된 해시 값을 반환합니다. [`UInt16`](/ko/reference/data-types/int-uint)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT kostikConsistentHash(16045690984833335023, 2);
```
```response title=Response theme={null}
┌─kostikConsistentHash(16045690984833335023, 2)─┐
│ 1 │
└───────────────────────────────────────────────┘
```
## metroHash64
도입 버전: v1.1.0
64비트 [MetroHash](http://www.jandrewrogers.com/2015/05/27/metrohash/) 해시 값을 생성합니다.
계산된 해시 값은 인수 타입이 서로 달라도 입력값이 같으면 동일할 수 있습니다.
예를 들어 크기가 서로 다른 정수 타입, 동일한 데이터를 가진 이름 있는 `Tuple`과 이름 없는 `Tuple`, 그리고 동일한 데이터를 가진 `Map`과 이에 대응하는 `Array(Tuple(key, value))` 타입이 이에 해당합니다.
**구문**
```sql theme={null}
metroHash64(arg1[, arg2, ...])
```
**인수**
* `arg1[, arg2, ...]` — 해시를 계산할 입력 인수입니다. 개수는 가변적입니다. [`Any`](/ko/reference/data-types)
**반환 값**
입력 인수에 대해 계산된 해시를 반환합니다. [`UInt64`](/ko/reference/data-types/int-uint)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT metroHash64(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS MetroHash, toTypeName(MetroHash) AS type;
```
```response title=Response theme={null}
┌────────────MetroHash─┬─type───┐
│ 14235658766382344533 │ UInt64 │
└──────────────────────┴────────┘
```
## murmurHash2\_32
도입 버전: v18.5.0
입력 값의 [MurmurHash2](https://github.com/aappleby/smhasher) 해시를 계산합니다.
계산된 해시 값은 인수 타입이 다르더라도 동일한 입력 값에 대해 같을 수 있습니다.
예를 들어 크기가 다른 정수 타입, 동일한 데이터를 가진 이름 있는 `Tuple`과 이름 없는 `Tuple`, 그리고 동일한 데이터를 가진 `Map`과 이에 대응하는 `Array(Tuple(key, value))` 타입이 여기에 해당합니다.
**구문**
```sql theme={null}
murmurHash2_32(arg1[, arg2, ...])
```
**인수**
* `arg1[, arg2, ...]` — 해시를 계산할 입력 인수입니다. 개수는 가변적입니다. [`Any`](/ko/reference/data-types)
**반환 값**
입력 인수에 대해 계산된 해시 값을 반환합니다. [`UInt32`](/ko/reference/data-types/int-uint)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT murmurHash2_32(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS MurmurHash2, toTypeName(MurmurHash2) AS type;
```
```response title=Response theme={null}
┌─MurmurHash2─┬─type───┐
│ 3681770635 │ UInt32 │
└─────────────┴────────┘
```
## murmurHash2\_64
도입 버전: v18.10.0
입력 값의 [MurmurHash2](https://github.com/aappleby/smhasher) 해시를 계산합니다.
서로 다른 인수 타입에서 동일한 입력 값에 대해 계산된 해시 값이 같을 수 있습니다.
예를 들어 크기가 다른 정수 타입, 동일한 데이터를 가진 이름 있는 `Tuple`과 이름 없는 `Tuple`, 그리고 동일한 데이터를 가진 `Map`과 이에 대응하는 `Array(Tuple(key, value))` 타입에서 이런 일이 발생할 수 있습니다.
**구문**
```sql theme={null}
murmurHash2_64(arg1[, arg2, ...])
```
**인수**
* `arg1[, arg2, ...]` — 해시를 계산할 가변 개수의 입력 인수입니다. [`Any`](/ko/reference/data-types)
**반환 값**
입력 인수의 계산된 해시를 반환합니다. [`UInt64`](/ko/reference/data-types/int-uint)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT murmurHash2_64(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS MurmurHash2, toTypeName(MurmurHash2) AS type;
```
```response title=Response theme={null}
┌──────────MurmurHash2─┬─type───┐
│ 11832096901709403633 │ UInt64 │
└──────────────────────┴────────┘
```
## murmurHash3\_128
도입 버전: v18.10.0
입력값의 128비트 [MurmurHash3](https://github.com/aappleby/smhasher) 해시를 계산합니다.
**구문**
```sql theme={null}
murmurHash3_128(arg1[, arg2, ...])
```
**인수**
* `arg1[, arg2, ...]` — 해시를 계산할 입력 인수입니다. 개수는 가변적입니다. [`Any`](/ko/reference/data-types)
**반환 값**
입력 인수에 대해 계산된 128비트 `MurmurHash3` 해시 값을 반환합니다. [`FixedString(16)`](/ko/reference/data-types/fixedstring)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT hex(murmurHash3_128('foo', 'foo', 'foo'));
```
```response title=Response theme={null}
┌─hex(murmurHash3_128('foo', 'foo', 'foo'))─┐
│ F8F7AD9B6CD4CF117A71E277E2EC2931 │
└───────────────────────────────────────────┘
```
## murmurHash3\_32
도입 버전: v18.10.0
[MurmurHash3](https://github.com/aappleby/smhasher) 해시 값을 생성합니다.
계산된 해시 값은 인수 타입이 서로 다르더라도 입력 값이 같으면 동일할 수 있습니다.
이는 예를 들어 크기가 다른 정수 타입, 동일한 데이터를 가진 이름 있는 `Tuple`과 이름 없는 `Tuple`, 동일한 데이터를 가진 `Map`과 그에 대응하는 `Array(Tuple(key, value))` 타입에 해당합니다.
**구문**
```sql theme={null}
murmurHash3_32(arg1[, arg2, ...])
```
**인수**
* `arg1[, arg2, ...]` — 해시를 계산할 입력 인수입니다. 개수는 가변적입니다. [`Any`](/ko/reference/data-types)
**반환 값**
입력 인수의 해시 값을 반환합니다. [`UInt32`](/ko/reference/data-types/int-uint)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT murmurHash3_32(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS MurmurHash3, toTypeName(MurmurHash3) AS type;
```
```response title=Response theme={null}
┌─MurmurHash3─┬─type───┐
│ 2152717 │ UInt32 │
└─────────────┴────────┘
```
## murmurHash3\_64
도입 버전: v18.10.0
입력값의 [MurmurHash3](https://github.com/aappleby/smhasher) 해시를 계산합니다.
계산된 해시 값은 인수 타입이 서로 달라도 입력값이 같으면 동일할 수 있습니다.
예를 들어 크기가 다른 정수 타입, 동일한 데이터를 가진 이름 있는 `Tuple`과 이름 없는 `Tuple`, 동일한 데이터를 가진 `Map`과 이에 대응하는 `Array(Tuple(key, value))` 타입이 이에 해당합니다.
**구문**
```sql theme={null}
murmurHash3_64(arg1[, arg2, ...])
```
**인수**
* `arg1[, arg2, ...]` — 해시를 계산할 가변 개수의 입력 인수입니다. [`Any`](/ko/reference/data-types)
**반환 값**
입력 인수의 해시 값을 반환합니다. [`UInt64`](/ko/reference/data-types/int-uint)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT murmurHash3_64(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS MurmurHash3, toTypeName(MurmurHash3) AS type;
```
```response title=Response theme={null}
┌──────────MurmurHash3─┬─type───┐
│ 11832096901709403633 │ UInt64 │
└──────────────────────┴────────┘
```
## ngramMinHash
도입 버전: v21.1.0
ASCII 문자열을 `ngramsize`개 기호의 n-그램으로 나누고, 각 n-그램의 해시 값을 계산한 다음 이 해시들로 이루어진 튜플을 반환합니다.
최소 해시값 계산에는 `hashnum`개의 최소 해시를 사용하고, 최대 해시값 계산에는 `hashnum`개의 최대 해시를 사용합니다.
대소문자를 구분합니다.
[`tupleHammingDistance`](/ko/reference/functions/regular-functions/tuple-functions#tupleHammingDistance)를 사용해 준중복 문자열을 감지하는 데 활용할 수 있습니다.
두 문자열에 대해 반환된 해시가 모두 같으면 두 문자열은 동일합니다.
**구문**
```sql theme={null}
ngramMinHash(string[, ngramsize, hashnum])
```
**인수**
* `string` — 해시를 계산할 문자열입니다. [`String`](/ko/reference/data-types/string)
* `ngramsize` — 선택 사항입니다. n-그램의 크기이며, `1`부터 `25`까지의 값을 사용할 수 있습니다. 기본값은 `3`입니다. [`UInt8`](/ko/reference/data-types/int-uint)
* `hashnum` — 선택 사항입니다. 결과 계산에 사용되는 최소 해시와 최대 해시의 개수이며, `1`부터 `25`까지의 값을 사용할 수 있습니다. 기본값은 `6`입니다. [`UInt8`](/ko/reference/data-types/int-uint)
**반환 값**
최소 해시와 최대 해시, 두 개의 해시를 담은 튜플을 반환합니다. [`Tuple`](/ko/reference/data-types/tuple)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT ngramMinHash('ClickHouse') AS Tuple;
```
```response title=Response theme={null}
┌─Tuple──────────────────────────────────────┐
│ (18333312859352735453,9054248444481805918) │
└────────────────────────────────────────────┘
```
## ngramMinHashArg
도입된 버전: v21.1.0
ASCII 문자열을 `ngramsize`개의 기호로 이루어진 n-그램으로 분할하고, 동일한 입력에 대해 [`ngramMinHash`](#ngramMinHash) 함수로 계산된 최소 및 최대 해시 값을 갖는 n-그램을 반환합니다.
이 함수는 대소문자를 구분합니다.
**구문**
```sql theme={null}
ngramMinHashArg(string[, ngramsize, hashnum])
```
**인수**
* `string` — 해시를 계산할 문자열입니다. [`String`](/ko/reference/data-types/string)
* `ngramsize` — 선택 사항입니다. n-그램의 크기이며, `1`부터 `25`까지의 숫자를 사용할 수 있습니다. 기본값은 `3`입니다. [`UInt8`](/ko/reference/data-types/int-uint)
* `hashnum` — 선택 사항입니다. 결과 계산에 사용하는 최소 및 최대 해시의 개수이며, `1`부터 `25`까지의 숫자를 사용할 수 있습니다. 기본값은 `6`입니다. [`UInt8`](/ko/reference/data-types/int-uint)
**반환 값**
각각 `hashnum`개의 n-그램을 포함하는 두 개의 튜플로 구성된 튜플을 반환합니다. [`Tuple(String)`](/ko/reference/data-types/tuple)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT ngramMinHashArg('ClickHouse') AS Tuple;
```
```response title=Response theme={null}
┌─Tuple─────────────────────────────────────────────────────────────────────────┐
│ (('ous','ick','lic','Hou','kHo','use'),('Hou','lic','ick','ous','ckH','Cli')) │
└───────────────────────────────────────────────────────────────────────────────┘
```
## ngramMinHashArgCaseInsensitive
도입 버전: v21.1.0
ASCII 문자열을 `ngramsize`개의 기호로 이루어진 n-그램으로 분할하고, 동일한 입력에 대해 [`ngramMinHashCaseInsensitive`](#ngramMinHashCaseInsensitive) 함수로 계산한 최소 및 최대 해시 값을 갖는 n-그램을 반환합니다.
대소문자를 구분하지 않습니다.
**구문**
```sql theme={null}
ngramMinHashArgCaseInsensitive(string[, ngramsize, hashnum])
```
**인수**
* `string` — 해시를 계산할 문자열입니다. [`String`](/ko/reference/data-types/string)
* `ngramsize` — 선택 사항입니다. n-그램의 크기이며, `1`부터 `25`까지의 값을 사용할 수 있습니다. 기본값은 `3`입니다. [`UInt8`](/ko/reference/data-types/int-uint)
* `hashnum` — 선택 사항입니다. 결과 계산에 사용되는 최소 해시와 최대 해시의 개수이며, `1`부터 `25`까지의 값을 사용할 수 있습니다. 기본값은 `6`입니다. [`UInt8`](/ko/reference/data-types/int-uint)
**반환 값**
각각 `hashnum`개의 n-그램을 포함하는 두 개의 튜플로 구성된 튜플을 반환합니다. [`Tuple(Tuple(String))`](/ko/reference/data-types/tuple)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT ngramMinHashArgCaseInsensitive('ClickHouse') AS Tuple;
```
```response title=Response theme={null}
┌─Tuple─────────────────────────────────────────────────────────────────────────┐
│ (('ous','ick','lic','kHo','use','Cli'),('kHo','lic','ick','ous','ckH','Hou')) │
└───────────────────────────────────────────────────────────────────────────────┘
```
## ngramMinHashArgCaseInsensitiveUTF8
도입 버전: v21.1.0
UTF-8 문자열을 `ngramsize`개 기호의 n-그램으로 분할한 다음, 동일한 입력에 대해 ngramMinHashCaseInsensitiveUTF8 함수로 계산한 최소 및 최대 해시에 해당하는 n-그램을 반환합니다.
대소문자를 구분하지 않습니다.
**구문**
```sql theme={null}
ngramMinHashArgCaseInsensitiveUTF8(string[, ngramsize, hashnum])
```
**인수**
* `string` — 해시를 계산할 문자열입니다. [`String`](/ko/reference/data-types/string)
* `ngramsize` — 선택 사항입니다. n-그램의 크기이며, `1`부터 `25` 사이의 값입니다. 기본값은 `3`입니다. [`UInt8`](/ko/reference/data-types/int-uint)
* `hashnum` — 선택 사항입니다. 결과 계산에 사용하는 최소 해시와 최대 해시의 개수이며, `1`부터 `25` 사이의 값입니다. 기본값은 `6`입니다. [`UInt8`](/ko/reference/data-types/int-uint)
**반환 값**
각각 `hashnum`개의 n-그램을 포함하는 두 개의 튜플로 구성된 튜플을 반환합니다. [`Tuple(Tuple(String))`](/ko/reference/data-types/tuple)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT ngramMinHashArgCaseInsensitiveUTF8('ClickHouse') AS Tuple;
```
```response title=Response theme={null}
┌─Tuple─────────────────────────────────────────────────────────────────────────┐
│ (('ckH','ous','ick','lic','kHo','use'),('kHo','lic','ick','ous','ckH','Hou')) │
└───────────────────────────────────────────────────────────────────────────────┘
```
## ngramMinHashArgUTF8
도입 버전: v21.1.0
UTF-8 문자열을 `ngramsize`개 기호로 이루어진 n-그램으로 분할한 뒤, 동일한 입력에 대해 `ngramMinHashUTF8` 함수가 계산한 최소 및 최대 해시를 갖는 n-그램을 반환합니다.
이 함수는 대소문자를 구분합니다.
**구문**
```sql theme={null}
ngramMinHashArgUTF8(string[, ngramsize, hashnum])
```
**인수**
* `string` — 해시를 계산할 문자열입니다. [`String`](/ko/reference/data-types/string)
* `ngramsize` — 선택 사항입니다. n-그램의 크기이며, `1`부터 `25`까지의 값입니다. 기본값은 `3`입니다. [`UInt8`](/ko/reference/data-types/int-uint)
* `hashnum` — 선택 사항입니다. 결과 계산에 사용되는 최소 및 최대 해시의 개수이며, `1`부터 `25`까지의 값입니다. 기본값은 `6`입니다. [`UInt8`](/ko/reference/data-types/int-uint)
**반환 값**
각각 `hashnum`개의 n-그램을 담은 두 개의 튜플로 구성된 튜플을 반환합니다. [`Tuple(Tuple(String))`](/ko/reference/data-types/tuple)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT ngramMinHashArgUTF8('ClickHouse') AS Tuple;
```
```response title=Response theme={null}
┌─Tuple─────────────────────────────────────────────────────────────────────────┐
│ (('ous','ick','lic','Hou','kHo','use'),('kHo','Hou','lic','ick','ous','ckH')) │
└───────────────────────────────────────────────────────────────────────────────┘
```
## ngramMinHashCaseInsensitive
도입 버전: v21.1.0
ASCII 문자열을 `ngramsize`개 기호로 이루어진 n-그램으로 분할하고, 각 n-그램의 해시 값을 계산한 뒤 이 해시들로 구성된 튜플을 반환합니다.
최소 해시는 `hashnum`개의 최소 해시를 사용해 계산하고, 최대 해시는 `hashnum`개의 최대 해시를 사용해 계산합니다.
대소문자를 구분하지 않습니다.
[`tupleHammingDistance`](/ko/reference/functions/regular-functions/tuple-functions#tupleHammingDistance)를 사용해 준중복 문자열을 감지하는 데 활용할 수 있습니다.
두 문자열에 대해 반환된 해시가 모두 같으면 해당 문자열은 동일합니다.
**구문**
```sql theme={null}
ngramMinHashCaseInsensitive(string[, ngramsize, hashnum])
```
**인수**
* `string` — String. [String](/ko/reference/data-types/string). - `ngramsize` — n-그램의 크기입니다. 선택 사항입니다. 가능한 값: `1`에서 `25` 사이의 임의의 숫자입니다. 기본값은 `3`입니다. [UInt8](/ko/reference/data-types/int-uint). - `hashnum` — 결과 계산에 사용되는 최소 및 최대 해시의 개수입니다. 선택 사항입니다. 가능한 값: `1`에서 `25` 사이의 임의의 숫자입니다. 기본값은 `6`입니다. [UInt8](/ko/reference/data-types/int-uint).
**반환 값**
최소 해시와 최대 해시, 두 개의 해시를 포함하는 Tuple입니다. [Tuple](/ko/reference/data-types/tuple)([UInt64](/ko/reference/data-types/int-uint), [UInt64](/ko/reference/data-types/int-uint)). [`Tuple`](/ko/reference/data-types/tuple)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT ngramMinHashCaseInsensitive('ClickHouse') AS Tuple;
```
```response title=Response theme={null}
┌─Tuple──────────────────────────────────────┐
│ (2106263556442004574,13203602793651726206) │
└────────────────────────────────────────────┘
```
## ngramMinHashCaseInsensitiveUTF8
도입 버전: v21.1.0
UTF-8 문자열을 `ngramsize`개 기호로 이루어진 n-그램으로 분할하고, 각 n-그램의 해시 값을 계산한 뒤 이러한 해시로 구성된 튜플을 반환합니다.
최소 해시를 계산할 때는 `hashnum`개의 최소 해시를 사용하고, 최대 해시를 계산할 때는 `hashnum`개의 최대 해시를 사용합니다.
대소문자를 구분하지 않습니다.
[`tupleHammingDistance`](/ko/reference/functions/regular-functions/tuple-functions#tupleHammingDistance)를 사용해 준중복 문자열을 감지할 수 있습니다.
두 문자열에 대해 반환된 해시가 모두 같으면 해당 문자열은 동일합니다.
**구문**
```sql theme={null}
ngramMinHashCaseInsensitiveUTF8(string [, ngramsize, hashnum])
```
**인수**
* `string` — 해시를 계산할 문자열입니다. [`String`](/ko/reference/data-types/string)
* `ngramsize` — 선택 사항입니다. n-그램의 크기이며, `1`부터 `25`까지의 값입니다. 기본값은 `3`입니다. [`UInt8`](/ko/reference/data-types/int-uint)
* `hashnum` — 선택 사항입니다. 결과 계산에 사용되는 최소 해시와 최대 해시의 개수이며, `1`부터 `25`까지의 값입니다. 기본값은 `6`입니다. [`UInt8`](/ko/reference/data-types/int-uint)
**반환 값**
최소 해시와 최대 해시, 두 개의 해시를 담은 튜플을 반환합니다. [`Tuple`](/ko/reference/data-types/tuple)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT ngramMinHashCaseInsensitiveUTF8('ClickHouse') AS Tuple;
```
```response title=Response theme={null}
┌─Tuple───────────────────────────────────────┐
│ (12493625717655877135,13203602793651726206) │
└─────────────────────────────────────────────┘
```
## ngramMinHashUTF8
도입 버전: v21.1.0
UTF-8 문자열을 `ngramsize`개 기호로 이루어진 n-그램으로 분할한 뒤, 각 n-그램의 해시 값을 계산하여 이 해시들로 구성된 튜플을 반환합니다.
최소 해시는 `hashnum`개의 최소 해시를 사용해 계산하고, 최대 해시는 `hashnum`개의 최대 해시를 사용해 계산합니다.
대소문자를 구분합니다.
[`tupleHammingDistance`](/ko/reference/functions/regular-functions/tuple-functions#tupleHammingDistance)를 사용해 준중복 문자열을 탐지하는 데 사용할 수 있습니다.
두 문자열에서 반환된 해시가 서로 같으면 해당 문자열은 동일합니다.
**구문**
```sql theme={null}
ngramMinHashUTF8(string[, ngramsize, hashnum])
```
**인수**
* `string` — 해시를 계산할 문자열입니다. [`String`](/ko/reference/data-types/string)
* `ngramsize` — 선택 사항입니다. n-그램의 크기이며, `1`부터 `25` 사이의 값입니다. 기본값은 `3`입니다. [`UInt8`](/ko/reference/data-types/int-uint)
* `hashnum` — 선택 사항입니다. 결과 계산에 사용되는 최소 해시와 최대 해시의 개수이며, `1`부터 `25` 사이의 값입니다. 기본값은 `6`입니다. [`UInt8`](/ko/reference/data-types/int-uint)
**반환 값**
최소 해시와 최대 해시, 두 개의 해시로 이루어진 튜플을 반환합니다. [`Tuple`](/ko/reference/data-types/tuple)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT ngramMinHashUTF8('ClickHouse') AS Tuple;
```
```response title=Response theme={null}
┌─Tuple──────────────────────────────────────┐
│ (18333312859352735453,6742163577938632877) │
└────────────────────────────────────────────┘
```
## ngramSimHash
도입 버전: v21.1.0
ASCII 문자열을 `ngramsize`개 기호로 이루어진 n-그램으로 나누고, n-그램 `simhash`를 반환합니다.
[`bitHammingDistance`](/ko/reference/functions/regular-functions/bit-functions#bitHammingDistance)와 함께 사용하면 준중복 문자열을 탐지할 수 있습니다.
두 문자열에 대해 계산된 `simhash` 값의 [해밍 거리](https://en.wikipedia.org/wiki/Hamming_distance)가 작을수록, 두 문자열이 동일할 가능성이 높습니다.
**구문**
```sql theme={null}
ngramSimHash(string[, ngramsize])
```
**인수**
* `string` — 대소문자를 구분하는 `simhash`를 계산할 문자열입니다. [`String`](/ko/reference/data-types/string)
* `ngramsize` — 선택 사항입니다. n-그램의 크기이며, `1`부터 `25`까지의 값입니다. 기본값은 `3`입니다. [`UInt8`](/ko/reference/data-types/int-uint)
**반환 값**
입력 문자열에 대해 계산된 해시값을 반환합니다. [`UInt64`](/ko/reference/data-types/int-uint)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT ngramSimHash('ClickHouse') AS Hash;
```
```response title=Response theme={null}
┌───────Hash─┐
│ 1627567969 │
└────────────┘
```
## ngramSimHashCaseInsensitive
도입 버전: v21.1.0
ASCII 문자열을 `ngramsize`개 기호로 이루어진 n-그램으로 분할하고, n-그램 `simhash`를 반환합니다.
대소문자를 구분하지 않습니다.
[`bitHammingDistance`](/ko/reference/functions/regular-functions/bit-functions#bitHammingDistance)를 사용해 준중복 문자열을 탐지하는 데 사용할 수 있습니다.
두 문자열에서 계산된 `simhash` 간의 [해밍 거리](https://en.wikipedia.org/wiki/Hamming_distance)가 작을수록 두 문자열이 동일할 가능성이 높습니다.
**구문**
```sql theme={null}
ngramSimHashCaseInsensitive(string[, ngramsize])
```
**인수**
* `string` — 대소문자를 구분하지 않는 `simhash`를 계산할 문자열입니다. [`String`](/ko/reference/data-types/string)
* `ngramsize` — 선택 사항입니다. n-그램의 크기이며, `1`부터 `25`까지의 숫자를 지정할 수 있습니다. 기본값은 `3`입니다. [`UInt8`](/ko/reference/data-types/int-uint)
**반환 값**
해시 값입니다. [UInt64](/ko/reference/data-types/int-uint). [`UInt64`](/ko/reference/data-types/int-uint)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT ngramSimHashCaseInsensitive('ClickHouse') AS Hash;
```
```response title=Response theme={null}
┌──────Hash─┐
│ 562180645 │
└───────────┘
```
## ngramSimHashCaseInsensitiveUTF8
도입 버전: v21.1.0
UTF-8 문자열을 `ngramsize`개 기호의 n-그램으로 분할하고, n-그램 `simhash`를 반환합니다.
대소문자를 구분하지 않습니다.
[bitHammingDistance](/ko/reference/functions/regular-functions/bit-functions#bitHammingDistance)를 사용해 준중복 문자열을 탐지하는 데 활용할 수 있습니다. 두 문자열에서 계산된 `simhashes`의 [해밍 거리](https://en.wikipedia.org/wiki/Hamming_distance)가 작을수록, 두 문자열이 동일할 가능성이 높아집니다.
**구문**
```sql theme={null}
ngramSimHashCaseInsensitiveUTF8(string[, ngramsize])
```
**인수**
* `string` — 해시를 계산할 문자열입니다. [`String`](/ko/reference/data-types/string)
* `ngramsize` — 선택 사항입니다. n-그램의 크기이며, `1`부터 `25` 사이의 값을 지정할 수 있습니다. 기본값은 `3`입니다. [`UInt8`](/ko/reference/data-types/int-uint)
**반환 값**
계산된 해시 값을 반환합니다. [`UInt64`](/ko/reference/data-types/int-uint)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT ngramSimHashCaseInsensitiveUTF8('ClickHouse') AS Hash;
```
```response title=Response theme={null}
┌───────Hash─┐
│ 1636742693 │
└────────────┘
```
## ngramSimHashUTF8
도입된 버전: v21.1.0
UTF-8로 인코딩된 문자열을 `ngramsize`개의 기호로 이루어진 n-그램으로 분할한 뒤 n-그램 `simhash`를 반환합니다.
대소문자를 구분합니다.
[`bitHammingDistance`](/ko/reference/functions/regular-functions/bit-functions#bitHammingDistance)와 함께 사용하여 준중복 문자열을 탐지할 수 있습니다.
두 문자열의 `simhashes`를 계산했을 때 [해밍 거리](https://en.wikipedia.org/wiki/Hamming_distance)가 작을수록 두 문자열이 동일할 가능성이 높습니다.
**구문**
```sql theme={null}
ngramSimHashUTF8(string[, ngramsize])
```
**인수**
* `string` — 해시를 계산할 문자열입니다. [`String`](/ko/reference/data-types/string)
* `ngramsize` — 선택 사항입니다. n-그램의 크기이며, `1`부터 `25`까지의 값이 가능합니다. 기본값은 `3`입니다. [`UInt8`](/ko/reference/data-types/int-uint)
**반환 값**
계산된 해시 값을 반환합니다. [`UInt64`](/ko/reference/data-types/int-uint)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT ngramSimHashUTF8('ClickHouse') AS Hash;
```
```response title=Response theme={null}
┌───────Hash─┐
│ 1628157797 │
└────────────┘
```
## sipHash128
도입 버전: v1.1.0
[`sipHash64`](#sipHash64)와 유사하지만 128비트 해시 값을 생성합니다. 즉, 최종 xor-folding 단계가 128비트까지 수행됩니다.
**새 프로젝트에서는 sipHash128Reference를 사용하세요**
이 128비트 변형은 참조 구현과 다르며 더 취약합니다.
이 버전은 작성 당시 SipHash에 공식적인 128비트 확장이 없었기 때문에 존재합니다.
새 프로젝트에서는 [`sipHash128Reference`](#sipHash128Reference) 사용을 권장합니다.
**구문**
```sql theme={null}
sipHash128(arg1[, arg2, ...])
```
**인수**
* `arg1[, arg2, ...]` — 해시를 계산할 입력 인수입니다. 개수는 가변적입니다. [`Any`](/ko/reference/data-types)
**반환 값**
128비트 `SipHash` 해시 값을 반환합니다. [`FixedString(16)`](/ko/reference/data-types/fixedstring)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT hex(sipHash128('foo', '\x01', 3));
```
```response title=Response theme={null}
┌─hex(sipHash128('foo', '', 3))────┐
│ 9DE516A64A414D4B1B609415E4523F24 │
└──────────────────────────────────┘
```
## sipHash128Keyed
도입 버전: v23.2.0
고정 키를 사용하는 대신 명시적으로 키 인수를 받는다는 점만 제외하면 [`sipHash128`](#sipHash128)과 동일합니다.
**새 프로젝트에서는 sipHash128ReferenceKeyed를 사용하세요**
이 128비트 변형은 참조 구현과 다르며 더 취약합니다.
이 버전이 존재하는 이유는 작성 당시 SipHash에 대한 공식적인 128비트 확장이 없었기 때문입니다.
새 프로젝트에서는 [`sipHash128ReferenceKeyed`](#sipHash128ReferenceKeyed)를 사용하는 것이 좋습니다.
**구문**
```sql theme={null}
sipHash128Keyed((k0, k1), [arg1, arg2, ...])
```
**인수**
* `(k0, k1)` — 키를 나타내는 두 개의 UInt64 값으로 구성된 튜플입니다. [`Tuple(UInt64, UInt64)`](/ko/reference/data-types/tuple)
* `arg1[, arg2, ...]` — 해시를 계산할 가변 개수의 입력 인수입니다. [`Any`](/ko/reference/data-types)
**반환 값**
유형이 [FixedString(16)](/ko/reference/data-types/fixedstring)인 128비트 `SipHash` 해시 값입니다. [`FixedString(16)`](/ko/reference/data-types/fixedstring)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT hex(sipHash128Keyed((506097522914230528, 1084818905618843912),'foo', '\x01', 3));
```
```response title=Response theme={null}
┌─hex(sipHash128Keyed((506097522914230528, 1084818905618843912), 'foo', '', 3))─┐
│ B8467F65C8B4CFD9A5F8BD733917D9BF │
└───────────────────────────────────────────────────────────────────────────────┘
```
## sipHash128Reference
도입 버전: v23.2.0
[`sipHash128`](/ko/reference/functions/regular-functions/hash-functions#sipHash128)와 유사하지만, SipHash 원저자의 128비트 알고리즘을 구현합니다.
**구문**
```sql theme={null}
sipHash128Reference(arg1[, arg2, ...])
```
**인수**
* `arg1[, arg2, ...]` — 해시를 계산할 가변 개수의 입력 인수입니다. [`Any`](/ko/reference/data-types)
**반환 값**
입력 인수의 128비트 `SipHash` 해시 값을 반환합니다. [`FixedString(16)`](/ko/reference/data-types/fixedstring)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT hex(sipHash128Reference('foo', '', 3));
```
```response title=Response theme={null}
┌─hex(sipHash128Reference('foo', '', 3))─┐
│ 4D1BE1A22D7F5933C0873E1698426260 │
└────────────────────────────────────────┘
```
## sipHash128ReferenceKeyed
도입 버전: v23.2.0
고정 키를 사용하는 대신 명시적으로 지정한 키 인수를 추가로 받는다는 점만 제외하면 [`sipHash128Reference`](#sipHash128Reference)와 동일합니다.
**구문**
```sql theme={null}
sipHash128ReferenceKeyed((k0, k1), arg1[, arg2, ...])
```
**인수**
* `(k0, k1)` — 키를 나타내는 두 값으로 이루어진 Tuple [`Tuple(UInt64, UInt64)`](/ko/reference/data-types/tuple)
* `arg1[, arg2, ...]` — 해시를 계산할 입력 인수로, 개수는 가변적입니다. [`Any`](/ko/reference/data-types)
**반환 값**
입력 인수에 대해 계산된 128비트 `SipHash` 해시 값을 반환합니다. [`FixedString(16)`](/ko/reference/data-types/fixedstring)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT hex(sipHash128Reference('foo', '', 3));
```
```response title=Response theme={null}
┌─hex(sipHash128Reference('foo', '', 3))─┐
│ 4D1BE1A22D7F5933C0873E1698426260 │
└────────────────────────────────────────┘
```
## sipHash64
도입 버전: v1.1.0
64비트 [SipHash](https://en.wikipedia.org/wiki/SipHash) 해시 값을 생성합니다.
이 함수는 암호학적 해시 함수입니다. [`MD5`](#MD5) 해시 함수보다 적어도 3배 빠릅니다.
이 함수는 모든 입력 매개변수를 문자열로 [해석](/ko/reference/functions/regular-functions/type-conversion-functions#reinterpretAsString)한 뒤, 각각의 해시 값을 계산합니다.
그런 다음 다음 알고리즘을 사용해 해시를 결합합니다.
1. 첫 번째 해시 값과 두 번째 해시 값을 배열로 연결한 다음 해시합니다.
2. 앞서 계산한 해시 값과 세 번째 입력 매개변수의 해시를 같은 방식으로 해시합니다.
3. 이 계산을 원래 입력의 나머지 모든 해시 값에 대해 반복합니다.
계산된 해시 값은 인수 타입이 서로 달라도 입력 값이 같으면 동일할 수 있습니다.
예를 들어 크기가 서로 다른 정수 타입, 동일한 데이터를 가진 이름 있는 `Tuple`과 이름 없는 `Tuple`, 동일한 데이터를 가진 `Map`과 이에 대응하는 `Array(Tuple(key, value))` 타입이 이에 해당합니다.
**구문**
```sql theme={null}
sipHash64(arg1[, arg2, ...])
```
**인수**
* `arg1[, arg2, ...]` — 가변 개수의 입력 인수입니다. [`Any`](/ko/reference/data-types)
**반환 값**
입력 인수의 해시 값을 계산하여 반환합니다. [`UInt64`](/ko/reference/data-types/int-uint)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT sipHash64(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS SipHash, toTypeName(SipHash) AS type;
```
```response title=Response theme={null}
┌──────────────SipHash─┬─type───┐
│ 11400366955626497465 │ UInt64 │
└──────────────────────┴────────┘
```
## sipHash64Keyed
도입 버전: v23.2.0
[`sipHash64`](#sipHash64)와 비슷하지만, 고정 키를 사용하는 대신 명시적으로 지정한 키 인수를 받습니다.
**구문**
```sql theme={null}
sipHash64Keyed((k0, k1), arg1[,arg2, ...])
```
**인수**
* `(k0, k1)` — 키를 나타내는 두 값의 튜플입니다. [`Tuple(UInt64, UInt64)`](/ko/reference/data-types/tuple)
* `arg1[,arg2, ...]` — 개수가 가변적인 입력 인수입니다. [`Any`](/ko/reference/data-types)
**반환 값**
입력값으로 계산된 해시를 반환합니다. [`UInt64`](/ko/reference/data-types/int-uint)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT sipHash64Keyed((506097522914230528, 1084818905618843912), array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS SipHash, toTypeName(SipHash) AS type;
```
```response title=Response theme={null}
┌─────────────SipHash─┬─type───┐
│ 8017656310194184311 │ UInt64 │
└─────────────────────┴────────┘
```
## wordShingleMinHash
도입 버전: v21.1.0
ASCII 문자열을 `shinglesize`개 단어로 이루어진 부분(shingle)으로 나누고, 각 단어 shingle의 해시 값을 계산한 다음 해당 해시로 구성된 튜플을 반환합니다.
`hashnum`개의 최소 해시를 사용해 최소 해시를 계산하고, `hashnum`개의 최대 해시를 사용해 최대 해시를 계산합니다.
대소문자를 구분합니다.
[`tupleHammingDistance`](/ko/reference/functions/regular-functions/tuple-functions#tupleHammingDistance)를 사용해 준중복 문자열을 감지하는 데 활용할 수 있습니다.
두 문자열에서 반환된 해시가 서로 같으면 두 문자열은 동일합니다.
**구문**
```sql theme={null}
wordShingleMinHash(string[, shinglesize, hashnum])
```
**인수**
* `string` — 해시를 계산할 문자열입니다. [`String`](/ko/reference/data-types/string)
* `shinglesize` — 선택 사항입니다. 단어 shingle의 크기이며, `1`부터 `25`까지의 값을 사용할 수 있습니다. 기본값은 `3`입니다. [`UInt8`](/ko/reference/data-types/int-uint)
* `hashnum` — 선택 사항입니다. 결과 계산에 사용하는 최소 및 최대 해시의 개수이며, `1`부터 `25`까지의 값을 사용할 수 있습니다. 기본값은 `6`입니다. [`UInt8`](/ko/reference/data-types/int-uint)
**반환 값**
최솟값과 최댓값, 두 개의 해시를 포함하는 Tuple을 반환합니다. [`Tuple(UInt64, UInt64)`](/ko/reference/data-types/tuple)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT wordShingleMinHash('ClickHouse® is a column-oriented database management system (DBMS) for online analytical processing of queries (OLAP).') AS Tuple;
```
```response title=Response theme={null}
┌─Tuple──────────────────────────────────────┐
│ (16452112859864147620,5844417301642981317) │
└────────────────────────────────────────────┘
```
## wordShingleMinHashArg
도입 버전: v1.1.0
ASCII 문자열을 각각 `shinglesize`개의 단어로 이루어진 부분(shingle)으로 나눈 뒤, 동일한 입력에 wordShingleMinHash 함수를 적용해 계산한 최소 및 최대 단어 hash를 갖는 shingle을 반환합니다.
대소문자를 구분합니다.
**구문**
```sql theme={null}
wordShingleMinHashArg(string[, shinglesize, hashnum])
```
**인수**
* `string` — 해시를 계산할 문자열입니다. [`String`](/ko/reference/data-types/string)
* `shinglesize` — 선택 사항입니다. 단어 shingle의 크기이며, `1`부터 `25`까지의 값을 지정할 수 있습니다. 기본값은 `3`입니다. [`UInt8`](/ko/reference/data-types/int-uint)
* `hashnum` — 선택 사항입니다. 결과 계산에 사용되는 최소 및 최대 해시의 개수이며, `1`부터 `25`까지의 값을 지정할 수 있습니다. 기본값은 `6`입니다. [`UInt8`](/ko/reference/data-types/int-uint)
**반환 값**
각각 `hashnum`개의 단어 shingle을 포함하는 2개의 튜플로 구성된 튜플을 반환합니다. [`Tuple(Tuple(String))`](/ko/reference/data-types/tuple)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT wordShingleMinHashArg('ClickHouse® is a column-oriented database management system (DBMS) for online analytical processing of queries (OLAP).', 1, 3) AS Tuple;
```
```response title=Response theme={null}
┌─Tuple─────────────────────────────────────────────────────────────────┐
│ (('OLAP','database','analytical'),('online','oriented','processing')) │
└───────────────────────────────────────────────────────────────────────┘
```
## wordShingleMinHashArgCaseInsensitive
도입 버전: v21.1.0
ASCII 문자열을 각각 `shinglesize`개 단어로 구성된 부분(단어 shingle)으로 나누고, 동일한 입력에 대해 [`wordShingleMinHashCaseInsensitive`](#wordShingleMinHashCaseInsensitive) 함수로 계산한 단어 해시의 최솟값과 최댓값에 해당하는 단어 shingle을 반환합니다.
대소문자를 구분하지 않습니다.
**구문**
```sql theme={null}
wordShingleMinHashArgCaseInsensitive(string[, shinglesize, hashnum])
```
**인수**
* `string` — 해시를 계산할 문자열입니다. [`String`](/ko/reference/data-types/string)
* `shinglesize` — 선택 사항입니다. 단어 shingle의 크기이며, `1`부터 `25`까지의 값입니다. 기본값은 `3`입니다. [`UInt8`](/ko/reference/data-types/int-uint)
* `hashnum` — 선택 사항입니다. 결과 계산에 사용되는 최소 및 최대 해시의 개수이며, `1`부터 `25`까지의 값입니다. 기본값은 `6`입니다. [`UInt8`](/ko/reference/data-types/int-uint)
**반환 값**
각각 `hashnum`개의 단어 shingle을 포함하는 두 개의 튜플을 담은 튜플을 반환합니다. [`Tuple(Tuple(String))`](/ko/reference/data-types/tuple)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT wordShingleMinHashArgCaseInsensitive('ClickHouse® is a column-oriented database management system (DBMS) for online analytical processing of queries (OLAP).', 1, 3) AS Tuple;
```
```response title=Response theme={null}
┌─Tuple──────────────────────────────────────────────────────────────────┐
│ (('queries','database','analytical'),('oriented','processing','DBMS')) │
└────────────────────────────────────────────────────────────────────────┘
```
## wordShingleMinHashArgCaseInsensitiveUTF8
도입 버전: v21.1.0
UTF-8 문자열을 각각 `shinglesize`개의 단어로 이루어진 조각(shingle)으로 분할하고, 동일한 입력에 대해 [`wordShingleMinHashCaseInsensitiveUTF8`](#wordShingleMinHashCaseInsensitiveUTF8) 함수로 계산한 최소 및 최대 단어 해시를 갖는 shingle을 반환합니다.
대소문자를 구분하지 않습니다.
**구문**
```sql theme={null}
wordShingleMinHashArgCaseInsensitiveUTF8(string[, shinglesize, hashnum])
```
**인수**
* `string` — 해시를 계산할 대상 `String`입니다. [`String`](/ko/reference/data-types/string)
* `shinglesize` — 선택 사항입니다. 단어 shingle의 크기이며, `1`부터 `25`까지의 값을 사용할 수 있습니다. 기본값은 `3`입니다. [`UInt8`](/ko/reference/data-types/int-uint)
* `hashnum` — 선택 사항입니다. 결과 계산에 사용되는 최소 및 최대 해시의 개수이며, `1`부터 `25`까지의 값을 사용할 수 있습니다. 기본값은 `6`입니다. [`UInt8`](/ko/reference/data-types/int-uint)
**반환 값**
각각 `hashnum`개의 단어 shingle을 포함하는 2개의 튜플로 구성된 튜플을 반환합니다. [`Tuple(Tuple(String))`](/ko/reference/data-types/tuple)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT wordShingleMinHashArgCaseInsensitiveUTF8('ClickHouse® is a column-oriented database management system (DBMS) for online analytical processing of queries (OLAP).', 1, 3) AS Tuple;
```
```response title=Response theme={null}
┌─Tuple──────────────────────────────────────────────────────────────────┐
│ (('queries','database','analytical'),('oriented','processing','DBMS')) │
└────────────────────────────────────────────────────────────────────────┘
```
## wordShingleMinHashArgUTF8
도입 버전: v21.1.0
UTF-8 문자열을 각각 `shinglesize`개의 단어로 구성된 부분(shingle)으로 분할한 뒤, 동일한 입력에 대해 [`wordShingleMinHashUTF8`](#wordShingleMinHashUTF8) 함수로 계산한 단어 해시의 최솟값과 최댓값에 해당하는 shingle을 반환합니다.
이 함수는 대소문자를 구분합니다.
**구문**
```sql theme={null}
wordShingleMinHashArgUTF8(string[, shinglesize, hashnum])
```
**인수**
* `string` — 해시를 계산할 대상 문자열입니다. [`String`](/ko/reference/data-types/string)
* `shinglesize` — 선택 사항입니다. 단어 shingle의 크기이며, `1`부터 `25` 사이의 값을 사용할 수 있습니다. 기본값은 `3`입니다. [`UInt8`](/ko/reference/data-types/int-uint)
* `hashnum` — 선택 사항입니다. 결과 계산에 사용되는 최소 및 최대 해시의 개수이며, `1`부터 `25` 사이의 값을 사용할 수 있습니다. 기본값은 `6`입니다. [`UInt8`](/ko/reference/data-types/int-uint)
**반환 값**
각각 `hashnum`개의 단어 shingle을 포함하는 두 개의 튜플로 구성된 튜플을 반환합니다. [`Tuple(Tuple(String))`](/ko/reference/data-types/tuple)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT wordShingleMinHashArgUTF8('ClickHouse® is a column-oriented database management system (DBMS) for online analytical processing of queries (OLAP).', 1, 3) AS Tuple;
```
```response title=Response theme={null}
┌─Tuple─────────────────────────────────────────────────────────────────┐
│ (('OLAP','database','analytical'),('online','oriented','processing')) │
└───────────────────────────────────────────────────────────────────────┘
```
## wordShingleMinHashCaseInsensitive
도입 버전: v21.1.0
ASCII 문자열을 `shinglesize`개 단어로 이루어진 부분(shingle)으로 나누고, 각 단어 shingle의 hash value를 계산한 뒤, 이 hash들을 포함하는 튜플을 반환합니다.
최소 hash는 `hashnum`개의 최소 hash를 사용해 계산하고, 최대 hash는 `hashnum`개의 최대 hash를 사용해 계산합니다.
대소문자를 구분하지 않습니다.
[`tupleHammingDistance`](/ko/reference/functions/regular-functions/tuple-functions#tupleHammingDistance)와 함께 사용하면 준중복 문자열을 감지할 수 있습니다.
두 문자열에 대해 반환된 hash가 모두 같으면, 해당 문자열은 동일합니다.
**구문**
```sql theme={null}
wordShingleMinHashCaseInsensitive(string[, shinglesize, hashnum])
```
**인수**
* `string` — 해시를 계산할 문자열입니다. [`String`](/ko/reference/data-types/string)
* `shinglesize` — 선택 사항입니다. 단어 shingle의 크기입니다. `1`부터 `25`까지의 값을 사용할 수 있습니다. 기본값은 `3`입니다. [`UInt8`](/ko/reference/data-types/int-uint)
* `hashnum` — 선택 사항입니다. 결과 계산에 사용되는 최소 해시와 최대 해시의 개수입니다. `1`부터 `25`까지의 값을 사용할 수 있습니다. 기본값은 `6`입니다. [`UInt8`](/ko/reference/data-types/int-uint)
**반환 값**
최소 해시와 최대 해시로 이루어진 Tuple을 반환합니다. [`Tuple(UInt64, UInt64)`](/ko/reference/data-types/tuple)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT wordShingleMinHashCaseInsensitive('ClickHouse® is a column-oriented database management system (DBMS) for online analytical processing of queries (OLAP).') AS Tuple;
```
```response title=Response theme={null}
┌─Tuple─────────────────────────────────────┐
│ (3065874883688416519,1634050779997673240) │
└───────────────────────────────────────────┘
```
## wordShingleMinHashCaseInsensitiveUTF8
도입 버전: v21.1.0
UTF-8 문자열을 `shinglesize`개 단어로 이루어진 부분(shingle)으로 나누고, 각 단어 shingle의 해시 값을 계산한 뒤, 이 해시들로 구성된 튜플을 반환합니다.
최소 해시는 `hashnum`개의 최소 해시를 사용해 계산하고, 최대 해시는 `hashnum`개의 최대 해시를 사용해 계산합니다.
대소문자를 구분하지 않습니다.
[`tupleHammingDistance`](/ko/reference/functions/regular-functions/tuple-functions#tupleHammingDistance)를 사용해 준중복 문자열을 탐지하는 데 사용할 수 있습니다.
두 문자열 모두에서 반환된 해시가 같으면 두 문자열은 동일합니다.
**구문**
```sql theme={null}
wordShingleMinHashCaseInsensitiveUTF8(string[, shinglesize, hashnum])
```
**인수**
* `string` — 해시를 계산할 문자열입니다. [`String`](/ko/reference/data-types/string)
* `shinglesize` — 선택 사항입니다. 단어 shingle의 크기이며, `1`부터 `25`까지의 값을 사용할 수 있습니다. 기본값은 `3`입니다. [`UInt8`](/ko/reference/data-types/int-uint)
* `hashnum` — 선택 사항입니다. 결과 계산에 사용되는 최소 해시와 최대 해시의 개수이며, `1`부터 `25`까지의 값을 사용할 수 있습니다. 기본값은 `6`입니다. [`UInt8`](/ko/reference/data-types/int-uint)
**반환 값**
최소 해시와 최대 해시로 이루어진 Tuple을 반환합니다. [`Tuple(UInt64, UInt64)`](/ko/reference/data-types/tuple)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT wordShingleMinHashCaseInsensitiveUTF8('ClickHouse® is a column-oriented database management system (DBMS) for online analytical processing of queries (OLAP).') AS Tuple;
```
```response title=Response theme={null}
┌─Tuple─────────────────────────────────────┐
│ (3065874883688416519,1634050779997673240) │
└───────────────────────────────────────────┘
```
## wordShingleMinHashUTF8
도입 버전: v21.1.0
UTF-8 문자열을 `shinglesize`개 단어로 이루어진 파트(shingle)로 나누고, 각 단어 shingle의 해시값을 계산한 다음 이 해시들로 구성된 튜플을 반환합니다.
최소 해시는 `hashnum`개의 최소 해시를 사용해 계산하고, 최대 해시는 `hashnum`개의 최대 해시를 사용해 계산합니다.
이 함수는 대소문자를 구분합니다.
[`tupleHammingDistance`](/ko/reference/functions/regular-functions/tuple-functions#tupleHammingDistance)와 함께 사용하면 준중복 문자열을 탐지할 수 있습니다.
두 문자열에서 반환된 해시가 모두 같으면, 해당 문자열은 동일합니다.
**구문**
```sql theme={null}
wordShingleMinHashUTF8(string[, shinglesize, hashnum])
```
**인수**
* `string` — 해시를 계산할 문자열입니다. [`String`](/ko/reference/data-types/string)
* `shinglesize` — 선택 사항입니다. 단어 shingle의 크기이며, `1`부터 `25`까지의 값을 사용할 수 있습니다. 기본값은 `3`입니다. [`UInt8`](/ko/reference/data-types/int-uint)
* `hashnum` — 선택 사항입니다. 결과 계산에 사용되는 최소 및 최대 해시의 개수이며, `1`부터 `25`까지의 값을 사용할 수 있습니다. 기본값은 `6`입니다. [`UInt8`](/ko/reference/data-types/int-uint)
**반환 값**
최솟값과 최댓값, 두 개의 해시로 구성된 튜플을 반환합니다. [`Tuple(UInt64, UInt64)`](/ko/reference/data-types/tuple)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT wordShingleMinHashUTF8('ClickHouse® is a column-oriented database management system (DBMS) for online analytical processing of queries (OLAP).') AS Tuple;
```
```response title=Response theme={null}
┌─Tuple──────────────────────────────────────┐
│ (16452112859864147620,5844417301642981317) │
└────────────────────────────────────────────┘
```
## wordShingleSimHash
도입 버전: v21.1.0
ASCII 문자열을 `shinglesize`개 단어씩 묶은 부분(shingle)으로 분할하고, 단어 shingle `simhash`를 반환합니다.
대소문자를 구분합니다.
[`bitHammingDistance`](/ko/reference/functions/regular-functions/bit-functions#bitHammingDistance)를 사용해 준중복 문자열을 탐지하는 데 사용할 수 있습니다.
두 문자열에서 계산된 `simhashes`의 [해밍 거리](https://en.wikipedia.org/wiki/Hamming_distance)가 작을수록 두 문자열이 동일할 가능성이 높습니다.
**구문**
```sql theme={null}
wordShingleSimHash(string[, shinglesize])
```
**인수**
* `string` — 해시를 계산할 대상 문자열입니다. [`String`](/ko/reference/data-types/string)
* `shinglesize` — 선택 사항입니다. 단어 shingle의 크기이며, `1`부터 `25`까지의 숫자입니다. 기본값은 `3`입니다. [`UInt8`](/ko/reference/data-types/int-uint)
**반환 값**
계산된 해시 값을 반환합니다. [`UInt64`](/ko/reference/data-types/int-uint)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT wordShingleSimHash('ClickHouse® is a column-oriented database management system (DBMS) for online analytical processing of queries (OLAP).') AS Hash;
```
```response title=Response theme={null}
┌───────Hash─┐
│ 2328277067 │
└────────────┘
```
## wordShingleSimHashCaseInsensitive
도입 버전: v21.1.0
ASCII 문자열을 `shinglesize`개 단어로 이루어진 부분(shingle)으로 나누고, 단어 shingle `simhash`를 반환합니다.
대소문자를 구분하지 않습니다.
[`bitHammingDistance`](/ko/reference/functions/regular-functions/bit-functions#bitHammingDistance)를 사용해 준중복 문자열을 탐지하는 데 사용할 수 있습니다.
두 문자열에서 계산된 `simhashes`의 [해밍 거리](https://en.wikipedia.org/wiki/Hamming_distance)가 작을수록, 두 문자열이 같을 가능성이 높습니다.
**구문**
```sql theme={null}
wordShingleSimHashCaseInsensitive(string[, shinglesize])
```
**인수**
* `string` — 해시를 계산할 문자열입니다. [`String`](/ko/reference/data-types/string)
* `shinglesize` — 선택 사항입니다. 단어 shingle의 크기이며, `1`부터 `25`까지의 숫자를 사용할 수 있습니다. 기본값은 `3`입니다. [`UInt8`](/ko/reference/data-types/int-uint)
**반환 값**
계산된 해시 값을 반환합니다. [`UInt64`](/ko/reference/data-types/int-uint)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT wordShingleSimHashCaseInsensitive('ClickHouse® is a column-oriented database management system (DBMS) for online analytical processing of queries (OLAP).') AS Hash;
```
```response title=Response theme={null}
┌───────Hash─┐
│ 2194812424 │
└────────────┘
```
## wordShingleSimHashCaseInsensitiveUTF8
도입 버전: v1.1.0
UTF-8로 인코딩된 문자열을 `shinglesize`개의 단어로 이루어진 파트(shingles)로 분할하고, 단어 shingle `simhash`를 반환합니다.
대소문자를 구분하지 않습니다.
[`bitHammingDistance`](/ko/reference/functions/regular-functions/bit-functions#bitHammingDistance)를 사용해 준중복 문자열을 탐지할 수 있습니다.
두 문자열에 대해 계산된 `simhashes`의 [해밍 거리](https://en.wikipedia.org/wiki/Hamming_distance)가 작을수록, 두 문자열이 동일할 가능성이 높습니다.
**구문**
```sql theme={null}
wordShingleSimHashCaseInsensitiveUTF8(string[, shinglesize])
```
**인수**
* `string` — 해시를 계산할 대상 `String`입니다. [`String`](/ko/reference/data-types/string)
* `shinglesize` — 선택 사항입니다. 단어 shingle의 크기이며, `1`부터 `25` 사이의 숫자여야 합니다. 기본값은 `3`입니다. [`UInt8`](/ko/reference/data-types/int-uint)
**반환 값**
계산된 해시 값을 반환합니다. [`UInt64`](/ko/reference/data-types/int-uint)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT wordShingleSimHashCaseInsensitiveUTF8('ClickHouse® is a column-oriented database management system (DBMS) for online analytical processing of queries (OLAP).') AS Hash;
```
```response title=Response theme={null}
┌───────Hash─┐
│ 2194812424 │
└────────────┘
```
## wordShingleSimHashUTF8
지원 버전: v21.1.0
UTF-8 문자열을 `shinglesize`개 단어로 이루어진 부분(shingle)으로 분할한 뒤, 단어 shingle `simhash`를 반환합니다.
이 함수는 대소문자를 구분합니다.
[`bitHammingDistance`](/ko/reference/functions/regular-functions/bit-functions#bitHammingDistance)를 사용해 준중복 문자열을 탐지할 수 있습니다.
두 문자열에서 계산된 `simhashes`의 [해밍 거리](https://en.wikipedia.org/wiki/Hamming_distance)가 작을수록, 두 문자열이 동일할 가능성이 높습니다.
**구문**
```sql theme={null}
wordShingleSimHashUTF8(string[, shinglesize])
```
**인수**
* `string` — 해시를 계산할 문자열입니다. [`String`](/ko/reference/data-types/string)
* `shinglesize` — 선택 사항입니다. 단어 shingle의 크기이며, `1`에서 `25` 사이의 값을 사용할 수 있습니다. 기본값은 `3`입니다. [`UInt8`](/ko/reference/data-types/int-uint)
**반환 값**
계산된 해시 값을 반환합니다. [`UInt64`](/ko/reference/data-types/int-uint)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT wordShingleSimHashUTF8('ClickHouse® is a column-oriented database management system (DBMS) for online analytical processing of queries (OLAP).') AS Hash;
```
```response title=Response theme={null}
┌───────Hash─┐
│ 2328277067 │
└────────────┘
```
## wyHash64
도입 버전: v22.7.0
64비트 [wyHash64](https://github.com/wangyi-fudan/wyhash) 해시 값을 계산합니다.
**구문**
```sql theme={null}
wyHash64(arg)
```
**인수**
* `arg` — 해시를 계산할 `String` 타입 인수입니다. [`String`](/ko/reference/data-types/string)
**반환 값**
계산된 64비트 해시 값을 반환합니다. [`UInt64`](/ko/reference/data-types/int-uint)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT wyHash64('ClickHouse') AS Hash;
```
```response title=Response theme={null}
12336419557878201794
```
## xxHash32
지원 버전: v20.1.0
문자열의 [xxHash](http://cyan4973.github.io/xxHash/)를 계산합니다.
64비트 버전은 [`xxHash64`](#xxHash64)를 참조하십시오.
**구문**
```sql theme={null}
xxHash32(arg)
```
**인수**
* `arg` — 해시를 계산할 입력 문자열입니다. [`String`](/ko/reference/data-types/string)
**반환 값**
입력 문자열의 32비트 해시값을 반환합니다. [`UInt32`](/ko/reference/data-types/int-uint)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT xxHash32('Hello, world!');
```
```response title=Response theme={null}
┌─xxHash32('Hello, world!')─┐
│ 834093149 │
└───────────────────────────┘
```
## xxHash64
도입된 버전: v20.1.0
문자열로부터 [xxHash](http://cyan4973.github.io/xxHash/)를 계산합니다.
32비트 버전은 [`xxHash32`](#xxHash32)를 참조하십시오.
**구문**
```sql theme={null}
xxHash64(arg)
```
**인수**
* `arg` — 해시할 입력 문자열입니다. [`String`](/ko/reference/data-types/string)
**반환 값**
입력 문자열의 64비트 해시 값을 반환합니다. [`UInt64`](/ko/reference/data-types/int-uint)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT xxHash64('Hello, world!');
```
```response title=Response theme={null}
┌─xxHash64('Hello, world!')─┐
│ 17691043854468224118 │
└───────────────────────────┘
```
## xxh3
도입 버전: v22.12.0
[XXH3](https://github.com/Cyan4973/xxHash) 64비트 해시 값을 계산합니다.
**구문**
```sql theme={null}
xxh3(expr)
```
**인수**
* `expr` — 임의의 데이터 타입의 표현식 목록입니다. [`Any`](/ko/reference/data-types)
**반환 값**
계산된 64비트 `xxh3` 해시 값을 반환합니다. [`UInt64`](/ko/reference/data-types/int-uint)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT xxh3('ClickHouse')
```
```response title=Response theme={null}
18009318874338624809
```
## xxh3\_128
도입 버전: v26.2.0
[XXH3](https://github.com/Cyan4973/xxHash) 128비트 해시 값을 계산합니다.
**구문**
```sql theme={null}
xxh3_128(expr)
```
**인수**
* `expr` — 임의의 데이터 타입을 갖는 표현식 목록입니다. [`Any`](/ko/reference/data-types)
**반환 값**
계산된 128비트 `xxh3` 해시 값을 반환합니다. [`UInt128`](/ko/reference/data-types/int-uint)
**예시**
**사용 예시**
```sql title=Query theme={null}
SELECT hex(xxh3_128('ClickHouse'))
```
```response title=Response theme={null}
3A038784C52804B4DBA43A038784C528
```