/// <summary>
/// Creates a CosmosPipelinedItemQueryExecutionContext.
/// </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 CosmosPipelinedItemQueryExecutionContext.</returns>
public static async Task <CosmosQueryExecutionContext> CreateAsync(
CosmosQueryContext 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));
QueryInfo queryInfo = partitionedQueryExecutionInfo.QueryInfo;
int actualPageSize = initialPageSize;
if (queryInfo.HasGroupBy)
{
initialPageSize = int.MaxValue;
constructorParams.QueryRequestOptions.MaxItemCount = int.MaxValue;
}
Func <string, Task <IDocumentQueryExecutionComponent> > createOrderByComponentFunc = async(continuationToken) =>
{
CosmosCrossPartitionQueryExecutionContext.CrossPartitionInitParams initParams = new CosmosCrossPartitionQueryExecutionContext.CrossPartitionInitParams(
collectionRid,
partitionedQueryExecutionInfo,
partitionKeyRanges,
initialPageSize,
continuationToken);
return(await CosmosOrderByItemQueryExecutionContext.CreateAsync(
constructorParams,
initParams,
cancellationToken));
};
Func <string, Task <IDocumentQueryExecutionComponent> > createParallelComponentFunc = async(continuationToken) =>
{
CosmosCrossPartitionQueryExecutionContext.CrossPartitionInitParams initParams = new CosmosCrossPartitionQueryExecutionContext.CrossPartitionInitParams(
collectionRid,
partitionedQueryExecutionInfo,
partitionKeyRanges,
initialPageSize,
continuationToken);
return(await CosmosParallelItemQueryExecutionContext.CreateAsync(
constructorParams,
initParams,
cancellationToken));
};
return((CosmosQueryExecutionContext)await PipelinedDocumentQueryExecutionContext.CreateHelperAsync(
partitionedQueryExecutionInfo.QueryInfo,
initialPageSize,
requestContinuation,
constructorParams.QueryRequestOptions.EnableGroupBy,
createOrderByComponentFunc,
createParallelComponentFunc));
}
public static async Task <CosmosQueryExecutionContext> CreateSpecializedDocumentQueryExecutionContextAsync(
CosmosQueryContext cosmosQueryContext,
InputParameters inputParameters,
PartitionedQueryExecutionInfo partitionedQueryExecutionInfo,
List <Documents.PartitionKeyRange> targetRanges,
string collectionRid,
CancellationToken cancellationToken)
{
if (!string.IsNullOrEmpty(partitionedQueryExecutionInfo.QueryInfo?.RewrittenQuery))
{
inputParameters.SqlQuerySpec = new SqlQuerySpec(
partitionedQueryExecutionInfo.QueryInfo.RewrittenQuery,
inputParameters.SqlQuerySpec.Parameters);
}
// Figure out the optimal page size.
long initialPageSize = inputParameters.MaxItemCount.GetValueOrDefault(ParallelQueryConfig.GetConfig().ClientInternalPageSize);
if (initialPageSize < -1 || initialPageSize == 0)
{
throw cosmosQueryContext.QueryClient.CreateBadRequestException($"Invalid MaxItemCount {initialPageSize}");
}
QueryInfo queryInfo = partitionedQueryExecutionInfo.QueryInfo;
bool getLazyFeedResponse = queryInfo.HasTop;
// We need to compute the optimal initial page size for order-by queries
if (queryInfo.HasOrderBy)
{
int top;
if (queryInfo.HasTop && (top = partitionedQueryExecutionInfo.QueryInfo.Top.Value) > 0)
{
// All partitions should initially fetch about 1/nth of the top value.
long pageSizeWithTop = (long)Math.Min(
Math.Ceiling(top / (double)targetRanges.Count) * PageSizeFactorForTop,
top);
if (initialPageSize > 0)
{
initialPageSize = Math.Min(pageSizeWithTop, initialPageSize);
}
else
{
initialPageSize = pageSizeWithTop;
}
}
else if (cosmosQueryContext.IsContinuationExpected)
{
if (initialPageSize < 0)
{
if (inputParameters.MaxBufferedItemCount.HasValue)
{
// Max of what the user is willing to buffer and the default (note this is broken if MaxBufferedItemCount = -1)
initialPageSize = Math.Max(inputParameters.MaxBufferedItemCount.Value, ParallelQueryConfig.GetConfig().DefaultMaximumBufferSize);
}
else
{
initialPageSize = ParallelQueryConfig.GetConfig().DefaultMaximumBufferSize;
}
}
initialPageSize = (long)Math.Min(
Math.Ceiling(initialPageSize / (double)targetRanges.Count) * PageSizeFactorForTop,
initialPageSize);
}
}
Debug.Assert(initialPageSize > 0 && initialPageSize <= int.MaxValue,
string.Format(CultureInfo.InvariantCulture, "Invalid MaxItemCount {0}", initialPageSize));
CosmosCrossPartitionQueryExecutionContext.CrossPartitionInitParams initParams = new CosmosCrossPartitionQueryExecutionContext.CrossPartitionInitParams(
sqlQuerySpec: inputParameters.SqlQuerySpec,
collectionRid: collectionRid,
partitionedQueryExecutionInfo: partitionedQueryExecutionInfo,
partitionKeyRanges: targetRanges,
initialPageSize: (int)initialPageSize,
maxConcurrency: inputParameters.MaxConcurrency,
maxItemCount: inputParameters.MaxItemCount,
maxBufferedItemCount: inputParameters.MaxBufferedItemCount);
return(await PipelinedDocumentQueryExecutionContext.CreateAsync(
inputParameters.ExecutionEnvironment,
cosmosQueryContext,
initParams,
inputParameters.InitialUserContinuationToken,
cancellationToken));
}