* split up select.md * array-join.md basic refactoring * distinct.md basic refactoring * format.md basic refactoring * from.md basic refactoring * group-by.md basic refactoring * having.md basic refactoring * additional index.md refactoring * into-outfile.md basic refactoring * join.md basic refactoring * limit.md basic refactoring * limit-by.md basic refactoring * order-by.md basic refactoring * prewhere.md basic refactoring * adjust operators/index.md links * adjust sample.md links * adjust more links * adjust operatots links * fix some links * adjust aggregate function article titles * basic refactor of remaining select clauses * absolute paths in make_links.sh * run make_links.sh * remove old select.md locations * translate docs/es * translate docs/fr * translate docs/fa * remove old operators.md location * change operators.md links * adjust links in docs/es * adjust links in docs/es * minor texts adjustments * wip * update machine translations to use new links * fix changelog * es build fixes * get rid of some select.md links * temporary adjust ru links * temporary adjust more ru links * improve curly brace handling * adjust ru as well * fa build fix * ru link fixes * zh link fixes * temporary disable part of anchor checks
17 KiB
machine_translated | machine_translated_rev | toc_priority | toc_title |
---|---|---|---|
true | 72537a2d52 |
50 | Hachage |
Les Fonctions De Hachage
Les fonctions de hachage peuvent être utilisées pour le brassage pseudo-aléatoire déterministe des éléments.
halfMD5
Interpréter tous les paramètres d'entrée sous forme de chaînes et calcule le MD5 la valeur de hachage pour chacun d'eux. Puis combine les hachages, prend les 8 premiers octets du hachage de la chaîne résultante, et les interprète comme UInt64
dans l'ordre des octets big-endian.
halfMD5(par1, ...)
La fonction est relativement lente (5 millions de chaînes courtes par seconde par cœur de processeur). Envisager l'utilisation de la sipHash64 la fonction la place.
Paramètre
La fonction prend un nombre variable de paramètres d'entrée. Les paramètres peuvent être tout de la types de données pris en charge.
Valeur Renvoyée
A UInt64 valeur de hachage du type de données.
Exemple
SELECT halfMD5(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS halfMD5hash, toTypeName(halfMD5hash) AS type
┌────────halfMD5hash─┬─type───┐
│ 186182704141653334 │ UInt64 │
└────────────────────┴────────┘
MD5
Calcule le MD5 à partir d'une chaîne et renvoie L'ensemble d'octets résultant en tant que FixedString(16). Si vous n'avez pas besoin de MD5 en particulier, mais que vous avez besoin d'un hachage cryptographique 128 bits décent, utilisez le ‘sipHash128’ la fonction la place. Si vous voulez obtenir le même résultat que la sortie de l'utilitaire md5sum, utilisez lower (hex(MD5 (s))).
sipHash64
Produit un 64 bits SipHash la valeur de hachage.
sipHash64(par1,...)
C'est une fonction de hachage cryptographique. Il fonctionne au moins trois fois plus vite que le MD5 fonction.
Fonction interpréter tous les paramètres d'entrée sous forme de chaînes et calcule la valeur de hachage pour chacun d'eux. Puis combine les hachages par l'algorithme suivant:
- Après avoir haché tous les paramètres d'entrée, la fonction obtient le tableau de hachages.
- La fonction prend le premier et le second éléments et calcule un hachage pour le tableau d'entre eux.
- Ensuite, la fonction prend la valeur de hachage, calculée à l'étape précédente, et le troisième élément du tableau de hachage initial, et calcule un hachage pour le tableau d'entre eux.
- L'étape précédente est répétée pour tous les éléments restants de la période initiale de hachage tableau.
Paramètre
La fonction prend un nombre variable de paramètres d'entrée. Les paramètres peuvent être tout de la types de données pris en charge.
Valeur Renvoyée
A UInt64 valeur de hachage du type de données.
Exemple
SELECT sipHash64(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS SipHash, toTypeName(SipHash) AS type
┌──────────────SipHash─┬─type───┐
│ 13726873534472839665 │ UInt64 │
└──────────────────────┴────────┘
sipHash128
Calcule SipHash à partir d'une chaîne. Accepte un argument de type chaîne. Renvoie FixedString (16). Diffère de sipHash64 en ce que l'état de pliage xor final n'est effectué que jusqu'à 128 bits.
cityHash64
Produit un 64 bits CityHash la valeur de hachage.
cityHash64(par1,...)
Ceci est une fonction de hachage non cryptographique rapide. Il utilise L'algorithme CityHash pour les paramètres de chaîne et la fonction de hachage rapide non cryptographique spécifique à l'implémentation pour les paramètres avec d'autres types de données. La fonction utilise le combinateur CityHash pour obtenir les résultats finaux.
Paramètre
La fonction prend un nombre variable de paramètres d'entrée. Les paramètres peuvent être tout de la types de données pris en charge.
Valeur Renvoyée
A UInt64 valeur de hachage du type de données.
Exemple
Appelez exemple:
SELECT cityHash64(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS CityHash, toTypeName(CityHash) AS type
┌─────────────CityHash─┬─type───┐
│ 12072650598913549138 │ UInt64 │
└──────────────────────┴────────┘
L'exemple suivant montre comment calculer la somme de l'ensemble de la table avec précision jusqu'à la ligne de commande:
SELECT groupBitXor(cityHash64(*)) FROM table
intHash32
Calcule un code de hachage 32 bits à partir de n'importe quel type d'entier. C'est une fonction de hachage non cryptographique relativement rapide de qualité moyenne pour les nombres.
intHash64
Calcule un code de hachage 64 bits à partir de n'importe quel type d'entier. Il fonctionne plus vite que intHash32. Qualité moyenne.
SHA1
SHA224
SHA256
Calcule SHA-1, SHA-224 ou SHA-256 à partir d'une chaîne et renvoie l'ensemble d'octets résultant en tant que FixedString(20), FixedString(28) ou FixedString(32). La fonction fonctionne assez lentement (SHA-1 traite environ 5 millions de chaînes courtes par seconde par cœur de processeur, tandis que SHA-224 et SHA-256 traitent environ 2,2 millions). Nous vous recommandons d'utiliser cette fonction uniquement dans les cas où vous avez besoin d'une fonction de hachage spécifique et que vous ne pouvez pas la sélectionner. Même dans ces cas, nous vous recommandons d'appliquer la fonction hors ligne et de pré-calculer les valeurs lors de leur insertion dans la table, au lieu de l'appliquer dans SELECTS.
URLHash(url [, N])
Une fonction de hachage non cryptographique rapide et de qualité décente pour une chaîne obtenue à partir d'une URL en utilisant un type de normalisation.
URLHash(s)
– Calculates a hash from a string without one of the trailing symbols /
,?
ou #
à la fin, si elle est présente.
URLHash(s, N)
– Calculates a hash from a string up to the N level in the URL hierarchy, without one of the trailing symbols /
,?
ou #
à la fin, si elle est présente.
Les niveaux sont les mêmes que dans URLHierarchy. Cette fonction est spécifique à Yandex.Metrica.
farmHash64
Produit un 64 bits FarmHash la valeur de hachage.
farmHash64(par1, ...)
La fonction utilise le Hash64
la méthode de tous les les méthodes disponibles.
Paramètre
La fonction prend un nombre variable de paramètres d'entrée. Les paramètres peuvent être tout de la types de données pris en charge.
Valeur Renvoyée
A UInt64 valeur de hachage du type de données.
Exemple
SELECT farmHash64(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS FarmHash, toTypeName(FarmHash) AS type
┌─────────────FarmHash─┬─type───┐
│ 17790458267262532859 │ UInt64 │
└──────────────────────┴────────┘
javaHash
Calculer JavaHash à partir d'une chaîne. Cette fonction de hachage n'est ni rapide ni de bonne qualité. La seule raison de l'utiliser est lorsque cet algorithme est déjà utilisé dans un autre système et que vous devez calculer exactement le même résultat.
Syntaxe
SELECT javaHash('');
Valeur renvoyée
A Int32
valeur de hachage du type de données.
Exemple
Requête:
SELECT javaHash('Hello, world!');
Résultat:
┌─javaHash('Hello, world!')─┐
│ -1880044555 │
└───────────────────────────┘
javaHashUTF16LE
Calculer JavaHash à partir d'une chaîne, en supposant qu'elle contient des octets représentant une chaîne en encodage UTF-16LE.
Syntaxe
javaHashUTF16LE(stringUtf16le)
Paramètre
stringUtf16le
— a string in UTF-16LE encoding.
Valeur renvoyée
A Int32
valeur de hachage du type de données.
Exemple
Requête correcte avec une chaîne codée UTF-16LE.
Requête:
SELECT javaHashUTF16LE(convertCharset('test', 'utf-8', 'utf-16le'))
Résultat:
┌─javaHashUTF16LE(convertCharset('test', 'utf-8', 'utf-16le'))─┐
│ 3556498 │
└──────────────────────────────────────────────────────────────┘
hiveHash
Calculer HiveHash
à partir d'une chaîne.
SELECT hiveHash('');
C'est juste JavaHash avec le bit de signe mis à zéro. Cette fonction est utilisée dans Apache Hive pour les versions antérieures à la version 3.0. Cette fonction de hachage n'est ni rapide ni de bonne qualité. La seule raison de l'utiliser est lorsque cet algorithme est déjà utilisé dans un autre système et que vous devez calculer exactement le même résultat.
Valeur renvoyée
A Int32
valeur de hachage du type de données.
Type: hiveHash
.
Exemple
Requête:
SELECT hiveHash('Hello, world!');
Résultat:
┌─hiveHash('Hello, world!')─┐
│ 267439093 │
└───────────────────────────┘
metroHash64
Produit un 64 bits MetroHash la valeur de hachage.
metroHash64(par1, ...)
Paramètre
La fonction prend un nombre variable de paramètres d'entrée. Les paramètres peuvent être tout de la types de données pris en charge.
Valeur Renvoyée
A UInt64 valeur de hachage du type de données.
Exemple
SELECT metroHash64(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS MetroHash, toTypeName(MetroHash) AS type
┌────────────MetroHash─┬─type───┐
│ 14235658766382344533 │ UInt64 │
└──────────────────────┴────────┘
jumpConsistentHash
Calcule JumpConsistentHash forme un UInt64. Accepte deux arguments: une clé de type UInt64 et le nombre de compartiments. Renvoie Int32. Pour plus d'informations, voir le lien: JumpConsistentHash
murmurHash2_32, murmurHash2_64
Produit un MurmurHash2 la valeur de hachage.
murmurHash2_32(par1, ...)
murmurHash2_64(par1, ...)
Paramètre
Les deux fonctions prennent un nombre variable de paramètres d'entrée. Les paramètres peuvent être tout de la types de données pris en charge.
Valeur Renvoyée
- Le
murmurHash2_32
fonction renvoie la valeur de hachage ayant le UInt32 type de données. - Le
murmurHash2_64
fonction renvoie la valeur de hachage ayant le UInt64 type de données.
Exemple
SELECT murmurHash2_64(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS MurmurHash2, toTypeName(MurmurHash2) AS type
┌──────────MurmurHash2─┬─type───┐
│ 11832096901709403633 │ UInt64 │
└──────────────────────┴────────┘
gccMurmurHash
Calcule un 64 bits MurmurHash2 valeur de hachage utilisant la même graine de hachage que gcc. Il est portable entre Clang et GCC construit.
Syntaxe
gccMurmurHash(par1, ...);
Paramètre
par1, ...
— A variable number of parameters that can be any of the types de données pris en charge.
Valeur renvoyée
- Valeur de hachage calculée.
Type: UInt64.
Exemple
Requête:
SELECT
gccMurmurHash(1, 2, 3) AS res1,
gccMurmurHash(('a', [1, 2, 3], 4, (4, ['foo', 'bar'], 1, (1, 2)))) AS res2
Résultat:
┌─────────────────res1─┬────────────────res2─┐
│ 12384823029245979431 │ 1188926775431157506 │
└──────────────────────┴─────────────────────┘
murmurHash3_32, murmurHash3_64
Produit un MurmurHash3 la valeur de hachage.
murmurHash3_32(par1, ...)
murmurHash3_64(par1, ...)
Paramètre
Les deux fonctions prennent un nombre variable de paramètres d'entrée. Les paramètres peuvent être tout de la types de données pris en charge.
Valeur Renvoyée
- Le
murmurHash3_32
la fonction retourne un UInt32 valeur de hachage du type de données. - Le
murmurHash3_64
la fonction retourne un UInt64 valeur de hachage du type de données.
Exemple
SELECT murmurHash3_32(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS MurmurHash3, toTypeName(MurmurHash3) AS type
┌─MurmurHash3─┬─type───┐
│ 2152717 │ UInt32 │
└─────────────┴────────┘
murmurHash3_128
Produit de 128 bits MurmurHash3 la valeur de hachage.
murmurHash3_128( expr )
Paramètre
expr
— Expression de retour d'un Chaîne-le type de la valeur.
Valeur Renvoyée
A FixedString (16) valeur de hachage du type de données.
Exemple
SELECT murmurHash3_128('example_string') AS MurmurHash3, toTypeName(MurmurHash3) AS type
┌─MurmurHash3──────┬─type────────────┐
│ 6<>1<1C>4"S5KT<4B>~~q │ FixedString(16) │
└──────────────────┴─────────────────┘
xxHash32, xxHash64
Calculer xxHash
à partir d'une chaîne. Il est proposé en deux saveurs, 32 et 64 bits.
SELECT xxHash32('');
OR
SELECT xxHash64('');
Valeur renvoyée
A Uint32
ou Uint64
valeur de hachage du type de données.
Type: xxHash
.
Exemple
Requête:
SELECT xxHash32('Hello, world!');
Résultat:
┌─xxHash32('Hello, world!')─┐
│ 834093149 │
└───────────────────────────┘
Voir Aussi