Beispiel #1
0
        public IEnumerator <Tuple> AsReaderOfAsync(QueryRequest request, CancellationToken token)
        {
            var accessor = request.GetAccessor();

            using (this)
                while (NextRow())
                {
                    yield return(ReadTupleWith(accessor));
                }
        }
Beispiel #2
0
        public IEnumerator <Tuple> AsReaderOf(QueryRequest request)
        {
            var accessor = request.GetAccessor();

            using (this)
                while (NextRow())
                {
                    yield return(ReadTupleWith(accessor));
                }
        }
Beispiel #3
0
        public override DataReader ExecuteTasksWithReader(QueryRequest lastRequest, CommandProcessorContext context)
        {
            var oldValue = context.AllowPartialExecution;

            context.AllowPartialExecution = false;
            ExecuteTasks(context);
            context.AllowPartialExecution = oldValue;

            var lastRequestCommand = Factory.CreateCommand();
            var commandPart        = Factory.CreateQueryPart(lastRequest, context.ParameterContext);

            ValidateCommandParameters(commandPart);
            lastRequestCommand.AddPart(commandPart);
            lastRequestCommand.ExecuteReader();
            return(lastRequestCommand.CreateReader(lastRequest.GetAccessor()));
        }
Beispiel #4
0
        public override DataReader ExecuteTasksWithReader(QueryRequest request, CommandProcessorContext context)
        {
            context.AllowPartialExecution = false;
            PutTasksForExecution(context);

            while (context.ProcessingTasks.Count >= batchSize)
            {
                _ = ExecuteBatch(batchSize, null, context);
            }

            for (;;)
            {
                var result = ExecuteBatch(context.ProcessingTasks.Count, request, context);
                if (result != null && context.ProcessingTasks.Count == 0)
                {
                    return(result.CreateReader(request.GetAccessor()));
                }
            }
        }
Beispiel #5
0
        public override async Task <DataReader> ExecuteTasksWithReaderAsync(QueryRequest request,
                                                                            CommandProcessorContext context, CancellationToken token)
        {
            context.AllowPartialExecution = false;
            PutTasksForExecution(context);

            while (context.ProcessingTasks.Count >= batchSize)
            {
                _ = await ExecuteBatchAsync(batchSize, null, context, token).ConfigureAwait(false);
            }

            for (; ;)
            {
                var result = await ExecuteBatchAsync(context.ProcessingTasks.Count, request, context, token).ConfigureAwait(false);

                if (result != null && context.ProcessingTasks.Count == 0)
                {
                    return(result.CreateReader(request.GetAccessor()));
                }
            }
        }
Beispiel #6
0
        public override async Task <DataReader> ExecuteTasksWithReaderAsync(QueryRequest lastRequest, CommandProcessorContext context, CancellationToken token)
        {
            var oldValue = context.AllowPartialExecution;

            context.AllowPartialExecution = false;

            token.ThrowIfCancellationRequested();

            await ExecuteTasksAsync(context, token).ConfigureAwait(false);

            context.AllowPartialExecution = oldValue;

            var lastRequestCommand = Factory.CreateCommand();
            var commandPart        = Factory.CreateQueryPart(lastRequest, context.ParameterContext);

            ValidateCommandParameters(commandPart);
            lastRequestCommand.AddPart(commandPart);
            token.ThrowIfCancellationRequested();
            await lastRequestCommand.ExecuteReaderAsync(token).ConfigureAwait(false);

            return(lastRequestCommand.CreateReader(lastRequest.GetAccessor()));
        }