/// <summary>Snippet for UpdateDatabaseDdlAsync</summary>
public async Task UpdateDatabaseDdlAsync()
{
// Snippet: UpdateDatabaseDdlAsync(DatabaseName,IEnumerable<string>,CallSettings)
// Additional: UpdateDatabaseDdlAsync(DatabaseName,IEnumerable<string>,CancellationToken)
// Create client
DatabaseAdminClient databaseAdminClient = await DatabaseAdminClient.CreateAsync();
// Initialize request argument(s)
DatabaseName database = new DatabaseName("[PROJECT]", "[INSTANCE]", "[DATABASE]");
IEnumerable <string> statements = new List <string>();
// Make the request
Operation <Empty, UpdateDatabaseDdlMetadata> response =
await databaseAdminClient.UpdateDatabaseDdlAsync(database, statements);
// Poll until the returned long-running operation is complete
Operation <Empty, UpdateDatabaseDdlMetadata> completedResponse =
await response.PollUntilCompletedAsync();
// The long-running operation is now complete.
// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation <Empty, UpdateDatabaseDdlMetadata> retrievedResponse =
await databaseAdminClient.PollOnceUpdateDatabaseDdlAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
// The long-running operation is now complete.
}
// End snippet
}
/// <summary>Snippet for CreateDatabaseAsync</summary>
public async Task CreateDatabaseAsync()
{
// Snippet: CreateDatabaseAsync(InstanceName,string,CallSettings)
// Additional: CreateDatabaseAsync(InstanceName,string,CancellationToken)
// Create client
DatabaseAdminClient databaseAdminClient = await DatabaseAdminClient.CreateAsync();
// Initialize request argument(s)
InstanceName parent = new InstanceName("[PROJECT]", "[INSTANCE]");
string createStatement = "";
// Make the request
Operation <Database, CreateDatabaseMetadata> response =
await databaseAdminClient.CreateDatabaseAsync(parent, createStatement);
// Poll until the returned long-running operation is complete
Operation <Database, CreateDatabaseMetadata> completedResponse =
await response.PollUntilCompletedAsync();
// Retrieve the operation result
Database result = completedResponse.Result;
// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation <Database, CreateDatabaseMetadata> retrievedResponse =
await databaseAdminClient.PollOnceCreateDatabaseAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
// If it has completed, then access the result
Database retrievedResult = retrievedResponse.Result;
}
// End snippet
}
/// <summary>Snippet for CreateDatabase</summary>
public void CreateDatabase_RequestObject()
{
// Snippet: CreateDatabase(CreateDatabaseRequest,CallSettings)
// Create client
DatabaseAdminClient databaseAdminClient = DatabaseAdminClient.Create();
// Initialize request argument(s)
CreateDatabaseRequest request = new CreateDatabaseRequest
{
ParentAsInstanceName = new InstanceName("[PROJECT]", "[INSTANCE]"),
CreateStatement = "",
};
// Make the request
Operation <Database, CreateDatabaseMetadata> response =
databaseAdminClient.CreateDatabase(request);
// Poll until the returned long-running operation is complete
Operation <Database, CreateDatabaseMetadata> completedResponse =
response.PollUntilCompleted();
// Retrieve the operation result
Database result = completedResponse.Result;
// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation <Database, CreateDatabaseMetadata> retrievedResponse =
databaseAdminClient.PollOnceCreateDatabase(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
// If it has completed, then access the result
Database retrievedResult = retrievedResponse.Result;
}
// End snippet
}
public void UpdateDatabaseDdl()
{
// Snippet: UpdateDatabaseDdl(string,IEnumerable<string>,CallSettings)
// Create client
DatabaseAdminClient databaseAdminClient = DatabaseAdminClient.Create();
// Initialize request argument(s)
string formattedDatabase = new DatabaseName("[PROJECT]", "[INSTANCE]", "[DATABASE]").ToString();
IEnumerable <string> statements = new List <string>();
// Make the request
Operation <Empty> response =
databaseAdminClient.UpdateDatabaseDdl(formattedDatabase, statements);
// Poll until the returned long-running operation is complete
Operation <Empty> completedResponse =
response.PollUntilCompleted();
// The long-running operation is now complete.
// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation <Empty> retrievedResponse =
databaseAdminClient.PollOnceUpdateDatabaseDdl(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
// The long-running operation is now complete.
}
// End snippet
}
public async Task InitializeAsync()
{
DatabaseAdminClient = await DatabaseAdminClient.CreateAsync();
bool.TryParse(Environment.GetEnvironmentVariable("RUN_SPANNER_CMEK_BACKUP_SAMPLES_TESTS"), out var runCmekBackupSampleTests);
RunCmekBackupSampleTests = runCmekBackupSampleTests;
ConnectionString = $"Data Source=projects/{ProjectId}/instances/{InstanceId}/databases/{DatabaseId}";
// Don't need to cleanup stale Backups and Databases when instance is new.
var isExistingInstance = await InitializeInstanceAsync();
if (isExistingInstance)
{
await DeleteStaleBackupsAsync();
await DeleteStaleDatabasesAsync();
}
await CreateInstanceWithMultiRegionAsync();
await DeleteStaleInstancesAsync();
await InitializeDatabaseAsync();
await InitializeBackupAsync();
// Create encryption key for creating an encrypted database and optionally backing up and restoring an encrypted database.
await InitializeEncryptionKeys();
if (RunCmekBackupSampleTests)
{
await InitializeEncryptedBackupAsync();
}
}
public static object SpannerRestoreDatabase(
string projectId, string instanceId, string databaseId, string backupId)
{
// Create the DatabaseAdminClient instance.
DatabaseAdminClient databaseAdminClient = DatabaseAdminClient.Create();
InstanceName parentAsInstanceName =
InstanceName.FromProjectInstance(projectId, instanceId);
BackupName backupAsBackupName =
BackupName.FromProjectInstanceBackup(projectId, instanceId, backupId);
// Make the RestoreDatabase request.
Operation <Database, RestoreDatabaseMetadata> response =
databaseAdminClient.RestoreDatabase(
parentAsInstanceName, databaseId, backupAsBackupName);
Console.WriteLine("Waiting for the operation to finish");
// Poll until the returned long-running operation is complete.
var completedResponse = response.PollUntilCompleted();
if (completedResponse.IsFaulted)
{
Console.WriteLine($"Database Restore Failed: {completedResponse.Exception}");
return(1);
}
RestoreInfo restoreInfo = completedResponse.Result.RestoreInfo;
Console.WriteLine(
$"Database {restoreInfo.BackupInfo.SourceDatabase} was restored " +
$"to {databaseId} from backup {restoreInfo.BackupInfo.Backup}");
return(0);
}
private static int Main(string[] args)
{
if (args.Length == 0 || args.Length > 2)
{
Console.WriteLine("Arguments: <project ID> [instance ID]");
Console.WriteLine("A default instance ID of 'spannerintegration' will be used if not specified.");
return(1);
}
string projectId = args[0];
string instanceId = args.Length == 2 ? args[1] : "spannerintegration";
var client = DatabaseAdminClient.Create();
var instanceName = new InstanceName(projectId, instanceId);
var databases = client.ListDatabases(instanceName).ToList();
foreach (var database in databases)
{
var name = DatabaseName.Parse(database.Name);
if (name.DatabaseId.StartsWith("testdb"))
{
Console.WriteLine($"Dropping {name.DatabaseId}");
client.DropDatabase(name);
}
}
return(0);
}
public static void DelelteDatabases()
{
string adminConnectionString = $"Data Source=projects/{projectId}/"
+ $"instances/{instanceId}";
DatabaseAdminClient databaseAdminClient = DatabaseAdminClient.Create();
InstanceName instanceName = InstanceName.FromProjectInstance(projectId, instanceId);
var databases = databaseAdminClient.ListDatabases(instanceName);
using (var connection = new SpannerConnection(adminConnectionString))
foreach (var database in databases)
{
using (var cmd = connection.CreateDdlCommand($@"DROP DATABASE {database.DatabaseName.DatabaseId}"))
{
try
{
cmd.ExecuteNonQuery();
}
catch (Exception)
{
continue;
}
}
}
}
public IEnumerable <Operation> ListDatabaseOperations(string projectId, string instanceId)
{
// Create the DatabaseAdminClient instance.
DatabaseAdminClient databaseAdminClient = DatabaseAdminClient.Create();
var filter = "(metadata.@type:type.googleapis.com/google.spanner.admin.database.v1.OptimizeRestoredDatabaseMetadata)";
ListDatabaseOperationsRequest request = new ListDatabaseOperationsRequest
{
ParentAsInstanceName = InstanceName.FromProjectInstance(projectId, instanceId),
Filter = filter
};
// List the optimize restored databases operations on the instance.
var operations = databaseAdminClient.ListDatabaseOperations(request);
foreach (var operation in operations)
{
OptimizeRestoredDatabaseMetadata metadata =
operation.Metadata.Unpack <OptimizeRestoredDatabaseMetadata>();
Console.WriteLine(
$"Database {metadata.Name} restored from backup is {metadata.Progress.ProgressPercent}% optimized.");
}
return(operations);
}
public static object SpannerUpdateBackup(string projectId, string instanceId, string backupId)
{
// Create the DatabaseAdminClient instance.
DatabaseAdminClient databaseAdminClient = DatabaseAdminClient.Create();
// Retrieve existing backup.
BackupName backupName =
BackupName.FromProjectInstanceBackup(projectId, instanceId, backupId);
Backup backup = databaseAdminClient.GetBackup(backupName);
// Add 14 days to the existing ExpireTime.
backup.ExpireTime = backup.ExpireTime.ToDateTime().AddDays(14).ToTimestamp();
UpdateBackupRequest backupUpdateRequest = new UpdateBackupRequest
{
UpdateMask = new FieldMask()
{
Paths =
{
"expire_time"
}
},
Backup = backup
};
// Make the UpdateBackup requests.
var updatedBackup = databaseAdminClient.UpdateBackup(backupUpdateRequest);
Console.WriteLine($"Updated Backup ExpireTime: {updatedBackup.ExpireTime}");
return(0);
}
/// <summary>
/// Deletes 5 oldest databases if the number of databases is more than 94.
/// This is to avoid resource exhausted errors.
/// </summary>
private async Task DeleteStaleDatabasesAsync()
{
DatabaseAdminClient databaseAdminClient = DatabaseAdminClient.Create();
var instanceName = InstanceName.FromProjectInstance(ProjectId, InstanceId);
var databases = databaseAdminClient.ListDatabases(instanceName);
if (databases.Count() < 95)
{
return;
}
var databasesToDelete = databases
.OrderBy(db => long.TryParse(
db.DatabaseName.DatabaseId.Replace("my-db-", "").Replace("my-restore-db-", ""),
out long creationDate) ? creationDate : long.MaxValue)
.Take(5);
// Delete the databases.
foreach (var database in databasesToDelete)
{
try
{
await DeleteDatabaseAsync(database.DatabaseName.DatabaseId);
}
catch (Exception) { }
}
}
public async Task UpdateDatabaseWithDefaultLeaderAsync(string projectId, string instanceId, string databaseId, string defaultLeader)
{
DatabaseAdminClient databaseAdminClient = await DatabaseAdminClient.CreateAsync();
var alterDatabaseStatement = @$ "ALTER DATABASE `{databaseId}` SET OPTIONS
(default_leader = '{defaultLeader}')";
// Create the UpdateDatabaseDdl request and execute it.
var request = new UpdateDatabaseDdlRequest
{
DatabaseAsDatabaseName = DatabaseName.FromProjectInstanceDatabase(projectId, instanceId, databaseId),
Statements = { alterDatabaseStatement }
};
var operation = await databaseAdminClient.UpdateDatabaseDdlAsync(request);
// Wait until the operation has finished.
Console.WriteLine("Waiting for the operation to finish.");
var completedResponse = await operation.PollUntilCompletedAsync();
if (completedResponse.IsFaulted)
{
Console.WriteLine($"Error while updating database: {completedResponse.Exception}");
throw completedResponse.Exception;
}
Console.WriteLine("Updated default leader");
}
/// <summary>Snippet for UpdateDatabaseDdl</summary>
public void UpdateDatabaseDdl_RequestObject()
{
// Snippet: UpdateDatabaseDdl(UpdateDatabaseDdlRequest,CallSettings)
// Create client
DatabaseAdminClient databaseAdminClient = DatabaseAdminClient.Create();
// Initialize request argument(s)
UpdateDatabaseDdlRequest request = new UpdateDatabaseDdlRequest
{
DatabaseAsDatabaseName = new DatabaseName("[PROJECT]", "[INSTANCE]", "[DATABASE]"),
Statements = { },
};
// Make the request
Operation <Empty, UpdateDatabaseDdlMetadata> response =
databaseAdminClient.UpdateDatabaseDdl(request);
// Poll until the returned long-running operation is complete
Operation <Empty, UpdateDatabaseDdlMetadata> completedResponse =
response.PollUntilCompleted();
// The long-running operation is now complete.
// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation <Empty, UpdateDatabaseDdlMetadata> retrievedResponse =
databaseAdminClient.PollOnceUpdateDatabaseDdl(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
// The long-running operation is now complete.
}
// End snippet
}
public async Task RunWithTemporaryDatabaseAsync(string instanceId, string databaseId, Func <string, Task> testFunction, params string[] extraStatements)
{
var operation = await DatabaseAdminClient.CreateDatabaseAsync(new CreateDatabaseRequest
{
ParentAsInstanceName = InstanceName.FromProjectInstance(ProjectId, instanceId),
CreateStatement = $"CREATE DATABASE `{databaseId}`",
ExtraStatements = { extraStatements },
});
var completedResponse = await operation.PollUntilCompletedAsync();
if (completedResponse.IsFaulted)
{
throw completedResponse.Exception;
}
try
{
await testFunction(databaseId);
}
finally
{
// Cleanup the test database.
await DatabaseAdminClient.DropDatabaseAsync(DatabaseName.FormatProjectInstanceDatabase(ProjectId, instanceId, databaseId));
}
}
private async Task DeleteStaleDatabasesAsync()
{
var instanceName = InstanceName.FromProjectInstance(ProjectId, InstanceId);
var databases = DatabaseAdminClient.ListDatabases(instanceName, pageSize: 200).ToList();
if (databases.Count < 50)
{
return;
}
var deleteCount = Math.Max(30, databases.Count - 50);
var databasesToDelete = databases
.OrderBy(db => long.TryParse(
db.DatabaseName.DatabaseId
.Replace("my-db-", "").Replace("my-restore-db-", "")
.Replace("my-enc-db-", "").Replace("my-enc-restore-db-", ""),
out long creationDate) ? creationDate : long.MaxValue)
.Take(deleteCount);
// Delete the databases.
foreach (var database in databasesToDelete)
{
try
{
await DeleteDatabaseAsync(database.DatabaseName.DatabaseId);
}
catch (Exception e)
{
Console.WriteLine($"Failed to delete stale test database {database.DatabaseName.DatabaseId}: {e.Message}");
}
}
}
public static object SpannerGetBackupOperations(string projectId, string instanceId, string databaseId)
{
// Create the DatabaseAdminClient instance.
DatabaseAdminClient databaseAdminClient = DatabaseAdminClient.Create();
var filter =
$"(metadata.database:{databaseId}) AND " +
"(metadata.@type:type.googleapis.com/google.spanner.admin.database.v1.CreateBackupMetadata)";
ListBackupOperationsRequest request = new ListBackupOperationsRequest
{
ParentAsInstanceName = InstanceName.FromProjectInstance(projectId, instanceId),
Filter = filter
};
// List the create backup operations on the database.
var backupOperations = databaseAdminClient.ListBackupOperations(request);
foreach (var operation in backupOperations)
{
CreateBackupMetadata metadata = operation.Metadata.Unpack <CreateBackupMetadata>();
Console.WriteLine(
$"Backup {metadata.Name} on " +
$"database {metadata.Database} is " +
$"{metadata.Progress.ProgressPercent}% complete");
}
return(0);
}
private async Task DeleteStaleBackupsAsync()
{
var instanceName = InstanceName.FromProjectInstance(ProjectId, InstanceId);
var backups = DatabaseAdminClient.ListBackups(instanceName, pageSize: 200).ToList();
if (backups.Count < 50)
{
return;
}
var deleteCount = Math.Max(30, backups.Count - 50);
var backupsToDelete = backups
.OrderBy(db => long.TryParse(
db.BackupName.BackupId.Replace("my-enc-backup-", ""),
out long creationDate) ? creationDate : long.MaxValue)
.Take(deleteCount);
// Delete the backups.
foreach (var backup in backupsToDelete)
{
try
{
await DatabaseAdminClient.DeleteBackupAsync(backup.BackupName);
}
catch (Exception) { }
}
}
public IEnumerable <Database> GetDatabases()
{
InstanceName instanceName = InstanceName.FromProjectInstance(ProjectId, InstanceId);
var databases = DatabaseAdminClient.ListDatabases(instanceName);
return(databases);
}
private async Task DeleteStaleBackupsAndDatabasesAsync()
{
DatabaseAdminClient databaseAdminClient = DatabaseAdminClient.Create();
var instanceName = InstanceName.FromProjectInstance(ProjectId, InstanceId);
var databases = databaseAdminClient.ListDatabases(instanceName)
.Where(c => c.DatabaseName.DatabaseId.StartsWith("my-db-") || c.DatabaseName.DatabaseId.StartsWith("my-restore-db-"));
var databasesToDelete = new List <string>();
// Delete all the databases created before 48 hrs.
var timestamp = DateTimeOffset.UtcNow.AddHours(-48).ToUnixTimeMilliseconds();
foreach (var database in databases)
{
var databaseId = database.DatabaseName.DatabaseId.Replace("my-restore-db-", "").Replace("my-db-", "");
if (long.TryParse(databaseId, out long dbCreationTime) && dbCreationTime <= timestamp)
{
databasesToDelete.Add(database.DatabaseName.DatabaseId);
}
}
await Console.Out.WriteLineAsync($"{databasesToDelete.Count} old databases found.");
// Get backups.
ListBackupsRequest request = new ListBackupsRequest
{
ParentAsInstanceName = instanceName,
Filter = $"database:my-db-"
};
var backups = databaseAdminClient.ListBackups(request);
// Backups that belong to the databases to be deleted.
var backupsToDelete = backups.Where(c => databasesToDelete.Contains(DatabaseName.Parse(c.Database).DatabaseId));
await Console.Out.WriteLineAsync($"{backupsToDelete.Count()} old backups found.");
// Delete the backups.
foreach (var backup in backupsToDelete)
{
try
{
DeleteBackupSample deleteBackupSample = new DeleteBackupSample();
deleteBackupSample.DeleteBackup(ProjectId, InstanceId, backup.BackupName.BackupId);
}
catch (Exception) { }
}
// Delete the databases.
foreach (var databaseId in databasesToDelete)
{
try
{
await DeleteDatabaseAsync(databaseId);
}
catch (Exception) { }
}
}
/// <summary>Snippet for GetIamPolicy</summary>
public void GetIamPolicy()
{
// Snippet: GetIamPolicy(string,CallSettings)
// Create client
DatabaseAdminClient databaseAdminClient = DatabaseAdminClient.Create();
// Initialize request argument(s)
string formattedResource = new DatabaseName("[PROJECT]", "[INSTANCE]", "[DATABASE]").ToString();
// Make the request
Policy response = databaseAdminClient.GetIamPolicy(formattedResource);
// End snippet
}
/// <summary>Snippet for GetDatabaseDdl</summary>
public void GetDatabaseDdl()
{
// Snippet: GetDatabaseDdl(DatabaseName,CallSettings)
// Create client
DatabaseAdminClient databaseAdminClient = DatabaseAdminClient.Create();
// Initialize request argument(s)
DatabaseName database = new DatabaseName("[PROJECT]", "[INSTANCE]", "[DATABASE]");
// Make the request
GetDatabaseDdlResponse response = databaseAdminClient.GetDatabaseDdl(database);
// End snippet
}
public void DeleteBackup(string projectId, string instanceId, string backupId)
{
// Create the DatabaseAdminClient instance.
DatabaseAdminClient databaseAdminClient = DatabaseAdminClient.Create();
// Make the DeleteBackup request.
BackupName backupName = BackupName.FromProjectInstanceBackup(projectId, instanceId, backupId);
databaseAdminClient.DeleteBackup(backupName);
Console.WriteLine("Backup deleted successfully.");
}
/// <summary>Snippet for SetIamPolicy</summary>
public void SetIamPolicy()
{
// Snippet: SetIamPolicy(string,Policy,CallSettings)
// Create client
DatabaseAdminClient databaseAdminClient = DatabaseAdminClient.Create();
// Initialize request argument(s)
string formattedResource = new Google.Cloud.Spanner.Common.V1.DatabaseName("[PROJECT]", "[INSTANCE]", "[DATABASE]").ToString();
Policy policy = new Policy();
// Make the request
Policy response = databaseAdminClient.SetIamPolicy(formattedResource, policy);
// End snippet
}
public void DropDatabase()
{
// Snippet: DropDatabase(string,CallSettings)
// Create client
DatabaseAdminClient databaseAdminClient = DatabaseAdminClient.Create();
// Initialize request argument(s)
string formattedDatabase = new DatabaseName("[PROJECT]", "[INSTANCE]", "[DATABASE]").ToString();
// Make the request
databaseAdminClient.DropDatabase(formattedDatabase);
// End snippet
}
/// <summary>Snippet for TestIamPermissions</summary>
public void TestIamPermissions()
{
// Snippet: TestIamPermissions(string,IEnumerable<string>,CallSettings)
// Create client
DatabaseAdminClient databaseAdminClient = DatabaseAdminClient.Create();
// Initialize request argument(s)
string formattedResource = new DatabaseName("[PROJECT]", "[INSTANCE]", "[DATABASE]").ToString();
IEnumerable <string> permissions = new List <string>();
// Make the request
TestIamPermissionsResponse response = databaseAdminClient.TestIamPermissions(formattedResource, permissions);
// End snippet
}
public void TestCreateBackup()
{
var databaseAdminClient = DatabaseAdminClient.Create();
var database = databaseAdminClient.GetDatabase(DatabaseName.FromProjectInstanceDatabase(_spannerFixture.ProjectId, _spannerFixture.InstanceId, _spannerFixture.BackupDatabaseId));
var earliestVersionTime = database.EarliestVersionTime.ToDateTime();
CreateBackupSample createBackupSample = new CreateBackupSample();
// Backup already exists since it was created in the test setup so it should throw an exception.
var exception = Assert.Throws <RpcException>(()
=> createBackupSample.CreateBackup(_spannerFixture.ProjectId, _spannerFixture.InstanceId, _spannerFixture.BackupDatabaseId, _spannerFixture.BackupId, earliestVersionTime));
Assert.Equal(StatusCode.AlreadyExists, exception.StatusCode);
}
public IEnumerable <Database> ListDatabases(string projectId, string instanceId)
{
var databaseAdminClient = DatabaseAdminClient.Create();
var instanceName = InstanceName.FromProjectInstance(projectId, instanceId);
var databases = databaseAdminClient.ListDatabases(instanceName);
foreach (var database in databases)
{
Console.WriteLine($"Default leader for database {database.DatabaseName.DatabaseId}: {database.DefaultLeader}");
}
return(databases);
}
public async Task <Database> CreateDatabaseWithEncryptionKeyAsync(string projectId, string instanceId, string databaseId, CryptoKeyName kmsKeyName)
{
// Create a DatabaseAdminClient instance that can be used to execute a
// CreateDatabaseRequest with custom encryption configuration options.
DatabaseAdminClient databaseAdminClient = DatabaseAdminClient.Create();
// Define create table statement for table #1.
var createSingersTable =
@"CREATE TABLE Singers (
SingerId INT64 NOT NULL,
FirstName STRING(1024),
LastName STRING(1024),
ComposerInfo BYTES(MAX)
) PRIMARY KEY (SingerId)";
// Define create table statement for table #2.
var createAlbumsTable =
@"CREATE TABLE Albums (
SingerId INT64 NOT NULL,
AlbumId INT64 NOT NULL,
AlbumTitle STRING(MAX)
) PRIMARY KEY (SingerId, AlbumId),
INTERLEAVE IN PARENT Singers ON DELETE CASCADE";
// Create the CreateDatabase request with encryption configuration and execute it.
var request = new CreateDatabaseRequest
{
ParentAsInstanceName = InstanceName.FromProjectInstance(projectId, instanceId),
CreateStatement = $"CREATE DATABASE `{databaseId}`",
ExtraStatements = { createSingersTable, createAlbumsTable },
EncryptionConfig = new EncryptionConfig
{
KmsKeyNameAsCryptoKeyName = kmsKeyName,
},
};
var operation = await databaseAdminClient.CreateDatabaseAsync(request);
// Wait until the operation has finished.
Console.WriteLine("Waiting for the operation to finish.");
var completedResponse = await operation.PollUntilCompletedAsync();
if (completedResponse.IsFaulted)
{
Console.WriteLine($"Error while creating database: {completedResponse.Exception}");
throw completedResponse.Exception;
}
var database = completedResponse.Result;
Console.WriteLine($"Database {database.Name} created with encryption key {database.EncryptionConfig.KmsKeyName}");
return(database);
}
/// <summary>Snippet for GetIamPolicyAsync</summary>
public async Task GetIamPolicyAsync()
{
// Snippet: GetIamPolicyAsync(string,CallSettings)
// Additional: GetIamPolicyAsync(string,CancellationToken)
// Create client
DatabaseAdminClient databaseAdminClient = await DatabaseAdminClient.CreateAsync();
// Initialize request argument(s)
string formattedResource = new DatabaseName("[PROJECT]", "[INSTANCE]", "[DATABASE]").ToString();
// Make the request
Policy response = await databaseAdminClient.GetIamPolicyAsync(formattedResource);
// End snippet
}
/// <summary>Snippet for GetIamPolicy</summary>
public void GetIamPolicy_RequestObject()
{
// Snippet: GetIamPolicy(GetIamPolicyRequest,CallSettings)
// Create client
DatabaseAdminClient databaseAdminClient = DatabaseAdminClient.Create();
// Initialize request argument(s)
GetIamPolicyRequest request = new GetIamPolicyRequest
{
Resource = new DatabaseName("[PROJECT]", "[INSTANCE]", "[DATABASE]").ToString(),
};
// Make the request
Policy response = databaseAdminClient.GetIamPolicy(request);
// End snippet
}
