Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Usa gli indici secondari con DynamoDB Mapper
<a name="ddb-mapper-secondary-indices"></a>

****  
**DynamoDB Mapper è una versione di anteprima per sviluppatori. Non è completa di funzionalità ed è soggetta a modifiche.**

## Definire uno schema per un indice secondario
<a name="ddb-mapper-secondary-indices-schema"></a>

Le tabelle DynamoDB supportano indici secondari che forniscono l'accesso ai dati utilizzando chiavi diverse da quelle definite nella tabella base stessa. Come per le tabelle base, DynamoDB Mapper interagisce con gli indici utilizzando il tipo. `[ItemSchema](https://docs.aws.amazon.com/sdk-for-kotlin/api/latest/dynamodb-mapper/aws.sdk.kotlin.hll.dynamodbmapper.items/-item-schema/index.html)`

Non è necessario che gli indici secondari di DynamoDB contengano tutti gli attributi della tabella di base. Di conseguenza, la classe Kotlin mappata a un indice può differire dalla classe Kotlin che esegue il mapping alla tabella base di quell'indice. In tal caso, è necessario dichiarare uno schema separato per la classe di indice.

Il codice seguente crea manualmente uno schema di indice per la tabella `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
        )
*/
```

Ora possiamo usare le `Model` istanze nelle operazioni.

## Usa indici secondari nelle operazioni
<a name="ddb-mapper-gs-index-ops"></a>

DynamoDB Mapper supporta un sottoinsieme di operazioni sugli indici, vale a dire e. `queryPaginated` `scanPaginated` Per richiamare queste operazioni su un indice, è necessario prima ottenere un riferimento a un indice dall'oggetto della tabella. Nell'esempio seguente, utilizziamo `modelSchema` quello che abbiamo creato in precedenza per l'`cars-by-model`indice (creazione non mostrata qui):

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

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

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