Modificar dados usando a gravação em lote

Esta página descreve as solicitações de gravação em lote do Spanner e como usá-las para modificar seus dados do Spanner.

É possível usar a gravação em lote do Spanner para inserir, atualizar ou excluir várias linhas nas tabelas do Spanner. A gravação em lote do Spanner oferece suporte a gravações de baixa latência sem uma operação de leitura e retorna respostas conforme as mutações são aplicadas em lotes. Para usar a gravação em lote, você agrupa mutações relacionadas, e todas as mutações em um grupo são confirmadas atomicamente. As mutações entre grupos são aplicadas em uma ordem não especificada e são independentes umas das outras (não atômicas). O Spanner não precisa esperar que todas as mutações sejam aplicadas antes de enviar uma resposta, o que significa que a gravação em lote permite falhas parciais. Também é possível executar várias gravações em lote por vez. Para mais informações, consulte Como usar a gravação em lote.

Casos de uso

A gravação em lote do Spanner é especialmente útil se você quiser confirmar um grande número de gravações sem uma operação de leitura, mas não precisar de uma transação atômica para todas as suas mutações.

Se você quiser agrupar suas solicitações DML, use a DML em lote para modificar os dados do Spanner. Para mais informações sobre as diferenças entre a DML e as mutações, consulte Comparação entre DML e mutações.

Para solicitações de mutação única, recomendamos usar uma transação de leitura-gravação de bloqueio.

Limitações

A gravação em lote do Spanner tem as seguintes limitações:

  • A gravação em lote do Spanner não está disponível usando o console do Google Cloud ou a Google Cloud CLI. Ele só está disponível usando APIs REST e RPC e a biblioteca de cliente Java do Spanner.

  • A proteção contra repetição não é compatível com a gravação em lote. É possível que as mutações sejam aplicadas mais de uma vez, e uma mutação que é aplicada mais de uma vez pode resultar em uma falha. Por exemplo, se uma mutação de inserção for repetida, ela poderá produzir um erro de "já existe" ou, se você usar chaves geradas ou de confirmação com base no carimbo de data/hora na mutação, isso poderá resultar na adição de outras linhas à tabela. Recomendamos estruturar suas gravações para que sejam idempotentes e evitar esse problema.

  • Não é possível reverter uma solicitação de gravação em lote concluída. É possível cancelar uma solicitação de gravação em lote em andamento. Se você cancelar uma gravação em lote em andamento, as mutações em grupos incompletos serão revertidas. As mutações em grupos concluídos são confirmadas no banco de dados.

  • O tamanho máximo de uma solicitação de gravação em lote é o mesmo do limite de uma solicitação de confirmação. Para mais informações, consulte Limites para criar, ler, atualizar e excluir dados.

Como usar a gravação em lote

Para usar a gravação em lote, você precisa ter a permissão spanner.databases.write no banco de dados que você quer modificar. É possível gravar mutações em lote de forma não atômica em uma única chamada usando uma chamada de solicitação REST ou API RPC.

Agrupe os seguintes tipos de mutação ao usar a gravação em lote:

  • Inserir linhas com o mesmo prefixo de chave primária nas tabelas mãe e filha.
  • Inserir linhas em tabelas com uma relação de chave externa entre elas.
  • Outros tipos de mutações relacionadas, dependendo do esquema do banco de dados e da lógica do aplicativo.

Também é possível fazer gravações em lote usando a biblioteca de cliente Java do Spanner. O exemplo de código a seguir atualiza a tabela Singers com novas linhas.

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

A seguir