# Usar o formato ORC no AWS Glue
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 ORC, este documento apresenta os recursos disponíveis para usar seus dados no AWS Glue.
O AWS Glue é compatível com o uso do formato ORC. Esse formato é um formato de dados orientado a desempenho e baseado em colunas. Para ver uma introdução ao formato pela autoridade padrão, consulte [Apache Orc](https://orc.apache.org/docs/).
Você pode usar o AWS Glue para ler arquivos ORC do Amazon S3 e de fontes de transmissão, bem como para gravar arquivos ORC no Amazon S3. Você pode ler e gravar arquivos `bzip` e `gzip` do S3 que contenham arquivos ORC. 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 as operações comuns do AWS Glue compatíveis com a opção de formato ORC.
| Leitura | Escrever | Leitura de transmissão | Agrupar arquivos pequenos | Marcadores de trabalho |
| --- | --- | --- | --- | --- |
| Compatível | Compatível | Compatível | Sem compatibilidade | Compatível\* |
\*Compatível com o AWS Glue versão 1.0\+
## Exemplo: ler arquivos ou pastas ORC do S3
**Pré-requisitos:** você precisará dos caminhos do S3 (`s3path`) para os arquivos ou pastas ORC que deseja ler.
**Configuração:** nas opções da sua função, especifique `format="orc"`. Em seu `connection_options`, use a chave `paths` para especificar seu `s3path`. Você pode configurar 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: [Referência de opções de conexão do Amazon S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3).
O seguinte script de ETL do AWS Glue mostra o processo de leitura de arquivos ou pastas ORC provenientes do S3:
------
#### [ Python ]
Neste exemplo, use o método [create\_dynamic\_frame.from\_options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create_dynamic_frame_from_options).
```
from pyspark.context import SparkContext
from awsglue.context import GlueContext
sc = SparkContext.getOrCreate()
glueContext = GlueContext(sc)
dynamicFrame = glueContext.create_dynamic_frame.from_options(
connection_type="s3",
connection_options={"paths": ["s3://{{s3path}}"]},
format="orc"
)
```
Você também pode usar DataFrames em um script (`pyspark.sql.DataFrame`).
```
dataFrame = spark.read\
.orc("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).
```
import com.amazonaws.services.glue.util.JsonOptions
import com.amazonaws.services.glue.GlueContext
import org.apache.spark.sql.SparkContext
object GlueApp {
def main(sysArgs: Array[String]): Unit = {
val spark: SparkContext = new SparkContext()
val glueContext: GlueContext = new GlueContext(spark)
val dynamicFrame = glueContext.getSourceWithFormat(
connectionType="s3",
format="orc",
options=JsonOptions("""{"paths": ["s3://{{s3path}}"]}""")
).getDynamicFrame()
}
}
```
Você também pode usar DataFrames em um script (`pyspark.sql.DataFrame`).
```
val dataFrame = spark.read
.orc("s3://{{s3path}}")
```
------
## Exemplo: gravar arquivos e pastas ORC no S3
**Pré-requisitos:** você precisará de um DataFrame (`dataFrame`) ou de um DynamicFrame (`dynamicFrame`) inicializado. Você também precisará do caminho de saída esperado do S3, `s3path`.
**Configuração:** nas opções da sua função, especifique `format="orc"`. Em suas opções de conexão, use a chave `paths` para especificar `s3path`. Em `connection_options`, você pode alterar ainda mais a forma como o gravador interage com o S3. Para obter detalhes, consulte Opções de formato de dados para entradas e saídas de ETL no AWSGlue: [Referência de opções de conexão do Amazon S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3). O código de exemplo a seguir mostra o processo:
------
#### [ Python ]
Neste exemplo, use o método [write\_dynamic\_frame.from\_options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-write_dynamic_frame_from_options).
```
from pyspark.context import SparkContext
from awsglue.context import GlueContext
sc = SparkContext.getOrCreate()
glueContext = GlueContext(sc)
glueContext.write_dynamic_frame.from_options(
frame={{dynamicFrame}},
connection_type="s3",
format="orc",
connection_options={
"path": "s3://{{s3path}}"
}
)
```
Você também pode usar DataFrames em um script (`pyspark.sql.DataFrame`).
```
df.write.orc("s3://{{s3path}}/")
```
------
#### [ Scala ]
Neste exemplo, use o método [getSinkWithFormat](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSinkWithFormat).
```
import com.amazonaws.services.glue.util.JsonOptions
import com.amazonaws.services.glue.{DynamicFrame, GlueContext}
import org.apache.spark.SparkContext
object GlueApp {
def main(sysArgs: Array[String]): Unit = {
val spark: SparkContext = new SparkContext()
val glueContext: GlueContext = new GlueContext(spark)
glueContext.getSinkWithFormat(
connectionType="s3",
options=JsonOptions("""{"path": "s3://{{s3path}}"}"""),
format="orc"
).writeDynamicFrame({{dynamicFrame}})
}
}
```
Você também pode usar DataFrames em um script (`pyspark.sql.DataFrame`).
```
df.write.orc("s3://{{s3path}}/")
```
------
## Referência de configuração de ORC
Não há valores de `format_options` para `format="orc"`. No entanto, quaisquer opções aceitas pelo código SparkSQL subjacente podem ser transmitidas para ele por meio do parâmetro de mapa `connection_options`.