# Usar visões materializadas com AWS o Glue A versão 5.1 e posterior do AWS Glue oferece suporte à criação e ao gerenciamento de visões materializadas do Apache Iceberg no Catálogo de Dados do AWS Glue. Uma visão materializada é uma tabela gerenciada que armazena o resultado pré-computado de uma consulta SQL no formato Apache Iceberg e é atualizada incrementalmente à medida que as tabelas de origem subjacentes mudam. Você pode usar visões materializadas para simplificar os pipelines de transformação de dados e acelerar o desempenho das consultas para workloads de analytics complexas. Quando você cria uma visão materializada usando o Spark no AWS Glue, a definição da visão e os metadados são armazenados no Catálogo de Dados do AWS Glue. Os resultados pré-computados são armazenados como tabelas do Apache Iceberg em buckets do Tabelas do Amazon S3 ou buckets de uso geral do Amazon S3 em sua conta. O Catálogo de Dados do AWS Glue monitora automaticamente as tabelas de origem e atualiza as visões materializadas usando a infraestrutura de computação gerenciada. **Topics** + [Como as visões materializadas funcionam com o AWS Glue](#materialized-views-how-they-work) + [Pré-requisitos](#materialized-views-prerequisites) + [Configurar o Spark para usar visões materializadas](#materialized-views-configuring-spark) + [Criar visualizações materializadas](#materialized-views-creating) + [Consultar visões materializadas](#materialized-views-querying) + [Atualizar visões materializadas](#materialized-views-refreshing) + [Gerenciar visões materializadas](#materialized-views-managing) + [Permissões para visões materializadas](#materialized-views-permissions) + [Monitorar operações de visão materializada](#materialized-views-monitoring) + [Exemplo: concluir fluxo de trabalho](#materialized-views-complete-workflow) + [Considerações e limitações](#materialized-views-considerations-limitations) ## Como as visões materializadas funcionam com o AWS Glue As visões materializadas se integram ao AWS Glue por meio do suporte ao Iceberg do Apache Spark nos trabalhos do AWS Glue e nos cadernos do AWS Glue Studio. Ao configurar sua sessão do Spark para usar o Catálogo de Dados do AWS Glue, você pode criar visões materializadas usando a sintaxe SQL padrão. O otimizador do Spark pode reescrever automaticamente as consultas para usar visões materializadas quando elas oferecem melhor desempenho, eliminando a necessidade de modificar manualmente o código da aplicação. O Catálogo de Dados do AWS Glue trata de todos os aspectos operacionais da manutenção da visão materializada, incluindo: + Detecção das alterações nas tabelas de origem usando a camada de metadados do Apache Iceberg + Agendamento e execução de operações de atualização usando a computação gerenciada do Spark + Determinação se deve realizar uma atualização completa ou incremental com base nas alterações de dados + Armazenamento de resultados pré-computados no formato Apache Iceberg para acesso por vários mecanismos Você pode consultar visões materializadas do AWS Glue usando as mesmas interfaces SQL do Spark que você usa para tabelas comuns. Os dados pré-computados também podem ser acessados de outros serviços, incluindo Amazon Athena e Amazon Redshift. ## Pré-requisitos Para usar visões materializadas com o AWS Glue, você precisa: + Uma conta da + AWS Glue versão 5.1 ou mais recente + Tabelas de origem no formato Apache Iceberg registradas no Catálogo de Dados do AWS Glue + Permissões AWS Lake Formation configuradas para tabelas de origem e bancos de dados de destino + Um bucket do Tabelas do S3 ou um bucket do S3 de uso geral registrado com AWS Lake Formation para armazenar dados de visão materializada + Um perfil do IAM com permissões para acessar o Catálogo de Dados do AWS Glue e o Amazon S3 ## Configurar o Spark para usar visões materializadas Para criar e gerenciar visões materializadas no AWS Glue, configure sua sessão do Spark com as extensões e configurações de catálogo necessárias do Iceberg. O método de configuração varia dependendo se você está usando trabalhos do AWS Glue ou cadernos do AWS Glue Studio. ### Configurar trabalhos do AWS Glue Ao criar ou atualizar um trabalho do AWS Glue, adicione os seguintes parâmetros de configuração como parâmetros do trabalho: #### Para buckets do Tabelas do 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.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' ) ``` #### Para buckets de uso geral do 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' ) ``` ### Configurar cadernos do AWS Glue Studio Nos cadernos do AWS Glue Studio, configure sua sessão do Spark usando o comando mágico %%configure no início do seu caderno: ``` %%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" } } ``` ### Habilitar a atualização incremental Para habilitar a otimização da atualização incremental, adicione as seguintes propriedades de configuração aos parâmetros do seu trabalho ou à configuração do caderno: ``` --conf spark.sql.optimizer.incrementalMVRefresh.enabled=true --conf spark.sql.optimizer.incrementalMVRefresh.deltaThresholdCheckEnabled=false ``` ### Parâmetros de configuração Os seguintes parâmetros de configuração controlam o comportamento da visão materializada: + `spark.sql.extensions`: permite extensões de sessão do Iceberg Spark necessárias para o suporte à visão materializada. + `spark.sql.optimizer.answerQueriesWithMVs.enabled`: permite reescrita automática de consultas para usar visões materializadas. Defina como true para ativar essa otimização. + `spark.sql.materializedViews.metadataCache.enabled`: permite o armazenamento em cache de metadados de visão materializada para otimização de consultas. Defina como true para melhorar o desempenho da reescrita de consultas. + `spark.sql.optimizer.incrementalMVRefresh.enabled`: permite a otimização incremental da atualização. Defina como true para processar somente os dados alterados durante as operações de atualização. + `spark.sql.optimizer.answerQueriesWithMVs.decimalAggregateCheckEnabled`: controla a validação de operações de agregação decimal na reescrita de consultas. Defina como false para desabilitar determinadas verificações de estouro decimal. ## Criar visualizações materializadas Você cria visões materializadas usando a instrução SQL CREATE MATERIALIZED VIEW nos trabalhos ou cadernos do AWS Glue. A definição da visão especifica a lógica de transformação como uma consulta SQL que faz referência a uma ou mais tabelas de origem. ### Criar uma visão materializada básica em trabalhos do AWS Glue O exemplo a seguir demonstra como criar uma visão materializada em um script de trabalho do AWS Glue. Use nomes de tabela totalmente qualificados com convenção de nomenclatura de três partes na definição da visão: ``` 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 """) ``` ### Criar uma visão materializada com atualização automática Para configurar a atualização automática, especifique uma programação de atualização ao criar a visão, usando nomes de tabela totalmente qualificados com convenção de nomenclatura de três partes na definição da visão: ``` 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 """) ``` ### Criar uma visão materializada com referências de catálogos cruzados Quando suas tabelas de origem estiverem em um catálogo diferente da visão materializada, use nomes de tabela totalmente qualificados com convenção de nomenclatura em três partes, tanto no nome da visão quanto na definição da visão: ``` 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 """) ``` ### Criar visões materializadas em cadernos do AWS Glue Studio Nos cadernos do AWS Glue Studio, você pode usar o comando mágico %%sql para criar visões materializadas, usando nomes de tabela totalmente qualificados com convenção de nomenclatura de três partes na definição da visão: ``` %%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 ``` ## Consultar visões materializadas Depois de criar uma visão materializada, você pode consultá-la como qualquer outra tabela usando instruções SQL SELECT padrão em seus trabalhos ou cadernos do AWS Glue. ### Consultas em trabalhos no 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() ``` ### Consultas em cadernos AWS Glue Studio ``` %%sql SELECT * FROM customer_orders ``` ### Reescrita automática de consultas Quando a reescrita automática de consultas está habilitada, o otimizador do Spark analisa suas consultas e usa automaticamente visões materializadas quando elas podem melhorar o desempenho. Por exemplo, se você executar a seguinte consulta: ``` result = spark.sql(""" SELECT customer_name, COUNT(*) as order_count, SUM(amount) as total_amount FROM orders GROUP BY customer_name """) ``` O otimizador do Spark reescreve automaticamente essa consulta para usar a visão materializada customer\$1orders em vez de processar a tabela de pedidos base, desde que a visão materializada seja atual. ### Verificar a reescrita automática de consulta Para verificar se uma consulta usa a reescrita automática de consultas, use o 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) ``` No plano de execução, procure o nome da visão materializada na operação BatchScan. Se o plano mostrar BatchScan glue\$1catalog.analytics.customer\$1orders em vez de BatchScan glue\$1catalog.sales.orders, a consulta foi automaticamente reescrita para usar a visão materializada. Observe que a reescrita automática da consulta requer tempo para que o cache de metadados do Spark seja preenchido após a criação de uma visão materializada. Normalmente, esse processo é concluído em 30 segundos. ## Atualizar visões materializadas Você pode atualizar as visões materializadas usando dois métodos: atualização completa ou atualização incremental. A atualização completa recalcula toda a visão materializada de todos os dados da tabela base, enquanto a atualização incremental processa somente os dados que foram alterados desde a última atualização. ### Atualização manual completa nos trabalhos do AWS Glue Para realizar uma atualização completa de uma visão materializada: ``` spark.sql("REFRESH MATERIALIZED VIEW customer_orders FULL") # Verify updated results result = spark.sql("SELECT * FROM customer_orders") result.show() ``` ### Atualização incremental manual em trabalhos do AWS Glue Para realizar uma atualização incremental, certifique-se de que a atualização incremental esteja ativada na configuração da sua sessão do Spark e, em seguida, execute: ``` spark.sql("REFRESH MATERIALIZED VIEW customer_orders") # Verify updated results result = spark.sql("SELECT * FROM customer_orders") result.show() ``` O Catálogo de Dados do AWS Glue determina automaticamente se a atualização incremental é aplicável com base na definição da visão e na quantidade de dados alterados. Se a atualização incremental não for possível, a operação retornará à atualização completa. ### Atualização nos cadernos do AWS Glue Studio Em cadernos, use o comando mágico %%sql: ``` %%sql REFRESH MATERIALIZED VIEW customer_orders FULL ``` ### Verificar execução da atualização incremental Para confirmar que a atualização incremental foi executada com sucesso, habilite o registro em log de depuração em seu trabalho do 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") ``` Pesquise a seguinte mensagem nos logs dos trabalhos do AWS Glue: ``` DEBUG RefreshMaterializedViewExec: Executed Incremental Refresh ``` ## Gerenciar visões materializadas O AWS Glue fornece comandos SQL para gerenciar o ciclo de vida das visões materializadas em seus trabalhos e cadernos. ### Descrever uma visão materializada Para visualizar metadados sobre uma visão materializada, incluindo sua definição, status de atualização e data e hora da última atualização: ``` spark.sql("DESCRIBE EXTENDED customer_orders").show(truncate=False) ``` ### Alterar uma visão materializada Para modificar o cronograma de atualização de uma visão materializada existente: ``` spark.sql(""" ALTER MATERIALIZED VIEW customer_orders ADD SCHEDULE REFRESH EVERY 2 HOURS """) ``` Para remover a atualização automática: ``` spark.sql(""" ALTER MATERIALIZED VIEW customer_orders DROP SCHEDULE """) ``` ### Eliminar uma visão materializada Para excluir uma visão materializada: ``` spark.sql("DROP MATERIALIZED VIEW customer_orders") ``` Esse comando remove a definição de visão materializada do Catálogo de Dados do AWS Glue e exclui os dados subjacentes da tabela do Iceberg do seu bucket do S3. ### Listar visões materializadas Para listar todas as visões materializadas em um banco de dados: ``` spark.sql("SHOW VIEWS FROM analytics").show() ``` ## Permissões para visões materializadas Para criar e gerenciar visões materializadas, você deve configurar as permissões do AWS Lake Formation. O perfil do IAM que cria a visão materializada (o perfil definidor) requer permissões específicas nas tabelas de origem e nos bancos de dados de destino. ### Permissões necessárias para o perfil de definidor O perfil deve ter as seguintes permissões: + Nas tabelas de origem: permissões SELECT ou ALL sem filtros de linha, coluna ou célula + No banco de dados de destino: permissão CREATE\$1TABLE + No Catálogo de Dados do AWS Glue: permissões das APIs GetTable e CreateTable Quando você cria uma visão materializada, o ARN do perfil definidor é armazenado na definição da visão. O Catálogo de Dados do AWS Glue assume esse perfil ao executar operações de atualização automática. Se o perfil do definidor perder o acesso às tabelas de origem, as operações de atualização falharão até que as permissões sejam restauradas. ### Permissões do IAM para trabalhos do AWS Glue O perfil do IAM do trabalho do AWS Glue requer as seguintes permissões: ``` { "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": "*" } ] } ``` O perfil que você usa para atualizar automaticamente a visão materializada deve ter a permissão iam:PassRole no perfil. ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "iam:PassRole" ], "Resource": [ "arn:aws:iam::111122223333:role/materialized-view-role-name" ] } ] } ``` Para que o Glue atualize automaticamente a visão materializada para você, o perfil também deve ter a política de confiança a seguir que permite que o serviço assuma o perfil. ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "iam:PassRole" ], "Resource": [ "arn:aws:iam::111122223333:role/materialized-view-role-name" ] } ] } ``` Se a visão materializada estiver armazenada em buckets do Tabelas do S3, também precisará adicionar a seguinte permissão ao perfil. ``` { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "s3tables:PutTableMaintenanceConfiguration" ], "Resource": "arn:aws:s3tables:*:123456789012:*" } ] } ``` ### Conceder acesso às visões materializadas Para conceder acesso a outros usuários para consultar uma visão materializada, use AWS Lake Formation para conceder a permissão SELECT na tabela de visão materializada. Os usuários podem consultar a visão materializada sem precisar de acesso direto às tabelas de origem subjacentes. Para obter informações detalhadas sobre como configurar as permissões do Lake Formation, consulte Conceder e revogar permissões nos recursos do Catálogo de Dados no Guia do Desenvolvedor do AWS Lake Formation. ## Monitorar operações de visão materializada O Catálogo de Dados do AWS Glue publica métricas e logs para operações de atualização de visões materializadas no Amazon CloudWatch. Você pode monitorar o status da atualização, a duração e o volume de dados processados por meio das métricas do CloudWatch. ### Visualizar logs de trabalho Para visualizar logs de trabalhos do AWS Glue que criam ou atualizam visões materializadas: 1. Abra o console do AWS Glue. 1. Selecione Trabalhos no painel de navegação. 1. Selecione seu trabalho e escolha Execuções. 1. Selecione uma execução específica e escolha Logs para visualizar os logs do CloudWatch. ### Definir alarmes Para receber notificações quando as operações de atualização falharem ou excederem a duração esperada, crie alarmes do CloudWatch nas métricas de visão materializada. Você também pode configurar as regras do Amazon EventBridge para acionar respostas automatizadas para atualizar eventos. ## Exemplo: concluir fluxo de trabalho O exemplo a seguir demonstra um fluxo de trabalho completo para criar e usar uma visão materializada no AWS Glue. ### Exemplo de script de trabalho do AWS 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() ``` ### Exemplo de caderno do 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 ``` ## Considerações e limitações Pense no seguinte ao usar visões materializadas com o AWS Glue: + Visões materializadas requerem o AWS Glue versão 5.1 ou posterior. + As tabelas de origem devem ser tabelas do Apache Iceberg registradas no Catálogo de Dados do AWS Glue. Tabelas do Apache Hive, do Apache Hudi e do Delta Lake da Linux Foundation não são compatíveis no lançamento. + As tabelas de origem devem residir na mesma Região e conta que a visão materializada. + Todas as tabelas de origem devem ser regidas pelo AWS Lake Formation. Permissões somente do IAM e acesso híbrido não são compatíveis. + As visões materializadas não podem referenciar as visões do Catálogo de Dados do AWS Glue, visões de vários dialetos ou outras visões materializadas como tabelas de origem. + O perfil definidor das visões deve ter acesso total de leitura (permissão SELECT ou ALL) em todas as tabelas de origem sem a aplicação de filtros de linha, coluna ou célula. + Com o tempo, as visões materializadas se tornam consistentes com as tabelas de origem. Durante a janela de atualização, as consultas podem retornar dados obsoletos. Execute a atualização manual para obter consistência imediata. + O intervalo mínimo de atualização automática é uma hora. + A atualização incremental oferece suporte a um subconjunto restrito de operações SQL. A definição da visão deve ser um único bloco SELECT-FROM-WHERE-GROUP BY-HAVING e não pode conter operações de conjunto, subconsultas, a palavra-chave DISTINCT em funções SELECT ou agregadas, funções de janela ou junções que não sejam INNER JOIN. + A atualização incremental não oferece suporte a funções definidas pelo usuário ou a determinadas funções integradas. Somente um subconjunto das funções integradas do Spark SQL é compatível. + A reescrita automática de consultas considera somente visões materializadas cujas definições pertencem a um subconjunto SQL restrito semelhante às restrições de atualização incremental. + Identificadores contendo caracteres especiais que não sejam caracteres alfanuméricos e sublinhados não são compatíveis nas consultas CREATE MATERIALIZED VIEW. Isso se aplica a todos os tipos de identificadores, incluindo nomes de catálogo/namespace/tabela, nomes de campos de coluna e estrutura, CTEs e aliases. + As colunas de visão materializada que começam com o prefixo \$1\$1ivm são reservadas para uso do sistema. A Amazon se reserva o direito de modificar ou remover essas colunas em versões futuras. + As cláusulas SORT BY, LIMIT, OFFSET, CLUSTER BY e ORDER BY não são compatíveis com as definições de visão materializada. + Tabelas de origem entre regiões e entre contas não são compatíveis. + As tabelas referenciadas na consulta de visão devem usar a convenção de nomenclatura em três partes (por exemplo, glue\$1catalog.my\$1db.my\$1table) porque a atualização automática não usa configurações padrão de catálogo e banco de dados. + As operações de atualização completa substituem a tabela inteira e tornam os snapshots anteriores indisponíveis. + Funções não determinísticas, como rand() ou current\$1timestamp(), não são compatíveis nas definições de visão materializada.