private async Task <(IList <IDocumentQueryExecutionComponent> components, QueryResponseCore response)> GetAllExecutionComponents()
{
(Func <string, Task <IDocumentQueryExecutionComponent> > func, QueryResponseCore response)setupContext = this.SetupBaseContextToVerifyFailureScenario();
List <IDocumentQueryExecutionComponent> components = new List <IDocumentQueryExecutionComponent>();
List <AggregateOperator> operators = new List <AggregateOperator>()
{
AggregateOperator.Average,
AggregateOperator.Count,
AggregateOperator.Max,
AggregateOperator.Min,
AggregateOperator.Sum
};
components.Add(await AggregateDocumentQueryExecutionComponent.CreateAsync(
Query.Core.ExecutionContext.ExecutionEnvironment.Client,
new Mock <CosmosQueryClient>().Object,
operators.ToArray(),
new Dictionary <string, AggregateOperator?>()
{
{ "test", AggregateOperator.Count }
},
new List <string>()
{
"test"
},
false,
null,
setupContext.func));
components.Add(await DistinctDocumentQueryExecutionComponent.CreateAsync(
Query.Core.ExecutionContext.ExecutionEnvironment.Client,
new Mock <CosmosQueryClient>().Object,
null,
setupContext.func,
DistinctQueryType.Ordered));
components.Add(await SkipDocumentQueryExecutionComponent.CreateAsync(
5,
null,
setupContext.func));
components.Add(await TakeDocumentQueryExecutionComponent.CreateLimitDocumentQueryExecutionComponentAsync(
new Mock <CosmosQueryClient>().Object,
5,
null,
setupContext.func));
components.Add(await TakeDocumentQueryExecutionComponent.CreateTopDocumentQueryExecutionComponentAsync(
new Mock <CosmosQueryClient>().Object,
5,
null,
setupContext.func));
return(components, setupContext.response);
}
private async Task <(IList <DocumentQueryExecutionComponentBase> components, QueryResponse response)> GetAllExecutionComponents()
{
(Func <string, Task <IDocumentQueryExecutionComponent> > func, QueryResponse response)setupContext = this.SetupBaseContextToVerifyFailureScenario();
List <DocumentQueryExecutionComponentBase> components = new List <DocumentQueryExecutionComponentBase>();
List <AggregateOperator> operators = new List <AggregateOperator>()
{
AggregateOperator.Average,
AggregateOperator.Count,
AggregateOperator.Max,
AggregateOperator.Min,
AggregateOperator.Sum
};
components.Add(await AggregateDocumentQueryExecutionComponent.CreateAsync(
operators.ToArray(),
null,
setupContext.func));
components.Add(await DistinctDocumentQueryExecutionComponent.CreateAsync(
null,
setupContext.func,
DistinctQueryType.Ordered));
components.Add(await SkipDocumentQueryExecutionComponent.CreateAsync(
5,
null,
setupContext.func));
components.Add(await TakeDocumentQueryExecutionComponent.CreateLimitDocumentQueryExecutionComponentAsync(
5,
null,
setupContext.func));
components.Add(await TakeDocumentQueryExecutionComponent.CreateTopDocumentQueryExecutionComponentAsync(
5,
null,
setupContext.func));
return(components, setupContext.response);
}
private static async Task <PipelinedDocumentQueryExecutionContext> CreateHelperAsync(
QueryInfo queryInfo,
int initialPageSize,
string requestContinuation,
bool allowGroupBy,
Func <string, Task <IDocumentQueryExecutionComponent> > createOrderByQueryExecutionContext,
Func <string, Task <IDocumentQueryExecutionComponent> > createParallelQueryExecutionContext)
{
Func <string, Task <IDocumentQueryExecutionComponent> > createComponentFunc;
if (queryInfo.HasOrderBy)
{
createComponentFunc = createOrderByQueryExecutionContext;
}
else
{
createComponentFunc = createParallelQueryExecutionContext;
}
if (queryInfo.HasAggregates && !queryInfo.HasGroupBy)
{
Func <string, Task <IDocumentQueryExecutionComponent> > createSourceCallback = createComponentFunc;
createComponentFunc = async(continuationToken) =>
{
return(await AggregateDocumentQueryExecutionComponent.CreateAsync(
queryInfo.Aggregates,
queryInfo.GroupByAliasToAggregateType,
queryInfo.HasSelectValue,
continuationToken,
createSourceCallback));
};
}
if (queryInfo.HasDistinct)
{
Func <string, Task <IDocumentQueryExecutionComponent> > createSourceCallback = createComponentFunc;
createComponentFunc = async(continuationToken) =>
{
return(await DistinctDocumentQueryExecutionComponent.CreateAsync(
continuationToken,
createSourceCallback,
queryInfo.DistinctType));
};
}
if (queryInfo.HasGroupBy)
{
if (!allowGroupBy)
{
throw new ArgumentException("Cross Partition GROUP BY is not supported.");
}
Func <string, Task <IDocumentQueryExecutionComponent> > createSourceCallback = createComponentFunc;
createComponentFunc = async(continuationToken) =>
{
return(await GroupByDocumentQueryExecutionComponent.CreateAsync(
continuationToken,
createSourceCallback,
queryInfo.GroupByAliasToAggregateType,
queryInfo.HasSelectValue));
};
}
if (queryInfo.HasOffset)
{
Func <string, Task <IDocumentQueryExecutionComponent> > createSourceCallback = createComponentFunc;
createComponentFunc = async(continuationToken) =>
{
return(await SkipDocumentQueryExecutionComponent.CreateAsync(
queryInfo.Offset.Value,
continuationToken,
createSourceCallback));
};
}
if (queryInfo.HasLimit)
{
Func <string, Task <IDocumentQueryExecutionComponent> > createSourceCallback = createComponentFunc;
createComponentFunc = async(continuationToken) =>
{
return(await TakeDocumentQueryExecutionComponent.CreateLimitDocumentQueryExecutionComponentAsync(
queryInfo.Limit.Value,
continuationToken,
createSourceCallback));
};
}
if (queryInfo.HasTop)
{
Func <string, Task <IDocumentQueryExecutionComponent> > createSourceCallback = createComponentFunc;
createComponentFunc = async(continuationToken) =>
{
return(await TakeDocumentQueryExecutionComponent.CreateTopDocumentQueryExecutionComponentAsync(
queryInfo.Top.Value,
continuationToken,
createSourceCallback));
};
}
return(new PipelinedDocumentQueryExecutionContext(
await createComponentFunc(requestContinuation), initialPageSize));
}
public static async Task <TryCatch <CosmosQueryExecutionContext> > TryCreateAsync(
ExecutionEnvironment executionEnvironment,
CosmosQueryContext queryContext,
CosmosCrossPartitionQueryExecutionContext.CrossPartitionInitParams initParams,
string requestContinuationToken,
CancellationToken cancellationToken)
{
if (queryContext == null)
{
throw new ArgumentNullException(nameof(initParams));
}
cancellationToken.ThrowIfCancellationRequested();
QueryInfo queryInfo = initParams.PartitionedQueryExecutionInfo.QueryInfo;
int initialPageSize = initParams.InitialPageSize;
if (queryInfo.HasGroupBy)
{
// The query will block until all groupings are gathered so we might as well speed up the process.
initParams = new CosmosCrossPartitionQueryExecutionContext.CrossPartitionInitParams(
sqlQuerySpec: initParams.SqlQuerySpec,
collectionRid: initParams.CollectionRid,
partitionedQueryExecutionInfo: initParams.PartitionedQueryExecutionInfo,
partitionKeyRanges: initParams.PartitionKeyRanges,
initialPageSize: int.MaxValue,
maxConcurrency: initParams.MaxConcurrency,
maxItemCount: int.MaxValue,
maxBufferedItemCount: initParams.MaxBufferedItemCount);
}
async Task <TryCatch <IDocumentQueryExecutionComponent> > tryCreateOrderByComponentAsync(string continuationToken)
{
return((await CosmosOrderByItemQueryExecutionContext.TryCreateAsync(
queryContext,
initParams,
continuationToken,
cancellationToken)).Try <IDocumentQueryExecutionComponent>(component => component));
}
async Task <TryCatch <IDocumentQueryExecutionComponent> > tryCreateParallelComponentAsync(string continuationToken)
{
return((await CosmosParallelItemQueryExecutionContext.TryCreateAsync(
queryContext,
initParams,
continuationToken,
cancellationToken)).Try <IDocumentQueryExecutionComponent>(component => component));
}
Func <string, Task <TryCatch <IDocumentQueryExecutionComponent> > > tryCreatePipelineAsync;
if (queryInfo.HasOrderBy)
{
tryCreatePipelineAsync = tryCreateOrderByComponentAsync;
}
else
{
tryCreatePipelineAsync = tryCreateParallelComponentAsync;
}
if (queryInfo.HasAggregates && !queryInfo.HasGroupBy)
{
Func <string, Task <TryCatch <IDocumentQueryExecutionComponent> > > tryCreateSourceAsync = tryCreatePipelineAsync;
tryCreatePipelineAsync = async(continuationToken) =>
{
return(await AggregateDocumentQueryExecutionComponent.TryCreateAsync(
executionEnvironment,
queryInfo.Aggregates,
queryInfo.GroupByAliasToAggregateType,
queryInfo.GroupByAliases,
queryInfo.HasSelectValue,
continuationToken,
tryCreateSourceAsync));
};
}
if (queryInfo.HasDistinct)
{
Func <string, Task <TryCatch <IDocumentQueryExecutionComponent> > > tryCreateSourceAsync = tryCreatePipelineAsync;
tryCreatePipelineAsync = async(continuationToken) =>
{
return(await DistinctDocumentQueryExecutionComponent.TryCreateAsync(
executionEnvironment,
continuationToken,
tryCreateSourceAsync,
queryInfo.DistinctType));
};
}
if (queryInfo.HasGroupBy)
{
Func <string, Task <TryCatch <IDocumentQueryExecutionComponent> > > tryCreateSourceAsync = tryCreatePipelineAsync;
tryCreatePipelineAsync = async(continuationToken) =>
{
return(await GroupByDocumentQueryExecutionComponent.TryCreateAsync(
executionEnvironment,
continuationToken,
tryCreateSourceAsync,
queryInfo.GroupByAliasToAggregateType,
queryInfo.GroupByAliases,
queryInfo.HasSelectValue));
};
}
if (queryInfo.HasOffset)
{
Func <string, Task <TryCatch <IDocumentQueryExecutionComponent> > > tryCreateSourceAsync = tryCreatePipelineAsync;
tryCreatePipelineAsync = async(continuationToken) =>
{
return(await SkipDocumentQueryExecutionComponent.TryCreateAsync(
queryInfo.Offset.Value,
continuationToken,
tryCreateSourceAsync));
};
}
if (queryInfo.HasLimit)
{
Func <string, Task <TryCatch <IDocumentQueryExecutionComponent> > > tryCreateSourceAsync = tryCreatePipelineAsync;
tryCreatePipelineAsync = async(continuationToken) =>
{
return(await TakeDocumentQueryExecutionComponent.TryCreateLimitDocumentQueryExecutionComponentAsync(
queryInfo.Limit.Value,
continuationToken,
tryCreateSourceAsync));
};
}
if (queryInfo.HasTop)
{
Func <string, Task <TryCatch <IDocumentQueryExecutionComponent> > > tryCreateSourceAsync = tryCreatePipelineAsync;
tryCreatePipelineAsync = async(continuationToken) =>
{
return(await TakeDocumentQueryExecutionComponent.TryCreateTopDocumentQueryExecutionComponentAsync(
queryInfo.Top.Value,
continuationToken,
tryCreateSourceAsync));
};
}
return((await tryCreatePipelineAsync(requestContinuationToken))
.Try <CosmosQueryExecutionContext>((source) => new PipelinedDocumentQueryExecutionContext(source, initialPageSize)));
}
/// <summary>
/// Creates a PipelinedDocumentQueryExecutionContext.
/// </summary>
/// <param name="constructorParams">The parameters for constructing the base class.</param>
/// <param name="collectionRid">The collection rid.</param>
/// <param name="partitionedQueryExecutionInfo">The partitioned query execution info.</param>
/// <param name="partitionKeyRanges">The partition key ranges.</param>
/// <param name="initialPageSize">The initial page size.</param>
/// <param name="requestContinuation">The request continuation.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>A task to await on, which in turn returns a PipelinedDocumentQueryExecutionContext.</returns>
public static async Task <IDocumentQueryExecutionContext> CreateAsync(
DocumentQueryExecutionContextBase.InitParams constructorParams,
string collectionRid,
PartitionedQueryExecutionInfo partitionedQueryExecutionInfo,
List <PartitionKeyRange> partitionKeyRanges,
int initialPageSize,
string requestContinuation,
CancellationToken cancellationToken)
{
DefaultTrace.TraceInformation(
string.Format(
CultureInfo.InvariantCulture,
"{0}, CorrelatedActivityId: {1} | Pipelined~Context.CreateAsync",
DateTime.UtcNow.ToString("o", CultureInfo.InvariantCulture),
constructorParams.CorrelatedActivityId));
Func <string, Task <IDocumentQueryExecutionComponent> > createComponentFunc;
QueryInfo queryInfo = partitionedQueryExecutionInfo.QueryInfo;
if (queryInfo.HasOrderBy)
{
createComponentFunc = async(continuationToken) =>
{
CrossPartitionQueryExecutionContext.CrossPartitionInitParams initParams = new CrossPartitionQueryExecutionContext.CrossPartitionInitParams(
collectionRid,
partitionedQueryExecutionInfo,
partitionKeyRanges,
initialPageSize,
continuationToken);
return(await OrderByDocumentQueryExecutionContext.CreateAsync(
constructorParams,
initParams,
cancellationToken));
};
}
else
{
createComponentFunc = async(continuationToken) =>
{
CrossPartitionQueryExecutionContext.CrossPartitionInitParams initParams = new CrossPartitionQueryExecutionContext.CrossPartitionInitParams(
collectionRid,
partitionedQueryExecutionInfo,
partitionKeyRanges,
initialPageSize,
continuationToken);
return(await ParallelDocumentQueryExecutionContext.CreateAsync(
constructorParams,
initParams,
cancellationToken));
};
}
if (queryInfo.HasAggregates)
{
Func <string, Task <IDocumentQueryExecutionComponent> > createSourceCallback = createComponentFunc;
createComponentFunc = async(continuationToken) =>
{
return(await AggregateDocumentQueryExecutionComponent.CreateAsync(
queryInfo.Aggregates,
continuationToken,
createSourceCallback));
};
}
if (queryInfo.HasDistinct)
{
Func <string, Task <IDocumentQueryExecutionComponent> > createSourceCallback = createComponentFunc;
createComponentFunc = async(continuationToken) =>
{
return(await DistinctDocumentQueryExecutionComponent.CreateAsync(
continuationToken,
createSourceCallback,
queryInfo.DistinctType));
};
}
if (queryInfo.HasOffset)
{
if (!constructorParams.FeedOptions.EnableCrossPartitionSkipTake)
{
throw new ArgumentException("Cross Partition OFFSET / LIMIT is not supported.");
}
Func <string, Task <IDocumentQueryExecutionComponent> > createSourceCallback = createComponentFunc;
createComponentFunc = async(continuationToken) =>
{
return(await SkipDocumentQueryExecutionComponent.CreateAsync(
queryInfo.Offset.Value,
continuationToken,
createSourceCallback));
};
}
if (queryInfo.HasLimit)
{
if (!constructorParams.FeedOptions.EnableCrossPartitionSkipTake)
{
throw new ArgumentException("Cross Partition OFFSET / LIMIT is not supported.");
}
Func <string, Task <IDocumentQueryExecutionComponent> > createSourceCallback = createComponentFunc;
createComponentFunc = async(continuationToken) =>
{
return(await TakeDocumentQueryExecutionComponent.CreateLimitDocumentQueryExecutionComponentAsync(
queryInfo.Limit.Value,
continuationToken,
createSourceCallback));
};
}
if (queryInfo.HasTop)
{
Func <string, Task <IDocumentQueryExecutionComponent> > createSourceCallback = createComponentFunc;
createComponentFunc = async(continuationToken) =>
{
return(await TakeDocumentQueryExecutionComponent.CreateTopDocumentQueryExecutionComponentAsync(
queryInfo.Top.Value,
continuationToken,
createSourceCallback));
};
}
return(new PipelinedDocumentQueryExecutionContext(
await createComponentFunc(requestContinuation), initialPageSize));
}
private static async Task <PipelinedDocumentQueryExecutionContext> CreateHelperAsync(
ExecutionEnvironment executionEnvironment,
CosmosQueryClient queryClient,
QueryInfo queryInfo,
int initialPageSize,
string requestContinuation,
Func <string, Task <IDocumentQueryExecutionComponent> > createOrderByQueryExecutionContext,
Func <string, Task <IDocumentQueryExecutionComponent> > createParallelQueryExecutionContext)
{
Func <string, Task <IDocumentQueryExecutionComponent> > createComponentFunc;
if (queryInfo.HasOrderBy)
{
createComponentFunc = createOrderByQueryExecutionContext;
}
else
{
createComponentFunc = createParallelQueryExecutionContext;
}
if (queryInfo.HasAggregates && !queryInfo.HasGroupBy)
{
Func <string, Task <IDocumentQueryExecutionComponent> > createSourceCallback = createComponentFunc;
createComponentFunc = async(continuationToken) =>
{
return(await AggregateDocumentQueryExecutionComponent.CreateAsync(
executionEnvironment,
queryClient,
queryInfo.Aggregates,
queryInfo.GroupByAliasToAggregateType,
queryInfo.GroupByAliases,
queryInfo.HasSelectValue,
continuationToken,
createSourceCallback));
};
}
if (queryInfo.HasDistinct)
{
Func <string, Task <IDocumentQueryExecutionComponent> > createSourceCallback = createComponentFunc;
createComponentFunc = async(continuationToken) =>
{
return(await DistinctDocumentQueryExecutionComponent.CreateAsync(
queryClient,
continuationToken,
createSourceCallback,
queryInfo.DistinctType));
};
}
if (queryInfo.HasGroupBy)
{
Func <string, Task <IDocumentQueryExecutionComponent> > createSourceCallback = createComponentFunc;
createComponentFunc = async(continuationToken) =>
{
return(await GroupByDocumentQueryExecutionComponent.CreateAsync(
queryClient,
continuationToken,
createSourceCallback,
queryInfo.GroupByAliasToAggregateType,
queryInfo.GroupByAliases,
queryInfo.HasSelectValue));
};
}
if (queryInfo.HasOffset)
{
Func <string, Task <IDocumentQueryExecutionComponent> > createSourceCallback = createComponentFunc;
createComponentFunc = async(continuationToken) =>
{
return(await SkipDocumentQueryExecutionComponent.CreateAsync(
queryInfo.Offset.Value,
continuationToken,
createSourceCallback));
};
}
if (queryInfo.HasLimit)
{
Func <string, Task <IDocumentQueryExecutionComponent> > createSourceCallback = createComponentFunc;
createComponentFunc = async(continuationToken) =>
{
return(await TakeDocumentQueryExecutionComponent.CreateLimitDocumentQueryExecutionComponentAsync(
queryClient,
queryInfo.Limit.Value,
continuationToken,
createSourceCallback));
};
}
if (queryInfo.HasTop)
{
Func <string, Task <IDocumentQueryExecutionComponent> > createSourceCallback = createComponentFunc;
createComponentFunc = async(continuationToken) =>
{
return(await TakeDocumentQueryExecutionComponent.CreateTopDocumentQueryExecutionComponentAsync(
queryClient,
queryInfo.Top.Value,
continuationToken,
createSourceCallback));
};
}
return(new PipelinedDocumentQueryExecutionContext(
await createComponentFunc(requestContinuation), initialPageSize));
}
