Modificar dados usando 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, agrupe relacionadas, e todas as mutações de um grupo são comprometidas de maneira atômica. 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 a aplicação de todas as mutações 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 suas solicitações DML, use o DML em lote para modificar os dados do Spanner. Para mais informações sobre diferenças entre DML e mutações, consulte Comparação entre DML e mutações.

Para solicitações de mutação única, recomendamos o uso de um método de bloqueio de leitura e gravação transação.

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 só está disponível usando 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 aplicada mais de uma vez, e uma mutação aplicada mais de uma vez pode em caso de falha. Por exemplo, se uma mutação de inserção for repetida, ela poderá produz um erro já existente ou, se você usar os comandos gerados ou de confirmação com base em carimbo de data/hora na mutação, isso pode resultar em linhas adicionais adicionados à tabela. Recomendamos estruturar suas gravações para que sejam idempotentes 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. Mutações em grupos concluídos estão confirmados no banco de dados.

  • O tamanho máximo de uma solicitação de gravação em lote é igual ao limite para 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 em 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 um REST ou API RPC solicitar chamada.

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

  • Inserção de linhas com o mesmo prefixo de chave primária na mãe e na filha tabelas.
  • 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 do Spanner Java. 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