Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Hyperloglog-Funktionen
Die HyperLogLog (HLL) -Funktionen in SQL bieten eine Möglichkeit, die Anzahl der eindeutigen Elemente (Kardinalität) in einem großen Datensatz effizient zu schätzen, selbst wenn der tatsächliche Satz eindeutiger Elemente nicht gespeichert ist.
Die Hauptvorteile der Verwendung von HLL-Funktionen sind:
+ **Speichereffizienz**: HLL-Skizzen benötigen viel weniger Speicherplatz als das Speichern des gesamten Satzes einzigartiger Elemente, sodass sie für große Datensätze geeignet sind.
+ **Verteiltes Rechnen**: HLL-Skizzen können über mehrere Datenquellen oder Verarbeitungsknoten hinweg kombiniert werden, was eine effiziente Schätzung der verteilten eindeutigen Anzahl ermöglicht.
+ **Ungefähre Ergebnisse**: HLL bietet eine ungefähre Schätzung der individuellen Anzahl mit einem einstellbaren Kompromiss zwischen Genauigkeit und Speicherverbrauch (über den Präzisionsparameter).
Diese Funktionen sind besonders nützlich in Szenarien, in denen Sie die Anzahl der einzelnen Elemente schätzen müssen, z. B. in Analyse-, Data Warehousing- und Echtzeit-Stream-Verarbeitungsanwendungen.
AWS Clean Rooms unterstützt die folgenden HLL-Funktionen.
**Topics**
+ [HLL\$1SKETCH\$1AGG-Funktion](HLL_SKETCH_AGG.md)
+ [Funktion HLL\$1SKETCH\$1ESTIMATE](HLL_SKETCH_ESTIMATE.md)
+ [HLL\$1UNION-Funktion](HLL_UNION.md)
+ [HLL\$1UNION\$1AGG-Funktion](HLL_UNION_AGG.md)
# HLL\$1SKETCH\$1AGG-Funktion
Die Aggregatfunktion HLL\$1SKETCH\$1AGG erstellt eine HLL-Skizze aus den Werten in der angegebenen Spalte. Sie gibt einen HLLSKETCH-Datentyp zurück, der die Werte der Eingabeausdrücke kapselt.
Die HLL\$1SKETCH\$1AGG-Agg-Aggregatfunktion funktioniert mit jedem Datentyp und ignoriert NULL-Werte.
Wenn keine Zeilen in einer Tabelle vorhanden sind oder alle Zeilen NULL sind, enthält die resultierende Skizze keine Index-Wert-Paare wie zum Beispiel `{"version":1,"logm":15,"sparse":{"indices":[],"values":[]}}`.
## Syntax
```
HLL_SKETCH_AGG (aggregate_expression[, lgConfigK ] )
```
## Argument
*aggregate\$1expression*
Jeder Ausdruck vom Typ INT, BIGINT, STRING oder BINARY, für den eine eindeutige Zählung erfolgt. Alle `NULL` Werte werden ignoriert.
*LgConfigK*
Eine optionale INT-Konstante zwischen 4 und 21 (einschließlich) mit dem Standardwert 12. Die Log-Base-2 von K, wobei K die Anzahl der Buckets oder Slots für die Skizze ist.
## Rückgabetyp
Die Funktion HLL\$1SKETCH\$1AGG gibt einen BINARY-Puffer zurück, der nicht NULL ist und die Skizze enthält, die aufgrund der Verwendung und Aggregation aller Eingabewerte in der HyperLogLog Aggregationsgruppe berechnet wurde.
## Beispiele
In den folgenden Beispielen wird der Algorithmus HyperLogLog (HLL) verwendet, um die eindeutige Anzahl der Werte in der Spalte zu schätzen. `col` Die `hll_sketch_agg(col, 12)` Funktion aggregiert die Werte in der Spalte col und erstellt so eine HLL-Skizze mit einer Genauigkeit von 12. Die `hll_sketch_estimate()` Funktion wird dann verwendet, um die eindeutige Anzahl von Werten auf der Grundlage der generierten HLL-Skizze zu schätzen. Das Endergebnis der Abfrage ist 3, was der geschätzten eindeutigen Anzahl von Werten in der `col` Spalte entspricht. In diesem Fall sind die unterschiedlichen Werte 1, 2 und 3.
```
SELECT hll_sketch_estimate(hll_sketch_agg(col, 12))
FROM VALUES (1), (1), (2), (2), (3) tab(col);
3
```
Im folgenden Beispiel wird auch der HLL-Algorithmus verwendet, um die eindeutige Anzahl von Werten in der `col` Spalte zu schätzen, aber es wird kein Genauigkeitswert für die HLL-Skizze angegeben. In diesem Fall wird die Standardgenauigkeit von 14 verwendet. Die `hll_sketch_agg(col)` Funktion verwendet die Werte in der `col` Spalte und erstellt eine HyperLogLog (HLL-) Skizze, bei der es sich um eine kompakte Datenstruktur handelt, mit der die unterschiedliche Anzahl von Elementen geschätzt werden kann. Die `hll_sketch_estimate(hll_sketch_agg(col))` Funktion berechnet anhand der im vorherigen Schritt erstellten HLL-Skizze eine Schätzung der unterschiedlichen Anzahl von Werten in der Spalte. `col` Das Endergebnis der Abfrage ist 3, was der geschätzten eindeutigen Anzahl von Werten in der `col` Spalte entspricht. In diesem Fall sind die unterschiedlichen Werte 1, 2 und 3.
```
SELECT hll_sketch_estimate(hll_sketch_agg(col))
FROM VALUES (1), (1), (2), (2), (3) tab(col);
3
```
# Funktion HLL\$1SKETCH\$1ESTIMATE
Die Funktion HLL\$1SKETCH\$1ESTIMATE verwendet eine HLL-Skizze und schätzt die Anzahl der eindeutigen Elemente, die durch die Skizze dargestellt werden. Sie verwendet den HyperLogLog (HLL) -Algorithmus, um eine probabilistische Annäherung an die Anzahl der Einzelwerte in einer bestimmten Spalte zu zählen. Dabei wird eine binäre Darstellung, ein sogenannter Sketch-Puffer, verwendet, der zuvor von der HLL\$1SKETCH\$1AGG-Funktion generiert wurde, und das Ergebnis als große Ganzzahl zurückgegeben.
Der HLL-Skizzieralgorithmus bietet eine effiziente Methode zur Schätzung der Anzahl eindeutiger Elemente, selbst bei großen Datensätzen, ohne dass der gesamte Satz von Einzelwerten gespeichert werden muss.
Mit den `hll_union_agg` Funktionen `hll_union` und können Skizzen auch miteinander kombiniert werden, indem sie diese Puffer als Eingaben verwenden und zusammenführen.
## Syntax
```
HLL_SKETCH_ESTIMATE (hllsketch_expression)
```
## Argument
*hllsketch\$1expression*
Ein `BINARY` Ausdruck, der eine von HLL\$1SKETCH\$1AGG generierte Skizze enthält
## Rückgabetyp
Die Funktion HLL\$1SKETCH\$1ESTIMATE gibt einen BIGINT-Wert zurück, der der ungefähren Anzahl unterschiedlicher Werte entspricht, die durch die Eingabeskizze dargestellt wird.
## Beispiele
In den folgenden Beispielen wird der Skizzieralgorithmus HyperLogLog (HLL) verwendet, um die Kardinalität (eindeutige Anzahl) der Werte in der Spalte zu schätzen. `col` Die `hll_sketch_agg(col, 12)` Funktion verwendet die `col` Spalte und erstellt eine HLL-Skizze mit einer Genauigkeit von 12 Bit. Die HLL-Skizze ist eine ungefähre Datenstruktur, mit der die Anzahl der eindeutigen Elemente in einem Satz effizient geschätzt werden kann. Die `hll_sketch_estimate()` Funktion verwendet die HLL-Skizze, die von erstellt wurde, `hll_sketch_agg` und schätzt die Kardinalität (eindeutige Anzahl) der durch die Skizze repräsentierten Werte. Die `FROM VALUES (1), (1), (2), (2), (3) tab(col);` generiert einen Testdatensatz mit 5 Zeilen, wobei die `col` Spalte die Werte 1, 1, 2, 2 und 3 enthält. Das Ergebnis dieser Abfrage ist die geschätzte eindeutige Anzahl der Werte in der `col` Spalte, die 3 ist.
```
SELECT hll_sketch_estimate(hll_sketch_agg(col, 12))
FROM VALUES (1), (1), (2), (2), (3) tab(col);
3
```
Der Unterschied zwischen dem folgenden und dem vorherigen Beispiel besteht darin, dass der Präzisionsparameter (12 Bit) im `hll_sketch_agg` Funktionsaufruf nicht angegeben ist. In diesem Fall wird die Standardgenauigkeit von 14 Bit verwendet, was im Vergleich zum vorherigen Beispiel, bei dem eine Genauigkeit von 12 Bit verwendet wurde, zu einer genaueren Schätzung der Anzahl von Einzelstücken führen kann.
```
SELECT hll_sketch_estimate(hll_sketch_agg(col))
FROM VALUES (1), (1), (2), (2), (3) tab(col);
3
```
# HLL\$1UNION-Funktion
Die Funktion HLL\$1UNION kombiniert zwei HLL-Skizzen zu einer einzigen, einheitlichen Skizze. Sie verwendet den HyperLogLog (HLL) -Algorithmus, um zwei Skizzen zu einer einzigen Skizze zu kombinieren. Abfragen können die resultierenden Puffer verwenden, um mit der Funktion ungefähre Einzelzahlen als lange Ganzzahlen zu berechnen. `hll_sketch_estimate`
## Syntax
```
HLL_UNION (( expr1, expr2 [, allowDifferentLgConfigK ] ))
```
## Argument
*ExprN*
Ein `BINARY` Ausdruck, der eine von HLL\$1SKETCH\$1AGG generierte Skizze enthält.
*allowDifferentLgConfigK*
Ein optionaler BOOLESCHER Ausdruck, der steuert, ob das Zusammenführen von zwei Skizzen mit unterschiedlichen LgConfigK-Werten zulässig ist. Der Standardwert ist `false`.
## Rückgabetyp
Die Funktion HLL\$1UNION gibt einen BINARY-Puffer zurück, der die HyperLogLog Skizze enthält, die als Ergebnis der Kombination der Eingabeausdrücke berechnet wurde. Wenn der `allowDifferentLgConfigK` Parameter gleich ist`true`, verwendet die Ergebnisskizze den kleineren der beiden angegebenen Werte. `lgConfigK`
## Beispiele
In den folgenden Beispielen wird der Skizzieralgorithmus HyperLogLog (HLL) verwendet, um die eindeutige Anzahl von Werten in zwei Spalten `col1` und in einem `col2` Datensatz zu schätzen.
Die `hll_sketch_agg(col1)` Funktion erstellt eine HLL-Skizze für die Einzelwerte in der Spalte. `col1`
Die `hll_sketch_agg(col2)` Funktion erstellt eine HLL-Skizze für die Einzelwerte in der Spalte col2.
Die `hll_union(...)` Funktion kombiniert die beiden in den Schritten 1 und 2 erstellten HLL-Skizzen zu einer einzigen, einheitlichen HLL-Skizze.
Die `hll_sketch_estimate(...)` Funktion verwendet die kombinierte HLL-Skizze und schätzt die eindeutige Anzahl der Werte für sowohl als auch. `col1` `col2`
Die `FROM VALUES` Klausel generiert einen Testdatensatz mit 5 Zeilen, der die Werte 1, 1, 2, 2 und 3 sowie die Werte 4, 4, 5, 5 und 6 `col2` enthält. `col1`
Das Ergebnis dieser Abfrage ist die geschätzte eindeutige Anzahl von Werten für beide `col1` und`col2`, die 6 ist. Der HLL-Skizzieralgorithmus bietet eine effiziente Methode zur Schätzung der Anzahl einzigartiger Elemente, selbst bei großen Datensätzen, ohne dass der gesamte Satz von Einzelwerten gespeichert werden muss. In diesem Beispiel wird die `hll_union` Funktion verwendet, um die HLL-Skizzen aus den beiden Spalten zu kombinieren, sodass die eindeutige Anzahl für den gesamten Datensatz geschätzt werden kann und nicht nur für jede Spalte einzeln.
```
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
```
Der Unterschied zwischen dem folgenden und dem vorherigen Beispiel besteht darin, dass der Präzisionsparameter (12 Bit) im `hll_sketch_agg` Funktionsaufruf nicht angegeben ist. In diesem Fall wird die Standardgenauigkeit von 14 Bit verwendet, was im Vergleich zum vorherigen Beispiel, bei dem eine Genauigkeit von 12 Bit verwendet wurde, zu einer genaueren Schätzung der Anzahl von Einzelstücken führen kann.
```
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);
```
# HLL\$1UNION\$1AGG-Funktion
Die Funktion HLL\$1UNION\$1AGG kombiniert mehrere HLL-Skizzen zu einer einzigen, einheitlichen Skizze. Sie verwendet den HyperLogLog (HLL) -Algorithmus, um eine Gruppe von Skizzen zu einer einzigen zu kombinieren. Abfragen können die resultierenden Puffer verwenden, um ungefähre Einzelzahlen mit der Funktion zu berechnen. `hll_sketch_estimate`
## Syntax
```
HLL_UNION_AGG ( expr [, allowDifferentLgConfigK ] )
```
## Argument
*expr*
Ein `BINARY` Ausdruck, der eine von HLL\$1SKETCH\$1AGG generierte Skizze enthält.
*allowDifferentLgConfigK*
Ein optionaler BOOLESCHER Ausdruck, der steuert, ob das Zusammenführen von zwei Skizzen mit unterschiedlichen LgConfigK-Werten zulässig ist. Der Standardwert ist `false`.
## Rückgabetyp
Die Funktion HLL\$1UNION\$1AGG gibt einen BINARY-Puffer zurück, der die HyperLogLog Skizze enthält, die als Ergebnis der Kombination der Eingabeausdrücke derselben Gruppe berechnet wurde. Wenn der `allowDifferentLgConfigK` Parameter gleich ist`true`, verwendet die Ergebnisskizze den kleineren der beiden angegebenen Werte. `lgConfigK`
## Beispiele
In den folgenden Beispielen wird der Skizzieralgorithmus HyperLogLog (HLL) verwendet, um die eindeutige Anzahl von Werten in mehreren HLL-Skizzen zu schätzen.
Im ersten Beispiel wird die eindeutige Anzahl von Werten in einem Datensatz geschätzt.
```
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
```
Die innere Abfrage erstellt zwei HLL-Skizzen:
+ Die erste SELECT-Anweisung erstellt eine Skizze aus einem einzelnen Wert von 1.
+ Die zweite SELECT-Anweisung erstellt eine Skizze aus einem anderen Einzelwert von 1, jedoch mit einer Genauigkeit von 20.
Die äußere Abfrage verwendet die Funktion HLL\$1UNION\$1AGG, um die beiden Skizzen zu einer einzigen Skizze zu kombinieren. Anschließend wendet sie die Funktion HLL\$1SKETCH\$1ESTIMATE auf diese kombinierte Skizze an, um die eindeutige Anzahl von Werten zu schätzen.
Das Ergebnis dieser Abfrage ist die geschätzte eindeutige Anzahl der Werte in der Spalte, d. h. `col` `1` Das bedeutet, dass die beiden Eingabewerte von 1 als eindeutig betrachtet werden, obwohl sie denselben Wert haben.
Das zweite Beispiel beinhaltet einen anderen Präzisionsparameter für die HLL\$1UNION\$1AGG-Funktion. In diesem Fall werden beide HLL-Skizzen mit einer Genauigkeit von 14 Bit erstellt, sodass sie erfolgreich mit dem Parameter kombiniert werden können. `hll_union_agg` `true`
```
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
```
Das Endergebnis der Abfrage ist die geschätzte eindeutige Anzahl, was in diesem Fall auch der Fall ist. `1` Das bedeutet, dass die beiden Eingabewerte von 1 als eindeutig betrachtet werden, obwohl sie denselben Wert haben.