internal async Task <CosmosQueryResponse <T> > NextResultSetAsync <T>(
int?maxItemCount,
string continuationToken,
CosmosRequestOptions options,
object state,
CancellationToken cancellationToken)
{
IDocumentQueryExecutionContext documentQueryExecution = (IDocumentQueryExecutionContext)state;
try
{
FeedResponse <CosmosElement> feedResponse = await documentQueryExecution.ExecuteNextAsync(cancellationToken);
return(CosmosQueryResponse <T> .CreateResponse <T>(
feedResponse : feedResponse,
jsonSerializer : this.clientContext.JsonSerializer,
hasMoreResults : !documentQueryExecution.IsDone,
resourceType : ResourceType.Document));
}
catch (DocumentClientException exception)
{
throw new CosmosException(
message: exception.Message,
statusCode: exception.StatusCode.HasValue ? exception.StatusCode.Value : HttpStatusCode.InternalServerError,
subStatusCode: (int)exception.GetSubStatus(),
activityId: exception.ActivityId,
requestCharge: exception.RequestCharge);
}
}
private async Task <FeedResponse <TResponse> > ExecuteNextPrivateAsync <TResponse>(CancellationToken cancellationToken)
{
if (this.queryExecutionContext == null)
{
this.queryExecutionContext = await this.CreateDocumentQueryExecutionContextAsync(true, cancellationToken);
}
else if (this.queryExecutionContext.IsDone)
{
this.queryExecutionContext.Dispose();
this.queryExecutionContext = await this.CreateDocumentQueryExecutionContextAsync(true, cancellationToken);
}
FeedResponse <CosmosElement> response = await this.queryExecutionContext.ExecuteNextAsync(cancellationToken);
FeedResponse <TResponse> typedFeedResponse = FeedResponseBinder.ConvertCosmosElementFeed <TResponse>(
response,
this.resourceTypeEnum,
this.feedOptions.JsonSerializerSettings);
if (!this.HasMoreResults && !tracedLastExecution)
{
DefaultTrace.TraceInformation(
string.Format(
CultureInfo.InvariantCulture,
"{0}, CorrelatedActivityId: {1} | Last ExecuteNextAsync with ExecuteNextAsyncMetrics: [{2}]",
DateTime.UtcNow.ToString("o", CultureInfo.InvariantCulture),
this.CorrelatedActivityId,
this.executeNextAysncMetrics));
tracedLastExecution = true;
}
return(typedFeedResponse);
}
private ProxyDocumentQueryExecutionContext(
IDocumentQueryExecutionContext innerExecutionContext,
IDocumentQueryClient client,
ResourceType resourceTypeEnum,
Type resourceType,
Expression expression,
FeedOptions feedOptions,
string resourceLink,
ContainerProperties collection,
bool isContinuationExpected,
Guid correlatedActivityId)
{
this.innerExecutionContext = innerExecutionContext;
this.client = client;
this.resourceTypeEnum = resourceTypeEnum;
this.resourceType = resourceType;
this.expression = expression;
this.feedOptions = feedOptions;
this.resourceLink = resourceLink;
this.collection = collection;
this.isContinuationExpected = isContinuationExpected;
this.correlatedActivityId = correlatedActivityId;
}
public async Task <FeedResponse <CosmosElement> > ExecuteNextAsync(CancellationToken token)
{
if (this.innerExecutionContext == null)
{
this.innerExecutionContext = await this.CreateItemQueryExecutionContextAsync(token);
}
return(await this.innerExecutionContext.ExecuteNextAsync(token));
}
public async Task <FeedResponse <dynamic> > ExecuteNextAsync(CancellationToken token)
{
if (this.IsDone)
{
throw new InvalidOperationException(RMResources.DocumentQueryExecutionContextIsDone);
}
Error error = null;
try
{
return(await this.innerExecutionContext.ExecuteNextAsync(token));
}
catch (DocumentClientException ex)
{
if (ex.StatusCode != HttpStatusCode.BadRequest || ex.GetSubStatus() != SubStatusCodes.CrossPartitionQueryNotServable)
{
throw;
}
error = ex.Error;
}
PartitionedQueryExecutionInfo partitionedQueryExecutionInfo =
JsonConvert.DeserializeObject <PartitionedQueryExecutionInfo>(error.AdditionalErrorInfo);
DefaultDocumentQueryExecutionContext queryExecutionContext =
(DefaultDocumentQueryExecutionContext)this.innerExecutionContext;
List <PartitionKeyRange> partitionKeyRanges =
await
queryExecutionContext.GetTargetPartitionKeyRanges(collection.ResourceId,
partitionedQueryExecutionInfo.QueryRanges);
this.innerExecutionContext = await DocumentQueryExecutionContextFactory.CreateSpecializedDocumentQueryExecutionContext(
this.client,
this.resourceTypeEnum,
this.resourceType,
this.expression,
this.feedOptions,
this.resourceLink,
isContinuationExpected,
partitionedQueryExecutionInfo,
partitionKeyRanges,
this.collection.ResourceId,
token,
this.correlatedActivityId);
return(await this.innerExecutionContext.ExecuteNextAsync(token));
}
/// <summary>
/// Retrieves an object that can iterate through the individual results of the query.
/// </summary>
/// <remarks>
/// This triggers a synchronous multi-page load.
/// </remarks>
/// <returns></returns>
public IEnumerator <T> GetEnumerator()
{
using (IDocumentQueryExecutionContext localQueryExecutionContext =
TaskHelper.InlineIfPossible(() => this.CreateDocumentQueryExecutionContextAsync(false, CancellationToken.None), null).Result)
{
while (!localQueryExecutionContext.IsDone)
{
IEnumerable <T> result = (dynamic)TaskHelper.InlineIfPossible(() => localQueryExecutionContext.ExecuteNextAsync(CancellationToken.None), null).Result;
foreach (T item in result)
{
yield return(item);
}
}
}
}
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));
}
internal async Task <List <T> > ExecuteAllAsync(CancellationToken cancellationToken = default(CancellationToken))
{
List <T> result = new List <T>();
using (IDocumentQueryExecutionContext localQueryExecutionContext =
await TaskHelper.InlineIfPossible(async() => await this.CreateDocumentQueryExecutionContextAsync(false, cancellationToken), null, cancellationToken))
{
while (!localQueryExecutionContext.IsDone)
{
FeedResponse <T> partialResult = await(dynamic) TaskHelper.InlineIfPossible(() => localQueryExecutionContext.ExecuteNextAsync(cancellationToken), null, cancellationToken);
result.AddRange(partialResult);
}
}
return(result);
}
public CosmosProxyItemQueryExecutionContext(
CosmosQueryContext queryContext,
CosmosContainerSettings containerSettings)
{
if (queryContext == null)
{
throw new ArgumentNullException(nameof(queryContext));
}
if (queryContext == null)
{
throw new ArgumentNullException(nameof(queryContext));
}
this.innerExecutionContext = new CosmosGatewayQueryExecutionContext(queryContext);
this.queryContext = queryContext;
this.containerSettings = containerSettings;
}
/// <summary>
/// Retrieves an object that can iterate through the individual results of the query.
/// </summary>
/// <remarks>
/// This triggers a synchronous multi-page load.
/// </remarks>
/// <returns></returns>
public IEnumerator <T> GetEnumerator()
{
using (IDocumentQueryExecutionContext localQueryExecutionContext =
TaskHelper.InlineIfPossible(() => this.CreateDocumentQueryExecutionContextAsync(false, CancellationToken.None), null).Result)
{
while (!localQueryExecutionContext.IsDone)
{
FeedResponse <CosmosElement> feedResponse = TaskHelper.InlineIfPossible(() => localQueryExecutionContext.ExecuteNextAsync(CancellationToken.None), null).Result;
FeedResponse <T> typedFeedResponse = FeedResponseBinder.ConvertCosmosElementFeed <T>(
feedResponse,
this.resourceTypeEnum,
this.feedOptions.JsonSerializerSettings);
foreach (T item in typedFeedResponse)
{
yield return(item);
}
}
}
}
private async Task <FeedResponse <TResponse> > ExecuteNextPrivateAsync <TResponse>(CancellationToken cancellationToken)
{
if (this.queryExecutionContext == null)
{
this.queryExecutionContext = await this.CreateDocumentQueryExecutionContextAsync(true, cancellationToken);
}
else if (this.queryExecutionContext.IsDone)
{
this.queryExecutionContext.Dispose();
this.queryExecutionContext = await this.CreateDocumentQueryExecutionContextAsync(true, cancellationToken);
}
// Have to do all this, since dynamic cast loses all the internal members.
FeedResponse <dynamic> response = await this.queryExecutionContext.ExecuteNextAsync(cancellationToken);
FeedResponse <TResponse> finalResponse = (dynamic)response;
finalResponse = new FeedResponse <TResponse>(
finalResponse,
finalResponse.Count,
finalResponse.Headers,
finalResponse.UseETagAsContinuation,
finalResponse.QueryMetrics,
finalResponse.RequestStatistics,
response.DisallowContinuationTokenMessage,
finalResponse.ResponseLengthBytes);
if (!this.HasMoreResults && !tracedLastExecution)
{
DefaultTrace.TraceInformation(
string.Format(
CultureInfo.InvariantCulture,
"{0}, CorrelatedActivityId: {1} | Last ExecuteNextAsync with ExecuteNextAsyncMetrics: [{2}]",
DateTime.UtcNow.ToString("o", CultureInfo.InvariantCulture),
this.CorrelatedActivityId,
this.executeNextAysncMetrics));
tracedLastExecution = true;
}
return(finalResponse);
}
private async Task <CosmosQueryResponse> QueryRequestExecutor(
string continuationToken,
CosmosRequestOptions requestOptions,
object state,
CancellationToken cancellationToken)
{
IDocumentQueryExecutionContext documentQueryExecution = (IDocumentQueryExecutionContext)state;
CosmosQueryRequestOptions queryRequestOptions = (CosmosQueryRequestOptions)requestOptions;
// DEVNOTE: Remove try catch once query pipeline is converted to exceptionless
try
{
FeedResponse <CosmosElement> feedResponse = await documentQueryExecution.ExecuteNextAsync(cancellationToken);
return(CosmosQueryResponse.CreateResponse(
feedResponse: feedResponse,
cosmosSerializationOptions: queryRequestOptions.CosmosSerializationOptions));
}
catch (DocumentClientException exception)
{
return(new CosmosQueryResponse(
errorMessage: exception.Message,
httpStatusCode: exception.StatusCode.HasValue ? exception.StatusCode.Value : HttpStatusCode.InternalServerError,
retryAfter: exception.RetryAfter));
}
catch (AggregateException ae)
{
DocumentClientException exception = ae.InnerException as DocumentClientException;
if (exception == null)
{
throw;
}
return(new CosmosQueryResponse(
errorMessage: exception.Message,
httpStatusCode: exception.StatusCode.HasValue ? exception.StatusCode.Value : HttpStatusCode.InternalServerError,
retryAfter: exception.RetryAfter));
}
}
/// <summary>
/// Retrieves an object that can iterate through the individual results of the query.
/// </summary>
/// <remarks>
/// This triggers a synchronous multi-page load.
/// </remarks>
public IEnumerator <T> GetEnumerator()
{
using (IDocumentQueryExecutionContext localQueryExecutionContext =
#pragma warning disable VSTHRD002 // Avoid problematic synchronous waits
TaskHelper.InlineIfPossible(() => this.CreateDocumentQueryExecutionContextAsync(false, CancellationToken.None), null).Result)
#pragma warning restore VSTHRD002 // Avoid problematic synchronous waits
{
while (!localQueryExecutionContext.IsDone)
{
#pragma warning disable VSTHRD002 // Avoid problematic synchronous waits
DocumentFeedResponse <CosmosElement> feedResponse = TaskHelper.InlineIfPossible(() => localQueryExecutionContext.ExecuteNextFeedResponseAsync(CancellationToken.None), null).Result;
#pragma warning restore VSTHRD002 // Avoid problematic synchronous waits
DocumentFeedResponse <T> typedFeedResponse = FeedResponseBinder.ConvertCosmosElementFeed <T>(
feedResponse,
this.resourceTypeEnum,
this.feedOptions.JsonSerializerSettings);
foreach (T item in typedFeedResponse)
{
yield return(item);
}
}
}
}
