Operaciones por lotes mediante el modelo de persistencia de objetos de AWS SDK for .NET - Amazon DynamoDB
Escritura por lotes: colocación y eliminación de varios elementos Obtención por lotes: obtención de varios elementos

Operaciones por lotes mediante el modelo de persistencia de objetos de AWS SDK for .NET

Escritura por lotes: colocación y eliminación de varios elementos

Para colocar o eliminar varios objetos en una tabla en una única solicitud, haga lo siguiente:

  • Ejecute el método CreateBatchWrite de DynamoDBContext y cree una instancia de la clase BatchWrite.

  • Especifique los elementos que desea colocar o eliminar.

    • Para colocar uno o varios elementos, utilice el método AddPutItem o AddPutItems.

    • Para eliminar uno o varios elementos, puede especificar la clave principal del elemento o un objeto del lado del cliente mapeado al elemento que desea eliminar. Utilice los métodos AddDeleteItem, AddDeleteItems y AddDeleteKey para especificar la lista de elementos que desea eliminar.

  • Llame al método BatchWrite.Execute para colocar y eliminar en la tabla todos los elementos especificados.

nota

Cuando se utiliza el modelo de persistencia de objetos, se puede especificar cualquier cantidad de operaciones en un lote. No obstante, tenga en cuenta que Amazon DynamoDB limita el número de operaciones de un lote y el tamaño total del lote para una operación por lote. Para obtener más información acerca de los límites específicos, consulte BatchWriteItem. Si el API detecta que la solicitud de escritura por lotes ha superado el número permitido de solicitudes de escritura o la carga de HTTP máxima permitida, divide el lote en varios lotes de menor tamaño. Además, si una respuesta a una escritura por lote devuelve elementos sin procesar, el API envía automáticamente otra solicitud de escritura por lote con esos elementos que no se han procesado.

Supongamos que hemos definido en C# una clase Book mapeada a la tabla ProductCatalog de DynamoDB. En el siguiente ejemplo de código C# se utiliza el objeto BatchWrite para cargar dos elementos y eliminar uno en la tabla ProductCatalog.

ejemplo 
DynamoDBContext context = new DynamoDBContext(client);
var bookBatch = context.CreateBatchWrite<Book>();

// 1. Specify two books to add.
Book book1 = new Book
{
  Id = 902,
  ISBN = "902-11-11-1111",
  ProductCategory = "Book",
  Title = "My book3 in batch write"
};
Book book2 = new Book
{
  Id = 903,
  ISBN = "903-11-11-1111",
  ProductCategory = "Book",
  Title = "My book4 in batch write"
};


bookBatch.AddPutItems(new List<Book> { book1, book2 });

// 2. Specify one book to delete.
bookBatch.AddDeleteKey(111);

bookBatch.Execute();

Para colocar o eliminar objetos de varias tablas, haga lo siguiente:

  • Cree una instancia de la clase BatchWrite para cada tipo y especifique los elementos que desee colocar o eliminar, como se describe en la sección anterior.

  • Utilice uno de los métodos siguientes para crear una instancia de MultiTableBatchWrite:

    • Ejecute el método Combine con uno de los objetos BatchWrite que creó en el paso anterior.

    • Proporcione una lista de objetos MultiTableBatchWrite para crear una instancia del tipo BatchWrite.

    • Ejecute el método CreateMultiTableBatchWrite de DynamoDBContext y pase la lista de objetos BatchWrite.

  • Llame al método Execute de MultiTableBatchWrite, que lleva a cabo las operaciones especificadas de colocación y eliminación en varias tablas.

Supongamos que ha definido clase C# Forum y Thread que mapea a las tablas Forum y Thread en DynamoDB. Además, supongamos que se ha habilitado el control de versiones en la clase Thread. Dado que el control de versiones no se admite en las operaciones por lotes, es preciso deshabilitarlo de forma explícita, tal y como se muestra en el siguiente ejemplo de código C#. En el ejemplo se utiliza el objeto MultiTableBatchWrite para llevar a cabo una eliminación de varias tablas.

ejemplo 
DynamoDBContext context = new DynamoDBContext(client);
// Create BatchWrite objects for each of the Forum and Thread classes.
var forumBatch = context.CreateBatchWrite<Forum>();

DynamoDBOperationConfig config = new DynamoDBOperationConfig();
config.SkipVersionCheck = true;
var threadBatch = context.CreateBatchWrite<Thread>(config);

// 1. New Forum item.
Forum newForum = new Forum
{
  Name = "Test BatchWrite Forum",
  Threads = 0
};
forumBatch.AddPutItem(newForum);

// 2. Specify a forum to delete by specifying its primary key.
forumBatch.AddDeleteKey("Some forum");

// 3. New Thread item.
Thread newThread = new Thread
{
  ForumName = "Amazon S3 forum",
  Subject = "My sample question",
  KeywordTags = new List<string> { "Amazon S3", "Bucket" },
   Message = "Message text"
};

threadBatch.AddPutItem(newThread);

// Now run multi-table batch write.
var superBatch = new MultiTableBatchWrite(forumBatch, threadBatch);
superBatch.Execute();

Para ver un ejemplo práctico, consulte Ejemplo: operación de escritura por lote con el modelo de persistencia de objetos de AWS SDK for .NET.

nota

El API de procesamiento por lotes de DynamoDB limita el número de escrituras del lote, así como el tamaño del lote. Para obtener más información, consulte BatchWriteItem. Cuando se utiliza el API del modelo de persistencia de objetos de .NET, se puede especificar cualquier cantidad de operaciones. Sin embargo, si el número de operaciones de un lote o el tamaño superan el límite, el API de .NET dividirá la solicitud de escritura por lotes en lotes de menor tamaño y enviará varias solicitudes de escritura por lotes a DynamoDB.

Obtención por lotes: obtención de varios elementos

Para recuperar varios elementos de una tabla en una única solicitud, haga lo siguiente:

  • Cree una instancia de la clase CreateBatchGet.

  • Especifique una lista de claves principales para recuperarlas.

  • Llame al método Execute. La respuesta devuelve los elementos de la propiedad Results.

En el siguiente ejemplo de código C# se recuperan tres elementos de la tabla ProductCatalog. Los elementos del resultado no están necesariamente en el mismo orden en que se han especificado las claves principales.

ejemplo 
DynamoDBContext context = new DynamoDBContext(client);
var bookBatch = context.CreateBatchGet<ProductCatalog>();
bookBatch.AddKey(101);
bookBatch.AddKey(102);
bookBatch.AddKey(103);
bookBatch.Execute();
// Process result.
Console.WriteLine(bookBatch.Results.Count);
Book book1 = bookBatch.Results[0];
Book book2 = bookBatch.Results[1];
Book book3 = bookBatch.Results[2];

Para recuperar objetos de varias tablas, haga lo siguiente:

  • Para cada tipo, cree una instancia del tipo CreateBatchGet y proporcione los valores de clave principal que desee recuperar de cada tabla.

  • Utilice uno de los métodos siguientes para crear una instancia de la clase MultiTableBatchGet:

    • Ejecute el método Combine con uno de los objetos BatchGet que creó en el paso anterior.

    • Proporcione una lista de objetos MultiBatchGet para crear una instancia del tipo BatchGet.

    • Ejecute el método CreateMultiTableBatchGet de DynamoDBContext y pase la lista de objetos BatchGet.

  • Llame al método Execute de MultiTableBatchGet, que devuelve los resultados con tipos en los objetos BatchGet individuales.

En el siguiente ejemplo de código C# recupera varios elementos de las tablas Order y OrderDetail mediante el método CreateBatchGet.

ejemplo 
var orderBatch = context.CreateBatchGet<Order>();
orderBatch.AddKey(101);
orderBatch.AddKey(102);

var orderDetailBatch = context.CreateBatchGet<OrderDetail>();
orderDetailBatch.AddKey(101, "P1");
orderDetailBatch.AddKey(101, "P2");
orderDetailBatch.AddKey(102, "P3");
orderDetailBatch.AddKey(102, "P1");

var orderAndDetailSuperBatch = orderBatch.Combine(orderDetailBatch);
orderAndDetailSuperBatch.Execute();

Console.WriteLine(orderBatch.Results.Count);
Console.WriteLine(orderDetailBatch.Results.Count);

Order order1 = orderBatch.Results[0];
Order order2 = orderBatch.Results[1];
OrderDetail orderDetail1 = orderDetailBatch.Results[0];