

# Gerenciar o Catálogo de Dados
<a name="manage-catalog"></a>

 O AWS Glue Data Catalog é um repositório central de metadados que armazena metadados estruturais e operacionais para seus conjuntos de dados do Amazon S3. Gerenciar o Catálogo de Dados de forma eficaz é crucial para manter a qualidade, o desempenho, a segurança e a governança dos dados.

 Ao entender e aplicar essas práticas de gerenciamento de Catálogos de Dados, é possível garantir que seus metadados permaneçam precisos, eficientes, seguros e bem governados à medida que seu cenário de dados evolui. 

Esta seção aborda os seguintes aspectos do gerenciamento do Catálogo de Dados:
+ *Atualização do esquema e das partições da tabela* Conforme seus dados evoluírem, talvez seja necessário atualizar o esquema da tabela ou a estrutura de partições definida no Catálogo de Dados. Para obter mais informações sobre como fazer essas atualizações programaticamente usando o AWS Glue ETL, consulte [Atualizar esquemas e adicionar novas partições ao Catálogo de Dados em trabalhos do AWS Glue ETL](update-from-job.md).
+ *Gerenciar estatísticas de colunas*: estatísticas de colunas precisas ajudam a otimizar os planos de consulta e melhorar a performance. Para obter mais informações sobre como gerar, atualizar e gerenciar estatísticas de colunas, consulte [Otimizar a performance da consulta usando estatísticas de coluna](column-statistics.md). 
+  *Criptografar o Catálogo de Dados* Para proteger metadados confidenciais, é possível criptografar seu Catálogo de Dados usando o AWS Key Management Service (AWS KMS). Esta seção explica como habilitar e gerenciar a criptografia em seu Catálogo de Dados. 
+ *Proteger o Catálogo de Dados com o AWS Lake Formation* O Lake Formation fornece uma abordagem abrangente para a segurança e o controle de acesso do data lake. É possível usar o Lake Formation para proteger e controlar o acesso ao seu catálogo de dados e aos dados subjacentes. 

**Topics**
+ [Atualizar esquemas e adicionar novas partições ao Catálogo de Dados em trabalhos do AWS Glue ETL](update-from-job.md)
+ [Otimizar a performance da consulta usando estatísticas de coluna](column-statistics.md)
+ [Como criptografar seu Data Catalog](catalog-encryption.md)
+ [Proteger seu catálogo de dados usando o Lake Formation](secure-catalog.md)
+ [Trabalho com as visualizações do AWS Glue Data Catalog no AWS Glue](catalog-views.md)

# Atualizar esquemas e adicionar novas partições ao Catálogo de Dados em trabalhos do AWS Glue ETL
<a name="update-from-job"></a>

O trabalho de extração, transformação e carregamento (ETL) pode criar partições de tabelas no armazenamento de dados de destino. Os esquemas do conjunto de dados podem evoluir e divergir do esquema do esquema do AWS Glue Data Catalog ao longo do tempo. Os trabalhos de ETL do AWS Glue agora oferecem vários recursos que podem ser usados no script de ETL para atualizar os esquemas e as partições no Data Catalog. Esses recursos permitem visualizar os resultados do trabalho de ETL no Data Catalog sem precisar executar o crawler novamente.

## Novas partições
<a name="update-from-job-partitions"></a>

Se quiser visualizar as novas partições no AWS Glue Data Catalog, é possível realizar um dos seguintes procedimentos:
+ Quando o trabalho terminar, execute novamente o crawler e exiba as novas partições no console quando o crawler terminar.
+ Quando o trabalho terminar, exiba as novas partições no console imediatamente, sem precisar executar novamente o crawler. Você pode habilitar esse recurso adicionando algumas linhas de código ao seu script de ETL, como exibido nos exemplos a seguir. O código usa o argumento `enableUpdateCatalog` para indicar que o Data Catalog deve ser atualizado durante a execução do trabalho à medida que as novas partições são criadas.

**Método 1**  
Passe `enableUpdateCatalog` e `partitionKeys` em um argumento de opções.  

```
additionalOptions = {"enableUpdateCatalog": True}
additionalOptions["partitionKeys"] = ["region", "year", "month", "day"]


sink = glueContext.write_dynamic_frame_from_catalog(frame=last_transform, database=<target_db_name>,
                                                    table_name=<target_table_name>, transformation_ctx="write_sink",
                                                    additional_options=additionalOptions)
```

```
val options = JsonOptions(Map(
    "path" -> <S3_output_path>, 
    "partitionKeys" -> Seq("region", "year", "month", "day"), 
    "enableUpdateCatalog" -> true))
val sink = glueContext.getCatalogSink(
    database = <target_db_name>, 
    tableName = <target_table_name>, 
    additionalOptions = options)sink.writeDynamicFrame(df)
```

**Método 2**  
Passe `enableUpdateCatalog` e `partitionKeys` em `getSink()` e chame o objeto `setCatalogInfo()` no `DataSink`.  

```
sink = glueContext.getSink(
    connection_type="s3", 
    path="<S3_output_path>",
    enableUpdateCatalog=True,
    partitionKeys=["region", "year", "month", "day"])
sink.setFormat("json")
sink.setCatalogInfo(catalogDatabase=<target_db_name>, catalogTableName=<target_table_name>)
sink.writeFrame(last_transform)
```

```
val options = JsonOptions(
   Map("path" -> <S3_output_path>, 
       "partitionKeys" -> Seq("region", "year", "month", "day"), 
       "enableUpdateCatalog" -> true))
val sink = glueContext.getSink("s3", options).withFormat("json")
sink.setCatalogInfo(<target_db_name>, <target_table_name>)
sink.writeDynamicFrame(df)
```

Agora, é possível criar novas tabelas de catálogo, atualizar tabelas existentes com esquema modificado e adicionar novas partições de tabelas no Data Catalog usando um trabalho de ETL do AWS Glue, sem a necessidade de executar crawlers novamente.

## Atualizar esquema da tabela
<a name="update-from-job-updating-table-schema"></a>

Se você quiser substituir o esquema da tabela do Data Catalog, é possível realizar um dos seguintes procedimentos:
+ Quando o trabalho for concluído, execute o crawler novamente e verifique se está configurado para atualizar a definição da tabela também. Visualize as partições no console junto com atualizações do esquema, quando o crawler finalizar. Para obter mais informações, consulte [Configurar um crawler com a API](https://docs.aws.amazon.com/glue/latest/dg/crawler-configuration.html#crawler-configure-changes-api).
+ Quando o trabalho for concluído, visualize o esquema modificado no console imediatamente, sem precisar executar o crawler novamente. Você pode habilitar esse recurso adicionando algumas linhas de código ao seu script de ETL, como exibido nos exemplos a seguir. O código usa `enableUpdateCatalog` definido como true e `updateBehavior` definido como `UPDATE_IN_DATABASE`, o que indica substituir o esquema e adicionar novas partições no Data Catalog durante a execução do trabalho.

------
#### [ Python ]

```
additionalOptions = {
    "enableUpdateCatalog": True, 
    "updateBehavior": "UPDATE_IN_DATABASE"}
additionalOptions["partitionKeys"] = ["partition_key0", "partition_key1"]

sink = glueContext.write_dynamic_frame_from_catalog(frame=last_transform, database=<dst_db_name>,
    table_name=<dst_tbl_name>, transformation_ctx="write_sink",
    additional_options=additionalOptions)
job.commit()
```

------
#### [ Scala ]

```
val options = JsonOptions(Map(
    "path" -> outputPath, 
    "partitionKeys" -> Seq("partition_0", "partition_1"), 
    "enableUpdateCatalog" -> true))
val sink = glueContext.getCatalogSink(database = nameSpace, tableName = tableName, additionalOptions = options)
sink.writeDynamicFrame(df)
```

------

Também é possível definir o valor de `updateBehavior` como `LOG` se quiser impedir que o esquema da tabela seja substituído, mas ainda quiser adicionar novas partições. O valor padrão de `updateBehavior` é `UPDATE_IN_DATABASE`, portanto, se você não defini-lo explicitamente, o esquema da tabela será substituído.

Se `enableUpdateCatalog` não estiver definido como true, independentemente da opção selecionada para `updateBehavior`, o trabalho de ETL não atualizará a tabela no Data Catalog. 

## Criar novas tabelas
<a name="update-from-job-creating-new-tables"></a>

Também é possível usar as mesmas opções para criar uma tabela no Data Catalog. Também é possível especificar o banco de dados e o nome da nova tabela usando `setCatalogInfo`.

------
#### [ Python ]

```
sink = glueContext.getSink(connection_type="s3", path="s3://path/to/data",
    enableUpdateCatalog=True, updateBehavior="UPDATE_IN_DATABASE",
    partitionKeys=["partition_key0", "partition_key1"])
sink.setFormat("<format>")
sink.setCatalogInfo(catalogDatabase=<dst_db_name>, catalogTableName=<dst_tbl_name>)
sink.writeFrame(last_transform)
```

------
#### [ Scala ]

```
val options = JsonOptions(Map(
    "path" -> outputPath, 
    "partitionKeys" -> Seq("<partition_1>", "<partition_2>"), 
    "enableUpdateCatalog" -> true, 
    "updateBehavior" -> "UPDATE_IN_DATABASE"))
val sink = glueContext.getSink(connectionType = "s3", connectionOptions = options).withFormat("<format>")
sink.setCatalogInfo(catalogDatabase = “<dst_db_name>”, catalogTableName = “<dst_tbl_name>”)
sink.writeDynamicFrame(df)
```

------

## Restrições
<a name="update-from-job-restrictions"></a>

Observe as seguintes restrições:
+ Somente os destinos do Amazon Simple Storage Service (Amazon S3) são suportados.
+ O atributo `enableUpdateCatalog` é suportado para tabelas governadas.
+ Somente os seguintes formatos são compatíveis: `json`, `csv`, `avro` e `parquet`.
+ Para criar ou atualizar tabelas com a classificação `parquet`, você deve utilizar o gravador de parquet do AWS Glue otimizado para DynamicFrames. Isso pode ser feito de uma das seguintes maneiras:
  + se você estiver atualizando uma tabela existente no catálogo com classificação `parquet`, a tabela deve ter a propriedade de tabela `"useGlueParquetWriter"` definida como `true` antes de você atualizá-la. Você pode definir essa propriedade por meio de APIs/SDK do AWS Glue, por meio do console ou por meio de uma instrução DDL do Athena.   
![\[Campo de edição de propriedade da tabela de catálogo no console do AWS Glue.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/edit-table-property.png)

    Depois que a propriedade da tabela do catálogo estiver definida, você poderá usar o seguinte trecho de código para atualizar a tabela do catálogo com os novos dados:

    ```
    glueContext.write_dynamic_frame.from_catalog(
        frame=frameToWrite,
        database="dbName",
        table_name="tableName",
        additional_options={
            "enableUpdateCatalog": True,
            "updateBehavior": "UPDATE_IN_DATABASE"
        }
    )
    ```
  + Se a tabela ainda não existir no catálogo, você pode utilizar o método `getSink()` em seu script com `connection_type="s3"` para adicionar a tabela e suas partições ao catálogo, além de gravar os dados no Amazon S3. Forneça as `partitionKeys` e a `compression` para seu fluxo de trabalho.

    ```
    s3sink = glueContext.getSink(
        path="s3://bucket/folder/",
        connection_type="s3",
        updateBehavior="UPDATE_IN_DATABASE",
        partitionKeys=[],
        compression="snappy",
        enableUpdateCatalog=True
    )
        
    s3sink.setCatalogInfo(
        catalogDatabase="dbName", catalogTableName="tableName"
    )
        
    s3sink.setFormat("parquet", useGlueParquetWriter=True)
    s3sink.writeFrame(frameToWrite)
    ```
  + O valor de formato `glueparquet` é um método herdado para habilitar o gravador parquet AWS Glue.
+ Quando `updateBehavior` for definido como `LOG`, as novas partições serão adicionadas somente se o esquema `DynamicFrame` for equivalente a, ou contiver, um subconjunto das colunas definidas no esquema da tabela do Data Catalog.
+ As atualizações de esquema não são aceitas para tabelas não particionadas (que não usam a opção “partitionKeys”).
+ As partitionKeys devem ser equivalentes e estar na mesma ordem, entre o parâmetro informado no script de ETL e as partitionKeys no esquema da tabela do Data Catalog.
+ Atualmente, esse recurso ainda não suporta atualização/criação de tabelas nas quais os esquemas de atualização são aninhados (por exemplo, matrizes dentro de estruturas).

Para obter mais informações, consulte [Programar scripts do Spark](aws-glue-programming.md).

# Trabalhar com conexões MongoDB em trabalhos de ETL
<a name="integrate-with-mongo-db"></a>

Você pode criar uma conexão para MongoDB e, em seguida, usar essa conexão em seu trabalho do AWS Glue. Para obter mais informações, consulte [Conexões do MongoDB](aws-glue-programming-etl-connect-mongodb-home.md) no guia de programação do AWS Glue. O `url`, `username` e `password` da conexão são armazenados na conexão do MongoDB. Outras opções podem ser especificadas em seu script de trabalho de ETL usando o parâmetro `additionalOptions` do `glueContext.getCatalogSource`. As outras opções podem incluir:
+ `database`: (obrigatório) o banco de dados MongoDB do qual fazer a leitura.
+ `collection`: (obrigatório) a coleção do MongoDB da qual fazer a leitura.

Ao colocar as informações de `database` e `collection` dentro do script de trabalho de ETL, você pode usar a mesma conexão em vários trabalhos.

1. Criar uma conexão do AWS Glue Data Catalog para a fonte de dados do MongoDB. Consulte ["connectionType": "mongodb"](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-connect.html#aws-glue-programming-etl-connect-mongodb) para uma descrição dos parâmetros de conexão. É possível criar a conexão ao utilizar o console, as APIs ou a CLI.

1. Crie um banco de dados no AWS Glue Data Catalog para armazenar as definições de tabela para seus dados do MongoDB. Consulte [Criar bancos de dados](define-database.md) para obter mais informações.

1. Crie um crawler que rastreie os dados no MongoDB usando as informações na conexão para se conectar ao MongoDB. O crawler cria as tabelas no AWS Glue Data Catalog que descrevem as tabelas no banco de dados MongoDB que você usa em seu trabalho. Consulte [Usar crawlers para preencher o catálogo de dados](add-crawler.md) para obter mais informações.

1. Crie um trabalho com um script personalizado. É possível criar o trabalho usando o console, as APIs ou a CLI. Para obter mais informações, consulte [Adicionar trabalhos no AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/add-job.html).

1. Escolha os destinos de dados para o seu trabalho. As tabelas que representam o destino dos dados podem ser definidas no Data Catalog, ou seu trabalho pode criar as tabelas de destino quando for executado. Você escolhe um local de destino ao criar o trabalho. Se o destino exigir uma conexão, ela também será referenciada no seu trabalho. Se o trabalho precisar de vários destinos de dados, você poderá adicioná-los posteriormente editando o script.

1. Personalize o ambiente de processamento de trabalhos informando os argumentos para seu trabalho e o script gerado. 

   A seguir, encontra-se um exemplo de como criar um `DynamicFrame` do banco de dados MongoDB com base na estrutura da tabela definida no Data Catalog. O código usa `additionalOptions` para fornecer as informações adicionais sobre a origem dos dados:

------
#### [  Scala  ]

   ```
   val resultFrame: DynamicFrame = glueContext.getCatalogSource(
           database = catalogDB, 
           tableName = catalogTable, 
           additionalOptions = JsonOptions(Map("database" -> DATABASE_NAME, 
                   "collection" -> COLLECTION_NAME))
         ).getDynamicFrame()
   ```

------
#### [  Python  ]

   ```
   glue_context.create_dynamic_frame_from_catalog(
           database = catalogDB,
           table_name = catalogTable,
           additional_options = {"database":"database_name", 
               "collection":"collection_name"})
   ```

------

1. Execute o trabalho, sob demanda ou por meio de um acionador.

# Otimizar a performance da consulta usando estatísticas de coluna
<a name="column-statistics"></a>

Você pode calcular estatísticas em nível de coluna para tabelas do AWS Glue Data Catalog em formatos de dados como Parquet, ORC, JSON, ION, CSV e XML sem precisar configurar pipelines de dados adicionais. As estatísticas de colunas ajudam você a entender os perfis de dados obtendo insights sobre os valores em uma coluna. 

O Catálogo de Dados possibilita a geração de estatísticas para valores de colunas, como valor mínimo, valor máximo, total de valores nulos, total de valores distintos, comprimento médio dos valores e ocorrências totais de valores reais. Os serviços analíticos da AWS, como o Amazon Redshift e o Amazon Athena, podem usar essas estatísticas de colunas para gerar planos de execução de consultas e escolher o plano ideal para melhorar a performance da consulta.

Há três cenários para a geração de estatísticas de colunas: 

 **Auto**   
O AWS Glue oferece suporte à geração automática de estatísticas de colunas no nível do catálogo para que ele possa gerar automaticamente estatísticas para novas tabelas no AWS Glue Data Catalog. 

**Programado**  
O AWS Glue oferece suporte à programação da geração de estatísticas de coluna para que ela possa ser executada automaticamente em uma programação recorrente.   
Com o cálculo de estatísticas programado, a tarefa de estatísticas de coluna atualiza as estatísticas gerais em nível de tabela, como mínimos, máximos e média, com as novas estatísticas, fornecendo aos mecanismos de consulta estatísticas precisas e atualizadas para otimizar a execução de consultas. 

**Sob demanda**  
Use essa opção para gerar estatísticas de coluna sob demanda sempre que necessário. Isso é útil para análises ad hoc ou quando as estatísticas precisam ser calculadas imediatamente. 

É possível configurar para executar a tarefa de geração de estatísticas de coluna usando o console do AWS Glue, a AWS CLI ou a API do AWS Glue. Quando você inicia o processo, o AWS Glue inicia um trabalho do Spark em segundo plano e atualiza os metadados da tabela AWS Glue no Catálogo de Dados. Você pode visualizar as estatísticas da coluna usando o console do AWS Glue ou a AWS CLI ou chamando a operação da API [GetColumnStatisticsForTable](https://docs.aws.amazon.com/glue/latest/webapi/API_GetColumnStatisticsForTable.html).

**nota**  
Se você estiver usando as permissões do Lake Formation para controlar o acesso à tabela, o perfil assumido pela tarefa de estatísticas da coluna exigirá acesso total à tabela para gerar estatísticas.

 O vídeo a seguir demonstra como aprimorar a performance da consulta usando estatísticas de colunas. 

[![AWS Videos](http://img.youtube.com/vi/https://www.youtube.com/embed/zUHEXJdHUxs?si=HjyhpoALR6RXJz2i/0.jpg)](http://www.youtube.com/watch?v=https://www.youtube.com/embed/zUHEXJdHUxs?si=HjyhpoALR6RXJz2i)


**Topics**
+ [Pré-requisitos para gerar estatísticas de colunas](column-stats-prereqs.md)
+ [Geração automática de estatísticas de colunas](auto-column-stats-generation.md)
+ [Gerar estatísticas de colunas em uma programação](generate-column-stats.md)
+ [Gerar estatísticas de colunas sob demanda](column-stats-on-demand.md)
+ [Visualizar estatísticas de colunas](view-column-stats.md)
+ [Visualizar as execuções de tarefas de estatísticas de colunas](view-stats-run.md)
+ [Interromper a execução da tarefa de estatísticas de coluna](stop-stats-run.md)
+ [Excluir estatísticas de colunas](delete-column-stats.md)
+ [Considerações e limitações](column-stats-notes.md)

# Pré-requisitos para gerar estatísticas de colunas
<a name="column-stats-prereqs"></a>

Para gerar ou atualizar as estatísticas de colunas, a tarefa de geração de estatísticas assume um perfil do AWS Identity and Access Management (IAM) em seu nome. Com base nas permissões concedidas ao perfil, a tarefa de geração de estatísticas de colunas pode ler os dados do datastore do Amazon S3.

Ao configurar a tarefa de geração de estatísticas de colunas, o AWS Glue permite que você crie um perfil que inclua a política `AWSGlueServiceRole` gerenciada pela AWS, além da política em linha necessária para a fonte de dados especificada. 

Se você especificar um perfil existente para a geração de estatísticas de colunas, certifique-se de que ele inclua a política `AWSGlueServiceRole` ou equivalente (ou uma versão dessa política com um escopo reduzido), além das políticas em linha necessárias. Siga estas etapas para criar um novo perfil do IAM:

**nota**  
 Para gerar estatísticas para tabelas gerenciadas pelo Lake Formation, o perfil do IAM usado para gerar estatísticas exige acesso total à tabela. 

Ao configurar a tarefa de geração de estatísticas de colunas, o AWS Glue permite que você crie um perfil que inclua a política `AWSGlueServiceRole` gerenciada pela AWS, além da política em linha necessária para a fonte de dados especificada. Você também pode criar um perfil e anexar as permissões listadas na política abaixo, e adicionar esse perfil à tarefa de geração de estatísticas de colunas.

**Para criar um perfil do IAM para gerar estatísticas de coluna**

1. Para criar um perfil do IAM, consulte [Criar um perfil do IAM para o AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/create-an-iam-role.html).

1. Para atualizar um perfil existente, no console do IAM, acesse o perfil do IAM que está sendo usado pelo processo de geração de estatísticas de colunas.

1. Na guia **Adicionar permissões**, escolha **Anexar políticas**. Na janela recém-aberta do navegador, escolha política gerenciada pela AWS `AWSGlueServiceRole`.

1. Você também precisa incluir permissão para ler dados da localização de dados do Amazon S3.

   Na seção **Adicionar permissões**, escolha **Criar política**. Na janela recém-aberta do navegador, crie uma nova política para usar com seu perfil.

1. Na página **Criar política**, escolha a guia **JSON**. Copie o seguinte código `JSON` no editor.
**nota**  
Nas políticas a seguir, substitua o ID da conta por uma Conta da AWS válida e substitua `region` pela região da tabela e `bucket-name` pelo nome do bucket do Amazon S3.

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Sid": "S3BucketAccess",
               "Effect": "Allow",
               "Action": [
                   "s3:ListBucket",
                   "s3:GetObject"
               ],
               "Resource": [
               	"arn:aws:s3:::amzn-s3-demo-bucket/*",
   							"arn:aws:s3:::amzn-s3-demo-bucket"
               ]
           }
        ]
   }
   ```

------

1. (Opcional) Se você estiver usando as permissões do Lake Formation para fornecer acesso aos seus dados, o perfil do IAM exigirá permissões de `lakeformation:GetDataAccess`.

------
#### [ JSON ]

****  

   ```
   {
     "Version":"2012-10-17",		 	 	 
     "Statement": [
       {
         "Sid": "LakeFormationDataAccess",
         "Effect": "Allow",
         "Action": "lakeformation:GetDataAccess",
         "Resource": [
           "*"
         ]
       }
     ]
   }
   ```

------

    Se a localização dos dados do Amazon S3 estiver registrada no Lake Formation e o perfil do IAM assumido pela tarefa de geração de estatísticas de colunas não tiver permissões de grupo `IAM_ALLOWED_PRINCIPALS` concedidas na tabela, o perfil exigirá as permissões `ALTER` e `DESCRIBE` do Lake Formation na tabela. O perfil usado para registrar o bucket do Amazon S3 requer as permissões `INSERT` e `DELETE` do Lake Formation na tabela. 

   Se a localização dos dados do Amazon S3 não estiver registrada no Lake Formation e o perfil do IAM não tiver permissões de grupo `IAM_ALLOWED_PRINCIPALS` concedidas na tabela, o perfil exigirá as permissões `ALTER`, `DESCRIBE`, `INSERT` e `DELETE` do Lake Formation na tabela. 

1. Se você ativou a opção `Automatic statistics generation` em nível de catálogo, o perfil do IAM deve ter a permissão `glue:UpdateCatalog` ou a permissão `ALTER CATALOG` do Lake Formation no Catálogo de Dados padrão. Você pode usar a operação `GetCatalog` para verificar as propriedades do catálogo. 

1. (Opcional) A tarefa de geração de estatísticas de colunas que grava Amazon CloudWatch Logs criptografados requer as permissões a seguir na política de chave.

------
#### [ JSON ]

****  

   ```
   {
     "Version":"2012-10-17",		 	 	 
     "Statement": [
       {
         "Sid": "CWLogsKmsPermissions",
         "Effect": "Allow",
         "Action": [
           "logs:CreateLogGroup",
           "logs:CreateLogStream",
           "logs:PutLogEvents",
           "logs:AssociateKmsKey"
         ],
         "Resource": [
           "arn:aws:logs:us-east-1:111122223333:log-group:/aws-glue:*"
         ]
       },
       {
         "Sid": "KmsPermissions",
         "Effect": "Allow",
         "Action": [
           "kms:GenerateDataKey",
           "kms:Decrypt",
           "kms:Encrypt"
         ],
         "Resource": [
           "arn:aws:kms:us-east-1:111122223333:key/arn of key used for ETL cloudwatch encryption"
         ],
         "Condition": {
           "StringEquals": {
             "kms:ViaService": [
               "glue.us-east-1.amazonaws.com"
             ]
           }
         }
       }
     ]
   }
   ```

------

1. O perfil que você usa para executar as estatísticas de colunas deve ter a permissão `iam:PassRole`.

------
#### [ JSON ]

****  

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

------

1. Ao criar um perfil do IAM para gerar estatísticas de colunas, esse perfil também deve ter a política de confiança a seguir que permite que o serviço assuma o perfil. 

------
#### [ JSON ]

****  

   ```
   {
     "Version":"2012-10-17",		 	 	 
     "Statement": [
       {
         "Sid": "TrustPolicy",
         "Effect": "Allow",
         "Principal": {
           "Service": "glue.amazonaws.com"
         },
         "Action": "sts:AssumeRole"
       }
     ]
   }
   ```

------

# Geração automática de estatísticas de colunas
<a name="auto-column-stats-generation"></a>

A geração automática de estatísticas de colunas permite a você agendar e calcular automaticamente estatísticas em novas tabelas no AWS Glue Data Catalog. Quando a geração automática de estatísticas é habilitada, o Catálogo de Dados descobre novas tabelas com formatos de dados específicos, como Parquet, JSON, CSV, XML, ORC, ION e Apache Iceberg, junto com seus caminhos de bucket individuais. Com uma configuração única de catálogo, o Catálogo de Dados gera estatísticas para essas tabelas.

 Os administradores do Data Lake podem configurar a geração de estatísticas selecionando o catálogo padrão no console do Lake Formation e habilitando as estatísticas da tabela usando a opção `Optimization configuration`. Quando você cria novas tabelas ou atualiza tabelas existentes no Catálogo de Dados, o Catálogo de Dados coleta semanalmente o número de valores distintos (NDVs) das tabelas do Apache Iceberg e estatísticas adicionais, como o número de nulos, tamanho máximo, mínimo e médio de outros formatos de arquivo compatíveis. 

Se você configurou a geração de estatísticas no nível da tabela ou se já excluiu as configurações de geração de estatísticas de uma tabela, essas configurações específicas da tabela têm precedência sobre as configurações padrão do catálogo para a geração automática de estatísticas de coluna.

 A tarefa de geração automática de estatísticas analisa 50% dos registros nas tabelas para calcular estatísticas. A geração automática de estatísticas de colunas garante que o Catálogo de dados mantenha as métricas semanais que podem ser usadas por mecanismos de consulta como Amazon Athena e Amazon Redshift Spectrum para melhorar a performance das consultas e reduzir custos potenciais. Isso permite programar a geração de estatísticas usando APIs ou o console do AWS Glue, fornecendo um processo automatizado sem intervenção manual. 

**Topics**
+ [Habilitar a geração automática de estatísticas em nível de catálogo](enable-auto-column-stats-generation.md)
+ [Visualizar configurações em nível de tabela automatizadas](view-auto-column-stats-settings.md)
+ [Desabilitar a geração de estatísticas de colunas em nível de catálogo](disable-auto-column-stats-generation.md)

# Habilitar a geração automática de estatísticas em nível de catálogo
<a name="enable-auto-column-stats-generation"></a>

É possível habilitar a geração automática de estatísticas de colunas para todas as novas tabelas do Apache Iceberg e tabelas em formatos não OTF (Parquet, JSON, CSV, XML, ORC, ION) no Catálogo de Dados. Depois de criar a tabela, você também poderá atualizar explicitamente as configurações de estatísticas de coluna manualmente.

 Para atualizar as configurações do Catálogo de Dados para habilitar o nível do catálogo, o perfil do IAM usado deve ter a permissão `glue:UpdateCatalog` ou a permissão `ALTER CATALOG` do AWS Lake Formation no catálogo raiz. É possível usar a API `GetCatalog` para verificar as propriedades do catálogo. 

------
#### [ Console de gerenciamento da AWS ]

**Para habilitar a geração automática de estatísticas de colunas no nível da conta**

1. Abra o console do Lake Formation em [https://console.aws.amazon.com/lakeformation/](https://console.aws.amazon.com/lakeformation/).

1. No painel de navegação à esquerda, escolha **Catálogos)**.

1. Na página **Resumo do catálogo**, escolha **Editar** em **Configuração da otimização**.   
![\[A captura de tela mostra as opções disponíveis para gerar estatísticas da coluna.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/edit-column-stats-auto.png)

1. Na página **Configuração da otimização de tabelas**, escolha a opção **Habilitar geração automática de estatísticas para as tabelas do catálogo**.  
![\[A captura de tela mostra as opções disponíveis para gerar estatísticas da coluna.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/edit-optimization-option.jpg)

1. Escolha um perfil do IAM existente ou crie um novo com as permissões necessárias para executar a tarefa de estatísticas de coluna.

1. Selecione **Enviar**.

------
#### [ AWS CLI ]

Você também pode habilitar a coleta de estatísticas em nível de catálogo via AWS CLI. Para configurar a coleta de estatísticas em nível de tabela usando a AWS CLI, execute o seguinte comando:

```
aws glue update-catalog --cli-input-json '{
    "name": "123456789012",
    "catalogInput": {
        "description": "Updating root catalog with role arn",
        "catalogProperties": {
            "customProperties": {
                "ColumnStatistics.RoleArn": "arn:aws:iam::"123456789012":role/service-role/AWSGlueServiceRole",
                "ColumnStatistics.Enabled": "true"
            }
        }
    }
}'
```

 O comando acima chama a operação `UpdateCatalog` do AWS Glue, que usa uma estrutura `CatalogProperties` com os seguintes pares de chave-valor para geração de estatísticas em nível de catálogo: 
+ ColumnStatistics.RoleArn: ARN do perfil do IAM a ser usado para todas as tarefas acionadas para geração de estatísticas em nível de catálogo
+ ColumnStatistics.Enabled: booleano que indica se as configurações em nível de catálogo estão habilitadas ou desabilitadas

------

# Visualizar configurações em nível de tabela automatizadas
<a name="view-auto-column-stats-settings"></a>

 Quando a coleta de estatísticas em nível de catálogo está habilitada, sempre que uma tabela do Apache Hive ou uma tabela do Apache Iceberg é criada ou atualizada por meio das APIs `CreateTable` ou `UpdateTable` via Console de gerenciamento da AWS, SDK ou Crawler do AWS Glue, uma configuração em nível de tabela equivalente é criada para essa tabela. 

 As tabelas com a geração automática de estatísticas habilitada devem seguir uma das seguintes propriedades:
+ Usar um `InputSerdeLibrary` que comece com org.apache.hadoop e em que `TableType` seja igual a `EXTERNAL_TABLE`
+ Usar um `InputSerdeLibrary` que comece com `com.amazon.ion` e em que `TableType` seja igual a `EXTERNAL_TABLE`
+ Conter table\$1type: "ICEBERG" em sua estrutura de parâmetros. 

 Após criar ou atualizar uma tabela, você poderá verificar os detalhes da tabela para confirmar a geração de estatísticas. `Statistics generation summary` mostra a propriedade `Schedule` definida como `AUTO` e o valor de `Statistics configuration` é `Inherited from catalog`. Qualquer configuração de tabela com a configuração a seguir seria acionada automaticamente pelo Glue internamente. 

![\[Uma imagem de uma tabela do Hive com coleta de estatísticas em nível de catálogo foi aplicada e as estatísticas foram coletadas.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/auto-stats-summary.png)


# Desabilitar a geração de estatísticas de colunas em nível de catálogo
<a name="disable-auto-column-stats-generation"></a>

 É possível desabilitar a geração automática de estatísticas de colunas para novas tabelas usando o console do AWS Lake Formation, a API `glue:UpdateCatalogSettings` ou a API `glue:DeleteColumnStatisticsTaskSettings`. 

**Para desabilitar a geração automática de estatísticas de colunas no nível da conta**

1. Abra o console do Lake Formation em [https://console.aws.amazon.com/lakeformation/](https://console.aws.amazon.com/lakeformation/).

1. No painel de navegação à esquerda, escolha **Catálogos)**.

1. Na página **Resumo do catálogo**, escolha **Editar** em **Configuração da otimização**. 

1. Na página **Configuração da otimização de tabelas**, desmarque a opção **Habilitar geração automática de estatísticas para as tabelas do catálogo**.

1. Selecione **Enviar**.

# Gerar estatísticas de colunas em uma programação
<a name="generate-column-stats"></a>

Siga estas etapas para configurar um cronograma para gerar estatísticas no AWS Glue Data Catalog usando o console do , o AWS Glue, a AWS CLI ou a operação [StartColumnStatisticsTaskRun](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-crawler-column-statistics.html#aws-glue-api-crawler-column-statistics-CreateColumnStatisticsTaskSettings).

------
#### [ Console ]

**Para gerar estatísticas de colunas usando o console**

1. Faça login no console do AWS Glue em [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/). 

1. Escolha uma tabela do Catálogo de Dados.

1. Escolha uma tabela na lista. 

1. Escolha a guia **Estatísticas de colunas** na seção inferior da página **Tabelas**.

1. Você também pode escolher **Gerar em uma programação** em **Estatísticas de colunas** em **Ações**.

1. Na página **Gerar estatísticas em uma programação**, configure uma programação recorrente para executar a tarefa de estatísticas de colunas escolhendo a frequência e a hora de início. É possível definir a frequência como a cada hora, diária ou semanal ou ainda definir uma expressão cron para especificar a programação.

   Uma expressão cron é uma string que representa um padrão de programação que consiste em 6 campos separados por espaços: \$1 \$1 \$1 \$1 \$1 <minuto> <hora> <dia do mês> <mês> <dia da semana> <ano> Por exemplo, para executar uma tarefa todos os dias à meia-noite, a expressão cron seria: 0 0 \$1 \$1 ? \$1

   Para obter mais informações, consulte [Expressões cron](https://docs.aws.amazon.com/glue/latest/dg/monitor-data-warehouse-schedule.html#CronExpressions).  
![\[A captura de tela mostra as opções disponíveis para gerar estatísticas da coluna.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/generate-column-stats-schedule.png)

1. Em seguida, escolha a opção de coluna para gerar estatísticas.
   + **Todas as colunas**: escolha essa opção para gerar estatísticas para todas as colunas na tabela.
   + **Colunas selecionadas**: escolha essa opção para gerar estatísticas para colunas específicas. É possível selecionar as colunas na lista suspensa.

1. Crie um perfil do IAM ou escolha um existente que tenha permissões para gerar estatísticas. O AWS Glue assume esse perfil para gerar estatísticas de colunas.

   Uma abordagem mais rápida é permitir que o console do AWS Glue crie um perfil para você. O perfil por ele criado destina-se especificamente à geração de estatísticas de colunas e inclui a política `AWSGlueServiceRole` gerenciada pela AWS e mais a política em linha necessária para a fonte de dados especificada. 

   Se você especificar um perfil existente para a geração de estatísticas de colunas, certifique-se de que ele inclua a política `AWSGlueServiceRole` ou equivalente (ou uma versão dessa política com um escopo reduzido), além das políticas em linha necessárias. 

1. (Opcional) Em seguida, escolha uma configuração de segurança para ativar a criptografia em repouso para logs.

1. (Opcional) É possível escolher um tamanho de amostra indicando somente uma porcentagem específica de linhas da tabela para gerar estatísticas. O padrão é todas as linhas. Use as setas para cima e para baixo para aumentar ou diminuir o valor percentual. 

   Recomendamos incluir todas as linhas na tabela para calcular estatísticas precisas. Use as linhas de exemplo para gerar estatísticas de coluna somente quando valores aproximados forem aceitáveis.

1. Escolha **Gerar estatísticas** para executar a tarefa de geração de estatísticas de colunas.

------
#### [ AWS CLI ]

O exemplo de AWS CLI a seguir pode ser usado para criar uma programação de geração de estatísticas de colunas. Os parâmetros obrigatórios são database-name, table-name e role, enquanto os parâmetros opcionais são schedule, column-name-list, catalog-id, sample-size e security-configuration.

```
aws glue create-column-statistics-task-settings \ 
 --database-name 'database_name' \ 
 --table-name table_name \ 
 --role 'arn:aws:iam::123456789012:role/stats-role' \ 
 --schedule 'cron(0 0-5 14 * * ?)' \ 
 --column-name-list 'col-1' \  
 --catalog-id '123456789012' \ 
 --sample-size '10.0 ' \
 --security-configuration 'test-security'
```

Também é possível pode gerar estatísticas de colunas chamando a operação [StartColumnStatisticsTaskRun](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-crawler-column-statistics.html#aws-glue-api-crawler-column-statistics-StartColumnStatisticsTaskRun).

------

# Gerenciar a programação para geração de estatísticas de colunas
<a name="manage-column-stats-schedule"></a>

Você pode gerenciar as operações de programação, como atualizar, iniciar, interromper e excluir programações para a geração de estatísticas de colunas no AWS Glue. É possível usar o console do AWS Glue, a AWS CLI ou [operações de API de estatísticas de colunas do AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-crawler-column-statistics.html) para realizar essas tarefas.

**Topics**
+ [Atualizar a programação da geração de estatísticas de colunas](#update-column-stats-shedule)
+ [Interromper a programação de geração de estatísticas de colunas](#stop-column-stats-schedule)
+ [Retomar a programação de geração de estatísticas de colunas](#resume-column-stats-schedule)
+ [Excluir programação de geração de estatísticas de colunas](#delete-column-stats-schedule)

## Atualizar a programação da geração de estatísticas de colunas
<a name="update-column-stats-shedule"></a>

É possível atualizar a programação para acionar a tarefa de geração de estatísticas de colunas após ela ser criada. É possível usar o console do AWS Glue ou a AWS CLI ou executar a operação [UpdateColumnStatisticsTaskSettings](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-crawler-column-statistics.html#aws-glue-api-crawler-column-statistics-UpdateColumnStatisticsTaskSettings) para atualizar a programação para uma tabela. É possível modificar os parâmetros de uma programação existente, como o tipo de programação (sob demanda ou programada) e outros parâmetros opcionais. 

------
#### [ Console de gerenciamento da AWS ]

**Para atualizar as configurações para uma tarefa de estatísticas de colunas**

1. Faça login no console do AWS Glue em [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).

1. Escolha a tabela que você deseja atualizar na lista de tabelas.

1. Na seção inferior da página de detalhes da tabela, escolha **Estatísticas de colunas**. 

1. Em **Ações**, escolha **Editar** para atualizar a programação.

1. Faça as alterações desejadas na programação e escolha **Salvar**.

------
#### [ AWS CLI ]

 Se você não estiver usando o recurso de geração de estatísticas do AWS Glue no console, poderá atualizar manualmente a programação usando o comando `update-column-statistics-task-settings`. O exemplo a seguir mostra como excluir estatísticas de colunas usando a AWS CLI. 

```
aws glue update-column-statistics-task-settings \ 
 --database-name 'database_name' \ 
 --table-name 'table_name' \ 
 --role arn:aws:iam::123456789012:role/stats_role \ 
 --schedule 'cron(0 0-5 16 * * ?)' \ 
 --column-name-list 'col-1' \
 --sample-size '20.0' \  
 --catalog-id '123456789012'\
 --security-configuration 'test-security'
```

------

## Interromper a programação de geração de estatísticas de colunas
<a name="stop-column-stats-schedule"></a>

 Se não precisar mais das estatísticas incrementais, você poderá interromper a geração agendada para economizar recursos e custos. Pausar a programação não afeta as estatísticas geradas anteriormente. Você pode retomar a programação conforme sua conveniência. 

------
#### [ Console de gerenciamento da AWS ]

**Para interromper a programação de uma tarefa de geração de estatísticas de colunas**

1. No console do AWS Glue, escolha **Tabelas** em Catálogo de Dados.

1. Selecione uma tabela com estatísticas de colunas.

1. Na página **Detalhes da tabela**, escolha **Estatísticas da coluna**.

1. Em **Ações**, escolha **Geração programada**, **Pausar**.

1. Escolha **Pausar** para confirmar.

------
#### [ AWS CLI ]

Para interromper a programação de execução de uma tarefa de estatísticas de colunas usando a AWS CLI, é possível usar o seguinte comando: 

```
aws glue stop-column-statistics-task-run-schedule \
 --database-name ''database_name' \
 --table-name 'table_name'
```

Substitua `database_name` e `table_name` pelos nomes reais do banco de dados e da tabela para os quais você deseja interromper a programação de execução da tarefa de estatísticas de colunas.

------

## Retomar a programação de geração de estatísticas de colunas
<a name="resume-column-stats-schedule"></a>

 Se você pausou a programação de geração de estatísticas, o AWS Glue permite retomá-lo conforme sua conveniência. Você pode retomar a programação usando o console do AWS Glue, a AWS CLI ou a operação [StartColumnStatisticsTaskRunSchedule](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-crawler-column-statistics.html#aws-glue-api-crawler-column-statistics-StartColumnStatisticsTaskRunSchedule). 

------
#### [ Console de gerenciamento da AWS ]

**Para retomar a programação de geração de estatísticas de colunas**

1. No console do AWS Glue, escolha **Tabelas** em Catálogo de Dados.

1. Selecione uma tabela com estatísticas de colunas.

1. Na página **Detalhes da tabela**, escolha **Estatísticas da coluna**.

1. Em **Ações**, escolha **Geração programada** e escolha **Retomar**.

1. Escolha **Retomar** para confirmar.

------
#### [ AWS CLI ]

Substitua `database_name` e `table_name` pelos nomes reais do banco de dados e da tabela para os quais você deseja interromper a programação de execução da tarefa de estatísticas de colunas.

```
aws glue start-column-statistics-task-run-schedule \
 --database-name 'database_name' \
 --table-name 'table_name'
```

------

## Excluir programação de geração de estatísticas de colunas
<a name="delete-column-stats-schedule"></a>

 Embora a manutenção de estatísticas atualizadas seja geralmente recomendada para otimizar a performance da consulta, há casos de uso específicos em que a remoção da programação de geração automática pode ser benéfica.
+ Se os dados permanecerem relativamente estáticos, as estatísticas de colunas existentes poderão permanecer precisas por um longo período, reduzindo a necessidade de atualizações frequentes. Excluir a programação pode evitar o consumo desnecessário de recursos e a sobrecarga associada à regeneração de estatísticas em dados inalterados.
+ Quando o controle manual sobre a geração de estatísticas é preferido. Ao excluir a programação automática, os administradores podem atualizar seletivamente as estatísticas de colunas em intervalos específicos ou após alterações significativas nos dados, alinhando o processo com suas estratégias de manutenção e necessidades de alocação de recursos. 

------
#### [ Console de gerenciamento da AWS ]

**Para excluir a programação de geração de estatísticas de colunas**

1. No console do AWS Glue, escolha **Tabelas** em Catálogo de Dados.

1. Selecione uma tabela com estatísticas de colunas.

1. Na página **Detalhes da tabela**, escolha **Estatísticas da coluna**.

1. Em **Ações**, escolha **Geração programada**, **Excluir**.

1. Escolha **Excluir** para confirmar.

------
#### [ AWS CLI ]

Substitua `database_name` e `table_name` pelos nomes reais do banco de dados e da tabela para os quais você deseja interromper a programação de execução da tarefa de estatísticas de colunas.

Você pode excluir estatísticas de colunas usando a operação da API [DeleteColumnStatisticsTaskSettings](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-crawler-column-statistics.html#aws-glue-api-crawler-column-statistics-DeleteColumnStatisticsTaskSettings) ou a AWS CLI. Os exemplos a seguir mostram como excluir a programação de geração de estatísticas de colunas usando a AWS Command Line Interface (AWS CLI).

```
aws glue delete-column-statistics-task-settings \
    --database-name 'database_name' \
    --table-name 'table_name'
```

------

# Gerar estatísticas de colunas sob demanda
<a name="column-stats-on-demand"></a>

É possível executar a tarefa de estatísticas de coluna para tabelas do AWS Glue Data Catalog sob demanda, sem uma programação definida. Essa opção é útil para análises ad hoc ou quando as estatísticas precisam ser calculadas imediatamente.

Siga estas etapas para gerar estatísticas de colunas sob demanda para tabelas do Catálogo de Dados usando o console ou a AWS CLI do AWS Glue.

------
#### [ Console de gerenciamento da AWS ]

**Para gerar estatísticas de colunas usando o console**

1. Faça login no console do AWS Glue em [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/). 

1. Escolha uma tabela do Catálogo de Dados.

1.  Escolha uma tabela na lista. 

1. Escolha **Gerar estatísticas** no menu **Ações**.

   Você também pode escolher a opção **Gerar**, **Gerar sob demanda** na guia **Estatísticas de colunas** na seção inferior da página **Tabela**.

1. Siga as etapas de 7 a 11 em [Gerar estatísticas de colunas em uma programação](generate-column-stats.md) para gerar estatísticas de colunas para a tabela.

1. Na página **Gerar estatísticas**, especifique as seguintes opções:   
![\[A captura de tela mostra as opções disponíveis para gerar estatísticas da coluna.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/generate-column-stats.png)
   + **Todas as colunas**: escolha essa opção para gerar estatísticas para todas as colunas na tabela.
   + **Colunas selecionadas**: escolha essa opção para gerar estatísticas para colunas específicas. É possível selecionar as colunas na lista suspensa.
   + **Perfil do IAM**: escolha **Criar um novo perfil do IAM** com as políticas de permissão necessárias para executar a tarefa de geração de estatísticas de colunas. Escolha Exibir detalhes da permissão para revisar a declaração de política. Também é possível selecionar um perfil do IAM na lista. Para mais informações sobre as permissões necessárias, consulte [Pré-requisitos para gerar estatísticas de colunas](column-stats-prereqs.md).

     O AWS Glue assume as permissões do perfil que você especificou para gerar estatísticas. 

     Para obter mais informações sobre o fornecimento de perfis para o AWS Glue, consulte [Identity-based policies for AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/security_iam_service-with-iam.html#security_iam_service-with-iam-id-based-policies).
   + (Opcional) Em seguida, escolha uma configuração de segurança para ativar a criptografia em repouso para logs.
   + **Linhas de exemplo**: escolha somente uma porcentagem específica de linhas da tabela para gerar estatísticas. O padrão é todas as linhas. Use as setas para cima e para baixo para aumentar ou diminuir o valor percentual.
**nota**  
Recomendamos incluir todas as linhas na tabela para calcular estatísticas precisas. Use as linhas de exemplo para gerar estatísticas de coluna somente quando valores aproximados forem aceitáveis.

   Escolha **Gerar estatísticas** para executar a tarefa.

------
#### [ AWS CLI ]

Esse comando acionará a execução de uma tarefa de estatísticas de colunas para a tabela especificada. É necessário fornecer o nome do banco de dados, o nome da tabela, um perfil do IAM com permissões para gerar estatísticas e, opcionalmente, fornecer os nomes das colunas e uma porcentagem do tamanho da amostra para o cálculo das estatísticas.

```
aws glue start-column-statistics-task-run \ 
    --database-name 'database_name \ 
    --table-name 'table_name' \ 
    --role 'arn:aws:iam::123456789012:role/stats-role' \
    --column-name 'col1','col2'  \
    --sample-size 10.0
```

Esse comando iniciará uma tarefa para gerar estatísticas de coluna para a tabela especificada. 

------

## Atualizar estatísticas de colunas sob demanda
<a name="update-column-stats-on-demand"></a>

 Manter estatísticas de colunas atualizadas é crucial para que o otimizador de consultas gere planos de execução eficientes, garantindo uma melhor performance de consultas, menor consumo de recursos e melhor performance geral do sistema. Esse processo é particularmente importante após alterações significativas nos dados, como cargas em massa ou modificações extensivas que podem tornar as estatísticas existentes obsoletas. 

É necessário executar explicitamente a tarefa **Gerar estatísticas** no console do AWS Glue para atualizar as estatísticas da coluna. O Catálogo de Dados não atualiza as estatísticas automaticamente.

Se você não estiver usando o recurso de geração de estatísticas do AWS Glue no console, poderá atualizar manualmente as estatísticas da coluna usando a operação da API [UpdateColumnStatisticsForTable](https://docs.aws.amazon.com/glue/latest/webapi/API_UpdateColumnStatisticsForTable.html) ou a AWS CLI. O exemplo a seguir mostra como excluir estatísticas de colunas usando a AWS CLI.

```
aws glue update-column-statistics-for-table --cli-input-json:

{
    "CatalogId": "111122223333",
    "DatabaseName": "database_name",
    "TableName": "table_name",
    "ColumnStatisticsList": [
        {
            "ColumnName": "col1",
            "ColumnType": "Boolean",
            "AnalyzedTime": "1970-01-01T00:00:00",
            "StatisticsData": {
                "Type": "BOOLEAN",
                "BooleanColumnStatisticsData": {
                    "NumberOfTrues": 5,
                    "NumberOfFalses": 5,
                    "NumberOfNulls": 0
                }
            }
        }
    ]
}
```

# Visualizar estatísticas de colunas
<a name="view-column-stats"></a>

Depois de gerar as estatísticas com êxito, o Data Catalog armazena essas informações para que os otimizadores baseados em custos no Amazon Athena e no Amazon Redshift façam as melhores escolhas ao executar consultas. As estatísticas variam de acordo com o tipo de coluna.

------
#### [ Console de gerenciamento da AWS ]

**Para visualizar estatísticas de colunas para uma tabela**
+ Após a execução da tarefa de estatísticas da coluna, a guia **Estatísticas da coluna** na página **Detalhes da tabela** mostra as estatísticas da tabela.   
![\[A captura de tela mostra as colunas geradas com base na execução mais recente.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/view-column-stats.png)

  As seguintes estatísticas estão disponíveis:
  + Nome da coluna: o nome da coluna usada para gerar as estatísticas
  + Última atualização: a data e a hora em que as estatísticas foram geradas
  + Comprimento médio: o comprimento médio dos valores na coluna
  + Valores distintos: o número total de valores distintos na coluna. Estimamos o número de valores distintos em uma coluna com erro relativo de 5%.
  + Valor máximo: o maior valor na coluna.
  + Valor mínimo: o menor valor na coluna. 
  + Comprimento máximo: o comprimento do valor mais alto na coluna.
  + Valores nulos: o número de valores nulos na coluna.
  + Valores verdadeiros: o número de valores verdadeiros na coluna.
  + Valores falsos: o número de valores falsos na coluna.
  + numFiles: o número total de arquivos na tabela. Esse valor está disponível na guia **Propriedades avançadas**.

------
#### [ AWS CLI ]

O exemplo a seguir mostra como recuperar estatísticas de colunas usando a AWS CLI.

```
aws glue get-column-statistics-for-table \
    --database-name database_name \
    --table-name table_name \
    --column-names <column_name>
```

 Você também pode visualizar as estatísticas da coluna usando a operação da API [GetColumnStatisticsForTable](https://docs.aws.amazon.com/glue/latest/webapi/API_GetColumnStatisticsForTable.html). 

------

# Visualizar as execuções de tarefas de estatísticas de colunas
<a name="view-stats-run"></a>

Depois de executar uma tarefa de estatísticas de coluna, é possível explorar os detalhes da execução da tarefa para uma tabela usando o console do AWS Glue, a AWS CLI ou a operação [GetColumnStatisticsTaskRuns](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-crawler-column-statistics.html#aws-glue-api-crawler-column-statistics-GetColumnStatisticsTaskRun).

------
#### [ Console ]

**Para visualizar detalhes da execução da tarefa de estatísticas da coluna**

1. No console do AWS Glue, escolha **Tabelas** em Catálogo de Dados.

1. Selecione uma tabela com estatísticas de colunas.

1. Na página **Detalhes da tabela**, escolha **Estatísticas da coluna**.

1. Escolha **Visualizar execuções**.

   É possível ver informações sobre todas as execuções associadas à tabela especificada.  
![\[A captura de tela mostra as opções disponíveis para gerar estatísticas da coluna.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/view-column-stats-task-runs.png)

------
#### [ AWS CLI ]

No exemplo a seguir, substitua os valores de `DatabaseName` e `TableName` pelos nomes reais do banco de dados e da tabela.

```
aws glue get-column-statistics-task-runs --input-cli-json file://input.json
{
    "DatabaseName": "database_name",
    "TableName": "table_name"
}
```

------

# Interromper a execução da tarefa de estatísticas de coluna
<a name="stop-stats-run"></a>

Você pode interromper a execução de uma tarefa de estatísticas de coluna para uma tabela usando o console do AWS Glue, a AWS CLI ou a operação [StopColumnStatisticsTaskRun](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-crawler-column-statistics.html#aws-glue-api-crawler-column-statistics-StopColumnStatisticsTaskRun).

------
#### [ Console ]

**Para interromper a execução de uma tarefa de estatísticas de coluna**

1. No console do AWS Glue, escolha **Tabelas** em Catálogo de Dados.

1. Selecione a tabela com a execução da tarefa de estatísticas da coluna em andamento.

1. Na página **Detalhes da tabela**, escolha **Estatísticas da coluna**.

1. Escolha **Parar**.

   Se você interromper a tarefa antes que a execução seja concluída, as estatísticas da coluna não serão geradas para a tabela.

------
#### [ AWS CLI ]

No exemplo a seguir, substitua os valores de `DatabaseName` e `TableName` pelos nomes reais do banco de dados e da tabela.

```
aws glue stop-column-statistics-task-run --input-cli-json file://input.json
{
    "DatabaseName": "database_name",
    "TableName": "table_name"
}
```

------

# Excluir estatísticas de colunas
<a name="delete-column-stats"></a>

Você pode excluir estatísticas de colunas usando a operação da API [DeleteColumnStatisticsForTable](https://docs.aws.amazon.com/glue/latest/webapi/API_DeleteColumnStatisticsForTable.html) ou a AWS CLI. Os exemplos a seguir mostram como excluir estatísticas de colunas usando a AWS Command Line Interface (AWS CLI).

```
aws glue delete-column-statistics-for-table \
    --database-name 'database_name' \
    --table-name 'table_name' \
    --column-name 'column_name'
```

# Considerações e limitações
<a name="column-stats-notes"></a>

As considerações e limitações a seguir se aplicam à geração de estatísticas de colunas.

**Considerações**
+ Usar amostragem para gerar estatísticas reduz o tempo de execução, mas pode gerar estatísticas imprecisas.
+ O Catálogo de Dados não armazena versões diferentes das estatísticas.
+ Só é possível executar uma tarefa de geração de estatísticas de cada vez por tabela.
+ Se uma tabela for criptografada usando a chave AWS KMS do cliente registrada no Catálogo de Dados, o AWS Glue usa a mesma chave para criptografar as estatísticas.

**A tarefa de estatísticas de colunas oferece suporte à geração de estatísticas:**
+ Quando o perfil do IAM tem permissões completas na tabela (IAM ou Lake Formation).
+ Quando o perfil do IAM tem permissões na tabela usando o modo de acesso híbrido do Lake Formation.

**A tarefa de estatísticas de colunas não oferece suporte à geração de estatísticas para:**
+ Tabelas com controle de acesso baseado em células do Lake Formation
+ Data lakes transacionais: Delta Lake do Linux foundation, Apache Hudi
+ Tabelas em bancos de dados federados: metastore do Hive, compartilhamentos de dados do Amazon Redshift
+ Colunas aninhadas, matrizes e tipos de dados struct.
+ Tabela que é compartilhada com você de outra conta

# Como criptografar seu Data Catalog
<a name="catalog-encryption"></a>

 Você pode proteger seus metadados armazenados no AWS Glue Data Catalog em repouso usando chaves de criptografia gerenciadas pelo AWS Key Management Service (AWS KMS). É possível habilitar a criptografia do Catálogo de Dados para o novo Catálogo de Dados usando as **Configurações do Catálogo de Dados**. Você pode habilitar ou desabilitar a criptografia para o Catálogo de Dados existente conforme necessário. Quando habilitada, o AWS Glue criptografa todos os novos metadados gravados no catálogo, enquanto os metadados existentes permanecem sem criptografia. 

Para obter informações detalhadas sobre como criptografar seu Catálogo de Dados, consulte [Como criptografar seu Data Catalog](encrypt-glue-data-catalog.md).

# Proteger seu catálogo de dados usando o Lake Formation
<a name="secure-catalog"></a>

 O AWS Lake Formation é um serviço que facilita configurar um data lake seguro na AWS. Ele fornece um local central para criar e gerenciar com segurança seus data lakes com a definição de permissões de controle de acesso refinadas. O Lake Formation usa o Catálogo de Dados para armazenar e recuperar metadados sobre seu data lake, como definições de tabelas, informações de esquema e configurações de controle de acesso a dados.

Você pode registrar a localização da tabela de metadados ou do banco de dados no Amazon S3 com o Lake Formation e usá-la para definir permissões em nível de metadados nos recursos do Catálogo de Dados. Também é possível usar o Lake Formation para gerenciar permissões de acesso ao armazenamento nos dados subjacentes armazenados no Amazon S3 em nome de mecanismos analíticos integrados.

Para obter mais informações, consulte [O que é o AWS Lake Formation?](lake-formation/latest/dg/what-is-lake-formation.html).

# Trabalho com as visualizações do AWS Glue Data Catalog no AWS Glue
<a name="catalog-views"></a>

 É possível criar e gerenciar as visualizações no AWS Glue Data Catalog, comumente conhecidas como visualizações do AWS Glue Data Catalog. Essas visualizações são úteis por serem compatíveis com diversos mecanismos de consulta SQL, permitindo o acesso à mesma visualização por diferentes serviços da AWS, como o Amazon Athena, o Amazon Redshift e o AWS Glue. É possível usar visualizações baseadas em Apache Iceberg, Apache Hudi e Delta Lake. 

 Ao criar uma visualização no Catálogo de Dados, você pode usar concessões de recursos e controles de acesso baseados em etiquetas no AWS Lake Formation para conceder acesso à visualização. Com esse método de controle de acesso, não é necessário configurar permissões de acesso adicionais para as tabelas referenciadas na criação da visualização. Esse método de concessão de permissões é chamado de semântica definidora, e essas exibições são chamadas de vizualizações definidoras. Para obter mais informações sobre controle de acesso no AWS Lake Formation, consulte a página [Granting and revoking permissions on Data Catalog resources](https://docs.aws.amazon.com/lake-formation/latest/dg/granting-catalog-permissions.html) no Guia do desenvolvedor do AWS Lake Formation. 

 As vizualizações do Data Catalog são úteis para os seguintes casos de uso: 
+  **Controle de acesso granular**: é possível criar uma visualização que restringe o acesso aos dados com base nas permissões necessárias ao usuário. Por exemplo, você pode usar visualizações no Catálogo de Dados para impedir que colaboradores externos ao departamento de Recursos Humanos acessem informações de identificação pessoal (PII). 
+  **Definição completa da visualização**: ao aplicar filtros em sua visualização no Catálogo de Dados, você garante que os registros de dados disponíveis estejam sempre completos. 
+  **Segurança aprimorada**: a obrigatoriedade de uma definição de consulta completa durante a criação da visualização contribui para reduzir a suscetibilidade das visualizações do Catálogo de Dados a comandos SQL de agentes mal-intencionados. 
+  **Compartilhamento de dados simplificado**: compartilhe dados com outras contas da AWS sem a necessidade de movimentação dos dados, usando o compartilhamento de dados entre contas no AWS Lake Formation. 

## Criação de uma visualização do Catálogo de Dados
<a name="catalog-creating-view"></a>

 Você pode criar visualizações do Catálogo de Dados usando a AWS CLI ou scripts de ETL do AWS Glue desenvolvidos com Spark SQL. A criação de visualizações do Catálogo de Dados segue uma sintaxe que inclui a especificação do tipo de visualização como `MULTI DIALECT` e do predicado `SECURITY` como `DEFINER`, o que configura uma visualização do tipo “definer”. 

 Exemplo de instrução SQL para a criação de uma visualização do Catálogo de Dados: 

```
CREATE PROTECTED MULTI DIALECT VIEW database_name.catalog_view SECURITY DEFINER
AS SELECT order_date, sum(totalprice) AS price
FROM source_table
GROUP BY order_date;
```

 Após criar uma visualização do Catálogo de Dados, é possível usar um perfil do IAM com a permissão “SELECT” do AWS Lake Formation sobre a visualização para consultá-la, usando serviços como o Amazon Athena, o Amazon Redshift ou trabalhos de ETL do AWS Glue. Não é necessário conceder acesso às tabelas subjacentes referenciadas na visualização. 

 Para obter mais informações sobre a criação e a configuração de visualizações do Catálogo de Dados, consulte a página [Building AWS Glue Data Catalog views](https://docs.aws.amazon.com/lake-formation/latest/dg/working-with-views.html) no Guia do desenvolvedor do AWS Lake Formation. 

## Operações compatíveis para visualizações
<a name="catalog-supported-view-operations"></a>

 Os fragmentos de comandos apresentados a seguir mostram como é possível trabalhar com as visualizações do Catálogo de Dados de diferentes formas: 

 **CREATE VIEW** 

 Cria uma visualização do Catálogo de Dados. A seguir, um exemplo que demonstra a criação da visualização usando uma tabela existente: 

```
CREATE PROTECTED MULTI DIALECT VIEW catalog_view 
SECURITY DEFINER AS SELECT * FROM my_catalog.my_database.source_table
```

 **ALTER VIEW** 

 Sintaxe disponível: 

```
ALTER VIEW view_name [FORCE] ADD DIALECT AS query
ALTER VIEW view_name [FORCE] UPDATE DIALECT AS query
ALTER VIEW view_name DROP DIALECT
```

 É possível usar a opção `FORCE ADD DIALECT` para aplicar a atualização do esquema e dos objetos secundários de acordo com o novo dialeto do mecanismo. Lembre-se de que essa ação pode resultar em erros de consulta, caso a opção `FORCE` não seja usada para atualizar os demais dialetos do mecanismo. A seguir, um exemplo que demonstra a aplicação: 

```
ALTER VIEW catalog_view FORCE ADD DIALECTAS
SELECT order_date, sum(totalprice) AS priceFROM source_tableGROUP BY orderdate;
```

 A seguir, um exemplo que demonstra a alteração de uma visualização para a atualização do dialeto: 

```
ALTER VIEW catalog_view UPDATE DIALECT AS
SELECT count(*) FROM my_catalog.my_database.source_table;
```

 **DESCRIBE VIEW** 

 Sintaxe disponível para descrever uma visualização: 

 `SHOW COLUMNS {FROM|IN} view_name [{FROM|IN} database_name]`: se o usuário tiver as permissões necessárias no AWS Glue e no AWS Lake Formation para descrever a visualização, será possível listar as colunas. A seguir, alguns exemplos de comandos que demonstram como visualizar colunas: 

```
SHOW COLUMNS FROM my_database.source_table;    
SHOW COLUMNS IN my_database.source_table;
```

 `DESCRIBE view_name`: se o usuário tiver as permissões necessárias no AWS Glue e no AWS Lake Formation para descrever a visualização, será possível listar as colunas na visualização, incluindo os respectivos metadados. 

 **DROP VIEW** 

 Sintaxe disponível: 

```
DROP VIEW [ IF EXISTS ] view_name
```

 A seguir, um exemplo de instrução `DROP` que demonstra como realizar um teste para verificar a existência da visualização antes de sua remoção: 

```
DROP VIEW IF EXISTS catalog_view;
```

 `SHOW CREATE VIEW view_name`: mostra a instrução SQL responsável pela criação da visualização especificada. A seguir, um exemplo que demonstra o processo de criação de uma visualização no Catálogo de Dados: 

```
SHOW CREATE TABLE my_database.catalog_view;CREATE PROTECTED MULTI DIALECT VIEW my_catalog.my_database.catalog_view (
  net_profit,
  customer_id,
  item_id,
  sold_date)
TBLPROPERTIES (
  'transient_lastDdlTime' = '1736267222')
SECURITY DEFINER AS SELECT * FROM
my_database.store_sales_partitioned_lf WHERE customer_id IN (SELECT customer_id from source_table limit 10)
```

 **SHOW VIEWS** 

 Lista todas as visualizações existentes no catálogo, incluindo as visualizações regulares, as visualizações com múltiplos dialetos (MDV, na sigla em inglês) e as MDVs sem suporte ao dialeto Spark. A sintaxe disponível é a seguinte: 

```
SHOW VIEWS [{ FROM | IN } database_name] [LIKE regex_pattern]:
```

 A seguir, um exemplo que demonstra um comando para mostrar as visualizações: 

```
SHOW VIEWS IN marketing_analytics LIKE 'catalog_view*';
```

 Para obter mais informações sobre a criação e a configuração de visualizações do Catálogo de Dados, consulte a página [Building AWS Glue Data Catalog views](https://docs.aws.amazon.com/lake-formation/latest/dg/working-with-views.html) no Guia do desenvolvedor do AWS Lake Formation. 

## Consulta de uma visualização do Catálogo de Dados
<a name="catalog-view-query"></a>

 Após criar uma visualização do Catálogo de Dados, é possível consultá-la normalmente. O perfil do IAM configurado em seus trabalhos do AWS Glue deve ter a permissão **SELECT** do Lake Formation na visualização do Catálogo de Dados. Não é necessário conceder acesso às tabelas subjacentes referenciadas na visualização. 

 Depois de configurar tudo, você pode consultar sua exibição. Por exemplo, você pode executar a consulta apresentada a seguir para acessar uma visualização. 

```
SELECT * from my_database.catalog_view LIMIT 10;
```

## Limitações
<a name="catalog-view-limitations"></a>

 Considere as limitações a seguir ao usar as vizualizações do Data Catalog. 
+  É possível criar visualizações do Catálogo de Dados apenas com a versão 5.0 ou superior do AWS Glue. 
+  O responsável pela definição da visualização do Catálogo de Dados deve ter permissão de acesso `SELECT` nas tabelas de base subjacentes acessadas pela visualização. A operação de criação da visualização do Catálogo de Dados não será bem-sucedida caso uma das tabelas de base tenha filtros do Lake Formation atribuídos ao perfil “definer”. 
+  As tabelas de base devem estar configuradas sem a permissão `IAMAllowedPrincipals` no data lake do AWS Lake Formation. Se presente, o erro **Visualizações de vários dialetos só podem fazer referência a tabelas sem permissões de IAMAllowedPrincipals permissions** ocorrerá. 
+  A localização da tabela no Amazon S3 deve estar registrada como um local de data lake no AWS Lake Formation. Caso a tabela não esteja registrada, será gerado o erro: `Multi Dialect views may only reference AWS Lake Formation managed tables`. Para obter informações sobre como registrar localizações do Amazon S3 no AWS Lake Formation, consulte [Registering an Amazon S3 location](https://docs.aws.amazon.com/lake-formation/latest/dg/register-data-lake.html) no Guia do desenvolvedor do AWS Lake Formation. 
+  Você só pode criar vizualizações `PROTECTED` do Data Catalog. Não há suporte para exibições `UNPROTECTED`. 
+  Você não pode referenciar tabelas de outra conta da AWS na definição de uma visualização do Catálogo de Dados. Além disso, não é possível referenciar uma tabela da mesma conta que esteja em uma região diferente. 
+  Para compartilhar dados entre contas ou regiões, a visualização inteira deve ser compartilhada entre contas e entre regiões, usando links de recurso do AWS Lake Formation. 
+  As funções definidas pelo usuário (UDFs) não são compatíveis. 
+  Não é possível fazer referência a outras vizualizações nas exibições do Data Catalog. 