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à.
# Amazon Redshift Spectrum
In questa sezione viene illustrato come utilizzare Redshift Spectrum per leggere in modo efficiente i dati da Amazon S3.
Con Amazon Redshift Spectrum puoi eseguire query e recuperare in modo efficace i dati strutturati e semistrutturati dai file in Amazon S3 senza dover caricare i dati nelle tabelle Amazon Redshift. Le query di Redshift Spectrum vengono eseguite molto rapidamente su set di dati di grandi dimensioni grazie a un parallelismo massiccio. L'elaborazione viene eseguita principalmente nel livello di Redshift Spectrum e la maggior parte dei dati rimane in Amazon S3. Più cluster possono eseguire simultaneamente query sullo stesso set di dati in Amazon S3 senza la necessità di effettuare copie dei dati per ogni cluster.
**Topics**
+ [Panoramica di Amazon Redshift Spectrum](c-spectrum-overview.md)
+ [Nozioni di base su Amazon Redshift Spectrum](c-getting-started-using-spectrum.md)
+ [Interroga le tabelle Amazon S3 da Amazon Redshift](querying-s3Tables.md)
+ [Policy IAM per Amazon Redshift Spectrum](c-spectrum-iam-policies.md)
+ [Redshift Spectrum e AWS Lake Formation](spectrum-lake-formation.md)
+ [File di dati per le query in Amazon Redshift Spectrum](c-spectrum-data-files.md)
+ [Schemi esterni in Amazon Redshift Spectrum](c-spectrum-external-schemas.md)
+ [Tabelle esterne per Redshift Spectrum](c-spectrum-external-tables.md)
+ [Utilizzo delle tabelle Apache Iceberg con Amazon Redshift](querying-iceberg.md)
+ [Prestazioni delle query di Amazon Redshift Spectrum](c-spectrum-external-performance.md)
+ [Opzioni per la gestione dei dati](t_setting-data-handling-options.md)
+ [Esempio: esecuzione di sottoquery correlate in Redshift Spectrum](c_performing-correlated-subqueries-spectrum.md)
+ [Metriche in Amazon Redshift Spectrum](c-spectrum-metrics.md)
+ [Risoluzione dei problemi relativi alle query in Amazon Redshift Spectrum](c-spectrum-troubleshooting.md)
+ [Tutorial: Esecuzione di query su dati nidificati con Amazon Redshift Spectrum](tutorial-query-nested-data.md)
# Panoramica di Amazon Redshift Spectrum
In questo argomento viene descritto nei dettagli come utilizzare Redshift Spectrum per leggere in modo efficiente da Amazon S3.
Amazon Redshift Spectrum si trova su dei server Amazon Redshift dedicati indipendenti dal cluster. Amazon Redshift trasmette al livello Redshift Spectrum molte attività che richiedono un'importante capacità di calcolo, come l'aggregazione e il filtraggio di predicati. Le query di Redshift Spectrum utilizzano quindi una capacità di elaborazione del cluster molto inferiore rispetto alle altre query. Redshift Spectrum consente inoltre un dimensionamento intelligente. In base alle richieste delle query, Redshift può potenzialmente utilizzare migliaia di istanze per beneficiare dell'elaborazione MPP (Massive Parallel Processing).
Per creare le tabelle di Redshift Spectrum, è necessario definire la struttura dei file e registrare quest'ultimi come tabelle in un catalogo dati esterno. Il catalogo dati esterno può essere AWS Glue il catalogo dati fornito con Amazon Athena o il tuo metastore Apache Hive. È possibile creare e gestire le tabelle esterne da Amazon Redshift utilizzando comandi DDL (data definition language) o qualsiasi altro strumento che si connette al catalogo di dati esterno. Le modifiche al catalogo di dati esterno sono immediatamente disponibili per tutti i cluster Amazon Redshift.
Inoltre, se lo desideri, puoi partizionare le tabelle esterne in una o più colonne. Questa operazione può consentire di migliorare le prestazioni, Il miglioramento si verifica in quanto l'ottimizzatore di query di Amazon Redshift elimina le partizioni che non contengono dati per la query.
Le viste materializzate delle tabelle Spectrum possono migliorare notevolmente i costi e le prestazioni. Per ulteriori informazioni, consulta [Viste materializzate per le tabelle di data lake esterne in Amazon Redshift SpectrumViste materializzate per le tabelle di data lake esterne](materialized-view-external-table.md).
Dopo la definizione delle tabelle di Redshift Spectrum, è possibile sottoporle a query e join esattamente come con qualunque altra tabella Amazon Redshift. Redshift Spectrum non supporta le operazioni di aggiornamento sulle tabelle esterne. Puoi aggiungere tabelle Redshift Spectrum a più cluster Amazon Redshift e interrogare gli stessi dati su Amazon S3 da qualsiasi cluster nella stessa regione. AWS Quando si aggiornano i file di dati Amazon S3, i dati diventano immediatamente disponibili per query da qualsiasi cluster Amazon Redshift.
Il catalogo AWS Glue dati a cui accedi potrebbe essere crittografato per aumentare la sicurezza. Se il AWS Glue catalogo è crittografato, è necessaria la chiave AWS Key Management Service (AWS KMS) AWS Glue per accedere al AWS Glue catalogo. AWS Glue la crittografia del catalogo non è disponibile in tutte le AWS regioni. Per un elenco delle AWS regioni supportate, consulta [Encryption and Secure Access AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/encryption-glue-resources.html) nella *[AWS Glue Developer Guide](https://docs.aws.amazon.com/glue/latest/dg/).*Per ulteriori informazioni sulla crittografia del catalogo AWS Glue dati, [consulta Encrypting Your AWS Glue Data Catalog](https://docs.aws.amazon.com/glue/latest/dg/encrypt-glue-data-catalog.html) nella *[Guida per gli AWS Glue sviluppatori](https://docs.aws.amazon.com/glue/latest/dg/)*.
**Nota**
Non è possibile visualizzare i dettagli per le tabelle Redshift Spectrum che utilizzano le stesse risorse utilizzate per le tabelle Amazon Redshift standard come [PG\$1TABLE\$1DEF](r_PG_TABLE_DEF.md), [STV\$1TBL\$1PERM](r_STV_TBL_PERM.md), PG\$1CLASS o information\$1schema. Se il tuo strumento di business intelligence o di analisi non riconosce le tabelle esterne Redshift Spectrum, configura l'applicazione per eseguire la query su [SVV\$1EXTERNAL\$1TABLES](r_SVV_EXTERNAL_TABLES.md) e [SVV\$1EXTERNAL\$1COLUMNS](r_SVV_EXTERNAL_COLUMNS.md).
## Regioni di Amazon Redshift Spectrum
Redshift Spectrum è disponibile Regioni AWS dove è disponibile Amazon Redshift, se non diversamente specificato nella documentazione specifica della regione. Per Regione AWS la disponibilità nelle aree commerciali, consulta [Endpoints di servizio](https://docs.aws.amazon.com/general/latest/gr/redshift-service.html#redshift_region) per l'API **Redshift** nel. *Riferimenti generali di Amazon Web Services*
# Limitazioni di Amazon Redshift Spectrum
In questo argomento vengono descritte le limitazioni per l’uso di Redshift Spectrum.
Quando utilizzi Amazon Redshift Spectrum, tieni in considerazione quanto segue:
+ Il cluster Amazon Redshift e il bucket Amazon S3 devono trovarsi nella stessa regione. AWS
+ Redshift Spectrum non supporta il routing VPC avanzato con i cluster con provisioning. Per accedere ai dati di Amazon S3 potrebbe essere necessario eseguire fasi di configurazioni aggiuntive. Per ulteriori informazioni, consulta [Utilizzo di Redshift Spectrum con routing VPC avanzato](https://docs.aws.amazon.com/redshift/latest/mgmt/spectrum-enhanced-vpc.html) nella *Guida alla gestione di Amazon Redshift*.
+ Redshift Spectrum supporta gli alias degli Access Point Amazon S3. Per ulteriori informazioni, consulta [Utilizzo di un alias in stile bucket per il punto di accesso](https://docs.aws.amazon.com/AmazonS3/latest/userguide/access-points-alias.html) nella *Guida dell'utente Amazon Simple Storage Service*. Tuttavia, Redshift Spectrum non supporta VPC con alias dei punti di accesso Amazon S3. Per ulteriori informazioni, consulta [Utilizzo di Redshift Spectrum con routing VPC avanzato](https://docs.aws.amazon.com/redshift/latest/mgmt/spectrum-enhanced-vpc.html) nella *Guida alla gestione di Amazon Redshift*.
+ Non puoi eseguire operazioni di aggiornamento o eliminazione sulle tabelle esterne. Per creare una nuova tabella esterna nello schema specificato, puoi utilizzare CREATE EXTERNAL TABLE. Per ulteriori informazioni su CREATE EXTERNAL TABLE AS, consultare [CREATE EXTERNAL TABLE](r_CREATE_EXTERNAL_TABLE.md). Per inserire i risultati di una query SELECT nelle tabelle esterne esistenti nei cataloghi esterni, puoi utilizzare INSERT (tabella esterna). Per ulteriori informazioni su INSERT (tabella esterna), consultare [INSERT (tabella esterna)](r_INSERT_external_table.md).
+ A meno AWS Glue Data Catalog che tu non stia utilizzando uno abilitato per AWS Lake Formation, non puoi controllare le autorizzazioni degli utenti su una tabella esterna. Puoi invece concedere e revocare autorizzazioni per lo schema esterno. Per ulteriori informazioni sull'utilizzo di AWS Lake Formation, consulta[Redshift Spectrum e AWS Lake Formation](spectrum-lake-formation.md).
+ Per eseguire le query di Redshift Spectrum, l'utente del database deve disporre dell'autorizzazione per creare tabelle temporanee nel database. L'esempio seguente concede l'autorizzazione temporanea per il database `spectrumdb` al gruppo di utenti `spectrumusers`.
```
grant temp on database spectrumdb to group spectrumusers;
```
Per ulteriori informazioni, consulta [GRANT](r_GRANT.md).
+ *Quando utilizzi Athena Data Catalog o AWS Glue Data Catalog come archivio di metadati, consulta [Quotas and Limits](https://docs.aws.amazon.com/redshift/latest/mgmt/amazon-redshift-limits.html) nella Amazon Redshift Management Guide.*
+ Redshift Spectrum non supporta Amazon EMR con Kerberos.
# Nozioni di base su Amazon Redshift Spectrum
In questo tutorial viene descritto come utilizzare Amazon Redshift Spectrum per eseguire le query sui dati direttamente dai file in Amazon S3. Se disponi già di un cluster e di un client SQL, puoi completare questo tutorial con un intervento minimo di impostazione.
**Nota**
Le query di Redshift Spectrum comportano dei costi supplementari. Quello relativo all'esecuzione delle query di esempio in questo tutorial è nominale. Per ulteriori informazioni sui prezzi, consulta [Prezzi di Amazon Redshift Spectrum](https://aws.amazon.com/redshift/pricing/#redshift-spectrum-pricing).
## Prerequisiti
Per utilizzare Redshift Spectrum, è necessario disporre di un cluster Amazon Redshift e un client SQL connesso al cluster di modo che sia possibile eseguire i comandi SQL. Il cluster e i file di dati in Amazon S3 devono trovarsi nella stessa Regione AWS.
Per informazioni sulla creazione di un cluster Amazon Redshift, consulta la pagina [Nozioni di base sui data warehouse con provisioning Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/gsg/new-user.html) nella *Guida alle operazioni di base di Amazon Redshift*. Per informazioni sulle modalità di connessione a un cluster, consulta [Connessione ai data warehouse Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/gsg/database-tasks.html) nella *Guida alle operazioni di base di Amazon Redshift*.
In alcuni degli esempi che seguono, i dati di esempio si trovano nella regione Stati Uniti orientali (Virginia settentrionale) (`us-east-1`), quindi è necessario un cluster che si trova in `us-east-1`. In alternativa, puoi utilizzare Amazon S3 per copiare oggetti di dati dai seguenti bucket e cartelle nel tuo bucket nel luogo in Regione AWS cui si trova il cluster:
+ `s3://redshift-downloads/tickit/spectrum/customers/*`
+ `s3://redshift-downloads/tickit/spectrum/sales_partition/*`
+ `s3://redshift-downloads/tickit/spectrum/sales/*`
+ `s3://redshift-downloads/tickit/spectrum/salesevent/*`
Esegui un comando Amazon S3 simile al seguente per copiare i dati di esempio che si trovano negli Stati Uniti orientali (Virginia settentrionale) nel tua Regione AWS. Prima di eseguire il comando, crea il bucket e le cartelle nel bucket in modo che corrispondano al comando di copia di Amazon S3. L'output del comando Amazon S3 copy conferma che i file vengono copiati *bucket-name* nel file desiderato. Regione AWS
```
aws s3 cp s3://redshift-downloads/tickit/spectrum/ s3://bucket-name/tickit/spectrum/ --copy-props none --recursive
```
## Guida introduttiva a Redshift Spectrum con AWS CloudFormation
In alternativa ai seguenti passaggi, puoi accedere al DataLake AWS CloudFormation modello Redshift Spectrum per creare uno stack con un bucket Amazon S3 su cui eseguire query. Per ulteriori informazioni, consulta [Avvia lo AWS CloudFormation stack e quindi interroga i dati in Amazon S3](#c-getting-started-using-spectrum-query-s3-data-cfn).
## Nozioni di base su Redshift Spectrum graduale
Per iniziare a utilizzare Amazon Redshift Spectrum, completare la seguente procedura:
+ [Passaggio 1. Creazione di un ruolo IAM per Amazon Redshift](#c-getting-started-using-spectrum-create-role)
+ [Fase 2: associazione del ruolo IAM al cluster](#c-getting-started-using-spectrum-add-role)
+ [Fase 3: creazione di uno schema esterno e di una tabella esterna](#c-getting-started-using-spectrum-create-external-table)
+ [Fase 4: Esecuzione di query sui dati in Amazon S3](#c-getting-started-using-spectrum-query-s3-data)
## Passaggio 1. Creazione di un ruolo IAM per Amazon Redshift
Il cluster necessita dell'autorizzazione per accedere al catalogo dati esterno in AWS Glue Amazon Athena e ai file di dati in Amazon S3. Per concedere questa autorizzazione, fare riferimento a un ruolo AWS Identity and Access Management (IAM) associato al cluster. Per ulteriori informazioni sull'utilizzo di ruoli con Amazon Redshift, consultare [Autorizzazione delle operazioni COPY e UNLOAD tramite ruoli IAM](https://docs.aws.amazon.com/redshift/latest/mgmt/copy-unload-iam-role.html).
**Nota**
In alcuni casi, puoi migrare il tuo Athena Data Catalog a AWS Glue un Data Catalog. Puoi farlo se il tuo cluster si trova in una AWS regione in cui AWS Glue è supportato e hai tabelle esterne Redshift Spectrum nell'Athena Data Catalog. Per utilizzare AWS Glue Data Catalog con Redshift Spectrum, potrebbe essere necessario modificare le policy IAM. Per ulteriori informazioni, consultare [Aggiornamento del catalogo dati AWS Glue](https://docs.aws.amazon.com/athena/latest/ug/glue-athena.html#glue-upgrade) nella *Guida per l'utente di Athena*.
Quando viene creato un ruolo per Amazon Redshift, scegliere uno dei seguenti approcci:
+ Se utilizzi Redshift Spectrum con un Athena Data Catalog o AWS Glue Data Catalog, segui i passaggi descritti in. [Come creare un ruolo IAM per Amazon Redshift](#spectrum-get-started-create-role)
+ Se utilizzi Redshift Spectrum con un AWS Glue Data Catalog programma abilitato per AWS Lake Formation, segui i passaggi descritti nelle seguenti procedure:
+ [Per creare un ruolo IAM per Amazon Redshift utilizzando un AWS Glue Data Catalog enabled for AWS Lake Formation](#spectrum-get-started-create-role-lake-formation)
+ [Come concedere le autorizzazioni SELECT nella tabella per eseguire le query del database Lake Formation](#spectrum-get-started-grant-lake-formation-table)
**Come creare un ruolo IAM per Amazon Redshift**
1. Aprire la [console IAM](https://console.aws.amazon.com/iam/home?#home).
1. Nel pannello di navigazione, selezionare **Ruoli**.
1. Selezionare **Create role (Crea ruolo)**.
1. Scegliere **Servizio AWS ** come entità attendibile, quindi scegliere **Redshift** come caso d'uso.
1. **In Caso d'uso per altro Servizi AWS****, scegli **Redshift - Personalizzabile**, quindi scegli Avanti.**
1. Verrà visualizzata la pagina **Allega la policy di autorizzazione**. Scegli `AmazonS3ReadOnlyAccess` e`AWSGlueConsoleFullAccess`, se utilizzi il AWS Glue Data Catalog. Oppure scegliere `AmazonAthenaFullAccess` se si utilizza il catalogo dati di Athena. Scegli **Next (Successivo)**.
**Nota**
La policy `AmazonS3ReadOnlyAccess` concede al cluster l'accesso in sola lettura a tutti i bucket Amazon S3. Per concedere l'accesso solo al bucket di dati di AWS esempio, crea una nuova politica e aggiungi le seguenti autorizzazioni.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:Get*",
"s3:List*"
],
"Resource": "arn:aws:s3:::redshift-downloads/*"
}
]
}
```
1. Per **Role name (Nome ruolo)**, digitare un nome per il ruolo, ad esempio **myspectrum\$1role**.
1. Esaminare le informazioni, quindi scegliere **Create role (Crea ruolo)**.
1. Nel riquadro di navigazione, seleziona **Ruoli**. Scegliere il nome del nuovo ruolo per visualizzare il riepilogo, quindi copiare il ruolo ARN visualizzato nel campo **Role ARN (ARN ruolo)**. Questo valore è l'Amazon Resource Name (ARN) per il ruolo appena creato. Viene utilizzato quando si creano tabelle esterne per fare riferimento ai file di dati in Amazon S3.
**Per creare un ruolo IAM per Amazon Redshift utilizzando un AWS Glue Data Catalog enabled for AWS Lake Formation**
1. Aprire la console IAM all'indirizzo [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. Nel pannello di navigazione, selezionare **Policy**.
Se è la prima volta che selezioni **Policy**, verrà visualizzata la pagina **Benvenuto nelle policy gestite**. Seleziona **Inizia**.
1. Scegli **Crea policy**.
1. Scegliere di creare la policy nella scheda **JSON**.
1. Incollare nel documento di policy JSON seguente, che concede l'accesso al catalogo di dati ma nega le autorizzazioni di amministratore per Lake Formation.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "RedshiftPolicyForLF",
"Effect": "Allow",
"Action": [
"glue:*",
"lakeformation:GetDataAccess"
],
"Resource": "*"
}
]
}
```
------
1. Una volta terminato, selezionare **Review (Rivedi)** per rivedere la policy. In Validatore di policy vengono segnalati eventuali errori di sintassi.
1. Nella pagina **Review policy (Rivedi policy)**, in **Name (Nome)** inserire **myspectrum\$1policy** per denominare la policy in fase di creazione. (Opzionale) Immettere una **Description (descrizione)**. Consulta il **Riepilogo** della policy per visualizzare le autorizzazioni concesse dalla policy. Seleziona **Create policy** (Crea policy) per salvare il proprio lavoro.
Dopo aver creato la policy, è possibile fornire l'accesso agli utenti.
Per fornire l’accesso, aggiungi autorizzazioni agli utenti, gruppi o ruoli:
+ Utenti e gruppi in AWS IAM Identity Center:
Crea un set di autorizzazioni. Segui le istruzioni riportate nella pagina [Create a permission set](https://docs.aws.amazon.com//singlesignon/latest/userguide/howtocreatepermissionset.html) (Creazione di un set di autorizzazioni) nella *Guida per l’utente di AWS IAM Identity Center *.
+ Utenti gestiti in IAM tramite un provider di identità:
Crea un ruolo per la federazione delle identità. Segui le istruzioni riportate nella pagina [Create a role for a third-party identity provider (federation)](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_roles_create_for-idp.html) della *Guida per l’utente IAM*.
+ Utenti IAM:
+ Crea un ruolo che l’utente possa assumere. Segui le istruzioni riportate nella pagina [Create a role for an IAM user](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_roles_create_for-user.html) della *Guida per l’utente IAM*.
+ (Non consigliato) Collega una policy direttamente a un utente o aggiungi un utente a un gruppo di utenti. Segui le istruzioni riportate nella pagina [Aggiunta di autorizzazioni a un utente (console)](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_users_change-permissions.html#users_change_permissions-add-console) nella *Guida per l’utente IAM*.
**Come concedere le autorizzazioni SELECT nella tabella per eseguire le query del database Lake Formation**
1. Apri la console Lake Formation all'indirizzo [https://console.aws.amazon.com/lakeformation/](https://console.aws.amazon.com/lakeformation/).
1. Nel menu di navigazione scegli **Autorizzazioni data lake**, quindi seleziona **Concedi**.
1. Segui le istruzioni presenti in [Granting table permissions using the named resource method](https://docs.aws.amazon.com/lake-formation/latest/dg/granting-table-permissions.html) nella *Guida per gli sviluppatori di AWS Lake Formation *. Inserisci le informazioni che seguono:
+ In **Ruolo IAM**, selezionare il ruolo IAM creato, `myspectrum_role`. Quando si esegue l'editori di query di Amazon Redshift, utilizzare il ruolo IAM per le autorizzazioni ai dati.
**Nota**
Per concedere l'autorizzazione SELECT nella tabella in un catalogo di dati abilitato per Lake Formation eseguire la query, procedere come segue:
Registrare il percorso dei dati in Lake Formation.
Concedere agli utenti le autorizzazioni per quel percorso in Lake Formation.
Le tabelle create sono disponibili nel percorso registrato in Lake Formation.
1. Scegliere **Concedi**.
**Importante**
Come best practice, concedere l'accesso solo agli oggetti Amazon S3 sottostanti attraverso le autorizzazioni Lake Formation. Per evitare un accesso non approvato, rimuovere qualsiasi autorizzazione concessa agli oggetti Amazon S3 al di fuori di Lake Formation. Se l'accesso agli oggetti Amazon S3 è stato effettuato prima della configurazione di Lake Formation, rimuovere qualsiasi autorizzazione di policy IAM o bucket configurata in precedenza. Per ulteriori informazioni, consulta [Upgrading AWS Glue Data Permissions to the AWS Lake Formation Model](https://docs.aws.amazon.com/lake-formation/latest/dg/upgrade-glue-lake-formation.html) e [Lake](https://docs.aws.amazon.com/lake-formation/latest/dg/lake-formation-permissions.html) Formation Permissions.
## Fase 2: associazione del ruolo IAM al cluster
Ora si dispone di un ruolo IAM che autorizza Amazon Redshift ad accedere al catalogo dati esterno e ad Amazon S3 per tuo conto. A questo punto è necessario associare tale ruolo al proprio cluster Amazon Redshift.
**Associare un ruolo IAM a un cluster**
1. Accedi a Console di gestione AWS e apri la console Amazon Redshift all'indirizzo. [https://console.aws.amazon.com/redshiftv2/](https://console.aws.amazon.com/redshiftv2/)
1. Dal menu di navigazione scegliere **Clusters** (Cluster), quindi scegliere il cluster da aggiornare.
1. In **Actions (Operazioni)**, scegliere **Manage IAM roles (Gestisci ruoli IAM)**. Viene visualizzata la pagina **IAM roles (Ruoli IAM)**.
1. Scegliere **Inserisci ARN** e quindi inserire un ARN o un ruolo IAM, oppure scegliere un ruolo IAM dall'elenco. Quindi scegliere **Add IAM role (Aggiungi ruolo IAM)** per aggiungerlo all'elenco degli **Attached IAM roles (Ruoli IAM collegati)**.
1. Scegliere **Done (Fatto)** per associare il ruolo IAM al cluster. Il cluster viene modificare per completare la variazione.
## Fase 3: creazione di uno schema esterno e di una tabella esterna
Creazione di tabelle esterne in uno schema esterno. Lo schema esterno fa riferimento a un database nel catalogo dati esterno e fornisce l'ARN del ruolo IAM che autorizza il tuo cluster ad accedere ad Amazon S3 per tuo conto. Puoi creare un database esterno in un Amazon Athena Data Catalog o in un metastore Apache Hive AWS Glue Data Catalog, come Amazon EMR. Per questo esempio, viene creato un database esterno in un catalogo dati Amazon Athena quando viene creato lo schema esterno di Amazon Redshift. Per ulteriori informazioni, consultare [Schemi esterni in Amazon Redshift Spectrum](c-spectrum-external-schemas.md).
**Per creare uno schema esterno e una tabella esterna**
1. Per creare uno schema esterno, sostituire l'ARN del ruolo IAM nel comando seguente con l'ARN del ruolo creato nella [fase 1](#c-getting-started-using-spectrum-create-role). Quindi eseguire il comando nel proprio client SQL.
```
create external schema myspectrum_schema
from data catalog
database 'myspectrum_db'
iam_role 'arn:aws:iam::123456789012:role/myspectrum_role'
create external database if not exists;
```
1. Per creare una tabella esterna, eseguire il comando CREATE EXTERNAL TABLE seguente.
**Nota**
Il cluster e il bucket Amazon S3 devono trovarsi nella stessa Regione AWS. Per questo esempio del comando CREATE EXTERNAL TABLE, il bucket Amazon S3 con i dati di esempio si trova negli Stati Uniti orientali (Virginia settentrionale). Regione AWS Per visualizzare i dati di origine, scarica il [file `sales_ts.000`](https://s3.amazonaws.com/redshift-downloads/tickit/spectrum/sales/sales_ts.000). .
È possibile modificare questo esempio per eseguirlo in un altro Regione AWS. Crea un bucket Amazon S3 nel formato desiderato. Regione AWS Copia i dati di vendita con un comando di copia di Amazon S3. Aggiorna quindi l'opzione relativa alla posizione del bucket nel comando di esempio `CREATE EXTERNAL TABLE` impostando il bucket in uso.
```
aws s3 cp s3://redshift-downloads/tickit/spectrum/sales/ s3://bucket-name/tickit/spectrum/sales/ --copy-props none --recursive
```
L'output del comando Amazon S3 copy conferma che il file è stato copiato *bucket-name* nel file desiderato. Regione AWS
```
copy: s3://redshift-downloads/tickit/spectrum/sales/sales_ts.000 to s3://bucket-name/tickit/spectrum/sales/sales_ts.000
```
```
create external table myspectrum_schema.sales(
salesid integer,
listid integer,
sellerid integer,
buyerid integer,
eventid integer,
dateid smallint,
qtysold smallint,
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/'
table properties ('numRows'='172000');
```
## Fase 4: Esecuzione di query sui dati in Amazon S3
Dopo aver creato le tabelle esterne, è possibile eseguire query utilizzando le stesse istruzioni SELECT utilizzate per eseguire query su altre tabelle Amazon Redshift. Queste query con istruzioni SELECT includono il join di tabelle, l'aggregazione di dati e il filtraggio di predicati.
**Come eseguire query sui dati in Amazon S3**
1. Ottenere Il numero di righe nella tabella MYSPECTRUM\$1SCHEMA.SALES.
```
select count(*) from myspectrum_schema.sales;
```
```
count
------
172462
```
1. Come best practice, lasciare le tabelle dei fatti più grandi in Amazon S3 e le tabelle con dimensioni più piccole in Amazon Redshift. Se hai caricato i dati di esempio in [Carica dati](https://docs.aws.amazon.com/redshift/latest/gsg/cm-dev-t-load-sample-data.html), nel database è disponibile una tabella denominata EVENT. Altrimenti, creare la tabella EVENT utilizzando il comando seguente.
```
create table event(
eventid integer not null distkey,
venueid smallint not null,
catid smallint not null,
dateid smallint not null sortkey,
eventname varchar(200),
starttime timestamp);
```
1. Caricare la tabella EVENT sostituendo l'ARN del ruolo IAM nel seguente comando COPY con l'ARN del ruolo creato in [Passaggio 1. Creazione di un ruolo IAM per Amazon Redshift](#c-getting-started-using-spectrum-create-role). Facoltativamente, puoi scaricare e visualizzare i [dati di origine `allevents_pipe.txt`](https://s3.amazonaws.com/redshift-downloads/tickit/allevents_pipe.txt) da un bucket Amazon S3. Regione AWS `us-east-1`
```
copy event from 's3://redshift-downloads/tickit/allevents_pipe.txt'
iam_role 'arn:aws:iam::123456789012:role/myspectrum_role'
delimiter '|' timeformat 'YYYY-MM-DD HH:MI:SS' region 'us-east-1';
```
L'esempio seguente unisce mediante join la tabella esterna Amazon S3 MYSPECTRUM\$1SCHEMA.SALES alla tabella Amazon Redshift locale EVENT per calcolare le vendite totali per i 10 eventi principali.
```
select top 10 myspectrum_schema.sales.eventid, sum(myspectrum_schema.sales.pricepaid) from myspectrum_schema.sales, event
where myspectrum_schema.sales.eventid = event.eventid
and myspectrum_schema.sales.pricepaid > 30
group by myspectrum_schema.sales.eventid
order by 2 desc;
```
```
eventid | sum
--------+---------
289 | 51846.00
7895 | 51049.00
1602 | 50301.00
851 | 49956.00
7315 | 49823.00
6471 | 47997.00
2118 | 47863.00
984 | 46780.00
7851 | 46661.00
5638 | 46280.00
```
1. Visualizza il piano delle query per la query precedente. Tenere presente le fasi `S3 Seq Scan`, `S3 HashAggregate` e `S3 Query Scan` eseguite sui dati in Amazon S3.
```
explain
select top 10 myspectrum_schema.sales.eventid, sum(myspectrum_schema.sales.pricepaid)
from myspectrum_schema.sales, event
where myspectrum_schema.sales.eventid = event.eventid
and myspectrum_schema.sales.pricepaid > 30
group by myspectrum_schema.sales.eventid
order by 2 desc;
```
```
QUERY PLAN
-----------------------------------------------------------------------------
XN Limit (cost=1001055770628.63..1001055770628.65 rows=10 width=31)
-> XN Merge (cost=1001055770628.63..1001055770629.13 rows=200 width=31)
Merge Key: sum(sales.derived_col2)
-> XN Network (cost=1001055770628.63..1001055770629.13 rows=200 width=31)
Send to leader
-> XN Sort (cost=1001055770628.63..1001055770629.13 rows=200 width=31)
Sort Key: sum(sales.derived_col2)
-> XN HashAggregate (cost=1055770620.49..1055770620.99 rows=200 width=31)
-> XN Hash Join DS_BCAST_INNER (cost=3119.97..1055769620.49 rows=200000 width=31)
Hash Cond: ("outer".derived_col1 = "inner".eventid)
-> XN S3 Query Scan sales (cost=3010.00..5010.50 rows=200000 width=31)
-> S3 HashAggregate (cost=3010.00..3010.50 rows=200000 width=16)
-> S3 Seq Scan myspectrum_schema.sales location:"s3://redshift-downloads/tickit/spectrum/sales" format:TEXT (cost=0.00..2150.00 rows=172000 width=16)
Filter: (pricepaid > 30.00)
-> XN Hash (cost=87.98..87.98 rows=8798 width=4)
-> XN Seq Scan on event (cost=0.00..87.98 rows=8798 width=4)
```
## Avvia lo AWS CloudFormation stack e quindi interroga i dati in Amazon S3
Dopo aver creato un cluster Amazon Redshift e esserti connesso al cluster, puoi installare il DataLake AWS CloudFormation modello Redshift Spectrum e quindi interrogare i tuoi dati.
CloudFormation installa il modello Redshift Spectrum Getting DataLake Started e crea uno stack che include quanto segue:
+ Un ruolo denominato `myspectrum_role` associato al cluster Redshift
+ Uno schema esterno denominato `myspectrum_schema`
+ Una tabella esterna denominata `sales` in un bucket Amazon S3
+ Una tabella Redshift denominata `event` caricata con dati
**Per avviare lo stack Redshift Spectrum Getting Started DataLake CloudFormation**
1. Scegliere [https://console.aws.amazon.com/cloudformation/home?#/stacks/new?stackName=DataLake&templateURL=https://s3.amazonaws.com/redshift-downloads/docs-downloads/DataLake.yml](https://console.aws.amazon.com/cloudformation/home?#/stacks/new?stackName=DataLake&templateURL=https://s3.amazonaws.com/redshift-downloads/docs-downloads/DataLake.yml). La CloudFormation console si apre con il template DataLake .yml selezionato.
Puoi anche scaricare e personalizzare il [modello DataLake CloudFormation CFN](https://s3.amazonaws.com/redshift-downloads/docs-downloads/DataLake.yml) Redshift Spectrum Getting Started, quindi aprire la CloudFormation console ([https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/)) e creare uno stack con il modello personalizzato.
1. Scegli **Next (Successivo)**.
1. In **Parametri**, inserisci il nome del cluster Amazon Redshift, il nome del database e il nome utente del database.
1. Scegli **Next (Successivo)**.
Vengono visualizzate le opzioni della pila.
1. Scegliere **Successivo** per accettare le impostazioni predefinite.
1. Consulta le informazioni e nella sezione **Capacità**, quindi scegli **Riconosco che AWS CloudFormation potrebbe creare risorse IAM**.
1. Seleziona **Crea stack**.
Se si verifica un errore durante la creazione della pila, vedere le seguenti informazioni:
+ Visualizza la scheda CloudFormation **Eventi** per informazioni che possono aiutarti a risolvere l'errore.
+ Elimina lo DataLake CloudFormation stack prima di riprovare l'operazione.
+ Assicurarsi di essere connesso al database Amazon Redshift.
+ Assicurati di aver inserito le informazioni corrette per il nome del cluster Amazon Redshift, il nome del database e il nome utente del database.
### Eseguire query sui dati in Amazon S3
Richiedere tabelle esterne utilizzando le stesse istruzioni SELECT utilizzate per eseguire query su altre tabelle Amazon Redshift. Queste query con istruzioni SELECT includono il join di tabelle, l'aggregazione di dati e il filtraggio di predicati.
La seguente query restituisce il numero di righe nella tabella esterna`myspectrum_schema.sales`.
```
select count(*) from myspectrum_schema.sales;
```
```
count
------
172462
```
### Effettuare il join di una tabella esterna con una tabella locale
L'esempio seguente unisce la tabella esterna `myspectrum_schema.sales` alla tabella locale `event` per calcolare le vendite totali per i 10 eventi principali.
```
select top 10 myspectrum_schema.sales.eventid, sum(myspectrum_schema.sales.pricepaid) from myspectrum_schema.sales, event
where myspectrum_schema.sales.eventid = event.eventid
and myspectrum_schema.sales.pricepaid > 30
group by myspectrum_schema.sales.eventid
order by 2 desc;
```
```
eventid | sum
--------+---------
289 | 51846.00
7895 | 51049.00
1602 | 50301.00
851 | 49956.00
7315 | 49823.00
6471 | 47997.00
2118 | 47863.00
984 | 46780.00
7851 | 46661.00
5638 | 46280.00
```
### Visualizzare il piano di query
Visualizza il piano delle query per la query precedente. Tenere presente le fasi `S3 Seq Scan`, `S3 HashAggregate` e `S3 Query Scan` eseguite nei dati in Amazon S3.
```
explain
select top 10 myspectrum_schema.sales.eventid, sum(myspectrum_schema.sales.pricepaid)
from myspectrum_schema.sales, event
where myspectrum_schema.sales.eventid = event.eventid
and myspectrum_schema.sales.pricepaid > 30
group by myspectrum_schema.sales.eventid
order by 2 desc;
```
```
QUERY PLAN
-----------------------------------------------------------------------------
XN Limit (cost=1001055770628.63..1001055770628.65 rows=10 width=31)
-> XN Merge (cost=1001055770628.63..1001055770629.13 rows=200 width=31)
Merge Key: sum(sales.derived_col2)
-> XN Network (cost=1001055770628.63..1001055770629.13 rows=200 width=31)
Send to leader
-> XN Sort (cost=1001055770628.63..1001055770629.13 rows=200 width=31)
Sort Key: sum(sales.derived_col2)
-> XN HashAggregate (cost=1055770620.49..1055770620.99 rows=200 width=31)
-> XN Hash Join DS_BCAST_INNER (cost=3119.97..1055769620.49 rows=200000 width=31)
Hash Cond: ("outer".derived_col1 = "inner".eventid)
-> XN S3 Query Scan sales (cost=3010.00..5010.50 rows=200000 width=31)
-> S3 HashAggregate (cost=3010.00..3010.50 rows=200000 width=16)
-> S3 Seq Scan spectrum.sales location:"s3://redshift-downloads/tickit/spectrum/sales" format:TEXT (cost=0.00..2150.00 rows=172000 width=16)
Filter: (pricepaid > 30.00)
-> XN Hash (cost=87.98..87.98 rows=8798 width=4)
-> XN Seq Scan on event (cost=0.00..87.98 rows=8798 width=4)
```
# Interroga le tabelle Amazon S3 da Amazon Redshift
Amazon Redshift si integra con i bucket di tabelle Amazon S3, consentendoti di accedere alle risorse delle tabelle S3 utilizzando Amazon Redshift. Che tu stia appena iniziando o gestendo migliaia di tabelle nel tuo ambiente Iceberg, i table bucket semplificano la gestione dei data lake su qualsiasi scala. Per ulteriori informazioni sui bucket, consultare [Bucket di tabella](https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-tables-buckets.html).
Questo argomento descrive come iniziare a usare Amazon S3 Tables e Redshift e accedere agli oggetti S3 Tables utilizzando Amazon Redshift.
## Prerequisiti
Prima di eseguire query su S3 Tables da Amazon Redshift, devi integrare S3 Tables con. AWS Glue Data Catalog Per istruzioni, consulta [Integrazione delle tabelle Amazon S3 con](https://docs.aws.amazon.com/glue/latest/dg/glue-federation-s3tables.html). AWS Glue Data Catalog
Dopo l'integrazione con S3 Tables AWS Glue Data Catalog, i dirigenti IAM con le autorizzazioni S3 Tables e AWS Glue IAM richieste possono scoprire S3 Tables tramite. AWS Glue Data Catalog
**Nota**
Il metodo 3 (awsdatacatalog montato automaticamente) presenta prerequisiti aggiuntivi. Per informazioni dettagliate, vedi [Metodo 3: awsdatacatalog montato automaticamente](#querying-s3Tables-method3).
## Interroga le tabelle S3 da Amazon Redshift
Per iniziare a eseguire query su S3 Tables, segui questi passaggi:
+ Fase 1: creare un ruolo IAM per Amazon Redshift
+ Fase 2: collegare un ruolo IAM al cluster Amazon Redshift
+ Fase 3: Interroga le tabelle S3 da Amazon Redshift
### Fase 1: creare un ruolo IAM per Amazon Redshift
Il cluster necessita dell'autorizzazione per accedere al catalogo esterno di S3 Tables in. AWS Glue Per fornire tale autorizzazione, Amazon Redshift utilizza un ruolo IAM collegato al cluster. Crea un ruolo IAM con le seguenti autorizzazioni politiche.
**Nota**
Nella politica e negli esempi seguenti, sostituiscilo `us-west-2` con la tua AWS regione e `111122223333` con l'ID AWS del tuo account.
**Per creare una politica:**
1. Aprire la console IAM all'indirizzo [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. Nel riquadro di navigazione, scegli **Policy**.
1. Scegli **Create Policy** (Crea policy).
1. Scegliere la scheda **JSON**.
1. Incolla il seguente documento di policy JSON:
```
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "GlueDataCatalogPermissions",
"Effect": "Allow",
"Action": [
"glue:GetCatalog",
"glue:GetDatabase",
"glue:GetTable",
"glue:GetTables",
"glue:UpdateTable",
"glue:DeleteTable"
],
"Resource": [
"arn:aws:glue:us-west-2:111122223333:catalog",
"arn:aws:glue:us-west-2:111122223333:catalog/s3tablescatalog",
"arn:aws:glue:us-west-2:111122223333:catalog/s3tablescatalog/*",
"arn:aws:glue:us-west-2:111122223333:database/s3tablescatalog/*/*",
"arn:aws:glue:us-west-2:111122223333:table/s3tablescatalog/*/*/*",
"arn:aws:glue:us-west-2:111122223333:database/*",
"arn:aws:glue:us-west-2:111122223333:table/*/*"
]
},
{
"Sid": "S3TablesDataAccessPermissions",
"Effect": "Allow",
"Action": [
"s3tables:GetTableBucket",
"s3tables:GetNamespace",
"s3tables:GetTable",
"s3tables:GetTableMetadataLocation",
"s3tables:GetTableData",
"s3tables:ListTableBuckets",
"s3tables:CreateTable",
"s3tables:PutTableData",
"s3tables:UpdateTableMetadataLocation",
"s3tables:ListNamespaces",
"s3tables:ListTables",
"s3tables:DeleteTable"
],
"Resource": [
"arn:aws:s3tables:us-west-2:111122223333:bucket/*",
"arn:aws:s3tables:us-west-2:111122223333:bucket/*/table/*"
]
}
]
}
```
1. Scegliere **Esamina policy**.
1. Nella pagina di **revisione della politica**, inserisci `GlueCatalogS3Tables_Policy` **Nome**. Facoltativamente, inserisci una descrizione. Esamina il riepilogo della politica, quindi scegli **Crea politica**.
**Per creare un ruolo IAM per Amazon Redshift:**
1. Aprire la [console IAM](https://console.aws.amazon.com/iam/).
1. Nel pannello di navigazione, selezionare **Ruoli**.
1. Selezionare **Create role (Crea ruolo)**.
1. Scegli il **AWS servizio** come entità affidabile, quindi scegli **Redshift come caso** d'uso.
1. **In Caso d'uso per altri AWS servizi****, scegli **Redshift - Personalizzabile**, quindi scegli Avanti.**
1. Nella pagina **Aggiungi autorizzazioni**, allega la `GlueCatalogS3Tables_Policy` policy che hai creato sopra. Scegli **Next (Successivo)**.
1. Per **Role name (Nome ruolo)**, digitare un nome per il ruolo, ad esempio `RedshiftS3TablesRole`.
1. Controlla le informazioni, quindi scegli **Crea ruolo**.
1. Nel riquadro di navigazione, seleziona **Ruoli**. Scegli il nome del tuo nuovo ruolo per visualizzare il riepilogo, quindi copia l'**ARN del ruolo** negli appunti. Utilizzerai questo ARN per creare schemi esterni per i namespace di S3 Tables.
**Nota**
Limita l'ambito a risorse specifiche sostituendo il carattere jolly con i nomi esatti di Amazon Resource Names (ARNs).
### Fase 2: collegare un ruolo IAM al cluster Amazon Redshift
Associa il ruolo IAM configurato nella Fase 1 al tuo cluster Amazon Redshift.
**Utilizzo della console AWS di gestione:**
1. Accedi alla console di AWS gestione e apri la console Amazon Redshift all'indirizzo. [https://console.aws.amazon.com/redshiftv2/](https://console.aws.amazon.com/redshiftv2/)
1. Dal menu di navigazione, scegliere **Clusters** (Cluster), quindi scegliere il cluster da aggiornare.
1. Per **Azioni**, scegli **Gestisci i ruoli IAM** per visualizzare l'elenco corrente dei ruoli IAM associati al cluster.
1. Nella pagina **Gestisci i ruoli IAM**, scegli il ruolo IAM da aggiungere, quindi scegli **Aggiungi ruolo IAM**.
1. Scegli **Save (Salva)** per salvare le modifiche.
**Utilizzo della AWS CLI:**
Esegui il comando seguente per associare un ruolo IAM a un cluster o uno spazio dei nomi esistente. Sostituisci `my-redshift-cluster` o `my-redshift-namespace` con l'identificatore o lo spazio dei nomi del cluster e `111122223333` con l'ID del tuo account. AWS
```
aws redshift modify-cluster-iam-roles \
--cluster-identifier my-redshift-cluster \
--add-iam-roles arn:aws:iam::111122223333:role/RedshiftS3TablesRole
-- for serverless
aws redshift-serverless update-namespace \
--namespace-name my-redshift-namespace \
--iam-roles "arn:aws:iam::111122223333:role/RedshiftS3TablesRole"
```
Per ulteriori informazioni, consulta [Associazione di ruoli IAM ai cluster](https://docs.aws.amazon.com/redshift/latest/mgmt/copy-unload-iam-role.html) nella *Guida alla gestione di Amazon Redshift*.
### Fase 3: Interroga le tabelle S3 da Amazon Redshift
Quando integri S3 Tables con AWS Glue Data Catalog, il servizio crea una struttura di catalogo federata che mappa le risorse di S3 Tables agli oggetti del catalogo: AWS Glue
+ **Un bucket da tavolo S3 diventa un catalogo in.** AWS Glue Data Catalog
+ **Un namespace S3 diventa un database.AWS Glue **
+ **Una tabella S3 diventa un oggetto tabella.AWS Glue **
L'integrazione crea la seguente gerarchia:
+ **Catalogo federato:** `s3tablescatalog` (creato automaticamente)
+ **Cataloghi per bambini:** ogni bucket da tavolo S3 diventa un catalogo per bambini sotto. `s3tablescatalog`
+ **Database:** ogni namespace S3 all'interno di un bucket di tabella diventa un database.
+ **Tabelle:** ogni tabella S3 all'interno di un namespace diventa una tabella.
Ad esempio, se hai un bucket di tabella S3 denominato `analytics-bucket` con uno spazio dei nomi `sales` contenente una tabella`transactions`, il percorso completo in sarebbe:. AWS Glue Data Catalog `s3tablescatalog/analytics-bucket/sales/transactions`
**Crea un link a una risorsa**
Prima di utilizzare uno dei tre metodi di interrogazione seguenti, è necessario creare un collegamento alla risorsa in AWS Glue Data Catalog. I link alle risorse consentono ad Amazon Redshift di fare riferimento ai database S3 Tables tramite il catalogo standard.
*Utilizzando la console: AWS Glue *
1. Apri la AWS Glue console all'indirizzo [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
1. Nel pannello di navigazione, seleziona **Database**.
1. Scegli **Crea**, quindi scegli **Link alla risorsa**.
1. Nella pagina **Crea collegamento a una risorsa**, fornisci le seguenti informazioni:
+ **Nome del link alla risorsa:** inserisci un nome per il link alla risorsa (ad esempio,`sales_resource_link`).
+ **Database condiviso:** inserisci il percorso del database S3 Tables (ad esempio,`s3tablescatalog/analytics-bucket/sales`).
+ **Proprietario del database condiviso:** inserisci l'ID AWS del tuo account.
+ **ID di catalogo del database condiviso:** inserisci l'ID del catalogo nel formato`:s3tablescatalog/`.
1. Scegli **Create** (Crea).
*Utilizzo della AWS CLI:*
```
aws glue create-database \
--region us-west-2 \
--cli-input-json '{
"CatalogId": "111122223333",
"DatabaseInput": {
"Name": "sales_resource_link",
"TargetDatabase": {
"CatalogId": "111122223333:s3tablescatalog/analytics-bucket",
"DatabaseName": "sales"
}
}
}'
```
Questo comando crea un link di risorse denominato `sales_resource_link` nel AWS Glue Data Catalog predefinito che punta al `sales` database nel bucket di tabella S3. `analytics-bucket`
Una volta creati i link alle risorse, Amazon Redshift offre tre metodi per interrogare le tabelle S3. Scegli il metodo più adatto al tuo caso d'uso.
**Nota**
Per creare un collegamento alle risorse a livello di database, l'amministratore di Redshift deve disporre dell'`AWS Glue:CreateDatabase`autorizzazione sul catalogo predefinito e sul database in fase di creazione.
#### Metodo 1: CREARE UNO SCHEMA ESTERNO
Utilizzalo `CREATE EXTERNAL SCHEMA` per creare uno schema esterno che faccia riferimento al tuo database S3 Tables. Questo metodo fornisce un controllo esplicito sulla denominazione e sulla configurazione dello schema.
Per i dettagli completi sulla sintassi, consulta [CREATE EXTERNAL SCHEMA](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_EXTERNAL_SCHEMA.html) nella *Amazon Redshift Database* Developer Guide.
**Esempio**
Usa il nome del database e l'ID del catalogo della Fase 3. `111122223333`Sostituiscilo con l'ID AWS del tuo account.
```
CREATE EXTERNAL SCHEMA s3tables_schema
FROM DATA CATALOG DATABASE 'sales_resource_link'
IAM_ROLE 'arn:aws:iam::111122223333:role/RedshiftS3TablesRole'
REGION 'us-west-2'
CATALOG_ID '111122223333';
SELECT * FROM s3tables_schema.transactions;
```
#### Metodo 2: CREARE UN DATABASE DA ARN
Da utilizzare `CREATE DATABASE` con la `FROM ARN` clausola per creare un database federato che faccia riferimento direttamente al collegamento alla AWS Glue risorsa. Questo metodo mappa automaticamente il AWS Glue database su un database Redshift.
Per i dettagli completi sulla sintassi, consulta [CREATE DATABASE](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_DATABASE.html) nella *Amazon Redshift Database* Developer Guide.
**Esempio**
Sostituiscilo `111122223333` con l'ID del tuo AWS account.
```
CREATE DATABASE s3tables_db
FROM ARN 'arn:aws:glue:us-west-2:111122223333:database/sales_resource_link'
WITH DATA CATALOG SCHEMA analytics_schema
IAM_ROLE 'arn:aws:iam::111122223333:role/RedshiftS3TablesRole';
SELECT * FROM s3tables_db.analytics_schema.transactions;
```
#### Metodo 3: awsdatacatalog montato automaticamente
Amazon Redshift può montare automaticamente i AWS Glue Data Catalog database, inclusi i link alle risorse di S3 Tables, tramite il database. `awsdatacatalog` Questo metodo richiede l'accesso federato a Spectrum (FAS) per essere abilitato sul cluster.
**Prerequisiti**
Per utilizzare il `awsdatacatalog` database montato automaticamente, è necessario abilitare l'accesso federato a Spectrum. Ciò consente ad Amazon Redshift di utilizzare credenziali di identità federate per accedere AWS Glue Data Catalog a fonti di dati esterne.
Per abilitare l'accesso federato a Spectrum:
1. Connect al cluster Redshift utilizzando un'identità IAM con le seguenti autorizzazioni:
+ `redshift:GetClusterCredentialsWithIAM`(per i cluster con provisioning) o `redshift-serverless:GetCredentials` (per Serverless)
+ `AmazonS3ReadOnlyAccess`
+ `AWSGlueConsoleFullAccess`
+ Autorizzazioni S3 Tables (come definite nella fase 1)
1. Quando ti connetti con un'identità IAM, Amazon Redshift crea automaticamente un utente del database con il prefisso `IAM:` (per utenti) o `IAMR:` (per ruoli).
1. In qualità di amministratore del cluster, concedi all'utente federato le autorizzazioni per accedere allo schema esterno. Sostituisci `my_user` con il tuo ruolo o nome utente IAM:
```
GRANT ALL ON SCHEMA awsdatacatalog TO "IAMR:my_user";
```
*Per istruzioni dettagliate sulla configurazione dell'accesso federato, consulta [Usare un'identità federata per gestire l'accesso di Amazon Redshift alle risorse locali e le tabelle esterne di Amazon Redshift Spectrum nella Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/authorization-fas-spectrum.html) Management Guide.*
**Interroga le tabelle S3**
Una volta configurato l'accesso federato, verifica gli schemi montati e interroga le tabelle S3.
Verifica gli schemi montati:
```
SHOW SCHEMAS FROM DATABASE awsdatacatalog;
```
Interroga le tabelle S3 utilizzando il nome del collegamento alle risorse del passaggio 3:
```
SELECT * FROM awsdatacatalog.sales_resource_link.transactions;
```
# Policy IAM per Amazon Redshift Spectrum
In questo argomento vengono illustrate le autorizzazioni IAM richieste per l’uso di Redshift Spectrum.
Per impostazione predefinita, Amazon Redshift Spectrum utilizza AWS Glue Data Catalog le AWS regioni che AWS Glue supportano. In altre AWS regioni, Redshift Spectrum utilizza il catalogo dati Athena. Il cluster necessita dell'autorizzazione per accedere al catalogo di dati esterno in AWS Glue o Athena e ai file di dati in Amazon S3. Fornisci tale autorizzazione facendo riferimento a un ruolo AWS Identity and Access Management (IAM) collegato al tuo cluster. Se si utilizza un metastore Apache Hive per gestire il catalogo dati, non sarà necessario fornire l'accesso a ad Athena.
Puoi concatenare i ruoli di modo che il cluster possa assumere altri ruoli non associati al cluster. Per ulteriori informazioni, consulta [Concatenazione di ruoli IAM per Amazon Redshift Spectrum](#c-spectrum-chaining-roles).
Il AWS Glue catalogo a cui accedi potrebbe essere crittografato per aumentare la sicurezza. Se il AWS Glue catalogo è crittografato, è necessaria la AWS KMS chiave AWS Glue per accedere al catalogo AWS Glue dati. Per ulteriori informazioni, [consulta Encrypting Your AWS Glue Data Catalog](https://docs.aws.amazon.com/glue/latest/dg/encrypt-glue-data-catalog.html) nella *[AWS Glue Developer Guide](https://docs.aws.amazon.com/glue/latest/dg/)*.
**Topics**
+ [Autorizzazioni di Amazon S3](#spectrum-iam-policies-s3)
+ [Autorizzazioni Amazon S3 tra account](#spectrum-iam-policies-cross-account)
+ [Policy per concedere o limitare l'accesso mediante Redshift Spectrum](#spectrum-iam-policies-spectrum-only)
+ [Policy per concedere autorizzazioni minime](#spectrum-iam-policies-minimum-permissions)
+ [Concatenazione di ruoli IAM per Amazon Redshift Spectrum](#c-spectrum-chaining-roles)
+ [Controllo dell'accesso al Data Catalog AWS Glue](#c-spectrum-glue-acess)
## Autorizzazioni di Amazon S3
Il cluster deve disporre almeno dell'accesso GET e LIST per il bucket Amazon S3. Se il bucket non si trova nello stesso AWS account del cluster, il bucket deve inoltre autorizzare il cluster ad accedere ai dati. Per ulteriori informazioni, consulta [Autorizzazione di Amazon Redshift ad accedere ad AWS altri servizi per tuo conto](https://docs.aws.amazon.com/redshift/latest/mgmt/authorizing-redshift-service.html).
**Nota**
Il bucket Amazon S3 non può utilizzare una policy di bucket che limita l'accesso solo da specifici endpoint VPC.
La policy seguente concede l'accesso GET e LIST a qualsiasi bucket Amazon S3. La policy consente l'accesso a bucket Amazon S3 per Redshift Spectrum nonché le operazioni COPY.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [{
"Effect": "Allow",
"Action": ["s3:Get*", "s3:List*"],
"Resource": "*"
}]
}
```
------
La policy seguente concede l'accesso GET e LIST al bucket Amazon S3 denominato `amzn-s3-demo-bucket`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [{
"Effect": "Allow",
"Action": ["s3:Get*", "s3:List*"],
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket/*"
}]
}
```
------
## Autorizzazioni Amazon S3 tra account
Per concedere a Redshift Spectrum l'autorizzazione ad accedere ai dati in un bucket Amazon S3 che appartiene a AWS un altro account, aggiungi la seguente policy al bucket Amazon S3. Per ulteriori informazioni, consultare la pagina relativa alla [concessione di autorizzazioni per bucket multiaccount](https://docs.aws.amazon.com/AmazonS3/latest/userguide/example-walkthroughs-managing-access-example2.html).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "Example permissions",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:role/spectrumrole"
},
"Action": [
"s3:GetBucketLocation",
"s3:GetObject",
"s3:ListMultipartUploadParts",
"s3:ListBucket",
"s3:ListBucketMultipartUploads"
],
"Resource": [
"arn:aws:s3:::bucketname",
"arn:aws:s3:::bucketname/*"
]
}
]
}
```
------
## Policy per concedere o limitare l'accesso mediante Redshift Spectrum
La policy di esempio seguente consente l’accesso a bucket Amazon S3 per Amazon Redshift. Quando aggiungi questa policy a un ruolo IAM, consigliamo di utilizzare un ruolo IAM che viene impiegato solo per Amazon Redshift. Suggeriamo inoltre di non riutilizzare i ruoli esistenti o di aggiungere ulteriori autorizzazioni a questo ruolo IAM.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:ListBucketVersions",
"s3:ListBucket"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket",
"arn:aws:s3:::amzn-s3-demo-bucket/*"
]
}
]
}
```
------
## Policy per concedere autorizzazioni minime
La seguente politica concede le autorizzazioni minime richieste per utilizzare Redshift Spectrum con Amazon S3 e Athena. AWS Glue
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:ListBucketVersions",
"s3:ListBucket",
"s3:GetObject"
],
"Resource": [
"arn:aws:s3:::bucketname",
"arn:aws:s3:::bucketname/folder1/folder2/*"
]
},
{
"Effect": "Allow",
"Action": [
"glue:CreateDatabase",
"glue:DeleteDatabase",
"glue:GetDatabase",
"glue:GetDatabases",
"glue:UpdateDatabase",
"glue:CreateTable",
"glue:DeleteTable",
"glue:BatchDeleteTable",
"glue:UpdateTable",
"glue:GetTable",
"glue:GetTables",
"glue:BatchCreatePartition",
"glue:CreatePartition",
"glue:DeletePartition",
"glue:BatchDeletePartition",
"glue:UpdatePartition",
"glue:GetPartition",
"glue:GetPartitions",
"glue:BatchGetPartition"
],
"Resource": "*"
}
]
}
```
------
Se invece utilizzi Athena per il tuo catalogo dati AWS Glue, la policy richiede l'accesso completo ad Athena. La policy seguente concede l'accesso alle risorse Athena. Se il database esterno è un metastore Hive, l'accesso ad Athena non è necessario.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [{
"Effect": "Allow",
"Action": ["athena:*"],
"Resource": ["*"]
}]
}
```
------
## Concatenazione di ruoli IAM per Amazon Redshift Spectrum
Quando associ un ruolo al cluster, quest'ultimo può assumere quel ruolo per accedere ad Amazon S3, Athena e AWS Glue per tuo conto. Se un ruolo collegato al cluster non ha accesso alle risorse necessarie, è possibile concatenare un altro ruolo, possibilmente appartenente a un altro account. Il cluster quindi può assumere temporaneamente il ruolo concatenato per accedere ai dati. Concatenando i ruoli è anche possibile concedere l'accesso a più account. È possibile concatenare un massimo di 10 ruoli. Ogni ruolo nella catena assume il ruolo successivo nella catena, fino a quando il cluster non assume il ruolo alla fine della catena.
Per concatenare i ruoli, stabilisci una relazione di trust tra di essi. Un ruolo che assume un altro ruolo deve avere una policy di autorizzazioni che gli consente di assumere il ruolo specificato. A sua volta, il ruolo che passa le autorizzazioni deve avere una policy di trust che gli consente di passare le relative autorizzazioni a un altro ruolo. Per ulteriori informazioni, consultare [Concatenazione di ruoli IAM in Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/authorizing-redshift-service.html#authorizing-redshift-service-chaining-roles).
Quando esegui il comando CREATE EXTERNAL SCHEMA, puoi concatenare i ruoli includendo un elenco di ruoli separati da virgole. ARNs
**Nota**
L'elenco di ruoli concatenati non deve includere spazi.
Negli esempi seguenti, `MyRedshiftRole` è collegato al cluster. `MyRedshiftRole` assume il ruolo `AcmeData`, che appartiene all'account `111122223333`.
```
create external schema acme from data catalog
database 'acmedb' region 'us-west-2'
iam_role 'arn:aws:iam::123456789012:role/MyRedshiftRole,arn:aws:iam::111122223333:role/AcmeData';
```
## Controllo dell'accesso al Data Catalog AWS Glue
Se lo utilizzi AWS Glue per il tuo catalogo di dati, puoi applicare un controllo granulare degli accessi al AWS Glue Data Catalog con la tua policy IAM. Ad esempio, potresti decidere di esporre soltanto alcuni database e tabelle a uno specifico ruolo IAM.
Le sezioni seguenti descrivono le politiche IAM per i vari livelli di accesso ai dati archiviati nel AWS Glue Data Catalog.
**Topics**
+ [Policy per le operazioni di database](#c-spectrum-glue-acess-database)
+ [Policy per le operazioni di tabella](#c-spectrum-glue-acess-tables)
+ [Policy per le operazioni di partizione](#c-spectrum-glue-acess-partitions)
### Policy per le operazioni di database
Se desideri concedere agli utenti le autorizzazioni per visualizzare e creare un database, devono disporre dei diritti di accesso sia al database che al AWS Glue Data Catalog.
Nella seguente query di esempio viene creato un database.
```
CREATE EXTERNAL SCHEMA example_db
FROM DATA CATALOG DATABASE 'example_db' region 'us-west-2'
IAM_ROLE 'arn:aws:iam::redshift-account:role/spectrumrole'
CREATE EXTERNAL DATABASE IF NOT EXISTS
```
La policy IAM seguente fornisce le autorizzazioni minime richieste per la creazione di un database.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"glue:GetDatabase",
"glue:CreateDatabase"
],
"Resource": [
"arn:aws:glue:us-west-2:111122223333:database/example_db",
"arn:aws:glue:us-west-2:111122223333:catalog"
]
}
]
}
```
------
La seguente query di esempio elenca i database correnti.
```
SELECT * FROM SVV_EXTERNAL_DATABASES WHERE
databasename = 'example_db1' or databasename = 'example_db2';
```
La policy IAM seguente fornisce le autorizzazioni minime richieste per elencare i database correnti.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"glue:GetDatabases"
],
"Resource": [
"arn:aws:glue:us-west-2:111122223333:database/example_db1",
"arn:aws:glue:us-west-2:111122223333:database/example_db2",
"arn:aws:glue:us-west-2:111122223333:catalog"
]
}
]
}
```
------
### Policy per le operazioni di tabella
Affinché possano visualizzare, creare, rimuovere, modificare o effettuare altre operazioni sulle tabelle, gli utenti hanno bisogno di diversi tipi di accessi. Hanno bisogno di poter accedere alle tabelle, ai database ai quali queste appartengono e al catalogo.
La query di esempio seguente crea una tabella esterna.
```
CREATE EXTERNAL TABLE example_db.example_tbl0(
col0 INT,
col1 VARCHAR(255)
) PARTITIONED BY (part INT) STORED AS TEXTFILE
LOCATION 's3://test/s3/location/';
```
La policy IAM seguente fornisce le autorizzazioni minime richieste per la creazione di una tabella esterna.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"glue:CreateTable"
],
"Resource": [
"arn:aws:glue:us-west-2:111122223333:catalog",
"arn:aws:glue:us-west-2:111122223333:database/example_db",
"arn:aws:glue:us-west-2:111122223333:table/example_db/example_tbl0"
]
}
]
}
```
------
Le query di esempio seguenti elencano ciascuna le tabelle esterne correnti.
```
SELECT * FROM svv_external_tables
WHERE tablename = 'example_tbl0' OR
tablename = 'example_tbl1';
```
```
SELECT * FROM svv_external_columns
WHERE tablename = 'example_tbl0' OR
tablename = 'example_tbl1';
```
```
SELECT parameters FROM svv_external_tables
WHERE tablename = 'example_tbl0' OR
tablename = 'example_tbl1';
```
La policy IAM seguente fornisce le autorizzazioni minime richieste per elencare le tabelle esterne correnti.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"glue:GetTables"
],
"Resource": [
"arn:aws:glue:us-west-2:111122223333:catalog",
"arn:aws:glue:us-west-2:111122223333:database/example_db",
"arn:aws:glue:us-west-2:111122223333:table/example_db/example_tbl0",
"arn:aws:glue:us-west-2:111122223333:table/example_db/example_tbl1"
]
}
]
}
```
------
La query di esempio seguente modifica una tabella esistente.
```
ALTER TABLE example_db.example_tbl0
SET TABLE PROPERTIES ('numRows' = '100');
```
La policy IAM seguente fornisce le autorizzazioni minime richieste per la modifica di una tabella esistente.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"glue:GetTable",
"glue:UpdateTable"
],
"Resource": [
"arn:aws:glue:us-west-2:111122223333:catalog",
"arn:aws:glue:us-west-2:111122223333:database/example_db",
"arn:aws:glue:us-west-2:111122223333:table/example_db/example_tbl0"
]
}
]
}
```
------
La query di esempio seguente rimuove una tabella esistente.
```
DROP TABLE example_db.example_tbl0;
```
La policy IAM seguente fornisce le autorizzazioni minime richieste per la rimozione di una tabella esistente.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"glue:DeleteTable"
],
"Resource": [
"arn:aws:glue:us-west-2:111122223333:catalog",
"arn:aws:glue:us-west-2:111122223333:database/example_db",
"arn:aws:glue:us-west-2:111122223333:table/example_db/example_tbl0"
]
}
]
}
```
------
### Policy per le operazioni di partizione
Perché possano effettuare operazioni a livello di partizione (visualizzazione, creazione, rimozione, modifica e così via), gli utenti hanno bisogno delle autorizzazioni per le tabelle alle quali appartengono le partizioni. Hanno inoltre bisogno delle autorizzazione per i database correlati e il catalogo dati AWS Glue .
La query di esempio seguente crea una partizione.
```
ALTER TABLE example_db.example_tbl0
ADD PARTITION (part=0) LOCATION 's3://test/s3/location/part=0/';
ALTER TABLE example_db.example_t
ADD PARTITION (part=1) LOCATION 's3://test/s3/location/part=1/';
```
La policy IAM seguente fornisce le autorizzazioni minime richieste per la creazione di una partizione.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"glue:GetTable",
"glue:BatchCreatePartition"
],
"Resource": [
"arn:aws:glue:us-west-2:111122223333:catalog",
"arn:aws:glue:us-west-2:111122223333:database/example_db",
"arn:aws:glue:us-west-2:111122223333:table/example_db/example_tbl0"
]
}
]
}
```
------
La seguente query di esempio elenca le partizioni correnti.
```
SELECT * FROM svv_external_partitions
WHERE schemname = 'example_db' AND
tablename = 'example_tbl0'
```
La policy IAM seguente fornisce le autorizzazioni minime richieste per elencare le partizioni correnti.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"glue:GetPartitions",
"glue:GetTables",
"glue:GetTable"
],
"Resource": [
"arn:aws:glue:us-west-2:111122223333:catalog",
"arn:aws:glue:us-west-2:111122223333:database/example_db",
"arn:aws:glue:us-west-2:111122223333:table/example_db/example_tbl0"
]
}
]
}
```
------
La query di esempio seguente modifica una partizione esistente.
```
ALTER TABLE example_db.example_tbl0 PARTITION(part='0')
SET LOCATION 's3://test/s3/new/location/part=0/';
```
La policy IAM seguente fornisce le autorizzazioni minime richieste per la modifica di una partizione esistente.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"glue:GetPartition",
"glue:UpdatePartition"
],
"Resource": [
"arn:aws:glue:us-west-2:111122223333:catalog",
"arn:aws:glue:us-west-2:111122223333:database/example_db",
"arn:aws:glue:us-west-2:111122223333:table/example_db/example_tbl0"
]
}
]
}
```
------
La query di esempio seguente rimuove una partizione esistente.
```
ALTER TABLE example_db.example_tbl0 DROP PARTITION(part='0');
```
La policy IAM seguente fornisce le autorizzazioni minime richieste per la rimozione di una partizione esistente.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"glue:DeletePartition"
],
"Resource": [
"arn:aws:glue:us-west-2:111122223333:catalog",
"arn:aws:glue:us-west-2:111122223333:database/example_db",
"arn:aws:glue:us-west-2:111122223333:table/example_db/example_tbl0"
]
}
]
}
```
------
# Redshift Spectrum e AWS Lake Formation
In questo argomento viene descritto come utilizzare Redshift Spectrum con Lake Formation. Lake Formation è un servizio per la condivisione di dati analitici.
Puoi utilizzarlo AWS Lake Formation per definire e applicare centralmente policy di accesso a livello di database, tabelle e colonne ai dati archiviati in Amazon S3. Dopo aver registrato i dati con AWS Glue Data Catalog abilitato con Lake Formation, è possibile eseguire query utilizzando diversi servizi, incluso Redshift Spectrum.
Lake Formation offre la sicurezza e la governance del catalogo di dati. All'interno di Lake Formation, è possibile concedere e revocare le autorizzazioni per gli oggetti del catalogo di dati, come database, tabelle, colonne e archiviazione Amazon S3 sottostante.
**Importante**
È possibile utilizzare Redshift Spectrum con un catalogo dati abilitato per Lake Formation solo AWS nelle regioni in cui è disponibile Lake Formation. Per l'elenco delle regioni disponibili, consulta [Endpoint e quote di AWS Lake Formation](https://docs.aws.amazon.com/general/latest/gr/lake-formation.html) in *Riferimenti generali di AWS*.
Utilizzando Redshift Spectrum con Lake Formation, è possibile effettuare le seguenti operazioni:
+ Utilizzare Lake Formation come luogo centralizzato in cui concedere e revocare le autorizzazioni e accedere alle policy di controllo su tutti i dati del data lake. Lake Formation offre una gerarchia alle autorizzazioni per controllare l'accesso a database e tabelle in un catalogo di dati. Per ulteriori informazioni, consulta la pagina relativa alla [panoramica delle autorizzazioni di Lake Formation](https://docs.aws.amazon.com/lake-formation/latest/dg/lake-formation-permissions.html) nella *Guida per gli sviluppatori di AWS Lake Formation *.
+ Crea tabelle esterne ed esegui query sui dati nel data lake. Prima che gli utenti nell'account possano eseguire le query, un amministratore dell'account data lake registra i percorsi Amazon S3 esistenti contenenti dati di origine con Lake Formation. L'amministratore crea anche tabelle e concede le autorizzazioni ai tuoi utenti. L'accesso può essere concesso per database, tabelle o colonne. L'amministratore può utilizzare i filtri di dati in Lake Formation per garantire un controllo granulare dell'accesso ai dati sensibili memorizzati in Amazon S3. Per ulteriori informazioni, consulta [Utilizzo di filtri di dati per la sicurezza a livello di riga e cella](#spectrum-lake-formation-data-filters).
Dopo che i dati sono stati registrati nel catalogo dati, ogni volta che gli utenti provano a eseguire le query, Lake Formation verifica l'accesso alla tabella per quel principal specifico. Lake Formation fornisce credenziali temporanee a Redshift Spectrum e la query viene eseguita.
+ Esegui le query Redshift Spectrum su un dispositivo montato automaticamente AWS Glue Data Catalog utilizzando credenziali IAM ottenute con o `GetCredentials` e `GetClusterCredentials` gestisci le autorizzazioni Lake Formation per utente del database (iamr:UserName o IAM:UserName).
Quando si utilizza Redshift Spectrum con un catalogo di dati abilitato per Lake Formation, deve essere soddisfatta una delle seguenti condizioni:
+ Un ruolo IAM associato al cluster con autorizzazione al catalogo dati.
+ Un'identità IAM federata configurata per gestire l'accesso a risorse esterne. Per maggiori informazioni, consulta [Utilizzo di un'identità federata per gestire l'accesso di Amazon Redshift alle risorse locali e alle tabelle esterne di Amazon Redshift Spectrum](https://docs.aws.amazon.com/redshift/latest/mgmt/authorization-fas-spectrum.html).
**Importante**
Non è possibile collegare i ruoli IAM quando si utilizza Redshift Spectrum con un catalogo di dati abilitato per Lake Formation.
*Per ulteriori informazioni sui passaggi necessari per la configurazione AWS Lake Formation per l'utilizzo con Redshift Spectrum, consulta [Tutorial: Creazione di un data lake da una sorgente JDBC in Lake Formation](https://docs.aws.amazon.com/lake-formation/latest/dg/getting-started-tutorial-jdbc.html) nella Developer Guide.AWS Lake Formation * In particolare, consulta [Esecuzione di query sui dati nel data lake utilizzando Amazon Redshift Spectrum](https://docs.aws.amazon.com/lake-formation/latest/dg/tut-query-redshift.html) per i dettagli sull'integrazione con Redshift Spectrum. I dati e AWS le risorse utilizzati in questo argomento dipendono dai passaggi precedenti del tutorial.
## Utilizzo di filtri di dati per la sicurezza a livello di riga e cella
Puoi definire filtri di dati AWS Lake Formation per controllare l'accesso delle query Redshift Spectrum a livello di riga e cella ai dati definiti nel tuo Data Catalog. Per configurare questo controllo, eseguirai le seguenti attività:
+ Creazione di un filtro di dati in Lake Formation con le seguenti informazioni:
+ Una specifica di colonna con un elenco di colonne da includere o escludere dai risultati della query.
+ Un'espressione di filtro di riga che specifica le righe da includere nei risultati della query.
Per ulteriori informazioni su come creare un filtro di dati, consulta [Filtri di dati in Lake Formation](https://docs.aws.amazon.com/lake-formation/latest/dg/data-filters-about.html) nella *Guida per gli sviluppatori di AWS Lake Formation *.
+ Creazione di una tabella esterna in Amazon Redshift che faccia riferimento a una tabella nel tuo catalogo dati abilitato per Lake Formation. Per dettagli su come eseguire query su una tabella di Lake Formation utilizzando Redshift Spectrum, consulta [Esecuzione di query sui dati nel data lake utilizzando Amazon Redshift Spectrum](https://docs.aws.amazon.com/lake-formation/latest/dg/tut-query-redshift.html) nella *Guida per gli sviluppatori di AWS Lake Formation *.
Dopo aver definito la tabella in Amazon Redshift, puoi eseguire query sulla tabella di Lake Formation e accedere solo alle righe e alle colonne consentite dal filtro di dati.
Per una guida dettagliata su come configurare la sicurezza a livello di riga e di cella in Lake Formation e quindi eseguire query mediante Redshift Spectrum, consulta la pagina relativa all'[utilizzo di Amazon Redshift Spectrum con policy di sicurezza a livello di riga e di cella definite in AWS Lake Formation](https://aws.amazon.com/blogs/big-data/use-amazon-redshift-spectrum-with-row-level-and-cell-level-security-policies-defined-in-aws-lake-formation/).
# File di dati per le query in Amazon Redshift Spectrum
In questa sezione viene descritto come creare file di dati in Amazon S3 in un formato supportato da Redshift Spectrum.
I file di dati utilizzati per le query in Amazon Redshift Spectrum sono in genere gli stessi tipi di file utilizzati per altre applicazioni. Ad esempio, gli stessi tipi di file vengono utilizzati con Amazon Athena, Amazon EMR e Quick. È possibile eseguire query sui dati nel loro formato originale direttamente da Amazon S3. Per farlo, i file di dati devono avere un formato supportato da Redshift Spectrum e trovarsi in un bucket Amazon S3 accessibile da parte del cluster.
Il bucket Amazon S3 con i file di dati e il cluster Amazon Redshift devono trovarsi nella stessa regione. AWS Per informazioni sulle AWS regioni supportate, consulta. [Regioni di Amazon Redshift Spectrum](c-spectrum-overview.md#c-spectrum-regions)
## Formati di dati per Redshift Spectrum
Redshift Spectrum supporta i seguenti formati di dati strutturati e semistrutturati:
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/redshift/latest/dg/c-spectrum-data-files.html)
Nella tabella precedente, i titoli indicano quanto segue:
+ **Colonna**: se il formato del file memorizza fisicamente i dati in una struttura orientata alle colonne anziché in una struttura orientata alle righe.
+ **Supporta letture parallele**: se il formato di file supporta la lettura di singoli blocchi all'interno del file. La lettura di singoli blocchi consente l'elaborazione distribuita di un file su più richieste Redshift Spectrum indipendenti invece di dover leggere il file completo in una singola richiesta.
+ **Unità di divisione**: per i formati di file che possono essere letti in parallelo, l'unità di divisione è il più piccolo blocco di dati che una singola richiesta Redshift Spectrum può elaborare.
**Nota**
I valori di timestamp nei file di testo devono essere nel formato `yyyy-MM-dd HH:mm:ss.SSSSSS`, come il seguente valore di timestamp `2017-05-01 11:30:59.000000`.
Consigliamo di utilizzare un formato di file di storage a colonne come Apache Parquet. Amazon Redshift supporta il formato di file di dati Apache Parquet v1. Con un formato di questo tipo, è possibile ridurre al minimo il trasferimento di dati al di fuori di Amazon S3 selezionando solo le colonne necessarie.
## Tipi di compressione per Redshift Spectrum
Per ridurre lo spazio di archiviazione, migliorare le prestazioni e ridurre i costi, consigliamo vivamente di comprimere i file di dati. Redshift Spectrum riconosce i tipi di compressione in funzione dell'estensione dei file.
Redshift Spectrum supporta i seguenti tipi di compressione ed estensioni:
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/redshift/latest/dg/c-spectrum-data-files.html)
Amazon Redshift supporta anche la compressione Zstandard (zstd) per i file Apache Parquet e le tabelle Apache Iceberg.
Puoi applicare la compressione a diversi livelli. Più comunemente, comprimi un intero file o comprimi singoli blocchi all'interno di un file. La compressione dei formati colonnari a livello di file non comporta vantaggi in termini di prestazioni.
Affinché Redshift Spectrum possa leggere un file in parallelo, deve essere vero quanto segue:
+ Il formato di file supporta le letture parallele.
+ La compressione a livello di file, se presente, supporta le letture parallele.
Non importa se le singole unità di divisione all'interno di un file vengono compresse utilizzando un algoritmo di compressione che può essere letto in parallelo, perché ogni unità divise viene elaborata da una singola richiesta Redshift Spectrum. Un esempio di questo sono i file Parquet compressi con Snappy. I singoli gruppi di righe all'interno del file Parquet vengono compressi utilizzando Snappy, ma la struttura di livello superiore del file rimane decompressa. In questo caso, il file può essere letto in parallelo perché ogni richiesta Redshift Spectrum può leggere ed elaborare singoli gruppi di righe da Amazon S3.
## Crittografia per Redshift Spectrum
Redshift Spectrum decrittografa in modo trasparente i file di dati crittografati utilizzando le seguenti opzioni di crittografia:
+ Crittografia lato server (SSE-S3) con una chiave di crittografia AES-256 gestita da Amazon S3.
+ Crittografia lato server con chiavi gestite da AWS Key Management Service (SSE-KMS).
Redshift Spectrum non supporta la crittografia lato client di Amazon S3. Per ulteriori informazioni sulla crittografia lato server, consultare [Protezione dei dati con la crittografia lato server](https://docs.aws.amazon.com/AmazonS3/latest/userguide/serv-side-encryption.html) nella *Guida per l'utente di Amazon Simple Storage Service*.
Amazon Redshift utilizza l'elaborazione MPP (Massively Parallel Processing) per eseguire rapidamente query complesse su grandi quantità di dati. Redshift Spectrum applica lo stesso principio per eseguire le query di dati esterni, utilizzando molteplici istanze di Redshift Spectrum per eseguire la scansione di file. Inserisci i file in una cartella distinta per ogni tabella.
Puoi ottimizzare i dati per l'elaborazione parallela procedendo come segue:
+ Se il formato di file o la compressione non supporta la lettura in parallelo, fraziona file di grandi dimensioni in molti file più piccoli. Ti consigliamo di utilizzare file di dimensioni comprese tra 64 MB e 1 GB.
+ Fai in modo che tutti i file siano all'incirca della stessa dimensione. Se alcuni file sono più grandi di altri, Redshift Spectrum non può distribuire il carico di lavoro in modo uniforme.
# Schemi esterni in Amazon Redshift Spectrum
In questo argomento viene illustrato come creare e utilizzare gli schemi esterni con Redshift Spectrum. Gli schemi esterni sono raccolte di tabelle che utilizzi come riferimenti per accedere ai dati all’esterno del cluster Amazon Redshift. Queste tabelle contengono i metadati sui dati esterni letti da Redshift Spectrum.
Tutte le tabelle esterne devono essere create in uno schema esterno, che crei utilizzando un'istruzione [CREATE EXTERNAL SCHEMA](r_CREATE_EXTERNAL_SCHEMA.md).
**Nota**
Alcune applicazioni utilizzano i termini *database* e *schema* in modo interscambiabile. In Amazon Redshift viene utilizzato il termine *schema*.
Uno schema esterno Amazon Redshift fa riferimento a un database esterno in un catalogo dati esterno. È possibile creare un database esterno in Amazon Redshift, in [Amazon Athena](https://docs.aws.amazon.com/athena/latest/ug/catalog.html), in [AWS Glue Data Catalog](https://docs.aws.amazon.com/glue/latest/dg/components-overview.html#data-catalog-intro) o in un metastore Apache Hive, come [Amazon EMR](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-what-is-emr.html). Se si crea un database esterno in Amazon Redshift, il database si trova nel catalogo dati di Athena. Per creare un database in un metastore Hive, devi crearlo nell'applicazione Hive.
Amazon Redshift deve essere autorizzato ad accedere al catalogo di dati in Athena e ai file di dati in Amazon S3 per tuo conto. Per fornire tale autorizzazione, devi prima creare un AWS Identity and Access Management ruolo (IAM). Successivamente, si collega il ruolo al cluster e si fornisce l'Amazon Resource Name (ARN) per il ruolo nell'istruzione `CREATE EXTERNAL SCHEMA` di Amazon Redshift. Per ulteriori informazioni sull'autorizzazione , consultare [Policy IAM per Amazon Redshift Spectrum](c-spectrum-iam-policies.md).
Per creare un database esterno nello stesso tempo, devi creare uno schema esterno, specificare `FROM DATA CATALOG` e includere la clausola `CREATE EXTERNAL DATABASE` nell'istruzione `CREATE EXTERNAL SCHEMA`.
L'esempio seguente crea uno schema esterno denominato `spectrum_schema` utilizzando il database esterno `spectrum_db`.
```
create external schema spectrum_schema from data catalog
database 'spectrum_db'
iam_role 'arn:aws:iam::123456789012:role/MySpectrumRole'
create external database if not exists;
```
Se il catalogo dati viene gestito mediante Athena, specificare il nome di database Athena e la regione AWS in cui si trova il catalogo dati Athena.
Nell'esempio seguente viene creato uno schema esterno che utilizza il database `sampledb` di default nel catalogo dati di Athena.
```
create external schema athena_schema from data catalog
database 'sampledb'
iam_role 'arn:aws:iam::123456789012:role/MySpectrumRole'
region 'us-east-2';
```
**Nota**
Il `region` parametro fa riferimento alla AWS regione in cui si trova il catalogo dati Athena, non alla posizione dei file di dati in Amazon S3.
Se il catalogo di dati viene gestito mediante un metastore Hive, come Amazon EMR, i gruppi di sicurezza devono essere configurati per consentire il traffico tra i cluster.
Nell'istruzione CREATE EXTERNAL SCHEMA, specifica `FROM HIVE METASTORE` e includi l'URI e il numero di porta del metastore. L'esempio seguente crea uno schema esterno che utilizza un database metastore Hive denominato `hive_db`.
```
create external schema hive_schema
from hive metastore
database 'hive_db'
uri '172.10.10.10' port 99
iam_role 'arn:aws:iam::123456789012:role/MySpectrumRole'
```
Per visualizzare gli schemi esterni per il cluster, eseguire una query sulla tabella di catalogo PG\$1EXTERNAL\$1SCHEMA o sulla vista SVV\$1EXTERNAL\$1SCHEMAS. L'esempio seguente esegue una query su SVV\$1EXTERNAL\$1SCHEMAS, che unisce in join PG\$1EXTERNAL\$1SCHEMA e PG\$1NAMESPACE.
```
select * from svv_external_schemas
```
Per la sintassi completa del comando e alcuni esempi, consultare [CREATE EXTERNAL SCHEMA](r_CREATE_EXTERNAL_SCHEMA.md).
## Utilizzo di cataloghi esterni in Amazon Redshift Spectrum
I metadati per i database esterni e le tabelle esterne di Amazon Redshift Spectrum sono archiviati in un catalogo dati esterno. Per impostazione predefinita, i metadati di Redshift Spectrum sono archiviati nel catalogo dati di Athena. È possibile visualizzare e gestire i database e le tabelle di Redshift Spectrum nella console Athena.
È inoltre possibile creare e gestire i database esterni e le tabelle esterne utilizzando il linguaggio DDL (Data Definition Language) Hive con Athena o un metastore Hive come Amazon EMR.
**Nota**
Consigliamo di utilizzare Amazon Redshift per creare e gestire i database esterni e le tabelle esterne in Redshift Spectrum.
### Visualizzazione dei database Redshift Spectrum in Athena e AWS Glue
È possibile creare un database esterno includendo la clausola CREATE EXTERNAL DATABASE IF NOT EXISTS nell'istruzione CREATE EXTERNAL SCHEMA. In questi casi, i metadati del database esterno sono archiviati nel catalogo dati. I metadati per le tabelle esterne che crei qualificati dallo schema esterno sono archiviati anche nel tuo catalogo dati .
Athena e AWS Glue mantieni un catalogo dati per ogni supporto. Regione AWS Per visualizzare i metadati della tabella, accedi ad Athena AWS Glue o alla console. In Athena, scegli **Origini dati, le** tue AWS Glue, quindi visualizza i dettagli del tuo database. In AWS Glue, scegli **Database**, il tuo database esterno, quindi visualizza i dettagli del tuo database.
Se le tabelle esterne vengono create e gestite mediante Athena, registrare il database utilizzando CREATE EXTERNAL SCHEMA. Ad esempio, il comando seguente registra il database Athena denominato `sampledb`.
```
create external schema athena_sample
from data catalog
database 'sampledb'
iam_role 'arn:aws:iam::123456789012:role/mySpectrumRole'
region 'us-east-1';
```
Quando si esegue una query sulla vista di sistema SVV\$1EXTERNAL\$1TABLES, vengono visualizzate le le tabelle nel database `sampledb` Athena e le tabelle create in Amazon Redshift.
```
select * from svv_external_tables;
```
```
schemaname | tablename | location
--------------+------------------+--------------------------------------------------------
athena_sample | elb_logs | s3://athena-examples/elb/plaintext
athena_sample | lineitem_1t_csv | s3://myspectrum/tpch/1000/lineitem_csv
athena_sample | lineitem_1t_part | s3://myspectrum/tpch/1000/lineitem_partition
spectrum | sales | s3://redshift-downloads/tickit/spectrum/sales
spectrum | sales_part | s3://redshift-downloads/tickit/spectrum/sales_part
```
### Registrazione di un database di un metastore Apache Hive
Se crei delle tabelle esterne in un metastore Apache Hive, puoi utilizzare CREATE EXTERNAL SCHEMA per registrare tali tabelle in Redshift Spectrum.
Nell'istruzione CREATE EXTERNAL SCHEMA, specifica la clausola FROM HIVE METASTORE e fornisci l'URI e il numero di porta del metastore Hive. Il ruolo IAM deve includere l'autorizzazione per accedere ad Amazon S3 ma nessuna autorizzazione Athena. L'esempio seguente registra un metastore Hive.
```
create external schema if not exists hive_schema
from hive metastore
database 'hive_database'
uri 'ip-10-0-111-111.us-west-2.compute.internal' port 9083
iam_role 'arn:aws:iam::123456789012:role/mySpectrumRole';
```
### Abilitazione del cluster Amazon Redshift per accedere al cluster Amazon EMR
Se il metastore Hive è in Amazon EMR, è necessario fornire al cluster Amazon Redshift l'accesso al cluster Amazon EMR. Per farlo, è necessario creare un gruppo di sicurezza Amazon EC2. Quindi si consente tutto il traffico in entrata verso il gruppo di sicurezza EC2 dal gruppo di sicurezza del cluster Amazon Redshift e dal gruppo di sicurezza del cluster Amazon EMR. Quindi viene aggiunta la sicurezza EC2 al cluster Amazon Redshift e al cluster Amazon EMR.
**Visualizzare il nome del gruppo di sicurezza del cluster Amazon Redshift**
Per visualizzare il gruppo di sicurezza, procedere come segue:
1. Accedi a Console di gestione AWS e apri la console Amazon Redshift all'indirizzo. [https://console.aws.amazon.com/redshiftv2/](https://console.aws.amazon.com/redshiftv2/)
1. Dal menu di navigazione scegliere **Clusters** (Cluster), quindi scegliere dall'elenco il cluster per visualizzarne i dettagli.
1. Scegliere **Properties (Proprietà)** e visualizzare la sezione **Network and security settings (Impostazioni rete e sicurezza)**.
1. Trova il gruppo di sicurezza in **Gruppo di sicurezza VPC** e prendi nota.
****
**Visualizzare il nome del gruppo di sicurezza dei nodi master di Amazon EMR**
1. Aprire il cluster Amazon EMR. Per ulteriori informazioni, consulta [Utilizzo delle configurazioni di sicurezza per impostare la sicurezza del cluster](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-security-configurations.html) nella *Guida alla gestione di Amazon EMR*.
1. In **Sicurezza e accesso**, prendere nota del nome del gruppo di sicurezza del nodo principale Amazon EMR.
![\[Schermata che evidenzia il nome del gruppo di sicurezza del nodo principale di Amazon EMR nella console Amazon EMR.\]](http://docs.aws.amazon.com/it_it/redshift/latest/dg/images/spectrum-emr-security-groups.png)
**Per creare o modificare un gruppo di sicurezza Amazon EC2 per consentire la connessione tra Amazon Redshift ed Amazon EMR**
1. Nel pannello di controllo di Amazon EC2, scegliere **Gruppi di sicurezza**. Per ulteriori informazioni, consulta [Regole del gruppo di sicurezza](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/security-group-rules.html) nella *Guida per l’utente di Amazon EC2*.
1. Scegliere **Create Security Group** (Crea gruppo di sicurezza).
1. Se si sta utilizzando VPC, scegliere quello in cui si trovano i cluster Amazon Redshift ed Amazon EMR.
1. Aggiungere una regola in entrata.
1. Per **Type** (Tipo), scegliere **Custom TCP** (TCP personalizzato).
1. In **Source (Origine)**, scegliere **Custom (Personalizzata)**.
1. Digitare il nome del gruppo di sicurezza Amazon Redshift.
1. Aggiungere un'altra regola in entrata.
1. Per **Type (Tipo)**, scegliere **TCP**.
1. Alla voce **Port Range (Intervallo porte)**, inserire **9083**.
**Nota**
La porta predefinita per un HMS EMR è 9083. Se HMS utilizza una porta differente, specificare la porta nella regola in entrata e nella definizione dello schema esterno.
1. In **Source (Origine)**, scegliere **Custom (Personalizzata)**.
1. Inserire un nome e una descrizione del gruppo di sicurezza.
1. Scegliere **Create Security Group** (Crea gruppo di sicurezza).
**Per aggiungere il gruppo di sicurezza Amazon EC2 creato nella procedura precedente al cluster Amazon Redshift**
1. Nella console Amazon Redshift, scegliere il cluster.
1. Scegli **Properties (Proprietà)**.
1. Visualizzare **Impostazioni di rete e sicurezza** e scegliere **Modificare**.
1. Nello stato **Gruppo di sicurezza VPC**, scegliere il nome del nuovo gruppo di sicurezza.
1. Scegli **Save changes** (Salva modifiche).
**Per aggiungere il gruppo di sicurezza Amazon EC2 al cluster Amazon EMR**
1. In Amazon EMR, scegliere il cluster. Per ulteriori informazioni, consulta [ Utilizzo configurazioni sicurezza per impostare la sicurezza del cluster](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-security-configurations.html) nella *Guida alla gestione di Amazon EMR*.
1. In **Hardware**, scegliere il collegamento per il nodo master.
1. Scegliere il collegamento nella colonna **EC2 instance ID (ID istanza EC2)**.
![\[Schermata che evidenzia il valore dell'ID di un'istanza Amazon EC2 nella console Amazon EMR.\]](http://docs.aws.amazon.com/it_it/redshift/latest/dg/images/spectrum-emr-add-security-group.png)
1. Per **Azioni**, scegliere **Sicurezza**, **Modifica gruppi di sicurezza**.
1. Nello stato**Gruppi di sicurezza associati**, scegliere il nuovo gruppo di sicurezza e scegliere **Aggiungi gruppo di sicurezza**.
1. Scegli **Save** (Salva).
# Tabelle esterne per Redshift Spectrum
In questo argomento viene illustrato come creare e utilizzare le tabelle esterne con Redshift Spectrum. Le tabelle esterne sono tabelle che utilizzi come riferimenti per accedere ai dati all’esterno del cluster Amazon Redshift. Queste tabelle contengono i metadati sui dati esterni letti da Redshift Spectrum.
Crei una tabella esterna in uno schema esterno. Per creare tabelle esterne, devi essere il proprietario dello schema esterno o un utente con privilegi avanzati. Per trasferire la proprietà di uno schema esterno, utilizza [ALTER SCHEMA](r_ALTER_SCHEMA.md) per cambiare il proprietario. L'esempio seguente cambia il proprietario dello schema `spectrum_schema` in `newowner`.
```
alter schema spectrum_schema owner to newowner;
```
Per eseguire una query di Redshift Spectrum, sono necessarie le seguenti autorizzazioni:
+ Autorizzazione di utilizzare lo schema
+ Autorizzazione di creare tabelle temporanee nel database corrente
L'esempio seguente concede l'autorizzazione all'utilizzo dello schema `spectrum_schema` al gruppo di utenti `spectrumusers`.
```
grant usage on schema spectrum_schema to group spectrumusers;
```
L'esempio seguente concede l'autorizzazione temporanea per il database `spectrumdb` al gruppo di utenti `spectrumusers`.
```
grant temp on database spectrumdb to group spectrumusers;
```
Puoi creare una tabella esterna in Amazon Redshift AWS Glue, Amazon Athena o un metastore Apache Hive. Per ulteriori informazioni, consultare [Nozioni di base sull'uso di AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/getting-started.html) nella *Guida per gli sviluppatori di AWS Glue *, [Nozioni di base](https://docs.aws.amazon.com/athena/latest/ug/getting-started.html) nella *Guida per l'utente di Amazon Athena* oppure [Apache Hive](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-hive.html) nella *Guida per gli sviluppatori di Amazon EMR*.
Se la tua tabella esterna è definita in AWS Glue, Athena o in un metastore Hive, devi prima creare uno schema esterno che faccia riferimento al database esterno. È quindi possibile fare riferimento alla tabella esterna nell'istruzione SELECT aggiungendo un prefisso al nome della tabella con il nome dello schema senza che sia necessario creare la tabella in Amazon Redshift. Per ulteriori informazioni, consulta [Schemi esterni in Amazon Redshift Spectrum](c-spectrum-external-schemas.md).
Per consentire ad Amazon Redshift di visualizzare le tabelle in AWS Glue Data Catalog, aggiungi il ruolo `glue:GetTable` IAM di Amazon Redshift. In caso contrario, si potrebbe verificare un errore simile al seguente:
```
RedshiftIamRoleSession is not authorized to perform: glue:GetTable on resource: *;
```
Ad esempio, si supponga di avere una tabella esterna denominata `lineitem_athena` definita nel catalogo esterno di Athena. In tal caso, puoi definire uno schema esterno denominato `athena_schema` e quindi eseguire una query sulla tabella utilizzando l'istruzione SELECT seguente.
```
select count(*) from athena_schema.lineitem_athena;
```
Per definire una tabella esterna in Amazon Redshift, utilizzare il comando [CREATE EXTERNAL TABLE](r_CREATE_EXTERNAL_TABLE.md). L'istruzione della tabella esterna definisce le colonne della tabella, il formato dei file di dati e la posizione dei dati in Amazon S3. Redshift Spectrum esegue la scansione dei file nella cartella specificata e in tutte le sottocartelle. Redshift Spectrum ignora i file nascosti e i file che iniziano con un punto, un carattere di sottolineatura o un marcatore hash ( . , \$1 o \$1) oppure che terminano con una tilde (\$1).
Nell'esempio seguente viene creata una tabella denominata SALES nello schema esterno Amazon Redshift denominato `spectrum`. I dati sono in file di testo delimitati da tabulazioni.
```
create external table spectrum.sales(
salesid integer,
listid integer,
sellerid integer,
buyerid integer,
eventid integer,
dateid smallint,
qtysold smallint,
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/'
table properties ('numRows'='172000');
```
Per visualizzare le tabelle esterne, eseguire una query sulla vista di sistema [SVV\$1EXTERNAL\$1TABLES](r_SVV_EXTERNAL_TABLES.md).
## Pseudocolonne
Di default, Amazon Redshift crea tabelle esterne con le pseudocolonne `$path`, `$size` e `$spectrum_oid`. Selezionare la colonna `$path` per visualizzare il percorso ai file di dati su Simple Storage Service (Amazon S3) e selezionare la colonna `$size` per visualizzare le dimensioni dei file di dati per ogni riga restituita da una query. La colonna `$spectrum_oid` consente di eseguire query correlate con Redshift Spectrum. Per vedere un esempio, consulta [Esempio: esecuzione di sottoquery correlate in Redshift Spectrum](c_performing-correlated-subqueries-spectrum.md). I nomi di colonna `$path`, `$size` e `$spectrum_oid` devono essere delimitati da virgolette doppie. Una clausola SELECT \$1 non restituisce le pseudocolonne. È necessario includere in modo esplicito i nomi delle colonne `$path`, `$size` e `$spectrum_oid` nella query, come indicato nel seguente esempio.
```
select "$path", "$size", "$spectrum_oid"
from spectrum.sales_part where saledate = '2008-12-01';
```
Puoi disabilitare la creazione di pseudocolonne per una sessione impostando il parametro di configurazione `spectrum_enable_pseudo_columns` su `false`. Per ulteriori informazioni, consulta [spectrum\$1enable\$1pseudo\$1columns](r_spectrum_enable_pseudo_columns.md). È anche possibile disabilitare solo la pseudocolonna `$spectrum_oid` impostando il parametro di configurazione `enable_spectrum_oid` su `false`. Per ulteriori informazioni, consulta [enable\$1spectrum\$1oid](r_spectrum_enable_spectrum_oid.md). Tuttavia, disabilitando la pseudocolonna `$spectrum_oid` viene disabilitato anche il supporto per le query correlate con Redshift Spectrum.
**Importante**
La selezione di `$size`, `$path` o `$spectrum_oid` comporta dei costi perché Redshift Spectrum analizza i file di dati su Simple Storage Service (Amazon S3) per determinare la dimensione del set di risultati. Per ulteriori informazioni sui prezzi, consultare [Prezzi di Amazon Redshift](https://aws.amazon.com/redshift/pricing/).
### Esempio di pseudocolonne
L'esempio seguente restituisce la dimensione totale dei file di dati correlati per una tabella esterna.
```
select distinct "$path", "$size"
from spectrum.sales_part;
$path | $size
--------------------------------------------------------------------------+-------
s3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-01/ | 1616
s3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-02/ | 1444
s3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-03/ | 1644
```
## Partizionamento delle tabelle esterne di Redshift Spectrum
Quando esegui la partizione dei dati, puoi limitare la quantità di dati sottoposti a scansione da Redshift Spectrum filtrandoli in base a qualsiasi chiave di partizione.
In genere, si partizionano i dati in base a criteri temporali. Ad esempio, puoi scegliere di eseguire il partizionamento per anno, mese, data e ora. Se hai dati da più origini, puoi eseguire il partizionamento in base a una data e a un identificatore di origine dati.
La procedura seguente descrive come partizionare i dati.
**Per partizionare i dati**
1. Archiviare i dati in cartelle di Amazon S3 in funzione della chiave di partizione.
Creare una cartella per ogni valore di partizione e assegnare un nome alla cartella con la chiave e il valore di partizione. Ad esempio, se si esegue la partizione per data, le cartelle possono essere denominate `saledate=2017-04-01`, `saledate=2017-04-02` e così via. Redshift Spectrum esegue la scansione dei file nella cartella di partizione e in tutte le sottocartelle. Redshift Spectrum ignora i file nascosti e i file che iniziano con un punto, un carattere di sottolineatura o un marcatore hash ( . , \$1 o \$1) oppure che terminano con una tilde (\$1).
1. Creare una tabella esterna e specificare la chiave di partizione nella clausola PARTITIONED BY.
La chiave di partizione non può essere Il nome di una colonna della tabella. Il tipo di dati può essere SMALLINT, INTEGER, BIGINT, DECIMAL, REAL, DOUBLE PRECISION, BOOLEAN, CHAR, VARCHAR, DATE o TIMESTAMP.
1. Aggiungere le partizioni.
Utilizzando [ALTER TABLE](r_ALTER_TABLE.md) … ADD PARTITION, aggiungere ogni partizione, specificando la colonna della partizione e il valore della chiave nonché la posizione della cartella di partizione in Amazon S3. È possibile aggiungere più partizioni in una singola istruzione ALTER TABLE … ADD. L'esempio seguente aggiunge partizioni per `'2008-01'` e `'2008-03'`.
```
alter table spectrum.sales_part add
partition(saledate='2008-01-01')
location 's3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-01/'
partition(saledate='2008-03-01')
location 's3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-03/';
```
**Nota**
Se utilizzi il AWS Glue catalogo, puoi aggiungere fino a 100 partizioni utilizzando una singola istruzione ALTER TABLE.
### Partizionamento di esempi di dati
In questo esempio, crei una tabella esterna partizionata con una singola chiave di partizione e una tabella esterna partizionata con due chiavi di partizione.
I dati di esempio per questo esempio si trovano in un bucket Amazon S3 che consente l'accesso in lettura a tutti gli utenti autenticati. AWS Il cluster e i file di dati esterni devono trovarsi nella stessa Regione AWS. Il bucket di dati di esempio si trova nella regione Stati Uniti orientali (Virginia settentrionale) (us-east-1). Per accedere ai dati mediante Redshift Spectrum, anche il cluster deve essere nella regione us-east-1. Per elencare le cartelle in Amazon S3, emettere il comando seguente.
```
aws s3 ls s3://redshift-downloads/tickit/spectrum/sales_partition/
```
```
PRE saledate=2008-01/
PRE saledate=2008-03/
PRE saledate=2008-04/
PRE saledate=2008-05/
PRE saledate=2008-06/
PRE saledate=2008-12/
```
Se non hai ancora uno schema esterno, esegui il comando seguente. Sostituisci il AWS Identity and Access Management tuo ruolo (IAM) con Amazon Resource Name (ARN).
```
create external schema spectrum
from data catalog
database 'spectrumdb'
iam_role 'arn:aws:iam::123456789012:role/myspectrumrole'
create external database if not exists;
```
#### Esempio 1: partizionamento con una singola chiave di partizione
Nell'esempio seguente, crei una tabella esterna partizionata per mese.
Per creare una tabella esterna partizionata per mese, esegui il comando seguente.
```
create external table spectrum.sales_part(
salesid integer,
listid integer,
sellerid integer,
buyerid integer,
eventid integer,
dateid smallint,
qtysold smallint,
pricepaid decimal(8,2),
commission decimal(8,2),
saletime timestamp)
partitioned by (saledate char(10))
row format delimited
fields terminated by '|'
stored as textfile
location 's3://redshift-downloads/tickit/spectrum/sales_partition/'
table properties ('numRows'='172000');
```
Per aggiungere le partizioni, esegui il comando ALTER TABLE seguente.
```
alter table spectrum.sales_part add
partition(saledate='2008-01')
location 's3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-01/'
partition(saledate='2008-03')
location 's3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-03/'
partition(saledate='2008-04')
location 's3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-04/';
```
Per selezionare i dati dalla tabella partizionata, esegui la seguente query.
```
select top 5 spectrum.sales_part.eventid, sum(spectrum.sales_part.pricepaid)
from spectrum.sales_part, event
where spectrum.sales_part.eventid = event.eventid
and spectrum.sales_part.pricepaid > 30
and saledate = '2008-01'
group by spectrum.sales_part.eventid
order by 2 desc;
```
```
eventid | sum
--------+---------
4124 | 21179.00
1924 | 20569.00
2294 | 18830.00
2260 | 17669.00
6032 | 17265.00
```
Per visualizzare le partizioni delle tabelle, eseguire una query sulla vista di sistema [SVV\$1EXTERNAL\$1PARTITIONS](r_SVV_EXTERNAL_PARTITIONS.md).
```
select schemaname, tablename, values, location from svv_external_partitions
where tablename = 'sales_part';
```
```
schemaname | tablename | values | location
-----------+------------+-------------+-------------------------------------------------------------------------
spectrum | sales_part | ["2008-01"] | s3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-01
spectrum | sales_part | ["2008-03"] | s3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-03
spectrum | sales_part | ["2008-04"] | s3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-04
```
#### Esempio 2: partizionamento con più chiavi di partizione
Per creare una tabella esterna partizionata per `date` e `eventid`, esegui il comando seguente.
```
create external table spectrum.sales_event(
salesid integer,
listid integer,
sellerid integer,
buyerid integer,
eventid integer,
dateid smallint,
qtysold smallint,
pricepaid decimal(8,2),
commission decimal(8,2),
saletime timestamp)
partitioned by (salesmonth char(10), event integer)
row format delimited
fields terminated by '|'
stored as textfile
location 's3://redshift-downloads/tickit/spectrum/salesevent/'
table properties ('numRows'='172000');
```
Per aggiungere le partizioni, esegui il comando ALTER TABLE seguente.
```
alter table spectrum.sales_event add
partition(salesmonth='2008-01', event='101')
location 's3://redshift-downloads/tickit/spectrum/salesevent/salesmonth=2008-01/event=101/'
partition(salesmonth='2008-01', event='102')
location 's3://redshift-downloads/tickit/spectrum/salesevent/salesmonth=2008-01/event=102/'
partition(salesmonth='2008-01', event='103')
location 's3://redshift-downloads/tickit/spectrum/salesevent/salesmonth=2008-01/event=103/'
partition(salesmonth='2008-02', event='101')
location 's3://redshift-downloads/tickit/spectrum/salesevent/salesmonth=2008-02/event=101/'
partition(salesmonth='2008-02', event='102')
location 's3://redshift-downloads/tickit/spectrum/salesevent/salesmonth=2008-02/event=102/'
partition(salesmonth='2008-02', event='103')
location 's3://redshift-downloads/tickit/spectrum/salesevent/salesmonth=2008-02/event=103/'
partition(salesmonth='2008-03', event='101')
location 's3://redshift-downloads/tickit/spectrum/salesevent/salesmonth=2008-03/event=101/'
partition(salesmonth='2008-03', event='102')
location 's3://redshift-downloads/tickit/spectrum/salesevent/salesmonth=2008-03/event=102/'
partition(salesmonth='2008-03', event='103')
location 's3://redshift-downloads/tickit/spectrum/salesevent/salesmonth=2008-03/event=103/';
```
Esegui la query seguente per selezionare i dati dalla tabella partizionata.
```
select spectrum.sales_event.salesmonth, event.eventname, sum(spectrum.sales_event.pricepaid)
from spectrum.sales_event, event
where spectrum.sales_event.eventid = event.eventid
and salesmonth = '2008-02'
and (event = '101'
or event = '102'
or event = '103')
group by event.eventname, spectrum.sales_event.salesmonth
order by 3 desc;
```
```
salesmonth | eventname | sum
-----------+-----------------+--------
2008-02 | The Magic Flute | 5062.00
2008-02 | La Sonnambula | 3498.00
2008-02 | Die Walkure | 534.00
```
## Mappatura delle colonne di una tabella esterna alle colonne ORC
Utilizzare le tabelle esterne di Amazon Redshift Spectrum per eseguire query sui dati dai file nel formato ORC. Il formato Optimized Row Columnar (ORC) è un formato di file di storage a colonne che supporta le strutture di dati annidate. Per ulteriori informazioni sull'esecuzione di query su dati nidificati, consultare [Esecuzione di query su dati nidificati con Amazon Redshift Spectrum](tutorial-query-nested-data.md#tutorial-nested-data-overview).
Quando crei una tabella esterna che fa riferimento ai dati in un file ORC, devi mappare ogni colonna della tabella verso una colonna nei dati ORC. A tale scopo, utilizza uno dei seguenti metodi:
+ [Mappatura in base alla posizione](#orc-mapping-by-position)
+ [Mappatura in base al nome delle colonne](#orc-mapping-by-name)
La mappatura in base al nome delle colonne è l'opzione predefinita.
### Mappatura in base alla posizione
Con la mappatura in base alla posizione, la prima colonna definita nella tabella esterna mappa alla prima colonna nel file di dati ORC, la seconda alla seconda e così via. Per la mappatura in base alla posizione, è necessario che l'ordine delle colonne nella tabella esterna e nel file ORC corrisponda. Diversamente, puoi mappare le colonne in base al nome.
**Importante**
Nelle release precedenti, Redshift Spectrum utilizzava la mappatura in base alla posizione come opzione predefinita. Se devi continuare a utilizzare la mappatura in base alla posizione per le tabelle esistenti, imposta la proprietà di tabella `orc.schema.resolution` su `position`, come mostrato nell'esempio seguente.
```
alter table spectrum.orc_example
set table properties('orc.schema.resolution'='position');
```
Ad esempio, la tabella `SPECTRUM.ORC_EXAMPLE` è definita come segue.
```
create external table spectrum.orc_example(
int_col int,
float_col float,
nested_col struct<
"int_col" : int,
"map_col" : map>
>
) stored as orc
location 's3://example/orc/files/';
```
La struttura della tabella può essere astratta come segue.
```
• 'int_col' : int
• 'float_col' : float
• 'nested_col' : struct
o 'int_col' : int
o 'map_col' : map
- key : int
- value : array
- value : float
```
Il file ORC sottostante presenta la seguente struttura di file.
```
• ORC file root(id = 0)
o 'int_col' : int (id = 1)
o 'float_col' : float (id = 2)
o 'nested_col' : struct (id = 3)
- 'int_col' : int (id = 4)
- 'map_col' : map (id = 5)
- key : int (id = 6)
- value : array (id = 7)
- value : float (id = 8)
```
In questo esempio, puoi mappare ciascuna colonna nella tabella esterna verso una colonna nel file di dati ORC rigorosamente in base alla posizione. Di seguito è riportata la mappatura.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/redshift/latest/dg/c-spectrum-external-tables.html)
### Mappatura in base al nome delle colonne
Tramite la mappatura dei nomi, puoi mappare le colonne in una tabella esterna verso colonne con nome nei file ORC allo stesso livello e con il medesimo nome.
Supponi ad esempio di voler mappare la tabella del precedente esempio, `SPECTRUM.ORC_EXAMPLE`, con un file ORC che utilizza la seguente struttura di file.
```
• ORC file root(id = 0)
o 'nested_col' : struct (id = 1)
- 'map_col' : map (id = 2)
- key : int (id = 3)
- value : array (id = 4)
- value : float (id = 5)
- 'int_col' : int (id = 6)
o 'int_col' : int (id = 7)
o 'float_col' : float (id = 8)
```
Utilizzando la mappatura basata sulla posizione, Redshift Spectrum tenta di eseguire la mappatura seguente.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/redshift/latest/dg/c-spectrum-external-tables.html)
Quando si esegue una query su una tabella con la precedente mappatura basata sulla posizione, il comando SELECT ha esito negativo sulla convalida del tipo in quanto le strutture sono diverse.
Puoi mappare la stessa tabella esterna verso entrambe le strutture di file mostrate negli esempi precedenti utilizzando la mappatura basata sui nomi. Le colonne di tabella `int_col`, `float_col` e `nested_col` vengono mappate in base al nome verso le colonne con i medesimi nomi nel file ORC. La colonna denominata `nested_col` nella tabella esterna è una colonna `struct` con sottocolonne denominate `map_col` e `int_col`. Le sottocolonne vengono inoltre mappate correttamente alle colonne corrispondenti nel file ORC in base al nome.
## Creazione di tabelle esterne per i dati gestiti in Apache Hudi
Per eseguire query sui dati in formato Apache Hudi Copy On Write (CoW), è possibile utilizzare le tabelle esterne di Amazon Redshift Spectrum. Una tabella Hudi Copy On Write è una raccolta di file Apache Parquet archiviati in Amazon S3. È possibile leggere le tabelle Copy On Write (CoW) nelle versioni 0.5.2, 0.6.0, 0.7.0, 0.8.0, 0.9.0, 0.10.0, 0.10.1, 0.11.0 e 0.11.1 di Apache Hudi create e modificate mediante operazioni di scrittura insert, delete e upsert. Le tabelle bootstrap, ad esempio, non sono supportate. Per ulteriori informazioni, consultare [Copia sulla tabella di scrittura](https://hudi.apache.org/docs/next/table_types#copy-on-write-table) nella documentazione open source di Apache Hudi.
Quando si crea una tabella esterna che fa riferimento ai dati in formato Hudi CoW, è necessario mappare ogni colonna della tabella esterna a una colonna nei dati Hudi. La mappatura viene eseguita per colonna.
Le istruzioni DDL (Data Definition Language) per tabelle Hudi partizionate e non partizionate sono simili a quelle degli altri formati di file Apache Parquet. Per le tabelle Hudi, `INPUTFORMAT` può essere definito come `org.apache.hudi.hadoop.HoodieParquetInputFormat`. Il parametro `LOCATION` deve puntare alla cartella di base della tabella Hudi che contiene la cartella `.hoodie`, necessaria per stabilire la tempistica di commit Hudi. In alcuni casi, un'operazione SELECT su una tabella Hudi potrebbe non riuscire con il messaggio Nessuna tempistica di commit Hudi valida trovata. In questo caso, verificare se la cartella `.hoodie` si trova nella posizione corretta e se contiene una tempistica di commit Hudi valida.
**Nota**
Il formato Apache Hudi è supportato solo quando si utilizza un AWS Glue Data Catalog. Non è supportato se si utilizza un metastore Apache Hive come catalogo esterno.
Il formato DDL per definire una tabella non partizionata è il seguente.
```
CREATE EXTERNAL TABLE tbl_name (columns)
ROW FORMAT SERDE 'org.apache.hadoop.hive.ql.io.parquet.serde.ParquetHiveSerDe'
STORED AS
INPUTFORMAT 'org.apache.hudi.hadoop.HoodieParquetInputFormat'
OUTPUTFORMAT 'org.apache.hadoop.hive.ql.io.parquet.MapredParquetOutputFormat'
LOCATION 's3://s3-bucket/prefix'
```
Il formato DDL per definire una tabella partizionata è il seguente.
```
CREATE EXTERNAL TABLE tbl_name (columns)
PARTITIONED BY(pcolumn1 pcolumn1-type[,...])
ROW FORMAT SERDE 'org.apache.hadoop.hive.ql.io.parquet.serde.ParquetHiveSerDe'
STORED AS
INPUTFORMAT 'org.apache.hudi.hadoop.HoodieParquetInputFormat'
OUTPUTFORMAT 'org.apache.hadoop.hive.ql.io.parquet.MapredParquetOutputFormat'
LOCATION 's3://s3-bucket/prefix'
```
Per aggiungere partizioni a una tabella Hudi partizionata, eseguire un comando ALTER TABLE ADD PARTITION in cui il parametro `LOCATION` punta alla sottocartella Amazon S3 con i file che appartengono alla partizione.
Il formato DDL per aggiungere le partizioni è il seguente.
```
ALTER TABLE tbl_name
ADD IF NOT EXISTS PARTITION(pcolumn1=pvalue1[,...])
LOCATION 's3://s3-bucket/prefix/partition-path'
```
## Creazione di tabelle esterne per i dati gestiti in Delta Lake
Per eseguire una query sui dati nelle tabelle Delta Lake, è possibile utilizzare le tabelle esterne di Amazon Redshift Spectrum.
Per accedere a una tabella Delta Lake da Redshift Spectrum, generare un manifest prima della query. Un *manifest* Delta Lake contiene un elenco di file che costituiscono uno snapshot coerente della tabella Delta Lake. In una tabella partizionata, esiste un solo manifest per partizione. Una tabella Delta Lake è una raccolta di file Apache Parquet archiviati in Amazon S3. Per ulteriori informazioni, consultare [Delta Lake](https://delta.io) nella documentazione open source di Delta Lake.
Quando si crea una tabella esterna che fa riferimento ai dati nelle tabelle Delta Lake, viene mappata ogni colonna della tabella a una colonna nella tabella Delta Lake. La mappatura viene eseguita per nome della colonna.
La DDL per le tabelle Delta Lake partizionate e non partizionate è simile a quella degli altri formati di file Apache Parquet. Per le tabelle Delta Lake, è possibile definire `INPUTFORMAT` come `org.apache.hadoop.hive.ql.io.SymlinkTextInputFormat` e `OUTPUTFORMAT` come `org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat`. Il parametro `LOCATION` deve puntare alla cartella del manifest nella cartella di base della tabella. Se un'operazione SELECT su una tabella Delta Lake non riesce per vari possibili motivi, consultare [Limitazioni e risoluzione dei problemi per le tabelle Delta Lake](#c-spectrum-column-mapping-delta-limitations).
Il formato DDL per definire una tabella non partizionata è il seguente.
```
CREATE EXTERNAL TABLE tbl_name (columns)
ROW FORMAT SERDE 'org.apache.hadoop.hive.ql.io.parquet.serde.ParquetHiveSerDe'
STORED AS
INPUTFORMAT 'org.apache.hadoop.hive.ql.io.SymlinkTextInputFormat'
OUTPUTFORMAT 'org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat'
LOCATION 's3://s3-bucket/prefix/_symlink_format_manifest'
```
Il formato DDL per definire una tabella partizionata è il seguente.
```
CREATE EXTERNAL TABLE tbl_name (columns)
PARTITIONED BY(pcolumn1 pcolumn1-type[,...])
ROW FORMAT SERDE 'org.apache.hadoop.hive.ql.io.parquet.serde.ParquetHiveSerDe'
STORED AS
INPUTFORMAT 'org.apache.hadoop.hive.ql.io.SymlinkTextInputFormat'
OUTPUTFORMAT 'org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat'
LOCATION 's3://s3-bucket>/prefix/_symlink_format_manifest'
```
Per aggiungere partizioni a una tabella Delta Lake partizionata, eseguire un comando ALTER TABLE ADD PARTITION in cui il parametro `LOCATION` punta alla sottocartella Amazon S3 che contiene il manifest per la partizione.
Il formato DDL per aggiungere le partizioni è il seguente.
```
ALTER TABLE tbl_name
ADD IF NOT EXISTS PARTITION(pcolumn1=pvalue1[,...])
LOCATION
's3://s3-bucket/prefix/_symlink_format_manifest/partition-path'
```
Oppure eseguire la DDL che punta direttamente al file manifest di Delta Lake.
```
ALTER TABLE tbl_name
ADD IF NOT EXISTS PARTITION(pcolumn1=pvalue1[,...])
LOCATION
's3://s3-bucket/prefix/_symlink_format_manifest/partition-path/manifest'
```
### Limitazioni e risoluzione dei problemi per le tabelle Delta Lake
Quando si eseguono query sulle tabelle Delta Lake da Redshift Spectrum, tenere presente quanto segue:
+ Se un manifest punta a uno snapshot o una partizione che non esiste più, le query hanno esito negativo fino a quando non viene generato un nuovo manifest valido. Ad esempio, questo potrebbe derivare da un'operazione VACUUM sulla tabella sottostante,
+ I manifest di Delta Lake forniscono coerenza solo a livello di partizione.
Nella tabella seguente vengono illustrati alcuni potenziali motivi per alcuni errori quando si esegue una query su una tabella Delta Lake.
| Messaggio di errore | Motivo possibile |
| --- | --- |
| Il manifest di Delta Lake nel bucket *s3-bucket-1* non può contenere voci nel bucket *s3-bucket-2*. | Le voci del manifest puntano a file in un bucket Amazon S3 diverso da quello specificato. |
| I file Delta Lake dovrebbero trovarsi nella stessa cartella. | Le voci del manifest puntano a file che hanno un prefisso Amazon S3 diverso da quello specificato. |
| Il file *nomefile* elencato nel manifest Delta Lake *percorso manifest* non è stato trovato. | Un file elencato nel manifest non è stato trovato in Amazon S3. |
| Errore durante il recupero del manifesto Delta Lake. | Il manifest non è stato trovato in Amazon S3. |
| Percorso S3 non valido. | Una voce nel file manifest non è un percorso Amazon S3 valido o il file manifest è stato danneggiato. |
# Utilizzo delle tabelle Apache Iceberg con Amazon Redshift
**Nota**
Per ottenere le prestazioni migliori quando utilizzi le tabelle Apache Iceberg con Amazon Redshift, devi generare statistiche per le colonne delle tabelle con AWS Glue. Per ulteriori informazioni, consulta [Generazione delle statistiche per le colonne delle tabelle Iceberg](https://docs.aws.amazon.com/glue/latest/dg/iceberg-generate-column-stats.html) nella *Guida per gli sviluppatori di AWS Glue *.
In questo argomento viene illustrato come utilizzare le tabelle in formato Apache Iceberg con Redshift Spectrum o Redshift serverless. Apache Iceberg è un formato ad alte prestazioni per le tabelle analitiche di grandi dimensioni.
È possibile utilizzare Redshift Spectrum o Redshift Serverless per interrogare le tabelle di Apache Iceberg catalogate in AWS Glue Data Catalog. Apache Iceberg è un formato di tabella open source per data lake. Per ulteriori informazioni, consulta [Apache Iceberg](https://iceberg.apache.org/) nella documentazione di Apache Iceberg.
Amazon Redshift fornisce coerenza transazionale per l'interrogazione delle tabelle Apache Iceberg. Puoi manipolare i dati nelle tue tabelle utilizzando servizi conformi ad ACID (atomicità, consistenza, isolamento, durabilità) come Amazon Athena e Amazon EMR mentre esegui query utilizzando Amazon Redshift. Amazon Redshift può utilizzare le statistiche delle tabelle archiviate nei metadati di Apache Iceberg per ottimizzare i piani di query e ridurre le scansioni dei file durante l'elaborazione delle query. Con Amazon Redshift SQL, puoi unire tabelle Redshift con tabelle data lake.
Per iniziare a usare le tabelle Iceberg con Amazon Redshift:
1. Crea una tabella Apache Iceberg su un AWS Glue Data Catalog database utilizzando un servizio compatibile come Amazon Athena o Amazon EMR. Per creare una tabella Iceberg usando Athena, vedi [Utilizzo delle tabelle Apache Iceberg](https://docs.aws.amazon.com/athena/latest/ug/querying-iceberg.html) nella *Guida per l'utente di Amazon Athena*.
1. Crea un cluster Amazon Redshift o un gruppo di lavoro Redshift Serverless con un ruolo IAM associato che consenta l'accesso al tuo data lake. Per informazioni su come creare cluster o gruppi di lavoro, consulta [Nozioni di base sui data warehouse con provisioning Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/gsg/new-user.html) e [Nozioni di base sui data warehouse Redshift serverless](https://docs.aws.amazon.com/redshift/latest/gsg/new-user-serverless.html) nella *Guida alle operazioni di base di Amazon Redshift*.
1. Connettiti al tuo cluster o gruppo di lavoro utilizzando l'editor di query v2 o un client SQL di terze parti. Per informazioni su come connetterti utilizzando Query Editor V2, consulta [Connessione a un data warehouse Amazon Redshift tramite gli strumenti del client SQL](https://docs.aws.amazon.com/redshift/latest/mgmt/connecting-to-cluster.html) nella *Guida alla gestione di Amazon Redshift*.
1. Crea uno schema esterno nel database Amazon Redshift per uno specifico database del Catalogo dati che include le tabelle Iceberg. Per informazioni sulla creazione di uno schema esterno, consulta [Schemi esterni in Amazon Redshift Spectrum](c-spectrum-external-schemas.md).
1. Esegui query SQL per accedere alle tabelle Iceberg nello schema esterno che hai creato.
## Considerazioni sull'utilizzo delle tabelle Apache Iceberg con Amazon Redshift
Quando utilizzi Amazon Redshift con le tabelle Iceberg, considera quanto segue:
+ **Supporto per la versione Iceberg**: Amazon Redshift supporta l'esecuzione di query sulle seguenti versioni delle tabelle Iceberg:
+ Versione 1 che definisce la modalità di gestione delle tabelle analitiche di grandi dimensioni utilizzando file di dati immutabili.
+ Versione 2 che aggiunge la possibilità di supportare l'aggiornamento e l'eliminazione a livello di riga mantenendo invariati i file di dati esistenti e gestendo le modifiche ai dati della tabella utilizzando i file di eliminazione.
Per la differenza tra le tabelle v1 e v2, consulta [Modifiche al tipo di formato](https://iceberg.apache.org/spec/#appendix-e-format-version-changes) nella documentazione di Apache Iceberg.
+ **Aggiungere partizioni**: non è necessario aggiungere manualmente le partizioni per le tabelle Apache Iceberg. Le nuove partizioni nelle tabelle Apache Iceberg vengono rilevate automaticamente da Amazon Redshift e non è necessaria alcuna operazione manuale per aggiornare le partizioni nella definizione della tabella. Eventuali modifiche alle specifiche della partizione vengono inoltre applicate automaticamente alle richieste senza alcun intervento da parte dell'utente.
+ **Inserimento di dati Iceberg in Amazon Redshift**: puoi utilizzare i comandi INSERT INTO o CREATE TABLE AS per importare dati dalla tua tabella Iceberg in una tabella Amazon Redshift locale. Al momento non è possibile utilizzare il comando COPY per inserire il contenuto di una tabella Apache Iceberg in una tabella Amazon Redshift locale.
+ **Viste materializzate**: puoi creare le viste materializzate nelle tabelle Apache Iceberg come faresti per qualsiasi altra tabella esterna in Amazon Redshift. Le stesse considerazioni per altri formati di tabelle di data lake si applicano alle tabelle Apache Iceberg. La riscrittura automatica delle query e le viste materializzate automatiche delle tabelle di data lake non sono attualmente supportate.
+ AWS Lake Formation controllo **granulare degli accessi: Amazon Redshift supporta il controllo** AWS Lake Formation granulare degli accessi sulle tabelle Apache Iceberg.
+ **Parametri di gestione dei dati definiti dall'utente**: Amazon Redshift supporta parametri di gestione dei dati definiti dall'utente nelle tabelle Apache Iceberg. Si utilizzano parametri di gestione dei dati definiti dall'utente sui file esistenti per personalizzare i dati interrogati in tabelle esterne ed evitare errori di scansione. Questi parametri forniscono funzionalità per gestire le discrepanze tra lo schema della tabella e i dati effettivi sui file. È possibile utilizzare parametri di gestione dei dati definiti dall'utente anche nelle tabelle Apache Iceberg.
+ **Domande sui viaggi nel tempo**: le query sui viaggi nel tempo non sono attualmente supportate con le tabelle Apache Iceberg.
+ **Prezzi**: quando accedi alle tabelle Iceberg da un cluster, ti vengono addebitati i prezzi di Redshift Spectrum. Quando accedi alle tabelle Iceberg da un gruppo di lavoro, ti vengono addebitati i prezzi di Redshift serverless. Per ulteriori informazioni sui prezzi di Redshift Spectrum e Redshift Serverless, consulta [Prezzi di Amazon Redshift](https://aws.amazon.com/redshift/pricing/).
+ **Memorizzazione nella cache dei metadati**: la memorizzazione nella cache dei metadati presuppone che i file di metadati siano immutabili in base alle [specifiche Iceberg](https://iceberg.apache.org/spec/#file-system-operations). L’immutabilità dei file di metadati è un requisito per l’integrità dei dati in Amazon Redshift.
+ Identità **federata: l'identità federata non è supportata durante la** scrittura su tabelle Apache Iceberg. Ciò include l'utilizzo della parola chiave SESSION per il parametro IAM\$1ROLE durante la creazione di schemi esterni. [Per ulteriori informazioni sui parametri IAM\$1ROLE, vedere CREATE EXTERNAL SCHEMA.](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_EXTERNAL_SCHEMA.html)
# Tipi di dati supportati con le tabelle Apache Iceberg
In questo argomento vengono descritti i tipi di dati supportati che Redshift Spectrum può leggere dalle tabelle in formato Apache Iceberg.
Amazon Redshift può eseguire query su tabelle Iceberg che contengono i seguenti tipi di dati:
```
binary
boolean
date
decimal
double
float
int
list
long
map
string
struct
timestamp without time zone
```
Quando crei e definisci una tabella Iceberg, utilizza i nomi dei tipi di dati di Amazon Redshift nell'istruzione SQL. Redshift li mappa automaticamente ai tipi di Iceberg corrispondenti. Per ulteriori informazioni sui tipi di tabella Iceberg, consulta [Schemi per Iceberg](https://iceberg.apache.org/docs/latest/schemas/) nella documentazione di Apache.
Durante la lettura dalle tabelle Iceberg, i tipi di dati Iceberg vengono mappati nei tipi di dati Redshift come mostrato nella tabella seguente:
****
| Tipo Iceberg | Tipo di Amazon Redshift | Note |
| --- | --- | --- |
| boolean | boolean | - |
| - | tinyint | Non supportato per le tabelle Iceberg. |
| - | smallint | Non supportato per le tabelle Iceberg. |
| int | int | - |
| long | bigint | - |
| double | double precision | - |
| float | real | - |
| decimal(P, S) | decimal(P, S) | P è precisione, S è scala. |
| - | char | Non supportato per le tabelle Iceberg. |
| string | varchar(16384) | Le stringhe più grandi di 16384 vengono troncate in 16384. |
| binary | varbyte(64000) | - |
| date | date | - |
| time | - | - |
| timestamp | timestamp | - |
| timestamptz | timestampz | - |
| list | SUPER | - |
| map | SUPER | - |
| struct<...> | SUPER | - |
| fixed(L) | - | Il tipo fixed(L) non è attualmente supportato in Redshift Spectrum. |
| uuid | - | Il tipo uuid non è attualmente supportato in Redshift Spectrum. |
| variant | - | Amazon Redshift non supporta Iceberg V3. |
| geometry | - | Amazon Redshift non supporta Iceberg V3. |
| geography | - | Amazon Redshift non supporta Iceberg V3. |
| timestamp\$1ns | - | Amazon Redshift non supporta Iceberg V3. |
| timestamptz\$1ns | - | Amazon Redshift non supporta Iceberg V3. |
| Unknown | - | Amazon Redshift non supporta Iceberg V3. |
I seguenti tipi di dati sono supportati durante la creazione di tabelle Iceberg da Redshift. I tipi di dati Redshift sono mappati nei tipi di dati Iceberg come mostrato nella tabella seguente.
****
| Tipo di Amazon Redshift | Alias Amazon Redshift | Tipo Iceberg | Note |
| --- | --- | --- | --- |
| integer | int, int4 | int | - |
| bigint | int8 | long | - |
| decimal | numeric | decimal(p,S) | - |
| real | float4 | float | - |
| double precision | float8, float | double | - |
| varchar | charactter varying,nvarchar, text | string | Il tipo di varchar(n) dati non è supportato durante la creazione di una tabella Iceberg. |
| date | - | date | - |
| timestamp | - | timestamp | - |
| timestamptz | - | timestamptz | - |
| boolean | - | boolean | - |
Quando si scrive su tabelle Iceberg, oltre ai tipi di dati menzionati nella tabella precedente, alcuni tipi di dati di origine vengono promossi ai tipi Iceberg compatibili, come illustrato nella tabella seguente.
| Tipo di Amazon Redshift | Tipo Iceberg |
| --- | --- |
| `tinyint` | `int` |
| `smallint` | `int` |
| `varchar(n)` | `string` |
Il tentativo di utilizzare tipi di dati non supportati comporterà errori di sintassi. Quando crei una tabella Iceberg con `CREATE TABLE AS SELECT` clausola, puoi aggiungere un cast esplicito per aggirare la differenza di tipo.
Ad esempio, supponiamo di avere una tabella Redshift RMS con lo schema seguente:
```
CREATE TABLE rms_t (c1 int, c2 char(20));
```
Se vuoi creare una tabella Iceberg utilizzando `rms_t` come sorgente, hai bisogno di un cast esplicito per la `c2` colonna, perché il `varchar(n)` tipo non è supportato:
```
CREATE TABLE ext_schema.iceberg_t AS SELECT c1, c2::varchar FROM rms_t;
```
Per ulteriori informazioni sui tipi di dati di Amazon Redshift, consultare [Tipi di dati](c_Supported_data_types.md).
# Riferimento alle tabelle Iceberg in Amazon Redshift
Amazon Redshift offre diversi modi per fare riferimento alle tabelle Apache Iceberg archiviate nel tuo data lake. È possibile utilizzare schemi esterni per creare riferimenti ai database Data Catalog contenenti tabelle Iceberg o utilizzare la notazione in tre parti per l'accesso diretto ai cataloghi montati automaticamente.
## Utilizzo di schemi esterni per fare riferimento alle tabelle Iceberg
Gli schemi esterni forniscono un modo per fare riferimento alle tabelle nel tuo catalogo dati direttamente da Amazon Redshift. Quando crei uno schema esterno, stabilisci una connessione tra il tuo database Amazon Redshift e uno specifico database Data Catalog che contiene le tue tabelle Iceberg.
Per creare uno schema esterno per le tabelle Iceberg:
```
CREATE EXTERNAL SCHEMA schema_name
FROM DATA CATALOG
DATABASE 'glue_database_name'
IAM_ROLE 'arn:aws:iam::account-id:role/role-name';
```
Dopo aver creato lo schema esterno, puoi interrogare le tabelle Iceberg usando una notazione in due parti:
```
SELECT * FROM schema_name.iceberg_table_name;
```
Puoi anche unire le tabelle Iceberg alle tabelle Amazon Redshift locali:
```
SELECT r.customer_id, i.order_date, r.customer_name
FROM local_customers r
JOIN schema_name.iceberg_orders i
ON r.customer_id = i.customer_id;
```
## Utilizzo della notazione in tre parti con cataloghi montati automaticamente
La notazione in tre parti consente di fare riferimento direttamente alle tabelle nei cataloghi montati automaticamente senza creare schemi esterni. Questo metodo è particolarmente utile quando si lavora con bucket da tavolo Amazon S3 federati con. AWS Lake Formation Per informazioni sulla configurazione del montaggio automatico del Data Catalog, consulta [Semplificare l'accesso agli oggetti esterni in Amazon Redshift utilizzando il montaggio automatico di](https://aws.amazon.com/blogs/big-data/simplify-external-object-access-in-amazon-redshift-using-automatic-mounting-of-the-aws-glue-data-catalog/). AWS Glue Data Catalog
La sintassi per la notazione in tre parti è:
```
"catalog_name".database_name.table_name
```
Ad esempio, per interrogare una tabella Iceberg in un catalogo di tabelle Amazon S3 montato automaticamente:
```
SELECT * FROM "my_table_bucket@s3tablescatalog".my_database.my_iceberg_table;
```
*Per ulteriori informazioni sull'integrazione dei bucket di tabelle di Amazon S3 con Amazon Redshift, [consulta Integrating S3 Tables with Amazon Redshift nella Amazon S3 User](https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-tables-integrating-redshift.html) Guide.*
Puoi anche utilizzare l'`USE`istruzione per impostare un catalogo e un database predefiniti:
```
USE "my_table_bucket@s3tablescatalog".my_database;
SELECT * FROM my_iceberg_table;
```
Per impostare un percorso di ricerca per la risoluzione dello schema:
```
USE "my_table_bucket@s3tablescatalog";
SET search_path TO my_database;
SELECT * FROM my_iceberg_table;
```
## Le migliori pratiche per fare riferimento alle tabelle Iceberg
Prendi in considerazione le seguenti best practice per fare riferimento alle tabelle Iceberg in Amazon Redshift:
+ **Usa nomi di schemi descrittivi**: quando crei schemi esterni, usa nomi che indichino chiaramente l'origine e lo scopo dei dati, come o. `sales_data_lake` `customer_analytics`
+ **Sfrutta le statistiche delle tabelle**: assicurati che le statistiche delle colonne vengano generate per le tue tabelle Iceberg, AWS Glue utilizzandole per ottimizzare le prestazioni delle query. Amazon Redshift utilizza queste statistiche per la pianificazione e l'ottimizzazione delle query.
+ **Considera l'aggiornamento dei dati**: le tabelle Iceberg possono essere aggiornate da altri servizi mentre le interroghi. Amazon Redshift offre coerenza transazionale, garantendo la visualizzazione di un'istantanea coerente dei dati durante l'esecuzione delle query.
+ **Usa le autorizzazioni IAM appropriate**: assicurati che il tuo cluster o gruppo di lavoro Amazon Redshift disponga delle autorizzazioni IAM necessarie per accedere alle posizioni Amazon S3 in cui sono archiviate le tabelle Iceberg, nonché ai metadati del Data Catalog.
+ **Monitora le prestazioni delle query**: utilizza le funzionalità di monitoraggio delle query di Amazon Redshift per monitorare le prestazioni delle query rispetto alle tabelle Iceberg e ottimizzarle in base alle esigenze.
## Schemi di riferimento comuni
Gli esempi seguenti mostrano modelli comuni per fare riferimento alle tabelle Iceberg:
**Aggregazione di dati su più tabelle Iceberg:**
```
SELECT
region,
SUM(sales_amount) as total_sales,
COUNT(*) as transaction_count
FROM data_lake.sales_transactions
WHERE transaction_date >= '2024-01-01'
GROUP BY region
ORDER BY total_sales DESC;
```
**Unire le tabelle Iceberg alle tabelle Amazon Redshift locali:**
```
SELECT
c.customer_name,
c.customer_tier,
SUM(o.order_amount) as total_orders
FROM customers c
JOIN data_lake.order_history o ON c.customer_id = o.customer_id
WHERE o.order_date >= CURRENT_DATE - INTERVAL '30 days'
GROUP BY c.customer_name, c.customer_tier;
```
**Utilizzo della notazione in tre parti con query complesse:**
```
WITH recent_orders AS (
SELECT customer_id, order_date, order_amount
FROM "analytics_bucket@s3tablescatalog".ecommerce.orders
WHERE order_date >= CURRENT_DATE - INTERVAL '7 days'
)
SELECT
customer_id,
COUNT(*) as order_count,
AVG(order_amount) as avg_order_value
FROM recent_orders
GROUP BY customer_id
HAVING COUNT(*) > 1;
```
# Scrittura su tabelle Apache Iceberg
Con Amazon Redshift, puoi creare e scrivere su tabelle Apache Iceberg archiviate in bucket di tabelle Amazon S3 e Amazon S3. La scrittura di dati Iceberg direttamente da Amazon Redshift semplifica la gestione dei dati eliminando strumenti aggiuntivi. Le tabelle Iceberg devono essere registrate con. AWS Glue Data Catalog
Puoi utilizzare l'architettura Lakehouse con le tabelle Apache Iceberg e contemporaneamente sfruttare la potente analisi SQL di Amazon Redshift su magazzini e laghi. Puoi anche accedere immediatamente a funzionalità avanzate di Amazon Redshift come le viste materializzate sulle tabelle Iceberg, migliorando in modo significativo le tue capacità analitiche senza aggiungere complessità.
La scrittura di Iceberg è supportata sia sui cluster con provisioning di Amazon Redshift che sulle istanze Serverless di Amazon Redshift.
**Topics**
+ [Comandi SQL](iceberg-writes-sql-syntax.md)
+ [Semantica delle transazioni](iceberg-writes-transaction-semantics.md)
+ [Best practice](iceberg-writes-best-practices.md)
# Comandi SQL
Le tabelle Apache Iceberg in Amazon Redshift offrono un modo efficace per gestire set di dati analitici di grandi dimensioni nel tuo data lake. Queste tabelle supportano le transazioni ACID, l'evoluzione degli schemi e le funzionalità di viaggio nel tempo, mantenendo al contempo prestazioni elevate per i carichi di lavoro di analisi. Utilizzando le tabelle Apache Iceberg, puoi organizzare e partizionare i dati in modo efficiente, controllare i formati e la compressione dei file e integrarti perfettamente con altri servizi. AWS
È possibile creare tabelle Iceberg partizionate e non partizionate utilizzando i comandi and. `CREATE TABLE ... USING ICEBERG` `CREATE TABLE ... USING ICEBERG AS SELECT` È possibile fare riferimento alle tabelle Iceberg utilizzando una notazione dello schema esterna () o una notazione in tre parti (). `external_schema.table_name` `"catalog_name".database_name.table_name` Gli esempi in questa sezione illustrano entrambi i metodi.
Dopo aver creato una tabella, è possibile aggiungere dati utilizzando `INSERT` i comandi standard. Tieni presente che, sebbene Amazon Redshift funzioni con molti tipi di dati Iceberg, potrebbe essere necessario convertire alcuni formati di dati quando inserisci informazioni.
Puoi visualizzare le tabelle Iceberg usando il comando. `SHOW TABLES` Se vuoi rimuovere una tabella da AWS Glue Data Catalog, puoi usare il `DROP TABLE` comando. Nota che questo rimuove solo la registrazione della tabella. I dati effettivi rimarranno in archiviazione finché non li elimini separatamente.
Tutte le altre istruzioni SQL, come`DELETE`,`UPDATE`, e `MERGE``ALTER TABLE`, non sono ancora supportate nelle tabelle Iceberg.
Le seguenti sezioni illustrano la sintassi SQL per la creazione, l'inserimento e la gestione di tabelle Iceberg in Amazon Redshift.
**Contents**
+ [CREATE TABLE](#iceberg-writes-create-table)
+ [CREATE TABLE AS SELECT](#iceberg-writes-create-table-as-select)
+ [SHOW TABLE](#iceberg-writes-show-table)
+ [INSERT INTO](#iceberg-writes-insert-into)
+ [DROP TABLE](#iceberg-writes-drop-table)
## CREATE TABLE
```
CREATE TABLE [IF NOT EXISTS] . (
column_name data_type [, ...]
)
USING ICEBERG
[LOCATION 's3://your-bucket-name/prefix/']
[PARTITIONED BY [[column_name | transform_function]], ...]
[TABLE PROPERTIES ('compression_type'='')]
```
Puoi anche usare una notazione in tre parti per i bucket di tabelle S3:
```
CREATE TABLE "@s3tablescatalog".. (
column_name data_type [, ...]
)
USING ICEBERG
[PARTITIONED BY [[column_name | transform_function]], ...]
[TABLE PROPERTIES ('compression_type'='')]
```
Nota che `` deve essere un nome di schema esterno esistente in cui verrà creata la tabella esterna. Per ulteriori informazioni su come creare e gestire schemi esterni, consulta [CREATE EXTERNAL SCHEMA](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_EXTERNAL_SCHEMA.html) nella documentazione di Amazon Redshift.
La `LOCATION` clausola definisce la posizione della tabella per questa tabella Iceberg appena creata. Per le tabelle Amazon S3, `LOCATION` non può essere specificato poiché la posizione della tabella è determinata dal catalogo delle tabelle Amazon S3 (). `s3tablescatalog`
In tutti gli altri casi, `LOCATION` è obbligatorio e deve essere una posizione vuota, il che significa che non ci sono oggetti Amazon S3 esistenti che condividono lo stesso bucket e lo stesso prefisso. Tieni presente che la regione del bucket Amazon S3 deve trovarsi nella stessa regione del cluster Amazon Redshift.
Tuttavia, AWS fornisce un metodo per replicare i dati dalle tabelle Iceberg archiviate in una AWS Glue Data Catalog in una Regione AWS diversa Regione AWS, che consente di replicare la scrittura in una regione diversa. Per ulteriori informazioni, consulta [Replicare](https://docs.aws.amazon.com/prescriptive-guidance/latest/apache-iceberg-on-aws/best-practices-workloads.html#workloads-replication) i dati in modo incrociato. Regioni AWS
`PARTITIONED BY`definisce la partizione della tabella Iceberg. Amazon Redshift supporta tutte le trasformazioni di partizione Iceberg v2 ad eccezione di. `void` Ecco l'elenco delle trasformazioni supportate:
+ **identità**
+ **secchio [N]**
+ **troncare [W]**
+ **anno**
+ **mese**
+ **giorno**
+ **ora**
Per le definizioni complete di queste trasformazioni e dei tipi di dati compatibili, consulta [Partition Transforms](https://iceberg.apache.org/spec/#partition-transforms) nella documentazione di Apache Iceberg.
Supporta il partizionamento a più livelli. `PARTITIONED BY` Ad esempio, puoi esegui il seguente comando:
```
CREATE TABLE ...
USING ICEBERG
LOCATION ...
PARTITIONED BY (bucket(16, id), year(ship_date));
```
Tuttavia, Amazon Redshift non supporta l'utilizzo di una singola colonna in più di una trasformazione. Ad esempio, la seguente sintassi non è supportata:
```
CREATE TABLE ...
USING ICEBERG
LOCATION ...
PARTITIONED BY (bucket(16, ship_date), year(ship_date));
```
La `TABLE PROPERTIES` clausola definisce le proprietà aggiuntive della tabella per questa tabella Iceberg. L'unica proprietà della tabella che supportiamo è quella `compression_type` che definisce la compressione predefinita dei file di dati di Parquet. Se questo non è specificato, `snappy` viene utilizzato come codec di compressione. I valori possibili per `compression_type` sono:`zstd`,`brotli`, `gzip``snappy`, e`uncompressed`.
**Nota**
`CREATE TABLE ... LIKE ...`non è supportato per le tabelle Iceberg. Inoltre, le tabelle Iceberg non supportano i vincoli di colonna e gli attributi di colonna come fa la tabella RMS.
In alternativa, puoi creare e popolare una tabella Iceberg con un'unica operazione utilizzando: `CREATE TABLE AS SELECT`
## CREATE TABLE AS SELECT
```
CREATE TABLE . [(
column_name[, ...]
)]
USING ICEBERG
[LOCATION 's3://your-bucket-name/prefix/']
[PARTITIONED BY [[column_name | transform_function]], ...]
[TABLE PROPERTIES ('compression_type'='')]
AS
SELECT query
```
Puoi anche usare la notazione in tre parti per creare tabelle nei cataloghi montati automaticamente:
```
CREATE TABLE "".. [(
column_name[, ...]
)]
USING ICEBERG
[LOCATION 's3://your-bucket-name/prefix/']
[PARTITIONED BY [[column_name | transform_function]], ...]
[TABLE PROPERTIES ('compression_type'='')]
AS
SELECT query
```
È simile all'`CREATE TABLE`istruzione tranne che `CREATE` è seguita da un'`SELECT`istruzione per popolare la tabella con i risultati della query. `SELECT`
La `CREATE TABLE` clausola qui non consente più di specificare i tipi di dati poiché i tipi di dati delle colonne verranno decisi `SELECT` dalla query.
Se la `SELECT` query fallisce per qualsiasi motivo, questa avrà esito negativo e la tabella Iceberg non verrà creata.
Puoi visualizzare la struttura delle tue tabelle Iceberg usando: `SHOW TABLE`
## SHOW TABLE
```
SHOW TABLE .
```
Puoi anche usare la notazione in tre parti con cataloghi montati automaticamente:
```
SHOW TABLE ""..
```
`SHOW TABLE`visualizza l'`CREATE TABLE`istruzione per la tabella Iceberg. Il comando mostrerà i risultati appropriati in base al tipo di tabella. Di seguito è riportato un esempio dell'`SHOW TABLE`output per la tabella Iceberg:
```
CREATE TABLE my_schema.items (id int, price decimal(5, 2))
USING ICEBERG
LOCATION 's3://my_s3_bucket/items/'
PARTITIONED BY (bucket(16, id))
TABLE PROPERTIES ('compression_type'='snappy')
```
**Nota**
Per le tabelle Amazon S3, poiché la posizione della tabella è gestita dal catalogo di tabelle Amazon S3, `LOCATION` la clausola verrà omessa nei risultati. `SHOW TABLE`
Dopo aver creato le tabelle, puoi aggiungere dati utilizzando: `INSERT INTO`
## INSERT INTO
```
INSERT INTO . [(column_name [, ...])] VALUES (...)
INSERT INTO . [(column_name [, ...])] (SELECT query)
-- Using three-part notation for S3 table buckets:
INSERT INTO "@s3tablescatalog".. [(column_name [, ...])] VALUES (...)
INSERT INTO "@s3tablescatalog".. [(column_name [, ...])] (SELECT query)
```
È possibile creare `INSERT INTO` una tabella Iceberg utilizzando la sintassi precedente. Se viene utilizzata una `VALUES` clausola, si forniscono i valori per le colonne elencate da `column_name` o per tutte le colonne se viene omessa `column_name` una parte.
Quando i dati vengono inseriti in una tabella partizionata, le nuove righe vengono distribuite in base alla specifica di partizione predefinita. Se per qualsiasi motivo la `SELECT` query fallisce, la query avrà esito negativo e nessun dato verrà inserito nella tabella Iceberg.
È possibile accedere a `INSERT INTO` una tabella Iceberg non creata da Amazon Redshift. Tuttavia, ci sono alcune limitazioni:
+ La tabella deve essere una tabella Iceberg v2.
+ La tabella deve utilizzare Parquet come formato dati predefinito.
+ La tabella non deve avere la compressione dei metadati impostata su True.
+ La tabella non deve essere abilitata Write-Audit-Publish (WAP).
Per rimuovere una tabella Iceberg dal catalogo, usa il `DROP TABLE` comando:
## DROP TABLE
```
DROP TABLE .
```
Puoi anche usare la notazione in tre parti con cataloghi montati automaticamente:
```
DROP TABLE "..
```
L'eliminazione di una tabella Iceberg è un'operazione che riguarda solo i metadati. Rimuove la voce della tabella da AWS Glue Data Catalog un catalogo di tabelle Amazon S3, se si tratta di una tabella Amazon S3. Amazon Redshift non pulisce o elimina alcun file di dati o file di metadati esistente sotto la posizione della tabella. Puoi utilizzare le funzionalità delle tabelle AWS Glue Amazon S3 per rimuovere file orfani. Per AWS Glue, consulta [Eliminazione](https://docs.aws.amazon.com/glue/latest/dg/orphan-file-deletion.html) di file orfani. Per le tabelle Amazon S3, consulta Manutenzione delle tabelle[.](https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-tables-maintenance.html)
# Semantica delle transazioni
Le query di scrittura di Redshift Iceberg supportano l'isolamento ACID e snapshot. Le transazioni di scrittura hanno un'atomicità garantita e non producono aggiornamenti parziali quando una query fallisce in modo imprevisto.
È possibile eseguire più transazioni Iceberg contemporaneamente e se due transazioni tentano di modificare la stessa tabella o partizione contemporaneamente, il commit della transazione fallisce. Ciò garantisce l'integrità dei dati. Quando ciò accade, è necessario risolvere i conflitti manualmente ed eseguire nuovamente le query non riuscite. Amazon Redshift non riprova e risolve automaticamente i conflitti.
Una singola query di scrittura Iceberg viene sempre trattata come una singola transazione di commit automatico. Quando una query di scrittura Iceberg, come la query CREATE o INSERT, è inclusa in un blocco di transazione esplicito, nessun'altra query può essere eseguita all'interno dello stesso blocco di transazione. La transazione fallirà.
Di seguito vengono riportati alcuni esempi. Il primo esempio dimostra che una query con una singola istruzione esegue sempre il commit automatico al termine della query. In questo scenario, stai creando una nuova tabella degli ordini di vendita:
```
CREATE TABLE sales_schema.orders (
order_id int,
customer_id int,
order_date date,
total_amount decimal(10,2)
) USING ICEBERG LOCATION 's3://my-data-lake/sales/orders/';
```
Questo esempio è un blocco di transazione esplicito per l'inserimento di un ordine del cliente utilizzando una notazione in tre parti per un bucket di tabella S3. La transazione non esegue il commit automatico dopo la query INSERT, ma esegue invece il commit e inserisce i dati dell'ordine con il comando COMMIT:
```
BEGIN;
INSERT INTO "analytics_bucket@s3tablescatalog".sales_db.orders VALUES (12345, 9876, '2024-10-30', 299.99);
COMMIT;
```
Questo esempio è uno scenario esplicito di rollback del blocco delle transazioni in cui stai testando l'inserimento di un ordine ma decidi di annullarlo. La transazione non esegue il commit automatico dopo la query INSERT, ma viene invece ripristinata con il comando ROLLBACK senza inserire l'ordine di test.
```
BEGIN;
INSERT INTO sales_schema.orders VALUES (12346, 5432, '2024-10-30', 150.75);
ROLLBACK;
```
Questo ultimo esempio dimostra come, quando si tenta di eseguire un'altra istruzione all'interno dello stesso blocco di transazione della query INSERT, la transazione fallisce senza inserire i dati dell'ordine. In questo scenario, state tentando di inserire un ordine e interrogare immediatamente la tabella:
```
BEGIN;
INSERT INTO sales_schema.orders VALUES (12347, 7890, '2024-10-30', 425.50);
SELECT * FROM sales_schema.orders WHERE order_id = 12347;
```
L'unica eccezione è l'`DROP TABLE`istruzione, che si comporta sempre come un'istruzione di commit automatico e non può essere eseguita all'interno di un blocco di transazione esplicito. Questo serve a mantenere lo stesso comportamento di una tabella `DROP TABLE` esterna. Per ulteriori informazioni, consulta [DROP TABLE](https://docs.aws.amazon.com/redshift/latest/dg/r_DROP_TABLE.html).
**Nota**
La scrittura Iceberg SQLs non può essere eseguita dall'interno della stored procedure.
# Best practice
Prendi in considerazione le seguenti best practice quando scrivi su una tabella Apache Iceberg:
+ Per carichi di lavoro di scrittura o streaming piccoli e frequenti, prendi in considerazione l'utilizzo delle funzionalità di compattazione fornite dalle AWS Glue Data Catalog nostre tabelle Amazon S3 per ottimizzare le dimensioni dei file per le letture.
+ Il `DROP TABLE` comando annulla la registrazione della tabella dal catalogo AWS Glue Data Catalog o dal catalogo delle tabelle di Amazon S3, ma i file rimangono. Puoi utilizzare le funzionalità delle tabelle AWS Glue Amazon S3 per rimuovere file orfani. Per AWS Glue, consulta [Eliminazione](https://docs.aws.amazon.com/glue/latest/dg/orphan-file-deletion.html) di file orfani. Per le tabelle Amazon S3, consulta Manutenzione delle tabelle[.](https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-tables-maintenance.html)
# Prestazioni delle query di Amazon Redshift Spectrum
In questo argomento viene illustrato come migliorare le prestazioni delle query Redshift Spectrum.
Esaminare il piano di query per determinare quali fasi sono state inviate al livello di Amazon Redshift Spectrum.
Le fasi seguenti sono correlate alla query di Redshift Spectrum:
+ S3 Seq Scan
+ S3 HashAggregate
+ S3 Query Scan
+ Seq Scan PartitionInfo
+ Partition Loop
Il seguente esempio mostra un piano di query per una query che unisce in join una tabella esterna a una tabella locale. Prendi nota dei HashAggregate passaggi S3 Seq Scan e S3 eseguiti sui dati su Amazon S3.
```
explain
select top 10 spectrum.sales.eventid, sum(spectrum.sales.pricepaid)
from spectrum.sales, event
where spectrum.sales.eventid = event.eventid
and spectrum.sales.pricepaid > 30
group by spectrum.sales.eventid
order by 2 desc;
```
```
QUERY PLAN
-----------------------------------------------------------------------------
XN Limit (cost=1001055770628.63..1001055770628.65 rows=10 width=31)
-> XN Merge (cost=1001055770628.63..1001055770629.13 rows=200 width=31)
Merge Key: sum(sales.derived_col2)
-> XN Network (cost=1001055770628.63..1001055770629.13 rows=200 width=31)
Send to leader
-> XN Sort (cost=1001055770628.63..1001055770629.13 rows=200 width=31)
Sort Key: sum(sales.derived_col2)
-> XN HashAggregate (cost=1055770620.49..1055770620.99 rows=200 width=31)
-> XN Hash Join DS_BCAST_INNER (cost=3119.97..1055769620.49 rows=200000 width=31)
Hash Cond: ("outer".derived_col1 = "inner".eventid)
-> XN S3 Query Scan sales (cost=3010.00..5010.50 rows=200000 width=31)
-> S3 HashAggregate (cost=3010.00..3010.50 rows=200000 width=16)
-> S3 Seq Scan spectrum.sales location:"s3://redshift-downloads/tickit/spectrum/sales" format:TEXT (cost=0.00..2150.00 rows=172000 width=16)
Filter: (pricepaid > 30.00)
-> XN Hash (cost=87.98..87.98 rows=8798 width=4)
-> XN Seq Scan on event (cost=0.00..87.98 rows=8798 width=4)
```
Nota i seguenti elementi nel piano di query:
+ Il nodo `S3 Seq Scan` mostra che il filtro `pricepaid > 30.00` è stato elaborato nel livello di Redshift Spectrum.
Un nodo di filtro sotto il nodo `XN S3 Query Scan` indica l'elaborazione di predicati in Amazon Redshift sopra i dati restituiti dal livello di Redshift Spectrum.
+ Il nodo `S3 HashAggregate` indica l'aggregazione nel livello Redshift Spectrum per il gruppo mediante la clausola (`group by spectrum.sales.eventid`).
Per migliorare le prestazioni di Redshift Spectrum procedi come segue:
+ Utilizza file di dati in formato Apache Parquet. Parquet archivia i dati in un formato a colonne, di conseguenza Redshift Spectrum può eliminare le colonne non necessarie dalla scansione. Se i dati sono in un formato file di testo, Redshift Spectrum deve eseguire la scansione dell'intero file.
+ Utilizza più file per ottimizzare l'elaborazione parallela. Fai in modo che le dimensioni dei file siano superiori a 64 MB. Evita l'asimmetria nella dimensione dei dati mantenendo i file all'incirca della stessa dimensione. Per informazioni sui file Apache Parquet e suggerimenti di configurazione, consulta [Formato dei file: configurazioni](https://parquet.apache.org/docs/file-format/configurations/) nella *documentazione di Apache Parquet*.
+ Utilizza il minor numero di colonne possibile nelle query.
+ Inserire le tabelle dei fatti di grandi dimensioni in Amazon S3 e le tabelle delle dimensioni più piccole utilizzate di frequente nel database Amazon Redshift locale.
+ Aggiorna le statistiche delle tabelle esterne impostando il parametro TABLE PROPERTIES numRows. Utilizzare [CREATE EXTERNAL TABLE](r_CREATE_EXTERNAL_TABLE.md) o [ALTER TABLE](r_ALTER_TABLE.md) per impostare il parametro TABLE PROPERTIES numRows allo scopo di riflettere il numero di righe nella tabella. Amazon Redshift non analizza le tabelle esterne per generare le statistiche delle tabelle che l'ottimizzatore di query utilizza per generare un piano di query. Se le statistiche della tabella non sono impostate per una tabella esterna, Amazon Redshift genera un piano di esecuzione della query. Amazon Redshift genera questo piano in base al presupposto che le tabelle esterne sono le tabelle più grandi e che quelle locali sono le più piccole.
+ Il pianificatore di query di Amazon Redshift, quando possibile, trasmette i predicati e le aggregazioni al livello di query di Redshift Spectrum. Quando da Amazon S3 sono restituite grandi quantità di dati, l'elaborazione è limitata dalle risorse del cluster. Redshift Spectrum esegue un dimensionamento automatico per elaborare le richieste di grandi dimensioni. Di conseguenza, le prestazioni globali migliorano ogni volta che trasmetti l'elaborazione al livello di Redshift Spectrum.
+ Scrivi le query per utilizzare filtri e aggregazioni che possono essere trasmessi al livello di Redshift Spectrum.
Di seguito sono riportati esempi di alcune operazioni che possono essere trasmesse al livello di Redshift Spectrum:
+ Clausole GROUP BY
+ Condizioni di confronto e di corrispondenza di modelli, come LIKE.
+ Funzioni di aggregazione come COUNT, SUM, AVG, MIN e MAX.
+ Funzioni di stringa.
Le operazioni che non possono essere trasmesse al livello di Redshift Spectrum includono DISTINCT e ORDER BY.
+ Utilizza le partizioni per limitare i dati sottoposti a scansione. Partiziona i dati in base ai predicati di query più comuni, quindi riduci le partizioni filtrandone le colonne. Per ulteriori informazioni, consultare [Partizionamento delle tabelle esterne di Redshift Spectrum](c-spectrum-external-tables.md#c-spectrum-external-tables-partitioning).
Eseguire una query su [SVL\$1S3PARTITION](r_SVL_S3PARTITION.md) per visualizzare le partizioni totali e quelle qualificate.
+ Usa il generatore AWS Glue di statistiche per calcolare le statistiche a livello di colonna per le tabelle. AWS Glue Data Catalog Una volta AWS Glue generate le statistiche per le tabelle nel catalogo dati, Amazon Redshift Spectrum utilizza automaticamente tali statistiche per ottimizzare il piano di query. *Per ulteriori informazioni sull'utilizzo delle statistiche a livello di colonna AWS Glue, consulta [Working with column statistics](https://docs.aws.amazon.com/glue/latest/dg/column-statistics.html) nella Developer Guide.AWS Glue *
# Opzioni per la gestione dei dati
In questo argomento viene illustrato come configurare il modo in cui Redshift Spectrum gestisce i dati in formati imprevisti.
È possibile impostare i parametri della tabella quando si creano tabelle esterne per personalizzare i dati sottoposti a query nelle tabelle esterne. In caso contrario, si possono verificare errori di scansione. Per ulteriori informazioni su queste proprietà, consultare PROPRIETÀ DI TABELLA in [CREATE EXTERNAL TABLE](r_CREATE_EXTERNAL_TABLE.md). Per alcuni esempi, consulta [Esempi di gestione dei dati](r_CREATE_EXTERNAL_TABLE_examples.md#r_CREATE_EXTERNAL_TABLE_examples-data-handling). Per un elenco dei possibili errori, consultare [SVL\$1SPECTRUM\$1SCAN\$1ERROR](r_SVL_SPECTRUM_SCAN_ERROR.md)
È possibile impostare le seguenti PROPRIETÀ DI TABELLA quando si creano tabelle esterne per specificare la gestione dell'input per i dati sottoposti a query in tabelle esterne.
+ `column_count_mismatch_handling` consente di determinare se il file contiene più o meno valori per una riga rispetto al numero di colonne specificato nella definizione della tabella esterna.
+ `invalid_char_handling` per specificare la gestione dell'input per i caratteri non validi nelle colonne contenenti dati VARCHAR, CHAR e stringa. Quando si specifica REPLACE per `invalid_char_handling`, è possibile specificare il carattere sostitutivo da utilizzare.
+ `numeric_overflow_handling` per specificare la gestione dell'eccedenza cast in colonne contenenti dati interi e decimali.
+ `surplus_bytes_handling` per specificare la gestione degli input per i byte in eccesso nelle colonne contenenti dati VARBYTE.
+ `surplus_char_handling` per specificare la gestione dell'input per i caratteri eccedenti nelle colonne contenenti dati VARCHAR, CHAR e stringa.
È possibile impostare un'opzione di configurazione per annullare le query che superano il numero massimo di errori. Per ulteriori informazioni, consulta [spectrum\$1query\$1maxerror](r_spectrum_query_maxerror.md).
# Esempio: esecuzione di sottoquery correlate in Redshift Spectrum
In questo argomento viene illustrato come eseguire sottoquery correlate in Redshift Spectrum. Una sottoquery correlata è una query che utilizza i valori della query esterna.
È possibile eseguire sottoquery correlate in Redshift Spectrum. La pseudocolonna `$spectrum_oid` consente di eseguire query correlate con Redshift Spectrum. Per eseguire una sottoquery correlata, la pseudocolonna `$spectrum_oid` deve essere abilitata ma non viene visualizzata nell'istruzione SQL. Per ulteriori informazioni, consulta [Pseudocolonne](c-spectrum-external-tables.md#c-spectrum-external-tables-pseudocolumns).
Per creare lo schema esterno e le tabelle esterne per questo esempio, consulta [Nozioni di base su Amazon Redshift Spectrum](c-getting-started-using-spectrum.md).
Di seguito è riportato un esempio di sottoquery correlata in Redshift Spectrum.
```
select *
from myspectrum_schema.sales s
where exists
( select *
from myspectrum_schema.listing l
where l.listid = s.listid )
order by salesid
limit 5;
```
```
salesid listid sellerid buyerid eventid dateid qtysold pricepaid commission saletime
1 1 36861 21191 7872 1875 4 728 109.2 2008-02-18 02:36:48
2 4 8117 11498 4337 1983 2 76 11.4 2008-06-06 05:00:16
3 5 1616 17433 8647 1983 2 350 52.5 2008-06-06 08:26:17
4 5 1616 19715 8647 1986 1 175 26.25 2008-06-09 08:38:52
5 6 47402 14115 8240 2069 2 154 23.1 2008-08-31 09:17:02
```
# Metriche in Amazon Redshift Spectrum
In questo argomento vengono descritte le viste di sistema che puoi utilizzare per monitorare le query di Redshift Spectrum.
È possibile monitorare le query di Amazon Redshift Spectrum utilizzando le seguenti viste di sistema:
+ [SVL\$1S3QUERY](r_SVL_S3QUERY.md)
Utilizza la vista SVL\$1S3QUERY per ottenere dettagli riguardanti le query di Redshift Spectrum (query S3) a livello di segmento e di sezione di nodo.
+ [SVL\$1S3QUERY\$1SUMMARY](r_SVL_S3QUERY_SUMMARY.md)
Utilizzare la vista SVL\$1S3QUERY\$1SUMMARY per ottenere un riepilogo di tutte le query Amazon Redshift Spectrum (query S3) che sono state eseguite nel sistema.
Di seguito sono elencati alcuni elementi da cercare in SVL\$1S3QUERY\$1SUMMARY:
+ Il numero di file elaborati dalla query di Redshift Spectrum.
+ Il numero di byte sottoposti a scansione da Amazon S3. Il costo di una query di Redshift Spectrum viene riflesso nella quantità di dati sottoposti a scansione da Amazon S3.
+ Il numero di byte restituiti dal livello Redshift Spectrum al cluster. Se viene restituita una grande quantità di dati, è possibile che le prestazioni del sistema peggiorino.
+ La durata massima e media delle richieste Redshift Spectrum. Le richieste di lunga durata potrebbero indicare un collo di bottiglia.
# Risoluzione dei problemi relativi alle query in Amazon Redshift Spectrum
Questo argomento è un riferimento per i problemi comuni che puoi incontrare con le query di Amazon Redshift Spectrum.
Per visualizzare gli errori generati dalle query di Redshift Spectrum, eseguire una query sulla tabella di sistema [SVL\$1S3LOG](r_SVL_S3LOG.md).
**Topics**
+ [Superamento del numero di nuovi tentativi](#spectrum-troubleshooting-retries-exceeded)
+ [Accesso limitato](#spectrum-troubleshooting-access-throttled)
+ [Superamento del limite di risorse](#spectrum-troubleshooting-resource-limit-exceeded)
+ [Nessuna riga restituita per una tabella partizionata](#spectrum-troubleshooting-no-rows-partitioned-table)
+ [Errore non autorizzato](#spectrum-troubleshooting-not-authorized-error)
+ [Formati di dati non compatibili](#spectrum-troubleshooting-incompatible-data-format)
+ [Errore di sintassi durante l'utilizzo della DDL Hive in Amazon Redshift](#spectrum-troubleshooting-syntax-error-using-hive-ddl)
+ [Autorizzazione per creare tabelle temporanee](#spectrum-troubleshooting-permission-to-create-temp-tables)
+ [Intervallo non valido](#spectrum-troubleshooting-invalid-range)
+ [Numero versione di Parquet non valido](#spectrum-troubleshooting-invalid-parquet-version)
+ [Campo obbligatorio mancante nelle informazioni sulla partizione esterna](#spectrum-troubleshooting-required-field-missing)
## Superamento del numero di nuovi tentativi
In caso di timeout di una richiesta di Amazon Redshift Spectrum, la richiesta viene annullata e inoltrata di nuovo. Dopo cinque tentativi non riusciti, la query non riesce con il seguente errore.
```
error: Spectrum Scan Error: Retries exceeded
```
Le cause possibili sono:
+ File di grandi dimensioni (superiori a 1 GB). Verificare la dimensione dei file in Amazon S3 e cercare file di dimensioni voluminose e disuguali. Dividi i file di grandi dimensioni in file più piccoli, di dimensione tra 100 MB e 1 GB. Fai in modo che i file siano della stessa dimensione.
+ Throughput di rete lento. Riesegui la query in seguito.
## Accesso limitato
Amazon Redshift Spectrum è soggetto alle quote di servizio di AWS altri servizi. In caso di utilizzo elevato, le richieste Redshift Spectrum potrebbero rallentare, causando il seguente errore.
```
error: Spectrum Scan Error: Access throttled
```
Possono verificarsi due tipi di limitazione:
+ Accesso limitato da Amazon S3
+ Accesso limitato da. AWS KMS
Il contesto di errore fornisce ulteriori dettagli sul tipo di limitazione. Di seguito, puoi trovare le cause e le possibili risoluzioni per questa limitazione.
### Accesso limitato da Amazon S3
Amazon S3 potrebbe limitare una richiesta Redshift Spectrum se la frequenza di richieste di lettura su un [prefisso](https://docs.aws.amazon.com/glossary/latest/reference/glos-chap.html#keyprefix) è troppo alta. Per informazioni sulla frequenza di GET/HEAD richiesta che puoi raggiungere in Amazon S3, consulta la Guida per l'utente dell'[ottimizzazione delle prestazioni di Amazon S3 nella guida per l'utente di Amazon](https://docs.aws.amazon.com/AmazonS3/latest/userguide/optimizing-performance.html) *Simple Storage* Service. La frequenza di GET/HEAD richieste di Amazon S3 tiene conto di tutte le GET/HEAD richieste su un prefisso, quindi diverse applicazioni che accedono allo stesso prefisso condividono la frequenza totale delle richieste.
Se le tue richieste Redshift Spectrum vengono spesso limitate da Amazon S3, riduci il numero di GET/HEAD richieste Amazon S3 che Redshift Spectrum invia ad Amazon S3. A tale scopo, prova a unire file di piccole dimensioni in file più grandi. Ti consigliamo di utilizzare dimensioni pari a 64 MB o superiori.
Considerare inoltre la possibilità di partizionare le tabelle Redshift Spectrum per beneficiare del filtraggio anticipato e ridurre il numero di file a cui si accede in Amazon S3. Per ulteriori informazioni, consulta [Partizionamento delle tabelle esterne di Redshift Spectrum](c-spectrum-external-tables.md#c-spectrum-external-tables-partitioning).
### Accesso limitato da AWS KMS
Se memorizzi i dati in Amazon S3 utilizzando la crittografia lato server (SSE-S3 o SSE-KMS), Amazon S3 richiama un'operazione API per ogni file a cui accede Redshift Spectrum. AWS KMS Queste richieste vengono conteggiate per la quota delle operazioni di crittografia; per ulteriori informazioni, consultare [Quote di richiesta AWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/requests-per-second.html). Per ulteriori informazioni su SSE-S3 e SSE-KMS, consultare [Protezione dei dati tramite crittografia lato server](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingServerSideEncryption.html) e [Protezione dei dati tramite crittografia lato server con Chiavi KMS archiviate in AWS KMS](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingKMSEncryption.html) nella *Guida per l'utente di Amazon Simple Storage Service*.
Un primo passo per ridurre il numero di richieste inviate da Redshift Spectrum AWS KMS consiste nel ridurre il numero di file a cui si accede. A tale scopo, prova a unire file di piccole dimensioni in file più grandi. Ti consigliamo di utilizzare dimensioni pari a 64 MB o superiori.
Se le tue richieste Redshift Spectrum vengono spesso limitate AWS KMS, prendi in considerazione la possibilità di richiedere un aumento della quota per la frequenza di AWS KMS richieste per le operazioni crittografiche. Per richiedere un aumento della quota, consulta [Limiti del servizio AWS](https://docs.aws.amazon.com/general/latest/gr/aws_service_limits.html) in *Riferimenti generali di Amazon Web Services*.
## Superamento del limite di risorse
Redshift Spectrum applica un limite superiore sulla quantità di memoria che una richiesta può utilizzare. Una richiesta Redshift Spectrum che richiede più memoria non riesce, causando il seguente errore.
```
error: Spectrum Scan Error: Resource limit exceeded
```
Esistono due motivi comuni che possono causare il superamento dei limiti di memoria di una richiesta Redshift Spectrum:
+ Redshift Spectrum elabora una grande porzione di dati che non possono essere suddivisi in blocchi più piccoli.
+ Un passaggio di aggregazione di grandi dimensioni viene elaborato da Redshift Spectrum.
Ti consigliamo di utilizzare un formato di file che supporti le letture parallele con dimensioni di divisione pari o inferiori a 128 MB. consultare [File di dati per le query in Amazon Redshift Spectrum](c-spectrum-data-files.md) per i formati di file supportati e le linee guida generiche per la creazione di file di dati. Quando utilizzi formati di file o algoritmi di compressione che non supportano le letture parallele, ti consigliamo di mantenere le dimensioni dei file tra 64 MB e 128 MB.
## Nessuna riga restituita per una tabella partizionata
Se la query restituisce zero righe da una tabella esterna partizionata, verifica se una partizione è stata aggiunta per questa tabella esterna. Redshift Spectrum esegue la scansione dei file in una posizione Amazon S3 che è stata esplicitamente aggiunta utilizzando `ALTER TABLE … ADD PARTITION`. Esegui la query sulla vista [SVV\$1EXTERNAL\$1PARTITIONS](r_SVV_EXTERNAL_PARTITIONS.md) per trovare le partizioni esistenti. Esegui `ALTER TABLE … ADD PARTITION` per ogni partizione mancante.
## Errore non autorizzato
Verificare che il ruolo IAM per il cluster consenta l'accesso agli oggetti dei file Amazon S3. Se il database esterno si trova in Amazon Athena, verificare che il ruolo IAM consenta l'accesso alle risorse Athena. Per ulteriori informazioni, consultare [Policy IAM per Amazon Redshift Spectrum](c-spectrum-iam-policies.md).
## Formati di dati non compatibili
Per un formato di file a colonne, come Apache Parquet, il tipo di colonna è incorporato ai dati. Il tipo di colonna nella definizione CREATE EXTERNAL TABLE deve corrispondere al tipo di colonna del file di dati. In caso di mancata corrispondenza, viene visualizzato un messaggio di errore simile al seguente:
```
File 'https://s3bucket/location/file has an incompatible Parquet schema
for column ‘s3://s3bucket/location.col1'. Column type: VARCHAR, Par
```
Il messaggio potrebbe essere troncato a causa del limite della lunghezza del messaggio. Per recuperare il messaggio completo, incluso il nome e il tipo di colonna, eseguire una query sulla vista di sistema [SVL\$1S3LOG](r_SVL_S3LOG.md).
Le seguenti query di esempio SVL\$1S3LOG per l'ultima query completata.
```
select message
from svl_s3log
where query = pg_last_query_id()
order by query,segment,slice;
```
Quanto segue è un esempio di risultato che mostra un messaggio di errore completo.
```
message
–––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––––-
Spectrum Scan Error. File 'https://s3bucket/location/file has an incompatible
Parquet schema for column ' s3bucket/location.col1'.
Column type: VARCHAR, Parquet schema:\noptional int64 l_orderkey [i:0 d:1 r:0]\n
```
Per correggere l'errore, modifica la tabella esterna affinché corrisponda al tipo di colonna del file Parquet.
## Errore di sintassi durante l'utilizzo della DDL Hive in Amazon Redshift
Per CREATE EXTERNAL TABLE, Amazon Redshift supporta un linguaggio DDL che è simile al linguaggio DDL Hive. Tuttavia, i due tipi di DDL non sono sempre esattamente gli stessi. Se si copia il DDL Hive per creare o modificare le tabelle esterne Amazon Redshift, è possibile che si verifichino errori di sintassi. Di seguito sono riportati alcuni esempi di differenze tra Amazon Redshift e la DDL Hive:
+ Amazon Redshift richiede l'utilizzo di virgolette singole (') mentre la DDL Hive supporta le virgolette doppie (").
+ Amazon Redshift non supporta il tipo di dati STRING. Utilizza invece VARCHAR.
## Autorizzazione per creare tabelle temporanee
Per eseguire le query di Redshift Spectrum, l'utente del database deve disporre dell'autorizzazione per creare tabelle temporanee nel database. L'esempio seguente concede l'autorizzazione temporanea per il database `spectrumdb` al gruppo di utenti `spectrumusers`.
```
grant temp on database spectrumdb to group spectrumusers;
```
Per ulteriori informazioni, consulta [GRANT](r_GRANT.md).
## Intervallo non valido
Redshift Spectrum prevede che i file in Amazon S3 appartenenti a una tabella esterna non vengano sovrascritti durante una query. In tal caso, può restituire il seguente errore.
```
Error: HTTP response error code: 416 Message: InvalidRange The requested range is not satisfiable
```
Per evitare l'errore, assicurati che i file Amazon S3 non vengano sovrascritti mentre sono soggetti a query con Redshift Spectrum.
## Numero versione di Parquet non valido
Redshift Spectrum controlla i metadati di ogni file Apache Parquet a cui accede. Se il controllo ha esito negativo, può essere visualizzato un errore simile al seguente:
```
File 'https://s3.region.amazonaws.com/s3bucket/location/file has an invalid version number
```
L'esito negativo del controllo può essere causato da due motivi comuni:
+ Il file Parquet è stato sovrascritto durante la query (consulta [Intervallo non valido](#spectrum-troubleshooting-invalid-range)).
+ Il file Parquet è danneggiato.
## Campo obbligatorio mancante nelle informazioni sulla partizione esterna
Quando tenti di aggiungere una partizione a una tabella esterna in un catalogo esterno, potrebbe venire restituito il seguente errore:
```
Error: The required field () is missing from the external partition information. Add missing field in partition and retry. Partition location:
```
Questo errore indica che una delle partizioni della tabella esterna utilizzata nella query presenta informazioni sui metadati della partizione mancanti. Questo succede nei casi seguenti:
+ È stata aggiunta una partizione a una tabella esterna in un catalogo esterno, ad esempio la, con informazioni parziali. AWS Glue Data Catalog
+ Hai eseguito query su una tabella partizionata in Amazon Redshift mentre aggiungevi o aggiornavi le partizioni per la tabella corrispondente in un catalogo esterno, come il AWS Glue Data Catalog.
Di seguito sono riportati i campi che devi compilare quando recuperi una partizione dal AWS Glue Data Catalog:
+ StorageDescriptor
+ InputFormat
+ OutputFormat
+ SerDeInfo
+ Valori
Puoi eseguire query su [SVV\$1EXTERNAL\$1PARTITIONS](r_SVV_EXTERNAL_PARTITIONS.md) per trovare le partizioni esistenti e visualizzare i dettagli sui relativi campi.
Per un elenco completo dei campi di AWS Glue Data Catalog partizione, consulta [Partition](https://docs.aws.amazon.com/glue/latest/webapi/API_Partition.html) in the *AWS Glue Web* API Reference.
# Tutorial: Esecuzione di query su dati nidificati con Amazon Redshift Spectrum
In questo tutorial viene dimostrato come eseguire query sui dati annidati con Redshift Spectrum. I dati annidati sono dati che contengono campi annidati. I campi annidati sono campi di cui è stato effettuato il join come un’unica entità, quali array, strutture oppure oggetti.
**Topics**
+ [Panoramica di](#tutorial-nested-data-overview)
+ [Fase 1: creazione di una tabella esterna contenente dati nidificati](#tutorial-nested-data-create-table)
+ [Fase 2: Esecuzione di query sui dati nidificati in Amazon S3 con estensioni SQL](#tutorial-query-nested-data-sqlextensions)
+ [Casi d'uso dei dati nidificati](nested-data-use-cases.md)
+ [Limitazioni relative ai dati annidati (anteprima)](nested-data-restrictions.md)
+ [Serializzazione di JSON nidificato complesso](serializing-complex-JSON.md)
## Panoramica di
Amazon Redshift Spectrum supporta l'esecuzione di query di dati nidificati nei formati di file Parquet, ORC, JSON e Ion. Redshift Spectrum accede ai dati mediante tabelle esterne. Puoi creare tabelle esterne che utilizzano i tipi di dati complessi `struct`, `array` e `map`.
Ad esempio, si supponga che il file di dati contenga i seguenti dati in Amazon S3 all'interno di una cartella denominata `customers`. Anche se non è presente un singolo elemento root, ciascun oggetto JSON in questi dati di esempio rappresenta una riga in una tabella.
```
{"id": 1,
"name": {"given": "John", "family": "Smith"},
"phones": ["123-457789"],
"orders": [{"shipdate": "2018-03-01T11:59:59.000Z", "price": 100.50},
{"shipdate": "2018-03-01T09:10:00.000Z", "price": 99.12}]
}
{"id": 2,
"name": {"given": "Jenny", "family": "Doe"},
"phones": ["858-8675309", "415-9876543"],
"orders": []
}
{"id": 3,
"name": {"given": "Andy", "family": "Jones"},
"phones": [],
"orders": [{"shipdate": "2018-03-02T08:02:15.000Z", "price": 13.50}]
}
```
Puoi utilizzare Amazon Redshift Spectrum per eseguire query sui dati nidificati nei file. Il seguente tutorial illustra la procedura da seguire con i dati Apache Parquet.
### Prerequisiti
Se ancora non utilizzi Redshift Spectrum, segui la procedura in [Nozioni di base su Amazon Redshift Spectrum](c-getting-started-using-spectrum.md) prima di continuare.
Per creare uno schema esterno, sostituire l'ARN del ruolo IAM nel comando seguente con l'ARN del ruolo creato in [Creazione di un ruolo IAM](c-getting-started-using-spectrum.md#c-getting-started-using-spectrum-create-role). Quindi eseguire il comando nel proprio client SQL.
```
create external schema spectrum
from data catalog
database 'myspectrum_db'
iam_role 'arn:aws:iam::123456789012:role/myspectrum_role'
create external database if not exists;
```
## Fase 1: creazione di una tabella esterna contenente dati nidificati
È possibile visualizzare i [dati di origine](https://s3.amazonaws.com/redshift-downloads/tickit/spectrum/customers/customer_file1) scaricandoli da Amazon S3.
Per creare la tabella esterna per questo tutorial, utilizza il comando seguente.
```
CREATE EXTERNAL TABLE spectrum.customers (
id int,
name struct,
phones array,
orders array>
)
STORED AS PARQUET
LOCATION 's3://redshift-downloads/tickit/spectrum/customers/';
```
Nell'esempio precedente, la tabella esterna `spectrum.customers` utilizza i tipi di dati `struct` e `array` per definire colonne con dati nidificati. Amazon Redshift Spectrum supporta l'esecuzione di query di dati nidificati nei formati di file Parquet, ORC, JSON e Ion. Il parametro `STORED AS` è `PARQUET` per i file Apache Parquet. Il parametro `LOCATION` deve fare riferimento alla cartella Amazon S3 che contiene i file o i dati nidificati. Per ulteriori informazioni, consulta [CREATE EXTERNAL TABLE](r_CREATE_EXTERNAL_TABLE.md).
Puoi nidificare tipi `array` e `struct` a qualsiasi livello. Ad esempio, puoi definire una colonna denominata `toparray` come mostrato nell'esempio seguente.
```
toparray array>>>>
```
Puoi inoltre nidificare tipi `struct` come mostrato per la colonna `x` nell'esempio seguente.
```
x struct
>
>
```
## Fase 2: Esecuzione di query sui dati nidificati in Amazon S3 con estensioni SQL
Redshift Spectrum supporta l'esecuzione di query su tipi complessi `array`, `map` e `struct` mediante estensioni alla sintassi SQL di Amazon Redshift.
### Estensione 1: accesso a colonne di struct
Puoi estrarre dati da colonne `struct` utilizzando una notazione punto che concatena i nomi dei campi in percorsi. Ad esempio, la query seguente restituisce il nome e il cognome dei clienti. L'accesso al nome viene eseguito dal percorso lungo `c.name.given`. L'accesso al cognome viene eseguito dal percorso lungo `c.name.family`.
```
SELECT c.id, c.name.given, c.name.family
FROM spectrum.customers c;
```
La query precedente restituisce i seguenti dati.
```
id | given | family
---|-------|-------
1 | John | Smith
2 | Jenny | Doe
3 | Andy | Jones
(3 rows)
```
Uno `struct` può essere una colonna di un altro `struct`, che a sua volta può essere una colonna di un altro `struct`, a qualsiasi livello. I percorsi di accesso alle colonne in `struct` nidificati in modo così profondo possono essere lunghi. Ad esempio, consultare la definizione relativa alla colonna `x` nell'esempio seguente.
```
x struct
>
>
```
Puoi accedere ai dati in `e` come `x.b.d.e`.
### Estensione 2: matrici estese a una clausola FROM
Puoi estrarre dati da colonne `array` (e, per estensione, da colonne `map`) specificando le colonne `array` in una clausola `FROM` al posto dei nomi delle tabelle. L'estensione si applica alla clausola `FROM` della query principale e, inoltre, alle clausole `FROM` delle query secondarie.
Puoi fare riferimento a elementi `array` in base alla posizione, ad esempio `c.orders[0]` (anteprima).
Combinando `arrays` estese e join, puoi annullare annidamenti in vari modi, come illustrato nei seguenti casi d'uso.
#### Annullamento di annidamenti mediante inner join
La seguente query seleziona le date di spedizione del cliente IDs e dell'ordine per i clienti che hanno ordini. L'estensione SQL nella clausola FROM `c.orders o` dipende dall'alias `c`.
```
SELECT c.id, o.shipdate
FROM spectrum.customers c, c.orders o
```
Per ciascun cliente `c` associato a degli ordini, la clausola `FROM` restituisce una riga per ogni ordine `o` del cliente `c`. La riga in questione combina la riga del cliente `c` e quella dell'ordine `o`. In seguito, la clausola `SELECT` mantiene solo `c.id` e `o.shipdate`. Il risultato è il seguente.
```
id| shipdate
--|----------------------
1 |2018-03-01 11:59:59
1 |2018-03-01 09:10:00
3 |2018-03-02 08:02:15
(3 rows)
```
L'alias `c` fornisce l'accesso ai campi dei clienti, mentre l'alias `o` consente l'accesso ai campi degli ordini.
La semantica è simile a quella di SQL standard. È possibile pensare a un processo in cui la clausola `FROM` esegue il loop nidificato mostrato sotto, mentre `SELECT` sceglie i campi da restituire.
```
for each customer c in spectrum.customers
for each order o in c.orders
output c.id and o.shipdate
```
Pertanto, se un cliente non è associato ad alcun ordine, non verrà mostrato tra i risultati.
Puoi pensare anche a un processo in cui la clausola `FROM` esegue un `JOIN` con la tabella `customers` e la matrice `orders`. In effetti, puoi anche scrivere la query, come mostrato nell'esempio seguente.
```
SELECT c.id, o.shipdate
FROM spectrum.customers c INNER JOIN c.orders o ON true
```
**Nota**
Se è presente uno schema denominato `c` con una tabella chiamata `orders`, allora `c.orders` fa riferimento alla tabella `orders` e non alla colonna della matrice di `customers`.
#### Annullamento di annidamenti mediante left join
La query seguente restituisce tutti i nomi dei clienti e i loro ordini. Se un cliente non ha effettuato alcun ordine, il suo nome viene comunque restituito. Tuttavia, in questo caso, l'ordine presenta colonne NULL, come mostrato nell'esempio seguente per Jenny Doe.
```
SELECT c.id, c.name.given, c.name.family, o.shipdate, o.price
FROM spectrum.customers c LEFT JOIN c.orders o ON true
```
La query precedente restituisce i seguenti dati.
```
id | given | family | shipdate | price
----|---------|---------|----------------------|--------
1 | John | Smith | 2018-03-01 11:59:59 | 100.5
1 | John | Smith | 2018-03-01 09:10:00 | 99.12
2 | Jenny | Doe | |
3 | Andy | Jones | 2018-03-02 08:02:15 | 13.5
(4 rows)
```
### Estensione 3: accesso diretto a una matrice di scalari tramite un alias
Quando un alias `p` in una clausola `FROM` si estende a una matrice di scalari, la query fa riferimento ai valori di `p` come `p`. Ad esempio, la query seguente genera coppie di nomi e numeri di telefono dei clienti.
```
SELECT c.name.given, c.name.family, p AS phone
FROM spectrum.customers c LEFT JOIN c.phones p ON true
```
La query precedente restituisce i seguenti dati.
```
given | family | phone
-------|----------|-----------
John | Smith | 123-4577891
Jenny | Doe | 858-8675309
Jenny | Doe | 415-9876543
Andy | Jones |
(4 rows)
```
### Estensione 4: accesso agli elementi del tipo di dati map
Redshift Spectrum tratta `map` come un tipo di dati `array` che contiene tipi `struct` con una colonna `key` e una colonna `value`. `key` deve essere uno `scalar`; il valore può essere qualunque tipo di dati.
Ad esempio, il codice seguente crea una tabella esterna con un tipo `map` per l'archiviazione dei numeri di telefono.
```
CREATE EXTERNAL TABLE spectrum.customers2 (
id int,
name struct,
phones map,
orders array>
)
STORED AS PARQUET
LOCATION 's3://redshift-downloads/tickit/spectrum/customers/';
```
Dal momento che un tipo `map` si comporta come un tipo `array` con colonne `key` e `value`, puoi pensare agli schemi precedenti come a quelli riportati di seguito.
```
CREATE EXTERNAL TABLE spectrum.customers3 (
id int,
name struct,
phones array>,
orders array>
)
STORED AS PARQUET
LOCATION 's3://redshift-downloads/tickit/spectrum/customers/';
```
La query seguente restituisce i nomi dei clienti con un numero di cellulare e il numero per ciascun nome. La query sul tipo map viene considerata equivalente a una query su un `array` nidificato di tipi `struct`. La query seguente restituisce dati solo se hai creato la tabella esterna come descritto in precedenza.
```
SELECT c.name.given, c.name.family, p.value
FROM spectrum.customers c, c.phones p
WHERE p.key = 'mobile';
```
**Nota**
La `key` per un tipo `map` è una `string` per i tipi di file Ion e JSON.
# Casi d'uso dei dati nidificati
In questo argomento vengono illustrati i casi d’uso per i dati annidati. I dati annidati sono dati che contengono campi annidati. I campi annidati sono campi di cui è stato effettuato il join come un’unica entità, quali array, strutture oppure oggetti.
Puoi combinare le estensioni descritte in precedenza con le consuete caratteristiche di SQL. I casi d'uso seguenti presentano alcune combinazioni comuni. Questi esempi offrono una dimostrazione dell'utilizzo dei dati nidificati. Non fanno parte del tutorial.
**Topics**
+ [Inserimento di dati nidificati](#ingesting-nested-data)
+ [Aggregazione di dati nidificati con query secondarie](#aggregating-with-subquery)
+ [Unione dei dati di Amazon Redshift e dei dati nidificati](#joining-redshift-data)
## Inserimento di dati nidificati
Puoi utilizzare l'istruzione `CREATE TABLE AS` per inserire dati da una tabella esterna contenente tipi di dati complessi. La query seguente estrae tutti i clienti e i relativi numeri di telefono dalla tabella esterna mediante `LEFT JOIN` e li archivia nella tabella `CustomerPhones` di Amazon Redshift.
```
CREATE TABLE CustomerPhones AS
SELECT c.name.given, c.name.family, p AS phone
FROM spectrum.customers c LEFT JOIN c.phones p ON true;
```
## Aggregazione di dati nidificati con query secondarie
Puoi utilizzare una query secondaria per aggregare dati nidificati. Questo approccio viene descritto nell'esempio seguente.
```
SELECT c.name.given, c.name.family, (SELECT COUNT(*) FROM c.orders o) AS ordercount
FROM spectrum.customers c;
```
Vengono restituiti i seguenti dati.
```
given | family | ordercount
--------|----------|--------------
Jenny | Doe | 0
John | Smith | 2
Andy | Jones | 1
(3 rows)
```
**Nota**
Quando aggreghi dati nidificati raggruppandoli in base alla riga padre, il modo più efficiente di procedere è quello illustrato nell'esempio precedente. Nell'esempio in questione, le righe nidificate di `c.orders` sono raggruppate in base alla riga padre `c`. In alternativa, se sai che l'`id` è univoco per ciascun `customer` e `o.shipdate` non è mai null, puoi eseguire l'aggregazione come illustrato nell'esempio seguente. Tuttavia, in genere questo approccio è meno efficiente rispetto a quello dell'esempio precedente.
```
SELECT c.name.given, c.name.family, COUNT(o.shipdate) AS ordercount
FROM spectrum.customers c LEFT JOIN c.orders o ON true
GROUP BY c.id, c.name.given, c.name.family;
```
Puoi inoltre scrivere la query utilizzando una query secondaria nella clausola `FROM` che fa riferimento a un alias (`c`) della query con predecessore e che estrae i dati della matrice. L'esempio seguente mostra questo approccio.
```
SELECT c.name.given, c.name.family, s.count AS ordercount
FROM spectrum.customers c, (SELECT count(*) AS count FROM c.orders o) s;
```
## Unione dei dati di Amazon Redshift e dei dati nidificati
È possibile unire i dati di Amazon Redshift e i dati nidificati in una tabella esterna. Ad esempio, si supponga di avere i seguenti dati nidificati in Amazon S3.
```
CREATE EXTERNAL TABLE spectrum.customers2 (
id int,
name struct,
phones array,
orders array>
);
```
Si supponga inoltre di avere la seguente tabella in Amazon Redshift.
```
CREATE TABLE prices (
id int,
price double precision
);
```
La query riportata di seguito restituisce il numero totale e l'importo degli acquisti di ciascun cliente sulla base di quanto indicato in precedenza. L'esempio seguente viene utilizzato soltanto a scopo illustrativo. Restituisce dati solo se hai creato le tabelle descritte in precedenza.
```
SELECT c.name.given, c.name.family, COUNT(o.date) AS ordercount, SUM(p.price) AS ordersum
FROM spectrum.customers2 c, c.orders o, prices p ON o.item = p.id
GROUP BY c.id, c.name.given, c.name.family;
```
# Limitazioni relative ai dati annidati (anteprima)
In questo argomento vengono illustrate le limitazioni per la lettura di dati annidati con Redshift Spectrum. I dati annidati sono dati che contengono campi annidati. I campi annidati sono campi di cui è stato effettuato il join come un’unica entità, quali array, strutture oppure oggetti.
**Nota**
Le limitazioni contrassegnate con (anteprima) nell’elenco seguente si applicano solo ai cluster di anteprima creati nelle seguenti Regioni.
Stati Uniti orientali (Ohio) (us-east-2)
Stati Uniti orientali (Virginia settentrionale) (us-east-1)
Stati Uniti occidentali (California settentrionale) (us-west-1)
Asia Pacifico (Tokyo) (ap-northeast-1)
Europa (Irlanda) (eu-west-1)
Europa (Stoccolma) (eu-north-1)
Per informazioni sulla configurazione di cluster di anteprima, consulta [Creazione di un cluster di anteprima](https://docs.aws.amazon.com/redshift/latest/mgmt/managing-clusters-console.html#cluster-preview) nella *Guida alla gestione di Amazon Redshift*.
Le seguenti limitazioni si applicano ai dati nidificati:
+ Un tipo `array` o `map` può contenere altri tipi `array` o `map`, purché le query su `arrays` o `maps` annidati non restituiscano valori `scalar` (anteprima).
+ Amazon Redshift Spectrum supporta i tipi di dati complessi solo come tabelle esterne.
+ Le colonne dei risultati delle query secondarie devono essere di primo livello (anteprima).
+ Se un'espressione `OUTER JOIN` si riferisce a una tabella nidificata, può fare riferimento solo a quella tabella e alle relative matrici (e mappe) nidificate. Se un'espressione `OUTER JOIN` non si riferisce a una tabella nidificata, può fare riferimento a qualsiasi numero di tabelle non nidificate.
+ Se una clausola `FROM` in una query secondaria si riferisce a una tabella nidificata, non può fare riferimento a nessun'altra tabella.
+ Se una query secondaria dipende da una tabella nidificata che si riferisce a una tabella padre, la query secondaria può utilizzare la tabella padre solo nella clausola `FROM`. Non puoi utilizzare l'elemento padre in un'altra clausola, ad esempio una di tipo `SELECT` o `WHERE`. Ad esempio, la seguente query non viene eseguita perché la clausola `SELECT` della query secondaria si riferisce alla tabella padre `c`.
```
SELECT c.name.given
FROM spectrum.customers c
WHERE (SELECT COUNT(c.id) FROM c.phones p WHERE p LIKE '858%') > 1;
```
La query riportata sotto viene eseguita perché l'elemento `c` è utilizzato solo nella clausola `FROM` della query secondaria.
```
SELECT c.name.given
FROM spectrum.customers c
WHERE (SELECT COUNT(*) FROM c.phones p WHERE p LIKE '858%') > 1;
```
+ Una query secondaria che accede ai dati nidificati non dalla clausola `FROM` deve restituire un unico valore. Fanno eccezione solo gli operatori `(NOT) EXISTS` in una clausola `WHERE`.
+ `(NOT) IN` non è supportato.
+ La profondità di nidificazione massima per tutti i tipi nidificati è 100. Questa restrizione si applica a tutti i formati di file (Parquet, ORC, Ion e JSON).
+ Le query secondarie di aggregazione che accedono a dati nidificati possono fare riferimento solo ad `arrays` e `maps` nella loro clausola `FROM`, non a una tabella esterna.
+ L'esecuzione di query sulle pseudocolonne di dati nidificati in una tabella di Redshift Spectrum non è supportata. Per ulteriori informazioni, consulta [Pseudocolonne](c-spectrum-external-tables.md#c-spectrum-external-tables-pseudocolumns).
+ Quando si estraggono i dati da colonne di matrici o mappe specificate in una clausola `FROM`, è possibile selezionare i valori dalle colonne solo se i valori sono `scalar`. Ad esempio, le seguenti query tentano entrambe di eseguire `SELECT` per gli elementi dall'interno di una matrice. La query che seleziona `arr.a` riesce perché `arr.a` è un valore `scalar`. La seconda query non riesce perché `array` è una matrice estratta da `s3.nested table` nella clausola `FROM` (anteprima).
```
SELECT array_column FROM s3.nested_table;
array_column
-----------------
[{"a":1},{"b":2}]
SELECT arr.a FROM s3.nested_table t, t.array_column arr;
arr.a
-----
1
--This query fails to run.
SELECT array FROM s3.nested_table tab, tab.array_column array;
```
Non è possibile utilizzare una matrice o una mappa nella clausola `FROM` che a sua volta proviene da un'altra matrice o mappa. Per selezionare matrici o altre strutture complesse annidate all'interno di altre matrici, prendi in considerazione di usare gli indici nell'istruzione `SELECT`.
# Serializzazione di JSON nidificato complesso
In questo argomento viene illustrato come serializzare i dati annidati in formato JSON. I dati annidati sono dati che contengono campi annidati. I campi annidati sono campi di cui è stato effettuato il join come un’unica entità, quali array, strutture oppure oggetti.
Un'alternativa ai metodi illustrati in questo tutorial consiste nell'eseguire una query sulle colonne di raccolta nidificate di primo livello come JSON serializzato. È possibile utilizzare la serializzazione per ispezionare, convertire e importare dati nidificati come JSON con Redshift Spectrum. Questo metodo è supportato per i formati ORC, JSON, Ion e Parquet. Utilizzare il parametro di configurazione della sessione `json_serialization_enable` per configurare il comportamento di serializzazione. Se impostato, i tipi di dati JSON complessi sono serializzati in VARCHAR(65535). È possibile accedere al JSON nidificato con [Funzioni JSON](json-functions.md). Per ulteriori informazioni, consultare [json\$1serialization\$1enable](r_json_serialization_enable.md).
Ad esempio, senza impostare `json_serialization_enable`, le seguenti query che accedono direttamente alle colonne nidificate avranno esito negativo.
```
SELECT * FROM spectrum.customers LIMIT 1;
=> ERROR: Nested tables do not support '*' in the SELECT clause.
SELECT name FROM spectrum.customers LIMIT 1;
=> ERROR: column "name" does not exist in customers
```
L'impostazione di `json_serialization_enable` consente di eseguire le query direttamente sulle raccolte di primo livello.
```
SET json_serialization_enable TO true;
SELECT * FROM spectrum.customers order by id LIMIT 1;
id | name | phones | orders
---+--------------------------------------+----------------+----------------------------------------------------------------------------------------------------------------------
1 | {"given": "John", "family": "Smith"} | ["123-457789"] | [{"shipdate": "2018-03-01T11:59:59.000Z", "price": 100.50}, {"shipdate": "2018-03-01T09:10:00.000Z", "price": 99.12}]
SELECT name FROM spectrum.customers order by id LIMIT 1;
name
---------
{"given": "John", "family": "Smith"}
```
Considerare quanto segue durante la serializzazione del JSON nidificato.
+ Quando le colonne di raccolta sono serializzate come VARCHAR(65535), non è possibile accedere direttamente ai relativi sottocampi nidificati come parte della sintassi della query (ad esempio, nella clausola filter). Tuttavia, le funzioni JSON possono essere utilizzate per accedere al JSON nidificato.
+ Le seguenti rappresentazioni specializzate non sono supportate:
+ Unioni ORC
+ Mappe ORC con chiavi di tipo complesso
+ Datagrammi Ion
+ SEXP Ion
+ I timestamp vengono restituiti come stringhe serializzate ISO.
+ Le chiavi delle mappe primitive sono promosse a stringa (ad esempio, da `1` a `"1"`).
+ I valori nulli di primo livello vengono serializzati come. NULLs
+ Se la serializzazione eccede la dimensione massima VARCHAR di 65535, la cella viene impostata su NULL.
## Serializzazione di tipi complessi contenenti stringhe JSON
Per impostazione predefinita, i valori stringa contenuti nelle raccolte nidificate vengono serializzati come stringhe JSON con escape. L'escape potrebbe essere indesiderato se le stringhe sono JSON valide. È invece possibile voler scrivere sottoelementi o campi nidificati che sono VARCHAR direttamente come JSON. Abilitare questo comportamento con la configurazione a livello di sessione `json_serialization_parse_nested_strings`. Quando sono impostati sia `json_serialization_enable` che `json_serialization_parse_nested_strings`, i valori JSON validi sono serializzati in linea senza caratteri escape. Se il valore non è JSON valido, viene eseguito l'escape come se il valore di configurazione `json_serialization_parse_nested_strings` non fosse impostato. Per ulteriori informazioni, consultare [json\$1serialization\$1parse\$1nested\$1strings](r_json_serialization_parse_nested_strings.md).
Ad esempio, si supponga che i dati dell'esempio precedente contengano JSON come tipo complesso `structs`nel campo `name` VARCHAR(20):
```
name
---------
{"given": "{\"first\":\"John\",\"middle\":\"James\"}", "family": "Smith"}
```
Quando è impostato `json_serialization_parse_nested_strings`, la colonna `name` viene serializzata come segue:
```
SET json_serialization_enable TO true;
SET json_serialization_parse_nested_strings TO true;
SELECT name FROM spectrum.customers order by id LIMIT 1;
name
---------
{"given": {"first":"John","middle":"James"}, "family": "Smith"}
```
Anziché essere sottoposto a escape in questo modo:
```
SET json_serialization_enable TO true;
SELECT name FROM spectrum.customers order by id LIMIT 1;
name
---------
{"given": "{\"first\":\"John\",\"middle\":\"James\"}", "family": "Smith"}
```