public async Task <IEnumerable <long> > ExecuteBatchDmlAsync(ExecuteBatchDmlRequest request, CancellationToken cancellationToken, int timeoutSeconds)
{
_hasExecutedDml = true;
ISpannerTransaction transaction = await SpannerTransactionTask.ConfigureAwait(false);
return(await transaction.ExecuteBatchDmlAsync(request, cancellationToken, timeoutSeconds).ConfigureAwait(false));
}
public async Task ExecuteBatchDmlAsync_RequestTransactionIsLeftAloneWhenPresent()
{
var pool = new FakeSessionPool();
var pooledSession = PooledSession.FromSessionName(pool, s_sampleSessionName);
// Make a successful request
var request = new ExecuteBatchDmlRequest {
Transaction = new TransactionSelector {
Begin = new TransactionOptions {
ReadOnly = new TransactionOptions.Types.ReadOnly()
}
}
};
pool.Mock.Setup(client => client.ExecuteBatchDmlAsync(request, It.IsAny <CallSettings>()))
.ReturnsAsync(new ExecuteBatchDmlResponse())
.Verifiable();
await pooledSession.ExecuteBatchDmlAsync(request, null);
// The call modifies the request's session, but not transaction.
Assert.Equal(s_sampleSessionName, request.SessionAsSessionName);
Assert.Equal(TransactionSelector.SelectorOneofCase.Begin, request.Transaction.SelectorCase);
Assert.Equal(new TransactionOptions.Types.ReadOnly(), request.Transaction.Begin.ReadOnly);
pool.Mock.Verify();
}
private async Task <IReadOnlyList <long> > ExecuteBatchDmlAsync(CancellationToken cancellationToken)
{
await Connection.EnsureIsOpenAsync(cancellationToken).ConfigureAwait(false);
var transaction = Transaction ?? Connection.AmbientTransaction ?? new EphemeralTransaction(Connection, s_readWriteOptions);
ExecuteBatchDmlRequest request = GetExecuteBatchDmlRequest();
IEnumerable <long> result = await transaction.ExecuteBatchDmlAsync(request, cancellationToken, CommandTimeout).ConfigureAwait(false);
return(result.ToList().AsReadOnly());
}
private ExecuteBatchDmlRequest GetExecuteBatchDmlRequest()
{
var request = new ExecuteBatchDmlRequest();
foreach (var command in Commands)
{
var statement = new Statement {
Sql = command.CommandText
};
command.Parameters.FillSpannerCommandParams(out var parameters, statement.ParamTypes, null);
statement.Params = parameters;
request.Statements.Add(statement);
}
return(request);
}
/// <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 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 ExecuteBatchDmlAsync()
{
Mock <Spanner.SpannerClient> mockGrpcClient = new Mock <Spanner.SpannerClient>(MockBehavior.Strict);
ExecuteBatchDmlRequest request = new ExecuteBatchDmlRequest
{
SessionAsSessionName = new SessionName("[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]"),
Transaction = new TransactionSelector(),
Statements = { },
Seqno = 109325920L,
};
ExecuteBatchDmlResponse expectedResponse = new ExecuteBatchDmlResponse();
mockGrpcClient.Setup(x => x.ExecuteBatchDmlAsync(request, It.IsAny <CallOptions>()))
.Returns(new Grpc.Core.AsyncUnaryCall <ExecuteBatchDmlResponse>(Task.FromResult(expectedResponse), null, null, null, null));
SpannerClient client = new SpannerClientImpl(mockGrpcClient.Object, null);
ExecuteBatchDmlResponse response = await client.ExecuteBatchDmlAsync(request);
Assert.Same(expectedResponse, response);
mockGrpcClient.VerifyAll();
}
public async Task ExecuteBatchDmlAsync_RequestTransactionIsPopulatedWhenNotPresent()
{
var pool = new FakeSessionPool();
var transactionId = ByteString.CopyFromUtf8("transaction");
var pooledSession = PooledSession.FromSessionName(pool, s_sampleSessionName);
var sessionWithTransaction = pooledSession.WithTransaction(transactionId, ReadWrite);
// Make a successful request
var request = new ExecuteBatchDmlRequest();
pool.Mock.Setup(client => client.ExecuteBatchDmlAsync(request, It.IsAny <CallSettings>()))
.ReturnsAsync(new ExecuteBatchDmlResponse())
.Verifiable();
await sessionWithTransaction.ExecuteBatchDmlAsync(request, null);
// The call modifies the request. (We can't easily check that it was modified before the RPC)
Assert.Equal(s_sampleSessionName, request.SessionAsSessionName);
Assert.Equal(transactionId, request.Transaction.Id);
pool.Mock.Verify();
}
public Task <IEnumerable <long> > ExecuteBatchDmlAsync(ExecuteBatchDmlRequest request, CancellationToken cancellationToken, int timeoutSeconds)
{
return(ExecuteHelper.WithErrorTranslationAndProfiling(Impl, "EphemeralTransaction.ExecuteBatchDmlAsync", _connection.Logger));
async Task <IEnumerable <long> > Impl()
{
using (var transaction = await _connection.BeginTransactionImplAsync(_transactionOptions, TransactionMode.ReadWrite, cancellationToken).ConfigureAwait(false))
{
transaction.CommitTimeout = timeoutSeconds;
IEnumerable <long> result;
result = await((ISpannerTransaction)transaction)
.ExecuteBatchDmlAsync(request, cancellationToken, timeoutSeconds)
.ConfigureAwait(false);
await transaction.CommitAsync(cancellationToken).ConfigureAwait(false);
return(result);
}
}
}
