Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Defina esquemas manualmente
<a name="ddb-mapper-code-schemas"></a>

****  
**DynamoDB Mapper es una versión preliminar para desarrolladores. No incluye todas las funciones y está sujeta a cambios.**

## Defina un esquema en el código
<a name="ddb-mapper-gs-manual-schema-def"></a>

Para obtener el máximo control y personalización, puede definir y personalizar manualmente los esquemas en el código. 

Como se muestra en el siguiente fragmento, es necesario incluir menos dependencias en el `build.gradle.kts` archivo en comparación con la creación de esquemas basada en anotaciones. 

(Puedes navegar hasta el {{X.Y.Z}} enlace para ver la última versión disponible).

```
// build.gradle.kts
val sdkVersion: String = [https://github.com/awslabs/aws-sdk-kotlin/releases/latest](https://github.com/awslabs/aws-sdk-kotlin/releases/latest) 

dependencies {
    implementation("aws.sdk.kotlin:dynamodb-mapper:$sdkVersion-beta") // For the Developer Preview, use the beta version of the latest SDK.
}
```

Ten en cuenta que no necesitas el complemento generador de esquemas ni el paquete de anotaciones.

El mapeo entre una clase de Kotlin y un elemento de DynamoDB requiere `[ItemSchema<T>](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/dynamodb-mapper/aws.sdk.kotlin.hll.dynamodbmapper.items/-item-schema/index.html)` una implementación, `T` donde es el tipo de la clase de Kotlin. Un esquema consta de los siguientes elementos:
+ Un conversor de elementos, que define cómo convertir entre instancias de objetos de Kotlin y elementos de DynamoDB.
+ Una especificación de clave de partición, que define el nombre y el tipo del atributo de clave de partición.
+ Opcionalmente, una especificación de clave de clasificación, que define el nombre y el tipo del atributo de clave de clasificación.

En el siguiente código, creamos una `CarSchema` instancia manualmente:

```
import aws.sdk.kotlin.hll.dynamodbmapper.items.ItemConverter
import aws.sdk.kotlin.hll.dynamodbmapper.items.ItemSchema
import aws.sdk.kotlin.hll.dynamodbmapper.model.itemOf

// We define a schema for this data class.
data class Car(val make: String, val model: String, val initialYear: Int)

// First, define an item converter.
val carConverter = object : ItemConverter<Car> {
    override fun convertTo(from: Car, onlyAttributes: Set<String>?): Item  = itemOf(
        "make" to AttributeValue.S(from.make),
        "model" to AttributeValue.S(from.model),
        "initialYear" to AttributeValue.N(from.initialYear.toString()),
    )

    override fun convertFrom(to: Item): Car = Car(
        make = to["make"]?.asSOrNull() ?: error("Invalid attribute `make`"),
        model = to["model"]?.asSOrNull() ?: error("Invalid attribute `model`"),
        initialYear = to["initialYear"]?.asNOrNull()?.toIntOrNull()
            ?: error("Invalid attribute `initialYear`"),
    )
}

// Next, define the specifications for the partition key and sort key.
val makeKey = KeySpec.String("make")
val modelKey = KeySpec.String("model")

// Finally, create the schema from the converter and key specifications.
// Note that the KeySpec for the partition key comes first in the ItemSchema constructor.
val CarSchema = ItemSchema(carConverter, makeKey, modelKey)
```

El código anterior crea un convertidor denominado`carConverter`, que se define como una implementación anónima de`ItemConverter<Car>`. El `convertTo` método del convertidor acepta un `Car` argumento y devuelve una `Item` instancia que representa las claves y valores literales de los atributos de los elementos de DynamoDB. El `convertFrom` método del convertidor acepta un `Item` argumento y devuelve una `Car` instancia a partir de los valores de atributo del `Item` argumento.

A continuación, el código crea dos especificaciones clave: una para la clave de partición y otra para la clave de clasificación. Cada tabla o índice de DynamoDB debe tener exactamente una clave de partición y, en consecuencia, también lo debe tener cada definición de esquema de DynamoDB Mapper. Los esquemas también pueden tener una clave de clasificación.

En la última declaración, el código crea un esquema para la tabla de `cars` DynamoDB a partir del convertidor y de las especificaciones clave.

El esquema resultante es equivalente al esquema basado en anotaciones que generamos en la sección. [Defina un esquema con anotaciones de clase](ddb-mapper-get-started.md#ddb-mapper-gs-anno-schema-def) Como referencia, la siguiente es la clase anotada que utilizamos:

### Clase de vehículo con anotaciones en DynamoDB Mapper
<a name="ejd_mxz_ddc"></a>

```
@DynamoDbItem
data class Car(
    @DynamoDbPartitionKey
    val make: String,
    
    @DynamoDbSortKey
    val model: String,
    
    val initialYear: Int
)
```

Además de implementar las suyas propias`ItemConverter`, DynamoDB Mapper incluye varias implementaciones útiles, como: 
+ `[SimpleItemConverter](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/dynamodb-mapper/aws.sdk.kotlin.hll.dynamodbmapper.items/-simple-item-converter/index.html)`: proporciona una lógica de conversión sencilla mediante el uso de un generador de descriptores de atributos y clases. Consulte el [Defina un conversor de artículos personalizado](ddb-mapper-anno-schema-gen.md#ddb-mapper-anno-schema-custom) ejemplo de cómo puede utilizar esta implementación.
+ `[HeterogeneousItemConverter](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/dynamodb-mapper/aws.sdk.kotlin.hll.dynamodbmapper.items/-heterogeneous-item-converter/index.html)`: proporciona una lógica de conversión de tipos polimórficos mediante el uso de un atributo discriminador y `ItemConverter` instancias delegadas para los subtipos.
+ `[DocumentConverter](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/dynamodb-mapper/aws.sdk.kotlin.hll.dynamodbmapper.items/-document-converter/index.html)`: proporciona lógica de conversión para datos no estructurados en objetos. [https://docs.aws.amazon.com/smithy-kotlin/api/latest/runtime-core/aws.smithy.kotlin.runtime.content/-document.html](https://docs.aws.amazon.com/smithy-kotlin/api/latest/runtime-core/aws.smithy.kotlin.runtime.content/-document.html)