Amazon Redshift non supporterà più la creazione di nuovi Python UDFs a partire dalla Patch 198. Python esistente UDFs continuerà a funzionare fino al 30 giugno 2026. Per ulteriori informazioni, consulta il [post del blog](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/).
Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# HyperLogLog schizzi
Questo argomento descrive come utilizzare gli HyperLogLog sketch in Amazon Redshift. HyperLogLog è un algoritmo per il problema del conteggio distinto, che approssima il numero di elementi distinti in un set di dati. HyperLogLog gli schizzi sono matrici di dati sull'unicità di un set di dati.
*HyperLogLog*è un algoritmo utilizzato per stimare la cardinalità di un multiset. Per *cardinalità* si intende il numero di valori distinti in un multiset. Ad esempio, nell'insieme di \$14,3,6,2,2,6,4,3,6,2,2,3\$1, la cardinalità è 4 con valori distinti di 4, 3, 6 e 2.
La precisione dell' HyperLogLog algoritmo (nota anche come valore m) può influire sulla precisione della cardinalità stimata. Durante la stima della cardinalità, Amazon Redshift utilizza un valore di precisione di default pari a 15. Questo valore può essere fino a 26 per i set di dati più piccoli. Pertanto, l'errore relativo medio varia tra lo 0,01 e lo 0,6%.
Quando si calcola la cardinalità di un multiset, l' HyperLogLog algoritmo genera un costrutto chiamato sketch HLL. Uno *schizzo HLL* incapsula le informazioni sui valori distinti in un multiset. Il tipo di dati Amazon Redshift HLLSKETCH rappresenta tali valori di schizzo. Questo tipo di dati può essere utilizzato per memorizzare gli schizzi in una tabella Amazon Redshift. Inoltre, Amazon Redshift supporta operazioni che possono essere applicate ai valori HLLSKETCH come funzioni di aggregazione e scalari. È possibile utilizzare queste funzioni per estrarre la cardinalità di un HLLSKETCH e combinare più valori HLLSKETCH.
Il tipo di dati HLLSKETCH offre notevoli vantaggi in termini di prestazioni di query quando si estrae la cardinalità da set di dati di grandi dimensioni. È possibile preaggregare questi set di dati utilizzando i valori HLLSKETCH e memorizzarli nelle tabelle. Amazon Redshift può estrarre la cardinalità direttamente dai valori HLLSKETCH memorizzati senza accedere ai set di dati sottostanti.
Durante l'elaborazione degli schizzi HLL, Amazon Redshift esegue ottimizzazioni che riducono al minimo l'ingombro di memoria dello schizzo e massimizzano la precisione della cardinalità estratta. Amazon Redshift utilizza due rappresentazioni per schizzi HLL, sparse e dense. Un HLLSKETCH inizia in formato sparso. Man mano che vengono inseriti nuovi valori, le sue dimensioni aumentano. Dopo che la sua dimensione raggiunge la dimensione della rappresentazione densa, Amazon Redshift converte automaticamente lo schizzo da sparso a denso.
Amazon Redshift importa, esporta e stampa un HLLSKETCH come JSON quando lo schizzo è in un formato sparso. Amazon Redshift importa, esporta e stampa un HLLSKETCH come stringa Base64 quando lo schizzo è in un formato denso. Per ulteriori informazioni su UNLOAD, consultare [Scarico del tipo di dati HLLSKETCH](r_UNLOAD.md#unload-usage-hll). Per importare dati contenenti testo o valori separati da virgola (CSV) in Amazon Redshift, utilizzare il comando COPY. Per ulteriori informazioni, consulta [Caricamento del tipo di dati HLLSKETCH](copy-usage_notes-hll.md).
Per informazioni sulle funzioni utilizzate con, vedere. HyperLogLog [HyperLogLog funzioni](hyperloglog-functions.md)
**Topics**
+ [Considerazioni](hyperloglog-functions-usage-notes.md)
+ [Limitazioni](hyperloglog-functions-limitations.md)
+ [Esempi](r_HLL-examples.md)
# Considerazioni
Questo argomento descrive i dettagli di utilizzo per HyperLogLog Amazon Redshift.
Di seguito sono riportate le considerazioni relative all'utilizzo HyperLogLog in Amazon Redshift:
+ Le seguenti non HyperLogLog funzioni possono accettare un input di tipo HLLSKETCH o colonne di tipo HLLSKETCH:
+ La funzione di aggregazione COUNT
+ Le espressioni condizionali COALESCE e NVL
+ Espressioni CASE
+ La codifica supportata è RAW.
+ È possibile eseguire un'operazione di UNLOAD sulla tabella con colonne HLLSKETCH in testo o CSV. È possibile usare le colonne UNLOAD HLLSKETCH per scrivere dati HLLSKETCH. Amazon Redshift mostra i dati in un formato JSON per una rappresentazione sparsa o un formato Base64 per una rappresentazione densa. Per ulteriori informazioni su UNLOAD, consultare [Scarico del tipo di dati HLLSKETCH](r_UNLOAD.md#unload-usage-hll).
Di seguito viene illustrato il formato utilizzato per uno schizzo sparso HyperLogLog rappresentato in formato JSON.
```
{"version":1,"logm":15,"sparse":{"indices":[15099259,33107846,37891580,50065963],"values":[2,3,2,1]}}
```
+ È possibile importare testo o dati CSV in Amazon Redshift utilizzando il comando COPY. Per ulteriori informazioni, consultare [Caricamento del tipo di dati HLLSKETCH](copy-usage_notes-hll.md).
+ La codifica di default per HLLSKETCH è RAW. Per ulteriori informazioni, consulta [Codifiche di compressione](c_Compression_encodings.md).
# Limitazioni
Questo argomento descrive le limitazioni HyperLogLog di Amazon Redshift.
Di seguito sono riportate le limitazioni per l'utilizzo HyperLogLog in Amazon Redshift:
+ Le tabelle Amazon Redshift non supportano una colonna HLLSKETH come chiave di ordinamento o chiave di distribuzione per una tabella Amazon Redshift.
+ Amazon Redshift non supporta colonne HLLSKETCH nelle clausole ORDER BY, GROUP BY o DISTINCT.
+ È possibile scaricare colonne di tipo UNLOAD HLLSKETCH solo in formato testo o CSV. Amazon Redshift scrive quindi i dati HLLSKETCH in un formato JSON o Base64. Per ulteriori informazioni su UNLOAD, consultare [UNLOAD](r_UNLOAD.md).
+ Amazon Redshift supporta solo HyperLogLog schizzi con una precisione (valore logm) di 15.
+ I driver JDBC e ODBC non supportano il tipo di dati HLLSKETCH. Pertanto, per rappresentare i valori HLLSKETCH il set di risultati utilizza VARCHAR.
+ Amazon Redshift Spectrum non supporta nativamente i dati HLLSKETCH. Per questo motivo non è possibile creare o modificare una tabella esterna con una colonna HLLSKETCH.
+ I tipi di dati per le funzioni definite dall'utente Python (UDFs) non supportano il tipo di dati HLLSKETCH. Per ulteriori informazioni su Python UDFs, vedere. [Python scalare UDFs](udf-creating-a-scalar-udf.md)
**Nota**
A partire dal 1° novembre 2025, Amazon Redshift non supporterà più la creazione di nuovi Python. UDFs Python esistente UDFs continuerà a funzionare fino al 30 giugno 2026. A partire dal 1° luglio 2026, Amazon Redshift non supporterà più Python. UDFs Ti consigliamo di migrare il tuo UDFs Python esistente a UDFs Lambda prima del 1° novembre 2025. Per informazioni sulla creazione e l'utilizzo di Lambda UDFs, consulta. [Lambda scalare UDFs](udf-creating-a-lambda-sql-udf.md) [Per informazioni sulla conversione di UDFs Python esistente in UDFs Lambda, consulta il post del blog.](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/)
# Esempi
Questa sezione contiene esempi di utilizzo HyperLogLog con Amazon Redshift.
**Topics**
+ [Esempio: restituzione della cardinalità in una query secondaria](#hll-examples-subquery)
+ [Esempio: restituzione di un tipo HLLSKETCH da schizzi combinati in una query secondaria](#hll-examples-combined-subquery)
+ [Esempio: restituisci uno HyperLogLog schizzo combinando più schizzi](#hll-examples-multiple-sketches)
+ [Esempio: generazione di HyperLogLog schizzi su dati S3 utilizzando tabelle esterne](#hll-examples-cache-sketches)
## Esempio: restituzione della cardinalità in una query secondaria
L'esempio seguente restituisce la cardinalità per ogni schizzo in una query secondaria per una tabella denominata *Sales*.
```
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);
```
La query seguente genera uno schizzo HLL per i clienti di ogni paese ed estrae la cardinalità. Questo mostra clienti unici di ogni paese.
```
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
...
```
## Esempio: restituzione di un tipo HLLSKETCH da schizzi combinati in una query secondaria
Nell'esempio seguente viene restituito un singolo tipo HLLSKETCH che rappresenta la combinazione di singoli schizzi da una query secondaria. Gli schizzi vengono combinati utilizzando la funzione di aggregazione HLL\$1COMBINE.
```
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)
```
## Esempio: restituisci uno HyperLogLog schizzo combinando più schizzi
Per l'esempio riportato di seguito, si supponga che la tabella `page-users` memorizzi gli schizzi preaggregati per ogni pagina visitata dagli utenti su un determinato sito Web. Ogni riga di questa tabella contiene uno HyperLogLog schizzo che rappresenta tutti gli utenti IDs che mostrano le pagine visitate.
```
page_users
-- +----------------+-------------+--------------+
-- | _PARTITIONTIME | page | sketch |
-- +----------------+-------------+--------------+
-- | 2019-07-28 | homepage | CHAQkAQYA... |
-- | 2019-07-28 | Product A | CHAQxPnYB... |
-- +----------------+-------------+--------------+
```
Nell'esempio seguente vengono uniti gli schizzi preaggregati e viene generato un singolo schizzo. Questo schizzo incapsula la cardinalità collettiva incapsulata da ogni schizzo.
```
SELECT hll_combine(sketch) as sketch
FROM page_users
```
L'output è simile al seguente.
```
-- +-----------------------------------------+
-- | sketch |
-- +-----------------------------------------+
-- | CHAQ3sGoCxgCIAuCB4iAIBgTIBgqgIAgAwY.... |
-- +-----------------------------------------+
```
Quando viene creato un nuovo schizzo, è possibile utilizzare la funzione HLL\$1CARDINALITY per ottenere i valori distinti collettivi, come illustrato di seguito.
```
SELECT hll_cardinality(sketch)
FROM (
SELECT
hll_combine(sketch) as sketch
FROM page_users
) AS hll_subquery
```
L'output è simile al seguente.
```
-- +-------+
-- | count |
-- +-------+
-- | 54356 |
-- +-------+
```
## Esempio: generazione di HyperLogLog schizzi su dati S3 utilizzando tabelle esterne
Gli esempi seguenti memorizzano nella cache gli HyperLogLog sketch per evitare di accedere direttamente ad Amazon S3 per la stima della cardinalità.
Puoi preaggregare e memorizzare nella cache HyperLogLog gli schizzi in tabelle esterne definite per contenere dati Amazon S3. In questo modo, è possibile estrarre stime di cardinalità senza accedere ai dati di base sottostanti.
Ad esempio, si supponga di aver scaricato un set di file di testo delimitati da tabulazioni in Amazon S3. La query riportata di seguito viene eseguita per definire una tabella esterna denominata `sales` nello schema esterno Amazon Redshift denominato `spectrum`. Il bucket Amazon S3 per questo esempio si trova negli Stati Uniti orientali (Virginia settentrionale). Regione AWS
```
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/';
```
Si supponga di voler calcolare gli acquirenti distinti che hanno acquistato un articolo in determinate date. A tale scopo, l'esempio seguente genera schizzi per l'acquirente IDs per ogni giorno dell'anno e memorizza il risultato nella tabella Amazon `hll_sales` Redshift.
```
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;
```
L'output è simile al seguente.
```
-- 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]}}
-- +---------------- +---------------------------------------------------------------------+
```
La query seguente estrae il numero stimato di acquirenti distinti che hanno acquistato un articolo durante il venerdì successivo al Ringraziamento nel 2008.
```
SELECT hll_cardinality(hll_combine(sketch)) as distinct_buyers
FROM hll_sales
WHERE trunc(saletime) = '2008-11-28';
```
L'output è simile al seguente.
```
distinct_buyers
---------------
386
```
Si supponga che si desidera il numero di utenti distinti che hanno acquistato un articolo in un determinato intervallo di date. Un esempio potrebbe essere dal venerdì dopo il Ringraziamento al lunedì successivo. Per ottenere questo risultato, la query seguente utilizza la funzione di aggregazione `hll_combine`. Questa funzione consente di evitare il doppio conteggio degli acquirenti che hanno acquistato un articolo in più di un giorno dell'intervallo selezionato.
```
SELECT hll_cardinality(hll_combine(sketch)) as distinct_buyers
FROM hll_sales
WHERE saletime BETWEEN '2008-11-28' AND '2008-12-01';
```
L'output è simile al seguente.
```
distinct_buyers
---------------
1166
```
Per conservare la `hll_sales` tabella up-to-date, esegui la seguente query alla fine di ogni giornata. In questo modo viene generato uno HyperLogLog schizzo basato sugli acquirenti che hanno acquistato un articolo oggi e lo si aggiunge alla `hll_sales` tabella. IDs
```
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;
```