Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

Materialisierte Ansichten mit AWS Glue verwenden

AWS Glue Version 5.1 und höher unterstützt die Erstellung und Verwaltung materialisierter Apache Iceberg-Ansichten im AWS Glue-Datenkatalog. Eine materialisierte Ansicht ist eine verwaltete Tabelle, die das vorberechnete Ergebnis einer SQL-Abfrage im Apache Iceberg-Format speichert und schrittweise aktualisiert wird, wenn sich die zugrunde liegenden Quelltabellen ändern. Sie können materialisierte Ansichten verwenden, um Pipelines zur Datentransformation zu vereinfachen und die Abfrageleistung für komplexe analytische Workloads zu beschleunigen.

Wenn Sie mit Spark in AWS Glue eine materialisierte Ansicht erstellen, werden die Ansichtsdefinition und die Metadaten im AWS Glue-Datenkatalog gespeichert. Die vorberechneten Ergebnisse werden als Apache Iceberg-Tabellen in Amazon S3 S3-Tabelles-Buckets oder Amazon S3 S3-Allzweck-Buckets in Ihrem Konto gespeichert. Der AWS Glue-Datenkatalog überwacht automatisch Quelltabellen und aktualisiert materialisierte Ansichten mithilfe einer verwalteten Recheninfrastruktur.

So funktionieren materialisierte Ansichten mit Glue AWS

Materialisierte Ansichten lassen sich über die Iceberg-Unterstützung von Apache Spark in AWS Glue-Jobs und AWS Glue Studio-Notebooks in AWS Glue integrieren. Wenn Sie Ihre Spark-Sitzung für die Verwendung des AWS Glue-Datenkatalogs konfigurieren, können Sie materialisierte Ansichten mithilfe der Standard-SQL-Syntax erstellen. Der Spark-Optimierer kann Abfragen automatisch so umschreiben, dass sie materialisierte Ansichten verwenden, wenn sie eine bessere Leistung bieten, sodass der Anwendungscode nicht manuell geändert werden muss.

Der AWS Glue-Datenkatalog behandelt alle betrieblichen Aspekte der Wartung von Materialized Views, einschließlich:

Sie können materialisierte Ansichten von AWS Glue mit denselben Spark-SQL-Schnittstellen abfragen, die Sie für normale Tabellen verwenden. Auf die vorberechneten Daten kann auch von anderen Diensten wie Amazon Athena und Amazon Redshift aus zugegriffen werden.

Voraussetzungen

Um materialisierte Ansichten mit AWS Glue zu verwenden, benötigen Sie:

Konfiguration von Spark für die Verwendung materialisierter Ansichten

Um materialisierte Ansichten in AWS Glue zu erstellen und zu verwalten, konfigurieren Sie Ihre Spark-Sitzung mit den erforderlichen Iceberg-Erweiterungen und Katalogeinstellungen. Die Konfigurationsmethode hängt davon ab, ob Sie Glue-Jobs oder AWS AWS Glue Studio-Notizbücher verwenden.

Konfiguration von AWS Glue-Jobs

Wenn Sie einen AWS Glue-Job erstellen oder aktualisieren, fügen Sie die folgenden Konfigurationsparameter als Job-Parameter hinzu:

Für S3-Tabellen-Buckets

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

Für S3-Allzweck-Buckets

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

Konfiguration von AWS Glue Studio-Notebooks

Konfigurieren Sie in AWS Glue Studio-Notizbüchern Ihre Spark-Sitzung mit dem Befehl %%configure magic am Anfang Ihres Notizbuchs:

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

Aktivierung der inkrementellen Aktualisierung

Um die inkrementelle Aktualisierungsoptimierung zu aktivieren, fügen Sie Ihren Jobparametern oder Ihrer Notebook-Konfiguration die folgenden Konfigurationseigenschaften hinzu:

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

Konfigurationsparameter

Die folgenden Konfigurationsparameter steuern das Verhalten der materialisierten Ansicht:

Erstellen von materialisierten Ansichten

Sie erstellen materialisierte Ansichten mit der SQL-Anweisung CREATE MATERIALIZED VIEW in AWS Glue-Jobs oder -Notebooks. Die View-Definition spezifiziert die Transformationslogik als eine SQL-Abfrage, die auf eine oder mehrere Quelltabellen verweist.

Erstellen einer grundlegenden materialisierten Ansicht in AWS Glue-Jobs

Das folgende Beispiel zeigt die Erstellung einer materialisierten Ansicht in einem AWS Glue-Job-Skript, wobei vollqualifizierte Tabellennamen mit dreiteiliger Benennungskonvention in der Ansichtsdefinition verwendet werden:

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

Erstellen einer materialisierten Ansicht mit automatischer Aktualisierung

Um die automatische Aktualisierung zu konfigurieren, geben Sie bei der Erstellung der Ansicht einen Aktualisierungszeitplan an. Verwenden Sie dabei vollqualifizierte Tabellennamen mit dreiteiliger Benennungskonvention in der Ansichtsdefinition:

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

Erstellen einer materialisierten Ansicht mit katalogübergreifenden Verweisen

Wenn sich Ihre Quelltabellen in einem anderen Katalog als Ihre materialisierte Ansicht befinden, verwenden Sie vollqualifizierte Tabellennamen mit dreiteiliger Benennungskonvention sowohl im Ansichtsnamen als auch in der Ansichtsdefinition:

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

Materialisierte Ansichten in AWS Glue Studio-Notizbüchern erstellen

In AWS Glue Studio-Notizbüchern können Sie den magischen Befehl %%sql verwenden, um materialisierte Ansichten zu erstellen, wobei Sie vollqualifizierte Tabellennamen mit dreiteiliger Benennungskonvention in der Ansichtsdefinition verwenden:

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

Abfragen materialisierter Ansichten

Nachdem Sie eine materialisierte Ansicht erstellt haben, können Sie sie wie jede andere Tabelle mit Standard-SQL-SELECT-Anweisungen in Ihren AWS Glue-Jobs oder -Notizbüchern abfragen.

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

Abfragen in AWS Glue Studio-Notizbüchern

%%sql
SELECT * FROM customer_orders

Automatisches Umschreiben von Abfragen

Wenn das automatische Umschreiben von Abfragen aktiviert ist, analysiert der Spark-Optimierer Ihre Abfragen und verwendet automatisch materialisierte Ansichten, wenn diese die Leistung verbessern können. Wenn Sie beispielsweise die folgende Abfrage ausführen:

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

Der Spark-Optimierer schreibt diese Abfrage automatisch neu, sodass sie die materialisierte Ansicht customer_orders verwendet, anstatt die Tabelle mit den Basisbestellungen zu verarbeiten, vorausgesetzt, die materialisierte Ansicht ist aktuell.

Überprüfung des automatischen Umschreibens von Abfragen

Verwenden Sie den Befehl EXPLAIN EXTENDED, um zu überprüfen, ob eine Abfrage das automatische Umschreiben von Abfragen verwendet:

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)

Suchen Sie im Ausführungsplan nach dem Namen der materialisierten Ansicht in der BatchScan Operation. Wenn der Plan BatchScan glue_catalog.analytics.customer_orders statt glue_catalog.sales.orders anzeigt, wurde die Abfrage automatisch so umgeschrieben, dass sie die BatchScan materialisierte Ansicht verwendet.

Beachten Sie, dass das automatische Umschreiben von Abfragen einige Zeit in Anspruch nimmt, bis der Spark-Metadatencache gefüllt ist, nachdem eine materialisierte Ansicht erstellt wurde. Dieser Vorgang ist in der Regel innerhalb von 30 Sekunden abgeschlossen.

Aktualisieren materialisierter Ansichten

Sie können materialisierte Ansichten mit zwei Methoden aktualisieren: vollständige Aktualisierung oder inkrementelle Aktualisierung. Bei der vollständigen Aktualisierung wird die gesamte materialisierte Ansicht anhand aller Basistabellendaten neu berechnet, während bei der inkrementellen Aktualisierung nur die Daten verarbeitet werden, die sich seit der letzten Aktualisierung geändert haben.

Manuelle vollständige Aktualisierung von AWS Glue-Jobs

So führen Sie eine vollständige Aktualisierung einer materialisierten Ansicht durch:

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

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

Manuelles inkrementelles Aktualisieren von AWS Glue-Jobs

Um eine inkrementelle Aktualisierung durchzuführen, stellen Sie sicher, dass die inkrementelle Aktualisierung in Ihrer Spark-Sitzungskonfiguration aktiviert ist, und führen Sie dann Folgendes aus:

spark.sql("REFRESH MATERIALIZED VIEW customer_orders")

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

Der AWS Glue-Datenkatalog bestimmt anhand der Ansichtsdefinition und der Menge der geänderten Daten automatisch, ob eine inkrementelle Aktualisierung möglich ist. Wenn eine inkrementelle Aktualisierung nicht möglich ist, wird der Vorgang auf eine vollständige Aktualisierung zurückgesetzt.

Aktualisierung in AWS Glue Studio-Notizbüchern

Verwenden Sie in Notizbüchern den magischen Befehl %%sql:

%%sql
REFRESH MATERIALIZED VIEW customer_orders FULL

Die Ausführung der inkrementellen Aktualisierung wird überprüft

Um zu bestätigen, dass die inkrementelle Aktualisierung erfolgreich ausgeführt wurde, aktivieren Sie die Debug-Protokollierung in Ihrem AWS Glue-Job:

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

Suchen Sie in den AWS Glue-Jobprotokollen nach der folgenden Meldung:

DEBUG RefreshMaterializedViewExec: Executed Incremental Refresh

Materialisierte Ansichten verwalten

AWS Glue bietet SQL-Befehle für die Verwaltung des Lebenszyklus materialisierter Ansichten in Ihren Jobs und Notizbüchern.

Beschreibung einer materialisierten Ansicht

So zeigen Sie Metadaten zu einer materialisierten Ansicht an, einschließlich ihrer Definition, ihres Aktualisierungsstatus und des Zeitstempels der letzten Aktualisierung:

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

Eine materialisierte Ansicht ändern

So ändern Sie den Aktualisierungszeitplan einer vorhandenen materialisierten Ansicht:

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

Um die automatische Aktualisierung zu entfernen:

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

Löschen einer materialisierten Ansicht

Um eine materialisierte Ansicht zu löschen:

spark.sql("DROP MATERIALIZED VIEW customer_orders")

Dieser Befehl entfernt die Definition der materialisierten Ansicht aus dem AWS Glue-Datenkatalog und löscht die zugrunde liegenden Iceberg-Tabellendaten aus Ihrem S3-Bucket.

Materialisierte Ansichten auflisten

Um alle materialisierten Ansichten in einer Datenbank aufzulisten:

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

Berechtigungen für materialisierte Ansichten

Um materialisierte Ansichten zu erstellen und zu verwalten, müssen Sie Berechtigungen konfigurieren AWS Lake Formation . Die IAM-Rolle, die die materialisierte Ansicht erstellt (die Definer-Rolle), erfordert spezielle Berechtigungen für Quelltabellen und Zieldatenbanken.

Erforderliche Berechtigungen für die Definer-Rolle

Die Definiererrolle muss über die folgenden Lake Formation Formation-Berechtigungen verfügen:

Wenn Sie eine materialisierte Ansicht erstellen, wird der ARN der Definiererrolle in der Ansichtsdefinition gespeichert. Der AWS Glue-Datenkatalog übernimmt diese Rolle bei der Ausführung automatischer Aktualisierungsvorgänge. Wenn die Definer-Rolle den Zugriff auf Quelltabellen verliert, schlagen Aktualisierungsvorgänge fehl, bis die Berechtigungen wiederhergestellt sind.

IAM-Berechtigungen für AWS Glue-Jobs

Für die IAM-Rolle Ihres AWS Glue-Jobs sind die folgenden Berechtigungen erforderlich:

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

Die Rolle, die Sie für die automatische Aktualisierung von Materialized View verwenden, muss über die iam: PassRole -Berechtigung für die Rolle verfügen.

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

Damit Glue die materialisierte Ansicht automatisch für Sie aktualisiert, muss die Rolle außerdem über die folgende Vertrauensrichtlinie verfügen, die es dem Dienst ermöglicht, die Rolle zu übernehmen.

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

Wenn die Materialized View in S3 Tables Buckets gespeichert ist, müssen Sie der Rolle außerdem die folgende Berechtigung hinzufügen.

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

Zugriff auf materialisierte Ansichten gewähren

Um anderen Benutzern Zugriff auf die Abfrage einer materialisierten Ansicht zu gewähren, verwenden Sie, AWS Lake Formation um die SELECT-Berechtigung für die Materialized View-Tabelle zu gewähren. Benutzer können die Materialized View abfragen, ohne direkten Zugriff auf die zugrunde liegenden Quelltabellen zu benötigen.

Ausführliche Informationen zur Konfiguration von Lake Formation Formation-Berechtigungen finden Sie unter Erteilen und Widerrufen von Berechtigungen für Datenkatalogressourcen im AWS Lake Formation Entwicklerhandbuch.

Überwachung von Materialized View-Vorgängen

Der AWS Glue-Datenkatalog veröffentlicht Metriken und Protokolle für Aktualisierungsvorgänge von Materialized Views auf Amazon CloudWatch. Sie können den Aktualisierungsstatus, die Dauer und das verarbeitete Datenvolumen anhand von CloudWatch Metriken überwachen.

Job-Logs anzeigen

So zeigen Sie Logs für AWS Glue-Jobs an, die materialisierte Ansichten erstellen oder aktualisieren:

Alarme einrichten

Um Benachrichtigungen zu erhalten, wenn Aktualisierungsvorgänge fehlschlagen oder die erwartete Dauer überschreiten, erstellen Sie CloudWatch Alarme für Materialized View-Metriken. Sie können EventBridge Amazon-Regeln auch so konfigurieren, dass automatische Antworten auf Aktualisierungsereignisse ausgelöst werden.

Beispiel: Vollständiger Workflow

Das folgende Beispiel zeigt einen vollständigen Arbeitsablauf für die Erstellung und Verwendung einer materialisierten Ansicht in AWS Glue.

Beispiel für ein AWS Glue-Jobskript

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

Beispiel für ein AWS Glue Studio-Notizbuch

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

Überlegungen und Einschränkungen

Beachten Sie Folgendes, wenn Sie materialisierte Ansichten mit AWS Glue verwenden: