public void ExecuteSql_RequestObject()
{
// Snippet: ExecuteSql(ExecuteSqlRequest,CallSettings)
// Create client
SpannerClient spannerClient = SpannerClient.Create();
// Initialize request argument(s)
ExecuteSqlRequest request = new ExecuteSqlRequest
{
Session = new SessionName("[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]").ToString(),
Sql = "",
};
// Make the request
ResultSet response = spannerClient.ExecuteSql(request);
// End snippet
}
public void BeginTransaction_RequestObject()
{
// Snippet: BeginTransaction(BeginTransactionRequest,CallSettings)
// Create client
SpannerClient spannerClient = SpannerClient.Create();
// Initialize request argument(s)
BeginTransactionRequest request = new BeginTransactionRequest
{
Session = new SessionName("[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]").ToString(),
Options = new TransactionOptions(),
};
// Make the request
Transaction response = spannerClient.BeginTransaction(request);
// End snippet
}
/// <summary>Snippet for PartitionQuery</summary>
public void PartitionQuery_RequestObject()
{
// Snippet: PartitionQuery(PartitionQueryRequest,CallSettings)
// Create client
SpannerClient spannerClient = SpannerClient.Create();
// Initialize request argument(s)
PartitionQueryRequest request = new PartitionQueryRequest
{
Session = new SessionName("[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]").ToString(),
Sql = "",
};
// Make the request
PartitionResponse response = spannerClient.PartitionQuery(request);
// End snippet
}
/// <summary>Snippet for Commit</summary>
public void Commit_RequestObject()
{
// Snippet: Commit(CommitRequest,CallSettings)
// Create client
SpannerClient spannerClient = SpannerClient.Create();
// Initialize request argument(s)
CommitRequest request = new CommitRequest
{
SessionAsSessionName = new SessionName("[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]"),
Mutations = { },
};
// Make the request
CommitResponse response = spannerClient.Commit(request);
// End snippet
}
public async Task BeginTransactionAsync()
{
// Snippet: BeginTransactionAsync(string,TransactionOptions,CallSettings)
// Additional: BeginTransactionAsync(string,TransactionOptions,CancellationToken)
// Create client
SpannerClient spannerClient = await SpannerClient.CreateAsync();
// Initialize request argument(s)
string formattedSession = new SessionName("[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]").ToString();
TransactionOptions options = new TransactionOptions();
// Make the request
Transaction response = await spannerClient.BeginTransactionAsync(formattedSession, options);
// End snippet
}
/// <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 = ByteString.Empty;
// Make the request
await spannerClient.RollbackAsync(session, transactionId);
// End snippet
}
public void DeleteSession_RequestObject()
{
// Snippet: DeleteSession(DeleteSessionRequest,CallSettings)
// Create client
SpannerClient spannerClient = SpannerClient.Create();
// Initialize request argument(s)
DeleteSessionRequest request = new DeleteSessionRequest
{
Name = new SessionName("[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]").ToString(),
};
// Make the request
spannerClient.DeleteSession(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
}
/// <summary>Snippet for Rollback</summary>
public void Rollback_RequestObject()
{
// Snippet: Rollback(RollbackRequest,CallSettings)
// Create client
SpannerClient spannerClient = SpannerClient.Create();
// Initialize request argument(s)
RollbackRequest request = new RollbackRequest
{
SessionAsSessionName = new SessionName("[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]"),
TransactionId = ByteString.Empty,
};
// Make the request
spannerClient.Rollback(request);
// 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 DeleteSessionAsync_RequestObject()
{
// Snippet: DeleteSessionAsync(DeleteSessionRequest,CallSettings)
// Create client
SpannerClient spannerClient = await SpannerClient.CreateAsync();
// Initialize request argument(s)
DeleteSessionRequest request = new DeleteSessionRequest
{
SessionName = new SessionName("[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]"),
};
// 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 PartitionRead</summary>
public void PartitionRead_RequestObject()
{
// Snippet: PartitionRead(PartitionReadRequest,CallSettings)
// Create client
SpannerClient spannerClient = SpannerClient.Create();
// Initialize request argument(s)
PartitionReadRequest request = new PartitionReadRequest
{
SessionAsSessionName = new SessionName("[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]"),
Table = "",
KeySet = new KeySet(),
};
// Make the request
PartitionResponse response = spannerClient.PartitionRead(request);
// End snippet
}
internal void ReleaseClient(SpannerClient spannerClient, SpannerConnectionStringBuilder connectionStringBuilder)
{
if (spannerClient != null)
{
var key = new ClientCredentialKey(connectionStringBuilder);
CredentialClientPool poolEntry;
if (_clientPoolByCredential.TryGetValue(key, out poolEntry))
{
poolEntry.ReleaseClient(spannerClient);
}
else
{
Logger.Error(() => "An attempt was made to release an unrecognized spanner client to the pool.");
}
}
}
/// <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
}
/// <inheritdoc />
public async Task <SpannerClient> CreateClientAsync(ServiceEndpoint endpoint, ChannelCredentials credentials,
IDictionary additionalOptions, Logger logger)
{
var allowImmediateTimeout = false;
if (additionalOptions.Contains(nameof(SpannerSettings.AllowImmediateTimeouts)))
{
allowImmediateTimeout = Convert.ToBoolean(additionalOptions[nameof(SpannerSettings.AllowImmediateTimeouts)]);
}
if (credentials == null)
{
credentials = await CreateDefaultChannelCredentialsAsync().ConfigureAwait(false);
}
var channel = new Channel(
endpoint.Host,
endpoint.Port,
credentials);
logger.LogPerformanceCounterFn("SpannerClient.RawCreateCount", x => x + 1);
//Pull the timeout from spanner options.
//The option must be set before OpenAsync is called.
var idempotentCallSettings = CallSettings.FromCallTiming(
CallTiming.FromRetry(
new RetrySettings(
SpannerSettings.GetDefaultRetryBackoff(),
SpannerSettings.GetDefaultTimeoutBackoff(),
SpannerSettings.ConvertTimeoutToExpiration(SpannerOptions.Instance.Timeout, allowImmediateTimeout),
SpannerSettings.IdempotentRetryFilter
)));
return(SpannerClient.Create(
channel, new SpannerSettings
{
CreateSessionSettings = idempotentCallSettings,
GetSessionSettings = idempotentCallSettings,
DeleteSessionSettings = idempotentCallSettings,
ExecuteSqlSettings = idempotentCallSettings,
ReadSettings = idempotentCallSettings,
BeginTransactionSettings = idempotentCallSettings,
CommitSettings = idempotentCallSettings,
RollbackSettings = idempotentCallSettings,
AllowImmediateTimeouts = allowImmediateTimeout
}));
}
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
}
/// <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
}
public async Task BeginTransactionAsync_RequestObject()
{
// Snippet: BeginTransactionAsync(BeginTransactionRequest,CallSettings)
// Create client
SpannerClient spannerClient = await SpannerClient.CreateAsync();
// Initialize request argument(s)
BeginTransactionRequest request = new BeginTransactionRequest
{
SessionAsSessionName = new SessionName("[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]"),
Options = new TransactionOptions(),
};
// Make the request
Transaction response = await spannerClient.BeginTransactionAsync(request);
// End snippet
}
/// <summary>Snippet for ExecuteBatchDml</summary>
public void ExecuteBatchDml_RequestObject()
{
// Snippet: ExecuteBatchDml(ExecuteBatchDmlRequest,CallSettings)
// Create client
SpannerClient spannerClient = SpannerClient.Create();
// 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 = spannerClient.ExecuteBatchDml(request);
// End snippet
}
public void Read_RequestObject()
{
// Snippet: Read(ReadRequest,CallSettings)
// Create client
SpannerClient spannerClient = SpannerClient.Create();
// 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 = spannerClient.Read(request);
// End snippet
}
/// <summary>Snippet for GetSessionAsync</summary>
public async Task GetSessionAsync_RequestObject()
{
// Snippet: GetSessionAsync(GetSessionRequest,CallSettings)
// Additional: GetSessionAsync(GetSessionRequest,CancellationToken)
// 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
}
public async Task ExecuteSqlAsync_RequestObject()
{
// Snippet: ExecuteSqlAsync(ExecuteSqlRequest,CallSettings)
// Create client
SpannerClient spannerClient = await SpannerClient.CreateAsync();
// Initialize request argument(s)
ExecuteSqlRequest request = new ExecuteSqlRequest
{
SessionAsSessionName = new SessionName("[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]"),
Sql = "",
};
// Make the request
ResultSet response = await spannerClient.ExecuteSqlAsync(request);
// End snippet
}
public Task <ReliableStreamReader> ExecuteQueryAsync(
ExecuteSqlRequest request,
CancellationToken cancellationToken,
int timeoutSeconds)
{
GaxPreconditions.CheckNotNull(request, nameof(request));
return(ExecuteHelper.WithErrorTranslationAndProfiling(
() =>
{
request.Transaction = new TransactionSelector {
SingleUse = _options
};
_client = _spannerConnection.SpannerClient;
return Task.FromResult(_client.GetSqlStreamReader(request, _session, timeoutSeconds));
},
"SingleUseTransaction.ExecuteQuery", _spannerConnection.Logger));
}
public void BatchCreateSessions()
{
SpannerClientBuilder builder = new SpannerClientBuilder
{
Endpoint = _fixture.Endpoint,
ChannelCredentials = ChannelCredentials.Insecure
};
SpannerClient client = builder.Build();
BatchCreateSessionsRequest request = new BatchCreateSessionsRequest
{
Database = "projects/p1/instances/i1/databases/d1",
SessionCount = 25,
SessionTemplate = new Session()
};
BatchCreateSessionsResponse response = client.BatchCreateSessions(request);
Assert.Equal(25, response.Session.Count);
}
/// <summary>Snippet for PartitionQueryAsync</summary>
public async Task PartitionQueryAsync_RequestObject()
{
// Snippet: PartitionQueryAsync(PartitionQueryRequest,CallSettings)
// Additional: PartitionQueryAsync(PartitionQueryRequest,CancellationToken)
// 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 void ReleaseClient(SpannerClient spannerClient,
ITokenAccess credentials = null,
ServiceEndpoint endpoint = null)
{
if (spannerClient != null)
{
var key = new ClientCredentialKey(credentials, endpoint);
CredentialClientPool poolEntry;
if (_clientPoolByCredential.TryGetValue(key, out poolEntry))
{
poolEntry.ReleaseClient(spannerClient);
}
else
{
Logger.Error(() => "An attempt was made to release an unrecognized spanner client to the pool.");
}
}
}
/// <inheritdoc />
public async Task <SpannerClient> CreateClientAsync(ServiceEndpoint endpoint, ITokenAccess credential)
{
ChannelCredentials channelCredentials;
if (credential == null)
{
channelCredentials = await CreateDefaultChannelCredentialsAsync().ConfigureAwait(false);
}
else
{
channelCredentials = credential.ToChannelCredentials();
}
var channel = new Channel(
endpoint.Host,
endpoint.Port,
channelCredentials);
Logger.LogPerformanceCounterFn("SpannerClient.RawCreateCount", x => x + 1);
//Pull the timeout from spanner options.
//The option must be set before OpenAsync is called.
var idempotentCallSettings = CallSettings.FromCallTiming(
CallTiming.FromRetry(
new RetrySettings(
SpannerSettings.GetDefaultRetryBackoff(),
SpannerSettings.GetDefaultTimeoutBackoff(),
Expiration.FromTimeout(SpannerOptions.Instance.Timeout),
SpannerSettings.IdempotentRetryFilter
)));
return(SpannerClient.Create(
channel, new SpannerSettings
{
CreateSessionSettings = idempotentCallSettings,
GetSessionSettings = idempotentCallSettings,
DeleteSessionSettings = idempotentCallSettings,
ExecuteSqlSettings = idempotentCallSettings,
ReadSettings = idempotentCallSettings,
BeginTransactionSettings = idempotentCallSettings,
CommitSettings = idempotentCallSettings,
RollbackSettings = idempotentCallSettings
}));
}
