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á.
# Iceberg
O [Apache Iceberg](https://iceberg.apache.org/) é um formato de tabela aberta para grandes conjuntos de dados no Amazon Simple Storage Service (Amazon S3). Ele fornece performance rápida de consultas em tabelas grandes, confirmações atômicas, gravações simultâneas e evolução de tabelas compatível com SQL. Desde o Amazon EMR 6.5.0, você pode usar o Apache Spark 3 em clusters do Amazon EMR com o formato de tabela Iceberg.
A tabela a seguir lista a versão do Iceberg incluída na versão mais recente da série 7.x do Amazon EMR, além dos componentes que o Amazon EMR instala com o Iceberg.
Para a versão dos componentes instalados com o Iceberg nesta versão, consulte Versões de componentes da [versão 7.12.0](emr-7120-release.md).
**Informações sobre a versão do Iceberg para o emr-7.12.0**
| Rótulo de versão do Amazon EMR | Versão do Iceberg | Componentes instalados com o Iceberg |
| --- | --- | --- |
| emr-7.12.0 | Iceberg 1.10.0-amzn-0 | Not available. |
A tabela a seguir lista a versão do Iceberg incluída na versão mais recente da série 6.x do Amazon EMR, além dos componentes que o Amazon EMR instala com o Iceberg.
Para obter a versão dos componentes instalados com o Iceberg nessa versão, consulte [Release 6.15.0 Component Versions](emr-6150-release.md).
**Informações de versão do Iceberg para o emr-6.15.0**
| Rótulo de versão do Amazon EMR | Versão do Iceberg | Componentes instalados com o Iceberg |
| --- | --- | --- |
| emr-6.15.0 | Iceberg 1.4.0-amzn-0 | Not available. |
**Topics**
+ [
# Como o Iceberg funciona
](emr-iceberg-how-it-works.md)
+ [
# Usar um cluster com o Iceberg
](emr-iceberg-use-cluster.md)
+ [
# Histórico de versões do Iceberg
](Iceberg-release-history.md)
# Como o Iceberg funciona
O Iceberg rastreia arquivos de dados individuais em uma tabela em vez de em diretórios. Dessa forma, os gravadores podem criar arquivos de dados no local (os arquivos não são movidos nem alterados). Além disso, os gravadores só podem adicionar arquivos à tabela em uma confirmação explícita. O estado da tabela é mantido em arquivos de metadados. Todas as alterações no estado da tabela criam um novo arquivo de metadados que substitui atomicamente os metadados antigos. O arquivo de metadados da tabela rastreia o esquema da tabela, a configuração do particionamento e outras propriedades.
Ele também inclui snapshots do conteúdo da tabela. Cada snapshot é um conjunto completo de arquivos de dados na tabela em um momento específico. Os snapshots são listados no arquivo de metadados, mas os arquivos de um snapshot são armazenados em arquivos manifesto separados. As transições atômicas de um arquivo de metadados da tabela para o próximo fornecem isolamento de snapshots. Os leitores usam o instantâneo que estava atualizado quando carregaram os metadados da tabela. Os leitores não são afetados pelas alterações até atualizarem e escolherem um novo local de metadados. Arquivos de dados em snapshots são armazenados em um ou mais arquivos manifesto que contêm uma linha para cada arquivo de dados na tabela, seus dados de partição e suas métricas. Um snapshot é a união de todos os arquivos nos seus manifestos. Os arquivos manifesto também podem ser compartilhados entre snapshots para evitar a regravação de metadados que são alterados com pouca frequência.
**Diagrama de snapshots do Iceberg**
![\[Diagrama de dois snapshots. Cada snapshot tem sua própria lista de manifestos, que armazena metadados sobre vários manifestos reutilizáveis. Cada manifesto se refere a um ou vários arquivos de dados.\]](http://docs.aws.amazon.com/pt_br/emr/latest/ReleaseGuide/images/Iceberg-snapshot-diagram.png)
O Iceberg oferece os seguintes atributos:
+ Oferece suporte a transações ACID e viagens no tempo no data lake do Amazon S3.
+ As novas tentativas de confirmação se beneficiam das vantagens de performance da [simultaneidade otimista](https://iceberg.apache.org/spec/#optimistic-concurrency).
+ A resolução de conflitos em nível de arquivo resulta em alta simultaneidade.
+ Com estatísticas mínimas e máximas por coluna nos metadados, você pode pular arquivos, o que aumenta a performance de consultas seletivas.
+ Você pode organizar tabelas em layouts de partição flexíveis, com a evolução da partição permitindo atualizações nos esquemas de partição. As consultas e os volumes de dados podem, então, mudar sem contar com diretórios físicos.
+ Oferece suporte à [evolução e à aplicação do esquema](https://iceberg.apache.org/docs/latest/evolution/#schema-evolution).
+ As tabelas do Iceberg funcionam como coletores idempotentes e fontes reproduzíveis. Isso permite streaming e suporte em lote com pipelines exatamente uma vez. Os coletores idempotentes rastreiam operações de gravação que foram bem-sucedidas no passado. Portanto, o coletor pode solicitar dados novamente em caso de falha e descartar dados que tiverem sido enviados várias vezes.
+ Visualize o histórico e a linhagem, incluindo evolução da tabela, o histórico de operações e as estatísticas de cada confirmação.
+ Migre de um conjunto de dados existente com uma opção de formato de dados (Parquet, ORC, Avro) e de um mecanismo de analytics (Spark, Trino, PrestoDB, Flink, Hive).
# Usar um cluster com o Iceberg
Esta seção inclui informações sobre como usar o Iceberg com Spark, Trino, Flink e Hive.
# Usar um cluster do Iceberg com o Spark
A partir da versão 6.5.0 do Amazon EMR, é possível usar o Iceberg com o cluster do Spark sem a necessidade de incluir ações de bootstrap. Nas versões 6.4.0 e anteriores do Amazon EMR, é possível usar uma ação de bootstrap para pré-instalar todas as dependências necessárias.
Neste tutorial, você usa o AWS CLI para trabalhar com o Iceberg em um cluster do Amazon EMR Spark. Para usar o console para criar um cluster com o Iceberg instalado, siga as etapas em [Criar um data lake no Apache Iceberg usando o Amazon Athena, o Amazon EMR e o AWS Glue](https://aws.amazon.com/blogs//big-data/build-an-apache-iceberg-data-lake-using-amazon-athena-amazon-emr-and-aws-glue/).
## Criar um cluster do Iceberg
Você pode criar um cluster com o Iceberg instalado usando o Console de gerenciamento da AWS, o AWS CLI ou a API do Amazon EMR. Neste tutorial, você usa o AWS CLI para trabalhar com o Iceberg em um cluster do Amazon EMR. Para usar o console para criar um cluster com o Iceberg instalado, siga as etapas em [Criar um data lake no Apache Iceberg usando o Amazon Athena, o Amazon EMR e o AWS Glue](https://aws.amazon.com/blogs//big-data/build-an-apache-iceberg-data-lake-using-amazon-athena-amazon-emr-and-aws-glue/).
Para usar o Iceberg no Amazon EMR com AWS CLI o, primeiro crie um cluster com as etapas a seguir. Para obter informações sobre como especificar a classificação do Iceberg usando o AWS CLI, consulte [Forneça uma configuração usando o AWS CLI ao criar um cluster](emr-configure-apps-create-cluster.md#emr-configure-apps-create-cluster-cli) ou. [Fornecer uma configuração usando o SDK do Java ao criar um cluster](emr-configure-apps-create-cluster.md#emr-configure-apps-create-cluster-sdk)
1. Crie um arquivo `configurations.json`, com o seguinte conteúdo:
```
[{
"Classification":"iceberg-defaults",
"Properties":{"iceberg.enabled":"true"}
}]
```
1. Em seguida, crie um cluster com a configuração a seguir. Substitua o exemplo do caminho do bucket do Amazon S3 e o ID da sub-rede pelos seus.
```
aws emr create-cluster --release-label emr-6.5.0 \
--applications Name=Spark \
--configurations file://configurations.json \
--region us-east-1 \
--name My_Spark_Iceberg_Cluster \
--log-uri s3://amzn-s3-demo-bucket/ \
--instance-type m5.xlarge \
--instance-count 2 \
--service-role EMR_DefaultRole_V2 \
--ec2-attributes InstanceProfile=EMR_EC2_DefaultRole,SubnetId=subnet-1234567890abcdef0
```
Como alternativa, é possível criar um cluster do Amazon EMR que inclua a aplicação do Spark e o arquivo `/usr/share/aws/iceberg/lib/iceberg-spark3-runtime.jar` como uma dependência do JAR em um trabalho do Spark. Para obter mais informações, consulte [Submitting Applications](https://spark.apache.org/docs/latest/submitting-applications.html#submitting-applications).
Para incluir o jar como uma dependência em um trabalho do Spark, adicione a seguinte propriedade de configuração à aplicação do Spark:
```
--conf "spark.jars=/usr/share/aws/iceberg/lib/iceberg-spark3-runtime.jar"
```
Para obter mais informações sobre as dependências de trabalho do Spark, consulte [Gerenciamento de dependências](https://spark.apache.org/docs/latest/running-on-kubernetes.html#dependency-management) no documento do Apache Spark [Executar o Spark no Kubernetes](https://spark.apache.org/docs/latest/running-on-kubernetes.html).
## Inicializar uma sessão do Spark para Iceberg
Os exemplos a seguir demonstram como iniciar o shell interativo do Spark, usar o envio do Spark ou usar os Cadernos do Amazon EMR para trabalhar com o Iceberg no Amazon EMR.
------
#### [ spark-shell ]
1. Conecte-se ao nó principal usando SSH. Para obter mais informações, consulte [Conectar-se ao nó principal usando SSH](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-connect-master-node-ssh.html) no *Guia de gerenciamento do Amazon EMR*.
1. Digite o seguinte comando para iniciar o shell do Spark. Para usar a PySpark concha, `spark-shell` substitua por`pyspark`.
```
spark-shell \
--conf spark.sql.catalog.my_catalog=org.apache.iceberg.spark.SparkCatalog \
--conf spark.sql.catalog.my_catalog.warehouse=s3://amzn-s3-demo-bucket/prefix/
--conf spark.sql.catalog.my_catalog.type=glue \
--conf spark.sql.defaultCatalog=my_catalog \
--conf spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions
```
------
#### [ spark-submit ]
1. Conecte-se ao nó principal usando SSH. Para obter mais informações, consulte [Conectar-se ao nó principal usando SSH](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-connect-master-node-ssh.html) no *Guia de gerenciamento do Amazon EMR*.
1. Insira o comando a seguir para iniciar a sessão do Spark no Iceberg.
```
spark-submit \
--conf spark.sql.catalog.my_catalog=org.apache.iceberg.spark.SparkCatalog \
--conf spark.sql.catalog.my_catalog.warehouse=s3://amzn-s3-demo-bucket1/prefix \
--conf spark.sql.catalog.my_catalog.type=glue \
--conf spark.sql.defaultCatalog=my_catalog \
--conf spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions
```
------
#### [ EMR Studio notebooks ]
Para inicializar uma sessão do Spark usando Cadernos do EMR Studio, configure a sessão do Spark usando o comando mágico `%%configure` no Caderno do Amazon EMR, como no exemplo a seguir. Para obter mais informações, consulte [Use EMR Notebooks magics](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-studio-magics.html#emr-magics) no *Guia de gerenciamento do Amazon EMR*.
```
%%configure -f{
"conf":{
"spark.sql.catalog.my_catalog":"org.apache.iceberg.spark.SparkCatalog",
"spark.sql.catalog.my_catalog.type":"glue",
"spark.sql.catalog.my_catalog.warehouse":"s3://amzn-s3-demo-bucket1/prefix/",
"spark.sql.defaultCatalog":"my_catalog",
"spark.sql.extensions":"org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions"
}
}
```
------
#### [ CLI ]
Para inicializar um cluster do Spark usando a CLI e definir todas as configurações padrão da sessão do Spark Iceberg, execute o exemplo a seguir. Para obter mais informações sobre como especificar uma classificação de configuração usando a AWS CLI API do Amazon EMR, [consulte](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-configure-apps.html) Configurar aplicativos.
```
[
{
"Classification": "spark-defaults",
"Properties": {
"spark.sql.catalog.my_catalog":"org.apache.iceberg.spark.SparkCatalog",
"spark.sql.catalog.my_catalog.type":"glue",
"spark.sql.catalog.my_catalog.warehouse":"s3://amzn-s3-demo-bucket1/prefix/",
"spark.sql.defaultCatalog":"my_catalog",
"spark.sql.extensions":"org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions"
}
}
]
```
------
## Gravar em uma tabela do Iceberg
O exemplo a seguir mostra como criar um DataFrame e gravá-lo como um conjunto de dados do Iceberg. Os exemplos demonstram como trabalhar com conjuntos de dados usando o shell do Spark durante a conexão com o nó principal usando SSH como usuário padrão do hadoop.
**nota**
Para colar exemplos de código no shell do Spark, digite `:paste` no prompt, cole o exemplo e pressione `CTRL+D`.
------
#### [ PySpark ]
O Spark inclui um shell baseado em Python, `pyspark`, que você pode usar para gerar protótipos de programas Spark escritos em Python. Invoque `pyspark` no nó principal.
```
## Create a DataFrame.
data = spark.createDataFrame([
("100", "2015-01-01", "2015-01-01T13:51:39.340396Z"),
("101", "2015-01-01", "2015-01-01T12:14:58.597216Z"),
("102", "2015-01-01", "2015-01-01T13:51:40.417052Z"),
("103", "2015-01-01", "2015-01-01T13:51:40.519832Z")
],["id", "creation_date", "last_update_time"])
## Write a DataFrame as a Iceberg dataset to the Amazon S3 location.
spark.sql("""CREATE TABLE IF NOT EXISTS dev.db.iceberg_table (id string,
creation_date string,
last_update_time string)
USING iceberg
location 's3://amzn-s3-demo-bucket/example-prefix/db/iceberg_table'""")
data.writeTo("dev.db.iceberg_table").append()
```
------
#### [ Scala ]
```
import org.apache.spark.sql.SaveMode
import org.apache.spark.sql.functions._
// Create a DataFrame.
val data = Seq(
("100", "2015-01-01", "2015-01-01T13:51:39.340396Z"),
("101", "2015-01-01", "2015-01-01T12:14:58.597216Z"),
("102", "2015-01-01", "2015-01-01T13:51:40.417052Z"),
("103", "2015-01-01", "2015-01-01T13:51:40.519832Z")
).toDF("id", "creation_date", "last_update_time")
// Write a DataFrame as a Iceberg dataset to the Amazon S3 location.
spark.sql("""CREATE TABLE IF NOT EXISTS dev.db.iceberg_table (id string,
creation_date string,
last_update_time string)
USING iceberg
location 's3://amzn-s3-demo-bucket/example-prefix/db/iceberg_table'""")
data.writeTo("dev.db.iceberg_table").append()
```
------
## Ler em uma tabela do Iceberg
------
#### [ PySpark ]
```
df = spark.read.format("iceberg").load("dev.db.iceberg_table")
df.show()
```
------
#### [ Scala ]
```
val df = spark.read.format("iceberg").load("dev.db.iceberg_table")
df.show()
```
------
#### [ Spark SQL ]
```
SELECT * from dev.db.iceberg_table LIMIT 10
```
------
## Usando o AWS Glue Data Catalog com o Spark Iceberg
Você pode se conectar ao AWS Glue Data Catalog a partir do Spark Iceberg. Esta seção mostra diferentes comandos para conexão.
### Conecte-se ao catálogo padrão do AWS Glue em sua região padrão
Este exemplo mostra como se conectar usando o tipo de catálogo do Glue. Se você não especificar um ID do catálogo, ele usará o padrão:
```
spark-submit \
--conf spark.sql.catalog.my_catalog=org.apache.iceberg.spark.SparkCatalog \
--conf spark.sql.catalog.my_catalog.warehouse=s3://amzn-s3-demo-bucket1/prefix \
--conf spark.sql.catalog.my_catalog.type=glue \
--conf spark.sql.defaultCatalog=my_catalog \
--conf spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions
```
### Conecte-se a um catálogo do AWS Glue com um ID de catálogo específico
Este exemplo mostra como se conectar usando um ID de catálogo:
```
spark-submit \
--conf spark.sql.catalog.my_catalog=org.apache.iceberg.spark.SparkCatalog \
--conf spark.sql.catalog.my_catalog.warehouse=s3://amzn-s3-demo-bucket1/prefix \
--conf spark.sql.catalog.my_catalog.type=glue \
--conf spark.sql.catalog.my_catalog.glue.id=AWS Glue catalog ID \
--conf spark.sql.defaultCatalog=my_catalog \
--conf spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions
```
Esse comando pode ser usado para se conectar a um catálogo AWS Glue em uma conta diferente, a um catálogo RMS ou a um catálogo federado.
## Usar o Iceberg REST Catalog (IRC) com o Spark Iceberg
As seções a seguir detalham como configurar a integração do Iceberg com um catálogo.
### Conecte-se ao AWS endpoint IRC do Glue Data Catalog
Veja a seguir um exemplo que demonstra um comando `spark-submit` para uso do Iceberg REST:
```
spark-submit \
--conf spark.sql.catalog.my_catalog=org.apache.iceberg.spark.SparkCatalog \
--conf spark.sql.catalog.my_catalog.warehouse=glue catalog ID \
--conf spark.sql.catalog.my_catalog.type=rest \
--conf spark.sql.catalog.my_catalog.uri=glue endpoint URI/iceberg \
--conf spark.sql.catalog.my_catalog.rest.sigv4-enabled=true \
--conf spark.sql.catalog.my_catalog.rest.signing-name=glue \
--conf spark.sql.defaultCatalog=my_catalog \
--conf spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions
```
Para utilizá-lo em um cluster habilitado para perfil de runtime, são necessárias as seguintes configurações adicionais do Spark:
```
"spark.hadoop.fs.s3.credentialsResolverClass": "software.amazon.glue.GlueTableCredentialsResolver",
"spark.hadoop.catalog-impl": "org.apache.iceberg.aws.glue.GlueCatalog",
"spark.hadoop.glue.id": glue catalog ID
"spark.hadoop.glue.endpoint": "glue endpoint"
```
Para ver a lista de URLs de endpoints do AWS Glue para cada região, consulte [Pontos de extremidade e AWS cotas do Glue](https://docs.aws.amazon.com/general/latest/gr/glue.html).
### Conectar-se a um endpoint IRC arbitrário
A seguir, é apresentado um exemplo de comando `spark-submit` para usar um endpoint IRC:
```
spark-submit \
--conf spark.sql.catalog.my_catalog=org.apache.iceberg.spark.SparkCatalog \
--conf spark.sql.catalog.my_catalog.warehouse=warehouse name \
--conf spark.sql.catalog.my_catalog.type=rest \
--conf spark.sql.catalog.my_catalog.uri=your rest endpoint \
--conf spark.sql.defaultCatalog=my_catalog \
--conf spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions
```
## Diferenças de configuração quando você usa o Iceberg versus SparkCatalog SparkSessionCatalog
O Iceberg disponibiliza duas maneiras de criar catálogos do Spark Iceberg. Você pode definir a configuração do Spark como `SparkCatalog` ou como `SparkSessionCatalog`.
### Usando o Iceberg SparkCatalog
A seguir, é mostrado o comando para usar **SparkCatalog**como catálogo do Spark Iceberg:
```
spark-shell \
--conf spark.sql.catalog.my_catalog=org.apache.iceberg.spark.SparkCatalog \
--conf spark.sql.catalog.my_catalog.warehouse=s3://amzn-s3-demo-bucket1/prefix \
--conf spark.sql.catalog.my_catalog.type=glue \
--conf spark.sql.defaultCatalog=my_catalog
```
Considerações sobre essa abordagem:
+ Você pode acessar as tabelas do Iceberg, mas nenhuma outra tabela.
+ O nome do catálogo não pode ser **spark\$1catalog**. Esse é o nome do catálogo inicial no Spark. Ele sempre se conecta a um metastore do Hive. É o catálogo padrão no Spark, a menos que o usuário o substitua usando `spark.sql.defaultCatalog`.
+ Você pode definir o `spark.sql.defaultCatalog` como o nome do seu catálogo para torná-lo o catálogo padrão.
### Usando o Iceberg SparkSessionCatalog
A seguir, é mostrado o comando para usar **SparkSessionCatalog**como catálogo do Spark Iceberg:
```
spark-shell \
--conf spark.sql.catalog.spark_catalog=org.apache.iceberg.spark.SparkSessionCatalog \
--conf spark.sql.catalog.spark_catalog.warehouse=s3://amzn-s3-demo-bucket1/prefix \
--conf spark.sql.catalog.spark_catalog.type=glue
```
Considerações sobre essa abordagem:
+ Se uma tabela não for encontrada como uma tabela do Iceberg, o Spark tentará ver se é uma tabela no metastore do Hive. Consulte [Usando o AWS Glue Data Catalog como catálogo do Hive](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-hive-metastore-glue.html) para obter mais informações.
+ O nome do catálogo não deve ser **spark\$1catalog**.
## Usar extensões do Iceberg Spark
O Iceberg oferece a extensão Spark `org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions` que os usuários podem configurar por meio da configuração de extensões do Spark `spark.sql.extensions`. As extensões habilitam recursos essenciais do Iceberg, como DELETE, UPDATE e MERGE em nível de linha, instruções e procedimentos da linguagem de definição de dados Spark específicos do Iceberg, como compactação, expiração de snapshot, ramificação e marcação, entre outros. Consulte o seguinte para obter mais detalhes:
+ Extensões de gravação do Iceberg Spark: [Gravações do Spark](https://iceberg.apache.org/docs/nightly/spark-writes/)
+ Extensões DDL do Iceberg Spark: [extensões ALTER TABLE SQL](https://iceberg.apache.org/docs/nightly/spark-ddl/#alter-table-sql-extensions/)
+ Extensões do procedimento Iceberg Spark: [Procedimentos do Spark](https://iceberg.apache.org/docs/nightly/spark-ddl/#alter-table-sql-extensions/)
## Considerações sobre o uso do Iceberg com o Spark
+ Por padrão, o Amazon EMR 6.5.0 não é compatível com a execução do Iceberg no Amazon EMR no EKS. Uma imagem personalizada do Amazon EMR 6.5.0 está disponível para que você possa passar `--jars local:///usr/share/aws/iceberg/lib/iceberg-spark3-runtime.jar` como parâmetro `spark-submit` para criar tabelas do Iceberg no Amazon EMR no EKS. Para obter mais informações, consulte [Enviar uma workload do Spark no Amazon EMR usando uma imagem personalizada](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/docker-custom-images-steps.html#docker-custom-images-submit) no *Catálogo de desenvolvimento do Amazon EMR no EKS*. Você também pode entrar em contato com Suporte para obter assistência. Desde o Amazon EMR 6.6.0, o Iceberg é compatível com o Amazon EMR no EKS.
+ Ao usar o AWS Glue como um catálogo para o Iceberg, certifique-se de que o banco de dados no qual você está criando uma tabela exista no AWS Glue. Se você estiver usando serviços como AWS Lake Formation e não conseguir carregar o catálogo, verifique se você tem acesso adequado ao serviço para executar o comando.
+ Se você usa o Iceberg SparkSessionCatalog, conforme descrito em[Diferenças de configuração quando você usa o Iceberg versus SparkCatalog SparkSessionCatalog](#emr-iceberg-spark-catalog), você deve seguir as etapas de configuração descritas em [Configurar o catálogo de dados do AWS Glue como metastore do Apache Hive](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-hive-metastore-glue.html), além de definir as configurações do catálogo de dados do Spark Iceberg Glue. AWS
# Usar um cluster do Iceberg com o Trino
Desde a versão 6.6.0 do Amazon EMR, você pode usar o Iceberg com o cluster do Trino.
Neste tutorial, você usa o AWS CLI para trabalhar com o Iceberg em um cluster Trino do Amazon EMR. Para usar o console para criar um cluster com o Iceberg instalado, siga as etapas em [Criar um data lake no Apache Iceberg usando o Amazon Athena, o Amazon EMR e o AWS Glue](https://aws.amazon.com/blogs//big-data/build-an-apache-iceberg-data-lake-using-amazon-athena-amazon-emr-and-aws-glue/).
## Criar um cluster do Iceberg
Para usar o Iceberg no Amazon EMR com AWS CLI o, primeiro crie um cluster com as etapas a seguir. Para obter informações sobre como especificar a classificação do Iceberg usando o AWS CLI, consulte [Forneça uma configuração usando o AWS CLI ao criar um cluster](emr-configure-apps-create-cluster.md#emr-configure-apps-create-cluster-cli) ou. [Fornecer uma configuração usando o SDK do Java ao criar um cluster](emr-configure-apps-create-cluster.md#emr-configure-apps-create-cluster-sdk)
1. Crie um arquivo `configurations.json` com o seguinte conteúdo. Por exemplo, se você quiser usar a metastore do Hive como catálogo, o arquivo deverá ter o conteúdo a seguir.
```
[
{
"Classification": "trino-connector-iceberg",
"Properties": {
"connector.name": "iceberg",
"hive.metastore.uri": "thrift://localhost:9083"
}
}
]
```
Se você quiser usar o AWS Glue Data Catalog como sua loja, seu arquivo deve ter o seguinte conteúdo.
```
[
{
"Classification": "trino-connector-iceberg",
"Properties": {
"connector.name": "iceberg",
"iceberg.catalog.type": "glue"
}
}
]
```
A partir do Amazon EMR 7.7.0, inclua a propriedade *fs.native-s3.enabled=true*
```
[
{
"Classification": "trino-connector-iceberg",
"Properties": {
"connector.name": "iceberg",
"iceberg.catalog.type": "glue",
"fs.native-s3.enabled": "true"
}
}
]
```
1. Crie um cluster com a seguinte configuração, substituindo o caminho do bucket do S3 e do nome da chave do exemplo pelos seus próprios.
```
aws emr create-cluster --release-label emr-6.7.0 \
--applications Name=Trino \
--region us-east-1 \
--name My_Trino_Iceberg_Cluster \
--log-uri s3://amzn-s3-demo-bucket \
--configurations file://configurations.json \
--instance-groups InstanceGroupType=MASTER,InstanceCount=1,InstanceType=c3.4xlarge InstanceGroupType=CORE,InstanceCount=3,InstanceType=c3.4xlarge \
--use-default-roles \
--ec2-attributes KeyName=
```
## Inicializar uma sessão do Trino para Iceberg
Para inicializar uma sessão no Trino, execute o comando a seguir.
```
trino-cli --catalog iceberg
```
## Gravar em uma tabela do Iceberg
Crie e grave na tabela com os comandos SQL a seguir.
```
trino> SHOW SCHEMAS;
trino> CREATE TABLE default.iceberg_table (
id int,
data varchar,
category varchar)
WITH (
format = 'PARQUET',
partitioning = ARRAY['category', 'bucket(id, 16)'],
location = 's3://amzn-s3-demo-bucket/')
trino> INSERT INTO default.iceberg_table VALUES (1,'a','c1'), (2,'b','c2'), (3,'c','c3');
```
## Ler em uma tabela do Iceberg
Para ler a tabela do Iceberg, execute o comando a seguir.
```
trino> SELECT * from default.iceberg_table;
```
## Considerações sobre o uso do Iceberg com o Trino
+ O Amazon EMR 6.5 não é nativamente compatível com o catálogo do Iceberg com o Trino. O Trino precisa do Iceberg v0.11, por isso recomendamos iniciar um cluster do Amazon EMR para Trino separado do cluster do Spark e incluir o Iceberg v0.11 neste cluster.
+ Ao usar o AWS Glue como um catálogo para o Iceberg, certifique-se de que o banco de dados no qual você está criando uma tabela exista no AWS Glue. Se você estiver usando serviços como AWS Lake Formation e não conseguir carregar o catálogo, verifique se você tem acesso adequado ao serviço para executar o comando.
+ A integração do Iceberg no Glue não funciona com o catálogo do Redshift Managed Storage.
# Usar um cluster do Iceberg com o Flink
Desde a versão 6.9.0 do Amazon EMR, você pode usar o Iceberg com um cluster do Flink sem as etapas de configuração necessárias ao usar a integração Iceberg-Flink de código aberto.
## Criar um cluster no Iceberg
É possível criar um cluster com o Iceberg instalado usando o Console de gerenciamento da AWS, a AWS CLI ou a API do Amazon EMR. Neste tutorial, você usa o AWS CLI para trabalhar com o Iceberg em um cluster do Amazon EMR. Para usar o console para criar um cluster com o Iceberg instalado, siga as etapas em [Criar um data lake no Apache Iceberg usando o Amazon Athena, o Amazon EMR e o AWS Glue](https://aws.amazon.com/blogs/big-data/build-an-apache-iceberg-data-lake-using-amazon-athena-amazon-emr-and-aws-glue/).
Para usar o Iceberg no Amazon EMR com AWS CLI o, primeiro crie um cluster com as etapas a seguir. Para obter informações sobre como especificar a classificação do Iceberg usando o AWS CLI, consulte [Forneça uma configuração usando o AWS CLI ao criar um cluster](emr-configure-apps-create-cluster.md#emr-configure-apps-create-cluster-cli) ou. [Fornecer uma configuração usando o SDK do Java ao criar um cluster](emr-configure-apps-create-cluster.md#emr-configure-apps-create-cluster-sdk) Crie um arquivo denominado `configurations.json` com o seguinte conteúdo:
```
[{
"Classification":"iceberg-defaults",
"Properties":{"iceberg.enabled":"true"}
}]
```
Em seguida, crie um cluster com a configuração a seguir, substituindo o exemplo de caminho do bucket do Amazon S3 e o ID da sub-rede pelos seus próprios valores:
```
aws emr create-cluster --release-label emr-6.9.0 \
--applications Name=Flink \
--configurations file://iceberg_configurations.json \
--region us-east-1 \
--name My_flink_Iceberg_Cluster \
--log-uri s3://amzn-s3-demo-bucket/ \
--instance-type m5.xlarge \
--instance-count 2 \
--service-role EMR_DefaultRole \
--ec2-attributes InstanceProfile=EMR_EC2_DefaultRole,SubnetId=subnet-1234567890abcdef
```
Como alternativa, é possível criar um cluster do Amazon EMR 6.9.0 contendo uma aplicação do Flink e usar o arquivo `/usr/share/aws/iceberg/lib/iceberg-flink-runtime.jar` como uma dependência do JAR em um trabalho do Flink.
## Usar o clinte SQL no Flink
O script do cliente SQL está localizado em `/usr/lib/flink/bin`. Você pode executar o script com o seguinte comando:
```
flink-yarn-session -d # starting the Flink YARN Session in detached mode
./sql-client.sh
```
Isso inicia um shell SQL no Flink.
## Exemplos do Flink
### Criar uma tabela no Iceberg
**SQL no Flink**
```
CREATE CATALOG glue_catalog WITH (
'type'='iceberg',
'warehouse'='',
'catalog-impl'='org.apache.iceberg.aws.glue.GlueCatalog',
'io-impl'='org.apache.iceberg.aws.s3.S3FileIO'
);
USE CATALOG glue_catalog;
CREATE DATABASE IF NOT EXISTS ;
USE ;
CREATE TABLE IF NOT EXISTS `glue_catalog`.``.`sample` (id int, data string);
```
**API de tabela**
```
EnvironmentSettings settings =
EnvironmentSettings.newInstance().inBatchMode().build();
TableEnvironment tEnv = TableEnvironment.create(settings);
String warehouse = "";
String db = "";
tEnv.executeSql(
"CREATE CATALOG glue_catalog WITH (\n"
+ " 'type'='iceberg',\n"
+ " 'warehouse'='"
+ warehouse
+ "',\n"
+ " 'catalog-impl'='org.apache.iceberg.aws.glue.GlueCatalog',\n"
+ " 'io-impl'='org.apache.iceberg.aws.s3.S3FileIO'\n"
+ " );");
tEnv.executeSql("USE CATALOG glue_catalog;");
tEnv.executeSql("CREATE DATABASE IF NOT EXISTS " + db + ";");
tEnv.executeSql("USE " + db + ";");
tEnv.executeSql(
"CREATE TABLE `glue_catalog`.`" + db + "`.`sample` (id bigint, data string);");
```
### Gravar em uma tabela do Iceberg
**SQL no Flink**
```
INSERT INTO `glue_catalog`.``.`sample` values (1, 'a'),(2,'b'),(3,'c');
```
**API de tabela**
```
tEnv.executeSql(
"INSERT INTO `glue_catalog`.`"
+ db
+ "`.`sample` values (1, 'a'),(2,'b'),(3,'c');");
```
**API de fluxo de dados**
```
final StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
final StreamTableEnvironment tableEnv = StreamTableEnvironment.create(env);
String db = "";
String warehouse = "";
GenericRowData rowData1 = new GenericRowData(2);
rowData1.setField(0, 1L);
rowData1.setField(1, StringData.fromString("a"));
DataStream input = env.fromElements(rowData1);
Map props = new HashMap<();
props.put("type", "iceberg");
props.put("warehouse", warehouse);
props.put("io-impl", "org.apache.iceberg.aws.s3.S3FileIO");
CatalogLoader glueCatlogLoader =
CatalogLoader.custom(
"glue",
props,
new Configuration(),
"org.apache.iceberg.aws.glue.GlueCatalog");
TableLoader tableLoader =
TableLoader.fromCatalog(glueCatlogLoader, TableIdentifier.of(db, "sample"));
DataStreamSink dataStreamSink =
FlinkSink.forRowData(input).tableLoader(tableLoader).append();
env.execute("Datastream Write");
```
### Ler em uma tabela do Iceberg
**SQL no Flink**
```
SELECT * FROM `glue_catalog`.``.`sample`;
```
**API de tabela**
```
Table result = tEnv.sqlQuery("select * from `glue_catalog`.`" + db + "`.`sample`;");
```
**API de fluxo de dados**
```
final StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
final StreamTableEnvironment tableEnv = StreamTableEnvironment.create(env);
String db = "";
String warehouse = "";
Map props = new HashMap<>();
props.put("type", "iceberg");
props.put("warehouse", warehouse);
props.put("io-impl", "org.apache.iceberg.aws.s3.S3FileIO");
CatalogLoader glueCatlogLoader =
CatalogLoader.custom(
"glue",
props,
new Configuration(),
"org.apache.iceberg.aws.glue.GlueCatalog");
TableLoader tableLoader =
TableLoader.fromCatalog(glueCatlogLoader, TableIdentifier.of(db, "sample"));
DataStream batch =
FlinkSource.forRowData().env(env).tableLoader(tableLoader).streaming(false).build();
batch.print().name("print-sink");
```
## Usar o catálogo do Hive
Certifique-se de que as dependências do Flink e do Hive sejam resolvidas conforme descrito em [Configurar o Flink com o Hive Metastore e o Catálogo do Glue](flink-configure.md#flink-configure-hive).
## Executar um trabalho do Flink
Uma forma de enviar um trabalho ao Flink é usar uma sessão do YARN do Flink por trabalho. Isso pode ser iniciado com o seguinte comando:
```
sudo flink run -m yarn-cluster -p 4 -yjm 1024m -ytm 4096m $JAR_FILE_NAME
```
## Considerações sobre o uso do Iceberg com o Flink
+ Ao usar o AWS Glue como um catálogo para o Iceberg, certifique-se de que o banco de dados no qual você está criando uma tabela exista no AWS Glue. Se você estiver usando serviços como AWS Lake Formation e não conseguir carregar o catálogo, verifique se você tem acesso adequado ao serviço para executar o comando.
+ A integração do Iceberg no Glue não funciona com o catálogo do Redshift Managed Storage.
# Usar um cluster do Iceberg com o Hive
Com as versões 6.9.0 e posteriores do Amazon EMR, você pode usar o Iceberg com um cluster do Hive sem precisar executar as etapas de configuração necessárias para a integração do IcebergHive de código aberto. Para as versões 6.8.0 e anteriores do Amazon EMR, você pode usar uma ação de bootstrap para instalar o jar `iceberg-hive-runtime` e configurar o suporte do Hive para Iceberg.
O Amazon EMR 6.9.0 inclui todos os atributos para a [integração do Hive 3.1.3 com o Iceberg 0.14.1](https://iceberg.apache.org/releases/#0140-release) e também inclui atributos adicionais do Amazon EMR, como seleção automática de mecanismos de execução compatíveis em runtime (Amazon EMR no EKS 6.9.0).
## Criar um cluster do Iceberg
Você pode criar um cluster com o Iceberg instalado usando o Console de gerenciamento da AWS, o AWS CLI ou a API do Amazon EMR. Neste tutorial, você usa o AWS CLI para trabalhar com o Iceberg em um cluster do Amazon EMR. Para usar o console para criar um cluster com o Iceberg instalado, siga as etapas em [Criar um data lake no Iceberg usando o Amazon Athena, o Amazon EMR e o AWS Glue](https://aws.amazon.com/blogs/big-data/build-an-apache-iceberg-data-lake-using-amazon-athena-amazon-emr-and-aws-glue/).
Para usar o Iceberg no Amazon EMR com AWS CLI o, primeiro crie um cluster usando as etapas abaixo. Para obter informações sobre como especificar a classificação Iceberg usando o AWS CLI ou o Java SDK, consulte ou. [Forneça uma configuração usando o AWS CLI ao criar um cluster](emr-configure-apps-create-cluster.md#emr-configure-apps-create-cluster-cli) [Fornecer uma configuração usando o SDK do Java ao criar um cluster](emr-configure-apps-create-cluster.md#emr-configure-apps-create-cluster-sdk) Crie um arquivo chamado `configurations.json` com o seguinte conteúdo:
```
[{
"Classification":"iceberg-defaults",
"Properties":{"iceberg.enabled":"true"}
}]
```
Em seguida, crie um cluster com a configuração a seguir, substituindo o exemplo de caminho do bucket do Amazon S3 e o ID da sub-rede pelos seus próprios:
```
aws emr create-cluster --release-label emr-6.9.0 \
--applications Name=Hive \
--configurations file://iceberg_configurations.json \
--region us-east-1 \
--name My_hive_Iceberg_Cluster \
--log-uri s3://amzn-s3-demo-bucket/ \
--instance-type m5.xlarge \
--instance-count 2 \
--service-role EMR_DefaultRole \
--ec2-attributes InstanceProfile=EMR_EC2_DefaultRole,SubnetId=subnet-1234567890abcdef
```
Um cluster do Iceberg no Hive faz o seguinte:
+ Carrega o jar de runtime do Hive no Iceberg no Hive e habilita a configuração relacionada ao Iceberg para o mecanismo do Hive.
+ Permite a seleção dinâmica do mecanismo de execução do Hive no Amazon EMR para impedir que os usuários configurem um mecanismo de execução compatível com o Iceberg.
**nota**
Atualmente, os clusters Hive Iceberg não são compatíveis com o AWS Glue Data Catalog. O catálogo padrão do Iceberg é `HiveCatalog`, que corresponde ao metastore configurado para o ambiente Hive. Para obter mais informações sobre gerenciamento de catálogos, consulte [Usando HCatalog](https://cwiki.apache.org/confluence/display/Hive/HCatalog+UsingHCat#HCatalogUsingHCat-UsingHCatalog) na documentação do [Apache Hive.](https://cwiki.apache.org/confluence/display/HIVE)
## Suporte a recursos
O Amazon EMR versão 6.9.0 é compatível com o Hive 3.1.3 e o Iceberg 0.14.1. O suporte a atributos é limitado aos atributos compatíveis com o Iceberg para o Hive 3.1.2 e 3.1.3. Os seguintes comandos são compatíveis:
+ Com as versões 6.9.0 a 6.12.x do Amazon EMR, você deve incluir o jar `libfb303` no diretório `auxlib` do Hive. Use o seguinte comando para instalar:
```
sudo /usr/bin/ln -sf /usr/lib/hive/lib/libfb303-*.jar /usr/lib/hive/auxlib/libfb303.jar
```
Com as versões 6.13 e posteriores do Amazon EMR, o jar `libfb303` é automaticamente vinculado ao diretório `auxlib` do Hive.
+ **Criar uma tabela**
+ **Tabela não particionada**: as tabelas externas no Hive podem ser criadas ao ser fornecido o manipulador de armazenamento da seguinte forma:
```
CREATE EXTERNAL TABLE x (i int) STORED BY 'org.apache.iceberg.mr.hive.HiveIcebergStorageHandler'
```
+ **Tabela particionada**: as tabelas externas particionadas no Hive podem ser criadas da seguinte forma:
```
CREATE EXTERNAL TABLE x (i int) PARTITIONED BY (j int) STORED BY 'org.apache.iceberg.mr.hive.HiveIcebergStorageHandler'
```
**nota**
O formato de `STORED AS` arquivo do não ORC/AVRO/PARQUET é suportado no Hive 3. A opção padrão e única é Parquet.
+ **Descartar uma tabela**: o comando `DROP TABLE` é usado para descartar tabelas, como no exemplo a seguir:
```
DROP TABLE [IF EXISTS] table_name [PURGE];
```
+ **Ler uma tabela**: as instruções `SELECT` podem ser usadas para ler tabelas do Iceberg no Hive, como no exemplo a seguir. Os mecanismos de execução compatíveis são MR e Tez.
```
SELECT * FROM table_name
```
[Para obter informações sobre a sintaxe de seleção do Hive, consulte LanguageManual Selecionar.](https://cwiki.apache.org/confluence/display/Hive/LanguageManual+Select) Para obter informações sobre instruções selecionadas com tabelas do Iceberg no Hive, consulte [Selecionar Apache Iceberg](https://iceberg.apache.org/docs/latest/hive/#select).
+ **Inserir em uma tabela**: a instrução `INSERT INTO` do HiveQL funciona em tabelas do Iceberg compatíveis somente com o mecanismo de execução do Map Reduce. Os usuários do Amazon EMR não precisam definir explicitamente o mecanismo de execução porque o Hive no Amazon EMR seleciona o mecanismo para tabelas do Iceberg no runtime.
+ **Inserção de tabela única**: exemplo:
```
INSERT INTO table_name VALUES ('a', 1);
INSERT INTO table_name SELECT...;
```
+ **Inserção de várias tabelas**: a inserção de várias tabelas não atômicas em instruções é compatível. Exemplo:
```
FROM source
INSERT INTO table_1 SELECT a, b
INSERT INTO table_2 SELECT c,d;
```
A partir do Amazon EMR 7.3.0, o Hive with Iceberg oferece suporte ao AWS Glue Data Catalog como metastore. Para usar o AWS Glue Data Catalog como metastore, defina a seguinte propriedade.
```
SET iceberg.catalog..catalog-impl=org.apache.iceberg.aws.glue.GlueCatalog;
```
Opcionalmente, você também pode definir a propriedade a seguir.
```
SET iceberg.catalog..type=glue;
```
Você pode então criar uma tabela usando o exemplo a seguir.
```
CREATE EXTERNAL TABLE table_name (col1 type1, col2 type2,..)
ROW FORMAT SERDE 'org.apache.iceberg.mr.hive.HiveIcebergSerDe'
STORED BY 'org.apache.iceberg.mr.hive.HiveIcebergStorageHandler'
location ''
TBLPROPERTIES ('table_type'='iceberg', 'iceberg.catalog'='');
```
## Considerações sobre o uso do Iceberg com o Hive
+ O Iceberg é compatível com os seguintes tipos de consulta:
+ Create table
+ Drop table
+ Inserir na tabela
+ Ler a tabela
+ Somente o mecanismo de execução MR (MapReduce) é suportado para operações de DML (linguagem de manipulação de dados), e o MR está obsoleto no Hive 3.1.3.
+ Para o Amazon EMR anterior à 7.3.0, o AWS Glue Data Catalog atualmente não é compatível com o Iceberg with Hive.
+ O tratamento de erros não é suficientemente robusto. Em casos de configuração incorreta, as inserções nas consultas podem ser concluídas com êxito. No entanto, a falha na atualização dos metadados pode resultar em perda de dados.
+ A integração do Iceberg no Glue não funciona com o catálogo do Redshift Managed Storage.
# Histórico de versões do Iceberg
A tabela a seguir lista a versão do Iceberg incluída em cada versão do Amazon EMR, além dos componentes instalados com a aplicação. Para obter as versões dos componentes em cada versão, consulte a seção Versão de componentes da sua versão em [Versões 7.x do Amazon EMR](emr-release-7x.md), [Versões de lançamento 6.x do Amazon EMR](emr-release-6x.md) ou [Versões de lançamento 5.x do Amazon EMR](emr-release-5x.md).
**Informações sobre a versão do Iceberg**
| Rótulo de versão do Amazon EMR | Versão do Iceberg | Componentes instalados com o Iceberg |
| --- | --- | --- |
| emr-7.12.0 | 1.10.0-amzn-0 | Not available. |
| emr-7.11.0 | 1.9.1-amzn-0 | Not available. |
| emr-7.10.0 | 1.8.1-amzn-0 | Not available. |
| emr-7.9.0 | 1.7.1-amzn-2 | Not available. |
| emr-7.8.0 | 1.7.1-amzn-1 | Not available. |
| emr-7.7.0 | 1.7.1-amzn-0 | Not available. |
| emr-7.6.0 | 1.6.1-amzn-2 | Not available. |
| emr-7.5.0 | 1.6.1-amzn-1 | Not available. |
| emr-7.4.0 | 1.6.1-amzn-0 | Not available. |
| emr-7.3.0 | 1.5.2-amzn-0 | Not available. |
| emr-7.2.0 | 1.5.0-amzn-0 | Not available. |
| emr-7.1.0 | 1.4.3-amzn-0 | Not available. |
| emr-7.0.0 | q1.4.2-amzn-0 | Not available. |
| emr-6.15.0 | 1.4.0-amzn-0 | Not available. |
| emr-6.14.0 | 1.3.1-amzn-0 | Not available. |
| emr-6.13.0 | 1.3.0-amzn-1 | Not available. |
| emr-6.12.0 | 1.3.0-amzn-0 | Not available. |
| emr-6.11.1 | 1.2.0-amzn-0 | Not available. |
| emr-6.11.0 | 1.2.0-amzn-0 | Not available. |
| emr-6.10.1 | 1.1.0-amzn-0 | Not available. |
| emr-6.10.0 | 1.1.0-amzn-0 | Not available. |
| emr-6.9.1 | 0.14.1-amzn-0 | Not available. |
| emr-6.9.0 | 0.14.1-amzn-0 | Not available. |
| emr-6.8.1 | 0.14.0-amzn-0 | Not available. |
| emr-6.8.0 | 0.14.0-amzn-0 | Not available. |
| emr-6.7.0 | 0.13.1-amzn-0 | Not available. |
| emr-6.6.0 | 0.13.1 | Not available. |
| emr-6.5.0 | 0.12.0 | Not available. |
# Notas da versão do Iceberg por versão
+ [Amazon EMR 6.9.0 - Notas da versão do Iceberg](Iceberg-release-history-690.md)
# Amazon EMR 6.9.0 - Notas da versão do Iceberg
## Amazon EMR 6.9.0 -Alterações no Iceberg
| Tipo | Description |
| --- | --- |
| Recurso | Integração do Flink no Amazon EMR com o Iceberg. |
| Recurso | Integração do Hive no Amazon EMR com o Iceberg. |
| Recurso | Support para armazenar arquivos de metadados do Iceberg no Amazon for Lustre FSx para melhorar o tempo de planejamento da consulta. |
| Backport | [PR 5050](https://github.com/apache/iceberg/pull/5050): Flink 1.15: suporte para opções de gravação nos comentários SQL de inserção em linha. |
| Backport | [PR 5282](https://github.com/apache/iceberg/pull/5282) AWS: Corrija falhas de repetição de PUT abrindo novos fluxos de arquivos de dados. |
| Backport | [PR 5318](https://github.com/apache/iceberg/pull/5318): Flink 1.15: Preenche a lacuna entre FlinkSource e IcebergSource (FLIP-27) e adicionou uma configuração opcional para usar a fonte FLIP-27 no Flink SQL. |
| Backport | [PR 5344](https://github.com/apache/iceberg/pull/5344): Flink 1.14: Preenche a lacuna entre FlinkSource e IcebergSource (FLIP-27) e adicionou uma configuração opcional para usar a fonte FLIP-27 no Flink SQL. |
| Backport | [PR 5393](https://github.com/apache/iceberg/pull/5393): Flink 1.14, 1.15: Evite converter métricas Iceberg MetricContext em Flink no leitor de origem FLIP-27. |
| Backport | [PR 5401](https://github.com/apache/iceberg/pull/5401): Flink 1.14, 1.15: IcebergSourceReader Grupo perdido no PR \$15393 para métricas do leitor de origem do FLIP-27. |
| Backport | [PR 5679](https://github.com/apache/iceberg/pull/5679): Spark 3.2, 3.3: Corrige a propagação de nulidade para o nó. MergeRows |
| Backport | [PR 5860](https://github.com/apache/iceberg/pull/5860): Spark 3.3: Correção QueryFailure ao executar RewriteManifestProcedure em tabelas particionadas por data. |
| Backport | [PR 5880](https://github.com/apache/iceberg/pull/5880): Spark 3.3: Corrige a nulidade nas projeções. merge-on-read |
| Backport | [PR 5917](https://github.com/apache/iceberg/pull/5917): Spark 3.2: Corrige a nulidade nas projeções. merge-on-read |