Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Programmation de scripts ETL AWS Glue dans Scala
Vous pouvez trouver des exemples de code et des utilitaires Scala AWS Glue dans le [référentiel AWS Glue d'exemples](https://github.com/awslabs/aws-glue-samples) sur le GitHub site Web.
AWS Glue prend en charge une extension du dialecte PySpark Scala pour les tâches d'extraction, de transformation et de chargement (ETL) par script. Les sections suivantes décrivent comment utiliser la bibliothèque Scala AWS Glue et l'API AWS Glue dans les scripts ETL, et fournissent la documentation de référence pour la bibliothèque.
**Contents**
+ [Utilisation de Scala](glue-etl-scala-using.md)
+ [Tester sur un DevEndpoint ordinateur portable](glue-etl-scala-using.md#aws-glue-programming-scala-using-notebook)
+ [Test sur un DevEndpoint REPL](glue-etl-scala-using.md#aws-glue-programming-scala-using-repl)
+ [Exemple de script Scala](glue-etl-scala-example.md)
+ [Liste des API 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)
+ [ChoiceOption trait](glue-etl-scala-apis-glue-choiceoption.md#glue-etl-scala-apis-glue-choiceoption-trait)
+ [ChoiceOption objet](glue-etl-scala-apis-glue-choiceoption.md#glue-etl-scala-apis-glue-choiceoption-object)
+ [Appliquer](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)
+ [pyWriteDynamiccadre](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)
+ [pyWriteDatacadre](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)
+ [errorsAsDynamiccadre](glue-etl-scala-apis-glue-datasink-class.md#glue-etl-scala-apis-glue-datasink-class-defs-errorsAsDynamicFrame)
+ [DataSink objet](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)
+ [DataSource trait](glue-etl-scala-apis-glue-datasource-trait.md)
+ [DynamicFrame](glue-etl-scala-apis-glue-dynamicframe.md)
+ [DynamicFrame classe](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)
+ [Nombre](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)
+ [errorsAsDynamicChâssis](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-errorsAsDynamicFrame)
+ [Filtre](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)
+ [getSchemaIfCalculé](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)
+ [Joindre](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-join)
+ [Map](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)
+ [Afficher](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-show)
+ [Simplifier DDBJson](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)
+ [bouleverser DDBJson](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)
+ [DynamicFrame objet](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)
+ [Déf 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)
+ [newFrameWithErreurs de définition](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)
+ [Écrire](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)
+ [Égal à](glue-etl-scala-apis-glue-dynamicrecord-class.md#glue-etl-scala-apis-glue-dynamicrecord-class-defs-equals)
+ [DynamicRecord objet](glue-etl-scala-apis-glue-dynamicrecord-class.md#glue-etl-scala-apis-glue-dynamicrecord-object)
+ [Appliquer](glue-etl-scala-apis-glue-dynamicrecord-class.md#glue-etl-scala-apis-glue-dynamicrecord-object-defs-apply)
+ [RecordTraverser trait](glue-etl-scala-apis-glue-dynamicrecord-class.md#glue-etl-scala-apis-glue-recordtraverser-trait)
+ [GlueContext](glue-etl-scala-apis-glue-gluecontext.md)
+ [addIngestionTimeColonnes](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)
+ [obtenir JDBCSink](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)
+ [getSinkWithFormater](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)
+ [getSourceWithFormater](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)
+ [MappingSpec classe de cas](glue-etl-scala-apis-glue-mappingspec.md#glue-etl-scala-apis-glue-mappingspec-case-class)
+ [MappingSpec objet](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)
+ [Appliquer](glue-etl-scala-apis-glue-mappingspec.md#glue-etl-scala-apis-glue-mappingspec-object-defs-apply-1)
+ [Appliquer](glue-etl-scala-apis-glue-mappingspec.md#glue-etl-scala-apis-glue-mappingspec-object-defs-apply-2)
+ [Appliquer](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)
+ [ResolveSpec objet](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)
+ [ResolveSpec classe de cas](glue-etl-scala-apis-glue-resolvespec.md#glue-etl-scala-apis-glue-resolvespec-case-class)
+ [Méthodes 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)
+ [ArrayNode classe de cas](glue-etl-scala-apis-glue-types-arraynode.md#glue-etl-scala-apis-glue-types-arraynode-case-class)
+ [Méthodes 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)
+ [BinaryNode classe de cas](glue-etl-scala-apis-glue-types-binarynode.md#glue-etl-scala-apis-glue-types-binarynode-case-class)
+ [Champs val](glue-etl-scala-apis-glue-types-binarynode.md#glue-etl-scala-apis-glue-types-binarynode-case-class-vals)
+ [Méthodes 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)
+ [BooleanNode classe de cas](glue-etl-scala-apis-glue-types-booleannode.md#glue-etl-scala-apis-glue-types-booleannode-case-class)
+ [Champs val](glue-etl-scala-apis-glue-types-booleannode.md#glue-etl-scala-apis-glue-types-booleannode-case-class-vals)
+ [Méthodes 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)
+ [ByteNode classe de cas](glue-etl-scala-apis-glue-types-bytenode.md#glue-etl-scala-apis-glue-types-bytenode-case-class)
+ [Champs val](glue-etl-scala-apis-glue-types-bytenode.md#glue-etl-scala-apis-glue-types-bytenode-case-class-vals)
+ [Méthodes 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)
+ [DateNode classe de cas](glue-etl-scala-apis-glue-types-datenode.md#glue-etl-scala-apis-glue-types-datenode-case-class)
+ [Champs val](glue-etl-scala-apis-glue-types-datenode.md#glue-etl-scala-apis-glue-types-datenode-case-class-vals)
+ [Méthodes 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)
+ [DecimalNode classe de cas](glue-etl-scala-apis-glue-types-decimalnode.md#glue-etl-scala-apis-glue-types-decimalnode-case-class)
+ [Champs val](glue-etl-scala-apis-glue-types-decimalnode.md#glue-etl-scala-apis-glue-types-decimalnode-case-class-vals)
+ [Méthodes 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)
+ [DoubleNode classe de cas](glue-etl-scala-apis-glue-types-doublenode.md#glue-etl-scala-apis-glue-types-doublenode-case-class)
+ [Champs val](glue-etl-scala-apis-glue-types-doublenode.md#glue-etl-scala-apis-glue-types-doublenode-case-class-vals)
+ [Méthodes 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)
+ [DynamicNode classe](glue-etl-scala-apis-glue-types-dynamicnode.md#glue-etl-scala-apis-glue-types-dynamicnode-class)
+ [Méthodes def](glue-etl-scala-apis-glue-types-dynamicnode.md#glue-etl-scala-apis-glue-types-dynamicnode-class-defs)
+ [DynamicNode objet](glue-etl-scala-apis-glue-types-dynamicnode.md#glue-etl-scala-apis-glue-types-dynamicnode-object)
+ [Méthodes 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)
+ [s’appliquent](glue-etl-scala-apis-glue-dq-EvaluateDataQuality.md#glue-etl-scala-apis-glue-dq-EvaluateDataQuality-defs-apply)
+ [Exemple](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)
+ [FloatNode classe de cas](glue-etl-scala-apis-glue-types-floatnode.md#glue-etl-scala-apis-glue-types-floatnode-case-class)
+ [Champs val](glue-etl-scala-apis-glue-types-floatnode.md#glue-etl-scala-apis-glue-types-floatnode-case-class-vals)
+ [Méthodes 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)
+ [Appliquer](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)
+ [Appliquer](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)
+ [Appliquer](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)
+ [IntegerNode classe de cas](glue-etl-scala-apis-glue-types-integernode.md#glue-etl-scala-apis-glue-types-integernode-case-class)
+ [Champs val](glue-etl-scala-apis-glue-types-integernode.md#glue-etl-scala-apis-glue-types-integernode-case-class-vals)
+ [Méthodes 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)
+ [LongNode classe de cas](glue-etl-scala-apis-glue-types-longnode.md#glue-etl-scala-apis-glue-types-longnode-case-class)
+ [Champs val](glue-etl-scala-apis-glue-types-longnode.md#glue-etl-scala-apis-glue-types-longnode-case-class-vals)
+ [Méthodes 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)
+ [MapLikeNode classe](glue-etl-scala-apis-glue-types-maplikenode.md#glue-etl-scala-apis-glue-types-maplikenode-class)
+ [Méthodes 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)
+ [MapNode classe de cas](glue-etl-scala-apis-glue-types-mapnode.md#glue-etl-scala-apis-glue-types-mapnode-case-class)
+ [Méthodes 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)
+ [NullNode classe](glue-etl-scala-apis-glue-types-nullnode.md#glue-etl-scala-apis-glue-types-nullnode-class)
+ [NullNode objet du boîtier](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)
+ [ObjectNode objet](glue-etl-scala-apis-glue-types-objectnode.md#glue-etl-scala-apis-glue-types-objectnode-object)
+ [Méthodes def](glue-etl-scala-apis-glue-types-objectnode.md#glue-etl-scala-apis-glue-types-objectnode-object-defs)
+ [ObjectNode classe de cas](glue-etl-scala-apis-glue-types-objectnode.md#glue-etl-scala-apis-glue-types-objectnode-case-class)
+ [Méthodes 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)
+ [ScalarNode classe](glue-etl-scala-apis-glue-types-scalarnode.md#glue-etl-scala-apis-glue-types-scalarnode-class)
+ [Méthodes def](glue-etl-scala-apis-glue-types-scalarnode.md#glue-etl-scala-apis-glue-types-scalarnode-class-defs)
+ [ScalarNode objet](glue-etl-scala-apis-glue-types-scalarnode.md#glue-etl-scala-apis-glue-types-scalarnode-object)
+ [Méthodes 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)
+ [ShortNode classe de cas](glue-etl-scala-apis-glue-types-shortnode.md#glue-etl-scala-apis-glue-types-shortnode-case-class)
+ [Champs val](glue-etl-scala-apis-glue-types-shortnode.md#glue-etl-scala-apis-glue-types-shortnode-case-class-vals)
+ [Méthodes 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)
+ [StringNode classe de cas](glue-etl-scala-apis-glue-types-stringnode.md#glue-etl-scala-apis-glue-types-stringnode-case-class)
+ [Champs val](glue-etl-scala-apis-glue-types-stringnode.md#glue-etl-scala-apis-glue-types-stringnode-case-class-vals)
+ [Méthodes 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)
+ [TimestampNode classe de cas](glue-etl-scala-apis-glue-types-timestampnode.md#glue-etl-scala-apis-glue-types-timestampnode-case-class)
+ [Champs val](glue-etl-scala-apis-glue-types-timestampnode.md#glue-etl-scala-apis-glue-types-timestampnode-case-class-vals)
+ [Méthodes 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)
+ [GlueArgParser objet](glue-etl-scala-apis-glue-util-glueargparser.md#glue-etl-scala-apis-glue-util-glueargparser-object)
+ [Méthodes def](glue-etl-scala-apis-glue-util-glueargparser.md#glue-etl-scala-apis-glue-util-glueargparser-object-defs)
+ [Tâche](glue-etl-scala-apis-glue-util-job.md)
+ [Objet Job](glue-etl-scala-apis-glue-util-job.md#glue-etl-scala-apis-glue-util-job-object)
+ [Méthodes def](glue-etl-scala-apis-glue-util-job.md#glue-etl-scala-apis-glue-util-job-object-defs)
# Utilisation de Scala pour programmer les scripts ETL AWS Glue
Vous pouvez générer automatiquement un programme ETL Scala à l'aide de la console AWS Glue et le modifier si nécessaire avant de l'affecter à une tâche. Vous pouvez également écrire votre propre programme à partir de zéro. Pour plus d'informations, consultez [Configuration des propriétés des tâches pour les tâches Spark dans AWS Glue](add-job.md). AWS Glue compile ensuite votre programme Scala sur le serveur avant d'exécuter la tâche associée.
Pour vous assurer que votre programme compile sans erreur et s'exécute comme prévu, il est important de le charger sur un point de développement dans un REPL (Read-Eval-Print Loop) ou un bloc-notes Jupyter et de le tester là avant de l'exécuter dans une tâche. Étant donné que le processus de compilation intervient sur le serveur, vous n'aurez pas une bonne visibilité sur les éventuels problèmes qui s'y produisent.
## Test d'un programme ETL Scala dans un bloc-notes Jupyter sur un point de terminaison de développement
Pour tester un programme Scala sur un point de terminaison de développement AWS Glue, définissez le point de terminaison de développement comme décrit dans [Ajout d'un point de terminaison de développement](add-dev-endpoint.md).
Ensuite, connectez-le à un bloc-notes Jupyter s'exécutant localement sur votre machine ou à distance sur un serveur de bloc-notes Amazon EC2. Pour installer une version locale d'un bloc-notes Jupyter, suivez les instructions fournies dans [Tutoriel : bloc-notes Jupyter dans JupyterLab](dev-endpoint-tutorial-local-jupyter.md).
La seule différence entre exécuter du code Scala et exécuter PySpark du code sur votre bloc-notes est que vous devez commencer chaque paragraphe du bloc-notes avec ce qui suit :
```
%spark
```
Cela empêche le serveur Notebook d'utiliser par défaut la version de l' PySparkinterpréteur Spark.
## Test d'un programme ETL Scala dans un REPL Scala
Vous pouvez tester un programme Scala sur un point de terminaison de développement à l'aide d'un REPL Scala AWS Glue. Suivez les instructions indiquées dans[Tutoriel : Utiliser un bloc-notes SageMaker AIDidacticiel : Utilisation d'un shell REPL](dev-endpoint-tutorial-repl.md), sauf à la fin de la SSH-to-REPL commande, remplacez `-t gluepyspark` par`-t glue-spark-shell`. Cela appelle la fonction REPL Scala AWS Glue.
Pour fermer la fonction REPL lorsque vous avez terminé, tapez `sys.exit`.
# Exemple de script Scala — ETL de streaming
**Example**
L'exemple de script ci-dessous se connecte à Amazon Kinesis Data Streams, utilise un schéma à partir du Data Catalog pour analyser un flux de données, joint le flux à un jeu de données statique sur Amazon S3 et génère les résultats joints dans Amazon S3 au format 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 dans la bibliothèque AWS Glue Scala
AWS Glueprend en charge une extension du dialecte PySpark Scala pour les tâches d'extraction, de transformation et de chargement (ETL) de scripts. Les sections suivantes décrivent le contenu APIs de la bibliothèque AWS Glue Scala.
## com.amazonaws.services.glue
Le package **com.amazonaws.services.glue de la bibliothèque Scala** contient les AWS Glue éléments suivants : APIs
+ [ChoiceOption](glue-etl-scala-apis-glue-choiceoption.md)
+ [DataSink](glue-etl-scala-apis-glue-datasink-class.md)
+ [DataSource trait](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
Le package **com.amazonaws.services.glue.ml** de la bibliothèque Scala contient les éléments suivants : AWS Glue 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
Le package **com.amazonaws.services.glue.dq** de la bibliothèque Scala contient les éléments suivants : AWS Glue APIs
+ [EvaluateDataQuality](glue-etl-scala-apis-glue-dq-EvaluateDataQuality.md)
## com.amazonaws.services.glue.types
Le package **com.amazonaws.services.glue.types** de la bibliothèque Scala contient les éléments suivants : AWS Glue 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
Le package **com.amazonaws.services.glue.util** de la bibliothèque Scala contient les éléments suivants : AWS Glue APIs
+ [GlueArgParser](glue-etl-scala-apis-glue-util-glueargparser.md)
+ [Tâche](glue-etl-scala-apis-glue-util-job.md)
# AWS GlueScala ChoiceOption APIs
**Topics**
+ [ChoiceOption trait](#glue-etl-scala-apis-glue-choiceoption-trait)
+ [ChoiceOption objet](#glue-etl-scala-apis-glue-choiceoption-object)
+ [Classe de cas ChoiceOptionWithResolver](#glue-etl-scala-apis-glue-choiceoptionwithresolver-case-class)
+ [Classe de cas MatchCatalogSchemaChoiceOption](#glue-etl-scala-apis-glue-matchcatalogschemachoiceoption-case-class)
**Package : com.amazonaws.services.glue**
## ChoiceOption trait
```
trait ChoiceOption extends Serializable
```
## ChoiceOption objet
**ChoiceOption**
```
object ChoiceOption
```
Une stratégie générale pour résoudre les choix applicables à tous les nœuds `ChoiceType` d'un `DynamicFrame`.
+ `val CAST`
+ `val MAKE_COLS`
+ `val MAKE_STRUCT`
+ `val MATCH_CATALOG`
+ `val PROJECT`
### def apply
```
def apply(choice: String): ChoiceOption
```
## Classe de cas ChoiceOptionWithResolver
```
case class ChoiceOptionWithResolver(name: String, choiceResolver: ChoiceResolver) extends ChoiceOption {}
```
## Classe de cas MatchCatalogSchemaChoiceOption
```
case class MatchCatalogSchemaChoiceOption() extends ChoiceOption {}
```
# DataSink Classe abstraite
**Topics**
+ [Déf writeDynamicFrame](#glue-etl-scala-apis-glue-datasink-class-defs-writeDynamicFrame)
+ [pyWriteDynamicCadre Def](#glue-etl-scala-apis-glue-datasink-class-defs-pyWriteDynamicFrame)
+ [Déf writeDataFrame](#glue-etl-scala-apis-glue-datasink-class-defs-writeDataFrame)
+ [pyWriteDataCadre Def](#glue-etl-scala-apis-glue-datasink-class-defs-pyWriteDataFrame)
+ [Déf 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)
+ [Déf setAccumulableSize](#glue-etl-scala-apis-glue-datasink-class-defs-setAccumulableSize)
+ [Déf getOutputError RecordsAccumulable](#glue-etl-scala-apis-glue-datasink-class-defs-getOutputErrorRecordsAccumulable)
+ [errorsAsDynamicCadre Def](#glue-etl-scala-apis-glue-datasink-class-defs-errorsAsDynamicFrame)
+ [DataSink objet](#glue-etl-scala-apis-glue-datasink-object)
**Package : com.amazonaws.services.glue**
```
abstract class DataSink
```
L'enregistreur analogue à un encapsule un `DataSource`. `DataSink` encapsule une destination et un format dans lequel un `DynamicFrame` peut être écrit.
## Déf writeDynamicFrame
```
def writeDynamicFrame( frame : DynamicFrame,
callSite : CallSite = CallSite("Not provided", "")
) : DynamicFrame
```
## pyWriteDynamicCadre Def
```
def pyWriteDynamicFrame( frame : DynamicFrame,
site : String = "Not provided",
info : String = "" )
```
## Déf writeDataFrame
```
def writeDataFrame(frame: DataFrame,
glueContext: GlueContext,
callSite: CallSite = CallSite("Not provided", "")
): DataFrame
```
## pyWriteDataCadre Def
```
def pyWriteDataFrame(frame: DataFrame,
glueContext: GlueContext,
site: String = "Not provided",
info: String = ""
): DataFrame
```
## Déf 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
```
## Déf setAccumulableSize
```
def setAccumulableSize( size : Int ) : Unit
```
## Déf getOutputError RecordsAccumulable
```
def getOutputErrorRecordsAccumulable : Accumulable[List[OutputError], OutputError]
```
## errorsAsDynamicCadre Def
```
def errorsAsDynamicFrame : DynamicFrame
```
## DataSink objet
```
object DataSink
```
### def recordMetrics
```
def recordMetrics( frame : DynamicFrame,
ctxt : String
) : DynamicFrame
```
# AWS GlueTrait Scala DataSource
**Package : com.amazonaws.services.glue**
Interface de haut niveau pour produire un `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
}
```
# AWS GlueScala DynamicFrame APIs
**Package : com.amazonaws.services.glue**
**Contents**
+ [AWS GlueClasse Scala DynamicFrame](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)
+ [Déf 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)
+ [errorsAsDynamicCadre Def](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)
+ [Déf getNumPartitions](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-getNumPartitions)
+ [Déf getSchemaIf calculé](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-getSchemaIfComputed)
+ [Déf isSchemaComputed](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-isSchemaComputed)
+ [Déf 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)
+ [Déf 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)
+ [Définissez par simplifier DDBJson](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)
+ [Déf 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 Unnest DDBJson](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-unnestddbjson)
+ [Déf 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)
+ [Déf withTransformationContext](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-withTransformationContext)
+ [L' DynamicFrame objet](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)
+ [Déf 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)
+ [newFrameWithErreurs de définition](glue-etl-scala-apis-glue-dynamicframe-object.md#glue-etl-scala-apis-glue-dynamicframe-object-defs-newFrameWithErrors)
# AWS GlueClasse Scala DynamicFrame
**Package : 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 = {} )
```
Un `DynamicFrame` est une collection distribuée d'objets [DynamicRecord](glue-etl-scala-apis-glue-dynamicrecord-class.md) à description automatique.
Le `DynamicFrame` est conçu pour fournir un modèle de données flexible pour les opérations ETL (extraction, transformation et chargement). Il ne nécessite pas de créer un schéma et peut être utilisé pour lire et transformer les données contenant des valeurs et des types incohérents ou complexes. Un schéma peut être calculé à la demande pour les opérations qui en nécessitent un.
Les `DynamicFrame` fournissent une plage de transformations pour le nettoyage des données et ETL. Ils prennent également en charge la conversion vers et depuis DataFrames SparkSQL afin de s'intégrer au code existant et aux nombreuses opérations d'analyse qui en découlent. DataFrames
Les paramètres suivants sont partagés entre plusieurs transformations AWS Glue qui construisent les `DynamicFrame`s :
+ `transformationContext` – Identificateur pour ce `DynamicFrame`. Le `transformationContext` est utilisé en tant que clé pour l'état de marque-page de tâche conservé d'une exécution à l'autre.
+ `callSite` — fournit les informations de contexte pour le signalement d'erreurs. Ces valeurs sont automatiquement définies lors de l'appel à partir de Python.
+ `stageThreshold` — Nombre maximal d'enregistrements d'erreurs autorisés depuis le calcul du `DynamicFrame` avant de lever une exception, à l'exclusion des enregistrements présents dans le `DynamicFrame` précédent.
+ `totalThreshold` — Nombre maximal d'enregistrements d'erreur avant qu'une exception ne soit levée, y compris ceux des images précédentes.
## val errorsCount
```
val errorsCount
```
Nombre d'enregistrements d'erreur dans le `DynamicFrame`. Les erreurs des opérations précédentes sont incluses dans le nombre.
## 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` – Séquence des mappages pour construire un nouveau `DynamicFrame`.
+ `caseSensitive` — indique si les colonnes sources sont considérées comme sensibles à la casse. La définition de ce paramètre sur false peut s'avérer utile lors de l'intégration à des boutiques qui ne distinguent pas les majuscules des minuscules, comme le AWS Glue Data Catalog.
Sélectionne, projette et convertit les colonnes en fonction d'une séquence de mappages.
Chaque mappage se compose d'une colonne source et d'un type, ainsi que d'une colonne cible et d'un type. Les mappages peuvent être spécifiés sous forme de quatre tuples (`source_path`, `source_type`,` target_path`, `target_type`) ou d'un objet [MappingSpec](glue-etl-scala-apis-glue-mappingspec.md) contenant les mêmes informations.
En plus des projections simples et de la conversion, les mappages peuvent être utilisés pour imbriquer ou désimbriquer les champs en séparant les composants du chemin d'accès par « `.` » (point).
Par exemple, supposons que vous ayez une trame `DynamicFrame` avec le schéma suivant.
```
{{{
root
|-- name: string
|-- age: int
|-- address: struct
| |-- state: string
| |-- zip: int
}}}
```
Vous pouvez effectuer l'appel suivant pour désimbriquer les champs `state` et `zip`.
```
{{{
df.applyMapping(
Seq(("name", "string", "name", "string"),
("age", "int", "age", "int"),
("address.state", "string", "state", "string"),
("address.zip", "int", "zip", "int")))
}}}
```
Le schéma obtenu est le suivant.
```
{{{
root
|-- name: string
|-- age: int
|-- state: string
|-- zip: int
}}}
```
Vous pouvez également utiliser `applyMapping` pour réimbriquer les colonnes. Par exemple, ce qui suit inverse la transformation précédente et crée une structure nommée `address` dans la cible.
```
{{{
df.applyMapping(
Seq(("name", "string", "name", "string"),
("age", "int", "age", "int"),
("state", "string", "address.state", "string"),
("zip", "int", "address.zip", "int")))
}}}
```
Les noms de champ qui contiennent des caractères « `.` » (point) peuvent être placés entre guillemets (````).
**Note**
La méthode `applyMapping` ne peut pas être utilisée actuellement pour mapper les colonnes imbriquées sous des tableaux.
## Déf assertErrorThreshold
```
def assertErrorThreshold : Unit
```
Action qui oblige le calcul et vérifie que le nombre d'enregistrements d'erreur est inférieur à `stageThreshold` et `totalThreshold`. Lève une exception si l'une ou l'autre condition échoue.
## def count
```
lazy
def count
```
Retourne le nombre d'éléments dans le `DynamicFrame`.
## def dropField
```
def dropField( path : String,
transformationContext : String = "",
callSite : CallSite = CallSite("Not provided", ""),
stageThreshold : Long = 0,
totalThreshold : Long = 0
) : DynamicFrame
```
Renvoie un nouveau `DynamicFrame` avec la colonne spécifiée supprimée.
## 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
```
Renvoie un nouveau `DynamicFrame` avec les colonnes spécifiées supprimées.
Vous pouvez utiliser cette méthode pour supprimer les colonnes imbriquées, y compris celles à l'intérieur de tableaux, mais pas pour supprimer des éléments de tableau spécifiques.
## def dropNulls
```
def dropNulls( transformationContext : String = "",
callSite : CallSite = CallSite("Not provided", ""),
stageThreshold : Long = 0,
totalThreshold : Long = 0 )
```
Renvoie un nouveau `DynamicFrame` avec toutes les colonnes null supprimées.
**Note**
Seules les colonnes de type `NullType` sont supprimées. Les valeurs null des autres colonnes ne sont pas supprimées ou modifiées.
## errorsAsDynamicCadre Def
```
def errorsAsDynamicFrame
```
Renvoie un nouveau `DynamicFrame`contenant les enregistrements d'erreur de ce `DynamicFrame`.
## def filter
```
def filter( f : DynamicRecord => Boolean,
errorMsg : String = "",
transformationContext : String = "",
callSite : CallSite = CallSite("Not provided"),
stageThreshold : Long = 0,
totalThreshold : Long = 0
) : DynamicFrame
```
Crée un nouveau `DynamicFrame` contenant uniquement les enregistrements pour lesquels la fonction '`f`' renvoie la valeur `true`. La fonction de filtre '`f`' ne doit pas muter l'enregistrement d'entrée.
## def getName
```
def getName : String
```
Renvoie le nom du `DynamicFrame`.
## Déf getNumPartitions
```
def getNumPartitions
```
Retourne le nombre de partitions du `DynamicFrame`.
## Déf getSchemaIf calculé
```
def getSchemaIfComputed : Option[Schema]
```
Renvoie le schéma s'il a déjà été calculé. N'analyse pas les données si le schéma n'a pas déjà été calculé.
## Déf isSchemaComputed
```
def isSchemaComputed : Boolean
```
Renvoie la valeur `true` si le schéma a été calculé pour ce `DynamicFrame`, ou `false` dans le cas contraire. Si la méthode renvoie la valeur false, l'appel de la méthode `schema` nécessite un autre passage sur les enregistrements du `DynamicFrame`.
## Déf 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` — Colonnes de ce `DynamicFrame` à utiliser pour la jointure.
+ `keys2` — colonnes de `frame2` à utiliser pour la jointure. Doit être de la même longueur que `keys1`.
+ `frame2` — Autre `DynamicFrame` à joindre.
Renvoie le résultat de l'exécution d'une équijointure avec `frame2` à l'aide des clés spécifiées.
## def map
```
def map( f : DynamicRecord => DynamicRecord,
errorMsg : String = "",
transformationContext : String = "",
callSite : CallSite = CallSite("Not provided", ""),
stageThreshold : Long = 0,
totalThreshold : Long = 0
) : DynamicFrame
```
Renvoie un nouveau `DynamicFrame` construit en appliquant la fonction spécifiée '`f`' à chaque enregistrement du `DynamicFrame`.
Comme cette méthode copie chaque enregistrement avant d'appliquer la fonction spécifiée, elle est sécurisée pour muter les enregistrements. Si la fonction de mappage lève une exception sur un enregistrement donné, celui-ci est marqué comme erreur, et le suivi de la pile est enregistré en tant que colonne dans l'enregistrement d'erreur.
## Déf 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` — trame `DynamicFrame` intermédiaire à fusionner.
+ `primaryKeys` — liste des champs de clé primaire permettant de faire correspondre les enregistrements des trames `DynamicFrame` source et intermédiaire.
+ `transformationContext` — chaîne unique utilisée pour récupérer les métadonnées relatives à la transformation en cours (facultatif).
+ `options` — chaîne de paires nom-valeur JSON qui fournissent des informations supplémentaires pour cette transformation.
+ `callSite` — permet de fournir des informations contextuelles pour le signalement d'erreurs.
+ `stageThreshold` – Une `Long`. Nombre d'erreurs identifiées dans la transformation donnée et à corriger lors du traitement.
+ `totalThreshold` – Une `Long`. Nombre total d'erreurs identifiées dans la transformation donnée et qui doivent être corrigées lors du traitement.
Fusionne cette trame `DynamicFrame` avec une trame `DynamicFrame` intermédiaire basée sur les clés primaires spécifiées pour identifier les enregistrements. Les registres en double (registres avec les mêmes clés primaires) ne sont pas dédupliqués. Si aucun enregistrement ne correspond dans la trame intermédiaire, tous les enregistrements (y compris les doublons) sont conservés dans la source. Si la trame intermédiaire contient des enregistrements correspondants, les enregistrements de la trame intermédiaire remplacent ceux de la source dans AWS Glue.
La trame `DynamicFrame` renvoyée contient l'enregistrement A dans les cas suivants :
1. Si `A` se trouve à la fois dans la trame source et la trame intermédiaire, c'est la valeur `A` de la trame intermédiaire qui est renvoyée.
1. Si `A` se trouve dans la table source et si `A.primaryKeys` ne se trouve pas dans la trame `stagingDynamicFrame` (en d'autres termes, `A` n'est pas mis à jour dans la table intermédiaire).
La trame source et la trame intermédiaire n'ont pas besoin d'avoir le même schéma.
**Example**
```
val mergedFrame: DynamicFrame = srcFrame.mergeDynamicFrames(stageFrame, Seq("id1", "id2"))
```
## def printSchema
```
def printSchema : Unit
```
Imprime le schéma du `DynamicFrame` sur `stdout` dans un format compréhensible par les utilisateurs.
## def recomputeSchema
```
def recomputeSchema : Schema
```
Force le recalcul d'un schéma. Ceci nécessite une analyse des données, mais peut « resserrer » le schéma si certains champs du schéma actuel ne sont pas présents dans les données.
Renvoie le schéma recalculé.
## 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` — nom à utiliser pour le `DynamicFrame` de base dans la sortie. Les trames `DynamicFrame` qui sont créés par les tableaux pivotants commencent avec ce préfixe.
+ `stagingPath` — chemin Amazon Simple Storage Service (Amazon S3) pour écrire des données intermédiaires.
+ `options` — crée les relations entre les options et la configuration. Non utilisé actuellement.
Aplanit toutes les structures imbriquées et pivote les tableaux en tables distinctes.
Vous pouvez utiliser cette opération pour préparer les données profondément imbriquées en vue de leur ingestion dans une base de données relationnelle. Les structs imbriquées sont mises à plat de la même manière que la transformation [unnest](#glue-etl-scala-apis-glue-dynamicframe-class-defs-unnest). De plus, les tableaux sont pivotés en tables distinctes et chaque élément du tableau devient une ligne. Par exemple, supposons que vous ayez une trame `DynamicFrame` avec les données suivantes.
```
{"name": "Nancy", "age": 47, "friends": ["Fred", "Lakshmi"]}
{"name": "Stephanie", "age": 28, "friends": ["Yao", "Phil", "Alvin"]}
{"name": "Nathan", "age": 54, "friends": ["Nicolai", "Karen"]}
```
Exécutez le code suivant.
```
{{{
df.relationalize("people", "s3:/my_bucket/my_path", JsonOptions.empty)
}}}
```
Il génère deux tables. La première table est nommée « people » et contient les éléments suivants.
```
{{{
{"name": "Nancy", "age": 47, "friends": 1}
{"name": "Stephanie", "age": 28, "friends": 2}
{"name": "Nathan", "age": 54, "friends": 3)
}}}
```
Ici, le tableau « friends » a été remplacé par une clé de jointure générée automatiquement. Une table séparée nommée `people.friends` est créée avec le contenu suivant.
```
{{{
{"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"}
}}}
```
Dans ce tableau, « `id` » est une clé de jointure qui identifie de quel enregistrement provenait l'élément de tableau, « `index` » fait référence à la position dans le tableau d'origine et « `val` » est l'entrée réelle du tableau.
La méthode `relationalize` renvoie la séquence de `DynamicFrame` créée en appliquant ce processus de façon récursive à tous les tableaux.
**Note**
La bibliothèque AWS Glue génère automatiquement les clés de jointure des nouvelles tables. Pour vous assurer que les clés de jointure sont uniques au travers des exécutions de tâche, vous devez activer les marque-pages de tâche.
## def renameField
```
def renameField( oldName : String,
newName : String,
transformationContext : String = "",
callSite : CallSite = CallSite("Not provided", ""),
stageThreshold : Long = 0,
totalThreshold : Long = 0
) : DynamicFrame
```
+ `oldName` — Nom d'origine de la colonne.
+ `newName` — Nouveau nom de la colonne.
Renvoie un nouveau `DynamicFrame` contenant le champ spécifié renommé.
Cette méthode peut être utilisée pour renommer les champs imbriqués. Par exemple, le code suivant remplace le nom `state` par `state_code` dans la structure de l'adresse.
```
{{{
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
```
Renvoie un nouveau `DynamicFrame` avec les partitions `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` — Action à appliquer aux colonnes `ChoiceType` non listées dans la séquence des spécifications.
+ `database` — base de données Data Catalog à utiliser avec l'action `match_catalog`.
+ `tableName` — table Data Catalog à utiliser avec l'action `match_catalog`.
Renvoie un nouveau `DynamicFrame` en remplaçant un ou plusieurs `ChoiceType` avec un type plus spécifique.
Il existe deux façons d'utiliser `resolveChoice`. La première consiste à spécifier une séquence de colonnes spécifiques et la façon de les résoudre. Celles-ci sont spécifiés en tant que tuples composés de paires (colonne, action).
Les actions possibles sont les suivantes :
+ `cast:type` — Tente de convertir toutes les valeurs dans le type spécifié.
+ `make_cols` – Convertit chaque type distinct en une colonne portant le nom `columnName_type`.
+ `make_struct` — Convertit une colonne en une structure avec des clés pour chaque type distinct.
+ `project:type` — Retient uniquement les valeurs du type spécifié.
L'autre mode pour `resolveChoice` consiste à spécifier une seule résolution pour tous les `ChoiceType`s. Vous pouvez utiliser cela lorsque la liste complète des `ChoiceType`s est inconnue avant l'exécution. En plus des actions répertoriées précédemment, ce mode prend également en charge l'action suivante :
+ `match_catalog``ChoiceType` — Tente de convertir chaque dans le type correspondant de la table de catalogue spécifiée.
**Exemples :**
Résolvez la colonne `user.id` en la convertissant en int et faites que le champ `address` conserve uniquement les structs.
```
{{{
df.resolveChoice(specs = Seq(("user.id", "cast:int"), ("address", "project:struct")))
}}}
```
Résolvez tous les objets `ChoiceType` en convertissant chaque choix en colonne séparée.
```
{{{
df.resolveChoice(choiceOption = Some(ChoiceOption("make_cols")))
}}}
```
Résolvez tous les objets `ChoiceType` en les convertissant dans les types de la table de catalogue spécifiée.
```
{{{
df.resolveChoice(choiceOption = Some(ChoiceOption("match_catalog")),
database = Some("my_database"),
tableName = Some("my_table"))
}}}
```
## def schema
```
def schema : Schema
```
Renvoie le schéma du `DynamicFrame`.
Le schéma renvoyé est assuré de contenir chaque champ présent dans un enregistrement de ce `DynamicFrame`. Mais dans un petit nombre de cas, il peut aussi contenir des champs supplémentaires. La méthode [unnest](#glue-etl-scala-apis-glue-dynamicframe-class-defs-unnest) peut être utilisée pour « resserrer » le schéma basé sur les enregistrements du `DynamicFrame`.
## def selectField
```
def selectField( fieldName : String,
transformationContext : String = "",
callSite : CallSite = CallSite("Not provided", ""),
stageThreshold : Long = 0,
totalThreshold : Long = 0
) : DynamicFrame
```
Renvoie un champ unique comme `DynamicFrame`.
## def selectFields
```
def selectFields( paths : Seq[String],
transformationContext : String = "",
callSite : CallSite = CallSite("Not provided", ""),
stageThreshold : Long = 0,
totalThreshold : Long = 0
) : DynamicFrame
```
+ `paths` — Séquence de noms de colonnes à sélectionner.
Renvoie un nouveau `DynamicFrame` contenant les colonnes spécifiées.
**Note**
La méthode `selectFields` peut uniquement être utilisée pour sélectionner les colonnes de niveau supérieur. La méthode [applyMapping](#glue-etl-scala-apis-glue-dynamicframe-class-defs-applyMapping) peut être utilisée pour sélectionner les colonnes imbriquées.
## def show
```
def show( numRows : Int = 20 ) : Unit
```
+ `numRows` — Nombre de lignes à imprimer.
Imprime les lignes du `DynamicFrame` au format JSON.
## Définissez par simplifier DDBJson
Les exportations DynamoDB avec le connecteur d’exportation AWS Glue DynamoDB donnent lieu à des fichiers JSON de structures imbriquées spécifiques. Pour en savoir plus, consultez [Data objects](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/S3DataExport.Output.html). `simplifyDDBJson` Simplifie les colonnes imbriquées dans ce type de données et renvoie une nouvelle colonne simplifiée DynamicFrame. DynamicFrame S’il existe plusieurs types ou un type Carte contenu dans un type Liste, les éléments de la liste ne seront pas simplifiés. Cette méthode prend uniquement en charge les données au format JSON d’exportation DynamoDB. Envisagez `unnest` pour effectuer des modifications similaires sur d’autres types de données.
```
def simplifyDDBJson() : DynamicFrame
```
Cette méthode n’utilise aucun paramètre.
**Exemple d'entrée**
Tenez compte du schéma suivant généré par une exportation 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
```
**Exemple de code**
```
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()
}
}
```
### Exemple de sortie
La transformation `simplifyDDBJson` simplifie cette exportation ainsi :
```
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
```
Transmettez la transformation qui renvoie les mêmes enregistrements, mais écrit un sous-ensemble d'enregistrements en tant qu'effet secondaire.
+ `path` — chemin d'accès dans Amazon S3 dans lequel écrire la sortie, sous la forme `s3://bucket//path`.
+ `options` — Carte `JsonOptions` facultative décrivant le comportement d'échantillonnage.
Renvoie un `DynamicFrame` contenant les mêmes enregistrements que celui-ci.
Par défaut, écrit 100 enregistrements arbitraires à l'emplacement spécifié par `path`. Ce comportement peut être personnalisé à l'aide de la carte `options`. Les clés valides incluent les suivantes :
+ `topk` — spécifie le nombre total d'enregistrements écrits. La valeur par défaut est 100.
+ `prob` — indique la probabilité (sous forme de décimale) qu'un enregistrement individuel soit inclus. La valeur par défaut est 1.
Par exemple, l'appel suivant échantillonne l'ensemble de données en sélectionnant chaque enregistrement avec une probabilité de 20 % et en s'arrêtant après l'écriture de 200 enregistrements.
```
{{{
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` — Chemins à inclure dans le premier `DynamicFrame`.
Renvoie une séquence de deux `DynamicFrame`s. Le premier `DynamicFrame`contient les chemins d'accès spécifiés et le deuxième contient toutes les autres colonnes.
**Exemple**
Cet exemple prend une `persons` table DynamicFrame créée à partir de la `legislators` base de données du AWS Glue Data Catalog et la DynamicFrame divise en deux, les champs spécifiés étant placés dans le premier DynamicFrame et les champs restants dans un second DynamicFrame. L'exemple choisit ensuite le premier DynamicFrame parmi le résultat.
```
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]
```
Fractionne les lignes en fonction des prédicats qui comparent les colonnes aux constantes.
+ `paths` — Colonnes à utiliser pour la comparaison.
+ `values` — Valeurs constantes à utiliser pour la comparaison.
+ `operators` — Opérateurs à utiliser pour la comparaison.
Renvoie une séquence de deux `DynamicFrame`s. Le premier contient les lignes pour lesquelles le prédicat a la valeur true et le deuxième contient celles pour lesquelles la valeur est false.
Les prédicats sont spécifiés en utilisant trois séquences : « `paths` » contient les noms de colonne (possiblement imbriqués), « `values` » contient les valeurs constantes de comparaison et « `operators` » contient les opérateurs à utiliser pour la comparaison. Les trois séquences doivent être de la même longueur : le `n`ème opérateur est utilisé pour comparer la `n`ème colonne à la `n`ème valeur.
Chaque opérateur doit être « `!=` », « `=` », « `<=` », « `<` », « `>=` » ou « `>` ».
Par exemple, l'appel suivant scinde une trame `DynamicFrame` afin que la première trame de sortie contienne les enregistrements des personnes de plus de 65 ans des États-Unis et que la deuxième contienne tous les autres enregistrements.
```
{{{
df.splitRows(Seq("age", "address.country"), Seq(65, "USA"), Seq(">=", "="))
}}}
```
## Déf stageErrorsCount
```
def stageErrorsCount
```
Renvoie le nombre d'enregistrements d'erreur créés pendant le calcul du `DynamicFrame`. Cela exclut les erreurs des opérations précédentes qui ont été transmises au `DynamicFrame` comme entrée.
## def toDF
```
def toDF( specs : Seq[ResolveSpec] = Seq.empty[ResolveSpec] ) : DataFrame
```
Convertit le `DynamicFrame` en un `DataFrame` Apache Spark SQL avec le même schéma et les mêmes enregistrements.
**Note**
Étant donné que les `DataFrame`s ne prennent pas en charge les `ChoiceType`s, cette méthode convertit automatiquement les colonnes `ChoiceType` en `StructType`s. Pour plus d'informations et pour connaître les options de résolution des choix, consultez [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` — colonne à analyser. Doit être de type string (chaîne) ou binary (binaire).
+ `format` — Le format à utiliser pour l'analyse.
+ `optionString` — Options à transmettre au format, telles que le séparateur CSV.
Analyse une chaîne ou une colonne binaire intégrée selon le format spécifié. Les colonnes analysées sont imbriquées sous une structure avec le nom de colonne d'origine.
Par exemple, supposons que vous ayez un fichier CSV avec une colonne JSON imbriquée.
```
name, age, address
Sally, 36, {"state": "NE", "city": "Omaha"}
...
```
Après une analyse initiale, vous obtenez une trame `DynamicFrame` avec le schéma suivant.
```
{{{
root
|-- name: string
|-- age: int
|-- address: string
}}}
```
Vous pouvez appeler `unbox` au niveau de la colonne « address » pour analyser les composants spécifiques.
```
{{{
df.unbox("address", "json")
}}}
```
Vous obtenez ainsi une trame `DynamicFrame` avec le schéma suivant.
```
{{{
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
```
Renvoie un nouveau `DynamicFrame` avec tous les structures imbriquées mises à plat. Les noms sont construits à l'aide du caractère « `.` » (point).
Par exemple, supposons que vous ayez une trame `DynamicFrame` avec le schéma suivant.
```
{{{
root
|-- name: string
|-- age: int
|-- address: struct
| |-- state: string
| |-- city: string
}}}
```
L'appel suivant désimbrique la struct « address ».
```
{{{
df.unnest()
}}}
```
Le schéma obtenu est le suivant.
```
{{{
root
|-- name: string
|-- age: int
|-- address.state: string
|-- address.city: string
}}}
```
Cette méthode désimbrique également les structs imbriquées à l'intérieur des tableaux. Mais pour des raisons historiques, le nom de ces champs est précédé par le nom du tableau englobant et par « `.val` ».
## Def Unnest DDBJson
```
unnestDDBJson(transformationContext : String = "",
callSite : CallSite = CallSite("Not Provided"),
stageThreshold : Long = 0,
totalThreshold : Long = 0): DynamicFrame
```
Supprime l'imbrication des colonnes imbriquées dans un `DynamicFrame` qui se trouvent spécifiquement dans la structure JSON DynamoDB, et renvoie une nouvelle version non imbriquée `DynamicFrame`. Les colonnes d'un tableau de types de structure ne seront pas non-imbriquées. Notez qu'il s'agit d'un type spécifique de transformation non imbriquée qui se comporte différemment de la transformation `unnest` normale et nécessite que les données soient déjà dans la structure JSON DynamoDB. Pour plus d'informations, consultez [JSON DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DataExport.Output.html#DataExport.Output.Data).
Par exemple, le schéma d'une lecture d'exportation avec la structure JSON DynamoDB pourrait ressembler à ce qui suit :
```
root
|-- Item: struct
| |-- ColA: struct
| | |-- S: string
| |-- ColB: struct
| | |-- S: string
| |-- ColC: struct
| | |-- N: string
| |-- ColD: struct
| | |-- L: array
| | | |-- element: null
```
La transformation `unnestDDBJson()` convertirait ceci en :
```
root
|-- ColA: string
|-- ColB: string
|-- ColC: string
|-- ColD: array
| |-- element: null
```
L'exemple de code suivant montre comment utiliser le connecteur d'exportation AWS Glue DynamoDB, appeler un DynamoDB JSON unnest et imprimer le nombre de partitions :
```
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()
}
}
```
## Déf withFrameSchema
```
def withFrameSchema( getSchema : () => Schema ) : DynamicFrame
```
+ `getSchema` — fonction qui renvoie le schéma à utiliser. Spécifiée en tant que fonction de paramètre zéro pour reporter un calcul potentiellement onéreux.
Définit le schéma du `DynamicFrame` sur la valeur spécifiée. La fonction est principalement utilisée en interne pour éviter un recalcul du schéma coûteux. Le schéma transmis doit contenir toutes les colonnes présentes dans les données.
## def withName
```
def withName( name : String ) : DynamicFrame
```
+ `name` — Nouveau nom à utiliser.
Renvoie une copie du `DynamicFrame` avec un nouveau nom.
## Déf withTransformationContext
```
def withTransformationContext( ctx : String ) : DynamicFrame
```
Renvoie une copie du `DynamicFrame` avec le contexte de transformation spécifié.
# L' DynamicFrame objet
**Package : com.amazonaws.services.glue**
```
object DynamicFrame
```
## def apply
```
def apply( df : DataFrame,
glueContext : GlueContext
) : DynamicFrame
```
## Déf 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)
```
## newFrameWithErreurs de définition
```
def newFrameWithErrors( prevFrame : DynamicFrame,
rdd : RDD[DynamicRecord],
name : String = "",
transformationContext : String = "",
callSite : CallSite,
stageThreshold : Long,
totalThreshold : Long
) : DynamicFrame
```
# AWS GlueClasse Scala DynamicRecord
**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)
+ [Déf 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)
+ [DynamicRecord objet](#glue-etl-scala-apis-glue-dynamicrecord-object)
+ [RecordTraverser trait](#glue-etl-scala-apis-glue-recordtraverser-trait)
**Package : com.amazonaws.services.glue**
```
class DynamicRecord extends Serializable with Writable with Cloneable
```
Un `DynamicRecord` est une structure de données à description automatique qui représente une ligne de données de l'ensemble de données en cours de traitement. Elle est auto-descriptive en ce sens que vous pouvez obtenir le schéma de la ligne représentée par le `DynamicRecord` en inspectant l'enregistrement lui-même. Un `DynamicRecord` est similaire à un `Row` dans Apache Spark.
## def addField
```
def addField( path : String,
dynamicNode : DynamicNode
) : Unit
```
Ajoute un [DynamicNode](glue-etl-scala-apis-glue-types-dynamicnode.md) au chemin d'accès spécifié.
+ `path` — Chemin d'accès du champ à ajouter.
+ `dynamicNode` — [DynamicNode](glue-etl-scala-apis-glue-types-dynamicnode.md) à ajouter au chemin d'accès spécifié.
## def dropField
```
def dropField(path: String, underRename: Boolean = false): Option[DynamicNode]
```
Supprime un [DynamicNode](glue-etl-scala-apis-glue-types-dynamicnode.md) du chemin spécifié et renvoie le nœud supprimé s'il n'y a pas un tableau dans le chemin d'accès spécifié.
+ `path` — Chemin d'accès du champ à supprimer.
+ `underRename``dropField` : valeur True si est appelé dans le cadre d'une transformation en nouveau nom ou false dans le cas contraire (false par défaut).
Retourne un `scala.Option Option` ([DynamicNode](glue-etl-scala-apis-glue-types-dynamicnode.md)).
## def setError
```
def setError( error : Error )
```
Définit cet enregistrement en tant qu'enregistrement d'erreur, comme spécifié par le paramètre `error`.
Retourne un `DynamicRecord`.
## def isError
```
def isError
```
Vérifie si cet enregistrement est un enregistrement d'erreur.
## def getError
```
def getError
```
Obtient `Error` si l'enregistrement est un enregistrement d'erreur. Renvoie `scala.Some Some` (Erreur) si cet enregistrement est un enregistrement d'erreur ou `scala.None` dans le cas contraire.
## def clearError
```
def clearError
```
Définissez `Error` sur `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
```
Clone cet enregistrement en un nouveau `DynamicRecord` et le renvoie.
## def schema
```
def schema
```
Obtient `Schema` en inspectant l'enregistrement.
## def getRoot
```
def getRoot : ObjectNode
```
Obtient le `ObjectNode` racine pour l'enregistrement.
## def toJson
```
def toJson : String
```
Obtient la chaîne JSON pour l'enregistrement.
## Déf getFieldNode
```
def getFieldNode( path : String ) : Option[DynamicNode]
```
Obtient la valeur du champ au `path` spécifié comme option de `DynamicNode`.
Renvoie `scala.Some Some` ([DynamicNode](glue-etl-scala-apis-glue-types-dynamicnode.md)) si le champ existe, ou dans le cas contraire `scala.None.None`.
## def getField
```
def getField( path : String ) : Option[Any]
```
Obtient la valeur du champ au `path` spécifié comme option de `DynamicNode`.
Retourne `scala.Some Some` (valeur).
## def hashCode
```
override def hashCode : Int
```
## def equals
```
override def equals( other : Any )
```
## DynamicRecord objet
```
object DynamicRecord
```
### Def apply
```
def apply( row : Row,
schema : SparkStructType )
```
Appliquez la méthode pour convertir un objet `Row` Apache Spark SQL en un [DynamicRecord](#glue-etl-scala-apis-glue-dynamicrecord-class).
+ `row` – Spark SQL `Row`.
+ `schema` — `Schema` de cette ligne.
Retourne un `DynamicRecord`.
## RecordTraverser trait
```
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 GlueScala GlueContext APIs
**Package : com.amazonaws.services.glue**
```
class GlueContext extends SQLContext(sc) (
@transient val sc : SparkContext,
val defaultSourcePartitioner : PartitioningStrategy )
```
`GlueContext` Est le point d'entrée pour lire et écrire un [DynamicFrame](glue-etl-scala-apis-glue-dynamicframe.md) depuis et vers Amazon Simple Storage Service (Amazon S3), le catalogue de données AWS Glue, JDBC, etc. Cette classe fournit des fonctions d'utilitaire pour créer des objets [DataSource trait](glue-etl-scala-apis-glue-datasource-trait.md) et [DataSink](glue-etl-scala-apis-glue-datasink-class.md) qui peuvent ensuite être utilisés pour lire et écrire les `DynamicFrame`.
Vous pouvez également utiliser `GlueContext` pour définir un nombre cible de partitions (par défaut 20) dans le `DynamicFrame` si le nombre de partitions créées à partir de la source est inférieure à un seuil minimal pour les partitions (par défaut 10).
## addIngestionTimeColonnes def
```
def addIngestionTimeColumns(
df : DataFrame,
timeGranularity : String = "") : dataFrame
```
Ajoute des colonnes de temps d’ingestion, telles que `ingest_year`, `ingest_month`, `ingest_day`, `ingest_hour`, `ingest_minute` à l’entrée `DataFrame`. Cette fonction est automatiquement générée dans le script généré par AWS Glue lorsque vous spécifiez une table Data Catalog avec Amazon S3 comme cible. Cette fonction met automatiquement à jour la partition avec les colonnes de temps d’ingestion sur la table de sortie. Cela permet aux données de sortie d’être automatiquement partitionnées à l’heure d’ingestion sans nécessiter de colonnes d’heure d’ingestion explicites dans les données d’entrée.
+ `dataFrame` – `dataFrame` auquel ajouter les colonnes de temps d’ingestion.
+ `timeGranularity` — granularité des colonnes de temps. Les valeurs valides sont « `day` », « `hour` » et « `minute` ». Par exemple, si « `hour` » est transmis à la fonction, les colonnes de temps « `ingest_year` », « `ingest_month` », « `ingest_day` » et « `ingest_hour` » seront ajoutées à l’original « `dataFrame` ».
Renvoie le bloc de données après l’ajout des colonnes de granularité temporelle.
Exemple :
```
glueContext.addIngestionTimeColumns(dataFrame, "hour")
```
## def createDataFrame FromOptions
```
def createDataFrameFromOptions( connectionType : String,
connectionOptions : JsonOptions,
transformationContext : String = "",
format : String = null,
formatOptions : JsonOptions = JsonOptions.empty
) : DataSource
```
Renvoie un `DataFrame` créé avec la connexion et le format spécifiés. Utilisez cette fonction uniquement avec les sources AWS de streaming Glue.
+ `connectionType` : type de connexion en streaming. Les valeurs valides sont `kinesis` et `kafka`.
+ `connectionOptions` : options de connexion, qui sont différentes pour Kinesis et Kafka. Vous trouverez la liste de toutes les options de connexion pour chaque source de données de streaming sur la page [Types et options de connexion pour ETL dans AWS Glue pour Spark](aws-glue-programming-etl-connect.md). Notez les différences suivantes dans les options de connexion en streaming :
+ Les sources de streaming Kinesis nécessitent `streamARN`, `startingPosition`, `inferSchema` et `classification`.
+ Les sources de streaming Kafka nécessitent `connectionName`, `topicName`, `startingOffsets`, `inferSchema` et `classification`.
+ `transformationContext` : contexte de transformation à utiliser (facultatif).
+ `format` : spécification de format (facultatif). Utilisée pour une connexion Amazon S3 ou AWS Glue prenant en charge plusieurs formats. Pour plus d'informations sur les formats pris en charge, veuillez consulter [Options de format pour les entrées et sorties dans AWS Glue pour Spark](aws-glue-programming-etl-format.md).
+ `formatOptions` : options de format pour le format spécifié. Pour de plus amples informations sur les options de formats pris en charge, veuillez consulter [Options de format de données](aws-glue-programming-etl-format.md).
Exemple pour la source de streaming Amazon Kinesis :
```
val data_frame_datasource0 =
glueContext.createDataFrameFromOptions(transformationContext = "datasource0", connectionType = "kinesis",
connectionOptions = JsonOptions("""{"streamName": "example_stream", "startingPosition": "TRIM_HORIZON", "inferSchema": "true", "classification": "json"}}"""))
```
Exemple pour la source de streaming 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)`**
S’applique à `batch_function` transmis à chaque micro-lot lu à partir de la source de streaming.
+ `frame`— Le DataFrame contenant le microlot actuel.
+ `batch_function` — fonction qui sera appliquée à chaque micro-lot.
+ `options` — collection de paires clé-valeur qui contient des informations sur le traitement de micro-lots. Les options suivantes sont requises :
+ `windowSize` — durée de traitement de chaque lot.
+ `checkpointLocation` — emplacement dans lequel les points de contrôle sont stockés pour la tâche ETL en streaming.
+ `batchMaxRetries` – nombre maximum de nouvelles tentatives pour ce lot en cas d’échec. La valeur par défaut est 3. Cette option n’est configurable que pour Glue version 2.0 et ultérieure.
**Exemple :**
```
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
```
Crée un [DataSink](glue-etl-scala-apis-glue-datasink-class.md) qui écrit dans un emplacement spécifié dans une table définie dans Data Catalog.
+ `database` – Nom de base de données dans le catalogue de données.
+ `tableName` – Nom de la table dans le catalogue de données.
+ `redshiftTmpDir` – Répertoire intermédiaire temporaire à utiliser avec certains récepteurs de données. Valeur définie sur vide par défaut.
+ `transformationContext` – Contexte de transformation associé au récepteur à utiliser par les signets de la tâche. Valeur définie sur vide par défaut.
+ `additionalOptions` — Options supplémentaires fournies à AWS Glue.
+ `catalogId` — ID du catalogue (ID du compte) Data Catalog auquel vous accédez. Lorsque la valeur est null, l'ID de compte par défaut de l'appelant est utilisé.
Renvoie le `DataSink`.
## def getCatalogSource
```
def getCatalogSource( database : String,
tableName : String,
redshiftTmpDir : String = "",
transformationContext : String = ""
pushDownPredicate : String = " "
additionalOptions: JsonOptions = JsonOptions.empty,
catalogId: String = null
) : DataSource
```
Crée un [DataSource trait](glue-etl-scala-apis-glue-datasource-trait.md) qui lit les données à partir d'une définition de table dans Data Catalog.
+ `database` — nom de la base de données dans Data Catalog.
+ `tableName` – Nom de la table dans le catalogue de données.
+ `redshiftTmpDir` – Répertoire intermédiaire temporaire à utiliser avec certains récepteurs de données. Valeur définie sur vide par défaut.
+ `transformationContext` – Contexte de transformation associé au récepteur à utiliser par les signets de la tâche. Valeur définie sur vide par défaut.
+ `pushDownPredicate` – Filtre les partitions sans avoir à répertorier ni lire tous les fichiers de votre jeu de données. Pour plus d'informations, consultez [Préfiltrage à l'aide des prédicats pushdown](aws-glue-programming-etl-partitions.md#aws-glue-programming-etl-partitions-pushdowns).
+ `additionalOptions` — Ensemble de paires nom-valeur facultatives. Les options possibles comprennent celles répertoriées dans [Types et options de connexion pour ETL dans AWS Glue pour Spark](aws-glue-programming-etl-connect.md), sauf pour `endpointUrl`, `streamName`, `bootstrap.servers`, `security.protocol`, `topicName`, `classification` et `delimiter`. Est une autre option prise en charge `catalogPartitionPredicate`:
`catalogPartitionPredicate` – Vous pouvez passer une expression de catalogue à filtrer en fonction des colonnes d'index. Cela envoie le filtrage du côté serveur. Pour en savoir plus, consultez [AWS Glue Indexes de partition](https://docs.aws.amazon.com/glue/latest/dg/partition-indexes.html). Notez que `push_down_predicate` et `catalogPartitionPredicate` utilisent des syntaxes différentes. Le premier utilise la syntaxe standard SQL Spark et le dernier utilise l'analyseur JSQL.
+ `catalogId` — ID du catalogue (ID du compte) Data Catalog auquel vous accédez. Lorsque la valeur est null, l'ID de compte par défaut de l'appelant est utilisé.
Renvoie le `DataSource`.
**Exemple pour la source de streaming**
```
val data_frame_datasource0 = glueContext.getCatalogSource(
database = "tempdb",
tableName = "test-stream-input",
redshiftTmpDir = "",
transformationContext = "datasource0",
additionalOptions = JsonOptions("""{
"startingPosition": "TRIM_HORIZON", "inferSchema": "false"}""")
).getDataFrame()
```
## def get JDBCSink
```
def getJDBCSink( catalogConnection : String,
options : JsonOptions,
redshiftTmpDir : String = "",
transformationContext : String = "",
catalogId: String = null
) : DataSink
```
Crée un [DataSink](glue-etl-scala-apis-glue-datasink-class.md) qui écrit dans une base de données JDBC spécifiée d'un objet `Connection` dans Data Catalog. L'objet `Connection` comporte des informations de connexion pour se connecter à un récepteur JDBC incluant l'URL, le nom d'utilisateur, le mot de passe, le VPC, le sous-réseau et les groupes de sécurité.
+ `catalogConnection` – Nom de la connexion dans le catalogue de données qui contient l'URL JDBC sur laquelle écrire.
+ `options` – Chaîne de paires nom-valeur JSON qui fournissent des informations supplémentaires nécessaires pour écrire dans un magasin de données JDBC. Cela inclut notamment les éléments suivants :
+ *dbtable* (obligatoire) — Nom de la table JDBC. Pour les magasins de données JDBC qui prennent en charge les schémas dans une base de données, spécifiez `schema.table-name`. Si aucun schéma n'est fourni, c'est le schéma « public » par défaut qui est utilisé. L'exemple suivant illustre un paramètre d'options qui pointe sur un schéma nommé `test` et une table nommée `test_table` dans la base de données `test_db`.
```
options = JsonOptions("""{"dbtable": "test.test_table", "database": "test_db"}""")
```
+ *database* (obligatoire) — Nom de la base de données JDBC.
+ Toutes les options supplémentaires transmises directement à l'enregistreur JDBC SparkSQL. Pour plus d'informations, consultez [Redshift data source for Spark](https://github.com/databricks/spark-redshift).
+ `redshiftTmpDir` — répertoire intermédiaire temporaire à utiliser avec certains récepteurs de données. Valeur définie sur vide par défaut.
+ `transformationContext` – Contexte de transformation associé au récepteur à utiliser par les signets de la tâche. Valeur définie sur vide par défaut.
+ `catalogId` — ID du catalogue (ID du compte) Data Catalog auquel vous accédez. Lorsque la valeur est null, l'ID de compte par défaut de l'appelant est utilisé.
Exemple de code :
```
getJDBCSink(catalogConnection = "my-connection-name", options = JsonOptions("""{"dbtable": "my-jdbc-table", "database": "my-jdbc-db"}"""), redshiftTmpDir = "", transformationContext = "datasink4")
```
Renvoie le `DataSink`.
## def getSink
```
def getSink( connectionType : String,
connectionOptions : JsonOptions,
transformationContext : String = ""
) : DataSink
```
Crée un [DataSink](glue-etl-scala-apis-glue-datasink-class.md) fichier qui écrit des données vers une destination telle qu'Amazon Simple Storage Service (Amazon S3), JDBC ou le AWS Glue Data Catalog, ou un flux de données Apache Kafka ou Amazon Kinesis.
+ `connectionType` — Type de connexion. Consultez [Types et options de connexion pour ETL dans AWS Glue pour Spark](aws-glue-programming-etl-connect.md).
+ `connectionOptions` — Chaîne JSON de paires nom-valeur JSON qui fournissent des informations supplémentaires pour établir la connexion avec le récepteur de données. Consultez [Types et options de connexion pour ETL dans AWS Glue pour Spark](aws-glue-programming-etl-connect.md).
+ `transformationContext` – Contexte de transformation associé au récepteur à utiliser par les signets de la tâche. Valeur définie sur vide par défaut.
Renvoie le `DataSink`.
## getSinkWithFormat def
```
def getSinkWithFormat( connectionType : String,
options : JsonOptions,
transformationContext : String = "",
format : String = null,
formatOptions : JsonOptions = JsonOptions.empty
) : DataSink
```
Crée un [DataSink](glue-etl-scala-apis-glue-datasink-class.md) qui écrit des données dans une destination comme Amazon S3, JDBC ou le catalogue de données, ou un flux de données Apache Kafka ou Amazon Kinesis. Définit également le format des données à écrire dans la destination.
+ `connectionType` — Type de connexion. Consultez [Types et options de connexion pour ETL dans AWS Glue pour Spark](aws-glue-programming-etl-connect.md).
+ `options` — Chaîne JSON de paires nom-valeur JSON qui fournissent des informations supplémentaires pour établir une connexion avec le récepteur de données. Consultez [Types et options de connexion pour ETL dans AWS Glue pour Spark](aws-glue-programming-etl-connect.md).
+ `transformationContext` – Contexte de transformation associé au récepteur à utiliser par les signets de la tâche. Valeur définie sur vide par défaut.
+ `format` — Format des données à écrire dans la destination.
+ `formatOptions` – Chaîne JSON de paires nom-valeur qui fournissent des options supplémentaires pour le formatage des données à la destination. Consultez [Options de format de données](aws-glue-programming-etl-format.md).
Renvoie le `DataSink`.
## def getSource
```
def getSource( connectionType : String,
connectionOptions : JsonOptions,
transformationContext : String = ""
pushDownPredicate
) : DataSource
```
Crée un [DataSource trait](glue-etl-scala-apis-glue-datasource-trait.md) fichier qui lit les données d'une source telle qu'Amazon S3, JDBC ou le AWS Glue Data Catalog. Prend également en charge les sources de données de streaming Kafka et Kinesis.
+ `connectionType` – Type de données de la source de données. Consultez [Types et options de connexion pour ETL dans AWS Glue pour Spark](aws-glue-programming-etl-connect.md).
+ `connectionOptions` — Chaîne de paires nom-valeur JSON qui fournissent des informations supplémentaires pour établir la connexion avec la source de données. Pour de plus amples informations, veuillez consulter [Types et options de connexion pour ETL dans AWS Glue pour Spark](aws-glue-programming-etl-connect.md).
Une source de streaming Kinesis nécessite les options de connexion suivantes : `streamARN`, `startingPosition`, `inferSchema` et `classification`.
Une source de streaming Kafka nécessite les options de connexion suivantes : `connectionName`, `topicName`, `startingOffsets`, `inferSchema` et `classification`.
+ `transformationContext` – Contexte de transformation associé au récepteur à utiliser par les signets de la tâche. Valeur définie sur vide par défaut.
+ `pushDownPredicate` – Prédicat sur les colonnes de partition.
Renvoie le `DataSource`.
Exemple pour la source de streaming 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)
}
```
Exemple pour la source de streaming 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)
}
```
## getSourceWithFormat def
```
def getSourceWithFormat( connectionType : String,
options : JsonOptions,
transformationContext : String = "",
format : String = null,
formatOptions : JsonOptions = JsonOptions.empty
) : DataSource
```
Crée un fichier [DataSource trait](glue-etl-scala-apis-glue-datasource-trait.md) qui lit les données d'une source telle qu'Amazon S3, JDBC ou le AWS Glue Data Catalog, et définit également le format des données stockées dans la source.
+ `connectionType` – Type de données de la source de données. Consultez [Types et options de connexion pour ETL dans AWS Glue pour Spark](aws-glue-programming-etl-connect.md).
+ `options` – Chaîne de paires nom-valeur JSON qui fournissent des informations supplémentaires pour établir la connexion avec la source de données. Consultez [Types et options de connexion pour ETL dans AWS Glue pour Spark](aws-glue-programming-etl-connect.md).
+ `transformationContext` – Contexte de transformation associé au récepteur à utiliser par les signets de la tâche. Valeur définie sur vide par défaut.
+ `format` – Format des données stockées à la source. Lorsque le `connectionType` est « s3 », vous pouvez également spécifier `format`. Peut être « avro », « csv », « grokLog », « ion », « json », « xml », « parquet » ou « orc ».
+ `formatOptions` – Chaîne JSON de paires nom-valeur qui fournissent des options supplémentaires pour l'analyse des données à la source. Consultez [Options de format de données](aws-glue-programming-etl-format.md).
Renvoie le `DataSource`.
**Exemples**
Créez un DynamicFrame à partir d'une source de données qui est un fichier de valeurs séparées par des virgules (CSV) sur 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()
```
Créez un DynamicFrame à partir d'une source de données PostgreSQL à l'aide d'une connexion 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()
```
Créez un DynamicFrame à partir d'une source de données MySQL à l'aide d'une connexion 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
```
Permet d'obtenir l'objet `SparkSession` associé à GlueContext. Utilisez cet SparkSession objet pour enregistrer des tables et UDFs pour l'utiliser avec `DataFrame` Created From DynamicFrames.
Renvoie le SparkSession.
## def startTransaction
```
def startTransaction(readOnly: Boolean):String
```
Démarrer une nouvelle transaction. Appelle en interne l’API [Démarrer la transaction](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) Lake Formation.
+ `readOnly` – Valeur booléenne indiquant si cette transaction doit être en lecture seule ou en lecture et en écriture. Les écritures effectuées à l’aide d’un ID de transaction en lecture seule seront rejetées. Les transactions en lecture seule n’ont pas besoin d’être validées.
Retourne l'ID de transaction.
## def commitTransaction
```
def commitTransaction(transactionId: String, waitForCommit: Boolean): Boolean
```
Tentative de validation de la transaction spécifiée. `commitTransaction` peut être renvoyé avant la fin de la validation de la transaction. Appelle en interne la Lake Formation [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) API.
+ `transactionId` – (Chaîne) La transaction à valider.
+ `waitForCommit` – (Booléen) Détermine si le `commitTransaction` retourne immédiatement. La valeur par défaut est True. Si elle est false,`commitTransaction` interroge et attend que la transaction soit validée. Le temps d’attente est limité à 1 minute en utilisant le backoff exponentiel avec un maximum de 6 tentatives de nouvelle tentative.
Renvoie une valeur de type Booléen pour indiquer si la validation a été effectuée ou non.
## def cancelTransaction
```
def cancelTransaction(transactionId: String): Unit
```
Tentative d'annulation de la transaction spécifiée. Appelle en interne l'[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)API Lake Formation.
+ `transactionId` – (Chaîne) La transaction à annuler.
Retourne une exception `TransactionCommittedException` si la transaction a déjà été validée.
## def this
```
def this( sc : SparkContext,
minPartitions : Int,
targetPartitions : Int )
```
Crée un objet `GlueContext` utilisant le `SparkContext` spécifié, les partitions minimales et les partitions cible.
+ `sc` — Le `SparkContext`.
+ `minPartitions` — Nombre minimal de partitions.
+ `targetPartitions` — Nombre cible de partitions.
Renvoie le `GlueContext`.
## def this
```
def this( sc : SparkContext )
```
Crée un objet `GlueContext` avec le `SparkContext` fourni. Définit le nombre minimal de partitions à 10 et de partitions cibles à 20.
+ `sc` — Le `SparkContext`.
Renvoie le `GlueContext`.
## def this
```
def this( sparkContext : JavaSparkContext )
```
Crée un objet `GlueContext` avec le `JavaSparkContext` fourni. Définit le nombre minimal de partitions à 10 et de partitions cibles à 20.
+ `sparkContext` — Le `JavaSparkContext`.
Renvoie le `GlueContext`.
# MappingSpec
**Package : com.amazonaws.services.glue**
## MappingSpec classe de cas
```
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` — `SchemaPath` du champ source.
+ `sourceType` — `DataType` du champ source.
+ `targetPath` — `SchemaPath` du champ cible.
+ `targetType` — `DataType` du champ cible.
Un `MappingSpec` spécifie un mappage entre un chemin d'accès source et un type de données source, et un chemin cible et un type de données cible. La valeur du chemin d'accès source de l'image source s'affiche dans l'image cible du chemin cible. Le type de données source est converti dans le type de données cible.
Il s'étend depuis `Product4` afin que vous puissiez manipuler n'importe quel `Product4` dans votre interface `applyMapping`.
## MappingSpec objet
```
object MappingSpec
```
L'objet `MappingSpec` coontient les membres suivants :
## Val orderingByTarget
```
val orderingByTarget: Ordering[MappingSpec]
```
## Def apply
```
def apply( sourcePath : String,
sourceType : DataType,
targetPath : String,
targetType : DataType
) : MappingSpec
```
Crée un `MappingSpec`.
+ `sourcePath` — Représentation sous forme de chaîne du chemin d'accès source.
+ `sourceType` – source `DataType`.
+ `targetPath` — Représentation sous forme de chaîne du chemin d'accès cible.
+ `targetType` – cible `DataType`.
Retourne un `MappingSpec`.
## def apply
```
def apply( sourcePath : String,
sourceTypeString : String,
targetPath : String,
targetTypeString : String
) : MappingSpec
```
Crée un `MappingSpec`.
+ `sourcePath` — Représentation sous forme de chaîne du chemin d'accès source.
+ `sourceType` — Représentation sous forme de chaîne du type de données source.
+ `targetPath` — Représentation sous forme de chaîne du chemin d'accès cible.
+ `targetType` — Représentation sous forme de chaîne du type de données cible.
Renvoie un MappingSpec.
## Def apply
```
def apply( product : Product4[String, String, String, String] ) : MappingSpec
```
Crée un `MappingSpec`.
+ `product` — `Product4` du chemin d'accès source, type de données source, chemin d'accès cible et type de données cible.
Retourne un `MappingSpec`.
# AWS GlueScala ResolveSpec APIs
**Topics**
+ [ResolveSpec objet](#glue-etl-scala-apis-glue-resolvespec-object)
+ [ResolveSpec classe de cas](#glue-etl-scala-apis-glue-resolvespec-case-class)
**Package : com.amazonaws.services.glue**
## ResolveSpec objet
**ResolveSpec**
```
object ResolveSpec
```
### def
```
def apply( path : String,
action : String
) : ResolveSpec
```
Crée un `ResolveSpec`.
+ `path` — Représentation sous forme de chaîne du champ de choix qui doit être résolu.
+ `action` — action de résolution. L'action peut être `Project`, `KeepAsStruct` ou `Cast`.
Renvoie le `ResolveSpec`.
### def
```
def apply( product : Product2[String, String] ) : ResolveSpec
```
Crée un `ResolveSpec`.
+ `product` – `Product2` de : chemin d'accès source, action de résolution.
Renvoie le `ResolveSpec`.
## ResolveSpec classe de cas
```
case class ResolveSpec extends Product2[String, String] (
path : SchemaPath,
action : String )
```
Crée un `ResolveSpec`.
+ `path` — Le `SchemaPath` du champ de choix qui doit être résolu.
+ `action` — action de résolution. L'action peut être `Project`, `KeepAsStruct` ou `Cast`.
### ResolveSpec méthodes def
```
def _1 : String
```
```
def _2 : String
```
# AWS GlueScala ArrayNode APIs
**Package : com.amazonaws.services.glue.types**
## ArrayNode classe de cas
**ArrayNode**
```
case class ArrayNode extends DynamicNode (
value : ArrayBuffer[DynamicNode] )
```
### ArrayNode méthodes def
```
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 GlueScala BinaryNode APIs
**Package : com.amazonaws.services.glue.types**
## BinaryNode classe de cas
**BinaryNode**
```
case class BinaryNode extends ScalarNode(value, TypeCode.BINARY) (
value : Array[Byte] )
```
### BinaryNode champs de val
+ `ordering`
### BinaryNode méthodes def
```
def clone
```
```
def equals( other : Any )
```
```
def hashCode : Int
```
# AWS GlueScala BooleanNode APIs
**Package : com.amazonaws.services.glue.types**
## BooleanNode classe de cas
**BooleanNode**
```
case class BooleanNode extends ScalarNode(value, TypeCode.BOOLEAN) (
value : Boolean )
```
### BooleanNode champs de val
+ `ordering`
### BooleanNode méthodes def
```
def equals( other : Any )
```
# AWS GlueScala ByteNode APIs
**Package : com.amazonaws.services.glue.types**
## ByteNode classe de cas
**ByteNode**
```
case class ByteNode extends ScalarNode(value, TypeCode.BYTE) (
value : Byte )
```
### ByteNode champs de val
+ `ordering`
### ByteNode méthodes def
```
def equals( other : Any )
```
# AWS GlueScala DateNode APIs
**Package : com.amazonaws.services.glue.types**
## DateNode classe de cas
**DateNode**
```
case class DateNode extends ScalarNode(value, TypeCode.DATE) (
value : Date )
```
### DateNode champs de val
+ `ordering`
### DateNode méthodes def
```
def equals( other : Any )
```
```
def this( value : Int )
```
# AWS GlueScala DecimalNode APIs
**Package : com.amazonaws.services.glue.types**
## DecimalNode classe de cas
**DecimalNode**
```
case class DecimalNode extends ScalarNode(value, TypeCode.DECIMAL) (
value : BigDecimal )
```
### DecimalNode champs de val
+ `ordering`
### DecimalNode méthodes def
```
def equals( other : Any )
```
```
def this( value : Decimal )
```
# AWS GlueScala DoubleNode APIs
**Package : com.amazonaws.services.glue.types**
## DoubleNode classe de cas
**DoubleNode**
```
case class DoubleNode extends ScalarNode(value, TypeCode.DOUBLE) (
value : Double )
```
### DoubleNode champs de val
+ `ordering`
### DoubleNode méthodes def
```
def equals( other : Any )
```
# AWS GlueScala DynamicNode APIs
**Topics**
+ [DynamicNode classe](#glue-etl-scala-apis-glue-types-dynamicnode-class)
+ [DynamicNode objet](#glue-etl-scala-apis-glue-types-dynamicnode-object)
**Package : com.amazonaws.services.glue.types**
## DynamicNode classe
**DynamicNode**
```
class DynamicNode extends Serializable with Cloneable
```
### DynamicNode méthodes def
```
def getValue : Any
```
Obtenir la valeur brute et la lier à l'enregistrement actuel :
```
def nodeType : TypeCode
```
```
def toJson : String
```
Méthode pour déboguer :
```
def toRow( schema : Schema,
options : Map[String, ResolveOption]
) : Row
```
```
def typeName : String
```
## DynamicNode objet
**DynamicNode**
```
object DynamicNode
```
### DynamicNode méthodes def
```
def quote( field : String,
useQuotes : Boolean
) : String
```
```
def quote( node : DynamicNode,
useQuotes : Boolean
) : String
```
# EvaluateDataQuality classe
| |
| --- |
| AWS Glue Data Quality est en version préliminaire AWS Glue et est susceptible d'être modifiée. |
**Package : com.amazonaws.services.glue.dq**
```
object EvaluateDataQuality
```
## Def apply
```
def apply(frame: DynamicFrame,
ruleset: String,
publishingOptions: JsonOptions = JsonOptions.empty): DynamicFrame
```
Évalue un ensemble de règles de qualité des données par rapport à un `DynamicFrame`, et renvoie un nouveau `DynamicFrame` avec les résultats de l'évaluation. Pour en savoir plus sur AWS Glue Data Quality, consultez[AWS Glue Qualité des données](glue-data-quality.md).
+ `frame` – `DynamicFrame` dont vous souhaitez évaluer la qualité des données.
+ `ruleset` – Ensemble de règles DQDL (Data Quality Definition Language) au format de chaîne. Pour en savoir plus sur DQDL, consultez le guide [Référence DQDL (Data Quality Definition Language)](dqdl.md).
+ `publishingOptions` – Dictionnaire qui spécifie les options de publication suivantes des résultats et des métriques d'une évaluation :
+ `dataQualityEvaluationContext`— Chaîne qui indique l'espace de noms sous lequel AWS Glue doit publier Amazon CloudWatch les métriques et les résultats de qualité des données. Les statistiques agrégées apparaissent dans CloudWatch, tandis que les résultats complets apparaissent dans l'interface de AWS Glue Studio.
+ Obligatoire : non
+ Valeur par défaut : `default_context`
+ `enableDataQualityCloudWatchMetrics`— Spécifie si les résultats de l'évaluation de la qualité des données doivent être publiés sur CloudWatch. Vous spécifiez un espace de noms pour les métriques à l'aide de l'option `dataQualityEvaluationContext`.
+ Obligatoire : non
+ Valeur par défaut : False
+ `enableDataQualityResultsPublishing` – Spécifie si les résultats relatifs à la qualité des données doivent être visibles dans l'onglet **Data Quality** (Qualité des données) de l'interface AWS Glue Studio.
+ Obligatoire : non
+ Valeur par défaut : True
+ `resultsS3Prefix`— Spécifie l'emplacement Amazon S3 où AWS Glue peut écrire les résultats de l'évaluation de la qualité des données.
+ Obligatoire : non
+ Valeur par défaut : "" (chaîne vide)
## Exemple
L'exemple de code suivant montre comment évaluer la qualité des données pour `DynamicFrame` avant d'effectuer une transformation `SelectFields`. Le script vérifie que l'ensemble des règles de qualité des données sont conformes avant de tenter la transformation.
```
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 GlueScala FloatNode APIs
**Package : com.amazonaws.services.glue.types**
## FloatNode classe de cas
**FloatNode**
```
case class FloatNode extends ScalarNode(value, TypeCode.FLOAT) (
value : Float )
```
### FloatNode champs de val
+ `ordering`
### FloatNode méthodes def
```
def equals( other : Any )
```
# FillMissingValues classe
**Package : 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
```
Remplit les valeurs manquantes d'un cadre dynamique dans une colonne spécifiée et renvoie un nouveau cadre avec des estimations dans une nouvelle colonne. Pour les lignes sans valeurs manquantes, la valeur de la colonne spécifiée est dupliquée dans la nouvelle colonne.
+ `frame`— Le champ DynamicFrame dans lequel les valeurs manquantes doivent être remplies. Obligatoire.
+ `missingValuesColumn` — colonne contenant les valeurs manquantes (valeurs `null` et chaînes vides). Obligatoire.
+ `outputColumn` — nom de la nouvelle colonne qui contiendra les valeurs estimées pour toutes les lignes dont la valeur était manquante. Facultatif ; la valeur par défaut est la valeur de `missingValuesColumn` avec le suffixe `"_filled"`.
+ `transformationContext` — chaîne unique utilisée pour identifier les informations sur l'état (facultatif).
+ `callSite` — utilisé pour fournir les informations de contexte pour le signalement d'erreurs.
+ `stageThreshold` — nombre maximal d'erreurs qui peuvent avoir lieu dans la transformation avant qu'elle ne soit arrêtée (facultatif ; la valeur par défaut est zéro).
+ `totalThreshold` — nombre maximal d'erreurs pouvant se produire globalement avant que le processus de traitement des erreurs ne soit arrêté (facultatif ; la valeur par défaut est zéro).
Renvoie une nouvelle image dynamique avec une colonne supplémentaire qui contient des estimations pour les lignes avec des valeurs manquantes et la valeur actuelle pour les autres lignes.
# FindMatches classe
**Package : 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
```
Recherchez des correspondances dans une image d'entrée et renvoyez une nouvelle image avec une nouvelle colonne contenant un ID unique par groupe de correspondance.
+ `frame`— L' DynamicFrame endroit où trouver des correspondances. Obligatoire.
+ `transformId`— Un identifiant unique associé à la FindMatches transformation à appliquer au cadre d'entrée. Obligatoire.
+ `transformationContext` — Identifiant de ce `DynamicFrame`. Le `transformationContext` est utilisé en tant que clé pour l'état de signet de tâche conservé d'une exécution à l'autre. Facultatif.
+ `callSite` – Permet de fournir des informations contextuelles pour le signalement d'erreurs. Ces valeurs sont automatiquement définies lors de l'appel à partir de Python. Facultatif.
+ `stageThreshold` – Nombre maximal d'enregistrements d'erreurs autorisés depuis le calcul du `DynamicFrame` avant de lever une exception, à l'exclusion des enregistrements présents dans le `DynamicFrame` précédent. Facultatif. La valeur par défaut est zéro.
+ `totalThreshold` – Nombre maximal d'enregistrements d'erreur avant qu'une exception ne soit levée, y compris ceux des images précédentes. Facultatif. La valeur par défaut est zéro.
+ `enforcedMatches` – Image pour les correspondances forcées. Facultatif. La valeur par défaut est `null`.
+ `computeMatchConfidenceScores` — Valeur booléenne indiquant s'il faut calculer un score de confiance pour chaque groupe d'enregistrements correspondants. Facultatif. La valeur par défaut est false.
Renvoie une nouvelle image dynamique avec un identifiant unique affecté à chaque groupe d'enregistrements correspondants.
# FindIncrementalMatches classe
**Package : 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
```
Recherchez des correspondances dans les images existantes et incrémentielles, et renvoyez une nouvelle image avec une colonne contenant un ID unique par groupe de correspondance.
+ `existingframe` – Image existante à laquelle un ID correspondant a été attribué pour chaque groupe. Obligatoire.
+ `incrementalframe` – Image incrémentielle utilisée pour rechercher des correspondances avec l'image existante. Obligatoire.
+ `transformId`— Un identifiant unique associé à la FindIncrementalMatches transformation à appliquer aux trames d'entrée. Obligatoire.
+ `transformationContext` — Identifiant de ce `DynamicFrame`. Le `transformationContext` est utilisé en tant que clé pour l'état de signet de tâche conservé d'une exécution à l'autre. Facultatif.
+ `callSite` – Permet de fournir des informations contextuelles pour le signalement d'erreurs. Ces valeurs sont automatiquement définies lors de l'appel à partir de Python. Facultatif.
+ `stageThreshold` – Nombre maximal d'enregistrements d'erreurs autorisés depuis le calcul du `DynamicFrame` avant de lever une exception, à l'exclusion des enregistrements présents dans le `DynamicFrame` précédent. Facultatif. La valeur par défaut est zéro.
+ `totalThreshold` – Nombre maximal d'enregistrements d'erreur avant qu'une exception ne soit levée, y compris ceux des images précédentes. Facultatif. La valeur par défaut est zéro.
+ `enforcedMatches` – Image pour les correspondances forcées. Facultatif. La valeur par défaut est `null`.
+ `computeMatchConfidenceScores` — Valeur booléenne indiquant s'il faut calculer un score de confiance pour chaque groupe d'enregistrements correspondants. Facultatif. La valeur par défaut est false.
Renvoie une nouvelle image dynamique avec un identifiant unique affecté à chaque groupe d'enregistrements correspondants.
# AWS GlueScala IntegerNode APIs
**Package : com.amazonaws.services.glue.types**
## IntegerNode classe de cas
**IntegerNode**
```
case class IntegerNode extends ScalarNode(value, TypeCode.INT) (
value : Int )
```
### IntegerNode champs de val
+ `ordering`
### IntegerNode méthodes def
```
def equals( other : Any )
```
# AWS GlueScala LongNode APIs
**Package : com.amazonaws.services.glue.types**
## LongNode classe de cas
**LongNode**
```
case class LongNode extends ScalarNode(value, TypeCode.LONG) (
value : Long )
```
### LongNode champs de val
+ `ordering`
### LongNode méthodes def
```
def equals( other : Any )
```
# AWS GlueScala MapLikeNode APIs
**Package : com.amazonaws.services.glue.types**
## MapLikeNode classe
**MapLikeNode**
```
class MapLikeNode extends DynamicNode (
value : mutable.Map[String, DynamicNode] )
```
### MapLikeNode méthodes def
```
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
```
**Exemple :** Soit le fichier JSON suivant :
```
{"foo": "bar"}
```
Si `useQuotes == true`, `toJson` génère `{"foo": "bar"}`. Si `useQuotes == false`, `toJson` génère `{foo: bar}` @return.
# AWS GlueScala MapNode APIs
**Package : com.amazonaws.services.glue.types**
## MapNode classe de cas
**MapNode**
```
case class MapNode extends MapLikeNode(value) (
value : mutable.Map[String, DynamicNode] )
```
### MapNode méthodes def
```
def clone
```
```
def equals( other : Any )
```
```
def hashCode : Int
```
```
def nodeType
```
```
def this
```
# AWS GlueScala NullNode APIs
**Topics**
+ [NullNode classe](#glue-etl-scala-apis-glue-types-nullnode-class)
+ [NullNode objet du boîtier](#glue-etl-scala-apis-glue-types-nullnode-case-object)
**Package : com.amazonaws.services.glue.types**
## NullNode classe
**NullNode**
```
class NullNode
```
## NullNode objet du boîtier
**NullNode**
```
case object NullNode extends NullNode
```
# AWS GlueScala ObjectNode APIs
**Topics**
+ [ObjectNode objet](#glue-etl-scala-apis-glue-types-objectnode-object)
+ [ObjectNode classe de cas](#glue-etl-scala-apis-glue-types-objectnode-case-class)
**Package : com.amazonaws.services.glue.types**
## ObjectNode objet
**ObjectNode**
```
object ObjectNode
```
### ObjectNode méthodes def
```
def apply( frameKeys : Set[String],
v1 : mutable.Map[String, DynamicNode],
v2 : mutable.Map[String, DynamicNode],
resolveWith : String
) : ObjectNode
```
## ObjectNode classe de cas
**ObjectNode**
```
case class ObjectNode extends MapLikeNode(value) (
val value : mutable.Map[String, DynamicNode] )
```
### ObjectNode méthodes def
```
def clone
```
```
def equals( other : Any )
```
```
def hashCode : Int
```
```
def nodeType
```
```
def this
```
# AWS GlueScala ScalarNode APIs
**Topics**
+ [ScalarNode classe](#glue-etl-scala-apis-glue-types-scalarnode-class)
+ [ScalarNode objet](#glue-etl-scala-apis-glue-types-scalarnode-object)
**Package : com.amazonaws.services.glue.types**
## ScalarNode classe
**ScalarNode**
```
class ScalarNode extends DynamicNode (
value : Any,
scalarType : TypeCode )
```
### ScalarNode méthodes def
```
def compare( other : Any,
operator : String
) : Boolean
```
```
def getValue
```
```
def hashCode : Int
```
```
def nodeType
```
```
def toJson
```
## ScalarNode objet
**ScalarNode**
```
object ScalarNode
```
### ScalarNode méthodes def
```
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 GlueScala ShortNode APIs
**Package : com.amazonaws.services.glue.types**
## ShortNode classe de cas
**ShortNode**
```
case class ShortNode extends ScalarNode(value, TypeCode.SHORT) (
value : Short )
```
### ShortNode champs de val
+ `ordering`
### ShortNode méthodes def
```
def equals( other : Any )
```
# AWS GlueScala StringNode APIs
**Package : com.amazonaws.services.glue.types**
## StringNode classe de cas
**StringNode**
```
case class StringNode extends ScalarNode(value, TypeCode.STRING) (
value : String )
```
### StringNode champs de val
+ `ordering`
### StringNode méthodes def
```
def equals( other : Any )
```
```
def this( value : UTF8String )
```
# AWS GlueScala TimestampNode APIs
**Package : com.amazonaws.services.glue.types**
## TimestampNode classe de cas
**TimestampNode**
```
case class TimestampNode extends ScalarNode(value, TypeCode.TIMESTAMP) (
value : Timestamp )
```
### TimestampNode champs de val
+ `ordering`
### TimestampNode méthodes def
```
def equals( other : Any )
```
```
def this( value : Long )
```
# AWS GlueScala GlueArgParser APIs
**Package : com.amazonaws.services.glue.util**
## GlueArgParser objet
**GlueArgParser**
```
object GlueArgParser
```
Strictement compatible avec la version Python de `utils.getResolvedOptions` dans le package `AWSGlueDataplanePython`.
### GlueArgParser méthodes def
```
def getResolvedOptions( args : Array[String],
options : Array[String]
) : Map[String, String]
```
```
def initParser( userOptionsSet : mutable.Set[String] ) : ArgumentParser
```
**Example Extraction des arguments transmis à une tâche**
Pour extraire les arguments d'une tâche, vous pouvez utiliser la méthode `getResolvedOptions`. Prenons l'exemple suivant, qui récupère un argument de tâche nommé `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)
```
# AWS GlueJob Scala APIs
**Package : com.amazonaws.services.glue.util**
## Objet Job
**Job**
```
object Job
```
### Modes 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
```