/// <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);
