Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
com.azure.cosmos.CosmosContainer Maven / Gradle / Ivy
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.
package com.azure.cosmos;
import com.azure.cosmos.implementation.throughputControl.config.GlobalThroughputControlGroup;
import com.azure.cosmos.models.CosmosBatch;
import com.azure.cosmos.models.CosmosBatchOperationResult;
import com.azure.cosmos.models.CosmosBatchRequestOptions;
import com.azure.cosmos.models.CosmosBatchResponse;
import com.azure.cosmos.models.CosmosBulkExecutionOptions;
import com.azure.cosmos.models.CosmosBulkOperationResponse;
import com.azure.cosmos.models.CosmosChangeFeedRequestOptions;
import com.azure.cosmos.models.CosmosContainerProperties;
import com.azure.cosmos.models.CosmosContainerRequestOptions;
import com.azure.cosmos.models.CosmosContainerResponse;
import com.azure.cosmos.models.CosmosItemIdentity;
import com.azure.cosmos.models.CosmosItemOperation;
import com.azure.cosmos.models.CosmosItemRequestOptions;
import com.azure.cosmos.models.CosmosItemResponse;
import com.azure.cosmos.models.CosmosPatchItemRequestOptions;
import com.azure.cosmos.models.CosmosPatchOperations;
import com.azure.cosmos.models.CosmosQueryRequestOptions;
import com.azure.cosmos.models.CosmosReadManyRequestOptions;
import com.azure.cosmos.models.FeedRange;
import com.azure.cosmos.models.FeedResponse;
import com.azure.cosmos.models.PartitionKey;
import com.azure.cosmos.models.SqlQuerySpec;
import com.azure.cosmos.models.ThroughputProperties;
import com.azure.cosmos.models.ThroughputResponse;
import com.azure.cosmos.util.CosmosPagedFlux;
import com.azure.cosmos.util.CosmosPagedIterable;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import reactor.core.Exceptions;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import java.util.List;
import static com.azure.cosmos.implementation.guava25.base.Preconditions.checkNotNull;
/**
* Provides synchronous methods for reading, deleting, and replacing existing Containers
* Provides methods for interacting with child resources (Items, Scripts, Conflicts)
*/
public class CosmosContainer {
private static final Logger logger = LoggerFactory.getLogger(CosmosContainer.class);
final CosmosAsyncContainer asyncContainer;
private final CosmosDatabase database;
private final String id;
private CosmosScripts scripts;
/**
* Instantiates a new Cosmos sync container.
*
* @param id the container id.
* @param database the database.
* @param container the container.
*/
CosmosContainer(String id, CosmosDatabase database, CosmosAsyncContainer container) {
this.id = id;
this.database = database;
this.asyncContainer = container;
}
/**
* Gets the current container id.
*
* @return the container id.
*/
public String getId() {
return id;
}
/**
* Reads the current container.
*
* @return the Cosmos container response with the read container.
*/
public CosmosContainerResponse read() {
return database.blockContainerResponse(this.asyncContainer.read());
}
/**
* Reads the current container while specifying additional options such as If-Match.
*
* @param options the options.
* @return the Cosmos container response.
*/
public CosmosContainerResponse read(CosmosContainerRequestOptions options) {
return database.blockContainerResponse(this.asyncContainer.read(options));
}
/**
* Deletes the current Cosmos container while specifying additional options such as If-Match.
*
* @param options the options.
* @return the cosmos container response.
*/
public CosmosContainerResponse delete(CosmosContainerRequestOptions options) {
return database.blockContainerResponse(this.asyncContainer.delete(options));
}
/**
* Deletes the current cosmos container.
*
* @return the cosmos container response.
*/
public CosmosContainerResponse delete() {
return database.blockContainerResponse(this.asyncContainer.delete());
}
/**
* Replaces the current container properties.
*
* @param containerProperties the container properties.
* @return the cosmos container response.
*/
public CosmosContainerResponse replace(CosmosContainerProperties containerProperties) {
return database.blockContainerResponse(this.asyncContainer.replace(containerProperties));
}
/**
* Replaces the current container properties while specifying additional options such as If-Match.
*
* @param containerProperties the container properties.
* @param options the options.
* @return the cosmos container response.
*/
public CosmosContainerResponse replace(CosmosContainerProperties containerProperties,
CosmosContainerRequestOptions options) {
return database.blockContainerResponse(this.asyncContainer.replace(containerProperties, options));
}
/**
* Sets the throughput for the current container.
*
*
* ThroughputProperties throughputProperties =
* ThroughputProperties.createAutoscaledThroughput(1000);
* try {
* ThroughputResponse throughputResponse =
* cosmosContainer.replaceThroughput(throughputProperties);
* System.out.println(throughputResponse);
* } catch (CosmosException ce) {
* ce.printStackTrace();
* } catch (Exception e) {
* e.printStackTrace();
* }
*
*
* @param throughputProperties the throughput properties (Optional).
* @return the throughput response.
*/
public ThroughputResponse replaceThroughput(ThroughputProperties throughputProperties) {
return database.throughputResponseToBlock(this.asyncContainer.replaceThroughput(throughputProperties));
}
/**
* Gets the throughput for the current container.
*
*
* try {
* ThroughputResponse throughputResponse = cosmosContainer.readThroughput();
* System.out.println(throughputResponse);
* } catch (CosmosException ce) {
* ce.printStackTrace();
* } catch (Exception e) {
* e.printStackTrace();
* }
*
*
* @return the throughput response.
*/
public ThroughputResponse readThroughput() {
return database.throughputResponseToBlock(this.asyncContainer.readThroughput());
}
/* Cosmos item operations */
/**
* Creates a new item synchronously and returns its respective Cosmos item response.
*
* @param the type parameter
* @param item the item
* @return the Cosmos item response
*/
public CosmosItemResponse createItem(T item) {
return this.blockItemResponse(this.asyncContainer.createItem(item));
}
/**
* Creates a new item synchronously and returns its respective Cosmos item response
* while specifying additional options.
*
* @param the type parameter.
* @param item the item.
* @param partitionKey the partition key.
* @param options the options.
* @return the Cosmos item response.
*/
public CosmosItemResponse createItem(T item,
PartitionKey partitionKey,
CosmosItemRequestOptions options) {
return this.blockItemResponse(this.asyncContainer.createItem(item, partitionKey, options));
}
/**
* Creates a new item synchronously and returns its respective Cosmos item response
* while specifying additional options.
*
* The partition key value will be automatically extracted from the item's content.
*
* @param the type parameter.
* @param item the item.
* @param options the options.
* @return the cosmos item response.
*/
public CosmosItemResponse createItem(T item, CosmosItemRequestOptions options) {
return this.blockItemResponse(this.asyncContainer.createItem(item, options));
}
/**
* Upserts an Cosmos item in the current container.
*
* @param the type parameter.
* @param item the item.
* @return the Cosmos item response.
*/
public CosmosItemResponse upsertItem(T item) {
return this.blockItemResponse(this.asyncContainer.upsertItem(item));
}
/**
* Upserts a item Cosmos sync item while specifying additional options.
*
* @param the type parameter.
* @param item the item.
* @param options the options.
* @return the Cosmos item response.
*/
public CosmosItemResponse upsertItem(T item, CosmosItemRequestOptions options) {
return this.blockItemResponse(this.asyncContainer.upsertItem(item, options));
}
/**
* Upserts an item Cosmos sync item while specifying additional options.
*
* @param the type parameter.
* @param item the item.
* @param partitionKey the partitionKey.
* @param options the options.
* @return the Cosmos item response.
*/
public CosmosItemResponse upsertItem(T item, PartitionKey partitionKey, CosmosItemRequestOptions options) {
return this.blockItemResponse(this.asyncContainer.upsertItem(item, partitionKey, options));
}
/**
* Block cosmos item response.
*
* @param itemMono the item mono.
* @return the cosmos item response.
*/
CosmosItemResponse blockItemResponse(Mono> itemMono) {
try {
return itemMono.block();
} catch (Exception ex) {
final Throwable throwable = Exceptions.unwrap(ex);
if (throwable instanceof CosmosException) {
throw (CosmosException) throwable;
} else {
throw ex;
}
}
}
/**
* Block cosmos item response.
*
* @param itemMono the item mono.
* @return the cosmos item response.
*/
FeedResponse blockFeedResponse(Mono> itemMono) {
try {
return itemMono.block();
} catch (Exception ex) {
final Throwable throwable = Exceptions.unwrap(ex);
if (throwable instanceof CosmosException) {
throw (CosmosException) throwable;
} else {
throw ex;
}
}
}
private CosmosItemResponse blockDeleteItemResponse(Mono> deleteItemMono) {
try {
return deleteItemMono.block();
} catch (Exception ex) {
final Throwable throwable = Exceptions.unwrap(ex);
if (throwable instanceof CosmosException) {
throw (CosmosException) throwable;
} else {
throw ex;
}
}
}
private CosmosBatchResponse blockBatchResponse(Mono batchResponseMono) {
try {
return batchResponseMono.block();
} catch (Exception ex) {
final Throwable throwable = Exceptions.unwrap(ex);
if (throwable instanceof CosmosException) {
throw (CosmosException) throwable;
} else {
throw ex;
}
}
}
private List> blockBulkResponse(
Flux> bulkResponse) {
try {
return bulkResponse.collectList().block();
} catch (Exception ex) {
final Throwable throwable = Exceptions.unwrap(ex);
if (throwable instanceof CosmosException) {
throw (CosmosException) throwable;
} else {
throw ex;
}
}
}
/**
* Read all items as {@link CosmosPagedIterable} in the current container.
*
* @param the type parameter.
* @param options the options.
* @param classType the classType.
* @return the {@link CosmosPagedIterable}.
*/
CosmosPagedIterable readAllItems(CosmosQueryRequestOptions options, Class classType) {
return getCosmosPagedIterable(this.asyncContainer.readAllItems(options, classType));
}
/**
* Query items in the current container returning the results as {@link CosmosPagedIterable}.
*
*
* CosmosQueryRequestOptions options = new CosmosQueryRequestOptions();
* String query = "SELECT * FROM Passenger WHERE Passenger.departure IN ('SEA', 'IND')";
* Iterable<FeedResponse<Passenger>> queryResponses = cosmosContainer.queryItems(query, options, Passenger.class)
* .iterableByPage();
*
* for (FeedResponse<Passenger> feedResponse : queryResponses) {
* List<Passenger> results = feedResponse.getResults();
* System.out.println(results);
* }
*
*
* @param the type parameter.
* @param query the query.
* @param options the options.
* @param classType the class type.
* @return the {@link CosmosPagedIterable}.
*/
public CosmosPagedIterable queryItems(String query, CosmosQueryRequestOptions options, Class classType) {
return getCosmosPagedIterable(this.asyncContainer.queryItems(query, options, classType));
}
/**
* Query items in the current container returning the results as {@link CosmosPagedIterable}.
*
*
* CosmosQueryRequestOptions options = new CosmosQueryRequestOptions();
* String query = "SELECT * FROM Passenger p WHERE (p.departure = @departure)";
* List<SqlParameter> parameters = Collections.singletonList(new SqlParameter("@departure", "SEA"));
* SqlQuerySpec sqlQuerySpec = new SqlQuerySpec(query, parameters);
*
* Iterable<FeedResponse<Passenger>> queryResponses = cosmosContainer.queryItems(sqlQuerySpec, options, Passenger.class)
* .iterableByPage();
*
* for (FeedResponse<Passenger> feedResponse : queryResponses) {
* List<Passenger> results = feedResponse.getResults();
* System.out.println(results);
* }
*
*
* @param the type parameter.
* @param querySpec the query spec.
* @param options the options.
* @param classType the class type.
* @return the {@link CosmosPagedIterable}.
*/
public CosmosPagedIterable queryItems(SqlQuerySpec querySpec, CosmosQueryRequestOptions options, Class classType) {
return getCosmosPagedIterable(this.asyncContainer.queryItems(querySpec, options, classType));
}
/**
* Query for items in the change feed of the current container using the {@link CosmosChangeFeedRequestOptions}.
*
*
* CosmosChangeFeedRequestOptions options = CosmosChangeFeedRequestOptions
* .createForProcessingFromNow(FeedRange.forFullRange())
* .allVersionsAndDeletes();
*
* Iterable<FeedResponse<Passenger>> feedResponses = cosmosContainer.queryChangeFeed(options, Passenger.class)
* .iterableByPage();
* for (FeedResponse<Passenger> feedResponse : feedResponses) {
* List<Passenger> results = feedResponse.getResults();
* System.out.println(results);
* }
*
*
*
* The next page can be retrieved by calling queryChangeFeed again with a new instance of
* {@link CosmosChangeFeedRequestOptions} created from the continuation token of the previously returned
* {@link FeedResponse} instance.
*
* @param the type parameter.
* @param options the change feed request options.
* @param classType the class type.
* @return a {@link CosmosPagedFlux} containing one feed response page
*/
public CosmosPagedIterable queryChangeFeed(
CosmosChangeFeedRequestOptions options,
Class classType) {
checkNotNull(options, "Argument 'options' must not be null.");
checkNotNull(classType, "Argument 'classType' must not be null.");
options.setMaxPrefetchPageCount(1);
return getCosmosPagedIterable(
this.asyncContainer
.queryChangeFeed(options, classType));
}
/**
* Reads many documents.
* Useful for reading many documents with a particular id and partition key in a single request.
* If any document from the list is missing, no exception will be thrown.
*
*
* List<CosmosItemIdentity> itemIdentityList = new ArrayList<>();
* itemIdentityList.add(new CosmosItemIdentity(new PartitionKey(passenger1Id), passenger1Id));
* itemIdentityList.add(new CosmosItemIdentity(new PartitionKey(passenger2Id), passenger2Id));
*
* FeedResponse<Passenger> passengerFeedResponse = cosmosContainer.readMany(itemIdentityList, Passenger.class);
* for (Passenger passenger : passengerFeedResponse.getResults()) {
* System.out.println(passenger);
* }
*
*
* @param the type parameter
* @param itemIdentityList CosmosItem id and partition key tuple of items that that needs to be read
* @param classType class type
* @return a Mono with feed response of cosmos items
*/
public FeedResponse readMany(
List itemIdentityList,
Class classType) {
return this.readMany(itemIdentityList, (CosmosReadManyRequestOptions)null, classType);
}
/**
* Reads many documents.
* Useful for reading many documents with a particular id and partition key in a single request.
* If any document from the list is missing, no exception will be thrown.
*
*
* List<CosmosItemIdentity> itemIdentityList = new ArrayList<>();
* itemIdentityList.add(new CosmosItemIdentity(new PartitionKey(passenger1Id), passenger1Id));
* itemIdentityList.add(new CosmosItemIdentity(new PartitionKey(passenger2Id), passenger2Id));
*
* FeedResponse<Passenger> passengerFeedResponse = cosmosContainer.readMany(itemIdentityList, Passenger.class);
* for (Passenger passenger : passengerFeedResponse.getResults()) {
* System.out.println(passenger);
* }
*
*
* @param the type parameter
* @param itemIdentityList CosmosItem id and partition key tuple of items that that needs to be read
* @param sessionToken the optional Session token - null if the read can be made without specific session token
* @param classType class type
* @return a Mono with feed response of cosmos items
*/
public FeedResponse readMany(
List itemIdentityList,
String sessionToken,
Class classType) {
return this.blockFeedResponse(
this.asyncContainer.readMany(
itemIdentityList,
sessionToken,
classType));
}
/**
* Reads many documents.
* Useful for reading many documents with a particular id and partition key in a single request.
* If any document from the list is missing, no exception will be thrown.
*
*
* List<CosmosItemIdentity> itemIdentityList = new ArrayList<>();
* itemIdentityList.add(new CosmosItemIdentity(new PartitionKey(passenger1Id), passenger1Id));
* itemIdentityList.add(new CosmosItemIdentity(new PartitionKey(passenger2Id), passenger2Id));
*
* FeedResponse<Passenger> passengerFeedResponse = cosmosContainer.readMany(itemIdentityList, Passenger.class);
* for (Passenger passenger : passengerFeedResponse.getResults()) {
* System.out.println(passenger);
* }
*
*
* @param the type parameter
* @param itemIdentityList CosmosItem id and partition key tuple of items that that needs to be read
* @param options the optional request options
* @param classType class type
* @return a Mono with feed response of cosmos items
*/
public FeedResponse readMany(
List itemIdentityList,
CosmosReadManyRequestOptions options,
Class classType) {
return this.blockFeedResponse(
this.asyncContainer.readMany(
itemIdentityList,
options,
classType));
}
/**
* Reads all the items of a logical partition returning the results as {@link CosmosPagedIterable}.
*
*
* CosmosPagedIterable<Passenger> passengers = cosmosContainer
* .readAllItems(new PartitionKey(partitionKey), Passenger.class);
*
* passengers.forEach(passenger -> {
* System.out.println(passenger);
* });
*
*
*
* @param the type parameter.
* @param partitionKey the partition key value of the documents that need to be read
* @param classType the class type.
* @return the {@link CosmosPagedIterable}.
*/
public CosmosPagedIterable readAllItems(
PartitionKey partitionKey,
Class classType) {
return this.readAllItems(partitionKey, new CosmosQueryRequestOptions(), classType);
}
/**
* Reads all the items of a logical partition returning the results as {@link CosmosPagedIterable}.
*
*
* CosmosPagedIterable<Passenger> passengers = cosmosContainer
* .readAllItems(new PartitionKey(partitionKey), Passenger.class);
*
* passengers.forEach(passenger -> {
* System.out.println(passenger);
* });
*
*
*
* @param the type parameter.
* @param partitionKey the partition key value of the documents that need to be read
* @param options the feed options.
* @param classType the class type.
* @return the {@link CosmosPagedIterable}.
*/
public CosmosPagedIterable readAllItems(
PartitionKey partitionKey,
CosmosQueryRequestOptions options,
Class classType) {
return getCosmosPagedIterable(this.asyncContainer.readAllItems(partitionKey, options, classType));
}
/**
* Reads an item in the current container.
*
* // Read an item
* try {
* CosmosItemResponse<Passenger> response = cosmosContainer.readItem(
* passenger.getId(),
* new PartitionKey(passenger.getId()),
* Passenger.class
* );
* Passenger passengerItem = response.getItem();
* } catch (NotFoundException e) {
* // catch exception if item not found
* System.out.printf("Passenger with item id %s not found\n",
* passenger.getId());
* } catch (Exception e) {
* System.out.println(e.getMessage());
* }
*
* // ...
*
*
* @param the type parameter.
* @param itemId the item id.
* @param partitionKey the partition key.
* @param itemType the class type of item.
* @return the Cosmos item response.
* @throws com.azure.cosmos.implementation.NotFoundException if document with the specified itemId does not exist
*/
public CosmosItemResponse readItem(String itemId, PartitionKey partitionKey, Class itemType) {
return this.blockItemResponse(asyncContainer.readItem(itemId,
partitionKey,
new CosmosItemRequestOptions(),
itemType));
}
/**
* Reads an item in the current container while specifying additional options.
* the type parameter.
* @param itemId the item id.
* @param partitionKey the partition key.
* @param options the options (Optional).
* @param itemType the class type of item.
* @return the Cosmos item response.
* @throws com.azure.cosmos.implementation.NotFoundException if document with the specified itemId does not exist
*/
public CosmosItemResponse readItem(
String itemId, PartitionKey partitionKey,
CosmosItemRequestOptions options, Class itemType) {
return this.blockItemResponse(asyncContainer.readItem(itemId, partitionKey, options, itemType));
}
/**
* Replaces an existing item in a container with a new item.
* It performs a complete replacement of the item,
* replacing all its properties with the properties of the new item
*
*
* CosmosItemResponse<Passenger> response = cosmosContainer.replaceItem(
* newPassenger,
* oldPassenger.getId(),
* new PartitionKey(oldPassenger.getId()),
* new CosmosItemRequestOptions());
*
*
* @param the type parameter.
* @param item the item.
* @param itemId the item id.
* @param partitionKey the partition key.
* @param options the options.
* @return the Cosmos item response.
*/
public CosmosItemResponse replaceItem(T item,
String itemId,
PartitionKey partitionKey,
CosmosItemRequestOptions options) {
return this.blockItemResponse(asyncContainer.replaceItem(item, itemId, partitionKey, options));
}
/**
* Run partial update that modifies specific properties or fields of the item without replacing the entire item.
*
*
*
* CosmosPatchOperations cosmosPatchOperations = CosmosPatchOperations.create();
*
* cosmosPatchOperations
* .add("/departure", "SEA")
* .increment("/trips", 1);
*
* CosmosItemResponse<Passenger> response = cosmosContainer.patchItem(
* passenger.getId(),
* new PartitionKey(passenger.getId()),
* cosmosPatchOperations,
* Passenger.class);
*
*
*
* @param the type parameter.
* @param itemId the item id.
* @param partitionKey the partition key.
* @param cosmosPatchOperations Represents a container having list of operations to be sequentially applied to the referred Cosmos item.
* @param itemType the item type.
*
* @return the Cosmos item resource response with the patched item or an exception.
*/
public CosmosItemResponse patchItem(
String itemId,
PartitionKey partitionKey,
CosmosPatchOperations cosmosPatchOperations,
Class itemType) {
return this.blockItemResponse(asyncContainer.patchItem(itemId, partitionKey, cosmosPatchOperations, itemType));
}
/**
* Run partial update that modifies specific properties or fields of the item without replacing the entire item.
*
*
*
* CosmosPatchOperations cosmosPatchOperations = CosmosPatchOperations.create();
*
* cosmosPatchOperations
* .add("/departure", "SEA")
* .increment("/trips", 1);
*
* CosmosItemResponse<Passenger> response = cosmosContainer.patchItem(
* passenger.getId(),
* new PartitionKey(passenger.getId()),
* cosmosPatchOperations,
* Passenger.class);
*
*
*
* @param the type parameter.
* @param itemId the item id.
* @param partitionKey the partition key.
* @param cosmosPatchOperations Represents a container having list of operations to be sequentially applied to the referred Cosmos item.
* @param options the request options.
* @param itemType the item type.
*
* @return the Cosmos item resource response with the patched item or an exception.
*/
public CosmosItemResponse patchItem(
String itemId,
PartitionKey partitionKey,
CosmosPatchOperations cosmosPatchOperations,
CosmosPatchItemRequestOptions options,
Class itemType) {
return this.blockItemResponse(asyncContainer.patchItem(itemId, partitionKey, cosmosPatchOperations, options, itemType));
}
/**
* Deletes an item in the current container.
*
*
*
* try {
* CosmosItemRequestOptions options = new CosmosItemRequestOptions();
* CosmosItemResponse<Object> deleteItemResponse = cosmosContainer.deleteItem(
* passenger.getId(),
* new PartitionKey(passenger.getId()),
* options
* );
* System.out.println(deleteItemResponse);
* } catch (NotFoundException e) {
* // catch exception if item not found
* System.out.printf("Passenger with item id %s not found\n",
* passenger.getId());
* } catch (Exception e) {
* System.out.println(e.getMessage());
* }
*
*
* @param itemId the item id.
* @param partitionKey the partition key.
* @param options the options.
* @return the Cosmos item response.
*/
public CosmosItemResponse deleteItem(String itemId, PartitionKey partitionKey,
CosmosItemRequestOptions options) {
return this.blockDeleteItemResponse(asyncContainer.deleteItem(itemId, partitionKey, options));
}
/**
* Deletes all items in the Container with the specified partitionKey value.
* Starts an asynchronous Cosmos DB background operation which deletes all items in the Container with the specified value.
* The asynchronous Cosmos DB background operation runs using a percentage of user RUs.
*
* @param partitionKey the partition key.
* @param options the options.
* @return the Cosmos item response
*/
public CosmosItemResponse deleteAllItemsByPartitionKey(PartitionKey partitionKey, CosmosItemRequestOptions options) {
return this.blockDeleteItemResponse(asyncContainer.deleteAllItemsByPartitionKey(partitionKey, options));
}
/**
* Deletes an item in the current container.
*
* @param the type parameter.
* @param item the item to be deleted.
* @param options the options.
* @return the Cosmos item response.
*/
public CosmosItemResponse deleteItem(T item, CosmosItemRequestOptions options) {
return this.blockDeleteItemResponse(asyncContainer.deleteItem(item, options));
}
/**
* Executes the transactional batch.
*
* @param cosmosBatch Batch having list of operation and partition key which will be executed by this container.
*
* @return A TransactionalBatchResponse which contains details of execution of the transactional batch.
*
* If the transactional batch executes successfully, the value returned by {@link
* CosmosBatchResponse#getStatusCode} on the response returned will be set to 200}.
*
* If an operation within the transactional batch fails during execution, no changes from the batch will be
* committed and the status of the failing operation is made available by {@link
* CosmosBatchResponse#getStatusCode} or by the exception. To obtain information about the operations
* that failed in case of some user error like conflict, not found etc, the response can be enumerated.
* This returns {@link CosmosBatchOperationResult} instances corresponding to each operation in the
* transactional batch in the order they were added to the transactional batch.
* For a result corresponding to an operation within the transactional batch, use
* {@link CosmosBatchOperationResult#getStatusCode}
* to access the status of the operation. If the operation was not executed or it was aborted due to the failure of
* another operation within the transactional batch, the value of this field will be 424;
* for the operation that caused the batch to abort, the value of this field
* will indicate the cause of failure.
*
* If there are issues such as request timeouts, Gone, session not available, network failure
* or if the service somehow returns 5xx then this will throw an exception instead of returning a CosmosBatchResponse.
*
* Use {@link CosmosBatchResponse#isSuccessStatusCode} on the response returned to ensure that the
* transactional batch succeeded.
*/
public CosmosBatchResponse executeCosmosBatch(CosmosBatch cosmosBatch) {
return this.blockBatchResponse(asyncContainer.executeCosmosBatch(cosmosBatch));
}
/**
* Executes the transactional batch.
*
* @param cosmosBatch Batch having list of operation and partition key which will be executed by this container.
* @param requestOptions Options that apply specifically to batch request.
*
* @return A CosmosBatchResponse which contains details of execution of the transactional batch.
*
* If the transactional batch executes successfully, the value returned by {@link
* CosmosBatchResponse#getStatusCode} on the response returned will be set to 200}.
*
* If an operation within the transactional batch fails during execution, no changes from the batch will be
* committed and the status of the failing operation is made available by {@link
* CosmosBatchResponse#getStatusCode} or by the exception. To obtain information about the operations
* that failed in case of some user error like conflict, not found etc, the response can be enumerated.
* This returns {@link CosmosBatchOperationResult} instances corresponding to each operation in the
* transactional batch in the order they were added to the transactional batch.
* For a result corresponding to an operation within the transactional batch, use
* {@link CosmosBatchOperationResult#getStatusCode}
* to access the status of the operation. If the operation was not executed or it was aborted due to the failure of
* another operation within the transactional batch, the value of this field will be 424;
* for the operation that caused the batch to abort, the value of this field
* will indicate the cause of failure.
*
* If there are issues such as request timeouts, Gone, session not available, network failure
* or if the service somehow returns 5xx then this will throw an exception instead of returning a CosmosBatchResponse.
*
* Use {@link CosmosBatchResponse#isSuccessStatusCode} on the response returned to ensure that the
* transactional batch succeeded.
*/
public CosmosBatchResponse executeCosmosBatch(
CosmosBatch cosmosBatch,
CosmosBatchRequestOptions requestOptions) {
return this.blockBatchResponse(asyncContainer.executeCosmosBatch(cosmosBatch, requestOptions));
}
/**
* Executes list of operations in Bulk.
*
* @param The context for the bulk processing.
* @param operations list of operation which will be executed by this container.
*
* @return An Iterable of {@link CosmosBulkOperationResponse} which contains operation and it's response or exception.
*
* To create a operation which can be executed here, use {@link com.azure.cosmos.models.CosmosBulkOperations}. For eg.
* for a upsert operation use {@link com.azure.cosmos.models.CosmosBulkOperations#getUpsertItemOperation(Object, PartitionKey)}
*
*
* We can get the corresponding operation using {@link CosmosBulkOperationResponse#getOperation()} and
* it's response using {@link CosmosBulkOperationResponse#getResponse()}. If the operation was executed
* successfully, the value returned by {@link com.azure.cosmos.models.CosmosBulkItemResponse#isSuccessStatusCode()} will be true. To get
* actual status use {@link com.azure.cosmos.models.CosmosBulkItemResponse#getStatusCode()}.
*
* To check if the operation had any exception, use {@link CosmosBulkOperationResponse#getException()} to
* get the exception.
*/
public Iterable> executeBulkOperations(
Iterable operations) {
return this.blockBulkResponse(asyncContainer.executeBulkOperations(Flux.fromIterable(operations)));
}
/**
* Executes list of operations in Bulk.
*
* @param The context for the bulk processing.
*
* @param operations list of operation which will be executed by this container.
* @param bulkOptions Options that apply for this Bulk request which specifies options regarding execution like
* concurrency, batching size, interval and context.
*
* @return An Iterable of {@link CosmosBulkOperationResponse} which contains operation and it's response or exception.
*
* To create a operation which can be executed here, use {@link com.azure.cosmos.models.CosmosBulkOperations}. For eg.
* for a upsert operation use {@link com.azure.cosmos.models.CosmosBulkOperations#getUpsertItemOperation(Object, PartitionKey)}
*
*
* We can get the corresponding operation using {@link CosmosBulkOperationResponse#getOperation()} and
* it's response using {@link CosmosBulkOperationResponse#getResponse()}. If the operation was executed
* successfully, the value returned by {@link com.azure.cosmos.models.CosmosBulkItemResponse#isSuccessStatusCode()} will be true. To get
* actual status use {@link com.azure.cosmos.models.CosmosBulkItemResponse#getStatusCode()}.
*
* To check if the operation had any exception, use {@link CosmosBulkOperationResponse#getException()} to
* get the exception.
*/
public Iterable> executeBulkOperations(
Iterable operations,
CosmosBulkExecutionOptions bulkOptions) {
return this.blockBulkResponse(asyncContainer.executeBulkOperations(Flux.fromIterable(operations), bulkOptions));
}
/**
* Gets the Cosmos scripts using the current container as context.
*
* @return the Cosmos sync scripts.
*/
public CosmosScripts getScripts() {
if (this.scripts == null) {
this.scripts = new CosmosScripts(this, asyncContainer.getScripts());
}
return this.scripts;
}
// TODO: should make partitionkey public in CosmosAsyncItem and fix the below call
private CosmosPagedIterable getCosmosPagedIterable(CosmosPagedFlux cosmosPagedFlux) {
return new CosmosPagedIterable<>(cosmosPagedFlux);
}
/**
* Obtains a list of {@link FeedRange} that can be used to parallelize Feed
* operations.
*
*
*
* List<FeedRange> feedRanges = cosmosContainer.getFeedRanges();
* for (FeedRange feedRange : feedRanges) {
* System.out.println("Feed range: " + feedRange);
* }
*
*
* @return An unmodifiable list of {@link FeedRange}
*/
public List getFeedRanges() {
try {
return asyncContainer.getFeedRanges().block();
} catch (Exception ex) {
final Throwable throwable = Exceptions.unwrap(ex);
if (throwable instanceof CosmosException) {
throw (CosmosException) throwable;
} else {
throw ex;
}
}
}
/**
* Enable the throughput control group with local control mode.
*
*
*
* ThroughputControlGroupConfig groupConfig =
* new ThroughputControlGroupConfigBuilder()
* .groupName("localControlGroup")
* .targetThroughputThreshold(0.1)
* .build();
*
* container.enableLocalThroughputControlGroup(groupConfig);
*
*
*
* @param groupConfig A {@link GlobalThroughputControlConfig}.
*/
public void enableLocalThroughputControlGroup(ThroughputControlGroupConfig groupConfig) {
this.asyncContainer.enableLocalThroughputControlGroup(groupConfig);
}
/**
* Enable the throughput control group with global control mode.
* The defined throughput limit will be shared across different clients.
*
*
*
* ThroughputControlGroupConfig groupConfig =
* new ThroughputControlGroupConfigBuilder()
* .groupName("localControlGroup")
* .targetThroughputThreshold(0.1)
* .build();
*
* GlobalThroughputControlConfig globalControlConfig =
* this.client.createGlobalThroughputControlConfigBuilder(database.getId(), container.getId())
* .setControlItemRenewInterval(Duration.ofSeconds(5))
* .setControlItemExpireInterval(Duration.ofSeconds(10))
* .build();
*
* container.enableGlobalThroughputControlGroup(groupConfig, globalControlConfig);
*
*
*
* @param groupConfig The throughput control group configuration, see {@link GlobalThroughputControlGroup}.
* @param globalControlConfig The global throughput control configuration, see {@link GlobalThroughputControlConfig}.
*/
public void enableGlobalThroughputControlGroup(ThroughputControlGroupConfig groupConfig, GlobalThroughputControlConfig globalControlConfig) {
this.asyncContainer.enableGlobalThroughputControlGroup(groupConfig, globalControlConfig);
}
/**
* Initializes the container by warming up the caches and connections for the current read region.
*
*
*
*
* @deprecated use {@link CosmosClientBuilder#openConnectionsAndInitCaches(CosmosContainerProactiveInitConfig)} instead.
*
*/
@Deprecated
public void openConnectionsAndInitCaches() {
blockVoidResponse(this.asyncContainer.openConnectionsAndInitCaches());
}
/**
* Initializes the container by warming up the caches and connections to a specified no. of proactive connection regions.
* For more information about proactive connection regions, see {@link CosmosContainerProactiveInitConfig#getProactiveConnectionRegionsCount()}
*
*
*
*
* @param numProactiveConnectionRegions the no of regions to proactively connect to from the preferred list of regions
* @deprecated use {@link CosmosClientBuilder#openConnectionsAndInitCaches(CosmosContainerProactiveInitConfig)} instead.
*/
@Deprecated
public void openConnectionsAndInitCaches(int numProactiveConnectionRegions) {
blockVoidResponse(this.asyncContainer.openConnectionsAndInitCaches(numProactiveConnectionRegions));
}
private void blockVoidResponse(Mono voidMono) {
try {
voidMono.block();
} catch (Exception ex) {
// swallow exceptions here
logger.warn("The void flux did not complete successfully", ex);
}
}
}
