voidCreateSequence(google::cloud::spanner_admin::DatabaseAdminClientadmin_client,google::cloud::spanner::Clientclient,std::stringconst&project_id,std::stringconst&instance_id,std::stringconst&database_id){google::cloud::spanner::Databasedatabase(project_id,instance_id,database_id);std::vector<std::string>statements;statements.emplace_back(R"""(      CREATE SEQUENCE Seq          OPTIONS (sequence_kind = 'bit_reversed_positive')  )""");statements.emplace_back(R"""(      CREATE TABLE Customers (          CustomerId INT64 DEFAULT (GET_NEXT_SEQUENCE_VALUE(SEQUENCE Seq)),          CustomerName STRING(1024)      ) PRIMARY KEY (CustomerId)  )""");autometadata=admin_client.UpdateDatabaseDdl(database.FullName(),std::move(statements)).get();if(!metadata)throwstd::move(metadata).status();std::cout <<"Created `Seq` sequence and `Customers` table,"            <<" where the key column `CustomerId`"            <<" uses the sequence as a default value,"            <<" new DDL:\n"            <<metadata->DebugString();autocommit=client.Commit([&client](google::cloud::spanner::Transactiontxn)->google::cloud::StatusOr<google::cloud::spanner::Mutations>{autosql=google::cloud::spanner::SqlStatement(R"""(            INSERT INTO Customers (CustomerName)              VALUES ('Alice'),                     ('David'),                     ('Marc')              THEN RETURN CustomerId        )""");usingRowType=std::tuple<std::int64_t>;autorows=client.ExecuteQuery(std::move(txn),std::move(sql));//Note:Thismutatormightbere-run,oritseffectsdiscarded,so//changingnon-transactionalstate(e.g.,byproducingoutput)is,//ingeneral,notsomethingtobeimitated.for(auto&row:google::cloud::spanner::StreamOf<RowType>(rows)){if(!row)returnstd::move(row).status();std::cout <<"Inserted customer record with CustomerId: "                    <<std::get<0>(*row) <<"\n";}std::cout <<"Number of customer records inserted is: "                  <<rows.RowsModified() <<"\n";returngoogle::cloud::spanner::Mutations{};});if(!commit)throwstd::move(commit).status();}

usingGoogle.Cloud.Spanner.Admin.Database.V1;usingGoogle.Cloud.Spanner.Common.V1;usingGoogle.Cloud.Spanner.Data;usingSystem;usingSystem.Collections.Generic;usingSystem.Threading.Tasks;publicclassCreateSequenceSample{publicasyncTask<List<long>>CreateSequenceAsync(stringprojectId,stringinstanceId,stringdatabaseId){DatabaseAdminClientdatabaseAdminClient=DatabaseAdminClient.Create();DatabaseNamedatabaseName=DatabaseName.FromProjectInstanceDatabase(projectId,instanceId,databaseId);string[]statements={"CREATE SEQUENCE Seq OPTIONS (sequence_kind = 'bit_reversed_positive')","CREATE TABLE Customers (CustomerId INT64 DEFAULT (GET_NEXT_SEQUENCE_VALUE(SEQUENCE Seq)), CustomerName STRING(1024)) PRIMARY KEY (CustomerId)"};varoperation=awaitdatabaseAdminClient.UpdateDatabaseDdlAsync(databaseName,statements);varcompletedResponse=awaitoperation.PollUntilCompletedAsync();if(completedResponse.IsFaulted){throwcompletedResponse.Exception;}Console.WriteLine("Created Seq sequence and Customers table, where the key column CustomerId uses the sequence as a default value");stringconnectionString=$"Data Source=projects/{projectId}/instances/{instanceId}/databases/{databaseId}";usingvarconnection=newSpannerConnection(connectionString);awaitconnection.OpenAsync();usingvarcmd=connection.CreateDmlCommand(@"INSERT INTO Customers (CustomerName) VALUES ('Alice'), ('David'), ('Marc') THEN RETURN CustomerId");varreader=awaitcmd.ExecuteReaderAsync();varcustomerIds=newList<long>();while(awaitreader.ReadAsync()){varcustomerId=reader.GetFieldValue<long>("CustomerId");Console.WriteLine($"Inserted customer record with CustomerId: {customerId}");customerIds.Add(customerId);}Console.WriteLine($"Number of customer records inserted is: {customerIds.Count}");returncustomerIds;}}

import("context""fmt""io""cloud.google.com/go/spanner"database"cloud.google.com/go/spanner/admin/database/apiv1"adminpb"cloud.google.com/go/spanner/admin/database/apiv1/databasepb""google.golang.org/api/iterator")funccreateSequence(wio.Writer,dbstring)error{// db := "projects/my-project/instances/my-instance/databases/my-database"ctx:=context.Background()adminClient,err:=database.NewDatabaseAdminClient(ctx)iferr!=nil{returnerr}deferadminClient.Close()// List of DDL statements to be applied to the database.// Create a sequence, and then use the sequence as auto generated primary key in Customers table.ddl:=[]string{"CREATE SEQUENCE Seq OPTIONS (sequence_kind = 'bit_reversed_positive')","CREATE TABLE Customers (CustomerId INT64 DEFAULT (GET_NEXT_SEQUENCE_VALUE(Sequence Seq)), CustomerName STRING(1024)) PRIMARY KEY (CustomerId)",}op,err:=adminClient.UpdateDatabaseDdl(ctx,&adminpb.UpdateDatabaseDdlRequest{Database:db,Statements:ddl,})iferr!=nil{returnerr}// Wait for the UpdateDatabaseDdl operation to finish.iferr:=op.Wait(ctx);err!=nil{returnfmt.Errorf("waiting for bit reverse sequence creation to finish failed: %w",err)}fmt.Fprintf(w,"Created Seq sequence and Customers table, where the key column CustomerId uses the sequence as a default value\n")client,err:=spanner.NewClient(ctx,db)iferr!=nil{returnerr}deferclient.Close()// Inserts records into the Customers table.// The ReadWriteTransaction function returns the commit timestamp and an error.// The commit timestamp is ignored in this case._,err=client.ReadWriteTransaction(ctx,func(ctxcontext.Context,txn*spanner.ReadWriteTransaction)error{stmt:=spanner.Statement{SQL:`INSERT INTO Customers (CustomerName) VALUES ('Alice'), ('David'), ('Marc') THEN RETURN CustomerId`,}iter:=txn.Query(ctx,stmt)deferiter.Stop()for{row,err:=iter.Next()iferr==iterator.Done{break}iferr!=nil{returnerr}varcustomerIdint64iferr:=row.Columns(&customerId);err!=nil{returnerr}fmt.Fprintf(w,"Inserted customer record with CustomerId: %d\n",customerId)}fmt.Fprintf(w,"Number of customer records inserted is: %d\n",iter.RowCount)returnnil})returnerr}

importcom.google.cloud.spanner.DatabaseClient;importcom.google.cloud.spanner.DatabaseId;importcom.google.cloud.spanner.ResultSet;importcom.google.cloud.spanner.Spanner;importcom.google.cloud.spanner.SpannerExceptionFactory;importcom.google.cloud.spanner.SpannerOptions;importcom.google.cloud.spanner.Statement;importcom.google.cloud.spanner.admin.database.v1.DatabaseAdminClient;importcom.google.common.collect.ImmutableList;importcom.google.spanner.admin.database.v1.DatabaseName;importjava.util.Objects;importjava.util.concurrent.ExecutionException;importjava.util.concurrent.TimeUnit;importjava.util.concurrent.TimeoutException;publicclassCreateSequenceSample{staticvoidcreateSequence(){// TODO(developer): Replace these variables before running the sample.finalStringprojectId="my-project";finalStringinstanceId="my-instance";finalStringdatabaseId="my-database";createSequence(projectId,instanceId,databaseId);}staticvoidcreateSequence(StringprojectId,StringinstanceId,StringdatabaseId){try(Spannerspanner=SpannerOptions.newBuilder().setProjectId(projectId).build().getService();DatabaseAdminClientdatabaseAdminClient=spanner.createDatabaseAdminClient()){databaseAdminClient.updateDatabaseDdlAsync(DatabaseName.of(projectId,instanceId,databaseId),ImmutableList.of("CREATE SEQUENCE Seq OPTIONS (sequence_kind = 'bit_reversed_positive')","CREATE TABLE Customers (CustomerId INT64 DEFAULT "+"(GET_NEXT_SEQUENCE_VALUE(SEQUENCE Seq)), CustomerName STRING(1024)) "+"PRIMARY KEY (CustomerId)")).get(5,TimeUnit.MINUTES);System.out.println("Created Seq sequence and Customers table, where the key column CustomerId "+"uses the sequence as a default value");finalDatabaseClientdbClient=spanner.getDatabaseClient(DatabaseId.of(projectId,instanceId,databaseId));LonginsertCount=dbClient.readWriteTransaction().run(transaction->{try(ResultSetrs=transaction.executeQuery(Statement.of("INSERT INTO Customers (CustomerName) VALUES "+"('Alice'), ('David'), ('Marc') THEN RETURN CustomerId"))){while(rs.next()){System.out.printf("Inserted customer record with CustomerId: %d\n",rs.getLong(0));}returnObjects.requireNonNull(rs.getStats()).getRowCountExact();}});System.out.printf("Number of customer records inserted is: %d\n",insertCount);}catch(ExecutionExceptione){// If the operation failed during execution, expose the cause.throwSpannerExceptionFactory.asSpannerException(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);}catch(TimeoutExceptione){// If the operation timed out propagate the timeoutthrowSpannerExceptionFactory.propagateTimeout(e);}}}

// Imports the Google Cloud client library.const{Spanner}=require('@google-cloud/spanner');/** * TODO(developer): Uncomment the following lines before running the sample. */// const projectId = 'my-project-id';// const instanceId = 'my-instance';// const databaseId = 'my-database';// Creates a clientconstspanner=newSpanner({projectId:projectId,});asyncfunctioncreateSequence(instanceId,databaseId){// Gets a reference to a Cloud Spanner Database Admin Client objectconstdatabaseAdminClient=spanner.getDatabaseAdminClient();constrequest=["CREATE SEQUENCE Seq OPTIONS (sequence_kind = 'bit_reversed_positive')",'CREATE TABLE Customers (CustomerId INT64 DEFAULT (GET_NEXT_SEQUENCE_VALUE(Sequence Seq)), CustomerName STRING(1024)) PRIMARY KEY (CustomerId)',];// Creates a new table with sequencetry{const[operation]=awaitdatabaseAdminClient.updateDatabaseDdl({database:databaseAdminClient.databasePath(projectId,instanceId,databaseId,),statements:request,});console.log('Waiting for operation to complete...');awaitoperation.promise();console.log('Created Seq sequence and Customers table, where the key column CustomerId uses the sequence as a default value.',);}catch(err){console.error('ERROR:',err);}// Gets a reference to a Cloud Spanner instance and databaseconstinstance=spanner.instance(instanceId);constdatabase=instance.database(databaseId);database.runTransaction(async(err,transaction)=>{if(err){console.error(err);return;}try{const[rows,stats]=awaittransaction.run({sql:"INSERT INTO Customers (CustomerName) VALUES ('Alice'), ('David'), ('Marc') THEN RETURN CustomerId",});rows.forEach(row=>{console.log(`Inserted customer record with CustomerId:${row.toJSON({wrapNumbers:true}).CustomerId.value          }`,);});constrowCount=Math.floor(stats[stats.rowCount]);console.log(`Number of customer records inserted is:${rowCount}`);awaittransaction.commit();}catch(err){console.error('ERROR:',err);}finally{// Close the database when finished.awaitdatabase.close();}});}awaitcreateSequence(instanceId,databaseId);

use Google\Cloud\Spanner\Admin\Database\V1\Client\DatabaseAdminClient;use Google\Cloud\Spanner\Admin\Database\V1\UpdateDatabaseDdlRequest;use Google\Cloud\Spanner\SpannerClient;use Google\Cloud\Spanner\Result;/** * Creates a sequence. * * Example: * ``` * create_sequence($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 create_sequence(string $projectId, string $instanceId, string $databaseId): void{    $databaseAdminClient = new DatabaseAdminClient();    $spanner = new SpannerClient();    $instance = $spanner->instance($instanceId);    $database = $instance->database($databaseId);    $databaseName = DatabaseAdminClient::databaseName($projectId, $instanceId, $databaseId);    $request = new UpdateDatabaseDdlRequest([        'database' => $databaseName,        'statements' => [            "CREATE SEQUENCE Seq OPTIONS (sequence_kind = 'bit_reversed_positive')",            'CREATE TABLE Customers (CustomerId INT64 DEFAULT (GET_NEXT_SEQUENCE_VALUE(' .            'Sequence Seq)), CustomerName STRING(1024)) PRIMARY KEY (CustomerId)'        ]    ]);    $operation = $databaseAdminClient->updateDatabaseDdl($request);    print('Waiting for operation to complete...' . PHP_EOL);    $operation->pollUntilComplete();    printf(        'Created Seq sequence and Customers table, where ' .        'the key column CustomerId uses the sequence as a default value' .        PHP_EOL    );    $transaction = $database->transaction();    $res = $transaction->execute(        'INSERT INTO Customers (CustomerName) VALUES ' .        "('Alice'), ('David'), ('Marc') THEN RETURN CustomerId"    );    $rows = $res->rows(Result::RETURN_ASSOCIATIVE);    foreach ($rows as $row) {        printf('Inserted customer record with CustomerId: %d %s',            $row['CustomerId'],            PHP_EOL        );    }    $transaction->commit();    printf(sprintf(        'Number of customer records inserted is: %d %s',        $res->stats()['rowCountExact'],        PHP_EOL    ));}

defcreate_sequence(instance_id,database_id):"""Creates the Sequence and insert data"""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=["CREATE SEQUENCE Seq OPTIONS (sequence_kind = 'bit_reversed_positive')","""CREATE TABLE Customers (            CustomerId     INT64 DEFAULT (GET_NEXT_SEQUENCE_VALUE(Sequence Seq)),            CustomerName      STRING(1024)            ) PRIMARY KEY (CustomerId)""",],)operation=database_admin_api.update_database_ddl(request)print("Waiting for operation to complete...")operation.result(OPERATION_TIMEOUT_SECONDS)print("Created Seq sequence and Customers table, where the key column CustomerId uses the sequence as a default value on database{} on instance{}".format(database_id,instance_id))definsert_customers(transaction):results=transaction.execute_sql("INSERT INTO Customers (CustomerName) VALUES ""('Alice'), ""('David'), ""('Marc') ""THEN RETURN CustomerId")forresultinresults:print("Inserted customer record with Customer Id:{}".format(*result))print("Number of customer records inserted is{}".format(results.stats.row_count_exact))instance=spanner_client.instance(instance_id)database=instance.database(database_id)database.run_in_transaction(insert_customers)

require"google/cloud/spanner"### This is a snippet for showcasing how to create a sequence.## @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_create_sequenceproject_id:,instance_id:,database_id:db_admin_client=Google::Cloud::Spanner::Admin::Database.database_admindatabase_path=db_admin_client.database_pathproject:project_id,instance:instance_id,database:database_idjob=db_admin_client.update_database_ddldatabase:database_path,statements:["CREATE SEQUENCE Seq OPTIONS (sequence_kind = 'bit_reversed_positive')","CREATE TABLE Customers (CustomerId INT64 DEFAULT (GET_NEXT_SEQUENCE_VALUE(Sequence Seq)), CustomerName STRING(1024)) PRIMARY KEY (CustomerId)"]puts"Waiting for operation to complete..."job.wait_until_done!puts"Created Seq sequence and Customers table, where the key column CustomerId uses the sequence as a default value"end

voidCreateSequence(google::cloud::spanner_admin::DatabaseAdminClientadmin_client,google::cloud::spanner::Databaseconst&database,google::cloud::spanner::Clientclient){std::vector<std::string>statements;statements.emplace_back(R"""(      CREATE SEQUENCE Seq BIT_REVERSED_POSITIVE  )""");statements.emplace_back(R"""(      CREATE TABLE Customers (          CustomerId    BIGINT DEFAULT NEXTVAL('Seq'),          CustomerName  CHARACTER VARYING(1024),          PRIMARY KEY (CustomerId)      )  )""");autometadata=admin_client.UpdateDatabaseDdl(database.FullName(),std::move(statements)).get();if(!metadata)throwstd::move(metadata).status();std::cout <<"Created `Seq` sequence and `Customers` table,"            <<" where the key column `CustomerId`"            <<" uses the sequence as a default value,"            <<" new DDL:\n"            <<metadata->DebugString();autocommit=client.Commit([&client](google::cloud::spanner::Transactiontxn)->google::cloud::StatusOr<google::cloud::spanner::Mutations>{autosql=google::cloud::spanner::SqlStatement(R"""(            INSERT INTO Customers (CustomerName)                VALUES ('Alice'),                       ('David'),                       ('Marc')                RETURNING CustomerId        )""");usingRowType=std::tuple<std::int64_t>;autorows=client.ExecuteQuery(std::move(txn),std::move(sql));//Note:Thismutatormightbere-run,oritseffectsdiscarded,so//changingnon-transactionalstate(e.g.,byproducingoutput)is,//ingeneral,notsomethingtobeimitated.for(auto&row:google::cloud::spanner::StreamOf<RowType>(rows)){if(!row)returnstd::move(row).status();std::cout <<"Inserted customer record with CustomerId: "                    <<std::get<0>(*row) <<"\n";}std::cout <<"Number of customer records inserted is: "                  <<rows.RowsModified() <<"\n";returngoogle::cloud::spanner::Mutations{};});if(!commit)throwstd::move(commit).status();}

usingGoogle.Cloud.Spanner.Common.V1;usingSystem.Threading.Tasks;usingSystem;usingGoogle.Cloud.Spanner.Admin.Database.V1;usingGoogle.Cloud.Spanner.Data;usingSystem.Collections.Generic;publicclassCreateSequencePostgresqlSample{publicasyncTask<List<long>>CreateSequencePostgresqlSampleAsync(stringprojectId,stringinstanceId,stringdatabaseId){DatabaseAdminClientdatabaseAdminClient=DatabaseAdminClient.Create();DatabaseNamedatabaseName=DatabaseName.FromProjectInstanceDatabase(projectId,instanceId,databaseId);string[]statements={"CREATE SEQUENCE Seq BIT_REVERSED_POSITIVE ;","CREATE TABLE Customers (CustomerId BIGINT DEFAULT nextval('Seq'), CustomerName character varying(1024), PRIMARY KEY (CustomerId))"};varoperation=awaitdatabaseAdminClient.UpdateDatabaseDdlAsync(databaseName,statements);varcompletedResponse=awaitoperation.PollUntilCompletedAsync();if(completedResponse.IsFaulted){throwcompletedResponse.Exception;}Console.WriteLine("Created Seq sequence and Customers table, where the key column CustomerId uses the sequence as a default value");stringconnectionString=$"Data Source=projects/{projectId}/instances/{instanceId}/databases/{databaseId}";usingvarconnection=newSpannerConnection(connectionString);awaitconnection.OpenAsync();usingvarcmd=connection.CreateDmlCommand(@"INSERT INTO Customers (CustomerName) VALUES ('Alice'), ('David'), ('Marc') RETURNING CustomerId");varreader=awaitcmd.ExecuteReaderAsync();varcustomerIds=newList<long>();while(awaitreader.ReadAsync()){varcustomerId=reader.GetFieldValue<long>("customerid");Console.WriteLine($"Inserted customer record with CustomerId: {customerId}");customerIds.Add(customerId);}Console.WriteLine($"Number of customer records inserted is: {customerIds.Count}");returncustomerIds;}}

import("context""fmt""io""cloud.google.com/go/spanner"database"cloud.google.com/go/spanner/admin/database/apiv1"adminpb"cloud.google.com/go/spanner/admin/database/apiv1/databasepb""google.golang.org/api/iterator")funcpgCreateSequence(wio.Writer,dbstring)error{// db := "projects/my-project/instances/my-instance/databases/my-database"ctx:=context.Background()adminClient,err:=database.NewDatabaseAdminClient(ctx)iferr!=nil{returnerr}deferadminClient.Close()// List of DDL statements to be applied to the database.// Create a sequence, and then use the sequence as auto generated primary key in Customers table.ddl:=[]string{"CREATE SEQUENCE Seq BIT_REVERSED_POSITIVE","CREATE TABLE Customers (CustomerId BIGINT DEFAULT nextval('Seq'), CustomerName character varying(1024), PRIMARY KEY (CustomerId))",}op,err:=adminClient.UpdateDatabaseDdl(ctx,&adminpb.UpdateDatabaseDdlRequest{Database:db,Statements:ddl,})iferr!=nil{returnerr}// Wait for the UpdateDatabaseDdl operation to finish.iferr:=op.Wait(ctx);err!=nil{returnfmt.Errorf("waiting for bit reverse sequence creation to finish failed: %w",err)}fmt.Fprintf(w,"Created Seq sequence and Customers table, where its key column CustomerId uses the sequence as a default value\n")client,err:=spanner.NewClient(ctx,db)iferr!=nil{returnerr}deferclient.Close()// Inserts records into the Customers table.// The ReadWriteTransaction function returns the commit timestamp and an error.// The commit timestamp is ignored in this case._,err=client.ReadWriteTransaction(ctx,func(ctxcontext.Context,txn*spanner.ReadWriteTransaction)error{stmt:=spanner.Statement{SQL:`INSERT INTO Customers (CustomerName) VALUES ('Alice'), ('David'), ('Marc') RETURNING CustomerId`,}iter:=txn.Query(ctx,stmt)deferiter.Stop()for{row,err:=iter.Next()iferr==iterator.Done{break}iferr!=nil{returnerr}varcustomerIdint64iferr:=row.Columns(&customerId);err!=nil{returnerr}fmt.Fprintf(w,"Inserted customer record with CustomerId: %d\n",customerId)}fmt.Fprintf(w,"Number of customer records inserted is: %d\n",iter.RowCount)returnnil})returnerr}

importcom.google.cloud.spanner.DatabaseClient;importcom.google.cloud.spanner.DatabaseId;importcom.google.cloud.spanner.ResultSet;importcom.google.cloud.spanner.Spanner;importcom.google.cloud.spanner.SpannerExceptionFactory;importcom.google.cloud.spanner.SpannerOptions;importcom.google.cloud.spanner.Statement;importcom.google.cloud.spanner.admin.database.v1.DatabaseAdminClient;importcom.google.common.collect.ImmutableList;importcom.google.spanner.admin.database.v1.DatabaseName;importjava.util.Objects;importjava.util.concurrent.ExecutionException;importjava.util.concurrent.TimeUnit;importjava.util.concurrent.TimeoutException;publicclassPgCreateSequenceSample{staticvoidpgCreateSequence(){// TODO(developer): Replace these variables before running the sample.finalStringprojectId="my-project";finalStringinstanceId="my-instance";finalStringdatabaseId="my-database";pgCreateSequence(projectId,instanceId,databaseId);}staticvoidpgCreateSequence(StringprojectId,StringinstanceId,StringdatabaseId){try(Spannerspanner=SpannerOptions.newBuilder().setProjectId(projectId).build().getService();DatabaseAdminClientdatabaseAdminClient=spanner.createDatabaseAdminClient()){databaseAdminClient.updateDatabaseDdlAsync(DatabaseName.of(projectId,instanceId,databaseId).toString(),ImmutableList.of("CREATE SEQUENCE Seq BIT_REVERSED_POSITIVE;","CREATE TABLE Customers (CustomerId BIGINT DEFAULT nextval('Seq'), "+"CustomerName character varying(1024), PRIMARY KEY (CustomerId))")).get(5,TimeUnit.MINUTES);System.out.println("Created Seq sequence and Customers table, where the key column "+"CustomerId uses the sequence as a default value");finalDatabaseClientdbClient=spanner.getDatabaseClient(DatabaseId.of(projectId,instanceId,databaseId));LonginsertCount=dbClient.readWriteTransaction().run(transaction->{try(ResultSetrs=transaction.executeQuery(Statement.of("INSERT INTO Customers (CustomerName) VALUES "+"('Alice'), ('David'), ('Marc') RETURNING CustomerId"))){while(rs.next()){System.out.printf("Inserted customer record with CustomerId: %d\n",rs.getLong(0));}returnObjects.requireNonNull(rs.getStats()).getRowCountExact();}});System.out.printf("Number of customer records inserted is: %d\n",insertCount);}catch(ExecutionExceptione){// If the operation failed during execution, expose the cause.throwSpannerExceptionFactory.asSpannerException(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);}catch(TimeoutExceptione){// If the operation timed out propagate the timeoutthrowSpannerExceptionFactory.propagateTimeout(e);}}}

// Imports the Google Cloud client library.const{Spanner}=require('@google-cloud/spanner');/** * TODO(developer): Uncomment the following lines before running the sample. */// const projectId = 'my-project-id';// const instanceId = 'my-instance';// const databaseId = 'my-database';// Creates a clientconstspanner=newSpanner({projectId:projectId,});asyncfunctioncreateSequence(instanceId,databaseId){// Gets a reference to a Cloud Spanner Database Admin Client objectconstdatabaseAdminClient=spanner.getDatabaseAdminClient();constrequest=['CREATE SEQUENCE Seq BIT_REVERSED_POSITIVE',"CREATE TABLE Customers (CustomerId BIGINT DEFAULT nextval('Seq'), CustomerName character varying(1024), PRIMARY KEY (CustomerId))",];// Creates a new table with sequencetry{const[operation]=awaitdatabaseAdminClient.updateDatabaseDdl({database:databaseAdminClient.databasePath(projectId,instanceId,databaseId,),statements:request,});console.log('Waiting for operation to complete...');awaitoperation.promise();console.log('Created Seq sequence and Customers table, where the key column CustomerId uses the sequence as a default value',);}catch(err){console.error('ERROR:',err);}// Gets a reference to a Cloud Spanner instance and databaseconstinstance=spanner.instance(instanceId);constdatabase=instance.database(databaseId);database.runTransaction(async(err,transaction)=>{if(err){console.error(err);return;}try{const[rows,stats]=awaittransaction.run({sql:"INSERT INTO Customers (CustomerName) VALUES ('Alice'), ('David'), ('Marc') RETURNING CustomerId",});rows.forEach(row=>{console.log(`Inserted customer record with CustomerId:${row.toJSON({wrapNumbers:true}).customerid.value          }`,);});constrowCount=Math.floor(stats[stats.rowCount]);console.log(`Number of customer records inserted is:${rowCount}`);awaittransaction.commit();}catch(err){console.error('ERROR:',err);}finally{// Close the spanner client when finished.// The databaseAdminClient does not require explicit closure. The closure of the Spanner client will automatically close the databaseAdminClient.spanner.close();}});}awaitcreateSequence(instanceId,databaseId);

use Google\Cloud\Spanner\Admin\Database\V1\Client\DatabaseAdminClient;use Google\Cloud\Spanner\Admin\Database\V1\UpdateDatabaseDdlRequest;use Google\Cloud\Spanner\SpannerClient;use Google\Cloud\Spanner\Result;/** * Creates a sequence. * Example: * ``` * pg_create_sequence($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 pg_create_sequence(    string $projectId,    string $instanceId,    string $databaseId): void {    $databaseAdminClient = new DatabaseAdminClient();    $spanner = new SpannerClient();    $instance = $spanner->instance($instanceId);    $database = $instance->database($databaseId);    $transaction = $database->transaction();    $operation = $databaseAdminClient->updateDatabaseDdl(new UpdateDatabaseDdlRequest([        'database' => DatabaseAdminClient::databaseName($projectId, $instanceId, $databaseId),        'statements' => [            'CREATE SEQUENCE Seq BIT_REVERSED_POSITIVE',            "CREATE TABLE Customers (            CustomerId           BIGINT DEFAULT nextval('Seq'),            CustomerName         CHARACTER VARYING(1024),            PRIMARY KEY (CustomerId))"        ]    ]));    print('Waiting for operation to complete ...' . PHP_EOL);    $operation->pollUntilComplete();    printf(        'Created Seq sequence and Customers table, where ' .        'the key column CustomerId uses the sequence as a default value' .        PHP_EOL    );    $res = $transaction->execute(        'INSERT INTO Customers (CustomerName) VALUES ' .        "('Alice'), ('David'), ('Marc') RETURNING CustomerId"    );    $rows = $res->rows(Result::RETURN_ASSOCIATIVE);    foreach ($rows as $row) {        printf('Inserted customer record with CustomerId: %d %s',            $row['customerid'],            PHP_EOL        );    }    $transaction->commit();    printf(sprintf(        'Number of customer records inserted is: %d %s',        $res->stats()['rowCountExact'],        PHP_EOL    ));}

defcreate_sequence(instance_id,database_id):"""Creates the Sequence and insert data"""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=["CREATE SEQUENCE Seq BIT_REVERSED_POSITIVE","""CREATE TABLE Customers (        CustomerId  BIGINT DEFAULT nextval('Seq'),        CustomerName  character varying(1024),        PRIMARY KEY (CustomerId)        )""",],)operation=database_admin_api.update_database_ddl(request)print("Waiting for operation to complete...")operation.result(OPERATION_TIMEOUT_SECONDS)print("Created Seq sequence and Customers table, where the key column CustomerId uses the sequence as a default value on database{} on instance{}".format(database_id,instance_id))definsert_customers(transaction):results=transaction.execute_sql("INSERT INTO Customers (CustomerName) VALUES ""('Alice'), ""('David'), ""('Marc') ""RETURNING CustomerId")forresultinresults:print("Inserted customer record with Customer Id:{}".format(*result))print("Number of customer records inserted is{}".format(results.stats.row_count_exact))instance=spanner_client.instance(instance_id)database=instance.database(database_id)database.run_in_transaction(insert_customers)

require"google/cloud/spanner"### This is a snippet for showcasing how to create a sequence using postgresql.## @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_postgresql_create_sequenceproject_id:,instance_id:,database_id:db_admin_client=Google::Cloud::Spanner::Admin::Database.database_admindatabase_path=db_admin_client.database_pathproject:project_id,instance:instance_id,database:database_idjob=db_admin_client.update_database_ddldatabase:database_path,statements:["CREATE SEQUENCE Seq BIT_REVERSED_POSITIVE","CREATE TABLE Customers (CustomerId BIGINT DEFAULT nextval('Seq'), CustomerName character varying(1024), PRIMARY KEY (CustomerId))"]puts"Waiting for operation to complete..."job.wait_until_done!puts"Created Seq sequence and Customers table, where its key column CustomerId uses the sequence as a default value"end

voidAlterSequence(google::cloud::spanner_admin::DatabaseAdminClientadmin_client,google::cloud::spanner::Clientclient,std::stringconst&project_id,std::stringconst&instance_id,std::stringconst&database_id){google::cloud::spanner::Databasedatabase(project_id,instance_id,database_id);std::vector<std::string>statements;statements.emplace_back(R"""(      ALTER SEQUENCE Seq          SET OPTIONS (skip_range_min = 1000, skip_range_max = 5000000)  )""");autometadata=admin_client.UpdateDatabaseDdl(database.FullName(),std::move(statements)).get();if(!metadata)throwstd::move(metadata).status();std::cout <<"Altered `Seq` sequence"            <<"  to skip an inclusive range between 1000 and 5000000,"            <<" new DDL:\n"            <<metadata->DebugString();autocommit=client.Commit([&client](google::cloud::spanner::Transactiontxn)->google::cloud::StatusOr<google::cloud::spanner::Mutations>{autosql=google::cloud::spanner::SqlStatement(R"""(            INSERT INTO Customers (CustomerName)              VALUES ('Lea'),                     ('Catalina'),                     ('Smith')              THEN RETURN CustomerId        )""");usingRowType=std::tuple<std::int64_t>;autorows=client.ExecuteQuery(std::move(txn),std::move(sql));//Note:Thismutatormightbere-run,oritseffectsdiscarded,so//changingnon-transactionalstate(e.g.,byproducingoutput)is,//ingeneral,notsomethingtobeimitated.for(auto&row:google::cloud::spanner::StreamOf<RowType>(rows)){if(!row)returnstd::move(row).status();std::cout <<"Inserted customer record with CustomerId: "                    <<std::get<0>(*row) <<"\n";}std::cout <<"Number of customer records inserted is: "                  <<rows.RowsModified() <<"\n";returngoogle::cloud::spanner::Mutations{};});if(!commit)throwstd::move(commit).status();}

usingGoogle.Cloud.Spanner.Admin.Database.V1;usingGoogle.Cloud.Spanner.Common.V1;usingGoogle.Cloud.Spanner.Data;usingSystem;usingSystem.Collections.Generic;usingSystem.Threading.Tasks;publicclassAlterSequenceSample{publicasyncTask<List<long>>AlterSequenceSampleAsync(stringprojectId,stringinstanceId,stringdatabaseId){DatabaseAdminClientdatabaseAdminClient=DatabaseAdminClient.Create();DatabaseNamedatabaseName=DatabaseName.FromProjectInstanceDatabase(projectId,instanceId,databaseId);string[]statements={"ALTER SEQUENCE Seq SET OPTIONS (skip_range_min = 1000, skip_range_max = 5000000)"};varoperation=awaitdatabaseAdminClient.UpdateDatabaseDdlAsync(databaseName,statements);varcompletedResponse=awaitoperation.PollUntilCompletedAsync();if(completedResponse.IsFaulted){throwcompletedResponse.Exception;}Console.WriteLine("Altered Seq sequence to skip an inclusive range between 1000 and 5000000");stringconnectionString=$"Data Source=projects/{projectId}/instances/{instanceId}/databases/{databaseId}";usingvarconnection=newSpannerConnection(connectionString);awaitconnection.OpenAsync();usingvarcmd=connection.CreateDmlCommand(@"INSERT INTO Customers (CustomerName) VALUES ('Alice'), ('David'), ('Marc') THEN RETURN CustomerId");varreader=awaitcmd.ExecuteReaderAsync();varcustomerIds=newList<long>();while(awaitreader.ReadAsync()){longcustomerId=reader.GetFieldValue<long>("CustomerId");Console.WriteLine($"Inserted customer record with CustomerId: {customerId}");customerIds.Add(customerId);}Console.WriteLine($"Number of customer records inserted is: {customerIds.Count}");returncustomerIds;}}

import("context""fmt""io""cloud.google.com/go/spanner"database"cloud.google.com/go/spanner/admin/database/apiv1"adminpb"cloud.google.com/go/spanner/admin/database/apiv1/databasepb""google.golang.org/api/iterator")funcalterSequence(wio.Writer,dbstring)error{// db := "projects/my-project/instances/my-instance/databases/my-database"ctx:=context.Background()adminClient,err:=database.NewDatabaseAdminClient(ctx)iferr!=nil{returnerr}deferadminClient.Close()// List of DDL statements to be applied to the database.// Alter the sequence to skip range [1000-5000000] for new keys.ddl:=[]string{"ALTER SEQUENCE Seq SET OPTIONS (skip_range_min = 1000, skip_range_max = 5000000)",}op,err:=adminClient.UpdateDatabaseDdl(ctx,&adminpb.UpdateDatabaseDdlRequest{Database:db,Statements:ddl,})iferr!=nil{returnerr}// Wait for the UpdateDatabaseDdl operation to finish.iferr:=op.Wait(ctx);err!=nil{returnfmt.Errorf("waiting for bit reverse sequence skip range to finish failed: %w",err)}fmt.Fprintf(w,"Altered Seq sequence to skip an inclusive range between 1000 and 5000000\n")client,err:=spanner.NewClient(ctx,db)iferr!=nil{returnerr}deferclient.Close()// Inserts records into the Customers table.// The ReadWriteTransaction function returns the commit timestamp and an error.// The commit timestamp is ignored in this case._,err=client.ReadWriteTransaction(ctx,func(ctxcontext.Context,txn*spanner.ReadWriteTransaction)error{stmt:=spanner.Statement{SQL:`INSERT INTO Customers (CustomerName) VALUES ('Lea'), ('Catalina'), ('Smith') THEN RETURN CustomerId`,}iter:=txn.Query(ctx,stmt)deferiter.Stop()for{row,err:=iter.Next()iferr==iterator.Done{break}iferr!=nil{returnerr}varcustomerIdint64iferr:=row.Columns(&customerId);err!=nil{returnerr}fmt.Fprintf(w,"Inserted customer record with CustomerId: %d\n",customerId)}fmt.Fprintf(w,"Number of customer records inserted is: %d\n",iter.RowCount)returnnil})returnerr}

importcom.google.cloud.spanner.DatabaseClient;importcom.google.cloud.spanner.DatabaseId;importcom.google.cloud.spanner.ResultSet;importcom.google.cloud.spanner.Spanner;importcom.google.cloud.spanner.SpannerExceptionFactory;importcom.google.cloud.spanner.SpannerOptions;importcom.google.cloud.spanner.Statement;importcom.google.cloud.spanner.admin.database.v1.DatabaseAdminClient;importcom.google.common.collect.ImmutableList;importcom.google.spanner.admin.database.v1.DatabaseName;importjava.util.Objects;importjava.util.concurrent.ExecutionException;importjava.util.concurrent.TimeUnit;importjava.util.concurrent.TimeoutException;publicclassAlterSequenceSample{staticvoidalterSequence(){// TODO(developer): Replace these variables before running the sample.finalStringprojectId="my-project";finalStringinstanceId="my-instance";finalStringdatabaseId="my-database";alterSequence(projectId,instanceId,databaseId);}staticvoidalterSequence(StringprojectId,StringinstanceId,StringdatabaseId){try(Spannerspanner=SpannerOptions.newBuilder().setProjectId(projectId).build().getService();DatabaseAdminClientdatabaseAdminClient=spanner.createDatabaseAdminClient()){databaseAdminClient.updateDatabaseDdlAsync(DatabaseName.of(projectId,instanceId,databaseId),ImmutableList.of("ALTER SEQUENCE Seq SET OPTIONS "+"(skip_range_min = 1000, skip_range_max = 5000000)")).get(5,TimeUnit.MINUTES);System.out.println("Altered Seq sequence to skip an inclusive range between 1000 and 5000000");finalDatabaseClientdbClient=spanner.getDatabaseClient(DatabaseId.of(projectId,instanceId,databaseId));LonginsertCount=dbClient.readWriteTransaction().run(transaction->{try(ResultSetrs=transaction.executeQuery(Statement.of("INSERT INTO Customers (CustomerName) VALUES "+"('Lea'), ('Catalina'), ('Smith') "+"THEN RETURN CustomerId"))){while(rs.next()){System.out.printf("Inserted customer record with CustomerId: %d\n",rs.getLong(0));}returnObjects.requireNonNull(rs.getStats()).getRowCountExact();}});System.out.printf("Number of customer records inserted is: %d\n",insertCount);}catch(ExecutionExceptione){// If the operation failed during execution, expose the cause.throwSpannerExceptionFactory.asSpannerException(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);}catch(TimeoutExceptione){// If the operation timed out propagate the timeoutthrowSpannerExceptionFactory.propagateTimeout(e);}}}

// Imports the Google Cloud client library.const{Spanner}=require('@google-cloud/spanner');/** * TODO(developer): Uncomment the following lines before running the sample. */// const projectId = 'my-project-id';// const instanceId = 'my-instance';// const databaseId = 'my-database';// Creates a clientconstspanner=newSpanner({projectId:projectId,});asyncfunctionalterSequence(instanceId,databaseId){// Gets a reference to a Cloud Spanner Database Admin Client objectconstdatabaseAdminClient=spanner.getDatabaseAdminClient();constrequest=['ALTER SEQUENCE Seq SET OPTIONS (skip_range_min = 1000, skip_range_max = 5000000)',];try{const[operation]=awaitdatabaseAdminClient.updateDatabaseDdl({database:databaseAdminClient.databasePath(projectId,instanceId,databaseId,),statements:request,});console.log('Waiting for operation to complete...');awaitoperation.promise();console.log('Altered Seq sequence to skip an inclusive range between 1000 and 5000000.',);}catch(err){console.error('ERROR:',err);}// Gets a reference to a Cloud Spanner instance and databaseconstinstance=spanner.instance(instanceId);constdatabase=instance.database(databaseId);database.runTransaction(async(err,transaction)=>{if(err){console.error(err);return;}try{const[rows,stats]=awaittransaction.run({sql:"INSERT INTO Customers (CustomerName) VALUES ('Lea'), ('Catalina'), ('Smith') THEN RETURN CustomerId",});rows.forEach(row=>{console.log(`Inserted customer record with CustomerId:${row.toJSON({wrapNumbers:true}).CustomerId.value          }`,);});constrowCount=Math.floor(stats[stats.rowCount]);console.log(`Number of customer records inserted is:${rowCount}`);awaittransaction.commit();}catch(err){console.error('ERROR:',err);}finally{// Close the database when finished.awaitdatabase.close();}});}awaitalterSequence(instanceId,databaseId);

use Google\Cloud\Spanner\Admin\Database\V1\Client\DatabaseAdminClient;use Google\Cloud\Spanner\Admin\Database\V1\UpdateDatabaseDdlRequest;use Google\Cloud\Spanner\Result;use Google\Cloud\Spanner\SpannerClient;/** * Alters a sequence. * Example: * ``` * alter_sequence($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 alter_sequence(string $projectId, string $instanceId, string $databaseId): void{    $databaseAdminClient = new DatabaseAdminClient();    $spanner = new SpannerClient();    $databaseName = DatabaseAdminClient::databaseName($projectId, $instanceId, $databaseId);    $instance = $spanner->instance($instanceId);    $database = $instance->database($databaseId);    $transaction = $database->transaction();    $statements = [         'ALTER SEQUENCE Seq SET OPTIONS ' .        '(skip_range_min = 1000, skip_range_max = 5000000)'    ];    $request = new UpdateDatabaseDdlRequest([        'database' => $databaseName,        'statements' => $statements    ]);    $operation = $databaseAdminClient->updateDatabaseDdl($request);    print('Waiting for operation to complete...' . PHP_EOL);    $operation->pollUntilComplete();    printf(        'Altered Seq sequence to skip an inclusive range between 1000 and 5000000' .        PHP_EOL    );    $res = $transaction->execute(        'INSERT INTO Customers (CustomerName) VALUES ' .        "('Lea'), ('Catalina'), ('Smith') THEN RETURN CustomerId"    );    $rows = $res->rows(Result::RETURN_ASSOCIATIVE);    foreach ($rows as $row) {        printf('Inserted customer record with CustomerId: %d %s',            $row['CustomerId'],            PHP_EOL        );    }    $transaction->commit();    printf(sprintf(        'Number of customer records inserted is: %d %s',        $res->stats()['rowCountExact'],        PHP_EOL    ));}

defalter_sequence(instance_id,database_id):"""Alters the Sequence and insert data"""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 SEQUENCE Seq SET OPTIONS (skip_range_min = 1000, skip_range_max = 5000000)",],)operation=database_admin_api.update_database_ddl(request)print("Waiting for operation to complete...")operation.result(OPERATION_TIMEOUT_SECONDS)print("Altered Seq sequence to skip an inclusive range between 1000 and 5000000 on database{} on instance{}".format(database_id,instance_id))definsert_customers(transaction):results=transaction.execute_sql("INSERT INTO Customers (CustomerName) VALUES ""('Lea'), ""('Cataline'), ""('Smith') ""THEN RETURN CustomerId")forresultinresults:print("Inserted customer record with Customer Id:{}".format(*result))print("Number of customer records inserted is{}".format(results.stats.row_count_exact))instance=spanner_client.instance(instance_id)database=instance.database(database_id)database.run_in_transaction(insert_customers)

require"google/cloud/spanner"### This is a snippet for showcasing how to alter a sequence.## @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_alter_sequenceproject_id:,instance_id:,database_id:db_admin_client=Google::Cloud::Spanner::Admin::Database.database_admindatabase_path=db_admin_client.database_pathproject:project_id,instance:instance_id,database:database_idjob=db_admin_client.update_database_ddldatabase:database_path,statements:["ALTER SEQUENCE Seq SET OPTIONS (skip_range_min = 1000, skip_range_max = 5000000)"]puts"Waiting for operation to complete..."job.wait_until_done!puts"Altered Seq sequence to skip an inclusive range between 1000 and 5000000"end

voidAlterSequence(google::cloud::spanner_admin::DatabaseAdminClientadmin_client,google::cloud::spanner::Databaseconst&database,google::cloud::spanner::Clientclient){std::vector<std::string>statements;statements.emplace_back(R"""(      ALTER SEQUENCE Seq SKIP RANGE 1000 5000000  )""");autometadata=admin_client.UpdateDatabaseDdl(database.FullName(),std::move(statements)).get();if(!metadata)throwstd::move(metadata).status();std::cout <<"Altered `Seq` sequence"            <<"  to skip an inclusive range between 1000 and 5000000,"            <<" new DDL:\n"            <<metadata->DebugString();autocommit=client.Commit([&client](google::cloud::spanner::Transactiontxn)->google::cloud::StatusOr<google::cloud::spanner::Mutations>{autosql=google::cloud::spanner::SqlStatement(R"""(            INSERT INTO Customers (CustomerName)                VALUES ('Lea'),                       ('Catalina'),                       ('Smith')                RETURNING CustomerId        )""");usingRowType=std::tuple<std::int64_t>;autorows=client.ExecuteQuery(std::move(txn),std::move(sql));//Note:Thismutatormightbere-run,oritseffectsdiscarded,so//changingnon-transactionalstate(e.g.,byproducingoutput)is,//ingeneral,notsomethingtobeimitated.for(auto&row:google::cloud::spanner::StreamOf<RowType>(rows)){if(!row)returnstd::move(row).status();std::cout <<"Inserted customer record with CustomerId: "                    <<std::get<0>(*row) <<"\n";}std::cout <<"Number of customer records inserted is: "                  <<rows.RowsModified() <<"\n";returngoogle::cloud::spanner::Mutations{};});if(!commit)throwstd::move(commit).status();}

usingGoogle.Cloud.Spanner.Admin.Database.V1;usingGoogle.Cloud.Spanner.Common.V1;usingGoogle.Cloud.Spanner.Data;usingGoogle.LongRunning;usingSystem;usingSystem.Collections.Generic;usingSystem.Threading.Tasks;publicclassAlterSequencePostgresqlSample{publicasyncTask<List<long>>AlterSequencePostgresqlSampleAsync(stringprojectId,stringinstanceId,stringdatabaseId){DatabaseAdminClientdatabaseAdminClient=DatabaseAdminClient.Create();DatabaseNamedatabaseName=DatabaseName.FromProjectInstanceDatabase(projectId,instanceId,databaseId);string[]statements={"ALTER SEQUENCE Seq SKIP RANGE 1000 5000000;"};varoperation=awaitdatabaseAdminClient.UpdateDatabaseDdlAsync(databaseName,statements);varcompletedResponse=awaitoperation.PollUntilCompletedAsync();if(completedResponse.IsFaulted){throwcompletedResponse.Exception;}Console.WriteLine("Altered Seq sequence to skip an inclusive range between 1000 and 5000000");stringconnectionString=$"Data Source=projects/{projectId}/instances/{instanceId}/databases/{databaseId}";usingvarconnection=newSpannerConnection(connectionString);awaitconnection.OpenAsync();usingvarcmd=connection.CreateDmlCommand(@"INSERT INTO Customers (CustomerName) VALUES ('Alice'), ('David'), ('Marc') RETURNING CustomerId");varreader=awaitcmd.ExecuteReaderAsync();varcustomerIds=newList<long>();while(awaitreader.ReadAsync()){varcustomerId=reader.GetFieldValue<long>("customerid");Console.WriteLine($"Inserted customer record with CustomerId: {customerId}");customerIds.Add(customerId);}Console.WriteLine($"Number of customer records inserted is: {customerIds.Count}");returncustomerIds;}}