private static ResultCursorBuilder GenerateBuilder(IDictionary <string, object> meta = null)
{
var builder = new ResultCursorBuilder();
builder.CollectFields(meta ?? new Dictionary <string, object> {
{ "fields", new List <object> {
"x"
} }
});
return(builder);
}
public async Task ShouldPauseAndResumeStreamingWithWatermarks()
{
var actions = new Queue <Action>();
var resourceHandler = new Mock <IResultResourceHandler>();
var builder =
new ResultCursorBuilder(CreateSummaryBuilder(), CreateTaskQueue(),
CreateMoreTaskQueue(actions),
null,
resourceHandler.Object, 2);
var counter = 0;
builder.RunCompleted(0, new[] { "a" }, null);
builder.PullCompleted(true, null);
builder.CurrentState.Should().Be(ResultCursorBuilder.State.RunCompleted);
actions.Enqueue(() =>
{
builder.PushRecord(new object[] { 1 });
counter++;
builder.PushRecord(new object[] { 2 });
counter++;
builder.PullCompleted(true, null);
});
actions.Enqueue(() =>
{
builder.PushRecord(new object[] { 3 });
counter++;
builder.PullCompleted(false, null);
});
var cursor = builder.CreateCursor();
var hasNext = await cursor.FetchAsync();
hasNext.Should().BeTrue();
resourceHandler.Verify(x => x.OnResultConsumedAsync(), Times.Never);
counter.Should().Be(2);
hasNext = await cursor.FetchAsync();
hasNext.Should().BeTrue();
resourceHandler.Verify(x => x.OnResultConsumedAsync(), Times.Once);
counter.Should().Be(3);
hasNext = await cursor.FetchAsync();
hasNext.Should().BeTrue();
counter.Should().Be(3);
hasNext = await cursor.FetchAsync();
hasNext.Should().BeFalse();
counter.Should().Be(3);
}
public void ShouldTransitionToCompletedWhenPullCompleted()
{
var builder =
new ResultCursorBuilder(CreateSummaryBuilder(), CreateTaskQueue(), null, null, null)
{
CurrentState = ResultCursorBuilder.State.RecordsStreaming
};
builder.PullCompleted(false, null);
builder.CurrentState.Should().Be(ResultCursorBuilder.State.Completed);
}
public async Task <IStatementResultCursor> RunInExplicitTransactionAsync(IConnection connection,
Statement statement)
{
var resultBuilder = new ResultCursorBuilder(
NewSummaryCollector(statement, connection.Server), connection.ReceiveOneAsync);
connection.Enqueue(new RunMessage(statement), resultBuilder, PullAll);
await connection.SendAsync().ConfigureAwait(false);
return(await resultBuilder.PreBuildAsync().ConfigureAwait(false));
}
public virtual async Task <IResultCursor> RunInExplicitTransactionAsync(IConnection connection, Query query, bool reactive, long fetchSize = Config.Infinite)
{
var summaryBuilder = new SummaryBuilder(query, connection.Server);
var streamBuilder = new ResultCursorBuilder(summaryBuilder, connection.ReceiveOneAsync, null, null, null);
var runHandler = new V3.RunResponseHandler(streamBuilder, summaryBuilder);
var pullAllHandler = new V3.PullResponseHandler(streamBuilder, summaryBuilder, null);
await connection.EnqueueAsync(new RunWithMetadataMessage(query), runHandler, PullAll, pullAllHandler).ConfigureAwait(false);
await connection.SendAsync().ConfigureAwait(false);
return(streamBuilder.CreateCursor());
}
public async Task <IStatementResultCursor> RunInAutoCommitTransactionAsync(IConnection connection,
Statement statement,
IResultResourceHandler resultResourceHandler)
{
var resultBuilder = new ResultCursorBuilder(statement.Text, statement.Parameters,
connection.ReceiveOneAsync, connection.Server, resultResourceHandler);
connection.Enqueue(new RunMessage(statement), resultBuilder, PullAll);
await connection.SendAsync().ConfigureAwait(false);
return(await resultBuilder.PreBuildAsync().ConfigureAwait(false));
}
public async Task <IStatementResultCursor> RunInAutoCommitTransactionAsync(IConnection connection,
Statement statement, IResultResourceHandler resultResourceHandler, Bookmark ignored, TransactionConfig txConfig)
{
AssertNullOrEmptyTransactionConfig(txConfig);
var resultBuilder = new ResultCursorBuilder(NewSummaryCollector(statement, connection.Server),
connection.ReceiveOneAsync, resultResourceHandler);
connection.Enqueue(new RunMessage(statement), resultBuilder, PullAll);
await connection.SendAsync().ConfigureAwait(false);
return(await resultBuilder.PreBuildAsync().ConfigureAwait(false));
}
public void ShouldTransitionToRecordsStreamingStreamingWhenRecordIsPushed()
{
var builder =
new ResultCursorBuilder(CreateSummaryBuilder(), CreateTaskQueue(), null, null, null);
builder.CurrentState.Should().Be(ResultCursorBuilder.State.RunAndRecordsRequested);
builder.RunCompleted(0, new[] { "a", "b", "c" }, null);
builder.CurrentState.Should().Be(ResultCursorBuilder.State.RunAndRecordsRequested);
builder.PushRecord(new object[] { 1, 2, 3 });
builder.CurrentState.Should().Be(ResultCursorBuilder.State.RecordsStreaming);
}
public override Task <IStatementResultCursor> RunAsync(Statement statement)
{
return(TryExecuteAsync(async() =>
{
EnsureNotFailed();
var resultBuilder = new ResultCursorBuilder(statement.Text, statement.Parameters, () => _connection.ReceiveOneAsync(),
_connection.Server);
_connection.Run(statement.Text, statement.Parameters, resultBuilder);
await _connection.SendAsync().ConfigureAwait(false);
return await resultBuilder.PreBuildAsync().ConfigureAwait(false);
}));
}
public override Task <IStatementResultCursor> RunAsync(Statement statement)
{
return(TryExecuteAsync(async() =>
{
await EnsureCanRunMoreStatementsAsync().ConfigureAwait(false);
_connection = await _connectionProvider.AcquireAsync(_defaultMode).ConfigureAwait(false);
var resultBuilder = new ResultCursorBuilder(statement.Text, statement.Parameters,
() => _connection.ReceiveOneAsync(), _connection.Server, this);
_connection.Run(statement.Text, statement.Parameters, resultBuilder);
await _connection.SendAsync().ConfigureAwait(false);
return await resultBuilder.PreBuildAsync().ConfigureAwait(false);
}));
}
public async Task ShouldCallMoreOnceAndReturnRecords()
{
var actions = new Queue <Action>();
var builder =
new ResultCursorBuilder(CreateSummaryBuilder(), CreateTaskQueue(actions),
MoreFunction(), CancelFunction(), null, reactive: true);
actions.Enqueue(() => builder.RunCompleted(0, new[] { "a" }, null));
actions.Enqueue(() => builder.PushRecord(new object[] { 1 }));
actions.Enqueue(() => builder.PushRecord(new object[] { 2 }));
actions.Enqueue(() => builder.PushRecord(new object[] { 3 }));
actions.Enqueue(() => builder.PullCompleted(false, null));
var list = await builder.CreateCursor().ToListAsync(r => r[0].As <int>());
list.Should().BeEquivalentTo(1, 2, 3);
moreCallCount.Should().Be(1);
cancelCallCount.Should().Be(0);
}
public async Task ShouldReturnFirstBatchOfRecordsAndCancel()
{
var actions = new Queue <Action>();
var builder =
new ResultCursorBuilder(CreateSummaryBuilder(), CreateTaskQueue(actions),
MoreFunction(), CancelFunction(), null, reactive: true);
actions.Enqueue(() => builder.RunCompleted(0, new[] { "a" }, null));
actions.Enqueue(() => builder.PushRecord(new object[] { 1 }));
actions.Enqueue(() => builder.PushRecord(new object[] { 2 }));
actions.Enqueue(() => builder.PullCompleted(true, null));
actions.Enqueue(() => builder.PullCompleted(false, null));
var cursor = builder.CreateCursor();
var keys = await cursor.KeysAsync();
keys.Should().BeEquivalentTo("a");
var hasRecord1 = await cursor.FetchAsync();
var record1 = cursor.Current;
hasRecord1.Should().BeTrue();
record1[0].Should().Be(1);
var hasRecord2 = await cursor.FetchAsync();
var record2 = cursor.Current;
hasRecord2.Should().BeTrue();
record2[0].Should().Be(2);
cursor.Cancel();
var list = await cursor.ToListAsync(r => r[0].As <int>());
list.Should().BeEmpty();
moreCallCount.Should().Be(1);
cancelCallCount.Should().Be(1);
}
public override async Task <IResultCursor> RunInAutoCommitTransactionAsync(IConnection connection,
Query query,
bool reactive,
IBookmarkTracker bookmarkTracker,
IResultResourceHandler resultResourceHandler,
string database,
Bookmark bookmark,
TransactionConfig config,
string impersonatedUser,
long fetchSize = Config.Infinite)
{
var summaryBuilder = new SummaryBuilder(query, connection.Server);
var streamBuilder = new ResultCursorBuilder(summaryBuilder, connection.ReceiveOneAsync,
RequestMore(connection, summaryBuilder, bookmarkTracker),
CancelRequest(connection, summaryBuilder, bookmarkTracker),
resultResourceHandler,
fetchSize, reactive);
var runHandler = new V4.RunResponseHandler(streamBuilder, summaryBuilder);
var pullMessage = default(PullMessage);
var pullHandler = default(V4.PullResponseHandler);
if (!reactive)
{
pullMessage = new PullMessage(fetchSize);
pullHandler = new V4.PullResponseHandler(streamBuilder, summaryBuilder, bookmarkTracker);
}
await connection
.EnqueueAsync(
GetRunWithMetaDataMessage(query, bookmark, config,
connection.GetEnforcedAccessMode(), database, impersonatedUser), runHandler,
pullMessage, pullHandler)
.ConfigureAwait(false);
await connection.SendAsync().ConfigureAwait(false);
return(streamBuilder.CreateCursor());
}
public virtual async Task <IResultCursor> RunInAutoCommitTransactionAsync(IConnection connection,
Query query,
bool reactive,
IBookmarkTracker bookmarkTracker,
IResultResourceHandler resultResourceHandler,
string database,
Bookmark bookmark,
TransactionConfig config,
long fetchSize = Config.Infinite)
{
AssertNullDatabase(database);
var summaryBuilder = new SummaryBuilder(query, connection.Server);
var streamBuilder = new ResultCursorBuilder(summaryBuilder, connection.ReceiveOneAsync, null, null, resultResourceHandler);
var runHandler = new V3.RunResponseHandler(streamBuilder, summaryBuilder);
var pullAllHandler = new V3.PullResponseHandler(streamBuilder, summaryBuilder, bookmarkTracker);
await connection.EnqueueAsync(new RunWithMetadataMessage(query, bookmark, config, connection.GetEnforcedAccessMode()), runHandler, PullAll, pullAllHandler).ConfigureAwait(false);
await connection.SendAsync().ConfigureAwait(false);
return(streamBuilder.CreateCursor());
}
public async Task ShouldCallCancelAndReturnNoRecords()
{
var actions = new Queue <Action>();
var builder =
new ResultCursorBuilder(CreateSummaryBuilder(), CreateTaskQueue(actions),
MoreFunction(), CancelFunction(), null, reactive: true);
actions.Enqueue(() => builder.RunCompleted(0, new[] { "a" }, null));
actions.Enqueue(() => builder.PullCompleted(false, null));
var cursor = builder.CreateCursor();
var keys = await cursor.KeysAsync();
keys.Should().BeEquivalentTo("a");
cursor.Cancel();
var list = await cursor.ToListAsync(r => r[0].As <int>());
list.Should().BeEmpty();
moreCallCount.Should().Be(0);
cancelCallCount.Should().Be(1);
}
public async Task ShouldInvokeResourceHandlerWhenCompleted()
{
var actions = new Queue <Action>();
var resourceHandler = new Mock <IResultResourceHandler>();
var builder =
new ResultCursorBuilder(CreateSummaryBuilder(), CreateTaskQueue(actions), null, null,
resourceHandler.Object);
actions.Enqueue(() => builder.RunCompleted(0, new[] { "a" }, null));
actions.Enqueue(() => builder.PushRecord(new object[] { 1 }));
actions.Enqueue(() => builder.PushRecord(new object[] { 2 }));
actions.Enqueue(() => builder.PushRecord(new object[] { 3 }));
actions.Enqueue(() => builder.PullCompleted(false, null));
var cursor = builder.CreateCursor();
var hasNext = await cursor.FetchAsync();
hasNext.Should().BeTrue();
resourceHandler.Verify(x => x.OnResultConsumedAsync(), Times.Never);
hasNext = await cursor.FetchAsync();
hasNext.Should().BeTrue();
resourceHandler.Verify(x => x.OnResultConsumedAsync(), Times.Never);
hasNext = await cursor.FetchAsync();
hasNext.Should().BeTrue();
resourceHandler.Verify(x => x.OnResultConsumedAsync(), Times.Never);
hasNext = await cursor.FetchAsync();
hasNext.Should().BeFalse();
resourceHandler.Verify(x => x.OnResultConsumedAsync(), Times.Once);
}
