public async Task GetStatementAsync_Should_Prepare_Once_And_Cache()
{
var sessionMock = new Mock <ISession>(MockBehavior.Strict);
sessionMock.Setup(s => s.Keyspace).Returns <string>(null);
sessionMock
.Setup(s => s.PrepareAsync(It.IsAny <string>()))
.Returns <string>(q => Task.FromResult(GetPrepared(q)));
var cql = Cql.New("Q");
var sf = new StatementFactory();
var statement = await sf.GetStatementAsync(sessionMock.Object, cql).ConfigureAwait(false);
Assert.IsInstanceOf <BoundStatement>(statement);
var ps = ((BoundStatement)statement).PreparedStatement;
for (var i = 0; i < 10; i++)
{
var bound = (BoundStatement)await sf.GetStatementAsync(sessionMock.Object, cql).ConfigureAwait(false);
Assert.AreSame(ps, bound.PreparedStatement);
}
}
/// <summary>
/// Executes asynchronously and uses the delegate to adapt the RowSet into the return value.
/// </summary>
private async Task <TResult> ExecuteAsyncAndAdapt <TResult>(Cql cql, Func <Statement, RowSet, TResult> adaptation)
{
var stmt = await _statementFactory.GetStatementAsync(_session, cql).ConfigureAwait(false);
var rs = await ExecuteStatementAsync(stmt, cql.ExecutionProfile).ConfigureAwait(false);
return(adaptation(stmt, rs));
}
/// <summary>
/// Executes asynchronously and uses the delegate to adapt the RowSet into the return value.
/// </summary>
private Task <TResult> ExecuteAsyncAndAdapt <TResult>(Cql cql, Func <Statement, RowSet, TResult> adaptation)
{
return(_statementFactory
.GetStatementAsync(_session, cql)
.Continue(t1 =>
_session
.ExecuteAsync(t1.Result)
.Continue(t2 => adaptation(t1.Result, t2.Result)))
//From Task<Task<TResult>> to Task<TResult>
.Unwrap());
}
public async Task GetStatementAsync_Should_Reprepare_Each_Time_After_Failed_Attempt()
{
var preparationFails = 1;
var sessionMock = new Mock <ISession>(MockBehavior.Strict);
sessionMock.Setup(s => s.Keyspace).Returns <string>(null);
sessionMock
.Setup(s => s.PrepareAsync(It.IsAny <string>()))
.Returns <string>(q =>
{
if (Volatile.Read(ref preparationFails) == 1)
{
throw new InvalidQueryException("Test temporal invalid query");
}
return(Task.FromResult(GetPrepared(q)));
});
var sf = new StatementFactory();
var cql = Cql.New("Q");
Parallel.For(0, 4, _ =>
{
Assert.Throws <InvalidQueryException>(() =>
TaskHelper.WaitToComplete(sf.GetStatementAsync(sessionMock.Object, cql)));
});
Interlocked.Exchange(ref preparationFails, 0);
// Should not fail after setting the flag
var statement = await sf.GetStatementAsync(sessionMock.Object, cql).ConfigureAwait(false);
Assert.IsInstanceOf <BoundStatement>(statement);
var ps = ((BoundStatement)statement).PreparedStatement;
for (var i = 0; i < 10; i++)
{
var bound = (BoundStatement)await sf.GetStatementAsync(sessionMock.Object, cql).ConfigureAwait(false);
Assert.AreSame(ps, bound.PreparedStatement);
}
}
public async Task <RowSet> ExecuteAsync()
{
object[] values;
var cqlQuery = GetCql(out values);
var session = GetTable().GetSession();
var stmt = await _statementFactory.GetStatementAsync(session, Cql.New(cqlQuery, values)).ConfigureAwait(false);
this.CopyQueryPropertiesTo(stmt);
return(await session.ExecuteAsync(stmt).ConfigureAwait(false));
}
/// <summary>
/// Asynchronously executes a conditional query and returns information whether it was applied.
/// </summary>
public new async Task <AppliedInfo <TEntity> > ExecuteAsync()
{
object[] values;
var cql = GetCql(out values);
var session = GetTable().GetSession();
var stmt = await StatementFactory.GetStatementAsync(session, Cql.New(cql, values)).ConfigureAwait(false);
this.CopyQueryPropertiesTo(stmt);
var rs = await session.ExecuteAsync(stmt).ConfigureAwait(false);
return(AppliedInfo <TEntity> .FromRowSet(_mapperFactory, cql, rs));
}
protected Task <RowSet> InternalExecuteAsync(string cqlQuery, object[] values)
{
var session = GetTable().GetSession();
return(StatementFactory
.GetStatementAsync(session, Cql.New(cqlQuery, values))
.ContinueSync(stmt =>
{
this.CopyQueryPropertiesTo(stmt);
return session.ExecuteAsync(stmt);
}).Unwrap());
}
public async Task GetStatementAsync_Should_Cache_Based_On_Query_Keyspace_And_Session_Instance()
{
var sessionMock1 = new Mock <ISession>(MockBehavior.Strict);
sessionMock1.Setup(s => s.Keyspace).Returns("ks1");
sessionMock1
.Setup(s => s.PrepareAsync(It.IsAny <string>()))
.Returns <string>(q => Task.FromResult(GetPrepared(q)));
var sessionMock2 = new Mock <ISession>(MockBehavior.Strict);
sessionMock2.Setup(s => s.Keyspace).Returns("ks2");
sessionMock2
.Setup(s => s.PrepareAsync(It.IsAny <string>()))
.Returns <string>(q => Task.FromResult(GetPrepared(q)));
var cql1A = Cql.New("Q1");
var cql1B = Cql.New("Q1");
var cql2 = Cql.New("Q2");
var sf = new StatementFactory();
var statement = await sf.GetStatementAsync(sessionMock1.Object, cql1A).ConfigureAwait(false);
var ps1 = GetPreparedStatement(statement);
for (var i = 0; i < 10; i++)
{
var bound1 = await sf.GetStatementAsync(sessionMock1.Object, cql1B)
.ConfigureAwait(false);
Assert.AreSame(ps1, GetPreparedStatement(bound1));
}
var bound2 = await sf.GetStatementAsync(sessionMock1.Object, cql2).ConfigureAwait(false);
// Different CQL should be cached differently
Assert.AreNotSame(ps1, GetPreparedStatement(bound2));
sessionMock1.Setup(s => s.Keyspace).Returns("ks2");
// Different keyspace, same query
var differentKsStatement = await sf.GetStatementAsync(sessionMock1.Object, cql1A).ConfigureAwait(false);
var psSession1 = GetPreparedStatement(differentKsStatement);
Assert.AreNotSame(ps1, psSession1);
// Different Session instance
var boundSession2 = await sf.GetStatementAsync(sessionMock2.Object, cql1A).ConfigureAwait(false);
var psSession2 = GetPreparedStatement(boundSession2);
Assert.AreNotSame(psSession1, psSession2);
// Same ks, query and ISession instance
var bound3 = await sf.GetStatementAsync(sessionMock2.Object, cql1A).ConfigureAwait(false);
Assert.AreSame(psSession2, GetPreparedStatement(bound3));
}
public async Task GetStatementAsync_Should_Prepare_Once_And_Cache()
{
var createdPreparedStatementsBag = new ConcurrentBag <Task <PreparedStatement> >();
var sessionMock = new Mock <ISession>(MockBehavior.Strict);
sessionMock.Setup(s => s.Keyspace).Returns <string>(null);
sessionMock
.Setup(s => s.PrepareAsync(It.IsAny <string>()))
.Returns <string>(q =>
{
var task = Task.FromResult(GetPrepared(q));
createdPreparedStatementsBag.Add(task);
return(task);
});
var cql = Cql.New("Q");
var sf = new StatementFactory();
var concurrentTasks = 1000;
var semaphore = new SemaphoreSlim(0, concurrentTasks);
var tasks =
Enumerable.Range(0, concurrentTasks)
.Select(_ => Task.Run(
async() =>
{
await semaphore.WaitAsync().ConfigureAwait(false);
return(await sf.GetStatementAsync(sessionMock.Object, cql).ConfigureAwait(false));
}))
.ToArray();
semaphore.Release(concurrentTasks);
await Task.WhenAll(tasks).ConfigureAwait(false);
var boundStatementsSet = new HashSet <BoundStatement>(
tasks.Select(t => (BoundStatement)t.Result),
new ReferenceEqualityComparer <BoundStatement>());
var preparedStatementsSet = new HashSet <PreparedStatement>(
tasks.Select(t => ((BoundStatement)t.Result).PreparedStatement),
new ReferenceEqualityComparer <PreparedStatement>());
var createdPreparedStatementsSet = new HashSet <PreparedStatement>(
createdPreparedStatementsBag.Select(t => t.Result),
new ReferenceEqualityComparer <PreparedStatement>());
Assert.AreEqual(1, preparedStatementsSet.Count);
Assert.AreEqual(concurrentTasks, boundStatementsSet.Count);
Assert.AreEqual(1, createdPreparedStatementsSet.Count);
}
public Task <RowSet> ExecuteAsync()
{
object[] values;
var cqlQuery = GetCql(out values);
var session = GetTable().GetSession();
return(_statementFactory
.GetStatementAsync(session, Cql.New(cqlQuery, values))
.Continue(t1 =>
{
var stmt = t1.Result;
this.CopyQueryPropertiesTo(stmt);
return session.ExecuteAsync(stmt);
}).Unwrap());
}
/// <summary>
/// Asynchronously executes a conditional query and returns information whether it was applied.
/// </summary>
public new Task <AppliedInfo <TEntity> > ExecuteAsync()
{
object[] values;
var cql = GetCql(out values);
var session = GetTable().GetSession();
return(StatementFactory
.GetStatementAsync(session, Cql.New(cql, values))
.Continue(t1 =>
{
var stmt = t1.Result;
this.CopyQueryPropertiesTo(stmt);
return session
.ExecuteAsync(stmt)
.Continue(t => AppliedInfo <TEntity> .FromRowSet(_mapperFactory, cql, t.Result));
})
.Unwrap());
}
public async Task <List <T> > FetchAsync <T>(Cql cql)
{
// Get the statement to execute and execute it
_cqlGenerator.AddSelect <T>(cql);
Statement statement = await _statementFactory.GetStatementAsync(cql).ConfigureAwait(false);
RowSet rows = await _session.ExecuteAsync(statement).ConfigureAwait(false);
// Map to return type
Func <Row, T> mapper = _mapperFactory.GetMapper <T>(cql.Statement, rows);
return(rows.Select(mapper).ToList());
}
/// <summary>
/// Asynchronously executes a conditional query with the provided execution profile and returns information whether it was applied.
/// </summary>
public new async Task <AppliedInfo <TEntity> > ExecuteAsync(string executionProfile)
{
if (executionProfile == null)
{
throw new ArgumentNullException(nameof(executionProfile));
}
object[] values;
var cql = GetCql(out values);
var session = GetTable().GetSession();
var stmt = await StatementFactory.GetStatementAsync(
session,
Cql.New(cql, values).WithExecutionProfile(executionProfile)).ConfigureAwait(false);
this.CopyQueryPropertiesTo(stmt);
var rs = await session.ExecuteAsync(stmt, executionProfile).ConfigureAwait(false);
return(AppliedInfo <TEntity> .FromRowSet(_mapperFactory, cql, rs));
}
public async Task GetStatementAsync_Should_PrepareTwiceAndCache_When_FirstPrepareFails()
{
var createdPreparedStatementsBag = new ConcurrentBag <Task <PreparedStatement> >();
var sessionMock = new Mock <ISession>(MockBehavior.Strict);
var firstTime = 1;
var exceptionMessage = "Test exception in prepare.";
sessionMock.Setup(s => s.Keyspace).Returns <string>(null);
sessionMock
.Setup(s => s.PrepareAsync(It.IsAny <string>()))
.Returns <string>(q =>
{
if (Interlocked.CompareExchange(ref firstTime, 0, 1) == 1)
{
PreparedStatement Func() => throw new Exception(exceptionMessage);
return(Task.Run((Func <PreparedStatement>)Func));
}
var task = Task.FromResult(GetPrepared(q));
createdPreparedStatementsBag.Add(task);
return(task);
});
var cql = Cql.New("Q");
var sf = new StatementFactory();
var concurrentTasks = 1000;
var semaphore = new SemaphoreSlim(0, concurrentTasks);
var tasks =
Enumerable.Range(0, concurrentTasks)
.Select(_ => Task.Run(
async() =>
{
await semaphore.WaitAsync().ConfigureAwait(false);
return(await sf.GetStatementAsync(sessionMock.Object, cql).ConfigureAwait(false));
}))
.ToArray();
semaphore.Release(concurrentTasks);
try
{
await Task.WhenAll(tasks).ConfigureAwait(false);
}
catch (Exception ex)
{
Assert.AreEqual(exceptionMessage, ex.Message);
}
Assert.AreEqual(1, tasks.Count(t => t.IsFaulted));
Assert.AreEqual(concurrentTasks - 1, tasks.Count(t => t.IsCompleted && !t.IsFaulted));
tasks = tasks.Where(t => !t.IsFaulted).ToArray();
var boundStatementsSet = new HashSet <BoundStatement>(
tasks.Select(t => (BoundStatement)t.Result),
new ReferenceEqualityComparer <BoundStatement>());
var preparedStatementsSet = new HashSet <PreparedStatement>(
tasks.Select(t => ((BoundStatement)t.Result).PreparedStatement),
new ReferenceEqualityComparer <PreparedStatement>());
var createdPreparedStatementsSet = new HashSet <PreparedStatement>(
createdPreparedStatementsBag.Select(t => t.Result),
new ReferenceEqualityComparer <PreparedStatement>());
Assert.AreEqual(1, preparedStatementsSet.Count);
Assert.AreEqual(concurrentTasks - 1, boundStatementsSet.Count);
Assert.AreEqual(1, createdPreparedStatementsSet.Count);
}
