Utiliser l'isolation de lecture répétable

Cette page explique comment utiliser l'isolation de lecture reproductible dans Spanner.

Repeatable read est un niveau d'isolation qui garantit que toutes les opérations de lecture d'une transaction voient un instantané cohérent de la base de données tel qu'il existait au début de la transaction. Dans Spanner, ce niveau d'isolation est implémenté à l'aide d'une technique également appelée isolation d'instantané. Cette approche est utile dans les scénarios de concurrence lecture-écriture élevée, où de nombreuses transactions lisent des données que d'autres transactions peuvent modifier. En utilisant un instantané fixe, la lecture répétée évite les impacts sur les performances du niveau d'isolation sérialisable, qui est plus rigoureux. Les lectures peuvent s'exécuter sans acquérir de verrous et sans bloquer les écritures simultanées, ce qui réduit potentiellement le nombre de transactions abandonnées qui pourraient devoir être relancées en raison de conflits de sérialisation. Pour en savoir plus, consultez Présentation des niveaux d'isolation.

Définir le niveau d'isolation

Vous pouvez définir le niveau d'isolation des transactions en lecture-écriture au niveau du client de base de données ou au niveau de la transaction à l'aide des méthodes suivantes :

Bibliothèques clientes

Go


import (
	"context"
	"fmt"
	"io"

	"cloud.google.com/go/spanner"
	pb "cloud.google.com/go/spanner/apiv1/spannerpb"
)

func writeWithTransactionUsingIsolationLevel(w io.Writer, db string) error {
	ctx := context.Background()

	// The isolation level specified at the client-level will be applied
	// to all RW transactions.
	cfg := spanner.ClientConfig{
		TransactionOptions: spanner.TransactionOptions{
			IsolationLevel: pb.TransactionOptions_SERIALIZABLE,
		},
	}
	client, err := spanner.NewClientWithConfig(ctx, db, cfg)
	if err != nil {
		return fmt.Errorf("failed to create client: %w", err)
	}
	defer client.Close()

	// The isolation level specified at the transaction-level takes
	// precedence over the isolation level configured at the client-level.
	// REPEATABLE_READ is used here to demonstrate overriding the client-level setting.
	txnOpts := spanner.TransactionOptions{
		IsolationLevel: pb.TransactionOptions_REPEATABLE_READ,
	}

	_, err = client.ReadWriteTransactionWithOptions(ctx, func(ctx context.Context, txn *spanner.ReadWriteTransaction) error {
		// Read the current album title
		key := spanner.Key{1, 1}
		row, err := txn.ReadRow(ctx, "Albums", key, []string{"AlbumTitle"})
		if err != nil {
			return fmt.Errorf("failed to read album: %v", err)
		}
		var title string
		if err := row.Column(0, &title); err != nil {
			return fmt.Errorf("failed to get album title: %v", err)
		}
		fmt.Fprintf(w, "Current album title: %s\n", title)

		// Update the album title
		stmt := spanner.Statement{
			SQL: `UPDATE Albums
				SET AlbumTitle = @AlbumTitle
				WHERE SingerId = @SingerId AND AlbumId = @AlbumId`,
			Params: map[string]interface{}{
				"SingerId":   1,
				"AlbumId":    1,
				"AlbumTitle": "New Album Title",
			},
		}
		count, err := txn.Update(ctx, stmt)
		if err != nil {
			return fmt.Errorf("failed to update album: %v", err)
		}
		fmt.Fprintf(w, "Updated %d record(s).\n", count)
		return nil
	}, txnOpts)

	if err != nil {
		return fmt.Errorf("transaction failed: %v", err)
	}
	return nil
}

Java

static void isolationLevelSetting(DatabaseId db) {
  // The isolation level specified at the client-level will be applied to all
  // RW transactions.
  DefaultReadWriteTransactionOptions transactionOptions =
      DefaultReadWriteTransactionOptions.newBuilder()
          .setIsolationLevel(IsolationLevel.SERIALIZABLE)
          .build();
  SpannerOptions options =
      SpannerOptions.newBuilder()
          .setDefaultTransactionOptions(transactionOptions)
          .build();
  Spanner spanner = options.getService();
  DatabaseClient dbClient = spanner.getDatabaseClient(db);
  dbClient
      // The isolation level specified at the transaction-level takes precedence
      // over the isolation level configured at the client-level.
      .readWriteTransaction(Options.isolationLevel(IsolationLevel.REPEATABLE_READ))
      .run(transaction -> {
        // Read an AlbumTitle.
        String selectSql =
            "SELECT AlbumTitle from Albums WHERE SingerId = 1 and AlbumId = 1";
        ResultSet resultSet = transaction.executeQuery(Statement.of(selectSql));
        String title = null;
        while (resultSet.next()) {
          title = resultSet.getString("AlbumTitle");
        }
        System.out.printf("Current album title: %s\n", title);

        // Update the title.
        String updateSql =
            "UPDATE Albums "
                + "SET AlbumTitle = 'New Album Title' "
                + "WHERE SingerId = 1 and AlbumId = 1";
        long rowCount = transaction.executeUpdate(Statement.of(updateSql));
        System.out.printf("%d record updated.\n", rowCount);
        return null;
      });
}

Node.js

// Imports the Google Cloud Spanner client library
const {Spanner, protos} = require('@google-cloud/spanner');
// The isolation level specified at the client-level will be applied
// to all RW transactions.
const isolationOptionsForClient = {
  defaultTransactionOptions: {
    isolationLevel:
      protos.google.spanner.v1.TransactionOptions.IsolationLevel.SERIALIZABLE,
  },
};

// Instantiates a client with defaultTransactionOptions
const spanner = new Spanner({
  projectId: projectId,
  defaultTransactionOptions: isolationOptionsForClient,
});

function runTransactionWithIsolationLevel() {
  // Gets a reference to a Cloud Spanner instance and database
  const instance = spanner.instance(instanceId);
  const database = instance.database(databaseId);
  // The isolation level specified at the request level takes precedence over the isolation level configured at the client level.
  const isolationOptionsForTransaction = {
    isolationLevel:
      protos.google.spanner.v1.TransactionOptions.IsolationLevel
        .REPEATABLE_READ,
  };

  database.runTransaction(
    isolationOptionsForTransaction,
    async (err, transaction) => {
      if (err) {
        console.error(err);
        return;
      }
      try {
        const query =
          'SELECT AlbumTitle FROM Albums WHERE SingerId = 1 AND AlbumId = 1';
        const results = await transaction.run(query);
        // Gets first album's title
        const rows = results[0].map(row => row.toJSON());
        const albumTitle = rows[0].AlbumTitle;
        console.log(`previous album title ${albumTitle}`);

        const update =
          "UPDATE Albums SET AlbumTitle = 'New Album Title' WHERE SingerId = 1 AND AlbumId = 1";
        const [rowCount] = await transaction.runUpdate(update);
        console.log(
          `Successfully updated ${rowCount} record in Albums table.`,
        );
        await transaction.commit();
        console.log(
          'Successfully executed read-write transaction with isolationLevel option.',
        );
      } catch (err) {
        console.error('ERROR:', err);
      } finally {
        transaction.end();
        // Close the database when finished.
        await database.close();
      }
    },
  );
}
runTransactionWithIsolationLevel();

Python

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

# The isolation level specified at the client-level will be applied to all RW transactions.
isolation_options_for_client = TransactionOptions.IsolationLevel.SERIALIZABLE

spanner_client = spanner.Client(
    default_transaction_options=DefaultTransactionOptions(
        isolation_level=isolation_options_for_client
    )
)
instance = spanner_client.instance(instance_id)
database = instance.database(database_id)

# The isolation level specified at the request level takes precedence over the isolation level configured at the client level.
isolation_options_for_transaction = (
    TransactionOptions.IsolationLevel.REPEATABLE_READ
)

def update_albums_with_isolation(transaction):
    # Read an AlbumTitle.
    results = transaction.execute_sql(
        "SELECT AlbumTitle from Albums WHERE SingerId = 1 and AlbumId = 1"
    )
    for result in results:
        print("Current Album Title: {}".format(*result))

    # Update the AlbumTitle.
    row_ct = transaction.execute_update(
        "UPDATE Albums SET AlbumTitle = 'A New Title' WHERE SingerId = 1 and AlbumId = 1"
    )

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

database.run_in_transaction(
    update_albums_with_isolation, isolation_level=isolation_options_for_transaction
)

REST

Vous pouvez utiliser l'API REST TransactionOptions.isolation_level pour définir le niveau d'isolation des transactions en lecture/écriture et en lecture seule au niveau de la transaction. Les options valides sont TransactionOptions.SERIALIZABLE et TransactionOptions.REPEATABLE_READ. Par défaut, Spanner définit le niveau d'isolation sur l'isolation sérialisable.

Limites

L'ensemble de limites suivant existe dans la version bêta de l'isolation de lecture reproductible.

  • Vous risquez de rencontrer des problèmes si votre schéma comporte des contraintes de vérification.
    • Un problème connu empêche la validation des contraintes de vérification, ce qui peut entraîner des violations de contraintes lors de l'exécution des transactions. Par conséquent, nous vous déconseillons d'utiliser l'isolation de lecture reproductible en aperçu si votre schéma comporte des contraintes de vérification.
  • Des problèmes peuvent survenir si des modifications simultanées du schéma ont lieu dans votre base de données pendant l'exécution des transactions.
    • Si vos instructions LMD utilisent l'option last_statement et qu'une modification simultanée du schéma se produit pendant l'exécution de l'instruction LMD, celle-ci peut faire l'objet d'une nouvelle tentative en interne et renvoyer une erreur indiquant que la nouvelle tentative LMD a été effectuée de manière incorrecte après la définition de l'option last_statement. Le problème peut être résolu en réessayant la transaction après l'application de la modification du schéma.
    • Si les requêtes d'une transaction rencontrent une erreur DEADLINE_EXCEEDED du client, réessayez la transaction après l'application de la modification du schéma pour résoudre le problème.

Cas d'utilisation non compatibles

  • Vous ne pouvez pas définir l'isolation de lecture reproductible sur les transactions LMD partitionnées.
  • Toutes les transactions en lecture seule fonctionnent déjà à un instantané fixe et ne nécessitent pas de verrous. Par conséquent, la définition de l'isolation de lecture reproductible dans ce type de transaction ne modifie aucun comportement.
  • Vous ne pouvez pas définir l'isolation de lecture reproductible sur les opérations de lecture seule, à usage unique et de partition à l'aide des bibliothèques clientes Spanner. Les bibliothèques clientes Spanner ne permettent pas de définir l'isolation de lecture reproductible sur les opérations de requête de lecture seule, à usage unique et de partition.

Étapes suivantes