Leseempfehlungen

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

Mit gerichteten Lesevorgängen in Spanner können schreibgeschützte Transaktionen und einzelne Lesevorgänge auf eine bestimmte Replikattyp oder -region innerhalb einer multiregionalen Instanzkonfiguration oder einer benutzerdefinierten regionale Konfiguration mit optionalen schreibgeschützten Regionen.

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 einheitlichere CPU-Auslastung.
  • Isolieren von Analysen in Ihrer Anwendung durch Minimieren der Auswirkungen auf Transaktionen Arbeitsbelastungen.
  • Bereitstellung einer teilweisen Isolierung für Lesevorgänge von Änderungsstreams. Wenn Sie zum Streamen die Spanner API verwenden Spanner-Datenänderungen helfen, die Auswirkungen auf Transaktionsarbeitslasten mithilfe von gerichteten Lesevorgängen erstellen.

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 nicht unterstützt. und partitionierte DML-Typen von Bulk-Aktualisierungen. Dieses 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 einen BAD_REQUEST-Fehler.

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 in einer multiregionalen Instanzkonfiguration oder eine benutzerdefinierte regionale Konfiguration mit optionalen schreibgeschützten Regionen.
  • Sie können gerichtete Lesevorgänge nicht mit Lese-/Schreibanfragen verwenden, da -Anfragen werden immer von der führenden Region bearbeitet.
  • In der Google Cloud Console oder der Google Cloud CLI können keine gerichteten Lesevorgänge verwendet werden. Es ist verfügbar mit REST und RPC APIs und Spanner Clientbibliotheken.
  • Sie können in einem einzelnen gerichteten Lesevorgang maximal 10 Replikate angeben.
  • Wenn Sie das Dashboard für Systemstatistiken verwenden oder im Metrics Explorer im Vorgänge pro Sekunde, Vorgänge pro Sekunde nach Datenbank und Vorgänge pro Sekunde nach API-Methodendiagrammen sehen Sie möglicherweise Ihre Anfrage für gerichtete Lesevorgänge an einem anderen Ort als dem von Ihnen angegebenen. In diesem Fall werden die Informationen Diagramme möglicherweise falsch sind. Sie können bestätigen, dass Ihre Leseanfragen werden mithilfe der CPU-Auslastungsmesswerte an die ausgewählten Regionen weitergeleitet. Diese Messwerte geben die genauesten Informationen dazu an, wohin die gerichteten Lesevorgänge führen. Traffic weitergeleitet wird.

Hinweise

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

  • Die Anwendung kann zusätzliche Latenz verursachen, wenn Sie Lesevorgänge an einen Replikat oder einer anderen Region als derjenigen, die der Anwendung am nächsten ist.
  • Sie können Traffic basierend auf folgenden Faktoren weiterleiten: <ph type="x-smartling-placeholder">
      </ph>
    • 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 automatisch Failover-Option ist aktiviert und alle angegebenen Replikate sind nicht verfügbar oder fehlerhaft ist, leitet Spanner Anfragen an ein Replikat außerhalb der Liste „includeReplicas“. Wenn Sie die automatische Failover-Option deaktivieren und alle die angegebenen Replikate nicht verfügbar oder fehlerhaft sind, werden die angegebenen Lesevorgänge schlägt 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 für diese Felder im Parameter directedReadOptions. Sie können nur eine der folgenden Optionen einfügen: includeReplicas oder excludeReplicas, nicht beides.

  • includeReplicas: enthält einen wiederholten Satz von replicaSelections. Diese Liste gibt die Reihenfolge an, in der Lesevorgänge an bestimmte Regionen oder Replikate weitergeleitet wurden zu berücksichtigen sind. Sie können maximal 10 includeReplicas angeben.
    • replicaSelections: besteht aus der Bereitstellung location oder Replikat type die Anfrage für gerichtete Lesevorgänge. Wenn Sie includeReplicas müssen Sie mindestens eines der folgenden Felder ausfüllen:
      • location: Der Standort, von dem die Anfrage für gerichtete Lesevorgänge verarbeitet wird. Die Standort muss eine der Regionen innerhalb des multiregionalen Standorts sein Konfiguration Ihrer Datenbank. Wenn der Standort nicht zu den Regionen innerhalb der multiregionalen Konfiguration Ihrer Datenbank, -Anfragen nicht wie erwartet weitergeleitet. Stattdessen werden sie vom nächstgelegene Region Du kannst beispielsweise Lesevorgänge an den Standort weiterleiten us-central1 für eine Datenbank in der multiregionalen Instanzkonfiguration nam6.
      • type: Der Replikattyp, der die Anfrage für gerichtete Lesevorgänge verarbeitet. Möglich Zu den Typen gehören READ_WRITE und READ_ONLY.
    • autoFailoverDisabled: Die Standardeinstellung ist False, was bedeutet, dass automatisch Failover ist aktiviert. Wenn der automatische Failover aktiviert ist und alle angegebene Replikate nicht verfügbar oder fehlerhaft sind, Spanner leitet Anfragen an ein Replikat außerhalb der includeReplicas-Liste weiter. Wenn Sie die automatische Failover-Option deaktivieren und alle angegebenen Replikate nicht verfügbar oder fehlerhaft ist, schlägt die Anfrage für gerichtete Lesevorgänge fehl. Mögliche Werte TRUE für deaktivierte und FALSE für aktivierte Elemente einschließen.
  • excludeReplicas: enthält einen wiederholten Satz von replicaSelections, die von der Bereitstellung von Anfragen ausgeschlossen ist. Spanner leitet keine Weiterleitungen an Replikate in dieser Liste.
    • replicaSelections: Der ausgeschlossene Standort oder Replikattyp. die Anfrage für gerichtete Lesevorgänge verarbeiten kann. Wenn Sie excludeReplicas verwenden, müssen Sie mindestens eines der folgenden Felder angeben:
      • location: Der Standort, der von der Auslieferung ausgeschlossen ist. gerichtete Lesevorgänge.
      • type: Der Replikattyp, der von der Bereitstellung der gerichteten Anfrage ausgeschlossen ist read-Anfrage stellen. Mögliche Typen sind READ_WRITE und READ_ONLY.

Um ein Beispiel für den Text eines REST-Anfragetexts zu sehen, klicken Sie auf den REST im Abschnitt Directed Reads.

Gesteuerte Lesevorgänge verwenden

Mit den Spanner-Clientbibliotheken sowie der REST API und der RPC API können Sie gerichtete Lesevorgänge durchfü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:

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 (Anfragetext):

    {
  "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:

Nächste Schritte