As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Use índices secundários com o DynamoDB Mapper
<a name="ddb-mapper-secondary-indices"></a>

****  
**O DynamoDB Mapper é uma versão prévia para desenvolvedores. O recurso não está completo e está sujeito a alterações.**

## Definir um esquema para um índice secundário
<a name="ddb-mapper-secondary-indices-schema"></a>

As tabelas do DynamoDB oferecem suporte a índices secundários que fornecem acesso aos dados usando chaves diferentes das definidas na própria tabela base. Assim como nas tabelas base, o DynamoDB Mapper interage com os índices usando o tipo. `[ItemSchema](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/dynamodb-mapper/aws.sdk.kotlin.hll.dynamodbmapper.items/-item-schema/index.html)`

Os índices secundários do DynamoDB não precisam conter todos os atributos da tabela base. Assim, a classe Kotlin que mapeia para um índice pode ser diferente da classe Kotlin que mapeia para a tabela base desse índice. Quando for esse o caso, um esquema separado deve ser declarado para a classe de índice.

O código a seguir cria manualmente um esquema de índice para a tabela do DynamoDB. `cars`

```
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
        )
*/
```

Agora podemos usar `Model` instâncias em operações.

## Use índices secundários nas operações
<a name="ddb-mapper-gs-index-ops"></a>

O DynamoDB Mapper suporta um subconjunto de operações em índices, a saber e. `queryPaginated` `scanPaginated` Para invocar essas operações em um índice, você deve primeiro obter uma referência a um índice do objeto de tabela. No exemplo a seguir, usamos o `modelSchema` que criamos anteriormente para o `cars-by-model` índice (criação não mostrada aqui):

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

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

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