public static Task<PartitionedQueryExecutionInfo> GetQueryPlanWithServiceInteropAsync(
CosmosQueryClient queryClient,
SqlQuerySpec sqlQuerySpec,
PartitionKeyDefinition partitionKeyDefinition,
bool hasLogicalPartitionKey,
CancellationToken cancellationToken = default(CancellationToken))
{
if (queryClient == null)
{
throw new ArgumentNullException(nameof(queryClient));
}
if (sqlQuerySpec == null)
{
throw new ArgumentNullException(nameof(sqlQuerySpec));
}
if (partitionKeyDefinition == null)
{
throw new ArgumentNullException(nameof(partitionKeyDefinition));
}
cancellationToken.ThrowIfCancellationRequested();
QueryPlanHandler queryPlanHandler = new QueryPlanHandler(queryClient);
return queryPlanHandler.GetQueryPlanAsync(
sqlQuerySpec,
partitionKeyDefinition,
QueryPlanRetriever.SupportedQueryFeatures,
hasLogicalPartitionKey,
cancellationToken);
}
public static Task <PartitionedQueryExecutionInfo> GetQueryPlanThroughGatewayAsync(
CosmosQueryClient client,
SqlQuerySpec sqlQuerySpec,
Uri resourceLink,
CancellationToken cancellationToken = default(CancellationToken))
{
if (client == null)
{
throw new ArgumentNullException(nameof(client));
}
if (sqlQuerySpec == null)
{
throw new ArgumentNullException(nameof(sqlQuerySpec));
}
if (resourceLink == null)
{
throw new ArgumentNullException(nameof(resourceLink));
}
cancellationToken.ThrowIfCancellationRequested();
return(client.ExecuteQueryPlanRequestAsync(
resourceLink,
ResourceType.Document,
OperationType.QueryPlan,
sqlQuerySpec,
QueryPlanRetriever.SupportedQueryFeaturesString,
cancellationToken));
}
public static SingleGroupAggregator Create(
CosmosQueryClient queryClient,
AggregateOperator[] aggregates,
IReadOnlyDictionary <string, AggregateOperator?> aggregateAliasToAggregateType,
IReadOnlyList <string> orderedAliases,
bool hasSelectValue,
string continuationToken)
{
SingleGroupAggregator aggregateValues;
if (hasSelectValue)
{
if (aggregates != null && aggregates.Any())
{
// SELECT VALUE <AGGREGATE>
aggregateValues = SelectValueAggregateValues.Create(aggregates[0], continuationToken);
}
else
{
// SELECT VALUE <NON AGGREGATE>
aggregateValues = SelectValueAggregateValues.Create(aggregateOperator: null, continuationToken: continuationToken);
}
}
else
{
aggregateValues = SelectListAggregateValues.Create(queryClient, aggregateAliasToAggregateType, orderedAliases, continuationToken);
}
return(aggregateValues);
}
public CosmosQueryContextCore(
CosmosQueryClient client,
QueryRequestOptions queryRequestOptions,
ResourceType resourceTypeEnum,
OperationType operationType,
Type resourceType,
Uri resourceLink,
Guid correlatedActivityId,
bool isContinuationExpected,
bool allowNonValueAggregateQuery,
CosmosDiagnosticsContext diagnosticsContext,
string containerResourceId = null)
: base(
client,
resourceTypeEnum,
operationType,
resourceType,
resourceLink,
correlatedActivityId,
isContinuationExpected,
allowNonValueAggregateQuery,
containerResourceId)
{
this.queryRequestOptions = queryRequestOptions;
this.diagnosticsContext = diagnosticsContext;
}
/// <summary>
/// Gets the list of partition key ranges.
/// 1. Check partition key range id
/// 2. Check Partition key
/// 3. Check the effective partition key
/// 4. Get the range from the PartitionedQueryExecutionInfo
/// </summary>
internal static async Task <List <Documents.PartitionKeyRange> > GetTargetPartitionKeyRangesAsync(
CosmosQueryClient queryClient,
string resourceLink,
PartitionedQueryExecutionInfo partitionedQueryExecutionInfo,
ContainerQueryProperties containerQueryProperties,
IDictionary <string, object> properties)
{
List <Documents.PartitionKeyRange> targetRanges;
if (containerQueryProperties.EffectivePartitionKeyString != null)
{
targetRanges = await queryClient.GetTargetPartitionKeyRangesByEpkStringAsync(
resourceLink,
containerQueryProperties.ResourceId,
containerQueryProperties.EffectivePartitionKeyString);
}
else if (TryGetEpkProperty(properties, out string effectivePartitionKeyString))
{
targetRanges = await queryClient.GetTargetPartitionKeyRangesByEpkStringAsync(
resourceLink,
containerQueryProperties.ResourceId,
effectivePartitionKeyString);
}
else
{
targetRanges = await queryClient.GetTargetPartitionKeyRangesAsync(
resourceLink,
containerQueryProperties.ResourceId,
partitionedQueryExecutionInfo.QueryRanges);
}
return(targetRanges);
}
/// <summary>
/// Gets the list of partition key ranges.
/// 1. Check partition key range id
/// 2. Check Partition key
/// 3. Check the effective partition key
/// 4. Get the range from the PartitionedQueryExecutionInfo
/// </summary>
internal static async Task <List <PartitionKeyRange> > GetTargetPartitionKeyRanges(
CosmosQueryClient queryClient,
string resourceLink,
PartitionedQueryExecutionInfo partitionedQueryExecutionInfo,
CosmosContainerSettings collection,
CosmosQueryRequestOptions queryRequestOptions)
{
List <PartitionKeyRange> targetRanges;
if (queryRequestOptions.PartitionKey != null)
{
targetRanges = await queryClient.GetTargetPartitionKeyRangesByEpkString(
resourceLink,
collection.ResourceId,
new PartitionKey(queryRequestOptions.PartitionKey).InternalKey.GetEffectivePartitionKeyString(collection.PartitionKey));
}
else if (TryGetEpkProperty(queryRequestOptions, out string effectivePartitionKeyString))
{
targetRanges = await queryClient.GetTargetPartitionKeyRangesByEpkString(
resourceLink,
collection.ResourceId,
effectivePartitionKeyString);
}
else
{
targetRanges = await queryClient.GetTargetPartitionKeyRanges(
resourceLink,
collection.ResourceId,
partitionedQueryExecutionInfo.QueryRanges);
}
return(targetRanges);
}
public CosmosQueryContext(
CosmosQueryClient client,
ResourceType resourceTypeEnum,
OperationType operationType,
Type resourceType,
SqlQuerySpec sqlQuerySpecFromUser,
QueryRequestOptions queryRequestOptions,
Uri resourceLink,
bool getLazyFeedResponse,
Guid correlatedActivityId,
bool isContinuationExpected,
bool allowNonValueAggregateQuery,
string containerResourceId = null)
{
if (client == null)
{
throw new ArgumentNullException(nameof(client));
}
if (resourceType == null)
{
throw new ArgumentNullException(nameof(resourceType));
}
if (sqlQuerySpecFromUser == null)
{
throw new ArgumentNullException(nameof(sqlQuerySpecFromUser));
}
if (queryRequestOptions == null)
{
throw new ArgumentNullException(nameof(queryRequestOptions));
}
if (correlatedActivityId == Guid.Empty)
{
throw new ArgumentException(nameof(correlatedActivityId));
}
this.OperationTypeEnum = operationType;
this.QueryClient = client;
this.ResourceTypeEnum = resourceTypeEnum;
this.ResourceType = resourceType;
this.SqlQuerySpec = sqlQuerySpecFromUser;
this.QueryRequestOptions = queryRequestOptions;
this.ResourceLink = resourceLink;
this.ContainerResourceId = containerResourceId;
this.IsContinuationExpected = isContinuationExpected;
this.AllowNonValueAggregateQuery = allowNonValueAggregateQuery;
this.CorrelatedActivityId = correlatedActivityId;
}
public static Task <PartitionedQueryExecutionInfo> GetQueryPlanWithServiceInteropAsync(
CosmosQueryClient queryClient,
SqlQuerySpec sqlQuerySpec,
PartitionKeyDefinition partitionKeyDefinition,
CancellationToken cancellationToken)
{
QueryPlanHandler queryPlanHandler = new QueryPlanHandler(queryClient);
return(queryPlanHandler.GetQueryPlanAsync(
sqlQuerySpec,
partitionKeyDefinition,
SupportedQueryFeatures,
cancellationToken));
}
public static SelectListAggregateValues Create(
CosmosQueryClient cosmosQueryClient,
IReadOnlyDictionary <string, AggregateOperator?> aggregateAliasToAggregateType,
IReadOnlyList <string> orderedAliases,
string continuationToken)
{
CosmosObject aliasToContinuationToken;
if (continuationToken != null)
{
if (!CosmosElement.TryParse(continuationToken, out aliasToContinuationToken))
{
throw cosmosQueryClient.CreateBadRequestException(
$"{nameof(SelectListAggregateValues)} continuation token is malformed: {continuationToken}.");
}
}
else
{
aliasToContinuationToken = null;
}
Dictionary <string, AggregateValue> groupingTable = new Dictionary <string, AggregateValue>();
foreach (KeyValuePair <string, AggregateOperator?> aliasToAggregate in aggregateAliasToAggregateType)
{
string alias = aliasToAggregate.Key;
AggregateOperator?aggregateOperator = aliasToAggregate.Value;
string aliasContinuationToken;
if (aliasToContinuationToken != null)
{
if (!(aliasToContinuationToken[alias] is CosmosString parsedAliasContinuationToken))
{
throw cosmosQueryClient.CreateBadRequestException(
$"{nameof(SelectListAggregateValues)} continuation token is malformed: {continuationToken}.");
}
aliasContinuationToken = parsedAliasContinuationToken.Value;
}
else
{
aliasContinuationToken = null;
}
groupingTable[alias] = AggregateValue.Create(aggregateOperator, aliasContinuationToken);
}
return(new SelectListAggregateValues(groupingTable, orderedAliases));
}
public static Task <PartitionedQueryExecutionInfo> GetQueryPlanThroughGatewayAsync(
CosmosQueryClient client,
SqlQuerySpec sqlQuerySpec,
Uri resourceLink,
CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
return(client.ExecuteQueryPlanRequestAsync(
resourceLink,
ResourceType.Document,
OperationType.QueryPlan,
sqlQuerySpec,
QueryPlanRetriever.SupportedQueryFeaturesString,
cancellationToken));
}
public static QueryIterator Create(
CosmosQueryClient client,
SqlQuerySpec sqlQuerySpec,
string continuationToken,
QueryRequestOptions queryRequestOptions,
Uri resourceLink,
bool isContinuationExpected,
bool allowNonValueAggregateQuery,
PartitionedQueryExecutionInfo partitionedQueryExecutionInfo)
{
if (queryRequestOptions == null)
{
queryRequestOptions = new QueryRequestOptions();
}
CosmosQueryContext context = new CosmosQueryContextCore(
client: client,
queryRequestOptions: queryRequestOptions,
resourceTypeEnum: Documents.ResourceType.Document,
operationType: Documents.OperationType.Query,
resourceType: typeof(QueryResponseCore),
resourceLink: resourceLink,
isContinuationExpected: isContinuationExpected,
allowNonValueAggregateQuery: allowNonValueAggregateQuery,
correlatedActivityId: Guid.NewGuid());
CosmosQueryExecutionContextFactory.InputParameters inputParams = new CosmosQueryExecutionContextFactory.InputParameters()
{
SqlQuerySpec = sqlQuerySpec,
InitialUserContinuationToken = continuationToken,
MaxBufferedItemCount = queryRequestOptions.MaxBufferedItemCount,
MaxConcurrency = queryRequestOptions.MaxConcurrency,
MaxItemCount = queryRequestOptions.MaxItemCount,
PartitionKey = queryRequestOptions.PartitionKey,
Properties = queryRequestOptions.Properties,
PartitionedQueryExecutionInfo = partitionedQueryExecutionInfo,
ExecutionEnvironment = queryRequestOptions.ExecutionEnvironment.GetValueOrDefault(Core.ExecutionContext.ExecutionEnvironment.Client),
ResponseContinuationTokenLimitInKb = queryRequestOptions.ResponseContinuationTokenLimitInKb,
};
return(new QueryIterator(
new CosmosQueryExecutionContextFactory(
cosmosQueryContext: context,
inputParameters: inputParams),
queryRequestOptions.CosmosSerializationFormatOptions));
}
public static QueryIterator Create(
CosmosQueryClient client,
SqlQuerySpec sqlQuerySpec,
string continuationToken,
QueryRequestOptions queryRequestOptions,
Uri resourceLink,
bool isContinuationExpected,
bool allowNonValueAggregateQuery,
PartitionedQueryExecutionInfo partitionedQueryExecutionInfo)
{
if (queryRequestOptions == null)
{
queryRequestOptions = new QueryRequestOptions();
}
CosmosQueryContext cosmosQueryContext = new CosmosQueryContextCore(
client: client,
queryRequestOptions: queryRequestOptions,
resourceTypeEnum: Documents.ResourceType.Document,
operationType: Documents.OperationType.Query,
resourceType: typeof(QueryResponseCore),
resourceLink: resourceLink,
isContinuationExpected: isContinuationExpected,
allowNonValueAggregateQuery: allowNonValueAggregateQuery,
correlatedActivityId: Guid.NewGuid());
CosmosQueryExecutionContextFactory.InputParameters inputParameters = new CosmosQueryExecutionContextFactory.InputParameters(
sqlQuerySpec: sqlQuerySpec,
initialUserContinuationToken: continuationToken,
maxConcurrency: queryRequestOptions.MaxConcurrency,
maxItemCount: queryRequestOptions.MaxItemCount,
maxBufferedItemCount: queryRequestOptions.MaxBufferedItemCount,
partitionKey: queryRequestOptions.PartitionKey,
properties: queryRequestOptions.Properties,
partitionedQueryExecutionInfo: partitionedQueryExecutionInfo,
executionEnvironment: queryRequestOptions.ExecutionEnvironment,
returnResultsInDeterministicOrder: queryRequestOptions.ReturnResultsInDeterministicOrder,
testInjections: queryRequestOptions.TestSettings);
return(new QueryIterator(
cosmosQueryContext,
CosmosQueryExecutionContextFactory.Create(cosmosQueryContext, inputParameters),
queryRequestOptions.CosmosSerializationFormatOptions,
queryRequestOptions));
}
/// <summary>
/// Gets the list of partition key ranges.
/// 1. Check partition key range id
/// 2. Check Partition key
/// 3. Check the effective partition key
/// 4. Get the range from the PartitionedQueryExecutionInfo
/// </summary>
internal static async Task <List <PartitionKeyRange> > GetTargetPartitionKeyRangesAsync(
CosmosQueryClient queryClient,
string resourceLink,
PartitionedQueryExecutionInfo partitionedQueryExecutionInfo,
CosmosContainerSettings collection,
QueryRequestOptions queryRequestOptions)
{
List <PartitionKeyRange> targetRanges;
if (queryRequestOptions.PartitionKey != null)
{
// Dis-ambiguate the NonePK if used
PartitionKeyInternal partitionKeyInternal = null;
if (Object.ReferenceEquals(queryRequestOptions.PartitionKey, CosmosContainerSettings.NonePartitionKeyValue))
{
partitionKeyInternal = collection.GetNoneValue();
}
else
{
partitionKeyInternal = new PartitionKey(queryRequestOptions.PartitionKey).InternalKey;
}
targetRanges = await queryClient.GetTargetPartitionKeyRangesByEpkStringAsync(
resourceLink,
collection.ResourceId,
partitionKeyInternal.GetEffectivePartitionKeyString(collection.PartitionKey));
}
else if (TryGetEpkProperty(queryRequestOptions, out string effectivePartitionKeyString))
{
targetRanges = await queryClient.GetTargetPartitionKeyRangesByEpkStringAsync(
resourceLink,
collection.ResourceId,
effectivePartitionKeyString);
}
else
{
targetRanges = await queryClient.GetTargetPartitionKeyRangesAsync(
resourceLink,
collection.ResourceId,
partitionedQueryExecutionInfo.QueryRanges);
}
return(targetRanges);
}
public static Task <PartitionedQueryExecutionInfo> GetPartitionedQueryExecutionInfoAsync(
CosmosQueryClient queryClient,
SqlQuerySpec sqlQuerySpec,
PartitionKeyDefinition partitionKeyDefinition,
bool requireFormattableOrderByQuery,
bool isContinuationExpected,
bool allowNonValueAggregateQuery,
CancellationToken cancellationToken)
{
// $ISSUE-felixfan-2016-07-13: We should probably get PartitionedQueryExecutionInfo from Gateway in GatewayMode
return(queryClient.GetPartitionedQueryExecutionInfoAsync(
sqlQuerySpec,
partitionKeyDefinition,
requireFormattableOrderByQuery,
isContinuationExpected,
allowNonValueAggregateQuery,
cancellationToken));
}
public static async Task <PartitionedQueryExecutionInfo> GetQueryPlanWithServiceInteropAsync(
CosmosQueryClient queryClient,
SqlQuerySpec sqlQuerySpec,
PartitionKeyDefinition partitionKeyDefinition,
bool hasLogicalPartitionKey,
CancellationToken cancellationToken = default(CancellationToken))
{
if (queryClient == null)
{
throw new ArgumentNullException(nameof(queryClient));
}
if (sqlQuerySpec == null)
{
throw new ArgumentNullException(nameof(sqlQuerySpec));
}
if (partitionKeyDefinition == null)
{
throw new ArgumentNullException(nameof(partitionKeyDefinition));
}
cancellationToken.ThrowIfCancellationRequested();
QueryPlanHandler queryPlanHandler = new QueryPlanHandler(queryClient);
TryCatch <PartitionedQueryExecutionInfo> tryGetQueryPlan = await queryPlanHandler.TryGetQueryPlanAsync(
sqlQuerySpec,
partitionKeyDefinition,
QueryPlanRetriever.SupportedQueryFeatures,
hasLogicalPartitionKey,
cancellationToken);
if (!tryGetQueryPlan.Succeeded)
{
throw new CosmosException(
System.Net.HttpStatusCode.BadRequest,
tryGetQueryPlan.Exception.Message);
}
return(tryGetQueryPlan.Result);
}
internal QueryIterator(
CosmosQueryClient client,
SqlQuerySpec sqlQuerySpec,
string continuationToken,
QueryRequestOptions queryRequestOptions,
Uri resourceLink,
bool isContinuationExpected,
bool allowNonValueAggregateQuery)
{
if (queryRequestOptions == null)
{
queryRequestOptions = new QueryRequestOptions();
}
CosmosQueryContext context = new CosmosQueryContextCore(
client: client,
queryRequestOptions: queryRequestOptions,
resourceTypeEnum: Documents.ResourceType.Document,
operationType: Documents.OperationType.Query,
resourceType: typeof(QueryResponseCore),
resourceLink: resourceLink,
isContinuationExpected: isContinuationExpected,
allowNonValueAggregateQuery: allowNonValueAggregateQuery,
correlatedActivityId: Guid.NewGuid());
CosmosQueryExecutionContextFactory.InputParameters inputParams = new CosmosQueryExecutionContextFactory.InputParameters()
{
SqlQuerySpec = sqlQuerySpec,
InitialUserContinuationToken = continuationToken,
MaxBufferedItemCount = queryRequestOptions.MaxBufferedItemCount,
MaxConcurrency = queryRequestOptions.MaxConcurrency,
MaxItemCount = queryRequestOptions.MaxItemCount,
PartitionKey = queryRequestOptions.PartitionKey,
Properties = queryRequestOptions.Properties
};
this.cosmosSerializationFormatOptions = queryRequestOptions.CosmosSerializationFormatOptions;
this.cosmosQueryExecutionContext = new CosmosQueryExecutionContextFactory(
cosmosQueryContext: context,
inputParameters: inputParams);
}
/// <summary>
/// Initializes a new instance of the OrderByContinuationToken struct.
/// </summary>
/// <param name="queryClient">The query client</param>
/// <param name="compositeContinuationToken">The composite continuation token (refer to property documentation).</param>
/// <param name="orderByItems">The order by items (refer to property documentation).</param>
/// <param name="rid">The rid (refer to property documentation).</param>
/// <param name="skipCount">The skip count (refer to property documentation).</param>
/// <param name="filter">The filter (refer to property documentation).</param>
public OrderByContinuationToken(
CosmosQueryClient queryClient,
CompositeContinuationToken compositeContinuationToken,
IList <OrderByItem> orderByItems,
string rid,
int skipCount,
string filter)
{
if (compositeContinuationToken == null)
{
throw new ArgumentNullException($"{nameof(compositeContinuationToken)} can not be null.");
}
if (orderByItems == null)
{
throw new ArgumentNullException($"{nameof(orderByItems)} can not be null.");
}
if (orderByItems.Count == 0)
{
throw new ArgumentException($"{nameof(orderByItems)} can not be empty.");
}
if (string.IsNullOrWhiteSpace(rid))
{
throw new ArgumentNullException($"{nameof(rid)} can not be null or empty or whitespace.");
}
if (skipCount < 0)
{
throw new ArgumentException($"{nameof(skipCount)} can not be negative.");
}
//// filter is allowed to be null.
this.CompositeContinuationToken = compositeContinuationToken;
this.OrderByItems = orderByItems;
this.Rid = rid;
this.SkipCount = skipCount;
}
internal QueryIterator(
CosmosQueryClient client,
SqlQuerySpec sqlQuerySpec,
string continuationToken,
QueryRequestOptions queryRequestOptions,
Uri resourceLink,
bool isContinuationExpected,
bool allowNonValueAggregateQuery)
{
this.cosmosQueryExecutionContext = new CosmosQueryExecutionContextFactory(
client: client,
resourceTypeEnum: Documents.ResourceType.Document,
operationType: Documents.OperationType.Query,
resourceType: typeof(QueryResponseCore),
sqlQuerySpec: sqlQuerySpec,
continuationToken: continuationToken,
queryRequestOptions: queryRequestOptions,
resourceLink: resourceLink,
isContinuationExpected: isContinuationExpected,
allowNonValueAggregateQuery: allowNonValueAggregateQuery,
correlatedActivityId: Guid.NewGuid());
}
public CosmosQueryContextCore(
CosmosQueryClient client,
ResourceType resourceTypeEnum,
OperationType operationType,
Type resourceType,
string resourceLink,
Guid correlatedActivityId,
bool isContinuationExpected,
bool allowNonValueAggregateQuery,
string containerResourceId = null)
: base(
client,
resourceTypeEnum,
operationType,
resourceType,
resourceLink,
correlatedActivityId,
isContinuationExpected,
allowNonValueAggregateQuery,
containerResourceId)
{
}
public CosmosQueryContext(
CosmosQueryClient client,
ResourceType resourceTypeEnum,
OperationType operationType,
Type resourceType,
Uri resourceLink,
Guid correlatedActivityId,
bool isContinuationExpected,
bool allowNonValueAggregateQuery,
string containerResourceId = null)
{
if (client == null)
{
throw new ArgumentNullException(nameof(client));
}
if (resourceType == null)
{
throw new ArgumentNullException(nameof(resourceType));
}
if (correlatedActivityId == Guid.Empty)
{
throw new ArgumentException(nameof(correlatedActivityId));
}
this.OperationTypeEnum = operationType;
this.QueryClient = client;
this.ResourceTypeEnum = resourceTypeEnum;
this.ResourceType = resourceType;
this.ResourceLink = resourceLink;
this.ContainerResourceId = containerResourceId;
this.IsContinuationExpected = isContinuationExpected;
this.AllowNonValueAggregateQuery = allowNonValueAggregateQuery;
this.CorrelatedActivityId = correlatedActivityId;
}
public static QueryIterator Create(
CosmosQueryClient client,
SqlQuerySpec sqlQuerySpec,
string continuationToken,
QueryRequestOptions queryRequestOptions,
Uri resourceLink,
bool isContinuationExpected,
bool allowNonValueAggregateQuery,
PartitionedQueryExecutionInfo partitionedQueryExecutionInfo)
{
if (queryRequestOptions == null)
{
queryRequestOptions = new QueryRequestOptions();
}
CosmosQueryContext cosmosQueryContext = new CosmosQueryContextCore(
client: client,
queryRequestOptions: queryRequestOptions,
resourceTypeEnum: Documents.ResourceType.Document,
operationType: Documents.OperationType.Query,
resourceType: typeof(QueryResponseCore),
resourceLink: resourceLink,
isContinuationExpected: isContinuationExpected,
allowNonValueAggregateQuery: allowNonValueAggregateQuery,
correlatedActivityId: Guid.NewGuid());
CosmosElement requestContinuationToken;
switch (queryRequestOptions.ExecutionEnvironment.GetValueOrDefault(ExecutionEnvironment.Client))
{
case ExecutionEnvironment.Client:
if (continuationToken != null)
{
if (!CosmosElement.TryParse(continuationToken, out requestContinuationToken))
{
return(new QueryIterator(
cosmosQueryContext,
new QueryExecutionContextWithException(
new MalformedContinuationTokenException(
$"Malformed Continuation Token: {requestContinuationToken}")),
queryRequestOptions.CosmosSerializationFormatOptions,
queryRequestOptions));
}
}
else
{
requestContinuationToken = null;
}
break;
case ExecutionEnvironment.Compute:
requestContinuationToken = queryRequestOptions.CosmosElementContinuationToken;
break;
default:
throw new ArgumentOutOfRangeException($"Unknown {nameof(ExecutionEnvironment)}: {queryRequestOptions.ExecutionEnvironment.Value}.");
}
CosmosQueryExecutionContextFactory.InputParameters inputParameters = new CosmosQueryExecutionContextFactory.InputParameters(
sqlQuerySpec: sqlQuerySpec,
initialUserContinuationToken: requestContinuationToken,
maxConcurrency: queryRequestOptions.MaxConcurrency,
maxItemCount: queryRequestOptions.MaxItemCount,
maxBufferedItemCount: queryRequestOptions.MaxBufferedItemCount,
partitionKey: queryRequestOptions.PartitionKey,
properties: queryRequestOptions.Properties,
partitionedQueryExecutionInfo: partitionedQueryExecutionInfo,
executionEnvironment: queryRequestOptions.ExecutionEnvironment,
returnResultsInDeterministicOrder: queryRequestOptions.ReturnResultsInDeterministicOrder,
testInjections: queryRequestOptions.TestSettings);
return(new QueryIterator(
cosmosQueryContext,
CosmosQueryExecutionContextFactory.Create(cosmosQueryContext, inputParameters),
queryRequestOptions.CosmosSerializationFormatOptions,
queryRequestOptions));
}
private async Task <CosmosQueryExecutionContext> CreateItemQueryExecutionContextAsync(
CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
string continuationToken = this.inputParameters.InitialUserContinuationToken;
if (this.inputParameters.InitialUserContinuationToken != null)
{
if (!PipelineContinuationToken.TryParse(
continuationToken,
out PipelineContinuationToken pipelineContinuationToken))
{
throw this.CosmosQueryContext.QueryClient.CreateBadRequestException(
$"Malformed {nameof(PipelineContinuationToken)}: {continuationToken}.");
}
if (PipelineContinuationToken.IsTokenFromTheFuture(pipelineContinuationToken))
{
throw this.CosmosQueryContext.QueryClient.CreateBadRequestException(
$"{nameof(PipelineContinuationToken)} Continuation token is from a newer version of the SDK. Upgrade the SDK to avoid this issue.\n {continuationToken}.");
}
if (!PipelineContinuationToken.TryConvertToLatest(
pipelineContinuationToken,
out PipelineContinuationTokenV1_1 latestVersionPipelineContinuationToken))
{
throw this.CosmosQueryContext.QueryClient.CreateBadRequestException(
$"{nameof(PipelineContinuationToken)}: '{continuationToken}' is no longer supported.");
}
continuationToken = latestVersionPipelineContinuationToken.SourceContinuationToken;
this.inputParameters.InitialUserContinuationToken = continuationToken;
if (latestVersionPipelineContinuationToken.QueryPlan != null)
{
this.inputParameters.PartitionedQueryExecutionInfo = latestVersionPipelineContinuationToken.QueryPlan;
}
}
CosmosQueryClient cosmosQueryClient = this.CosmosQueryContext.QueryClient;
ContainerQueryProperties containerQueryProperties = await cosmosQueryClient.GetCachedContainerQueryPropertiesAsync(
this.CosmosQueryContext.ResourceLink,
this.inputParameters.PartitionKey,
cancellationToken);
this.CosmosQueryContext.ContainerResourceId = containerQueryProperties.ResourceId;
PartitionedQueryExecutionInfo partitionedQueryExecutionInfo;
if (this.inputParameters.PartitionedQueryExecutionInfo != null)
{
partitionedQueryExecutionInfo = this.inputParameters.PartitionedQueryExecutionInfo;
}
else
{
if (this.CosmosQueryContext.QueryClient.ByPassQueryParsing())
{
// For non-Windows platforms(like Linux and OSX) in .NET Core SDK, we cannot use ServiceInterop, so need to bypass in that case.
// We are also now bypassing this for 32 bit host process running even on Windows as there are many 32 bit apps that will not work without this
partitionedQueryExecutionInfo = await QueryPlanRetriever.GetQueryPlanThroughGatewayAsync(
this.CosmosQueryContext.QueryClient,
this.inputParameters.SqlQuerySpec,
this.CosmosQueryContext.ResourceLink,
cancellationToken);
}
else
{
//todo:elasticcollections this may rely on information from collection cache which is outdated
//if collection is deleted/created with same name.
//need to make it not rely on information from collection cache.
Documents.PartitionKeyDefinition partitionKeyDefinition;
object partitionKeyDefinitionObject;
if (this.inputParameters.Properties != null &&
this.inputParameters.Properties.TryGetValue(InternalPartitionKeyDefinitionProperty, out partitionKeyDefinitionObject))
{
if (partitionKeyDefinitionObject is Documents.PartitionKeyDefinition definition)
{
partitionKeyDefinition = definition;
}
else
{
throw new ArgumentException(
"partitionkeydefinition has invalid type",
nameof(partitionKeyDefinitionObject));
}
}
else
{
partitionKeyDefinition = containerQueryProperties.PartitionKeyDefinition;
}
partitionedQueryExecutionInfo = await QueryPlanRetriever.GetQueryPlanWithServiceInteropAsync(
this.CosmosQueryContext.QueryClient,
this.inputParameters.SqlQuerySpec,
partitionKeyDefinition,
this.inputParameters.PartitionKey != null,
cancellationToken);
}
}
this.partitionedQueryExecutionInfo = partitionedQueryExecutionInfo;
return(await this.CreateFromPartitionedQuerExecutionInfoAsync(
partitionedQueryExecutionInfo,
containerQueryProperties,
cancellationToken));
}
/// <summary>
/// Initializes a new instance of the CosmosCrossPartitionQueryExecutionContext class.
/// </summary>
/// <param name="queryContext">Constructor parameters for the base class.</param>
/// <param name="maxConcurrency">The max concurrency</param>
/// <param name="maxBufferedItemCount">The max buffered item count</param>
/// <param name="maxItemCount">Max item count</param>
/// <param name="moveNextComparer">Comparer used to figure out that document producer tree to serve documents from next.</param>
/// <param name="fetchPrioirtyFunction">The priority function to determine which partition to fetch documents from next.</param>
/// <param name="equalityComparer">Used to determine whether we need to return the continuation token for a partition.</param>
protected CosmosCrossPartitionQueryExecutionContext(
CosmosQueryContext queryContext,
int?maxConcurrency,
int?maxItemCount,
int?maxBufferedItemCount,
IComparer <ItemProducerTree> moveNextComparer,
Func <ItemProducerTree, int> fetchPrioirtyFunction,
IEqualityComparer <CosmosElement> equalityComparer)
{
if (moveNextComparer == null)
{
throw new ArgumentNullException(nameof(moveNextComparer));
}
if (fetchPrioirtyFunction == null)
{
throw new ArgumentNullException(nameof(fetchPrioirtyFunction));
}
if (equalityComparer == null)
{
throw new ArgumentNullException(nameof(equalityComparer));
}
this.queryContext = queryContext ?? throw new ArgumentNullException(nameof(queryContext));
this.queryClient = queryContext.QueryClient ?? throw new ArgumentNullException(nameof(queryContext.QueryClient));
this.itemProducerForest = new PriorityQueue <ItemProducerTree>(moveNextComparer, isSynchronized: true);
this.fetchPrioirtyFunction = fetchPrioirtyFunction;
this.comparableTaskScheduler = new ComparableTaskScheduler(maxConcurrency.GetValueOrDefault(0));
this.equalityComparer = equalityComparer;
this.requestChargeTracker = new RequestChargeTracker();
this.diagnosticsPages = new ConcurrentBag <QueryPageDiagnostics>();
this.actualMaxPageSize = maxItemCount.GetValueOrDefault(ParallelQueryConfig.GetConfig().ClientInternalMaxItemCount);
if (this.actualMaxPageSize < 0)
{
throw new ArgumentOutOfRangeException("actualMaxPageSize should never be less than 0");
}
if (this.actualMaxPageSize > int.MaxValue)
{
throw new ArgumentOutOfRangeException("actualMaxPageSize should never be greater than int.MaxValue");
}
if (maxBufferedItemCount.HasValue)
{
this.actualMaxBufferedItemCount = maxBufferedItemCount.Value;
}
else
{
this.actualMaxBufferedItemCount = ParallelQueryConfig.GetConfig().DefaultMaximumBufferSize;
}
if (this.actualMaxBufferedItemCount < 0)
{
throw new ArgumentOutOfRangeException("actualMaxBufferedItemCount should never be less than 0");
}
if (this.actualMaxBufferedItemCount > int.MaxValue)
{
throw new ArgumentOutOfRangeException("actualMaxBufferedItemCount should never be greater than int.MaxValue");
}
this.CanPrefetch = maxConcurrency.HasValue && maxConcurrency.Value != 0;
}
private static async Task <PipelinedDocumentQueryExecutionContext> CreateHelperAsync(
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(
queryInfo.Aggregates,
queryInfo.GroupByAliasToAggregateType,
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(
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(
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));
}
public static QueryIterator Create(
ContainerCore containerCore,
CosmosQueryClient client,
CosmosClientContext clientContext,
SqlQuerySpec sqlQuerySpec,
string continuationToken,
FeedRangeInternal feedRangeInternal,
QueryRequestOptions queryRequestOptions,
string resourceLink,
bool isContinuationExpected,
bool allowNonValueAggregateQuery,
bool forcePassthrough,
PartitionedQueryExecutionInfo partitionedQueryExecutionInfo)
{
if (queryRequestOptions == null)
{
queryRequestOptions = new QueryRequestOptions();
}
CosmosQueryContextCore cosmosQueryContext = new CosmosQueryContextCore(
client: client,
resourceTypeEnum: Documents.ResourceType.Document,
operationType: Documents.OperationType.Query,
resourceType: typeof(QueryResponseCore),
resourceLink: resourceLink,
isContinuationExpected: isContinuationExpected,
allowNonValueAggregateQuery: allowNonValueAggregateQuery,
correlatedActivityId: Guid.NewGuid());
NetworkAttachedDocumentContainer networkAttachedDocumentContainer = new NetworkAttachedDocumentContainer(
containerCore,
client,
queryRequestOptions);
DocumentContainer documentContainer = new DocumentContainer(networkAttachedDocumentContainer);
CosmosElement requestContinuationToken;
switch (queryRequestOptions.ExecutionEnvironment.GetValueOrDefault(ExecutionEnvironment.Client))
{
case ExecutionEnvironment.Client:
if (continuationToken != null)
{
TryCatch <CosmosElement> tryParse = CosmosElement.Monadic.Parse(continuationToken);
if (tryParse.Failed)
{
return(new QueryIterator(
cosmosQueryContext,
new FaultedQueryPipelineStage(
new MalformedContinuationTokenException(
message: $"Malformed Continuation Token: {continuationToken}",
innerException: tryParse.Exception)),
queryRequestOptions.CosmosSerializationFormatOptions,
queryRequestOptions,
clientContext));
}
requestContinuationToken = tryParse.Result;
}
else
{
requestContinuationToken = null;
}
break;
case ExecutionEnvironment.Compute:
requestContinuationToken = queryRequestOptions.CosmosElementContinuationToken;
break;
default:
throw new ArgumentOutOfRangeException($"Unknown {nameof(ExecutionEnvironment)}: {queryRequestOptions.ExecutionEnvironment.Value}.");
}
CosmosQueryExecutionContextFactory.InputParameters inputParameters = new CosmosQueryExecutionContextFactory.InputParameters(
sqlQuerySpec: sqlQuerySpec,
initialUserContinuationToken: requestContinuationToken,
initialFeedRange: feedRangeInternal,
maxConcurrency: queryRequestOptions.MaxConcurrency,
maxItemCount: queryRequestOptions.MaxItemCount,
maxBufferedItemCount: queryRequestOptions.MaxBufferedItemCount,
partitionKey: queryRequestOptions.PartitionKey,
properties: queryRequestOptions.Properties,
partitionedQueryExecutionInfo: partitionedQueryExecutionInfo,
executionEnvironment: queryRequestOptions.ExecutionEnvironment,
returnResultsInDeterministicOrder: queryRequestOptions.ReturnResultsInDeterministicOrder,
forcePassthrough: forcePassthrough,
testInjections: queryRequestOptions.TestSettings);
return(new QueryIterator(
cosmosQueryContext,
CosmosQueryExecutionContextFactory.Create(documentContainer, cosmosQueryContext, inputParameters, NoOpTrace.Singleton),
queryRequestOptions.CosmosSerializationFormatOptions,
queryRequestOptions,
clientContext));
}
/// <summary>
/// Initializes a new instance of the ItemProducerTree class.
/// </summary>
/// <param name="queryContext">query context.</param>
/// <param name="querySpecForInit">query spec init.</param>
/// <param name="partitionKeyRange">The partition key range.</param>
/// <param name="produceAsyncCompleteCallback">Callback to invoke once a fetch finishes.</param>
/// <param name="itemProducerTreeComparer">Comparer to determine, which tree to produce from.</param>
/// <param name="equalityComparer">Comparer to see if we need to return the continuation token for a partition.</param>
/// <param name="deferFirstPage">Whether or not to defer fetching the first page.</param>
/// <param name="collectionRid">The collection to drain from.</param>
/// <param name="initialPageSize">The initial page size.</param>
/// <param name="initialContinuationToken">The initial continuation token.</param>
public ItemProducerTree(
CosmosQueryContext queryContext,
SqlQuerySpec querySpecForInit,
PartitionKeyRange partitionKeyRange,
Action <ItemProducerTree, int, double, QueryMetrics, long, CancellationToken> produceAsyncCompleteCallback,
IComparer <ItemProducerTree> itemProducerTreeComparer,
IEqualityComparer <CosmosElement> equalityComparer,
bool deferFirstPage,
string collectionRid,
long initialPageSize = 50,
string initialContinuationToken = null)
{
if (queryContext == null)
{
throw new ArgumentNullException($"{nameof(queryContext)}");
}
if (itemProducerTreeComparer == null)
{
throw new ArgumentNullException($"{nameof(itemProducerTreeComparer)}");
}
if (produceAsyncCompleteCallback == null)
{
throw new ArgumentNullException($"{nameof(produceAsyncCompleteCallback)}");
}
if (itemProducerTreeComparer == null)
{
throw new ArgumentNullException($"{nameof(itemProducerTreeComparer)}");
}
if (equalityComparer == null)
{
throw new ArgumentNullException($"{nameof(equalityComparer)}");
}
if (string.IsNullOrEmpty(collectionRid))
{
throw new ArgumentException($"{nameof(collectionRid)} can not be null or empty.");
}
this.Root = new ItemProducer(
queryContext,
querySpecForInit,
partitionKeyRange,
(itemProducer, itemsBuffered, resourceUnitUsage, queryMetrics, requestLength, token) => produceAsyncCompleteCallback(this, itemsBuffered, resourceUnitUsage, queryMetrics, requestLength, token),
equalityComparer,
initialPageSize,
initialContinuationToken);
this.queryClient = queryContext.QueryClient;
this.children = new PriorityQueue <ItemProducerTree>(itemProducerTreeComparer, true);
this.deferFirstPage = deferFirstPage;
this.collectionRid = collectionRid;
this.createItemProducerTreeCallback = ItemProducerTree.CreateItemProducerTreeCallback(
queryContext,
querySpecForInit,
produceAsyncCompleteCallback,
itemProducerTreeComparer,
equalityComparer,
deferFirstPage,
collectionRid,
initialPageSize);
this.executeWithSplitProofingSemaphore = new SemaphoreSlim(1, 1);
}
public CosmosQueryExecutionContextFactory(
CosmosQueryClient client,
ResourceType resourceTypeEnum,
OperationType operationType,
Type resourceType,
SqlQuerySpec sqlQuerySpec,
QueryRequestOptions queryRequestOptions,
Uri resourceLink,
bool isContinuationExpected,
bool allowNonValueAggregateQuery,
Guid correlatedActivityId)
{
if (client == null)
{
throw new ArgumentNullException(nameof(client));
}
if (sqlQuerySpec == null)
{
throw new ArgumentNullException(nameof(sqlQuerySpec));
}
if (queryRequestOptions == null)
{
throw new ArgumentNullException(nameof(queryRequestOptions));
}
if (resourceLink == null)
{
throw new ArgumentNullException(nameof(resourceLink));
}
// Prevent users from updating the values after creating the execution context.
QueryRequestOptions cloneQueryRequestOptions = queryRequestOptions.Clone();
// Swapping out negative values in feedOptions for int.MaxValue
if (cloneQueryRequestOptions.MaxBufferedItemCount.HasValue && cloneQueryRequestOptions.MaxBufferedItemCount < 0)
{
cloneQueryRequestOptions.MaxBufferedItemCount = int.MaxValue;
}
if (cloneQueryRequestOptions.MaxConcurrency.HasValue && cloneQueryRequestOptions.MaxConcurrency < 0)
{
cloneQueryRequestOptions.MaxConcurrency = int.MaxValue;
}
if (cloneQueryRequestOptions.MaxItemCount.HasValue && cloneQueryRequestOptions.MaxItemCount < 0)
{
cloneQueryRequestOptions.MaxItemCount = int.MaxValue;
}
this.cosmosQueryContext = new CosmosQueryContext(
client: client,
resourceTypeEnum: resourceTypeEnum,
operationType: operationType,
resourceType: resourceType,
sqlQuerySpecFromUser: sqlQuerySpec,
queryRequestOptions: cloneQueryRequestOptions,
resourceLink: resourceLink,
getLazyFeedResponse: isContinuationExpected,
isContinuationExpected: isContinuationExpected,
allowNonValueAggregateQuery: allowNonValueAggregateQuery,
correlatedActivityId: correlatedActivityId);
}
private async Task <CosmosQueryExecutionContext> CreateItemQueryExecutionContextAsync(
CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
CosmosQueryClient cosmosQueryClient = this.CosmosQueryContext.QueryClient;
ContainerQueryProperties containerQueryProperties = await cosmosQueryClient.GetCachedContainerQueryPropertiesAsync(
this.CosmosQueryContext.ResourceLink,
this.inputParameters.PartitionKey,
cancellationToken);
this.CosmosQueryContext.ContainerResourceId = containerQueryProperties.ResourceId;
PartitionedQueryExecutionInfo partitionedQueryExecutionInfo;
if (this.CosmosQueryContext.QueryClient.ByPassQueryParsing() && TestFlag)
{
// For non-Windows platforms(like Linux and OSX) in .NET Core SDK, we cannot use ServiceInterop, so need to bypass in that case.
// We are also now bypassing this for 32 bit host process running even on Windows as there are many 32 bit apps that will not work without this
partitionedQueryExecutionInfo = await QueryPlanRetriever.GetQueryPlanThroughGatewayAsync(
this.CosmosQueryContext.QueryClient,
this.inputParameters.SqlQuerySpec,
this.CosmosQueryContext.ResourceLink,
cancellationToken);
}
else
{
//todo:elasticcollections this may rely on information from collection cache which is outdated
//if collection is deleted/created with same name.
//need to make it not rely on information from collection cache.
Documents.PartitionKeyDefinition partitionKeyDefinition;
object partitionKeyDefinitionObject;
if (this.inputParameters.Properties != null &&
this.inputParameters.Properties.TryGetValue(InternalPartitionKeyDefinitionProperty, out partitionKeyDefinitionObject))
{
if (partitionKeyDefinitionObject is Documents.PartitionKeyDefinition definition)
{
partitionKeyDefinition = definition;
}
else
{
throw new ArgumentException(
"partitionkeydefinition has invalid type",
nameof(partitionKeyDefinitionObject));
}
}
else
{
partitionKeyDefinition = containerQueryProperties.PartitionKeyDefinition;
}
partitionedQueryExecutionInfo = await QueryPlanRetriever.GetQueryPlanWithServiceInteropAsync(
this.CosmosQueryContext.QueryClient,
this.inputParameters.SqlQuerySpec,
partitionKeyDefinition,
this.inputParameters.PartitionKey != null,
cancellationToken);
}
List <Documents.PartitionKeyRange> targetRanges = await CosmosQueryExecutionContextFactory.GetTargetPartitionKeyRangesAsync(
this.CosmosQueryContext.QueryClient,
this.CosmosQueryContext.ResourceLink.OriginalString,
partitionedQueryExecutionInfo,
containerQueryProperties,
this.inputParameters.Properties);
if (!string.IsNullOrEmpty(partitionedQueryExecutionInfo.QueryInfo.RewrittenQuery))
{
// We need pass down the rewritten query.
this.inputParameters.SqlQuerySpec = new SqlQuerySpec()
{
QueryText = partitionedQueryExecutionInfo.QueryInfo.RewrittenQuery,
Parameters = this.inputParameters.SqlQuerySpec.Parameters
};
}
return(await CosmosQueryExecutionContextFactory.CreateSpecializedDocumentQueryExecutionContextAsync(
this.CosmosQueryContext,
this.inputParameters,
partitionedQueryExecutionInfo,
targetRanges,
containerQueryProperties.ResourceId,
cancellationToken));
}
