Leseempfehlungen

Vorschau — Directed reads

Diese Funktion unterliegt den „Nutzungsbedingungen für Pre-GA-Angebote“ im Abschnitt „Allgemeine Nutzungsbedingungen“ der dienstspezifischen Nutzungsbedingungen. Pre-GA-Funktionen sind „wie besehen“ verfügbar und werden möglicherweise nur eingeschränkt unterstützt. Weitere Informationen finden Sie in den Beschreibungen der Startphase.

Auf dieser Seite werden von Spanner gesteuerte Lesevorgänge und ihre Verwendung beschrieben.

Mit gerichteten Lesevorgängen in Spanner können Sie schreibgeschützte Transaktionen und einzelne Lesevorgänge flexibel an einen bestimmten Replikattyp oder eine bestimmte Region innerhalb einer multiregionalen Instanzkonfiguration oder einer benutzerdefinierten regionalen Konfiguration mit optionalen schreibgeschützten Regionen weiterleiten.

Gängige Anwendungsfälle

Hier einige häufige Anwendungsfälle für gerichtete Lesevorgänge:

• Load-Balancing von Arbeitslasten über mehrere Regionen hinweg, um eine gleichmäßigere CPU-Auslastung zu erreichen
• Isolieren Sie Analysen in Ihrer Anwendung, indem Sie die Auswirkungen auf Transaktionsarbeitslasten minimieren.
• Bereitstellung einer teilweisen Isolierung für Lesevorgänge von Änderungsstreams. Wenn Sie die Spanner API zum Streamen von Spanner-Datenänderungen verwenden, können Sie die Auswirkungen auf Transaktionsarbeitslasten durch gerichtete Lesevorgänge minimieren.

Unterstützte Abfragevorgänge

Abfragevorgänge	Werden gerichtete Lesevorgänge unterstützt?
Veralteter Lesezugriff	Ja
Aussagekräftiger Lesestoff	Ja
Lese-Schreib-Transaktion	Nein

Gezielte Lesevorgänge werden für Lese-Schreib-Transaktionen und partitionierte DML-Bulk-Aktualisierungen nicht unterstützt. Das liegt daran, dass Lese-Schreib-Transaktionen in der führenden Region verarbeitet werden müssen. Wenn gerichtete Lesevorgänge in einer Lese-Schreib-Transaktion verwendet werden, schlägt die Transaktion mit dem Fehler BAD_REQUEST fehl.

Beschränkungen

Für Spanner-gerichtete Lesevorgänge gelten die folgenden Einschränkungen:

• Sie können gerichtete Lesevorgänge nur in einer Spanner-Instanz verwenden, die sich in einer multiregionalen Instanzkonfiguration oder einer benutzerdefinierten regionalen Konfiguration mit optionalen schreibgeschützten Regionen befindet.
• Sie können keine gerichteten Lesevorgänge mit Lese-/Schreibanfragen verwenden, da Schreibanfragen immer von der führenden Region verarbeitet werden.
• In der Google Cloud Console oder der Google Cloud CLI können keine gerichteten Lesevorgänge verwendet werden. Sie ist über die REST API und die RPC API sowie die Spanner-Clientbibliotheken verfügbar.
• Sie können in einem einzelnen gerichteten Lesevorgang maximal 10 Replikate angeben.
• Wenn Sie das Dashboard für Systemstatistiken oder den Metrics Explorer in den Diagrammen „Vorgänge pro Sekunde“, „Vorgänge pro Sekunde nach Datenbank“ und „Vorgänge pro Sekunde nach API-Methoden“ verwenden, wird Ihre Anfrage für gerichtete Lesevorgänge möglicherweise an einem anderen als dem von Ihnen angegebenen Ort angezeigt. In diesem Fall sind die Informationen aus den Diagrammen möglicherweise falsch. Mit den CPU-Auslastungsmesswerten können Sie prüfen, ob Ihre Leseanfragen an die ausgewählten Regionen weitergeleitet werden. Diese Messwerte geben die genauesten Informationen darüber an, wohin Traffic mit gerichteten Lesevorgängen weitergeleitet wird.

Hinweise

Beachten Sie Folgendes, bevor Sie gerichtete Lesevorgänge verwenden:

• Die Anwendung kann zusätzliche Latenz verursachen, wenn Sie Lesevorgänge an ein Replikat oder eine Region weiterleiten, das nicht der Anwendung am nächsten ist.
• Sie können Traffic basierend auf folgenden Kriterien weiterleiten:
  • Name der Region (z. B. us-central1).
  • Replikattyp (mögliche Werte: READ_ONLY und READ_WRITE).
• Die Option für automatisches Failover in gerichteten Lesevorgängen ist standardmäßig aktiviert. Wenn der automatische Failover aktiviert ist und alle angegebenen Replikate nicht verfügbar oder fehlerhaft sind, leitet Spanner Anfragen an ein Replikat außerhalb der includeReplicas-Liste weiter. Wenn Sie die Option für automatisches Failover deaktivieren und alle angegebenen Replikate nicht verfügbar oder fehlerhaft sind, schlägt die Anfrage für gerichtete Lesevorgänge fehl.

Parameter für gerichtete Lesevorgänge

Wenn Sie die REST API oder die RPC API für gerichtete Lesevorgänge verwenden, müssen Sie diese Felder im Parameter directedReadOptions definieren. Sie können entweder includeReplicas oder excludeReplicas angeben, nicht beides.

• includeReplicas: enthält einen wiederholten Satz von replicaSelections. Diese Liste gibt die Reihenfolge an, in der gerichtete Lesevorgänge in bestimmte Regionen oder Replikattypen berücksichtigt werden sollen. Sie können maximal 10 includeReplicas angeben.
  • replicaSelections: Besteht aus der location oder dem Replikat-type, das die Anfrage für gerichtete Lesevorgänge verarbeitet. Wenn Sie includeReplicas verwenden, müssen Sie mindestens eines der folgenden Felder angeben:
    • location: Der Standort, von dem die Anfrage für gerichtete Lesevorgänge verarbeitet wird. Der Standort muss eine der Regionen innerhalb der multiregionalen Konfiguration Ihrer Datenbank sein. Wenn der Standort nicht zu den Regionen innerhalb der multiregionalen Konfiguration Ihrer Datenbank gehört, werden Anfragen nicht wie erwartet weitergeleitet. Stattdessen werden sie von der nächstgelegenen Region bedient. Sie können beispielsweise Lesevorgänge an den Speicherort us-central1 einer Datenbank in der multiregionalen Instanzkonfiguration nam6 weiterleiten.
    • type: Der Replikattyp, der die Anfrage für gerichtete Lesevorgänge verarbeitet. Mögliche Typen sind READ_WRITE und READ_ONLY.
  • autoFailoverDisabled: Die Standardeinstellung ist False. Das bedeutet, dass der automatische Failover aktiviert ist. Wenn die Option für den automatischen Failover aktiviert ist und alle angegebenen Replikate nicht verfügbar oder fehlerhaft sind, leitet Spanner Anfragen an ein Replikat außerhalb der Liste includeReplicas weiter. Wenn Sie die Option für automatisches Failover deaktivieren und alle angegebenen Replikate nicht verfügbar oder fehlerhaft sind, schlägt die Anfrage für gerichtete Lesevorgänge fehl. Mögliche Werte sind TRUE für deaktiviert und FALSE für aktiviert.
• excludeReplicas: Enthält einen wiederholten Satz von replicaSelections, der von der Verarbeitung von Anfragen ausgeschlossen ist. Spanner leitet Anfragen nicht an Replikate in dieser Liste weiter.
  • replicaSelections: Der Standort oder Replikattyp, der von der Anfrage für gerichtete Lesevorgänge ausgeschlossen ist. Wenn Sie excludeReplicas verwenden, müssen Sie mindestens eines der folgenden Felder angeben:
    • location: Der Standort, der von der Anfrage für gerichtete Lesevorgänge ausgeschlossen ist.
    • type: Der Replikattyp, der von der Ausführung der gerichteten Leseanfrage ausgeschlossen ist. Mögliche Typen sind READ_WRITE und READ_ONLY.

Wenn Sie ein Beispiel für den Text einer REST-Anfrage aufrufen möchten, klicken Sie im Abschnitt Directed Reads auf den Tab „REST“.

Gesteuerte Lesevorgänge verwenden

Sie können die Spanner-Clientbibliotheken sowie die REST API und die RPC API verwenden, um gerichtete Lesevorgänge auszuführen.

Clientbibliotheken

C++

void DirectedRead(std::string const& project_id, std::string const& instance_id,
                  std::string const& database_id) {
  namespace spanner = ::google::cloud::spanner;

  // Create a client with a DirectedReadOption.
  auto client = spanner::Client(
      spanner::MakeConnection(
          spanner::Database(project_id, instance_id, database_id)),
      google::cloud::Options{}.set<spanner::DirectedReadOption>(
          spanner::ExcludeReplicas({spanner::ReplicaSelection("us-east4")})));

  spanner::SqlStatement select(
      "SELECT SingerId, AlbumId, AlbumTitle FROM Albums");
  using RowType = std::tuple<std::int64_t, std::int64_t, std::string>;

  // A DirectedReadOption on the operation will override the option set
  // at the client level.
  auto rows = client.ExecuteQuery(
      std::move(select),
      google::cloud::Options{}.set<spanner::DirectedReadOption>(
          spanner::IncludeReplicas(
              {spanner::ReplicaSelection(spanner::ReplicaType::kReadWrite)},
              /*auto_failover_disabled=*/true)));
  for (auto& row : spanner::StreamOf<RowType>(rows)) {
    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";
  }
  std::cout << "Read completed for [spanner_directed_read]\n";
}

C#

using Google.Cloud.Spanner.Data;
using Google.Cloud.Spanner.V1;
using System.Collections.Generic;
using System.Threading.Tasks;

public class DirectedReadsAsyncSample
{
    public class Album
    {
        public int SingerId { get; set; }
        public int AlbumId { get; set; }
        public string AlbumTitle { get; set; }
    }

    public async Task<List<Album>> DirectedReadsAsync(string projectId, string instanceId, string databaseId)
    {
        string connectionString = $"Data Source=projects/{projectId}/instances/{instanceId}/databases/{databaseId}";
        using var connection = new SpannerConnection(connectionString);

        using var cmd = connection.CreateSelectCommand("SELECT SingerId, AlbumId, AlbumTitle FROM Albums");
        // Set directed read options on a query or read command.
        cmd.DirectedReadOptions = new DirectedReadOptions
        {
            IncludeReplicas = new DirectedReadOptions.Types.IncludeReplicas
            {
                AutoFailoverDisabled = true,
                ReplicaSelections =
                {
                    new DirectedReadOptions.Types.ReplicaSelection
                    {
                        Location = "us-central1",
                        Type = DirectedReadOptions.Types.ReplicaSelection.Types.Type.ReadOnly
                    }
                }
            }
        };

        var albums = new List<Album>();
        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")
            });
        }
        return albums;
    }
}

Go

import (
	"context"
	"fmt"
	"io"

	"cloud.google.com/go/spanner"
	sppb "cloud.google.com/go/spanner/apiv1/spannerpb"
	"google.golang.org/api/iterator"
)

//	Shows how to run a query with directed read options.
//	Only one of ExcludeReplicas or IncludeReplicas can be set
//	Each accepts a list of ReplicaSelections which contains Location and Type
//	* `location` - The location must be one of the regions within the
//	multi-region configuration of your database.
//	* `type` - The type of the replica
//	Some examples of using replica_selectors are:
//	* `location:us-east1` --> The "us-east1" replica(s) of any available type
//		will be used to process the request.
//	* `type:READ_ONLY`    --> The "READ_ONLY" type replica(s) in nearest
//	available location will be used to process the
//	request.
//	* `location:us-east1 type:READ_ONLY` --> The "READ_ONLY" type replica(s)
//	in location "us-east1" will be used to process the request.
//		IncludeReplicas also contains an option for AutoFailoverDisabled which when set
//	Spanner will not route requests to a replica outside the
//	IncludeReplicas list when all the specified replicas are unavailable
//	or unhealthy. The default value is `false`

func directedReadOptions(w io.Writer, db string) error {
	// db = `projects/<project>/instances/<instance-id>/database/<database-id>`
	ctx := context.Background()
	directedReadOptionsForClient := &sppb.DirectedReadOptions{
		Replicas: &sppb.DirectedReadOptions_ExcludeReplicas_{
			ExcludeReplicas: &sppb.DirectedReadOptions_ExcludeReplicas{
				ReplicaSelections: []*sppb.DirectedReadOptions_ReplicaSelection{
					{
						Location: "us-east4",
					},
				},
			},
		},
	}
	// DirectedReadOptions can be set at client level and will be used in all read-only transaction requests
	client, err := spanner.NewClientWithConfig(ctx, db, spanner.ClientConfig{DirectedReadOptions: directedReadOptionsForClient})
	if err != nil {
		return err
	}
	defer client.Close()

	// DirectedReadOptions set at Request level will override the options set at Client level.
	directedReadOptionsForRequest := &sppb.DirectedReadOptions{
		Replicas: &sppb.DirectedReadOptions_IncludeReplicas_{
			IncludeReplicas: &sppb.DirectedReadOptions_IncludeReplicas{
				ReplicaSelections: []*sppb.DirectedReadOptions_ReplicaSelection{
					{
						Type: sppb.DirectedReadOptions_ReplicaSelection_READ_ONLY,
					},
				},
				AutoFailoverDisabled: true,
			},
		},
	}

	statement := spanner.Statement{SQL: `SELECT SingerId, AlbumId, AlbumTitle FROM Albums`}
	// // Read rows while passing directedReadOptions directly to the query.
	iter := client.Single().QueryWithOptions(ctx, statement, spanner.QueryOptions{DirectedReadOptions: directedReadOptionsForRequest})
	defer iter.Stop()
	for {
		row, err := iter.Next()
		if err == iterator.Done {
			return nil
		}
		if err != nil {
			return err
		}
		var singerID, 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

import com.google.cloud.spanner.DatabaseClient;
import com.google.cloud.spanner.DatabaseId;
import com.google.cloud.spanner.Options;
import com.google.cloud.spanner.ResultSet;
import com.google.cloud.spanner.Spanner;
import com.google.cloud.spanner.SpannerOptions;
import com.google.cloud.spanner.Statement;
import com.google.spanner.v1.DirectedReadOptions;
import com.google.spanner.v1.DirectedReadOptions.ExcludeReplicas;
import com.google.spanner.v1.DirectedReadOptions.IncludeReplicas;
import com.google.spanner.v1.DirectedReadOptions.ReplicaSelection;

public class DirectedReadSample {
  static void directedRead() {
    // TODO(developer): Replace these variables before running the sample.
    final String projectId = "my-project";
    final String instanceId = "my-instance";
    final String databaseId = "my-database";
    directedRead(projectId, instanceId, databaseId);
  }

  static void directedRead(String projectId, String instanceId, String databaseId) {
    // Only one of excludeReplicas or includeReplicas can be set
    // Each accepts a list of replicaSelections which contains location and type
    //   * `location` - The location must be one of the regions within the
    //      multi-region configuration of your database.
    //   * `type` - The type of the replica
    // Some examples of using replicaSelectors are:
    //   * `location:us-east1` --> The "us-east1" replica(s) of any available type
    //                             will be used to process the request.
    //   * `type:READ_ONLY`    --> The "READ_ONLY" type replica(s) in nearest
    // .                            available location will be used to process the
    //                             request.
    //   * `location:us-east1 type:READ_ONLY` --> The "READ_ONLY" type replica(s)
    //                          in location "us-east1" will be used to process
    //                          the request.
    //  includeReplicas also contains an option called autoFailoverDisabled, which when set to true
    //  will instruct Spanner to not route requests to a replica outside the
    //  includeReplicas list when all the specified replicas are unavailable
    //  or unhealthy. Default value is `false`.
    final DirectedReadOptions directedReadOptionsForClient =
        DirectedReadOptions.newBuilder()
            .setExcludeReplicas(
                ExcludeReplicas.newBuilder()
                    .addReplicaSelections(
                        ReplicaSelection.newBuilder().setLocation("us-east4").build())
                    .build())
            .build();

    // You can set default `DirectedReadOptions` for a Spanner client. These options will be applied
    // to all read-only transactions that are executed by this client, unless specific
    // DirectedReadOptions are set for a query.
    // Directed read can only be used for read-only transactions. The default options will be
    // ignored for any read/write transaction that the client executes.
    try (Spanner spanner =
        SpannerOptions.newBuilder()
            .setProjectId(projectId)
            .setDirectedReadOptions(directedReadOptionsForClient)
            .build()
            .getService()) {
      final DatabaseClient dbClient =
          spanner.getDatabaseClient(DatabaseId.of(projectId, instanceId, databaseId));

      // DirectedReadOptions at request level will override the options set at
      // client level (through SpannerOptions).
      final DirectedReadOptions directedReadOptionsForRequest =
          DirectedReadOptions.newBuilder()
              .setIncludeReplicas(
                  IncludeReplicas.newBuilder()
                      .addReplicaSelections(
                          ReplicaSelection.newBuilder()
                              .setType(ReplicaSelection.Type.READ_WRITE)
                              .build())
                      .setAutoFailoverDisabled(true)
                      .build())
              .build();

      // Read rows while passing DirectedReadOptions directly to the query.
      try (ResultSet rs =
          dbClient
              .singleUse()
              .executeQuery(
                  Statement.of("SELECT SingerId, AlbumId, AlbumTitle FROM Albums"),
                  Options.directedRead(directedReadOptionsForRequest))) {
        while (rs.next()) {
          System.out.printf(
              "SingerId: %d, AlbumId: %d, AlbumTitle: %s\n",
              rs.getLong(0), rs.getLong(1), rs.getString(2));
        }
        System.out.println("Successfully executed read-only transaction with directedReadOptions");
      }
    }
  }
}

Node.js

// Imports the Google Cloud Spanner client library
const {Spanner, protos} = require('@google-cloud/spanner');

// Only one of excludeReplicas or includeReplicas can be set
// Each accepts a list of replicaSelections which contains location and type
//   * `location` - The location must be one of the regions within the
//      multi-region configuration of your database.
//   * `type` - The type of the replica
// Some examples of using replicaSelectors are:
//   * `location:us-east1` --> The "us-east1" replica(s) of any available type
//                             will be used to process the request.
//   * `type:READ_ONLY`    --> The "READ_ONLY" type replica(s) in nearest
//.                            available location will be used to process the
//                             request.
//   * `location:us-east1 type:READ_ONLY` --> The "READ_ONLY" type replica(s)
//                          in location "us-east1" will be used to process
//                          the request.
//  includeReplicas also contains an option for autoFailover which when set
//  Spanner will not route requests to a replica outside the
//  includeReplicas list when all the specified replicas are unavailable
//  or unhealthy. The default value is `false`
const directedReadOptionsForClient = {
  excludeReplicas: {
    replicaSelections: [
      {
        location: 'us-east4',
      },
    ],
  },
};

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

async function spannerDirectedReads() {
  // Gets a reference to a Cloud Spanner instance and backup
  const instance = spanner.instance(instanceId);
  const database = instance.database(databaseId);
  const directedReadOptionsForRequest = {
    includeReplicas: {
      replicaSelections: [
        {
          type: protos.google.spanner.v1.DirectedReadOptions.ReplicaSelection
            .Type.READ_ONLY,
        },
      ],
      autoFailoverDisabled: true,
    },
  };

  await database.getSnapshot(async (err, transaction) => {
    if (err) {
      console.error(err);
      return;
    }
    try {
      // Read rows while passing directedReadOptions directly to the query.
      // These will override the options passed at Client level.
      const [rows] = await transaction.run({
        sql: 'SELECT SingerId, AlbumId, AlbumTitle FROM Albums',
        directedReadOptions: directedReadOptionsForRequest,
      });
      rows.forEach(row => {
        const json = row.toJSON();
        console.log(
          `SingerId: ${json.SingerId}, AlbumId: ${json.AlbumId}, AlbumTitle: ${json.AlbumTitle}`
        );
      });
      console.log(
        'Successfully executed read-only transaction with directedReadOptions'
      );
    } catch (err) {
      console.error('ERROR:', err);
    } finally {
      transaction.end();
      // Close the database when finished.
      await database.close();
    }
  });
}
spannerDirectedReads();

PHP

use Google\Cloud\Spanner\SpannerClient;
use Google\Cloud\Spanner\V1\DirectedReadOptions\ReplicaSelection\Type as ReplicaType;

/**
 * Queries sample data from the database with directed read options.
 * Example:
 * ```
 * directed_read($instanceId, $databaseId);
 * ```
 *
 * @param string $instanceId The Spanner instance ID.
 * @param string $databaseId The Spanner database ID.
 */
function directed_read(string $instanceId, string $databaseId): void
{
    $directedReadOptionsForClient = [
        'directedReadOptions' => [
            'excludeReplicas' => [
                'replicaSelections' => [
                    [
                        'location' => 'us-east4'
                    ]
                ]
            ]
        ]
    ];

    $directedReadOptionsForRequest = [
        'directedReadOptions' => [
            'includeReplicas' => [
                'replicaSelections' => [
                    [
                        'type' => ReplicaType::READ_WRITE
                    ]
                ],
                'autoFailoverDisabled' => true
            ]
        ]
    ];

    $spanner = new SpannerClient($directedReadOptionsForClient);
    $instance = $spanner->instance($instanceId);
    $database = $instance->database($databaseId);
    $snapshot = $database->snapshot();

    // directedReadOptions at Request level will override the options set at
    // Client level
    $results = $snapshot->execute(
        'SELECT SingerId, AlbumId, AlbumTitle FROM Albums',
        $directedReadOptionsForRequest
    );

    foreach ($results as $row) {
        printf('SingerId: %s, AlbumId: %s, AlbumTitle: %s' . PHP_EOL,
            $row['SingerId'], $row['AlbumId'], $row['AlbumTitle']);
    }
}

Python

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

directed_read_options_for_client = {
    "exclude_replicas": {
        "replica_selections": [
            {
                "location": "us-east4",
            },
        ],
    },
}

# directed_read_options can be set at client level and will be used in all
# read-only transaction requests
spanner_client = spanner.Client(
    directed_read_options=directed_read_options_for_client
)
instance = spanner_client.instance(instance_id)
database = instance.database(database_id)

directed_read_options_for_request = {
    "include_replicas": {
        "replica_selections": [
            {
                "type_": DirectedReadOptions.ReplicaSelection.Type.READ_ONLY,
            },
        ],
        "auto_failover_disabled": True,
    },
}

with database.snapshot() as snapshot:
    # Read rows while passing directed_read_options directly to the query.
    # These will override the options passed at Client level.
    results = snapshot.execute_sql(
        "SELECT SingerId, AlbumId, AlbumTitle FROM Albums",
        directed_read_options=directed_read_options_for_request,
    )

    for row in results:
        print("SingerId: {}, AlbumId: {}, AlbumTitle: {}".format(*row))

Ruby

require "google/cloud/spanner"

##
# This is a snippet for showcasing how to pass in directed read options.
#
# @param project_id  [String] The ID of the Google Cloud project.
# @param instance_id [String] The ID of the spanner instance.
# @param database_id [String] The ID of the database.
#
def spanner_directed_read project_id:, instance_id:, database_id:
  # Only one of exclude_replicas or include_replicas can be set.
  # Each accepts a list of replica_selections which contains location and type
  #   * `location` - The location must be one of the regions within the
  #      multi-region configuration of your database.
  #   * `type` - The type of the replica
  # Some examples of using replicaSelectors are:
  #   * `location:us-east1` --> The "us-east1" replica(s) of any available type
  #                             will be used to process the request.
  #   * `type:READ_ONLY`    --> The "READ_ONLY" type replica(s) in the nearest
  # .                            available location will be used to process the
  #                             request.
  #   * `location:us-east1 type:READ_ONLY` --> The "READ_ONLY" type replica(s)
  #                          in location "us-east1" will be used to process
  #                          the request.
  #  include_replicas also contains an option for auto_failover_disabled. If set
  #  Spanner will not route requests to a replica outside the
  #  include_replicas list even if all the specified replicas are
  #  unavailable or unhealthy. The default value is `false`.
  directed_read_options_for_client = {
    include_replicas: {
      replica_selections: [{ location: "us-east4" }]
    }
  }

  # Instantiates a client with directedReadOptions
  spanner = Google::Cloud::Spanner.new project: project_id
  client  = spanner.client instance_id, database_id, directed_read_options: directed_read_options_for_client

  directed_read_options = {
    include_replicas: {
      replica_selections: [{ type: "READ_WRITE" }],
      auto_failover_disabled: true
    }
  }

  result = client.execute_sql "SELECT SingerId, AlbumId, AlbumTitle FROM Albums", directed_read_options: directed_read_options
  result.rows.each do |row|
    puts "SingerId: #{row[:SingerId]}"
    puts "AlbumId: #{row[:AlbumId]}"
    puts "AlbumTitle: #{row[:AlbumTitle]}"
  end
  puts "Successfully executed read-only transaction with directed_read_options"
end

REST

Sie können die folgenden REST APIs verwenden, um gerichtete Lesevorgänge auszuführen:

• executeSql
• executeStreamingSql
• read
• streamingRead

So führen Sie beispielsweise gerichtete Lesevorgänge in us-central1 mit executeSQL aus:

1. Klicken Sie auf projects.instances.databases.sessions.executeSql.

2. Geben Sie für session (Sitzung) Folgendes ein:

   projects/<VAR>PROJECT-ID</VAR>/instances/<VAR>INSTANCE-ID</VAR>/databases/<VAR>DATABASE-ID</VAR>/sessions/<VAR>SESSION-ID</VAR>
   

   Ersetzen Sie Folgendes:

   • PROJECT-ID: Projekt-ID.
   • INSTANCE-ID: Instanz-ID.
   • DATABASE-ID: die Datenbank-ID.
   • SESSION-ID: die Sitzungs-ID. Sie erhalten den Wert SESSION-ID, wenn Sie eine Sitzung erstellen.

3. Verwenden Sie Folgendes für Request body (Requesttext):

   {
     "directedReadOptions": {
       "includeReplicas": {
         "replicaSelections": [
           {
             "location": "us-central1",
           }
         ]
       }
     },
     "sql": "SELECT SingerId, AlbumId, AlbumTitle FROM Albums"
   }
   

4. Klicken Sie auf Execute (Ausführen). In der Antwort werden die Abfrageergebnisse angegeben.

RPC

Sie können die folgenden RPC APIs verwenden, um gerichtete Lesevorgänge auszuführen:

• ExecuteSql
• ExecuteStreamingSql
• Read
• StreamingRead

Nächste Schritte

• Lesevorgänge außerhalb von Transaktionen