voidDirectedRead(std::stringconst&project_id,std::stringconst&instance_id,std::stringconst&database_id){namespacespanner=::google::cloud::spanner;// Create a client with a DirectedReadOption.autoclient=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::SqlStatementselect("SELECT SingerId, AlbumId, AlbumTitle FROM Albums");usingRowType=std::tuple<std::int64_t,std::int64_t,std::string>;// A DirectedReadOption on the operation will override the option set// at the client level.autorows=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)throwstd::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";}

usingGoogle.Cloud.Spanner.Data;usingGoogle.Cloud.Spanner.V1;usingSystem.Collections.Generic;usingSystem.Threading.Tasks;publicclassDirectedReadsAsyncSample{publicclassAlbum{publicintSingerId{get;set;}publicintAlbumId{get;set;}publicstringAlbumTitle{get;set;}}publicasyncTask<List<Album>>DirectedReadsAsync(stringprojectId,stringinstanceId,stringdatabaseId){stringconnectionString=$"Data Source=projects/{projectId}/instances/{instanceId}/databases/{databaseId}";usingvarconnection=newSpannerConnection(connectionString);usingvarcmd=connection.CreateSelectCommand("SELECT SingerId, AlbumId, AlbumTitle FROM Albums");// Set directed read options on a query or read command.cmd.DirectedReadOptions=newDirectedReadOptions{IncludeReplicas=newDirectedReadOptions.Types.IncludeReplicas{AutoFailoverDisabled=true,ReplicaSelections={newDirectedReadOptions.Types.ReplicaSelection{Location="us-central1",Type=DirectedReadOptions.Types.ReplicaSelection.Types.Type.ReadOnly}}}};varalbums=newList<Album>();usingvarreader=awaitcmd.ExecuteReaderAsync();while(awaitreader.ReadAsync()){albums.Add(newAlbum{AlbumId=reader.GetFieldValue<int>("AlbumId"),SingerId=reader.GetFieldValue<int>("SingerId"),AlbumTitle=reader.GetFieldValue<string>("AlbumTitle")});}returnalbums;}}

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`funcdirectedReadOptions(wio.Writer,dbstring)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 requestsclient,err:=spanner.NewClientWithConfig(ctx,db,spanner.ClientConfig{DirectedReadOptions:directedReadOptionsForClient})iferr!=nil{returnerr}deferclient.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})deferiter.Stop()for{row,err:=iter.Next()iferr==iterator.Done{returnnil}iferr!=nil{returnerr}varsingerID,albumIDint64varalbumTitlestringiferr:=row.Columns(&singerID,&albumID,&albumTitle);err!=nil{returnerr}fmt.Fprintf(w,"%d %d %s\n",singerID,albumID,albumTitle)}}

importcom.google.cloud.spanner.DatabaseClient;importcom.google.cloud.spanner.DatabaseId;importcom.google.cloud.spanner.Options;importcom.google.cloud.spanner.ResultSet;importcom.google.cloud.spanner.Spanner;importcom.google.cloud.spanner.SpannerOptions;importcom.google.cloud.spanner.Statement;importcom.google.spanner.v1.DirectedReadOptions;importcom.google.spanner.v1.DirectedReadOptions.ExcludeReplicas;importcom.google.spanner.v1.DirectedReadOptions.IncludeReplicas;importcom.google.spanner.v1.DirectedReadOptions.ReplicaSelection;publicclassDirectedReadSample{staticvoiddirectedRead(){// TODO(developer): Replace these variables before running the sample.finalStringprojectId="my-project";finalStringinstanceId="my-instance";finalStringdatabaseId="my-database";directedRead(projectId,instanceId,databaseId);}staticvoiddirectedRead(StringprojectId,StringinstanceId,StringdatabaseId){// 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`.finalDirectedReadOptionsdirectedReadOptionsForClient=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(Spannerspanner=SpannerOptions.newBuilder().setProjectId(projectId).setDirectedReadOptions(directedReadOptionsForClient).build().getService()){finalDatabaseClientdbClient=spanner.getDatabaseClient(DatabaseId.of(projectId,instanceId,databaseId));// DirectedReadOptions at request level will override the options set at// client level (through SpannerOptions).finalDirectedReadOptionsdirectedReadOptionsForRequest=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(ResultSetrs=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");}}}}

// Imports the Google Cloud Spanner client libraryconst{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`constdirectedReadOptionsForClient={excludeReplicas:{replicaSelections:[{location:'us-east4',},],},};// Instantiates a client with directedReadOptionsconstspanner=newSpanner({projectId:projectId,directedReadOptions:directedReadOptionsForClient,});asyncfunctionspannerDirectedReads(){// Gets a reference to a Cloud Spanner instance and backupconstinstance=spanner.instance(instanceId);constdatabase=instance.database(databaseId);constdirectedReadOptionsForRequest={includeReplicas:{replicaSelections:[{type:protos.google.spanner.v1.DirectedReadOptions.ReplicaSelection.Type.READ_ONLY,},],autoFailoverDisabled:true,},};awaitdatabase.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]=awaittransaction.run({sql:'SELECT SingerId, AlbumId, AlbumTitle FROM Albums',directedReadOptions:directedReadOptionsForRequest,});rows.forEach(row=>{constjson=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.awaitdatabase.close();}});}spannerDirectedReads();

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']);    }}

# 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 requestsspanner_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,},}withdatabase.snapshot()assnapshot:# 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,)forrowinresults:print("SingerId:{}, AlbumId:{}, AlbumTitle:{}".format(*row))

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.#defspanner_directed_readproject_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 directedReadOptionsspanner=Google::Cloud::Spanner.newproject:project_idclient=spanner.clientinstance_id,database_id,directed_read_options:directed_read_options_for_clientdirected_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_optionsresult.rows.eachdo|row|puts"SingerId:#{row[:SingerId]}"puts"AlbumId:#{row[:AlbumId]}"puts"AlbumTitle:#{row[:AlbumTitle]}"endputs"Successfully executed read-only transaction with directed_read_options"end