/// <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 async Task <IDocumentQueryExecutionContext> CreateDocumentQueryExecutionContextAsync(
IDocumentQueryClient client,
ResourceType resourceTypeEnum,
Type resourceType,
Expression expression,
FeedOptions feedOptions,
string resourceLink,
bool isContinuationExpected,
CancellationToken token,
Guid correlatedActivityId)
{
CosmosContainerSettings collection = null;
if (resourceTypeEnum.IsCollectionChild())
{
CollectionCache collectionCache = await client.GetCollectionCacheAsync();
using (
DocumentServiceRequest request = DocumentServiceRequest.Create(
OperationType.Query,
resourceTypeEnum,
resourceLink,
AuthorizationTokenType.Invalid)) //this request doesnt actually go to server
{
collection = await collectionCache.ResolveCollectionAsync(request, token);
}
if (feedOptions != null && feedOptions.PartitionKey != null && feedOptions.PartitionKey.Equals(Documents.PartitionKey.None))
{
feedOptions.PartitionKey = Documents.PartitionKey.FromInternalKey(collection.GetNoneValue());
}
}
DocumentQueryExecutionContextBase.InitParams constructorParams = new DocumentQueryExecutionContextBase.InitParams(
client,
resourceTypeEnum,
resourceType,
expression,
feedOptions,
resourceLink,
false,
correlatedActivityId);
// 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
if (CustomTypeExtensions.ByPassQueryParsing())
{
// We create a ProxyDocumentQueryExecutionContext that will be initialized with DefaultDocumentQueryExecutionContext
// which will be used to send the query to Gateway and on getting 400(bad request) with 1004(cross partition query not servable), we initialize it with
// PipelinedDocumentQueryExecutionContext by providing the partition query execution info that's needed(which we get from the exception returned from Gateway).
ProxyDocumentQueryExecutionContext proxyQueryExecutionContext =
ProxyDocumentQueryExecutionContext.Create(
client,
resourceTypeEnum,
resourceType,
expression,
feedOptions,
resourceLink,
token,
collection,
isContinuationExpected,
correlatedActivityId);
return(proxyQueryExecutionContext);
}
DefaultDocumentQueryExecutionContext queryExecutionContext = await DefaultDocumentQueryExecutionContext.CreateAsync(
constructorParams, isContinuationExpected, token);
// If isContinuationExpected is false, we want to check if there are aggregates.
if (
resourceTypeEnum.IsCollectionChild() &&
resourceTypeEnum.IsPartitioned() &&
(feedOptions.EnableCrossPartitionQuery || !isContinuationExpected))
{
//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.
PartitionedQueryExecutionInfo partitionedQueryExecutionInfo = await queryExecutionContext.GetPartitionedQueryExecutionInfoAsync(
partitionKeyDefinition : collection.PartitionKey,
requireFormattableOrderByQuery : true,
isContinuationExpected : isContinuationExpected,
allowNonValueAggregateQuery : false,
hasLogicalPartitionKey : feedOptions.PartitionKey != null,
cancellationToken : token);
if (DocumentQueryExecutionContextFactory.ShouldCreateSpecializedDocumentQueryExecutionContext(
resourceTypeEnum,
feedOptions,
partitionedQueryExecutionInfo,
collection.PartitionKey,
isContinuationExpected))
{
List <PartitionKeyRange> targetRanges = await GetTargetPartitionKeyRangesAsync(
queryExecutionContext,
partitionedQueryExecutionInfo,
collection,
feedOptions);
return(await CreateSpecializedDocumentQueryExecutionContextAsync(
constructorParams,
partitionedQueryExecutionInfo,
targetRanges,
collection.ResourceId,
isContinuationExpected,
token));
}
}
return(queryExecutionContext);
}
private async Task <IDocumentQueryExecutionContext> CreateItemQueryExecutionContextAsync(CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
CosmosContainerSettings collection = null;
if (this.cosmosQueryContext.ResourceTypeEnum.IsCollectionChild())
{
CollectionCache collectionCache = await this.cosmosQueryContext.QueryClient.GetCollectionCacheAsync();
using (
DocumentServiceRequest request = DocumentServiceRequest.Create(
OperationType.Query,
this.cosmosQueryContext.ResourceTypeEnum,
this.cosmosQueryContext.ResourceLink.OriginalString,
AuthorizationTokenType.Invalid)) //this request doesn't actually go to server
{
collection = await collectionCache.ResolveCollectionAsync(request, cancellationToken);
}
if (this.cosmosQueryContext.QueryRequestOptions != null && this.cosmosQueryContext.QueryRequestOptions.PartitionKey != null && this.cosmosQueryContext.QueryRequestOptions.PartitionKey.Equals(PartitionKey.None))
{
this.cosmosQueryContext.QueryRequestOptions.PartitionKey = PartitionKey.FromInternalKey(collection.GetNoneValue());
}
}
if (collection == null)
{
throw new ArgumentException($"The container was not found for resource: {this.cosmosQueryContext.ResourceLink.OriginalString} ");
}
this.cosmosQueryContext.ContainerResourceId = collection.ResourceId;
// 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
if (this.cosmosQueryContext.QueryClient.ByPassQueryParsing())
{
// We create a ProxyDocumentQueryExecutionContext that will be initialized with DefaultDocumentQueryExecutionContext
// which will be used to send the query to Gateway and on getting 400(bad request) with 1004(cross partition query not servable), we initialize it with
// PipelinedDocumentQueryExecutionContext by providing the partition query execution info that's needed(which we get from the exception returned from Gateway).
CosmosProxyItemQueryExecutionContext proxyQueryExecutionContext =
new CosmosProxyItemQueryExecutionContext(
queryContext: this.cosmosQueryContext,
containerSettings: collection);
return(proxyQueryExecutionContext);
}
//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.
PartitionedQueryExecutionInfo partitionedQueryExecutionInfo = await GetPartitionedQueryExecutionInfoAsync(
queryClient : this.cosmosQueryContext.QueryClient,
sqlQuerySpec : this.cosmosQueryContext.SqlQuerySpec,
partitionKeyDefinition : collection.PartitionKey,
requireFormattableOrderByQuery : true,
isContinuationExpected : true,
allowNonValueAggregateQuery : this.cosmosQueryContext.AllowNonValueAggregateQuery,
cancellationToken : cancellationToken);
List <PartitionKeyRange> targetRanges = await GetTargetPartitionKeyRanges(
this.cosmosQueryContext.QueryClient,
this.cosmosQueryContext.ResourceLink.OriginalString,
partitionedQueryExecutionInfo,
collection,
this.cosmosQueryContext.QueryRequestOptions);
return(await CreateSpecializedDocumentQueryExecutionContext(
this.cosmosQueryContext,
partitionedQueryExecutionInfo,
targetRanges,
collection.ResourceId,
cancellationToken));
}