/// <summary>Snippet for StreamingRead</summary>
public async Task StreamingRead()
{
// Snippet: StreamingRead(ReadRequest,CallSettings)
// Create client
SpannerClient spannerClient = SpannerClient.Create();
// Initialize request argument
ReadRequest request = new ReadRequest
{
SessionAsSessionName = new SessionName("[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]"),
Table = "",
Columns = { },
KeySet = new KeySet(),
};
// Make the request, returning a streaming response
SpannerClient.StreamingReadStream streamingResponse = spannerClient.StreamingRead(request);
// Read streaming responses from server until complete
IAsyncEnumerator <PartialResultSet> responseStream = streamingResponse.ResponseStream;
while (await responseStream.MoveNext())
{
PartialResultSet response = responseStream.Current;
// Do something with streamed response
}
// The response stream has completed
// End snippet
}
/// <inheritdoc />
private static async Task <SpannerClient> CreateClientAsync(SpannerClientCreationOptions channelOptions)
{
var credentials = await channelOptions.GetCredentialsAsync().ConfigureAwait(false);
var channel = new Channel(channelOptions.Endpoint.Host, channelOptions.Endpoint.Port, credentials);
var apiConfig = new ApiConfig
{
ChannelPool = new ChannelPoolConfig
{
MaxSize = (uint)channelOptions.MaximumGrpcChannels,
MaxConcurrentStreamsLowWatermark = channelOptions.MaximumConcurrentStreamsLowWatermark
},
Method = { s_methodConfigs }
};
var grpcOptions = new List <ChannelOption>
{
// Keep the channel alive for streaming requests.
new ChannelOption("grpc.keepalive_time_ms", 60_000),
new ChannelOption(GcpCallInvoker.ApiConfigChannelArg, apiConfig.ToString())
};
var endpoint = channelOptions.Endpoint;
var callInvoker = new GcpCallInvoker(endpoint.Host, endpoint.Port, credentials, grpcOptions);
// We don't need to modify the default timeouts themselves, because we always go through a PooledSession call that accepts
// a per-call timeout.
var settings = new SpannerSettings {
AllowImmediateTimeouts = channelOptions.AllowImmediateTimeouts
};
return(SpannerClient.Create(callInvoker, settings));
}
}
/// <inheritdoc />
private static async Task <SpannerClient> CreateClientAsync(SpannerClientCreationOptions channelOptions, SpannerSettings spannerSettings, Logger logger)
{
var credentials = await channelOptions.GetCredentialsAsync().ConfigureAwait(false);
var channel = new Channel(channelOptions.Endpoint.Host, channelOptions.Endpoint.Port, credentials);
var apiConfig = new ApiConfig
{
ChannelPool = new ChannelPoolConfig
{
MaxSize = (uint)channelOptions.MaximumGrpcChannels,
MaxConcurrentStreamsLowWatermark = channelOptions.MaximumConcurrentStreamsLowWatermark
},
Method = { s_methodConfigs }
};
var grpcOptions = new List <ChannelOption>
{
// Keep the channel alive for streaming requests.
new ChannelOption("grpc.keepalive_time_ms", 60_000),
new ChannelOption(GcpCallInvoker.ApiConfigChannelArg, apiConfig.ToString())
};
var endpoint = channelOptions.Endpoint;
var callInvoker = new GcpCallInvoker(endpoint.Host, endpoint.Port, credentials, grpcOptions);
return(SpannerClient.Create(callInvoker, spannerSettings));
}
}
/// <summary>Snippet for GetSession</summary>
public void GetSession()
{
// Snippet: GetSession(SessionName,CallSettings)
// Create client
SpannerClient spannerClient = SpannerClient.Create();
// Initialize request argument(s)
SessionName name = new SessionName("[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]");
// Make the request
Session response = spannerClient.GetSession(name);
// End snippet
}
/// <summary>Snippet for CreateSession</summary>
public void CreateSession()
{
// Snippet: CreateSession(DatabaseName,CallSettings)
// Create client
SpannerClient spannerClient = SpannerClient.Create();
// Initialize request argument(s)
DatabaseName database = new DatabaseName("[PROJECT]", "[INSTANCE]", "[DATABASE]");
// Make the request
Session response = spannerClient.CreateSession(database);
// End snippet
}
/// <summary>Snippet for BeginTransaction</summary>
public void BeginTransaction()
{
// Snippet: BeginTransaction(SessionName,TransactionOptions,CallSettings)
// Create client
SpannerClient spannerClient = SpannerClient.Create();
// Initialize request argument(s)
SessionName session = new SessionName("[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]");
TransactionOptions options = new TransactionOptions();
// Make the request
Transaction response = spannerClient.BeginTransaction(session, options);
// End snippet
}
/// <summary>Snippet for BatchCreateSessions</summary>
public void BatchCreateSessions()
{
// Snippet: BatchCreateSessions(DatabaseName,int,CallSettings)
// Create client
SpannerClient spannerClient = SpannerClient.Create();
// Initialize request argument(s)
DatabaseName database = new DatabaseName("[PROJECT]", "[INSTANCE]", "[DATABASE]");
int sessionCount = 0;
// Make the request
BatchCreateSessionsResponse response = spannerClient.BatchCreateSessions(database, sessionCount);
// End snippet
}
public void DeleteSession()
{
// Snippet: DeleteSession(string,CallSettings)
// Create client
SpannerClient spannerClient = SpannerClient.Create();
// Initialize request argument(s)
string formattedName = new SessionName("[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]").ToString();
// Make the request
spannerClient.DeleteSession(formattedName);
// End snippet
}
/// <summary>Snippet for Commit</summary>
public void Commit1()
{
// Snippet: Commit(SessionName,ByteString,IEnumerable<Mutation>,CallSettings)
// Create client
SpannerClient spannerClient = SpannerClient.Create();
// Initialize request argument(s)
SessionName session = new SessionName("[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]");
ByteString transactionId = ByteString.Empty;
IEnumerable <Mutation> mutations = new List <Mutation>();
// Make the request
CommitResponse response = spannerClient.Commit(session, transactionId, mutations);
// End snippet
}
public void Rollback()
{
// Snippet: Rollback(string,ByteString,CallSettings)
// Create client
SpannerClient spannerClient = SpannerClient.Create();
// Initialize request argument(s)
string formattedSession = new SessionName("[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]").ToString();
ByteString transactionId = ByteString.CopyFromUtf8("");
// Make the request
spannerClient.Rollback(formattedSession, transactionId);
// End snippet
}
/// <summary>Snippet for Commit</summary>
public void Commit2()
{
// Snippet: Commit(SessionName,TransactionOptions,IEnumerable<Mutation>,CallSettings)
// Create client
SpannerClient spannerClient = SpannerClient.Create();
// 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 = spannerClient.Commit(session, singleUseTransaction, mutations);
// End snippet
}
/// <summary>Snippet for Rollback</summary>
public void Rollback()
{
// Snippet: Rollback(SessionName,ByteString,CallSettings)
// Create client
SpannerClient spannerClient = SpannerClient.Create();
// Initialize request argument(s)
SessionName session = new SessionName("[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]");
ByteString transactionId = ByteString.Empty;
// Make the request
spannerClient.Rollback(session, transactionId);
// End snippet
}
/// <inheritdoc />
public async Task <SpannerClient> CreateClientAsync(ServiceEndpoint endpoint, ITokenAccess credential, IDictionary additionalOptions)
{
ChannelCredentials channelCredentials;
var allowImmediateTimeout = false;
if (additionalOptions.Contains(nameof(SpannerSettings.AllowImmediateTimeouts)))
{
allowImmediateTimeout = Convert.ToBoolean(additionalOptions[nameof(SpannerSettings.AllowImmediateTimeouts)]);
}
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(),
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
}));
}
/// <summary>Snippet for GetSession</summary>
public void GetSession_RequestObject()
{
// Snippet: GetSession(GetSessionRequest,CallSettings)
// Create client
SpannerClient spannerClient = SpannerClient.Create();
// Initialize request argument(s)
GetSessionRequest request = new GetSessionRequest
{
SessionName = new SessionName("[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]"),
};
// Make the request
Session response = spannerClient.GetSession(request);
// End snippet
}
/// <summary>Snippet for CreateSession</summary>
public void CreateSession_RequestObject()
{
// Snippet: CreateSession(CreateSessionRequest,CallSettings)
// Create client
SpannerClient spannerClient = SpannerClient.Create();
// Initialize request argument(s)
CreateSessionRequest request = new CreateSessionRequest
{
DatabaseAsDatabaseName = new DatabaseName("[PROJECT]", "[INSTANCE]", "[DATABASE]"),
};
// Make the request
Session response = spannerClient.CreateSession(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
}
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 BeginTransaction</summary>
public void BeginTransaction_RequestObject()
{
// Snippet: BeginTransaction(BeginTransactionRequest,CallSettings)
// Create client
SpannerClient spannerClient = SpannerClient.Create();
// Initialize request argument(s)
BeginTransactionRequest request = new BeginTransactionRequest
{
SessionAsSessionName = new SessionName("[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]"),
Options = new TransactionOptions(),
};
// Make the request
Transaction response = spannerClient.BeginTransaction(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
}
/// <summary>Snippet for BatchCreateSessions</summary>
public void BatchCreateSessions_RequestObject()
{
// Snippet: BatchCreateSessions(BatchCreateSessionsRequest,CallSettings)
// Create client
SpannerClient spannerClient = SpannerClient.Create();
// Initialize request argument(s)
BatchCreateSessionsRequest request = new BatchCreateSessionsRequest
{
DatabaseAsDatabaseName = new DatabaseName("[PROJECT]", "[INSTANCE]", "[DATABASE]"),
SessionCount = 0,
};
// Make the request
BatchCreateSessionsResponse response = spannerClient.BatchCreateSessions(request);
// End snippet
}
/// <summary>Snippet for ExecuteSql</summary>
public void ExecuteSql_RequestObject()
{
// Snippet: ExecuteSql(ExecuteSqlRequest,CallSettings)
// Create client
SpannerClient spannerClient = SpannerClient.Create();
// Initialize request argument(s)
ExecuteSqlRequest request = new ExecuteSqlRequest
{
SessionAsSessionName = new SessionName("[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]"),
Sql = "",
};
// Make the request
ResultSet response = spannerClient.ExecuteSql(request);
// 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
}
/// <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
}
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 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
}
/// <summary>Snippet for ListSessions</summary>
public void ListSessions_RequestObject()
{
// Snippet: ListSessions(ListSessionsRequest,CallSettings)
// Create client
SpannerClient spannerClient = SpannerClient.Create();
// Initialize request argument(s)
ListSessionsRequest request = new ListSessionsRequest
{
Database = new Google.Cloud.Spanner.Common.V1.DatabaseName("[PROJECT]", "[INSTANCE]", "[DATABASE]").ToString(),
};
// Make the request
PagedEnumerable <ListSessionsResponse, Session> response =
spannerClient.ListSessions(request);
// Iterate over all response items, lazily performing RPCs as required
foreach (Session item in response)
{
// Do something with each item
Console.WriteLine(item);
}
// Or iterate over pages (of server-defined size), performing one RPC per page
foreach (ListSessionsResponse page in response.AsRawResponses())
{
// 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 = response.ReadPage(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 <long> CustomTimeoutsAndRetriesAsync(string projectId, string instanceId, string databaseId)
{
// Create a SessionPool.
SpannerClient client = SpannerClient.Create();
SessionPool sessionPool = new SessionPool(client, new SessionPoolOptions());
// Acquire a session with a read-write transaction to run a query.
DatabaseName databaseName =
DatabaseName.FromProjectInstanceDatabase(projectId, instanceId, databaseId);
TransactionOptions transactionOptions = new TransactionOptions
{
ReadWrite = new ReadWrite()
};
using PooledSession session = await sessionPool.AcquireSessionAsync(
databaseName, transactionOptions, CancellationToken.None);
ExecuteSqlRequest request = new ExecuteSqlRequest
{
Sql = "INSERT Singers (SingerId, FirstName, LastName) VALUES (20, 'George', 'Washington')"
};
// Prepare the call settings with custom timeout and retry settings.
CallSettings settings = CallSettings
.FromExpiration(Expiration.FromTimeout(TimeSpan.FromSeconds(60)))
.WithRetry(RetrySettings.FromExponentialBackoff(
maxAttempts: 12,
initialBackoff: TimeSpan.FromMilliseconds(500),
maxBackoff: TimeSpan.FromMilliseconds(6400),
backoffMultiplier: 1.5,
retryFilter: RetrySettings.FilterForStatusCodes(
new StatusCode[] { StatusCode.Unavailable, StatusCode.DeadlineExceeded })));
ResultSet result = await session.ExecuteSqlAsync(request, settings);
await session.CommitAsync(new CommitRequest(), null);
return(result.Stats.RowCountExact);
}
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);
}
