Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Utiliser des index secondaires avec DynamoDB Mapper
<a name="ddb-mapper-secondary-indices"></a>

****  
**DynamoDB Mapper est une version préliminaire pour les développeurs. Les fonctionnalités ne sont pas complètes et sont susceptibles d'être modifiées.**

## Définition d'un schéma pour un index secondaire
<a name="ddb-mapper-secondary-indices-schema"></a>

Les tables DynamoDB prennent en charge des index secondaires qui permettent d'accéder aux données à l'aide de clés différentes de celles définies dans la table de base elle-même. Comme pour les tables de base, DynamoDB Mapper interagit avec les indices en utilisant le type. `[ItemSchema](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/dynamodb-mapper/aws.sdk.kotlin.hll.dynamodbmapper.items/-item-schema/index.html)`

Les index secondaires DynamoDB ne doivent pas nécessairement contenir tous les attributs de la table de base. Par conséquent, la classe Kotlin qui correspond à un index peut être différente de la classe Kotlin qui correspond à la table de base de cet index. Dans ce cas, un schéma distinct doit être déclaré pour la classe d'index.

Le code suivant crée manuellement un schéma d'index pour la table `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
        )
*/
```

Nous pouvons désormais utiliser des `Model` instances dans les opérations.

## Utiliser des indices secondaires dans les opérations
<a name="ddb-mapper-gs-index-ops"></a>

Le mappeur DynamoDB prend en charge un sous-ensemble d'opérations sur les indices, à savoir et. `queryPaginated` `scanPaginated` Pour appeler ces opérations sur un index, vous devez d'abord obtenir une référence à un index à partir de l'objet de table. Dans l'exemple suivant, nous utilisons celui `modelSchema` que nous avons créé précédemment pour l'`cars-by-model`index (création non illustrée ici) :

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

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

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