Manage backups

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)
{
DatabaseAdminClient databaseAdminClient=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;
}
Backup backup=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;
publicclass CopyBackupSample{
staticvoidcopyBackup(){
// TODO(developer): Replace these variables before running the sample.
String projectId="my-project";
String instanceId="my-instance";
String sourceBackupId="my-backup";
String destinationBackupId="my-destination-backup";
try(Spanner spanner=
SpannerOptions .newBuilder().setProjectId(projectId).build().getService();
DatabaseAdminClient databaseAdminClient=spanner.createDatabaseAdminClient()){
copyBackup(databaseAdminClient,projectId,instanceId,sourceBackupId,destinationBackupId);
}
}
staticvoidcopyBackup(
DatabaseAdminClient databaseAdminClient,
String projectId,
String instanceId,
String sourceBackupId,
String destinationBackupId){
Timestamp expireTime=
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+"]...");
Backup destinationBackup;
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 library
const{Spanner}=require('@google-cloud/spanner');
const{PreciseDate}=require('@google-cloud/precise-date');
// Creates a client
constspanner=newSpanner ({
projectId:projectId,
});
// Gets a reference to a Cloud Spanner Database Admin Client object
constdatabaseAdminClient=spanner.getDatabaseAdminClient ();
asyncfunctionspannerCopyBackup(){
// Expire copy backup 14 days in the future
constexpireTime=Spanner .timestamp (
Date.now()+1000*60*60*24*14,
).toStruct ();
// Copy the source backup
try{
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 ready
const[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.typesimport backup as backup_pb
 spanner_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.
 assert copy_backup.state == backup_pb.Backup.State.READY
 print(
 "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_admin
instance_path=database_admin_client.instance_pathproject:project_id,instance:instance_id
backup_path=database_admin_client.backup_pathproject:project_id,
instance:instance_id,
backup:backup_id
source_backup=database_admin_client.backup_pathproject:project_id,
instance:instance_id,
backup:source_backup_id
expire_time=Time.now+(14*24*3600)# 14 days from now
job=database_admin_client.copy_backupparent:instance_path,
backup_id:backup_id,
source_backup:source_backup,
expire_time:expire_time
puts"Copy backup operation in progress"
job.wait_until_done!
backup=database_admin_client.get_backupname:backup_path
puts"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.
DatabaseAdminClient databaseAdminClient=DatabaseAdminClient .Create ();
varfilter=$"(metadata.@type:type.googleapis.com/google.spanner.admin.database.v1.CreateBackupMetadata) AND (metadata.database:{databaseId})";
ListBackupOperationsRequest request=newListBackupOperationsRequest
{
ParentAsInstanceName=InstanceName .FromProjectInstance (projectId,instanceId),
Filter=filter
};
// List the create backup operations on the database.
varbackupOperations=databaseAdminClient.ListBackupOperations (request);
foreach(varoperationinbackupOperations)
{
CreateBackupMetadata metadata=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.
DatabaseAdminClient databaseAdminClient=DatabaseAdminClient .Create ();
varfilter=$"(metadata.@type:type.googleapis.com/google.spanner.admin.database.v1.CopyBackupMetadata) AND (metadata.source_backup:{backupId})";
ListBackupOperationsRequest request=newListBackupOperationsRequest
{
ParentAsInstanceName=InstanceName .FromProjectInstance (projectId,instanceId),
Filter=filter
};
// List the copy backup operations on the database.
varbackupOperations=databaseAdminClient.ListBackupOperations (request);
foreach(varoperationinbackupOperations)
{
CopyBackupMetadata metadata=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 library
const{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 client
constspanner=newSpanner ({
projectId:projectId,
});
// Gets a reference to a Cloud Spanner Database Admin Client object
constdatabaseAdminClient=spanner.getDatabaseAdminClient ();
// List create backup operations
try{
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 operations
try{
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.typesimport backup as backup_pb
 spanner_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)
 for op in operations:
 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)
 for op in operations:
 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_admin
instance_path=database_admin_client.instance_pathproject:project_id,instance:instance_id
jobs=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.error
else
puts"Backup #{job.results.name} on database #{database_id} is #{job.metadata.progress.progress_percent}% complete"
end
end

# 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_admin
instance_path=database_admin_client.instance_pathproject:project_id,instance:instance_id
filter="(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:filter
jobs.eachdo|job|
ifjob.error?
putsjob.error
else
puts"Backup #{job.results.name} on source backup #{backup_id} is #{job.metadata.progress.progress_percent}% complete"
end
end

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.
DatabaseAdminClient databaseAdminClient=DatabaseAdminClient .Create ();
// Initialize backup request parameters.
Backup backup=newBackup
{
DatabaseAsDatabaseName=DatabaseName .FromProjectInstanceDatabase (projectId,instanceId,databaseId),
ExpireTime=DateTime.UtcNow.AddDays(14).ToTimestamp ()
};
InstanceName parentAsInstanceName=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.");
BackupName backupAsBackupName=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 library
const{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 client
constspanner=newSpanner ({
projectId:projectId,
});
// Gets a reference to a Cloud Spanner Database Admin Client object
constdatabaseAdminClient=spanner.getDatabaseAdminClient ();
// Creates a new backup of the database
try{
console.log(
`Creating backup of database ${databaseAdminClient.databasePath(
projectId,
instanceId,
databaseId,
)}.`,
);
// Expire backup one day in the future
constexpireTime=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 backup
awaitoperation .cancel();
console.log('Backup cancelled.');
}catch(err){
console.error('ERROR:',err);
}finally{
// Delete backup in case it got created before the cancel operation
awaitdatabaseAdminClient.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.typesimport backup as backup_pb
 spanner_client = spanner.Client()
 database_admin_api = spanner_client.database_admin_api
 expire_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.
 while not operation.done():
 time.sleep(300) # 5 mins
 try:
 database_admin_api.get_backup(
 backup_pb.GetBackupRequest(
 name=database_admin_api.backup_path(
 spanner_client.project, instance_id, backup_id
 ),
 )
 )
 except NotFound:
 print("Backup creation was successfully cancelled.")
 return
 print("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_admin
instance_path=database_admin_client.instance_pathproject:project_id,instance:instance_id
db_path=database_admin_client.database_pathproject:project_id,
instance:instance_id,
database:database_id
backup_path=database_admin_client.backup_pathproject:project_id,
instance:instance_id,
backup:backup_id
expire_time=Time.now+(14*24*3600)# 14 days from now
job=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.cancel
job.wait_until_done!
begin
backup=database_admin_client.get_backupname:backup_path
database_admin_client.delete_backupname:backup_pathifbackup
rescueStandardError
nil# no cleanup needed when a backup is not created
end
puts"#{backup_id} creation job cancelled"

voidListBackups(google::cloud::spanner_admin::DatabaseAdminClientclient,
std::stringconst&project_id,
std::stringconst&instance_id){
google::cloud::spanner::Instancein(project_id,instance_id);
std::cout << "All backups:\n";
for(auto&backup:client.ListBackups(in.FullName())){
if(!backup)throwstd::move(backup).status();
std::cout << "Backup " << backup->name() << " on database "
 << backup->database() << " with size : " << backup->size_bytes()
 << " bytes.\n";
}
}

usingGoogle.Cloud.Spanner.Admin.Database.V1 ;
usingGoogle.Cloud.Spanner.Common.V1 ;
usingSystem;
usingSystem.Collections.Generic;
usingSystem.Linq;
publicclassListBackupsSample
{
publicIEnumerable<Backup>ListBackups(stringprojectId,stringinstanceId,stringdatabaseId,stringbackupId)
{
// Create the DatabaseAdminClient instance.
DatabaseAdminClient databaseAdminClient=DatabaseAdminClient .Create ();
InstanceName parentAsInstanceName=InstanceName .FromProjectInstance (projectId,instanceId);
// List all backups.
Console.WriteLine("All backups:");
varallBackups=databaseAdminClient.ListBackups (parentAsInstanceName);
PrintBackups(allBackups);
ListBackupsRequest request=newListBackupsRequest
{
ParentAsInstanceName=parentAsInstanceName,
};
// List backups containing backup name.
Console.WriteLine($"Backups with backup name containing {backupId}:");
request.Filter =$"name:{backupId}";
varbackupsWithName=databaseAdminClient.ListBackups (request);
PrintBackups(backupsWithName);
// List backups on a database containing name.
Console.WriteLine($"Backups with database name containing {databaseId}:");
request.Filter =$"database:{databaseId}";
varbackupsWithDatabaseName=databaseAdminClient.ListBackups (request);
PrintBackups(backupsWithDatabaseName);
// List backups that expire within 30 days.
Console.WriteLine("Backups expiring within 30 days:");
stringexpireTime=DateTime.UtcNow.AddDays(30).ToString("O");
request.Filter =$"expire_time < \"{expireTime}\"";
varexpiringBackups=databaseAdminClient.ListBackups (request);
PrintBackups(expiringBackups);
// List backups with a size greater than 100 bytes.
Console.WriteLine("Backups with size > 100 bytes:");
request.Filter ="size_bytes > 100";
varbackupsWithSize=databaseAdminClient.ListBackups (request);
PrintBackups(backupsWithSize);
// List backups created in the last day that are ready.
Console.WriteLine("Backups created within last day that are ready:");
stringcreateTime=DateTime.UtcNow.AddDays(-1).ToString("O");
request.Filter =$"create_time >= \"{createTime}\" AND state:READY";
varrecentReadyBackups=databaseAdminClient.ListBackups (request);
PrintBackups(recentReadyBackups);
// List backups in pages of 500 elements each
foreach(varpageindatabaseAdminClient.ListBackups (parentAsInstanceName,pageSize:500).AsRawResponses())
{
PrintBackups(page);
}
returnallBackups;
}
privatestaticvoidPrintBackups(IEnumerable<Backup>backups)
{
// We print the first 5 elements each time for demonstration purposes.
// You can print all backups in the sequence by removing the call to Take(5).
// If the sequence has been returned by a paginated operation it will lazily
// fetch elements in pages as needed.
foreach(Backup backupinbackups.Take(5))
{
Console.WriteLine($"Backup Name : {backup.Name}");
};
}
}

import(
"context"
"fmt"
"io"
"regexp"
"time"
database"cloud.google.com/go/spanner/admin/database/apiv1"
adminpb"cloud.google.com/go/spanner/admin/database/apiv1/databasepb"
"google.golang.org/api/iterator"
)
funclistBackups(ctxcontext.Context,wio.Writer,db,backupIDstring)error{
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]
printBackups:=func(iter*database.BackupIterator )error{
for{
resp,err:=iter.Next()
iferr==iterator.Done{
returnnil
}
iferr!=nil{
returnerr
}
fmt.Fprintf(w,"Backup %s\n",resp.Name)
}
}
variter*database.BackupIterator
varfilterstring
// List all backups.
iter=adminClient.ListBackups(ctx,&adminpb.ListBackupsRequest{
Parent:instanceName,
})
iferr:=printBackups(iter);err!=nil{
returnerr
}
// List all backups that contain a name.
iter=adminClient.ListBackups(ctx,&adminpb.ListBackupsRequest{
Parent:instanceName,
Filter:"name:"+backupID,
})
iferr:=printBackups(iter);err!=nil{
returnerr
}
// List all backups that expire before a timestamp.
expireTime:=time.Now().AddDate(0,0,30)
filter=fmt.Sprintf(`expire_time < "%s"`,expireTime.Format(time.RFC3339))
iter=adminClient.ListBackups(ctx,&adminpb.ListBackupsRequest{
Parent:instanceName,
Filter:filter,
})
iferr:=printBackups(iter);err!=nil{
returnerr
}
// List all backups for a database that contains a name.
iter=adminClient.ListBackups(ctx,&adminpb.ListBackupsRequest{
Parent:instanceName,
Filter:"database:"+db,
})
iferr:=printBackups(iter);err!=nil{
returnerr
}
// List all backups with a size greater than some bytes.
iter=adminClient.ListBackups(ctx,&adminpb.ListBackupsRequest{
Parent:instanceName,
Filter:"size_bytes > 100",
})
iferr:=printBackups(iter);err!=nil{
returnerr
}
// List backups that were created after a timestamp that are also ready.
createTime:=time.Now().AddDate(0,0,-1)
filter=fmt.Sprintf(
`create_time >= "%s" AND state:READY`,
createTime.Format(time.RFC3339),
)
iter=adminClient.ListBackups(ctx,&adminpb.ListBackupsRequest{
Parent:instanceName,
Filter:filter,
})
iferr:=printBackups(iter);err!=nil{
returnerr
}
// List backups with pagination.
request:=&adminpb.ListBackupsRequest{
Parent:instanceName,
PageSize:10,
}
for{
iter=adminClient.ListBackups(ctx,request)
iferr:=printBackups(iter);err!=nil{
returnerr
}
pageToken:=iter.PageInfo().Token
ifpageToken==""{
break
}else{
request.PageToken=pageToken
}
}
fmt.Fprintf(w,"Backups listed.\n")
returnnil
}

staticvoidlistBackups(
DatabaseAdminClientdbAdminClient,StringprojectId,
StringinstanceId,StringdatabaseId,StringbackupId){
InstanceNameinstanceName=InstanceName.of(projectId,instanceId);
// List all backups.
System.out.println("All backups:");
for(Backupbackup:dbAdminClient.listBackups(
instanceName.toString()).iterateAll()){
System.out.println(backup);
}
// List all backups with a specific name.
System.out.println(
String.format("All backups with backup name containing \"%s\":",backupId));
ListBackupsRequestlistBackupsRequest=
ListBackupsRequest.newBuilder().setParent(instanceName.toString())
.setFilter(String.format("name:%s",backupId)).build();
for(Backupbackup:dbAdminClient.listBackups(listBackupsRequest).iterateAll()){
System.out.println(backup);
}
// List all backups for databases whose name contains a certain text.
System.out.println(
String.format(
"All backups for databases with a name containing \"%s\":",databaseId));
listBackupsRequest=
ListBackupsRequest.newBuilder().setParent(instanceName.toString())
.setFilter(String.format("database:%s",databaseId)).build();
for(Backupbackup:dbAdminClient.listBackups(listBackupsRequest).iterateAll()){
System.out.println(backup);
}
// List all backups that expire before a certain time.
com.google.cloud.TimestampexpireTime=com.google.cloud.Timestamp.ofTimeMicroseconds(
TimeUnit.MICROSECONDS.convert(
System.currentTimeMillis()+TimeUnit.DAYS.toMillis(30),TimeUnit.MILLISECONDS));
System.out.println(String.format("All backups that expire before %s:",expireTime));
listBackupsRequest=
ListBackupsRequest.newBuilder().setParent(instanceName.toString())
.setFilter(String.format("expire_time < \"%s\"",expireTime)).build();
for(Backupbackup:dbAdminClient.listBackups(listBackupsRequest).iterateAll()){
System.out.println(backup);
}
// List all backups with size greater than a certain number of bytes.
listBackupsRequest=
ListBackupsRequest.newBuilder().setParent(instanceName.toString())
.setFilter("size_bytes > 100").build();
System.out.println("All backups with size greater than 100 bytes:");
for(Backupbackup:dbAdminClient.listBackups(listBackupsRequest).iterateAll()){
System.out.println(backup);
}
// List all backups with a create time after a certain timestamp and that are also ready.
com.google.cloud.TimestampcreateTime=com.google.cloud.Timestamp.ofTimeMicroseconds(
TimeUnit.MICROSECONDS.convert(
System.currentTimeMillis()-TimeUnit.DAYS.toMillis(1),TimeUnit.MILLISECONDS));
System.out.println(
String.format(
"All databases created after %s and that are ready:",createTime.toString()));
listBackupsRequest=
ListBackupsRequest.newBuilder().setParent(instanceName.toString())
.setFilter(String.format(
"create_time >= \"%s\" AND state:READY",createTime.toString())).build();
for(Backupbackup:dbAdminClient.listBackups(listBackupsRequest).iterateAll()){
System.out.println(backup);
}
// List backups using pagination.
System.out.println("All backups, listed using pagination:");
listBackupsRequest=
ListBackupsRequest.newBuilder().setParent(instanceName.toString()).setPageSize(10).build();
while(true){
ListBackupsPagedResponseresponse=dbAdminClient.listBackups(listBackupsRequest);
for(Backupbackup:response.getPage().iterateAll()){
System.out.println(backup);
}
StringnextPageToken=response.getNextPageToken();
if(!Strings.isNullOrEmpty(nextPageToken)){
listBackupsRequest=listBackupsRequest.toBuilder().setPageToken(nextPageToken).build();
}else{
break;
}
}
}

// 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';
// const backupId = 'my-backup';
// Creates a client
constspanner=newSpanner ({
projectId:projectId,
});
// Gets a reference to a Cloud Spanner Database Admin Client object
constdatabaseAdminClient=spanner.getDatabaseAdminClient ();
try{
// Get the parent(instance) of the database
constparent=databaseAdminClient.instancePath(projectId,instanceId);
// List all backups
const[allBackups]=awaitdatabaseAdminClient.listBackups({
parent:parent,
});
console.log('All backups:');
allBackups.forEach(backups=>{
if(backups.name){
constbackup=backups.name;
constdelimiter=
'projects/'+projectId+'/instances/'+instanceId+'/backups/';
constresult=backup.substring(delimiter.length);
console.log(result);
}
});
// List backups filtered by backup name
const[backupsByName]=awaitdatabaseAdminClient.listBackups({
parent:parent,
filter:`Name:${backupId}`,
});
console.log('Backups matching backup name:');
backupsByName.forEach(backup=>{
if(backup.name){
constbackupName=backup.name;
constdelimiter=
'projects/'+projectId+'/instances/'+instanceId+'/backups/';
constresult=backupName.substring(delimiter.length);
console.log(result);
}
});
// List backups expiring within 30 days
constexpireTime=newDate();
expireTime.setDate(expireTime.getDate()+30);
const[backupsByExpiry]=awaitdatabaseAdminClient.listBackups({
parent:parent,
filter:`expire_time < "${expireTime.toISOString()}"`,
});
console.log('Backups expiring within 30 days:');
backupsByExpiry.forEach(backup=>{
if(backup.name){
constbackupName=backup.name;
constdelimiter=
'projects/'+projectId+'/instances/'+instanceId+'/backups/';
constresult=backupName.substring(delimiter.length);
console.log(result);
}
});
// List backups filtered by database name
const[backupsByDbName]=awaitdatabaseAdminClient.listBackups({
parent:parent,
filter:`Database:${databaseId}`,
});
console.log('Backups matching database name:');
backupsByDbName.forEach(backup=>{
if(backup.name){
constbackupName=backup.name;
constdelimiter=
'projects/'+projectId+'/instances/'+instanceId+'/backups/';
constresult=backupName.substring(delimiter.length);
console.log(result);
}
});
// List backups filtered by backup size
const[backupsBySize]=awaitdatabaseAdminClient.listBackups({
parent:parent,
filter:'size_bytes > 100',
});
console.log('Backups filtered by size:');
backupsBySize.forEach(backup=>{
if(backup.name){
constbackupName=backup.name;
constdelimiter=
'projects/'+projectId+'/instances/'+instanceId+'/backups/';
constresult=backupName.substring(delimiter.length);
console.log(result);
}
});
// List backups that are ready that were created after a certain time
constcreateTime=newDate();
createTime.setDate(createTime.getDate()-1);
const[backupsByCreateTime]=awaitdatabaseAdminClient.listBackups({
parent:parent,
filter:`(state:READY) AND (create_time >= "${createTime.toISOString()}")`,
});
console.log('Ready backups filtered by create time:');
backupsByCreateTime.forEach(backup=>{
if(backup.name){
constbackupName=backup.name;
constdelimiter=
'projects/'+projectId+'/instances/'+instanceId+'/backups/';
constresult=backupName.substring(delimiter.length);
console.log(result);
}
});
// List backups using pagination
console.log('Get backups paginated:');
const[backups]=awaitdatabaseAdminClient.listBackups({
parent:parent,
pageSize:3,
});
backups.forEach(backup=>{
if(backup.name){
constbackupName=backup.name;
constdelimiter=
'projects/'+projectId+'/instances/'+instanceId+'/backups/';
constresult=backupName.substring(delimiter.length);
console.log(result);
}
});
}catch(err){
console.error('ERROR:',err);
}