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.

# Utilice índices secundarios con DynamoDB Mapper
<a name="ddb-mapper-secondary-indices"></a>

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

## Defina un esquema para un índice secundario
<a name="ddb-mapper-secondary-indices-schema"></a>

Las tablas de DynamoDB admiten índices secundarios que proporcionan acceso a los datos mediante claves distintas de las definidas en la propia tabla base. Al igual que con las tablas base, DynamoDB Mapper interactúa con los índices mediante el tipo. `[ItemSchema](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/dynamodb-mapper/aws.sdk.kotlin.hll.dynamodbmapper.items/-item-schema/index.html)`

No es necesario que los índices secundarios de DynamoDB contengan todos los atributos de la tabla base. En consecuencia, la clase de Kotlin que se asigna a un índice puede diferir de la clase de Kotlin que se asigna a la tabla base de ese índice. En ese caso, se debe declarar un esquema independiente para la clase de índice.

El código siguiente crea manualmente un esquema de índice para la tabla de `cars` DynamoDB.

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

// This is a data class for modelling the index of the Car table. Note
// that it contains a subset of the fields from the Car class and also 
// uses different names for them.
data class Model(val name: String, val manufacturer: String)

// We define an item converter.
val modelConverter = object : ItemConverter<Model> {
    override fun convertTo(from: Model, onlyAttributes: Set<String>?): Item  = itemOf(
        "model" to AttributeValue.S(from.name),
        "make" to AttributeValue.S(from.manufacturer),
    )

    override fun convertFrom(to: Item): Model = Model(
        name = to["model"]?.asSOrNull() ?: error("Invalid attribute `model`"),
        manufacturer = to["make"]?.asSOrNull() ?: error("Invalid attribute `make`"),
    )
}
val modelKey = KeySpec.String("model")
val makeKey = KeySpec.String("make")

val modelSchema = ItemSchema(modelConverter, modelKey, makeKey) // The partition key specification is the second parameter.

/* Note that `Model` index's partition key is `model` and its sort key is `make`,
   whereas the `Car` base table uses `make` as the partition key and `model` as the sort key:

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

Ahora podemos usar `Model` instancias en las operaciones.

## Utilice índices secundarios en las operaciones
<a name="ddb-mapper-gs-index-ops"></a>

DynamoDB Mapper admite un subconjunto de operaciones en índices, a saber, y. `queryPaginated` `scanPaginated` Para invocar estas operaciones en un índice, primero debe obtener una referencia a un índice desde el objeto de la tabla. En el siguiente ejemplo, utilizamos lo `modelSchema` que creamos anteriormente para el `cars-by-model` índice (la creación no se muestra aquí):

```
val table = mapper.getTable("cars", CarSchema)
val index = table.getIndex("cars-by-model", modelSchema)

val modelFlow = index
    .scanPaginated { }
    .items()

modelFlow.collect { model -> println(model) }
```