voidCopyBackup(google::cloud::spanner_admin::DatabaseAdminClientclient,std::stringconst&src_project_id,std::stringconst&src_instance_id,std::stringconst&src_backup_id,std::stringconst&dst_project_id,std::stringconst&dst_instance_id,std::stringconst&dst_backup_id,google::cloud::spanner::Timestampexpire_time){google::cloud::spanner::Backupsource(google::cloud::spanner::Instance(src_project_id,src_instance_id),src_backup_id);google::cloud::spanner::Instancedst_in(dst_project_id,dst_instance_id);autocopy_backup=client.CopyBackup(dst_in.FullName(),dst_backup_id,source.FullName(),expire_time.get<google::protobuf::Timestamp>().value()).get();if(!copy_backup)throwstd::move(copy_backup).status();std::cout <<"Copy Backup " <<copy_backup->name()//            <<" of " <<source.FullName()//            <<" of size " <<copy_backup->size_bytes() <<" bytes as of "            <<google::cloud::spanner::MakeTimestamp(copy_backup->version_time()).value()            <<" was created at "            <<google::cloud::spanner::MakeTimestamp(copy_backup->create_time()).value()            <<".\n";}

usingGoogle.Api.Gax;usingGoogle.Cloud.Spanner.Admin.Database.V1;usingGoogle.Cloud.Spanner.Common.V1;usingGoogle.Protobuf.WellKnownTypes;usingSystem;publicclassCopyBackupSample{publicBackupCopyBackup(stringsourceProjectId,stringsourceInstanceId,stringsourceBackupId,stringtargetProjectId,stringtargetInstanceId,stringtargetBackupId,DateTimeOffsetexpireTime){DatabaseAdminClientdatabaseAdminClient=DatabaseAdminClient.Create();varrequest=newCopyBackupRequest{SourceBackupAsBackupName=newBackupName(sourceProjectId,sourceInstanceId,sourceBackupId),ParentAsInstanceName=newInstanceName(targetProjectId,targetInstanceId),BackupId=targetBackupId,ExpireTime=Timestamp.FromDateTimeOffset(expireTime)};varresponse=databaseAdminClient.CopyBackup(request);Console.WriteLine("Waiting for the operation to finish.");varcompletedResponse=response.PollUntilCompleted(newPollSettings(Expiration.FromTimeout(TimeSpan.FromMinutes(15)),TimeSpan.FromMinutes(2)));if(completedResponse.IsFaulted){Console.WriteLine($"Error while creating backup: {completedResponse.Exception}");throwcompletedResponse.Exception;}Backupbackup=completedResponse.Result;Console.WriteLine($"Backup created successfully.");Console.WriteLine($"Backup with Id {sourceBackupId} has been copied from {sourceProjectId}/{sourceInstanceId} to {targetProjectId}/{targetInstanceId} Backup {targetBackupId}");Console.WriteLine($"Backup {backup.Name} of size {backup.SizeBytes} bytes was created at {backup.CreateTime} from {backup.Database} and is in state {backup.State} and has version time {backup.VersionTime}");returnbackup;}}

import("context""fmt""io""time"database"cloud.google.com/go/spanner/admin/database/apiv1"adminpb"cloud.google.com/go/spanner/admin/database/apiv1/databasepb"pbt"github.com/golang/protobuf/ptypes/timestamp")// copyBackup copies an existing backup to a given instance in same or different region, or in same or different project.funccopyBackup(wio.Writer,instancePathstring,copyBackupIdstring,sourceBackupPathstring)error{// instancePath := "projects/my-project/instances/my-instance"// copyBackupId := "my-copy-backup"// sourceBackupPath := "projects/my-project/instances/my-instance/backups/my-source-backup"// Add timeout to context.ctx,cancel:=context.WithTimeout(context.Background(),time.Hour)defercancel()// Instantiate database admin client.adminClient,err:=database.NewDatabaseAdminClient(ctx)iferr!=nil{returnfmt.Errorf("database.NewDatabaseAdminClient: %w",err)}deferadminClient.Close()expireTime:=time.Now().AddDate(0,0,14)// Instantiate the request for performing copy backup operation.copyBackupReq:=adminpb.CopyBackupRequest{Parent:instancePath,BackupId:copyBackupId,SourceBackup:sourceBackupPath,ExpireTime:&pbt.Timestamp{Seconds:expireTime.Unix(),Nanos:int32(expireTime.Nanosecond())},}// Start copying the backup.copyBackupOp,err:=adminClient.CopyBackup(ctx,&copyBackupReq)iferr!=nil{returnfmt.Errorf("adminClient.CopyBackup: %w",err)}// Wait for copy backup operation to complete.fmt.Fprintf(w,"Waiting for backup copy %s/backups/%s to complete...\n",instancePath,copyBackupId)copyBackup,err:=copyBackupOp.Wait(ctx)iferr!=nil{returnfmt.Errorf("copyBackup.Wait: %w",err)}// Check if long-running copyBackup operation is completed.if!copyBackupOp.Done(){returnfmt.Errorf("backup %v could not be copied to %v",sourceBackupPath,copyBackupId)}// Get the name, create time, version time and backup size.copyBackupCreateTime:=time.Unix(copyBackup.CreateTime.Seconds,int64(copyBackup.CreateTime.Nanos))copyBackupVersionTime:=time.Unix(copyBackup.VersionTime.Seconds,int64(copyBackup.VersionTime.Nanos))fmt.Fprintf(w,"Backup %s of size %d bytes was created at %s with version time %s\n",copyBackup.Name,copyBackup.SizeBytes,copyBackupCreateTime.Format(time.RFC3339),copyBackupVersionTime.Format(time.RFC3339))returnnil}

importcom.google.cloud.Timestamp;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.Backup;importcom.google.spanner.admin.database.v1.BackupName;importcom.google.spanner.admin.database.v1.InstanceName;importjava.time.Instant;importjava.time.OffsetDateTime;importjava.time.ZoneId;importjava.util.concurrent.ExecutionException;importjava.util.concurrent.TimeUnit;publicclassCopyBackupSample{staticvoidcopyBackup(){// TODO(developer): Replace these variables before running the sample.StringprojectId="my-project";StringinstanceId="my-instance";StringsourceBackupId="my-backup";StringdestinationBackupId="my-destination-backup";try(Spannerspanner=SpannerOptions.newBuilder().setProjectId(projectId).build().getService();DatabaseAdminClientdatabaseAdminClient=spanner.createDatabaseAdminClient()){copyBackup(databaseAdminClient,projectId,instanceId,sourceBackupId,destinationBackupId);}}staticvoidcopyBackup(DatabaseAdminClientdatabaseAdminClient,StringprojectId,StringinstanceId,StringsourceBackupId,StringdestinationBackupId){TimestampexpireTime=Timestamp.ofTimeMicroseconds(TimeUnit.MICROSECONDS.convert(System.currentTimeMillis()+TimeUnit.DAYS.toMillis(14),TimeUnit.MILLISECONDS));// Initiate the request which returns an OperationFuture.System.out.println("Copying backup ["+destinationBackupId+"]...");BackupdestinationBackup;try{// Creates a copy of an existing backup.// Wait for the backup operation to complete.destinationBackup=databaseAdminClient.copyBackupAsync(InstanceName.of(projectId,instanceId),destinationBackupId,BackupName.of(projectId,instanceId,sourceBackupId),expireTime.toProto()).get();System.out.println("Copied backup ["+destinationBackup.getName()+"]");}catch(ExecutionExceptione){throw(SpannerException)e.getCause();}catch(InterruptedExceptione){throwSpannerExceptionFactory.propagateInterrupt(e);}// Load the metadata of the new backup from the server.destinationBackup=databaseAdminClient.getBackup(destinationBackup.getName());System.out.println(String.format("Backup %s of size %d bytes was copied at %s for version of database at %s",destinationBackup.getName(),destinationBackup.getSizeBytes(),OffsetDateTime.ofInstant(Instant.ofEpochSecond(destinationBackup.getCreateTime().getSeconds(),destinationBackup.getCreateTime().getNanos()),ZoneId.systemDefault()),OffsetDateTime.ofInstant(Instant.ofEpochSecond(destinationBackup.getVersionTime().getSeconds(),destinationBackup.getVersionTime().getNanos()),ZoneId.systemDefault())));}}

/** * TODO(developer): Uncomment these variables before running the sample. */// const instanceId = 'my-instance';// const backupId = 'my-backup',// const sourceBackupPath = 'projects/my-project-id/instances/my-source-instance/backups/my-source-backup',// const projectId = 'my-project-id';// Imports the Google Cloud Spanner client libraryconst{Spanner}=require('@google-cloud/spanner');const{PreciseDate}=require('@google-cloud/precise-date');// Creates a clientconstspanner=newSpanner({projectId:projectId,});// Gets a reference to a Cloud Spanner Database Admin Client objectconstdatabaseAdminClient=spanner.getDatabaseAdminClient();asyncfunctionspannerCopyBackup(){// Expire copy backup 14 days in the futureconstexpireTime=Spanner.timestamp(Date.now()+1000*60*60*24*14,).toStruct();// Copy the source backuptry{console.log(`Creating copy of the source backup${sourceBackupPath}.`);const[operation]=awaitdatabaseAdminClient.copyBackup({parent:databaseAdminClient.instancePath(projectId,instanceId),sourceBackup:sourceBackupPath,backupId:backupId,expireTime:expireTime,});console.log(`Waiting for backup copy${databaseAdminClient.backupPath(projectId,instanceId,backupId,)} to complete...`,);awaitoperation.promise();// Verify the copy backup is readyconst[copyBackup]=awaitdatabaseAdminClient.getBackup({name:databaseAdminClient.backupPath(projectId,instanceId,backupId),});if(copyBackup.state==='READY'){console.log(`Backup copy${copyBackup.name} of size `+`${copyBackup.sizeBytes} bytes was created at `+`${newPreciseDate(copyBackup.createTime).toISOString()} `+'with version time '+`${newPreciseDate(copyBackup.versionTime).toISOString()}`,);}else{console.error('ERROR: Copy of backup is not ready.');}}catch(err){console.error('ERROR:',err);}}spannerCopyBackup();

use Google\Cloud\Spanner\Admin\Database\V1\CopyBackupRequest;use Google\Cloud\Spanner\Admin\Database\V1\Client\DatabaseAdminClient;use Google\Protobuf\Timestamp;/** * Create a copy backup from another source backup. * Example: * ``` * copy_backup($projectId, $destInstanceId, $destBackupId, $sourceInstanceId, $sourceBackupId); * ``` * * @param string $projectId The Google Cloud project ID. * @param string $destInstanceId The Spanner instance ID where the copy backup will reside. * @param string $destBackupId The Spanner backup ID of the new backup to be created. * @param string $sourceInstanceId The Spanner instance ID of the source backup. * @param string $sourceBackupId The Spanner backup ID of the source. */function copy_backup(    string $projectId,    string $destInstanceId,    string $destBackupId,    string $sourceInstanceId,    string $sourceBackupId): void {    $databaseAdminClient = new DatabaseAdminClient();    $destInstanceFullName = DatabaseAdminClient::instanceName($projectId, $destInstanceId);    $expireTime = new Timestamp();    $expireTime->setSeconds((new \DateTime('+8 hours'))->getTimestamp());    $sourceBackupFullName = DatabaseAdminClient::backupName($projectId, $sourceInstanceId, $sourceBackupId);    $request = new CopyBackupRequest([        'source_backup' => $sourceBackupFullName,        'parent' => $destInstanceFullName,        'backup_id' => $destBackupId,        'expire_time' => $expireTime    ]);    $operationResponse = $databaseAdminClient->copyBackup($request);    $operationResponse->pollUntilComplete();    if ($operationResponse->operationSucceeded()) {        $destBackupInfo = $operationResponse->getResult();        printf(            'Backup %s of size %d bytes was copied at %d from the source backup %s' . PHP_EOL,            basename($destBackupInfo->getName()),            $destBackupInfo->getSizeBytes(),            $destBackupInfo->getCreateTime()->getSeconds(),            $sourceBackupId        );        printf('Version time of the copied backup: %d' . PHP_EOL, $destBackupInfo->getVersionTime()->getSeconds());    } else {        $error = $operationResponse->getError();        printf('Backup not created due to error: %s.' . PHP_EOL, $error->getMessage());    }}

defcopy_backup(instance_id,backup_id,source_backup_path):"""Copies a backup."""fromgoogle.cloud.spanner_admin_database_v1.typesimportbackupasbackup_pbspanner_client=spanner.Client()database_admin_api=spanner_client.database_admin_api# Create a backup object and wait for copy backup operation to complete.expire_time=datetime.utcnow()+timedelta(days=14)request=backup_pb.CopyBackupRequest(parent=database_admin_api.instance_path(spanner_client.project,instance_id),backup_id=backup_id,source_backup=source_backup_path,expire_time=expire_time,)operation=database_admin_api.copy_backup(request)# Wait for backup operation to complete.copy_backup=operation.result(2100)# Verify that the copy backup is ready.assertcopy_backup.state==backup_pb.Backup.State.READYprint("Backup{} of size{} bytes was created at{} with version time{}".format(copy_backup.name,copy_backup.size_bytes,copy_backup.create_time,copy_backup.version_time,))

# project_id  = "Your Google Cloud project ID"# instance_id = "The ID of the destination instance that will contain the backup copy"# backup_id = "The ID of the backup copy"# source_backup = "The source backup to be copied"require"google/cloud/spanner"require"google/cloud/spanner/admin/database"database_admin_client=Google::Cloud::Spanner::Admin::Database.database_admininstance_path=database_admin_client.instance_pathproject:project_id,instance:instance_idbackup_path=database_admin_client.backup_pathproject:project_id,instance:instance_id,backup:backup_idsource_backup=database_admin_client.backup_pathproject:project_id,instance:instance_id,backup:source_backup_idexpire_time=Time.now+(14*24*3600)# 14 days from nowjob=database_admin_client.copy_backupparent:instance_path,backup_id:backup_id,source_backup:source_backup,expire_time:expire_timeputs"Copy backup operation in progress"job.wait_until_done!backup=database_admin_client.get_backupname:backup_pathputs"Backup#{backup_id} of size#{backup.size_bytes} bytes was copied at#{backup.create_time} from#{source_backup} for version#{backup.version_time}"

voidListBackupOperations(google::cloud::spanner_admin::DatabaseAdminClientclient,std::stringconst&project_id,std::stringconst&instance_id,std::stringconst&database_id,std::stringconst&backup_id){google::cloud::spanner::Instancein(project_id,instance_id);google::cloud::spanner::Databasedatabase(in,database_id);google::cloud::spanner::Backupbackup(in,backup_id);google::spanner::admin::database::v1::ListBackupOperationsRequestrequest;request.set_parent(in.FullName());request.set_filter(std::string("(metadata.@type=type.googleapis.com/")+"google.spanner.admin.database.v1.CreateBackupMetadata)"+" AND (metadata.database="+database.FullName()+")");for(auto&operation:client.ListBackupOperations(request)){if(!operation)throwstd::move(operation).status();google::spanner::admin::database::v1::CreateBackupMetadatametadata;operation->metadata().UnpackTo(&metadata);std::cout <<"Backup " <<metadata.name() <<" of database "              <<metadata.database() <<" is "              <<metadata.progress().progress_percent() <<"% complete.\n";}request.set_filter(std::string("(metadata.@type:type.googleapis.com/")+"google.spanner.admin.database.v1.CopyBackupMetadata)"+" AND (metadata.source_backup="+backup.FullName()+")");for(auto&operation:client.ListBackupOperations(request)){if(!operation)throwstd::move(operation).status();google::spanner::admin::database::v1::CopyBackupMetadatametadata;operation->metadata().UnpackTo(&metadata);std::cout <<"Copy " <<metadata.name() <<" of backup "              <<metadata.source_backup() <<" is "              <<metadata.progress().progress_percent() <<"% complete.\n";}}

usingGoogle.Cloud.Spanner.Admin.Database.V1;usingGoogle.Cloud.Spanner.Common.V1;usingGoogle.LongRunning;usingSystem;usingSystem.Collections.Generic;publicclassListBackupOperationsSample{publicIEnumerable<Operation>ListBackupOperations(stringprojectId,stringinstanceId,stringdatabaseId){// Create the DatabaseAdminClient instance.DatabaseAdminClientdatabaseAdminClient=DatabaseAdminClient.Create();varfilter=$"(metadata.@type:type.googleapis.com/google.spanner.admin.database.v1.CreateBackupMetadata) AND (metadata.database:{databaseId})";ListBackupOperationsRequestrequest=newListBackupOperationsRequest{ParentAsInstanceName=InstanceName.FromProjectInstance(projectId,instanceId),Filter=filter};// List the create backup operations on the database.varbackupOperations=databaseAdminClient.ListBackupOperations(request);foreach(varoperationinbackupOperations){CreateBackupMetadatametadata=operation.Metadata.Unpack<CreateBackupMetadata>();Console.WriteLine($"Backup {metadata.Name} on "+$"database {metadata.Database} is "+$"{metadata.Progress.ProgressPercent}% complete");}returnbackupOperations;}}

usingGoogle.Cloud.Spanner.Admin.Database.V1;usingGoogle.Cloud.Spanner.Common.V1;usingGoogle.LongRunning;usingSystem;usingSystem.Collections.Generic;publicclassListCopyBackupOperationsSample{publicIEnumerable<Operation>ListCopyBackupOperations(stringprojectId,stringinstanceId,stringdatabaseId,stringbackupId){// Create the DatabaseAdminClient instance.DatabaseAdminClientdatabaseAdminClient=DatabaseAdminClient.Create();varfilter=$"(metadata.@type:type.googleapis.com/google.spanner.admin.database.v1.CopyBackupMetadata) AND (metadata.source_backup:{backupId})";ListBackupOperationsRequestrequest=newListBackupOperationsRequest{ParentAsInstanceName=InstanceName.FromProjectInstance(projectId,instanceId),Filter=filter};// List the copy backup operations on the database.varbackupOperations=databaseAdminClient.ListBackupOperations(request);foreach(varoperationinbackupOperations){CopyBackupMetadatametadata=operation.Metadata.Unpack<CopyBackupMetadata>();Console.WriteLine($"Backup {metadata.Name} from source backup {metadata.SourceBackup} is {metadata.Progress.ProgressPercent}% complete");}returnbackupOperations;}}

import("context""fmt""io""regexp"database"cloud.google.com/go/spanner/admin/database/apiv1"adminpb"cloud.google.com/go/spanner/admin/database/apiv1/databasepb""github.com/golang/protobuf/ptypes""google.golang.org/api/iterator")// listBackupOperations lists the backup operations that are pending or have completed/failed/cancelled within the last 7 days.funclistBackupOperations(wio.Writer,dbstring,backupIdstring)error{// db := "projects/my-project/instances/my-instance/databases/my-database"// backupID := "my-backup"ctx:=context.Background()adminClient,err:=database.NewDatabaseAdminClient(ctx)iferr!=nil{returnerr}deferadminClient.Close()matches:=regexp.MustCompile("^(.*)/databases/(.*)$").FindStringSubmatch(db)ifmatches==nil||len(matches)!=3{returnfmt.Errorf("Invalid database id %s",db)}instanceName:=matches[1]// List the CreateBackup operations.filter:=fmt.Sprintf("(metadata.@type:type.googleapis.com/google.spanner.admin.database.v1.CreateBackupMetadata) AND (metadata.database:%s)",db)iter:=adminClient.ListBackupOperations(ctx,&adminpb.ListBackupOperationsRequest{Parent:instanceName,Filter:filter,})for{resp,err:=iter.Next()iferr==iterator.Done{break}iferr!=nil{returnerr}metadata:=&adminpb.CreateBackupMetadata{}iferr:=ptypes.UnmarshalAny(resp.Metadata,metadata);err!=nil{returnerr}fmt.Fprintf(w,"Backup %s on database %s is %d%% complete.\n",metadata.Name,metadata.Database,metadata.Progress.ProgressPercent,)}// List the CopyBackup operations.filter=fmt.Sprintf("(metadata.@type:type.googleapis.com/google.spanner.admin.database.v1.CopyBackupMetadata) AND (metadata.source_backup:%s)",backupId)iter=adminClient.ListBackupOperations(ctx,&adminpb.ListBackupOperationsRequest{Parent:instanceName,Filter:filter,})for{resp,err:=iter.Next()iferr==iterator.Done{break}iferr!=nil{returnerr}metadata:=&adminpb.CopyBackupMetadata{}iferr:=ptypes.UnmarshalAny(resp.Metadata,metadata);err!=nil{returnerr}fmt.Fprintf(w,"Backup %s copied from %s is %d%% complete.\n",metadata.Name,metadata.SourceBackup,metadata.Progress.ProgressPercent,)}returnnil}

staticvoidlistBackupOperations(DatabaseAdminClientdatabaseAdminClient,StringprojectId,StringinstanceId,StringdatabaseId,StringbackupId){InstanceNameinstanceName=InstanceName.of(projectId,instanceId);// Get 'CreateBackup' operations for the sample database.Stringfilter=String.format("(metadata.@type:type.googleapis.com/"+"google.spanner.admin.database.v1.CreateBackupMetadata) "+"AND (metadata.database:%s)",DatabaseName.of(projectId,instanceId,databaseId).toString());ListBackupOperationsRequestlistBackupOperationsRequest=ListBackupOperationsRequest.newBuilder().setParent(instanceName.toString()).setFilter(filter).build();ListBackupOperationsPagedResponsecreateBackupOperations=databaseAdminClient.listBackupOperations(listBackupOperationsRequest);System.out.println("Create Backup Operations:");for(Operationop:createBackupOperations.iterateAll()){try{CreateBackupMetadatametadata=op.getMetadata().unpack(CreateBackupMetadata.class);System.out.println(String.format("Backup %s on database %s pending: %d%% complete",metadata.getName(),metadata.getDatabase(),metadata.getProgress().getProgressPercent()));}catch(InvalidProtocolBufferExceptione){// The returned operation does not contain CreateBackupMetadata.System.err.println(e.getMessage());}}// Get copy backup operations for the sample database.filter=String.format("(metadata.@type:type.googleapis.com/"+"google.spanner.admin.database.v1.CopyBackupMetadata) "+"AND (metadata.source_backup:%s)",BackupName.of(projectId,instanceId,backupId).toString());listBackupOperationsRequest=ListBackupOperationsRequest.newBuilder().setParent(instanceName.toString()).setFilter(filter).build();ListBackupOperationsPagedResponsecopyBackupOperations=databaseAdminClient.listBackupOperations(listBackupOperationsRequest);System.out.println("Copy Backup Operations:");for(Operationop:copyBackupOperations.iterateAll()){try{CopyBackupMetadatacopyBackupMetadata=op.getMetadata().unpack(CopyBackupMetadata.class);System.out.println(String.format("Copy Backup %s on backup %s pending: %d%% complete",copyBackupMetadata.getName(),copyBackupMetadata.getSourceBackup(),copyBackupMetadata.getProgress().getProgressPercent()));}catch(InvalidProtocolBufferExceptione){// The returned operation does not contain CopyBackupMetadata.System.err.println(e.getMessage());}}}

// Imports the Google Cloud client libraryconst{Spanner,protos}=require('@google-cloud/spanner');/** * TODO(developer): Uncomment the following lines before running the sample. */// const projectId = 'my-project-id';// const databaseId = 'my-database';// const backupId = 'my-backup';// const instanceId = 'my-instance';// Creates a clientconstspanner=newSpanner({projectId:projectId,});// Gets a reference to a Cloud Spanner Database Admin Client objectconstdatabaseAdminClient=spanner.getDatabaseAdminClient();// List create backup operationstry{const[backupOperations]=awaitdatabaseAdminClient.listBackupOperations({parent:databaseAdminClient.instancePath(projectId,instanceId),filter:'(metadata.@type:type.googleapis.com/google.spanner.admin.database.v1.CreateBackupMetadata) '+`AND (metadata.database:${databaseId})`,});console.log('Create Backup Operations:');backupOperations.forEach(backupOperation=>{constmetadata=protos.google.spanner.admin.database.v1.CreateBackupMetadata.decode(backupOperation.metadata.value,);console.log(`Backup${metadata.name} on database${metadata.database} is `+`${metadata.progress.progressPercent}% complete.`,);});}catch(err){console.error('ERROR:',err);}// List copy backup operationstry{console.log('(metadata.@type:type.googleapis.com/google.spanner.admin.database.v1.CopyBackupMetadata) '+`AND (metadata.source_backup:${backupId})`,);const[backupOperations]=awaitdatabaseAdminClient.listBackupOperations({parent:databaseAdminClient.instancePath(projectId,instanceId),filter:'(metadata.@type:type.googleapis.com/google.spanner.admin.database.v1.CopyBackupMetadata) '+`AND (metadata.source_backup:${backupId})`,});console.log('Copy Backup Operations:');backupOperations.forEach(backupOperation=>{constmetadata=protos.google.spanner.admin.database.v1.CopyBackupMetadata.decode(backupOperation.metadata.value,);console.log(`Backup${metadata.name} copied from source backup${metadata.sourceBackup} is `+`${metadata.progress.progressPercent}% complete.`,);});}catch(err){console.error('ERROR:',err);}

use Google\Cloud\Spanner\Admin\Database\V1\Client\DatabaseAdminClient;use Google\Cloud\Spanner\Admin\Database\V1\CreateBackupMetadata;use Google\Cloud\Spanner\Admin\Database\V1\CopyBackupMetadata;use Google\Cloud\Spanner\Admin\Database\V1\ListBackupOperationsRequest;/** * List all create backup operations in an instance. * Optionally passing the backupId will also list the * copy backup operations on the backup. * * @param string $projectId The Google Cloud project ID. * @param string $instanceId The Spanner instance ID. * @param string $databaseId The Spanner database ID. * @param string $backupId The Spanner backup ID whose copy operations need to be listed. */function list_backup_operations(    string $projectId,    string $instanceId,    string $databaseId,    string $backupId): void {    $databaseAdminClient = new DatabaseAdminClient();    $parent = DatabaseAdminClient::instanceName($projectId, $instanceId);    // List the CreateBackup operations.    $filterCreateBackup = '(metadata.@type:type.googleapis.com/' .        'google.spanner.admin.database.v1.CreateBackupMetadata) AND ' . "(metadata.database:$databaseId)";    // See https://cloud.google.com/spanner/docs/reference/rpc/google.spanner.admin.database.v1#listbackupoperationsrequest    // for the possible filter values    $filterCopyBackup = sprintf('(metadata.@type:type.googleapis.com/' .        'google.spanner.admin.database.v1.CopyBackupMetadata) AND ' . "(metadata.source_backup:$backupId)");    $operations = $databaseAdminClient->listBackupOperations(        new ListBackupOperationsRequest([            'parent' => $parent,            'filter' => $filterCreateBackup        ])    );    foreach ($operations->iterateAllElements() as $operation) {        $obj = new CreateBackupMetadata();        $meta = $operation->getMetadata()->unpack($obj);        $backupName = basename($meta->getName());        $dbName = basename($meta->getDatabase());        $progress = $meta->getProgress()->getProgressPercent();        printf('Backup %s on database %s is %d%% complete.' . PHP_EOL, $backupName, $dbName, $progress);    }    $operations = $databaseAdminClient->listBackupOperations(        new ListBackupOperationsRequest([            'parent' => $parent,            'filter' => $filterCopyBackup        ])    );    foreach ($operations->iterateAllElements() as $operation) {        $obj = new CopyBackupMetadata();        $meta = $operation->getMetadata()->unpack($obj);        $backupName = basename($meta->getName());        $progress = $meta->getProgress()->getProgressPercent();        printf('Copy Backup %s on source backup %s is %d%% complete.' . PHP_EOL, $backupName, $backupId, $progress);    }}

deflist_backup_operations(instance_id,database_id,backup_id):fromgoogle.cloud.spanner_admin_database_v1.typesimportbackupasbackup_pbspanner_client=spanner.Client()database_admin_api=spanner_client.database_admin_api# List the CreateBackup operations.filter_=("(metadata.@type:type.googleapis.com/""google.spanner.admin.database.v1.CreateBackupMetadata) ""AND (metadata.database:{})").format(database_id)request=backup_pb.ListBackupOperationsRequest(parent=database_admin_api.instance_path(spanner_client.project,instance_id),filter=filter_,)operations=database_admin_api.list_backup_operations(request)foropinoperations:metadata=protobuf_helpers.from_any_pb(backup_pb.CreateBackupMetadata,op.metadata)print("Backup{} on database{}:{}% complete.".format(metadata.name,metadata.database,metadata.progress.progress_percent))# List the CopyBackup operations.filter_=("(metadata.@type:type.googleapis.com/google.spanner.admin.database.v1.CopyBackupMetadata) ""AND (metadata.source_backup:{})").format(backup_id)request=backup_pb.ListBackupOperationsRequest(parent=database_admin_api.instance_path(spanner_client.project,instance_id),filter=filter_,)operations=database_admin_api.list_backup_operations(request)foropinoperations:metadata=protobuf_helpers.from_any_pb(backup_pb.CopyBackupMetadata,op.metadata)print("Backup{} on source backup{}:{}% complete.".format(metadata.name,metadata.source_backup,metadata.progress.progress_percent,))

# 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"database_admin_client=Google::Cloud::Spanner::Admin::Database.database_admininstance_path=database_admin_client.instance_pathproject:project_id,instance:instance_idjobs=database_admin_client.list_backup_operationsparent:instance_path,filter:"metadata.@type:type.googleapis.com/google.spanner.admin.database.v1.CreateBackupMetadata"jobs.eachdo|job|ifjob.error?putsjob.errorelseputs"Backup#{job.results.name} on database#{database_id} is#{job.metadata.progress.progress_percent}% complete"endend

# project_id  = "Your Google Cloud project ID"# instance_id = "Your Spanner instance ID"# backup_id = "You Spanner backup ID"require"google/cloud/spanner"require"google/cloud/spanner/admin/database"database_admin_client=Google::Cloud::Spanner::Admin::Database.database_admininstance_path=database_admin_client.instance_pathproject:project_id,instance:instance_idfilter="(metadata.@type:type.googleapis.com/google.spanner.admin.database.v1.CopyBackupMetadata) AND (metadata.source_backup:#{backup_id})"jobs=database_admin_client.list_backup_operationsparent:instance_path,filter:filterjobs.eachdo|job|ifjob.error?putsjob.errorelseputs"Backup#{job.results.name} on source backup#{backup_id} is#{job.metadata.progress.progress_percent}% complete"endend

voidCreateBackupAndCancel(google::cloud::spanner_admin::DatabaseAdminClientclient,std::stringconst&project_id,std::stringconst&instance_id,std::stringconst&database_id,std::stringconst&backup_id,google::cloud::spanner::Timestampexpire_time){google::cloud::spanner::Databasedatabase(project_id,instance_id,database_id);google::spanner::admin::database::v1::CreateBackupRequestrequest;request.set_parent(database.instance().FullName());request.set_backup_id(backup_id);request.mutable_backup()->set_database(database.FullName());*request.mutable_backup()->mutable_expire_time()=expire_time.get<google::protobuf::Timestamp>().value();autof=client.CreateBackup(request);f.cancel();autobackup=f.get();if(backup){autostatus=client.DeleteBackup(backup->name());if(!status.ok())throwstd::move(status);std::cout <<"Backup " <<backup->name() <<" was deleted.\n";}else{std::cout <<"CreateBackup operation was cancelled with the message '"              <<backup.status().message() <<"'.\n";}}

usingGoogle.Cloud.Spanner.Admin.Database.V1;usingGoogle.Cloud.Spanner.Common.V1;usingGoogle.LongRunning;usingGoogle.Protobuf.WellKnownTypes;usingSystem;publicclassCancelBackupOperationSample{publicOperation<Backup,CreateBackupMetadata>CancelBackupOperation(stringprojectId,stringinstanceId,stringdatabaseId,stringbackupId){// Create the DatabaseAdminClient instance.DatabaseAdminClientdatabaseAdminClient=DatabaseAdminClient.Create();// Initialize backup request parameters.Backupbackup=newBackup{DatabaseAsDatabaseName=DatabaseName.FromProjectInstanceDatabase(projectId,instanceId,databaseId),ExpireTime=DateTime.UtcNow.AddDays(14).ToTimestamp()};InstanceNameparentAsInstanceName=InstanceName.FromProjectInstance(projectId,instanceId);// Make the CreateBackup request.Operation<Backup,CreateBackupMetadata>operation=databaseAdminClient.CreateBackup(parentAsInstanceName,backup,backupId);// Cancel the operation.operation.Cancel();// Poll until the long-running operation is completed in case the backup was// created before the operation was cancelled.Console.WriteLine("Waiting for the operation to finish.");Operation<Backup,CreateBackupMetadata>completedOperation=operation.PollUntilCompleted();if(completedOperation.IsFaulted){Console.WriteLine($"Create backup operation cancelled: {operation.Name}");}else{Console.WriteLine("The backup was created before the operation was cancelled. Backup needs to be deleted.");BackupNamebackupAsBackupName=BackupName.FromProjectInstanceBackup(projectId,instanceId,backupId);databaseAdminClient.DeleteBackup(backupAsBackupName);}returncompletedOperation;}}

import("context""fmt""io""regexp""time"longrunning"cloud.google.com/go/longrunning/autogen/longrunningpb"database"cloud.google.com/go/spanner/admin/database/apiv1"adminpb"cloud.google.com/go/spanner/admin/database/apiv1/databasepb"pbt"github.com/golang/protobuf/ptypes/timestamp""google.golang.org/grpc/codes""google.golang.org/grpc/status")funccancelBackup(ctxcontext.Context,wio.Writer,db,backupIDstring)error{matches:=regexp.MustCompile("^(.+)/databases/(.+)$").FindStringSubmatch(db)ifmatches==nil||len(matches)!=3{returnfmt.Errorf("cancelBackup: invalid database id %q",db)}adminClient,err:=database.NewDatabaseAdminClient(ctx)iferr!=nil{returnfmt.Errorf("cancelBackup.NewDatabaseAdminClient: %w",err)}deferadminClient.Close()expireTime:=time.Now().AddDate(0,0,14)// Create a backup.req:=adminpb.CreateBackupRequest{Parent:matches[1],BackupId:backupID,Backup:&adminpb.Backup{Database:db,ExpireTime:&pbt.Timestamp{Seconds:expireTime.Unix(),Nanos:int32(expireTime.Nanosecond())},},}op,err:=adminClient.CreateBackup(ctx,&req)iferr!=nil{returnfmt.Errorf("cancelBackup.CreateBackup: %w",err)}// Cancel backup creation.err=adminClient.LROClient.CancelOperation(ctx,&longrunning.CancelOperationRequest{Name:op.Name()})iferr!=nil{returnfmt.Errorf("cancelBackup.CancelOperation: %w",err)}// Cancel operations are best effort so either it will complete or be// cancelled.backup,err:=op.Wait(ctx)iferr!=nil{ifwaitStatus,ok:=status.FromError(err);!ok||waitStatus.Code()!=codes.Canceled{returnfmt.Errorf("cancelBackup.Wait: %w",err)}}else{// Backup was completed before it could be cancelled so delete the// unwanted backup.err=adminClient.DeleteBackup(ctx,&adminpb.DeleteBackupRequest{Name:backup.Name})iferr!=nil{returnfmt.Errorf("cancelBackup.DeleteBackup: %w",err)}}fmt.Fprintf(w,"Backup cancelled.\n")returnnil}

staticvoidcancelCreateBackup(DatabaseAdminClientdbAdminClient,StringprojectId,StringinstanceId,StringdatabaseId,StringbackupId){// Set expire time to 14 days from now.TimestampexpireTime=Timestamp.newBuilder().setSeconds(TimeUnit.MILLISECONDS.toSeconds((System.currentTimeMillis()+TimeUnit.DAYS.toMillis(14)))).build();BackupNamebackupName=BackupName.of(projectId,instanceId,backupId);Backupbackup=Backup.newBuilder().setName(backupName.toString()).setDatabase(DatabaseName.of(projectId,instanceId,databaseId).toString()).setExpireTime(expireTime).build();try{// Start the creation of a backup.System.out.println("Creating backup ["+backupId+"]...");OperationFuture<Backup,CreateBackupMetadata>op=dbAdminClient.createBackupAsync(InstanceName.of(projectId,instanceId),backup,backupId);// Try to cancel the backup operation.System.out.println("Cancelling create backup operation for ["+backupId+"]...");dbAdminClient.getOperationsClient().cancelOperation(op.getName());// Get a polling future for the running operation. This future will regularly poll the server// for the current status of the backup operation.RetryingFuture<OperationSnapshot>pollingFuture=op.getPollingFuture();// Wait for the operation to finish.// isDone will return true when the operation is complete, regardless of whether it was// successful or not.while(!pollingFuture.get().isDone()){System.out.println("Waiting for the cancelled backup operation to finish...");Thread.sleep(TimeUnit.MILLISECONDS.convert(5,TimeUnit.SECONDS));}if(pollingFuture.get().getErrorCode()==null){// Backup was created before it could be cancelled. Delete the backup.dbAdminClient.deleteBackup(backupName);System.out.println("Backup operation for ["+backupId+"] successfully finished before it could be cancelled");}elseif(pollingFuture.get().getErrorCode().getCode()==StatusCode.Code.CANCELLED){System.out.println("Backup operation for ["+backupId+"] successfully cancelled");}}catch(ExecutionExceptione){throwSpannerExceptionFactory.newSpannerException(e.getCause());}catch(InterruptedExceptione){throwSpannerExceptionFactory.propagateInterrupt(e);}}

// Imports the Google Cloud client library and precise date libraryconst{Spanner,protos}=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';// const backupId = 'my-backup';// Creates a clientconstspanner=newSpanner({projectId:projectId,});// Gets a reference to a Cloud Spanner Database Admin Client objectconstdatabaseAdminClient=spanner.getDatabaseAdminClient();// Creates a new backup of the databasetry{console.log(`Creating backup of database${databaseAdminClient.databasePath(projectId,instanceId,databaseId,)}.`,);// Expire backup one day in the futureconstexpireTime=Date.now()+1000*60*60*24;const[operation]=awaitdatabaseAdminClient.createBackup({parent:databaseAdminClient.instancePath(projectId,instanceId),backupId:backupId,backup:(protos.google.spanner.admin.database.v1.Backup={database:databaseAdminClient.databasePath(projectId,instanceId,databaseId,),expireTime:Spanner.timestamp(expireTime).toStruct(),name:databaseAdminClient.backupPath(projectId,instanceId,backupId),}),});// Cancel the backupawaitoperation.cancel();console.log('Backup cancelled.');}catch(err){console.error('ERROR:',err);}finally{// Delete backup in case it got created before the cancel operationawaitdatabaseAdminClient.deleteBackup({name:databaseAdminClient.backupPath(projectId,instanceId,backupId),});// 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();}

use Google\ApiCore\ApiException;use Google\Cloud\Spanner\Admin\Database\V1\Backup;use Google\Cloud\Spanner\Admin\Database\V1\Client\DatabaseAdminClient;use Google\Cloud\Spanner\Admin\Database\V1\CreateBackupRequest;use Google\Cloud\Spanner\Admin\Database\V1\DeleteBackupRequest;use Google\Cloud\Spanner\Admin\Database\V1\GetBackupRequest;use Google\Protobuf\Timestamp;/** * Cancel a backup operation. * Example: * ``` * cancel_backup($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 cancel_backup(string $projectId, string $instanceId, string $databaseId): void{    $databaseAdminClient = new DatabaseAdminClient();    $databaseFullName = DatabaseAdminClient::databaseName($projectId, $instanceId, $databaseId);    $instanceFullName = DatabaseAdminClient::instanceName($projectId, $instanceId);    $expireTime = new Timestamp();    $expireTime->setSeconds((new \DateTime('+14 days'))->getTimestamp());    $backupId = uniqid('backup-' . $databaseId . '-cancel');    $request = new CreateBackupRequest([        'parent' => $instanceFullName,        'backup_id' => $backupId,        'backup' => new Backup([            'database' => $databaseFullName,            'expire_time' => $expireTime        ])    ]);    $operation = $databaseAdminClient->createBackup($request);    $operation->cancel();    // Cancel operations are always successful regardless of whether the operation is    // still in progress or is complete.    printf('Cancel backup operation complete.' . PHP_EOL);    // Operation may succeed before cancel() has been called. So we need to clean up created backup.    try {        $request = new GetBackupRequest();        $request->setName($databaseAdminClient->backupName($projectId, $instanceId, $backupId));        $info = $databaseAdminClient->getBackup($request);    } catch (ApiException $ex) {        return;    }    $databaseAdminClient->deleteBackup(new DeleteBackupRequest([        'name' => $databaseAdminClient->backupName($projectId, $instanceId, $backupId)    ]));}

defcancel_backup(instance_id,database_id,backup_id):fromgoogle.cloud.spanner_admin_database_v1.typesimportbackupasbackup_pbspanner_client=spanner.Client()database_admin_api=spanner_client.database_admin_apiexpire_time=datetime.utcnow()+timedelta(days=30)# Create a backup.request=backup_pb.CreateBackupRequest(parent=database_admin_api.instance_path(spanner_client.project,instance_id),backup_id=backup_id,backup=backup_pb.Backup(database=database_admin_api.database_path(spanner_client.project,instance_id,database_id),expire_time=expire_time,),)operation=database_admin_api.create_backup(request)# Cancel backup creation.operation.cancel()# Cancel operations are the best effort so either it will complete or# be cancelled.whilenotoperation.done():time.sleep(300)# 5 minstry:database_admin_api.get_backup(backup_pb.GetBackupRequest(name=database_admin_api.backup_path(spanner_client.project,instance_id,backup_id),))exceptNotFound:print("Backup creation was successfully cancelled.")returnprint("Backup was created before the cancel completed.")database_admin_api.delete_backup(backup_pb.DeleteBackupRequest(name=database_admin_api.backup_path(spanner_client.project,instance_id,backup_id),))print("Backup deleted.")

# project_id  = "Your Google Cloud project ID"# instance_id = "Your Spanner instance ID"# database_id = "Your Spanner database ID"# backup_id = "Your Spanner backup ID"require"google/cloud/spanner"require"google/cloud/spanner/admin/database"database_admin_client=Google::Cloud::Spanner::Admin::Database.database_admininstance_path=database_admin_client.instance_pathproject:project_id,instance:instance_iddb_path=database_admin_client.database_pathproject:project_id,instance:instance_id,database:database_idbackup_path=database_admin_client.backup_pathproject:project_id,instance:instance_id,backup:backup_idexpire_time=Time.now+(14*24*3600)# 14 days from nowjob=database_admin_client.create_backupparent:instance_path,backup_id:backup_id,backup:{database:db_path,expire_time:expire_time}puts"Backup operation in progress"job.canceljob.wait_until_done!beginbackup=database_admin_client.get_backupname:backup_pathdatabase_admin_client.delete_backupname:backup_pathifbackuprescueStandardErrornil# no cleanup needed when a backup is not createdendputs"#{backup_id} creation job cancelled"