Modificar dados usando a gravação em lote

Nesta página, descrevemos as solicitações de gravação em lote do Spanner e como usá-las modificar os dados do Spanner.

Use a gravação em lote do Spanner para inserir, atualizar ou excluir várias linhas nas tabelas do Spanner. Spanner. A gravação em lote oferece suporte a gravações de baixa latência sem uma operação de leitura e retorna respostas rápidas já que 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 de aguardar que todas as mutações sejam aplicadas antes de enviar uma resposta, o que significa gravação em lote permite falha parcial. Também é possível executar diversos gravações de cada vez. Para mais informações, consulte Como usar gravação em lote.

Casos de uso

A gravação em lote do Spanner é especialmente útil se você quiser confirmar um de gravações sem uma operação de leitura, mas sem a necessidade para todas as suas mutações.

Se você quiser agrupar as solicitações DML, use a DML em lote para modificar os dados do Spanner. Para mais informações sobre as diferenças entre DML e 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 bloqueada.

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 Google Cloud CLI. Ele está disponível apenas usando APIs REST e RPC e a biblioteca de cliente Java do Spanner.

  • Proteção contra repetição não oferece suporte ao uso da 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 a evitar esse problema.

  • Não é possível reverter uma solicitação de gravação em lote concluída. Você pode cancelar uma uma solicitação de gravação em lote em andamento. Se você cancelar uma gravação em lote em andamento, mutações em grupos não concluídos sã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 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.
  • Inserção de linhas em tabelas com um relacionamento de chave externa entre as tabelas.
  • Outros tipos de mutações relacionadas, dependendo do esquema do seu banco de dados e 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