Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra. # Fonctions Hyperloglog Les fonctions HyperLogLog (HLL) de SQL permettent d'estimer efficacement le nombre d'éléments uniques (cardinalité) dans un ensemble de données volumineux, même lorsque l'ensemble réel d'éléments uniques n'est pas stocké. Les principaux avantages de l'utilisation des fonctions HLL sont les suivants : + **Efficacité de la mémoire** : les esquisses HLL nécessitent beaucoup moins de mémoire que le stockage de l'ensemble complet d'éléments uniques, ce qui les rend adaptées à de grands ensembles de données. + **Informatique distribuée** : les esquisses HLL peuvent être combinées entre plusieurs sources de données ou nœuds de traitement, ce qui permet une estimation distribuée efficace du nombre unique. + **Résultats approximatifs** : HLL fournit une estimation du nombre unique approximative, avec un compromis ajustable entre précision et utilisation de la mémoire (via le paramètre de précision). Ces fonctions sont particulièrement utiles dans les scénarios où vous devez estimer le nombre d'éléments uniques, tels que dans les applications d'analyse, d'entreposage de données et de traitement de flux en temps réel. AWS Clean Rooms prend en charge les fonctions HLL suivantes. **Topics** + [Fonction HLL\$1SKETCH\$1AGG](HLL_SKETCH_AGG.md) + [Fonction HLL\$1SKETCH\$1ESTIMATE](HLL_SKETCH_ESTIMATE.md) + [Fonction HLL\$1UNION](HLL_UNION.md) + [Fonction HLL\$1UNION\$1AGG](HLL_UNION_AGG.md) # Fonction HLL\$1SKETCH\$1AGG La fonction d'agrégation HLL\$1SKETCH\$1AGG crée une esquisse HLL à partir des valeurs de la colonne spécifiée. Elle renvoie un type de données HLLSKETCH qui encapsule les valeurs des expressions d'entrée. La fonction d'agrégation HLL\$1SKETCH\$1AGG fonctionne avec tous les types de données et ignore les valeurs NULL. Lorsqu’il n’y a pas de lignes dans une table ou que toutes les lignes sont NULL, le schéma résultant n’a pas de paires index-valeur telles que `{"version":1,"logm":15,"sparse":{"indices":[],"values":[]}}`. ## Syntaxe ``` HLL_SKETCH_AGG (aggregate_expression[, lgConfigK ] ) ``` ## Argument *aggregate\$1expression* Toute expression de type INT, BIGINT, STRING ou BINARY par rapport à laquelle un comptage unique sera effectué. Toutes `NULL` les valeurs sont ignorées. *LG Configk* Une constante INT optionnelle comprise entre 4 et 21 inclus avec 12 par défaut. Log-base-2 de K, où K est le nombre de compartiments ou de fentes pour l'esquisse. ## Type de retour La fonction HLL\$1SKETCH\$1AGG renvoie un tampon BINAIRE non NULL contenant l' HyperLogLog esquisse calculée en raison de la consommation et de l'agrégation de toutes les valeurs d'entrée du groupe d'agrégation. ## Exemples Les exemples suivants utilisent l'algorithme HyperLogLog (HLL) pour estimer le nombre distinct de valeurs dans la `col` colonne. La `hll_sketch_agg(col, 12)` fonction agrège les valeurs de la colonne col pour créer une esquisse HLL avec une précision de 12. La `hll_sketch_estimate()` fonction est ensuite utilisée pour estimer le nombre distinct de valeurs sur la base de l'esquisse HLL générée. Le résultat final de la requête est 3, ce qui représente le nombre distinct estimé de valeurs dans la `col` colonne. Dans ce cas, les valeurs distinctes sont 1, 2 et 3. ``` SELECT hll_sketch_estimate(hll_sketch_agg(col, 12)) FROM VALUES (1), (1), (2), (2), (3) tab(col); 3 ``` L'exemple suivant utilise également l'algorithme HLL pour estimer le nombre distinct de valeurs dans la `col` colonne, mais il ne spécifie pas de valeur de précision pour l'esquisse HLL. Dans ce cas, il utilise la précision par défaut de 14. La `hll_sketch_agg(col)` fonction prend les valeurs de la `col` colonne et crée une esquisse HyperLogLog (HLL), qui est une structure de données compacte qui peut être utilisée pour estimer le nombre distinct d'éléments. La `hll_sketch_estimate(hll_sketch_agg(col))` fonction prend l'esquisse HLL créée à l'étape précédente et calcule une estimation du nombre distinct de valeurs dans la `col` colonne. Le résultat final de la requête est 3, ce qui représente le nombre distinct estimé de valeurs dans la `col` colonne. Dans ce cas, les valeurs distinctes sont 1, 2 et 3. ``` SELECT hll_sketch_estimate(hll_sketch_agg(col)) FROM VALUES (1), (1), (2), (2), (3) tab(col); 3 ``` # Fonction HLL\$1SKETCH\$1ESTIMATE La fonction HLL\$1SKETCH\$1ESTIMATE prend une esquisse HLL et estime le nombre d'éléments uniques représentés par l'esquisse. Il utilise l'algorithme HyperLogLog (HLL) pour compter une approximation probabiliste du nombre de valeurs uniques dans une colonne donnée, en consommant une représentation binaire connue sous le nom de tampon d'esquisse précédemment générée par la fonction HLL\$1SKETCH\$1AGG et en renvoyant le résultat sous la forme d'un grand entier. L'algorithme d'esquisse HLL fournit un moyen efficace d'estimer le nombre d'éléments uniques, même pour de grands ensembles de données, sans avoir à stocker l'ensemble complet des valeurs uniques. Les `hll_union_agg` fonctions `hll_union` et peuvent également combiner des esquisses en consommant et en fusionnant ces tampons en tant qu'entrées. ## Syntaxe ``` HLL_SKETCH_ESTIMATE (hllsketch_expression) ``` ## Argument *hllsketch\$1expression* `BINARY`Expression contenant une esquisse générée par HLL\$1SKETCH\$1AGG ## Type de retour La fonction HLL\$1SKETCH\$1ESTIMATE renvoie une valeur BIGINT correspondant au nombre distinct approximatif représenté par l'esquisse en entrée. ## Exemples Les exemples suivants utilisent l'algorithme d'esquisse HyperLogLog (HLL) pour estimer la cardinalité (nombre unique) des valeurs de la colonne. `col` La `hll_sketch_agg(col, 12)` fonction prend la `col` colonne et crée une esquisse HLL avec une précision de 12 bits. L'esquisse HLL est une structure de données approximative qui permet d'estimer efficacement le nombre d'éléments uniques dans un ensemble. La `hll_sketch_estimate()` fonction prend l'esquisse HLL créée par `hll_sketch_agg` et estime la cardinalité (nombre unique) des valeurs représentées par l'esquisse. `FROM VALUES (1), (1), (2), (2), (3) tab(col);`Génère un ensemble de données de test de 5 lignes, où la `col` colonne contient les valeurs 1, 1, 2, 2 et 3. Le résultat de cette requête est le nombre unique estimé des valeurs de la `col` colonne, qui est de 3. ``` SELECT hll_sketch_estimate(hll_sketch_agg(col, 12)) FROM VALUES (1), (1), (2), (2), (3) tab(col); 3 ``` La différence entre l'exemple suivant et le précédent est que le paramètre de précision (12 bits) n'est pas spécifié dans l'appel de `hll_sketch_agg` fonction. Dans ce cas, la précision par défaut de 14 bits est utilisée, ce qui peut fournir une estimation plus précise du nombre unique par rapport à l'exemple précédent qui utilisait 12 bits de précision. ``` SELECT hll_sketch_estimate(hll_sketch_agg(col)) FROM VALUES (1), (1), (2), (2), (3) tab(col); 3 ``` # Fonction HLL\$1UNION La fonction HLL\$1UNION combine deux esquisses HLL en une seule esquisse unifiée. Il utilise l'algorithme HyperLogLog (HLL) pour combiner deux esquisses en une seule. Les requêtes peuvent utiliser les tampons obtenus pour calculer des nombres uniques approximatifs sous forme de longs entiers avec la `hll_sketch_estimate` fonction. ## Syntaxe ``` HLL_UNION (( expr1, expr2 [, allowDifferentLgConfigK ] )) ``` ## Argument *ExPRN* `BINARY`Expression contenant une esquisse générée par HLL\$1SKETCH\$1AGG. *allowDifferentLgConfiguration K* Expression BOOLEAN facultative contrôlant s'il faut autoriser la fusion de deux esquisses avec des valeurs LGConfigk différentes. La valeur par défaut est `false`. ## Type de retour La fonction HLL\$1UNION renvoie une mémoire tampon BINAIRE contenant l' HyperLogLog esquisse calculée à la suite de la combinaison des expressions d'entrée. Lorsque le `allowDifferentLgConfigK` paramètre est défini`true`, l'esquisse du résultat utilise la plus petite des deux `lgConfigK` valeurs fournies. ## Exemples Les exemples suivants utilisent l'algorithme d'esquisse HyperLogLog (HLL) pour estimer le nombre unique de valeurs sur deux colonnes `col1` et `col2` dans un ensemble de données. La `hll_sketch_agg(col1)` fonction crée une esquisse HLL pour les valeurs uniques de la `col1` colonne. La `hll_sketch_agg(col2)` fonction crée une esquisse HLL pour les valeurs uniques de la colonne col2. La `hll_union(...)` fonction combine les deux esquisses HLL créées aux étapes 1 et 2 en une seule esquisse HLL unifiée. La `hll_sketch_estimate(...)` fonction prend l'esquisse HLL combinée et estime le nombre unique de valeurs entre les deux `col1` et`col2`. La `FROM VALUES` clause génère un ensemble de données de test de 5 lignes, `col1` contenant les valeurs 1, 1, 2, 2 et 3, et `col2` contenant les valeurs 4, 4, 5, 5 et 6. Le résultat de cette requête est le nombre unique estimé de valeurs entre les deux `col1` et`col2`, qui est de 6. L'algorithme d'esquisse HLL fournit un moyen efficace d'estimer le nombre d'éléments uniques, même pour de grands ensembles de données, sans avoir à stocker l'ensemble complet des valeurs uniques. Dans cet exemple, la `hll_union` fonction est utilisée pour combiner les esquisses HLL des deux colonnes, ce qui permet d'estimer le nombre unique pour l'ensemble de données, plutôt que pour chaque colonne individuellement. ``` SELECT hll_sketch_estimate( hll_union( hll_sketch_agg(col1), hll_sketch_agg(col2))) FROM VALUES (1, 4), (1, 4), (2, 5), (2, 5), (3, 6) AS tab(col1, col2); 6 ``` La différence entre l'exemple suivant et le précédent est que le paramètre de précision (12 bits) n'est pas spécifié dans l'appel de `hll_sketch_agg` fonction. Dans ce cas, la précision par défaut de 14 bits est utilisée, ce qui peut fournir une estimation plus précise du nombre unique par rapport à l'exemple précédent qui utilisait 12 bits de précision. ``` SELECT hll_sketch_estimate( hll_union( hll_sketch_agg(col1, 14), hll_sketch_agg(col2, 14))) FROM VALUES (1, 4), (1, 4), (2, 5), (2, 5), (3, 6) AS tab(col1, col2); ``` # Fonction HLL\$1UNION\$1AGG La fonction HLL\$1UNION\$1AGG combine plusieurs esquisses HLL en une seule esquisse unifiée. Il utilise l'algorithme HyperLogLog (HLL) pour combiner un groupe de croquis en un seul. Les requêtes peuvent utiliser les tampons obtenus pour calculer des nombres uniques approximatifs à l'aide de la `hll_sketch_estimate` fonction. ## Syntaxe ``` HLL_UNION_AGG ( expr [, allowDifferentLgConfigK ] ) ``` ## Argument *expr* `BINARY`Expression contenant une esquisse générée par HLL\$1SKETCH\$1AGG. *allowDifferentLgConfiguration K* Expression BOOLEAN facultative contrôlant s'il faut autoriser la fusion de deux esquisses avec des valeurs LGConfigk différentes. La valeur par défaut est `false`. ## Type de retour La fonction HLL\$1UNION\$1AGG renvoie une mémoire tampon BINAIRE contenant l' HyperLogLog esquisse calculée en combinant les expressions d'entrée du même groupe. Lorsque le `allowDifferentLgConfigK` paramètre est défini`true`, l'esquisse du résultat utilise la plus petite des deux `lgConfigK` valeurs fournies. ## Exemples Les exemples suivants utilisent l'algorithme d'esquisse HyperLogLog (HLL) pour estimer le nombre unique de valeurs dans plusieurs esquisses HLL. Le premier exemple estime le nombre unique de valeurs dans un ensemble de données. ``` SELECT hll_sketch_estimate(hll_union_agg(sketch, true)) FROM (SELECT hll_sketch_agg(col) as sketch FROM VALUES (1) AS tab(col) UNION ALL SELECT hll_sketch_agg(col, 20) as sketch FROM VALUES (1) AS tab(col)); 1 ``` La requête interne crée deux esquisses HLL : + La première instruction SELECT crée une esquisse à partir d'une valeur unique de 1. + La deuxième instruction SELECT crée une esquisse à partir d'une autre valeur unique de 1, mais avec une précision de 20. La requête externe utilise la fonction HLL\$1UNION\$1AGG pour combiner les deux esquisses en une seule esquisse. Il applique ensuite la fonction HLL\$1SKETCH\$1ESTIMATE à cette esquisse combinée pour estimer le nombre unique de valeurs. Le résultat de cette requête est le nombre unique estimé des valeurs de la `col` colonne, qui est`1`. Cela signifie que les deux valeurs d'entrée de 1 sont considérées comme uniques, même si elles ont la même valeur. Le deuxième exemple inclut un paramètre de précision différent pour la fonction HLL\$1UNION\$1AGG. Dans ce cas, les deux esquisses HLL sont créées avec une précision de 14 bits, ce qui permet de les combiner avec succès à l'aide `hll_union_agg` du `true` paramètre. ``` SELECT hll_sketch_estimate(hll_union_agg(sketch, true)) FROM (SELECT hll_sketch_agg(col, 14) as sketch FROM VALUES (1) AS tab(col) UNION ALL SELECT hll_sketch_agg(col, 14) as sketch FROM VALUES (1) AS tab(col)); 1 ``` Le résultat final de la requête est le nombre unique estimé, qui dans ce cas l'est également`1`. Cela signifie que les deux valeurs d'entrée de 1 sont considérées comme uniques, même si elles ont la même valeur.