/// <summary> /// This method creates a query for items under a container in an Azure Cosmos database using a SQL statement with parameterized values. It returns a CosmosResultSetStreamIterator. /// For more information on preparing SQL statements with parameterized values, please see <see cref="CosmosSqlQueryDefinition"/>. /// </summary> /// <param name="sqlQueryText">The cosmos SQL query string.</param> /// <param name="maxConcurrency">The number of concurrent operations run client side during parallel query execution in the Azure Cosmos DB service.</param> /// <param name="partitionKey">The partition key for the item. <see cref="Microsoft.Azure.Documents.PartitionKey"/></param> /// <param name="maxItemCount">(Optional) The max item count to return as part of the query</param> /// <param name="continuationToken">(Optional) The continuation token in the Azure Cosmos DB service.</param> /// <param name="requestOptions">(Optional) The options for the item query request <see cref="CosmosQueryRequestOptions"/></param> /// <remarks> /// Query as a stream only supports single partition queries /// </remarks> /// <example> /// Create a query to get all the ToDoActivity that have a cost greater than 9000 for the specified partition /// <code language="c#"> /// <![CDATA[ /// public class ToDoActivity{ /// public string id {get; set;} /// public string status {get; set;} /// public int cost {get; set;} /// } /// /// CosmosResultSetIterator setIterator = this.Container.Items.CreateItemQueryAsStream( /// sqlQueryText: "select * from ToDos t where t.cost > 9000", /// partitionKey: "Error"); /// /// while (setIterator.HasMoreResults) /// { /// using (CosmosResponseMessage response = await setIterator.FetchNextSetAsync()) /// { /// using (StreamReader sr = new StreamReader(response.Content)) /// using (JsonTextReader jtr = new JsonTextReader(sr)) /// { /// JObject result = JObject.Load(jtr); /// } /// } /// } /// ]]> /// </code> /// </example> public abstract CosmosResultSetIterator CreateItemQueryAsStream( string sqlQueryText, int maxConcurrency, object partitionKey = null, int?maxItemCount = null, string continuationToken = null, CosmosQueryRequestOptions requestOptions = null);
private Task <CosmosQueryResponse <T> > ItemFeedRequestExecutor <T>( int?maxItemCount, string continuationToken, CosmosRequestOptions options, object state, CancellationToken cancellationToken) { Uri resourceUri = this.container.LinkUri; return(this.clientContext.ProcessResourceOperationAsync <CosmosQueryResponse <T> >( resourceUri: resourceUri, resourceType: ResourceType.Document, operationType: OperationType.ReadFeed, requestOptions: options, requestEnricher: request => { CosmosQueryRequestOptions.FillContinuationToken(request, continuationToken); CosmosQueryRequestOptions.FillMaxItemCount(request, maxItemCount); }, responseCreator: response => this.clientContext.ResponseFactory.CreateResultSetQueryResponse <T>(response), cosmosContainerCore: this.container, partitionKey: null, streamPayload: null, cancellationToken: cancellationToken)); }
private Task <CosmosQueryResponse <CosmosDatabaseSettings> > DatabaseFeedRequestExecutor( int?maxItemCount, string continuationToken, CosmosRequestOptions options, object state, CancellationToken cancellationToken) { Debug.Assert(state == null); Uri resourceUri = new Uri(Paths.Databases_Root, UriKind.Relative); return(ExecUtils.ProcessResourceOperationAsync <CosmosQueryResponse <CosmosDatabaseSettings> >( this.client, resourceUri, ResourceType.Database, OperationType.ReadFeed, options, request => { CosmosQueryRequestOptions.FillContinuationToken(request, continuationToken); CosmosQueryRequestOptions.FillMaxItemCount(request, maxItemCount); }, response => this.client.ResponseFactory.CreateResultSetQueryResponse <CosmosDatabaseSettings>(response), cancellationToken)); }
public override CosmosResultSetIterator <T> CreateItemQuery <T>( CosmosSqlQueryDefinition sqlQueryDefinition, int maxConcurrency, int?maxItemCount = null, string continuationToken = null, CosmosQueryRequestOptions requestOptions = null) { requestOptions = requestOptions ?? new CosmosQueryRequestOptions(); requestOptions.EnableCrossPartitionQuery = true; requestOptions.RequestContinuation = continuationToken; requestOptions.MaxItemCount = maxItemCount; requestOptions.MaxConcurrency = maxConcurrency; IDocumentQueryExecutionContext documentQueryExecution = new CosmosQueryExecutionContextFactory( client: this.queryClient, resourceTypeEnum: ResourceType.Document, operationType: OperationType.Query, resourceType: typeof(T), sqlQuerySpec: sqlQueryDefinition.ToSqlQuerySpec(), queryRequestOptions: requestOptions, resourceLink: this.container.LinkUri, isContinuationExpected: true, allowNonValueAggregateQuery: true, correlatedActivityId: Guid.NewGuid()); return(new CosmosDefaultResultSetIterator <T>( maxItemCount, continuationToken, requestOptions, this.NextResultSetAsync <T>, documentQueryExecution)); }
private Task <CosmosResponseMessage> ItemStreamFeedRequestExecutor( int?maxItemCount, string continuationToken, CosmosRequestOptions options, object state, CancellationToken cancellationToken) { Uri resourceUri = this.container.LinkUri; return(ExecUtils.ProcessResourceOperationAsync <CosmosResponseMessage>( client: this.container.Database.Client, resourceUri: resourceUri, resourceType: ResourceType.Document, operationType: OperationType.ReadFeed, requestOptions: options, requestEnricher: request => { CosmosQueryRequestOptions.FillContinuationToken(request, continuationToken); CosmosQueryRequestOptions.FillMaxItemCount(request, maxItemCount); }, responseCreator: response => response, partitionKey: null, streamPayload: null, cancellationToken: cancellationToken)); }
private Task <CosmosQueryResponse <CosmosUserDefinedFunctionSettings> > ContainerFeedRequestExecutor( int?maxItemCount, string continuationToken, CosmosRequestOptions options, object state, CancellationToken cancellationToken) { Debug.Assert(state == null); return(this.clientContext.ProcessResourceOperationAsync <CosmosQueryResponse <CosmosUserDefinedFunctionSettings> >( resourceUri: this.container.LinkUri, resourceType: ResourceType.UserDefinedFunction, operationType: OperationType.ReadFeed, requestOptions: options, cosmosContainerCore: null, partitionKey: null, streamPayload: null, requestEnricher: request => { CosmosQueryRequestOptions.FillContinuationToken(request, continuationToken); CosmosQueryRequestOptions.FillMaxItemCount(request, maxItemCount); }, responseCreator: response => this.clientContext.ResponseFactory.CreateResultSetQueryResponse <CosmosUserDefinedFunctionSettings>(response), cancellationToken: cancellationToken)); }
internal async Task <CosmosQueryResponse <T> > NextResultSetAsync <T>( int?maxItemCount, string continuationToken, CosmosRequestOptions options, object state, CancellationToken cancellationToken) { CosmosQueryRequestOptions cosmosQueryRequestOptions = options as CosmosQueryRequestOptions ?? new CosmosQueryRequestOptions(); FeedOptions feedOptions = cosmosQueryRequestOptions.ToFeedOptions(); feedOptions.RequestContinuation = continuationToken; feedOptions.MaxItemCount = maxItemCount; IDocumentQuery <T> documentClientResult = this.client.DocumentClient.CreateDocumentQuery <T>( collectionLink: this.container.LinkUri.OriginalString, feedOptions: feedOptions, querySpec: state as SqlQuerySpec).AsDocumentQuery(); try { FeedResponse <T> feedResponse = await documentClientResult.ExecuteNextAsync <T>(cancellationToken); return(CosmosQueryResponse <T> .CreateResponse <T>(feedResponse, feedResponse.ResponseContinuation, documentClientResult.HasMoreResults)); } 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); } }
public override CosmosResultSetIterator CreateItemQueryAsStream( CosmosSqlQueryDefinition sqlQueryDefinition, int maxConcurrency, object partitionKey = null, int?maxItemCount = null, string continuationToken = null, CosmosQueryRequestOptions requestOptions = null) { requestOptions = requestOptions ?? new CosmosQueryRequestOptions(); requestOptions.maxConcurrency = maxConcurrency; requestOptions.EnableCrossPartitionQuery = true; FeedOptions feedOptions = requestOptions.ToFeedOptions(); feedOptions.RequestContinuation = continuationToken; feedOptions.MaxItemCount = maxItemCount; if (partitionKey != null) { PartitionKey pk = new PartitionKey(partitionKey); feedOptions.PartitionKey = pk; } DocumentQuery <CosmosQueryResponse> documentQuery = (DocumentQuery <CosmosQueryResponse>) this.client.DocumentClient.CreateDocumentQuery <CosmosQueryResponse>( collectionLink: this.container.LinkUri.OriginalString, feedOptions: feedOptions, querySpec: sqlQueryDefinition.ToSqlQuerySpec()); return(new CosmosResultSetIteratorCore( maxItemCount, continuationToken, requestOptions, this.QueryRequestExecutor, documentQuery)); }
private Task <CosmosQueryResponse <CosmosDatabaseSettings> > DatabaseFeedRequestExecutor( int?maxItemCount, string continuationToken, CosmosRequestOptions options, object state, CancellationToken cancellationToken) { Debug.Assert(state == null); Uri resourceUri = new Uri(Paths.Databases_Root, UriKind.Relative); return(this.clientContext.ProcessResourceOperationAsync <CosmosQueryResponse <CosmosDatabaseSettings> >( resourceUri: resourceUri, resourceType: ResourceType.Database, operationType: OperationType.ReadFeed, requestOptions: options, cosmosContainerCore: null, partitionKey: null, streamPayload: null, requestEnricher: request => { CosmosQueryRequestOptions.FillContinuationToken(request, continuationToken); CosmosQueryRequestOptions.FillMaxItemCount(request, maxItemCount); }, responseCreator: response => this.clientContext.ResponseFactory.CreateResultSetQueryResponse <CosmosDatabaseSettings>(response), cancellationToken: cancellationToken)); }
/// <summary> /// This method creates a query for items under a container in an Azure Cosmos database using a SQL statement with parameterized values. It returns a CosmosResultSetIterator. /// For more information on preparing SQL statements with parameterized values, please see <see cref="CosmosSqlQueryDefinition"/>. /// </summary> /// <param name="sqlQueryText">The cosmos SQL query text.</param> /// <param name="maxConcurrency">The number of concurrent operations run client side during parallel query execution in the Azure Cosmos DB service.</param> /// <param name="maxItemCount">(Optional) The max item count to return as part of the query</param> /// <param name="continuationToken">(Optional) The continuation token in the Azure Cosmos DB service.</param> /// <param name="requestOptions">(Optional) The options for the item query request <see cref="CosmosQueryRequestOptions"/></param> /// <param name="cancellationToken">(Optional) <see cref="CancellationToken"/> representing request cancellation.</param> /// <example> /// Create a query to get all the ToDoActivity that have a cost greater than 9000 /// <code language="c#"> /// <![CDATA[ /// public class ToDoActivity{ /// public string id {get; set;} /// public string status {get; set;} /// public int cost {get; set;} /// } /// /// CosmosResultSetIterator<ToDoActivity> setIterator = this.Container.Items.CreateItemQuery<ToDoActivity>( /// "select * from ToDos t where t.cost > 9000", /// maxConcurrency: 2); /// /// while (setIterator.HasMoreResults) /// { /// foreach(var item in await setIterator.FetchNextSetAsync()){ /// { /// Console.WriteLine(item.cost); /// } /// } /// ]]> /// </code> /// </example> public abstract CosmosResultSetIterator <T> CreateItemQuery <T>( string sqlQueryText, int maxConcurrency, int?maxItemCount = null, string continuationToken = null, CosmosQueryRequestOptions requestOptions = null, CancellationToken cancellationToken = default(CancellationToken));
internal ChangeFeedResultSetIterator( int?maxItemCount, string continuationToken, CosmosQueryRequestOptions options, NextResultSetDelegate nextDelegate, object state = null) : base(maxItemCount, continuationToken, options, nextDelegate, state) { }
internal abstract Task <FeedResponse <CosmosElement> > ExecuteItemQueryAsync( Uri resourceUri, ResourceType resourceType, OperationType operationType, CosmosQueryRequestOptions requestOptions, SqlQuerySpec sqlQuerySpec, Action <CosmosRequestMessage> requestEnricher, CancellationToken cancellationToken);
public override CosmosFeedResultSetIterator GetContainerStreamIterator( int?maxItemCount = null, string continuationToken = null, CosmosQueryRequestOptions requestOptions = null) { return(new CosmosFeedResultSetIteratorCore( maxItemCount, continuationToken, requestOptions, this.ContainerStreamFeedRequestExecutor)); }
public void StatelessTest() { CosmosQueryRequestOptions requestOption = new CosmosQueryRequestOptions(); requestOption.RequestContinuation = "SomeToken"; CosmosRequestMessage testMessage = new CosmosRequestMessage(); requestOption.FillRequestOptions(testMessage); Assert.IsNull(testMessage.Headers.Continuation); }
public override CosmosResultSetIterator <T> CreateItemQuery <T>( string sqlQueryText, int maxConcurrency, int?maxItemCount = null, string continuationToken = null, CosmosQueryRequestOptions requestOptions = null) { return(this.CreateItemQuery <T>( new CosmosSqlQueryDefinition(sqlQueryText), maxConcurrency, maxItemCount, continuationToken, requestOptions)); }
public override CosmosResultSetIterator <T> CreateItemQuery <T>( CosmosSqlQueryDefinition sqlQueryDefinition, int maxConcurrency, int?maxItemCount = null, string continuationToken = null, CosmosQueryRequestOptions requestOptions = null, CancellationToken cancellationToken = default(CancellationToken)) { CosmosQueryRequestOptions options = requestOptions ?? new CosmosQueryRequestOptions(); options.maxConcurrency = maxConcurrency; options.EnableCrossPartitionQuery = true; return(new CosmosDefaultResultSetIterator <T>( maxItemCount, continuationToken, options, this.NextResultSetAsync <T>, sqlQueryDefinition.ToSqlQuerySpec())); }
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)); } }
private Task <CosmosResponseMessage> ContainerStreamFeedRequestExecutor( int?maxItemCount, string continuationToken, CosmosRequestOptions requestOptions, object state, CancellationToken cancellationToken) { return(ExecUtils.ProcessResourceOperationStreamAsync( client: this.client, resourceUri: this.database.LinkUri, resourceType: ResourceType.Collection, operationType: OperationType.ReadFeed, partitionKey: null, streamPayload: null, requestOptions: requestOptions, requestEnricher: request => { CosmosQueryRequestOptions.FillContinuationToken(request, continuationToken); CosmosQueryRequestOptions.FillMaxItemCount(request, maxItemCount); }, cancellationToken: cancellationToken)); }
internal override async Task <FeedResponse <CosmosElement> > ExecuteItemQueryAsync( Uri resourceUri, ResourceType resourceType, OperationType operationType, CosmosQueryRequestOptions requestOptions, SqlQuerySpec sqlQuerySpec, Action <CosmosRequestMessage> requestEnricher, CancellationToken cancellationToken) { CosmosResponseMessage message = await this.clientContext.ProcessResourceOperationStreamAsync( resourceUri : resourceUri, resourceType : resourceType, operationType : operationType, requestOptions : requestOptions, partitionKey : requestOptions.PartitionKey, cosmosContainerCore : this.cosmosContainerCore, streamPayload : this.clientContext.JsonSerializer.ToStream <SqlQuerySpec>(sqlQuerySpec), requestEnricher : requestEnricher, cancellationToken : cancellationToken); return(this.GetFeedResponse(requestOptions, resourceType, message)); }
private Task <CosmosQueryResponse <CosmosUserDefinedFunctionSettings> > ContainerFeedRequestExecutor( int?maxItemCount, string continuationToken, CosmosRequestOptions options, object state, CancellationToken cancellationToken) { Debug.Assert(state == null); return(ExecUtils.ProcessResourceOperationAsync <CosmosQueryResponse <CosmosUserDefinedFunctionSettings> >( this.container.Database.Client, this.container.LinkUri, ResourceType.UserDefinedFunction, OperationType.ReadFeed, options, request => { CosmosQueryRequestOptions.FillContinuationToken(request, continuationToken); CosmosQueryRequestOptions.FillMaxItemCount(request, maxItemCount); }, response => this.client.ResponseFactory.CreateResultSetQueryResponse <CosmosUserDefinedFunctionSettings>(response), cancellationToken)); }
private Task <CosmosQueryResponse <CosmosStoredProcedureSettings> > StoredProcedureFeedRequestExecutor( int?maxItemCount, string continuationToken, CosmosRequestOptions options, object state, CancellationToken cancellationToken) { Uri resourceUri = this.container.LinkUri; return(ExecUtils.ProcessResourceOperationAsync <CosmosQueryResponse <CosmosStoredProcedureSettings> >( this.container.Database.Client, resourceUri, ResourceType.StoredProcedure, OperationType.ReadFeed, options, request => { CosmosQueryRequestOptions.FillContinuationToken(request, continuationToken); CosmosQueryRequestOptions.FillMaxItemCount(request, maxItemCount); }, response => this.client.ResponseFactory.CreateResultSetQueryResponse <CosmosStoredProcedureSettings>(response), cancellationToken)); }
internal CosmosQueryRequestOptions Clone() { CosmosQueryRequestOptions queryRequestOptions = new CosmosQueryRequestOptions { AccessCondition = this.AccessCondition, RequestContinuation = this.RequestContinuation, MaxItemCount = this.MaxItemCount, ResponseContinuationTokenLimitInKb = this.ResponseContinuationTokenLimitInKb, EnableScanInQuery = this.EnableScanInQuery, EnableLowPrecisionOrderBy = this.EnableLowPrecisionOrderBy, MaxBufferedItemCount = this.MaxBufferedItemCount, SessionToken = this.SessionToken, ConsistencyLevel = this.ConsistencyLevel, MaxConcurrency = this.MaxConcurrency, PartitionKey = this.PartitionKey, EnableCrossPartitionQuery = this.EnableCrossPartitionQuery, CosmosSerializationOptions = this.CosmosSerializationOptions, EnableCrossPartitionSkipTake = this.EnableCrossPartitionSkipTake, Properties = this.Properties }; return(queryRequestOptions); }
public override CosmosResultSetIterator <T> CreateItemQuery <T>( CosmosSqlQueryDefinition sqlQueryDefinition, object partitionKey, int?maxItemCount = null, string continuationToken = null, CosmosQueryRequestOptions requestOptions = null) { CosmosQueryRequestOptions options = requestOptions ?? new CosmosQueryRequestOptions(); if (partitionKey != null) { PartitionKey pk = new PartitionKey(partitionKey); options.PartitionKey = pk; } options.EnableCrossPartitionQuery = false; return(new CosmosDefaultResultSetIterator <T>( maxItemCount, continuationToken, options, this.NextResultSetAsync <T>, sqlQueryDefinition.ToSqlQuerySpec())); }
/// <summary> /// Gets an iterator to go through all the containers for the database /// </summary> /// <param name="maxItemCount">(Optional) The max item count to return as part of the query</param> /// <param name="continuationToken">The continuation token in the Azure Cosmos DB service.</param> /// <param name="requestOptions">(Optional) The options for the container request <see cref="CosmosQueryRequestOptions"/></param> public abstract CosmosFeedResultSetIterator GetContainerStreamIterator( int?maxItemCount = null, string continuationToken = null, CosmosQueryRequestOptions requestOptions = null);
private FeedResponse <CosmosElement> GetFeedResponse( CosmosQueryRequestOptions requestOptions, ResourceType resourceType, CosmosResponseMessage cosmosResponseMessage) { using (cosmosResponseMessage) { // DEVNOTE: For now throw the exception. Needs to be converted to handle exceptionless path. cosmosResponseMessage.EnsureSuccessStatusCode(); // Execute the callback an each element of the page // For example just could get a response like this // { // "_rid": "qHVdAImeKAQ=", // "Documents": [{ // "id": "03230", // "_rid": "qHVdAImeKAQBAAAAAAAAAA==", // "_self": "dbs\/qHVdAA==\/colls\/qHVdAImeKAQ=\/docs\/qHVdAImeKAQBAAAAAAAAAA==\/", // "_etag": "\"410000b0-0000-0000-0000-597916b00000\"", // "_attachments": "attachments\/", // "_ts": 1501107886 // }], // "_count": 1 // } // And you should execute the callback on each document in "Documents". MemoryStream memoryStream = new MemoryStream(); cosmosResponseMessage.Content.CopyTo(memoryStream); long responseLengthBytes = memoryStream.Length; byte[] content = memoryStream.ToArray(); IJsonNavigator jsonNavigator = null; // Use the users custom navigator first. If it returns null back try the // internal override navigator. if (requestOptions.CosmosSerializationOptions != null) { jsonNavigator = requestOptions.CosmosSerializationOptions.CreateCustomNavigatorCallback(content); if (jsonNavigator == null) { throw new InvalidOperationException("The CosmosSerializationOptions did not return a JSON navigator."); } } else { jsonNavigator = JsonNavigator.Create(content); } string resourceName = this.GetRootNodeName(resourceType); if (!jsonNavigator.TryGetObjectProperty( jsonNavigator.GetRootNode(), resourceName, out ObjectProperty objectProperty)) { throw new InvalidOperationException($"Response Body Contract was violated. QueryResponse did not have property: {resourceName}"); } IJsonNavigatorNode cosmosElements = objectProperty.ValueNode; if (!(CosmosElement.Dispatch( jsonNavigator, cosmosElements) is CosmosArray cosmosArray)) { throw new InvalidOperationException($"QueryResponse did not have an array of : {resourceName}"); } int itemCount = cosmosArray.Count; return(new FeedResponse <CosmosElement>( result: cosmosArray, count: itemCount, responseHeaders: cosmosResponseMessage.Headers.CosmosMessageHeaders, responseLengthBytes: responseLengthBytes)); } }
/// <summary> /// This method creates a query for items under a container in an Azure Cosmos database using a SQL statement with parameterized values. It returns a CosmosResultSetIterator. /// For more information on preparing SQL statements with parameterized values, please see <see cref="CosmosSqlQueryDefinition"/>. /// </summary> /// <param name="sqlQueryDefinition">The cosmos SQL query definition.</param> /// <param name="maxConcurrency">The number of concurrent operations run client side during parallel query execution in the Azure Cosmos DB service.</param> /// <param name="maxItemCount">(Optional) The max item count to return as part of the query</param> /// <param name="continuationToken">(Optional) The continuation token in the Azure Cosmos DB service.</param> /// <param name="requestOptions">(Optional) The options for the item query request <see cref="CosmosQueryRequestOptions"/></param> /// <example> /// Create a query to get all the ToDoActivity that have a cost greater than 9000 /// <code language="c#"> /// <![CDATA[ /// public class ToDoActivity{ /// public string id {get; set;} /// public string status {get; set;} /// public int cost {get; set;} /// } /// /// CosmosSqlQueryDefinition sqlQuery = new CosmosSqlQueryDefinition("select * from ToDos t where t.cost > @expensive").UseParameter("@expensive", 9000); /// CosmosResultSetIterator<ToDoActivity> setIterator = this.Container.Items.CreateItemQuery<ToDoActivity>( /// sqlQuery, /// maxConcurrency: 2); /// /// while (setIterator.HasMoreResults) /// { /// foreach(var item in await setIterator.FetchNextSetAsync()){ /// { /// Console.WriteLine(item.cost); /// } /// } /// ]]> /// </code> /// </example> public abstract CosmosResultSetIterator <T> CreateItemQuery <T>( CosmosSqlQueryDefinition sqlQueryDefinition, int maxConcurrency, int?maxItemCount = null, string continuationToken = null, CosmosQueryRequestOptions requestOptions = null);
/// <summary> /// This method creates a query for items under a container in an Azure Cosmos database using a SQL statement with parameterized values. It returns a CosmosResultSetIterator. /// For more information on preparing SQL statements with parameterized values, please see <see cref="CosmosSqlQueryDefinition"/>. /// </summary> /// <param name="sqlQueryText">The cosmos SQL query text.</param> /// <param name="partitionKey">The partition key for the item. <see cref="Microsoft.Azure.Documents.PartitionKey"/></param> /// <param name="maxItemCount">(Optional) The max item count to return as part of the query</param> /// <param name="continuationToken">(Optional) The continuation token in the Azure Cosmos DB service.</param> /// <param name="requestOptions">(Optional) The options for the item query request <see cref="CosmosQueryRequestOptions"/></param> /// <example> /// Create a query to get all the ToDoActivity that have a cost greater than 9000 /// <code language="c#"> /// <![CDATA[ /// public class ToDoActivity{ /// public string id {get; set;} /// public string status {get; set;} /// public int cost {get; set;} /// } /// /// CosmosResultSetIterator<ToDoActivity> setIterator = this.Container.Items.CreateItemQuery<ToDoActivity>( /// sqlQueryText: "select * from ToDos t where t.cost > 9000", /// partitionKey: "Error"); /// /// while (setIterator.HasMoreResults) /// { /// foreach(var item in await setIterator.FetchNextSetAsync()){ /// { /// Console.WriteLine(item.cost); /// } /// } /// ]]> /// </code> /// </example> public abstract CosmosResultSetIterator <T> CreateItemQuery <T>( string sqlQueryText, object partitionKey, int?maxItemCount = null, string continuationToken = null, CosmosQueryRequestOptions requestOptions = null);