Usar el aislamiento de lectura repetible

En esta página se describe cómo usar el aislamiento de lectura repetible en Spanner.

La lectura repetible es un nivel de aislamiento que asegura que todas las operaciones de lectura de una transacción vean una captura coherente de la base de datos tal como estaba al inicio de la transacción. En Spanner, este nivel de aislamiento se implementa mediante una técnica que también se suele denominar aislamiento de instantánea. Este enfoque es útil en situaciones de alta simultaneidad de lectura y escritura en las que numerosas transacciones leen datos que otras transacciones podrían estar modificando. Al usar una instantánea fija, la lectura repetible evita los efectos en el rendimiento del nivel de aislamiento serializable, que es más riguroso. Las lecturas se pueden ejecutar sin adquirir bloqueos y sin bloquear las escrituras simultáneas, lo que puede dar lugar a menos transacciones abortadas que deban volver a intentarse debido a conflictos de serialización. Para obtener más información, consulta la descripción general de los niveles de aislamiento.

Definir el nivel de aislamiento

Puede definir el nivel de aislamiento en las transacciones de lectura y escritura a nivel de cliente de la base de datos o a nivel de transacción mediante los siguientes métodos:

Bibliotecas de cliente

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

Puedes usar la API REST TransactionOptions.isolation_level para definir el nivel de aislamiento en las transacciones de lectura y escritura y de solo lectura a nivel de transacción. Las opciones válidas son TransactionOptions.SERIALIZABLE y TransactionOptions.REPEATABLE_READ. De forma predeterminada, Spanner define el nivel de aislamiento en aislamiento serializable.

Limitaciones

La versión preliminar de aislamiento de lectura repetible tiene las siguientes limitaciones.

  • Es posible que tengas problemas si tu esquema tiene restricciones de comprobación.
    • Hay un problema conocido que impide que se validen las restricciones de comprobación, lo que puede provocar infracciones de restricciones cuando se confirman las transacciones. Por lo tanto, no recomendamos usar el aislamiento de lectura repetible en la vista previa si tu esquema tiene restricciones de comprobación.
  • Puede que tengas problemas si se producen cambios de esquema simultáneos en tu base de datos mientras se ejecutan transacciones.
    • Si tus instrucciones DML usan la opción last_statement y se produce un cambio de esquema simultáneo mientras se ejecuta la instrucción DML, es posible que se vuelva a intentar internamente y se devuelva un error que indique que la instrucción DML se ha vuelto a intentar de forma incorrecta después de definir la opción last_statement. Si se vuelve a intentar la transacción después de que se aplique el cambio de esquema, se solucionará este problema.
    • Si las solicitudes de una transacción experimentan un error DEADLINE_EXCEEDED del cliente, vuelve a intentar la transacción después de que se aplique el cambio de esquema para resolver el problema.

Casos prácticos no admitidos

  • No puedes definir el aislamiento de lectura repetible en transacciones DML particionadas.
  • Todas las transacciones de solo lectura ya operan en una captura fija y no requieren bloqueos, por lo que definir el aislamiento de lectura repetible en este tipo de transacción no cambia ningún comportamiento.
  • No puedes definir el aislamiento de lectura repetible en operaciones de solo lectura, de un solo uso y de partición con las bibliotecas cliente de Spanner. Las bibliotecas cliente de Spanner no tendrán la opción de definir el aislamiento de lectura repetible en operaciones de consulta de solo lectura, de un solo uso y de partición.

Siguientes pasos