Repeatable Read 分離を使用する

このページでは、Spanner で再現可能な読み取り分離を使用する方法について説明します。

再現可能な読み取りは、トランザクション内のすべての読み取りオペレーションが、トランザクションの開始時点でのデータベースの一貫したスナップショットを参照することを保証する分離レベルです。Spanner では、この分離レベルはスナップショット分離とも呼ばれる手法を使用して実装されます。このアプローチは、多数のトランザクションが他のトランザクションによって変更される可能性のあるデータを読み取る、読み取り / 書き込みの同時実行性が高いシナリオで有効です。固定スナップショットを使用することで、リピータブル リードは、より厳密なシリアライズ可能な分離レベルのパフォーマンスへの影響を回避します。読み取りはロックを取得せずに実行でき、同時書き込みをブロックしないため、シリアル化の競合が原因で再試行が必要になる可能性のあるトランザクションの中止が少なくなる可能性があります。詳細については、分離レベルの概要をご覧ください。

分離レベルを設定する

読み取り / 書き込みトランザクションの分離レベルは、次の方法でデータベース クライアント レベルまたはトランザクション レベルで設定できます。

クライアント ライブラリ

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

TransactionOptions.isolation_level REST API を使用して、トランザクション レベルで読み取り / 書き込みトランザクションと読み取り専用トランザクションの分離レベルを設定できます。有効なオプションは TransactionOptions.SERIALIZABLE と TransactionOptions.REPEATABLE_READ です。デフォルトでは、Spanner は分離レベルを直列化可能な分離に設定します。

制限事項

Repeatable Read 分離のプレビューには、次の制限事項があります。

  • スキーマにチェック制約がある場合、問題が発生する可能性があります。
    • チェック制約が検証されない既知の問題があります。この問題により、トランザクションの commit 時に制約違反が発生する可能性があります。そのため、スキーマにチェック制約がある場合は、プレビューで反復可能読み取り分離を使用することをおすすめしません。
  • トランザクションの実行中にデータベースでスキーマの同時変更が発生すると、問題が発生する可能性があります。
    • DML ステートメントで last_statement オプションが使用され、DML ステートメントの実行中に同時スキーマ変更が発生すると、内部的に再試行され、last_statement オプションの設定後に DML が誤って再試行されたことを示すエラーが返されることがあります。スキーマの変更が適用された後にトランザクションを再試行すると、この問題は解決します。
    • トランザクション内のリクエストでクライアントから DEADLINE_EXCEEDED エラーが発生した場合は、スキーマの変更が適用された後にトランザクションを再試行して問題を解決します。

サポートされていないユースケース

  • パーティション化 DML トランザクションで繰り返し読み取り分離を設定することはできません。
  • すべての読み取り専用トランザクションはすでに固定スナップショットで動作しており、ロックを必要としないため、このトランザクション タイプで繰り返し読み取り分離を設定しても動作は変わりません。
  • Spanner クライアント ライブラリを使用して、読み取り専用、単一使用、パーティション オペレーションに反復可能読み取り分離を設定することはできません。Spanner クライアント ライブラリには、読み取り専用、単一使用、パーティション クエリ オペレーションに反復可能読み取り分離を設定するオプションはありません。

次のステップ