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

Utilizzo di viste materializzate con AWS Glue

AWS La versione 5.1 e successive di Glue supporta la creazione e la gestione delle viste materializzate di Apache Iceberg nel AWS Glue Data Catalog. Una vista materializzata è una tabella gestita che memorizza il risultato precalcolato di una query SQL in formato Apache Iceberg e si aggiorna in modo incrementale man mano che le tabelle di origine sottostanti cambiano. È possibile utilizzare le viste materializzate per semplificare le pipeline di trasformazione dei dati e accelerare le prestazioni delle query per carichi di lavoro analitici complessi.

Quando crei una vista materializzata utilizzando Spark in AWS Glue, la definizione della vista e i metadati vengono archiviati nel AWS Glue Data Catalog. I risultati precalcolati vengono archiviati come tabelle Apache Iceberg in bucket Amazon S3 Tables o bucket Amazon S3 per uso generico all'interno del tuo account. Il AWS Glue Data Catalog monitora automaticamente le tabelle dei sorgenti e aggiorna le viste materializzate utilizzando un'infrastruttura di elaborazione gestita.

Come funzionano le viste materializzate con AWS Glue

Le viste materializzate si integrano con AWS Glue tramite il supporto Iceberg di Apache Spark nei notebook Glue AWS job e AWS Glue Studio. Quando configuri la sessione Spark per utilizzare il AWS Glue Data Catalog, puoi creare viste materializzate utilizzando la sintassi SQL standard. L'ottimizzatore Spark può riscrivere automaticamente le query per utilizzare le viste materializzate quando offrono prestazioni migliori, eliminando la necessità di modificare manualmente il codice dell'applicazione.

Il AWS Glue Data Catalog gestisce tutti gli aspetti operativi della manutenzione delle viste materializzate, tra cui:

Puoi interrogare le viste materializzate da AWS Glue usando le stesse interfacce SQL Spark che usi per le tabelle normali. I dati precalcolati sono accessibili anche da altri servizi, tra cui Amazon Athena e Amazon Redshift.

Prerequisiti

Per utilizzare le viste materializzate con AWS Glue, è necessario:

Configurazione di Spark per l'utilizzo di viste materializzate

Per creare e gestire le viste materializzate in AWS Glue, configura la tua sessione Spark con le estensioni Iceberg e le impostazioni del catalogo richieste. Il metodo di configurazione varia a seconda che si utilizzino i lavori AWS Glue o i notebook AWS Glue Studio.

Configurazione dei lavori AWS Glue

Durante la creazione o l'aggiornamento di un lavoro AWS Glue, aggiungete i seguenti parametri di configurazione come parametri del lavoro:

Per i bucket S3 Tables

job = glue.create_job(
    Name='materialized-view-job',
    Role='arn:aws:iam::111122223333:role/GlueServiceRole',
    Command={
        'Name': 'glueetl',
        'ScriptLocation': 's3://amzn-s3-demo-bucket/scripts/mv-script.py',
        'PythonVersion': '3'
    },
    DefaultArguments={
        '--enable-glue-datacatalog': 'true',
        '--conf': 'spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions '
        '--conf spark.sql.catalog.glue_catalog=org.apache.iceberg.spark.SparkCatalog '
                  '--conf spark.sql.catalog.glue_catalog.type=glue '
                  '--conf spark.sql.catalog.glue_catalog.warehouse=s3://amzn-s3-demo-bucket/warehouse '
                  '--conf spark.sql.catalog.glue_catalog.glue.region=us-east-1 '
                  '--conf spark.sql.catalog.glue_catalog.glue.id=111122223333 '
                  '--conf spark.sql.catalog.glue_catalog.glue.account-id=111122223333 ',
                  '--conf spark.sql.catalog.glue_catalog.glue.lakeformation-enabled=true ',
                  '--conf spark.sql.catalog.s3t_catalog=org.apache.iceberg.spark.SparkCatalog '
                  '--conf spark.sql.catalog.s3t_catalog.type=glue '
                  '--conf spark.sql.catalog.s3t_catalog.glue.id=111122223333:s3tablescatalog/my-table-bucket ',
                  '--conf spark.sql.catalog.s3t_catalog.glue.account-id=111122223333 ',
                  '--conf spark.sql.catalog.s3t_catalog.glue.lakeformation-enabled=true ',
                  '--conf spark.sql.catalog.s3t_catalog.warehouse=s3://amzn-s3-demo-bucket/mv-warehouse '
                  '--conf spark.sql.catalog.s3t_catalog.glue.region=us-east-1 '
                  '--conf spark.sql.defaultCatalog=s3t_catalog '
                  '--conf spark.sql.optimizer.answerQueriesWithMVs.enabled=true '
                  '--conf spark.sql.materializedViews.metadataCache.enabled=true'
    },
    GlueVersion='5.1'
)

Per bucket S3 per uso generico

job = glue.create_job(
    Name='materialized-view-job',
    Role='arn:aws:iam::111122223333:role/GlueServiceRole',
    Command={
        'Name': 'glueetl',
        'ScriptLocation': 's3://amzn-s3-demo-bucket/scripts/mv-script.py',
        'PythonVersion': '3'
    },
    DefaultArguments={
        '--enable-glue-datacatalog': 'true',
        '--conf': 'spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions '
                  '--conf spark.sql.catalog.glue_catalog=org.apache.iceberg.spark.SparkCatalog '
                  '--conf spark.sql.catalog.glue_catalog.type=glue '
                  '--conf spark.sql.catalog.glue_catalog.warehouse=s3://amzn-s3-demo-bucket/warehouse '
                  '--conf spark.sql.catalog.glue_catalog.glue.region=us-east-1 '
                  '--conf spark.sql.catalog.glue_catalog.glue.id=111122223333 ',
                  '--conf spark.sql.catalog.glue_catalog.glue.account-id=111122223333 ',
                  '--conf spark.sql.catalog.glue_catalog.glue.lakeformation-enabled=true ',
                  '--conf spark.sql.defaultCatalog=glue_catalog '
                  '--conf spark.sql.optimizer.answerQueriesWithMVs.enabled=true '
                  '--conf spark.sql.materializedViews.metadataCache.enabled=true'
    },
    GlueVersion='5.1'
)

Configurazione dei notebook AWS Glue Studio

Nei taccuini AWS Glue Studio, configura la tua sessione Spark usando il comando magico %%configure all'inizio del notebook:

%%configure
{
    "conf": {
        "spark.sql.extensions": "org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions",
        "spark.sql.catalog.glue_catalog": "org.apache.iceberg.spark.SparkCatalog",
        "spark.sql.catalog.glue_catalog.type": "glue",
        "spark.sql.catalog.glue_catalog.warehouse": "s3://amzn-s3-demo-bucket/warehouse",
        "spark.sql.catalog.glue_catalog.glue.region": "us-east-1",
        "spark.sql.catalog.glue_catalog.glue.id": "111122223333",
        "spark.sql.catalog.glue_catalog.glue.account-id": "111122223333",
        "spark.sql.catalog.glue_catalog.glue.lakeformation-enabled": "true",
        "spark.sql.defaultCatalog": "glue_catalog",
        "spark.sql.optimizer.answerQueriesWithMVs.enabled": "true",
        "spark.sql.materializedViews.metadataCache.enabled": "true"
    }
}

Attivazione dell'aggiornamento incrementale

Per abilitare l'ottimizzazione dell'aggiornamento incrementale, aggiungete le seguenti proprietà di configurazione ai parametri del lavoro o alla configurazione del notebook:

--conf spark.sql.optimizer.incrementalMVRefresh.enabled=true
--conf spark.sql.optimizer.incrementalMVRefresh.deltaThresholdCheckEnabled=false

Parametri di configurazione

I seguenti parametri di configurazione controllano il comportamento delle viste materializzate:

Creazione di viste materializzate

È possibile creare viste materializzate utilizzando l'istruzione SQL CREATE MATERIALIZED VIEW nei lavori o nei AWS notebook Glue. La definizione della vista specifica la logica di trasformazione come una query SQL che fa riferimento a una o più tabelle di origine.

Creazione di una vista materializzata di base nei lavori AWS Glue

L'esempio seguente dimostra la creazione di una vista materializzata in uno script di lavoro AWS Glue, utilizza nomi di tabella completi con una convenzione di denominazione in tre parti nella definizione della vista:

from awsglue.context import GlueContext
from pyspark.context import SparkContext

sc = SparkContext()
glueContext = GlueContext(sc)
spark = glueContext.spark_session

# Create materialized view
spark.sql("""
    CREATE MATERIALIZED VIEW customer_orders
    AS 
    SELECT 
        customer_name, 
        COUNT(*) as order_count, 
        SUM(amount) as total_amount 
    FROM glue_catalog.sales.orders
    GROUP BY customer_name
""")

Creazione di una vista materializzata con aggiornamento automatico

Per configurare l'aggiornamento automatico, specificate una pianificazione di aggiornamento durante la creazione della vista, utilizzando nomi di tabella completi con una convenzione di denominazione in tre parti nella definizione della vista:

spark.sql("""
    CREATE MATERIALIZED VIEW customer_orders
    SCHEDULE REFRESH EVERY 1 HOUR
    AS 
    SELECT 
        customer_name, 
        COUNT(*) as order_count, 
        SUM(amount) as total_amount 
    FROM glue_catalog.sales.orders
    GROUP BY customer_name
""")

Creazione di una vista materializzata con riferimenti tra cataloghi

Quando le tabelle di origine si trovano in un catalogo diverso rispetto alla vista materializzata, utilizzate nomi di tabella completi con una convenzione di denominazione in tre parti sia nel nome della vista che nella definizione della vista:

spark.sql("""
    CREATE MATERIALIZED VIEW s3t_catalog.analytics.customer_summary
    AS 
    SELECT 
        customer_name, 
        COUNT(*) as order_count, 
        SUM(amount) as total_amount 
    FROM glue_catalog.sales.orders
    GROUP BY customer_name
""")

Creazione di viste materializzate nei notebook AWS Glue Studio

Nei notebook AWS Glue Studio, è possibile utilizzare il comando magico %%sql per creare viste materializzate, utilizzando nomi di tabella completi con una convenzione di denominazione in tre parti nella definizione delle viste:

%%sql
CREATE MATERIALIZED VIEW customer_orders
AS 
SELECT 
    customer_name, 
    COUNT(*) as order_count, 
    SUM(amount) as total_amount 
FROM glue_catalog.sales.orders
GROUP BY customer_name

Invio di query alle viste materializzate

Dopo aver creato una vista materializzata, è possibile interrogarla come qualsiasi altra tabella utilizzando le istruzioni SQL SELECT standard nei job o nei notebook AWS Glue.

Interrogazione nei lavori AWS Glue

from awsglue.context import GlueContext
from pyspark.context import SparkContext

sc = SparkContext()
glueContext = GlueContext(sc)
spark = glueContext.spark_session

# Query materialized view
result = spark.sql("SELECT * FROM customer_orders")
result.show()

Interrogazione nei notebook AWS Glue Studio

%%sql
SELECT * FROM customer_orders

Riscrittura automatica delle interrogazioni

Quando la riscrittura automatica delle query è abilitata, l'ottimizzatore Spark analizza le query e utilizza automaticamente le viste materializzate quando possono migliorare le prestazioni. Ad esempio, se esegui la seguente query:

result = spark.sql("""
    SELECT 
        customer_name, 
        COUNT(*) as order_count, 
        SUM(amount) as total_amount 
    FROM orders
    GROUP BY customer_name
""")

L'ottimizzatore Spark riscrive automaticamente questa query per utilizzare la vista materializzata customer_orders invece di elaborare la tabella degli ordini di base, a condizione che la vista materializzata sia aggiornata.

Verifica della riscrittura automatica delle query

Per verificare se una query utilizza la riscrittura automatica delle query, utilizzate il comando EXPLAIN EXTENDED:

spark.sql("""
    EXPLAIN EXTENDED
    SELECT customer_name, COUNT(*) as order_count, SUM(amount) as total_amount 
    FROM orders
    GROUP BY customer_name
""").show(truncate=False)

Nel piano di esecuzione, cercate il nome della vista materializzata nell' BatchScan operazione. Se il piano mostra BatchScan glue_catalog.analytics.customer_orders anziché glue_catalog.sales.orders, la query è stata riscritta automaticamente per utilizzare la BatchScan vista materializzata.

Tieni presente che la riscrittura automatica delle query richiede del tempo prima che la cache dei metadati Spark venga compilata dopo la creazione di una vista materializzata. Questo processo viene in genere completato entro 30 secondi.

Aggiornamento delle viste materializzate

È possibile aggiornare le viste materializzate utilizzando due metodi: aggiornamento completo o aggiornamento incrementale. L'aggiornamento completo ricalcola l'intera vista materializzata da tutti i dati della tabella di base, mentre l'aggiornamento incrementale elabora solo i dati che sono stati modificati dall'ultimo aggiornamento.

Aggiornamento manuale completo nei lavori AWS Glue

Per eseguire un aggiornamento completo di una vista materializzata:

spark.sql("REFRESH MATERIALIZED VIEW customer_orders FULL")

# Verify updated results
result = spark.sql("SELECT * FROM customer_orders")
result.show()

Aggiornamento incrementale manuale nei lavori AWS Glue

Per eseguire un aggiornamento incrementale, assicurati che l'aggiornamento incrementale sia abilitato nella configurazione della sessione Spark, quindi esegui:

spark.sql("REFRESH MATERIALIZED VIEW customer_orders")

# Verify updated results
result = spark.sql("SELECT * FROM customer_orders")
result.show()

Il AWS Glue Data Catalog determina automaticamente se l'aggiornamento incrementale è applicabile in base alla definizione della vista e alla quantità di dati modificati. Se l'aggiornamento incrementale non è possibile, l'operazione torna all'aggiornamento completo.

Aggiornamento nei notebook AWS Glue Studio

Nei notebook, usa il comando magico %%sql:

%%sql
REFRESH MATERIALIZED VIEW customer_orders FULL

Verifica dell'esecuzione dell'aggiornamento incrementale

Per confermare che l'aggiornamento incrementale sia stato eseguito correttamente, abilita la registrazione di debug nel tuo job Glue: AWS

from awsglue.context import GlueContext
from pyspark.context import SparkContext
import logging

sc = SparkContext()
glueContext = GlueContext(sc)
spark = glueContext.spark_session

# Enable debug logging
logger = logging.getLogger('org.apache.spark.sql')
logger.setLevel(logging.DEBUG)

# Execute refresh
spark.sql("REFRESH MATERIALIZED VIEW customer_orders")

Cerca il seguente messaggio nei log dei lavori di AWS Glue:

DEBUG RefreshMaterializedViewExec: Executed Incremental Refresh

Gestione delle viste materializzate

AWS Glue fornisce comandi SQL per la gestione del ciclo di vita delle viste materializzate nei lavori e nei notebook.

Descrizione di una vista materializzata

Per visualizzare i metadati relativi a una vista materializzata, tra cui la definizione, lo stato di aggiornamento e il timestamp dell'ultimo aggiornamento:

spark.sql("DESCRIBE EXTENDED customer_orders").show(truncate=False)

Alterazione di una vista materializzata

Per modificare la pianificazione di aggiornamento di una vista materializzata esistente:

spark.sql("""
    ALTER MATERIALIZED VIEW customer_orders 
    ADD SCHEDULE REFRESH EVERY 2 HOURS
""")

Per rimuovere l'aggiornamento automatico:

spark.sql("""
    ALTER MATERIALIZED VIEW customer_orders 
    DROP SCHEDULE
""")

Eliminare una vista materializzata

Per eliminare una vista materializzata:

spark.sql("DROP MATERIALIZED VIEW customer_orders")

Questo comando rimuove la definizione della vista materializzata dal AWS Glue Data Catalog ed elimina i dati della tabella Iceberg sottostante dal bucket S3.

Elenco delle viste materializzate

Per elencare tutte le viste materializzate in un database:

spark.sql("SHOW VIEWS FROM analytics").show()

Autorizzazioni per le viste materializzate

Per creare e gestire le viste materializzate, è necessario configurare le autorizzazioni. AWS Lake Formation Il ruolo IAM che crea la vista materializzata (il ruolo definer) richiede autorizzazioni specifiche sulle tabelle di origine e sui database di destinazione.

Autorizzazioni richieste per il ruolo di definitore

Il ruolo che definisce deve avere i seguenti permessi di Lake Formation:

Quando si crea una vista materializzata, l'ARN del ruolo definitore viene memorizzato nella definizione della vista. Il AWS Glue Data Catalog assume questo ruolo durante l'esecuzione di operazioni di aggiornamento automatico. Se il ruolo di definitore perde l'accesso alle tabelle di origine, le operazioni di aggiornamento falliranno fino al ripristino delle autorizzazioni.

Autorizzazioni IAM per i lavori AWS Glue

Il ruolo IAM del tuo lavoro AWS Glue richiede le seguenti autorizzazioni:

{
    "Version": "2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "glue:GetCatalog",
                "glue:GetCatalogs",
                "glue:GetTable",
                "glue:GetTables",
                "glue:CreateTable",
                "glue:UpdateTable",
                "glue:DeleteTable",
                "glue:GetDatabase",
                "glue:GetDatabases",
                "cloudwatch:PutMetricData"
            ],
            "Resource": "*"
        },
        {
            "Effect": "Allow",
            "Action": [
                "s3:GetObject",
                "s3:PutObject",
                "s3:DeleteObject"
            ],
            "Resource": [
                "arn:aws:s3:::amzn-s3-demo-bucket/*"
            ]
        },
        {
            "Effect": "Allow",
            "Action": [
                "s3:ListBucket"
            ],
            "Resource": [
                "arn:aws:s3:::amzn-s3-demo-bucket"
            ]
        },
        {
            "Effect": "Allow",
            "Action": [
                "logs:CreateLogGroup",
                "logs:CreateLogStream",
                "logs:PutLogEvents"
            ],
            "Resource": [
                "arn:aws:logs:*:*:*:/aws-glue/*"
            ]
        },
        {
            "Effect": "Allow",
            "Action": [
                "lakeformation:GetDataAccess"
            ],
            "Resource": "*"
        }
    ]
}

Il ruolo che usi per l'aggiornamento automatico di Materialized View deve avere l'PassRole autorizzazione iam: sul ruolo.

{
  "Version":"2012-10-17",		 	 	 
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "iam:PassRole"
      ],
      "Resource": [
        "arn:aws:iam::111122223333:role/materialized-view-role-name"
      ]
    }
  ]
}
      

Affinché Glue aggiorni automaticamente la vista materializzata, il ruolo deve inoltre avere la seguente politica di attendibilità che consenta al servizio di assumere il ruolo.

{
  "Version":"2012-10-17",		 	 	 
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "iam:PassRole"
      ],
      "Resource": [
        "arn:aws:iam::111122223333:role/materialized-view-role-name"
      ]
    }
  ]
}
      

Se la vista materializzata è archiviata in S3 Tables Bucket, devi anche aggiungere la seguente autorizzazione al ruolo.

{
  "Version": "2012-10-17",		 	 	 
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "s3tables:PutTableMaintenanceConfiguration"
      ],
      "Resource": "arn:aws:s3tables:*:123456789012:*"
    }
  ]
}
      

Concessione dell'accesso alle viste materializzate

Per concedere ad altri utenti l'accesso all'interrogazione di una vista materializzata, utilizzare questa opzione AWS Lake Formation per concedere l'autorizzazione SELECT sulla tabella delle viste materializzate. Gli utenti possono interrogare la vista materializzata senza richiedere l'accesso diretto alle tabelle di origine sottostanti.

Per informazioni dettagliate sulla configurazione delle autorizzazioni di Lake Formation, consulta Concessione e revoca delle autorizzazioni sulle risorse di Data Catalog nella Developer Guide. AWS Lake Formation

Monitoraggio delle operazioni di visualizzazione materializzata

Il AWS Glue Data Catalog pubblica metriche e log per le operazioni di aggiornamento delle viste materializzate su Amazon. CloudWatch Puoi monitorare lo stato dell'aggiornamento, la durata e il volume di dati elaborati tramite metriche. CloudWatch

Visualizzazione dei registri dei lavori

Per visualizzare i log dei lavori AWS Glue che creano o aggiornano viste materializzate:

Configurazione degli allarmi

Per ricevere notifiche quando le operazioni di aggiornamento falliscono o superano la durata prevista, crea CloudWatch allarmi sulle metriche delle viste materializzate. Puoi anche configurare EventBridge le regole di Amazon per attivare risposte automatiche agli eventi di aggiornamento.

Esempio: flusso di lavoro completo

L'esempio seguente dimostra un flusso di lavoro completo per la creazione e l'utilizzo di una vista materializzata in AWS Glue.

Esempio di script AWS Glue job

import sys
from awsglue.transforms import *
from awsglue.utils import getResolvedOptions
from pyspark.context import SparkContext
from awsglue.context import GlueContext
from awsglue.job import Job

args = getResolvedOptions(sys.argv, ['JOB_NAME'])
sc = SparkContext()
glueContext = GlueContext(sc)
spark = glueContext.spark_session
job = Job(glueContext)
job.init(args['JOB_NAME'], args)

# Create database and base table
spark.sql("CREATE DATABASE IF NOT EXISTS sales")
spark.sql("USE sales")

spark.sql("""
    CREATE TABLE IF NOT EXISTS orders (
        id INT,
        customer_name STRING,
        amount DECIMAL(10,2),
        order_date DATE
    )
""")

# Insert sample data
spark.sql("""
    INSERT INTO orders VALUES 
        (1, 'John Doe', 150.00, DATE('2024-01-15')),
        (2, 'Jane Smith', 200.50, DATE('2024-01-16')),
        (3, 'Bob Johnson', 75.25, DATE('2024-01-17'))
""")

# Create materialized view
spark.sql("""
    CREATE MATERIALIZED VIEW customer_summary
    AS 
    SELECT 
        customer_name, 
        COUNT(*) as order_count, 
        SUM(amount) as total_amount 
    FROM glue_catalog.sales.orders
    GROUP BY customer_name
""")

# Query the materialized view
print("Initial materialized view data:")
spark.sql("SELECT * FROM customer_summary").show()

# Insert additional data
spark.sql("""
    INSERT INTO orders VALUES 
        (4, 'Jane Smith', 350.00, DATE('2024-01-18')),
        (5, 'Bob Johnson', 100.25, DATE('2024-01-19'))
""")

# Refresh the materialized view
spark.sql("REFRESH MATERIALIZED VIEW customer_summary FULL")

# Query updated results
print("Updated materialized view data:")
spark.sql("SELECT * FROM customer_summary").show()

job.commit()

Esempio di notebook AWS Glue Studio

%%configure
{
    "conf": {
        "spark.sql.extensions": "org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions",
        "spark.sql.catalog.glue_catalog": "org.apache.iceberg.spark.SparkCatalog",
        "spark.sql.catalog.glue_catalog.type": "glue",
        "spark.sql.catalog.glue_catalog.warehouse": "s3://amzn-s3-demo-bucket/warehouse",
        "spark.sql.catalog.glue_catalog.glue.region": "us-east-1",
        "spark.sql.catalog.glue_catalog.glue.id": "111122223333",
        "spark.sql.catalog.glue_catalog.glue.account-id": "111122223333",
        "spark.sql.catalog.glue_catalog.glue.lakeformation-enabled": "true",
        "spark.sql.defaultCatalog": "glue_catalog",
        "spark.sql.optimizer.answerQueriesWithMVs.enabled": "true",
        "spark.sql.materializedViews.metadataCache.enabled": "true"
    }
}

%%sql
CREATE DATABASE IF NOT EXISTS sales

%%sql
USE sales

%%sql
CREATE TABLE IF NOT EXISTS orders (
    id INT,
    customer_name STRING,
    amount DECIMAL(10,2),
    order_date DATE
)

%%sql
INSERT INTO orders VALUES 
    (1, 'John Doe', 150.00, DATE('2024-01-15')),
    (2, 'Jane Smith', 200.50, DATE('2024-01-16')),
    (3, 'Bob Johnson', 75.25, DATE('2024-01-17'))

%%sql
CREATE MATERIALIZED VIEW customer_summary
AS 
SELECT 
    customer_name, 
    COUNT(*) as order_count, 
    SUM(amount) as total_amount 
FROM glue_catalog.sales.orders
GROUP BY customer_name

%%sql
SELECT * FROM customer_summary

%%sql
INSERT INTO orders VALUES 
    (4, 'Jane Smith', 350.00, DATE('2024-01-18')),
    (5, 'Bob Johnson', 100.25, DATE('2024-01-19'))

%%sql
REFRESH MATERIALIZED VIEW customer_summary FULL

%%sql
SELECT * FROM customer_summary

Considerazioni e limitazioni

Considerate quanto segue quando utilizzate viste materializzate con AWS Glue: