Modifica datos con la escritura por lotes

En esta página, se describen las solicitudes de escritura por lotes de Spanner y cómo puedes usarlas modificar tus datos de Spanner.

Puedes usar la escritura por lotes de Spanner para insertar, actualizar o borrar varias filas en tus tablas de Spanner. Spanner la escritura por lotes admite escrituras de baja latencia sin una operación de lectura y muestra las respuestas, mientras que las mutaciones se aplican en lotes. Para usar la escritura por lotes, debes agrupar de mutaciones relacionadas entre sí, y todas las mutaciones de un grupo se confirman de forma atómica. Las mutaciones entre los grupos se aplican en un orden no especificado. son independientes entre sí (no atómicos). Spanner no necesita esperar a que se apliquen todas las mutaciones antes de enviar una respuesta, lo que significa que la escritura por lotes permite fallas parciales. También puedes ejecutar múltiples lotes escribe a la vez. Para obtener más información, consulta Cómo usar la escritura por lotes.

Casos de uso

La escritura por lotes de Spanner es muy útil si quieres confirmar un grandes cantidades de operaciones de escritura sin una operación de lectura, pero que no requieren una de todas tus mutaciones.

Si quieres agrupar tus solicitudes DML por lotes, usa batch DML. para modificar tus datos de Spanner. Para obtener más información sobre el sobre las diferencias entre el DML y las mutaciones, consulta Compara el DML y las mutaciones.

Para las solicitudes de mutación única, recomendamos usar un bloqueo de lectura y escritura transacción.

Limitaciones

La escritura por lotes de Spanner tiene las siguientes limitaciones:

  • La escritura por lotes de Spanner no está disponible si se usa La consola de Google Cloud o Google Cloud CLI. Solo está disponible si se usa REST y RPC APIs y la biblioteca cliente de Java para Spanner.

  • Protección contra la repetición La escritura por lotes no es compatible. Es posible que las mutaciones sean aplicar más de una vez, y una mutación que se aplica más de una vez podría un error. Por ejemplo, si una mutación de inserción se vuelve a reproducir, podría produce un error que ya existe o si usas claves basadas en marcas de tiempo en la mutación, es posible que se deban usar agregado a la tabla. Te recomendamos estructurar las escrituras para que sean idempotentes. evitar este problema.

  • No puedes revertir una solicitud de escritura por lotes completada. Puedes cancelar un solicitud de escritura por lotes en curso. Si cancelas una escritura por lotes en curso, en los grupos no completados se revierten. Mutaciones en grupos completados se confirman en la base de datos.

  • El tamaño máximo de una solicitud de escritura por lotes es el mismo que el límite de una una solicitud de confirmación. Para obtener más información, consulta Límites para crear, leer, actualizar y borrar datos.

Cómo usar la escritura por lotes

Para usar la escritura por lotes, debes tener el permiso spanner.databases.write en la base de datos que quieres modificar. Puedes escribir mutaciones por lotes de forma no atómica en una sola llamada con un REST o API de RPC solicitar una llamada.

Debes agrupar los siguientes tipos de mutación cuando uses la escritura por lotes:

  • Insertar filas con el mismo prefijo de clave primaria en el elemento superior y el secundario en diferentes tipos de tablas particionadas.
  • Insertar filas en tablas con una relación de clave externa entre ellas
  • Otros tipos de mutaciones relacionadas según el esquema de tu base de datos y la lógica de la aplicación.

También puedes escribir por lotes con la biblioteca cliente de Spanner para Java. En el siguiente ejemplo de código, se actualiza la tabla Singers con filas nuevas.

Java 


import com.google.api.gax.rpc.ServerStream;
import com.google.cloud.spanner.DatabaseClient;
import com.google.cloud.spanner.DatabaseId;
import com.google.cloud.spanner.Mutation;
import com.google.cloud.spanner.MutationGroup;
import com.google.cloud.spanner.Options;
import com.google.cloud.spanner.Spanner;
import com.google.cloud.spanner.SpannerOptions;
import com.google.common.collect.ImmutableList;
import com.google.rpc.Code;
import com.google.spanner.v1.BatchWriteResponse;

public class BatchWriteAtLeastOnceSample {

  /***
   * Assume DDL for the underlying database:
   * <pre>{@code
   *   CREATE TABLE Singers (
   *     SingerId   INT64 NOT NULL,
   *     FirstName  STRING(1024),
   *     LastName   STRING(1024),
   *   ) PRIMARY KEY (SingerId)
   *
   *   CREATE TABLE Albums (
   *     SingerId     INT64 NOT NULL,
   *     AlbumId      INT64 NOT NULL,
   *     AlbumTitle   STRING(1024),
   *   ) PRIMARY KEY (SingerId, AlbumId),
   *   INTERLEAVE IN PARENT Singers ON DELETE CASCADE
   * }</pre>
   */

  private static final MutationGroup MUTATION_GROUP1 =
      MutationGroup.of(
          Mutation.newInsertOrUpdateBuilder("Singers")
              .set("SingerId")
              .to(16)
              .set("FirstName")
              .to("Scarlet")
              .set("LastName")
              .to("Terry")
              .build());
  private static final MutationGroup MUTATION_GROUP2 =
      MutationGroup.of(
          Mutation.newInsertOrUpdateBuilder("Singers")
              .set("SingerId")
              .to(17)
              .set("FirstName")
              .to("Marc")
              .build(),
          Mutation.newInsertOrUpdateBuilder("Singers")
              .set("SingerId")
              .to(18)
              .set("FirstName")
              .to("Catalina")
              .set("LastName")
              .to("Smith")
              .build(),
          Mutation.newInsertOrUpdateBuilder("Albums")
              .set("SingerId")
              .to(17)
              .set("AlbumId")
              .to(1)
              .set("AlbumTitle")
              .to("Total Junk")
              .build(),
          Mutation.newInsertOrUpdateBuilder("Albums")
              .set("SingerId")
              .to(18)
              .set("AlbumId")
              .to(2)
              .set("AlbumTitle")
              .to("Go, Go, Go")
              .build());

  static void batchWriteAtLeastOnce() {
    // TODO(developer): Replace these variables before running the sample.
    final String projectId = "my-project";
    final String instanceId = "my-instance";
    final String databaseId = "my-database";
    batchWriteAtLeastOnce(projectId, instanceId, databaseId);
  }

  static void batchWriteAtLeastOnce(String projectId, String instanceId, String databaseId) {
    try (Spanner spanner =
        SpannerOptions.newBuilder().setProjectId(projectId).build().getService()) {
      DatabaseId dbId = DatabaseId.of(projectId, instanceId, databaseId);
      final DatabaseClient dbClient = spanner.getDatabaseClient(dbId);

      // Creates and issues a BatchWrite RPC request that will apply the mutation groups
      // non-atomically and respond back with a stream of BatchWriteResponse.
      ServerStream<BatchWriteResponse> responses =
          dbClient.batchWriteAtLeastOnce(
              ImmutableList.of(MUTATION_GROUP1, MUTATION_GROUP2),
              Options.tag("batch-write-tag"));

      // Iterates through the results in the stream response and prints the MutationGroup indexes,
      // commit timestamp and status.
      for (BatchWriteResponse response : responses) {
        if (response.getStatus().getCode() == Code.OK_VALUE) {
          System.out.printf(
              "Mutation group indexes %s have been applied with commit timestamp %s",
              response.getIndexesList(), response.getCommitTimestamp());
        } else {
          System.out.printf(
              "Mutation group indexes %s could not be applied with error code %s and "
                  + "error message %s", response.getIndexesList(),
              Code.forNumber(response.getStatus().getCode()), response.getStatus().getMessage());
        }
      }
    }
  }
}

¿Qué sigue?