/// <summary>Snippet for RollbackAsync</summary>
public async Task RollbackAsync()
{
// Snippet: RollbackAsync(SessionName,ByteString,CallSettings)
// Additional: RollbackAsync(SessionName,ByteString,CancellationToken)
// Create client
SpannerClient spannerClient = await SpannerClient.CreateAsync();
// Initialize request argument(s)
SessionName session = new SessionName("[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]");
ByteString transactionId = Google.Protobuf.ByteString.CopyFromUtf8("");
// Make the request
await spannerClient.RollbackAsync(session, transactionId);
// End snippet
}
/// <summary>Snippet for BeginTransactionAsync</summary>
public async Task BeginTransactionAsync()
{
// Snippet: BeginTransactionAsync(SessionName,TransactionOptions,CallSettings)
// Additional: BeginTransactionAsync(SessionName,TransactionOptions,CancellationToken)
// Create client
SpannerClient spannerClient = await SpannerClient.CreateAsync();
// Initialize request argument(s)
SessionName session = new SessionName("[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]");
TransactionOptions options = new TransactionOptions();
// Make the request
Transaction response = await spannerClient.BeginTransactionAsync(session, options);
// End snippet
}
public async Task CreateSessionAsync_RequestObject()
{
// Snippet: CreateSessionAsync(CreateSessionRequest,CallSettings)
// Create client
SpannerClient spannerClient = await SpannerClient.CreateAsync();
// Initialize request argument(s)
CreateSessionRequest request = new CreateSessionRequest
{
Database = new DatabaseName("[PROJECT]", "[INSTANCE]", "[DATABASE]").ToString(),
};
// Make the request
Session response = await spannerClient.CreateSessionAsync(request);
// End snippet
}
public async Task GetSessionAsync_RequestObject()
{
// Snippet: GetSessionAsync(GetSessionRequest,CallSettings)
// Create client
SpannerClient spannerClient = await SpannerClient.CreateAsync();
// Initialize request argument(s)
GetSessionRequest request = new GetSessionRequest
{
SessionName = new SessionName("[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]"),
};
// Make the request
Session response = await spannerClient.GetSessionAsync(request);
// End snippet
}
/// <summary>Snippet for CommitAsync</summary>
public async Task CommitAsync2()
{
// Snippet: CommitAsync(SessionName,TransactionOptions,IEnumerable<Mutation>,CallSettings)
// Additional: CommitAsync(SessionName,TransactionOptions,IEnumerable<Mutation>,CancellationToken)
// Create client
SpannerClient spannerClient = await SpannerClient.CreateAsync();
// Initialize request argument(s)
SessionName session = new SessionName("[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]");
TransactionOptions singleUseTransaction = new TransactionOptions();
IEnumerable <Mutation> mutations = new List <Mutation>();
// Make the request
CommitResponse response = await spannerClient.CommitAsync(session, singleUseTransaction, mutations);
// End snippet
}
public async Task DeleteSessionAsync_RequestObject()
{
// Snippet: DeleteSessionAsync(DeleteSessionRequest,CallSettings)
// Create client
SpannerClient spannerClient = await SpannerClient.CreateAsync();
// Initialize request argument(s)
DeleteSessionRequest request = new DeleteSessionRequest
{
Name = new SessionName("[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]").ToString(),
};
// Make the request
await spannerClient.DeleteSessionAsync(request);
// End snippet
}
public async Task CommitAsync1()
{
// Snippet: CommitAsync(string,ByteString,IEnumerable<Mutation>,CallSettings)
// Additional: CommitAsync(string,ByteString,IEnumerable<Mutation>,CancellationToken)
// Create client
SpannerClient spannerClient = await SpannerClient.CreateAsync();
// Initialize request argument(s)
string formattedSession = new SessionName("[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]").ToString();
ByteString transactionId = ByteString.CopyFromUtf8("");
IEnumerable <Mutation> mutations = new List <Mutation>();
// Make the request
CommitResponse response = await spannerClient.CommitAsync(formattedSession, transactionId, mutations);
// End snippet
}
/// <summary>Snippet for ListSessionsAsync</summary>
public async Task ListSessionsAsync_RequestObject()
{
// Snippet: ListSessionsAsync(ListSessionsRequest,CallSettings)
// Create client
SpannerClient spannerClient = await SpannerClient.CreateAsync();
// Initialize request argument(s)
ListSessionsRequest request = new ListSessionsRequest
{
Database = new Google.Cloud.Spanner.Common.V1.DatabaseName("[PROJECT]", "[INSTANCE]", "[DATABASE]").ToString(),
};
// Make the request
PagedAsyncEnumerable <ListSessionsResponse, Session> response =
spannerClient.ListSessionsAsync(request);
// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((Session item) =>
{
// Do something with each item
Console.WriteLine(item);
});
// Or iterate over pages (of server-defined size), performing one RPC per page
await response.AsRawResponses().ForEachAsync((ListSessionsResponse page) =>
{
// Do something with each page of items
Console.WriteLine("A page of results:");
foreach (Session item in page)
{
Console.WriteLine(item);
}
});
// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page <Session> singlePage = await response.ReadPageAsync(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (Session item in singlePage)
{
Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;
// End snippet
}
public async Task RollbackAsync_RequestObject()
{
// Snippet: RollbackAsync(RollbackRequest,CallSettings)
// Create client
SpannerClient spannerClient = await SpannerClient.CreateAsync();
// Initialize request argument(s)
RollbackRequest request = new RollbackRequest
{
Session = new SessionName("[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]").ToString(),
TransactionId = ByteString.CopyFromUtf8(""),
};
// Make the request
await spannerClient.RollbackAsync(request);
// End snippet
}
public async Task CommitAsync_RequestObject()
{
// Snippet: CommitAsync(CommitRequest,CallSettings)
// Create client
SpannerClient spannerClient = await SpannerClient.CreateAsync();
// Initialize request argument(s)
CommitRequest request = new CommitRequest
{
Session = new SessionName("[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]").ToString(),
Mutations = { },
};
// Make the request
CommitResponse response = await spannerClient.CommitAsync(request);
// End snippet
}
public async Task BeginTransactionAsync_RequestObject()
{
// Snippet: BeginTransactionAsync(BeginTransactionRequest,CallSettings)
// Create client
SpannerClient spannerClient = await SpannerClient.CreateAsync();
// Initialize request argument(s)
BeginTransactionRequest request = new BeginTransactionRequest
{
Session = new SessionName("[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]").ToString(),
Options = new TransactionOptions(),
};
// Make the request
Transaction response = await spannerClient.BeginTransactionAsync(request);
// End snippet
}
public async Task ExecuteSqlAsync_RequestObject()
{
// Snippet: ExecuteSqlAsync(ExecuteSqlRequest,CallSettings)
// Create client
SpannerClient spannerClient = await SpannerClient.CreateAsync();
// Initialize request argument(s)
ExecuteSqlRequest request = new ExecuteSqlRequest
{
Session = new SessionName("[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]").ToString(),
Sql = "",
};
// Make the request
ResultSet response = await spannerClient.ExecuteSqlAsync(request);
// End snippet
}
/// <summary>Snippet for BatchCreateSessionsAsync</summary>
public async Task BatchCreateSessionsAsync_RequestObject()
{
// Snippet: BatchCreateSessionsAsync(BatchCreateSessionsRequest,CallSettings)
// Additional: BatchCreateSessionsAsync(BatchCreateSessionsRequest,CancellationToken)
// Create client
SpannerClient spannerClient = await SpannerClient.CreateAsync();
// Initialize request argument(s)
BatchCreateSessionsRequest request = new BatchCreateSessionsRequest
{
DatabaseAsDatabaseName = new DatabaseName("[PROJECT]", "[INSTANCE]", "[DATABASE]"),
};
// Make the request
BatchCreateSessionsResponse response = await spannerClient.BatchCreateSessionsAsync(request);
// End snippet
}
/// <summary>Snippet for PartitionQueryAsync</summary>
public async Task PartitionQueryAsync_RequestObject()
{
// Snippet: PartitionQueryAsync(PartitionQueryRequest,CallSettings)
// Create client
SpannerClient spannerClient = await SpannerClient.CreateAsync();
// Initialize request argument(s)
PartitionQueryRequest request = new PartitionQueryRequest
{
Session = new SessionName("[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]").ToString(),
Sql = "",
};
// Make the request
PartitionResponse response = await spannerClient.PartitionQueryAsync(request);
// End snippet
}
/// <summary>Snippet for RollbackAsync</summary>
public async Task RollbackAsync_RequestObject()
{
// Snippet: RollbackAsync(RollbackRequest,CallSettings)
// Additional: RollbackAsync(RollbackRequest,CancellationToken)
// Create client
SpannerClient spannerClient = await SpannerClient.CreateAsync();
// Initialize request argument(s)
RollbackRequest request = new RollbackRequest
{
SessionAsSessionName = new SessionName("[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]"),
TransactionId = ByteString.Empty,
};
// Make the request
await spannerClient.RollbackAsync(request);
// End snippet
}
public async Task ReadAsync_RequestObject()
{
// Snippet: ReadAsync(ReadRequest,CallSettings)
// Create client
SpannerClient spannerClient = await SpannerClient.CreateAsync();
// Initialize request argument(s)
ReadRequest request = new ReadRequest
{
Session = new SessionName("[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]").ToString(),
Table = "",
Columns = { },
KeySet = new KeySet(),
};
// Make the request
ResultSet response = await spannerClient.ReadAsync(request);
// End snippet
}
/// <summary>Snippet for PartitionReadAsync</summary>
public async Task PartitionReadAsync_RequestObject()
{
// Snippet: PartitionReadAsync(PartitionReadRequest,CallSettings)
// Additional: PartitionReadAsync(PartitionReadRequest,CancellationToken)
// Create client
SpannerClient spannerClient = await SpannerClient.CreateAsync();
// Initialize request argument(s)
PartitionReadRequest request = new PartitionReadRequest
{
SessionAsSessionName = new SessionName("[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]"),
Table = "",
KeySet = new KeySet(),
};
// Make the request
PartitionResponse response = await spannerClient.PartitionReadAsync(request);
// End snippet
}
/// <summary>Snippet for ExecuteBatchDmlAsync</summary>
public async Task ExecuteBatchDmlAsync_RequestObject()
{
// Snippet: ExecuteBatchDmlAsync(ExecuteBatchDmlRequest,CallSettings)
// Additional: ExecuteBatchDmlAsync(ExecuteBatchDmlRequest,CancellationToken)
// Create client
SpannerClient spannerClient = await SpannerClient.CreateAsync();
// Initialize request argument(s)
ExecuteBatchDmlRequest request = new ExecuteBatchDmlRequest
{
SessionAsSessionName = new SessionName("[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]"),
Transaction = new TransactionSelector(),
Statements = { },
Seqno = 0L,
};
// Make the request
ExecuteBatchDmlResponse response = await spannerClient.ExecuteBatchDmlAsync(request);
// End snippet
}
public async Task <SpannerClient> AcquireClientFromEntryAsync()
{
if (_client == null)
{
Logger.Debug(() => "Creating a new SpannerClient.");
var endpoint = _key.Endpoint ?? SpannerClient.DefaultEndpoint;
if (_key.Credential != null)
{
lock (_sync)
{
if (_client == null)
{
var channel = new Channel(
endpoint.Host,
endpoint.Port,
_key.Credential.ToChannelCredentials());
_client = SpannerClient.Create(channel);
}
}
}
else
{
lock (_sync)
{
if (_creationTask == null || _creationTask.IsFaulted)
{
_creationTask = SpannerClient.CreateAsync(endpoint);
}
}
// await needs to be done outside of the monitor.
_client = await _creationTask.ConfigureAwait(false);
}
}
return(_client);
}
