Amazon Redshift unterstützt UDFs ab Patch 198 nicht mehr die Erstellung von neuem Python. Das bestehende Python UDFs wird bis zum 30. Juni 2026 weiterhin funktionieren. Weitere Informationen finden Sie im [Blog-Posting](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/). 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 skizzen In diesem Thema wird beschrieben, wie Sie HyperLogLog Skizzen in Amazon Redshift verwenden. HyperLogLog ist ein Algorithmus für das Count-Distinct Problem, bei dem die Anzahl der unterschiedlichen Elemente in einem Datensatz approximiert wird. HyperLogLog Skizzen sind Anordnungen von Eindeutigkeitsdaten eines Datensatzes. *HyperLogLog*ist ein Algorithmus, der zur Schätzung der Kardinalität eines Multisets verwendet wird. *Kardinalität* bezieht sich auf die Anzahl der einzelnen Werte in einer Multimenge. Zum Beispiel: In der Menge \$14,3,6,2,2,6,4,3,6,2,2,3\$1 ist die Kardinalität 4, da die einzelnen Werte 4, 3, 6 und 2 sind. Die Genauigkeit des HyperLogLog Algorithmus (auch als M-Wert bezeichnet) kann sich auf die Genauigkeit der geschätzten Kardinalität auswirken. Während der Kardinalitätsschätzung verwendet Amazon Redshift einen Standardgenauigkeitswert von 15. Bei kleineren Datensätzen ist ein Wert von bis zu 26 möglich. Die durchschnittliche relative Fehlerquote liegt also zwischen 0,01 und 0,6 %. Bei der Berechnung der Kardinalität einer Mehrfachmenge generiert der HyperLogLog Algorithmus ein Konstrukt, das als HLL-Skizze bezeichnet wird. *HLL-Skizzen *kapseln Informationen zu den unterschiedlichen Werte in einem Multiset. Der Amazon-Redshift-Datentyp HLLSKETCH repräsentiert diese Skizzenwerte. Der Datentyp kann verwendet werden, um Skizzen in einer Amazon-Redshift-Tabelle zu speichern. Darüber hinaus unterstützt Amazon Redshift Vorgänge, die als Aggregation- und Skalarfunktionen auf HLLSKETCH-Werte angewendet werden können. Mit diesen Funktionen können Sie die Kardinalität einer HLLSKETCH extrahieren und mehrere HLLSKETCH-Werte kombinieren. Der Datentyp HLLSKETCH bietet erhebliche Abfrageleistungsvorteile beim Extrahieren der Kardinalität aus großen Datensätzen. Sie können eine Voraggregation dieser Datensätze vornehmen, indem Sie HLLSKETCH-Werte verwenden und diese in Tabellen speichern. Amazon Redshift kann die Kardinalität direkt aus den gespeicherten HLLSKETCH-Werten extrahieren, ohne auf die zugrundeliegenden Datensätze zuzugreifen. Bei der Verarbeitung von HLL-Skizzen führt Amazon Redshift Optimierungen durch, die den Speicherbedarf der Skizze minimieren und die Genauigkeit der extrahierten Kardinalität maximieren. Amazon Redshift verwendet zwei Darstellungen für HLL-Skizzen, rudimentär und ausführlich. Zu Beginn hat eine HLLSKETCH ein rudimentäres Format. Wenn neue Werte in eingefügt werden, nimmt die Größe zu. Wenn die Größe die Größe der ausführlichen Darstellung erreicht hat, konvertiert Amazon Redshift die Skizze automatisch von rudimentär zu ausführlich. Amazon Redshift importiert, exportiert und gibt eine HLLSKETCH als JSON aus, wenn die Skizze ein rudimentäres Format hat. Amazon Redshift importiert, exportiert und gibt eine HLLSKETCH als Base64-Zeichenfolge aus, wenn die Skizze ein ausführliches Format hat. Weitere Informationen zu UNLOAD finden Sie unter [Entladen des Datentyps HLLSKETCH](r_UNLOAD.md#unload-usage-hll). Verwenden Sie den COPY-Befehl, um Text- oder CSV-Daten (Comma-Separated Value) in Amazon Redshift zu importieren. Weitere Informationen finden Sie unter [Laden des Datentyps HLLSKETCH](copy-usage_notes-hll.md). Hinweise zu Funktionen, die mit verwendet werden, finden Sie unter. HyperLogLog [HyperLogLog Funktionen](hyperloglog-functions.md) **Topics** + [Überlegungen](hyperloglog-functions-usage-notes.md) + [Einschränkungen](hyperloglog-functions-limitations.md) + [Beispiele](r_HLL-examples.md) # Überlegungen In diesem Thema werden Nutzungsdetails für HyperLogLog in Amazon Redshift beschrieben. Die folgenden Überlegungen sollten bei der Verwendung HyperLogLog in Amazon Redshift beachtet werden: + Die folgenden HyperLogLog Nichtfunktionen können eine Eingabe des Typs HLLSKETCH oder Spalten des Typs HLLSKETCH akzeptieren: + Die Aggregatfunktion COUNT + Die bedingten Ausdrücke COALESCE und NVL + CASE-Ausdrücke + Die unterstützte Kodierung ist RAW. + Sie können einen UNLOAD-Vorgang für eine Tabelle mit HLLSKETCH-Spalten in Text oder CSV-Spalten durchführen. Sie können die UNLOAD-HLLSKETCH-Spalten verwenden, um HLLSKETCH-Daten zu schreiben. Amazon Redshift zeigt Daten für eine rudimentäre Darstellung im JSON-Format und für eine ausführliche Darstellung im Base64-Format an. Weitere Informationen zu UNLOAD finden Sie unter [Entladen des Datentyps HLLSKETCH](r_UNLOAD.md#unload-usage-hll). Im Folgenden wird das Format gezeigt, das für eine dünn besetzte HyperLogLog Skizze verwendet wird, die in einem JSON-Format dargestellt wird. ``` {"version":1,"logm":15,"sparse":{"indices":[15099259,33107846,37891580,50065963],"values":[2,3,2,1]}} ``` + Sie können Text- oder CSV-Daten mit dem Befehl COPY in Amazon Redshift importieren. Weitere Informationen finden Sie unter [Laden des Datentyps HLLSKETCH](copy-usage_notes-hll.md). + Die Standardkodierung für HLLSKETCH ist RAW. Weitere Informationen finden Sie unter [Kompressionskodierungen](c_Compression_encodings.md). # Einschränkungen In diesem Thema werden Einschränkungen für HyperLogLog in Amazon Redshift beschrieben. Die folgenden Einschränkungen gelten für die Verwendung HyperLogLog in Amazon Redshift: + Amazon-Redshift-Tabellen unterstützen keine HLLSKETCH-Spalte als Sortierschlüssel oder Verteilungsschlüssel. + Amazon Redshift unterstützt keine HLLSKETCH-Spalten in ORDER-BY-, GROUP-BY- oder DISTINCT-Klauseln. + Sie können HLLSKETCH-Spalten nur im Text- oder CSV-Format entladen. Amazon Redshift schreibt die HLLSKETCH-Daten dann entweder im JSON- oder im Base64-Format. Weitere Informationen zu UNLOAD finden Sie unter [UNLOAD](r_UNLOAD.md). + Amazon Redshift unterstützt nur HyperLogLog Skizzen mit einer Genauigkeit (Logm-Wert) von 15. + JDBC- und ODBC-Treiber unterstützen den HLLSKETCH-Datentyp nicht. Daher verwendet der Ergebnissatz VARCHAR, um die HLLSKETCH-Werte darzustellen. + Amazon Redshift Spectrum unterstützt die HLLSKETCH-Daten nicht standardmäßig. Daher können Sie keine externe Tabelle mit einer HLLSKETCH-Spalte erstellen oder ändern. + Datentypen für benutzerdefinierte Python-Funktionen (UDFs) unterstützen den HLLSKETCH-Datentyp nicht. Weitere Hinweise zu Python finden UDFs Sie unter[Skalares Python UDFs](udf-creating-a-scalar-udf.md). **Anmerkung** Ab dem 1. November 2025 wird Amazon Redshift die Erstellung von neuem Python UDFs nicht mehr unterstützen. Das bestehende Python UDFs wird bis zum 30. Juni 2026 weiterhin funktionieren. Ab dem 1. Juli 2026 wird Amazon Redshift Python nicht mehr unterstützen. UDFs Wir empfehlen, dass Sie Ihr vorhandenes Python UDFs vor dem 1. November 2025 UDFs auf Lambda migrieren. Informationen zur Erstellung und Verwendung von Lambda finden Sie UDFs unter[Skalares Lambda UDFs](udf-creating-a-lambda-sql-udf.md). Informationen zur Konvertierung von vorhandenem Python UDFs nach Lambda UDFs finden Sie im [Blogbeitrag](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/). # Beispiele Dieser Abschnitt enthält Beispiele für die Verwendung HyperLogLog mit Amazon Redshift. **Topics** + [Beispiel: Rückgabe der Kardinalität in einer Unterabfrage](#hll-examples-subquery) + [Beispiel: Rückgabe eines HLLSKETCH-Typs von kombinierten Skizzen in einer Unterabfrage](#hll-examples-combined-subquery) + [Beispiel: Gibt eine HyperLogLog Skizze aus der Kombination mehrerer Skizzen zurück](#hll-examples-multiple-sketches) + [Beispiel: Generieren Sie mithilfe externer HyperLogLog Tabellen Skizzen anhand von S3-Daten](#hll-examples-cache-sketches) ## Beispiel: Rückgabe der Kardinalität in einer Unterabfrage Im folgenden Beispiel wird die Kardinalität für jede Skizze in einer Unterabfrage für eine Tabelle mit dem Namen *Sales (Vertrieb)* zurückgegeben. ``` CREATE TABLE Sales (customer VARCHAR, country VARCHAR, amount BIGINT); INSERT INTO Sales VALUES ('David Joe', 'Greece', 14.5), ('David Joe', 'Greece', 19.95), ('John Doe', 'USA', 29.95), ('John Doe', 'USA', 19.95), ('George Spanos', 'Greece', 9.95), ('George Spanos', 'Greece', 2.95); ``` Die folgende Abfrage generiert eine HLL-Skizze für die Kunden jedes Landes und extrahiert die Kardinalität. So werden die eindeutigen Kunden aus jedem Land angezeigt. ``` SELECT hll_cardinality(sketch), country FROM (SELECT hll_create_sketch(customer) AS sketch, country FROM Sales GROUP BY country) AS hll_subquery; hll_cardinality | country ----------------+--------- 1 | USA 2 | Greece ... ``` ## Beispiel: Rückgabe eines HLLSKETCH-Typs von kombinierten Skizzen in einer Unterabfrage Im folgenden Beispiel wird ein einzelner HLLSKETCH-Typ zurückgegeben, der die Kombination einzelner Skizzen aus einer Unterabfrage darstellt. Die Skizzen werden mit der Aggregationsfunktion HLL\$1COMBINE kombiniert. ``` SELECT hll_combine(sketch) FROM (SELECT hll_create_sketch(customer) AS sketch FROM Sales GROUP BY country) AS hll_subquery hll_combine -------------------------------------------------------------------------------------------- {"version":1,"logm":15,"sparse":{"indices":[29808639,35021072,47612452],"values":[1,1,1]}} (1 row) ``` ## Beispiel: Gibt eine HyperLogLog Skizze aus der Kombination mehrerer Skizzen zurück Im folgenden Beispiel nehmen wir an, dass die Tabelle `page-users` die voraggregierten Skizzen für jede Seite speichert, die Benutzer auf einer bestimmten Website besucht haben. Jede Zeile in dieser Tabelle enthält eine HyperLogLog Skizze, die alle Benutzer darstellt IDs , die die besuchten Seiten aufrufen. ``` page_users -- +----------------+-------------+--------------+ -- | _PARTITIONTIME | page | sketch | -- +----------------+-------------+--------------+ -- | 2019-07-28 | homepage | CHAQkAQYA... | -- | 2019-07-28 | Product A | CHAQxPnYB... | -- +----------------+-------------+--------------+ ``` Im folgenden Beispiel werden die voraggregierten Skizzen zu einer einzelnen Skizze zusammengefasst. Diese Skizze kapselt die kollektive Kardinalität, die jede Skizze kapselt. ``` SELECT hll_combine(sketch) as sketch FROM page_users ``` Die Ausgabe sieht folgendermaßen oder ähnlich aus. ``` -- +-----------------------------------------+ -- | sketch | -- +-----------------------------------------+ -- | CHAQ3sGoCxgCIAuCB4iAIBgTIBgqgIAgAwY.... | -- +-----------------------------------------+ ``` Wenn eine neue Skizze erstellt wird, können Sie die Funktion HLL\$1CARDINALITY verwenden, um die kollektiven eindeutigen Werte abzurufen, wie im Folgenden gezeigt. ``` SELECT hll_cardinality(sketch) FROM ( SELECT hll_combine(sketch) as sketch FROM page_users ) AS hll_subquery ``` Die Ausgabe sieht folgendermaßen oder ähnlich aus. ``` -- +-------+ -- | count | -- +-------+ -- | 54356 | -- +-------+ ``` ## Beispiel: Generieren Sie mithilfe externer HyperLogLog Tabellen Skizzen anhand von S3-Daten In den folgenden Beispielen werden HyperLogLog Skizzen zwischengespeichert, um zu vermeiden, dass zur Kardinalitätsschätzung direkt auf Amazon S3 zugegriffen wird. Sie können HyperLogLog Skizzen vorab aggregieren und in externen Tabellen zwischenspeichern, die für Amazon S3 S3-Daten definiert sind. Auf diese Weise können Sie Kardinalitätsschätzungen extrahieren, ohne auf die zugrundeliegenden Basisdaten zuzugreifen. Angenommen, Sie haben eine Reihe von Textdateien mit Tabulatortrennzeichen in Amazon S3 entladen. Sie führen die folgende Abfrage aus, um eine externe Tabelle mit Namen `sales` im externen Amazon-Redshift-Schema mit dem Namen `spectrum` zu definieren. Der Amazon S3 S3-Bucket für dieses Beispiel befindet sich im Osten der USA (Nord-Virginia) AWS-Region. ``` create external table spectrum.sales( salesid integer, listid integer, sellerid smallint, buyerid smallint, eventid integer, dateid integer, qtysold integer, pricepaid decimal(8,2), commission decimal(8,2), saletime timestamp) row format delimited fields terminated by '\t' stored as textfile location 's3://redshift-downloads/tickit/spectrum/sales/'; ``` Angenommen, Sie möchten die einzelnen Käufer berechnen, die einen Artikel zu einem beliebigen Datum gekauft haben. Zu diesem Zweck generiert das folgende Beispiel Skizzen für den Käufer IDs für jeden Tag des Jahres und speichert das Ergebnis in der Amazon Redshift Redshift-Tabelle. `hll_sales` ``` CREATE TABLE hll_sales AS SELECT saletime, hll_create_sketch(buyerid) AS sketch FROM spectrum.sales GROUP BY saletime; SELECT TOP 5 * FROM hll_sales; ``` Die Ausgabe sieht folgendermaßen oder ähnlich aus. ``` -- hll_sales -- | saletime | sketch | -- +-----------------+---------------------------------------------------------------------+ -- | 7/22/2008 8:30 | {"version":1,"logm":15,"sparse":{"indices":[9281416],"values":[1]}} -- | 2/19/2008 0:38 | {"version":1,"logm":15,"sparse":{"indices":[48735497],"values":[3]}} -- | 11/5/2008 4:49 | {"version":1,"logm":15,"sparse":{"indices":[27858661],"values":[1]}} -- | 10/27/2008 4:08 | {"version":1,"logm":15,"sparse":{"indices":[65295430],"values":[2]}} -- | 2/16/2008 9:37 | {"version":1,"logm":15,"sparse":{"indices":[56869618],"values":[2]}} -- +---------------- +---------------------------------------------------------------------+ ``` Die folgende Abfrage extrahiert die geschätzte Anzahl verschiedener Käufer, die am Black Friday 2008 einen Artikel gekauft haben. ``` SELECT hll_cardinality(hll_combine(sketch)) as distinct_buyers FROM hll_sales WHERE trunc(saletime) = '2008-11-28'; ``` Die Ausgabe sieht folgendermaßen oder ähnlich aus. ``` distinct_buyers --------------- 386 ``` Angenommen, Sie möchten die Anzahl der eindeutigen Benutzer, die einen Artikel an einem bestimmten Datumsbereich gekauft haben abrufen. Der Zeitraum könnte sich zum Beispiel vom Black Friday bis zum darauffolgenden Montag erstrecken. Um diese Information abzurufen, verwendet die folgende Abfrage die Aggregationsfunktion `hll_combine`. Mit dieser Funktion können Sie vermeiden, dass Käufer doppelt gezählt werden, die einen Artikel an mehr als einem Tag des ausgewählten Bereichs gekauft haben. ``` SELECT hll_cardinality(hll_combine(sketch)) as distinct_buyers FROM hll_sales WHERE saletime BETWEEN '2008-11-28' AND '2008-12-01'; ``` Die Ausgabe sieht folgendermaßen oder ähnlich aus. ``` distinct_buyers --------------- 1166 ``` Um die `hll_sales` Tabelle beizubehalten up-to-date, führen Sie am Ende jedes Tages die folgende Abfrage aus. Auf diese Weise wird eine HyperLogLog Skizze erstellt, die auf IDs der Anzahl der Käufer basiert, die heute einen Artikel gekauft haben, und dieser wird der `hll_sales` Tabelle hinzugefügt. ``` INSERT INTO hll_sales SELECT saletime, hll_create_sketch(buyerid) FROM spectrum.sales WHERE TRUNC(saletime) = to_char(GETDATE(), 'YYYY-MM-DD') GROUP BY saletime; ```