# Uso do formato XML no AWS Glue
<a name="aws-glue-programming-etl-format-xml-home"></a>

O AWS Glue recupera dados de fontes e grava dados em destinos armazenados e transportados em vários formatos de dados. Se seus dados forem armazenados ou transportados no formato de dados XML, este documento apresenta os recursos disponíveis para usar seus dados no AWS Glue. 

O AWS Glue é compatível com o uso do formato XML. Esse formato representa estruturas de dados altamente configuráveis e rigidamente definidas que não são baseadas em linhas ou colunas. O XML é altamente padronizado. Para uma introdução ao formato pela autoridade padrão, consulte [XML Essentials](https://www.w3.org/standards/xml/core) (Conceitos básicos de XML). 

Você pode usar o AWS Glue para ler arquivos XML do Amazon S3, bem como arquivos `bzip` e `gzip` contendo arquivos XML. Você configura o comportamento de compactação no [Parâmetros de conexão do S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3) e não na configuração apresentada nesta página. 

A tabela a seguir mostra quais são os recursos comuns do AWS Glue compatíveis com a opção de formato XML.


| Leitura | Escrever | Leitura de transmissão | Agrupar arquivos pequenos | Marcadores de trabalho | 
| --- | --- | --- | --- | --- | 
| Compatível | Sem compatibilidade | Sem compatibilidade | Compatível | Compatível | 

## Exemplo: ler XML do S3
<a name="aws-glue-programming-etl-format-xml-read"></a>

 O leitor de XML usa um nome de tag XML. Ele examina elementos com essa tag em sua entrada para inferir um esquema e preenche um DynamicFrame com valores correspondentes. A funcionalidade de XML do AWS Glue se comporta de modo semelhante a [XML Data Source for Apache Spark](https://github.com/databricks/spark-xml) (Fonte de dados XML para Apache Spark). Talvez você consiga obter informações sobre o comportamento básico comparando esse leitor com a documentação do projeto. 

**Pré-requisitos:** você precisará dos caminhos do S3 (`s3path`) para os arquivos ou pastas XML que deseja ler, além de algumas informações sobre seu arquivo XML. Você também precisará da tag para o elemento XML que deseja ler, `xmlTag`. 

 **Configuração:** nas opções da sua função, especifique `format="xml"`. Em seu `connection_options`, use a chave `paths` para especificar `s3path`. Você pode configurar adicionalmente como o leitor interage com o S3 no `connection_options`. Para mais detalhes, consulte os tipos de conexão e opções para ETL no AWS Glue: [Parâmetros de conexão do S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3). Em seu `format_options`, use a chave `rowTag` para especificar `xmlTag`. Você pode configurar adicionalmente como o leitor interpreta os arquivos XML em seu `format_options`. Para obter mais detalhes, consulte [XML Configuration Reference](#aws-glue-programming-etl-format-xml-reference) (Referência de configuração de XML).

O seguinte script de ETL do AWS Glue mostra o processo de leitura de arquivos ou pastas XML provenientes do S3. 

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

Neste exemplo, use o método [create\$1dynamic\$1frame.from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create_dynamic_frame_from_options).

```
# Example: Read XML from S3
# Set the rowTag option to configure the reader.

from awsglue.context import GlueContext
from pyspark.context import SparkContext

sc = SparkContext.getOrCreate()
glueContext = GlueContext(sc)

dynamicFrame = glueContext.create_dynamic_frame.from_options(
    connection_type="s3",
    connection_options={"paths": ["s3://s3path"]},
    format="xml",
    format_options={"rowTag": "xmlTag"},
)
```

Você também pode usar DataFrames em um script (`pyspark.sql.DataFrame`).

```
dataFrame = spark.read\
    .format("xml")\
    .option("rowTag", "xmlTag")\
    .load("s3://s3path")
```

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

Neste exemplo, use a operação [getSourceWithFormat](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSourceWithFormat).

```
// Example: Read XML from S3
// Set the rowTag option to configure the reader.

import com.amazonaws.services.glue.util.JsonOptions
import com.amazonaws.services.glue.GlueContext
import org.apache.spark.sql.SparkSession

val glueContext = new GlueContext(SparkContext.getOrCreate())
val sparkSession: SparkSession = glueContext.getSparkSession

object GlueApp {
  def main(sysArgs: Array[String]): Unit = {
    val dynamicFrame = glueContext.getSourceWithFormat(
      formatOptions=JsonOptions("""{"rowTag": "xmlTag"}"""), 
      connectionType="s3", 
      format="xml", 
      options=JsonOptions("""{"paths": ["s3://s3path"], "recurse": true}""")
    ).getDynamicFrame()
}
```

Você também pode usar DataFrames em um script (`org.apache.spark.sql.DataFrame`).

```
val dataFrame = spark.read
  .option("rowTag", "xmlTag")
  .format("xml")
  .load("s3://s3path“)
```

------

## Referência de configuração de XML
<a name="aws-glue-programming-etl-format-xml-reference"></a>

Você pode usar o seguinte `format_options` sempre que as bibliotecas do AWS Glue especificarem `format="xml"`:
+ `rowTag`: especifica a tag XML no arquivo a ser tratada como uma linha. Tags de linha não podem ser de fechamento automático.
  + **Tipo:** texto, **obrigatório**
+ `encoding`: especifica a codificação de caracteres. Pode ser o nome ou alias de um [Charset](https://docs.oracle.com/javase/8/docs/api/java/nio/charset/Charset.html) compatível com nosso ambiente de runtime. Não oferecemos garantias específicas em relação ao suporte à codificação, mas as codificações principais devem funcionar. 
  + **Tipo:** texto, **padrão:** `"UTF-8"`
+ `excludeAttribute`: especifica se você deseja excluir atributos em elementos ou não.
  + **Tipo:** booliano, **padrão:** `false`
+ `treatEmptyValuesAsNulls`: especifica se o espaço em branco deve ser tratado como um valor nulo.
  + **Tipo:** booliano, **padrão:** `false`
+ `attributePrefix`: um prefixo para atributos a fim de diferenciá-los de elementos de texto secundários. Esse prefixo é usado para nomes de campo.
  + **Tipo:** texto, **padrão:** `"_"`
+ `valueTag`: a tag usada para um valor quando há atributos no elemento que não têm secundários.
  + **Tipo:** texto, **padrão:** `"_VALUE"`
+ `ignoreSurroundingSpaces`: especifica se o espaço em branco que envolve valores deve ser ignorado.
  + **Tipo:** booliano, **padrão:** `false`
+ `withSchema`: contém o esquema esperado, em situações nas quais você deseja substituir o esquema inferido. Se você não usar essa opção, o AWS Glue inferirá o esquema com base nos dados XML.
  + **Tipo:** texto, **padrão:** não aplicável
  + O valor deve ser um objeto JSON que represente um `StructType`.

## Especificar manualmente o esquema XML
<a name="aws-glue-programming-etl-format-xml-withschema"></a>

**Exemplo de esquema XML manual**

Este é um exemplo de uso da opção de formato `withSchema` para especificar o esquema para dados XML.

```
from awsglue.gluetypes import *

schema = StructType([ 
  Field("id", IntegerType()),
  Field("name", StringType()),
  Field("nested", StructType([
    Field("x", IntegerType()),
    Field("y", StringType()),
    Field("z", ChoiceType([IntegerType(), StringType()]))
  ]))
])

datasource0 = create_dynamic_frame_from_options(
    connection_type, 
    connection_options={"paths": ["s3://xml_bucket/someprefix"]},
    format="xml", 
    format_options={"withSchema": json.dumps(schema.jsonValue())},
    transformation_ctx = ""
)
```