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à.

# Esecuzione di query sui dati replicati in Amazon Redshift
<a name="zero-etl-using.querying-and-creating-materialized-views"></a>

Dopo aver aggiunto i dati all'origine, questi vengono replicati pressoché in tempo reale nel data warehouse Amazon Redshift e sono pronti per l'esecuzione di query. Per informazioni sulle metriche di integrazione e sulle statistiche delle tabelle, consulta [Metriche per le integrazioni Zero-ETL](zero-etl-using.metrics.md).

**Nota**  
Poiché un database è identico a uno schema in MySQL, il livello di database MySQL è mappato al livello dello schema di Amazon Redshift. Tieni presente questa differenza di mappatura quando esegui le query sui dati replicati da Aurora MySQL o RDS per MySQL.

**Come eseguire query sui dati replicati**

1. Accedi alla console Amazon Redshift e scegli **Editor di query v2**.

1. Connettiti al gruppo di lavoro Amazon Redshift serverless o al cluster con provisioning di Amazon Redshift e scegli il database dall'elenco a discesa.

1. Utilizza un'istruzione SELECT per selezionare tutti i dati replicati dallo schema e dalla tabella che hai creato nell'origine. Per distinguere tra maiuscole e minuscole, usa le virgolette doppie (" ") per i nomi di schemi, tabelle e colonne. Esempio:

   ```
   SELECT * FROM "schema_name"."table_name";
   ```

   Puoi anche eseguire query sui dati utilizzando l’API dati Amazon Redshift.

## Esecuzione di query sui dati replicati con viste materializzate
<a name="zero-etl-using.transforming"></a>

Puoi creare viste materializzate nel database Amazon Redshift locale per trasformare i dati replicati tramite le integrazioni Zero-ETL. Connettiti al database locale e utilizza le query tra database per accedere ai database di destinazione. È possibile utilizzare nomi di oggetti completi con la notazione in tre parti (destination-database-name.schema-name.table-name) oppure creare uno schema esterno che faccia riferimento alla coppia database-schema di destinazione e utilizzare la notazione in due parti (.table-name). external-schema-name Per ulteriori informazioni sulle query tra database, consulta [Esecuzione di query sui dati tra database](https://docs.aws.amazon.com/redshift/latest/dg/cross-database-overview.html).

Utilizzate l'esempio seguente per creare e inserire dati di esempio nelle tabelle e nelle tabelle dall'origine. *sales\$1zetl* *event\$1zetl* *tickit\$1zetl* Le tabelle vengono replicate nel database Amazon *zetl\$1int\$1db* Redshift.

```
CREATE TABLE sales_zetl (
        salesid integer NOT NULL primary key,
        eventid integer NOT NULL,
        pricepaid decimal(8, 2)
);
 
CREATE TABLE event_zetl (
        eventid integer NOT NULL PRIMARY KEY,
        eventname varchar(200)
);
       
INSERT INTO sales_zetl VALUES(1, 1, 3.33);
INSERT INTO sales_zetl VALUES(2, 2, 4.44);
INSERT INTO sales_zetl VALUES(3, 2, 5.55);
 
INSERT INTO event_zetl VALUES(1, "Event 1");
INSERT INTO event_zetl VALUES(2, "Event 2");
```

Puoi creare una vista materializzata per ottenere le vendite totali per ogni evento utilizzando la notazione in tre parti:

```
--three part notation zetl-database-name.schema-name.table-name 
CREATE MATERIALIZED VIEW mv_transformed_sales_per_event_3p 
AUTO REFRESH YES
AS
(SELECT eventname, sum(pricepaid) as total_price
FROM  zetl_int_db.tickit_zetl.sales_zetl S, zetl_int_db.tickit_zetl.event_zetl E
WHERE S.eventid = E.eventid
GROUP BY 1);
```

Puoi creare una vista materializzata per ottenere le vendite totali per ogni evento utilizzando la notazione in due parti:

```
--two part notation external-schema-name.table-name notation
CREATE EXTERNAL schema ext_tickit_zetl
FROM REDSHIFT
DATABASE zetl_int_db
SCHEMA tickit_zetl;
 
CREATE MATERIALIZED VIEW mv_transformed_sales_per_event_2p
AUTO REFRESH YES
AS
(
    SELECT eventname, sum(pricepaid) as total_price
    FROM  ext_tickit_zetl.sales_zetl S, ext_tickit_zetl.event_zetl E
    WHERE S.eventid = E.eventid
    GROUP BY 1  
);
```

Per visualizzare le viste materializzate create usa l'esempio seguente.

```
SELECT * FROM mv_transformed_sales_per_event_3p;
 
+-----------+-------------+
| eventname | total_price |
+-----------+-------------+
| Event 1   | 3.33        |
| Event 2   | 9.99        |
+-----------+-------------+
 
SELECT * FROM mv_transformed_sales_per_event_2p;
 
+-----------+-------------+
| eventname | total_price |
+-----------+-------------+
| Event 1   | 3.33        |
| Event 2   | 9.99        |
+-----------+-------------+
```

## Esecuzione di query sui dati replicati da DynamoDB
<a name="zero-etl-using.querying-ddb"></a>

Quando replichi i dati da Amazon DynamoDB in un database Amazon Redshift, questi vengono archiviati in una vista materializzata in una colonna di tipo di dati SUPER.

Per questo esempio, i seguenti dati vengono archiviati in DynamoDB.

```
{
    "key1": {
        "S": "key_1"
    },
    "key2": {
        "N": 0
    },
    "payload": {
        "L": [
            {
                "S": "sale1"
            },
            {
                "S": "sale2"
            },
        ]
    },
}
```

La vista materializzata di Amazon Redshift è definita come segue.

```
CREATE MATERIALIZED VIEW mv_sales
                    BACKUP NO
                    AUTO REFRESH YES
                    AS
                    SELECT "value"."payload"."L"[0]."S"::VARCHAR AS first_payload
                    FROM public.sales;
```

Per visualizzare i dati nella vista materializzata, esegui un comando SQL. 

```
SELECT first_payload FROM mv_sales;
```