/// <summary>
/// Creates a CosmosPipelinedItemQueryExecutionContext.
/// </summary>
/// <param name="queryContext">The parameters for constructing the base class.</param>
/// <param name="initParams">The initial parameters</param>
/// <param name="requestContinuationToken">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 queryContext,
CosmosCrossPartitionQueryExecutionContext.CrossPartitionInitParams initParams,
string requestContinuationToken,
CancellationToken cancellationToken)
{
DefaultTrace.TraceInformation(
string.Format(
CultureInfo.InvariantCulture,
"{0}, CorrelatedActivityId: {1} | Pipelined~Context.CreateAsync",
DateTime.UtcNow.ToString("o", CultureInfo.InvariantCulture),
queryContext.CorrelatedActivityId));
QueryInfo queryInfo = initParams.PartitionedQueryExecutionInfo.QueryInfo;
int actualPageSize = initParams.InitialPageSize;
int initialPageSize = initParams.InitialPageSize;
CosmosCrossPartitionQueryExecutionContext.CrossPartitionInitParams parameters = initParams;
if (queryInfo.HasGroupBy)
{
initialPageSize = int.MaxValue;
initParams = new CosmosCrossPartitionQueryExecutionContext.CrossPartitionInitParams(
sqlQuerySpec: initParams.SqlQuerySpec,
collectionRid: initParams.CollectionRid,
partitionedQueryExecutionInfo: initParams.PartitionedQueryExecutionInfo,
partitionKeyRanges: initParams.PartitionKeyRanges,
initialPageSize: initialPageSize,
maxConcurrency: initParams.MaxConcurrency,
maxItemCount: int.MaxValue,
maxBufferedItemCount: initParams.MaxBufferedItemCount);
}
Func <string, Task <IDocumentQueryExecutionComponent> > createOrderByComponentFunc = async(continuationToken) =>
{
return(await CosmosOrderByItemQueryExecutionContext.CreateAsync(
queryContext,
initParams,
continuationToken,
cancellationToken));
};
Func <string, Task <IDocumentQueryExecutionComponent> > createParallelComponentFunc = async(continuationToken) =>
{
return(await CosmosParallelItemQueryExecutionContext.CreateAsync(
queryContext,
initParams,
continuationToken,
cancellationToken));
};
return((CosmosQueryExecutionContext)await PipelinedDocumentQueryExecutionContext.CreateHelperAsync(
queryContext.QueryClient,
initParams.PartitionedQueryExecutionInfo.QueryInfo,
initialPageSize,
requestContinuationToken,
createOrderByComponentFunc,
createParallelComponentFunc));
}
/// <summary>
/// Creates a CosmosPipelinedItemQueryExecutionContext.
/// </summary>
/// <param name="executionEnvironment">The environment to execute on.</param>
/// <param name="queryContext">The parameters for constructing the base class.</param>
/// <param name="initParams">The initial parameters</param>
/// <param name="requestContinuationToken">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(
ExecutionEnvironment executionEnvironment,
CosmosQueryContext queryContext,
CosmosCrossPartitionQueryExecutionContext.CrossPartitionInitParams initParams,
string requestContinuationToken,
CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
QueryInfo queryInfo = initParams.PartitionedQueryExecutionInfo.QueryInfo;
int initialPageSize = initParams.InitialPageSize;
CosmosCrossPartitionQueryExecutionContext.CrossPartitionInitParams parameters = initParams;
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);
}
Func <string, Task <IDocumentQueryExecutionComponent> > createOrderByComponentFunc = async(continuationToken) =>
{
return(await CosmosOrderByItemQueryExecutionContext.CreateAsync(
queryContext,
initParams,
continuationToken,
cancellationToken));
};
Func <string, Task <IDocumentQueryExecutionComponent> > createParallelComponentFunc = async(continuationToken) =>
{
return(await CosmosParallelItemQueryExecutionContext.CreateAsync(
queryContext,
initParams,
continuationToken,
cancellationToken));
};
return((CosmosQueryExecutionContext)await PipelinedDocumentQueryExecutionContext.CreateHelperAsync(
executionEnvironment,
queryContext.QueryClient,
initParams.PartitionedQueryExecutionInfo.QueryInfo,
initialPageSize,
requestContinuationToken,
createOrderByComponentFunc,
createParallelComponentFunc));
}
/// <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));
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,
createOrderByComponentFunc,
createParallelComponentFunc)));
}
/// <summary>
/// Creates a CosmosPipelinedItemQueryExecutionContext.
/// </summary>
/// <param name="executionEnvironment">The environment to execute on.</param>
/// <param name="queryContext">The parameters for constructing the base class.</param>
/// <param name="initParams">The initial parameters</param>
/// <param name="requestContinuationToken">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(
ExecutionEnvironment executionEnvironment,
CosmosQueryContext queryContext,
CosmosCrossPartitionQueryExecutionContext.CrossPartitionInitParams initParams,
string requestContinuationToken,
CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
if (requestContinuationToken != null)
{
if (!PipelineContinuationToken.TryParse(
requestContinuationToken,
out PipelineContinuationToken pipelineContinuationToken))
{
throw queryContext.QueryClient.CreateBadRequestException(
$"Malformed {nameof(PipelineContinuationToken)}: {requestContinuationToken}.");
}
if (PipelineContinuationToken.IsTokenFromTheFuture(pipelineContinuationToken))
{
throw queryContext.QueryClient.CreateBadRequestException(
$"{nameof(PipelineContinuationToken)} Continuation token is from a newer version of the SDK. Upgrade the SDK to avoid this issue.\n {requestContinuationToken}.");
}
if (!PipelineContinuationToken.TryConvertToLatest(
pipelineContinuationToken,
out PipelineContinuationTokenV1_1 latestVersionPipelineContinuationToken))
{
throw queryContext.QueryClient.CreateBadRequestException(
$"{nameof(PipelineContinuationToken)}: '{requestContinuationToken}' is no longer supported.");
}
requestContinuationToken = latestVersionPipelineContinuationToken.SourceContinuationToken;
}
QueryInfo queryInfo = initParams.PartitionedQueryExecutionInfo.QueryInfo;
int initialPageSize = initParams.InitialPageSize;
CosmosCrossPartitionQueryExecutionContext.CrossPartitionInitParams parameters = initParams;
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);
}
Func <string, Task <IDocumentQueryExecutionComponent> > createOrderByComponentFunc = async(continuationToken) =>
{
return(await CosmosOrderByItemQueryExecutionContext.CreateAsync(
queryContext,
initParams,
continuationToken,
cancellationToken));
};
Func <string, Task <IDocumentQueryExecutionComponent> > createParallelComponentFunc = async(continuationToken) =>
{
return(await CosmosParallelItemQueryExecutionContext.CreateAsync(
queryContext,
initParams,
continuationToken,
cancellationToken));
};
return((CosmosQueryExecutionContext)await PipelinedDocumentQueryExecutionContext.CreateHelperAsync(
executionEnvironment,
queryContext.QueryClient,
initParams.PartitionedQueryExecutionInfo.QueryInfo,
initialPageSize,
requestContinuationToken,
createOrderByComponentFunc,
createParallelComponentFunc));
}
/// <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 <IDocumentQueryExecutionContext> 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));
Func <string, Task <IDocumentQueryExecutionComponent> > createComponentFunc;
QueryInfo queryInfo = partitionedQueryExecutionInfo.QueryInfo;
if (queryInfo.HasOrderBy)
{
createComponentFunc = async(continuationToken) =>
{
CosmosCrossPartitionQueryExecutionContext.CrossPartitionInitParams initParams = new CosmosCrossPartitionQueryExecutionContext.CrossPartitionInitParams(
collectionRid,
partitionedQueryExecutionInfo,
partitionKeyRanges,
initialPageSize,
continuationToken);
return(await CosmosOrderByItemQueryExecutionContext.CreateAsync(
constructorParams,
initParams,
cancellationToken));
};
}
else
{
createComponentFunc = async(continuationToken) =>
{
CosmosCrossPartitionQueryExecutionContext.CrossPartitionInitParams initParams = new CosmosCrossPartitionQueryExecutionContext.CrossPartitionInitParams(
collectionRid,
partitionedQueryExecutionInfo,
partitionKeyRanges,
initialPageSize,
continuationToken);
return(await CosmosParallelItemQueryExecutionContext.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.QueryRequestOptions.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.QueryRequestOptions.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 CosmosPipelinedItemQueryExecutionContext(
await createComponentFunc(requestContinuation), initialPageSize));
}
