private async Task <CosmosContainerSettings> GetContainerSettingsAsync(CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
CosmosContainerSettings containerSettings = 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
{
containerSettings = await collectionCache.ResolveCollectionAsync(request, cancellationToken);
}
}
if (containerSettings == null)
{
throw new ArgumentException($"The container was not found for resource: {this.cosmosQueryContext.ResourceLink.OriginalString} ");
}
return(containerSettings);
}
public override async Task ForceRefreshCollectionCacheAsync(string collectionLink, CancellationToken cancellationToken)
{
this.ClearSessionTokenCache(collectionLink);
CollectionCache collectionCache = await this.documentClient.GetCollectionCacheAsync();
using (Documents.DocumentServiceRequest request = Documents.DocumentServiceRequest.Create(
Documents.OperationType.Query,
Documents.ResourceType.Collection,
collectionLink,
Documents.AuthorizationTokenType.Invalid)) //this request doesn't actually go to server
{
request.ForceNameCacheRefresh = true;
await collectionCache.ResolveCollectionAsync(request, cancellationToken);
}
}
private async Task ForceRefreshCollectionCacheAsync(CancellationToken cancellationToken)
{
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
{
request.ForceNameCacheRefresh = true;
await collectionCache.ResolveCollectionAsync(request, cancellationToken);
}
this.cosmosQueryContext.QueryClient.ClearSessionTokenCache(this.cosmosQueryContext.ResourceLink.OriginalString);
}
private async Task <Tuple <DocumentFeedResponse <CosmosElement>, string> > ExecuteOnceAsync(
IDocumentClientRetryPolicy retryPolicyInstance,
CancellationToken cancellationToken)
{
// Don't reuse request, as the rest of client SDK doesn't reuse requests between retries.
// The code leaves some temporary garbage in request (in RequestContext etc.),
// which shold be erased during retries.
using (DocumentServiceRequest request = await this.CreateRequestAsync())
{
DocumentFeedResponse <CosmosElement> feedRespose;
string partitionIdentifier;
// We need to determine how to execute the request:
if (LogicalPartitionKeyProvided(request))
{
feedRespose = await this.ExecuteRequestAsync(request, retryPolicyInstance, cancellationToken);
partitionIdentifier = $"PKId({request.Headers[HttpConstants.HttpHeaders.PartitionKey]})";
}
else if (PhysicalPartitionKeyRangeIdProvided(this))
{
CollectionCache collectionCache = await this.Client.GetCollectionCacheAsync();
ContainerProperties collection = await collectionCache.ResolveCollectionAsync(request, CancellationToken.None);
request.RouteTo(new PartitionKeyRangeIdentity(collection.ResourceId, base.PartitionKeyRangeId));
feedRespose = await this.ExecuteRequestAsync(request, retryPolicyInstance, cancellationToken);
partitionIdentifier = base.PartitionKeyRangeId;
}
else
{
// The query is going to become a full fan out, but we go one partition at a time.
if (ServiceInteropAvailable())
{
// Get the routing map provider
CollectionCache collectionCache = await this.Client.GetCollectionCacheAsync();
ContainerProperties collection = await collectionCache.ResolveCollectionAsync(request, CancellationToken.None);
QueryPartitionProvider queryPartitionProvider = await this.Client.GetQueryPartitionProviderAsync(cancellationToken);
IRoutingMapProvider routingMapProvider = await this.Client.GetRoutingMapProviderAsync();
// Figure out what partition you are going to based on the range from the continuation token
// If token is null then just start at partitionKeyRangeId "0"
List <CompositeContinuationToken> suppliedTokens;
Range <string> rangeFromContinuationToken =
this.partitionRoutingHelper.ExtractPartitionKeyRangeFromContinuationToken(
request.Headers,
out suppliedTokens);
Tuple <PartitionRoutingHelper.ResolvedRangeInfo, IReadOnlyList <Range <string> > > queryRoutingInfo =
await this.TryGetTargetPartitionKeyRangeAsync(
request,
collection,
queryPartitionProvider,
routingMapProvider,
rangeFromContinuationToken,
suppliedTokens);
if (request.IsNameBased && queryRoutingInfo == null)
{
request.ForceNameCacheRefresh = true;
collection = await collectionCache.ResolveCollectionAsync(request, CancellationToken.None);
queryRoutingInfo = await this.TryGetTargetPartitionKeyRangeAsync(
request,
collection,
queryPartitionProvider,
routingMapProvider,
rangeFromContinuationToken,
suppliedTokens);
}
if (queryRoutingInfo == null)
{
throw new NotFoundException($"{DateTime.UtcNow.ToString("o", CultureInfo.InvariantCulture)}: Was not able to get queryRoutingInfo even after resolve collection async with force name cache refresh to the following collectionRid: {collection.ResourceId} with the supplied tokens: {JsonConvert.SerializeObject(suppliedTokens)}");
}
request.RouteTo(new PartitionKeyRangeIdentity(collection.ResourceId, queryRoutingInfo.Item1.ResolvedRange.Id));
DocumentFeedResponse <CosmosElement> response = await this.ExecuteRequestAsync(request, retryPolicyInstance, cancellationToken);
// Form a composite continuation token (range + backend continuation token).
// If the backend continuation token was null for the range,
// then use the next adjacent range.
// This is how the default execution context serially visits every partition.
if (!await this.partitionRoutingHelper.TryAddPartitionKeyRangeToContinuationTokenAsync(
response.Headers,
providedPartitionKeyRanges: queryRoutingInfo.Item2,
routingMapProvider: routingMapProvider,
collectionRid: collection.ResourceId,
resolvedRangeInfo: queryRoutingInfo.Item1))
{
// Collection to which this request was resolved doesn't exist.
// Retry policy will refresh the cache and return NotFound.
throw new NotFoundException($"{DateTime.UtcNow.ToString("o", CultureInfo.InvariantCulture)}: Call to TryAddPartitionKeyRangeToContinuationTokenAsync failed to the following collectionRid: {collection.ResourceId} with the supplied tokens: {JsonConvert.SerializeObject(suppliedTokens)}");
}
feedRespose = response;
partitionIdentifier = queryRoutingInfo.Item1.ResolvedRange.Id;
}
else
{
// For non-Windows platforms(like Linux and OSX) in .NET Core SDK, we cannot use ServiceInterop for parsing the query,
// so forcing the request through Gateway. We are also now by-passing this for 32-bit host process in NETFX on Windows
// as the ServiceInterop dll is only available in 64-bit.
request.UseGatewayMode = true;
feedRespose = await this.ExecuteRequestAsync(request, retryPolicyInstance, cancellationToken);
partitionIdentifier = "Gateway";
}
}
return(new Tuple <DocumentFeedResponse <CosmosElement>, string>(feedRespose, partitionIdentifier));
}
}
public static async Task <IDocumentQueryExecutionContext> CreateDocumentQueryExecutionContextAsync(
IDocumentQueryClient client,
ResourceType resourceTypeEnum,
Type resourceType,
Expression expression,
FeedOptions feedOptions,
string resourceLink,
bool isContinuationExpected,
CancellationToken token,
Guid correlatedActivityId)
{
ContainerProperties 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 : true,
hasLogicalPartitionKey : feedOptions.PartitionKey != null,
cancellationToken : token);
if (DocumentQueryExecutionContextFactory.ShouldCreateSpecializedDocumentQueryExecutionContext(
resourceTypeEnum,
feedOptions,
partitionedQueryExecutionInfo,
collection.PartitionKey,
isContinuationExpected))
{
List <PartitionKeyRange> targetRanges = await GetTargetPartitionKeyRangesAsync(
queryExecutionContext,
partitionedQueryExecutionInfo,
collection,
feedOptions);
// Devnote this will get replace by the new v3 to v2 logic
throw new NotSupportedException("v2 query excution context is currently not supported.");
}
}
return(queryExecutionContext);
}
public override async Task <ResponseMessage> SendAsync(
RequestMessage request,
CancellationToken cancellationToken)
{
using (ITrace childTrace = request.Trace.StartChild(this.FullHandlerName, TraceComponent.RequestHandler, Tracing.TraceLevel.Info))
{
request.Trace = childTrace;
ResponseMessage response = null;
string originalContinuation = request.Headers.ContinuationToken;
try
{
RntdbEnumerationDirection rntdbEnumerationDirection = RntdbEnumerationDirection.Forward;
if (request.Properties.TryGetValue(HttpConstants.HttpHeaders.EnumerationDirection, out object direction))
{
rntdbEnumerationDirection = (byte)direction == (byte)RntdbEnumerationDirection.Reverse ? RntdbEnumerationDirection.Reverse : RntdbEnumerationDirection.Forward;
}
request.Headers.Remove(HttpConstants.HttpHeaders.IsContinuationExpected);
request.Headers.Add(HttpConstants.HttpHeaders.IsContinuationExpected, bool.TrueString);
if (!request.Properties.TryGetValue(HandlerConstants.StartEpkString, out object startEpk))
{
startEpk = PartitionKeyInternal.MinimumInclusiveEffectivePartitionKey;
}
if (!request.Properties.TryGetValue(HandlerConstants.EndEpkString, out object endEpk))
{
endEpk = PartitionKeyInternal.MaximumExclusiveEffectivePartitionKey;
}
startEpk ??= PartitionKeyInternal.MinimumInclusiveEffectivePartitionKey;
endEpk ??= PartitionKeyInternal.MaximumExclusiveEffectivePartitionKey;
List <Range <string> > providedRanges = new List <Range <string> >
{
new Range <string>(
(string)startEpk,
(string)endEpk,
isMinInclusive: true,
isMaxInclusive: false)
};
DocumentServiceRequest serviceRequest = request.ToDocumentServiceRequest();
PartitionKeyRangeCache routingMapProvider = await this.client.DocumentClient.GetPartitionKeyRangeCacheAsync();
CollectionCache collectionCache = await this.client.DocumentClient.GetCollectionCacheAsync(NoOpTrace.Singleton);
ContainerProperties collectionFromCache =
await collectionCache.ResolveCollectionAsync(serviceRequest, CancellationToken.None);
//direction is not expected to change between continuations.
Range <string> rangeFromContinuationToken =
this.partitionRoutingHelper.ExtractPartitionKeyRangeFromContinuationToken(serviceRequest.Headers, out List <CompositeContinuationToken> suppliedTokens);
ResolvedRangeInfo resolvedRangeInfo =
await this.partitionRoutingHelper.TryGetTargetRangeFromContinuationTokenRangeAsync(
providedPartitionKeyRanges : providedRanges,
routingMapProvider : routingMapProvider,
collectionRid : collectionFromCache.ResourceId,
rangeFromContinuationToken : rangeFromContinuationToken,
suppliedTokens : suppliedTokens,
direction : rntdbEnumerationDirection);
if (serviceRequest.IsNameBased && resolvedRangeInfo.ResolvedRange == null && resolvedRangeInfo.ContinuationTokens == null)
{
serviceRequest.ForceNameCacheRefresh = true;
collectionFromCache = await collectionCache.ResolveCollectionAsync(serviceRequest, CancellationToken.None);
resolvedRangeInfo = await this.partitionRoutingHelper.TryGetTargetRangeFromContinuationTokenRangeAsync(
providedPartitionKeyRanges : providedRanges,
routingMapProvider : routingMapProvider,
collectionRid : collectionFromCache.ResourceId,
rangeFromContinuationToken : rangeFromContinuationToken,
suppliedTokens : suppliedTokens,
direction : rntdbEnumerationDirection);
}
if (resolvedRangeInfo.ResolvedRange == null && resolvedRangeInfo.ContinuationTokens == null)
{
return(((DocumentClientException) new NotFoundException(
$"{DateTime.UtcNow.ToString("o", CultureInfo.InvariantCulture)}: Was not able to get queryRoutingInfo even after resolve collection async with force name cache refresh to the following collectionRid: {collectionFromCache.ResourceId} with the supplied tokens: {JsonConvert.SerializeObject(suppliedTokens)}")
).ToCosmosResponseMessage(request));
}
serviceRequest.RouteTo(new PartitionKeyRangeIdentity(collectionFromCache.ResourceId, resolvedRangeInfo.ResolvedRange.Id));
response = await base.SendAsync(request, cancellationToken);
if (!response.IsSuccessStatusCode)
{
this.SetOriginalContinuationToken(request, response, originalContinuation);
}
else
{
if (!await this.partitionRoutingHelper.TryAddPartitionKeyRangeToContinuationTokenAsync(
response.Headers.CosmosMessageHeaders,
providedPartitionKeyRanges: providedRanges,
routingMapProvider: routingMapProvider,
collectionRid: collectionFromCache.ResourceId,
resolvedRangeInfo: resolvedRangeInfo,
direction: rntdbEnumerationDirection))
{
return(((DocumentClientException) new NotFoundException(
$"{DateTime.UtcNow.ToString("o", CultureInfo.InvariantCulture)}: Call to TryAddPartitionKeyRangeToContinuationTokenAsync failed to the following collectionRid: {collectionFromCache.ResourceId} with the supplied tokens: {JsonConvert.SerializeObject(suppliedTokens)}")
).ToCosmosResponseMessage(request));
}
}
return(response);
}
catch (DocumentClientException ex)
{
ResponseMessage errorResponse = ex.ToCosmosResponseMessage(request);
this.SetOriginalContinuationToken(request, errorResponse, originalContinuation);
return(errorResponse);
}
catch (CosmosException ex)
{
ResponseMessage errorResponse = ex.ToCosmosResponseMessage(request);
this.SetOriginalContinuationToken(request, errorResponse, originalContinuation);
return(errorResponse);
}
catch (AggregateException ex)
{
this.SetOriginalContinuationToken(request, response, originalContinuation);
// TODO: because the SDK underneath this path uses ContinueWith or task.Result we need to catch AggregateExceptions here
// in order to ensure that underlying DocumentClientExceptions get propagated up correctly. Once all ContinueWith and .Result
// is removed this catch can be safely removed.
AggregateException innerExceptions = ex.Flatten();
Exception docClientException = innerExceptions.InnerExceptions.FirstOrDefault(innerEx => innerEx is DocumentClientException);
if (docClientException != null)
{
return(((DocumentClientException)docClientException).ToCosmosResponseMessage(request));
}
throw;
}
}
}
private async Task <FeedResponse <dynamic> > ExecuteOnceAsync(IDocumentClientRetryPolicy retryPolicyInstance, CancellationToken cancellationToken)
{
// Don't reuse request, as the rest of client SDK doesn't reuse requests between retries.
// The code leaves some temporary garbage in request (in RequestContext etc.),
// which shold be erased during retries.
using (DocumentServiceRequest request = await this.CreateRequestAsync())
{
if (retryPolicyInstance != null)
{
retryPolicyInstance.OnBeforeSendRequest(request);
}
if (!string.IsNullOrEmpty(request.Headers[HttpConstants.HttpHeaders.PartitionKey]) ||
!request.ResourceType.IsPartitioned())
{
return(await this.ExecuteRequestAsync(request, cancellationToken));
}
CollectionCache collectionCache = await this.Client.GetCollectionCacheAsync();
CosmosContainerSettings collection =
await collectionCache.ResolveCollectionAsync(request, CancellationToken.None);
if (!string.IsNullOrEmpty(base.PartitionKeyRangeId))
{
request.RouteTo(new PartitionKeyRangeIdentity(collection.ResourceId, base.PartitionKeyRangeId));
return(await this.ExecuteRequestAsync(request, cancellationToken));
}
// For non-Windows platforms(like Linux and OSX) in .NET Core SDK, we cannot use ServiceInterop for parsing the query,
// so forcing the request through Gateway. We are also now by-passing this for 32-bit host process in NETFX on Windows
// as the ServiceInterop dll is only available in 64-bit.
if (CustomTypeExtensions.ByPassQueryParsing())
{
request.UseGatewayMode = true;
return(await this.ExecuteRequestAsync(request, cancellationToken));
}
QueryPartitionProvider queryPartitionProvider = await this.Client.GetQueryPartitionProviderAsync(cancellationToken);
IRoutingMapProvider routingMapProvider = await this.Client.GetRoutingMapProviderAsync();
List <CompositeContinuationToken> suppliedTokens;
Range <string> rangeFromContinuationToken =
this.partitionRoutingHelper.ExtractPartitionKeyRangeFromContinuationToken(request.Headers, out suppliedTokens);
Tuple <PartitionRoutingHelper.ResolvedRangeInfo, IReadOnlyList <Range <string> > > queryRoutingInfo =
await this.TryGetTargetPartitionKeyRangeAsync(
request,
collection,
queryPartitionProvider,
routingMapProvider,
rangeFromContinuationToken,
suppliedTokens);
if (request.IsNameBased && queryRoutingInfo == null)
{
request.ForceNameCacheRefresh = true;
collection = await collectionCache.ResolveCollectionAsync(request, CancellationToken.None);
queryRoutingInfo = await this.TryGetTargetPartitionKeyRangeAsync(
request,
collection,
queryPartitionProvider,
routingMapProvider,
rangeFromContinuationToken,
suppliedTokens);
}
if (queryRoutingInfo == null)
{
throw new NotFoundException($"{DateTime.UtcNow.ToString("o", CultureInfo.InvariantCulture)}: Was not able to get queryRoutingInfo even after resolve collection async with force name cache refresh to the following collectionRid: {collection.ResourceId} with the supplied tokens: {JsonConvert.SerializeObject(suppliedTokens)}");
}
request.RouteTo(new PartitionKeyRangeIdentity(collection.ResourceId, queryRoutingInfo.Item1.ResolvedRange.Id));
FeedResponse <dynamic> response = await this.ExecuteRequestAsync(request, cancellationToken);
if (!await this.partitionRoutingHelper.TryAddPartitionKeyRangeToContinuationTokenAsync(
response.Headers,
providedPartitionKeyRanges: queryRoutingInfo.Item2,
routingMapProvider: routingMapProvider,
collectionRid: collection.ResourceId,
resolvedRangeInfo: queryRoutingInfo.Item1))
{
// Collection to which this request was resolved doesn't exist.
// Retry policy will refresh the cache and return NotFound.
throw new NotFoundException($"{DateTime.UtcNow.ToString("o", CultureInfo.InvariantCulture)}: Call to TryAddPartitionKeyRangeToContinuationTokenAsync failed to the following collectionRid: {collection.ResourceId} with the supplied tokens: {JsonConvert.SerializeObject(suppliedTokens)}");
}
return(response);
}
}
public static async Task <IDocumentQueryExecutionContext> CreateDocumentQueryExecutionContextAsync(
IDocumentQueryClient client,
ResourceType resourceTypeEnum,
Type resourceType,
Expression expression,
FeedOptions feedOptions,
string resourceLink,
bool isContinuationExpected,
CancellationToken token,
Guid correlatedActivityId)
{
DocumentQueryExecutionContextBase.InitParams constructorParams = new DocumentQueryExecutionContextBase.InitParams(
client,
resourceTypeEnum,
resourceType,
expression,
feedOptions,
resourceLink,
false,
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);
}
}
// 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.CreateAsync(
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(
collection.PartitionKey,
true,
isContinuationExpected,
token);
if (DocumentQueryExecutionContextFactory.ShouldCreateSpecializedDocumentQueryExecutionContext(
resourceTypeEnum,
feedOptions,
partitionedQueryExecutionInfo,
collection.PartitionKey,
isContinuationExpected))
{
List <PartitionKeyRange> targetRanges;
if (!string.IsNullOrEmpty(feedOptions.PartitionKeyRangeId))
{
targetRanges =
new List <PartitionKeyRange>
{
await queryExecutionContext.GetTargetPartitionKeyRangeById(
collection.ResourceId,
feedOptions.PartitionKeyRangeId)
};
}
else
{
List <Range <string> > queryRanges = partitionedQueryExecutionInfo.QueryRanges;
if (feedOptions.PartitionKey != null)
{
queryRanges = new List <Range <string> >
{
Range <string> .GetPointRange(
feedOptions.PartitionKey.InternalKey.GetEffectivePartitionKeyString(
collection.PartitionKey))
};
}
targetRanges =
await queryExecutionContext.GetTargetPartitionKeyRanges(collection.ResourceId, queryRanges);
}
return(await CreateSpecializedDocumentQueryExecutionContext(
constructorParams,
partitionedQueryExecutionInfo,
targetRanges,
collection.ResourceId,
isContinuationExpected,
token));
}
}
return(queryExecutionContext);
}
private static async Task <Tuple <bool, PartitionKeyRange> > TryResolvePartitionKeyRangeAsync(
DocumentServiceRequest request,
ISessionContainer sessionContainer,
PartitionKeyRangeCache partitionKeyRangeCache,
CollectionCache clientCollectionCache,
bool refreshCache)
{
if (refreshCache)
{
request.ForceMasterRefresh = true;
request.ForceNameCacheRefresh = true;
}
PartitionKeyRange partitonKeyRange = null;
ContainerProperties collection = await clientCollectionCache.ResolveCollectionAsync(
request,
CancellationToken.None,
NoOpTrace.Singleton);
string partitionKeyString = request.Headers[HttpConstants.HttpHeaders.PartitionKey];
if (partitionKeyString != null)
{
CollectionRoutingMap collectionRoutingMap = await partitionKeyRangeCache.TryLookupAsync(
collectionRid : collection.ResourceId,
previousValue : null,
request : request,
cancellationToken : CancellationToken.None,
NoOpTrace.Singleton);
if (refreshCache && collectionRoutingMap != null)
{
collectionRoutingMap = await partitionKeyRangeCache.TryLookupAsync(
collectionRid : collection.ResourceId,
previousValue : collectionRoutingMap,
request : request,
cancellationToken : CancellationToken.None,
NoOpTrace.Singleton);
}
partitonKeyRange = AddressResolver.TryResolveServerPartitionByPartitionKey(
request: request,
partitionKeyString: partitionKeyString,
collectionCacheUptoDate: false,
collection: collection,
routingMap: collectionRoutingMap);
}
else if (request.PartitionKeyRangeIdentity != null)
{
PartitionKeyRangeIdentity partitionKeyRangeId = request.PartitionKeyRangeIdentity;
partitonKeyRange = await partitionKeyRangeCache.TryGetPartitionKeyRangeByIdAsync(
collection.ResourceId,
partitionKeyRangeId.PartitionKeyRangeId,
NoOpTrace.Singleton,
refreshCache);
}
else if (request.RequestContext.ResolvedPartitionKeyRange != null)
{
partitonKeyRange = request.RequestContext.ResolvedPartitionKeyRange;
}
if (partitonKeyRange == null)
{
if (refreshCache)
{
return(new Tuple <bool, PartitionKeyRange>(false, null));
}
// need to refresh cache. Maybe split happened.
return(await GatewayStoreModel.TryResolvePartitionKeyRangeAsync(
request : request,
sessionContainer : sessionContainer,
partitionKeyRangeCache : partitionKeyRangeCache,
clientCollectionCache : clientCollectionCache,
refreshCache : true));
}
return(new Tuple <bool, PartitionKeyRange>(true, partitonKeyRange));
}
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));
}
