/// <summary> /// Executes all registred requests plus the specified one query, /// returning <see cref="IEnumerator{Tuple}"/> for the last query. /// </summary> /// <param name="request">The request to execute.</param> /// <returns>A <see cref="IEnumerator{Tuple}"/> for the specified request.</returns> public abstract IEnumerator <Tuple> ExecuteTasksWithReader(QueryRequest request, CommandProcessorContext context);
/// <summary> /// Asynchronously executes all registred requests plus the specified one query. /// Default implementation is synchronous and returns complete task. /// </summary> /// <param name="request">The request to execute.</param> /// <param name="context">The context in which the requests are executed.</param> /// <param name="token">Token to cancel operation.</param> /// <returns>A task performing this operation.</returns> public virtual Task <IEnumerator <Tuple> > ExecuteTasksWithReaderAsync(QueryRequest request, CommandProcessorContext context, CancellationToken token) { token.ThrowIfCancellationRequested(); return(Task.FromResult(ExecuteTasksWithReader(request, context))); }
private void RegisterQueryTask(QueryTask task, QueryRequest request) { task.Result = new List <Tuple>(); commandProcessor.RegisterTask(new SqlLoadTask(request, task.Result, task.ParameterContext)); }
private async Task <Command> ExecuteBatchAsync(int numberOfTasks, QueryRequest lastRequest, CommandProcessorContext context, CancellationToken token) { if (numberOfTasks == 0 && lastRequest == null) { return(null); } var tasksToProcess = context.ProcessingTasks; AllocateCommand(context); var shouldReturnReader = false; try { while (numberOfTasks > 0 && tasksToProcess.Count > 0) { var task = tasksToProcess.Peek(); context.CurrentTask = task; task.ProcessWith(this, context); if (context.CurrentTask == null) { numberOfTasks--; _ = tasksToProcess.Dequeue(); } else { break; } } var command = context.ActiveCommand; if (lastRequest != null && tasksToProcess.Count == 0) { var part = Factory.CreateQueryPart(lastRequest, context.ParameterContext); if (!PendCommandPart(command, part)) { shouldReturnReader = true; command.AddPart(part); } } if (command.Count == 0) { return(null); } var hasQueryTasks = context.ActiveTasks.Count > 0; if (!hasQueryTasks && !shouldReturnReader) { _ = await command.ExecuteNonQueryAsync(token).ConfigureAwait(false); return(null); } await command.ExecuteReaderAsync(token).ConfigureAwait(false); if (hasQueryTasks) { var currentQueryTask = 0; while (currentQueryTask < context.ActiveTasks.Count) { var queryTask = context.ActiveTasks[currentQueryTask]; var accessor = queryTask.Request.GetAccessor(); var result = queryTask.Output; while (command.NextRow()) { result.Add(command.ReadTupleWith(accessor)); } _ = command.NextResult(); currentQueryTask++; } } return(shouldReturnReader ? command : null); } finally { if (!shouldReturnReader) { await context.ActiveCommand.DisposeAsync().ConfigureAwait(false); } ReleaseCommand(context); } }
/// <summary> /// Executes all registered requests plus the specified one query, /// returning <see cref="IEnumerator{Tuple}"/> for the last query. /// </summary> /// <param name="request">A <see cref="QueryRequest"/> instance to be executed.</param> /// <param name="context">A contextual information to be used while executing /// the specified <paramref name="request"/>.</param> /// <returns>A <see cref="IEnumerator{Tuple}"/> for the specified request.</returns> public abstract DataReader ExecuteTasksWithReader(QueryRequest request, CommandProcessorContext context);
public override async Task <IEnumerator <Tuple> > ExecuteTasksWithReaderAsync(QueryRequest request, CommandProcessorContext context, CancellationToken token) { context.ProcessingTasks = new Queue <SqlTask>(tasks); tasks.Clear(); while (context.ProcessingTasks.Count >= batchSize) { await ExecuteBatchAsync(batchSize, null, context, token).ConfigureAwait(false); } return((await ExecuteBatchAsync(context.ProcessingTasks.Count, request, context, token).ConfigureAwait(false)).AsReaderOf(request)); }
private Command ExecuteBatch(int numberOfTasks, QueryRequest lastRequest, CommandProcessorContext context) { var shouldReturnReader = lastRequest != null; if (numberOfTasks == 0 && !shouldReturnReader) { return(null); } var tasksToProcess = context.ProcessingTasks; AllocateCommand(context); try { while (numberOfTasks > 0 && tasksToProcess.Count > 0) { numberOfTasks--; var task = tasksToProcess.Dequeue(); task.ProcessWith(this, context); } if (shouldReturnReader) { var part = Factory.CreateQueryPart(lastRequest); context.ActiveCommand.AddPart(part); } if (context.ActiveCommand.Count == 0) { return(null); } var hasQueryTasks = context.ActiveTasks.Count > 0; if (!hasQueryTasks && !shouldReturnReader) { context.ActiveCommand.ExecuteNonQuery(); return(null); } context.ActiveCommand.ExecuteReader(); if (hasQueryTasks) { int currentQueryTask = 0; while (currentQueryTask < context.ActiveTasks.Count) { var queryTask = context.ActiveTasks[currentQueryTask]; var accessor = queryTask.Request.GetAccessor(); var result = queryTask.Output; while (context.ActiveCommand.NextRow()) { result.Add(context.ActiveCommand.ReadTupleWith(accessor)); } context.ActiveCommand.NextResult(); currentQueryTask++; } } return(shouldReturnReader ? context.ActiveCommand : null); } finally { if (!shouldReturnReader) { context.ActiveCommand.Dispose(); } ReleaseCommand(context); } }
async Task <IEnumerator <Tuple> > IProviderExecutor.ExecuteTupleReaderAsync(QueryRequest request, CancellationToken token) { Prepare(); using (var context = new CommandProcessorContext()) return(await commandProcessor.ExecuteTasksWithReaderAsync(request, context, token).ConfigureAwait(false)); }
public override async Task <IEnumerator <Tuple> > ExecuteTasksWithReaderAsync(QueryRequest lastRequest, CommandProcessorContext context, CancellationToken token) { var oldValue = context.AllowPartialExecution; context.AllowPartialExecution = false; token.ThrowIfCancellationRequested(); await ExecuteTasksAsync(context, token); context.AllowPartialExecution = oldValue; var lastRequestCommand = Factory.CreateCommand(); var commandPart = Factory.CreateQueryPart(lastRequest); lastRequestCommand.AddPart(commandPart); token.ThrowIfCancellationRequested(); await lastRequestCommand.ExecuteReaderAsync(token); return(lastRequestCommand.AsReaderOf(lastRequest)); }