# Programando scripts de ETL do AWS Glue no Scala
É possível encontrar exemplos de código Scala e utilitários para o AWS Glue no [Repositório de exemplos do AWS Glue](https://github.com/awslabs/aws-glue-samples) no site do GitHub.
O AWS Glue oferece suporte a uma extensão do dialeto PySpark Scala para criação de scripts de trabalhos de extração, transformação e carregamento (ETL). As seções a seguir descrevem como usar a biblioteca Scala do AWS Glue e a API do AWS Glue em scripts de ETL e fornecem documentação de referência para a biblioteca.
**Contents**
+ [Usar o Scala](glue-etl-scala-using.md)
+ [Testar em um caderno do DevEndpoint](glue-etl-scala-using.md#aws-glue-programming-scala-using-notebook)
+ [Testar em um REPL do DevEndpoint](glue-etl-scala-using.md#aws-glue-programming-scala-using-repl)
+ [Exemplo de script do Scala](glue-etl-scala-example.md)
+ [Lista de APIs do Scala](glue-etl-scala-apis.md)
+ [com.amazonaws.services.glue](glue-etl-scala-apis.md#glue-etl-scala-apis-glue)
+ [com.amazonaws.services.glue.ml](glue-etl-scala-apis.md#glue-etl-scala-apis-glue-ml)
+ [com.amazonaws.services.glue.dq](glue-etl-scala-apis.md#glue-etl-scala-apis-glue-dq)
+ [com.amazonaws.services.glue.types](glue-etl-scala-apis.md#glue-etl-scala-apis-glue-types)
+ [com.amazonaws.services.glue.util](glue-etl-scala-apis.md#glue-etl-scala-apis-glue-util)
+ [ChoiceOption](glue-etl-scala-apis-glue-choiceoption.md)
+ [Característica ChoiceOption](glue-etl-scala-apis-glue-choiceoption.md#glue-etl-scala-apis-glue-choiceoption-trait)
+ [Objeto ChoiceOption](glue-etl-scala-apis-glue-choiceoption.md#glue-etl-scala-apis-glue-choiceoption-object)
+ [Aplicar](glue-etl-scala-apis-glue-choiceoption.md#glue-etl-scala-apis-glue-choiceoption-object-def-apply)
+ [ChoiceOptionWithResolver](glue-etl-scala-apis-glue-choiceoption.md#glue-etl-scala-apis-glue-choiceoptionwithresolver-case-class)
+ [MatchCatalogSchemaChoiceOption](glue-etl-scala-apis-glue-choiceoption.md#glue-etl-scala-apis-glue-matchcatalogschemachoiceoption-case-class)
+ [DataSink](glue-etl-scala-apis-glue-datasink-class.md)
+ [writeDynamicFrame](glue-etl-scala-apis-glue-datasink-class.md#glue-etl-scala-apis-glue-datasink-class-defs-writeDynamicFrame)
+ [pyWriteDynamicFrame](glue-etl-scala-apis-glue-datasink-class.md#glue-etl-scala-apis-glue-datasink-class-defs-pyWriteDynamicFrame)
+ [writeDataFrame](glue-etl-scala-apis-glue-datasink-class.md#glue-etl-scala-apis-glue-datasink-class-defs-writeDataFrame)
+ [pyWriteDataFrame](glue-etl-scala-apis-glue-datasink-class.md#glue-etl-scala-apis-glue-datasink-class-defs-pyWriteDataFrame)
+ [setCatalogInfo](glue-etl-scala-apis-glue-datasink-class.md#glue-etl-scala-apis-glue-datasink-class-defs-setCatalogInfo)
+ [supportsFormat](glue-etl-scala-apis-glue-datasink-class.md#glue-etl-scala-apis-glue-datasink-class-defs-supportsFormat)
+ [setFormat](glue-etl-scala-apis-glue-datasink-class.md#glue-etl-scala-apis-glue-datasink-class-defs-setFormat)
+ [withFormat](glue-etl-scala-apis-glue-datasink-class.md#glue-etl-scala-apis-glue-datasink-class-defs-withFormat)
+ [setAccumulableSize](glue-etl-scala-apis-glue-datasink-class.md#glue-etl-scala-apis-glue-datasink-class-defs-setAccumulableSize)
+ [getOutputErrorRecordsAccumulable](glue-etl-scala-apis-glue-datasink-class.md#glue-etl-scala-apis-glue-datasink-class-defs-getOutputErrorRecordsAccumulable)
+ [errorsAsDynamicFrame](glue-etl-scala-apis-glue-datasink-class.md#glue-etl-scala-apis-glue-datasink-class-defs-errorsAsDynamicFrame)
+ [Objeto DataSink](glue-etl-scala-apis-glue-datasink-class.md#glue-etl-scala-apis-glue-datasink-object)
+ [recordMetrics](glue-etl-scala-apis-glue-datasink-class.md#glue-etl-scala-apis-glue-datasink-object-defs-recordMetrics)
+ [Característica do DataSource](glue-etl-scala-apis-glue-datasource-trait.md)
+ [DynamicFrame](glue-etl-scala-apis-glue-dynamicframe.md)
+ [Classe DynamicFrame](glue-etl-scala-apis-glue-dynamicframe-class.md)
+ [errorsCount](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-vals-errorsCount)
+ [applyMapping](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-applyMapping)
+ [assertErrorThreshold](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-assertErrorThreshold)
+ [Contagem](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-count)
+ [dropField](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-dropField)
+ [dropFields](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-dropFields)
+ [dropNulls](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-dropNulls)
+ [errorsAsDynamicFrame](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-errorsAsDynamicFrame)
+ [Filtro](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-filter)
+ [getName](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-getName)
+ [getNumPartitions](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-getNumPartitions)
+ [getSchemaIfComputed](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-getSchemaIfComputed)
+ [isSchemaComputed](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-isSchemaComputed)
+ [javaToPython](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-javaToPython)
+ [Ingressar](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-join)
+ [Mapa](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-map)
+ [mergeDynamicFrames](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-merge)
+ [printSchema](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-printSchema)
+ [recomputeSchema](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-recomputeSchema)
+ [Relationalize](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-relationalize)
+ [renameField](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-renameField)
+ [Repartition](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-repartition)
+ [resolveChoice](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-resolveChoice)
+ [Schema](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-schema)
+ [selectField](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-selectField)
+ [selectFields](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-selectFields)
+ [Mostrar](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-show)
+ [SimplifyDDBJson](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-simplifyDDBJson)
+ [Spigot](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-spigot)
+ [splitFields](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-splitFields)
+ [Def splitRows](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-splitRows)
+ [stageErrorsCount](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-stageErrorsCount)
+ [toDF](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-toDF)
+ [Unbox](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-unbox)
+ [Unnest](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-unnest)
+ [unnestDDBJson](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-unnestddbjson)
+ [withFrameSchema](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-withFrameSchema)
+ [Def withName](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-withName)
+ [withTransformationContext](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-withTransformationContext)
+ [Objeto DynamicFrame](glue-etl-scala-apis-glue-dynamicframe-object.md)
+ [Def apply](glue-etl-scala-apis-glue-dynamicframe-object.md#glue-etl-scala-apis-glue-dynamicframe-object-defs-apply)
+ [Def emptyDynamicFrame](glue-etl-scala-apis-glue-dynamicframe-object.md#glue-etl-scala-apis-glue-dynamicframe-object-defs-emptyDynamicFrame)
+ [Def fromPythonRDD](glue-etl-scala-apis-glue-dynamicframe-object.md#glue-etl-scala-apis-glue-dynamicframe-object-defs-fromPythonRDD)
+ [Def ignoreErrors](glue-etl-scala-apis-glue-dynamicframe-object.md#glue-etl-scala-apis-glue-dynamicframe-object-defs-ignoreErrors)
+ [Def inlineErrors](glue-etl-scala-apis-glue-dynamicframe-object.md#glue-etl-scala-apis-glue-dynamicframe-object-defs-inlineErrors)
+ [Def newFrameWithErrors](glue-etl-scala-apis-glue-dynamicframe-object.md#glue-etl-scala-apis-glue-dynamicframe-object-defs-newFrameWithErrors)
+ [DynamicRecord](glue-etl-scala-apis-glue-dynamicrecord-class.md)
+ [addField](glue-etl-scala-apis-glue-dynamicrecord-class.md#glue-etl-scala-apis-glue-dynamicrecord-class-defs-addField)
+ [dropField](glue-etl-scala-apis-glue-dynamicrecord-class.md#glue-etl-scala-apis-glue-dynamicrecord-class-defs-dropField)
+ [setError](glue-etl-scala-apis-glue-dynamicrecord-class.md#glue-etl-scala-apis-glue-dynamicrecord-class-defs-setError)
+ [isError](glue-etl-scala-apis-glue-dynamicrecord-class.md#glue-etl-scala-apis-glue-dynamicrecord-class-defs-isError)
+ [getError](glue-etl-scala-apis-glue-dynamicrecord-class.md#glue-etl-scala-apis-glue-dynamicrecord-class-defs-getError)
+ [clearError](glue-etl-scala-apis-glue-dynamicrecord-class.md#glue-etl-scala-apis-glue-dynamicrecord-class-defs-clearError)
+ [Gravar](glue-etl-scala-apis-glue-dynamicrecord-class.md#glue-etl-scala-apis-glue-dynamicrecord-class-defs-write)
+ [readFields](glue-etl-scala-apis-glue-dynamicrecord-class.md#glue-etl-scala-apis-glue-dynamicrecord-class-defs-readFields)
+ [Clone](glue-etl-scala-apis-glue-dynamicrecord-class.md#glue-etl-scala-apis-glue-dynamicrecord-class-defs-clone)
+ [Schema](glue-etl-scala-apis-glue-dynamicrecord-class.md#glue-etl-scala-apis-glue-dynamicrecord-class-defs-schema)
+ [getRoot](glue-etl-scala-apis-glue-dynamicrecord-class.md#glue-etl-scala-apis-glue-dynamicrecord-class-defs-getRoot)
+ [toJson](glue-etl-scala-apis-glue-dynamicrecord-class.md#glue-etl-scala-apis-glue-dynamicrecord-class-defs-toJson)
+ [getFieldNode](glue-etl-scala-apis-glue-dynamicrecord-class.md#glue-etl-scala-apis-glue-dynamicrecord-class-defs-getFieldNode)
+ [getField](glue-etl-scala-apis-glue-dynamicrecord-class.md#glue-etl-scala-apis-glue-dynamicrecord-class-defs-getField)
+ [hashCode](glue-etl-scala-apis-glue-dynamicrecord-class.md#glue-etl-scala-apis-glue-dynamicrecord-class-defs-hashCode)
+ [Igual](glue-etl-scala-apis-glue-dynamicrecord-class.md#glue-etl-scala-apis-glue-dynamicrecord-class-defs-equals)
+ [Objeto DynamicRecord](glue-etl-scala-apis-glue-dynamicrecord-class.md#glue-etl-scala-apis-glue-dynamicrecord-object)
+ [Aplicar](glue-etl-scala-apis-glue-dynamicrecord-class.md#glue-etl-scala-apis-glue-dynamicrecord-object-defs-apply)
+ [Característica RecordTraverser](glue-etl-scala-apis-glue-dynamicrecord-class.md#glue-etl-scala-apis-glue-recordtraverser-trait)
+ [GlueContext](glue-etl-scala-apis-glue-gluecontext.md)
+ [addIngestionTimeColumns](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-addIngestionTimeColumns)
+ [createDataFrameFromOptions](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-createDataFrameFromOptions)
+ [forEachBatch](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-forEachBatch)
+ [getCatalogSink](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getCatalogSink)
+ [getCatalogSource](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getCatalogSource)
+ [getJDBCSink](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getJDBCSink)
+ [getSink](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSink)
+ [getSinkWithFormat](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSinkWithFormat)
+ [getSource](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSource)
+ [getSourceWithFormat](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSourceWithFormat)
+ [getSparkSession](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSparkSession)
+ [startTransaction](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-start-transaction)
+ [commitTransaction](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-commit-transaction)
+ [cancelTransaction](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-cancel-transaction)
+ [this](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-this-1)
+ [this](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-this-2)
+ [this](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-this-3)
+ [MappingSpec](glue-etl-scala-apis-glue-mappingspec.md)
+ [Classe do caso MappingSpec](glue-etl-scala-apis-glue-mappingspec.md#glue-etl-scala-apis-glue-mappingspec-case-class)
+ [Objeto MappingSpec](glue-etl-scala-apis-glue-mappingspec.md#glue-etl-scala-apis-glue-mappingspec-object)
+ [orderingByTarget](glue-etl-scala-apis-glue-mappingspec.md#glue-etl-scala-apis-glue-mappingspec-object-val-orderingbytarget)
+ [Aplicar](glue-etl-scala-apis-glue-mappingspec.md#glue-etl-scala-apis-glue-mappingspec-object-defs-apply-1)
+ [Aplicar](glue-etl-scala-apis-glue-mappingspec.md#glue-etl-scala-apis-glue-mappingspec-object-defs-apply-2)
+ [Aplicar](glue-etl-scala-apis-glue-mappingspec.md#glue-etl-scala-apis-glue-mappingspec-object-defs-apply-3)
+ [ResolveSpec](glue-etl-scala-apis-glue-resolvespec.md)
+ [Objeto ResolveSpec](glue-etl-scala-apis-glue-resolvespec.md#glue-etl-scala-apis-glue-resolvespec-object)
+ [Def](glue-etl-scala-apis-glue-resolvespec.md#glue-etl-scala-apis-glue-resolvespec-object-def-apply_1)
+ [Def](glue-etl-scala-apis-glue-resolvespec.md#glue-etl-scala-apis-glue-resolvespec-object-def-apply_2)
+ [Classe do caso ResolveSpec](glue-etl-scala-apis-glue-resolvespec.md#glue-etl-scala-apis-glue-resolvespec-case-class)
+ [Métodos def](glue-etl-scala-apis-glue-resolvespec.md#glue-etl-scala-apis-glue-resolvespec-case-class-defs)
+ [ArrayNode](glue-etl-scala-apis-glue-types-arraynode.md)
+ [Classe do caso ArrayNode](glue-etl-scala-apis-glue-types-arraynode.md#glue-etl-scala-apis-glue-types-arraynode-case-class)
+ [Métodos def](glue-etl-scala-apis-glue-types-arraynode.md#glue-etl-scala-apis-glue-types-arraynode-case-class-defs)
+ [BinaryNode](glue-etl-scala-apis-glue-types-binarynode.md)
+ [Classe do caso BinaryNode](glue-etl-scala-apis-glue-types-binarynode.md#glue-etl-scala-apis-glue-types-binarynode-case-class)
+ [Campos val](glue-etl-scala-apis-glue-types-binarynode.md#glue-etl-scala-apis-glue-types-binarynode-case-class-vals)
+ [Métodos def](glue-etl-scala-apis-glue-types-binarynode.md#glue-etl-scala-apis-glue-types-binarynode-case-class-defs)
+ [BooleanNode](glue-etl-scala-apis-glue-types-booleannode.md)
+ [Classe do caso BooleanNode](glue-etl-scala-apis-glue-types-booleannode.md#glue-etl-scala-apis-glue-types-booleannode-case-class)
+ [Campos val](glue-etl-scala-apis-glue-types-booleannode.md#glue-etl-scala-apis-glue-types-booleannode-case-class-vals)
+ [Métodos def](glue-etl-scala-apis-glue-types-booleannode.md#glue-etl-scala-apis-glue-types-booleannode-case-class-defs)
+ [ByteNode](glue-etl-scala-apis-glue-types-bytenode.md)
+ [Classe do caso ByteNode](glue-etl-scala-apis-glue-types-bytenode.md#glue-etl-scala-apis-glue-types-bytenode-case-class)
+ [Campos val](glue-etl-scala-apis-glue-types-bytenode.md#glue-etl-scala-apis-glue-types-bytenode-case-class-vals)
+ [Métodos def](glue-etl-scala-apis-glue-types-bytenode.md#glue-etl-scala-apis-glue-types-bytenode-case-class-defs)
+ [DateNode](glue-etl-scala-apis-glue-types-datenode.md)
+ [Classe do caso DateNode](glue-etl-scala-apis-glue-types-datenode.md#glue-etl-scala-apis-glue-types-datenode-case-class)
+ [Campos val](glue-etl-scala-apis-glue-types-datenode.md#glue-etl-scala-apis-glue-types-datenode-case-class-vals)
+ [Métodos def](glue-etl-scala-apis-glue-types-datenode.md#glue-etl-scala-apis-glue-types-datenode-case-class-defs)
+ [DecimalNode](glue-etl-scala-apis-glue-types-decimalnode.md)
+ [Classe do caso DecimalNode](glue-etl-scala-apis-glue-types-decimalnode.md#glue-etl-scala-apis-glue-types-decimalnode-case-class)
+ [Campos val](glue-etl-scala-apis-glue-types-decimalnode.md#glue-etl-scala-apis-glue-types-decimalnode-case-class-vals)
+ [Métodos def](glue-etl-scala-apis-glue-types-decimalnode.md#glue-etl-scala-apis-glue-types-decimalnode-case-class-defs)
+ [DoubleNode](glue-etl-scala-apis-glue-types-doublenode.md)
+ [Classe do caso DoubleNode](glue-etl-scala-apis-glue-types-doublenode.md#glue-etl-scala-apis-glue-types-doublenode-case-class)
+ [Campos val](glue-etl-scala-apis-glue-types-doublenode.md#glue-etl-scala-apis-glue-types-doublenode-case-class-vals)
+ [Métodos def](glue-etl-scala-apis-glue-types-doublenode.md#glue-etl-scala-apis-glue-types-doublenode-case-class-defs)
+ [DynamicNode](glue-etl-scala-apis-glue-types-dynamicnode.md)
+ [Classe DynamicNode](glue-etl-scala-apis-glue-types-dynamicnode.md#glue-etl-scala-apis-glue-types-dynamicnode-class)
+ [Métodos def](glue-etl-scala-apis-glue-types-dynamicnode.md#glue-etl-scala-apis-glue-types-dynamicnode-class-defs)
+ [Objeto DynamicNode](glue-etl-scala-apis-glue-types-dynamicnode.md#glue-etl-scala-apis-glue-types-dynamicnode-object)
+ [Métodos def](glue-etl-scala-apis-glue-types-dynamicnode.md#glue-etl-scala-apis-glue-types-dynamicnode-object-defs)
+ [EvaluateDataQuality](glue-etl-scala-apis-glue-dq-EvaluateDataQuality.md)
+ [apply](glue-etl-scala-apis-glue-dq-EvaluateDataQuality.md#glue-etl-scala-apis-glue-dq-EvaluateDataQuality-defs-apply)
+ [Exemplo](glue-etl-scala-apis-glue-dq-EvaluateDataQuality.md#glue-etl-scala-apis-glue-dq-EvaluateDataQuality-example)
+ [FloatNode](glue-etl-scala-apis-glue-types-floatnode.md)
+ [Classe do caso FloatNode](glue-etl-scala-apis-glue-types-floatnode.md#glue-etl-scala-apis-glue-types-floatnode-case-class)
+ [Campos val](glue-etl-scala-apis-glue-types-floatnode.md#glue-etl-scala-apis-glue-types-floatnode-case-class-vals)
+ [Métodos def](glue-etl-scala-apis-glue-types-floatnode.md#glue-etl-scala-apis-glue-types-floatnode-case-class-defs)
+ [FillMissingValues](glue-etl-scala-apis-glue-ml-fillmissingvalues.md)
+ [Aplicar](glue-etl-scala-apis-glue-ml-fillmissingvalues.md#glue-etl-scala-apis-glue-ml-fillmissingvalues-defs-apply)
+ [FindMatches](glue-etl-scala-apis-glue-ml-findmatches.md)
+ [Aplicar](glue-etl-scala-apis-glue-ml-findmatches.md#glue-etl-scala-apis-glue-ml-findmatches-defs-apply)
+ [FindIncrementalMatches](glue-etl-scala-apis-glue-ml-findincrementalmatches.md)
+ [Aplicar](glue-etl-scala-apis-glue-ml-findincrementalmatches.md#glue-etl-scala-apis-glue-ml-findincrementalmatches-defs-apply)
+ [IntegerNode](glue-etl-scala-apis-glue-types-integernode.md)
+ [Classe do caso IntegerNode](glue-etl-scala-apis-glue-types-integernode.md#glue-etl-scala-apis-glue-types-integernode-case-class)
+ [Campos val](glue-etl-scala-apis-glue-types-integernode.md#glue-etl-scala-apis-glue-types-integernode-case-class-vals)
+ [Métodos def](glue-etl-scala-apis-glue-types-integernode.md#glue-etl-scala-apis-glue-types-integernode-case-class-defs)
+ [LongNode](glue-etl-scala-apis-glue-types-longnode.md)
+ [Classe do caso LongNode](glue-etl-scala-apis-glue-types-longnode.md#glue-etl-scala-apis-glue-types-longnode-case-class)
+ [Campos val](glue-etl-scala-apis-glue-types-longnode.md#glue-etl-scala-apis-glue-types-longnode-case-class-vals)
+ [Métodos def](glue-etl-scala-apis-glue-types-longnode.md#glue-etl-scala-apis-glue-types-longnode-case-class-defs)
+ [MapLikeNode](glue-etl-scala-apis-glue-types-maplikenode.md)
+ [Classe MapLikeNode](glue-etl-scala-apis-glue-types-maplikenode.md#glue-etl-scala-apis-glue-types-maplikenode-class)
+ [Métodos def](glue-etl-scala-apis-glue-types-maplikenode.md#glue-etl-scala-apis-glue-types-maplikenode-class-defs)
+ [MapNode](glue-etl-scala-apis-glue-types-mapnode.md)
+ [Classe do caso MapNode](glue-etl-scala-apis-glue-types-mapnode.md#glue-etl-scala-apis-glue-types-mapnode-case-class)
+ [Métodos def](glue-etl-scala-apis-glue-types-mapnode.md#glue-etl-scala-apis-glue-types-mapnode-case-class-defs)
+ [NullNode](glue-etl-scala-apis-glue-types-nullnode.md)
+ [Classe NullNode](glue-etl-scala-apis-glue-types-nullnode.md#glue-etl-scala-apis-glue-types-nullnode-class)
+ [Objeto do caso NullNode](glue-etl-scala-apis-glue-types-nullnode.md#glue-etl-scala-apis-glue-types-nullnode-case-object)
+ [ObjectNode](glue-etl-scala-apis-glue-types-objectnode.md)
+ [Objeto ObjectNode](glue-etl-scala-apis-glue-types-objectnode.md#glue-etl-scala-apis-glue-types-objectnode-object)
+ [Métodos def](glue-etl-scala-apis-glue-types-objectnode.md#glue-etl-scala-apis-glue-types-objectnode-object-defs)
+ [Classe do caso ObjectNode](glue-etl-scala-apis-glue-types-objectnode.md#glue-etl-scala-apis-glue-types-objectnode-case-class)
+ [Métodos def](glue-etl-scala-apis-glue-types-objectnode.md#glue-etl-scala-apis-glue-types-objectnode-case-class-defs)
+ [ScalarNode](glue-etl-scala-apis-glue-types-scalarnode.md)
+ [Classe ScalarNode](glue-etl-scala-apis-glue-types-scalarnode.md#glue-etl-scala-apis-glue-types-scalarnode-class)
+ [Métodos def](glue-etl-scala-apis-glue-types-scalarnode.md#glue-etl-scala-apis-glue-types-scalarnode-class-defs)
+ [Objeto ScalarNode](glue-etl-scala-apis-glue-types-scalarnode.md#glue-etl-scala-apis-glue-types-scalarnode-object)
+ [Métodos def](glue-etl-scala-apis-glue-types-scalarnode.md#glue-etl-scala-apis-glue-types-scalarnode-object-defs)
+ [ShortNode](glue-etl-scala-apis-glue-types-shortnode.md)
+ [Classe do caso ShortNode](glue-etl-scala-apis-glue-types-shortnode.md#glue-etl-scala-apis-glue-types-shortnode-case-class)
+ [Campos val](glue-etl-scala-apis-glue-types-shortnode.md#glue-etl-scala-apis-glue-types-shortnode-case-class-vals)
+ [Métodos def](glue-etl-scala-apis-glue-types-shortnode.md#glue-etl-scala-apis-glue-types-shortnode-case-class-defs)
+ [StringNode](glue-etl-scala-apis-glue-types-stringnode.md)
+ [Classe do caso StringNode](glue-etl-scala-apis-glue-types-stringnode.md#glue-etl-scala-apis-glue-types-stringnode-case-class)
+ [Campos val](glue-etl-scala-apis-glue-types-stringnode.md#glue-etl-scala-apis-glue-types-stringnode-case-class-vals)
+ [Métodos def](glue-etl-scala-apis-glue-types-stringnode.md#glue-etl-scala-apis-glue-types-stringnode-case-class-defs)
+ [TimestampNode](glue-etl-scala-apis-glue-types-timestampnode.md)
+ [Classe do caso TimestampNode](glue-etl-scala-apis-glue-types-timestampnode.md#glue-etl-scala-apis-glue-types-timestampnode-case-class)
+ [Campos val](glue-etl-scala-apis-glue-types-timestampnode.md#glue-etl-scala-apis-glue-types-timestampnode-case-class-vals)
+ [Métodos def](glue-etl-scala-apis-glue-types-timestampnode.md#glue-etl-scala-apis-glue-types-timestampnode-case-class-defs)
+ [GlueArgParser](glue-etl-scala-apis-glue-util-glueargparser.md)
+ [Objeto GlueArgParser](glue-etl-scala-apis-glue-util-glueargparser.md#glue-etl-scala-apis-glue-util-glueargparser-object)
+ [Métodos def](glue-etl-scala-apis-glue-util-glueargparser.md#glue-etl-scala-apis-glue-util-glueargparser-object-defs)
+ [Trabalho](glue-etl-scala-apis-glue-util-job.md)
+ [Objeto Job](glue-etl-scala-apis-glue-util-job.md#glue-etl-scala-apis-glue-util-job-object)
+ [Métodos def](glue-etl-scala-apis-glue-util-job.md#glue-etl-scala-apis-glue-util-job-object-defs)
# Usar o Scala para programar scripts de ETL do AWS Glue
Você pode gerar automaticamente um programa Scala de extração, transformação e carga (ETL) usando o console do AWS Glue e modificá-lo conforme necessário antes de atribui-lo a um trabalho. Ou, você pode escrever seu próprio programa do zero. Para obter mais informações, consulte [Configurar propriedades de trabalho para trabalhos do Spark no AWS Glue](add-job.md). Em seguida, o AWS Glue compila seu programa Scala no servidor antes de executar o trabalho associado.
Para ter certeza de que seu programa compila sem erros e é executado como esperado, é muito importante carregá-lo em um endpoint de desenvolvimento em um REPL (Read-Eval-Print Loop) ou em um caderno Jupyter e testá-lo antes de executá-lo em um trabalho. Como o processo de compilação ocorre no servidor, você não terá uma boa visibilidade dos problemas que ocorrem lá.
## Testar um programa de ETL Scala em um caderno Jupyter em um endpoint de desenvolvimento
Para testar um programa Scala em um endpoint de desenvolvimento do AWS Glue, configure o endpoint de desenvolvimento conforme descrito em [Adicionar um endpoint de desenvolvimento](add-dev-endpoint.md).
Em seguida, conecte-o a um caderno Jupyter que esteja em execução localmente na sua máquina ou remotamente em um servidor de cadernos do Amazon EC2. Para instalar uma versão local de um caderno Jupyter, siga as instruções em [Tutorial: caderno Jupyter no JupyterLab](dev-endpoint-tutorial-local-jupyter.md).
A única diferença entre executar o código Scala e executar o código PySpark no seu notebook é que você deve iniciar cada parágrafo no notebook com o seguinte:
```
%spark
```
Isso impede que o servidor do notebook seja padronizado para o tipo do PySpark do intérprete Spark.
## Testar um programa de ETL Scala em um Scala REPL
Você pode testar um programa Scala em um endpoint do desenvolvedor usando o Scala REPL do AWS Glue. Siga as instruções em [Tutorial: usar um caderno do SageMaker AITutorial: usar um shell REPL](dev-endpoint-tutorial-repl.md), exceto no final do comando SSH para REPL, substitua `-t gluepyspark` por `-t glue-spark-shell`. Isso invoca o Scala REPL do AWS Glue.
Para fechar o REPL quando você concluir, digite `sys.exit`.
# Exemplo de script do Scala: ETL de transmissão
**Example**
O script de exemplo a seguir se conecta ao Amazon Kinesis Data Streams, usa um esquema do Data Catalog para analisar um fluxo de dados, une o fluxo a um conjunto de dados estático no Amazon S3 e gera os resultados unidos no Amazon S3 em formato parquet.
```
// This script connects to an Amazon Kinesis stream, uses a schema from the data catalog to parse the stream,
// joins the stream to a static dataset on Amazon S3, and outputs the joined results to Amazon S3 in parquet format.
import com.amazonaws.services.glue.GlueContext
import com.amazonaws.services.glue.util.GlueArgParser
import com.amazonaws.services.glue.util.Job
import java.util.Calendar
import org.apache.spark.SparkContext
import org.apache.spark.sql.Dataset
import org.apache.spark.sql.Row
import org.apache.spark.sql.SaveMode
import org.apache.spark.sql.SparkSession
import org.apache.spark.sql.functions.from_json
import org.apache.spark.sql.streaming.Trigger
import scala.collection.JavaConverters._
object streamJoiner {
def main(sysArgs: Array[String]) {
val spark: SparkContext = new SparkContext()
val glueContext: GlueContext = new GlueContext(spark)
val sparkSession: SparkSession = glueContext.getSparkSession
import sparkSession.implicits._
// @params: [JOB_NAME]
val args = GlueArgParser.getResolvedOptions(sysArgs, Seq("JOB_NAME").toArray)
Job.init(args("JOB_NAME"), glueContext, args.asJava)
val staticData = sparkSession.read // read() returns type DataFrameReader
.format("csv")
.option("header", "true")
.load("s3://amzn-s3-demo-bucket/inputs/productsStatic.csv") // load() returns a DataFrame
val datasource0 = sparkSession.readStream // readstream() returns type DataStreamReader
.format("kinesis")
.option("streamName", "stream-join-demo")
.option("endpointUrl", "https://kinesis.us-east-1.amazonaws.com")
.option("startingPosition", "TRIM_HORIZON")
.load // load() returns a DataFrame
val selectfields1 = datasource0.select(from_json($"data".cast("string"), glueContext.getCatalogSchemaAsSparkSchema("stream-demos", "stream-join-demo2")) as "data").select("data.*")
val datasink2 = selectfields1.writeStream.foreachBatch { (dataFrame: Dataset[Row], batchId: Long) => { //foreachBatch() returns type DataStreamWriter
val joined = dataFrame.join(staticData, "product_id")
val year: Int = Calendar.getInstance().get(Calendar.YEAR)
val month :Int = Calendar.getInstance().get(Calendar.MONTH) + 1
val day: Int = Calendar.getInstance().get(Calendar.DATE)
val hour: Int = Calendar.getInstance().get(Calendar.HOUR_OF_DAY)
if (dataFrame.count() > 0) {
joined.write // joined.write returns type DataFrameWriter
.mode(SaveMode.Append)
.format("parquet")
.option("quote", " ")
.save("s3://amzn-s3-demo-bucket/output/" + "/year=" + "%04d".format(year) + "/month=" + "%02d".format(month) + "/day=" + "%02d".format(day) + "/hour=" + "%02d".format(hour) + "/")
}
}
} // end foreachBatch()
.trigger(Trigger.ProcessingTime("100 seconds"))
.option("checkpointLocation", "s3://amzn-s3-demo-bucket/checkpoint/")
.start().awaitTermination() // start() returns type StreamingQuery
Job.commit()
}
}
```
# APIs na biblioteca Scala no AWS Glue
O AWS Glue oferece suporte a uma extensão do dialeto PySpark Scala para trabalhos de extração, transformação e carregamento (ETL) em script. As seções a seguir descrevem as APIs na biblioteca Scala do AWS Glue.
## com.amazonaws.services.glue
O pacote **com.amazonaws.services.glue** na biblioteca Scala do AWS Glue contém as seguintes APIs:
+ [ChoiceOption](glue-etl-scala-apis-glue-choiceoption.md)
+ [DataSink](glue-etl-scala-apis-glue-datasink-class.md)
+ [Característica do DataSource](glue-etl-scala-apis-glue-datasource-trait.md)
+ [DynamicFrame](glue-etl-scala-apis-glue-dynamicframe.md)
+ [DynamicRecord](glue-etl-scala-apis-glue-dynamicrecord-class.md)
+ [GlueContext](glue-etl-scala-apis-glue-gluecontext.md)
+ [MappingSpec](glue-etl-scala-apis-glue-mappingspec.md)
+ [ResolveSpec](glue-etl-scala-apis-glue-resolvespec.md)
## com.amazonaws.services.glue.ml
O pacote **com.amazonaws.services.glue.ml** na biblioteca de Scala do AWS Glue contém as seguintes APIs:
+ [FillMissingValues](glue-etl-scala-apis-glue-ml-fillmissingvalues.md)
+ [FindIncrementalMatches](glue-etl-scala-apis-glue-ml-findincrementalmatches.md)
+ [FindMatches](glue-etl-scala-apis-glue-ml-findmatches.md)
## com.amazonaws.services.glue.dq
O pacote **com.amazonaws.services.glue.ml** na biblioteca Sacal da AWS Gluecontém as seguintes APIs:
+ [EvaluateDataQuality](glue-etl-scala-apis-glue-dq-EvaluateDataQuality.md)
## com.amazonaws.services.glue.types
O pacote **com.amazonaws.services.glue.types** na biblioteca Scala do AWS Glue contém as seguintes APIs:
+ [ArrayNode](glue-etl-scala-apis-glue-types-arraynode.md)
+ [BinaryNode](glue-etl-scala-apis-glue-types-binarynode.md)
+ [BooleanNode](glue-etl-scala-apis-glue-types-booleannode.md)
+ [ByteNode](glue-etl-scala-apis-glue-types-bytenode.md)
+ [DateNode](glue-etl-scala-apis-glue-types-datenode.md)
+ [DecimalNode](glue-etl-scala-apis-glue-types-decimalnode.md)
+ [DoubleNode](glue-etl-scala-apis-glue-types-doublenode.md)
+ [DynamicNode](glue-etl-scala-apis-glue-types-dynamicnode.md)
+ [FloatNode](glue-etl-scala-apis-glue-types-floatnode.md)
+ [IntegerNode](glue-etl-scala-apis-glue-types-integernode.md)
+ [LongNode](glue-etl-scala-apis-glue-types-longnode.md)
+ [MapLikeNode](glue-etl-scala-apis-glue-types-maplikenode.md)
+ [MapNode](glue-etl-scala-apis-glue-types-mapnode.md)
+ [NullNode](glue-etl-scala-apis-glue-types-nullnode.md)
+ [ObjectNode](glue-etl-scala-apis-glue-types-objectnode.md)
+ [ScalarNode](glue-etl-scala-apis-glue-types-scalarnode.md)
+ [ShortNode](glue-etl-scala-apis-glue-types-shortnode.md)
+ [StringNode](glue-etl-scala-apis-glue-types-stringnode.md)
+ [TimestampNode](glue-etl-scala-apis-glue-types-timestampnode.md)
## com.amazonaws.services.glue.util
O pacote **com.amazonaws.services.glue.util** na biblioteca Scala do AWS Glue contém as seguintes APIs:
+ [GlueArgParser](glue-etl-scala-apis-glue-util-glueargparser.md)
+ [Trabalho](glue-etl-scala-apis-glue-util-job.md)
# APIs ChoiceOption em Scala no AWS Glue
**Topics**
+ [Característica ChoiceOption](#glue-etl-scala-apis-glue-choiceoption-trait)
+ [Objeto ChoiceOption](#glue-etl-scala-apis-glue-choiceoption-object)
+ [Classe do caso ChoiceOptionWithResolver](#glue-etl-scala-apis-glue-choiceoptionwithresolver-case-class)
+ [Classe do caso MatchCatalogSchemaChoiceOption](#glue-etl-scala-apis-glue-matchcatalogschemachoiceoption-case-class)
**Pacote: com.amazonaws.services.glue**
## Característica ChoiceOption
```
trait ChoiceOption extends Serializable
```
## Objeto ChoiceOption
**ChoiceOption**
```
object ChoiceOption
```
Uma estratégia geral para determinar a opção aplicável a todos os nós `ChoiceType` em um `DynamicFrame`.
+ `val CAST`
+ `val MAKE_COLS`
+ `val MAKE_STRUCT`
+ `val MATCH_CATALOG`
+ `val PROJECT`
### Def apply
```
def apply(choice: String): ChoiceOption
```
## Classe do caso ChoiceOptionWithResolver
```
case class ChoiceOptionWithResolver(name: String, choiceResolver: ChoiceResolver) extends ChoiceOption {}
```
## Classe do caso MatchCatalogSchemaChoiceOption
```
case class MatchCatalogSchemaChoiceOption() extends ChoiceOption {}
```
# Classe abstrata DataSink
**Topics**
+ [Def writeDynamicFrame](#glue-etl-scala-apis-glue-datasink-class-defs-writeDynamicFrame)
+ [Def pyWriteDynamicFrame](#glue-etl-scala-apis-glue-datasink-class-defs-pyWriteDynamicFrame)
+ [Def WriteDataFrame](#glue-etl-scala-apis-glue-datasink-class-defs-writeDataFrame)
+ [Def pyWriteDataFrame](#glue-etl-scala-apis-glue-datasink-class-defs-pyWriteDataFrame)
+ [Def setCatalogInfo](#glue-etl-scala-apis-glue-datasink-class-defs-setCatalogInfo)
+ [Def supportsFormat](#glue-etl-scala-apis-glue-datasink-class-defs-supportsFormat)
+ [Def setFormat](#glue-etl-scala-apis-glue-datasink-class-defs-setFormat)
+ [Def withFormat](#glue-etl-scala-apis-glue-datasink-class-defs-withFormat)
+ [Def setAccumulableSize](#glue-etl-scala-apis-glue-datasink-class-defs-setAccumulableSize)
+ [Def getOutputErrorRecordsAccumulable](#glue-etl-scala-apis-glue-datasink-class-defs-getOutputErrorRecordsAccumulable)
+ [Def errorsAsDynamicFrame](#glue-etl-scala-apis-glue-datasink-class-defs-errorsAsDynamicFrame)
+ [Objeto DataSink](#glue-etl-scala-apis-glue-datasink-object)
**Pacote: com.amazonaws.services.glue**
```
abstract class DataSink
```
O gravador analógico a um `DataSource`. O `DataSink` encapsula um destino e um formato no qual um `DynamicFrame` pode ser gravado.
## Def writeDynamicFrame
```
def writeDynamicFrame( frame : DynamicFrame,
callSite : CallSite = CallSite("Not provided", "")
) : DynamicFrame
```
## Def pyWriteDynamicFrame
```
def pyWriteDynamicFrame( frame : DynamicFrame,
site : String = "Not provided",
info : String = "" )
```
## Def WriteDataFrame
```
def writeDataFrame(frame: DataFrame,
glueContext: GlueContext,
callSite: CallSite = CallSite("Not provided", "")
): DataFrame
```
## Def pyWriteDataFrame
```
def pyWriteDataFrame(frame: DataFrame,
glueContext: GlueContext,
site: String = "Not provided",
info: String = ""
): DataFrame
```
## Def setCatalogInfo
```
def setCatalogInfo(catalogDatabase: String,
catalogTableName : String,
catalogId : String = "")
```
## Def supportsFormat
```
def supportsFormat( format : String ) : Boolean
```
## Def setFormat
```
def setFormat( format : String,
options : JsonOptions
) : Unit
```
## Def withFormat
```
def withFormat( format : String,
options : JsonOptions = JsonOptions.empty
) : DataSink
```
## Def setAccumulableSize
```
def setAccumulableSize( size : Int ) : Unit
```
## Def getOutputErrorRecordsAccumulable
```
def getOutputErrorRecordsAccumulable : Accumulable[List[OutputError], OutputError]
```
## Def errorsAsDynamicFrame
```
def errorsAsDynamicFrame : DynamicFrame
```
## Objeto DataSink
```
object DataSink
```
### Def recordMetrics
```
def recordMetrics( frame : DynamicFrame,
ctxt : String
) : DynamicFrame
```
# Característica DataSource Scala do AWS Glue
**Pacote: com.amazonaws.services.glue**
Uma interface de alto nível para produzir um `DynamicFrame`.
```
trait DataSource {
def getDynamicFrame : DynamicFrame
def getDynamicFrame( minPartitions : Int,
targetPartitions : Int
) : DynamicFrame
def getDataFrame : DataFrame
/** @param num: the number of records for sampling.
* @param options: optional parameters to control sampling behavior. Current available parameter for Amazon S3 sources in options:
* 1. maxSamplePartitions: the maximum number of partitions the sampling will read.
* 2. maxSampleFilesPerPartition: the maximum number of files the sampling will read in one partition.
*/
def getSampleDynamicFrame(num:Int, options: JsonOptions = JsonOptions.empty): DynamicFrame
def glueContext : GlueContext
def setFormat( format : String,
options : String
) : Unit
def setFormat( format : String,
options : JsonOptions
) : Unit
def supportsFormat( format : String ) : Boolean
def withFormat( format : String,
options : JsonOptions = JsonOptions.empty
) : DataSource
}
```
# APIs DynamicFrame em Scala do AWS Glue
**Pacote: com.amazonaws.services.glue**
**Contents**
+ [Classe DynamicFrame em Scala do AWS Glue](glue-etl-scala-apis-glue-dynamicframe-class.md)
+ [Val errorsCount](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-vals-errorsCount)
+ [Def applyMapping](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-applyMapping)
+ [Def assertErrorThreshold](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-assertErrorThreshold)
+ [Def count](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-count)
+ [Def dropField](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-dropField)
+ [Def dropFields](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-dropFields)
+ [Def dropNulls](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-dropNulls)
+ [Def errorsAsDynamicFrame](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-errorsAsDynamicFrame)
+ [Def filter](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-filter)
+ [Def getName](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-getName)
+ [Def getNumPartitions](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-getNumPartitions)
+ [Def getSchemaIfComputed](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-getSchemaIfComputed)
+ [Def isSchemaComputed](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-isSchemaComputed)
+ [Def javaToPython](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-javaToPython)
+ [Def join](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-join)
+ [Def map](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-map)
+ [Def mergeDynamicFrames](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-merge)
+ [Def printSchema](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-printSchema)
+ [Def recomputeSchema](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-recomputeSchema)
+ [Def relationalize](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-relationalize)
+ [Def renameField](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-renameField)
+ [Def repartition](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-repartition)
+ [Def resolveChoice](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-resolveChoice)
+ [Def schema](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-schema)
+ [Def selectField](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-selectField)
+ [Def selectFields](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-selectFields)
+ [Def show](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-show)
+ [Def simplifyDDBJson](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-simplifyDDBJson)
+ [Def spigot](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-spigot)
+ [Def splitFields](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-splitFields)
+ [Def splitRows](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-splitRows)
+ [Def stageErrorsCount](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-stageErrorsCount)
+ [Def toDF](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-toDF)
+ [Def unbox](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-unbox)
+ [Def unnest](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-unnest)
+ [Def unnestDDBJson](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-unnestddbjson)
+ [Def withFrameSchema](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-withFrameSchema)
+ [Def withName](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-withName)
+ [Def withTransformationContext](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-withTransformationContext)
+ [O objeto DynamicFrame](glue-etl-scala-apis-glue-dynamicframe-object.md)
+ [Def apply](glue-etl-scala-apis-glue-dynamicframe-object.md#glue-etl-scala-apis-glue-dynamicframe-object-defs-apply)
+ [Def emptyDynamicFrame](glue-etl-scala-apis-glue-dynamicframe-object.md#glue-etl-scala-apis-glue-dynamicframe-object-defs-emptyDynamicFrame)
+ [Def fromPythonRDD](glue-etl-scala-apis-glue-dynamicframe-object.md#glue-etl-scala-apis-glue-dynamicframe-object-defs-fromPythonRDD)
+ [Def ignoreErrors](glue-etl-scala-apis-glue-dynamicframe-object.md#glue-etl-scala-apis-glue-dynamicframe-object-defs-ignoreErrors)
+ [Def inlineErrors](glue-etl-scala-apis-glue-dynamicframe-object.md#glue-etl-scala-apis-glue-dynamicframe-object-defs-inlineErrors)
+ [Def newFrameWithErrors](glue-etl-scala-apis-glue-dynamicframe-object.md#glue-etl-scala-apis-glue-dynamicframe-object-defs-newFrameWithErrors)
# Classe DynamicFrame em Scala do AWS Glue
**Pacote: com.amazonaws.services.glue**
```
class DynamicFrame extends Serializable with Logging (
val glueContext : GlueContext,
_records : RDD[DynamicRecord],
val name : String = s"",
val transformationContext : String = DynamicFrame.UNDEFINED,
callSite : CallSite = CallSite("Not provided", ""),
stageThreshold : Long = 0,
totalThreshold : Long = 0,
prevErrors : => Long = 0,
errorExpr : => Unit = {} )
```
Um `DynamicFrame` é uma coleção distribuída de objetos autodescritivos [DynamicRecord](glue-etl-scala-apis-glue-dynamicrecord-class.md).
`DynamicFrame`s são projetados para fornecer um modelo de dados flexível para operações de ETL (extração, transformação e carregamento). Eles não exigem um esquema para criar e podem ser usados para ler e transformar dados com valores e tipos confusos ou inconsistentes. Um esquema pode ser calculado sob demanda para as operações que precisam de um.
`DynamicFrame` fornece uma variedade de transformações para limpeza de dados e ETL. Eles também suportam conversão de e para os DataFrames SparkSQL para integração com o código existente e as muitas operações de analytics que os DataFrames fornecem.
Os seguintes parâmetros são compartilhados em muitas das transformações do AWS Glue que constroem `DynamicFrame`s:
+ `transformationContext` — o identificador para esse `DynamicFrame`. O `transformationContext` é usado como uma chave para o estado do marcador de trabalho que é mantido nas execuções.
+ `callSite`: fornece informações de contexto para o relatório de erros. Esses valores são definidos automaticamente quando chamados do Python.
+ `stageThreshold` — O número máximo de registros de erros permitido a partir da computação desse `DynamicFrame` antes de lançar uma exceção, excluindo os registros presentes no `DynamicFrame` anterior.
+ `totalThreshold` – O número máximo de registros de erros totais antes que uma exceção seja lançada, incluindo os de quadros anteriores.
## Val errorsCount
```
val errorsCount
```
O número de registros de erros neste `DynamicFrame`. Isso inclui erros de operações anteriores.
## Def applyMapping
```
def applyMapping( mappings : Seq[Product4[String, String, String, String]],
caseSensitive : Boolean = true,
transformationContext : String = "",
callSite : CallSite = CallSite("Not provided", ""),
stageThreshold : Long = 0,
totalThreshold : Long = 0
) : DynamicFrame
```
+ `mappings` — Uma sequência de mapeamentos para construir um novo `DynamicFrame`.
+ `caseSensitive`: informa se deve ou não tratar as colunas de origem como colunas que diferenciam letras maiúsculas de minúsculas. Definir essa opção como false pode ajudar na integração com armazenamentos que não diferenciam maiúsculas de minúsculas, como o AWS Glue Data Catalog.
Seleciona, projeta e converte colunas com base em uma sequência de mapeamentos.
Cada mapeamento é composto por uma coluna e um tipo de origem e uma coluna e um tipo de destino. Mapeamentos podem ser especificados como um objeto 4-tuple (`source_path`, `source_type`,` target_path`, `target_type`) or a [MappingSpec](glue-etl-scala-apis-glue-mappingspec.md) que contém a mesma informação.
Além de usar mapeamentos para projeções simples e da conversão, você pode usar os mapeamentos para aninhar ou desaninhar campos, separando os componentes do caminho com '`.`' (ponto).
Por exemplo, digamos que você tem um `DynamicFrame` com o seguinte esquema.
```
{{{
root
|-- name: string
|-- age: int
|-- address: struct
| |-- state: string
| |-- zip: int
}}}
```
Você pode fazer a seguinte chamada para desaninhar os campos `state` e `zip`.
```
{{{
df.applyMapping(
Seq(("name", "string", "name", "string"),
("age", "int", "age", "int"),
("address.state", "string", "state", "string"),
("address.zip", "int", "zip", "int")))
}}}
```
O esquema resultante será o seguinte.
```
{{{
root
|-- name: string
|-- age: int
|-- state: string
|-- zip: int
}}}
```
Você também pode usar `applyMapping` para aninhar novamente as colunas. Por exemplo, o seguinte inverte a transformação anterior e cria uma estrutura chamada `address` no destino.
```
{{{
df.applyMapping(
Seq(("name", "string", "name", "string"),
("age", "int", "age", "int"),
("state", "string", "address.state", "string"),
("zip", "int", "address.zip", "int")))
}}}
```
Os nomes de campo que contêm caracteres '`.`' (período) pode ser cotado usando acentos graves (````).
**nota**
Atualmente, você não pode usar o método `applyMapping` para mapear colunas que estão aninhadas sob arrays.
## Def assertErrorThreshold
```
def assertErrorThreshold : Unit
```
Uma ação que força a computação e verifica se o número de registros de erros está abaixo de `stageThreshold` e de `totalThreshold`. Lança uma exceção se a condição falhar.
## Def count
```
lazy
def count
```
Retorna o número de elementos neste `DynamicFrame`.
## Def dropField
```
def dropField( path : String,
transformationContext : String = "",
callSite : CallSite = CallSite("Not provided", ""),
stageThreshold : Long = 0,
totalThreshold : Long = 0
) : DynamicFrame
```
Retorna um novo `DynamicFrame` com a coluna especificada removida.
## Def dropFields
```
def dropFields( fieldNames : Seq[String], // The column names to drop.
transformationContext : String = "",
callSite : CallSite = CallSite("Not provided", ""),
stageThreshold : Long = 0,
totalThreshold : Long = 0
) : DynamicFrame
```
Retorna um novo `DynamicFrame` com as colunas especificadas removidas.
Esse método pode ser usado para excluir colunas aninhadas, incluindo aquelas dentro de matrizes, mas não pode ser usado para descartar elementos de matriz específicos.
## Def dropNulls
```
def dropNulls( transformationContext : String = "",
callSite : CallSite = CallSite("Not provided", ""),
stageThreshold : Long = 0,
totalThreshold : Long = 0 )
```
Retorna um novo `DynamicFrame` com todas as colunas nulas removidas.
**nota**
Isso remove apenas colunas do tipo `NullType`. Valores nulos individuais em outras colunas não são removidos ou modificados.
## Def errorsAsDynamicFrame
```
def errorsAsDynamicFrame
```
Retorna um novo `DynamicFrame` contendo os registros de erro deste `DynamicFrame`.
## Def filter
```
def filter( f : DynamicRecord => Boolean,
errorMsg : String = "",
transformationContext : String = "",
callSite : CallSite = CallSite("Not provided"),
stageThreshold : Long = 0,
totalThreshold : Long = 0
) : DynamicFrame
```
Cria um novo `DynamicFrame` que contém apenas os registros para os quais a função "`f`" retorna `true`. A função de filtro "`f`" não deve alterar o registro de entrada.
## Def getName
```
def getName : String
```
Retorna o nome deste `DynamicFrame`.
## Def getNumPartitions
```
def getNumPartitions
```
Retorna o número de partições neste `DynamicFrame`.
## Def getSchemaIfComputed
```
def getSchemaIfComputed : Option[Schema]
```
Retorna o esquema, se ele já foi calculado. Não verifica os dados se o esquema ainda não tiver sido calculado.
## Def isSchemaComputed
```
def isSchemaComputed : Boolean
```
Retorna `true` se o esquema foi calculado para este `DynamicFrame` ou `false`, se não. Se esse método retorna falso, chamar o método `schema` exige outra passagem pelos registros nesse `DynamicFrame`.
## Def javaToPython
```
def javaToPython : JavaRDD[Array[Byte]]
```
## Def join
```
def join( keys1 : Seq[String],
keys2 : Seq[String],
frame2 : DynamicFrame,
transformationContext : String = "",
callSite : CallSite = CallSite("Not provided", ""),
stageThreshold : Long = 0,
totalThreshold : Long = 0
) : DynamicFrame
```
+ `keys1` – As colunas nesse `DynamicFrame` para usar na junção.
+ `keys2`: as colunas no `frame2` a serem usadas na junção. Deve ter o mesmo tamanho que `keys1`.
+ `frame2` — O `DynamicFrame` para usar na junção.
Retorna o resultado da execução de uma junção equivalente com `frame2` usando as chaves especificadas.
## Def map
```
def map( f : DynamicRecord => DynamicRecord,
errorMsg : String = "",
transformationContext : String = "",
callSite : CallSite = CallSite("Not provided", ""),
stageThreshold : Long = 0,
totalThreshold : Long = 0
) : DynamicFrame
```
Retorna um novo `DynamicFrame` criado aplicando a função especificada "`f`" para cada registro nesse `DynamicFrame`.
Este método copia cada registro antes de aplicar a função especificada, portanto, é seguro alterar os registros. Se a função de mapeamento lançar uma exceção em um determinado registro, esse registro é marcado como um erro e o rastreamento de pilha é salvo como uma coluna no registro de erros.
## Def mergeDynamicFrames
```
def mergeDynamicFrames( stageDynamicFrame: DynamicFrame, primaryKeys: Seq[String], transformationContext: String = "",
options: JsonOptions = JsonOptions.empty, callSite: CallSite = CallSite("Not provided"),
stageThreshold: Long = 0, totalThreshold: Long = 0): DynamicFrame
```
+ `stageDynamicFrame`: o `DynamicFrame` de preparação para mesclar.
+ `primaryKeys`: a lista de campos de chave primária para corresponder aos registros da fonte e `DynamicFrame`s de preparação.
+ `transformationContext`: uma string exclusiva usada para recuperar os metadados sobre a transformação atual (opcional).
+ `options`: uma string de pares nome-valor JSON que fornecem informações adicionais para essa transformação.
+ `callSite`: usado para fornecer informações de contexto para o relatório de erros.
+ `stageThreshold` — uma `Long`. O número de erros na transformação para a qual o processamento precisa apresentar falhas.
+ `totalThreshold` — uma `Long`. O número total de erros nessa transformação para os quais o processamento precisa apresentar falhas.
Mescla esse `DynamicFrame` com uma preparação `DynamicFrame` de acordo com as chaves primárias especificadas para identificar registros. Registros duplicados (com as mesmas chaves primárias) não são eliminados. Se não houver nenhum registro correspondente no quadro de preparação, todos os registros (incluindo os duplicados) serão retidos da origem. Se o quadro de preparação tiver registros correspondentes, os do quadro de preparação substituirão os da origem no AWS Glue.
O `DynamicFrame` retornado contém registro A nos seguintes casos:
1. Se `A` existir no quadro de origem e no quadro de preparação, o `A` do quadro de preparação será retornado.
1. Se `A` estiver na tabela de origem e `A.primaryKeys` não estiver no `stagingDynamicFrame` (isso significa que `A` não é atualizado na tabela de preparação).
O quadro de origem e o quadro de preparação não precisam ter o mesmo esquema.
**Example**
```
val mergedFrame: DynamicFrame = srcFrame.mergeDynamicFrames(stageFrame, Seq("id1", "id2"))
```
## Def printSchema
```
def printSchema : Unit
```
Imprime o esquema deste `DynamicFrame` para `stdout` em um formato legível.
## Def recomputeSchema
```
def recomputeSchema : Schema
```
Força um recálculo do esquema. Isso requer uma verificação nos dados, mas pode "restringir" o esquema se houver alguns campos no esquema atual que não estejam presentes nos dados.
Retorna o esquema recalculado.
## Def relationalize
```
def relationalize( rootTableName : String,
stagingPath : String,
options : JsonOptions = JsonOptions.empty,
transformationContext : String = "",
callSite : CallSite = CallSite("Not provided"),
stageThreshold : Long = 0,
totalThreshold : Long = 0
) : Seq[DynamicFrame]
```
+ `rootTableName`: o nome a ser usado para o `DynamicFrame` base na saída. `DynamicFrame`s criados pelo deslocamento de matrizes começam com isso como um prefixo.
+ `stagingPath`: o caminho do Amazon Simple Storage Service (Amazon S3) para gravação de dados intermediários.
+ `options`: opções e a configuração da função Relationalize. Não utilizado no momento.
Nivela todas as estruturas aninhadas e matrizes dinâmicas em tabelas separadas.
Você pode usar essa operação para preparar dados extremamente aninhados para adição em um banco de dados relacional. As estruturas aninhadas são niveladas da mesma maneira que a transformação [Unnest](#glue-etl-scala-apis-glue-dynamicframe-class-defs-unnest). Além disso, as matrizes são dinamizadas em tabelas separadas, com cada elemento da matriz se tornando uma linha. Por exemplo, digamos que você tenha um `DynamicFrame` com os seguintes dados.
```
{"name": "Nancy", "age": 47, "friends": ["Fred", "Lakshmi"]}
{"name": "Stephanie", "age": 28, "friends": ["Yao", "Phil", "Alvin"]}
{"name": "Nathan", "age": 54, "friends": ["Nicolai", "Karen"]}
```
Execute o código a seguir.
```
{{{
df.relationalize("people", "s3:/my_bucket/my_path", JsonOptions.empty)
}}}
```
Isso produz duas tabelas. A primeira tabela é chamada "pessoas" e contém o seguinte.
```
{{{
{"name": "Nancy", "age": 47, "friends": 1}
{"name": "Stephanie", "age": 28, "friends": 2}
{"name": "Nathan", "age": 54, "friends": 3)
}}}
```
Aqui, a matriz de amigos foi substituída por uma chave de junção gerada automaticamente. Uma tabela separada chamada `people.friends` é criada com o seguinte conteúdo.
```
{{{
{"id": 1, "index": 0, "val": "Fred"}
{"id": 1, "index": 1, "val": "Lakshmi"}
{"id": 2, "index": 0, "val": "Yao"}
{"id": 2, "index": 1, "val": "Phil"}
{"id": 2, "index": 2, "val": "Alvin"}
{"id": 3, "index": 0, "val": "Nicolai"}
{"id": 3, "index": 1, "val": "Karen"}
}}}
```
Nessa tabela, '`id`' é uma chave de junção que identifica de qual registro o elemento da matriz é proveniente, '`index`' refere-se à posição na matriz original e '`val`' é a entrada real da matriz.
O método `relationalize` retorna a sequência de `DynamicFrame` criada aplicando esse processo recursivamente a todas as matrizes.
**nota**
A biblioteca do AWS Glue gera automaticamente chaves de junção para novas tabelas. Para garantir que as chaves de junção sejam exclusivas nas execuções do trabalho, você deve ativar as marcações de trabalho.
## Def renameField
```
def renameField( oldName : String,
newName : String,
transformationContext : String = "",
callSite : CallSite = CallSite("Not provided", ""),
stageThreshold : Long = 0,
totalThreshold : Long = 0
) : DynamicFrame
```
+ `oldName` – O nome original da coluna.
+ `newName` – O novo nome da coluna.
Retorna um novo `DynamicFrame` com campo especificado renomeado.
Você pode usar esse método para renomear campos aninhados. Por exemplo, o código a seguir renomearia `state` como `state_code` na estrutura de endereço.
```
{{{
df.renameField("address.state", "address.state_code")
}}}
```
## Def repartition
```
def repartition( numPartitions : Int,
transformationContext : String = "",
callSite : CallSite = CallSite("Not provided", ""),
stageThreshold : Long = 0,
totalThreshold : Long = 0
) : DynamicFrame
```
Retorna um novo `DynamicFrame` com partições `numPartitions`.
## Def resolveChoice
```
def resolveChoice( specs : Seq[Product2[String, String]] = Seq.empty[ResolveSpec],
choiceOption : Option[ChoiceOption] = None,
database : Option[String] = None,
tableName : Option[String] = None,
transformationContext : String = "",
callSite : CallSite = CallSite("Not provided", ""),
stageThreshold : Long = 0,
totalThreshold : Long = 0
) : DynamicFrame
```
+ `choiceOption` — Uma ação a ser aplicada a todas as colunas `ChoiceType` não listadas na sequência de especificações.
+ `database`: o banco de dados do Data Catalog a ser usado com a ação `match_catalog`.
+ `tableName`: a tabela do Data Catalog a ser usada com a ação `match_catalog`.
Retorna um novo `DynamicFrame` substituindo um ou mais `ChoiceType` por um tipo mais específico.
Há duas maneiras de usar `resolveChoice`. A primeira é especificar uma sequência de colunas específicas e como resolvê-las. Elas são especificadas como tuplas compostas de pares (coluna, ação).
A seguir estão as ações possíveis:
+ `cast:type` – Tenta converter todos os valores para o tipo especificado.
+ `make_cols` — converte cada tipo distinto em uma coluna com o nome `columnName_type`.
+ `make_struct` – Converte uma coluna em uma estrutura com chaves para cada tipo distinto.
+ `project:type` — Mantém apenas valores do tipo especificado.
O outro modo para `resolveChoice` é especificar uma única resolução para todos os `ChoiceType`s. Você pode usar isso em casos em que a lista completa de `ChoiceType`s for desconhecida antes da execução. Além das ações listadas anteriormente, esse modo também aceita a seguinte ação:
+ `match_catalog``ChoiceType` – Tenta converter cada para o tipo correspondente na tabela de catálogo especificada.
**Examples:**
Corrija a coluna `user.id` convertendo para um inteiro e faça o campo `address` reter apenas as estruturas.
```
{{{
df.resolveChoice(specs = Seq(("user.id", "cast:int"), ("address", "project:struct")))
}}}
```
Resolva todos os `ChoiceType`s convertendo cada opção em uma coluna separada.
```
{{{
df.resolveChoice(choiceOption = Some(ChoiceOption("make_cols")))
}}}
```
Resolva todos os `ChoiceType`s convertendo para os tipos na tabela de catálogo especificada.
```
{{{
df.resolveChoice(choiceOption = Some(ChoiceOption("match_catalog")),
database = Some("my_database"),
tableName = Some("my_table"))
}}}
```
## Def schema
```
def schema : Schema
```
Retorna o esquema deste `DynamicFrame`.
O esquema retornado é garantido para conter todos os domínios que estão presentes nesse registro `DynamicFrame`. Mas em um pequeno número de casos, ele também pode conter campos adicionais. Você pode usar o método [Unnest](#glue-etl-scala-apis-glue-dynamicframe-class-defs-unnest) para "restringir" o esquema com base nos registros deste `DynamicFrame`.
## Def selectField
```
def selectField( fieldName : String,
transformationContext : String = "",
callSite : CallSite = CallSite("Not provided", ""),
stageThreshold : Long = 0,
totalThreshold : Long = 0
) : DynamicFrame
```
Retorna um único campo como um `DynamicFrame`.
## Def selectFields
```
def selectFields( paths : Seq[String],
transformationContext : String = "",
callSite : CallSite = CallSite("Not provided", ""),
stageThreshold : Long = 0,
totalThreshold : Long = 0
) : DynamicFrame
```
+ `paths` — A sequência de nomes de coluna para selecionar.
Retorna um novo `DynamicFrame` contendo as colunas especificadas.
**nota**
O método `selectFields` só pode ser usado para selecionar as colunas de nível superior. O método [applyMapping](#glue-etl-scala-apis-glue-dynamicframe-class-defs-applyMapping) pode ser usado para selecionar as colunas aninhadas.
## Def show
```
def show( numRows : Int = 20 ) : Unit
```
+ `numRows` – O número de linhas a serem impressas.
Imprime linhas desse `DynamicFrame` no formato JSON.
## Def simplifyDDBJson
As exportações do DynamoDB feitas com o conector de exportação para DynamoDB do AWS Glue resultam em arquivos JSON de estruturas aninhadas específicas. Para obter mais informações, consulte [Objetos de dados](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/S3DataExport.Output.html). `simplifyDDBJson` Simplifica as colunas aninhadas em um DynamicFrame desse tipo de dados e retorna um novo DynamicFrame simplificado. Se houver vários tipos ou um tipo de mapa contidos em um tipo de lista, os elementos na lista não serão simplificados. Esse método oferece suporte somente a dados no for mato JSON de exportação do DynamoDB. Considere o `unnest` para realizar alterações semelhantes em outros tipos de dados.
```
def simplifyDDBJson() : DynamicFrame
```
Esse método não aceita parâmetros.
**Exemplo de entrada**
Considere o seguinte esquema gerado por uma exportação do DynamoDB:
```
root
|-- Item: struct
| |-- parentMap: struct
| | |-- M: struct
| | | |-- childMap: struct
| | | | |-- M: struct
| | | | | |-- appName: struct
| | | | | | |-- S: string
| | | | | |-- packageName: struct
| | | | | | |-- S: string
| | | | | |-- updatedAt: struct
| | | | | | |-- N: string
| |-- strings: struct
| | |-- SS: array
| | | |-- element: string
| |-- numbers: struct
| | |-- NS: array
| | | |-- element: string
| |-- binaries: struct
| | |-- BS: array
| | | |-- element: string
| |-- isDDBJson: struct
| | |-- BOOL: boolean
| |-- nullValue: struct
| | |-- NULL: boolean
```
**Código de exemplo**
```
import com.amazonaws.services.glue.GlueContext
import com.amazonaws.services.glue.util.GlueArgParser
import com.amazonaws.services.glue.util.Job
import com.amazonaws.services.glue.util.JsonOptions
import com.amazonaws.services.glue.DynamoDbDataSink
import org.apache.spark.SparkContextimport scala.collection.JavaConverters._
object GlueApp {
def main(sysArgs: Array[String]): Unit = {
val glueContext = new GlueContext(SparkContext.getOrCreate())
val args = GlueArgParser.getResolvedOptions(sysArgs, Seq("JOB_NAME").toArray)
Job.init(args("JOB_NAME"), glueContext, args.asJava)
val dynamicFrame = glueContext.getSourceWithFormat(
connectionType = "dynamodb",
options = JsonOptions(Map(
"dynamodb.export" -> "ddb",
"dynamodb.tableArn" -> "ddbTableARN",
"dynamodb.s3.bucket" -> "exportBucketLocation",
"dynamodb.s3.prefix" -> "exportBucketPrefix",
"dynamodb.s3.bucketOwner" -> "exportBucketAccountID",
))
).getDynamicFrame()
val simplified = dynamicFrame.simplifyDDBJson()
simplified.printSchema()
Job.commit()
}
}
```
### Exemplo de saída
A transformação `simplifyDDBJson` simplificará isso para:
```
root
|-- parentMap: struct
| |-- childMap: struct
| | |-- appName: string
| | |-- packageName: string
| | |-- updatedAt: string
|-- strings: array
| |-- element: string
|-- numbers: array
| |-- element: string
|-- binaries: array
| |-- element: string
|-- isDDBJson: boolean
|-- nullValue: null
```
## Def spigot
```
def spigot( path : String,
options : JsonOptions = new JsonOptions("{}"),
transformationContext : String = "",
callSite : CallSite = CallSite("Not provided"),
stageThreshold : Long = 0,
totalThreshold : Long = 0
) : DynamicFrame
```
Transformação de passagem que retorna os mesmos registros, mas grava um subconjunto de registros como um efeito secundário.
+ `path` — o caminho no Amazon S3 no qual gravar a saída, no formato `s3://bucket//path`.
+ `options` — Um mapa opcional `JsonOptions` que descreve o comportamento de amostragem.
Retorna um `DynamicFrame` que contém os mesmos registros deste.
Por padrão, grava 100 registros arbitrários no local especificado por `path`. Você pode personalizar esse comportamento usando o mapa `options`. Chaves válidas incluem o seguinte:
+ `topk`: especifica o número total de registros gravados. O padrão é 100.
+ `prob`: especifica a probabilidade (como um número decimal) de incluir um registro individual. O padrão é 1.
Por exemplo, a chamada a seguir seria um exemplo do conjunto de dados, selecionando cada registro com uma probabilidade de 20% e interrompendo após a gravação de 200 registros.
```
{{{
df.spigot("s3://my_bucket/my_path", JsonOptions(Map("topk" -> 200, "prob" -> 0.2)))
}}}
```
## Def splitFields
```
def splitFields( paths : Seq[String],
transformationContext : String = "",
callSite : CallSite = CallSite("Not provided", ""),
stageThreshold : Long = 0,
totalThreshold : Long = 0
) : Seq[DynamicFrame]
```
+ `paths` — Os caminhos a serem incluídos no primeiro `DynamicFrame`.
Retorna uma sequência de dois `DynamicFrame`s. O primeiro `DynamicFrame` contém os caminhos especificados e o segundo, todas as outras colunas.
**Exemplo**
Este exemplo usa um DynamicFrame criado a partir da tabela `persons` no banco de dados `legislators` no catálogo de dados do Glue da AWS e divide o DynamicFrame em dois, com os campos especificados entrando no primeiro DynamicFrame e os campos restantes entrando em um segundo DynamicFrame. O exemplo então escolhe o primeiro DynamicFrame do resultado.
```
val InputFrame = glueContext.getCatalogSource(database="legislators", tableName="persons",
transformationContext="InputFrame").getDynamicFrame()
val SplitField_collection = InputFrame.splitFields(paths=Seq("family_name", "name", "links.note",
"links.url", "gender", "image", "identifiers.scheme", "identifiers.identifier", "other_names.lang",
"other_names.note", "other_names.name"), transformationContext="SplitField_collection")
val ResultFrame = SplitField_collection(0)
```
## Def splitRows
```
def splitRows( paths : Seq[String],
values : Seq[Any],
operators : Seq[String],
transformationContext : String,
callSite : CallSite,
stageThreshold : Long,
totalThreshold : Long
) : Seq[DynamicFrame]
```
Divide linhas com base em predicados que comparam colunas com constantes.
+ `paths` — As colunas a serem usadas para comparação.
+ `values` — Os valores constantes a serem usados para comparação.
+ `operators` — Os operadores a serem usados para comparação.
Retorna uma sequência de dois `DynamicFrame`s. O primeiro contém linhas para as quais o predicado é verdadeiro, e o segundo contém linhas para as quais ele é falso.
Os predicados são especificados usando três sequências: "`paths`" contém os nomes de coluna (possivelmente aninhados), "`values`" contém os valores constantes para comparar e "`operators`" contém os operadores a serem usados para comparação. Todas as três sequências devem ter o mesmo tamanho: o operador `n` é usado para comparar a coluna `n` com o valor `n`.
Cada operador deve ser um de "`!=`", "`=`", "`<=`", "`<`", "`>=`" ou "`>`".
Como exemplo, a chamada a seguir dividiria um `DynamicFrame` para que o primeiro quadro de saída contivesse registros de pessoas dos Estados Unidos com mais de 65 anos, e o segundo contivesse todos os outros registros.
```
{{{
df.splitRows(Seq("age", "address.country"), Seq(65, "USA"), Seq(">=", "="))
}}}
```
## Def stageErrorsCount
```
def stageErrorsCount
```
Retorna o número de registros de erros criados durante o cálculo desse `DynamicFrame`. Isso exclui erros de operações anteriores que foram passadas para este `DynamicFrame` como entrada.
## Def toDF
```
def toDF( specs : Seq[ResolveSpec] = Seq.empty[ResolveSpec] ) : DataFrame
```
Converte isso `DynamicFrame` para um Apache Spark SQL `DataFrame` com o mesmo esquema e registros.
**nota**
Como `DataFrame`s não oferecem suporte para `ChoiceType`s, esse método converte automaticamente colunas `ChoiceType` em `StructType`s. Para obter mais informações e opções para opções de resolução, consulte [resolveChoice](#glue-etl-scala-apis-glue-dynamicframe-class-defs-resolveChoice).
## Def unbox
```
def unbox( path : String,
format : String,
optionString : String = "{}",
transformationContext : String = "",
callSite : CallSite = CallSite("Not provided"),
stageThreshold : Long = 0,
totalThreshold : Long = 0
) : DynamicFrame
```
+ `path`: a coluna a ser analisada. Deve ser uma string ou binária.
+ `format` – O formato a ser usado para a análise.
+ `optionString` – Opções para passar para o formato, como o separador CSV.
Analisa uma coluna de string ou binária incorporada de acordo com o formato especificado. Colunas analisadas são aninhadas sob uma estrutura com o nome da coluna original.
Por exemplo, suponha que há um arquivo CSV com uma coluna JSON incorporada,
```
name, age, address
Sally, 36, {"state": "NE", "city": "Omaha"}
...
```
Após uma análise inicial, seria obtido um `DynamicFrame` com o seguinte esquema.
```
{{{
root
|-- name: string
|-- age: int
|-- address: string
}}}
```
É possível chamar `unbox` na coluna de endereço para analisar os componentes específicos.
```
{{{
df.unbox("address", "json")
}}}
```
Isso nos dá um `DynamicFrame` com o seguinte esquema.
```
{{{
root
|-- name: string
|-- age: int
|-- address: struct
| |-- state: string
| |-- city: string
}}}
```
## Def unnest
```
def unnest( transformationContext : String = "",
callSite : CallSite = CallSite("Not Provided"),
stageThreshold : Long = 0,
totalThreshold : Long = 0
) : DynamicFrame
```
Retorna um novo `DynamicFrame` com todas as estruturas aninhadas niveladas. Os nomes são criados usando o caractere '`.`' (ponto).
Por exemplo, digamos que você tem um `DynamicFrame` com o seguinte esquema.
```
{{{
root
|-- name: string
|-- age: int
|-- address: struct
| |-- state: string
| |-- city: string
}}}
```
A chamada a seguir desaninha a estrutura do endereço.
```
{{{
df.unnest()
}}}
```
O esquema resultante será o seguinte.
```
{{{
root
|-- name: string
|-- age: int
|-- address.state: string
|-- address.city: string
}}}
```
Esse método também desaninha estruturas aninhados dentro de matrizes. No entanto, por razões históricas, os nomes dos campos são prefixados com o nome do array de fechamento e "`.val`".
## Def unnestDDBJson
```
unnestDDBJson(transformationContext : String = "",
callSite : CallSite = CallSite("Not Provided"),
stageThreshold : Long = 0,
totalThreshold : Long = 0): DynamicFrame
```
Desaninha colunas aninhadas em um `DynamicFrame` que estão especificamente na estrutura JSON do DynamoDB e retorna um novo `DynamicFrame` não aninhado. Colunas que pertençam a uma matriz de tipos de estrutura não serão desaninhadas. Observe que esse é um tipo específico de transformação de desaninhamento que se comporta diferentemente da transformação `unnest` comum e requer que os dados já estejam na estrutura JSON do DynamoDB. Para mais informações, consulte [JSON do DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DataExport.Output.html#DataExport.Output.Data).
Por exemplo, o esquema de uma leitura de uma exportação com a estrutura JSON do DynamoDB pode se parecer com o seguinte:
```
root
|-- Item: struct
| |-- ColA: struct
| | |-- S: string
| |-- ColB: struct
| | |-- S: string
| |-- ColC: struct
| | |-- N: string
| |-- ColD: struct
| | |-- L: array
| | | |-- element: null
```
A transformação `unnestDDBJson()` converteria isso em:
```
root
|-- ColA: string
|-- ColB: string
|-- ColC: string
|-- ColD: array
| |-- element: null
```
O exemplo de código a seguir mostra como usar o conector de exportação para DynamoDB do AWS Glue, invocar um desaninhamento de JSON do DynamoDB e imprimir o número de partições:
```
import com.amazonaws.services.glue.GlueContext
import com.amazonaws.services.glue.util.GlueArgParser
import com.amazonaws.services.glue.util.Job
import com.amazonaws.services.glue.util.JsonOptions
import com.amazonaws.services.glue.DynamoDbDataSink
import org.apache.spark.SparkContext
import scala.collection.JavaConverters._
object GlueApp {
def main(sysArgs: Array[String]): Unit = {
val glueContext = new GlueContext(SparkContext.getOrCreate())
val args = GlueArgParser.getResolvedOptions(sysArgs, Seq("JOB_NAME").toArray)
Job.init(args("JOB_NAME"), glueContext, args.asJava)
val dynamicFrame = glueContext.getSourceWithFormat(
connectionType = "dynamodb",
options = JsonOptions(Map(
"dynamodb.export" -> "ddb",
"dynamodb.tableArn" -> "",
"dynamodb.s3.bucket" -> "",
"dynamodb.s3.prefix" -> "",
"dynamodb.s3.bucketOwner" -> "",
))
).getDynamicFrame()
val unnested = dynamicFrame.unnestDDBJson()
print(unnested.getNumPartitions())
Job.commit()
}
}
```
## Def withFrameSchema
```
def withFrameSchema( getSchema : () => Schema ) : DynamicFrame
```
+ `getSchema`: uma função que retorna o esquema a ser usado. Especificado como uma função de parâmetro zero para adiar a computação potencialmente dispendiosa.
Define o esquema desse `DynamicFrame` com o valor especificado. Isso é usado principalmente de maneira interna para evitar a recomputação dispendiosa do esquema. O esquema transmitido deve conter todas as colunas presentes nos dados.
## Def withName
```
def withName( name : String ) : DynamicFrame
```
+ `name` — O novo nome a ser usado.
Retorna uma cópia desse `DynamicFrame` com um novo nome.
## Def withTransformationContext
```
def withTransformationContext( ctx : String ) : DynamicFrame
```
Retorna uma cópia desse `DynamicFrame` com o contexto de transformação especificado.
# O objeto DynamicFrame
**Pacote: com.amazonaws.services.glue**
```
object DynamicFrame
```
## Def apply
```
def apply( df : DataFrame,
glueContext : GlueContext
) : DynamicFrame
```
## Def emptyDynamicFrame
```
def emptyDynamicFrame( glueContext : GlueContext ) : DynamicFrame
```
## Def fromPythonRDD
```
def fromPythonRDD( rdd : JavaRDD[Array[Byte]],
glueContext : GlueContext
) : DynamicFrame
```
## Def ignoreErrors
```
def ignoreErrors( fn : DynamicRecord => DynamicRecord ) : DynamicRecord
```
## Def inlineErrors
```
def inlineErrors( msg : String,
callSite : CallSite
) : (DynamicRecord => DynamicRecord)
```
## Def newFrameWithErrors
```
def newFrameWithErrors( prevFrame : DynamicFrame,
rdd : RDD[DynamicRecord],
name : String = "",
transformationContext : String = "",
callSite : CallSite,
stageThreshold : Long,
totalThreshold : Long
) : DynamicFrame
```
# Classe DynamicRecord em Scala do AWS Glue
**Topics**
+ [Def addField](#glue-etl-scala-apis-glue-dynamicrecord-class-defs-addField)
+ [Def dropField](#glue-etl-scala-apis-glue-dynamicrecord-class-defs-dropField)
+ [Def setError](#glue-etl-scala-apis-glue-dynamicrecord-class-defs-setError)
+ [Def isError](#glue-etl-scala-apis-glue-dynamicrecord-class-defs-isError)
+ [Def getError](#glue-etl-scala-apis-glue-dynamicrecord-class-defs-getError)
+ [Def clearError](#glue-etl-scala-apis-glue-dynamicrecord-class-defs-clearError)
+ [Def write](#glue-etl-scala-apis-glue-dynamicrecord-class-defs-write)
+ [Def readFields](#glue-etl-scala-apis-glue-dynamicrecord-class-defs-readFields)
+ [Def clone](#glue-etl-scala-apis-glue-dynamicrecord-class-defs-clone)
+ [Def schema](#glue-etl-scala-apis-glue-dynamicrecord-class-defs-schema)
+ [Def getRoot](#glue-etl-scala-apis-glue-dynamicrecord-class-defs-getRoot)
+ [Def toJson](#glue-etl-scala-apis-glue-dynamicrecord-class-defs-toJson)
+ [Def getFieldNode](#glue-etl-scala-apis-glue-dynamicrecord-class-defs-getFieldNode)
+ [Def getField](#glue-etl-scala-apis-glue-dynamicrecord-class-defs-getField)
+ [Def hashCode](#glue-etl-scala-apis-glue-dynamicrecord-class-defs-hashCode)
+ [Def equals](#glue-etl-scala-apis-glue-dynamicrecord-class-defs-equals)
+ [Objeto DynamicRecord](#glue-etl-scala-apis-glue-dynamicrecord-object)
+ [Característica RecordTraverser](#glue-etl-scala-apis-glue-recordtraverser-trait)
**Pacote: com.amazonaws.services.glue**
```
class DynamicRecord extends Serializable with Writable with Cloneable
```
Um `DynamicRecord` é uma estrutura de dados autodescritiva que representa uma linha de conjunto de dados que está sendo processado. É autodescritiva, no sentido de que você pode obter o esquema da linha representada pelo `DynamicRecord`, inspecionando o próprio registro. Um `DynamicRecord` é semelhante a uma `Row` no Apache Spark
## Def addField
```
def addField( path : String,
dynamicNode : DynamicNode
) : Unit
```
Adiciona um [DynamicNode](glue-etl-scala-apis-glue-types-dynamicnode.md) ao caminho especificado.
+ `path` – O caminho para o campo a ser adicionado.
+ `dynamicNode` — O [DynamicNode](glue-etl-scala-apis-glue-types-dynamicnode.md) a ser adicionado no caminho especificado.
## Def dropField
```
def dropField(path: String, underRename: Boolean = false): Option[DynamicNode]
```
Remove um [DynamicNode](glue-etl-scala-apis-glue-types-dynamicnode.md) do caminho especificado e retorna o nó removido se não houver uma matriz no caminho especificado.
+ `path` — O caminho para o campo a ser removido.
+ `underRename``dropField` – Verdadeiro se for chamado como parte de uma transformação de renomeação ou falso, caso contrário (falso por padrão).
Retorna um `scala.Option Option` ([DynamicNode](glue-etl-scala-apis-glue-types-dynamicnode.md)).
## Def setError
```
def setError( error : Error )
```
Define esse registro como um registro de erro, conforme especificado pelo parâmetro `error`.
Retorna um `DynamicRecord`.
## Def isError
```
def isError
```
Verifica se esse registro é um registro de erro.
## Def getError
```
def getError
```
Obtém o `Error` se o registro for um registro de erro. Retorna `scala.Some Some` (Erro) se esse registro for um registro de erro ou `scala.None`, caso contrário.
## Def clearError
```
def clearError
```
Defina `Error` como `scala.None.None` .
## Def write
```
override def write( out : DataOutput ) : Unit
```
## Def readFields
```
override def readFields( in : DataInput ) : Unit
```
## Def clone
```
override def clone : DynamicRecord
```
Clona esse registro para um novo `DynamicRecord` e o retorna.
## Def schema
```
def schema
```
Obtém o `Schema` ao inspecionar o registro.
## Def getRoot
```
def getRoot : ObjectNode
```
Obtém a raiz `ObjectNode` do registro.
## Def toJson
```
def toJson : String
```
Obtém a string JSON para o registro.
## Def getFieldNode
```
def getFieldNode( path : String ) : Option[DynamicNode]
```
Obtém o valor do campo no `path` especificado como uma opção de `DynamicNode`.
Retorna `scala.Some Some` ([DynamicNode](glue-etl-scala-apis-glue-types-dynamicnode.md)) se o campo existir ou `scala.None.None`, caso contrário.
## Def getField
```
def getField( path : String ) : Option[Any]
```
Obtém o valor do campo no `path` especificado como uma opção de `DynamicNode`.
Retorna `scala.Some Some` (valor).
## Def hashCode
```
override def hashCode : Int
```
## Def equals
```
override def equals( other : Any )
```
## Objeto DynamicRecord
```
object DynamicRecord
```
### Def apply
```
def apply( row : Row,
schema : SparkStructType )
```
Aplique o método para converter um Apache Spark SQL `Row` em um [DynamicRecord](#glue-etl-scala-apis-glue-dynamicrecord-class).
+ `row` — Um Spark SQL `Row`.
+ `schema` – O `Schema` dessa linha.
Retorna um `DynamicRecord`.
## Característica RecordTraverser
```
trait RecordTraverser {
def nullValue(): Unit
def byteValue(value: Byte): Unit
def binaryValue(value: Array[Byte]): Unit
def booleanValue(value: Boolean): Unit
def shortValue(value: Short) : Unit
def intValue(value: Int) : Unit
def longValue(value: Long) : Unit
def floatValue(value: Float): Unit
def doubleValue(value: Double): Unit
def decimalValue(value: BigDecimal): Unit
def stringValue(value: String): Unit
def dateValue(value: Date): Unit
def timestampValue(value: Timestamp): Unit
def objectStart(length: Int): Unit
def objectKey(key: String): Unit
def objectEnd(): Unit
def mapStart(length: Int): Unit
def mapKey(key: String): Unit
def mapEnd(): Unit
def arrayStart(length: Int): Unit
def arrayEnd(): Unit
}
```
# AWS GlueAPIs GlueContext em Scala do
**Pacote: com.amazonaws.services.glue**
```
class GlueContext extends SQLContext(sc) (
@transient val sc : SparkContext,
val defaultSourcePartitioner : PartitioningStrategy )
```
`GlueContext` é o ponto de entrada para leitura e gravação de um [DynamicFrame](glue-etl-scala-apis-glue-dynamicframe.md) de e para o Amazon Simple Storage Service (Amazon S3), AWS Glue Data Catalog, JDBC e assim por diante. Essa classe fornece funções de utilitário para criar objetos [Característica do DataSource](glue-etl-scala-apis-glue-datasource-trait.md) e [DataSink](glue-etl-scala-apis-glue-datasink-class.md) que, por sua vez, podem ser usados para ler e gravar `DynamicFrame`s.
`GlueContext` também pode ser usado para definir um número de partições de destino (o padrão é 20) no `DynamicFrame` se o número de partições criado da origem é menor do que um limite mínimo para as partições (o padrão é 10).
## def addIngestionTimeColumns
```
def addIngestionTimeColumns(
df : DataFrame,
timeGranularity : String = "") : dataFrame
```
Acrescenta colunas de tempo de ingestão, como `ingest_year`, `ingest_month`, `ingest_day`, `ingest_hour`, `ingest_minute`, para o `DataFrame` de entrada. Essa função é gerada automaticamente no script gerado pelo AWS Glue, quando você especifica uma tabela do catálogo de dados com o Amazon S3 como destino. Essa função atualiza automaticamente a partição com colunas de tempo de ingestão na tabela de saída. Isso permite que os dados de saída sejam particionados automaticamente no tempo de ingestão sem exigir colunas de tempo de ingestão explícitas nos dados de entrada.
+ `dataFrame`: o `dataFrame` ao qual anexar as colunas de tempo de ingestão.
+ `timeGranularity`: o detalhamento das colunas de tempo. Os valores válidos são “`day`”, “`hour`” e “`minute`”. Por exemplo, se “`hour`” é transmitido para a função, o `dataFrame` original terá as colunas de tempo “`ingest_year`”, “`ingest_month`”, “`ingest_day`” e “`ingest_hour`” anexadas.
Retorna o quadro de dados após anexar as colunas de detealhamento de tempo.
Exemplo:
```
glueContext.addIngestionTimeColumns(dataFrame, "hour")
```
## def createDataFrameFromOptions
```
def createDataFrameFromOptions( connectionType : String,
connectionOptions : JsonOptions,
transformationContext : String = "",
format : String = null,
formatOptions : JsonOptions = JsonOptions.empty
) : DataSource
```
Retorna um `DataFrame` criado com a conexão e o formato especificados. Use essa função apenas com fontes de transmissão do AWS Glue.
+ `connectionType`: o tipo de conexão de transmissão. Os valores válidos são `kinesis` e `kafka`.
+ `connectionOptions`: opções de conexão, a quais são diferentes para Kinesis e Kafka. Você pode encontrar a lista de todas as opções de conexão para cada origem dos dados de transmissão em [Tipos e opções de conexão para ETL no AWS Glue para Spark](aws-glue-programming-etl-connect.md). Observe as seguintes diferenças nas opções de conexão de transmissão:
+ As fontes de transmissão do Kinesis exigem `streamARN`, `startingPosition`, `inferSchema` e `classification`.
+ As fontes de transmissão do Kafka exigem `connectionName`, `topicName`, `startingOffsets`, `inferSchema` e `classification`.
+ `transformationContext`: o contexto de transformação a ser usado (opcional).
+ `format`: uma especificação de formato (opcional). É usado para uma conexão do Amazon S3 ou do AWS Glue com suporte para vários formatos. Para obter informações sobre os formatos compatíveis, consulte . [Opções de formato de dados para entradas e saídas no AWS Glue para Spark](aws-glue-programming-etl-format.md)
+ `formatOptions`: as opções de formato para o formato especificado. Para obter informações sobre as opções de formato compatíveis, consulte [Opções de formato de dados](aws-glue-programming-etl-format.md).
Exemplo para fonte de transmissão do Amazon Kinesis:
```
val data_frame_datasource0 =
glueContext.createDataFrameFromOptions(transformationContext = "datasource0", connectionType = "kinesis",
connectionOptions = JsonOptions("""{"streamName": "example_stream", "startingPosition": "TRIM_HORIZON", "inferSchema": "true", "classification": "json"}}"""))
```
Exemplo para fonte de transmissão do Kafka:
```
val data_frame_datasource0 =
glueContext.createDataFrameFromOptions(transformationContext = "datasource0", connectionType = "kafka",
connectionOptions = JsonOptions("""{"connectionName": "example_connection", "topicName": "example_topic", "startingPosition": "earliest", "inferSchema": "false", "classification": "json", "schema":"`column1` STRING, `column2` STRING"}"""))
```
## forEachBatch
**`forEachBatch(frame, batch_function, options)`**
Aplica a `batch_function` transmitida para cada microlote lido a partir da fonte de transmissão.
+ `frame`: o DataFrame que contém o microlote atual.
+ `batch_function`: uma função que será aplicada para cada microlote.
+ `options`: uma coleção de pares de chave-valor que contém informações sobre como processar microlotes. São necessárias as seguintes opções:
+ `windowSize`: a quantidade de tempo gasto no processamento de cada lote.
+ `checkpointLocation`: o local onde os pontos de verificação são armazenados para o trabalho de ETL de transmissão.
+ `batchMaxRetries`: o número máximo de novas tentativas deste lote em caso de falha. O valor padrão é 3. Essa opção só pode ser configurada para o Glue versão 2.0 e posterior.
**Exemplo:**
```
glueContext.forEachBatch(data_frame_datasource0, (dataFrame: Dataset[Row], batchId: Long) =>
{
if (dataFrame.count() > 0)
{
val datasource0 = DynamicFrame(glueContext.addIngestionTimeColumns(dataFrame, "hour"), glueContext)
// @type: DataSink
// @args: [database = "tempdb", table_name = "fromoptionsoutput", stream_batch_time = "100 seconds",
// stream_checkpoint_location = "s3://from-options-testing-eu-central-1/fromOptionsOutput/checkpoint/",
// transformation_ctx = "datasink1"]
// @return: datasink1
// @inputs: [frame = datasource0]
val options_datasink1 = JsonOptions(
Map("partitionKeys" -> Seq("ingest_year", "ingest_month","ingest_day", "ingest_hour"),
"enableUpdateCatalog" -> true))
val datasink1 = glueContext.getCatalogSink(
database = "tempdb",
tableName = "fromoptionsoutput",
redshiftTmpDir = "",
transformationContext = "datasink1",
additionalOptions = options_datasink1).writeDynamicFrame(datasource0)
}
}, JsonOptions("""{"windowSize" : "100 seconds",
"checkpointLocation" : "s3://from-options-testing-eu-central-1/fromOptionsOutput/checkpoint/"}"""))
```
## def getCatalogSink
```
def getCatalogSink( database : String,
tableName : String,
redshiftTmpDir : String = "",
transformationContext : String = ""
additionalOptions: JsonOptions = JsonOptions.empty,
catalogId: String = null
) : DataSink
```
Cria um [DataSink](glue-etl-scala-apis-glue-datasink-class.md) que grava em um local especificado de uma tabela definida no Data Catalog.
+ `database`: o nome do banco de dados no Data Catalog.
+ `tableName`: o nome da tabela no Data Catalog.
+ `redshiftTmpDir`: o diretório de preparação temporário a ser usado com determinados coletores de dados. Definido como vazio por padrão.
+ `transformationContext`: o contexto de transformação associado ao coletor a ser usado pelos marcadores de trabalho. Definido como vazio por padrão.
+ `additionalOptions` – opções adicionais fornecidas ao AWS Glue.
+ `catalogId`: o ID do catálogo (ID da conta) do Data Catalog que está sendo acessado. Quando nulo, o ID da conta do chamador padrão é usado.
Retorna o `DataSink`.
## def getCatalogSource
```
def getCatalogSource( database : String,
tableName : String,
redshiftTmpDir : String = "",
transformationContext : String = ""
pushDownPredicate : String = " "
additionalOptions: JsonOptions = JsonOptions.empty,
catalogId: String = null
) : DataSource
```
Cria um [Característica do DataSource](glue-etl-scala-apis-glue-datasource-trait.md) que lê dados em uma definição de tabela do Data Catalog.
+ `database`: o nome do banco de dados no Data Catalog.
+ `tableName`: o nome da tabela no Data Catalog.
+ `redshiftTmpDir`: o diretório de preparação temporário a ser usado com determinados coletores de dados. Definido como vazio por padrão.
+ `transformationContext`: o contexto de transformação associado ao coletor a ser usado pelos marcadores de trabalho. Definido como vazio por padrão.
+ `pushDownPredicate`: filtra partições sem a necessidade de listar e ler todos os arquivos no seu conjunto de dados. Para obter mais informações, consulte [Pré-filtragem usando a aplicação de predicados](aws-glue-programming-etl-partitions.md#aws-glue-programming-etl-partitions-pushdowns).
+ `additionalOptions` – Uma coleção de pares nome-valor opcionais. As opções possíveis incluem as listadas em [Tipos e opções de conexão para ETL no AWS Glue para Spark](aws-glue-programming-etl-connect.md), exceto para `endpointUrl`, `streamName`, `bootstrap.servers`, `security.protocol`, `topicName`, `classification` e `delimiter`. Outra opção suportada é `catalogPartitionPredicate`:
`catalogPartitionPredicate`: você pode transmitir uma expressão de catálogo para filtrar com base nas colunas de índice. Isso leva a filtragem para o lado do servidor. Para obter mais informações, consulte [Índices de partição do AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/partition-indexes.html). Observe que `push_down_predicate` e `catalogPartitionPredicate` usam sintaxes diferentes. O primeiro usa a sintaxe padrão do Spark SQL e o outro usa o analisador JSQL.
+ `catalogId`: o ID do catálogo (ID da conta) do Data Catalog que está sendo acessado. Quando nulo, o ID da conta do chamador padrão é usado.
Retorna o `DataSource`.
**Exemplo de fonte de transmissão**
```
val data_frame_datasource0 = glueContext.getCatalogSource(
database = "tempdb",
tableName = "test-stream-input",
redshiftTmpDir = "",
transformationContext = "datasource0",
additionalOptions = JsonOptions("""{
"startingPosition": "TRIM_HORIZON", "inferSchema": "false"}""")
).getDataFrame()
```
## def getJDBCSink
```
def getJDBCSink( catalogConnection : String,
options : JsonOptions,
redshiftTmpDir : String = "",
transformationContext : String = "",
catalogId: String = null
) : DataSink
```
Cria um [DataSink](glue-etl-scala-apis-glue-datasink-class.md) que grava em um banco de dados JDBC especificado em um objeto `Connection` no Data Catalog. O objeto `Connection` tem informações para se conectar a um depósito JDBC, incluindo URL, nome de usuário, senha, VPC, sub-rede e grupos de segurança.
+ `catalogConnection`: o nome da conexão no Data Catalog que contém o URL do JDBC onde gravar.
+ `options`: uma string de pares de nome-valor JSON que fornecem as informações adicionais necessárias para gravar em um datastore do JDBC. Isso inclui:
+ *dbtable* (obrigatório) — O nome da tabela JDBC. Para armazenamentos de dados JDBC que oferecem suporte a esquemas dentro de um banco de dados, especifique `schema.table-name`. Se um esquema não for fornecido, o esquema "público" padrão será usado. O exemplo a seguir mostra um parâmetro de opções que aponta para um esquema chamado `test` e uma tabela chamada `test_table` no banco de dados `test_db`.
```
options = JsonOptions("""{"dbtable": "test.test_table", "database": "test_db"}""")
```
+ *database* (obrigatório) — O nome do banco de dados do JDBC.
+ Todas as opções adicionais transmitidas diretamente para gravador do JDBC de SparkSQL. Para obter mais informações, consulte [Fonte de dados Redshift para Spark](https://github.com/databricks/spark-redshift).
+ `redshiftTmpDir`: um diretório de preparação temporário a ser usado com determinados coletores de dados. Definido como vazio por padrão.
+ `transformationContext`: o contexto de transformação associado ao coletor a ser usado pelos marcadores de trabalho. Definido como vazio por padrão.
+ `catalogId`: o ID do catálogo (ID da conta) do Data Catalog que está sendo acessado. Quando nulo, o ID da conta do chamador padrão é usado.
Código de exemplo:
```
getJDBCSink(catalogConnection = "my-connection-name", options = JsonOptions("""{"dbtable": "my-jdbc-table", "database": "my-jdbc-db"}"""), redshiftTmpDir = "", transformationContext = "datasink4")
```
Retorna o `DataSink`.
## def getSink
```
def getSink( connectionType : String,
connectionOptions : JsonOptions,
transformationContext : String = ""
) : DataSink
```
Cria um [DataSink](glue-etl-scala-apis-glue-datasink-class.md) que grava dados em um destino como Amazon Simple Storage Service (Amazon S3), JDBC, Catálogo de Dados do AWS Glue ou um fluxo de dados do Amazon Kinesis ou do Apache Kafka.
+ `connectionType` — O tipo da conexão. Consulte [Tipos e opções de conexão para ETL no AWS Glue para Spark](aws-glue-programming-etl-connect.md).
+ `connectionOptions` – uma string de pares de nome/valor JSON que fornecem as informações adicionais para estabelecer a conexão com o depósito de dados. Consulte [Tipos e opções de conexão para ETL no AWS Glue para Spark](aws-glue-programming-etl-connect.md).
+ `transformationContext`: o contexto de transformação associado ao coletor a ser usado pelos marcadores de trabalho. Definido como vazio por padrão.
Retorna o `DataSink`.
## def getSinkWithFormat
```
def getSinkWithFormat( connectionType : String,
options : JsonOptions,
transformationContext : String = "",
format : String = null,
formatOptions : JsonOptions = JsonOptions.empty
) : DataSink
```
Cria um [DataSink](glue-etl-scala-apis-glue-datasink-class.md) que grava dados em um destino como Amazon S3, JDBC, Catálogo de Dados ou um fluxo de dados do Amazon Kinesis ou do Apache Kafka. Também define o formato dos dados que serão gravados no destino.
+ `connectionType` — O tipo da conexão. Consulte [Tipos e opções de conexão para ETL no AWS Glue para Spark](aws-glue-programming-etl-connect.md).
+ `options` — Uma string de pares de nome/valor JSON que fornecem as informações adicionais para estabelecer a conexão com o depósito de dados. Consulte [Tipos e opções de conexão para ETL no AWS Glue para Spark](aws-glue-programming-etl-connect.md).
+ `transformationContext`: o contexto de transformação associado ao coletor a ser usado pelos marcadores de trabalho. Definido como vazio por padrão.
+ `format` — O formato dos dados a serem gravados no destino.
+ `formatOptions`: uma string de pares de nome-valor JSON que fornecem opções adicionais para a formatação de dados no destino. Consulte [Opções de formato de dados](aws-glue-programming-etl-format.md).
Retorna o `DataSink`.
## def getSource
```
def getSource( connectionType : String,
connectionOptions : JsonOptions,
transformationContext : String = ""
pushDownPredicate
) : DataSource
```
Cria um [Característica do DataSource](glue-etl-scala-apis-glue-datasource-trait.md) que lê dados em uma fonte, como o Amazon S3, JDBC ou AWS Glue Data Catalog. Também oferece suporte a origens de dados de transmissão do Kafka e Kinesis.
+ `connectionType`: o tipo da origem dos dados. Consulte [Tipos e opções de conexão para ETL no AWS Glue para Spark](aws-glue-programming-etl-connect.md).
+ `connectionOptions` – uma string de pares de nome/valor JSON que fornecem as informações adicionais para estabelecer uma conexão com a origem de dados. Para obter mais informações, consulte [Tipos e opções de conexão para ETL no AWS Glue para Spark](aws-glue-programming-etl-connect.md).
Uma fonte de transmissão do Kinesis requer as seguintes opções de conexão: `streamARN`, `startingPosition`, `inferSchema` e `classification`.
Uma fonte de transmissão do Kafka requer as seguintes opções de conexão: `connectionName`, `topicName`, `startingOffsets`, `inferSchema` e `classification`.
+ `transformationContext`: o contexto de transformação associado ao coletor a ser usado pelos marcadores de trabalho. Definido como vazio por padrão.
+ `pushDownPredicate`: predicado em colunas de partição.
Retorna o `DataSource`.
Exemplo para fonte de transmissão do Amazon Kinesis:
```
val kinesisOptions = jsonOptions()
data_frame_datasource0 = glueContext.getSource("kinesis", kinesisOptions).getDataFrame()
private def jsonOptions(): JsonOptions = {
new JsonOptions(
s"""{"streamARN": "arn:aws:kinesis:eu-central-1:123456789012:stream/fromOptionsStream",
|"startingPosition": "TRIM_HORIZON",
|"inferSchema": "true",
|"classification": "json"}""".stripMargin)
}
```
Exemplo para fonte de transmissão do Kafka:
```
val kafkaOptions = jsonOptions()
val data_frame_datasource0 = glueContext.getSource("kafka", kafkaOptions).getDataFrame()
private def jsonOptions(): JsonOptions = {
new JsonOptions(
s"""{"connectionName": "ConfluentKafka",
|"topicName": "kafka-auth-topic",
|"startingOffsets": "earliest",
|"inferSchema": "true",
|"classification": "json"}""".stripMargin)
}
```
## def getSourceWithFormat
```
def getSourceWithFormat( connectionType : String,
options : JsonOptions,
transformationContext : String = "",
format : String = null,
formatOptions : JsonOptions = JsonOptions.empty
) : DataSource
```
Cria um [Característica do DataSource](glue-etl-scala-apis-glue-datasource-trait.md) que lê dados em uma fonte, como o Amazon S3, JDBC ou AWS Glue Data Catalog, e também define o formato dos dados armazenados na fonte.
+ `connectionType`: o tipo da origem dos dados. Consulte [Tipos e opções de conexão para ETL no AWS Glue para Spark](aws-glue-programming-etl-connect.md).
+ `options`: uma string de pares de nome-valor JSON que fornecem as informações adicionais para estabelecer uma conexão com a origem dos dados. Consulte [Tipos e opções de conexão para ETL no AWS Glue para Spark](aws-glue-programming-etl-connect.md).
+ `transformationContext`: o contexto de transformação associado ao coletor a ser usado pelos marcadores de trabalho. Definido como vazio por padrão.
+ `format`: o formato dos dados armazenados na fonte. Quando o `connectionType` é "s3", você também pode especificar `format`. Pode ser um de “avro”, “csv”, “grokLog”, “ion”, “json”, “xml”, “parquet” ou “orc”.
+ `formatOptions`: uma string de pares de nome-valor JSON que fornecem opções adicionais para a análise dos dados na fonte. Consulte [Opções de formato de dados](aws-glue-programming-etl-format.md).
Retorna o `DataSource`.
**Exemplos**
Crie um DynamicFrame a partir de uma origem de dados que seja um arquivo com valores separados por vírgula (CSV) no Amazon S3:
```
val datasource0 = glueContext.getSourceWithFormat(
connectionType="s3",
options =JsonOptions(s"""{"paths": [ "s3://csv/nycflights.csv"]}"""),
transformationContext = "datasource0",
format = "csv",
formatOptions=JsonOptions(s"""{"withHeader":"true","separator": ","}""")
).getDynamicFrame()
```
Crie um DynamicFrame a partir de uma origem de dados que seja um PostgreSQL usando uma conexão JDBC:
```
val datasource0 = glueContext.getSourceWithFormat(
connectionType="postgresql",
options =JsonOptions(s"""{
"url":"jdbc:postgresql://databasePostgres-1.rds.amazonaws.com:5432/testdb",
"dbtable": "public.company",
"redshiftTmpDir":"",
"user":"username",
"password":"password123"
}"""),
transformationContext = "datasource0").getDynamicFrame()
```
Crie um DynamicFrame a partir de uma origem de dados que seja um MySQL usando uma conexão JDBC:
```
val datasource0 = glueContext.getSourceWithFormat(
connectionType="mysql",
options =JsonOptions(s"""{
"url":"jdbc:mysql://databaseMysql-1.rds.amazonaws.com:3306/testdb",
"dbtable": "athenatest_nycflights13_csv",
"redshiftTmpDir":"",
"user":"username",
"password":"password123"
}"""),
transformationContext = "datasource0").getDynamicFrame()
```
## def getSparkSession
```
def getSparkSession : SparkSession
```
Obtém o objeto `SparkSession` associado a este GlueContext. Use este objeto SparkSession para registrar tabelas e UDFs a serem usados com `DataFrame` criado dos DynamicFrames.
Retorna o SparkSession.
## def startTransaction
```
def startTransaction(readOnly: Boolean):String
```
Iniciar uma nova transação. Chama internamente a API [startTransaction](https://docs.aws.amazon.com/lake-formation/latest/dg/aws-lake-formation-api-aws-lake-formation-api-transactions.html#aws-lake-formation-api-aws-lake-formation-api-transactions-StartTransaction) do Lake Formation.
+ `readOnly`: (booleano) indica se esta transação deve ser somente de leitura ou de leitura e gravação. As gravações feitas usando um ID de transação somente de leitura serão rejeitadas. As transações somente de leitura não precisam ser confirmadas.
Retorna o ID da transação.
## def commitTransaction
```
def commitTransaction(transactionId: String, waitForCommit: Boolean): Boolean
```
Tenta confirmar a transação especificada. `commitTransaction` pode retornar antes que a transação tenha terminado de confirmar. Chama internamente a API [commitTransaction](https://docs.aws.amazon.com/lake-formation/latest/dg/aws-lake-formation-api-aws-lake-formation-api-transactions.html#aws-lake-formation-api-aws-lake-formation-api-transactions-CommitTransaction) do Lake Formation.
+ `transactionId`: (string) a transação a ser confirmada.
+ `waitForCommit`: (booleano) Determina se `commitTransaction` retorna imediatamente. O valor padrão é true. Se for falso, `commitTransaction` sonda e aguarda até que a transação seja confirmada. A quantidade de tempo de espera é restrita a 1 minuto usando recuo exponencial com um máximo de 6 tentativas.
Retorna um booleano para indicar se a confirmação foi feita ou não.
## def cancelTransaction
```
def cancelTransaction(transactionId: String): Unit
```
Tenta cancelar a transação especificada. Chama internamente a API [cancelTransaction](https://docs.aws.amazon.com/lake-formation/latest/dg/aws-lake-formation-api-aws-lake-formation-api-transactions.html#aws-lake-formation-api-aws-lake-formation-api-transactions-CancelTransaction) do Lake Formation.
+ `transactionId`: (string) a transação a ser cancelada.
Retorna uma exceção `TransactionCommittedException` se a transação tiver sido confirmada anteriormente.
## def this
```
def this( sc : SparkContext,
minPartitions : Int,
targetPartitions : Int )
```
Cria um objeto `GlueContext` usando o `SparkContext` especificado, um mínimo de partições e partições de destino.
+ `sc` — O `SparkContext`.
+ `minPartitions` – O número mínimo de partições.
+ `targetPartitions` — O número destino de partições.
Retorna o `GlueContext`.
## def this
```
def this( sc : SparkContext )
```
Cria um objeto `GlueContext` com o `SparkContext` fornecido. Define o mínimo de partições como 10 e as partições de destino como 20.
+ `sc` — O `SparkContext`.
Retorna o `GlueContext`.
## def this
```
def this( sparkContext : JavaSparkContext )
```
Cria um objeto `GlueContext` com o `JavaSparkContext` fornecido. Define o mínimo de partições como 10 e as partições de destino como 20.
+ `sparkContext` — O `JavaSparkContext`.
Retorna o `GlueContext`.
# MappingSpec
**Pacote: com.amazonaws.services.glue**
## Classe do caso MappingSpec
```
case class MappingSpec( sourcePath: SchemaPath,
sourceType: DataType,
targetPath: SchemaPath,
targetType: DataTyp
) extends Product4[String, String, String, String] {
override def _1: String = sourcePath.toString
override def _2: String = ExtendedTypeName.fromDataType(sourceType)
override def _3: String = targetPath.toString
override def _4: String = ExtendedTypeName.fromDataType(targetType)
}
```
+ `sourcePath` – O `SchemaPath` do campo de origem.
+ `sourceType` – O `DataType` do campo de origem.
+ `targetPath` – O `SchemaPath` do campo de destino.
+ `targetType` – O `DataType` do campo de destino.
Um `MappingSpec` especifica um mapeamento de um caminho de origem e um tipo de dados de origem para um caminho de destino e um tipo de dados de destino. O valor no caminho de origem no quadro de origem aparece no quadro de destino no caminho de destino. O tipo de dados de origem é convertido no tipo de dados de destino.
Ele se estende a partir de `Product4` para que você possa lidar com qualquer `Product4` em sua interface do `applyMapping`.
## Objeto MappingSpec
```
object MappingSpec
```
O objeto `MappingSpec` tem os seguintes membros:
## Val orderingByTarget
```
val orderingByTarget: Ordering[MappingSpec]
```
## Def apply
```
def apply( sourcePath : String,
sourceType : DataType,
targetPath : String,
targetType : DataType
) : MappingSpec
```
Cria um `MappingSpec`.
+ `sourcePath` – Uma representação de string do caminho de origem.
+ `sourceType` — O de origem `DataType`.
+ `targetPath` – Uma representação de string do caminho de destino.
+ `targetType` — O de destino `DataType`.
Retorna um `MappingSpec`.
## Def apply
```
def apply( sourcePath : String,
sourceTypeString : String,
targetPath : String,
targetTypeString : String
) : MappingSpec
```
Cria um `MappingSpec`.
+ `sourcePath` – Uma representação de string do caminho de origem.
+ `sourceType` – Uma representação de string do tipo de dados de origem.
+ `targetPath` – Uma representação de string do caminho de destino.
+ `targetType` – Uma representação de string do tipo de dados de destino.
Retorna um MappingSpec.
## Def apply
```
def apply( product : Product4[String, String, String, String] ) : MappingSpec
```
Cria um `MappingSpec`.
+ `product` — O `Product4` do caminho de origem, do tipo de dados de origem, do caminho de destino e do tipo de dados de destino.
Retorna um `MappingSpec`.
# AWS GlueAPIs ResolveSpec no Scala do
**Topics**
+ [Objeto ResolveSpec](#glue-etl-scala-apis-glue-resolvespec-object)
+ [Classe do caso ResolveSpec](#glue-etl-scala-apis-glue-resolvespec-case-class)
**Pacote: com.amazonaws.services.glue**
## Objeto ResolveSpec
**ResolveSpec**
```
object ResolveSpec
```
### Def
```
def apply( path : String,
action : String
) : ResolveSpec
```
Cria um `ResolveSpec`.
+ `path` – Uma representação da string do campo de escolha que precisa ser resolvido.
+ `action`: uma ação de resolução. A ação pode ser uma das seguintes: `Project`, `KeepAsStruct` ou `Cast`.
Retorna o `ResolveSpec`.
### Def
```
def apply( product : Product2[String, String] ) : ResolveSpec
```
Cria um `ResolveSpec`.
+ `product` — `Product2` de: caminho de origem, ação de resolução.
Retorna o `ResolveSpec`.
## Classe do caso ResolveSpec
```
case class ResolveSpec extends Product2[String, String] (
path : SchemaPath,
action : String )
```
Cria um `ResolveSpec`.
+ `path` – O `SchemaPath` do campo de escolha que precisa ser resolvido.
+ `action`: uma ação de resolução. A ação pode ser uma das seguintes: `Project`, `KeepAsStruct` ou `Cast`.
### Métodos def ResolveSpec
```
def _1 : String
```
```
def _2 : String
```
# AWS GlueAPIs ArrayNode em Scala do
**Pacote: com.amazonaws.services.glue.types**
## Classe do caso ArrayNode
**ArrayNode**
```
case class ArrayNode extends DynamicNode (
value : ArrayBuffer[DynamicNode] )
```
### Métodos def de ArrayNode
```
def add( node : DynamicNode )
```
```
def clone
```
```
def equals( other : Any )
```
```
def get( index : Int ) : Option[DynamicNode]
```
```
def getValue
```
```
def hashCode : Int
```
```
def isEmpty : Boolean
```
```
def nodeType
```
```
def remove( index : Int )
```
```
def this
```
```
def toIterator : Iterator[DynamicNode]
```
```
def toJson : String
```
```
def update( index : Int,
node : DynamicNode )
```
# AWS GlueAPIs BinaryNode em Scala do
**Pacote: com.amazonaws.services.glue.types**
## Classe do caso BinaryNode
**BinaryNode**
```
case class BinaryNode extends ScalarNode(value, TypeCode.BINARY) (
value : Array[Byte] )
```
### Campos val BinaryNode
+ `ordering`
### Métodos def BinaryNode
```
def clone
```
```
def equals( other : Any )
```
```
def hashCode : Int
```
# AWS GlueAPIs BooleanNode em Scala no
**Pacote: com.amazonaws.services.glue.types**
## Classe do caso BooleanNode
**BooleanNode**
```
case class BooleanNode extends ScalarNode(value, TypeCode.BOOLEAN) (
value : Boolean )
```
### Campos val BooleanNode
+ `ordering`
### Métodos def BooleanNode
```
def equals( other : Any )
```
# AWS GlueAPIs de ByteNode de Scala do
**Pacote: com.amazonaws.services.glue.types**
## Classe do caso ByteNode
**ByteNode**
```
case class ByteNode extends ScalarNode(value, TypeCode.BYTE) (
value : Byte )
```
### Campos val ByteNode
+ `ordering`
### Métodos def ByteNode
```
def equals( other : Any )
```
# AWS GlueAPIs de DateNode de Scala do
**Pacote: com.amazonaws.services.glue.types**
## Classe do caso DateNode
**DateNode**
```
case class DateNode extends ScalarNode(value, TypeCode.DATE) (
value : Date )
```
### Campos val DateNode
+ `ordering`
### Métodos def DateNode
```
def equals( other : Any )
```
```
def this( value : Int )
```
# AWS GlueAPIs DecimalNode em Scala no
**Pacote: com.amazonaws.services.glue.types**
## Classe do caso DecimalNode
**DecimalNode**
```
case class DecimalNode extends ScalarNode(value, TypeCode.DECIMAL) (
value : BigDecimal )
```
### Campos val DecimalNode
+ `ordering`
### Métodos def DecimalNode
```
def equals( other : Any )
```
```
def this( value : Decimal )
```
# AWS GlueAPIs DoubleNode em Scala no
**Pacote: com.amazonaws.services.glue.types**
## Classe do caso DoubleNode
**DoubleNode**
```
case class DoubleNode extends ScalarNode(value, TypeCode.DOUBLE) (
value : Double )
```
### Campos val DoubleNode
+ `ordering`
### Métodos def DoubleNode
```
def equals( other : Any )
```
# AWS GlueAPIs DynamicNode em Scala no
**Topics**
+ [Classe DynamicNode](#glue-etl-scala-apis-glue-types-dynamicnode-class)
+ [Objeto DynamicNode](#glue-etl-scala-apis-glue-types-dynamicnode-object)
**Pacote: com.amazonaws.services.glue.types**
## Classe DynamicNode
**DynamicNode**
```
class DynamicNode extends Serializable with Cloneable
```
### Métodos def DynamicNode
```
def getValue : Any
```
Obter um valor simples e vinculado ao registro atual:
```
def nodeType : TypeCode
```
```
def toJson : String
```
Método para depuração:
```
def toRow( schema : Schema,
options : Map[String, ResolveOption]
) : Row
```
```
def typeName : String
```
## Objeto DynamicNode
**DynamicNode**
```
object DynamicNode
```
### Métodos def DynamicNode
```
def quote( field : String,
useQuotes : Boolean
) : String
```
```
def quote( node : DynamicNode,
useQuotes : Boolean
) : String
```
# Classe EvaluateDataQuality
| |
| --- |
| O AWS Glue Data Quality está em uma versão pré-lançamento do AWS Glue e está sujeito a alterações. |
**Pacote: com.amazonaws.services.glue.dq**
```
object EvaluateDataQuality
```
## Def apply
```
def apply(frame: DynamicFrame,
ruleset: String,
publishingOptions: JsonOptions = JsonOptions.empty): DynamicFrame
```
Avalia um conjunto de regras de qualidade de dados em relação a um `DynamicFrame` e retorna um novo `DynamicFrame` com os resultados da avaliação. Para saber mais sobre o AWS Glue Data Quality, consulte [AWS Glue Data Quality](glue-data-quality.md).
+ `frame`: o `DynamicFrame` cuja qualidade de dados você deseja avaliar.
+ `ruleset`: um conjunto de regras em Data Quality Definition Language (DQDL) no formato de string. Para saber mais sobre DQDL, consulte o guia de [Referência de Data Quality Definition Language (DQDL)](dqdl.md).
+ `publishingOptions`: um dicionário que especifica as seguintes opções para publicar resultados e métricas de avaliação:
+ `dataQualityEvaluationContext`: uma string que especifica o namespace com o qual o AWS Glue deve publicar as métricas e os resultados de qualidade dos dados do Amazon CloudWatch. As métricas agregadas aparecem no CloudWatch, enquanto os resultados completos aparecem na interface do AWS Glue Studio.
+ Obrigatório: Não
+ Valor padrão: `default_context`
+ `enableDataQualityCloudWatchMetrics`: especifica se os resultados da avaliação de qualidade dos dados devem ser publicados no CloudWatch. Você especifica um namespace para as métricas usando a opção `dataQualityEvaluationContext`.
+ Obrigatório: Não
+ Valor padrão: False
+ `enableDataQualityResultsPublishing`: especifica se os resultados de qualidade dos dados devem estar visíveis na guia **Data Quality** (Qualidade de dados) na interface do AWS Glue Studio.
+ Obrigatório: Não
+ Valor padrão: true
+ `resultsS3Prefix`: especifica o local no Amazon S3 em que o AWS Glue pode gravar os resultados da avaliação de qualidade dos dados.
+ Obrigatório: Não
+ Valor padrão: "" (string vazia)
## Exemplo
O código de exemplo a seguir demonstra como avaliar a qualidade dos dados de um `DynamicFrame` antes de realizar uma transformação `SelectFields`. O script verifica se todas as regras de qualidade de dados são aprovadas antes de tentar a transformação.
```
import com.amazonaws.services.glue.GlueContext
import com.amazonaws.services.glue.MappingSpec
import com.amazonaws.services.glue.errors.CallSite
import com.amazonaws.services.glue.util.GlueArgParser
import com.amazonaws.services.glue.util.Job
import com.amazonaws.services.glue.util.JsonOptions
import org.apache.spark.SparkContext
import scala.collection.JavaConverters._
import com.amazonaws.services.glue.dq.EvaluateDataQuality
object GlueApp {
def main(sysArgs: Array[String]) {
val spark: SparkContext = new SparkContext()
val glueContext: GlueContext = new GlueContext(spark)
// @params: [JOB_NAME]
val args = GlueArgParser.getResolvedOptions(sysArgs, Seq("JOB_NAME").toArray)
Job.init(args("JOB_NAME"), glueContext, args.asJava)
// Create DynamicFrame with data
val Legislators_Area = glueContext.getCatalogSource(database="legislators", tableName="areas_json", transformationContext="S3bucket_node1").getDynamicFrame()
// Define data quality ruleset
val DQ_Ruleset = """
Rules = [ColumnExists "id"]
"""
// Evaluate data quality
val DQ_Results = EvaluateDataQuality.apply(frame=Legislators_Area, ruleset=DQ_Ruleset, publishingOptions=JsonOptions("""{"dataQualityEvaluationContext": "Legislators_Area", "enableDataQualityMetrics": "true", "enableDataQualityResultsPublishing": "true"}"""))
assert(DQ_Results.filter(_.getField("Outcome").contains("Failed")).count == 0, "Failing DQ rules for Legislators_Area caused the job to fail.")
// Script generated for node Select Fields
val SelectFields_Results = Legislators_Area.selectFields(paths=Seq("id", "name"), transformationContext="Legislators_Area")
Job.commit()
}
}
```
# AWS GlueAPIs FloatNode em Scala do
**Pacote: com.amazonaws.services.glue.types**
## Classe do caso FloatNode
**FloatNode**
```
case class FloatNode extends ScalarNode(value, TypeCode.FLOAT) (
value : Float )
```
### Campos val FloatNode
+ `ordering`
### Métodos def FloatNode
```
def equals( other : Any )
```
# Classe FillMissingValues
**Pacote: com.amazonaws.services.glue.ml**
```
object FillMissingValues
```
## Def apply
```
def apply(frame: DynamicFrame,
missingValuesColumn: String,
outputColumn: String = "",
transformationContext: String = "",
callSite: CallSite = CallSite("Not provided", ""),
stageThreshold: Long = 0,
totalThreshold: Long = 0): DynamicFrame
```
Preenche os valores ausentes de um quadro dinâmico em uma coluna especificada e retorna um novo quadro com estimativas em uma nova coluna. Para linhas sem valores ausentes, o valor da coluna especificada é duplicado para a nova coluna.
+ `frame`: o DynamicFrame no qual preencher valores ausentes. Obrigatório.
+ `missingValuesColumn`: a coluna que contém valores ausentes (valores `null` e strings vazias). Obrigatório.
+ `outputColumn`: o nome da nova coluna que conterá valores estimados para todas as linhas cujo valor estava ausente. Opcional. O padrão é o valor da `missingValuesColumn` seguida do sufixo `"_filled"`.
+ `transformationContext`: uma string única que é usada para identificar informações de estado (opcional).
+ `callSite`: usado para fornecer informações de contexto para o relatório de erros (opcional).
+ `stageThreshold`: o número máximo de erros que podem ocorrer na transformação antes que ela falhe (opcional, o padrão é zero).
+ `totalThreshold`: o número máximo de erros que podem ocorrer antes que o processamento falhe (opcional, o padrão é zero).
Retorna um novo quadro dinâmico com uma coluna adicional que contém estimativas para linhas com valores ausentes e o valor presente para outras linhas.
# Classe FindMatches
**Pacote: com.amazonaws.services.glue.ml**
```
object FindMatches
```
## Def apply
```
def apply(frame: DynamicFrame,
transformId: String,
transformationContext: String = "",
callSite: CallSite = CallSite("Not provided", ""),
stageThreshold: Long = 0,
totalThreshold: Long = 0,
enforcedMatches: DynamicFrame = null): DynamicFrame,
computeMatchConfidenceScores: Boolean
```
Localize correspondências em um quadro de entrada e retorne um novo quadro com uma nova coluna contendo um ID exclusivo por grupo de correspondência.
+ `frame`: o DynamicFrame no qual encontrar correspondências. Obrigatório.
+ `transformId`: o ID exclusivo associado à transformação FindMatches a ser aplicado em registros no quadro de entrada. Obrigatório.
+ `transformationContext`: o identificador para esse `DynamicFrame`. O `transformationContext` é usado como uma chave para o estado do marcador de trabalho que é mantido nas execuções. Opcional.
+ `callSite`: usado para fornecer informações de contexto para o relatório de erros. Esses valores são definidos automaticamente quando chamados do Python. Opcional.
+ `stageThreshold`: o número máximo de registros de erros permitidos a partir da computação desse `DynamicFrame` antes de lançar uma exceção, excluindo os registros presentes no `DynamicFrame` anterior. Opcional. O padrão é zero.
+ `totalThreshold`: o número máximo de registros de erros totais antes que uma exceção seja lançada, incluindo os de quadros anteriores. Opcional. O padrão é zero.
+ `enforcedMatches`: o quadro para correspondências impostas. Opcional. O padrão é `null`.
+ `computeMatchConfidenceScores`: um valor booleano que indica se é preciso calcular uma pontuação de confiança para cada grupo de registros correspondentes. Opcional. O padrão é falso.
Retorna um novo quadro dinâmico com um identificador exclusivo atribuído a cada grupo de registros correspondentes.
# Classe FindIncrementalMatches
**Pacote: com.amazonaws.services.glue.ml**
```
object FindIncrementalMatches
```
## Def apply
```
apply(existingFrame: DynamicFrame,
incrementalFrame: DynamicFrame,
transformId: String,
transformationContext: String = "",
callSite: CallSite = CallSite("Not provided", ""),
stageThreshold: Long = 0,
totalThreshold: Long = 0,
enforcedMatches: DynamicFrame = null): DynamicFrame,
computeMatchConfidenceScores: Boolean
```
Encontre correspondências entre os quadros existentes e incrementais e retorne um novo quadro com uma coluna contendo um ID exclusivo por grupo de correspondência.
+ `existingframe`: um quadro existente ao qual foi atribuído um ID correspondente para cada grupo. Obrigatório.
+ `incrementalframe`: um quadro incremental usado para encontrar correspondências no quadro existente. Obrigatório.
+ `transformId`: o ID exclusivo associado à transformação FindIncrementalMatches a ser aplicado em registros no quadro de entrada. Obrigatório.
+ `transformationContext`: o identificador para esse `DynamicFrame`. O `transformationContext` é usado como uma chave para o estado do marcador de trabalho que é mantido nas execuções. Opcional.
+ `callSite`: usado para fornecer informações de contexto para o relatório de erros. Esses valores são definidos automaticamente quando chamados do Python. Opcional.
+ `stageThreshold`: o número máximo de registros de erros permitidos a partir da computação desse `DynamicFrame` antes de lançar uma exceção, excluindo os registros presentes no `DynamicFrame` anterior. Opcional. O padrão é zero.
+ `totalThreshold`: o número máximo de registros de erros totais antes que uma exceção seja lançada, incluindo os de quadros anteriores. Opcional. O padrão é zero.
+ `enforcedMatches`: o quadro para correspondências impostas. Opcional. O padrão é `null`.
+ `computeMatchConfidenceScores`: um valor booleano que indica se é preciso calcular uma pontuação de confiança para cada grupo de registros correspondentes. Opcional. O padrão é falso.
Retorna um novo quadro dinâmico com um identificador exclusivo atribuído a cada grupo de registros correspondentes.
# AWS GlueAPIs de IntegerNode de Scala do
**Pacote: com.amazonaws.services.glue.types**
## Classe do caso IntegerNode
**IntegerNode**
```
case class IntegerNode extends ScalarNode(value, TypeCode.INT) (
value : Int )
```
### Campos val IntegerNode
+ `ordering`
### Métodos def IntegerNode
```
def equals( other : Any )
```
# AWS GlueAPIs LongNode em Scala do
**Pacote: com.amazonaws.services.glue.types**
## Classe do caso LongNode
**LongNode**
```
case class LongNode extends ScalarNode(value, TypeCode.LONG) (
value : Long )
```
### Campos val LongNode
+ `ordering`
### Métodos def LongNode
```
def equals( other : Any )
```
# AWS GlueAPIs MapLikeNode no Scala do
**Pacote: com.amazonaws.services.glue.types**
## Classe MapLikeNode
**MapLikeNode**
```
class MapLikeNode extends DynamicNode (
value : mutable.Map[String, DynamicNode] )
```
### Métodos def MapLikeNode
```
def clear : Unit
```
```
def get( name : String ) : Option[DynamicNode]
```
```
def getValue
```
```
def has( name : String ) : Boolean
```
```
def isEmpty : Boolean
```
```
def put( name : String,
node : DynamicNode
) : Option[DynamicNode]
```
```
def remove( name : String ) : Option[DynamicNode]
```
```
def toIterator : Iterator[(String, DynamicNode)]
```
```
def toJson : String
```
```
def toJson( useQuotes : Boolean ) : String
```
**Exemplo:** Dado esse JSON:
```
{"foo": "bar"}
```
Se `useQuotes == true`, `toJson` gera `{"foo": "bar"}`. Se `useQuotes == false`, `toJson` gera `{foo: bar}` @return.
# APIs MapNode no Scala do AWS Glue
**Pacote: com.amazonaws.services.glue.types**
## Classe do caso MapNode
**MapNode**
```
case class MapNode extends MapLikeNode(value) (
value : mutable.Map[String, DynamicNode] )
```
### Métodos def MapNode
```
def clone
```
```
def equals( other : Any )
```
```
def hashCode : Int
```
```
def nodeType
```
```
def this
```
# AWS GlueAPIs NullNode no Scala do
**Topics**
+ [Classe NullNode](#glue-etl-scala-apis-glue-types-nullnode-class)
+ [Objeto do caso NullNode](#glue-etl-scala-apis-glue-types-nullnode-case-object)
**Pacote: com.amazonaws.services.glue.types**
## Classe NullNode
**NullNode**
```
class NullNode
```
## Objeto do caso NullNode
**NullNode**
```
case object NullNode extends NullNode
```
# AWS GlueAPIs ObjectNode no Scala do
**Topics**
+ [Objeto ObjectNode](#glue-etl-scala-apis-glue-types-objectnode-object)
+ [Classe do caso ObjectNode](#glue-etl-scala-apis-glue-types-objectnode-case-class)
**Pacote: com.amazonaws.services.glue.types**
## Objeto ObjectNode
**ObjectNode**
```
object ObjectNode
```
### Métodos def ObjectNode
```
def apply( frameKeys : Set[String],
v1 : mutable.Map[String, DynamicNode],
v2 : mutable.Map[String, DynamicNode],
resolveWith : String
) : ObjectNode
```
## Classe do caso ObjectNode
**ObjectNode**
```
case class ObjectNode extends MapLikeNode(value) (
val value : mutable.Map[String, DynamicNode] )
```
### Métodos def ObjectNode
```
def clone
```
```
def equals( other : Any )
```
```
def hashCode : Int
```
```
def nodeType
```
```
def this
```
# APIs ScalarNode no Scala do AWS Glue
**Topics**
+ [Classe ScalarNode](#glue-etl-scala-apis-glue-types-scalarnode-class)
+ [Objeto ScalarNode](#glue-etl-scala-apis-glue-types-scalarnode-object)
**Pacote: com.amazonaws.services.glue.types**
## Classe ScalarNode
**ScalarNode**
```
class ScalarNode extends DynamicNode (
value : Any,
scalarType : TypeCode )
```
### Métodos def ScalarNode
```
def compare( other : Any,
operator : String
) : Boolean
```
```
def getValue
```
```
def hashCode : Int
```
```
def nodeType
```
```
def toJson
```
## Objeto ScalarNode
**ScalarNode**
```
object ScalarNode
```
### Métodos def ScalarNode
```
def apply( v : Any ) : DynamicNode
```
```
def compare( tv : Ordered[T],
other : T,
operator : String
) : Boolean
```
```
def compareAny( v : Any,
y : Any,
o : String )
```
```
def withEscapedSpecialCharacters( jsonToEscape : String ) : String
```
# AWS GlueAPIs ShortNode no Scala do
**Pacote: com.amazonaws.services.glue.types**
## Classe do caso ShortNode
**ShortNode**
```
case class ShortNode extends ScalarNode(value, TypeCode.SHORT) (
value : Short )
```
### Campos val ShortNode
+ `ordering`
### Métodos def ShortNode
```
def equals( other : Any )
```
# AWS GlueAPIs StringNode no Scala do
**Pacote: com.amazonaws.services.glue.types**
## Classe do caso StringNode
**StringNode**
```
case class StringNode extends ScalarNode(value, TypeCode.STRING) (
value : String )
```
### Campos val StringNode
+ `ordering`
### Métodos def StringNode
```
def equals( other : Any )
```
```
def this( value : UTF8String )
```
# AWS GlueAPIs TimestampNode no Scala do
**Pacote: com.amazonaws.services.glue.types**
## Classe do caso TimestampNode
**TimestampNode**
```
case class TimestampNode extends ScalarNode(value, TypeCode.TIMESTAMP) (
value : Timestamp )
```
### Campos val TimestampNode
+ `ordering`
### Métodos def TimestampNode
```
def equals( other : Any )
```
```
def this( value : Long )
```
# AWS GlueAPIs GlueArgParser em Scala no
**Pacote: com.amazonaws.services.glue.util**
## Objeto GlueArgParser
**GlueArgParser**
```
object GlueArgParser
```
Isso é estritamente consistente com a versão do Python de `utils.getResolvedOptions` no pacote `AWSGlueDataplanePython`.
### Métodos def GlueArgParser
```
def getResolvedOptions( args : Array[String],
options : Array[String]
) : Map[String, String]
```
```
def initParser( userOptionsSet : mutable.Set[String] ) : ArgumentParser
```
**Example Recuperar argumentos passados para um trabalho**
Para recuperar os argumentos do trabalho, você pode usar o método `getResolvedOptions`. Considere o exemplo a seguir, que recupera um argumento de trabalho denominado `aws_region`.
```
val args = GlueArgParser.getResolvedOptions(sysArgs, Seq("JOB_NAME","aws_region").toArray)
Job.init(args("JOB_NAME"), glueContext, args.asJava)
val region = args("aws_region")
println(region)
```
# APIs de trabalho em Scala do AWS Glue
**Pacote: com.amazonaws.services.glue.util**
## Objeto Job
**Trabalho**
```
object Job
```
### Métodos def Job
```
def commit
```
```
def init( jobName : String,
glueContext : GlueContext,
args : java.util.Map[String, String] = Map[String, String]().asJava
) : this.type
```
```
def init( jobName : String,
glueContext : GlueContext,
endpoint : String,
args : java.util.Map[String, String]
) : this.type
```
```
def isInitialized
```
```
def reset
```
```
def runId
```