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

Definire uno schema per un indice secondario

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

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

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-modelindice (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) }