Utilizzare l'isolamento di lettura ripetibile

Questa pagina descrive come utilizzare l'isolamento di lettura ripetibile in Spanner.

La lettura ripetibile è un livello di isolamento che garantisce che tutte le operazioni di lettura all'interno di una transazione vedano uno snapshot coerente del database così com'era all'inizio della transazione. In Spanner, questo livello di isolamento viene implementato utilizzando una tecnica comunemente chiamata anche isolamento degli snapshot. Questo approccio è vantaggioso in scenari di concorrenza di lettura/scrittura elevata in cui numerose transazioni leggono dati che altre transazioni potrebbero modificare. Utilizzando uno snapshot fisso, la lettura ripetibile evita gli impatti sulle prestazioni del livello di isolamento serializzabile più rigoroso. Le letture possono essere eseguite senza acquisire blocchi e senza bloccare le scritture simultanee, il che comporta potenzialmente un numero inferiore di transazioni interrotte che potrebbero dover essere riprovate a causa di conflitti di serializzazione. Per maggiori informazioni, consulta la panoramica del livello di isolamento.

Imposta il livello di isolamento

Puoi impostare il livello di isolamento nelle transazioni di lettura/scrittura a livello di client di database o di transazione utilizzando i seguenti metodi:

Librerie client

Vai


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

Puoi utilizzare l'API REST TransactionOptions.isolation_level per impostare il livello di isolamento delle transazioni di lettura/scrittura e di sola lettura a livello di transazione. Le opzioni valide sono TransactionOptions.SERIALIZABLE e TransactionOptions.REPEATABLE_READ. Per impostazione predefinita, Spanner imposta il livello di isolamento su serializzabile.

Limitazioni

Il seguente insieme di limitazioni esiste nell'anteprima dell'isolamento di lettura ripetibile.

  • Potresti riscontrare problemi se lo schema presenta vincoli di controllo.
    • Esiste un problema noto che impedisce la convalida dei vincoli di controllo, il che può comportare violazioni dei vincoli quando vengono eseguite le transazioni. Pertanto, non è consigliabile utilizzare l'isolamento di lettura ripetibile in anteprima se lo schema ha vincoli di controllo.
  • Potresti riscontrare problemi se si verificano modifiche simultanee dello schema nel tuo database durante l'esecuzione delle transazioni.
    • Se le tue istruzioni DML utilizzano l'opzione last_statement e si verifica una modifica dello schema simultanea durante l'esecuzione dell'istruzione DML, potrebbe essere eseguito un nuovo tentativo interno e restituito un errore che indica che il nuovo tentativo di esecuzione dell'istruzione DML è stato eseguito in modo errato dopo l'impostazione dell'opzione last_statement. Se riprovi la transazione dopo l'applicazione della modifica dello schema, il problema viene risolto.
    • Se le richieste in una transazione riscontrano un errore DEADLINE_EXCEEDED dal client, riprova la transazione dopo l'applicazione della modifica dello schema per risolvere il problema.

Casi d'uso non supportati

  • Non puoi impostare l'isolamento in lettura continua nelle transazioni DML partizionate.
  • Tutte le transazioni di sola lettura operano già a uno snapshot fisso e non richiedono blocchi, quindi l'impostazione dell'isolamento di lettura ripetibile in questo tipo di transazione non modifica alcun comportamento.
  • Non puoi impostare l'isolamento di lettura ripetibile su operazioni di sola lettura, monouso e di partizione utilizzando le librerie client Spanner. Le librerie client Spanner non avranno l'opzione per impostare l'isolamento di lettura ripetibile su operazioni di query di sola lettura, monouso e di partizione.

Passaggi successivi