usingGoogle.Cloud.Spanner.Admin.Database.V1;usingGoogle.Cloud.Spanner.Common.V1;usingGoogle.LongRunning;usingGoogle.Protobuf.WellKnownTypes;usingSystem;usingSystem.Threading.Tasks;publicclassUpdateDatabaseWithDefaultLeaderAsyncSample{publicasyncTask<Operation<Empty,UpdateDatabaseDdlMetadata>>UpdateDatabaseWithDefaultLeaderAsync(stringprojectId,stringinstanceId,stringdatabaseId,stringdefaultLeader){DatabaseAdminClientdatabaseAdminClient=awaitDatabaseAdminClient.CreateAsync();varalterDatabaseStatement=@$"ALTER DATABASE `{databaseId}` SET OPTIONS(default_leader='{defaultLeader}')";// Create the UpdateDatabaseDdl request and execute it.varrequest=newUpdateDatabaseDdlRequest{DatabaseAsDatabaseName=DatabaseName.FromProjectInstanceDatabase(projectId,instanceId,databaseId),Statements={alterDatabaseStatement}};varoperation=awaitdatabaseAdminClient.UpdateDatabaseDdlAsync(request);// Wait until the operation has finished.Console.WriteLine("Waiting for the operation to finish.");Operation<Empty,UpdateDatabaseDdlMetadata>completedResponse=awaitoperation.PollUntilCompletedAsync();if(completedResponse.IsFaulted){Console.WriteLine($"Error while updating database: {completedResponse.Exception}");throwcompletedResponse.Exception;}Console.WriteLine("Updated default leader");returncompletedResponse;}}

voidUpdateDatabaseWithDefaultLeader(google::cloud::spanner_admin::DatabaseAdminClientclient,std::stringconst&project_id,std::stringconst&instance_id,std::stringconst&database_id,std::stringconst&default_leader){google::cloud::spanner::Databasedatabase(project_id,instance_id,database_id);std::vector<std::string>statements;statements.push_back("ALTER DATABASE `"+database_id+"` "+"SET OPTIONS (default_leader='"+default_leader+"')");autometadata=client.UpdateDatabaseDdl(database.FullName(),std::move(statements)).get();if(!metadata)throwstd::move(metadata).status();std::cout <<"`default_leader` altered, new DDL metadata:\n"            <<metadata->DebugString();}

import("context""fmt""io""regexp"database"cloud.google.com/go/spanner/admin/database/apiv1"adminpb"cloud.google.com/go/spanner/admin/database/apiv1/databasepb")// updateDatabaseWithDefaultLeader updates the default leader for a given databasefuncupdateDatabaseWithDefaultLeader(wio.Writer,dbstring,defaultLeaderstring)error{// db = `projects/<project>/instances/<instance-id>/database/<database-id>`// defaultLeader = `nam3`matches:=regexp.MustCompile("^(.+)/databases/(.+)$").FindStringSubmatch(db)ifmatches==nil||len(matches)!=3{returnfmt.Errorf("updateDatabaseWithDefaultLeader: invalid database id %q",db)}ctx:=context.Background()adminClient,err:=database.NewDatabaseAdminClient(ctx)iferr!=nil{returnerr}deferadminClient.Close()op,err:=adminClient.UpdateDatabaseDdl(ctx,&adminpb.UpdateDatabaseDdlRequest{Database:db,Statements:[]string{fmt.Sprintf("ALTER DATABASE `%s` SET OPTIONS (default_leader = '%s')",matches[2],defaultLeader,),},})iferr!=nil{returnerr}iferr:=op.Wait(ctx);err!=nil{returnerr}fmt.Fprintf(w,"Updated the default leader\n")returnnil}

importcom.google.cloud.spanner.Spanner;importcom.google.cloud.spanner.SpannerException;importcom.google.cloud.spanner.SpannerExceptionFactory;importcom.google.cloud.spanner.SpannerOptions;importcom.google.cloud.spanner.admin.database.v1.DatabaseAdminClient;importcom.google.spanner.admin.database.v1.DatabaseName;importjava.util.Collections;importjava.util.concurrent.ExecutionException;publicclassUpdateDatabaseWithDefaultLeaderSample{staticvoidupdateDatabaseWithDefaultLeader(){// TODO(developer): Replace these variables before running the sample.finalStringprojectId="my-project";finalStringinstanceId="my-instance";finalStringdatabaseId="my-database";finalStringdefaultLeader="my-default-leader";updateDatabaseWithDefaultLeader(projectId,instanceId,databaseId,defaultLeader);}staticvoidupdateDatabaseWithDefaultLeader(StringprojectId,StringinstanceId,StringdatabaseId,StringdefaultLeader){try(Spannerspanner=SpannerOptions.newBuilder().setProjectId(projectId).build().getService();DatabaseAdminClientdatabaseAdminClient=spanner.createDatabaseAdminClient()){databaseAdminClient.updateDatabaseDdlAsync(DatabaseName.of(projectId,instanceId,databaseId),Collections.singletonList(String.format("ALTER DATABASE `%s` SET OPTIONS (default_leader = '%s')",databaseId,defaultLeader))).get();System.out.println("Updated default leader to "+defaultLeader);}catch(ExecutionExceptione){// If the operation failed during execution, expose the cause.throw(SpannerException)e.getCause();}catch(InterruptedExceptione){// Throw when a thread is waiting, sleeping, or otherwise occupied,// and the thread is interrupted, either before or during the activity.throwSpannerExceptionFactory.propagateInterrupt(e);}}}

/** * TODO(developer): Uncomment the following lines before running the sample. */// const projectId = 'my-project-id';// const instanceId = 'my-instance-id';// const databaseId = 'my-database-id';// const defaultLeader = 'my-default-leader';// Imports the Google Cloud client libraryconst{Spanner}=require('@google-cloud/spanner');// creates a clientconstspanner=newSpanner({projectId:projectId,});constdatabaseAdminClient=spanner.getDatabaseAdminClient();asyncfunctionupdateDatabaseWithDefaultLeader(){console.log(`Updating database${databaseAdminClient.databasePath(projectId,instanceId,databaseId,)}.`,);constsetDefaultLeaderStatement=`    ALTER DATABASE \`${databaseId}\`    SET OPTIONS (default_leader = '${defaultLeader}')`;const[operation]=awaitdatabaseAdminClient.updateDatabaseDdl({database:databaseAdminClient.databasePath(projectId,instanceId,databaseId,),statements:[setDefaultLeaderStatement],});console.log(`Waiting for updating of${databaseId} to complete...`);awaitoperation.promise();console.log(`Updated database${databaseId} with default leader${defaultLeader}.`,);}updateDatabaseWithDefaultLeader();

use Google\Cloud\Spanner\Admin\Database\V1\Client\DatabaseAdminClient;use Google\Cloud\Spanner\Admin\Database\V1\GetDatabaseRequest;use Google\Cloud\Spanner\Admin\Database\V1\UpdateDatabaseDdlRequest;/** * Updates the default leader of the database. * Example: * ``` * update_database_with_default_leader($projectId, $instanceId, $databaseId, $defaultLeader); * ``` * * @param string $projectId The Google Cloud project ID. * @param string $instanceId The Spanner instance ID. * @param string $databaseId The Spanner database ID. * @param string $defaultLeader The leader instance configuration used by default. */function update_database_with_default_leader(    string $projectId,    string $instanceId,    string $databaseId,    string $defaultLeader): void {    $databaseAdminClient = new DatabaseAdminClient();    $databaseName = DatabaseAdminClient::databaseName($projectId, $instanceId, $databaseId);    $statement = "ALTER DATABASE `$databaseId` SET OPTIONS (default_leader = '$defaultLeader')";    $request = new UpdateDatabaseDdlRequest([        'database' => $databaseName,        'statements' => [$statement]    ]);    $operation = $databaseAdminClient->updateDatabaseDdl($request);    print('Waiting for operation to complete...' . PHP_EOL);    $operation->pollUntilComplete();    $database = $databaseAdminClient->getDatabase(        new GetDatabaseRequest(['name' => $databaseName])    );    printf('Updated the default leader to %s' . PHP_EOL, $database->getDefaultLeader());}

defupdate_database_with_default_leader(instance_id,database_id,default_leader):"""Updates a database with tables with a default leader."""fromgoogle.cloud.spanner_admin_database_v1.typesimportspanner_database_adminspanner_client=spanner.Client()database_admin_api=spanner_client.database_admin_apirequest=spanner_database_admin.UpdateDatabaseDdlRequest(database=database_admin_api.database_path(spanner_client.project,instance_id,database_id),statements=["ALTER DATABASE{}"" SET OPTIONS (default_leader = '{}')".format(database_id,default_leader)],)operation=database_admin_api.update_database_ddl(request)operation.result(OPERATION_TIMEOUT_SECONDS)print("Database{} updated with default leader{}".format(database_id,default_leader))

# project_id  = "Your Google Cloud project ID"# instance_id = "Your Spanner instance ID"# database_id = "Your Spanner database ID"# default_leader = "Spanner database default leader"require"google/cloud/spanner"require"google/cloud/spanner/admin/database"db_admin_client=Google::Cloud::Spanner::Admin::Database.database_adminproject_id:project_iddb_path=db_admin_client.database_pathproject:project_id,instance:instance_id,database:database_idstatements=["ALTER DATABASE `#{database_id}` SET OPTIONS (    default_leader = '#{default_leader}'  )"]job=db_admin_client.update_database_ddldatabase:db_path,statements:statementsjob.wait_until_done!database=job.resultsputs"Updated default leader"

usingGoogle.Cloud.Spanner.Admin.Database.V1;usingGoogle.Cloud.Spanner.Common.V1;usingSystem;usingSystem.Threading.Tasks;publicclassCreateDatabaseWithDefaultLeaderAsyncSample{publicasyncTask<Database>CreateDatabaseWithDefaultLeaderAsync(stringprojectId,stringinstanceId,stringdatabaseId,stringdefaultLeader){DatabaseAdminClientdatabaseAdminClient=awaitDatabaseAdminClient.CreateAsync();// Define create table statement for table #1.varcreateSingersTable=@"CREATE TABLE Singers (                SingerId INT64 NOT NULL,                FirstName STRING(1024),                LastName STRING(1024),                ComposerInfo BYTES(MAX)            ) PRIMARY KEY (SingerId)";// Define create table statement for table #2.varcreateAlbumsTable=@"CREATE TABLE Albums (                SingerId INT64 NOT NULL,                AlbumId INT64 NOT NULL,                AlbumTitle STRING(MAX)            ) PRIMARY KEY (SingerId, AlbumId),            INTERLEAVE IN PARENT Singers ON DELETE CASCADE";// Define alter database statement to set default leader.varalterDatabaseStatement=@$"ALTER DATABASE `{databaseId}` SET OPTIONS (default_leader = '{defaultLeader}')";// Create the CreateDatabase request with default leader and execute it.varrequest=newCreateDatabaseRequest{ParentAsInstanceName=InstanceName.FromProjectInstance(projectId,instanceId),CreateStatement=$"CREATE DATABASE `{databaseId}`",ExtraStatements={createSingersTable,createAlbumsTable,alterDatabaseStatement},};varoperation=awaitdatabaseAdminClient.CreateDatabaseAsync(request);// Wait until the operation has finished.Console.WriteLine("Waiting for the operation to finish.");varcompletedResponse=awaitoperation.PollUntilCompletedAsync();if(completedResponse.IsFaulted){Console.WriteLine($"Error while creating database: {completedResponse.Exception}");throwcompletedResponse.Exception;}vardatabase=completedResponse.Result;Console.WriteLine($"Created database [{databaseId}]");Console.WriteLine($"\t Default leader: {database.DefaultLeader}");returndatabase;}}

voidCreateDatabaseWithDefaultLeader(google::cloud::spanner_admin::DatabaseAdminClientclient,std::stringconst&project_id,std::stringconst&instance_id,std::stringconst&database_id,std::stringconst&default_leader){google::cloud::spanner::Databasedatabase(project_id,instance_id,database_id);google::spanner::admin::database::v1::CreateDatabaseRequestrequest;request.set_parent(database.instance().FullName());request.set_create_statement("CREATE DATABASE `"+database.database_id()+"`");request.add_extra_statements("ALTER DATABASE `"+database_id+"` "+"SET OPTIONS (default_leader='"+default_leader+"')");autodb=client.CreateDatabase(request).get();if(!db)throwstd::move(db).status();std::cout <<"Database " <<db->name() <<" created.\n" <<db->DebugString();}

import("context""fmt""io""regexp"database"cloud.google.com/go/spanner/admin/database/apiv1"adminpb"cloud.google.com/go/spanner/admin/database/apiv1/databasepb")// createDatabaseWithDefaultLeader creates a database with a default leaderfunccreateDatabaseWithDefaultLeader(wio.Writer,dbstring,defaultLeaderstring)error{// db = `projects/<project>/instances/<instance-id>/database/<database-id>`// defaultLeader = `my-default-leader`matches:=regexp.MustCompile("^(.*)/databases/(.*)$").FindStringSubmatch(db)ifmatches==nil||len(matches)!=3{returnfmt.Errorf("createDatabaseWithDefaultLeader: invalid database id %s",db)}ctx:=context.Background()adminClient,err:=database.NewDatabaseAdminClient(ctx)iferr!=nil{returnerr}deferadminClient.Close()alterDatabase:=fmt.Sprintf("ALTER DATABASE `%s` SET OPTIONS (default_leader = '%s')",matches[2],defaultLeader,)req:=adminpb.CreateDatabaseRequest{Parent:matches[1],CreateStatement:"CREATE DATABASE `"+matches[2]+"`",ExtraStatements:[]string{`CREATE TABLE Singers (SingerId   INT64 NOT NULL,FirstName  STRING(1024),LastName   STRING(1024),SingerInfo BYTES(MAX)) PRIMARY KEY (SingerId)`,`CREATE TABLE Albums (SingerId     INT64 NOT NULL,AlbumId      INT64 NOT NULL,AlbumTitle   STRING(MAX)) PRIMARY KEY (SingerId, AlbumId),INTERLEAVE IN PARENT Singers ON DELETE CASCADE`,alterDatabase,},}op,err:=adminClient.CreateDatabase(ctx,&req)iferr!=nil{returnfmt.Errorf("createDatabaseWithDefaultLeader.CreateDatabase: %w",err)}dbObj,err:=op.Wait(ctx)iferr!=nil{returnfmt.Errorf("createDatabaseWithDefaultLeader.Wait: %w",err)}fmt.Fprintf(w,"Created database [%s] with default leader%q\n",dbObj.Name,dbObj.DefaultLeader)returnnil}

importcom.google.cloud.spanner.SpannerException;importcom.google.cloud.spanner.SpannerExceptionFactory;importcom.google.cloud.spanner.admin.database.v1.DatabaseAdminClient;importcom.google.common.collect.ImmutableList;importcom.google.spanner.admin.database.v1.CreateDatabaseRequest;importcom.google.spanner.admin.database.v1.Database;importjava.io.IOException;importjava.util.concurrent.ExecutionException;publicclassCreateDatabaseWithDefaultLeaderSample{staticvoidcreateDatabaseWithDefaultLeader()throwsIOException{// TODO(developer): Replace these variables before running the sample.finalStringinstanceName="projects/my-project/instances/my-instance-id";finalStringdatabaseId="my-database-name";finalStringdefaultLeader="my-default-leader";createDatabaseWithDefaultLeader(instanceName,databaseId,defaultLeader);}staticvoidcreateDatabaseWithDefaultLeader(StringinstanceName,StringdatabaseId,StringdefaultLeader)throwsIOException{try(DatabaseAdminClientdatabaseAdminClient=DatabaseAdminClient.create()){DatabasecreatedDatabase=databaseAdminClient.createDatabaseAsync(CreateDatabaseRequest.newBuilder().setParent(instanceName).setCreateStatement("CREATE DATABASE `"+databaseId+"`").addAllExtraStatements(ImmutableList.of("CREATE TABLE Singers ("+"  SingerId   INT64 NOT NULL,"+"  FirstName  STRING(1024),"+"  LastName   STRING(1024),"+"  SingerInfo BYTES(MAX)"+") PRIMARY KEY (SingerId)","CREATE TABLE Albums ("+"  SingerId     INT64 NOT NULL,"+"  AlbumId      INT64 NOT NULL,"+"  AlbumTitle   STRING(MAX)"+") PRIMARY KEY (SingerId, AlbumId),"+"  INTERLEAVE IN PARENT Singers ON DELETE CASCADE","ALTER DATABASE "+"`"+databaseId+"`"+" SET OPTIONS ( default_leader = '"+defaultLeader+"' )")).build()).get();System.out.println("Created database ["+createdDatabase.getName()+"]");System.out.println("\tDefault leader: "+createdDatabase.getDefaultLeader());}catch(ExecutionExceptione){// If the operation failed during execution, expose the cause.throw(SpannerException)e.getCause();}catch(InterruptedExceptione){// Throw when a thread is waiting, sleeping, or otherwise occupied,// and the thread is interrupted, either before or during the activity.throwSpannerExceptionFactory.propagateInterrupt(e);}}}

/** * TODO(developer): Uncomment the following lines before running the sample. */// const projectId = 'my-project-id';// const instanceId = 'my-instance-id';// const databaseId = 'my-database-id';// const defaultLeader = 'my-default-leader'; example: 'asia-northeast1'// Imports the Google Cloud client libraryconst{Spanner}=require('@google-cloud/spanner');// creates a clientconstspanner=newSpanner({projectId:projectId,});// Gets a reference to a Cloud Spanner Database Admin Client objectconstdatabaseAdminClient=spanner.getDatabaseAdminClient();asyncfunctioncreateDatabaseWithDefaultLeader(){// Create a new database with an extra statement which will alter the// database after creation to set the default leader.console.log(`Creating database${databaseAdminClient.databasePath(projectId,instanceId,databaseId,)}.`,);constcreateSingersTableStatement=`    CREATE TABLE Singers (      SingerId   INT64 NOT NULL,      FirstName  STRING(1024),      LastName   STRING(1024),      SingerInfo BYTES(MAX)    ) PRIMARY KEY (SingerId)`;constcreateAlbumsStatement=`    CREATE TABLE Albums (      SingerId     INT64 NOT NULL,      AlbumId      INT64 NOT NULL,      AlbumTitle   STRING(MAX)    ) PRIMARY KEY (SingerId, AlbumId),      INTERLEAVE IN PARENT Singers ON DELETE CASCADE`;// Default leader is one of the possible values in the leaderOptions field of the// instance config of the instance where the database is created.constsetDefaultLeaderStatement=`    ALTER DATABASE \`${databaseId}\`    SET OPTIONS (default_leader = '${defaultLeader}')`;const[operation]=awaitdatabaseAdminClient.createDatabase({createStatement:'CREATE DATABASE `'+databaseId+'`',extraStatements:[createSingersTableStatement,createAlbumsStatement,setDefaultLeaderStatement,],parent:databaseAdminClient.instancePath(projectId,instanceId),});console.log(`Waiting for creation of${databaseId} to complete...`);awaitoperation.promise();console.log(`Created database${databaseId} with default leader${defaultLeader}.`,);}createDatabaseWithDefaultLeader();

use Google\Cloud\Spanner\Admin\Database\V1\Client\DatabaseAdminClient;use Google\Cloud\Spanner\Admin\Database\V1\CreateDatabaseRequest;use Google\Cloud\Spanner\Admin\Database\V1\GetDatabaseRequest;/** * Creates a database with a default leader. * Example: * ``` * create_database_with_default_leader($projectId, $instanceId, $databaseId, $defaultLeader); * ``` * * @param string $projectId The Google Cloud project ID. * @param string $instanceId The Spanner instance ID. * @param string $databaseId The Spanner database ID. * @param string $defaultLeader The leader instance configuration used by default. */function create_database_with_default_leader(    string $projectId,    string $instanceId,    string $databaseId,    string $defaultLeader): void {    $databaseAdminClient = new DatabaseAdminClient();    $instance = $databaseAdminClient->instanceName($projectId, $instanceId);    $databaseIdFull = $databaseAdminClient->databaseName($projectId, $instanceId, $databaseId);    $operation = $databaseAdminClient->createDatabase(        new CreateDatabaseRequest([            'parent' => $instance,            'create_statement' => sprintf('CREATE DATABASE `%s`', $databaseId),            'extra_statements' => [                'CREATE TABLE Singers (' .                'SingerId     INT64 NOT NULL,' .                'FirstName    STRING(1024),' .                'LastName     STRING(1024),' .                'SingerInfo   BYTES(MAX)' .                ') PRIMARY KEY (SingerId)',                'CREATE TABLE Albums (' .                    'SingerId     INT64 NOT NULL,' .                    'AlbumId      INT64 NOT NULL,' .                    'AlbumTitle   STRING(MAX)' .                ') PRIMARY KEY (SingerId, AlbumId),' .                'INTERLEAVE IN PARENT Singers ON DELETE CASCADE',                "ALTER DATABASE `$databaseId` SET OPTIONS(default_leader='$defaultLeader')"            ]        ])    );    print('Waiting for operation to complete...' . PHP_EOL);    $operation->pollUntilComplete();    $database = $databaseAdminClient->getDatabase(        new GetDatabaseRequest(['name' => $databaseIdFull])    );    printf('Created database %s on instance %s with default leader %s' . PHP_EOL,        $databaseId, $instanceId, $database->getDefaultLeader());}

defcreate_database_with_default_leader(instance_id,database_id,default_leader):"""Creates a database with tables with a default leader."""fromgoogle.cloud.spanner_admin_database_v1.typesimportspanner_database_adminspanner_client=spanner.Client()database_admin_api=spanner_client.database_admin_apirequest=spanner_database_admin.CreateDatabaseRequest(parent=database_admin_api.instance_path(spanner_client.project,instance_id),create_statement=f"CREATE DATABASE `{database_id}`",extra_statements=["""CREATE TABLE Singers (                SingerId     INT64 NOT NULL,                FirstName    STRING(1024),                LastName     STRING(1024),                SingerInfo   BYTES(MAX)            ) PRIMARY KEY (SingerId)""","""CREATE TABLE Albums (                SingerId     INT64 NOT NULL,                AlbumId      INT64 NOT NULL,                AlbumTitle   STRING(MAX)            ) PRIMARY KEY (SingerId, AlbumId),            INTERLEAVE IN PARENT Singers ON DELETE CASCADE""","ALTER DATABASE{}"" SET OPTIONS (default_leader = '{}')".format(database_id,default_leader),],)operation=database_admin_api.create_database(request=request)print("Waiting for operation to complete...")database=operation.result(OPERATION_TIMEOUT_SECONDS)print("Database{} created with default leader{}".format(database.name,database.default_leader))

# project_id  = "Your Google Cloud project ID"# instance_id = "Your Spanner instance ID"# database_id = "Your Spanner database ID"# default_leader = "Spanner database default leader"require"google/cloud/spanner"require"google/cloud/spanner/admin/database"db_admin_client=Google::Cloud::Spanner::Admin::Database.database_adminproject_id:project_idinstance_path=\db_admin_client.instance_pathproject:project_id,instance:instance_idstatements=["CREATE TABLE Singers (    SingerId     INT64 NOT NULL,    FirstName    STRING(1024),    LastName     STRING(1024),    SingerInfo   BYTES(MAX)  ) PRIMARY KEY (SingerId)","CREATE TABLE Albums (    SingerId     INT64 NOT NULL,    AlbumId      INT64 NOT NULL,    AlbumTitle   STRING(MAX)  ) PRIMARY KEY (SingerId, AlbumId),  INTERLEAVE IN PARENT Singers ON DELETE CASCADE","ALTER DATABASE `#{database_id}` SET OPTIONS (    default_leader = '#{default_leader}'  )"]job=db_admin_client.create_database\parent:instance_path,create_statement:"CREATE DATABASE `#{database_id}`",extra_statements:statementsjob.wait_until_done!database=job.resultsputs"Created database [#{database.name}] with default leader:#{database.default_leader}"

usingGoogle.Cloud.Spanner.Admin.Database.V1;usingGoogle.Cloud.Spanner.Common.V1;usingSystem;usingSystem.Collections.Generic;usingSystem.Threading.Tasks;publicclassGetDatabaseDdlAsyncSample{publicasyncTask<GetDatabaseDdlResponse>GetDatabaseDdlAsync(stringprojectId,stringinstanceId,stringdatabaseId){DatabaseAdminClientdatabaseAdminClient=awaitDatabaseAdminClient.CreateAsync();DatabaseNamedatabaseName=DatabaseName.FromProjectInstanceDatabase(projectId,instanceId,databaseId);GetDatabaseDdlResponsedatabaseDdl=awaitdatabaseAdminClient.GetDatabaseDdlAsync(databaseName);Console.WriteLine($"DDL statements for database {databaseId}:");foreach(varstatementindatabaseDdl.Statements){Console.WriteLine(statement);}returndatabaseDdl;}}

voidGetDatabaseDdl(google::cloud::spanner_admin::DatabaseAdminClientclient,std::stringconst&project_id,std::stringconst&instance_id,std::stringconst&database_id){namespacespanner=::google::cloud::spanner;autodatabase=client.GetDatabaseDdl(spanner::Database(project_id,instance_id,database_id).FullName());if(!database)throwstd::move(database).status();std::cout <<"Database metadata is:\n" <<database->DebugString();}

import("context""fmt""io""regexp"database"cloud.google.com/go/spanner/admin/database/apiv1"adminpb"cloud.google.com/go/spanner/admin/database/apiv1/databasepb")// getDatabaseDdl gets the DDL for the databasefuncgetDatabaseDdl(wio.Writer,dbstring)error{// db = `projects/<project>/instances/<instance-id>/database/<database-id>`matches:=regexp.MustCompile("^(.*)/databases/(.*)$").FindStringSubmatch(db)ifmatches==nil||len(matches)!=3{returnfmt.Errorf("getDatabaseDdl: invalid database id %s",db)}ctx:=context.Background()adminClient,err:=database.NewDatabaseAdminClient(ctx)iferr!=nil{returnerr}deferadminClient.Close()op,err:=adminClient.GetDatabaseDdl(ctx,&adminpb.GetDatabaseDdlRequest{Database:db,})iferr!=nil{returnerr}fmt.Fprintf(w,"Database DDL is as follows: \n [%v]",op.GetStatements())returnnil}

importcom.google.cloud.spanner.Spanner;importcom.google.cloud.spanner.SpannerOptions;importcom.google.cloud.spanner.admin.database.v1.DatabaseAdminClient;importcom.google.spanner.admin.database.v1.DatabaseName;importcom.google.spanner.admin.database.v1.GetDatabaseDdlResponse;publicclassGetDatabaseDdlSample{staticvoidgetDatabaseDdl(){// TODO(developer): Replace these variables before running the sample.finalStringprojectId="my-project";finalStringinstanceId="my-instance";finalStringdatabaseId="my-database";getDatabaseDdl(projectId,instanceId,databaseId);}staticvoidgetDatabaseDdl(StringprojectId,StringinstanceId,StringdatabaseId){try(Spannerspanner=SpannerOptions.newBuilder().setProjectId(projectId).build().getService();DatabaseAdminClientdatabaseAdminClient=spanner.createDatabaseAdminClient()){finalGetDatabaseDdlResponseresponse=databaseAdminClient.getDatabaseDdl(DatabaseName.of(projectId,instanceId,databaseId));System.out.println("Retrieved database DDL for "+databaseId);for(Stringddl:response.getStatementsList()){System.out.println(ddl);}}}}

/** * TODO(developer): Uncomment the following lines before running the sample. */// const projectId = 'my-project-id';// const instanceId = 'my-instance-id';// const databaseId = 'my-database-id';// Imports the Google Cloud client libraryconst{Spanner}=require('@google-cloud/spanner');// creates a clientconstspanner=newSpanner({projectId:projectId,});constdatabaseAdminClient=spanner.getDatabaseAdminClient();asyncfunctiongetDatabaseDdl(){// Get the schema definition of the database.const[ddlStatements]=awaitdatabaseAdminClient.getDatabaseDdl({database:databaseAdminClient.databasePath(projectId,instanceId,databaseId,),});console.log(`Retrieved database DDL for${databaseAdminClient.databasePath(projectId,instanceId,databaseId,)}:`,);ddlStatements.statements.forEach(element=>{console.log(element);});}getDatabaseDdl();

use Google\Cloud\Spanner\Admin\Database\V1\Client\DatabaseAdminClient;use Google\Cloud\Spanner\Admin\Database\V1\GetDatabaseDdlRequest;/** * Gets the database DDL statements. * Example: * ``` * get_database_ddl($projectId, $instanceId, $databaseId); * ``` * * @param string $projectId The Google Cloud project ID. * @param string $instanceId The Spanner instance ID. * @param string $databaseId The Spanner database ID. */function get_database_ddl(string $projectId, string $instanceId, string $databaseId): void{    $databaseAdminClient = new DatabaseAdminClient();    $databaseName = DatabaseAdminClient::databaseName($projectId, $instanceId, $databaseId);    $request = new GetDatabaseDdlRequest(['database' => $databaseName]);    $statements = $databaseAdminClient->getDatabaseDdl($request)->getStatements();    printf("Retrieved database DDL for $databaseId" . PHP_EOL);    foreach ($statements as $statement) {        printf($statement . PHP_EOL);    }}

defget_database_ddl(instance_id,database_id):"""Gets the database DDL statements."""spanner_client=spanner.Client()database_admin_api=spanner_client.database_admin_apiddl=database_admin_api.get_database_ddl(database=database_admin_api.database_path(spanner_client.project,instance_id,database_id))print("Retrieved database DDL for{}".format(database_id))forstatementinddl.statements:print(statement)

# project_id  = "Your Google Cloud project ID"# instance_id = "Your Spanner instance ID"# database_id = "Your Spanner database ID"require"google/cloud/spanner"require"google/cloud/spanner/admin/database"db_admin_client=Google::Cloud::Spanner::Admin::Database.database_adminproject_id:project_iddb_path=db_admin_client.database_pathproject:project_id,instance:instance_id,database:database_idddl=db_admin_client.get_database_ddldatabase:db_pathputsddl.statements

usingGoogle.Cloud.Spanner.Data;usingSystem;usingSystem.Threading.Tasks;publicclassGetDatabaseDefaultLeaderFromInformationSchemaAsyncSample{publicasyncTask<string>GetDatabaseDefaultLeaderFromInformationSchemaAsync(stringprojectId,stringinstanceId,stringdatabaseId){stringconnectionString=$"Data Source=projects/{projectId}/instances/{instanceId}/databases/{databaseId}";usingvarconnection=newSpannerConnection(connectionString);varcmd=connection.CreateSelectCommand(@"SELECT                s.OPTION_NAME,                s.OPTION_VALUE            FROM                INFORMATION_SCHEMA.DATABASE_OPTIONS s            WHERE                s.OPTION_NAME = 'default_leader'");vardefaultLeader=string.Empty;Console.WriteLine($"Default leader for {databaseId}:");usingvarreader=awaitcmd.ExecuteReaderAsync();while(awaitreader.ReadAsync()){defaultLeader=reader.GetFieldValue<string>("OPTION_VALUE");Console.WriteLine(defaultLeader);}returndefaultLeader;}}

voidQueryInformationSchemaDatabaseOptions(google::cloud::spanner::Clientclient){namespacespanner=::google::cloud::spanner;// clang-format misinterprets the namespace alias followed by a block as// introducing a sub-namespace and so adds a misleading namespace-closing// comment at the end. This separating comment defeats that.{autorows=client.ExecuteQuery(spanner::SqlStatement(R"""(        SELECT s.OPTION_NAME, s.OPTION_VALUE        FROM INFORMATION_SCHEMA.DATABASE_OPTIONS s        WHERE s.OPTION_NAME = 'default_leader')"""));usingRowType=std::tuple<std::string,std::string>;for(auto&row:spanner::StreamOf<RowType>(rows)){if(!row)throwstd::move(row).status();std::cout <<std::get<0>(*row) <<"=" <<std::get<1>(*row) <<"\n";}}{autorows=client.ExecuteQuery(spanner::SqlStatement(R"""(        SELECT s.OPTION_NAME, s.OPTION_VALUE        FROM INFORMATION_SCHEMA.DATABASE_OPTIONS s        WHERE s.OPTION_NAME = 'version_retention_period')"""));usingRowType=std::tuple<std::string,std::string>;for(auto&row:spanner::StreamOf<RowType>(rows)){if(!row)throwstd::move(row).status();std::cout <<std::get<0>(*row) <<"=" <<std::get<1>(*row) <<"\n";}}}

import("context""fmt""io""regexp""cloud.google.com/go/spanner""google.golang.org/api/iterator")// queryInformationSchemaDatabaseOptions queries the database options from the// information schema table.funcqueryInformationSchemaDatabaseOptions(wio.Writer,dbstring)error{// db = `projects/<project>/instances/<instance-id>/database/<database-id>`matches:=regexp.MustCompile("^(.+)/databases/(.+)$").FindStringSubmatch(db)ifmatches==nil||len(matches)!=3{returnfmt.Errorf("queryInformationSchemaDatabaseOptions: invalid database id %q",db)}databaseID:=matches[2]ctx:=context.Background()client,err:=spanner.NewClient(ctx,db)iferr!=nil{returnerr}deferclient.Close()stmt:=spanner.Statement{SQL:`SELECT OPTION_NAME, OPTION_VALUE                                FROM INFORMATION_SCHEMA.DATABASE_OPTIONS                                    WHERE OPTION_NAME = 'default_leader'`}iter:=client.Single().Query(ctx,stmt)deferiter.Stop()for{row,err:=iter.Next()iferr==iterator.Done{returnnil}iferr!=nil{returnerr}varoption_name,option_valuestringiferr:=row.Columns(&option_name,&option_value);err!=nil{returnerr}fmt.Fprintf(w,"The result of the query to get %s for %s is %s",option_name,databaseID,option_value)}}

importcom.google.cloud.spanner.DatabaseClient;importcom.google.cloud.spanner.DatabaseId;importcom.google.cloud.spanner.ResultSet;importcom.google.cloud.spanner.Spanner;importcom.google.cloud.spanner.SpannerOptions;importcom.google.cloud.spanner.Statement;publicclassQueryInformationSchemaDatabaseOptionsSample{staticvoidqueryInformationSchemaDatabaseOptions(){// TODO(developer): Replace these variables before running the sample.finalStringprojectId="my-project";finalStringinstanceId="my-instance";finalStringdatabaseId="my-database";queryInformationSchemaDatabaseOptions(projectId,instanceId,databaseId);}staticvoidqueryInformationSchemaDatabaseOptions(StringprojectId,StringinstanceId,StringdatabaseId){try(Spannerspanner=SpannerOptions.newBuilder().setProjectId(projectId).build().getService()){finalDatabaseIdid=DatabaseId.of(projectId,instanceId,databaseId);finalDatabaseClientdatabaseClient=spanner.getDatabaseClient(id);try(ResultSetresultSet=databaseClient.singleUse().executeQuery(Statement.of("SELECT OPTION_NAME, OPTION_VALUE"+" FROM INFORMATION_SCHEMA.DATABASE_OPTIONS"+" WHERE OPTION_NAME = 'default_leader'"))){if(resultSet.next()){finalStringoptionName=resultSet.getString("OPTION_NAME");finalStringoptionValue=resultSet.getString("OPTION_VALUE");System.out.println("The "+optionName+" for "+id+" is "+optionValue);}else{System.out.println("Database "+id+" does not have a value for option 'default_leader'");}}}}}

/** * TODO(developer): Uncomment the following lines before running the sample. */// const projectId = 'my-project-id';// const instanceId = 'my-instance-id';// const databaseId = 'my-database-id';// Imports the Google Cloud client libraryconst{Spanner}=require('@google-cloud/spanner');// Creates a clientconstspanner=newSpanner({projectId:projectId,});// Gets a reference to a Cloud Spanner instance and a database.constinstance=spanner.instance(instanceId);constdatabase=instance.database(databaseId);asyncfunctiongetDatabaseDdl(){// Get the default leader option for the database.const[rows]=awaitdatabase.run({sql:`      SELECT s.OPTION_NAME, s.OPTION_VALUE      FROM INFORMATION_SCHEMA.DATABASE_OPTIONS s      WHERE s.OPTION_NAME = 'default_leader'`,json:true,});if(rows.length >0){constoption=rows[0];console.log(`The${option.OPTION_NAME} for${databaseId} is${option.OPTION_VALUE}`,);}else{console.log(`Database${databaseId} does not have a value for option 'default_leader'`,);}}getDatabaseDdl();

use Google\Cloud\Spanner\SpannerClient;/** * Queries the default leader of a database. * Example: * ``` * query_information_schema_database_options($instanceId, $databaseId); * ``` * * @param string $instanceId The Spanner instance ID. * @param string $databaseId The Spanner database ID. */function query_information_schema_database_options(string $instanceId, string $databaseId): void{    $spanner = new SpannerClient();    $instance = $spanner->instance($instanceId);    $database = $instance->database($databaseId);    $results = $database->execute(        "SELECT s.OPTION_NAME, s.OPTION_VALUE        FROM INFORMATION_SCHEMA.DATABASE_OPTIONS s        WHERE s.OPTION_NAME = 'default_leader'"    );    foreach ($results as $row) {        $optionName = $row['OPTION_NAME'];        $optionValue = $row['OPTION_VALUE'];        printf("The $optionName for $databaseId is $optionValue" . PHP_EOL);    }    if (!$results->stats()['rowCountExact']) {        printf("Database $databaseId does not have a value for option 'default_leader'");    }}

defquery_information_schema_database_options(instance_id,database_id):"""Queries the default leader of a database."""spanner_client=spanner.Client()instance=spanner_client.instance(instance_id)database=instance.database(database_id)withdatabase.snapshot()assnapshot:results=snapshot.execute_sql("SELECT OPTION_VALUE AS default_leader ""FROM INFORMATION_SCHEMA.DATABASE_OPTIONS ""WHERE SCHEMA_NAME = '' AND OPTION_NAME = 'default_leader'")forresultinresults:print("Database{} has default leader{}".format(database_id,result[0]))

# project_id  = "Your Google Cloud project ID"# instance_id = "Your Spanner instance ID"# database_id = "Your Spanner database IDrequire"google/cloud/spanner"spanner=Google::Cloud::Spanner.newproject:project_idclient=spanner.clientinstance_id,database_idclient.execute("SELECT s.OPTION_NAME, s.OPTION_VALUE "\"FROM INFORMATION_SCHEMA.DATABASE_OPTIONS s "\"WHERE s.OPTION_NAME = 'default_leader'").rows.eachdo|row|putsrowend

usingGoogle.Cloud.Spanner.Admin.Database.V1;usingGoogle.Cloud.Spanner.Common.V1;usingSystem;usingSystem.Collections.Generic;usingSystem.Linq;publicclassListDatabasesSample{publicIEnumerable<Database>ListDatabases(stringprojectId,stringinstanceId){vardatabaseAdminClient=DatabaseAdminClient.Create();varinstanceName=InstanceName.FromProjectInstance(projectId,instanceId);vardatabases=databaseAdminClient.ListDatabases(instanceName);// We print the first 5 elements for demonstration purposes.// You can print all databases in the sequence by removing the call to Take(5).// The sequence will lazily fetch elements in pages as needed.foreach(vardatabaseindatabases.Take(5)){Console.WriteLine($"Default leader for database {database.DatabaseName.DatabaseId}: {database.DefaultLeader}");}returndatabases;}}

voidListDatabases(google::cloud::spanner_admin::DatabaseAdminClientclient,std::stringconst&project_id,std::stringconst&instance_id){google::cloud::spanner::Instancein(project_id,instance_id);intcount=0;for(auto&database:client.ListDatabases(in.FullName())){if(!database)throwstd::move(database).status();std::cout <<"Database " <<database->name() <<" full metadata:\n"              <<database->DebugString();++count;}if(count==0){std::cout <<"No databases found in instance " <<instance_id              <<" for project << " <<project_id <<"\n";}}

import("context""fmt""io"database"cloud.google.com/go/spanner/admin/database/apiv1"adminpb"cloud.google.com/go/spanner/admin/database/apiv1/databasepb""google.golang.org/api/iterator")// listDatabases gets list of all databases for an instancefunclistDatabases(wio.Writer,instanceIdstring)error{// instanceId = `projects/<project>/instances/<instance-id>ctx:=context.Background()adminClient,err:=database.NewDatabaseAdminClient(ctx)iferr!=nil{returnerr}deferadminClient.Close()iter:=adminClient.ListDatabases(ctx,&adminpb.ListDatabasesRequest{Parent:instanceId,})fmt.Fprintf(w,"Databases for instance/[%s]",instanceId)for{resp,err:=iter.Next()iferr==iterator.Done{break}iferr!=nil{returnerr}fmt.Fprintf(w,"%s\n",resp.Name)}returnnil}

importcom.google.cloud.spanner.Spanner;importcom.google.cloud.spanner.SpannerOptions;importcom.google.cloud.spanner.admin.database.v1.DatabaseAdminClient;importcom.google.cloud.spanner.admin.database.v1.DatabaseAdminClient.ListDatabasesPage;importcom.google.cloud.spanner.admin.database.v1.DatabaseAdminClient.ListDatabasesPagedResponse;importcom.google.spanner.admin.database.v1.Database;importcom.google.spanner.admin.database.v1.InstanceName;publicclassListDatabasesSample{staticvoidlistDatabases(){// TODO(developer): Replace these variables before running the sample.finalStringprojectId="my-project";finalStringinstanceId="my-instance";listDatabases(projectId,instanceId);}staticvoidlistDatabases(StringprojectId,StringinstanceId){try(Spannerspanner=SpannerOptions.newBuilder().setProjectId(projectId).build().getService();DatabaseAdminClientdatabaseAdminClient=spanner.createDatabaseAdminClient()){ListDatabasesPagedResponseresponse=databaseAdminClient.listDatabases(InstanceName.of(projectId,instanceId));System.out.println("Databases for projects/"+projectId+"/instances/"+instanceId);for(ListDatabasesPagepage:response.iteratePages()){for(Databasedatabase:page.iterateAll()){finalStringdefaultLeader=database.getDefaultLeader().equals("")?"":"(default leader = "+database.getDefaultLeader()+")";System.out.println("\t"+database.getName()+" "+defaultLeader);}}}}}

/** * TODO(developer): Uncomment the following lines before running the sample. */// const projectId = 'my-project-id';// const instanceId = 'my-instance-id';// Imports the Google Cloud client libraryconst{Spanner}=require('@google-cloud/spanner');// creates a clientconstspanner=newSpanner({projectId:projectId,});constdatabaseAdminClient=spanner.getDatabaseAdminClient();asyncfunctionlistDatabases(){// Lists all databases on the instance.const[databases]=awaitdatabaseAdminClient.listDatabases({parent:databaseAdminClient.instancePath(projectId,instanceId),});console.log(`Databases for projects/${projectId}/instances/${instanceId}:`);databases.forEach(database=>{constdefaultLeader=database.defaultLeader?`(default leader =${database.defaultLeader})`:'';console.log(`\t${database.name}${defaultLeader}`);});}listDatabases();

use Google\Cloud\Spanner\Admin\Database\V1\Client\DatabaseAdminClient;use Google\Cloud\Spanner\Admin\Database\V1\ListDatabasesRequest;/** * Lists the databases and their leader options. * Example: * ``` * list_databases($projectId, $instanceId); * ``` * * @param string $projectId The Google Cloud project ID. * @param string $instanceId The Spanner instance ID. */function list_databases(string $projectId, string $instanceId): void{    $databaseAdminClient = new DatabaseAdminClient();    $instanceName = DatabaseAdminClient::instanceName($projectId, $instanceId);    $request = new ListDatabasesRequest(['parent' => $instanceName]);    $resp = $databaseAdminClient->listDatabases($request);    $databases = $resp->iterateAllElements();    printf('Databases for %s' . PHP_EOL, $instanceName);    foreach ($databases as $database) {        printf("\t%s (default leader = %s)" . PHP_EOL, $database->getName(), $database->getDefaultLeader());    }}

deflist_databases(instance_id):"""Lists databases and their leader options."""fromgoogle.cloud.spanner_admin_database_v1.typesimportspanner_database_adminspanner_client=spanner.Client()database_admin_api=spanner_client.database_admin_apirequest=spanner_database_admin.ListDatabasesRequest(parent=database_admin_api.instance_path(spanner_client.project,instance_id))fordatabaseindatabase_admin_api.list_databases(request=request):print("Database{} has default leader{}".format(database.name,database.default_leader))

# project_id  = "Your Google Cloud project ID"# instance_id = "Your Spanner instance ID"require"google/cloud/spanner"require"google/cloud/spanner/admin/database"db_admin_client=Google::Cloud::Spanner::Admin::Database.database_adminproject_id:project_idinstance_path=db_admin_client.instance_pathproject:project_id,instance:instance_iddatabases=db_admin_client.list_databasesparent:instance_pathdatabases.eachdo|db|puts"#{db.name} : default leader#{db.default_leader}"end

usingGoogle.Cloud.Spanner.Admin.Instance.V1;usingSystem;usingSystem.Threading.Tasks;publicclassGetInstanceConfigAsyncSample{publicasyncTask<InstanceConfig>GetInstanceConfigAsync(stringprojectId,stringinstanceConfigId){varinstanceAdminClient=awaitInstanceAdminClient.CreateAsync();varinstanceConfigName=InstanceConfigName.FromProjectInstanceConfig(projectId,instanceConfigId);varinstanceConfig=awaitinstanceAdminClient.GetInstanceConfigAsync(instanceConfigName);Console.WriteLine($"Available leader options for instance config {instanceConfigName.InstanceConfigId}:");foreach(varleaderininstanceConfig.LeaderOptions){Console.WriteLine(leader);}returninstanceConfig;}}

voidGetInstanceConfig(google::cloud::spanner_admin::InstanceAdminClientclient,std::stringconst&project_id,std::stringconst&config_id){autoproject=google::cloud::Project(project_id);autoconfig=client.GetInstanceConfig(project.FullName()+"/instanceConfigs/"+config_id);if(!config)throwstd::move(config).status();std::cout <<"The instanceConfig " <<config->name()            <<" exists and its metadata is:\n"            <<config->DebugString();}

import("context""fmt""io"instance"cloud.google.com/go/spanner/admin/instance/apiv1""cloud.google.com/go/spanner/admin/instance/apiv1/instancepb")// getInstanceConfig gets available leader optionsfuncgetInstanceConfig(wio.Writer,instanceConfigNamestring)error{// defaultLeader = `nam3`ctx:=context.Background()instanceAdmin,err:=instance.NewInstanceAdminClient(ctx)iferr!=nil{returnerr}deferinstanceAdmin.Close()ic,err:=instanceAdmin.GetInstanceConfig(ctx,&instancepb.GetInstanceConfigRequest{Name:instanceConfigName,})iferr!=nil{returnfmt.Errorf("could not get instance config %s: %w",instanceConfigName,err)}fmt.Fprintf(w,"Available leader options for instance config %s: %v",instanceConfigName,ic.LeaderOptions)returnnil}

importcom.google.cloud.spanner.Spanner;importcom.google.cloud.spanner.SpannerOptions;importcom.google.cloud.spanner.admin.instance.v1.InstanceAdminClient;importcom.google.spanner.admin.instance.v1.InstanceConfig;importcom.google.spanner.admin.instance.v1.InstanceConfigName;publicclassGetInstanceConfigSample{staticvoidgetInstanceConfig(){// TODO(developer): Replace these variables before running the sample.finalStringprojectId="my-project";finalStringinstanceConfigId="nam6";getInstanceConfig(projectId,instanceConfigId);}staticvoidgetInstanceConfig(StringprojectId,StringinstanceConfigId){try(Spannerspanner=SpannerOptions.newBuilder().setProjectId(projectId).build().getService();InstanceAdminClientinstanceAdminClient=spanner.createInstanceAdminClient()){finalInstanceConfigNameinstanceConfigName=InstanceConfigName.of(projectId,instanceConfigId);finalInstanceConfiginstanceConfig=instanceAdminClient.getInstanceConfig(instanceConfigName.toString());System.out.printf("Available leader options for instance config %s: %s%n",instanceConfig.getName(),instanceConfig.getLeaderOptionsList());}}}

/** * TODO(developer): Uncomment the following line before running the sample. */// const projectId = 'my-project-id';// Imports the Google Cloud client libraryconst{Spanner}=require('@google-cloud/spanner');// Creates a clientconstspanner=newSpanner({projectId:projectId,});constinstanceAdminClient=spanner.getInstanceAdminClient();asyncfunctiongetInstanceConfig(){// Get the instance config for the multi-region North America 6 (NAM6).// See https://cloud.google.com/spanner/docs/instance-configurations#configuration for a list of all available// configurations.const[instanceConfig]=awaitinstanceAdminClient.getInstanceConfig({name:instanceAdminClient.instanceConfigPath(projectId,'nam6'),});console.log(`Available leader options for instance config${instanceConfig.name} ('${instanceConfig.displayName}'):${instanceConfig.leaderOptions.join()}`,);}getInstanceConfig();