Présentation des transactions

Toutefois, les concepts et la sémantique s'appliquent aux bases de données utilisant les dialectes GoogleSQL et PostgreSQL.

Cette page décrit les transactions dans Spanner et présente les interfaces de transaction en lecture-écriture, en lecture seule et LMD partitionné de Spanner.

Dans Spanner, une transaction est un ensemble de lectures et d'écritures. Toutes les opérations d'une transaction sont atomiques, ce qui signifie qu'elles réussissent toutes ou échouent toutes.

Une session permet d'effectuer des transactions dans une base de données Spanner. Une session représente un canal de communication logique avec le service de base de données Spanner. Les sessions peuvent exécuter une ou plusieurs transactions à la fois. Pour en savoir plus, consultez Sessions.

Types de transactions

Spanner accepte les types de transactions suivants, chacun étant conçu pour des modèles d'interaction de données spécifiques :

  • Lecture-écriture : ces transactions sont utilisées pour les opérations de lecture et d'écriture, suivies d'un commit. Ils peuvent acquérir des verrous. En cas d'échec, elles devront être relancées. Bien qu'elles soient limitées à une seule base de données, elles peuvent modifier les données de plusieurs tables de cette base de données.

  • Lecture seule : ces transactions garantissent la cohérence des données sur plusieurs opérations de lecture, mais ne permettent pas de modifier les données. Elles s'exécutent à un code temporel déterminé par le système pour assurer la cohérence, ou à un code temporel passé configuré par l'utilisateur. Contrairement aux transactions en lecture-écriture, elles ne nécessitent pas d'opération de commit ni de verrous. Cependant, elles peuvent être mises en pause en attendant que les opérations d'écriture en cours se terminent.

  • LMD partitionné : ce type de transaction exécute des instructions LMD en tant qu'opérations LMD partitionnées. Il est optimisé pour l'exécution d'instructions LMD à grande échelle, mais avec des restrictions pour garantir que l'instruction est idempotente et partitionnable de manière à pouvoir s'exécuter indépendamment des autres partitions. Pour de nombreuses écritures ne nécessitant pas de transaction atomique, envisagez d'utiliser des écritures par lot. Pour en savoir plus, consultez Modifier des données à l'aide d'écritures par lot.

Transactions en lecture-écriture

Une transaction en lecture-écriture se compose de zéro, une ou plusieurs instructions de lecture ou de requête, suivies d'une requête de commit. À tout moment avant la requête de commit, le client peut envoyer une requête de rollback pour annuler la transaction.

Isolation sérialisable

En utilisant le niveau d'isolation sérialisable par défaut avec la simultanéité pessimiste, les transactions en lecture-écriture lisent, modifient et écrivent des données de manière atomique. Ce type de transaction est cohérence externe.

Lorsque vous utilisez des transactions en lecture-écriture, nous vous recommandons de minimiser la durée d'activité d'une transaction. Des transactions plus courtes permettent de conserver les verrous moins longtemps, ce qui augmente la probabilité d'un commit réussi et réduit les conflits. En effet, les verrouillages de longue durée peuvent entraîner des blocages et des abandons de transactions. Spanner tente de maintenir les verrous de lecture actifs tant que la transaction continue d'effectuer des lectures et qu'elle n'a pas été terminée par un commit ou un rollback. Si le client reste inactif pendant de longues périodes, Spanner peut libérer les verrous de la transaction et l'abandonner.

Pour effectuer une opération d'écriture qui dépend d'une ou de plusieurs opérations de lecture, utilisez une transaction en lecture-écriture :

  • Si vous devez effectuer un commit d'une ou de plusieurs opérations d'écriture de manière atomique, effectuez ces écritures dans la même transaction en lecture-écriture. Par exemple, si vous transférez 200 $ du compte A vers le compte B, effectuez les deux opérations d'écriture (diminution du compte A de 200 $ et augmentation du compte B de 200 $) et les lectures des soldes de compte initiaux dans la même transaction.
  • Si vous souhaitez doubler le solde du compte A, effectuez les opérations de lecture et d'écriture au sein de la même transaction. Cela garantit que le système lit le solde avant de le doubler et de le mettre à jour.
  • Si les opérations d'écriture dépendent des opérations de lecture, effectuez les deux dans la même transaction en lecture-écriture, même si les écritures ne s'exécutent pas. Par exemple, si vous souhaitez transférer 200 $ du compte A vers le compte B uniquement si le solde de A est supérieur à 500 $, incluez la lecture du solde de A et les opérations d'écriture conditionnelle dans la même transaction, même si le transfert n'a pas lieu.

Pour effectuer des opérations de lecture, utilisez une seule méthode de lecture ou une transaction en lecture seule :

  • Si vous n'effectuez que des opérations de lecture et que vous pouvez exprimer l'opération de lecture à l'aide d'une méthode de lecture unique, utilisez la méthode de lecture unique ou une transaction en lecture seule. Contrairement aux transactions en lecture-écriture, les lectures uniques n'acquièrent pas de verrous.

Vous pouvez également configurer l'isolation sérialisable pour utiliser la simultanéité optimiste. Le contrôle de simultanéité optimiste suppose que les conflits sont rares. Les lectures et les requêtes, même au sein d'une transaction en lecture-écriture, s'effectuent sans acquérir de verrous. Avec l'isolation sérialisable, les lectures sont validées au moment du commit. Cela garantit qu'aucune autre transaction validée simultanément n'a modifié les données précédemment lues par la transaction.

Isolation de lecture répétée

Dans Spanner, l'isolation de lecture reproductible est implémentée à l'aide d'une technique appelée "isolation d'instantané". L'isolation de lecture reproductible garantit que toutes les opérations de lecture d'une transaction sont cohérentes avec la base de données telle qu'elle existait au début de la transaction. Il garantit également que les écritures simultanées sur les mêmes données ne réussissent que s'il n'y a pas de conflit.

Avec la simultanéité optimiste par défaut, les écritures n'acquièrent pas de verrous avant le moment du commit. En cas de conflit avec les données écrites ou en raison d'événements temporaires dans Spanner, comme un redémarrage du serveur, Spanner peut toujours annuler les transactions. Étant donné que les lectures dans les transactions en lecture-écriture n'acquièrent pas de verrous dans l'isolation de lecture répétée, il n'y a aucune différence entre l'exécution d'opérations en lecture seule dans une transaction en lecture seule ou en lecture-écriture.

Utilisez la simultanéité pessimiste avec une lecture reproductible pour acquérir des verrous exclusifs pour les données lues avec une clause FOR UPDATE ou l'indice lock_scanned_ranges=exclusive, et pour les données écrites par des requêtes LMD. Cette sémantique est plus proche du comportement de verrouillage de l'isolation de lecture reproductible dans d'autres bases de données. Avec la simultanéité pessimiste, toutes les lectures sont diffusées au niveau de l'instantané. Les transactions peuvent donc être annulées si des transactions simultanées mettent à jour les données lues. Toutefois, il empêche les transactions simultanées de mettre à jour les données verrouillées entre le moment où les verrous sont acquis et le moment de la validation, ce qui peut réduire les conflits d'écriture-écriture potentiels.

Envisagez d'utiliser des transactions en lecture-écriture avec un niveau d'isolation de lecture répétée dans les scénarios suivants :

  • La charge de travail est axée sur la lecture et présente peu de conflits d'écriture.
  • L'application rencontre des goulots d'étranglement des performances en raison de retards dus à des conflits de verrouillage et à des abandons de transactions causés par des transactions plus anciennes et de priorité plus élevée qui blessent des transactions plus récentes et de priorité inférieure pour éviter d'éventuels interblocages (wound-wait).
  • L'application ne nécessite pas les garanties plus strictes fournies par le niveau d'isolation sérialisable.

Envisagez d'utiliser l'isolation de lecture reproductible avec simultanéité pessimiste pour les charges de travail où les instructions FOR UPDATE et LMD acquièrent des verrous.

Lorsque vous effectuez une opération d'écriture qui dépend d'une ou de plusieurs opérations de lecture, un décalage d'écriture est possible avec l'isolation de lecture reproductible. Le décalage d'écriture provient d'un type particulier de mise à jour simultanée, où chaque mise à jour est acceptée indépendamment, mais leur effet combiné ne respecte pas l'intégrité des données de l'application. Par conséquent, veillez à effectuer les lectures qui font partie de la section critique d'une transaction avec une clause FOR UPDATE ou un indice lock_scanned_ranges=exclusive pour éviter l'asymétrie d'écriture. Pour en savoir plus, consultez Conflits de lecture-écriture et exactitude, ainsi que l'exemple présenté dans Sémantique de lecture-écriture.

Interface

Les bibliothèques clientes Spanner fournissent une interface permettant d'exécuter un ensemble de tâches dans une transaction en lecture-écriture, avec de nouvelles tentatives en cas d'abandon de la transaction. Une transaction peut nécessiter plusieurs tentatives avant d'être validée.

Plusieurs situations peuvent entraîner l'abandon d'une transaction. Par exemple, si deux transactions tentent de modifier des données simultanément, un interblocage peut se produire. Dans ce cas, Spanner annule une transaction pour permettre à l'autre de se poursuivre. Moins fréquemment, des événements temporaires dans Spanner peuvent également entraîner l'abandon de transactions.

Toutes les transactions en lecture-écriture fournissent les propriétés ACID des bases de données relationnelles. Comme les transactions sont atomiques, une transaction abandonnée n'affecte pas la base de données. Les bibliothèques clientes Spanner relancent automatiquement ces transactions. Si vous n'utilisez pas les bibliothèques clientes, relancez vous-même la transaction pour améliorer les taux de réussite. Chaque nouvelle tentative qui entraîne une erreur ABORTED augmente la priorité de verrouillage de la transaction. Pour conserver cette priorité de verrouillage, relancez la transaction au cours de la même session. Si vous utilisez des sessions multiplexées, définissez également TransactionOptions.ReadWrite.multiplexed_session_previous_transaction_id sur l'ID de la transaction abandonnée lorsque vous commencez la nouvelle tentative. De plus, les pilotes client Spanner incluent une logique interne de nouvelle tentative de transaction qui masque les erreurs temporaires en réexécutant la transaction.

Si vous utilisez des sessions multiplexées, les bibliothèques clientes Spanner envoient l'ID de la transaction abandonnée à chaque nouvelle tentative. Cela permet à la transaction relancée de conserver sa priorité de verrouillage, même si d'autres transactions partagent la même session.

Lorsque vous utilisez une transaction dans une bibliothèque cliente Spanner, vous définissez le corps de la transaction en tant qu'objet de fonction. Cette fonction encapsule les lectures et les écritures effectuées sur une ou plusieurs tables de base de données. La bibliothèque cliente Spanner exécute cette fonction de manière répétée jusqu'à ce que la transaction soit validée ou qu'elle rencontre une erreur qui ne peut pas être relancée.

Cette boucle de nouvelle tentative est distincte des paramètres de délai avant expiration et de nouvelle tentative pour les RPC individuels, et sa durée par défaut dépend de la bibliothèque cliente. Pour limiter la durée totale d'une transaction, y compris les nouvelles tentatives, consultez Configurer le délai avant expiration d'une transaction.

Exemple

Supposons que vous disposiez d'une colonne MarketingBudget dans la table Albums :

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

Votre service marketing vous demande de transférer 200 000 $ du budget de Albums (2, 2) vers Albums (1, 1), mais uniquement si l'argent est disponible dans le budget de cet album. Vous devez utiliser une transaction de verrouillage en lecture-écriture pour cette opération, car la transaction peut effectuer des écritures en fonction du résultat d'une lecture.

Les exemples de bibliothèque cliente suivants montrent comment exécuter une transaction en lecture-écriture à l'aide du niveau d'isolation sérialisable par défaut :

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"

Pour obtenir des exemples d'exécution d'une transaction en lecture-écriture à l'aide de l'isolation de lecture répétée, consultez Utiliser le niveau d'isolation de lecture répétée.

Sémantique

Cette section décrit la sémantique des transactions en lecture-écriture dans Spanner.

Propriétés

L'isolation sérialisable est le niveau d'isolation par défaut dans Spanner. Sous l'isolation sérialisable, Spanner fournit aux clients les garanties de contrôle de simultanéité les plus strictes pour les transactions, à savoir la cohérence externe. Une transaction en lecture-écriture exécute un ensemble de lectures et d'écritures de manière atomique. Les écritures peuvent se poursuivre sans être bloquées par les transactions en lecture seule. Le code temporel auquel les transactions en lecture-écriture sont exécutées correspond au temps écoulé. L'ordre de sérialisation correspond à l'ordre de ces codes temporels.

Ces propriétés aident les développeurs d'applications à se concentrer sur l'exactitude de chaque transaction, sans se soucier de la protection de son exécution par rapport à d'autres transactions pouvant être exécutées simultanément.

Vous pouvez également exécuter vos transactions en lecture-écriture à l'aide de l'isolation de lecture reproductible. L'isolation de lecture reproductible garantit que toutes les opérations de lecture d'une transaction voient un instantané fort et cohérent de la base de données tel qu'il existait au début de la transaction. Pour en savoir plus, consultez Isolation de lecture reproductible.

Transactions en lecture-écriture avec isolation sérialisable

Une fois qu'une transaction contenant une série de lectures et d'écritures dans l'isolation sérialisable par défaut a été validée, les conditions suivantes s'appliquent :

  • La transaction renvoie des valeurs qui reflètent un instantané cohérent au moment de la validation de la transaction.
  • Les lignes ou plages vides restent vides au moment du commit.
  • La transaction valide toutes les écritures selon le code temporel de validation de la transaction.
  • Aucune transaction ne peut voir les écritures tant que la transaction n'est pas validée.

Les pilotes clients Spanner incluent une logique de nouvelle tentative de transaction qui masque les erreurs temporaires en réexécutant la transaction et en validant les données observées par le client.

L'effet est que toutes les lectures et écritures semblent s'être produites à un moment précis, à la fois du point de vue de la transaction elle-même et du point de vue des autres lecteurs et rédacteurs de la base de données Spanner. Cela signifie que les lectures et les écritures se produisent au même code temporel. Pour obtenir un exemple, consultez Sérialisabilité et cohérence externe.

Transactions en lecture-écriture avec isolation de lecture reproductible

Une fois qu'une transaction avec isolation de lecture reproductible a été validée, les conditions suivantes s'appliquent :

  • La transaction renvoie des valeurs qui reflètent un instantané cohérent de la base de données. L'instantané est généralement établi lors de la première opération de transaction, qui peut ne pas être identique au code temporel de commit.
  • Étant donné que la lecture reproductible est mise en œuvre à l'aide de l'isolation d'instantané, la transaction valide toutes les écritures au code temporel de commit de la transaction uniquement si l'ensemble d'écriture n'a pas changé entre le code temporel de l'instantané de la transaction et le code temporel de commit.
  • Les autres transactions ne voient les écritures qu'après la validation de la transaction.

Isolation pour les transactions en lecture-écriture avec des opérations en lecture seule

Lorsqu'une transaction en lecture-écriture n'effectue que des opérations de lecture, elle offre des garanties de cohérence similaires à celles d'une transaction en lecture seule. Toutes les lectures de la transaction renvoient des données à partir d'un code temporel cohérent, y compris la confirmation des lignes inexistantes.

Une différence se produit lorsqu'une transaction en lecture-écriture est validée sans exécuter d'opération d'écriture. Dans ce scénario, il n'est pas garanti que les données lues dans la transaction soient restées inchangées dans la base de données entre l'opération de lecture et la validation de la transaction.

Pour garantir la fraîcheur des données et vérifier qu'elles n'ont pas été modifiées depuis leur dernière récupération, une lecture ultérieure est requise. Cette nouvelle lecture peut être effectuée dans une autre transaction en lecture-écriture ou avec une lecture forte.

Pour une efficacité optimale, si une transaction n'effectue que des lectures, utilisez une transaction en lecture seule plutôt qu'une transaction en lecture-écriture, en particulier lorsque vous utilisez l'isolation sérialisable.

Différence entre la sérialisabilité et la cohérence externe d'une part, et la lecture reproductible d'autre part

Par défaut, Spanner offre des garanties transactionnelles fortes, y compris la sérialisabilité et la cohérence externe. Ces propriétés garantissent que les données restent cohérentes et que les opérations se déroulent dans un ordre prévisible, même dans un environnement distribué.

La sérialisabilité garantit que toutes les transactions semblent s'exécuter l'une après l'autre dans un ordre séquentiel unique, même si elles sont traitées simultanément. Pour ce faire, Spanner attribue des codes temporels de commit aux transactions, reflétant l'ordre dans lequel elles ont été validées.

Spanner fournit une garantie encore plus forte, appelée cohérence externe. Cela signifie que non seulement les transactions sont validées dans un ordre reflété par leurs codes temporels de commit, mais que ces codes temporels s'alignent également sur l'heure réelle. Cela vous permet de comparer les codes temporels de commit au temps réel, ce qui vous donne une vue cohérente et ordonnée de vos données à l'échelle mondiale.

En substance, si une transaction Txn1 est validée avant une autre transaction Txn2 en temps réel, l'horodatage de commit de Txn1 est antérieur à celui de Txn2.

Prenons l'exemple suivant :

Chronologie montrant l'exécution de deux transactions qui lisent les mêmes données

Dans ce scénario, pendant la période t :

  • La transaction Txn1 lit les données A, prépare une écriture dans A, puis effectue un commit.
  • La transaction Txn2 commence après le début de la transaction Txn1. Il lit les données B, puis les données A.

Même si Txn2 a démarré avant la fin de Txn1, Txn2 observe les modifications apportées par Txn1 à A. En effet, Txn2 lit A après que Txn1 a validé son écriture dans A.

Bien que Txn1 et Txn2 puissent se chevaucher dans leur temps d'exécution, leurs codes temporels de commit, respectivement c1 et c2, appliquent un ordre de transaction linéaire. Cela signifie que :

  • Toutes les lectures et écritures dans Txn1 semblent s'être produites à un moment précis, c1.
  • Toutes les lectures et écritures dans Txn2 semblent s'être produites à un moment précis, c2.
  • Il est important de noter que c1 est antérieur à c2 pour les écritures validées, même si les écritures ont eu lieu sur des machines différentes. Si Txn2 n'effectue que des lectures, c1 est antérieur ou identique à c2.

Cet ordre strict signifie que si une opération de lecture ultérieure observe les effets de Txn2, elle observe également les effets de Txn1. Cette propriété est vraie pour toutes les transactions validées.

En revanche, si vous utilisez l'isolation de lecture reproductible, le scénario suivant se produit pour les mêmes transactions :

  • Txn1 commence par lire les données A, en créant son propre instantané de la base de données à ce moment-là.
  • Txn2 commence alors à lire les données B et établit son propre instantané.
  • Ensuite, Txn1 modifie les données A et valide ses modifications.
  • Txn2 tente de lire les données A. Il est important de noter que, comme elle fonctionne sur un instantané antérieur, Txn2 ne voit pas la mise à jour que Txn1 vient d'apporter à A. Txn2 lit l'ancienne valeur.
  • Txn2 modifie les données B et effectue un commit.

Dans ce scénario, chaque transaction s'exécute sur son propre instantané cohérent de la base de données, pris au moment où la transaction commence. Cette séquence peut entraîner une anomalie de décalage d'écriture si l'écriture dans B par Txn2 dépendait logiquement de la valeur lue à partir de A. En substance, Txn2 a effectué ses mises à jour sur la base d'informations obsolètes, et son écriture ultérieure peut enfreindre un invariant au niveau de l'application. Pour éviter que ce scénario ne se produise, envisagez d'utiliser SELECT...FOR UPDATE pour l'isolation de lecture reproductible ou de créer des contraintes de vérification dans votre schéma.

Garanties de lecture et d'écriture en cas d'échec de transaction

Si un appel pour exécuter une transaction échoue, les garanties de lecture et d'écriture dont vous disposez dépendent de l'erreur qui a provoqué l'échec de l'appel de commit sous-jacent.

Spanner peut exécuter les opérations d'une transaction plusieurs fois en interne. Si une tentative d'exécution échoue, l'erreur renvoyée spécifie les conditions qui se sont produites et indique les garanties que vous recevez. Toutefois, si Spanner relance votre transaction, les effets secondaires de ses opérations (par exemple, les modifications apportées à des systèmes externes ou à un état du système en dehors d'une base de données Spanner) peuvent se produire plusieurs fois.

En cas d'échec d'une transaction Spanner, les garanties que vous recevez pour les lectures et les écritures dépendent de l'erreur spécifique rencontrée lors de l'opération de commit.

Par exemple, un message d'erreur tel que "Ligne introuvable" ou "La ligne existe déjà" indique un problème lors de l'écriture des mutations mises en mémoire tampon. Cela peut se produire si, par exemple, une ligne que le client tente de mettre à jour n'existe pas. Dans ces scénarios :

  • Les lectures sont cohérentes : toutes les données lues pendant la transaction sont garanties cohérentes jusqu'au point d'erreur.
  • Les écritures ne sont pas appliquées : les mutations tentées par la transaction ne sont pas validées dans la base de données.
  • Cohérence des lignes : l'inexistence (ou l'état existant) de la ligne qui a déclenché l'erreur est cohérente avec les lectures effectuées dans la transaction.

Vous pouvez annuler les opérations de lecture asynchrones dans Spanner à tout moment sans affecter les autres opérations en cours dans la même transaction. Cette flexibilité est utile si une opération de niveau supérieur est annulée ou si vous décidez d'interrompre une lecture en fonction des résultats initiaux.

Toutefois, il est important de comprendre que demander l'annulation d'une lecture ne garantit pas son arrêt immédiat. Après une demande d'annulation, l'opération de lecture peut toujours :

  • Réussite : la lecture peut se terminer et renvoyer des résultats avant que l'annulation ne prenne effet.
  • Échec pour une autre raison : la lecture peut se terminer en raison d'une autre erreur, telle qu'une annulation.
  • Renvoyer des résultats incomplets : la lecture peut renvoyer des résultats partiels, qui sont ensuite validés dans le cadre du processus de commit de la transaction.

L'annulation d'une opération de commit annule l'intégralité de la transaction, sauf si celle-ci a déjà été validée ou a échoué pour une autre raison.

Atomicité, cohérence, durabilité

En plus de l'isolation, Spanner fournit les autres garanties de propriétés ACID :

  • Atomicité : une transaction est considérée comme atomique si toutes ses opérations sont effectuées avec succès, ou si aucune ne l'est. Si une opération d'une transaction échoue, l'ensemble de la transaction est annulé et revient à son état d'origine, ce qui garantit l'intégrité des données.
  • Cohérence : une transaction doit maintenir l'intégrité des règles et des contraintes de la base de données. Une fois la transaction terminée, la base de données doit être dans un état valide, conformément aux règles prédéfinies.
  • Durabilité : une fois qu'une transaction est validée, ses modifications sont stockées de manière permanente dans la base de données et persistent en cas de défaillance du système, de panne de courant ou d'autres perturbations.

Performances

Cette section décrit les problèmes qui affectent les performances des transactions en lecture-écriture.

Contrôle de simultanéité par verrouillage

Par défaut, Spanner permet à plusieurs clients d'interagir simultanément avec la même base de données dans son niveau d'isolation sérialisable par défaut. Pour maintenir la cohérence des données entre ces transactions simultanées, Spanner dispose d'un mécanisme de verrouillage qui utilise des verrous partagés et exclusifs. Ces verrous en lecture ne sont acquis que pour les transactions sérialisables, mais pas pour les transactions qui utilisent l'isolation de lecture reproductible.

Lorsqu'une transaction sérialisable effectue une opération de lecture, Spanner acquiert des verrous de lecture partagés sur les données concernées. Ces verrous partagés permettent à d'autres opérations de lecture simultanées d'accéder aux mêmes données. Cette simultanéité est maintenue jusqu'à ce que votre transaction se prépare à valider ses modifications.

Dans l'isolation sérialisable, pendant la phase de commit, à mesure que les écritures sont appliquées, la transaction tente de transformer ses verrous en verrous exclusifs. Pour ce faire, Spanner effectue les opérations suivantes :

  • Bloque toutes les nouvelles requêtes de verrouillage en lecture partagé sur les données concernées.
  • Attend que tous les verrous de lecture partagés existants sur ces données soient libérés.
  • Une fois que tous les verrous de lecture partagés sont effacés, il place un verrou exclusif, ce qui lui accorde un accès exclusif aux données pendant la durée de l'écriture.

En revanche, ni l'isolation sérialisable de Spanner avec simultanéité optimiste, ni l'isolation de lecture reproductible avec simultanéité optimiste n'acquièrent de verrous pendant l'exécution de la transaction. Lors de la validation, la transaction acquiert des verrous exclusifs pour les données écrites. La transaction peut devoir attendre des verrouillages si une transaction simultanée valide également des écritures sur les mêmes données.

Dans l'isolation de lecture reproductible avec simultanéité pessimiste, des verrous exclusifs sont acquis pour les données lues par les requêtes qui utilisent FOR UPDATE ou l'indice lock_scanned_ranges=exclusive, et pour les données écrites avec des requêtes LMD. Par conséquent, aucun autre verrou n'est nécessaire au moment du commit.

Notes au sujet des verrous :

  • Précision : Spanner applique des verrous au niveau des lignes et des colonnes. Cela signifie que si la transaction T1 détient un verrou sur la colonne A de la ligne albumid, la transaction T2 peut toujours écrire simultanément dans la colonne B de la même ligne albumid sans conflit.
  • Écritures sans lectures :

    • Lorsqu'il n'y a pas de lecture dans la transaction, Spanner peut ne pas nécessiter de verrou exclusif pour les écritures sans lecture. À la place, il peut utiliser un verrou partagé d'écriture. En effet, l'ordre d'application des écritures sans lecture est déterminé par leurs codes temporels de commit, ce qui permet à plusieurs rédacteurs d'opérer simultanément sur le même élément sans conflit. Un verrou exclusif n'est nécessaire que si votre transaction lit d'abord les données qu'elle a l'intention d'écrire.
    • Dans l'isolation de lecture reproductible, les transactions acquièrent généralement des verrous exclusifs pour les cellules écrites au moment de la validation.
  • Index secondaires pour les recherches de lignes : dans l'isolation sérialisable, lors de l'exécution de lectures dans une transaction en lecture-écriture, l'utilisation d'index secondaires peut améliorer considérablement les performances. En utilisant des index secondaires pour limiter les lignes analysées à une plage plus petite, Spanner verrouille moins de lignes dans la table, ce qui permet une plus grande modification simultanée des lignes en dehors de cette plage spécifique.

  • Accès exclusif aux ressources externes : les verrous internes de Spanner sont conçus pour assurer la cohérence des données dans la base de données Spanner elle-même. Ne les utilisez pas pour garantir un accès exclusif à des ressources en dehors de Spanner. Spanner peut annuler des transactions pour diverses raisons, y compris des optimisations internes du système telles que le déplacement de données entre les ressources de calcul. Si une transaction est relancée (soit explicitement par le code de votre application, soit implicitement par des bibliothèques clientes telles que le pilote JDBC Spanner), les verrous ne sont garantis que pendant la tentative de commit réussie.

  • Statistiques de verrouillage : pour diagnostiquer et examiner les conflits de verrouillage dans votre base de données, utilisez l'outil d'introspection Statistiques de verrouillage.

Détection des blocages

Spanner détecte quand plusieurs transactions peuvent être bloquées et force l'abandon de toutes les transactions sauf une. Prenons le scénario suivant : Txn1 détient un verrou sur l'enregistrement A et attend un verrou sur l'enregistrement B, tandis que Txn2 détient un verrou sur l'enregistrement B et attend un verrou sur l'enregistrement A. Pour résoudre ce problème, l'une des transactions doit être annulée, ce qui libère son verrou et permet à l'autre de continuer.

Spanner utilise l'algorithme wound-wait standard pour la détection des interblocages. En arrière-plan, Spanner suit l'âge de chaque transaction demandant des verrous en conflit. Elle permet aux transactions plus anciennes d'annuler les transactions plus récentes. Une transaction plus ancienne est une transaction dont la première lecture, requête ou validation s'est produite plus tôt.

En donnant la priorité aux transactions plus anciennes, Spanner garantit que chaque transaction finit par acquérir des verrous une fois qu'elle est suffisamment ancienne pour avoir une priorité plus élevée. Par exemple, une transaction plus ancienne nécessitant un verrou partagé par l'auteur peut annuler une transaction plus récente contenant un verrou partagé par le lecteur.

Exécution distribuée

Spanner peut exécuter des transactions sur des données réparties sur plusieurs serveurs, bien que cette fonctionnalité ait un coût en termes de performances par rapport aux transactions sur un seul serveur.

Quels types de transactions peuvent être distribués ? Spanner peut répartir la responsabilité des lignes de base de données sur plusieurs serveurs. En règle générale, une ligne et les lignes de table entrelacées correspondantes sont diffusées par le même serveur, tout comme deux lignes de la même table avec des clés proches. Spanner peut effectuer des transactions sur des lignes situées sur différents serveurs. Toutefois, en règle générale, les transactions affectant de nombreuses lignes colocalisées sont plus rapides et moins coûteuses que celles affectant de nombreuses lignes dispersées dans la base de données ou dans une grande table.

Les transactions les plus efficaces dans Spanner n'incluent que les lectures et les écritures qui doivent être appliquées de manière atomique. Les transactions sont plus rapides lorsque toutes les lectures et écritures accèdent aux données dans une même partie de l'espace clé.

Transactions en lecture seule

En plus de verrouiller les transactions en lecture-écriture, Spanner propose des transactions en lecture seule.

Utilisez une transaction en lecture seule lorsque vous devez exécuter plusieurs lectures au même horodatage. Si vous pouvez exprimer votre lecture à l'aide de l'une des méthodes de lecture unique de Spanner, vous devez utiliser cette méthode de lecture unique. Les performances liées à l'utilisation d'un appel en lecture unique devraient être comparables à celles d'une lecture unique effectuée dans une transaction en lecture seule.

Si vous lisez une grande quantité de données, envisagez d'utiliser des partitions pour lire les données en parallèle.

Parce que les transactions en lecture seule n'effectuent aucune écriture, elles ne peuvent ni être verrouillées, ni bloquer les autres transactions. Les transactions en lecture seule observent un préfixe cohérent de l'historique de commit des transactions. De la sorte, votre application obtient toujours des données cohérentes.

Interface

Spanner fournit une interface permettant d'exécuter un ensemble de tâches dans le contexte d'une transaction en lecture seule, avec de nouvelles tentatives en cas d'abandon de la transaction.

Exemple

L'exemple suivant montre comment utiliser une transaction en lecture seule pour obtenir des données cohérentes pour deux lectures au même code temporel :

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

Sémantique

Cette section décrit la sémantique des transactions en lecture seule.

Transactions d'instantané en lecture seule

Lorsqu'une transaction en lecture seule s'exécute dans Spanner, elle effectue toutes ses lectures à un seul point logique dans le temps. Cela signifie que la transaction en lecture seule et tous les autres lecteurs et rédacteurs simultanés voient un instantané cohérent de la base de données à ce moment précis.

Ces transactions d'instantané en lecture seule offrent une approche plus simple pour les lectures cohérentes que les transactions en lecture-écriture avec verrouillage. Voici pourquoi :

  • Aucun verrou : les transactions en lecture seule n'acquièrent pas de verrous. À la place, elles sélectionnent un code temporel Spanner et exécutent toutes les lectures sur cette version historique des données. Comme elles n'utilisent pas de verrous, elles ne bloquent pas les transactions simultanées en lecture-écriture.
  • Aucun abandon : ces transactions ne sont jamais abandonnées. Bien qu'elles puissent échouer si le code temporel de lecture choisi est récupéré, la règle de récupération de mémoire par défaut de Spanner est généralement suffisamment généreuse pour que la plupart des applications ne rencontrent pas ce problème.
  • Aucun commit ni rollback : les transactions en lecture seule ne nécessitent pas d'appels à sessions.commit ou sessions.rollback, et sont en fait empêchées de le faire.

Pour exécuter une transaction d'instantané, le client définit une limite de code temporel, qui indique à Spanner comment sélectionner un code temporel de lecture. Les types de limites d'horodatage sont les suivants :

  • Lectures fortes : ces lectures garantissent que vous verrez les effets de toutes les transactions validées avant le début de la lecture. Toutes les lignes d'une même lecture sont cohérentes. Cependant, les lectures fortes ne sont pas reproductibles, même si elles renvoient un code temporel et qu'une nouvelle lecture au même code temporel est reproductible. Deux transactions fortes consécutives en lecture seule peuvent produire des résultats différents en raison d'écritures simultanées. Les requêtes sur les flux de modifications doivent utiliser cette limite. Pour en savoir plus, consultez TransactionOptions.ReadOnly.strong.
  • Obsolescence exacte : cette option exécute des lectures à un code temporel que vous spécifiez, soit sous la forme d'un code temporel absolu, soit sous la forme d'une durée d'obsolescence par rapport à l'heure actuelle. Cela vous permet d'observer un préfixe cohérent de l'historique des transactions globales jusqu'à ce code temporel. La lecture attend que toutes les transactions en conflit susceptibles d'être validées au moment du code temporel de lecture ou avant soient terminées. Bien qu'il soit légèrement plus rapide que les modes d'obsolescence limitée, il peut renvoyer des données plus anciennes. Pour en savoir plus, consultez TransactionOptions.ReadOnly.read_timestamp et TransactionOptions.ReadOnly.exact_staleness.
  • Obsolescence limitée : Spanner sélectionne le code temporel le plus récent qui permet à l'instance répliquée disponible la plus proche de diffuser la lecture sans blocage, dans une limite d'obsolescence que vous définissez. Toutes les lignes renvoyées sont cohérentes. Comme les lectures fortes, les lectures avec obsolescence limitée ne sont pas reproductibles, car différentes lectures peuvent s'exécuter à des codes temporels différents, même avec la même limite. Ces lectures s'effectuent en deux phases (négociation du code temporel, puis lecture) et sont généralement un peu plus lentes que les lectures non actualisées exactes, mais elles renvoient souvent des résultats plus récents. Ce mode n'est disponible que pour les transactions en lecture seule à usage unique, car la négociation du code temporel nécessite de connaître à l'avance les lignes auxquelles la lecture accède. Pour en savoir plus, consultez TransactionOptions.ReadOnly.max_staleness et TransactionOptions.ReadOnly.min_read_timestamp.

Les lectures exactes et les lectures non actualisées limitées s'exécutent sur l'instance répliquée disponible la plus proche. Si cette instance répliquée n'est pas à jour par rapport au code temporel de lecture, elle doit communiquer avec l'instance répliquée leader avant de diffuser la lecture. Les lectures non actualisées avec limites sont moins susceptibles de nécessiter cette communication avec le leader, car Spanner choisit un code temporel que l'instance répliquée peut déjà diffuser.

Transactions à LMD partitionné

Vous pouvez utiliser le LMD partitionné pour exécuter des instructions UPDATE et DELETE à grande échelle sans rencontrer de limites de transaction ni verrouiller une table entière. Pour ce faire, Spanner partitionne l'espace de clés et exécute les instructions LMD sur chaque partition dans une transaction en lecture-écriture distincte.

Pour utiliser le LMD non partitionné, vous exécutez des instructions dans des transactions en lecture-écriture que vous créez explicitement dans votre code. Pour en savoir plus, consultez Utiliser le LMD.

Interface

Spanner fournit l'interface TransactionOptions.partitionedDml pour exécuter une seule instruction LMD partitionnée.

Exemples

L'exemple de code suivant met à jour la colonne MarketingBudget de la table Albums.

C++

Vous utilisez la fonction ExecutePartitionedDml() pour exécuter une instruction LMD partitionnée.

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#

Vous utilisez la méthode ExecutePartitionedUpdateAsync() pour exécuter une instruction LMD partitionnée.


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

Vous utilisez la méthode PartitionedUpdate() pour exécuter une instruction LMD partitionnée.


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

Vous utilisez la méthode executePartitionedUpdate() pour exécuter une instruction LMD partitionnée.

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

Vous utilisez la méthode runPartitionedUpdate() pour exécuter une instruction LMD partitionnée.

// 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

Vous utilisez la méthode executePartitionedUpdate() pour exécuter une instruction LMD partitionnée.

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

Vous utilisez la méthode execute_partitioned_dml() pour exécuter une instruction LMD partitionnée.

# 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

Vous utilisez la méthode execute_partitioned_update() pour exécuter une instruction LMD partitionnée.

# 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."

L'exemple de code suivant supprime les lignes de la table Singers, en fonction de la colonne 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."

Sémantique

Cette section décrit la sémantique du LMD partitionné.

Comprendre l'exécution du LMD partitionné

Vous ne pouvez exécuter qu'une seule instruction LMD partitionnée à la fois, que vous utilisiez une méthode de bibliothèque cliente ou la Google Cloud CLI.

Les transactions partitionnées ne sont pas compatibles avec les commits ni les rollbacks. Spanner exécute et applique l'instruction LMD immédiatement. Si vous annulez l'opération ou si elle échoue, Spanner annule toutes les partitions en cours d'exécution et ne démarre pas les partitions restantes. Cependant, Spanner n'effectue pas de rollback des partitions qui ont déjà été exécutées.

Stratégie d'acquisition de verrous LMD partitionnés

Pour réduire les conflits de verrouillage, le LMD partitionné n'acquiert des verrous de lecture que sur les lignes correspondant à la clause WHERE. Les transactions plus petites et indépendantes utilisées pour chaque partition conservent également les verrous moins longtemps.

Anciens codes temporels de lecture et récupération de mémoire des versions

Spanner effectue une récupération de mémoire des versions pour collecter les données supprimées ou écrasées et récupérer de l'espace de stockage. Par défaut, les données datant de plus d'une heure sont récupérées. Spanner ne peut pas effectuer de lectures à des codes temporels antérieurs à la valeur VERSION_RETENTION_PERIOD configurée, qui est d'une heure par défaut, mais peut être configurée pour une durée maximale d'une semaine. Lorsque les lectures deviennent trop anciennes pendant l'exécution, elles échouent et renvoient l'erreur FAILED_PRECONDITION.

Requêtes sur les flux de modifications

Un flux de modifications est un objet de schéma que vous pouvez configurer pour surveiller les modifications de données dans une base de données entière, des tables spécifiques ou un ensemble défini de colonnes dans une base de données.

Lorsque vous créez un flux de modifications, Spanner définit une fonction de valeur de table (TVF) SQL correspondante. Vous pouvez utiliser cette TVF pour interroger les enregistrements de modifications dans le flux de modifications associé à l'aide de la méthode sessions.executeStreamingSql. Le nom de la TVF est généré à partir du nom du flux de modifications et commence toujours par READ_.

Toutes les requêtes sur les TVF de flux de modifications doivent être exécutées à l'aide de l'API sessions.executeStreamingSql dans une transaction en lecture seule à usage unique avec un timestamp_bound en lecture seule fort. La TVF du flux de modifications vous permet de spécifier start_timestamp et end_timestamp pour la période. Tous les enregistrements de modification de la période de conservation sont accessibles à l'aide de cette timestamp_bound forte en lecture seule. Tous les autres TransactionOptions ne sont pas valides pour les requêtes de flux de modifications.

De plus, si TransactionOptions.read_only.return_read_timestamp est défini sur true, le message Transaction décrivant la transaction renvoie une valeur spéciale de 2^63 - 2 au lieu d'un code temporel de lecture valide. Vous devez supprimer cette valeur spéciale et ne pas l'utiliser pour les requêtes ultérieures.

Pour en savoir plus, consultez Workflow de requête de flux de modifications.

Transactions inactives

Une transaction est considérée comme inactive si elle ne comporte aucune lecture ou requête SQL en attente et qu'elle n'en a pas démarré au cours des 10 dernières secondes. Spanner peut annuler les transactions inactives pour éviter qu'elles ne conservent des verrous indéfiniment. Si une transaction inactive est annulée, la validation échoue et renvoie une erreur ABORTED. L'exécution périodique d'une petite requête, telle que SELECT 1, dans la transaction peut l'empêcher de devenir inactive.

Étapes suivantes