> ## Documentation Index > Fetch the complete documentation index at: https://private-7c7dfe99-mintlify-8a08bda2.mintlify.site/llms.txt > Use this file to discover all available pages before exploring further. > ハッシュ関数のドキュメント # ハッシュ関数 ハッシュ関数は、要素を決定論的な擬似ランダム順に並べ替えるために使用できます。 Simhash は、近い (類似した) argument に対して近いハッシュ値を返すハッシュ関数です。 ほとんどのハッシュ関数は、任意の型の引数を任意個受け取れます。 NULL のハッシュは NULL です。Nullable カラムの 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-2 と比べて約 2 倍の性能を示し、SHA-256 と同じ長さのハッシュを生成します。 BLAKE3 ハッシュを FixedString(32) 型のバイト配列として返します。 **構文** ```sql theme={null} BLAKE3(message) ``` **引数** * `message` — ハッシュ化する入力文字列。[`String`](/ja/reference/data-types/string) **戻り値** 入力文字列の BLAKE3 ハッシュを、32 バイトの固定長文字列として返します。[`FixedString(32)`](/ja/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`](/ja/reference/data-types/string) **戻り値** 指定された入力文字列の MD4 ハッシュを固定長文字列として返します。[`FixedString(16)`](/ja/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`](/ja/reference/data-types/string) **戻り値** 指定した入力文字列の MD5 ハッシュを固定長文字列として返します。[`FixedString(16)`](/ja/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`](/ja/reference/data-types/string) **戻り値** 指定された入力文字列の RIPEMD160 ハッシュを固定長文字列として返します。[`FixedString(20)`](/ja/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`](/ja/reference/data-types/string) **戻り値** 指定された入力文字列の SHA1 ハッシュを固定長文字列として返します。 [`FixedString(20)`](/ja/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`](/ja/reference/data-types/string) **戻り値** 指定された入力文字列の SHA224 ハッシュを固定長文字列として返します。[`FixedString(28)`](/ja/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`](/ja/reference/data-types/string) **戻り値** 指定した入力文字列の SHA256 ハッシュを固定長文字列として返します。[`FixedString(32)`](/ja/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`](/ja/reference/data-types/string) **戻り値** 指定した入力文字列の SHA384 ハッシュを固定長文字列として返します。[`FixedString(48)`](/ja/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`](/ja/reference/data-types/string) **戻り値** 指定された入力文字列の SHA512 ハッシュを固定長文字列で返します。 [`FixedString(64)`](/ja/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`](/ja/reference/data-types/string) **戻り値** 与えられた入力文字列の SHA512\_256 ハッシュを固定長文字列として返します。[`FixedString(32)`](/ja/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 から得た文字列に対して使用する、高速で十分な品質の非暗号学的ハッシュ関数です。 このハッシュ関数には 2 つのモードがあります。 | Mode | Description | | ----------------- | ------------------------------------------------------------------------------------------- | | `URLHash(url)` | 末尾に `/`、`?`、`#` のいずれかがある場合はそれを除き、その文字列からハッシュを計算します。 | | `URLHash(url, N)` | 末尾に `/`、`?`、`#` のいずれかがある場合はそれを除き、URL 階層の N レベルまでの文字列からハッシュを計算します。レベルは `URLHierarchy` と同じです。 | **構文** ```sql theme={null} URLHash(url[, N]) ``` **引数** * `url` — ハッシュ化するURL文字列。 [`String`](/ja/reference/data-types/string) * `N` — 任意。URL階層内のレベル。 [`(U)Int*`](/ja/reference/data-types/int-uint) **戻り値** `url` のハッシュ値を返します。 [`UInt64`](/ja/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 コンビネータを使用します。 Google は、CityHash が ClickHouse に追加された後でそのアルゴリズムを変更しました。 つまり、ClickHouse の cityHash64 と Google のオリジナルの CityHash は、現在では異なる結果を生成します。 ClickHouse の cityHash64 は CityHash v1.0.2 に対応しています。 計算されたハッシュ値は、引数の型が異なっていても、同じ入力値に対して同一になる場合があります。 これは、たとえばサイズの異なる整数型、同じデータを持つ名前付きおよび名前なしの `Tuple`、同じデータを持つ `Map` と、それに対応する `Array(Tuple(key, value))` 型に影響します。 **構文** ```sql theme={null} cityHash64(arg1[, arg2, ...]) ``` **引数** * `arg1[, arg2, ...]` — ハッシュを計算する対象となる、可変個の入力引数です。 [`Any`](/ja/reference/data-types) **戻り値** 入力引数から計算されたハッシュ値を返します。 [`UInt64`](/ja/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`、および同じデータを持つ `Map` と対応する `Array(Tuple(key, value))` 型に当てはまります。 **構文** ```sql theme={null} farmFingerprint64(arg1[, arg2, ...]) ``` **引数** * `arg1[, arg2, ...]` — ハッシュを計算するための入力引数。可変個を指定できます。[`Any`](/ja/reference/data-types) **戻り値** 入力引数から計算されたハッシュ値を返します。[`UInt64`](/ja/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`、同じデータを持つ `Map` と対応する `Array(Tuple(key, value))` 型に当てはまります。 **構文** ```sql theme={null} farmHash64(arg1[, arg2, ...]) ``` **引数** * `arg1[, arg2, ...]` — ハッシュの計算対象となる可変長の入力引数。[`Any`](/ja/reference/data-types) **戻り値** 入力引数から計算されたハッシュ値を返します。[`UInt64`](/ja/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)で使用されているものと同じシードを用いて、入力値の 64 ビット [MurmurHash2](https://github.com/aappleby/smhasher) ハッシュを計算します。 Clang と GCC のビルド間で移植性があります。 **構文** ```sql theme={null} gccMurmurHash(arg1[, arg2, ...]) ``` **引数** * `arg1[, arg2, ...]` — ハッシュを計算する対象となる可変個の引数。[`Any`](/ja/reference/data-types) **戻り値** 入力引数のハッシュ値を返します。[`UInt64`](/ja/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 すべての入力 パラメータを文字列として[解釈し](/ja/reference/functions/regular-functions/type-conversion-functions#reinterpretAsString)、それぞれの MD5 ハッシュ値を計算します。次に、それらのハッシュを結合し、得られた文字列のハッシュの先頭 8 バイトを取り、 それらをビッグエンディアンのバイト順で [UInt64](/ja/reference/data-types/int-uint) として解釈します。この関数は 比較的低速です (プロセッサコアあたり、1 秒間に 500 万件の短い文字列) 。 代わりに [`sipHash64`](#sipHash64) 関数の使用を検討してください。 この関数は可変個の入力パラメータを受け取ります。 引数には、サポートされている任意のデータ型を指定できます。 一部のデータ型では、引数の型が異なっていても、同じ値に対して計算されるハッシュ関数の値が同じになる場合があります (サイズの異なる整数、同じデータを持つ名前付きおよび名前なしの Tuple、同じデータを持つ Map と対応する Array(Tuple(key, value)) 型) 。 **構文** ```sql theme={null} halfMD5(arg1[, arg2, ..., argN]) ``` **引数** * `arg1[, arg2, ..., argN]` — ハッシュの計算対象となる可変個の引数。[`Any`](/ja/reference/data-types) **戻り値** 指定された入力パラメータから計算された half MD5 ハッシュを、ビッグエンディアンのバイト順の `UInt64` として返します。[`UInt64`](/ja/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`](/ja/reference/data-types/string) **戻り値** 入力文字列の計算済みの "hive hash" を返します。[`Int32`](/ja/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`](/ja/reference/data-types/int-uint) または [`Bool`](/ja/reference/data-types/boolean) または [`Decimal`](/ja/reference/data-types/decimal) または [`Float*`](/ja/reference/data-types/float) または [`String`](/ja/reference/data-types/string) または [`FixedString`](/ja/reference/data-types/fixedstring) または [`UUID`](/ja/reference/data-types/uuid) または [`Date`](/ja/reference/data-types/date) または [`Time`](/ja/reference/data-types/time) または [`DateTime`](/ja/reference/data-types/datetime) 型の、ハッシュ計算の対象となる値 **戻り値** 0 をシードとする 32 ビットの Murmur3 ハッシュ (x86 バリアント) を返します [`Int32`](/ja/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*`](/ja/reference/data-types/int-uint) **戻り値** 入力整数の32ビットのハッシュ値を返します。[`UInt32`](/ja/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*`](/ja/reference/data-types/int-uint) **戻り値** 64 ビットのハッシュ値。[`UInt64`](/ja/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 型に CAST する必要があります。 **構文** ```sql theme={null} javaHash(arg) ``` **引数** * `arg` — ハッシュ化する入力値。[`Any`](/ja/reference/data-types) **戻り値** `arg` のハッシュ値を返します [`Int32`](/ja/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`](/ja/reference/data-types/string) **戻り値** UTF-16LE でエンコードされた文字列のハッシュ値を返します。[`Int32`](/ja/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 整数の[ジャンプコンシステントハッシュ](https://arxiv.org/pdf/1406.2294.pdf)を計算します。 **構文** ```sql theme={null} jumpConsistentHash(key, buckets) ``` **引数** * `key` — 入力キー。 [`UInt64`](/ja/reference/data-types/int-uint) * `buckets` — バケット数。 [`Int32`](/ja/reference/data-types/int-uint) **戻り値** 算出されたハッシュ値を返します。 [`Int32`](/ja/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) ハッシュを計算します。 **構文** ```sql theme={null} kafkaMurmurHash(arg1[, arg2, ...]) ``` **引数** * `arg1[, arg2, ...]` — ハッシュを計算する対象となる可変個のパラメーター。[`Any`](/ja/reference/data-types) **戻り値** 入力引数から計算されたハッシュ値を返します。[`UInt32`](/ja/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`](/ja/reference/data-types/string) **戻り値** 入力文字列の Keccak-256 ハッシュを、32 バイト長の固定長文字列として返します。[`FixedString(32)`](/ja/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) の コンシステントハッシュ アルゴリズムです。 効率的に動作するのは `n <= 32768` の場合に限られます。 **構文** ```sql theme={null} kostikConsistentHash(input, n) ``` **別名**: `yandexConsistentHash` **引数** * `input` — 整数のキー。[`UInt64`](/ja/reference/data-types/int-uint) * `n` — バケットの数。[`UInt16`](/ja/reference/data-types/int-uint) **戻り値** 算出されたハッシュ値を返します。[`UInt16`](/ja/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`、同じデータを持つ`Map`と対応する`Array(Tuple(key, value))`型で、このケースが発生することがあります。 **構文** ```sql theme={null} metroHash64(arg1[, arg2, ...]) ``` **引数** * `arg1[, arg2, ...]` — ハッシュ値を計算する対象となる、可変個の入力引数。 [`Any`](/ja/reference/data-types) **戻り値** 入力引数から計算されたハッシュ値を返します。 [`UInt64`](/ja/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`、同じデータを持つ `Map` と、それに対応する `Array(Tuple(key, value))` 型などに当てはまります。 **構文** ```sql theme={null} murmurHash2_32(arg1[, arg2, ...]) ``` **引数** * `arg1[, arg2, ...]` — ハッシュの計算対象となる入力引数。可変個指定できます。[`Any`](/ja/reference/data-types) **戻り値** 入力引数から計算されたハッシュ値を返します。[`UInt32`](/ja/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`、`Map` と、同じデータを持つ対応する `Array(Tuple(key, value))` 型でこのことが当てはまります。 **構文** ```sql theme={null} murmurHash2_64(arg1[, arg2, ...]) ``` **引数** * `arg1[, arg2, ...]` — ハッシュの計算対象となる、可変個の入力引数。[`Any`](/ja/reference/data-types) **戻り値** 入力引数から計算されたハッシュ値を返します。[`UInt64`](/ja/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`](/ja/reference/data-types) **戻り値** 入力引数から計算された 128 ビットの `MurmurHash3` ハッシュ値を返します。[`FixedString(16)`](/ja/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`、同じデータを持つ `Map` と、それに対応する `Array(Tuple(key, value))` 型に当てはまります。 **構文** ```sql theme={null} murmurHash3_32(arg1[, arg2, ...]) ``` **引数** * `arg1[, arg2, ...]` — ハッシュを計算する対象の入力引数。可変個指定できます。[`Any`](/ja/reference/data-types) **戻り値** 入力引数から計算されたハッシュ値を返します。[`UInt32`](/ja/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`、`Map` と同じデータを持つ対応する `Array(Tuple(key, value))` 型などに当てはまります。 **構文** ```sql theme={null} murmurHash3_64(arg1[, arg2, ...]) ``` **引数** * `arg1[, arg2, ...]` — ハッシュを計算する対象となる、可変個の入力引数。[`Any`](/ja/reference/data-types) **戻り値** 入力引数から計算されたハッシュ値を返します。[`UInt64`](/ja/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-gramに分割し、各N-gramのハッシュ値を計算して、それらのハッシュを含むTupleを返します。 `hashnum`個の最小ハッシュを使って最小ハッシュを計算し、`hashnum`個の最大ハッシュを使って最大ハッシュを計算します。 この関数は大文字と小文字を区別します。 [`tupleHammingDistance`](/ja/reference/functions/regular-functions/tuple-functions#tupleHammingDistance)と組み合わせることで、類似した文字列を検出できます。 2つの文字列で返されるハッシュがどちらも同じであれば、それらの文字列は同一です。 **構文** ```sql theme={null} ngramMinHash(string[, ngramsize, hashnum]) ``` **引数** * `string` — ハッシュを計算する文字列。[`String`](/ja/reference/data-types/string) * `ngramsize` — 任意。N-gram のサイズ。`1` から `25` までの任意の数値を指定します。デフォルト値は `3` です。[`UInt8`](/ja/reference/data-types/int-uint) * `hashnum` — 任意。結果の計算に使用する最小ハッシュと最大ハッシュの個数。`1` から `25` までの任意の数値を指定します。デフォルト値は `6` です。[`UInt8`](/ja/reference/data-types/int-uint) **戻り値** 最小ハッシュと最大ハッシュの 2 つのハッシュからなるタプルを返します。[`Tuple`](/ja/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-gram に分割し、同じ入力に対して [`ngramMinHash`](#ngramMinHash) 関数で計算されたハッシュ値が最小および最大の N-gram を返します。 大文字と小文字を区別します。 **構文** ```sql theme={null} ngramMinHashArg(string[, ngramsize, hashnum]) ``` **引数** * `string` — ハッシュを計算する対象の文字列です。[`String`](/ja/reference/data-types/string) * `ngramsize` — 任意。N-gram のサイズです。`1` から `25` までの任意の値を指定できます。デフォルト値は `3` です。[`UInt8`](/ja/reference/data-types/int-uint) * `hashnum` — 任意。結果の計算に使用する最小ハッシュ値と最大ハッシュ値の数です。`1` から `25` までの任意の値を指定できます。デフォルト値は `6` です。[`UInt8`](/ja/reference/data-types/int-uint) **戻り値** それぞれが `hashnum` 個の N-gram を含む 2 つのタプルからなるタプルを返します。[`Tuple(String)`](/ja/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-gramに分割し、同じ入力に対して[`ngramMinHashCaseInsensitive`](#ngramMinHashCaseInsensitive)関数で計算される、ハッシュ値が最小および最大のN-gramを返します。 大文字と小文字を区別しません。 **構文** ```sql theme={null} ngramMinHashArgCaseInsensitive(string[, ngramsize, hashnum]) ``` **引数** * `string` — ハッシュを計算する対象の文字列。[`String`](/ja/reference/data-types/string) * `ngramsize` — 省略可能。N-gram のサイズ。`1` から `25` までの任意の数値を指定します。デフォルト値は `3` です。[`UInt8`](/ja/reference/data-types/int-uint) * `hashnum` — 省略可能。結果の計算に使用する最小ハッシュ数および最大ハッシュ数。`1` から `25` までの任意の数値を指定します。デフォルト値は `6` です。[`UInt8`](/ja/reference/data-types/int-uint) **戻り値** それぞれ `hashnum` 個の N-gram を含む 2 つの タプル から構成される タプル を返します。[`Tuple(Tuple(String))`](/ja/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-gram に分割し、同じ入力に対して ngramMinHashCaseInsensitiveUTF8 関数で計算した、ハッシュ値が最小および最大の N-gram を返します。 大文字と小文字を区別しません。 **構文** ```sql theme={null} ngramMinHashArgCaseInsensitiveUTF8(string[, ngramsize, hashnum]) ``` **引数** * `string` — ハッシュを計算する対象の文字列。[`String`](/ja/reference/data-types/string) * `ngramsize` — 任意。N-gram のサイズです。`1` から `25` までの任意の整数を指定できます。デフォルト値は `3` です。[`UInt8`](/ja/reference/data-types/int-uint) * `hashnum` — 任意。結果の計算に使用する最小ハッシュおよび最大ハッシュの個数です。`1` から `25` までの任意の整数を指定できます。デフォルト値は `6` です。[`UInt8`](/ja/reference/data-types/int-uint) **戻り値** それぞれ `hashnum` 個の N-gram を含む 2 つのタプルからなるタプルを返します。[`Tuple(Tuple(String))`](/ja/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-gram に分割し、同じ入力に対して `ngramMinHashUTF8` 関数で計算された、最小および最大のハッシュ値を持つ N-gram を返します。 この関数は大文字と小文字を区別します。 **構文** ```sql theme={null} ngramMinHashArgUTF8(string[, ngramsize, hashnum]) ``` **引数** * `string` — ハッシュを計算する文字列です。 [`String`](/ja/reference/data-types/string) * `ngramsize` — 任意。N-gram のサイズです。`1` から `25` までの任意の数値を指定できます。デフォルト値は `3` です。 [`UInt8`](/ja/reference/data-types/int-uint) * `hashnum` — 任意。結果の計算に使用する最小ハッシュ値と最大ハッシュ値の数です。`1` から `25` までの任意の数値を指定できます。デフォルト値は `6` です。 [`UInt8`](/ja/reference/data-types/int-uint) **戻り値** それぞれ `hashnum` 個の N-gram を含む 2 つのタプルからなるタプルを返します。 [`Tuple(Tuple(String))`](/ja/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-gram に分割し、各 N-gram のハッシュ値を計算して、それらのハッシュを含むタプルを返します。 `hashnum` 個の最小ハッシュを使って最小ハッシュを計算し、`hashnum` 個の最大ハッシュを使って最大ハッシュを計算します。 大文字と小文字を区別しません。 [`tupleHammingDistance`](/ja/reference/functions/regular-functions/tuple-functions#tupleHammingDistance) と組み合わせることで、準重複文字列を検出できます。 2 つの文字列で返されるハッシュが同じであれば、それらの文字列は同一です。 **構文** ```sql theme={null} ngramMinHashCaseInsensitive(string[, ngramsize, hashnum]) ``` **引数** * `string` — String. [String](/ja/reference/data-types/string). - `ngramsize` — N-gram のサイズ。省略可能。設定可能な値: `1` から `25` までの任意の数。デフォルト値: `3`。[UInt8](/ja/reference/data-types/int-uint). - `hashnum` — 結果の計算に使用する最小ハッシュと最大ハッシュの数。省略可能。設定可能な値: `1` から `25` までの任意の数。デフォルト値: `6`。[UInt8](/ja/reference/data-types/int-uint). **戻り値** 最小値と最大値の 2 つのハッシュからなる タプル。[Tuple](/ja/reference/data-types/tuple)([UInt64](/ja/reference/data-types/int-uint), [UInt64](/ja/reference/data-types/int-uint)). [`Tuple`](/ja/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-gram に分割し、各 N-gram のハッシュ値を計算して、それらのハッシュを含む Tuple を返します。 最小ハッシュの計算には `hashnum` 個の最小ハッシュを、最大ハッシュの計算には `hashnum` 個の最大ハッシュを使用します。 大文字と小文字は区別されません。 [`tupleHammingDistance`](/ja/reference/functions/regular-functions/tuple-functions#tupleHammingDistance) を使用して、準重複文字列を検出できます。 2 つの文字列で返されるハッシュが同じであれば、それらの文字列は同一です。 **構文** ```sql theme={null} ngramMinHashCaseInsensitiveUTF8(string [, ngramsize, hashnum]) ``` **引数** * `string` — ハッシュを計算する文字列です。 [`String`](/ja/reference/data-types/string) * `ngramsize` — 任意。n-gram のサイズです。`1` から `25` までの任意の数値を指定できます。デフォルト値は `3` です。 [`UInt8`](/ja/reference/data-types/int-uint) * `hashnum` — 任意。結果の計算に使用する最小ハッシュと最大ハッシュの数です。`1` から `25` までの任意の数値を指定できます。デフォルト値は `6` です。 [`UInt8`](/ja/reference/data-types/int-uint) **戻り値** 最小ハッシュと最大ハッシュの 2 つを含むタプルを返します。 [`Tuple`](/ja/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-gram に分割し、各 N-gram のハッシュ値を計算して、それらのハッシュを含むタプルを返します。 `hashnum` 個の最小ハッシュを使って最小ハッシュを計算し、`hashnum` 個の最大ハッシュを使って最大ハッシュを計算します。 大文字と小文字を区別します。 [`tupleHammingDistance`](/ja/reference/functions/regular-functions/tuple-functions#tupleHammingDistance) を使用して、準重複文字列を検出できます。 2 つの文字列について、返されるハッシュが両方の文字列で同じであれば、それらの文字列は同一です。 **構文** ```sql theme={null} ngramMinHashUTF8(string[, ngramsize, hashnum]) ``` **引数** * `string` — ハッシュを計算する文字列です。 [`String`](/ja/reference/data-types/string) * `ngramsize` — 任意。n-gram のサイズです。`1` から `25` までの任意の数値を指定できます。デフォルト値は `3` です。 [`UInt8`](/ja/reference/data-types/int-uint) * `hashnum` — 任意。結果の計算に使用する最小ハッシュ値と最大ハッシュ値の個数です。`1` から `25` までの任意の数値を指定できます。デフォルト値は `6` です。 [`UInt8`](/ja/reference/data-types/int-uint) **戻り値** 2 つのハッシュ値 (最小値と最大値) を含むタプルを返します。 [`Tuple`](/ja/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-gram に分割し、その N-gram の `simhash` を返します。 [`bitHammingDistance`](/ja/reference/functions/regular-functions/bit-functions#bitHammingDistance) を使用して、準重複文字列の検出に利用できます。 2 つの文字列について計算された `simhashes` の [ハミング距離](https://en.wikipedia.org/wiki/Hamming_distance) が小さいほど、それらの文字列が同じである可能性は高くなります。 **構文** ```sql theme={null} ngramSimHash(string[, ngramsize]) ``` **引数** * `string` — 大文字と小文字を区別する `simhash` を計算する対象の文字列。[`String`](/ja/reference/data-types/string) * `ngramsize` — 任意。n-gram のサイズで、`1` から `25` までの任意の数値です。デフォルト値は `3` です。[`UInt8`](/ja/reference/data-types/int-uint) **戻り値** 入力文字列から計算された hash を返します。[`UInt64`](/ja/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-gram に分割し、その N-gram の `simhash` を返します。 大文字と小文字は区別されません。 [`bitHammingDistance`](/ja/reference/functions/regular-functions/bit-functions#bitHammingDistance) と組み合わせることで、準重複文字列の検出に利用できます。 2 つの文字列から計算した `simhashes` の [ハミング距離](https://en.wikipedia.org/wiki/Hamming_distance) が小さいほど、それらの文字列が同一である可能性は高くなります。 **構文** ```sql theme={null} ngramSimHashCaseInsensitive(string[, ngramsize]) ``` **引数** * `string` — 大文字と小文字を区別しない `simhash` を計算する文字列。 [`String`](/ja/reference/data-types/string) * `ngramsize` — 任意。N-gram のサイズ。`1` から `25` までの任意の数値を指定できます。デフォルト値は `3` です。 [`UInt8`](/ja/reference/data-types/int-uint) **戻り値** ハッシュ値。 [UInt64](/ja/reference/data-types/int-uint)。 [`UInt64`](/ja/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-gram に分割し、その N-gram の `simhash` を返します。 大文字と小文字は区別されません。 [bitHammingDistance](/ja/reference/functions/regular-functions/bit-functions#bitHammingDistance) を使用すると、準重複文字列の検出に利用できます。2 つの文字列について計算された `simhashes` の [ハミング距離](https://en.wikipedia.org/wiki/Hamming_distance) が小さいほど、それらの文字列が同一である可能性が高くなります。 **構文** ```sql theme={null} ngramSimHashCaseInsensitiveUTF8(string[, ngramsize]) ``` **引数** * `string` — ハッシュを計算する対象の文字列。[`String`](/ja/reference/data-types/string) * `ngramsize` — 省略可能。N-gram のサイズで、`1` から `25` までの任意の数値です。デフォルト値は `3` です。[`UInt8`](/ja/reference/data-types/int-uint) **戻り値** 計算されたハッシュ値を返します。[`UInt64`](/ja/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-gram に分割し、その N-gram の `simhash` を返します。 大文字と小文字を区別します。 [`bitHammingDistance`](/ja/reference/functions/regular-functions/bit-functions#bitHammingDistance) を使って、準重複文字列の検出に利用できます。 2 つの文字列について計算された `simhash` の [ハミング距離](https://en.wikipedia.org/wiki/Hamming_distance) が小さいほど、それらの文字列が同一である可能性は高くなります。 **構文** ```sql theme={null} ngramSimHashUTF8(string[, ngramsize]) ``` **引数** * `string` — ハッシュを計算する対象の文字列です。 [`String`](/ja/reference/data-types/string) * `ngramsize` — 任意。n-gram のサイズで、`1` から `25` までの任意の数値を指定します。デフォルト値は `3` です。 [`UInt8`](/ja/reference/data-types/int-uint) **戻り値** 計算されたハッシュ値を返します。 [`UInt64`](/ja/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`](/ja/reference/data-types) **戻り値** 128 ビットの `SipHash` ハッシュ値を返します。[`FixedString(16)`](/ja/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)` — キーを表す 2 つの UInt64 値のタプルです。 [`Tuple(UInt64, UInt64)`](/ja/reference/data-types/tuple) * `arg1[, arg2, ...]` — ハッシュを計算する対象となる、可変個の入力引数です。 [`Any`](/ja/reference/data-types) **戻り値** 型 [FixedString(16)](/ja/reference/data-types/fixedstring) の 128 ビット `SipHash` ハッシュ値です。 [`FixedString(16)`](/ja/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`](/ja/reference/functions/regular-functions/hash-functions#sipHash128) と同様ですが、SipHash の原著者による 128 ビットアルゴリズムを実装しています。 **構文** ```sql theme={null} sipHash128Reference(arg1[, arg2, ...]) ``` **引数** * `arg1[, arg2, ...]` — ハッシュの計算対象となる入力引数。個数は可変です。[`Any`](/ja/reference/data-types) **戻り値** 入力引数から計算された 128 ビットの `SipHash` ハッシュ値を返します。[`FixedString(16)`](/ja/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)` — キーを表す 2 つの値からなる Tuple [`Tuple(UInt64, UInt64)`](/ja/reference/data-types/tuple) * `arg1[, arg2, ...]` — ハッシュの計算対象となる可変個の入力引数です。 [`Any`](/ja/reference/data-types) **戻り値** 入力引数から計算された 128 ビットの `SipHash` ハッシュ値を返します。 [`FixedString(16)`](/ja/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倍の速度で動作します。 この関数は、すべての入力パラメータを文字列として[解釈](/ja/reference/functions/regular-functions/type-conversion-functions#reinterpretAsString)し、それぞれのハッシュ値を計算します。 その後、次のアルゴリズムでそれらを結合します。 1. 1つ目と2つ目のハッシュ値を連結して配列にし、その配列をハッシュ化します。 2. 先ほど計算したハッシュ値と3つ目の入力パラメータのハッシュを、同様の方法でハッシュ化します。 3. この計算を、元の入力に含まれる残りすべてのハッシュ値に対して繰り返します。 計算されたハッシュ値は、引数の型が異なっていても、同じ入力値に対しては同一になる場合があります。 これは、たとえばサイズの異なる整数型、同じデータを持つ名前付きおよび名前なしの`Tuple`、同じデータを持つ`Map`と、それに対応する`Array(Tuple(key, value))`型などに当てはまります。 **構文** ```sql theme={null} sipHash64(arg1[, arg2, ...]) ``` **引数** * `arg1[, arg2, ...]` — 可変個の入力引数。[`Any`](/ja/reference/data-types) **戻り値** 入力引数から計算されたハッシュ値を返します。[`UInt64`](/ja/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)` — キーを表す 2 つの値のタプルです。 [`Tuple(UInt64, UInt64)`](/ja/reference/data-types/tuple) * `arg1[,arg2, ...]` — 可変個の入力引数です。 [`Any`](/ja/reference/data-types) **戻り値** 入力値から計算されたハッシュ値を返します。 [`UInt64`](/ja/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` 語からなるパーツ (シングル) に分割し、各ワードシングルのハッシュ値を計算して、それらのハッシュを含むタプルを返します。 最小ハッシュの計算には `hashnum` 個の最小ハッシュを、最大ハッシュの計算には `hashnum` 個の最大ハッシュを使用します。 大文字と小文字は区別されます。 [`tupleHammingDistance`](/ja/reference/functions/regular-functions/tuple-functions#tupleHammingDistance) と組み合わせることで、類似した重複文字列を検出できます。 2つの文字列で返されるハッシュが同じであれば、それらの文字列は同一です。 **構文** ```sql theme={null} wordShingleMinHash(string[, shinglesize, hashnum]) ``` **引数** * `string` — ハッシュを計算する対象の文字列。 [`String`](/ja/reference/data-types/string) * `shinglesize` — 任意。ワードシングルのサイズです。`1` から `25` までの任意の値を指定できます。デフォルト値は `3` です。 [`UInt8`](/ja/reference/data-types/int-uint) * `hashnum` — 任意。結果の計算に使用する最小ハッシュと最大ハッシュの個数です。`1` から `25` までの任意の値を指定できます。デフォルト値は `6` です。 [`UInt8`](/ja/reference/data-types/int-uint) **戻り値** 最小ハッシュと最大ハッシュの 2 つのハッシュを含むタプルを返します。 [`Tuple(UInt64, UInt64)`](/ja/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` 語ごとの部分 (ワードシングル) に分割し、同じ入力に対して wordShingleMinHash 関数で計算された、単語ハッシュの最小値と最大値に対応する ワードシングル を返します。 この関数は大文字と小文字を区別します。 **構文** ```sql theme={null} wordShingleMinHashArg(string[, shinglesize, hashnum]) ``` **引数** * `string` — ハッシュを計算する文字列。[`String`](/ja/reference/data-types/string) * `shinglesize` — 省略可能。ワードシングルのサイズ。`1` から `25` までの任意の数値を指定します。デフォルト値は `3` です。[`UInt8`](/ja/reference/data-types/int-uint) * `hashnum` — 省略可能。結果の計算に使用する最小ハッシュ数と最大ハッシュ数。`1` から `25` までの任意の数値を指定します。デフォルト値は `6` です。[`UInt8`](/ja/reference/data-types/int-uint) **戻り値** それぞれに `hashnum` 個のワードシングルを含む 2 つのタプルからなるタプルを返します。[`Tuple(Tuple(String))`](/ja/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` 語ごとの部分 (ワードシングル) に分割し、同じ入力に対して [`wordShingleMinHashCaseInsensitive`](#wordShingleMinHashCaseInsensitive) 関数で計算される単語 hash の最小値と最大値に対応する ワードシングル を返します。 大文字と小文字を区別しません。 **構文** ```sql theme={null} wordShingleMinHashArgCaseInsensitive(string[, shinglesize, hashnum]) ``` **引数** * `string` — ハッシュを計算する対象の文字列。[`String`](/ja/reference/data-types/string) * `shinglesize` — 任意。ワードシングルのサイズ。`1` から `25` までの任意の値。デフォルト値は `3` です。[`UInt8`](/ja/reference/data-types/int-uint) * `hashnum` — 任意。結果の計算に使用する最小ハッシュと最大ハッシュの数。`1` から `25` までの任意の値。デフォルト値は `6` です。[`UInt8`](/ja/reference/data-types/int-uint) **戻り値** それぞれが `hashnum` 個のワードシングルを含む 2 つのタプルからなるタプルを返します。[`Tuple(Tuple(String))`](/ja/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` 語からなる部分 (シングル) に分割し、同じ入力に対して [`wordShingleMinHashCaseInsensitiveUTF8`](#wordShingleMinHashCaseInsensitiveUTF8) 関数で計算された単語ハッシュの最小値および最大値に対応するシングルを返します。 大文字と小文字を区別しません。 **構文** ```sql theme={null} wordShingleMinHashArgCaseInsensitiveUTF8(string[, shinglesize, hashnum]) ``` **引数** * `string` — ハッシュを計算する文字列です。 [`String`](/ja/reference/data-types/string) * `shinglesize` — 任意。ワードシングルのサイズです。`1` から `25` までの任意の数を指定できます。デフォルト値は `3` です。 [`UInt8`](/ja/reference/data-types/int-uint) * `hashnum` — 任意。結果の計算に使用する最小ハッシュと最大ハッシュの数です。`1` から `25` までの任意の数を指定できます。デフォルト値は `6` です。 [`UInt8`](/ja/reference/data-types/int-uint) **戻り値** 各タプルが `hashnum` 個のワードシングルを含む、2 つのタプルからなるタプルを返します。 [`Tuple(Tuple(String))`](/ja/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` 語ずつの部分 (シングル) に分割し、同じ入力に対して [`wordShingleMinHashUTF8`](#wordShingleMinHashUTF8) 関数で計算された単語 hash の最小値と最大値に対応するシングルを返します。 大文字と小文字を区別します。 **構文** ```sql theme={null} wordShingleMinHashArgUTF8(string[, shinglesize, hashnum]) ``` **引数** * `string` — hash を計算する対象の文字列。[`String`](/ja/reference/data-types/string) * `shinglesize` — 任意。ワードシングルのサイズです。`1` から `25` までの任意の数値を指定できます。デフォルト値は `3` です。[`UInt8`](/ja/reference/data-types/int-uint) * `hashnum` — 任意。結果の計算に使用する最小および最大の hash の数です。`1` から `25` までの任意の数値を指定できます。デフォルト値は `6` です。[`UInt8`](/ja/reference/data-types/int-uint) **戻り値** それぞれ `hashnum` 個のワードシングルを含む 2 つのタプルから成るタプルを返します。[`Tuple(Tuple(String))`](/ja/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`語からなる部分列 (シングル) に分割し、各ワードシングルのハッシュ値を計算して、そのハッシュ値のタプルを返します。 最小ハッシュの計算には`hashnum`個の最小ハッシュを、最大ハッシュの計算には`hashnum`個の最大ハッシュを使用します。 大文字と小文字を区別しません。 [`tupleHammingDistance`](/ja/reference/functions/regular-functions/tuple-functions#tupleHammingDistance)と組み合わせることで、準重複文字列の検出に使用できます。 2つの文字列で返されるハッシュ値が同じであれば、それらの文字列は同一です。 **構文** ```sql theme={null} wordShingleMinHashCaseInsensitive(string[, shinglesize, hashnum]) ``` **引数** * `string` — ハッシュを計算する対象の文字列です。 [`String`](/ja/reference/data-types/string) * `shinglesize` — 任意。ワードシングルのサイズです。`1` から `25` までの任意の数値を指定できます。デフォルト値は `3` です。 [`UInt8`](/ja/reference/data-types/int-uint) * `hashnum` — 任意。結果の計算に使用する最小ハッシュと最大ハッシュの数です。`1` から `25` までの任意の数値を指定できます。デフォルト値は `6` です。 [`UInt8`](/ja/reference/data-types/int-uint) **戻り値** 最小ハッシュと最大ハッシュの 2 つを含むタプルを返します。 [`Tuple(UInt64, UInt64)`](/ja/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` 語からなる部分 (シングル) に分割し、各ワードシングルのハッシュ値を計算して、それらのハッシュを含むタプルを返します。 `hashnum` 個の最小ハッシュを使って最小ハッシュを計算し、`hashnum` 個の最大ハッシュを使って最大ハッシュを計算します。 大文字と小文字を区別しません。 [`tupleHammingDistance`](/ja/reference/functions/regular-functions/tuple-functions#tupleHammingDistance) と組み合わせることで、準重複文字列を検出できます。 2 つの文字列で返されるハッシュが同じであれば、それらの文字列は同一です。 **構文** ```sql theme={null} wordShingleMinHashCaseInsensitiveUTF8(string[, shinglesize, hashnum]) ``` **引数** * `string` — ハッシュを計算する文字列です。 [`String`](/ja/reference/data-types/string) * `shinglesize` — 任意。ワードシングルのサイズです。`1` から `25` までの任意の数値を指定できます。デフォルト値は `3` です。 [`UInt8`](/ja/reference/data-types/int-uint) * `hashnum` — 任意。結果の計算に使用する最小ハッシュ数と最大ハッシュ数です。`1` から `25` までの任意の数値を指定できます。デフォルト値は `6` です。 [`UInt8`](/ja/reference/data-types/int-uint) **戻り値** 最小ハッシュ値と最大ハッシュ値の 2 つのハッシュを含む Tuple を返します。 [`Tuple(UInt64, UInt64)`](/ja/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`語ごとの部分 (ワードシングル) に分割し、各ワードシングルのハッシュ値を計算して、それらのハッシュを含むタプルを返します。 最小ハッシュの計算には`hashnum`個の最小ハッシュを、最大ハッシュの計算には`hashnum`個の最大ハッシュを使用します。 大文字と小文字を区別します。 [`tupleHammingDistance`](/ja/reference/functions/regular-functions/tuple-functions#tupleHammingDistance)を使用して、類似した重複文字列を検出できます。 2つの文字列で返されるハッシュが同じであれば、それらの文字列は同一です。 **構文** ```sql theme={null} wordShingleMinHashUTF8(string[, shinglesize, hashnum]) ``` **引数** * `string` — ハッシュを計算する対象の文字列。[`String`](/ja/reference/data-types/string) * `shinglesize` — 任意。ワードシングルのサイズです。`1` から `25` までの任意の数値を指定できます。デフォルト値は `3` です。[`UInt8`](/ja/reference/data-types/int-uint) * `hashnum` — 任意。結果の計算に使用する最小ハッシュ値と最大ハッシュ値の数です。`1` から `25` までの任意の数値を指定できます。デフォルト値は `6` です。[`UInt8`](/ja/reference/data-types/int-uint) **戻り値** 最小値と最大値の 2 つのハッシュを含むタプルを返します。[`Tuple(UInt64, UInt64)`](/ja/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`語単位の部分 (シングル) に分割し、ワードシングル `simhash` を返します。 大文字と小文字は区別されます。 [`bitHammingDistance`](/ja/reference/functions/regular-functions/bit-functions#bitHammingDistance)を使用して、類似文字列の検出に利用できます。 2つの文字列について計算された`simhashes`の[ハミング距離](https://en.wikipedia.org/wiki/Hamming_distance)が小さいほど、それらの文字列が同一である可能性が高くなります。 **構文** ```sql theme={null} wordShingleSimHash(string[, shinglesize]) ``` **引数** * `string` — ハッシュを計算する文字列。 [`String`](/ja/reference/data-types/string) * `shinglesize` — 省略可能。ワードシングルのサイズで、`1` から `25` までの任意の数値です。デフォルト値は `3` です。 [`UInt8`](/ja/reference/data-types/int-uint) **戻り値** 計算されたハッシュ値を返します。 [`UInt64`](/ja/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`語ごとの部分 (ワードシングル) に分割し、ワードシングル`simhash`を返します。 大文字と小文字は区別されません。 [`bitHammingDistance`](/ja/reference/functions/regular-functions/bit-functions#bitHammingDistance)を使用して、類似文字列の検出に利用できます。 2つの文字列について計算された`simhashes`の[ハミング距離](https://en.wikipedia.org/wiki/Hamming_distance)が小さいほど、それらの文字列が同一である可能性が高くなります。 **構文** ```sql theme={null} wordShingleSimHashCaseInsensitive(string[, shinglesize]) ``` **引数** * `string` — ハッシュを計算する文字列です。[`String`](/ja/reference/data-types/string) * `shinglesize` — 省略可。ワードシングルのサイズです。`1` から `25` までの任意の数値を指定できます。デフォルト値は `3` です。[`UInt8`](/ja/reference/data-types/int-uint) **戻り値** 計算されたハッシュ値を返します。[`UInt64`](/ja/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` 語ごとの部分 (シングル) に分割し、ワードシングル `simhash` を返します。 大文字と小文字は区別されません。 [`bitHammingDistance`](/ja/reference/functions/regular-functions/bit-functions#bitHammingDistance) を使用すると、半重複文字列の検出に利用できます。 2 つの文字列について計算された `simhashes` の [ハミング距離](https://en.wikipedia.org/wiki/Hamming_distance) が小さいほど、それらの文字列が同一である可能性が高くなります。 **構文** ```sql theme={null} wordShingleSimHashCaseInsensitiveUTF8(string[, shinglesize]) ``` **引数** * `string` — ハッシュを計算する対象の文字列。[`String`](/ja/reference/data-types/string) * `shinglesize` — 任意。ワードシングルのサイズを指定します。`1` から `25` までの数値を指定でき、デフォルト値は `3` です。[`UInt8`](/ja/reference/data-types/int-uint) **戻り値** 計算されたハッシュ値を返します。[`UInt64`](/ja/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) に分割し、ワードシングル`simhash`を返します。 大文字と小文字は区別されます。 [`bitHammingDistance`](/ja/reference/functions/regular-functions/bit-functions#bitHammingDistance)を使用して、準重複文字列の検出に利用できます。 2つの文字列で計算された`simhash`の[ハミング距離](https://en.wikipedia.org/wiki/Hamming_distance)が小さいほど、それらの文字列が同一である可能性は高くなります。 **構文** ```sql theme={null} wordShingleSimHashUTF8(string[, shinglesize]) ``` **引数** * `string` — ハッシュを計算する文字列です。[`String`](/ja/reference/data-types/string) * `shinglesize` — 任意。ワードシングルのサイズです。`1` から `25` までの任意の数値を指定できます。デフォルト値は `3` です。[`UInt8`](/ja/reference/data-types/int-uint) **戻り値** 計算されたハッシュ値を返します。[`UInt64`](/ja/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`](/ja/reference/data-types/string) **戻り値** 計算された 64 ビットハッシュ値 [`UInt64`](/ja/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`](/ja/reference/data-types/string) **戻り値** 入力文字列の32ビットハッシュ値を返します。[`UInt32`](/ja/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`](/ja/reference/data-types/string) **戻り値** 入力文字列の計算済み 64 ビットハッシュを返します。[`UInt64`](/ja/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`](/ja/reference/data-types) **戻り値** 計算された 64 ビットの `xxh3` ハッシュ値 [`UInt64`](/ja/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`](/ja/reference/data-types) **戻り値** 計算された128ビットの`xxh3`ハッシュ値[`UInt128`](/ja/reference/data-types/int-uint)を返します。 **例** **使用例** ```sql title=Query theme={null} SELECT hex(xxh3_128('ClickHouse')) ``` ```response title=Response theme={null} 3A038784C52804B4DBA43A038784C528 ```