public async Task <CosmosQueryExecutionContext> CreateFromPartitionedQuerExecutionInfoAsync(
PartitionedQueryExecutionInfo partitionedQueryExecutionInfo,
ContainerQueryProperties containerQueryProperties,
CancellationToken cancellationToken = default(CancellationToken))
{
cancellationToken.ThrowIfCancellationRequested();
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));
}
private QueryIterator(
CosmosQueryExecutionContextFactory cosmosQueryExecutionContext,
CosmosSerializationFormatOptions cosmosSerializationFormatOptions)
{
if (cosmosQueryExecutionContext == null)
{
throw new ArgumentNullException(nameof(cosmosQueryExecutionContext));
}
this.cosmosQueryExecutionContext = cosmosQueryExecutionContext;
this.cosmosSerializationFormatOptions = cosmosSerializationFormatOptions;
}
public async Task <FeedResponse <CosmosElement> > ExecuteNextAsync(CancellationToken token)
{
if (this.IsDone)
{
throw new InvalidOperationException(RMResources.DocumentQueryExecutionContextIsDone);
}
Error error;
try
{
return(await this.innerExecutionContext.ExecuteNextAsync(token));
}
catch (CosmosException ex)
{
if (ex.StatusCode != HttpStatusCode.BadRequest || ex.SubStatusCode != (int)SubStatusCodes.CrossPartitionQueryNotServable)
{
throw;
}
error = ex.Error;
}
PartitionedQueryExecutionInfo partitionedQueryExecutionInfo =
JsonConvert.DeserializeObject <PartitionedQueryExecutionInfo>(error.AdditionalErrorInfo);
string rewrittenQuery = partitionedQueryExecutionInfo.QueryInfo.RewrittenQuery;
if (!string.IsNullOrEmpty(rewrittenQuery))
{
this.queryContext.SqlQuerySpec.QueryText = rewrittenQuery;
}
List <PartitionKeyRange> partitionKeyRanges =
await this.queryContext.QueryClient.GetTargetPartitionKeyRanges(
this.queryContext.ResourceLink.OriginalString,
this.containerSettings.ResourceId,
partitionedQueryExecutionInfo.QueryRanges);
this.innerExecutionContext = await CosmosQueryExecutionContextFactory.CreateSpecializedDocumentQueryExecutionContext(
this.queryContext,
partitionedQueryExecutionInfo,
partitionKeyRanges,
this.containerSettings.ResourceId,
token);
return(await this.innerExecutionContext.ExecuteNextAsync(token));
}
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));
}
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);
}
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 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));
}
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));
}
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));
}