Visão geral das transações

Nesta página, descrevemos as transações no Spanner e apresentamos as interfaces de transação de leitura e gravação, somente leitura e DML particionada do Spanner.

Uma transação no Spanner é um conjunto de leituras e gravações. Todas as operações em uma transação são atômicas, ou seja, todas são bem-sucedidas ou todas falham.

Uma sessão é usada para realizar transações em um banco de dados do Spanner. Uma sessão representa um canal de comunicação lógico com o serviço de banco de dados do Spanner. As sessões podem executar uma ou várias transações por vez. Para mais informações, consulte Sessões.

Tipos de transação

O Spanner é compatível com os seguintes tipos de transação, cada um projetado para padrões específicos de interação de dados:

  • Leitura e gravação: essas transações são usadas para operações de leitura e gravação, seguidas por uma confirmação. Eles podem adquirir bloqueios. Se falharem, será necessário tentar de novo. Embora estejam confinados a um único banco de dados, eles podem modificar dados em várias tabelas desse banco de dados.

  • Somente leitura: essas transações garantem a consistência dos dados em várias operações de leitura, mas não permitem modificações de dados. Elas são executadas em um carimbo de data/hora determinado pelo sistema para consistência ou em um carimbo de data/hora anterior configurado pelo usuário. Ao contrário das transações de leitura e gravação, elas não exigem uma operação de commit ou bloqueios. No entanto, elas podem ser pausadas para aguardar a conclusão das operações de gravação em andamento.

  • DML particionada: esse tipo de transação executa instruções DML como operações de DML particionada. Ele é otimizado para executar instruções DML em grande escala, mas com restrições para garantir que a instrução seja idempotente e particionável de uma forma que permita que ela seja executada independentemente de outras partições. Para várias gravações que não precisam de uma transação atômica, use gravações em lote. Para mais informações, consulte Modificar dados usando gravações em lote.

Transações de leitura e gravação

Uma transação de leitura e gravação consiste em zero ou mais leituras ou instruções de consulta seguidas por uma solicitação de confirmação. A qualquer momento antes da solicitação de commit, o cliente pode enviar uma solicitação de reversão para cancelar a transação.

Isolamento serializável

Usando o nível de isolamento serializável padrão com simultaneidade pessimista, as transações de leitura e gravação leem, modificam e gravam dados de forma atômica. Esse tipo de transação é externamente consistente.

Ao usar transações de leitura e gravação, recomendamos que você minimize o tempo em que uma transação fica ativa. Durações de transação mais curtas resultam em bloqueios mantidos por menos tempo, o que aumenta a probabilidade de uma confirmação bem-sucedida e reduz a contenção. Isso ocorre porque bloqueios de longa duração podem levar a impasses e cancelamentos de transações. O Spanner tenta manter os bloqueios de leitura ativos enquanto a transação continuar realizando leituras e não for encerrada por commit ou reverter. Se o cliente permanecer inativo por longos períodos, o Spanner poderá liberar os bloqueios da transação e abortar a transação.

Para executar uma operação de gravação que depende de uma ou mais operações de leitura, use uma transação de leitura/gravação:

  • Se você precisar confirmar uma ou mais operações de gravação atomicamente, execute essas gravações na mesma transação de leitura e gravação. Por exemplo, se você transferir US$ 200 da conta A para a conta B, realize as duas operações de gravação (diminuindo US $200 da conta A e aumentando US $200 da conta B) e as leituras dos saldos iniciais da conta na mesma transação.
  • Se você quiser dobrar o saldo da conta A, execute as operações de leitura e gravação na mesma transação. Isso garante que o sistema leia o saldo antes de dobrá-lo e atualizá-lo.
  • Se as operações de gravação dependerem das operações de leitura, execute ambas na mesma transação de leitura e gravação, mesmo que as gravações não sejam executadas. Por exemplo, se você quiser transferir US $200 da conta A para a conta B somente se o saldo de A for maior que US $500, inclua a leitura do saldo de A e as operações de gravação condicional na mesma transação, mesmo que a transferência não ocorra.

Para realizar operações de leitura, use um único método de leitura ou uma transação somente leitura:

  • Se você estiver realizando apenas operações de leitura e puder expressar a operação de leitura usando um método de leitura única, use o método de leitura única ou uma transação somente leitura. Ao contrário das transações de leitura e gravação, as leituras únicas não adquirem bloqueios.

Como alternativa, também é possível configurar o isolamento serializável para usar a simultaneidade otimista. O controle de simultaneidade otimista pressupõe que os conflitos são raros. As leituras e consultas, mesmo em uma transação de leitura e gravação, prosseguem sem adquirir bloqueios. Com o isolamento serializável, as leituras são validadas no momento da confirmação. Isso garante que nenhuma outra transação confirmada simultaneamente tenha modificado os dados lidos anteriormente pela transação.

Isolamento de leitura repetível

No Spanner, o isolamento de leitura repetível é implementado usando uma técnica conhecida como isolamento de snapshot. O isolamento de leitura repetível garante que todas as operações de leitura em uma transação sejam consistentes com o banco de dados como ele existia no início da transação. Ele também garante que as gravações simultâneas nos mesmos dados só sejam bem-sucedidas se não houver conflitos.

Com a simultaneidade otimista padrão, as gravações não adquirem bloqueios até o momento da confirmação. Se houver um conflito com os dados gravados ou devido a eventos temporários no Spanner, como a reinicialização de um servidor, o Spanner ainda poderá cancelar as transações. Como as leituras em transações de leitura/gravação não adquirem bloqueios no isolamento de leitura repetível, não há diferença entre executar operações somente leitura em uma transação somente leitura ou de leitura/gravação.

Use a simultaneidade pessimista com leitura repetível para adquirir bloqueios exclusivos para dados lidos com uma cláusula FOR UPDATE ou a dica lock_scanned_ranges=exclusive e para dados gravados por consultas DML. Essa semântica é mais semelhante ao comportamento de bloqueio do isolamento de leitura repetível em outros bancos de dados. Com a simultaneidade pessimista, todas as leituras são exibidas no snapshot. Portanto, as transações podem ser canceladas se transações simultâneas atualizarem os dados lidos. No entanto, ele impede que transações simultâneas atualizem os dados bloqueados desde o momento em que os bloqueios são adquiridos até o momento da confirmação, o que pode reduzir possíveis conflitos de gravação-gravação.

Considere usar transações de leitura e gravação em isolamento de leitura repetível nos seguintes cenários:

  • A carga de trabalho tem alta demanda de leitura e poucos conflitos de gravação.
  • O aplicativo está enfrentando gargalos de desempenho devido a atrasos de concorrência de bloqueio e cancelamentos de transações causados por transações mais antigas e de maior prioridade que prejudicam as transações mais recentes e de menor prioridade para evitar possíveis impasses (wound-wait).
  • O aplicativo não exige as garantias mais rígidas fornecidas pelo nível de isolamento serializável.

Considere usar o isolamento de leitura repetível com simultaneidade pessimista para cargas de trabalho em que as instruções FOR UPDATE e DML adquirem bloqueios.

Ao realizar uma operação de gravação que depende de uma ou mais operações de leitura, pode ocorrer distorção de gravação no isolamento de leitura repetível. A distorção de gravação surge de um tipo específico de atualização simultânea, em que cada atualização é aceita de forma independente, mas o efeito combinado viola a integridade dos dados do aplicativo. Portanto, faça leituras que façam parte da seção crítica de uma transação com uma cláusula FOR UPDATE ou uma dica lock_scanned_ranges=exclusive para evitar distorções de gravação. Para mais informações, consulte Conflitos de leitura e gravação e correção e o exemplo discutido em Semântica de leitura e gravação.

Interface

As bibliotecas de cliente do Spanner fornecem uma interface para executar um corpo de trabalho em uma transação de leitura e gravação, com novas tentativas de cancelamento de transações. Uma transação pode exigir várias novas tentativas antes de ser confirmada.

Várias situações podem causar o cancelamento de transações. Por exemplo, se duas transações tentarem modificar dados simultaneamente, poderá ocorrer um deadlock. Nesses casos, o Spanner cancela uma transação para permitir que a outra prossiga. Com menos frequência, eventos temporários no Spanner também podem causar cancelamentos de transações.

Todas as transações de leitura/gravação fornecem as propriedades ACID de bancos de dados relacionais. Como as transações são atômicas, uma transação cancelada não afeta o banco de dados. As bibliotecas de cliente do Spanner tentam realizar essas transações novamente de forma automática. Se você não usar as bibliotecas de cliente, tente realizar a transação novamente para melhorar as taxas de sucesso. Cada nova tentativa que resulta em um erro ABORTED aumenta a prioridade de bloqueio da transação. Para manter essa prioridade de bloqueio, tente novamente a transação na mesma sessão. Se você usar sessões multiplexadas, também defina TransactionOptions.ReadWrite.multiplexed_session_previous_transaction_id como o ID da transação cancelada ao iniciar a nova tentativa. Além disso, os drivers de cliente do Spanner incluem uma lógica interna de nova tentativa de transação que mascara erros temporários ao executar novamente a transação.

Se você usar sessões multiplexadas, as bibliotecas de cliente do Spanner vão enviar o ID da transação cancelada com cada nova tentativa. Isso permite que a transação repetida mantenha a prioridade de bloqueio, mesmo que outras transações compartilhem a mesma sessão.

Ao usar uma transação em uma biblioteca de cliente do Spanner, você define o corpo da transação como um objeto de função. Essa função encapsula as leituras e gravações realizadas em uma ou mais tabelas do banco de dados. A biblioteca de cliente do Spanner executa essa função repetidamente até que a transação seja confirmada ou encontre um erro que não possa ser repetido.

Esse loop de repetição é separado das configurações de tempo limite e repetição para RPCs individuais, e a duração padrão dele depende da biblioteca de cliente. Para limitar o tempo total de uma transação, incluindo novas tentativas, consulte Configurar o tempo limite da transação.

Exemplo

Suponha que você tenha uma coluna MarketingBudget na tabela Albums:

CREATE TABLE Albums (
  SingerId        INT64 NOT NULL,
  AlbumId         INT64 NOT NULL,
  AlbumTitle      STRING(MAX),
  MarketingBudget INT64
) PRIMARY KEY (SingerId, AlbumId);

O departamento de marketing pede que você transfira US $200.000 do orçamento de Albums (2, 2) para Albums (1, 1), mas apenas se o dinheiro estiver disponível no orçamento desse álbum. Use uma transação de leitura/gravação com bloqueio para essa operação, porque a transação pode realizar gravações dependendo do resultado de uma leitura.

Os exemplos de biblioteca de cliente a seguir mostram como executar uma transação de leitura e gravação usando o nível de isolamento serializável padrão:

C++

void ReadWriteTransaction(google::cloud::spanner::Client client) {
  namespace spanner = ::google::cloud::spanner;
  using ::google::cloud::Status;
  using ::google::cloud::StatusCode;
  using ::google::cloud::StatusOr;

  // A helper to read a single album MarketingBudget.
  auto get_current_budget =
      [](spanner::Client client, spanner::Transaction txn,
         std::int64_t singer_id,
         std::int64_t album_id) -> StatusOr<std::int64_t> {
    auto key = spanner::KeySet().AddKey(spanner::MakeKey(singer_id, album_id));
    auto rows = client.Read(std::move(txn), "Albums", std::move(key),
                            {"MarketingBudget"});
    using RowType = std::tuple<std::int64_t>;
    auto row = spanner::GetSingularRow(spanner::StreamOf<RowType>(rows));
    if (!row) return std::move(row).status();
    return std::get<0>(*std::move(row));
  };

  auto constexpr kInsufficientFundsMessage =
      "The second album does not have enough funds to transfer";
  auto commit = client.Commit(
      [&](spanner::Transaction const& txn) -> StatusOr<spanner::Mutations> {
        auto b1 = get_current_budget(client, txn, 1, 1);
        if (!b1) return std::move(b1).status();
        auto b2 = get_current_budget(client, txn, 2, 2);
        if (!b2) return std::move(b2).status();
        std::int64_t transfer_amount = 200000;

        if (*b2 < transfer_amount) {
          return Status(StatusCode::kFailedPrecondition,
                        kInsufficientFundsMessage);
        }

        return spanner::Mutations{
            spanner::UpdateMutationBuilder(
                "Albums", {"SingerId", "AlbumId", "MarketingBudget"})
                .EmplaceRow(1, 1, *b1 + transfer_amount)
                .EmplaceRow(2, 2, *b2 - transfer_amount)
                .Build()};
      });

  if (!commit) throw std::move(commit).status();
  std::cout << "Transfer was successful [spanner_read_write_transaction]\n";
}

C#


using Google.Cloud.Spanner.Data;
using System;
using System.Threading.Tasks;
using System.Transactions;

public class ReadWriteWithTransactionAsyncSample
{
    public async Task<int> ReadWriteWithTransactionAsync(string projectId, string instanceId, string databaseId)
    {
        // This sample transfers 200,000 from the MarketingBudget
        // field of the second Album to the first Album. Make sure to run
        // the Add Column and Write Data To New Column samples first,
        // in that order.

        string connectionString = $"Data Source=projects/{projectId}/instances/{instanceId}/databases/{databaseId}";

        using TransactionScope scope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled);
        decimal transferAmount = 200000;
        decimal secondBudget = 0;
        decimal firstBudget = 0;

        using var connection = new SpannerConnection(connectionString);
        using var cmdLookup1 = connection.CreateSelectCommand("SELECT * FROM Albums WHERE SingerId = 2 AND AlbumId = 2");

        using (var reader = await cmdLookup1.ExecuteReaderAsync())
        {
            while (await reader.ReadAsync())
            {
                // Read the second album's budget.
                secondBudget = reader.GetFieldValue<decimal>("MarketingBudget");
                // Confirm second Album's budget is sufficient and
                // if not raise an exception. Raising an exception
                // will automatically roll back the transaction.
                if (secondBudget < transferAmount)
                {
                    throw new Exception($"The second album's budget {secondBudget} is less than the amount to transfer.");
                }
            }
        }

        // Read the first album's budget.
        using var cmdLookup2 = connection.CreateSelectCommand("SELECT * FROM Albums WHERE SingerId = 1 and AlbumId = 1");
        using (var reader = await cmdLookup2.ExecuteReaderAsync())
        {
            while (await reader.ReadAsync())
            {
                firstBudget = reader.GetFieldValue<decimal>("MarketingBudget");
            }
        }

        // Specify update command parameters.
        using var cmdUpdate = connection.CreateUpdateCommand("Albums", new SpannerParameterCollection
        {
            { "SingerId", SpannerDbType.Int64 },
            { "AlbumId", SpannerDbType.Int64 },
            { "MarketingBudget", SpannerDbType.Int64 },
        });

        // Update second album to remove the transfer amount.
        secondBudget -= transferAmount;
        cmdUpdate.Parameters["SingerId"].Value = 2;
        cmdUpdate.Parameters["AlbumId"].Value = 2;
        cmdUpdate.Parameters["MarketingBudget"].Value = secondBudget;
        var rowCount = await cmdUpdate.ExecuteNonQueryAsync();

        // Update first album to add the transfer amount.
        firstBudget += transferAmount;
        cmdUpdate.Parameters["SingerId"].Value = 1;
        cmdUpdate.Parameters["AlbumId"].Value = 1;
        cmdUpdate.Parameters["MarketingBudget"].Value = firstBudget;
        rowCount += await cmdUpdate.ExecuteNonQueryAsync();
        scope.Complete();
        Console.WriteLine("Transaction complete.");
        return rowCount;
    }
}

Go


import (
	"context"
	"fmt"
	"io"

	"cloud.google.com/go/spanner"
)

func writeWithTransaction(w io.Writer, db string) error {
	ctx := context.Background()
	client, err := spanner.NewClient(ctx, db)
	if err != nil {
		return err
	}
	defer client.Close()

	_, err = client.ReadWriteTransaction(ctx, func(ctx context.Context, txn *spanner.ReadWriteTransaction) error {
		getBudget := func(key spanner.Key) (int64, error) {
			row, err := txn.ReadRow(ctx, "Albums", key, []string{"MarketingBudget"})
			if err != nil {
				return 0, err
			}
			var budget int64
			if err := row.Column(0, &budget); err != nil {
				return 0, err
			}
			return budget, nil
		}
		album2Budget, err := getBudget(spanner.Key{2, 2})
		if err != nil {
			return err
		}
		const transferAmt = 200000
		if album2Budget >= transferAmt {
			album1Budget, err := getBudget(spanner.Key{1, 1})
			if err != nil {
				return err
			}
			album1Budget += transferAmt
			album2Budget -= transferAmt
			cols := []string{"SingerId", "AlbumId", "MarketingBudget"}
			txn.BufferWrite([]*spanner.Mutation{
				spanner.Update("Albums", cols, []interface{}{1, 1, album1Budget}),
				spanner.Update("Albums", cols, []interface{}{2, 2, album2Budget}),
			})
			fmt.Fprintf(w, "Moved %d from Album2's MarketingBudget to Album1's.", transferAmt)
		}
		return nil
	})
	return err
}

Java

static void writeWithTransaction(DatabaseClient dbClient) {
  dbClient
      .readWriteTransaction()
      .run(transaction -> {
        // Transfer marketing budget from one album to another. We do it in a transaction to
        // ensure that the transfer is atomic.
        Struct row =
            transaction.readRow("Albums", Key.of(2, 2), Arrays.asList("MarketingBudget"));
        long album2Budget = row.getLong(0);
        // Transaction will only be committed if this condition still holds at the time of
        // commit. Otherwise it will be aborted and the callable will be rerun by the
        // client library.
        long transfer = 200000;
        if (album2Budget >= transfer) {
          long album1Budget =
              transaction
                  .readRow("Albums", Key.of(1, 1), Arrays.asList("MarketingBudget"))
                  .getLong(0);
          album1Budget += transfer;
          album2Budget -= transfer;
          transaction.buffer(
              Mutation.newUpdateBuilder("Albums")
                  .set("SingerId")
                  .to(1)
                  .set("AlbumId")
                  .to(1)
                  .set("MarketingBudget")
                  .to(album1Budget)
                  .build());
          transaction.buffer(
              Mutation.newUpdateBuilder("Albums")
                  .set("SingerId")
                  .to(2)
                  .set("AlbumId")
                  .to(2)
                  .set("MarketingBudget")
                  .to(album2Budget)
                  .build());
        }
        return null;
      });
}

Node.js

// This sample transfers 200,000 from the MarketingBudget field
// of the second Album to the first Album, as long as the second
// Album has enough money in its budget. Make sure to run the
// addColumn and updateData samples first (in that order).

// Imports the Google Cloud client library
const {Spanner} = require('@google-cloud/spanner');

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// const projectId = 'my-project-id';
// const instanceId = 'my-instance';
// const databaseId = 'my-database';

// Creates a client
const spanner = new Spanner({
  projectId: projectId,
});

// Gets a reference to a Cloud Spanner instance and database
const instance = spanner.instance(instanceId);
const database = instance.database(databaseId);

const transferAmount = 200000;

// Note: the `runTransaction()` method is non blocking and returns "void".
// For sequential execution of the transaction use `runTransactionAsync()` method which returns a promise.
// For example: await database.runTransactionAsync(async (err, transaction) => { ... })
database.runTransaction(async (err, transaction) => {
  if (err) {
    console.error(err);
    return;
  }
  let firstBudget, secondBudget;
  const queryOne = {
    columns: ['MarketingBudget'],
    keys: [[2, 2]], // SingerId: 2, AlbumId: 2
  };

  const queryTwo = {
    columns: ['MarketingBudget'],
    keys: [[1, 1]], // SingerId: 1, AlbumId: 1
  };

  Promise.all([
    // Reads the second album's budget
    transaction.read('Albums', queryOne).then(results => {
      // Gets second album's budget
      const rows = results[0].map(row => row.toJSON());
      secondBudget = rows[0].MarketingBudget;
      console.log(`The second album's marketing budget: ${secondBudget}`);

      // Makes sure the second album's budget is large enough
      if (secondBudget < transferAmount) {
        throw new Error(
          `The second album's budget (${secondBudget}) is less than the transfer amount (${transferAmount}).`,
        );
      }
    }),

    // Reads the first album's budget
    transaction.read('Albums', queryTwo).then(results => {
      // Gets first album's budget
      const rows = results[0].map(row => row.toJSON());
      firstBudget = rows[0].MarketingBudget;
      console.log(`The first album's marketing budget: ${firstBudget}`);
    }),
  ])
    .then(() => {
      console.log(firstBudget, secondBudget);
      // Transfers the budgets between the albums
      firstBudget += transferAmount;
      secondBudget -= transferAmount;

      console.log(firstBudget, secondBudget);

      // Updates the database
      // Note: Cloud Spanner interprets Node.js numbers as FLOAT64s, so they
      // must be converted (back) to strings before being inserted as INT64s.
      transaction.update('Albums', [
        {
          SingerId: '1',
          AlbumId: '1',
          MarketingBudget: firstBudget.toString(),
        },
        {
          SingerId: '2',
          AlbumId: '2',
          MarketingBudget: secondBudget.toString(),
        },
      ]);
    })
    .then(() => {
      // Commits the transaction and send the changes to the database
      return transaction.commit();
    })
    .then(() => {
      console.log(
        `Successfully executed read-write transaction to transfer ${transferAmount} from Album 2 to Album 1.`,
      );
    })
    .catch(err => {
      console.error('ERROR:', err);
    })
    .then(() => {
      transaction.end();
      // Closes the database when finished
      return database.close();
    });
});

PHP

use Google\Cloud\Spanner\SpannerClient;
use Google\Cloud\Spanner\Transaction;
use UnexpectedValueException;

/**
 * Performs a read-write transaction to update two sample records in the
 * database.
 *
 * This will transfer 200,000 from the `MarketingBudget` field for the second
 * Album to the first Album. If the `MarketingBudget` for the second Album is
 * too low, it will raise an exception.
 *
 * Before running this sample, you will need to run the `update_data` sample
 * to populate the fields.
 * Example:
 * ```
 * read_write_transaction($instanceId, $databaseId);
 * ```
 *
 * @param string $instanceId The Spanner instance ID.
 * @param string $databaseId The Spanner database ID.
 */
function read_write_transaction(string $instanceId, string $databaseId): void
{
    $spanner = new SpannerClient();
    $instance = $spanner->instance($instanceId);
    $database = $instance->database($databaseId);

    $database->runTransaction(function (Transaction $t) use ($spanner) {
        $transferAmount = 200000;

        // Read the second album's budget.
        $secondAlbumKey = [2, 2];
        $secondAlbumKeySet = $spanner->keySet(['keys' => [$secondAlbumKey]]);
        $secondAlbumResult = $t->read(
            'Albums',
            $secondAlbumKeySet,
            ['MarketingBudget'],
            ['limit' => 1]
        );

        $firstRow = $secondAlbumResult->rows()->current();
        $secondAlbumBudget = $firstRow['MarketingBudget'];
        if ($secondAlbumBudget < $transferAmount) {
            // Throwing an exception will automatically roll back the transaction.
            throw new UnexpectedValueException(
                'The second album\'s budget is lower than the transfer amount: ' . $transferAmount
            );
        }

        $firstAlbumKey = [1, 1];
        $firstAlbumKeySet = $spanner->keySet(['keys' => [$firstAlbumKey]]);
        $firstAlbumResult = $t->read(
            'Albums',
            $firstAlbumKeySet,
            ['MarketingBudget'],
            ['limit' => 1]
        );

        // Read the first album's budget.
        $firstRow = $firstAlbumResult->rows()->current();
        $firstAlbumBudget = $firstRow['MarketingBudget'];

        // Update the budgets.
        $secondAlbumBudget -= $transferAmount;
        $firstAlbumBudget += $transferAmount;
        printf('Setting first album\'s budget to %s and the second album\'s ' .
            'budget to %s.' . PHP_EOL, $firstAlbumBudget, $secondAlbumBudget);

        // Update the rows.
        $t->updateBatch('Albums', [
            ['SingerId' => 1, 'AlbumId' => 1, 'MarketingBudget' => $firstAlbumBudget],
            ['SingerId' => 2, 'AlbumId' => 2, 'MarketingBudget' => $secondAlbumBudget],
        ]);

        // Commit the transaction!
        $t->commit();

        print('Transaction complete.' . PHP_EOL);
    });
}

Python

def read_write_transaction(instance_id, database_id):
    """Performs a read-write transaction to update two sample records in the
    database.

    This will transfer 200,000 from the `MarketingBudget` field for the second
    Album to the first Album. If the `MarketingBudget` is too low, it will
    raise an exception.

    Before running this sample, you will need to run the `update_data` sample
    to populate the fields.
    """
    spanner_client = spanner.Client()
    instance = spanner_client.instance(instance_id)
    database = instance.database(database_id)

    def update_albums(transaction):
        # Read the second album budget.
        second_album_keyset = spanner.KeySet(keys=[(2, 2)])
        second_album_result = transaction.read(
            table="Albums",
            columns=("MarketingBudget",),
            keyset=second_album_keyset,
            limit=1,
        )
        second_album_row = list(second_album_result)[0]
        second_album_budget = second_album_row[0]

        transfer_amount = 200000

        if second_album_budget < transfer_amount:
            # Raising an exception will automatically roll back the
            # transaction.
            raise ValueError("The second album doesn't have enough funds to transfer")

        # Read the first album's budget.
        first_album_keyset = spanner.KeySet(keys=[(1, 1)])
        first_album_result = transaction.read(
            table="Albums",
            columns=("MarketingBudget",),
            keyset=first_album_keyset,
            limit=1,
        )
        first_album_row = list(first_album_result)[0]
        first_album_budget = first_album_row[0]

        # Update the budgets.
        second_album_budget -= transfer_amount
        first_album_budget += transfer_amount
        print(
            "Setting first album's budget to {} and the second album's "
            "budget to {}.".format(first_album_budget, second_album_budget)
        )

        # Update the rows.
        transaction.update(
            table="Albums",
            columns=("SingerId", "AlbumId", "MarketingBudget"),
            values=[(1, 1, first_album_budget), (2, 2, second_album_budget)],
        )

    database.run_in_transaction(update_albums)

    print("Transaction complete.")

Ruby

# project_id  = "Your Google Cloud project ID"
# instance_id = "Your Spanner instance ID"
# database_id = "Your Spanner database ID"

require "google/cloud/spanner"

spanner         = Google::Cloud::Spanner.new project: project_id
client          = spanner.client instance_id, database_id
transfer_amount = 200_000

client.transaction do |transaction|
  first_album  = transaction.read("Albums", [:MarketingBudget], keys: [[1, 1]]).rows.first
  second_album = transaction.read("Albums", [:MarketingBudget], keys: [[2, 2]]).rows.first

  raise "The second album does not have enough funds to transfer" if second_album[:MarketingBudget] < transfer_amount

  new_first_album_budget  = first_album[:MarketingBudget] + transfer_amount
  new_second_album_budget = second_album[:MarketingBudget] - transfer_amount

  transaction.update "Albums", [
    { SingerId: 1, AlbumId: 1, MarketingBudget: new_first_album_budget  },
    { SingerId: 2, AlbumId: 2, MarketingBudget: new_second_album_budget }
  ]
end

puts "Transaction complete"

Para exemplos de como executar uma transação de leitura e gravação usando o isolamento de leitura repetível, consulte Usar o nível de isolamento de leitura repetível.

Semântica

Nesta seção, descrevemos a semântica das transações de leitura e gravação no Spanner.

Propriedades

O isolamento serializável é o nível de isolamento padrão no Spanner. No isolamento serializável, o Spanner oferece aos clientes as garantias mais rigorosas de controle de simultaneidade para transações, a consistência externa. Uma transação de leitura/gravação executa um conjunto de leituras e gravações de forma atômica. As gravações podem prosseguir sem serem bloqueadas por transações somente leitura. O carimbo de data/hora em que as transações de leitura e gravação são executadas corresponde ao tempo decorrido. A ordem de serialização corresponde à ordem do carimbo de data/hora.

Devido a essas propriedades, como desenvolvedor de aplicativos, você se concentra na exatidão de cada transação por si só, sem se preocupar em como proteger a execução dela contra outras transações que podem ser executadas ao mesmo tempo.

Também é possível executar transações de leitura e gravação usando o isolamento de leitura repetível. O isolamento de leitura repetível garante que todas as operações de leitura em uma transação vejam um snapshot forte e consistente do banco de dados como ele existia no início da transação. Para mais informações, consulte Isolamento de leitura repetível.

Transações de leitura e gravação com isolamento serializável

Depois de confirmar uma transação que contém uma série de leituras e gravações no isolamento serializável padrão, o seguinte se aplica:

  • A transação retorna valores que refletem um snapshot consistente no carimbo de data/hora de confirmação da transação.
  • As linhas ou intervalos vazios permanecem vazios no momento da confirmação.
  • A transação confirma todas as gravações no carimbo de data/hora de confirmação da transação.
  • Nenhuma transação pode ver as gravações até que a transação seja confirmada.

Os drivers de cliente do Spanner incluem uma lógica de repetição de transação que mascara erros temporários ao executar novamente a transação e validar os dados que o cliente observa.

O efeito é que todas as leituras e gravações parecem ter ocorrido em um único momento, tanto da perspectiva da própria transação quanto da perspectiva de outros leitores e gravadores no banco de dados do Spanner. Isso significa que as leituras e gravações ocorrem no mesmo carimbo de data/hora. Para ver um exemplo, consulte Capacidade de serialização e consistência externa.

Transações de leitura e gravação com isolamento de leitura repetível

Depois de confirmar uma transação com isolamento de leitura repetível, o seguinte se aplica:

  • A transação retorna valores que refletem um snapshot consistente do banco de dados. O snapshot normalmente é estabelecido durante a primeira operação de transação, que pode não ser igual ao carimbo de data/hora de confirmação.
  • Como a leitura repetível é implementada usando o isolamento de snapshot, a transação confirma todas as gravações no carimbo de data/hora de confirmação da transação somente se o conjunto de gravações não tiver mudado entre o carimbo de data/hora do snapshot da transação e o carimbo de data/hora de confirmação.
  • As outras transações não veem as gravações até que a transação seja confirmada.

Isolamento para transações de leitura e gravação com operações somente leitura

Quando uma transação de leitura e gravação executa apenas operações de leitura, ela oferece garantias de consistência semelhantes às de uma transação somente leitura. Todas as leituras na transação retornam dados de um carimbo de data/hora consistente, incluindo a confirmação de linhas inexistentes.

Uma diferença é quando uma transação de leitura e gravação é confirmada sem executar uma operação de gravação. Nesse cenário, não há garantia de que os dados lidos na transação permaneceram inalterados no banco de dados entre a operação de leitura e a confirmação da transação.

Para garantir a atualização de dados e validar que eles não foram modificados desde a última recuperação, é necessária uma leitura subsequente. Essa nova leitura pode ser realizada em outra transação de leitura e gravação ou com uma leitura forte.

Para otimizar a eficiência, se uma transação estiver realizando exclusivamente leituras, use uma transação somente leitura em vez de uma transação de leitura e gravação, especialmente ao usar o isolamento serializável.

Como a serialização e a consistência externa diferem da leitura repetível

Por padrão, o Spanner oferece garantias transacionais fortes, incluindo capacidade de serialização e consistência externa. Essas propriedades garantem que os dados permaneçam consistentes e que as operações ocorram em uma ordem previsível, mesmo em um ambiente distribuído.

A serialização garante que todas as transações pareçam ser executadas uma após a outra em uma única ordem sequencial, mesmo que sejam processadas simultaneamente. O Spanner faz isso atribuindo carimbos de data/hora de confirmação às transações, refletindo a ordem em que foram confirmadas.

O Spanner oferece uma garantia ainda mais forte, conhecida como consistência externa. Isso significa que não apenas as transações são confirmadas em uma ordem refletida pelos carimbos de data/hora de confirmação, mas esses carimbos também se alinham com o tempo real. Isso permite comparar carimbos de data/hora de commit com o tempo real, fornecendo uma visualização consistente e ordenada globalmente dos seus dados.

Em essência, se uma transação Txn1 for confirmada antes de outra transação Txn2 em tempo real, o carimbo de data/hora de confirmação de Txn1 será anterior ao carimbo de data/hora de confirmação de Txn2.

Veja o exemplo a seguir.

Linha do tempo que mostra a execução de duas transações que leem os mesmos dados

Nesse cenário, durante o cronograma t:

  • A transação Txn1 lê os dados A, prepara uma gravação em A e, em seguida, faz o commit.
  • A transação Txn2 começa depois que Txn1 é iniciada. Ele lê os dados B e, em seguida, os dados A.

Mesmo que Txn2 tenha começado antes da conclusão de Txn1, Txn2 observa as mudanças feitas por Txn1 em A. Isso ocorre porque Txn2 lê A depois que Txn1 confirma a gravação em A.

Embora Txn1 e Txn2 possam se sobrepor no tempo de execução, os carimbos de data/hora de confirmação, c1 e c2, respectivamente, aplicam uma ordem de transação linear. Isso significa que:

  • Todas as leituras e gravações em Txn1 parecem ter ocorrido em um único momento, c1.
  • Todas as leituras e gravações em Txn2 parecem ter ocorrido em um único momento, c2.
  • É importante ressaltar que c1 é anterior a c2 para gravações confirmadas, mesmo que as gravações tenham ocorrido em máquinas diferentes. Se Txn2 realizar apenas leituras, c1 será anterior ou simultâneo a c2.

Essa ordenação forte significa que, se uma operação de leitura subsequente observar os efeitos de Txn2, ela também vai observar os efeitos de Txn1. Essa propriedade é verdadeira para todas as transações confirmadas.

Por outro lado, se você usar o isolamento de leitura repetível, o seguinte cenário vai ocorrer para as mesmas transações:

  • Txn1 começa lendo os dados A, criando o próprio snapshot do banco de dados naquele momento.
  • Em seguida, Txn2 começa, lendo os dados B e estabelecendo o próprio snapshot.
  • Em seguida, Txn1 modifica os dados A e confirma as mudanças.
  • Txn2 tenta ler os dados A. Como está operando em um snapshot anterior, Txn2 não vê a atualização que Txn1 acabou de fazer em A. Txn2 lê o valor mais antigo.
  • Txn2 modifica os dados B e faz commits.

Nesse cenário, cada transação opera no próprio snapshot consistente do banco de dados, tirado no momento em que a transação começa. Essa sequência pode levar a uma anomalia de distorção de gravação se a gravação em B por Txn2 depender logicamente do valor lido em A. Em essência, Txn2 fez as atualizações com base em informações desatualizadas, e a gravação subsequente pode violar uma invariante no nível do aplicativo. Para evitar que esse cenário ocorra, use SELECT...FOR UPDATE para isolamento de leitura repetível ou crie restrições de verificação no esquema.

Garantias de leitura e gravação em caso de falha na transação

Se uma chamada para executar uma transação falhar, as garantias de leitura e gravação que você tem dependem do erro que causou a falha na chamada de commit subjacente.

O Spanner pode executar as operações de uma transação várias vezes internamente. Se uma tentativa de execução falhar, o erro retornado vai especificar as condições que ocorreram e indicar as garantias que você recebe. No entanto, se o Spanner repetir a transação, os efeitos colaterais das operações (por exemplo, alterações em sistemas externos ou em um estado do sistema fora de um banco de dados do Spanner) poderão ocorrer várias vezes.

Quando uma transação do Spanner falha, as garantias que você recebe para leituras e gravações dependem do erro específico encontrado durante a operação de confirmação.

Por exemplo, uma mensagem de erro como "Linha não encontrada" ou "A linha já existe" indica um problema durante a gravação de mutações em buffer. Isso pode ocorrer se, por exemplo, uma linha que o cliente está tentando atualizar não existir. Nesses cenários:

  • As leituras são consistentes: todos os dados lidos durante a transação são consistentes até o ponto do erro.
  • As gravações não são aplicadas: as mutações que a transação tentou fazer não são confirmadas no banco de dados.
  • Consistência de linha: a não existência (ou estado atual) da linha que acionou o erro é consistente com as leituras realizadas na transação.

É possível cancelar operações de leitura assíncronas no Spanner a qualquer momento sem afetar outras operações em andamento na mesma transação. Essa flexibilidade é útil se uma operação de nível superior for cancelada ou se você decidir interromper uma leitura com base nos resultados iniciais.

No entanto, é importante entender que solicitar o cancelamento de uma leitura não garante o encerramento imediato dela. Após uma solicitação de cancelamento, a operação de leitura ainda pode:

  • Conclusão: a leitura pode terminar o processamento e retornar resultados antes que o cancelamento entre em vigor.
  • Falha por outro motivo: a leitura pode ser encerrada devido a um erro diferente, como uma interrupção.
  • Retornar resultados incompletos: a leitura pode retornar resultados parciais, que são validados como parte do processo de confirmação da transação.

O cancelamento de uma operação de commit cancela toda a transação, a menos que ela já tenha sido confirmada ou tenha falhado por outro motivo.

Atomicidade, consistência, durabilidade

Além do isolamento, o Spanner oferece as outras garantias de propriedade ACID:

  • Atomicidade: uma transação é considerada atômica se todas as operações de TI forem concluídas com sucesso ou nenhuma delas. Se alguma operação em uma transação falhar, toda a transação será revertida para o estado original, garantindo a integridade de dados.
  • Consistência: uma transação precisa manter a integridade das regras e restrições do banco de dados. Depois que uma transação é concluída, o banco de dados precisa estar em um estado válido, de acordo com as regras predefinidas.
  • Durabilidade: depois que uma transação é confirmada, as mudanças são armazenadas permanentemente no banco de dados e persistem em caso de falhas do sistema, interrupções de energia ou outras interrupções.

Desempenho

Nesta seção, descrevemos os problemas que afetam o desempenho das transações de leitura e gravação.

Controle de simultaneidade de bloqueio

Por padrão, o Spanner permite que vários clientes interajam com o mesmo banco de dados simultaneamente no nível de isolamento serializável padrão. Para manter a consistência dos dados nessas transações simultâneas, o Spanner tem um mecanismo de bloqueio que usa bloqueios compartilhados e exclusivos. Esses bloqueios de leitura são adquiridos apenas para transações serializáveis, mas não para transações que usam isolamento de leitura repetível.

Quando uma transação serializável executa uma operação de leitura, o Spanner adquire bloqueios de leitura compartilhados nos dados relevantes. Esses bloqueios compartilhados permitem que outras operações de leitura simultâneas acessem os mesmos dados. Essa simultaneidade é mantida até que a transação se prepare para confirmar as alterações.

No isolamento serializável, durante a fase de confirmação, conforme as gravações são aplicadas, a transação tenta fazer upgrade dos bloqueios para bloqueios exclusivos. Para isso, o Spanner faz o seguinte:

  • Bloqueia novas solicitações de bloqueio de leitura compartilhada nos dados afetados.
  • Aguarda a liberação de todos os bloqueios de leitura compartilhados nos dados.
  • Depois que todos os bloqueios de leitura compartilhados são liberados, ele coloca um bloqueio exclusivo, concedendo acesso único aos dados durante a gravação.

Por outro lado, nem o isolamento serializável do Spanner com simultaneidade otimista nem o isolamento de leitura repetível com simultaneidade otimista adquirem bloqueios durante a execução da transação. Ao confirmar, a transação adquire bloqueios exclusivos para os dados gravados. A transação pode ter que esperar por bloqueios se uma transação simultânea também estiver confirmando gravações nos mesmos dados.

No isolamento de leitura repetível com simultaneidade pessimista, os bloqueios exclusivos são adquiridos para os dados lidos por consultas que usam FOR UPDATE ou a dica lock_scanned_ranges=exclusive e para dados gravados com consultas DML. Portanto, não é necessário adquirir mais bloqueios no momento da confirmação.

Observações sobre bloqueios:

  • Granularidade: o Spanner aplica bloqueios na granularidade de linha e coluna. Isso significa que, se a transação T1 mantiver um bloqueio na coluna A da linha albumid, a transação T2 ainda poderá gravar simultaneamente na coluna B da mesma linha albumid sem conflito.
  • Gravações sem leituras:

    • Quando não há leituras na transação, o Spanner pode não exigir um bloqueio exclusivo para gravações sem leituras. Em vez disso, ele pode usar um bloqueio compartilhado de gravação. Isso ocorre porque a ordem de aplicação para gravações sem leituras é determinada pelos carimbos de data/hora de confirmação, permitindo que vários gravadores operem no mesmo item simultaneamente sem conflitos. Um bloqueio exclusivo só é necessário se a transação ler primeiro os dados que pretende gravar.
    • No isolamento de leitura repetível, as transações geralmente adquirem bloqueios exclusivos para células gravadas no momento da confirmação.
  • Índices secundários para pesquisas de linha: no isolamento serializável, ao realizar leituras em uma transação de leitura e gravação, o uso de índices secundários pode melhorar significativamente o desempenho. Ao usar índices secundários para limitar as linhas verificadas a um intervalo menor, o Spanner bloqueia menos linhas na tabela, permitindo uma maior modificação simultânea de linhas fora desse intervalo específico.

  • Acesso exclusivo a recursos externos: os bloqueios internos do Spanner são projetados para garantir a consistência dos dados no próprio banco de dados do Spanner. Não as use para garantir acesso exclusivo a recursos fora do Spanner. O Spanner pode cancelar transações por vários motivos, incluindo otimizações internas do sistema, como movimentação de dados entre recursos de computação. Se uma transação for repetida (explicitamente pelo código do aplicativo ou implicitamente por bibliotecas de cliente, como o driver JDBC do Spanner), os bloqueios só serão garantidos durante a tentativa de confirmação bem-sucedida.

  • Estatísticas de bloqueio: para diagnosticar e investigar conflitos de bloqueio no seu banco de dados, use a ferramenta de introspecção Estatísticas de bloqueio.

Detecção de impasses

O Spanner detecta quando várias transações podem estar em deadlock e força todas as transações, exceto uma, a serem canceladas. Considere este cenário: Txn1 mantém um bloqueio no registro A e está aguardando um bloqueio no registro B, enquanto Txn2 mantém um bloqueio no registro B e está aguardando um bloqueio no registro A. Para resolver isso, uma das transações precisa ser cancelada, liberando o bloqueio e permitindo que a outra continue.

O Spanner usa o algoritmo padrão de wound-wait para detecção de deadlock. Em segundo plano, o Spanner rastreia a idade de cada transação que solicita bloqueios conflitantes. Ele permite que transações mais antigas cancelem as mais recentes. Uma transação mais antiga é aquela em que a leitura, consulta ou confirmação mais antiga ocorreu antes.

Ao priorizar transações mais antigas, o Spanner garante que todas as transações acabem adquirindo bloqueios depois de se tornarem antigas o suficiente para ter prioridade mais alta. Por exemplo, uma transação mais antiga que precisa de um bloqueio compartilhado de gravação pode interromper uma transação mais recente que tenha um bloqueio compartilhado de leitura.

Execução distribuída

O Spanner pode executar transações em dados que abrangem vários servidores, mas esse recurso tem um custo de desempenho em comparação com transações de servidor único.

Quais tipos de transações podem ser distribuídos? O Spanner pode distribuir a responsabilidade pelas linhas do banco de dados entre vários servidores. Normalmente, uma linha e as linhas da tabela intercalada correspondente são exibidas pelo mesmo servidor, assim como duas linhas na mesma tabela com chaves próximas. O Spanner pode realizar transações em linhas em servidores diferentes. No entanto, como regra geral, as transações que afetam muitas linhas colocalizadas são mais rápidas e baratas do que aquelas que afetam muitas linhas espalhadas pelo banco de dados ou por uma tabela grande.

As transações mais eficientes no Spanner incluem apenas as leituras e gravações que precisam ser aplicadas de forma atômica. As transações são mais rápidas quando todas as leituras e gravações acessam dados na mesma parte do espaço de chave.

Transações somente leitura

Além de bloquear transações de leitura e gravação, o Spanner oferece transações somente leitura.

Use uma transação somente leitura quando precisar executar mais de uma leitura no mesmo carimbo de data/hora. Se for possível expressar sua leitura usando um dos métodos de leitura única do Spanner, use esse método. O desempenho da utilização de uma chamada de leitura única é comparável ao de uma única leitura feita em uma transação somente leitura.

Se você estiver lendo uma grande quantidade de dados, use partições para ler os dados em paralelo.

Como as transações somente leitura não gravam, elas não mantêm bloqueios e não bloqueiam outras transações. As transações somente leitura estão de acordo com um prefixo consistente do histórico de confirmações da transação. Portanto, o aplicativo sempre recebe dados consistentes.

Interface

O Spanner fornece uma interface para executar um corpo de trabalho no contexto de uma transação somente leitura, com novas tentativas de cancelamento de transações.

Exemplo

O exemplo a seguir mostra como usar uma transação somente leitura para receber dados consistentes para duas leituras no mesmo carimbo de data/hora:

C++

void ReadOnlyTransaction(google::cloud::spanner::Client client) {
  namespace spanner = ::google::cloud::spanner;
  auto read_only = spanner::MakeReadOnlyTransaction();

  spanner::SqlStatement select(
      "SELECT SingerId, AlbumId, AlbumTitle FROM Albums");
  using RowType = std::tuple<std::int64_t, std::int64_t, std::string>;

  // Read#1.
  auto rows1 = client.ExecuteQuery(read_only, select);
  std::cout << "Read 1 results\n";
  for (auto& row : spanner::StreamOf<RowType>(rows1)) {
    if (!row) throw std::move(row).status();
    std::cout << "SingerId: " << std::get<0>(*row)
              << " AlbumId: " << std::get<1>(*row)
              << " AlbumTitle: " << std::get<2>(*row) << "\n";
  }
  // Read#2. Even if changes occur in-between the reads the transaction ensures
  // that Read #1 and Read #2 return the same data.
  auto rows2 = client.ExecuteQuery(read_only, select);
  std::cout << "Read 2 results\n";
  for (auto& row : spanner::StreamOf<RowType>(rows2)) {
    if (!row) throw std::move(row).status();
    std::cout << "SingerId: " << std::get<0>(*row)
              << " AlbumId: " << std::get<1>(*row)
              << " AlbumTitle: " << std::get<2>(*row) << "\n";
  }
}

C#


using Google.Cloud.Spanner.Data;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using System.Transactions;

public class QueryDataWithTransactionAsyncSample
{
    public class Album
    {
        public int SingerId { get; set; }
        public int AlbumId { get; set; }
        public string AlbumTitle { get; set; }
    }

    public async Task<List<Album>> QueryDataWithTransactionAsync(string projectId, string instanceId, string databaseId)
    {
        string connectionString = $"Data Source=projects/{projectId}/instances/{instanceId}/databases/{databaseId}";

        var albums = new List<Album>();
        using TransactionScope scope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled);
        using var connection = new SpannerConnection(connectionString);

        // Opens the connection so that the Spanner transaction included in the TransactionScope
        // is read-only TimestampBound.Strong.
        await connection.OpenAsync(SpannerTransactionCreationOptions.ReadOnly, options: null, cancellationToken: default);
        using var cmd = connection.CreateSelectCommand("SELECT SingerId, AlbumId, AlbumTitle FROM Albums");

        // Read #1.
        using (var reader = await cmd.ExecuteReaderAsync())
        {
            while (await reader.ReadAsync())
            {
                Console.WriteLine("SingerId : " + reader.GetFieldValue<string>("SingerId")
                    + " AlbumId : " + reader.GetFieldValue<string>("AlbumId")
                    + " AlbumTitle : " + reader.GetFieldValue<string>("AlbumTitle"));
            }
        }

        // Read #2. Even if changes occur in-between the reads,
        // the transaction ensures that Read #1 and Read #2
        // return the same data.
        using (var reader = await cmd.ExecuteReaderAsync())
        {
            while (await reader.ReadAsync())
            {
                albums.Add(new Album
                {
                    AlbumId = reader.GetFieldValue<int>("AlbumId"),
                    SingerId = reader.GetFieldValue<int>("SingerId"),
                    AlbumTitle = reader.GetFieldValue<string>("AlbumTitle")
                });
            }
        }
        scope.Complete();
        Console.WriteLine("Transaction complete.");
        return albums;
    }
}

Go


import (
	"context"
	"fmt"
	"io"

	"cloud.google.com/go/spanner"
	"google.golang.org/api/iterator"
)

func readOnlyTransaction(w io.Writer, db string) error {
	ctx := context.Background()
	client, err := spanner.NewClient(ctx, db)
	if err != nil {
		return err
	}
	defer client.Close()

	ro := client.ReadOnlyTransaction()
	defer ro.Close()
	stmt := spanner.Statement{SQL: `SELECT SingerId, AlbumId, AlbumTitle FROM Albums`}
	iter := ro.Query(ctx, stmt)
	defer iter.Stop()
	for {
		row, err := iter.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			return err
		}
		var singerID int64
		var albumID int64
		var albumTitle string
		if err := row.Columns(&singerID, &albumID, &albumTitle); err != nil {
			return err
		}
		fmt.Fprintf(w, "%d %d %s\n", singerID, albumID, albumTitle)
	}

	iter = ro.Read(ctx, "Albums", spanner.AllKeys(), []string{"SingerId", "AlbumId", "AlbumTitle"})
	defer iter.Stop()
	for {
		row, err := iter.Next()
		if err == iterator.Done {
			return nil
		}
		if err != nil {
			return err
		}
		var singerID int64
		var albumID int64
		var albumTitle string
		if err := row.Columns(&singerID, &albumID, &albumTitle); err != nil {
			return err
		}
		fmt.Fprintf(w, "%d %d %s\n", singerID, albumID, albumTitle)
	}
}

Java

static void readOnlyTransaction(DatabaseClient dbClient) {
  // ReadOnlyTransaction must be closed by calling close() on it to release resources held by it.
  // We use a try-with-resource block to automatically do so.
  try (ReadOnlyTransaction transaction = dbClient.readOnlyTransaction()) {
    try (ResultSet queryResultSet =
        transaction.executeQuery(
            Statement.of("SELECT SingerId, AlbumId, AlbumTitle FROM Albums"))) {
      while (queryResultSet.next()) {
        System.out.printf(
            "%d %d %s\n",
            queryResultSet.getLong(0), queryResultSet.getLong(1), queryResultSet.getString(2));
      }
    } // queryResultSet.close() is automatically called here
    try (ResultSet readResultSet =
        transaction.read(
          "Albums", KeySet.all(), Arrays.asList("SingerId", "AlbumId", "AlbumTitle"))) {
      while (readResultSet.next()) {
        System.out.printf(
            "%d %d %s\n",
            readResultSet.getLong(0), readResultSet.getLong(1), readResultSet.getString(2));
      }
    } // readResultSet.close() is automatically called here
  } // transaction.close() is automatically called here
}

Node.js

// Imports the Google Cloud client library
const {Spanner} = require('@google-cloud/spanner');

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// const projectId = 'my-project-id';
// const instanceId = 'my-instance';
// const databaseId = 'my-database';

// Creates a client
const spanner = new Spanner({
  projectId: projectId,
});

// Gets a reference to a Cloud Spanner instance and database
const instance = spanner.instance(instanceId);
const database = instance.database(databaseId);

// Gets a transaction object that captures the database state
// at a specific point in time
database.getSnapshot(async (err, transaction) => {
  if (err) {
    console.error(err);
    return;
  }
  const queryOne = 'SELECT SingerId, AlbumId, AlbumTitle FROM Albums';

  try {
    // Read #1, using SQL
    const [qOneRows] = await transaction.run(queryOne);

    qOneRows.forEach(row => {
      const json = row.toJSON();
      console.log(
        `SingerId: ${json.SingerId}, AlbumId: ${json.AlbumId}, AlbumTitle: ${json.AlbumTitle}`,
      );
    });

    const queryTwo = {
      columns: ['SingerId', 'AlbumId', 'AlbumTitle'],
    };

    // Read #2, using the `read` method. Even if changes occur
    // in-between the reads, the transaction ensures that both
    // return the same data.
    const [qTwoRows] = await transaction.read('Albums', queryTwo);

    qTwoRows.forEach(row => {
      const json = row.toJSON();
      console.log(
        `SingerId: ${json.SingerId}, AlbumId: ${json.AlbumId}, AlbumTitle: ${json.AlbumTitle}`,
      );
    });

    console.log('Successfully executed read-only transaction.');
  } catch (err) {
    console.error('ERROR:', err);
  } finally {
    transaction.end();
    // Close the database when finished.
    await database.close();
  }
});

PHP

use Google\Cloud\Spanner\SpannerClient;

/**
 * Reads data inside of a read-only transaction.
 *
 * Within the read-only transaction, or "snapshot", the application sees
 * consistent view of the database at a particular timestamp.
 * Example:
 * ```
 * read_only_transaction($instanceId, $databaseId);
 * ```
 *
 * @param string $instanceId The Spanner instance ID.
 * @param string $databaseId The Spanner database ID.
 */
function read_only_transaction(string $instanceId, string $databaseId): void
{
    $spanner = new SpannerClient();
    $instance = $spanner->instance($instanceId);
    $database = $instance->database($databaseId);

    $snapshot = $database->snapshot();
    $results = $snapshot->execute(
        'SELECT SingerId, AlbumId, AlbumTitle FROM Albums'
    );
    print('Results from the first read:' . PHP_EOL);
    foreach ($results as $row) {
        printf('SingerId: %s, AlbumId: %s, AlbumTitle: %s' . PHP_EOL,
            $row['SingerId'], $row['AlbumId'], $row['AlbumTitle']);
    }

    // Perform another read using the `read` method. Even if the data
    // is updated in-between the reads, the snapshot ensures that both
    // return the same data.
    $keySet = $spanner->keySet(['all' => true]);
    $results = $database->read(
        'Albums',
        $keySet,
        ['SingerId', 'AlbumId', 'AlbumTitle']
    );

    print('Results from the second read:' . PHP_EOL);
    foreach ($results->rows() as $row) {
        printf('SingerId: %s, AlbumId: %s, AlbumTitle: %s' . PHP_EOL,
            $row['SingerId'], $row['AlbumId'], $row['AlbumTitle']);
    }
}

Python

def read_only_transaction(instance_id, database_id):
    """Reads data inside of a read-only transaction.

    Within the read-only transaction, or "snapshot", the application sees
    consistent view of the database at a particular timestamp.
    """
    spanner_client = spanner.Client()
    instance = spanner_client.instance(instance_id)
    database = instance.database(database_id)

    with database.snapshot(multi_use=True) as snapshot:
        # Read using SQL.
        results = snapshot.execute_sql(
            "SELECT SingerId, AlbumId, AlbumTitle FROM Albums"
        )

        print("Results from first read:")
        for row in results:
            print("SingerId: {}, AlbumId: {}, AlbumTitle: {}".format(*row))

        # Perform another read using the `read` method. Even if the data
        # is updated in-between the reads, the snapshot ensures that both
        # return the same data.
        keyset = spanner.KeySet(all_=True)
        results = snapshot.read(
            table="Albums", columns=("SingerId", "AlbumId", "AlbumTitle"), keyset=keyset
        )

        print("Results from second read:")
        for row in results:
            print("SingerId: {}, AlbumId: {}, AlbumTitle: {}".format(*row))

Ruby

# project_id  = "Your Google Cloud project ID"
# instance_id = "Your Spanner instance ID"
# database_id = "Your Spanner database ID"

require "google/cloud/spanner"

spanner = Google::Cloud::Spanner.new project: project_id
client  = spanner.client instance_id, database_id

client.snapshot do |snapshot|
  snapshot.execute("SELECT SingerId, AlbumId, AlbumTitle FROM Albums").rows.each do |row|
    puts "#{row[:AlbumId]} #{row[:AlbumTitle]} #{row[:SingerId]}"
  end

  # Even if changes occur in-between the reads, the transaction ensures that
  # both return the same data.
  snapshot.read("Albums", [:AlbumId, :AlbumTitle, :SingerId]).rows.each do |row|
    puts "#{row[:AlbumId]} #{row[:AlbumTitle]} #{row[:SingerId]}"
  end
end

Semântica

Nesta seção, descrevemos a semântica das transações somente leitura.

Transações somente leitura de snapshot

Quando uma transação somente leitura é executada no Spanner, ela realiza todas as leituras em um único momento lógico. Isso significa que tanto a transação somente leitura quanto qualquer outro leitor e gravador simultâneo veem um snapshot consistente do banco de dados naquele momento específico.

Essas transações somente leitura de snapshot oferecem uma abordagem mais simples para leituras consistentes em comparação com o bloqueio de transações de leitura e gravação. Geralmente, estes são os motivos:

  • Sem bloqueios: as transações somente leitura não adquirem bloqueios. Em vez disso, elas operam selecionando um carimbo de data/hora do Spanner e executando todas as leituras nessa versão histórica dos dados. Como elas não usam bloqueios, não bloqueiam transações simultâneas de leitura/gravação.
  • Sem cancelamentos: essas transações nunca são canceladas. Embora possam falhar se o carimbo de data/hora de leitura escolhido for coletado como lixo, a política de coleta de lixo padrão do Spanner normalmente é generosa o suficiente para que a maioria dos aplicativos não encontre esse problema.
  • Sem commits ou reversões: as transações somente leitura não exigem chamadas para sessions.commit ou sessions.rollback e são impedidas de fazer isso.

Para executar uma transação de snapshot, o cliente define um limite de carimbo de data/hora, que instrui o Spanner sobre como selecionar um carimbo de data/hora de leitura. Os tipos de limites de carimbo de data/hora incluem:

  • Leituras fortes: garantem que você verá os efeitos de todas as transações confirmadas antes do início da leitura. Todas as linhas em uma única leitura são consistentes. No entanto, as leituras fortes não são repetíveis, embora retornem um carimbo de data/hora, e a leitura novamente nesse mesmo carimbo de data/hora seja repetível. Duas transações consecutivas de leitura forte podem produzir resultados diferentes devido a gravações simultâneas. As consultas em fluxo de alterações precisam usar esse limite. Para mais detalhes, consulte TransactionOptions.ReadOnly.strong.
  • Desatualização exata: essa opção executa leituras em um carimbo de data/hora especificado por você, seja como um carimbo de data/hora absoluto ou como uma duração de desatualização em relação ao horário atual. Ele garante que você observe um prefixo consistente do histórico de transações globais até esse carimbo de data/hora. A leitura aguarda até que todas as transações conflitantes que possam ser confirmadas no carimbo de data/hora de leitura ou antes dele sejam concluídas. Embora seja um pouco mais rápido do que os modos de desatualização limitada, ele pode retornar dados mais antigos. Para mais detalhes, consulte TransactionOptions.ReadOnly.read_timestamp e TransactionOptions.ReadOnly.exact_staleness.
  • Desatualização limitada: o Spanner seleciona o carimbo de data/hora mais recente que permite que a réplica disponível mais próxima exiba a leitura sem bloqueio, dentro de um limite de desatualização definido por você. Todas as linhas retornadas são consistentes. Assim como as leituras fortes, as leituras desatualizadas limitadas não são repetíveis, porque leituras diferentes podem ser executadas em carimbos de data/hora diferentes, mesmo com o mesmo limite. Essas leituras operam em duas fases (negociação de carimbo de data/hora e, em seguida, a leitura) e geralmente são um pouco mais lentas do que as leituras desatualizadas exatas, mas costumam retornar resultados mais recentes. Esse modo está disponível apenas para transações de uso único somente leitura, porque a negociação de carimbo de data/hora requer saber com antecedência quais linhas a leitura acessa. Para mais detalhes, consulte TransactionOptions.ReadOnly.max_staleness e TransactionOptions.ReadOnly.min_read_timestamp.

As leituras de desatualização exata e limitada são executadas na réplica disponível mais próxima. Se essa réplica não estiver atualizada com o carimbo de data/hora de leitura, ela precisará se comunicar com a réplica líder antes de disponibilizar a leitura. As leituras desatualizadas limitadas têm menos probabilidade de precisar dessa comunicação do líder, porque o Spanner escolhe um carimbo de data/hora que a réplica já pode exibir.

Transações de DML particionada

É possível usar a DML particionada para executar instruções UPDATE e DELETE em grande escala sem encontrar limites de transação ou bloquear uma tabela inteira. Para isso, o Spanner particiona o espaço de chaves e executa as instruções DML em cada partição em uma transação de leitura e gravação separada.

Para usar a DML não particionada, execute instruções em transações de leitura e gravação que você cria explicitamente no código. Para mais detalhes, consulte Como usar a DML.

Interface

O Spanner fornece a interface TransactionOptions.partitionedDml para executar uma única instrução DML particionada.

Exemplos

O exemplo de código a seguir atualiza a coluna MarketingBudget da tabela Albums.

C++

Use a função ExecutePartitionedDml() para executar uma instrução DML particionada.

void DmlPartitionedUpdate(google::cloud::spanner::Client client) {
  namespace spanner = ::google::cloud::spanner;
  auto result = client.ExecutePartitionedDml(
      spanner::SqlStatement("UPDATE Albums SET MarketingBudget = 100000"
                            "  WHERE SingerId > 1"));
  if (!result) throw std::move(result).status();
  std::cout << "Updated at least " << result->row_count_lower_bound
            << " row(s) [spanner_dml_partitioned_update]\n";
}

C#

Use o método ExecutePartitionedUpdateAsync() para executar uma instrução DML particionada.


using Google.Cloud.Spanner.Data;
using System;
using System.Threading.Tasks;

public class UpdateUsingPartitionedDmlCoreAsyncSample
{
    public async Task<long> UpdateUsingPartitionedDmlCoreAsync(string projectId, string instanceId, string databaseId)
    {
        string connectionString = $"Data Source=projects/{projectId}/instances/{instanceId}/databases/{databaseId}";

        using var connection = new SpannerConnection(connectionString);
        await connection.OpenAsync();

        using var cmd = connection.CreateDmlCommand("UPDATE Albums SET MarketingBudget = 100000 WHERE SingerId > 1");
        long rowCount = await cmd.ExecutePartitionedUpdateAsync();

        Console.WriteLine($"{rowCount} row(s) updated...");
        return rowCount;
    }
}

Go

Use o método PartitionedUpdate() para executar uma instrução DML particionada.


import (
	"context"
	"fmt"
	"io"

	"cloud.google.com/go/spanner"
)

func updateUsingPartitionedDML(w io.Writer, db string) error {
	ctx := context.Background()
	client, err := spanner.NewClient(ctx, db)
	if err != nil {
		return err
	}
	defer client.Close()

	stmt := spanner.Statement{SQL: "UPDATE Albums SET MarketingBudget = 100000 WHERE SingerId > 1"}
	rowCount, err := client.PartitionedUpdate(ctx, stmt)
	if err != nil {
		return err
	}
	fmt.Fprintf(w, "%d record(s) updated.\n", rowCount)
	return nil
}

Java

Use o método executePartitionedUpdate() para executar uma instrução DML particionada.

static void updateUsingPartitionedDml(DatabaseClient dbClient) {
  String sql = "UPDATE Albums SET MarketingBudget = 100000 WHERE SingerId > 1";
  long rowCount = dbClient.executePartitionedUpdate(Statement.of(sql));
  System.out.printf("%d records updated.\n", rowCount);
}

Node.js

Use o método runPartitionedUpdate() para executar uma instrução DML particionada.

// Imports the Google Cloud client library
const {Spanner} = require('@google-cloud/spanner');

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// const projectId = 'my-project-id';
// const instanceId = 'my-instance';
// const databaseId = 'my-database';

// Creates a client
const spanner = new Spanner({
  projectId: projectId,
});

// Gets a reference to a Cloud Spanner instance and database
const instance = spanner.instance(instanceId);
const database = instance.database(databaseId);

try {
  const [rowCount] = await database.runPartitionedUpdate({
    sql: 'UPDATE Albums SET MarketingBudget = 100000 WHERE SingerId > 1',
  });
  console.log(`Successfully updated ${rowCount} records.`);
} catch (err) {
  console.error('ERROR:', err);
} finally {
  // Close the database when finished.
  database.close();
}

PHP

Use o método executePartitionedUpdate() para executar uma instrução DML particionada.

use Google\Cloud\Spanner\SpannerClient;

/**
 * Updates sample data in the database by partition with a DML statement.
 *
 * This updates the `MarketingBudget` column which must be created before
 * running this sample. You can add the column by running the `add_column`
 * sample or by running this DDL statement against your database:
 *
 *     ALTER TABLE Albums ADD COLUMN MarketingBudget INT64
 *
 * Example:
 * ```
 * update_data($instanceId, $databaseId);
 * ```
 *
 * @param string $instanceId The Spanner instance ID.
 * @param string $databaseId The Spanner database ID.
 */
function update_data_with_partitioned_dml(string $instanceId, string $databaseId): void
{
    $spanner = new SpannerClient();
    $instance = $spanner->instance($instanceId);
    $database = $instance->database($databaseId);

    $rowCount = $database->executePartitionedUpdate(
        'UPDATE Albums SET MarketingBudget = 100000 WHERE SingerId > 1'
    );

    printf('Updated %d row(s).' . PHP_EOL, $rowCount);
}

Python

Use o método execute_partitioned_dml() para executar uma instrução DML particionada.

# instance_id = "your-spanner-instance"
# database_id = "your-spanner-db-id"

spanner_client = spanner.Client()
instance = spanner_client.instance(instance_id)
database = instance.database(database_id)

row_ct = database.execute_partitioned_dml(
    "UPDATE Albums SET MarketingBudget = 100000 WHERE SingerId > 1"
)

print("{} records updated.".format(row_ct))

Ruby

Use o método execute_partitioned_update() para executar uma instrução DML particionada.

# project_id  = "Your Google Cloud project ID"
# instance_id = "Your Spanner instance ID"
# database_id = "Your Spanner database ID"

require "google/cloud/spanner"

spanner = Google::Cloud::Spanner.new project: project_id
client  = spanner.client instance_id, database_id

row_count = client.execute_partition_update(
  "UPDATE Albums SET MarketingBudget = 100000 WHERE SingerId > 1"
)

puts "#{row_count} records updated."

O exemplo de código a seguir exclui linhas da tabela Singers com base na coluna SingerId.

C++

void DmlPartitionedDelete(google::cloud::spanner::Client client) {
  namespace spanner = ::google::cloud::spanner;
  auto result = client.ExecutePartitionedDml(
      spanner::SqlStatement("DELETE FROM Singers WHERE SingerId > 10"));
  if (!result) throw std::move(result).status();
  std::cout << "Deleted at least " << result->row_count_lower_bound
            << " row(s) [spanner_dml_partitioned_delete]\n";
}

C#


using Google.Cloud.Spanner.Data;
using System;
using System.Threading.Tasks;

public class DeleteUsingPartitionedDmlCoreAsyncSample
{
    public async Task<long> DeleteUsingPartitionedDmlCoreAsync(string projectId, string instanceId, string databaseId)
    {
        string connectionString = $"Data Source=projects/{projectId}/instances/{instanceId}/databases/{databaseId}";

        using var connection = new SpannerConnection(connectionString);
        await connection.OpenAsync();

        using var cmd = connection.CreateDmlCommand("DELETE FROM Singers WHERE SingerId > 10");
        long rowCount = await cmd.ExecutePartitionedUpdateAsync();

        Console.WriteLine($"{rowCount} row(s) deleted...");
        return rowCount;
    }
}

Go


import (
	"context"
	"fmt"
	"io"

	"cloud.google.com/go/spanner"
)

func deleteUsingPartitionedDML(w io.Writer, db string) error {
	ctx := context.Background()
	client, err := spanner.NewClient(ctx, db)
	if err != nil {
		return err
	}
	defer client.Close()

	stmt := spanner.Statement{SQL: "DELETE FROM Singers WHERE SingerId > 10"}
	rowCount, err := client.PartitionedUpdate(ctx, stmt)
	if err != nil {
		return err

	}
	fmt.Fprintf(w, "%d record(s) deleted.", rowCount)
	return nil
}

Java

static void deleteUsingPartitionedDml(DatabaseClient dbClient) {
  String sql = "DELETE FROM Singers WHERE SingerId > 10";
  long rowCount = dbClient.executePartitionedUpdate(Statement.of(sql));
  System.out.printf("%d records deleted.\n", rowCount);
}

Node.js

// Imports the Google Cloud client library
const {Spanner} = require('@google-cloud/spanner');

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// const projectId = 'my-project-id';
// const instanceId = 'my-instance';
// const databaseId = 'my-database';

// Creates a client
const spanner = new Spanner({
  projectId: projectId,
});

// Gets a reference to a Cloud Spanner instance and database
const instance = spanner.instance(instanceId);
const database = instance.database(databaseId);

try {
  const [rowCount] = await database.runPartitionedUpdate({
    sql: 'DELETE FROM Singers WHERE SingerId > 10',
  });
  console.log(`Successfully deleted ${rowCount} records.`);
} catch (err) {
  console.error('ERROR:', err);
} finally {
  // Close the database when finished.
  database.close();
}

PHP

use Google\Cloud\Spanner\SpannerClient;

/**
 * Delete sample data in the database by partition with a DML statement.
 *
 * This updates the `MarketingBudget` column which must be created before
 * running this sample. You can add the column by running the `add_column`
 * sample or by running this DDL statement against your database:
 *
 *     ALTER TABLE Albums ADD COLUMN MarketingBudget INT64
 *
 * Example:
 * ```
 * update_data($instanceId, $databaseId);
 * ```
 *
 * @param string $instanceId The Spanner instance ID.
 * @param string $databaseId The Spanner database ID.
 */
function delete_data_with_partitioned_dml(string $instanceId, string $databaseId): void
{
    $spanner = new SpannerClient();
    $instance = $spanner->instance($instanceId);
    $database = $instance->database($databaseId);

    $rowCount = $database->executePartitionedUpdate(
        'DELETE FROM Singers WHERE SingerId > 10'
    );

    printf('Deleted %d row(s).' . PHP_EOL, $rowCount);
}

Python

# instance_id = "your-spanner-instance"
# database_id = "your-spanner-db-id"
spanner_client = spanner.Client()
instance = spanner_client.instance(instance_id)
database = instance.database(database_id)

row_ct = database.execute_partitioned_dml("DELETE FROM Singers WHERE SingerId > 10")

print("{} record(s) deleted.".format(row_ct))

Ruby

# project_id  = "Your Google Cloud project ID"
# instance_id = "Your Spanner instance ID"
# database_id = "Your Spanner database ID"

require "google/cloud/spanner"

spanner = Google::Cloud::Spanner.new project: project_id
client  = spanner.client instance_id, database_id

row_count = client.execute_partition_update(
  "DELETE FROM Singers WHERE SingerId > 10"
)

puts "#{row_count} records deleted."

Semântica

Nesta seção, descrevemos a semântica da DML particionada.

Noções básicas sobre a execução de DML particionada

Só é possível executar uma instrução DML particionada por vez, seja usando um método de biblioteca de cliente ou a Google Cloud CLI.

As transações particionadas não são compatíveis com confirmações ou reversões. O Spanner executa e aplica a instrução DML imediatamente. Se você cancelar a operação ou se ela falhar, o Spanner vai cancelar todas as partições em execução e não vai iniciar as restantes. No entanto, o Spanner não reverter as partições que já foram executadas.

Estratégia de aquisição de bloqueio de DML particionada

Para reduzir a disputa por bloqueio, a DML particionada adquire bloqueios de leitura apenas em linhas que correspondem à cláusula WHERE. Transações menores e independentes usadas para cada partição também mantêm bloqueios por menos tempo.

Carimbos de data/hora de leitura antigos e coleta de lixo de versões

O Spanner realiza a coleta de lixo de versões para coletar dados excluídos ou substituídos e recuperar o armazenamento. Por padrão, os dados com mais de uma hora são reivindicados. O Spanner não pode realizar leituras em carimbos de data/hora anteriores ao VERSION_RETENTION_PERIOD configurado, que, por padrão, é de uma hora, mas pode ser configurado para até uma semana. Quando as leituras ficam muito antigas durante a execução, elas falham e retornam o erro FAILED_PRECONDITION.

Consultas em fluxo de alterações

Um fluxo de alterações é um objeto de esquema que pode ser configurado para monitorar modificações de dados em um banco de dados inteiro, em tabelas específicas ou em um conjunto definido de colunas em um banco de dados.

Quando você cria um fluxo de alterações, o Spanner define uma função com valor de tabela (TVF, na sigla em inglês) do SQL correspondente. É possível usar essa TVF para consultar os registros de alteração no fluxo de alterações associado com o método sessions.executeStreamingSql. O nome da TVF é gerado com base no nome do fluxo de alterações e sempre começa com READ_.

Todas as consultas em TVFs de fluxo de alterações precisam ser executadas usando a API sessions.executeStreamingSql em uma transação somente leitura de uso único com um timestamp_bound somente leitura forte. A TVF do fluxo de alterações permite especificar start_timestamp e end_timestamp para o período. Todos os registros de alteração dentro do período de armazenamento podem ser acessados usando essa timestamp_bound forte somente leitura. Todos os outros TransactionOptions são inválidos para consultas de fluxo de alterações.

Além disso, se TransactionOptions.read_only.return_read_timestamp estiver definido como true, a mensagem Transaction que descreve a transação retornará um valor especial de 2^63 - 2 em vez de um carimbo de data/hora de leitura válido. Descarte esse valor especial e não o use em consultas subsequentes.

Para mais informações, consulte Fluxo de trabalho de consulta de fluxos de alterações.

Transações inativas

Uma transação é considerada inativa se não tiver leituras ou consultas SQL pendentes e não tiver iniciado uma nos últimos 10 segundos. O Spanner pode cancelar transações inativas para evitar que elas mantenham bloqueios indefinidamente. Se uma transação ociosa for cancelada, a confirmação vai falhar e retornar um erro ABORTED. Executar periodicamente uma consulta pequena, como SELECT 1, dentro da transação pode evitar que ela fique inativa.

A seguir