internal abstract Task <PartitionedQueryExecutionInfo> ExecuteQueryPlanRequestAsync(
     Uri resourceUri,
     Documents.ResourceType resourceType,
     Documents.OperationType operationType,
     SqlQuerySpec sqlQuerySpec,
     string supportedQueryFeatures,
     CancellationToken cancellationToken);
Exemple #2
0
 internal abstract Task <PartitionedQueryExecutionInfo> ExecuteQueryPlanRequestAsync(
     Uri resourceUri,
     Documents.ResourceType resourceType,
     Documents.OperationType operationType,
     SqlQuerySpec sqlQuerySpec,
     Action <RequestMessage> requestEnricher,
     CancellationToken cancellationToken);
 public abstract Task <PartitionedQueryExecutionInfo> ExecuteQueryPlanRequestAsync(
     string resourceUri,
     Documents.ResourceType resourceType,
     Documents.OperationType operationType,
     SqlQuerySpec sqlQuerySpec,
     PartitionKey?partitionKey,
     string supportedQueryFeatures,
     CosmosDiagnosticsContext diagnosticsContext,
     CancellationToken cancellationToken);
Exemple #4
0
 public abstract Task <PartitionedQueryExecutionInfo> ExecuteQueryPlanRequestAsync(
     string resourceUri,
     Documents.ResourceType resourceType,
     Documents.OperationType operationType,
     SqlQuerySpec sqlQuerySpec,
     PartitionKey?partitionKey,
     string supportedQueryFeatures,
     Guid clientQueryCorrelationId,
     ITrace trace,
     CancellationToken cancellationToken);
 internal abstract Task <QueryResponseCore> ExecuteItemQueryAsync <QueryRequestOptionType>(
     Uri resourceUri,
     Documents.ResourceType resourceType,
     Documents.OperationType operationType,
     QueryRequestOptionType requestOptions,
     SqlQuerySpec sqlQuerySpec,
     string continuationToken,
     Documents.PartitionKeyRangeIdentity partitionKeyRange,
     bool isContinuationExpected,
     int pageSize,
     CancellationToken cancellationToken);
 public abstract Task <QueryResponseCore> ExecuteItemQueryAsync(
     string resourceUri,
     Documents.ResourceType resourceType,
     Documents.OperationType operationType,
     Guid clientQueryCorrelationId,
     QueryRequestOptions requestOptions,
     Action <QueryPageDiagnostics> queryPageDiagnostics,
     SqlQuerySpec sqlQuerySpec,
     string continuationToken,
     Documents.PartitionKeyRangeIdentity partitionKeyRange,
     bool isContinuationExpected,
     int pageSize,
     CancellationToken cancellationToken);
 public abstract Task <TryCatch <QueryPage> > ExecuteItemQueryAsync(
     string resourceUri,
     Documents.ResourceType resourceType,
     Documents.OperationType operationType,
     Guid clientQueryCorrelationId,
     FeedRange feedRange,
     QueryRequestOptions requestOptions,
     SqlQuerySpec sqlQuerySpec,
     string continuationToken,
     bool isContinuationExpected,
     int pageSize,
     ITrace trace,
     CancellationToken cancellationToken);
 internal override Task <PartitionedQueryExecutionInfo> ExecuteQueryPlanRequestAsync(
     Uri resourceUri,
     Documents.ResourceType resourceType,
     Documents.OperationType operationType,
     SqlQuerySpec sqlQuerySpec,
     Cosmos.PartitionKey?partitionKey,
     string supportedQueryFeatures,
     CancellationToken cancellationToken)
 {
     return(this.QueryClient.ExecuteQueryPlanRequestAsync(
                resourceUri,
                resourceType,
                operationType,
                sqlQuerySpec,
                partitionKey,
                supportedQueryFeatures,
                this.diagnosticsContext,
                cancellationToken));
 }
 public CosmosQueryContext(
     CosmosQueryClient client,
     ResourceType resourceTypeEnum,
     OperationType operationType,
     Type resourceType,
     string resourceLink,
     Guid correlatedActivityId,
     bool isContinuationExpected,
     bool allowNonValueAggregateQuery,
     string containerResourceId = null)
 {
     this.OperationTypeEnum           = operationType;
     this.QueryClient                 = client ?? throw new ArgumentNullException(nameof(client));
     this.ResourceTypeEnum            = resourceTypeEnum;
     this.ResourceType                = resourceType ?? throw new ArgumentNullException(nameof(resourceType));
     this.ResourceLink                = resourceLink;
     this.ContainerResourceId         = containerResourceId;
     this.IsContinuationExpected      = isContinuationExpected;
     this.AllowNonValueAggregateQuery = allowNonValueAggregateQuery;
     this.CorrelatedActivityId        = (correlatedActivityId == Guid.Empty) ? throw new ArgumentOutOfRangeException(nameof(correlatedActivityId)) : correlatedActivityId;
 }
 internal override Task <PartitionedQueryExecutionInfo> ExecuteQueryPlanRequestAsync(
     string resourceUri,
     Documents.ResourceType resourceType,
     Documents.OperationType operationType,
     SqlQuerySpec sqlQuerySpec,
     Cosmos.PartitionKey?partitionKey,
     string supportedQueryFeatures,
     ITrace trace,
     CancellationToken cancellationToken)
 {
     return(this.QueryClient.ExecuteQueryPlanRequestAsync(
                resourceUri,
                resourceType,
                operationType,
                sqlQuerySpec,
                partitionKey,
                supportedQueryFeatures,
                this.CorrelatedActivityId,
                trace,
                cancellationToken));
 }
        public CosmosQueryExecutionContextFactory(
            CosmosQueryClient client,
            Documents.ResourceType resourceTypeEnum,
            Documents.OperationType operationType,
            Type resourceType,
            SqlQuerySpec sqlQuerySpec,
            string continuationToken,
            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.InitialUserContinuationToken = continuationToken;

            this.CosmosQueryContext = new CosmosQueryContext(
                client: client,
                resourceTypeEnum: resourceTypeEnum,
                operationType: operationType,
                resourceType: resourceType,
                sqlQuerySpecFromUser: sqlQuerySpec,
                queryRequestOptions: cloneQueryRequestOptions,
                resourceLink: resourceLink,
                isContinuationExpected: isContinuationExpected,
                allowNonValueAggregateQuery: allowNonValueAggregateQuery,
                correlatedActivityId: correlatedActivityId);
        }