Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Utilisation de vues matérialisées avec Glue AWS

AWS Les versions 5.1 et ultérieures de Glue permettent de créer et de gérer des vues matérialisées Apache Iceberg dans le catalogue de données AWS Glue. Une vue matérialisée est une table gérée qui stocke le résultat précalculé d'une requête SQL au format Apache Iceberg et qui est mise à jour progressivement à mesure que les tables sources sous-jacentes changent. Vous pouvez utiliser des vues matérialisées pour simplifier les pipelines de transformation des données et accélérer les performances des requêtes pour les charges de travail analytiques complexes.

Lorsque vous créez une vue matérialisée à l'aide de Spark in AWS Glue, la définition de la vue et les métadonnées sont stockées dans le catalogue de données AWS Glue. Les résultats précalculés sont stockés sous forme de tables Apache Iceberg dans des compartiments Amazon S3 Tables ou dans des compartiments à usage général Amazon S3 au sein de votre compte. Le catalogue de données AWS Glue surveille automatiquement les tables sources et actualise les vues matérialisées à l'aide d'une infrastructure informatique gérée.

Comment fonctionnent les vues matérialisées avec Glue AWS

Les vues matérialisées s'intègrent à AWS Glue grâce au support Iceberg d'Apache Spark dans les tâches AWS Glue et les blocs-notes AWS Glue Studio. Lorsque vous configurez votre session Spark pour utiliser le catalogue de données AWS Glue, vous pouvez créer des vues matérialisées à l'aide de la syntaxe SQL standard. L'optimiseur Spark peut automatiquement réécrire les requêtes pour utiliser des vues matérialisées lorsqu'elles offrent de meilleures performances, éliminant ainsi le besoin de modifier manuellement le code de l'application.

Le catalogue de données AWS Glue gère tous les aspects opérationnels de la maintenance des vues matérialisées, notamment :

Vous pouvez interroger des vues matérialisées à partir de AWS Glue en utilisant les mêmes interfaces SQL Spark que celles que vous utilisez pour les tables classiques. Les données précalculées sont également accessibles depuis d'autres services, notamment Amazon Athena et Amazon Redshift.

Prérequis

Pour utiliser des vues matérialisées avec AWS Glue, vous devez :

Configuration de Spark pour utiliser des vues matérialisées

Pour créer et gérer des vues matérialisées dans AWS Glue, configurez votre session Spark avec les extensions Iceberg et les paramètres de catalogue requis. La méthode de configuration varie selon que vous utilisez des tâches AWS Glue ou des blocs-notes AWS Glue Studio.

Configuration des tâches AWS Glue

Lorsque vous créez ou mettez à jour une tâche AWS Glue, ajoutez les paramètres de configuration suivants en tant que paramètres de tâche :

Pour seaux 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'
)

Pour les godets à usage général S3

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'
)

Configuration des blocs-notes AWS Glue Studio

Dans les blocs-notes AWS Glue Studio, configurez votre session Spark à l'aide de la commande magique %%configure au début de votre bloc-notes :

%%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"
    }
}

Activation de l'actualisation incrémentielle

Pour activer l'optimisation de l'actualisation incrémentielle, ajoutez les propriétés de configuration suivantes aux paramètres de votre tâche ou à la configuration de votre bloc-notes :

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

Paramètres de configuration

Les paramètres de configuration suivants contrôlent le comportement des vues matérialisées :

Création de vues matérialisées

Vous créez des vues matérialisées à l'aide de l'instruction SQL CREATE MATERIALIZED VIEW dans les jobs ou les AWS blocs-notes Glue. La définition de la vue spécifie la logique de transformation sous la forme d'une requête SQL qui fait référence à une ou plusieurs tables sources.

Création d'une vue matérialisée de base dans les tâches AWS Glue

L'exemple suivant montre comment créer une vue matérialisée dans un script de tâche AWS Glue. Utilisez des noms de table complets avec une convention de dénomination en trois parties dans la définition de la vue :

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
""")

Création d'une vue matérialisée avec actualisation automatique

Pour configurer l'actualisation automatique, spécifiez un calendrier d'actualisation lors de la création de la vue, en utilisant des noms de table complets avec une convention de dénomination en trois parties dans la définition de la vue :

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
""")

Création d'une vue matérialisée avec des références croisées à des catalogues

Lorsque vos tables sources se trouvent dans un catalogue différent de celui de votre vue matérialisée, utilisez des noms de table complets avec une convention de dénomination en trois parties à la fois dans le nom de la vue et dans la définition de la vue :

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
""")

Création de vues matérialisées dans les blocs-notes AWS Glue Studio

Dans les blocs-notes AWS Glue Studio, vous pouvez utiliser la commande magique %%sql pour créer des vues matérialisées, en utilisant des noms de table complets avec une convention de dénomination en trois parties pour la définition des vues :

%%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

Interrogation de vues matérialisées

Après avoir créé une vue matérialisée, vous pouvez l'interroger comme n'importe quelle autre table à l'aide des instructions SQL SELECT standard dans vos jobs AWS Glue ou vos carnets de notes.

Effectuer des requêtes dans AWS Glue Jobs

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()

Effectuer des requêtes dans les AWS blocs-notes Glue Studio

%%sql
SELECT * FROM customer_orders

Réécriture automatique des requêtes

Lorsque la réécriture automatique des requêtes est activée, l'optimiseur Spark analyse vos requêtes et utilise automatiquement des vues matérialisées lorsqu'elles peuvent améliorer les performances. Par exemple, si vous exécutez la requête suivante :

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

L'optimiseur Spark réécrit automatiquement cette requête pour utiliser la vue matérialisée customer_orders au lieu de traiter la table des commandes de base, à condition que la vue matérialisée soit à jour.

Vérification de la réécriture automatique des requêtes

Pour vérifier si une requête utilise la réécriture automatique des requêtes, utilisez la commande 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)

Dans le plan d'exécution, recherchez le nom de la vue matérialisée dans l' BatchScan opération. Si le plan affiche BatchScan glue_catalog.analytics.customer_orders au lieu de glue_catalog.sales.orders, la requête a été automatiquement réécrite pour BatchScan utiliser la vue matérialisée.

Notez que la réécriture automatique des requêtes nécessite du temps pour que le cache de métadonnées Spark soit rempli après la création d'une vue matérialisée. Ce processus se termine généralement en 30 secondes.

Actualisation de vues matérialisées

Vous pouvez actualiser les vues matérialisées à l'aide de deux méthodes : actualisation complète ou actualisation incrémentielle. L'actualisation complète recalcule l'intégralité de la vue matérialisée à partir de toutes les données de la table de base, tandis que l'actualisation incrémentielle traite uniquement les données modifiées depuis la dernière actualisation.

Actualisation complète manuelle dans les tâches AWS Glue

Pour actualiser complètement une vue matérialisée :

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

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

Actualisation incrémentielle manuelle dans les tâches AWS Glue

Pour effectuer une actualisation incrémentielle, assurez-vous que l'actualisation incrémentielle est activée dans la configuration de votre session Spark, puis exécutez :

spark.sql("REFRESH MATERIALIZED VIEW customer_orders")

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

Le catalogue de données AWS Glue détermine automatiquement si une actualisation incrémentielle est applicable en fonction de la définition de la vue et de la quantité de données modifiées. Si l'actualisation incrémentielle n'est pas possible, l'opération revient à une actualisation complète.

Rafraîchissant dans les blocs-notes AWS Glue Studio

Dans les ordinateurs portables, utilisez la commande magique %%sql :

%%sql
REFRESH MATERIALIZED VIEW customer_orders FULL

Vérification de l'exécution de l'actualisation incrémentielle

Pour confirmer que l'actualisation incrémentielle a bien été exécutée, activez la journalisation du débogage dans votre tâche AWS Glue :

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")

Recherchez le message suivant dans les journaux des tâches de AWS Glue :

DEBUG RefreshMaterializedViewExec: Executed Incremental Refresh

Gestion des vues matérialisées

AWS Glue fournit des commandes SQL pour gérer le cycle de vie des vues matérialisées dans vos tâches et carnets de notes.

Décrire une vue matérialisée

Pour afficher les métadonnées relatives à une vue matérialisée, notamment sa définition, son état d'actualisation et l'horodatage de la dernière actualisation :

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

Modification d'une vue matérialisée

Pour modifier le calendrier d'actualisation d'une vue matérialisée existante :

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

Pour supprimer l'actualisation automatique :

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

Supprimer une vue matérialisée

Pour supprimer une vue matérialisée :

spark.sql("DROP MATERIALIZED VIEW customer_orders")

Cette commande supprime la définition de la vue matérialisée du catalogue de données AWS Glue et supprime les données de la table Iceberg sous-jacente de votre compartiment S3.

Répertorier les vues matérialisées

Pour répertorier toutes les vues matérialisées d'une base de données :

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

Autorisations pour les vues matérialisées

Pour créer et gérer des vues matérialisées, vous devez configurer AWS Lake Formation les autorisations. Le rôle IAM qui crée la vue matérialisée (le rôle de définition) nécessite des autorisations spécifiques sur les tables sources et les bases de données cibles.

Autorisations requises pour le rôle de définisseur

Le rôle de définition doit disposer des autorisations Lake Formation suivantes :

Lorsque vous créez une vue matérialisée, l'ARN du rôle de définition est stocké dans la définition de la vue. Le catalogue de données AWS Glue assume ce rôle lorsqu'il exécute des opérations d'actualisation automatique. Si le rôle de définition perd l'accès aux tables sources, les opérations d'actualisation échoueront tant que les autorisations ne seront pas restaurées.

Autorisations IAM pour les tâches AWS Glue

Le rôle IAM de votre tâche AWS Glue nécessite les autorisations suivantes :

{
    "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": "*"
        }
    ]
}

Le rôle que vous utilisez pour l'actualisation automatique de Materialized View doit disposer de l'PassRole autorisation iam : sur le rôle.

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

Pour que Glue actualise automatiquement la vue matérialisée pour vous, le rôle doit également respecter la politique de confiance suivante qui permet au service d'assumer le rôle.

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

Si la vue matérialisée est stockée dans des compartiments de tables S3, vous devez également ajouter l'autorisation suivante au rôle.

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

Octroi de l'accès aux vues matérialisées

Pour autoriser d'autres utilisateurs à interroger une vue matérialisée, accordez l' AWS Lake Formation autorisation SELECT sur la table des vues matérialisées. Les utilisateurs peuvent interroger la vue matérialisée sans avoir besoin d'accéder directement aux tables sources sous-jacentes.

Pour des informations détaillées sur la configuration des autorisations de Lake Formation, consultez la section Octroi et révocation d'autorisations sur les ressources du catalogue de données dans le manuel du AWS Lake Formation développeur.

Surveillance des opérations de visualisation matérialisée

Le AWS Glue Data Catalog publie des statistiques et des journaux pour les opérations d'actualisation des vues matérialisées sur Amazon CloudWatch. Vous pouvez surveiller l'état, la durée et le volume de données traités par le biais de CloudWatch métriques d'actualisation.

Afficher les journaux des tâches

Pour consulter les journaux des tâches AWS Glue qui créent ou actualisent des vues matérialisées, procédez comme suit :

Configuration des alarmes

Pour recevoir des notifications lorsque les opérations d'actualisation échouent ou dépassent la durée prévue, créez des CloudWatch alarmes sur les métriques des vues matérialisées. Vous pouvez également configurer les EventBridge règles Amazon pour déclencher des réponses automatisées afin d'actualiser les événements.

Exemple : flux de travail complet

L'exemple suivant illustre un flux de travail complet pour créer et utiliser une vue matérialisée dans AWS Glue.

Exemple de script AWS de tâche Glue

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()

Exemple de bloc-notes 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

Considérations et restrictions

Lorsque vous utilisez des vues matérialisées avec AWS Glue, tenez compte des points suivants :