# API en la biblioteca Scala de AWS Glue
<a name="glue-etl-scala-apis"></a>

AWS Glue es compatible con una extensión del dialecto Scala de PySpark para los trabajos de extraer, transformar y cargar (ETL) scripts. En las siguientes secciones se describen las API de la biblioteca Scala de AWS Glue.

## com.amazonaws.services.glue
<a name="glue-etl-scala-apis-glue"></a>

El paquete **com.amazonaws.services.glue** de la biblioteca AWS Glue Scala contiene las API siguientes:
+ [ChoiceOption](glue-etl-scala-apis-glue-choiceoption.md)
+ [DataSink](glue-etl-scala-apis-glue-datasink-class.md)
+ [Característica DataSource](glue-etl-scala-apis-glue-datasource-trait.md)
+ [DynamicFrame](glue-etl-scala-apis-glue-dynamicframe.md)
+ [DynamicRecord](glue-etl-scala-apis-glue-dynamicrecord-class.md)
+ [GlueContext](glue-etl-scala-apis-glue-gluecontext.md)
+ [MappingSpec](glue-etl-scala-apis-glue-mappingspec.md)
+ [ResolveSpec](glue-etl-scala-apis-glue-resolvespec.md)

## com.amazonaws.services.glue.ml
<a name="glue-etl-scala-apis-glue-ml"></a>

El paquete **com.amazonaws.services.glue.ml** de la biblioteca de AWS Glue Scala contiene las siguientes API:
+ [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
<a name="glue-etl-scala-apis-glue-dq"></a>

El paquete **com.amazonaws.services.glue.dq** de la biblioteca de Scala de AWS Glue contiene las siguientes API:
+ [EvaluateDataQuality](glue-etl-scala-apis-glue-dq-EvaluateDataQuality.md)

## com.amazonaws.services.glue.types
<a name="glue-etl-scala-apis-glue-types"></a>

El paquete **com.amazonaws.services.glue.types** de la biblioteca AWS Glue Scala contiene las API siguientes:
+ [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
<a name="glue-etl-scala-apis-glue-util"></a>

El paquete **com.amazonaws.services.util** de la biblioteca AWS Glue Scala contiene las API siguientes:
+ [GlueArgParser](glue-etl-scala-apis-glue-util-glueargparser.md)
+ [Trabajo](glue-etl-scala-apis-glue-util-job.md)

# API ChoiceOption Scala de AWS Glue
<a name="glue-etl-scala-apis-glue-choiceoption"></a>

**Topics**
+ [Característica ChoiceOption](#glue-etl-scala-apis-glue-choiceoption-trait)
+ [Objeto ChoiceOption](#glue-etl-scala-apis-glue-choiceoption-object)
+ [case class ChoiceOptionWithResolver](#glue-etl-scala-apis-glue-choiceoptionwithresolver-case-class)
+ [case class MatchCatalogSchemaChoiceOption](#glue-etl-scala-apis-glue-matchcatalogschemachoiceoption-case-class)

**Paquete: com.amazonaws.services.glue**

## Característica ChoiceOption
<a name="glue-etl-scala-apis-glue-choiceoption-trait"></a>

```
trait ChoiceOption extends Serializable 
```

## Objeto ChoiceOption
<a name="glue-etl-scala-apis-glue-choiceoption-object"></a>

 **ChoiceOption**

```
object ChoiceOption
```

Una estrategia general para resolver la selección aplicable a todos los nodos `ChoiceType` de un objeto `DynamicFrame`.
+ `val CAST`
+ `val MAKE_COLS`
+ `val MAKE_STRUCT`
+ `val MATCH_CATALOG`
+ `val PROJECT`

### Def apply
<a name="glue-etl-scala-apis-glue-choiceoption-object-def-apply"></a>

```
def apply(choice: String): ChoiceOption
```



## case class ChoiceOptionWithResolver
<a name="glue-etl-scala-apis-glue-choiceoptionwithresolver-case-class"></a>

```
case class ChoiceOptionWithResolver(name: String, choiceResolver: ChoiceResolver) extends ChoiceOption {}
```



## case class MatchCatalogSchemaChoiceOption
<a name="glue-etl-scala-apis-glue-matchcatalogschemachoiceoption-case-class"></a>

```
case class MatchCatalogSchemaChoiceOption() extends ChoiceOption {}
```



# Abstract DataSink class
<a name="glue-etl-scala-apis-glue-datasink-class"></a>

**Topics**
+ [def writeDynamicFrame](#glue-etl-scala-apis-glue-datasink-class-defs-writeDynamicFrame)
+ [def pyWriteDynamicFrame](#glue-etl-scala-apis-glue-datasink-class-defs-pyWriteDynamicFrame)
+ [Def writeDataFrame](#glue-etl-scala-apis-glue-datasink-class-defs-writeDataFrame)
+ [Def pyWriteDataFrame](#glue-etl-scala-apis-glue-datasink-class-defs-pyWriteDataFrame)
+ [def setCatalogInfo](#glue-etl-scala-apis-glue-datasink-class-defs-setCatalogInfo)
+ [def supportsFormat](#glue-etl-scala-apis-glue-datasink-class-defs-supportsFormat)
+ [def setFormat](#glue-etl-scala-apis-glue-datasink-class-defs-setFormat)
+ [def withFormat](#glue-etl-scala-apis-glue-datasink-class-defs-withFormat)
+ [def setAccumulableSize](#glue-etl-scala-apis-glue-datasink-class-defs-setAccumulableSize)
+ [def getOutputErrorRecordsAccumulable](#glue-etl-scala-apis-glue-datasink-class-defs-getOutputErrorRecordsAccumulable)
+ [def errorsAsDynamicFrame](#glue-etl-scala-apis-glue-datasink-class-defs-errorsAsDynamicFrame)
+ [Objeto DataSink](#glue-etl-scala-apis-glue-datasink-object)

**Paquete: com.amazonaws.services.glue**

```
abstract class DataSink
```

El escritor análogo a un `DataSource`. `DataSink` encapsula un destino y un formato en el que se puede escribir un objeto `DynamicFrame`.

## def writeDynamicFrame
<a name="glue-etl-scala-apis-glue-datasink-class-defs-writeDynamicFrame"></a>

```
def writeDynamicFrame( frame : DynamicFrame,
                       callSite : CallSite = CallSite("Not provided", "")
                     ) : DynamicFrame
```



## def pyWriteDynamicFrame
<a name="glue-etl-scala-apis-glue-datasink-class-defs-pyWriteDynamicFrame"></a>

```
def pyWriteDynamicFrame( frame : DynamicFrame,
                         site : String = "Not provided",
                         info : String = "" )
```



## Def writeDataFrame
<a name="glue-etl-scala-apis-glue-datasink-class-defs-writeDataFrame"></a>

```
def writeDataFrame(frame: DataFrame,
                   glueContext: GlueContext,
                   callSite: CallSite = CallSite("Not provided", "")
                   ): DataFrame
```



## Def pyWriteDataFrame
<a name="glue-etl-scala-apis-glue-datasink-class-defs-pyWriteDataFrame"></a>

```
def pyWriteDataFrame(frame: DataFrame,
                     glueContext: GlueContext,
                     site: String = "Not provided",
                     info: String = ""
                     ): DataFrame
```



## def setCatalogInfo
<a name="glue-etl-scala-apis-glue-datasink-class-defs-setCatalogInfo"></a>

```
def setCatalogInfo(catalogDatabase: String, 
                   catalogTableName : String, 
                   catalogId : String = "")
```



## def supportsFormat
<a name="glue-etl-scala-apis-glue-datasink-class-defs-supportsFormat"></a>

```
def supportsFormat( format : String ) : Boolean
```



## def setFormat
<a name="glue-etl-scala-apis-glue-datasink-class-defs-setFormat"></a>

```
def setFormat( format : String,
               options : JsonOptions
             ) : Unit
```



## def withFormat
<a name="glue-etl-scala-apis-glue-datasink-class-defs-withFormat"></a>

```
def withFormat( format : String,
                options : JsonOptions = JsonOptions.empty
              ) : DataSink
```



## def setAccumulableSize
<a name="glue-etl-scala-apis-glue-datasink-class-defs-setAccumulableSize"></a>

```
def setAccumulableSize( size : Int ) : Unit
```



## def getOutputErrorRecordsAccumulable
<a name="glue-etl-scala-apis-glue-datasink-class-defs-getOutputErrorRecordsAccumulable"></a>

```
def getOutputErrorRecordsAccumulable : Accumulable[List[OutputError], OutputError]
```



## def errorsAsDynamicFrame
<a name="glue-etl-scala-apis-glue-datasink-class-defs-errorsAsDynamicFrame"></a>

```
def errorsAsDynamicFrame : DynamicFrame
```



## Objeto DataSink
<a name="glue-etl-scala-apis-glue-datasink-object"></a>

```
object DataSink
```

### def recordMetrics
<a name="glue-etl-scala-apis-glue-datasink-object-defs-recordMetrics"></a>

```
def recordMetrics( frame : DynamicFrame,
                   ctxt : String
                 ) : DynamicFrame
```



# Característica DataSource Scala de AWS Glue
<a name="glue-etl-scala-apis-glue-datasource-trait"></a>

**Paquete: com.amazonaws.services.glue**

Una interfaz de alto nivel para producir 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 
}
```

# API DynamicFrame Scala de AWS Glue
<a name="glue-etl-scala-apis-glue-dynamicframe"></a>

**Paquete: com.amazonaws.services.glue**

**Contents**
+ [Clase DynamicFrame Scala de AWS Glue](glue-etl-scala-apis-glue-dynamicframe-class.md)
  + [Val errorsCount](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-vals-errorsCount)
  + [Def applyMapping](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-applyMapping)
  + [Def assertErrorThreshold](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-assertErrorThreshold)
  + [Def count](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-count)
  + [Def dropField](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-dropField)
  + [Def dropFields](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-dropFields)
  + [Def dropNulls](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-dropNulls)
  + [def errorsAsDynamicFrame](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-errorsAsDynamicFrame)
  + [Def filter](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-filter)
  + [Def getName](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-getName)
  + [Def getNumPartitions](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-getNumPartitions)
  + [Def getSchemaIfComputed](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-getSchemaIfComputed)
  + [Def isSchemaComputed](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-isSchemaComputed)
  + [Def javaToPython](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-javaToPython)
  + [Def join](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-join)
  + [Def map](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-map)
  + [Def mergeDynamicFrames](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-merge)
  + [Def printSchema](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-printSchema)
  + [Def recomputeSchema](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-recomputeSchema)
  + [Def relationalize](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-relationalize)
  + [Def renameField](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-renameField)
  + [Def repartition](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-repartition)
  + [Def resolveChoice](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-resolveChoice)
  + [Def schema](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-schema)
  + [Def selectField](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-selectField)
  + [Def selectFields](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-selectFields)
  + [Def show](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-show)
  + [Def simplifyDDBJson](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-simplifyDDBJson)
  + [Def spigot](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-spigot)
  + [Def splitFields](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-splitFields)
  + [Def splitRows](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-splitRows)
  + [Def stageErrorsCount](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-stageErrorsCount)
  + [Def toDF](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-toDF)
  + [Def unbox](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-unbox)
  + [Def unnest](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-unnest)
  + [Def unnestDDBJson](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-unnestddbjson)
  + [Def withFrameSchema](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-withFrameSchema)
  + [Def withName](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-withName)
  + [Def withTransformationContext](glue-etl-scala-apis-glue-dynamicframe-class.md#glue-etl-scala-apis-glue-dynamicframe-class-defs-withTransformationContext)
+ [Objeto DynamicFrame](glue-etl-scala-apis-glue-dynamicframe-object.md)
  + [Def apply](glue-etl-scala-apis-glue-dynamicframe-object.md#glue-etl-scala-apis-glue-dynamicframe-object-defs-apply)
  + [def emptyDynamicFrame](glue-etl-scala-apis-glue-dynamicframe-object.md#glue-etl-scala-apis-glue-dynamicframe-object-defs-emptyDynamicFrame)
  + [Def fromPythonRDD](glue-etl-scala-apis-glue-dynamicframe-object.md#glue-etl-scala-apis-glue-dynamicframe-object-defs-fromPythonRDD)
  + [Def ignoreErrors](glue-etl-scala-apis-glue-dynamicframe-object.md#glue-etl-scala-apis-glue-dynamicframe-object-defs-ignoreErrors)
  + [Def inlineErrors](glue-etl-scala-apis-glue-dynamicframe-object.md#glue-etl-scala-apis-glue-dynamicframe-object-defs-inlineErrors)
  + [Def newFrameWithErrors](glue-etl-scala-apis-glue-dynamicframe-object.md#glue-etl-scala-apis-glue-dynamicframe-object-defs-newFrameWithErrors)

# Clase DynamicFrame Scala de AWS Glue
<a name="glue-etl-scala-apis-glue-dynamicframe-class"></a>

**Paquete: 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 = {} )
```

`DynamicFrame` es una colección distribuida de objetos [DynamicRecord](glue-etl-scala-apis-glue-dynamicrecord-class.md) autodescriptivos.

`DynamicFrame`Los elementos s se han diseñado para proporcionar un modelo de datos flexible para operaciones de ETL (extracción, transformación y carga). No necesitan un esquema para crearse y se pueden usar para leer y transformar datos que contienen valores y tipos confusos o incoherentes. Un esquema se puede calcular bajo demanda para las operaciones que necesiten uno.

`DynamicFrame`Los objetos proporcionan una serie de transformaciones para la limpieza de datos y ETL. También admiten la conversión a clases DataFrame de SparkSQL, y desde dichas clases, para integrarse con el código existente y las numerosas operaciones de análisis que proporcionan las clases DataFrame.

Los siguientes parámetros se comparten entre las numerosas transformaciones de AWS Glue que construyen objetos `DynamicFrame`:
+ `transformationContext` — identificador de este `DynamicFrame`. El parámetro `transformationContext` se utiliza como clave para el estado de marcador de flujo de trabajo que se conserva de una ejecución a otra.
+ `callSite`: proporciona información de contexto para los informes de error. Estos valores se establecen automáticamente cuando se realiza la llamada desde Python.
+ `stageThreshold`: número máximo de registros de error permitidos en el cálculo de este objeto `DynamicFrame` antes de generar una excepción, sin incluir los registros presentes en el objeto `DynamicFrame` anterior.
+ `totalThreshold`: número máximo registros de error totales antes de que se genere una excepción, incluidos los de marcos anteriores.

## Val errorsCount
<a name="glue-etl-scala-apis-glue-dynamicframe-class-vals-errorsCount"></a>

```
val errorsCount
```

El número de registros de error en este objeto `DynamicFrame`. Se incluyen errores de las operaciones anteriores.

## Def applyMapping
<a name="glue-etl-scala-apis-glue-dynamicframe-class-defs-applyMapping"></a>

```
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` — secuencia de mapeos para construir un objeto nuevo `DynamicFrame`.
+ `caseSensitive`: indica si hay que considerar que las columnas de origen distinguen entre mayúsculas y minúsculas. Configurar este valor como falso puede ser de ayuda al realizar integraciones con almacenes que no distinguen entre mayúsculas y minúsculas, como AWS Glue Data Catalog.

Selecciona, proyecta y convierte las columnas en función de una secuencia de mapeos.

Cada mapeo se compone de una columna y un tipo de origen y una columna y un tipo de destino. Los mapeos se pueden especificar como una tupla cuádruple (`source_path`, `source_type`, ` target_path`, `target_type`) o un objeto [MappingSpec](glue-etl-scala-apis-glue-mappingspec.md) que contiene la misma información.

Además de usar los mapeos para proyecciones y conversiones simples, también se pueden usar para anidar o aplanar campos separando los componentes de la ruta con "`.`" (punto). 

Por ejemplo, suponga que tiene una instancia de `DynamicFrame` con el siguiente esquema.

```
 {{{
   root
   |-- name: string
   |-- age: int
   |-- address: struct
   |    |-- state: string
   |    |-- zip: int
 }}}
```

Puede hacer la siguiente llamada para quitar el anidamiento en los campos `state` y `zip`:

```
 {{{
   df.applyMapping(
    Seq(("name", "string", "name", "string"),
        ("age", "int", "age", "int"),
        ("address.state", "string", "state", "string"),
        ("address.zip", "int", "zip", "int")))
 }}}
```

El esquema resultante es el siguiente.

```
 {{{
   root
   |-- name: string
   |-- age: int
   |-- state: string
   |-- zip: int
 }}}
```

También puede utilizar `applyMapping` para volver a anidar columnas. Por ejemplo, el siguiente código invierte la transformación anterior y crea una estructura denominada `address` en el destino.

```
 {{{
   df.applyMapping(
    Seq(("name", "string", "name", "string"),
        ("age", "int", "age", "int"),
        ("state", "string", "address.state", "string"),
        ("zip", "int", "address.zip", "int")))
 }}}
```

Los nombres de los campos que contienen caracteres "`.`" (punto) se pueden citar mediante acentos graves (````).

**nota**  
Actualmente no se puede usar el método `applyMapping` para mapear columnas anidadas en matrices.

## Def assertErrorThreshold
<a name="glue-etl-scala-apis-glue-dynamicframe-class-defs-assertErrorThreshold"></a>

```
def assertErrorThreshold : Unit
```

Acción que fuerza el cómputo y verifica que el número de registros de error esté por debajo de `stageThreshold` y `totalThreshold`. Genera una excepción si no se cumple ninguna de las condiciones.

## Def count
<a name="glue-etl-scala-apis-glue-dynamicframe-class-defs-count"></a>

```
lazy
def count
```

Devuelve el número de elementos en este objeto `DynamicFrame`.

## Def dropField
<a name="glue-etl-scala-apis-glue-dynamicframe-class-defs-dropField"></a>

```
def dropField( path : String,
               transformationContext : String = "",
               callSite : CallSite = CallSite("Not provided", ""),
               stageThreshold : Long = 0,
               totalThreshold : Long = 0
             ) : DynamicFrame
```

Devuelve un objeto `DynamicFrame` nuevo sin la columna especificada.

## Def dropFields
<a name="glue-etl-scala-apis-glue-dynamicframe-class-defs-dropFields"></a>

```
def dropFields( fieldNames : Seq[String],   // The column names to drop.
                transformationContext : String = "",
                callSite : CallSite = CallSite("Not provided", ""),
                stageThreshold : Long = 0,
                totalThreshold : Long = 0
              ) : DynamicFrame
```

Devuelve un objeto `DynamicFrame` nuevo sin las columnas especificadas.

Este método se puede utilizar para eliminar columnas anidadas, incluidas las que se encuentran en matrices, pero no para descartar elementos de matriz específicos.

## Def dropNulls
<a name="glue-etl-scala-apis-glue-dynamicframe-class-defs-dropNulls"></a>

```
def dropNulls( transformationContext : String = "",
               callSite : CallSite = CallSite("Not provided", ""),
               stageThreshold : Long = 0,
               totalThreshold : Long = 0 )
```

Devuelve un objeto `DynamicFrame` nuevo sin las columnas nulas.

**nota**  
Solo se eliminan las columnas del tipo `NullType`. Los valores nulos individuales de otras columnas no se eliminan ni modifican.

## def errorsAsDynamicFrame
<a name="glue-etl-scala-apis-glue-dynamicframe-class-defs-errorsAsDynamicFrame"></a>

```
def errorsAsDynamicFrame
```

Devuelve un objeto `DynamicFrame` nuevo que contiene los registros de error de este `DynamicFrame`.

## Def filter
<a name="glue-etl-scala-apis-glue-dynamicframe-class-defs-filter"></a>

```
def filter( f : DynamicRecord => Boolean,
            errorMsg : String = "",
            transformationContext : String = "",
            callSite : CallSite = CallSite("Not provided"),
            stageThreshold : Long = 0,
            totalThreshold : Long = 0
          ) : DynamicFrame
```

Crea un objeto `DynamicFrame` nuevo que solo contiene los registros en los que la función "`f`" devuelve `true`. La función de filtro "`f`" no debe mutar el registro de entrada.

## Def getName
<a name="glue-etl-scala-apis-glue-dynamicframe-class-defs-getName"></a>

```
def getName : String 
```

Devuelve el nombre de este objeto `DynamicFrame`.

## Def getNumPartitions
<a name="glue-etl-scala-apis-glue-dynamicframe-class-defs-getNumPartitions"></a>

```
def getNumPartitions
```

Devuelve el número de particiones en este objeto `DynamicFrame`.

## Def getSchemaIfComputed
<a name="glue-etl-scala-apis-glue-dynamicframe-class-defs-getSchemaIfComputed"></a>

```
def getSchemaIfComputed : Option[Schema] 
```

Devuelve el esquema si ya se ha calculado. No analiza los datos si aún no se ha calculado el esquema.

## Def isSchemaComputed
<a name="glue-etl-scala-apis-glue-dynamicframe-class-defs-isSchemaComputed"></a>

```
def isSchemaComputed : Boolean 
```

Devuelve `true` si el esquema se ha calculado para este objeto `DynamicFrame`, de lo contrario devuelve `false`. Si este método devuelve false, la llamada al método `schema` necesitará otra pasada por los registros en este objeto `DynamicFrame`.

## Def javaToPython
<a name="glue-etl-scala-apis-glue-dynamicframe-class-defs-javaToPython"></a>

```
def javaToPython : JavaRDD[Array[Byte]] 
```



## Def join
<a name="glue-etl-scala-apis-glue-dynamicframe-class-defs-join"></a>

```
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`: las columnas de este objeto `DynamicFrame` que se utilizarán para la combinación.
+ `keys2`: las columnas de `frame2` que se utilizarán para la combinación. Deben tener la misma longitud que `keys1`.
+ `frame2`: el elemento `DynamicFrame` con el que debe realizarse la combinación.

Devuelve el resultado de realizar una combinación equijoin con `frame2` utilizando las claves especificadas.

## Def map
<a name="glue-etl-scala-apis-glue-dynamicframe-class-defs-map"></a>

```
def map( f : DynamicRecord => DynamicRecord,
         errorMsg : String = "",
         transformationContext : String = "",
         callSite : CallSite = CallSite("Not provided", ""),
         stageThreshold : Long = 0,
         totalThreshold : Long = 0
       ) : DynamicFrame
```

Devuelve un objeto `DynamicFrame` nuevo creado aplicando la función "`f`" especificada a cada registro de este objeto `DynamicFrame`.

Este método copia cada registro antes de aplicar la función especificada, por lo que es seguro para mutar los registros. Si la función de mapeo genera una excepción en un registro determinado, dicho registro se marca como un error y la pila de seguimiento se guarda como una columna en el registro de errores.

## Def mergeDynamicFrames
<a name="glue-etl-scala-apis-glue-dynamicframe-class-defs-merge"></a>

```
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`: `DynamicFrame` provisional que se fusionará.
+ `primaryKeys`: la lista de campos de clave principal para hacer coincidir los registros de los `DynamicFrame` de origen y provisionales.
+ `transformationContext`: una cadena única que se utiliza para recuperar metadatos sobre la transformación actual (opcional).
+ `options`: una cadena de pares de nombre-valor de JSON que proporcionan información adicional para esta transformación.
+ `callSite`: se utiliza para proporcionar información de contexto para los informes de error.
+ `stageThreshold` — un valor `Long`. Número de errores de la transformación especificada que provocarán que el proceso se termine.
+ `totalThreshold` — un elemento `Long`. Número total de errores hasta esta transformación (incluida) que provocarán que el proceso se termine.

Combina este objeto `DynamicFrame` con una instancia provisional de `DynamicFrame` en función de las claves principales especificadas para identificar registros. Los registros duplicados (registros con las mismas claves principales) no se eliminan. Si no hay ningún registro que coincida en el marco provisional, se retienen todos los registros del origen (incluidos los duplicados). Si el marco provisional tiene registros coincidentes, estos sobrescriben a los registros del origen en AWS Glue.

La instancia de `DynamicFrame` devuelta contiene el registro A en los siguientes casos:

1. Si `A` existe tanto en el marco de origen como en el marco provisional, se devuelve `A` en el marco provisional.

1. Si `A` está en la tabla de origen y `A.primaryKeys` no está en `stagingDynamicFrame` (significa que `A` no se actualiza en la tabla provisional).

No es necesario que el marco de origen y el marco provisional tengan el mismo esquema.

**Example**  

```
val mergedFrame: DynamicFrame = srcFrame.mergeDynamicFrames(stageFrame, Seq("id1", "id2"))
```

## Def printSchema
<a name="glue-etl-scala-apis-glue-dynamicframe-class-defs-printSchema"></a>

```
def printSchema : Unit 
```

Imprime el esquema de este objeto `DynamicFrame` en `stdout` en un formato fácil de leer.

## Def recomputeSchema
<a name="glue-etl-scala-apis-glue-dynamicframe-class-defs-recomputeSchema"></a>

```
def recomputeSchema : Schema 
```

Fuerza un nuevo cálculo del esquema. Es necesario realizar un análisis de los datos, lo que podría "endurecer" el esquema si hay algunos campos del esquema actual que no están en los datos.

Devuelve el esquema calculado de nuevo.

## Def relationalize
<a name="glue-etl-scala-apis-glue-dynamicframe-class-defs-relationalize"></a>

```
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`: el nombre que se va a utilizar para el `DynamicFrame` base en la salida. Los `DynamicFrame` que se crean mediante matrices dinámicas comienzan con este prefijo.
+ `stagingPath`: la ruta de Amazon Simple Storage Service (Amazon S3) para escribir datos intermedios.
+ `options`: opciones y configuración de Rationalize. En la actualidad no se utiliza.

Aplana todas las estructuras anidadas y convierte las matrices en tablas independientes.

Puede utilizar esta operación para preparar datos con anidamiento profundo para su incorporación a una base de datos relacional. Las estructuras anidadas se aplanan de la misma manera en que lo haría la transformación [Unnest](#glue-etl-scala-apis-glue-dynamicframe-class-defs-unnest). Además, las matrices se dividen en tablas independientes en las que cada elemento de matriz se convierte en una fila. Por ejemplo, supongamos que tiene una instancia de `DynamicFrame` con los siguientes datos.

```
 {"name": "Nancy", "age": 47, "friends": ["Fred", "Lakshmi"]}
 {"name": "Stephanie", "age": 28, "friends": ["Yao", "Phil", "Alvin"]}
 {"name": "Nathan", "age": 54, "friends": ["Nicolai", "Karen"]}
```

Ejecute el siguiente código.

```
{{{
  df.relationalize("people", "s3:/my_bucket/my_path", JsonOptions.empty)
}}}
```

Se generan dos tablas. La primera tabla se denomina "people" y contiene lo siguiente.

```
{{{
  {"name": "Nancy", "age": 47, "friends": 1}
  {"name": "Stephanie", "age": 28, "friends": 2}
  {"name": "Nathan", "age": 54, "friends": 3)
}}}
```

Aquí, la matriz friends se ha reemplazado por una clave de combinación generada automáticamente. Se crea una tabla diferente llamada `people.friends` con el siguiente contenido.

```
{{{
  {"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"}
}}}
```

En esta tabla, "`id`" es una clave de combinación que identifica de qué registro procede el elemento de matriz, "`index`" hace referencia a la posición en la matriz original y "`val`" es la entrada de matriz real.

El método `relationalize` devuelve la secuencia de objetos `DynamicFrame` creados aplicando este proceso de forma recursiva a todas las matrices.

**nota**  
La biblioteca de AWS Glue genera automáticamente las claves de combinación de las tablas nuevas. Para garantizar que las claves de combinación sean únicas en las ejecuciones de flujo de trabajo, debe habilitar los marcadores de flujo de trabajo.

## Def renameField
<a name="glue-etl-scala-apis-glue-dynamicframe-class-defs-renameField"></a>

```
def renameField( oldName : String,
                 newName : String,
                 transformationContext : String = "",
                 callSite : CallSite = CallSite("Not provided", ""),
                 stageThreshold : Long = 0,
                 totalThreshold : Long = 0
               ) : DynamicFrame
```
+ `oldName`: el nombre original de la columna.
+ `newName`: el nuevo nombre de la columna.

Devuelve un `DynamicFrame` nuevo que incluye el campo especificado con un nuevo nombre.

Puede usar este método para cambiar el nombre de los campos anidados. Por ejemplo, el siguiente código cambiaría el nombre de `state` a `state_code` en la estructura de dirección.

```
{{{
  df.renameField("address.state", "address.state_code")
}}}
```

## Def repartition
<a name="glue-etl-scala-apis-glue-dynamicframe-class-defs-repartition"></a>

```
def repartition( numPartitions : Int,
                 transformationContext : String = "",
                 callSite : CallSite = CallSite("Not provided", ""),
                 stageThreshold : Long = 0,
                 totalThreshold : Long = 0
               ) : DynamicFrame
```

Devuelve un objeto `DynamicFrame` nuevo con `numPartitions` particiones.

## Def resolveChoice
<a name="glue-etl-scala-apis-glue-dynamicframe-class-defs-resolveChoice"></a>

```
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`: acción que se aplica a todas las columnas `ChoiceType` que no están indicadas en la secuencia specs.
+ `database`: la base de datos de Data Catalog que se usará con la acción `match_catalog`.
+ `tableName`: la tabla de Data Catalog que se usará con la acción `match_catalog`.

Devuelve un objeto `DynamicFrame` nuevo reemplazando uno o varios `ChoiceType` por un tipo más específico.

Hay dos formas de usar `resolveChoice`. La primera consiste en especificar una secuencia de columnas específicas y cómo resolverlas. Se especifican como tuplas compuestas de pares (columna, acción).

Los posibles valores son los siguientes:
+ `cast:type`: intenta convertir todos los valores al tipo especificado.
+ `make_cols` — convierte cada tipo diferenciado en una columna con el nombre `columnName_type`.
+ `make_struct`: convierte una columna en una estructura con claves para cada tipo diferenciado.
+ `project:type`: retiene solo valores del tipo especificado.

El otro modo de `resolveChoice` es especificar una resolución única para todas las columnas `ChoiceType`. Se puede utilizar en los casos en los que se desconozca la lista completa de `ChoiceType` antes de la ejecución. Además de las acciones enumeradas anteriormente, este modo también admite la siguiente acción:
+ `match_catalog`: intenta convertir cada `ChoiceType` al tipo correspondiente en la tabla de catálogos especificada.

**Ejemplos:**

Resolver la columna `user.id` mediante la conversión a int y hacer que el campo `address` solo conserve estructuras.

```
{{{
  df.resolveChoice(specs = Seq(("user.id", "cast:int"), ("address", "project:struct")))
}}}
```

Resolver todas las columnas `ChoiceType` convirtiendo cada opción en una columna independiente.

```
{{{
  df.resolveChoice(choiceOption = Some(ChoiceOption("make_cols")))
}}}
```

Resolver todas las columnas `ChoiceType` mediante la conversión a los tipos de la tabla de catálogos especificada.

```
{{{
  df.resolveChoice(choiceOption = Some(ChoiceOption("match_catalog")),
                   database = Some("my_database"),
                   tableName = Some("my_table"))
}}}
```

## Def schema
<a name="glue-etl-scala-apis-glue-dynamicframe-class-defs-schema"></a>

```
def schema : Schema 
```

Devuelve el esquema de este objeto `DynamicFrame`.

El esquema devuelto contiene todos los campos presentes en un registro en este objeto `DynamicFrame`. Sin embargo, en un pequeño número de casos, es posible que también contenga campos adicionales. Puede usar el método [Unnest](#glue-etl-scala-apis-glue-dynamicframe-class-defs-unnest) para "ajustar" el esquema en función de los registros de este objeto `DynamicFrame`.

## Def selectField
<a name="glue-etl-scala-apis-glue-dynamicframe-class-defs-selectField"></a>

```
def selectField( fieldName : String,
                 transformationContext : String = "",
                 callSite : CallSite = CallSite("Not provided", ""),
                 stageThreshold : Long = 0,
                 totalThreshold : Long = 0
               ) : DynamicFrame
```

Devuelve un campo individual como un objeto `DynamicFrame`.

## Def selectFields
<a name="glue-etl-scala-apis-glue-dynamicframe-class-defs-selectFields"></a>

```
def selectFields( paths : Seq[String],
                  transformationContext : String = "",
                  callSite : CallSite = CallSite("Not provided", ""),
                  stageThreshold : Long = 0,
                  totalThreshold : Long = 0
                ) : DynamicFrame
```
+ `paths`: secuencia de los nombres de columna que se seleccionarán.

Devuelve un nuevo objeto `DynamicFrame` que contiene las columnas especificadas.

**nota**  
Solo puede usar el método `selectFields` para seleccionar columnas de nivel superior. Puede usar el método [applyMapping](#glue-etl-scala-apis-glue-dynamicframe-class-defs-applyMapping) para seleccionar columnas anidadas.

## Def show
<a name="glue-etl-scala-apis-glue-dynamicframe-class-defs-show"></a>

```
def show( numRows : Int = 20 ) : Unit 
```
+ `numRows`: número de filas que se imprimirán.

Imprime filas de este objeto `DynamicFrame` en formato JSON.

## Def simplifyDDBJson
<a name="glue-etl-scala-apis-glue-dynamicframe-class-defs-simplifyDDBJson"></a>

Las exportaciones de DynamoDB con el conector de exportaciones de DynamoDB de AWS Glue generan archivos JSON con estructuras anidadas específicas. Para obtener más información, consulte [Objetos de datos](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/S3DataExport.Output.html). `simplifyDDBJson` Simplifica las columnas anidadas en un DynamicFrame de este tipo de datos y genera un DynamicFrame nuevo y simplificado. Si hay varios tipos y un tipo de mapa contenidos en tipo de lista, los elementos en la lista no se simplificarán. Este método solo es compatible con los datos exportados de DynamoDB con el formato JSON. Considere la acción de `unnest` para realizar cambios similares en otros tipos de datos.

```
def simplifyDDBJson() : DynamicFrame 
```

Este método no toma ningún parámetro.

**Ejemplo de entrada**

Considere el siguiente esquema generado por una exportación a DynamoDB:

```
root
|-- Item: struct
|    |-- parentMap: struct
|    |    |-- M: struct
|    |    |    |-- childMap: struct
|    |    |    |    |-- M: struct
|    |    |    |    |    |-- appName: struct
|    |    |    |    |    |    |-- S: string
|    |    |    |    |    |-- packageName: struct
|    |    |    |    |    |    |-- S: string
|    |    |    |    |    |-- updatedAt: struct
|    |    |    |    |    |    |-- N: string
|    |-- strings: struct
|    |    |-- SS: array
|    |    |    |-- element: string
|    |-- numbers: struct
|    |    |-- NS: array
|    |    |    |-- element: string
|    |-- binaries: struct
|    |    |-- BS: array
|    |    |    |-- element: string
|    |-- isDDBJson: struct
|    |    |-- BOOL: boolean
|    |-- nullValue: struct
|    |    |-- NULL: boolean
```

**Código de ejemplo**

```
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()
  }

}
```

### Ejemplo de resultado
<a name="simplifyDDBJson-example-output"></a>

La transformación de `simplifyDDBJson` simplificará esto de la siguiente forma:

```
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
<a name="glue-etl-scala-apis-glue-dynamicframe-class-defs-spigot"></a>

```
def spigot( path : String,
            options : JsonOptions = new JsonOptions("{}"),
            transformationContext : String = "",
            callSite : CallSite = CallSite("Not provided"),
            stageThreshold : Long = 0,
            totalThreshold : Long = 0
          ) : DynamicFrame
```

Transformación de paso a través que devuelve los mismos registros, pero escribe un subconjunto de registros como efecto secundario.
+ `path` — ruta de Amazon S3 en la que se escribirá la salida, con el formato `s3://bucket//path`.
+ `options`: mapa `JsonOptions` opcional que describe el comportamiento de muestreo.

Devuelve un objeto `DynamicFrame` que contiene los mismos registros que este.

De forma predeterminada, escribe 100 registros arbitrarios en la ubicación especificada por `path`. Puede personalizar este comportamiento mediante el mapa `options`. Entre las claves válidas se incluyen:
+ `topk`: especifica el número total de registros escritos. El valor predeterminado es 100.
+ `prob`: especifica la probabilidad de que se incluya un registro individual (como decimal). El valor predeterminado es 1.

Por ejemplo, la siguiente llamada realizaría un muestreo del conjunto de datos seleccionando cada registro con una probabilidad del 20 % y se detendría después de que se hubieran escrito 200 registros.

```
{{{
  df.spigot("s3://my_bucket/my_path", JsonOptions(Map("topk" -&gt; 200, "prob" -&gt; 0.2)))
}}}
```

## Def splitFields
<a name="glue-etl-scala-apis-glue-dynamicframe-class-defs-splitFields"></a>

```
def splitFields( paths : Seq[String],
                 transformationContext : String = "",
                 callSite : CallSite = CallSite("Not provided", ""),
                 stageThreshold : Long = 0,
                 totalThreshold : Long = 0
               ) : Seq[DynamicFrame]
```
+ `paths` — las rutas que se incluirán en el primer objeto `DynamicFrame`.

Devuelve una secuencia de dos objetos `DynamicFrame`. El primer `DynamicFrame` contiene las rutas especificadas y el segundo contiene las demás columnas.

**Ejemplo**

En este ejemplo, se toma un objeto DynamicFrame creado a partir de la tabla `persons` en la base de datos `legislators` de Data Catalog de AWS Glue y divide el DynamicFrame en dos, con los campos especificados incluidos en el primer DynamicFrame y los campos restantes incluidos en un segundo DynamicFrame. Luego, el ejemplo elige el primer DynamicFrame del resultado.

```
val InputFrame = glueContext.getCatalogSource(database="legislators", tableName="persons", 
transformationContext="InputFrame").getDynamicFrame()

val SplitField_collection = InputFrame.splitFields(paths=Seq("family_name", "name", "links.note", 
"links.url", "gender", "image", "identifiers.scheme", "identifiers.identifier", "other_names.lang", 
"other_names.note", "other_names.name"), transformationContext="SplitField_collection")

val ResultFrame = SplitField_collection(0)
```

## Def splitRows
<a name="glue-etl-scala-apis-glue-dynamicframe-class-defs-splitRows"></a>

```
def splitRows( paths : Seq[String],
               values : Seq[Any],
               operators : Seq[String],
               transformationContext : String,
               callSite : CallSite,
               stageThreshold : Long,
               totalThreshold : Long
             ) : Seq[DynamicFrame]
```

Divide las filas en función de predicados que comparan columnas con constantes.
+ `paths`: columnas que se van a utilizar para la comparación.
+ `values`: valores constantes que se van a utilizar para la comparación.
+ `operators`: operadores que se van a utilizar para la comparación.

Devuelve una secuencia de dos objetos `DynamicFrame`. El primero contiene filas en las que se aplica el predicado y el segundo contiene las que no se les aplica.

Los predicados se especifican usando tres secuencias: "`paths`" contiene los nombres de columna (posiblemente anidadas), "`values`" contiene los valores constantes con los que se realizará la comparación y "`operators`" contiene los operadores que se usarán para la comparación. Las tres secuencias deben tener la misma longitud: el operador que ocupa la posición `n` se usa para comparar la columna `n` con el valor `n`.

Cada operador debe ser uno de los siguientes: "`!=`", "`=`", "`<=`", "`<`", "`>=`" o "`>`".

A modo de ejemplo, la siguiente llamada dividiría un objeto `DynamicFrame` de modo que el primer marco de salida contuviera los registros de personas de más de 65 años de Estados Unidos y el segundo contuviera todos los demás registros.

```
{{{
  df.splitRows(Seq("age", "address.country"), Seq(65, "USA"), Seq("&gt;=", "="))
}}}
```

## Def stageErrorsCount
<a name="glue-etl-scala-apis-glue-dynamicframe-class-defs-stageErrorsCount"></a>

```
def stageErrorsCount
```

Devuelve el número de registros de error creado al calcular este objeto `DynamicFrame`. Se excluyen los errores de operaciones anteriores que se pasaron a este objeto `DynamicFrame` como entrada.

## Def toDF
<a name="glue-etl-scala-apis-glue-dynamicframe-class-defs-toDF"></a>

```
def toDF( specs : Seq[ResolveSpec] = Seq.empty[ResolveSpec] ) : DataFrame 
```

Convierte este `DynamicFrame` en un `DataFrame` Apache Spark SQL con el mismo esquema y registros.

**nota**  
Dado que los objetos `DataFrame` no admiten `ChoiceType`, este método convierte automáticamente las columnas `ChoiceType` en `StructType`. Para obtener más información y opciones para la resolución de elección, consulte [resolveChoice](#glue-etl-scala-apis-glue-dynamicframe-class-defs-resolveChoice).

## Def unbox
<a name="glue-etl-scala-apis-glue-dynamicframe-class-defs-unbox"></a>

```
def unbox( path : String,
           format : String,
           optionString : String = "{}",
           transformationContext : String = "",
           callSite : CallSite = CallSite("Not provided"),
           stageThreshold : Long = 0,
           totalThreshold : Long = 0
         ) : DynamicFrame
```
+ `path`: la columna que se va a analizar. Debe tener formato de cadena o binario.
+ `format`: el formato que se utilizará para el análisis.
+ `optionString`: opciones que se pasarán al formato, como el separador CSV.

Analiza una cadena insertada o una columna binaria de acuerdo con el formato especificado. Las columnas analizadas se anidan en una estructura con el nombre de columna original.

Por ejemplo, suponga que tiene un archivo CSV con una columna JSON insertada.

```
name, age, address
Sally, 36, {"state": "NE", "city": "Omaha"}
...
```

Después de un análisis inicial, obtendrá un objeto `DynamicFrame` con el siguiente esquema.

```
{{{
  root
  |-- name: string
  |-- age: int
  |-- address: string
}}}
```

Puede llamar a `unbox` en la columna de dirección para analizar los componentes específicos.

```
{{{
  df.unbox("address", "json")
}}}
```

Esto nos proporciona un objeto `DynamicFrame` con el siguiente esquema.

```
{{{
  root
  |-- name: string
  |-- age: int
  |-- address: struct
  |    |-- state: string
  |    |-- city: string
}}}
```

## Def unnest
<a name="glue-etl-scala-apis-glue-dynamicframe-class-defs-unnest"></a>

```
def unnest( transformationContext : String = "",
            callSite : CallSite = CallSite("Not Provided"),
            stageThreshold : Long = 0,
            totalThreshold : Long = 0
          ) : DynamicFrame
```

Devuelve un objeto `DynamicFrame` nuevo con todas las estructuras anidadas aplanadas. Los nombres se crean con el carácter "`.`" (punto).

Por ejemplo, suponga que tiene una instancia de `DynamicFrame` con el siguiente esquema.

```
{{{
  root
  |-- name: string
  |-- age: int
  |-- address: struct
  |    |-- state: string
  |    |-- city: string
}}}
```

La siguiente llamada elimina el anidamiento de la estructura de dirección:

```
{{{
  df.unnest()
}}}
```

El esquema resultante es el siguiente.

```
{{{
  root
  |-- name: string
  |-- age: int
  |-- address.state: string
  |-- address.city: string
}}}
```

Este método también aplana las estructuras anidadas de dentro de las matrices. Sin embargo, por razones históricas, los nombres de dichos campos tienen anexado previamente el nombre de la matriz contenedora y "`.val`".

## Def unnestDDBJson
<a name="glue-etl-scala-apis-glue-dynamicframe-class-defs-unnestddbjson"></a>

```
unnestDDBJson(transformationContext : String = "",
            callSite : CallSite = CallSite("Not Provided"),
            stageThreshold : Long = 0,
            totalThreshold : Long = 0): DynamicFrame
```

Desanida las columnas anidadas de un elemento `DynamicFrame` que se encuentren específicamente en la estructura JSON de DynamoDB y devuelve un nuevo elemento `DynamicFrame` no anidado. Las columnas que sean de una matriz de tipos de estructuras no se desanidarán. Tenga en cuenta que esta transformación de desanidamiento es un tipo específico que se comporta de modo diferente a la transformación `unnest` normal y requiere que los datos ya estén en la estructura JSON de DynamoDB. Para obtener más información, consulte [JSON de DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DataExport.Output.html#DataExport.Output.Data).

Por ejemplo, el esquema de una lectura de una exportación con la estructura JSON de DynamoDB puede parecerse al siguiente:

```
root
|-- Item: struct
|    |-- ColA: struct
|    |    |-- S: string
|    |-- ColB: struct
|    |    |-- S: string
|    |-- ColC: struct
|    |    |-- N: string
|    |-- ColD: struct
|    |    |-- L: array
|    |    |    |-- element: null
```

La transformación `unnestDDBJson()` convertiría esto en:

```
root
|-- ColA: string
|-- ColB: string
|-- ColC: string
|-- ColD: array    
|    |-- element: null
```

En el siguiente ejemplo de código, se muestra cómo utilizar el conector de exportación de DynamoDB de AWS Glue, invocar un desanidamiento JSON de DynamoDB e imprimir el número de particiones:

```
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" -> "<test_source>",
        "dynamodb.s3.bucket" -> "<bucket name>",
        "dynamodb.s3.prefix" -> "<bucket prefix>",
        "dynamodb.s3.bucketOwner" -> "<account_id of bucket>",
      ))
    ).getDynamicFrame()
    
    val unnested = dynamicFrame.unnestDDBJson()
    print(unnested.getNumPartitions())

    Job.commit()
  }

}
```

## Def withFrameSchema
<a name="glue-etl-scala-apis-glue-dynamicframe-class-defs-withFrameSchema"></a>

```
def withFrameSchema( getSchema : () => Schema ) : DynamicFrame 
```
+ `getSchema`: función que devuelve el esquema que se va a utilizar. Se especifica como una función sin parámetros para diferir el cómputo potencialmente costoso.

Establece el esquema de este objeto `DynamicFrame` en el valor especificado. Se utiliza principalmente de forma interna para evitar un nuevo y costoso cálculo de esquema. El esquema pasado debe contener todas las columnas presentes en los datos.

## Def withName
<a name="glue-etl-scala-apis-glue-dynamicframe-class-defs-withName"></a>

```
def withName( name : String ) : DynamicFrame 
```
+ `name`: nuevo nombre que se usará.

Devuelve una copia de este objeto `DynamicFrame` con un nuevo nombre.

## Def withTransformationContext
<a name="glue-etl-scala-apis-glue-dynamicframe-class-defs-withTransformationContext"></a>

```
def withTransformationContext( ctx : String ) : DynamicFrame 
```

Devuelve una copia de este objeto `DynamicFrame` con el contexto de transformación especificado.

# Objeto DynamicFrame
<a name="glue-etl-scala-apis-glue-dynamicframe-object"></a>

**Paquete: com.amazonaws.services.glue**

```
object DynamicFrame
```

## Def apply
<a name="glue-etl-scala-apis-glue-dynamicframe-object-defs-apply"></a>

```
def apply( df : DataFrame,
           glueContext : GlueContext
         ) : DynamicFrame
```



## def emptyDynamicFrame
<a name="glue-etl-scala-apis-glue-dynamicframe-object-defs-emptyDynamicFrame"></a>

```
def emptyDynamicFrame( glueContext : GlueContext ) : DynamicFrame 
```



## Def fromPythonRDD
<a name="glue-etl-scala-apis-glue-dynamicframe-object-defs-fromPythonRDD"></a>

```
def fromPythonRDD( rdd : JavaRDD[Array[Byte]],
                   glueContext : GlueContext
                 ) : DynamicFrame
```



## Def ignoreErrors
<a name="glue-etl-scala-apis-glue-dynamicframe-object-defs-ignoreErrors"></a>

```
def ignoreErrors( fn : DynamicRecord => DynamicRecord ) : DynamicRecord 
```



## Def inlineErrors
<a name="glue-etl-scala-apis-glue-dynamicframe-object-defs-inlineErrors"></a>

```
def inlineErrors( msg : String,
                  callSite : CallSite
                ) : (DynamicRecord => DynamicRecord)
```



## Def newFrameWithErrors
<a name="glue-etl-scala-apis-glue-dynamicframe-object-defs-newFrameWithErrors"></a>

```
def newFrameWithErrors( prevFrame : DynamicFrame,
                        rdd : RDD[DynamicRecord],
                        name : String = "",
                        transformationContext : String = "",
                        callSite : CallSite,
                        stageThreshold : Long,
                        totalThreshold : Long
                      ) : DynamicFrame
```



# Clase DynamicRecord Scala de AWS Glue
<a name="glue-etl-scala-apis-glue-dynamicrecord-class"></a>

**Topics**
+ [Def addField](#glue-etl-scala-apis-glue-dynamicrecord-class-defs-addField)
+ [Def dropField](#glue-etl-scala-apis-glue-dynamicrecord-class-defs-dropField)
+ [Def setError](#glue-etl-scala-apis-glue-dynamicrecord-class-defs-setError)
+ [Def isError](#glue-etl-scala-apis-glue-dynamicrecord-class-defs-isError)
+ [Def getError](#glue-etl-scala-apis-glue-dynamicrecord-class-defs-getError)
+ [Def clearError](#glue-etl-scala-apis-glue-dynamicrecord-class-defs-clearError)
+ [Def write](#glue-etl-scala-apis-glue-dynamicrecord-class-defs-write)
+ [Def readFields](#glue-etl-scala-apis-glue-dynamicrecord-class-defs-readFields)
+ [Def clone](#glue-etl-scala-apis-glue-dynamicrecord-class-defs-clone)
+ [Def schema](#glue-etl-scala-apis-glue-dynamicrecord-class-defs-schema)
+ [Def getRoot](#glue-etl-scala-apis-glue-dynamicrecord-class-defs-getRoot)
+ [Def toJson](#glue-etl-scala-apis-glue-dynamicrecord-class-defs-toJson)
+ [Def getFieldNode](#glue-etl-scala-apis-glue-dynamicrecord-class-defs-getFieldNode)
+ [Def getField](#glue-etl-scala-apis-glue-dynamicrecord-class-defs-getField)
+ [Def hashCode](#glue-etl-scala-apis-glue-dynamicrecord-class-defs-hashCode)
+ [Def equals](#glue-etl-scala-apis-glue-dynamicrecord-class-defs-equals)
+ [Objeto DynamicRecord](#glue-etl-scala-apis-glue-dynamicrecord-object)
+ [Característica RecordTraverser](#glue-etl-scala-apis-glue-recordtraverser-trait)

**Paquete: com.amazonaws.services.glue**

```
class DynamicRecord extends Serializable with Writable with Cloneable
```

Un objeto `DynamicRecord` es una estructura de datos autodescriptiva que representa una fila de datos en el conjunto de datos que se está procesando. Es autodescriptiva en el sentido de que se puede obtener el esquema de la fila representado mediante el objeto `DynamicRecord` si se inspecciona el registro. Un objeto `DynamicRecord` es similar a `Row` en Apache Spark.

## Def addField
<a name="glue-etl-scala-apis-glue-dynamicrecord-class-defs-addField"></a>

```
def addField( path : String,
              dynamicNode : DynamicNode
            ) : Unit
```

Agrega un objeto [DynamicNode](glue-etl-scala-apis-glue-types-dynamicnode.md) a la ruta especificada.
+ `path`: ruta del campo que se va a agregar.
+ `dynamicNode`: [DynamicNode](glue-etl-scala-apis-glue-types-dynamicnode.md) que se agregará a la ruta especificada.

## Def dropField
<a name="glue-etl-scala-apis-glue-dynamicrecord-class-defs-dropField"></a>

```
 def dropField(path: String, underRename: Boolean = false): Option[DynamicNode]
```

Descarta un objeto [DynamicNode](glue-etl-scala-apis-glue-types-dynamicnode.md) de la ruta especifica y devuelve el nodo descartado si no hay una matriz en la ruta especificada.
+ `path`: ruta al campo que se descartará.
+ `underRename`: true si se llama a `dropField` como parte de una transformación de cambio de nombre; de lo contrario, false (false de forma predeterminada).

Devuelve `scala.Option Option` ([DynamicNode](glue-etl-scala-apis-glue-types-dynamicnode.md)).

## Def setError
<a name="glue-etl-scala-apis-glue-dynamicrecord-class-defs-setError"></a>

```
def setError( error : Error )
```

Establece este registro como un registro de error, tal y como se especifica mediante el parámetro `error`.

Devuelve `DynamicRecord`.

## Def isError
<a name="glue-etl-scala-apis-glue-dynamicrecord-class-defs-isError"></a>

```
def isError
```

Comprueba si es un registro de error.

## Def getError
<a name="glue-etl-scala-apis-glue-dynamicrecord-class-defs-getError"></a>

```
def getError
```

Obtiene el `Error` si es un registro de error. Devuelve `scala.Some Some` (Error) si es un registro de error; de lo contrario, `scala.None`.

## Def clearError
<a name="glue-etl-scala-apis-glue-dynamicrecord-class-defs-clearError"></a>

```
def clearError
```

Configure el `Error` en `scala.None.None`.

## Def write
<a name="glue-etl-scala-apis-glue-dynamicrecord-class-defs-write"></a>

```
override def write( out : DataOutput ) : Unit 
```



## Def readFields
<a name="glue-etl-scala-apis-glue-dynamicrecord-class-defs-readFields"></a>

```
override def readFields( in : DataInput ) : Unit 
```



## Def clone
<a name="glue-etl-scala-apis-glue-dynamicrecord-class-defs-clone"></a>

```
override def clone : DynamicRecord 
```

Clona este registro en un nuevo objeto `DynamicRecord` y lo devuelve.

## Def schema
<a name="glue-etl-scala-apis-glue-dynamicrecord-class-defs-schema"></a>

```
def schema
```

Obtiene el objeto `Schema` mediante la inspección del registro.

## Def getRoot
<a name="glue-etl-scala-apis-glue-dynamicrecord-class-defs-getRoot"></a>

```
def getRoot : ObjectNode 
```

Obtiene el objeto `ObjectNode` raíz del registro.

## Def toJson
<a name="glue-etl-scala-apis-glue-dynamicrecord-class-defs-toJson"></a>

```
def toJson : String 
```

Obtiene la cadena JSON del registro.

## Def getFieldNode
<a name="glue-etl-scala-apis-glue-dynamicrecord-class-defs-getFieldNode"></a>

```
def getFieldNode( path : String ) : Option[DynamicNode] 
```

Obtiene el valor del campo en la `path` especificada como una opción de `DynamicNode`.

Devuelve `scala.Some Some` ([DynamicNode](glue-etl-scala-apis-glue-types-dynamicnode.md)) si el campo existe; de lo contrario, `scala.None.None`.

## Def getField
<a name="glue-etl-scala-apis-glue-dynamicrecord-class-defs-getField"></a>

```
def getField( path : String ) : Option[Any] 
```

Obtiene el valor del campo en la `path` especificada como una opción de `DynamicNode`.

Devuelve `scala.Some Some` (valor).

## Def hashCode
<a name="glue-etl-scala-apis-glue-dynamicrecord-class-defs-hashCode"></a>

```
override def hashCode : Int 
```



## Def equals
<a name="glue-etl-scala-apis-glue-dynamicrecord-class-defs-equals"></a>

```
override def equals( other : Any )
```



## Objeto DynamicRecord
<a name="glue-etl-scala-apis-glue-dynamicrecord-object"></a>

```
object DynamicRecord
```

### Def apply
<a name="glue-etl-scala-apis-glue-dynamicrecord-object-defs-apply"></a>

```
def apply( row : Row,
           schema : SparkStructType )
```

Aplique el método para convertir un objeto `Row` de Apache Spark SQL en un objeto [DynamicRecord](#glue-etl-scala-apis-glue-dynamicrecord-class).
+ `row` — un objeto de Spark SQL `Row`.
+ `schema`: el objeto `Schema` de la fila.

Devuelve `DynamicRecord`.

## Característica RecordTraverser
<a name="glue-etl-scala-apis-glue-recordtraverser-trait"></a>

```
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 GlueAPI GlueContext Scala de
<a name="glue-etl-scala-apis-glue-gluecontext"></a>

**Paquete: com.amazonaws.services.glue**

```
class GlueContext extends SQLContext(sc) (
           @transient val sc : SparkContext,
           val defaultSourcePartitioner : PartitioningStrategy )
```

`GlueContext` es el punto de entrada para leer y escribir un [DynamicFrame](glue-etl-scala-apis-glue-dynamicframe.md) desde y hacia Amazon Simple Storage Service (Amazon S3), el AWS Glue Data Catalog, JDBC, etc. Esta clase ofrece funciones de utilidades para crear objetos [Característica DataSource](glue-etl-scala-apis-glue-datasource-trait.md) y [DataSink](glue-etl-scala-apis-glue-datasink-class.md) que, a su vez, se pueden usar para leer y escribir objetos `DynamicFrame`.

También se puede utilizar `GlueContext` para establecer un número de particiones de destino (el valor predeterminado es 20) en el objeto `DynamicFrame` si el número de particiones creadas desde el origen es menor que un umbral mínimo para las particiones (el valor predeterminado es 10).

## def addIngestionTimeColumns
<a name="glue-etl-scala-apis-glue-gluecontext-defs-addIngestionTimeColumns"></a>

```
def addIngestionTimeColumns(
         df : DataFrame, 
         timeGranularity : String = "") : dataFrame
```

Agrega columnas de tiempo de ingesta como `ingest_year`, `ingest_month`, `ingest_day`, `ingest_hour`, `ingest_minute` al `DataFrame` de entrada. Esta función se genera en forma automática en el script generado por AWS Glue cuando especifique una tabla del Catálogo de datos con Amazon S3 como destino. Esta función actualiza en forma automática la partición con columnas de tiempo de ingesta en la tabla de salida. Esto permite que los datos de salida se dividan automáticamente en el tiempo de ingesta sin requerir columnas de tiempo de ingesta explícitas en los datos de entrada.
+ `dataFrame`: el `dataFrame` al que anexar las columnas de tiempo de ingesta.
+ `timeGranularity`: la granularidad de las columnas de tiempo. Los valores válidos son “`day`”, “`hour`” y “`minute`”. Por ejemplo, si “`hour`” se transfiere a la función, el `dataFrame` original tendrá las columnas de tiempo “`ingest_year`,” “`ingest_month`,” “`ingest_day`” y “`ingest_hour`” anexadas.

Devuelve el marco de datos después de anexar las columnas de granularidad de tiempo.

Ejemplo:

```
glueContext.addIngestionTimeColumns(dataFrame, "hour")
```

## def createDataFrameFromOptions
<a name="glue-etl-scala-apis-glue-gluecontext-defs-createDataFrameFromOptions"></a>

```
def createDataFrameFromOptions( connectionType : String,
                         connectionOptions : JsonOptions,
                         transformationContext : String = "",
                         format : String = null,
                         formatOptions : JsonOptions = JsonOptions.empty
                       ) : DataSource
```

Muestra un `DataFrame` que se crea con la conexión y el formato especificados. Utilice esta función sólo con orígenes de streaming de AWS Glue.
+ `connectionType`: el tipo de conexión de streaming. Los valores válidos son `kinesis` y `kafka`.
+ `connectionOptions`: opciones de conexión, que son diferentes para Kinesis y Kafka. Puede encontrar la lista de todas las opciones de conexión para cada origen de datos de streaming en [Tipos de conexión y opciones para ETL en AWS Glue para Spark](aws-glue-programming-etl-connect.md). Tenga en cuenta las siguientes diferencias en las opciones de conexión de streaming:
  + Los orígenes de streaming de Kinesis requieren `streamARN`, `startingPosition`, `inferSchema` y `classification`.
  + Los orígenes de streaming de Kafka requieren `connectionName`, `topicName`, `startingOffsets`, `inferSchema` y `classification`.
+ `transformationContext`: el contexto de transformación que se va a utilizar (opcional).
+ `format`: una especificación de formato (opcional). Se utiliza con una conexión de Amazon S3 o AWS Glue que admite diversos formatos. Para obtener información acerca de los formatos soportados, consulte [Opciones de formato de datos para las entradas y las salidas en AWS Glue para Spark](aws-glue-programming-etl-format.md)
+ `formatOptions`: opciones de formato para el formato especificado. Para obtener información acerca de las opciones de formatos soportados, consulte [Opciones de formato de datos](aws-glue-programming-etl-format.md).

Ejemplo de origen de streaming de Amazon Kinesis:

```
val data_frame_datasource0 = 
glueContext.createDataFrameFromOptions(transformationContext = "datasource0", connectionType = "kinesis", 
connectionOptions = JsonOptions("""{"streamName": "example_stream", "startingPosition": "TRIM_HORIZON", "inferSchema": "true", "classification": "json"}}"""))
```

Ejemplo de origen de streaming de 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
<a name="glue-etl-scala-apis-glue-gluecontext-defs-forEachBatch"></a>

**`forEachBatch(frame, batch_function, options)`**

Se aplica la `batch_function` transferida a cada microlote que se lee desde el origen de streaming.
+ `frame`: el DataFrame que contiene el microlote actual.
+ `batch_function`: una función que se aplicará para cada microlote.
+ `options`: una recopilación de pares clave-valor que contiene información sobre cómo procesar microlotes. Se requieren las siguientes opciones:
  + `windowSize`: cantidad de tiempo que se debe dedicar al procesamiento de cada lote.
  + `checkpointLocation`: la ubicación donde se almacenan los puntos de verificación para el trabajo de ETL de streaming.
  + `batchMaxRetries`: número máximo de reintentos permitidos para este lote si se genera un error. El valor predeterminado es 3. Esta opción sólo se puede configurar para Glue versión 2.0 y superior.

**Ejemplo:**

```
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
<a name="glue-etl-scala-apis-glue-gluecontext-defs-getCatalogSink"></a>

```
def getCatalogSink( database : String,
        tableName : String,
        redshiftTmpDir : String = "",
        transformationContext : String = ""
        additionalOptions: JsonOptions = JsonOptions.empty,
        catalogId: String = null   
) : DataSink
```

Crea un [DataSink](glue-etl-scala-apis-glue-datasink-class.md) que escribe en una ubicación especificada en una tabla definida en el Data Catalog.
+ `database`: nombre de la base de datos en el Data Catalog.
+ `tableName`: nombre de la tabla en el Data Catalog.
+ `redshiftTmpDir`: directorio provisional que se usará con determinados receptores de datos. Se establece en un valor vacío de forma predeterminada.
+ `transformationContext`: contexto de transformación asociado con el receptor que utilizarán los marcadores de trabajo. Se establece en un valor vacío de forma predeterminada.
+ `additionalOptions` – opciones adicionales para AWS Glue. 
+ `catalogId`: ID de catálogo (ID de cuenta) del Data Catalog al que se accede. Cuando el valor es nulo, se utiliza el ID de cuenta predeterminado del intermediario. 

Devuelve el `DataSink`.

## def getCatalogSource
<a name="glue-etl-scala-apis-glue-gluecontext-defs-getCatalogSource"></a>

```
def getCatalogSource( database : String,
                      tableName : String,
                      redshiftTmpDir : String = "",
                      transformationContext : String = ""
                      pushDownPredicate : String = " "
                      additionalOptions: JsonOptions = JsonOptions.empty,
                      catalogId: String = null
                    ) : DataSource
```

Crea un objeto [Característica DataSource](glue-etl-scala-apis-glue-datasource-trait.md) que lee datos de una definición de tabla en el Data Catalog.
+ `database`: nombre de la base de datos en el Data Catalog.
+ `tableName`: nombre de la tabla en el Data Catalog.
+ `redshiftTmpDir`: directorio provisional que se usará con determinados receptores de datos. Se establece en un valor vacío de forma predeterminada.
+ `transformationContext`: contexto de transformación asociado con el receptor que utilizarán los marcadores de trabajo. Se establece en un valor vacío de forma predeterminada.
+ `pushDownPredicate`: filtra particiones sin tener que enumerar y leer todos los archivos del conjunto de datos. Para obtener más información, consulte [Filtrado previo con predicados de inserción](aws-glue-programming-etl-partitions.md#aws-glue-programming-etl-partitions-pushdowns).
+ `additionalOptions`: conjunto de pares nombre-valor opcionales. Las opciones posibles incluyen las enumeradas en [Tipos de conexión y opciones para ETL en AWS Glue para Spark](aws-glue-programming-etl-connect.md), excepto por `endpointUrl`, `streamName`, `bootstrap.servers`, `security.protocol`, `topicName`, `classification` y `delimiter`. Otra opción soportada es `catalogPartitionPredicate`:

  `catalogPartitionPredicate`: puede transferir una expresión de catálogo para filtrar en función de las columnas de índice. Esto inserta el filtrado hacia el lado del servidor. Para obtener más información, consulte [Índices de partición de AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/partition-indexes.html). Tenga en cuenta que `push_down_predicate` y `catalogPartitionPredicate` utilizan sintaxis diferentes. El primero utiliza la sintaxis estándar de Spark SQL y el segundo utiliza el analizador JSQL.
+ `catalogId`: ID de catálogo (ID de cuenta) del Data Catalog al que se accede. Cuando el valor es nulo, se utiliza el ID de cuenta predeterminado del intermediario. 

Devuelve el `DataSource`.

**Ejemplo de origen 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 getJDBCSink
<a name="glue-etl-scala-apis-glue-gluecontext-defs-getJDBCSink"></a>

```
def getJDBCSink( catalogConnection : String,
                 options : JsonOptions,
                 redshiftTmpDir : String = "",
                 transformationContext : String = "",
                 catalogId: String = null
               ) : DataSink
```

Crea un [DataSink](glue-etl-scala-apis-glue-datasink-class.md) que escribe en una base de datos JDBC especificada en un objeto `Connection` en el Data Catalog. El objeto `Connection` tiene información para conectarse a un receptor de JDBC, incluida la URL, el nombre de usuario, la contraseña, la VPC, la subred y los grupos de seguridad.
+ `catalogConnection`: nombre de la conexión en el Data Catalog que contiene la URL de JDBC en la que se va a escribir.
+ `options`: cadena de pares de nombre-valor de JSON que proporcionan información adicional que se exige para escribir en un almacén de datos JDBC. Esto incluye: 
  + *dbtable* (obligatorio): nombre de la tabla de JDBC. Para almacenes de datos de JDBC que admiten esquemas dentro de una base de datos, especifique `schema.table-name`. Si no se ha proporcionado un esquema, se usa el esquema “public” predeterminado. El siguiente ejemplo muestra un parámetro de opciones que apunta a un esquema llamado `test` y a una tabla llamada `test_table` en la base de datos `test_db`.

    ```
    options = JsonOptions("""{"dbtable": "test.test_table", "database": "test_db"}""")
    ```
  + *database* (obligatorio): nombre de la base de datos de JDBC.
  + Todas las opciones adicionales transferidas directamente al escritor SparkSQL de JDBC. Para obtener más información, consulte el artículo acerca del [origen de datos Redshift de Spark](https://github.com/databricks/spark-redshift).
+ `redshiftTmpDir`: directorio provisional que se usará con determinados receptores de datos. Se establece en un valor vacío de forma predeterminada.
+ `transformationContext`: contexto de transformación asociado con el receptor que utilizarán los marcadores de trabajo. Se establece en un valor vacío de forma predeterminada.
+ `catalogId`: ID de catálogo (ID de cuenta) del Data Catalog al que se accede. Cuando el valor es nulo, se utiliza el ID de cuenta predeterminado del intermediario. 

Código de ejemplo:

```
getJDBCSink(catalogConnection = "my-connection-name", options = JsonOptions("""{"dbtable": "my-jdbc-table", "database": "my-jdbc-db"}"""), redshiftTmpDir = "", transformationContext = "datasink4")
```

Devuelve el `DataSink`.

## def getSink
<a name="glue-etl-scala-apis-glue-gluecontext-defs-getSink"></a>

```
def getSink( connectionType : String,
             connectionOptions : JsonOptions,
             transformationContext : String = ""
           ) : DataSink
```

Crea una [DataSink](glue-etl-scala-apis-glue-datasink-class.md) que escribe datos a destinos tales como Amazon Simple Storage Service (Amazon S3), JDBC, el Catálogo de datos de AWS Glue o los flujos de datos de Apache Kafka o de Amazon Kinesis. 
+ `connectionType` — Tipo de la conexión. Consulte [Tipos de conexión y opciones para ETL en AWS Glue para Spark](aws-glue-programming-etl-connect.md).
+ `connectionOptions`: una cadena de pares de nombre-valor de JSON que proporcionan información adicional para establecer la conexión con el receptor de datos. Consulte [Tipos de conexión y opciones para ETL en AWS Glue para Spark](aws-glue-programming-etl-connect.md).
+ `transformationContext`: contexto de transformación asociado con el receptor que utilizarán los marcadores de trabajo. Se establece en un valor vacío de forma predeterminada.

Devuelve el `DataSink`.

## def getSinkWithFormat
<a name="glue-etl-scala-apis-glue-gluecontext-defs-getSinkWithFormat"></a>

```
def getSinkWithFormat( connectionType : String,
                       options : JsonOptions,
                       transformationContext : String = "",
                       format : String = null,
                       formatOptions : JsonOptions = JsonOptions.empty
                     ) : DataSink
```

Crea una [DataSink](glue-etl-scala-apis-glue-datasink-class.md) que escribe datos a destinos tales como Amazon S3, JDBC o el Catálogo de datos o los flujos de datos de Apache Kafka o de Amazon Kinesis. También establece el formato de los datos que se escribirán en el destino.
+ `connectionType` — Tipo de la conexión. Consulte [Tipos de conexión y opciones para ETL en AWS Glue para Spark](aws-glue-programming-etl-connect.md).
+ `options`: cadena de pares de nombre-valor de JSON que proporcionan información adicional para establecer una conexión con el receptor de datos. Consulte [Tipos de conexión y opciones para ETL en AWS Glue para Spark](aws-glue-programming-etl-connect.md).
+ `transformationContext`: contexto de transformación asociado con el receptor que utilizarán los marcadores de trabajo. Se establece en un valor vacío de forma predeterminada.
+ `format`: formato de los datos que se escribirán en el destino.
+ `formatOptions`: una cadena de pares de nombre-valor de JSON que proporcionan opciones adicionales para el formato de los datos en el destino. Consulte [Opciones de formato de datos](aws-glue-programming-etl-format.md).

Devuelve el `DataSink`.

## def getSource
<a name="glue-etl-scala-apis-glue-gluecontext-defs-getSource"></a>

```
def getSource( connectionType : String,
               connectionOptions : JsonOptions,
               transformationContext : String = ""
               pushDownPredicate
             ) : DataSource
```

Crea una [Característica DataSource](glue-etl-scala-apis-glue-datasource-trait.md) que lee datos de un origen como Amazon S3, JDBC o AWS Glue Data Catalog. También soporta orígenes de datos de streaming de Kafka y Kinesis.
+ `connectionType`: tipo de origen de datos. Consulte [Tipos de conexión y opciones para ETL en AWS Glue para Spark](aws-glue-programming-etl-connect.md).
+ `connectionOptions`: una cadena de pares de nombre-valor de JSON que proporcionan información adicional para establecer una conexión con el origen de datos. Para obtener más información, consulte [Tipos de conexión y opciones para ETL en AWS Glue para Spark](aws-glue-programming-etl-connect.md).

  Un origen de streaming de Kinesis requiere las siguientes opciones de conexión: `streamARN`, `startingPosition`, `inferSchema` y `classification`.

  Un origen de streaming de Kafka requiere las siguientes opciones de conexión: `connectionName`, `topicName`, `startingOffsets`, `inferSchema` y `classification`.
+ `transformationContext`: contexto de transformación asociado con el receptor que utilizarán los marcadores de trabajo. Se establece en un valor vacío de forma predeterminada.
+ `pushDownPredicate`: predicado en columnas de partición.

Devuelve el `DataSource`.

Ejemplo de origen de streaming de 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)
}
```

Ejemplo de origen de streaming de Kafka:

```
val kafkaOptions = jsonOptions()
val data_frame_datasource0 = glueContext.getSource("kafka", kafkaOptions).getDataFrame()

private def jsonOptions(): JsonOptions = {
    new JsonOptions(
      s"""{"connectionName": "ConfluentKafka",
         |"topicName": "kafka-auth-topic",
         |"startingOffsets": "earliest",
         |"inferSchema": "true",
         |"classification": "json"}""".stripMargin)
 }
```

## def getSourceWithFormat
<a name="glue-etl-scala-apis-glue-gluecontext-defs-getSourceWithFormat"></a>

```
def getSourceWithFormat( connectionType : String,
                         options : JsonOptions,
                         transformationContext : String = "",
                         format : String = null,
                         formatOptions : JsonOptions = JsonOptions.empty
                       ) : DataSource
```

Crea una [Característica DataSource](glue-etl-scala-apis-glue-datasource-trait.md) que lee datos de un origen como Amazon S3, JDBC o AWS Glue Data Catalog y también establece el formato de los datos almacenados en el origen.
+ `connectionType`: tipo de origen de datos. Consulte [Tipos de conexión y opciones para ETL en AWS Glue para Spark](aws-glue-programming-etl-connect.md).
+ `options`: una cadena de pares de nombre-valor de JSON que proporciona información adicional para establecer una conexión con el origen de datos. Consulte [Tipos de conexión y opciones para ETL en AWS Glue para Spark](aws-glue-programming-etl-connect.md).
+ `transformationContext`: contexto de transformación asociado con el receptor que utilizarán los marcadores de flujo de trabajo. Se establece en un valor vacío de forma predeterminada.
+ `format`: formato de los datos que se almacenan en el origen. Cuando el `connectionType` es "s3", también puede especificar `format`. Puede ser "avro", "csv", "grokLog", "ion", "json", "xml", "parquet" u "orco". 
+ `formatOptions`: una cadena de pares de nombre-valor de JSON que proporciona opciones adicionales para analizar los datos en el origen. Consulte [Opciones de formato de datos](aws-glue-programming-etl-format.md).

Devuelve el `DataSource`.

**Ejemplos**

Cree un DynamicFrame a partir de un origen de datos que sea un archivo de valores separados por comas (CSV) en 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()
```

Cree un DynamicFrame a partir de un origen de datos que es un PostgreSQL mediante una conexión 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()
```

Cree un DynamicFrame a partir de un origen de datos que es un MySQL usando una conexión 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
<a name="glue-etl-scala-apis-glue-gluecontext-defs-getSparkSession"></a>

```
def getSparkSession : SparkSession 
```

Obtiene el objeto `SparkSession` asociado a este GlueContext. Utilice este objeto SparkSession para registrar tablas y UDF con el fin de usarlas con el objeto `DataFrame` creado a partir de los objetos DynamicFrame.

Devuelve el objeto SparkSession.

## Definición de startTransaction (iniciar transacción)
<a name="glue-etl-scala-apis-glue-gluecontext-defs-start-transaction"></a>

```
def startTransaction(readOnly: Boolean):String
```

Inicia una nueva transacción. Llama de forma interna a la API [startTransaction](https://docs.aws.amazon.com/lake-formation/latest/dg/aws-lake-formation-api-aws-lake-formation-api-transactions.html#aws-lake-formation-api-aws-lake-formation-api-transactions-StartTransaction) de Lake Formation.
+ `readOnly`: (booleano) indica si esta transacción debe ser de solo lectura o de lectura y escritura. Se rechazarán las escrituras realizadas con un ID de transacción de solo lectura. No es necesario confirmar las transacciones de solo lectura.

Devuelve el ID de la transacción.

## Definición de commitTransaction (confirmar transacción)
<a name="glue-etl-scala-apis-glue-gluecontext-defs-commit-transaction"></a>

```
def commitTransaction(transactionId: String, waitForCommit: Boolean): Boolean
```

Intenta confirmar la transacción especificada. Es posible que se devuelva `commitTransaction` antes de que la transacción haya terminado de confirmarse. Llama de forma interna a la API [commitTransaction](https://docs.aws.amazon.com/lake-formation/latest/dg/aws-lake-formation-api-aws-lake-formation-api-transactions.html#aws-lake-formation-api-aws-lake-formation-api-transactions-CommitTransaction) de Lake Formation.
+ `transactionId`: (cadena) la transacción que se confirmará.
+ `waitForCommit`: (booleano) determina si se devuelve `commitTransaction` de inmediato. El valor predeterminado es true. Si es falso, `commitTransaction` realiza un sondeo y espera hasta que la transacción se haya confirmado. La cantidad de tiempo de espera se limita a un minuto mediante retroceso exponencial con un máximo de seis reintentos.

Devuelve un valor booleano para indicar si se realizó o no la confirmación. 

## Definición de cancelTransaction (cancelar transacción)
<a name="glue-etl-scala-apis-glue-gluecontext-defs-cancel-transaction"></a>

```
def cancelTransaction(transactionId: String): Unit
```

Intenta cancelar la transacción especificada. Llama de forma interna a la API [CancelTransaction](https://docs.aws.amazon.com/lake-formation/latest/dg/aws-lake-formation-api-aws-lake-formation-api-transactions.html#aws-lake-formation-api-aws-lake-formation-api-transactions-CancelTransaction) de Lake Formation.
+ `transactionId`: (cadena) la transacción que se cancelará.

Devuelve una excepción de `TransactionCommittedException` si la transacción se había confirmado con anterioridad.

## def this
<a name="glue-etl-scala-apis-glue-gluecontext-defs-this-1"></a>

```
def this( sc : SparkContext,
          minPartitions : Int,
          targetPartitions : Int )
```

Crea un objeto `GlueContext` con el objeto `SparkContext` especificado, particiones mínimas y particiones de destino.
+ `sc` — la `SparkContext`.
+ `minPartitions`: número mínimo de particiones.
+ `targetPartitions`: número de particiones de destino.

Devuelve el `GlueContext`.

## def this
<a name="glue-etl-scala-apis-glue-gluecontext-defs-this-2"></a>

```
def this( sc : SparkContext )
```

Crear un objeto `GlueContext` con el `SparkContext` proporcionado. Establece las particiones mínimas en 10 y las particiones de destino en 20.
+ `sc` — la `SparkContext`.

Devuelve el `GlueContext`.

## def this
<a name="glue-etl-scala-apis-glue-gluecontext-defs-this-3"></a>

```
def this( sparkContext : JavaSparkContext )
```

Crear un objeto `GlueContext` con el `JavaSparkContext` proporcionado. Establece las particiones mínimas en 10 y las particiones de destino en 20.
+ `sparkContext` — la `JavaSparkContext`.

Devuelve el `GlueContext`.

# MappingSpec
<a name="glue-etl-scala-apis-glue-mappingspec"></a>

**Paquete: com.amazonaws.services.glue**

## Case class MappingSpec
<a name="glue-etl-scala-apis-glue-mappingspec-case-class"></a>

```
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` del campo de origen.
+ `sourceType`: `DataType` del campo de origen.
+ `targetPath`: `SchemaPath` del campo de destino.
+ `targetType`: `DataType` del campo de destino.

Un objeto `MappingSpec` especifica un mapeo desde una ruta y un tipo de datos de origen a una ruta y un tipo de datos de destino. El valor en la ruta de origen en el marco de origen aparece en el marco de destino en la ruta de destino. El tipo de datos de origen se convierte al de destino.

Se extiende desde `Product4` para que usted pueda gestionar todos los `Product4` de su interfaz `applyMapping`.

## Objeto MappingSpec
<a name="glue-etl-scala-apis-glue-mappingspec-object"></a>

```
object MappingSpec
```

El objeto `MappingSpec` tiene los siguientes miembros:

## Val orderingByTarget
<a name="glue-etl-scala-apis-glue-mappingspec-object-val-orderingbytarget"></a>

```
val orderingByTarget: Ordering[MappingSpec]
```



## Def apply
<a name="glue-etl-scala-apis-glue-mappingspec-object-defs-apply-1"></a>

```
def apply( sourcePath : String,
           sourceType : DataType,
           targetPath : String,
           targetType : DataType
         ) : MappingSpec
```

Crea un `MappingSpec`.
+ `sourcePath`: representación de cadena de la ruta de origen.
+ `sourceType` — el objeto de origen `DataType`.
+ `targetPath`: representación de cadena de la ruta de destino.
+ `targetType` — el objeto de destino `DataType`.

Devuelve `MappingSpec`.

## Def apply
<a name="glue-etl-scala-apis-glue-mappingspec-object-defs-apply-2"></a>

```
def apply( sourcePath : String,
           sourceTypeString : String,
           targetPath : String,
           targetTypeString : String
         ) : MappingSpec
```

Crea un `MappingSpec`.
+ `sourcePath`: representación de cadena de la ruta de origen.
+ `sourceType`: representación de cadena del tipo de datos de origen.
+ `targetPath`: representación de cadena de la ruta de destino.
+ `targetType`: representación de cadena del tipo de datos de destino.

Devuelve un objeto MappingSpec.

## Def apply
<a name="glue-etl-scala-apis-glue-mappingspec-object-defs-apply-3"></a>

```
def apply( product : Product4[String, String, String, String] ) : MappingSpec 
```

Crea un `MappingSpec`.
+ `product`: el elemento `Product4` de la ruta de origen, el tipo de datos de origen, la ruta de destino y el tipo de datos de destino.

Devuelve `MappingSpec`.

# AWS GlueAPI ResolveSpec Scala de
<a name="glue-etl-scala-apis-glue-resolvespec"></a>

**Topics**
+ [Objeto ResolveSpec](#glue-etl-scala-apis-glue-resolvespec-object)
+ [Case class ResolveSpec](#glue-etl-scala-apis-glue-resolvespec-case-class)

**Paquete: com.amazonaws.services.glue**

## Objeto ResolveSpec
<a name="glue-etl-scala-apis-glue-resolvespec-object"></a>

 **ResolveSpec**

```
object ResolveSpec
```

### Def
<a name="glue-etl-scala-apis-glue-resolvespec-object-def-apply_1"></a>

```
def apply( path : String,
           action : String
         ) : ResolveSpec
```

Crea un `ResolveSpec`.
+ `path`: representación de cadena del campo de elección que se debe resolver.
+ `action`: acción de resolución. La acción puede ser una de las siguientes: `Project`, `KeepAsStruct` o `Cast`.

Devuelve el `ResolveSpec`.

### Def
<a name="glue-etl-scala-apis-glue-resolvespec-object-def-apply_2"></a>

```
def apply( product : Product2[String, String] ) : ResolveSpec 
```

Crea un `ResolveSpec`.
+ `product`: `Product2` de: ruta de origen, acción de resolución.

Devuelve el `ResolveSpec`.

## Case class ResolveSpec
<a name="glue-etl-scala-apis-glue-resolvespec-case-class"></a>

```
case class ResolveSpec extends Product2[String, String]  (
           path : SchemaPath,
           action : String )
```

Crea un `ResolveSpec`.
+ `path`: `SchemaPath` del campo de elección que se debe resolver.
+ `action`: acción de resolución. La acción puede ser una de las siguientes: `Project`, `KeepAsStruct` o `Cast`.

### Métodos def de ResolveSpec
<a name="glue-etl-scala-apis-glue-resolvespec-case-class-defs"></a>

```
def _1 : String 
```

```
def _2 : String 
```

# AWS GlueAPI ArrayNode Scala de
<a name="glue-etl-scala-apis-glue-types-arraynode"></a>

**Paquete: com.amazonaws.services.glue.types**

## Case class ArrayNode
<a name="glue-etl-scala-apis-glue-types-arraynode-case-class"></a>

 **ArrayNode**

```
case class ArrayNode extends DynamicNode  (
           value : ArrayBuffer[DynamicNode] )
```

### Métodos def de ArrayNode
<a name="glue-etl-scala-apis-glue-types-arraynode-case-class-defs"></a>

```
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 GlueAPI BinaryNode Scala de
<a name="glue-etl-scala-apis-glue-types-binarynode"></a>

**Paquete: com.amazonaws.services.glue.types**

## Case class BinaryNode
<a name="glue-etl-scala-apis-glue-types-binarynode-case-class"></a>

 **BinaryNode**

```
case class BinaryNode extends ScalarNode(value, TypeCode.BINARY)  (
           value : Array[Byte] )
```

### Campos val de BinaryNode
<a name="glue-etl-scala-apis-glue-types-binarynode-case-class-vals"></a>
+ `ordering`

### Métodos def de BinaryNode
<a name="glue-etl-scala-apis-glue-types-binarynode-case-class-defs"></a>

```
def clone
```

```
def equals( other : Any )
```

```
def hashCode : Int 
```

# AWS GlueAPI BooleanNode Scala de
<a name="glue-etl-scala-apis-glue-types-booleannode"></a>

**Paquete: com.amazonaws.services.glue.types**

## Case class BooleanNode
<a name="glue-etl-scala-apis-glue-types-booleannode-case-class"></a>

 **BooleanNode**

```
case class BooleanNode extends ScalarNode(value, TypeCode.BOOLEAN)  (
           value : Boolean )
```

### Campos val de BooleanNode
<a name="glue-etl-scala-apis-glue-types-booleannode-case-class-vals"></a>
+ `ordering`

### Métodos def de BooleanNode
<a name="glue-etl-scala-apis-glue-types-booleannode-case-class-defs"></a>

```
def equals( other : Any )
```

# AWS GlueAPI ByteNode Scala de
<a name="glue-etl-scala-apis-glue-types-bytenode"></a>

**Paquete: com.amazonaws.services.glue.types**

## Case class ByteNode
<a name="glue-etl-scala-apis-glue-types-bytenode-case-class"></a>

 **ByteNode**

```
case class ByteNode extends ScalarNode(value, TypeCode.BYTE)  (
           value : Byte )
```

### Campos val de ByteNode
<a name="glue-etl-scala-apis-glue-types-bytenode-case-class-vals"></a>
+ `ordering`

### Métodos def de ByteNode
<a name="glue-etl-scala-apis-glue-types-bytenode-case-class-defs"></a>

```
def equals( other : Any )
```

# AWS GlueAPI DateNode Scala de
<a name="glue-etl-scala-apis-glue-types-datenode"></a>

**Paquete: com.amazonaws.services.glue.types**

## Case class DateNode
<a name="glue-etl-scala-apis-glue-types-datenode-case-class"></a>

 **DateNode**

```
case class DateNode extends ScalarNode(value, TypeCode.DATE)  (
           value : Date )
```

### Campos val de DateNode
<a name="glue-etl-scala-apis-glue-types-datenode-case-class-vals"></a>
+ `ordering`

### Métodos def de DateNode
<a name="glue-etl-scala-apis-glue-types-datenode-case-class-defs"></a>

```
def equals( other : Any )
```

```
def this( value : Int )
```

# AWS GlueAPI DecimalNode Scala de
<a name="glue-etl-scala-apis-glue-types-decimalnode"></a>

**Paquete: com.amazonaws.services.glue.types**

## Case class DecimalNode
<a name="glue-etl-scala-apis-glue-types-decimalnode-case-class"></a>

 **DecimalNode**

```
case class DecimalNode extends ScalarNode(value, TypeCode.DECIMAL)  (
           value : BigDecimal )
```

### Campos val de DecimalNode
<a name="glue-etl-scala-apis-glue-types-decimalnode-case-class-vals"></a>
+ `ordering`

### Métodos def de DecimalNode
<a name="glue-etl-scala-apis-glue-types-decimalnode-case-class-defs"></a>

```
def equals( other : Any )
```

```
def this( value : Decimal )
```

# AWS GlueAPI DoubleNode Scala de
<a name="glue-etl-scala-apis-glue-types-doublenode"></a>

**Paquete: com.amazonaws.services.glue.types**

## Case class DoubleNode
<a name="glue-etl-scala-apis-glue-types-doublenode-case-class"></a>

 **DoubleNode**

```
case class DoubleNode extends ScalarNode(value, TypeCode.DOUBLE)  (
           value : Double )
```

### Campos val de DoubleNode
<a name="glue-etl-scala-apis-glue-types-doublenode-case-class-vals"></a>
+ `ordering`

### Métodos def de DoubleNode
<a name="glue-etl-scala-apis-glue-types-doublenode-case-class-defs"></a>

```
def equals( other : Any )
```

# AWS GlueAPI DynamicNode Scala de
<a name="glue-etl-scala-apis-glue-types-dynamicnode"></a>

**Topics**
+ [Clase DynamicNode](#glue-etl-scala-apis-glue-types-dynamicnode-class)
+ [Objeto DynamicNode](#glue-etl-scala-apis-glue-types-dynamicnode-object)

**Paquete: com.amazonaws.services.glue.types**

## Clase DynamicNode
<a name="glue-etl-scala-apis-glue-types-dynamicnode-class"></a>

**DynamicNode**

```
class DynamicNode extends Serializable with Cloneable 
```

### Métodos def de DynamicNode
<a name="glue-etl-scala-apis-glue-types-dynamicnode-class-defs"></a>

```
def getValue : Any
```

Obtenga el valor sin formato y vincúlelo al registro actual:

```
def nodeType : TypeCode
```

```
def toJson : String
```

Método de depuración:

```
def toRow( schema : Schema,
           options : Map[String, ResolveOption]
         ) : Row
```

```
def typeName : String 
```

## Objeto DynamicNode
<a name="glue-etl-scala-apis-glue-types-dynamicnode-object"></a>

 **DynamicNode**

```
object DynamicNode
```

### Métodos def de DynamicNode
<a name="glue-etl-scala-apis-glue-types-dynamicnode-object-defs"></a>

```
def quote( field : String,
           useQuotes : Boolean
         ) : String
```

```
def quote( node : DynamicNode,
           useQuotes : Boolean
         ) : String
```

# Clase de EvaluateDataQuality
<a name="glue-etl-scala-apis-glue-dq-EvaluateDataQuality"></a>


|  | 
| --- |
|  Calidad de datos de AWS Glue se encuentra en versión preliminar para AWS Glue, por lo que es una característica que está sujeta a cambios.  | 

**Paquete: com.amazonaws.services.glue.dq**

```
object EvaluateDataQuality
```

## Def apply
<a name="glue-etl-scala-apis-glue-dq-EvaluateDataQuality-defs-apply"></a>

```
def apply(frame: DynamicFrame,
            ruleset: String,
            publishingOptions: JsonOptions = JsonOptions.empty): DynamicFrame
```

Evalúa un conjunto de reglas de calidad de datos en relación con un `DynamicFrame` y devuelve un `DynamicFrame` nuevo con los resultados de la evaluación. Para obtener más información sobre Calidad de datos de AWS Glue, consulte [Calidad de datos de AWS Glue](glue-data-quality.md).
+ `frame`: el objeto `DynamicFrame` del que quiere evaluar la calidad de los datos.
+ `ruleset`: un conjunto de reglas de lenguaje de definición de calidad de datos (DQDL) en formato de cadena. Para obtener más información sobre DQDL, consulte la guía de [Referencia del lenguaje de definición de calidad de datos (DQDL)](dqdl.md).
+ `publishingOptions`: un diccionario que especifica las siguientes opciones para publicar los resultados y las métricas de la evaluación:
  + `dataQualityEvaluationContext`: una cadena que especifica el espacio de nombres en el que AWS Glue debe publicar las métricas de Amazon CloudWatch y los resultados de calidad de los datos. Las métricas agregadas aparecen en CloudWatch, mientras que los resultados completos aparecen en la interfaz de AWS Glue Studio.
    + Obligatorio: no
    + Valor predeterminado: `default_context`
  + `enableDataQualityCloudWatchMetrics`: especifica si los resultados de la evaluación de la calidad de los datos deben publicarse en CloudWatch. Especifique un espacio de nombres para las métricas mediante la opción `dataQualityEvaluationContext`.
    + Obligatorio: no
    + Valor predeterminado: False
  + `enableDataQualityResultsPublishing`: especifica si los resultados de calidad de los datos deben estar visibles en la pestaña **Data Quality** (Calidad de datos) de la interfaz de AWS Glue Studio.
    + Obligatorio: no
    + Valor predeterminado: true
  + `resultsS3Prefix`: especifica la ubicación de Amazon S3 en la que AWS Glue puede escribir los resultados de la evaluación de la calidad de los datos.
    + Obligatorio: no
    + Valor predeterminado: "" (cadena vacía)

## Ejemplo
<a name="glue-etl-scala-apis-glue-dq-EvaluateDataQuality-example"></a>

El siguiente código de ejemplo muestra cómo evaluar la calidad de los datos de un `DynamicFrame` antes de hacer una transformación de `SelectFields`. El script verifica que se cumplan todas las reglas de calidad de datos antes de intentar la transformación.

```
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 GlueAPI FloatNode Scala de
<a name="glue-etl-scala-apis-glue-types-floatnode"></a>

**Paquete: com.amazonaws.services.glue.types**

## Case class FloatNode
<a name="glue-etl-scala-apis-glue-types-floatnode-case-class"></a>

**FloatNode**

```
case class FloatNode extends ScalarNode(value, TypeCode.FLOAT)  (
           value : Float )
```

### Campos val de FloatNode
<a name="glue-etl-scala-apis-glue-types-floatnode-case-class-vals"></a>
+ `ordering`

### Métodos def de FloatNode
<a name="glue-etl-scala-apis-glue-types-floatnode-case-class-defs"></a>

```
def equals( other : Any )
```

# Clase FillMissingValues
<a name="glue-etl-scala-apis-glue-ml-fillmissingvalues"></a>

**Paquete: com.amazonaws.services.glue.ml**

```
object FillMissingValues
```

## Def apply
<a name="glue-etl-scala-apis-glue-ml-fillmissingvalues-defs-apply"></a>

```
def apply(frame: DynamicFrame,
          missingValuesColumn: String,
          outputColumn: String = "",
          transformationContext: String = "",
          callSite: CallSite = CallSite("Not provided", ""),
          stageThreshold: Long = 0,
          totalThreshold: Long = 0): DynamicFrame
```

Rellena los valores que faltan de un marco dinámico en una columna especificada y devuelve un nuevo marco con estimaciones en una nueva columna. Para filas sin valores faltantes, el valor de la columna especificada se duplica en la nueva columna.
+ `frame`: DynamicFrame en el que rellenar los valores que faltan. Obligatorio.
+ `missingValuesColumn`: la columna que contiene valores faltantes (valores `null` y cadenas vacías). Obligatorio.
+ `outputColumn`: el nombre de la nueva columna que contendrá valores estimados para todas las filas cuyo valor faltaba. Opcional; el valor predeterminado es `missingValuesColumn` con el sufijo `"_filled"`.
+ `transformationContext`: una cadena única que se utiliza para identificar la información de estado (opcional).
+ `callSite`: se utiliza para proporcionar información de contexto para los informes de error. (Opcional).
+ `stageThreshold`: el número máximo de errores que se pueden producir en la transformación antes de que se determine que es errónea (opcional, el valor predeterminado es cero).
+ `totalThreshold`: el número máximo de errores que se pueden producir en total antes de que se determine que el proceso es erróneo (opcional, el valor predeterminado es cero).

Devuelve un nuevo marco dinámico con una columna adicional que contiene estimaciones para filas con valores faltantes y el valor actual para otras filas.

# Clase FindMatches
<a name="glue-etl-scala-apis-glue-ml-findmatches"></a>

**Paquete: com.amazonaws.services.glue.ml**

```
object FindMatches
```

## Def apply
<a name="glue-etl-scala-apis-glue-ml-findmatches-defs-apply"></a>

```
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
```

Busque coincidencias en un marco de entrada y devuelva un nuevo marco con una nueva columna que contenga un ID único por grupo de coincidencias.
+ `frame`: DynamicFrame en el que buscar coincidencias. Obligatorio.
+ `transformId`: ID único asociado a la transformación FindMatches que se aplicará en el marco de entrada. Obligatorio.
+ `transformationContext`: identificador de este `DynamicFrame`. Se utiliza `transformationContext` como clave para el estado de marcador de trabajo que se conserva de una ejecución a otra. Opcional.
+ `callSite`: se utiliza para proporcionar información de contexto para los informes de error. Estos valores se establecen automáticamente cuando se realiza la llamada desde Python. Opcional.
+ `stageThreshold`: número máximo de registros de errores permitidos en el cálculo de este `DynamicFrame` antes de generar una excepción, sin incluir los registros presentes en el `DynamicFrame` anterior. Opcional. El rol predeterminado es cero.
+ `totalThreshold`: número máximo registros de errores totales antes de que se genere una excepción, incluidos los de marcos anteriores. Opcional. El rol predeterminado es cero.
+ `enforcedMatches`: el marco para las coincidencias forzadas. Opcional. El valor predeterminado es `null`.
+ `computeMatchConfidenceScores`: valor booleano que indica si se calcula una puntuación de confianza para cada grupo de registros coincidentes. Opcional. El valor predeterminado es false.

Devuelve un nuevo marco dinámico con un identificador único asignado a cada grupo de registros coincidentes.

# Clase FindIncrementalMatches
<a name="glue-etl-scala-apis-glue-ml-findincrementalmatches"></a>

**Paquete: com.amazonaws.services.glue.ml**

```
object FindIncrementalMatches
```

## Def apply
<a name="glue-etl-scala-apis-glue-ml-findincrementalmatches-defs-apply"></a>

```
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
```

Busca coincidencias entre los marcos existentes y progresivos y devuelve un nuevo marco con una columna que contiene un ID único por grupo de coincidencias.
+ `existingframe`: un marco existente al que se le ha asignado un ID coincidente para cada grupo. Obligatorio.
+ `incrementalframe`: un marco progresivo utilizado para encontrar coincidencias con el marco existente. Obligatorio.
+ `transformId`: un ID único asociado a la transformación FindIncrementalMatches que se aplicará a los marcos de entrada. Obligatorio.
+ `transformationContext`: identificador de este `DynamicFrame`. Se utiliza `transformationContext` como clave para el estado de marcador de trabajo que se conserva de una ejecución a otra. Opcional.
+ `callSite`: se utiliza para proporcionar información de contexto para los informes de error. Estos valores se establecen automáticamente cuando se realiza la llamada desde Python. Opcional.
+ `stageThreshold`: número máximo de registros de errores permitidos en el cálculo de este `DynamicFrame` antes de generar una excepción, sin incluir los registros presentes en el `DynamicFrame` anterior. Opcional. El rol predeterminado es cero.
+ `totalThreshold`: número máximo registros de errores totales antes de que se genere una excepción, incluidos los de marcos anteriores. Opcional. El rol predeterminado es cero.
+ `enforcedMatches`: el marco para las coincidencias forzadas. Opcional. El valor predeterminado es `null`.
+ `computeMatchConfidenceScores`: valor booleano que indica si se calcula una puntuación de confianza para cada grupo de registros coincidentes. Opcional. El valor predeterminado es false.

Devuelve un nuevo marco dinámico con un identificador único asignado a cada grupo de registros coincidentes.

# AWS GlueAPI IntegerNode Scala de
<a name="glue-etl-scala-apis-glue-types-integernode"></a>

**Paquete: com.amazonaws.services.glue.types**

## Case class IntegerNode
<a name="glue-etl-scala-apis-glue-types-integernode-case-class"></a>

**IntegerNode**

```
case class IntegerNode extends ScalarNode(value, TypeCode.INT)  (
           value : Int )
```

### Campos val de IntegerNode
<a name="glue-etl-scala-apis-glue-types-integernode-case-class-vals"></a>
+ `ordering`

### Métodos def de IntegerNode
<a name="glue-etl-scala-apis-glue-types-integernode-case-class-defs"></a>

```
def equals( other : Any )
```

# AWS GlueAPI LongNode Scala de
<a name="glue-etl-scala-apis-glue-types-longnode"></a>

**Paquete: com.amazonaws.services.glue.types**

## Case class LongNode
<a name="glue-etl-scala-apis-glue-types-longnode-case-class"></a>

 **LongNode**

```
case class LongNode extends ScalarNode(value, TypeCode.LONG)  (
           value : Long )
```

### Campos val de LongNode
<a name="glue-etl-scala-apis-glue-types-longnode-case-class-vals"></a>
+ `ordering`

### Métodos def de LongNode
<a name="glue-etl-scala-apis-glue-types-longnode-case-class-defs"></a>

```
def equals( other : Any )
```

# AWS GlueAPI MapLikeNode Scala de
<a name="glue-etl-scala-apis-glue-types-maplikenode"></a>

**Paquete: com.amazonaws.services.glue.types**

## Case class MapLikeNode
<a name="glue-etl-scala-apis-glue-types-maplikenode-class"></a>

**MapLikeNode**

```
class MapLikeNode extends DynamicNode  (
           value : mutable.Map[String, DynamicNode] )
```

### Métodos def de MapLikeNode
<a name="glue-etl-scala-apis-glue-types-maplikenode-class-defs"></a>

```
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 
```

**Ejemplo:** Teniendo en cuenta este JSON: 

```
{"foo": "bar"}
```

Si `useQuotes == true`, `toJson` devuelve `{"foo": "bar"}`. Si `useQuotes == false`, `toJson` devuelve `{foo: bar}` @return.

# API MapNode Scala de AWS Glue
<a name="glue-etl-scala-apis-glue-types-mapnode"></a>

**Paquete: com.amazonaws.services.glue.types**

## Case class MapNode
<a name="glue-etl-scala-apis-glue-types-mapnode-case-class"></a>

 **MapNode**

```
case class MapNode extends MapLikeNode(value)  (
           value : mutable.Map[String, DynamicNode] )
```

### Métodos def de MapNode
<a name="glue-etl-scala-apis-glue-types-mapnode-case-class-defs"></a>

```
def clone
```

```
def equals( other : Any )
```

```
def hashCode : Int 
```

```
def nodeType
```

```
def this
```

# AWS GlueAPI NullNode Scala de
<a name="glue-etl-scala-apis-glue-types-nullnode"></a>

**Topics**
+ [Clase NullNode](#glue-etl-scala-apis-glue-types-nullnode-class)
+ [Case object NullNode](#glue-etl-scala-apis-glue-types-nullnode-case-object)

**Paquete: com.amazonaws.services.glue.types**

## Clase NullNode
<a name="glue-etl-scala-apis-glue-types-nullnode-class"></a>

 **NullNode**

```
class NullNode
```

## Case object NullNode
<a name="glue-etl-scala-apis-glue-types-nullnode-case-object"></a>

 **NullNode**

```
case object NullNode extends NullNode 
```

# AWS GlueAPI ObjectNode Scala de
<a name="glue-etl-scala-apis-glue-types-objectnode"></a>

**Topics**
+ [Objeto ObjectNode](#glue-etl-scala-apis-glue-types-objectnode-object)
+ [Case class ObjectNode](#glue-etl-scala-apis-glue-types-objectnode-case-class)

**Paquete: com.amazonaws.services.glue.types**

## Objeto ObjectNode
<a name="glue-etl-scala-apis-glue-types-objectnode-object"></a>

**ObjectNode**

```
object ObjectNode
```

### Métodos def de ObjectNode
<a name="glue-etl-scala-apis-glue-types-objectnode-object-defs"></a>

```
def apply( frameKeys : Set[String],
           v1 : mutable.Map[String, DynamicNode],
           v2 : mutable.Map[String, DynamicNode],
           resolveWith : String
         ) : ObjectNode
```

## Case class ObjectNode
<a name="glue-etl-scala-apis-glue-types-objectnode-case-class"></a>

 **ObjectNode**

```
case class ObjectNode extends MapLikeNode(value)  (
           val value : mutable.Map[String, DynamicNode] )
```

### Métodos def de ObjectNode
<a name="glue-etl-scala-apis-glue-types-objectnode-case-class-defs"></a>

```
def clone
```

```
def equals( other : Any )
```

```
def hashCode : Int 
```

```
def nodeType
```

```
def this
```

# API ScalarNode Scala de AWS Glue
<a name="glue-etl-scala-apis-glue-types-scalarnode"></a>

**Topics**
+ [Clase ScalarNode](#glue-etl-scala-apis-glue-types-scalarnode-class)
+ [Objeto ScalarNode](#glue-etl-scala-apis-glue-types-scalarnode-object)

**Paquete: com.amazonaws.services.glue.types**

## Clase ScalarNode
<a name="glue-etl-scala-apis-glue-types-scalarnode-class"></a>

**ScalarNode**

```
class ScalarNode extends DynamicNode  (
           value : Any,
           scalarType : TypeCode )
```

### Métodos def de ScalarNode
<a name="glue-etl-scala-apis-glue-types-scalarnode-class-defs"></a>

```
def compare( other : Any,
             operator : String
           ) : Boolean
```

```
def getValue
```

```
def hashCode : Int 
```

```
def nodeType
```

```
def toJson
```

## Objeto ScalarNode
<a name="glue-etl-scala-apis-glue-types-scalarnode-object"></a>

 **ScalarNode**

```
object ScalarNode
```

### Métodos def de ScalarNode
<a name="glue-etl-scala-apis-glue-types-scalarnode-object-defs"></a>

```
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 GlueAPI ShortNode Scala de
<a name="glue-etl-scala-apis-glue-types-shortnode"></a>

**Paquete: com.amazonaws.services.glue.types**

## Case class ShortNode
<a name="glue-etl-scala-apis-glue-types-shortnode-case-class"></a>

**ShortNode**

```
case class ShortNode extends ScalarNode(value, TypeCode.SHORT)  (
           value : Short )
```

### Campos val de ShortNode
<a name="glue-etl-scala-apis-glue-types-shortnode-case-class-vals"></a>
+ `ordering`

### Métodos def de ShortNode
<a name="glue-etl-scala-apis-glue-types-shortnode-case-class-defs"></a>

```
def equals( other : Any )
```

# AWS GlueAPI StringNode Scala de
<a name="glue-etl-scala-apis-glue-types-stringnode"></a>

**Paquete: com.amazonaws.services.glue.types**

## Case class StringNode
<a name="glue-etl-scala-apis-glue-types-stringnode-case-class"></a>

 **StringNode**

```
case class StringNode extends ScalarNode(value, TypeCode.STRING)  (
           value : String )
```

### Campos val de StringNode
<a name="glue-etl-scala-apis-glue-types-stringnode-case-class-vals"></a>
+ `ordering`

### Métodos def de StringNode
<a name="glue-etl-scala-apis-glue-types-stringnode-case-class-defs"></a>

```
def equals( other : Any )
```

```
def this( value : UTF8String )
```

# AWS GlueAPI TimestampNode Scala de
<a name="glue-etl-scala-apis-glue-types-timestampnode"></a>

**Paquete: com.amazonaws.services.glue.types**

## Case class TimestampNode
<a name="glue-etl-scala-apis-glue-types-timestampnode-case-class"></a>

**TimestampNode**

```
case class TimestampNode extends ScalarNode(value, TypeCode.TIMESTAMP)  (
           value : Timestamp )
```

### Campos val de TimestampNode
<a name="glue-etl-scala-apis-glue-types-timestampnode-case-class-vals"></a>
+ `ordering`

### Métodos def de TimestampNode
<a name="glue-etl-scala-apis-glue-types-timestampnode-case-class-defs"></a>

```
def equals( other : Any )
```

```
def this( value : Long )
```

# AWS GlueAPI GlueArgParser Scala de
<a name="glue-etl-scala-apis-glue-util-glueargparser"></a>

**Paquete: com.amazonaws.services.glue.util**

## Objeto GlueArgParser
<a name="glue-etl-scala-apis-glue-util-glueargparser-object"></a>

**GlueArgParser**

```
object GlueArgParser
```

Esto es estrictamente coherente con la versión para Python de `utils.getResolvedOptions` del paquete `AWSGlueDataplanePython`.

### Métodos def de GlueArgParser
<a name="glue-etl-scala-apis-glue-util-glueargparser-object-defs"></a>

```
def getResolvedOptions( args : Array[String],
                        options : Array[String]
                      ) : Map[String, String]
```

```
def initParser( userOptionsSet : mutable.Set[String] ) : ArgumentParser 
```

**Example Recuperación de los argumentos que se pasan a un trabajo**  
Para recuperar los argumentos del trabajo, puede usar el método `getResolvedOptions`. Considere el siguiente ejemplo, que recupera un argumento de trabajo denominado `aws_region`.  

```
val args = GlueArgParser.getResolvedOptions(sysArgs, Seq("JOB_NAME","aws_region").toArray)
Job.init(args("JOB_NAME"), glueContext, args.asJava)
val region = args("aws_region")
println(region)
```

# API Job Scala de AWS Glue
<a name="glue-etl-scala-apis-glue-util-job"></a>

**Paquete: com.amazonaws.services.glue.util**

## Objeto de trabajo
<a name="glue-etl-scala-apis-glue-util-job-object"></a>

 **Trabajo**

```
object Job
```

### Métodos def de trabajo
<a name="glue-etl-scala-apis-glue-util-job-object-defs"></a>

```
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
```