As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# AWS Glue Data Catalog Vistas do edifício
No AWS Glue Data Catalog, uma *exibição* é uma tabela virtual na qual o conteúdo é definido por uma consulta SQL que faz referência a uma ou mais tabelas. Você pode criar uma visualização do catálogo de dados que faça referência a até 10 tabelas usando editores SQL para Amazon Athena, Amazon Redshift ou Apache Spark usando o EMR Serverless ou a versão 5.0. AWS Glue As tabelas de referência subjacentes de uma exibição podem pertencer ao mesmo banco de dados ou a bancos de dados diferentes dentro Conta da AWS do mesmo catálogo de dados.
Você pode referenciar AWS Glue tabelas e tabelas padrão em formatos de tabela aberta (OTF), como [Apache Hudi](https://hudi.incubator.apache.org/), Linux Foundation [Delta Lake](https://delta.io/) e [Apache Iceberg](https://iceberg.apache.org/), com dados subjacentes armazenados em locais do Amazon S3 registrados com. AWS Lake Formation Além disso, você pode criar visualizações de tabelas federadas em unidades de compartilhamento de dados do Amazon Redshift que são compartilhadas com o Lake Formation.
## Diferenciar visualizações do Catálogo de Dados de outros tipos de visualização
As visualizações do Catálogo de Dados diferem das visualizações do Apache Hive, do Apache Spark e do Amazon Athena. A visualização do Catálogo de Dados é um recurso nativo do AWS Glue Data Catalog, e é uma visualização criada pelo definidor de vários dialetos. Você pode criar uma visualização do Catálogo de Dados usando um dos serviços de analytics compatíveis, como o Athena ou o Amazon Redshift Spectrum, e acessar a mesma visualização usando outros serviços de analytics compatíveis. Entretanto, as visualizações do Apache Hive, do Apache Spark e do Athena são criadas de forma independente em cada serviço de analytics, como o Athena e o Amazon Redshift, e são visíveis e acessíveis somente dentro desse serviço.
## O que é uma visualização de programador?
Uma visualização de programador é uma visualização SQL que opera com base nas permissões da entidade principal que a criou. O perfil do programador tem as permissões necessárias para acessar as tabelas referidas e executa a instrução SQL que programa a visualização. O definidor cria a visualização e a compartilha com outros usuários por meio AWS Lake Formation do controle de acesso refinado.
Quando um usuário consulta a visualização do programador, o mecanismo de consulta usa as permissões do perfil do programador para acessar as tabelas de referência subjacentes. Essa abordagem permite que os usuários interajam com a visualização sem precisar de acesso direto às tabelas de origem, aumentando a segurança e simplificando o gerenciamento do acesso aos dados.
Para configurar uma visualização definidora, a função definidora do IAM pode estar na mesma AWS conta das tabelas base ou em uma conta diferente usando funções de definidor entre contas. Para obter mais informações sobre as permissões necessárias para o perfil do programador, consulte [Pré-requisitos para criar visualizações](views-prereqs.md).
## Um framework para visualizações de vários dialetos
O Catálogo de Dados aceita a criação de visualizações usando vários dialetos da linguagem de consulta estruturada (SQL). SQL é uma linguagem usada para armazenar e processar informações em um banco de dados relacional e cada mecanismo AWS analítico usa sua própria variação de SQL ou dialeto SQL.
Você cria uma visualização do Catálogo de Dados em um dialeto SQL usando um dos mecanismos de consulta de analytics compatíveis. Posteriormente, você pode atualizar a visualização usando a instrução `ALTER VIEW` em um dialeto SQL diferente em qualquer outro mecanismo de analytics compatível. No entanto, cada dialeto deve fazer referência ao mesmo conjunto de tabelas, colunas e tipos de dados.
Você pode acessar os vários dialetos disponíveis para a visualização usando a `GetTable` API AWS CLI e AWS o console. Assim, a visualização do Catálogo de Dados fica visível e disponível para consultas em diferentes mecanismos de analytics compatíveis.
Ao definir um esquema de visualização comum e um objeto de metadados que você pode consultar em vários mecanismos, as visualizações do catálogo de dados permitem usar visualizações uniformes em todo o data lake.
Para obter mais detalhes sobre como o esquema é resolvido para cada dialeto, consulte o [link para a referência da API](). Para obter mais detalhes sobre as regras de correspondência para diferentes tipos, consulte o [link para a seção relevante no documento da API]().
## Integrar a permissões do Lake Formation
Você pode usar AWS Lake Formation para centralizar o gerenciamento de permissões nas AWS Glue Data Catalog visualizações dos usuários. Você pode conceder permissões refinadas nas visualizações do Catálogo de Dados usando o método de recurso nomeado ou tags LF e compartilhá-las entre AWS organizações e unidades Contas da AWS organizacionais. Você também pode compartilhar e acessar as visualizações do Catálogo de Dados Regiões da AWS usando links de recursos. Isso permite que os usuários forneçam acesso aos dados sem duplicar a fonte de dados ou compartilhar as tabelas subjacentes.
A declaração `CREATE VIEW` DDL de uma visualização do catálogo de dados pode referenciar AWS Glue as tabelas e tabelas padrão em formatos de tabela aberta (OTF), como Hudi, Delta Lake e Iceberg, com dados subjacentes armazenados em locais do Amazon S3 registrados no Lake Formation, bem como as tabelas federadas do compartilhamento de dados do Amazon Redshift que são compartilhadas com o Lake Formation. As tabelas podem ter qualquer formato de arquivo, desde que o mecanismo usado para consultar a visualização seja compatível com esse formato. Você também pode fazer referência a funções integradas do mecanismo no qual elas são executadas, mas outros recursos específicos do mecanismo podem não ser permitidos. Para obter mais detalhes, consulte [Considerações e limitações das visualizações do catálogo de dados](views-notes.md)
## Casos de uso
Os casos de uso importantes das visualizações do Catálogo de Dados são apresentados abaixo:
+ Criar e gerenciar permissões em um único esquema de visualização. Isso ajuda a evitar o risco de permissões inconsistentes em visualizações duplicadas criadas em vários mecanismos.
+ Conceda permissões aos usuários em uma visualização que faz referência a várias tabelas sem conceder permissões diretamente nas tabelas de referência subjacentes.
+ Obtenha a filtragem no nível de linha em tabelas que usam tags do LF (em que as tags do LF se disseminam em cascata somente até o nível da coluna) aplicando tags do LF nas visualizações e concedendo permissões baseadas em tags do LF aos usuários.
## Serviços de AWS análise compatíveis para visualizações
Os seguintes serviços de AWS análise oferecem suporte à criação de visualizações do Catálogo de Dados:
+ banco de dados de origem
+ Amazon Athena versão 3
+ Apache Spark no EMR Sem Servidor
+ Apache Spark na versão 5.0 AWS Glue
## Recursos adicionais do
É possível saber mais sobre o Catálogo de Dados neste guia do usuário, bem como nos seguintes recursos:
O vídeo a seguir demonstra como criar visualizações e consultá-las no Athena e no Amazon Redshift.
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/rFO2OoxVYxE?si=Z0qsyuvTp2ZJg-PL)
**Topics**
+ [Diferenciar visualizações do Catálogo de Dados de outros tipos de visualização](#diff-views)
+ [O que é uma visualização de programador?](#definer-view)
+ [Um framework para visualizações de vários dialetos](#multi-dialect)
+ [Integrar a permissões do Lake Formation](#lf-view-integ)
+ [Casos de uso](#views-use-cases)
+ [Serviços de AWS análise compatíveis para visualizações](#views-supported-engines)
+ [Recursos adicionais do](#views-addtional-resources)
+ [Pré-requisitos para criar visualizações](views-prereqs.md)
+ [Criar visualizações do Catálogo de Dados usando instruções DDL](create-views.md)
+ [Criando visualizações do Catálogo de Dados usando AWS Glue APIs](views-api-usage.md)
+ [Conceder permissões nas visualizações do catálogo de dados](grant-perms-views.md)
+ [Visões materializadas](materialized-views.md)
# Pré-requisitos para criar visualizações
+ Para criar visualizações no catálogo de dados, é necessário registrar os locais de dados subjacentes do Amazon S3 das tabelas de referência no Lake Formation. Para obter detalhes sobre o registro de dados no Lake Formation, consulte [Adicionar uma localização do Amazon S3 ao seu data lake](register-data-lake.md).
+ Somente perfis do IAM podem criar visualizações do Catálogo de Dados. Outras identidades do IAM não podem criar visualizações do catálogo de dados.
+ O perfil do IAM que define a visualização deve ter as seguintes permissões:
+ Permissão `SELECT` completa do Lake Formation com a opção `Grantable` em todas as tabelas de referência, com todas as colunas incluídas.
+ A permissão `CREATE_TABLE` do Lake Formation no banco de dados de destino em que as visualizações estão sendo criadas.
+ Uma política de confiança para que a Lake Formation e AWS Glue os serviços assumam a função.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "DataCatalogViewDefinerAssumeRole1",
"Effect": "Allow",
"Principal": {
"Service": [
"glue.amazonaws.com",
"lakeformation.amazonaws.com"
]
},
"Action": "sts:AssumeRole"
}
]
}
```
------
+ O objetivo: PassRole permissão para AWS Glue e Lake Formation.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "DataCatalogViewDefinerPassRole1",
"Action": [
"iam:PassRole"
],
"Effect": "Allow",
"Resource": "*",
"Condition": {
"StringEquals": {
"iam:PassedToService": [
"glue.amazonaws.com",
"lakeformation.amazonaws.com"
]
}
}
}
]
}
```
------
+ AWS Glue e permissões do Lake Formation.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"Glue:GetDatabase",
"Glue:GetDatabases",
"Glue:CreateTable",
"Glue:GetTable",
"Glue:GetTables",
"Glue:BatchGetPartition",
"Glue:GetPartitions",
"Glue:GetPartition",
"Glue:GetTableVersion",
"Glue:GetTableVersions",
"Glue:PassConnection",
"lakeFormation:GetDataAccess"
],
"Resource": "*"
}
]
}
```
------
+ Não é possível criar visualizações em um banco de dados que tenha a permissão `Super` ou `ALL` concedida ao grupo `IAMAllowedPrincipals`. Você pode revogar a permissão `Super` para o grupo `IAMAllowedPrincipals` em um banco de dados, consultar [Etapa 4: mude seus armazenamentos de dados para o modelo de permissões do Lake Formation](upgrade-glue-lake-formation.md#upgrade-glue-lake-formation-step4) ou criar um banco de dados com a caixa **Usar somente o controle de acesso do IAM para novas tabelas neste banco de dados** desmarcada em **Permissões padrão para tabelas recém-criadas**.
# Criar visualizações do Catálogo de Dados usando instruções DDL
Você pode criar AWS Glue Data Catalog visualizações usando editores SQL para Athena, Amazon Redshift e usando o/. AWS Glue APIs AWS CLI
Para criar uma visualização do Catálogo de Dados usando editores SQL, escolha Athena ou Redshift Spectrum e crie a visualização usando uma instrução `CREATE VIEW` da linguagem de definição de dados (DDL). Depois de criar uma visualização no dialeto do primeiro mecanismo, você pode usar uma instrução DDL `ALTER VIEW` do segundo mecanismo para adicionar os outros dialetos.
Ao definir as visualizações, é importante considerar o seguinte:
+ **Definir visualizações de vários dialetos**: quando você define uma visualização com vários dialetos, os esquemas dos diferentes dialetos devem corresponder. Cada dialeto SQL terá uma especificação de sintaxe ligeiramente diferente. A sintaxe da consulta que define a visualização do Catálogo de Dados deve ser resolvida exatamente na mesma lista de colunas, incluindo tipos e nomes, em todos os dialetos. Essas informações são armazenadas no `StorageDescriptor` da visualização. Os dialetos também devem fazer referência aos mesmos objetos subjacentes da tabela do Catálogo de Dados.
Para adicionar outro dialeto a uma visualização usando DDL, você pode usar a instrução `ALTER VIEW`. Se uma instrução `ALTER VIEW` tentar atualizar a definição da visualização, como modificar o descritor de armazenamento ou as tabelas subjacentes da visualização, a instrução vai gerar a mensagem de erro: “Input and existing storage descriptor mismatch”. Você pode usar operações de conversão de SQL para garantir que os tipos de coluna de visualização correspondam.
+ **Atualizar uma visualização**: para atualizar a visualização, você pode usar a API `UpdateTable`. Se você atualizar a visualização sem compatibilizar os descritores de armazenamento ou as tabelas de referência, poderá fornecer o sinalizador `FORCE` (consulte a documentação do SQL do mecanismo para obter a sintaxe). Depois de uma atualização forçada, a visualização assumirá a tabela `StorageDescriptor` forçada e a de referência. Qualquer DDL `ALTER VIEW` adicional deve corresponder aos valores modificados. Uma visualização que foi atualizada para ter dialetos incompatíveis terá o status “Obsoleto”. O status da visualização é visível no console do Lake Formation e usa a operação `GetTable`.
+ **Fazer referência a um tipo de coluna varchar como uma string**: não é possível converter um tipo de coluna varchar do Redshift Spectrum em uma string. Se uma visualização for criada no Redshift Spectrum com um tipo de coluna varchar e um dialeto subsequente tentar fazer referência a esse campo como uma string, o Catálogo de Dados a tratará como string sem a necessidade do sinalizador `FORCE`.
+ **Tratamento de campos de tipos complexos**: o Amazon Redshift trata todos os tipos complexos como [tipos SUPER](https://docs.aws.amazon.com/redshift/latest/dg/r_SUPER_type.html), enquanto o Athena especifica o tipo complexo. Se uma visualização tiver um campo de tipo `SUPER` e outro mecanismo fizer referência a essa coluna como um tipo complexo específico, como struct (`>`), o Catálogo de Dados presumirá que o campo seja do tipo complexo específico e o usará no descritor de armazenamento, sem exigir o sinalizador `Force`.
Para obter mais informações sobre a sintaxe para criar e gerenciar visualizações do catálogo de dados, consulte:
+ [Uso das visualizações do AWS Glue Data Catalog](https://docs.aws.amazon.com/athena/latest/ug/views-glue.html) no Guia do usuário do Amazon Athena.
+ [Glue Data Catalog view query syntax](https://docs.aws.amazon.com/athena/latest/ug/views-glue-ddl.html) no Guia do usuário do Amazon Athena.
+ [Creating views in the AWS Glue Data Catalog](https://docs.aws.amazon.com/redshift/latest/dg/data-catalog-views-overview.html) no Guia do desenvolvedor do banco de dados do Amazon Redshift.
Para obter mais informações sobre os comandos SQL relacionados a exibições no Data Catalog, consulte [CREATE EXTERNAL VIEW](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_EXTERNAL_VIEW.html), [ALTER EXTERNAL VIEW](https://docs.aws.amazon.com/redshift/latest/dg/r_ALTER_EXTERNAL_VIEW.html) e [DROP EXTERNAL VIEW](https://docs.aws.amazon.com/redshift/latest/dg/r_DROP_EXTERNAL_VIEW.html).
Após a criação de uma visualização do Catálogo de Dados, os respectivos detalhes ficam disponíveis no console do Lake Formation.
1. Selecione **Visualizações** no catálogo de dados no console do Lake Formation.
1. Uma lista das visualizações disponíveis é exibida na página de visualizações.
1. Selecione uma visualização na lista e a página de detalhes mostrará os atributos da visualização.
![\[A seção inferior contém cinco guias dispostas horizontalmente, e cada guia inclui as informações correspondentes.\]](http://docs.aws.amazon.com/pt_br/lake-formation/latest/dg/images/view-definition.png)
Schema
Selecione uma linha de `Column` e escolha **Editar tags do LF** para atualizar os valores das tags ou atribuir novas tags do LF.
Definições de SQL
É possível ver uma lista das definições de SQL disponíveis. Selecione **Adicionar definição de SQL** e escolha um mecanismo de consulta para adicionar uma definição de SQL. Selecione um mecanismo de consulta (Athena ou Amazon Redshift) na coluna `Edit definition` para atualizar as definições de SQL.
Tags do LF
Selecione **Editar tags do LF** para editar valores para uma tag ou atribuir novas tags. É possível usar tags do LF para conceder permissões nas visualizações.
Acesso entre contas
Você pode ver uma lista de Contas da AWS organizações e unidades organizacionais (OUs) com as quais você compartilhou a visualização do Catálogo de Dados.
Tabelas subjacentes
As tabelas subjacentes referenciadas na definição de SQL usada para criar a exibição são mostradas nessa guia.
# Criando visualizações do Catálogo de Dados usando AWS Glue APIs
Você pode usar AWS Glue [CreateTable](https://docs.aws.amazon.com/glue/latest/webapi/API_CreateTable.html)e [UpdateTable](https://docs.aws.amazon.com/glue/latest/webapi/API_UpdateTable.html) APIs para criar e atualizar exibições no Catálogo de Dados. As operações `CreateTable` e `UpdateTable` têm uma nova estrutura de `TableInput` para `ViewDefinition`, enquanto as operações `SearchTables`, `GetTable`, `GetTables`, `GetTableVersion` e `GetTableVersions` fornecem a `ViewDefinition` na respectiva sintaxe de saída para as visualizações. Além disso, há um novo campo de `Status` na saída da API `GetTable`.
Duas novas AWS Glue conexões estão disponíveis para validar o dialeto SQL para cada mecanismo de consulta compatível Amazon Athena e para o Amazon Redshift.
Os `CreateTable` e `UpdateTable` APIs são assíncronos quando usados com visualizações. Quando eles APIs são chamados com vários dialetos SQL, a chamada é validada com cada mecanismo para determinar se o dialeto pode ser executado nesse mecanismo e se o esquema resultante da visualização de cada dialeto corresponde. O AWS Glue serviço usa essas conexões para fazer chamadas internas para os mecanismos analíticos. Essas chamadas simulam o que o mecanismo faz para validar se uma instrução DDL SQL `CREATE VIEW` ou `ALTER VIEW` foi executada no mecanismo.
Se o SQL fornecido for válido e os esquemas corresponderem entre os dialetos de visualização, a API do AWS Glue confirmará atomicamente o resultado. A atomicidade permite que visualizações com vários dialetos sejam criadas ou alteradas sem nenhum tempo de inatividade.
**Topics**
+ [Criação de AWS Glue conexões para validar o status](views-api-usage-connection.md)
+ [Validar o status de geração de visualizações](views-api-usage-get-table.md)
+ [Estados e operações assíncronos](views-api-usage-async-states.md)
+ [Cenários de falha na criação de visualizações durante operações assíncronas](views-api-usage-errors.md)
# Criação de AWS Glue conexões para validar o status
Para criar ou atualizar uma AWS Glue Data Catalog visualização usando as `UpdateTable` operações `CreateTable` ou, você deve criar um novo tipo de AWS Glue conexão para validação e fornecê-lo ao mecanismo de análise compatível. Essas conexões são necessárias para usar as visualizações do Catálogo de Dados com o Athena ou o Amazon Redshift. Você pode criar essas conexões somente usando o AWS CLI, AWS SDKs, ou AWS Glue APIs. Você não pode usar o Console de gerenciamento da AWS para criar a AWS Glue conexão.
**nota**
Se o perfil do programador de visualizações e o perfil que chama `CreateTable` ou `UpdateTable` forem diferentes, ambos precisarão da permissão `glue:PassConnection` na declaração de política do IAM.
Para obter mais informações, consulte a documentação de [criação de conexão](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/glue/create-connection.html) AWS CLI .
**AWS CLI comando para criar uma conexão**
Veja a seguir um AWS CLI comando para criar uma conexão:
```
aws glue create-connection --region us-east-1
--endpoint-url https://glue.us-east-1.amazonaws.com
--cli-input-json file:///root/path/to/create-connection.json
```
**AWS CLI entrada JSON**
Para Amazon Redshift:
```
{
"CatalogId": "123456789012",
"ConnectionInput": {
"ConnectionType": "VIEW_VALIDATION_REDSHIFT",
"Name": "views-preview-cluster-connection-2",
"Description": "My first Amazon Redshift validation connection",
"ConnectionProperties": {
"DATABASE": "dev",
"CLUSTER_IDENTIFIER": "glue-data-catalog-views-preview-cluster"
}
}
}
```
Para Amazon Athena:
```
{
"CatalogId": "123456789012",
"ConnectionInput": {
"ConnectionType": "VIEW_VALIDATION_ATHENA",
"Name": "views-preview-cluster-connection-3",
"Description": "My first Amazon Athena validation connection",
"ConnectionProperties": {
"WORKGROUP_NAME": "workgroup-name"
}
}
}
```
# Validar o status de geração de visualizações
Quando você executa as operações `CreateTable` ou `UpdateTable`, o campo `Status` da saída da API `GetTable` mostra os detalhes do status de criação da visualização. Para `create` solicitações em que a tabela ainda não existe, AWS Glue cria uma tabela vazia durante o processo assíncrono. Ao chamar `GetTable`, você pode passar um sinalizador booliano `IncludeStatusDetails` opcional, que mostra informações de diagnóstico sobre a solicitação. No caso de uma falha, esse sinalizador mostra uma mensagem de erro com o status individual de cada dialeto.
Erros durante as operações de criação, leitura, atualização e exclusão de visualizações (CRUD) podem ocorrer durante o processamento no serviço AWS Glue/Lake Formation ou durante a validação do SQL de visualização no Amazon Redshift ou no Athena. Quando ocorre um erro durante a validação em um mecanismo, o serviço AWS Glue apresenta a mensagem de erro que o mecanismo exibe.
**Campos de status**
Estes são os campos de status:
+ Status (um status genérico, que se aplica a diferentes tipos de trabalho):
+ QUEUED
+ IN\$1PROGRESS
+ SUCCESS
+ FAILED
+ Action: indica qual ação foi chamada na tabela. No momento, somente as operações `CREATE` ou `UPDATE` estão disponíveis.
Distinguir entre as operações `UPDATE` e `CREATE` é importante ao trabalhar com visualizações. O tipo de operação determina como você deve prosseguir com a consulta das tabelas.
Uma operação `UPDATE` significa que a tabela já existe no Catálogo de Dados. Nesse caso, você pode continuar consultando a tabela criada anteriormente sem problemas. Entretanto, uma operação `CREATE `indica que a tabela nunca foi criada com sucesso. Se uma tabela estiver marcada como `CREATE`, a tentativa de consultá-la falhará porque ela ainda não existe no sistema. Portanto, é essencial identificar o tipo de operação (UPDATE ou CREATE) antes de tentar consultar uma tabela.
+ RequestedBy — O ARN do usuário que solicitou a alteração assíncrona.
+ UpdatedBy — O ARN do usuário que alterou manualmente pela última vez o processo de alteração assíncrona, como solicitar um cancelamento ou modificação.
+ Error: este campo só aparece quando o estado é **FAILED**. Essa é uma mensagem de exceção no nível principal. Pode haver erros diferentes para cada dialeto.
+ ErrorCode — O tipo de exceção.
+ ErrorMessage — uma breve descrição da exceção.
+ RequestTime — uma string de data formatada em ISO 8601 indicando a hora em que a alteração foi iniciada.
+ UpdateTime — uma string de data formatada em ISO 8601 indicando a hora em que o estado foi atualizado pela última vez.
# Estados e operações assíncronos
Quando você executa uma solicitação `glue:CreateTable`, a criação assíncrona da visualização do Catálogo de Dados inicia-se. Nas seções a seguir, este documento descreve `Status` a AWS Glue visão que está disponível em uma `glue:GetTable` resposta. Por motivo de brevidade, esta seção omite a resposta completa.
```
{
"Table": {
...
"Status": {
...
"Action": "CREATE",
"State": "QUEUED",
}
}
}
```
Ambos os atributos acima representam informações importantes de diagnóstico que indicam o estado da operação assíncrona, bem como as ações que podem ser executadas nessa visualização. Abaixo estão os valores possíveis que esses atributos podem assumir.
1. `Status.Action`
1. CREATE
1. UPDATE
1. `Status.State`
1. QUEUED
1. IN\$1PROGRESS
1. SUCCESS
1. FAILED
Também é importante observar que algumas atualizações em uma visualização do Catálogo de Dados não exigem uma operação assíncrona. Por exemplo, para atualizar o atributo `Description` da tabela. Como isso não requer nenhuma operação assíncrona, os metadados da tabela resultante não terão nenhum `Status`, e o atributo será `NULL`.
```
{
"Table": {
...,
"Description": "I changed this attribute!"
}
}
```
A seguir, este tópico explora como as informações de status acima podem afetar as operações que podem ser executadas em uma AWS Glue exibição.
**cola: CreateTable**
Não há alterações nessa API em comparação com a forma como `glue:CreateTable` funciona para qualquer tabela do Glue. É possível chamar `CreateTable` para qualquer nome de tabela que ainda não exista.
**cola: UpdateTable**
Essa operação não pode ser executada em uma AWS Glue exibição que tenha as seguintes informações de status:
1. Action == CREATE e State == QUEUED
1. Action == CREATE e State == IN\$1PROGRESS
1. Action == CREATE e State == FAILED
1. Action == UPDATE e State == QUEUED
1. Action == UPDATE e State == IN\$1PROGRESS
Resumindo, você pode atualizar uma visualização do Catálogo de Dados somente quando ela atender aos requisitos a seguir.
1. Foi criada com sucesso pela primeira vez.
1. Action == CREATE e State == SUCCESS
1. Atingiu um estado final após uma operação de atualização assíncrona.
1. Action == UPDATE e State == SUCCESS
1. Action == UPDATE e State == FAILED
1. Tem um atributo de estado `NULL` em decorrência de uma atualização síncrona.
**cola: DeleteTable**
Não há alterações nessa operação quando comparada à forma como `glue:DeleteTable` funciona em qualquer AWS Glue tabela. Você pode excluir uma visualização do Catálogo de Dados, independentemente do respectivo estado.
**cola: GetTable**
Não há alterações nessa operação quando comparada à forma como `glue:GetTable` funciona em qualquer AWS Glue tabela. No entanto, não é possível consultar uma visualização do Catálogo de Dados nos mecanismos analíticos enquanto ela não for criada com sucesso pela primeira vez. `Action == CREATE and State == SUCCESS`. Depois de criar uma visualização do Catálogo de Dados com sucesso pela primeira vez, você pode consultar a visualização, independentemente do respectivo status.
**nota**
Todas as informações nesta seção se aplicam a todas as tabelas lidas `GetTable``GetTables`, APIs como, `SearchTables` e.
# Cenários de falha na criação de visualizações durante operações assíncronas
Os exemplos a seguir são representativos dos tipos de erro que podem resultar das chamadas de API `CreateTable` ou `UpdateTable` da visualização. Eles não são completos, pois a superfície de erro das falhas de consultas SQL é muito grande.
## Cenário 1: falha na consulta do Amazon Redshift
A consulta fornecida para o Amazon Redshift inclui um nome de tabela com erro de ortografia que não pode ser encontrado no Catálogo de Dados durante a validação. O erro resultante é mostrado no campo `Status` na resposta `GetTable` da visualização.
Solicitação `GetTable`:
```
{
"CatalogId": "123456789012",
"DatabaseName": "async-view-test-db",
"TableInput": {
"Name": "view-athena-redshift-72",
"Description": "This is an atomic operation",
"StorageDescriptor": {
"Columns": [
{ "Name": "col1", "Type": "int" },
{ "Name": "col2", "Type": "string" },
{ "Name": "col3", "Type": "double" }
]
},
"ViewDefinition": {
"Definer": "arn:aws:iam::123456789012:role/GDCViewDefiner",
"SubObjects": [ "arn:aws:glue:us-east-1:123456789012:table/gdc-view-playground-db/table_1" ],
"Representations": [
{
"Dialect": "ATHENA",
"DialectVersion": "3",
"ViewOriginalText": "SELECT * FROM \"gdc-view-playground-db\".\"table_1\"",
"ValidationConnection": "athena-connection"
},
{
"Dialect": "REDSHIFT",
"DialectVersion": "1.0",
"ViewOriginalText": "SELECT * FROM \"gdc-view-playground-external-schema\".\"table__1\";",
"ValidationConnection": "redshift-connection"
}
]
}
}
}
```
Resposta `GetTable`:
```
IncludeStatusDetails = FALSE
{
"Table": {
"Name": "view-athena-redshift-72",
"DatabaseName": "async-view-test-db",
"Description": "",
"CreateTime": "2024-07-11T11:39:19-07:00",
"UpdateTime": "2024-07-11T11:39:19-07:00",
"Retention": 0,
"ViewOriginalText": "",
"ViewExpandedText": "",
"TableType": "",
"CreatedBy": "arn:aws:iam::123456789012:user/zcaisse",
"IsRegisteredWithLakeFormation": false,
"CatalogId": "123456789012",
"IsRowFilteringEnabled": false,
"VersionId": "-1",
"DatabaseId": "",
"IsMultiDialectView": false,
"Status": {
"RequestedBy": "arn:aws:iam::123456789012:user/zcaisse",
"UpdatedBy": "arn:aws:iam::123456789012:user/zcaisse",
"RequestTime": "2024-07-11T11:39:19-07:00",
"UpdateTime": "2024-07-11T11:40:06-07:00",
"Action": "CREATE",
"State": "FAILED"
}
}
}
IncludeStatusDetails = TRUE
{
"Table": {
"Name": "view-athena-redshift-72",
"DatabaseName": "async-view-test-db",
"Description": "",
"CreateTime": "2024-07-11T11:39:19-07:00",
"UpdateTime": "2024-07-11T11:39:19-07:00",
"Retention": 0,
"ViewOriginalText": "",
"ViewExpandedText": "",
"TableType": "",
"CreatedBy": "arn:aws:iam::123456789012:user/zcaisse",
"IsRegisteredWithLakeFormation": false,
"CatalogId": "123456789012",
"IsRowFilteringEnabled": false,
"VersionId": "-1",
"DatabaseId": "",
"IsMultiDialectView": false,
"Status": {
"RequestedBy": "arn:aws:iam::123456789012:user/zcaisse",
"UpdatedBy": "arn:aws:iam::123456789012:user/zcaisse",
"RequestTime": "2024-07-11T11:39:19-07:00",
"UpdateTime": "2024-07-11T11:40:06-07:00",
"Action": "CREATE",
"State": "FAILED",
"Error": {
"ErrorCode": "QueryExecutionException",
"ErrorMessage": "Error received during view SQL validation using a connection: [Connection Name: redshift-connection | Query Execution Id: ddb711d3-2415-4aa9-b251-6a76ab4f41b1 | Timestamp: Thu Jul 11 18:39:37 UTC 2024]: Redshift returned error for the statement: ERROR: AwsClientException: EntityNotFoundException from glue - Entity Not Found"
},
"Details": {
"RequestedChange": {
"Name": "view-athena-redshift-72",
"DatabaseName": "async-view-test-db",
"Description": "This is an atomic operation",
"Retention": 0,
"StorageDescriptor": {
"Columns": [
{
"Name": "col1",
"Type": "int"
},
{
"Name": "col2",
"Type": "string"
},
{
"Name": "col3",
"Type": "double"
}
],
"Compressed": false,
"NumberOfBuckets": 0,
"SortColumns": [],
"StoredAsSubDirectories": false
},
"TableType": "VIRTUAL_VIEW",
"IsRegisteredWithLakeFormation": false,
"CatalogId": "123456789012",
"IsRowFilteringEnabled": false,
"VersionId": "-1",
"DatabaseId": "",
"ViewDefinition": {
"IsProtected": true,
"Definer": "arn:aws:iam::123456789012:role/GDCViewDefiner",
"SubObjects": [
"arn:aws:glue:us-east-1:123456789012:table/gdc-view-playground-db/table_1"
],
"Representations": [
{
"Dialect": "ATHENA",
"DialectVersion": "3",
"ViewOriginalText": "SELECT * FROM \"gdc-view-playground-db\".\"table_1\"",
"IsStale": false
},
{
"Dialect": "REDSHIFT",
"DialectVersion": "1.0",
"ViewOriginalText": "SELECT * FROM \"gdc-view-playground-external-schema\".\"table__1\";",
"IsStale": false
}
]
},
"IsMultiDialectView": true
},
"ViewValidations": [
{
"Dialect": "ATHENA",
"DialectVersion": "3",
"ViewValidationText": "SELECT * FROM \"gdc-view-playground-db\".\"table_1\"",
"UpdateTime": "2024-07-11T11:40:06-07:00",
"State": "SUCCESS"
},
{
"Dialect": "REDSHIFT",
"DialectVersion": "1.0",
"ViewValidationText": "SELECT * FROM \"gdc-view-playground-external-schema\".\"table__1\";",
"UpdateTime": "2024-07-11T11:39:37-07:00",
"State": "FAILED",
"Error": {
"ErrorCode": "QueryExecutionException",
"ErrorMessage": "Error received during view SQL validation using a connection: [Connection Name: redshift-connection | Query Execution Id: ddb711d3-2415-4aa9-b251-6a76ab4f41b1 | Timestamp: Thu
Jul 11 18:39:37 UTC 2024]: Redshift returned error for the statement: ERROR: AwsClientException: EntityNotFoundException from glue - Entity Not Found"
}
}
]
}
}
}
}
```
## Cenário 2: conexão inválida do Amazon Redshift
A conexão do Amazon Redshift no exemplo a seguir está malformada porque se refere a um banco de dados do Amazon Redshift que não existe no endpoint fornecido. cluster/serverless O Amazon Redshift não consegue validar a visualização e o campo `Status` na resposta `GetTable` mostra o erro `"State": "FAILED"` do Amazon Redshift).
Solicitação `GetTable`:
```
{
"CatalogId": "123456789012",
"DatabaseName": "async-view-test-db",
"TableInput": {
"Name": "view-athena-redshift-73",
"Description": "This is an atomic operation",
"StorageDescriptor": {
"Columns": [
{ "Name": "col1", "Type": "int" },
{ "Name": "col2", "Type": "string" },
{ "Name": "col3", "Type": "double" }
]
},
"ViewDefinition": {
"Definer": "arn:aws:iam::123456789012:role/GDCViewDefiner",
"SubObjects": [ "arn:aws:glue:us-east-1:123456789012:table/gdc-view-playground-db/table_1" ],
"Representations": [
{
"Dialect": "ATHENA",
"DialectVersion": "3",
"ViewOriginalText": "SELECT * FROM \"gdc-view-playground-db\".\"table_1\"",
"ValidationConnection": "athena-connection"
},
{
"Dialect": "REDSHIFT",
"DialectVersion": "1.0",
"ViewOriginalText": "SELECT * FROM \"gdc-view-playground-external-schema\".\"table_1\";",
"ValidationConnection": "redshift-connection-malformed"
}
]
}
}
}
```
Resposta `GetTable`:
```
IncludeStatusDetails = FALSE
{
"Table": {
"Name": "view-athena-redshift-73",
"DatabaseName": "async-view-test-db",
"Description": "",
"CreateTime": "2024-07-11T11:43:27-07:00",
"UpdateTime": "2024-07-11T11:43:27-07:00",
"Retention": 0,
"ViewOriginalText": "",
"ViewExpandedText": "",
"TableType": "",
"CreatedBy": "arn:aws:iam::123456789012:user/zcaisse",
"IsRegisteredWithLakeFormation": false,
"CatalogId": "123456789012",
"IsRowFilteringEnabled": false,
"VersionId": "-1",
"DatabaseId": "",
"IsMultiDialectView": false,
"Status": {
"RequestedBy": "arn:aws:iam::123456789012:user/zcaisse",
"UpdatedBy": "arn:aws:iam::123456789012:user/zcaisse",
"RequestTime": "2024-07-11T11:43:27-07:00",
"UpdateTime": "2024-07-11T11:43:40-07:00",
"Action": "CREATE",
"State": "FAILED"
}
}
}
IncludeStatusDetails = TRUE
{
"Table": {
"Name": "view-athena-redshift-73",
"DatabaseName": "async-view-test-db",
"Description": "",
"CreateTime": "2024-07-11T11:43:27-07:00",
"UpdateTime": "2024-07-11T11:43:27-07:00",
"Retention": 0,
"ViewOriginalText": "",
"ViewExpandedText": "",
"TableType": "",
"CreatedBy": "arn:aws:iam::123456789012:user/zcaisse",
"IsRegisteredWithLakeFormation": false,
"CatalogId": "123456789012",
"IsRowFilteringEnabled": false,
"VersionId": "-1",
"DatabaseId": "",
"IsMultiDialectView": false,
"Status": {
"RequestedBy": "arn:aws:iam::123456789012:user/zcaisse",
"UpdatedBy": "arn:aws:iam::123456789012:user/zcaisse",
"RequestTime": "2024-07-11T11:43:27-07:00",
"UpdateTime": "2024-07-11T11:43:40-07:00",
"Action": "CREATE",
"State": "FAILED",
"Error": {
"ErrorCode": "QueryExecutionException",
"ErrorMessage": "Error received during view SQL validation using a connection: [Connection Name: redshift-connection-malformed | Query Execution Id: 69bfafd4-3d51-4cb0-9320-7ce5404b1809 | Timestamp: Thu Jul 11 18:43:38 UTC 2024]: Redshift returned error for the statement: FATAL: database \"devooo\" does not exist"
},
"Details": {
"RequestedChange": {
"Name": "view-athena-redshift-73",
"DatabaseName": "async-view-test-db",
"Description": "This is an atomic operation",
"Retention": 0,
"StorageDescriptor": {
"Columns": [
{
"Name": "col1",
"Type": "int"
},
{
"Name": "col2",
"Type": "string"
},
{
"Name": "col3",
"Type": "double"
}
],
"Compressed": false,
"NumberOfBuckets": 0,
"SortColumns": [],
"StoredAsSubDirectories": false
},
"TableType": "VIRTUAL_VIEW",
"IsRegisteredWithLakeFormation": false,
"CatalogId": "123456789012",
"IsRowFilteringEnabled": false,
"VersionId": "-1",
"DatabaseId": "",
"ViewDefinition": {
"IsProtected": true,
"Definer": "arn:aws:iam::123456789012:role/GDCViewDefiner",
"SubObjects": [
"arn:aws:glue:us-east-1:123456789012:table/gdc-view-playground-db/table_1"
],
"Representations": [
{
"Dialect": "ATHENA",
"DialectVersion": "3",
"ViewOriginalText": "SELECT * FROM \"gdc-view-playground-db\".\"table_1\"",
"IsStale": false
},
{
"Dialect": "REDSHIFT",
"DialectVersion": "1.0",
"ViewOriginalText": "SELECT * FROM \"gdc-view-playground-external-schema\".\"table_1\";",
"IsStale": false
}
]
},
"IsMultiDialectView": true
},
"ViewValidations": [
{
"Dialect": "ATHENA",
"DialectVersion": "3",
"ViewValidationText": "SELECT * FROM \"gdc-view-playground-db\".\"table_1\"",
"UpdateTime": "2024-07-11T11:43:40-07:00",
"State": "SUCCESS"
},
{
"Dialect": "REDSHIFT",
"DialectVersion": "1.0",
"ViewValidationText": "SELECT * FROM \"gdc-view-playground-external-schema\".\"table_1\";",
"UpdateTime": "2024-07-11T11:43:38-07:00",
"State": "FAILED",
"Error": {
"ErrorCode": "QueryExecutionException",
"ErrorMessage": "Error received during view SQL validation using a connection: [Connection Name: redshift-connection-malformed | Query Execution Id: 69bfafd4-3d51-4cb0-9320-7ce5404b1809 | Time
stamp: Thu Jul 11 18:43:38 UTC 2024]: Redshift returned error for the statement: FATAL: database \"devooo\" does not exist"
}
}
]
}
}
}
}
```
## Cenário 3: falha na consulta do Athena
Aqui, o SQL para o Athena é inválido porque a consulta digita incorretamente o nome do banco de dados. A validação da consulta do Athena detecta isso e o erro resultante aparece por meio do objeto `Status` em uma chamada `GetTable`.
Solicitação `GetTable`:
```
{
"CatalogId": "123456789012",
"DatabaseName": "async-view-test-db",
"TableInput": {
"Name": "view-athena-redshift-70",
"Description": "This is an atomic operation",
"StorageDescriptor": {
"Columns": [
{ "Name": "col1", "Type": "int" },
{ "Name": "col2", "Type": "string" },
{ "Name": "col3", "Type": "double" }
]
},
"ViewDefinition": {
"Definer": "arn:aws:iam::123456789012:role/GDCViewDefiner",
"SubObjects": [ "arn:aws:glue:us-east-1:123456789012:table/gdc-view-playground-db/table_1" ],
"Representations": [
{
"Dialect": "ATHENA",
"DialectVersion": "3",
"ViewOriginalText": "SELECT * FROM \"gdc--view-playground-db\".\"table_1\"",
"ValidationConnection": "athena-connection"
},
{
"Dialect": "REDSHIFT",
"DialectVersion": "1.0",
"ViewOriginalText": "SELECT * FROM \"gdc-view-playground-external-schema\".\"table_1\";",
"ValidationConnection": "redshift-connection"
}
]
}
}
}
```
Resposta `GetTable`:
```
IncludeStatusDetails = FALSE
{
"Table": {
"Name": "view-athena-redshift-70",
"DatabaseName": "async-view-test-db",
"Description": "",
"CreateTime": "2024-07-11T11:09:53-07:00",
"UpdateTime": "2024-07-11T11:09:53-07:00",
"Retention": 0,
"ViewOriginalText": "",
"ViewExpandedText": "",
"TableType": "",
"CreatedBy": "arn:aws:iam::123456789012:user/",
"IsRegisteredWithLakeFormation": false,
"CatalogId": "123456789012",
"IsRowFilteringEnabled": false,
"VersionId": "-1",
"DatabaseId": "",
"IsMultiDialectView": false,
"Status": {
"RequestedBy": "arn:aws:iam::123456789012:user/zcaisse",
"UpdatedBy": "arn:aws:iam::123456789012:user/zcaisse",
"RequestTime": "2024-07-11T11:09:54-07:00",
"UpdateTime": "2024-07-11T11:10:41-07:00",
"Action": "CREATE",
"State": "FAILED",
}
}
}
IncludeStatusDetails = TRUE
{
"Table": {
"Name": "view-athena-redshift-70",
"DatabaseName": "async-view-test-db",
"Description": "",
"CreateTime": "2024-07-11T11:09:53-07:00",
"UpdateTime": "2024-07-11T11:09:53-07:00",
"Retention": 0,
"ViewOriginalText": "",
"ViewExpandedText": "",
"TableType": "",
"CreatedBy": "arn:aws:iam::123456789012:user/zcaisse",
"IsRegisteredWithLakeFormation": false,
"CatalogId": "123456789012",
"IsRowFilteringEnabled": false,
"VersionId": "-1",
"DatabaseId": "",
"IsMultiDialectView": false,
"Status": {
"RequestedBy": "arn:aws:iam::123456789012:user/zcaisse",
"UpdatedBy": "arn:aws:iam::123456789012:user/zcaisse",
"RequestTime": "2024-07-11T11:09:54-07:00",
"UpdateTime": "2024-07-11T11:10:41-07:00",
"Action": "CREATE",
"State": "FAILED",
"Error": {
"ErrorCode": "QueryExecutionException",
"ErrorMessage": "Error received during view SQL validation using a connection: [Connection Name: athena-connection | Query Execution Id: d9bb1e6d-ce26-4b35-8276-8a199af966aa | Timestamp: Thu Jul 11 18:10:
41 UTC 2024]: Athena validation FAILED: {ErrorCategory: 2,ErrorType: 1301,Retryable: false,ErrorMessage: line 1:118: Schema 'gdc--view-playground-db' does not exist}"
},
"Details": {
"RequestedChange": {
"Name": "view-athena-redshift-70",
"DatabaseName": "async-view-test-db",
"Description": "This is an atomic operation",
"Retention": 0,
"StorageDescriptor": {
"Columns": [
{
"Name": "col1",
"Type": "int"
},
{
"Name": "col2",
"Type": "string"
},
{
"Name": "col3",
"Type": "double"
}
],
"Compressed": false,
"NumberOfBuckets": 0,
"SortColumns": [],
"StoredAsSubDirectories": false
},
"TableType": "VIRTUAL_VIEW",
"IsRegisteredWithLakeFormation": false,
"CatalogId": "123456789012",
"IsRowFilteringEnabled": false,
"VersionId": "-1",
"DatabaseId": "",
"ViewDefinition": {
"IsProtected": true,
"Definer": "arn:aws:iam::123456789012:role/GDCViewDefiner",
"SubObjects": [
"arn:aws:glue:us-east-1:123456789012:table/gdc-view-playground-db/table_1"
],
"Representations": [
{
"Dialect": "ATHENA",
"DialectVersion": "3",
"ViewOriginalText": "SELECT * FROM \"gdc--view-playground-db\".\"table_1\"",
"IsStale": false
},
{
"Dialect": "REDSHIFT",
"DialectVersion": "1.0",
"ViewOriginalText": "SELECT * FROM \"gdc-view-playground-external-schema\".\"table_1\";",
"IsStale": false
}
]
},
"IsMultiDialectView": true
},
"ViewValidations": [
{
"Dialect": "ATHENA",
"DialectVersion": "3",
"ViewValidationText": "SELECT * FROM \"gdc--view-playground-db\".\"table_1\"",
"UpdateTime": "2024-07-11T11:10:41-07:00",
"State": "FAILED",
"Error": {
"ErrorCode": "QueryExecutionException",
"ErrorMessage": "Error received during view SQL validation using a connection: [Connection Name: athena-connection | Query Execution Id: d9bb1e6d-ce26-4b35-8276-8a199af966aa | Timestamp: Thu J
ul 11 18:10:41 UTC 2024]: Athena validation FAILED: {ErrorCategory: 2,ErrorType: 1301,Retryable: false,ErrorMessage: line 1:118: Schema 'gdc--view-playground-db' does not exist}"
}
},
{
"Dialect": "REDSHIFT",
"DialectVersion": "1.0",
"ViewValidationText": "SELECT * FROM \"gdc-view-playground-external-schema\".\"table_1\";",
"UpdateTime": "2024-07-11T11:10:41-07:00",
"State": "SUCCESS"
}
]
}
}
}
}
```
## Cenário 4: descritores de armazenamento incompatíveis
O SQL fornecido para o dialeto do Athena seleciona `col1` e `col2`, enquanto o SQL para o Redshift seleciona somente `col1`. Isso provoca um erro de incompatibilidade do descritor de armazenamento.
Solicitação `GetTable`:
```
{
"CatalogId": "123456789012",
"DatabaseName": "async-view-test-db",
"TableInput": {
"Name": "view-athena-redshift-71",
"Description": "This is an atomic operation",
"StorageDescriptor": {
"Columns": [
{ "Name": "col1", "Type": "int" },
{ "Name": "col2", "Type": "string" },
{ "Name": "col3", "Type": "double" }
]
},
"ViewDefinition": {
"Definer": "arn:aws:iam::123456789012:role/GDCViewDefiner",
"SubObjects": [ "arn:aws:glue:us-east-1:123456789012:table/gdc-view-playground-db/table_1" ],
"Representations": [
{
"Dialect": "ATHENA",
"DialectVersion": "3",
"ViewOriginalText": "SELECT col1, col2 FROM \"gdc-view-playground-db\".\"table_1\"",
"ValidationConnection": "athena-connection"
},
{
"Dialect": "REDSHIFT",
"DialectVersion": "1.0",
"ViewOriginalText": "SELECT col1 FROM \"gdc-view-playground-external-schema\".\"table_1\";",
"ValidationConnection": "redshift-connection"
}
]
}
}
}
```
Resposta `GetTable`:
```
IncludeStatusDetails = FALSE
{
"Table": {
"Name": "view-athena-redshift-71",
"DatabaseName": "async-view-test-db",
"Description": "",
"CreateTime": "2024-07-11T11:22:02-07:00",
"UpdateTime": "2024-07-11T11:22:02-07:00",
"Retention": 0,
"ViewOriginalText": "",
"ViewExpandedText": "",
"TableType": "",
"CreatedBy": "arn:aws:iam::123456789012:user/zcaisse",
"IsRegisteredWithLakeFormation": false,
"CatalogId": "123456789012",
"IsRowFilteringEnabled": false,
"VersionId": "-1",
"DatabaseId": "",
"IsMultiDialectView": false,
"Status": {
"RequestedBy": "arn:aws:iam::123456789012:user/zcaisse",
"UpdatedBy": "arn:aws:iam::123456789012:user/zcaisse",
"RequestTime": "2024-07-11T11:22:02-07:00",
"UpdateTime": "2024-07-11T11:23:19-07:00",
"Action": "CREATE",
"State": "FAILED"
}
}
}
IncludeStatusDetails = TRUE
{
"Table": {
"Name": "view-athena-redshift-71",
"DatabaseName": "async-view-test-db",
"Description": "",
"CreateTime": "2024-07-11T11:22:02-07:00",
"UpdateTime": "2024-07-11T11:22:02-07:00",
"Retention": 0,
"ViewOriginalText": "",
"ViewExpandedText": "",
"TableType": "",
"CreatedBy": "arn:aws:iam::123456789012:user/zcaisse",
"IsRegisteredWithLakeFormation": false,
"CatalogId": "123456789012",
"IsRowFilteringEnabled": false,
"VersionId": "-1",
"DatabaseId": "",
"IsMultiDialectView": false,
"Status": {
"RequestedBy": "arn:aws:iam::123456789012:user/zcaisse",
"UpdatedBy": "arn:aws:iam::123456789012:user/zcaisse",
"RequestTime": "2024-07-11T11:22:02-07:00",
"UpdateTime": "2024-07-11T11:23:19-07:00",
"Action": "CREATE",
"State": "FAILED",
"Error": {
"ErrorCode": "InvalidInputException",
"ErrorMessage": "Engine and existing storage descriptor mismatch"
},
"Details": {
"RequestedChange": {
"Name": "view-athena-redshift-71",
"DatabaseName": "async-view-test-db",
"Description": "This is an atomic operation",
"Retention": 0,
"StorageDescriptor": {
"Columns": [
{
"Name": "col1",
"Type": "int"
},
{
"Name": "col2",
"Type": "string"
},
{
"Name": "col3",
"Type": "double"
}
],
"Compressed": false,
"NumberOfBuckets": 0,
"SortColumns": [],
"StoredAsSubDirectories": false
},
"TableType": "VIRTUAL_VIEW",
"IsRegisteredWithLakeFormation": false,
"CatalogId": "123456789012",
"IsRowFilteringEnabled": false,
"VersionId": "-1",
"DatabaseId": "",
"ViewDefinition": {
"IsProtected": true,
"Definer": "arn:aws:iam::123456789012:role/GDCViewDefiner",
"SubObjects": [
"arn:aws:glue:us-east-1:123456789012:table/gdc-view-playground-db/table_1"
],
"Representations": [
{
"Dialect": "ATHENA",
"DialectVersion": "3",
"ViewOriginalText": "SELECT col1, col2 FROM \"gdc-view-playground-db\".\"table_1\"",
"IsStale": false
},
{
"Dialect": "REDSHIFT",
"DialectVersion": "1.0",
"ViewOriginalText": "SELECT col1 FROM \"gdc-view-playground-external-schema\".\"table_1\";",
"IsStale": false
}
]
},
"IsMultiDialectView": true
},
"ViewValidations": [
{
"Dialect": "ATHENA",
"DialectVersion": "3",
"ViewValidationText": "SELECT col1, col2 FROM \"gdc-view-playground-db\".\"table_1\"",
"UpdateTime": "2024-07-11T11:23:19-07:00",
"State": "FAILED",
"Error": {
"ErrorCode": "InvalidInputException",
"ErrorMessage": "Engine and existing storage descriptor mismatch"
}
},
{
"Dialect": "REDSHIFT",
"DialectVersion": "1.0",
"ViewValidationText": "SELECT col1 FROM \"gdc-view-playground-external-schema\".\"table_1\";",
"UpdateTime": "2024-07-11T11:22:49-07:00",
"State": "FAILED",
"Error": {
"ErrorCode": "InvalidInputException",
"ErrorMessage": "Engine and existing storage descriptor mismatch"
}
}
]
}
}
}
}
```
# Conceder permissões nas visualizações do catálogo de dados
Depois de criar visualizações no AWS Glue Data Catalog, você pode conceder permissões de data lake em visualizações a diretores de todas Contas da AWS as organizações e unidades organizacionais. É possível conceder permissões usando tags do LF ou o método de recurso nomeado. Para obter mais informações sobre os recursos de tag, consulte [Controle de acesso baseado em tags do Lake Formation](tag-based-access-control.md). Para obter mais informações sobre como conceder permissões a visualizações diretamente, consulte [Conceder permissões em visualizações usando o método de recurso nomeado](granting-view-permissions.md).
# Visões materializadas
**Topics**
+ [Diferenciando visualizações materializadas de outros tipos de visualização](#materialized-views-differentiating)
+ [Casos de uso](#materialized-views-use-cases)
+ [Principais conceitos](#materialized-views-key-concepts)
+ [Permissões para visões materializadas](#materialized-views-permissions)
+ [Criação e gerenciamento de visualizações materializadas](#materialized-views-creating-managing)
+ [Armazenamento e acesso aos dados](#materialized-views-storage-access)
+ [Integração com permissões AWS Lake Formation](#materialized-views-lake-formation)
+ [Monitoramento e depuração](#materialized-views-monitoring-debugging)
+ [Gerenciando trabalhos de atualização](#materialized-views-managing-refresh-jobs)
+ [Monitoramento e solução de problemas](#materialized-views-monitoring-troubleshooting)
+ [Considerações e limitações](#materialized-views-considerations-limitations)
No Catálogo de AWS Glue Dados, uma visualização materializada é uma tabela gerenciada que armazena o resultado pré-computado de uma consulta SQL no formato Apache Iceberg. Diferentemente das visualizações padrão do Catálogo de Dados que executam a consulta sempre que são acessadas, as visualizações materializadas armazenam fisicamente os resultados da consulta e os atualizam à medida que as tabelas de origem subjacentes mudam. Você pode criar visualizações materializadas usando o Apache Spark versão 3.5.6\$1 no Amazon Athena, Amazon EMR ou. AWS Glue
As visualizações materializadas fazem referência às tabelas do Apache Iceberg registradas no catálogo de dados, com AWS Glue dados pré-computados armazenados como tabelas do Apache Iceberg em buckets do Amazon S3 Tables ou buckets de uso geral do Amazon S3, tornando-os acessíveis a partir de vários mecanismos de consulta, incluindo Amazon Athena, Amazon Redshift e mecanismos de terceiros compatíveis com o Iceberg.
## Diferenciando visualizações materializadas de outros tipos de visualização
As visualizações materializadas diferem das visualizações do catálogo de AWS Glue dados, das visualizações do Apache Spark e das visualizações do Amazon Athena de maneiras fundamentais. Embora as visualizações do Catálogo de Dados sejam tabelas virtuais que executam a definição da consulta SQL sempre que são acessadas, as visualizações materializadas armazenam fisicamente os resultados pré-computados da consulta. Isso elimina a computação redundante e melhora significativamente o desempenho da consulta para transformações complexas acessadas com frequência.
As visualizações materializadas também diferem dos pipelines tradicionais de transformação de dados criados com AWS Glue ETL ou tarefas personalizadas do Spark. Em vez de escrever código personalizado para lidar com a detecção de alterações, atualizações incrementais e orquestração do fluxo de trabalho, você define visualizações materializadas usando a sintaxe SQL padrão. O Catálogo AWS Glue de Dados monitora automaticamente as tabelas de origem, detecta alterações e atualiza as visualizações materializadas usando uma infraestrutura computacional totalmente gerenciada.
## Casos de uso
Veja a seguir casos de uso importantes para visualizações materializadas:
+ **Acelere consultas analíticas complexas** — crie visualizações materializadas que pré-computam junções, agregações e funções de janela caras. Os mecanismos do Spark reescrevem automaticamente as consultas subsequentes para usar os resultados pré-computados, reduzindo a latência da consulta e os custos de computação.
+ **Simplifique os pipelines de transformação de dados** — substitua tarefas complexas de ETL que lidam com detecção de alterações, atualizações incrementais e orquestração de fluxo de trabalho por definições simples de visualização materializada baseadas em SQL. O Catálogo AWS Glue de Dados gerencia toda a complexidade operacional automaticamente.
+ **Habilite análises de autoatendimento com acesso controlado aos dados** — Crie visualizações materializadas com curadoria que transformam dados brutos em conjuntos de dados prontos para uso comercial. Conceda aos usuários acesso a visualizações materializadas sem expor as tabelas de origem subjacentes, simplificando o gerenciamento da segurança e fortalecendo a análise de autoatendimento.
+ **Otimize a engenharia de recursos para aprendizado de máquina** — defina visualizações materializadas que implementam transformações de recursos para modelos de ML. O recurso de atualização automática garante que os repositórios de recursos permaneçam atualizados à medida que os dados de origem evoluem, enquanto a atualização incremental minimiza os custos de computação.
+ **Implemente um compartilhamento eficiente de dados** — crie visualizações materializadas que filtram e transformam dados para consumidores específicos. Compartilhe visualizações materializadas entre contas e regiões usando AWS Lake Formation, eliminando a necessidade de duplicação de dados e mantendo a governança centralizada.
## Principais conceitos
### Atualização automática
A atualização automática é um recurso que monitora continuamente suas tabelas de origem e atualiza as visualizações materializadas de acordo com um cronograma definido por você. Ao criar uma visualização materializada, você pode especificar uma frequência de atualização usando uma programação baseada em tempo com intervalos de até uma hora. O Catálogo de AWS Glue Dados usa a infraestrutura computacional gerenciada do Spark para executar operações de atualização em segundo plano, lidando de forma transparente com todos os aspectos da detecção de alterações e atualizações incrementais.
Quando os dados de origem mudam entre os intervalos de atualização, a visualização materializada fica temporariamente obsoleta. As consultas que acessam diretamente a visualização materializada podem retornar resultados desatualizados até que a próxima atualização programada seja concluída. Para cenários que exigem acesso imediato aos dados mais atuais, você pode executar uma atualização manual usando o comando `REFRESH MATERIALIZED VIEW` SQL.
### Atualização incremental
A atualização incremental é uma técnica de otimização que processa somente os dados que foram alterados nas tabelas de origem desde a última atualização, em vez de recomputar toda a visualização materializada. O Catálogo de AWS Glue Dados aproveita a camada de metadados do Apache Iceberg para rastrear com eficiência as alterações nas tabelas de origem e determinar quais partes da visualização materializada precisam de atualizações.
Essa abordagem reduz significativamente os custos de computação e a duração da atualização em comparação com as operações de atualização completa, especialmente para grandes conjuntos de dados em que apenas uma pequena porcentagem dos dados é alterada entre os ciclos de atualização. O mecanismo de atualização incremental opera automaticamente; você não precisa escrever uma lógica personalizada para detectar ou processar dados alterados.
### Reescrita automática de consultas
A reescrita automática de consultas é um recurso de otimização de consultas disponível nos mecanismos do Spark no Amazon Athena, Amazon EMR e. AWS Glue Quando você executa uma consulta em tabelas base, o otimizador do Spark analisa seu plano de consulta e determina automaticamente se as visualizações materializadas disponíveis podem satisfazer a consulta com mais eficiência. Se existir uma visualização materializada adequada, o otimizador reescreve a consulta de forma transparente para usar os resultados pré-computados em vez de processar as tabelas base.
Essa otimização ocorre sem exigir nenhuma alteração no código do aplicativo ou nas instruções de consulta. O otimizador Spark garante que a reescrita automática de consultas só se aplique quando a visualização materializada estiver atualizada e puder produzir resultados precisos. Se uma visualização materializada estiver obsoleta ou não corresponder totalmente aos requisitos de consulta, o otimizador executa o plano de consulta original em relação às tabelas base, priorizando a correção em detrimento do desempenho.
### Exibir função do definidor
Uma visualização materializada opera com base nas permissões da função do IAM que a criou, conhecida como função definidora de visualizações. A função definidora deve ter acesso de leitura a todas as tabelas base referenciadas na definição da visualização materializada e criar permissões de tabela no banco de dados de destino. Quando o Catálogo de AWS Glue Dados atualiza uma exibição materializada, ele assume a função de definidor de acessar tabelas de origem e gravar resultados atualizados.
Esse modelo de segurança permite que você conceda aos usuários acesso às visualizações materializadas sem conceder a eles permissões diretas nas tabelas de origem subjacentes. Se a função do definidor de visualizações perder o acesso a qualquer tabela base, as operações de atualização subsequentes falharão até que as permissões sejam restauradas.
## Permissões para visões materializadas
Para criar e gerenciar visualizações materializadas, você deve configurar AWS Lake Formation as permissões. 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 AWS Glue dados — GetTable e nas permissões CreateTable da API
Quando você cria uma visão materializada, o ARN do perfil definidor é armazenado na definição da visão. O Catálogo AWS Glue de Dados assume essa função 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 AWS Glue trabalhos
A AWS Glue função do IAM do seu trabalho exige 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": "*"
}
]
}
```
A função que você usa para a atualização automática do Materialized View deve ter a PassRole permissão iam: na função.
```
{
"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",
"Principal": {
"Service": "glue.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
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 a outros usuários acesso para consultar uma visualização materializada, use AWS Lake Formation para conceder a permissão SELECT na tabela de visualizaçã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 AWS Lake Formation Desenvolvedor.
## Criação e gerenciamento de visualizações materializadas
Você cria visualizações materializadas usando a `CREATE MATERIALIZED VIEW` instrução SQL nos mecanismos do Spark. A definição da exibição especifica a consulta SQL que define a lógica de transformação, o nome do banco de dados e da tabela de destino e a configuração de atualização opcional. Você pode definir transformações complexas, incluindo agregações, junções em várias tabelas, filtros e funções de janela.
```
CREATE MATERIALIZED VIEW sales_summary
AS
SELECT
region,
product_category,
SUM(sales_amount) as total_sales,
COUNT(DISTINCT customer_id) as unique_customers
FROM sales_transactions
WHERE transaction_date >= current_date - interval '90' day
GROUP BY region, product_category;
```
Para configurar a atualização automática, inclua a agenda de atualização na sua definição de exibição:
```
CREATE MATERIALIZED VIEW sales_summary
SCHEDULE REFRESH EVERY 1 HOUR
AS
SELECT region, product_category, SUM(sales_amount) as total_sales
FROM sales_transactions
GROUP BY region, product_category;
```
Você pode atualizar manualmente uma visualização materializada a qualquer momento usando o `REFRESH MATERIALIZED VIEW` comando:
```
REFRESH MATERIALIZED VIEW sales_summary;
```
Para modificar o cronograma de atualização de uma visualização materializada existente, use a `ALTER MATERIALIZED VIEW` instrução:
```
ALTER MATERIALIZED VIEW sales_summary
ADD SCHEDULE REFRESH EVERY 2 HOURS;
```
### Visões materializadas aninhadas
Você pode criar visualizações materializadas que referenciem outras visualizações materializadas como tabelas base, permitindo transformações de dados em vários estágios. Quando você cria visualizações materializadas aninhadas, o Catálogo de AWS Glue Dados rastreia dependências e propaga automaticamente as atualizações por meio da hierarquia de visualizações materializadas. Quando uma visualização materializada básica é atualizada, todas as visualizações materializadas posteriores que dependem dela são atualizadas adequadamente.
Esse recurso permite que você decomponha transformações complexas em estágios lógicos, melhorando a capacidade de manutenção e permitindo a atualização seletiva das camadas de transformação com base em seus requisitos de atualização de dados.
## Armazenamento e acesso aos dados
As visualizações materializadas armazenam resultados pré-computados como tabelas Apache Iceberg em buckets S3 Tables ou buckets S3 de uso geral em sua conta. AWS O Catálogo AWS Glue de Dados gerencia todos os aspectos da manutenção da tabela Iceberg, incluindo compactação e retenção de instantâneos, por meio dos recursos de otimização automatizada do S3 Tables.
Como as visualizações materializadas são armazenadas como tabelas do Iceberg, você pode lê-las diretamente de qualquer mecanismo compatível com o Iceberg, incluindo Amazon Athena, Amazon Redshift e plataformas de análise de terceiros. Essa acessibilidade multimecanismo garante que seus dados pré-computados permaneçam acessíveis em todo o seu ecossistema de análise sem duplicação de dados ou conversão de formato.
## Integração com permissões AWS Lake Formation
Você pode usar AWS Lake Formation para gerenciar permissões refinadas em visualizações materializadas. O criador da visualização se torna automaticamente o proprietário da visualização materializada e pode conceder permissões a outros usuários ou funções usando o método AWS Lake Formation de recurso nomeado ou as tags LF.
Quando você concede `SELECT` permissão a um usuário em uma visualização materializada, ele pode consultar os resultados pré-computados sem precisar acessar as tabelas de origem subjacentes. Esse modelo de segurança simplifica o gerenciamento do acesso aos dados e permite que você implemente o princípio do menor privilégio, fornecendo aos usuários acesso somente às transformações de dados específicas de que precisam.
Você pode compartilhar visualizações materializadas entre AWS contas, AWS organizações e unidades organizacionais usando os recursos de compartilhamento entre contas AWS Lake Formation da. Você também pode acessar visualizações materializadas em todas AWS as regiões usando links de recursos, permitindo a governança centralizada de dados com acesso distribuído aos dados.
## Monitoramento e depuração
O Catálogo AWS Glue de Dados publica todas as operações de atualização de visualizações materializadas e métricas associadas na Amazon. CloudWatch Você pode monitorar a hora de início, a hora de término, a duração, o volume de dados processados e o status da atualização por meio CloudWatch de métricas. Quando as operações de atualização falham, as mensagens de erro e as informações de diagnóstico são capturadas nos CloudWatch registros.
Você pode configurar CloudWatch alarmes para receber notificações quando os trabalhos de atualização excederem a duração esperada ou falharem repetidamente. O Catálogo de AWS Glue Dados também publica eventos de alteração para execuções de atualização bem-sucedidas e malsucedidas, permitindo que você integre operações de visualização materializada em uma automação mais ampla do fluxo de trabalho.
Para verificar o status atual de uma visualização materializada, use o comando `DESCRIBE MATERIALIZED VIEW` SQL, que retorna metadados, incluindo status de inatividade, data e hora da última atualização e configuração do cronograma de atualização.
## Gerenciando trabalhos de atualização
### Iniciando uma atualização manual
Acione uma atualização imediata fora do intervalo programado.
Permissão necessária: AWS as credenciais usadas para fazer a chamada à API devem ter `glue:GetTable` permissão para a visualização materializada.
Para o catálogo de tabelas do S3:
```
aws glue start-materialized-view-refresh-task-run \
--catalog-id :s3tablescatalog/ \
--database-name \
--table-name
```
Para o Root Catalog:
```
aws glue start-materialized-view-refresh-task-run \
--catalog-id \
--database-name \
--table-name
```
### Verificando o status da atualização
Obtenha o status de um trabalho de atualização específico:
```
aws glue get-materialized-view-refresh-task-run \
--catalog-id \
--materialized-view-refresh-task-run-id
```
### Histórico de atualização da lista
Visualize todas as tarefas de atualização de uma visão materializada:
```
aws glue list-materialized-view-refresh-task-runs \
--catalog-id \
--database-name \
--table-name
```
**nota**
Use `:s3tablescatalog/` para tabelas S3 ou `` para catálogo raiz.
### Interrompendo uma atualização em execução
Cancelar um trabalho de atualização em andamento:
```
aws glue stop-materialized-view-refresh-task-run \
--catalog-id \
--database-name \
--table-name
```
## Monitoramento e solução de problemas
Há três maneiras de monitorar as tarefas de atualização de visualizações materializadas:
### CloudWatch Métricas
Visualize métricas agregadas para todas as suas tarefas de atualização de visualização materializada em: CloudWatch
Métricas disponíveis:
+ AWS/Glue namespace com dimensões:
+ CatalogId: Seu identificador de catálogo
+ DatabaseName: Banco de dados contendo a visualização materializada
+ TableName: Nome da visualização materializada
+ TaskType: Defina como "MaterializedViewRefresh”
Visualizando no console:
1. Navegue até CloudWatch Console → Métricas
1. Selecione o AWS namespace /Glue
1. Filtrar por dimensões: CatalogId, DatabaseName, TableName, TaskType
1. Veja métricas de sucesso, fracasso e duração do trabalho
Exemplo de consulta de CloudWatch métricas:
```
{AWS/Glue,CatalogId,DatabaseName,TableName,TaskType} MaterializedViewRefresh
```
Usando AWS CLI:
```
aws cloudwatch get-metric-statistics \
--namespace AWS/Glue \
--metric-name \
--dimensions Name=CatalogId,Value= \
Name=DatabaseName,Value= \
Name=TableName,Value= \
Name=TaskType,Value=MaterializedViewRefresh \
--start-time \
--end-time \
--period 3600 \
--statistics Sum \
--region
```
### CloudWatch Registros
Visualize registros de execução detalhados para execuções individuais de tarefas de atualização:
Grupo de registros: `/aws-glue/materialized-views/`
Onde `` está um UUID (por exemplo, abc12345-def6-7890-ghij-klmnopqrstuv).
Visualizando registros:
```
# List log streams for a task run
aws logs describe-log-streams \
--log-group-name /aws-glue/materialized-views/ \
--region
# Get log events
aws logs get-log-events \
--log-group-name /aws-glue/materialized-views/ \
--log-stream-name \
--region
```
No CloudWatch console:
1. Navegue até CloudWatch → Grupos de registros
1. Pesquise por /aws-glue/materialized-views/
1. Selecione o grupo de registros com seu ID de execução da tarefa
1. Visualize registros detalhados de execução, erros e resultados de tarefas do Spark
### Notificações
Inscreva-se em eventos para receber notificações em tempo real sobre mudanças no estado da tarefa de atualização:
Tipos de eventos disponíveis:
+ Tarefa de atualização do Glue Materialized View iniciada
+ A tarefa de atualização do Glue Materialized View foi bem-sucedida
+ Falha na tarefa de atualização do Glue Materialized View
+ Falha na invocação de atualização automática do Glue Materialized View
Criando uma regra:
```
aws events put-rule \
--name materialized-view-refresh-notifications \
--event-pattern '{
"source": ["aws.glue"],
"detail-type": [
"Glue Materialized View Refresh Task Started",
"Glue Materialized View Refresh Task Succeeded",
"Glue Materialized View Refresh Task Failed",
"Glue Materialized View Auto-Refresh Invocation Failure"
]
}' \
--region
```
Adicionando um alvo (por exemplo, tópico do SNS):
```
aws events put-targets \
--rule materialized-view-refresh-notifications \
--targets "Id"="1","Arn"="arn:aws:sns:::" \
--region
```
### Visualizando o status de atualização
Verifique o status de seus trabalhos de atualização de visualização materializada usando a AWS Glue API:
```
aws glue get-materialized-view-refresh-task-run \
--catalog-id \
--materialized-view-refresh-task-run-id \
--region
```
Ou liste todas as execuções de atualização recentes:
```
aws glue list-materialized-view-refresh-task-runs \
--catalog-id \
--database-name \
--table-name \
--region
```
Isso mostra:
+ Hora da última atualização
+ Status de atualização (BEM-SUCEDIDA, FALHA, EM EXECUÇÃO, PARADA)
+ ID de execução da tarefa
+ Mensagens de erro (se falharem)
Estados comuns de atualização:
+ EM EXECUÇÃO: O trabalho de atualização está sendo executado no momento
+ BEM-SUCEDIDO: Atualização concluída com sucesso
+ FALHA: A atualização encontrou um erro
+ PARADO: a atualização foi cancelada manualmente
Solução de problemas de atualizações com falha:
Se uma atualização falhar, verifique:
1. Permissões do IAM: garanta que a função definidora tenha acesso a todas as tabelas base e ao local da visualização materializada
1. Disponibilidade da tabela base: verifique se todas as tabelas referenciadas existem e estão acessíveis
1. Validade da consulta: confirme se a consulta SQL é válida para o dialeto SQL do Spark
1. Limites de recursos: verifique se você atingiu os limites de atualização simultânea da sua conta
Use a GetMaterializedViewRefreshTaskRun API para recuperar mensagens de erro detalhadas.
## Considerações e limitações
+ As visualizações materializadas só podem referenciar tabelas do Apache Iceberg registradas no Catálogo de AWS Glue Dados como tabelas base.
+ A criação de visualizações e a reescrita automática de consultas estão disponíveis somente nos mecanismos Spark no Apache Spark versão 3.5.6 e superior no Amazon Athena, Amazon EMR e (versão 5.1). AWS Glue
+ Eventualmente, as visualizações materializadas são consistentes com as tabelas base. Durante a janela de atualização, as consultas que acessam diretamente a visualização materializada podem retornar dados desatualizados. Para acesso imediato aos dados atuais, execute uma atualização manual.
+ O intervalo mínimo de atualização automática é uma hora. Para casos de uso que exigem atualizações mais frequentes, execute atualizações manuais programaticamente usando o comando. `REFRESH MATERIALIZED VIEW`
+ A reescrita da consulta prioriza a correção em detrimento do desempenho. Se uma visualização materializada estiver obsoleta ou não puder atender aos requisitos de consulta com precisão, os mecanismos do Spark executam a consulta original nas tabelas base.