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));
}
/// <summary>
/// Used internally by friends ensrue robust argument and
/// exception-less handling, with container information
/// </summary>
internal static Task <T> ProcessResourceOperationAsync <T>(
CosmosClient client,
string resourceUri,
ResourceType resourceType,
OperationType operationType,
RequestOptions requestOptions,
ContainerInternal cosmosContainerCore,
PartitionKey?partitionKey,
Stream streamPayload,
Action <RequestMessage> requestEnricher,
Func <ResponseMessage, T> responseCreator,
CancellationToken cancellationToken)
{
if (client == null)
{
throw new ArgumentNullException(nameof(client));
}
return(ExecUtils.ProcessResourceOperationAsync(
requestHandler: client.RequestHandler,
resourceUri: resourceUri,
resourceType: resourceType,
operationType: operationType,
requestOptions: requestOptions,
cosmosContainerCore: cosmosContainerCore,
partitionKey: partitionKey,
streamPayload: streamPayload,
requestEnricher: requestEnricher,
responseCreator: responseCreator,
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));
}
internal static Task <T> ProcessCollectionCreateAsync <T>(
CosmosContainerSettings containerSettings,
CosmosDatabase database,
int?throughput,
Func <CosmosResponseMessage, T> responseCreator,
CosmosRequestOptions requestOptions = null,
CancellationToken cancellationToken = default(CancellationToken))
{
if (containerSettings == null)
{
throw new ArgumentNullException(nameof(containerSettings));
}
containerSettings.ValidateRequiredProperties();
database.Client.DocumentClient.ValidateResource(containerSettings);
return(ExecUtils.ProcessResourceOperationAsync <T>(
database.Client,
database.LinkUri,
ResourceType.Collection,
OperationType.Create,
requestOptions,
partitionKey: null,
streamPayload: containerSettings.GetResourceStream(),
requestEnricher: (httpRequestMessage) => httpRequestMessage.AddThroughputHeader(throughput),
responseCreator: responseCreator,
cancellationToken: cancellationToken));
}
private Task <CosmosDatabaseResponse> ProcessAsync(
OperationType operationType,
CosmosRequestOptions requestOptions = null,
CancellationToken cancellationToken = default(CancellationToken))
{
return(ExecUtils.ProcessResourceOperationAsync <CosmosDatabaseResponse>(
this.Client,
this.LinkUri,
ResourceType.Database,
operationType,
requestOptions,
streamPayload: null,
responseCreator: response =>
this.Client.ResponseFactory.CreateDatabaseResponse(response, this),
cancellationToken: cancellationToken));
}
/// <summary>
/// Creates a user defined function as an asynchronous operation in the Azure Cosmos DB service.
/// </summary>
/// <param name="userDefinedFunctionSettings">The <see cref="CosmosUserDefinedFunctionSettings"/> object.</param>
/// <param name="requestOptions">(Optional) The options for the user defined function request <see cref="CosmosRequestOptions"/></param>
/// <param name="cancellationToken">(Optional) <see cref="CancellationToken"/> representing request cancellation.</param>
/// <returns>A task object representing the service response for the asynchronous operation.</returns>
/// <exception cref="ArgumentNullException">If <paramref name="userDefinedFunctionSettings"/> is not set.</exception>
/// <exception cref="System.AggregateException">Represents a consolidation of failures that occurred during async processing. Look within InnerExceptions to find the actual exception(s)</exception>
/// <exception cref="CosmosException">This exception can encapsulate many different types of errors. To determine the specific error always look at the StatusCode property. Some common codes you may get when creating a user defined function are:
/// <list type="table">
/// <listheader>
/// <term>StatusCode</term><description>Reason for exception</description>
/// </listheader>
/// <item>
/// <term>400</term><description>BadRequest - This means something was wrong with the request supplied. It is likely that an Id was not supplied for the new user defined function or that the Body was malformed.</description>
/// </item>
/// <item>
/// <term>403</term><description>Forbidden - You have reached your quota of user defined functions for the collection supplied. Contact support to have this quota increased.</description>
/// </item>
/// <item>
/// <term>409</term><description>Conflict - This means a <see cref="CosmosUserDefinedFunctionSettings"/> with an id matching the id you supplied already existed.</description>
/// </item>
/// <item>
/// <term>413</term><description>RequestEntityTooLarge - This means the body of the <see cref="CosmosUserDefinedFunctionSettings"/> you tried to create was too large.</description>
/// </item>
/// </list>
/// </exception>
/// <example>
/// This creates a user defined function then uses the function in an item query.
/// <code language="c#">
/// <![CDATA[
///
/// await this.container.UserDefinedFunctions.CreateUserDefinedFunctionAsync(
/// new CosmosUserDefinedFunctionSettings
/// {
/// Id = "calculateTax",
/// Body = @"function(amt) { return amt * 0.05; }"
/// });
///
/// CosmosSqlQueryDefinition sqlQuery = new CosmosSqlQueryDefinition(
/// "SELECT VALUE udf.calculateTax(t.cost) FROM toDoActivity t where t.cost > @expensive and t.status = @status")
/// .UseParameter("@expensive", 9000)
/// .UseParameter("@status", "Done");
///
/// CosmosResultSetIterator<double> setIterator = this.container.Items.CreateItemQuery<double>(
/// sqlQueryDefinition: sqlQuery,
/// partitionKey: "Done");
///
/// while (setIterator.HasMoreResults)
/// {
/// foreach (var tax in await setIterator.FetchNextSetAsync())
/// {
/// Console.WriteLine(tax);
/// }
/// }
/// ]]>
/// </code>
/// </example>
public virtual Task <CosmosUserDefinedFunctionResponse> CreateUserDefinedFunctionAsync(
CosmosUserDefinedFunctionSettings userDefinedFunctionSettings,
CosmosRequestOptions requestOptions = null,
CancellationToken cancellationToken = default(CancellationToken))
{
return(ExecUtils.ProcessResourceOperationAsync <CosmosUserDefinedFunctionResponse>(
this.container.Database.Client,
this.container.LinkUri,
ResourceType.UserDefinedFunction,
OperationType.Create,
requestOptions,
partitionKey: null,
streamPayload: userDefinedFunctionSettings.GetResourceStream(),
requestEnricher: null,
responseCreator: response => this.client.ResponseFactory.CreateUserDefinedFunctionResponse(response, new CosmosUserDefinedFunction(this.container, userDefinedFunctionSettings.Id)),
cancellationToken: cancellationToken));
}
private Task <CosmosContainerResponse> ProcessAsync(
CosmosContainerSettings containerSettings,
OperationType operationType,
CosmosContainerRequestOptions requestOptions = null,
CancellationToken cancellationToken = default(CancellationToken))
{
return(ExecUtils.ProcessResourceOperationAsync <CosmosContainerResponse>(
this.Client,
this.LinkUri,
ResourceType.Collection,
operationType,
requestOptions,
containerSettings?.GetResourceStream(),
response =>
this.Client.ResponseFactory.CreateContainerResponse(response, this),
cancellationToken));
}
internal virtual Task <CosmosUserDefinedFunctionResponse> ProcessAsync(
object partitionKey,
Stream streamPayload,
OperationType operationType,
CosmosRequestOptions requestOptions,
CancellationToken cancellationToken)
{
return(ExecUtils.ProcessResourceOperationAsync <CosmosUserDefinedFunctionResponse>(
this.Client,
this.LinkUri,
ResourceType.UserDefinedFunction,
operationType,
requestOptions,
partitionKey,
streamPayload,
null,
response => this.Client.ResponseFactory.CreateUserDefinedFunctionResponse(response, this),
cancellationToken));
}
internal static Task <T> ProcessResourceOperationAsync <T>(
CosmosClient client,
Uri resourceUri,
ResourceType resourceType,
OperationType operationType,
CosmosRequestOptions requestOptions,
Func <CosmosResponseMessage, T> responseCreator,
CancellationToken cancellationToken)
{
return(ExecUtils.ProcessResourceOperationAsync(
client,
resourceUri,
resourceType,
operationType,
requestOptions,
partitionKey: null,
streamPayload: null,
requestEnricher: null,
responseCreator: responseCreator,
cancellationToken: cancellationToken));
}
internal static Task <T> ProcessResourceOperationAsync <T>(
CosmosClient client,
string resourceUri,
ResourceType resourceType,
OperationType operationType,
RequestOptions requestOptions,
Func <ResponseMessage, T> responseCreator,
CancellationToken cancellationToken)
{
return(ExecUtils.ProcessResourceOperationAsync(
client,
resourceUri,
resourceType,
operationType,
requestOptions,
cosmosContainerCore: null,
feedRange: null,
streamPayload: null,
requestEnricher: null,
responseCreator: responseCreator,
cancellationToken: cancellationToken));
}
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 static Task <T> CreateDatabaseCoreAsync <T>(
CosmosDatabaseSettings databaseSettings,
CosmosClient client,
Func <CosmosResponseMessage, T> responseCreator,
CosmosRequestOptions requestOptions = null,
int?throughput = null,
CancellationToken cancellationToken = default(CancellationToken))
{
client.DocumentClient.ValidateResource(databaseSettings);
Uri resourceUri = new Uri(Paths.Databases_Root, UriKind.Relative);
return(ExecUtils.ProcessResourceOperationAsync <T>(
client,
resourceUri,
ResourceType.Database,
OperationType.Create,
requestOptions,
partitionKey: null,
streamPayload: databaseSettings.GetResourceStream(),
requestEnricher: (httpRequestMessage) => httpRequestMessage.AddThroughputHeader(throughput),
responseCreator: responseCreator,
cancellationToken: cancellationToken));
}
