Catégories :

Fonctions utilitaires et de hachage

HASH

Renvoie une valeur de hachage 64 bits signée. Notez que HASH ne renvoie jamais NULL, même pour les entrées NULL.

Les utilisations possibles de la fonction HASH incluent :

  • Convertissez des valeurs de données asymétriques en valeurs susceptibles d’être distribuées de manière plus aléatoire ou plus uniforme.

    Par exemple, vous pouvez diviser un groupe de valeurs très asymétriques et générer un ensemble de valeurs susceptibles d’être distribuées de manière aléatoire ou uniforme.

  • Placez les données dans des compartiments. Étant donné que le hachage peut convertir des valeurs de données asymétriques en valeurs réparties plus distribuées, vous pouvez utiliser le hachage pour prendre des valeurs asymétriques et créer des compartiments de taille approximativement égale.

    Si le hachage seul ne suffit pas pour obtenir le nombre de compartiments distincts voulu, vous pouvez combiner le hachage avec les fonctions ROUND ou WIDTH_BUCKET.

Note

HASH est une fonction propriétaire qui accepte un nombre variable d’expressions d’entrée de types arbitraires et renvoie une valeur signée. Ce n’est pas une fonction de hachage cryptographique et cela ne doit pas être utilisé en tant que tel.

Les fonctions de hachage cryptographique présentent quelques propriétés que cette fonction ne possède pas, par exemple :

  • Le hachage cryptographique d’une valeur ne peut pas être inversé pour rechercher la valeur d’origine.

  • Étant donné une valeur, il est impossible de trouver une autre valeur avec le même hachage cryptographique.

Pour des raisons cryptographiques, utilisez les familles de fonctions SHA (dans Fonctions de chaîne et fonctions binaires).

Voir aussi

HASH_AGG

Syntaxe

HASH( <expr> [ , <expr2> ... ] )

HASH(*)

Arguments

exprN

L’expression peut être une expression générale de tout type de données Snowflake.

Renvoie

Renvoie une valeur signée de 64 bits sous la forme NUMBER(19,0).

HASH ne renvoie jamais NULL, même pour les entrées NULL.

Notes sur l’utilisation

  • HASH est stable dans le sens où il garantit :

    • Deux valeurs quelconques de type NUMBER comparables bénéficieront du même hachage (même valeur de hachage), même si les types respectifs présentent une précision et/ou une échelle différentes.

    • Deux valeurs quelconques de type FLOAT qui peuvent être converties en NUMBER(38, 0) sans perte de précision bénéficieront du même hachage (même valeur de hachage). Par exemple, les éléments suivants renvoient tous la même valeur de hachage :

      • HASH(10::NUMBER(38,0))

      • HASH(10::NUMBER(5,3))

      • HASH(10::FLOAT)

    • Deux valeurs quelconques de typeTIMESTAMP_TZ comparables bénéficieront du même hachage (même valeur de hachage), même si les horodatages proviennent de différents fuseaux horaires.

    • Cette garantie s’applique également aux valeurs NUMBER, FLOAT et TIMESTAMP_TZ dans une colonne VARIANT.

    • Notez que cette garantie ne s’applique pas aux autres combinaisons de types, même s’il existe des conversions implicites entre les types. Par exemple, avec une probabilité écrasante, ce qui suit ne renverra pas les mêmes valeurs de hachage, même si 10 = '10' après la conversion implicite :

      • HASH(10)

      • HASH('10')

  • HASH(*) signifie créer une seule valeur hachée basée sur toutes les colonnes de la ligne.

  • N’utilisez pas HASH() pour créer des clés uniques. HASH() a une résolution finie de 64 bits et est garanti pour renvoyer des valeurs non uniques si plus de 2^64 valeurs sont entrées, par exemple, pour une table comportant plus de 2^64 lignes. En pratique, si l’entrée est de l’ordre de 2^32 lignes (environ 4 milliards de lignes) ou plus, il est raisonnablement probable que la fonction renvoie au moins une valeur en double.

Détails du classement

No impact.

  • Deux chaînes identiques mais ayant des spécifications de classement différentes ont la même valeur de hachage. En d’autres termes, seule la chaîne, et non la spécification de classement, affecte la valeur de hachage.

  • Deux chaînes différentes, mais se égales selon un classement, peuvent avoir une valeur de hachage différente. Par exemple, deux chaînes identiques utilisant un classement insensible à la ponctuation auront normalement des valeurs de hachage différentes, car seule la chaîne, et non la spécification du classement, affecte la valeur de hachage.

Exemples

SELECT HASH(SEQ8()) FROM TABLE(GENERATOR(rowCount=>10));

----------------------+
     HASH(SEQ8())     |
----------------------+
 -6076851061503311999 |
 -4730168494964875235 |
 -3690131753453205264 |
 -7287585996956442977 |
 -1285360004004520191 |
 4801857165282451853  |
 -2112898194861233169 |
 1885958945512144850  |
 -3994946021335987898 |
 -3559031545629922466 |
----------------------+
SELECT HASH(10), HASH(10::number(38,0)), HASH(10::number(5,3)), HASH(10::float);

---------------------+------------------------+-----------------------+---------------------+
      HASH(10)       | HASH(10::NUMBER(38,0)) | HASH(10::NUMBER(5,3)) |   HASH(10::FLOAT)   |
---------------------+------------------------+-----------------------+---------------------+
 1599627706822963068 | 1599627706822963068    | 1599627706822963068   | 1599627706822963068 |
---------------------+------------------------+-----------------------+---------------------+
SELECT HASH(10), HASH('10');

---------------------+---------------------+
      HASH(10)       |     HASH('10')      |
---------------------+---------------------+
 1599627706822963068 | 3622494980440108984 |
---------------------+---------------------+
SELECT HASH(null), HASH(null, null), HASH(null, null, null);

---------------------+--------------------+------------------------+
     HASH(NULL)      |  HASH(NULL, NULL)  | HASH(NULL, NULL, NULL) |
---------------------+--------------------+------------------------+
 8817975702393619368 | 953963258351104160 | 2941948363845684412    |
---------------------+--------------------+------------------------+

L’exemple ci-dessous montre que même si la table contient plusieurs colonnes, HASH(*) renvoie une valeur unique par ligne.

CREATE TABLE orders (order_ID INTEGER, customer_ID INTEGER, order_date ...);

...

SELECT HASH(*) FROM orders LIMIT 10;

----------------------+
       HASH(*)        |
----------------------+
 -3527903796973745449 |
 6296330861892871310  |
 6918165900200317484  |
 -2762842444336053314 |
 -2340602249668223387 |
 5248970923485160358  |
 -5807737826218607124 |
 428973568495579456   |
 2583438210124219420  |
 4041917286051184231  |
----------------------+