@InterfaceStability.Committed @InterfaceAudience.Public public interface AsyncBucket
Defines operations that can be executed asynchronously against a Couchbase Server bucket.
Note that only a subset of the provided operations are available for “memcached” type buckets. Also, some other operations are only available against specific versions of Couchbase Server.
Always apply a Observable.timeout(long, TimeUnit) of some form to add a boundary between the SDK as an integration point and the application. Networks are unreliable, servers can fail and the SDK contains bugs. With applying a timeout and reacting to them accordingly, application level code is less likely to fail.
| Modifier and Type | Method and Description |
|---|---|
<T> Observable<DocumentFragment<T>> |
addUniqueIn(DocumentFragment<T> fragment,
boolean createParents,
PersistTo persistTo,
ReplicateTo replicateTo)
Adds a value in an existing array inside a
JSON document provided said value isn’t already present in the array (as checked using string comparison). |
<D extends Document<?>> |
append(D document)
Append a
Documents content to an existing one. |
<D extends Document<?>> |
append(D document,
PersistTo persistTo)
Append a
Documents content to an existing one. |
<D extends Document<?>> |
append(D document,
PersistTo persistTo,
ReplicateTo replicateTo)
Append a
Documents content to an existing one. |
<D extends Document<?>> |
append(D document,
ReplicateTo replicateTo)
Append a
Documents content to an existing one. |
<T> Observable<DocumentFragment<T>> |
arrayInsertIn(DocumentFragment<T> fragment,
PersistTo persistTo,
ReplicateTo replicateTo)
Insert a value in an existing array inside a
JSON document, at a specific index as denoted by the path (eg. |
Observable<AsyncBucketManager> |
bucketManager()
Provides access to the
AsyncBucketManager for administrative access. |
Observable<Boolean> |
close()
Closes the
AsyncBucket. |
Observable<ClusterFacade> |
core()
Returns the underlying “core-io” library through its
ClusterFacade. |
Observable<JsonLongDocument> |
counter(String id,
long delta)
Increment or decrement a counter with the given value or throw an exception if it does not exist yet.
|
Observable<JsonLongDocument> |
counter(String id,
long delta,
long initial)
Increment or decrement a counter with the given value and a initial value if it does not exist.
|
Observable<JsonLongDocument> |
counter(String id,
long delta,
long initial,
int expiry)
Increment or decrement a counter with the given value and a initial value if it does not exist.
|
Observable<JsonLongDocument> |
counter(String id,
long delta,
long initial,
int expiry,
PersistTo persistTo)
Increment or decrement a counter with the given value and a initial value if it does not exist.
|
Observable<JsonLongDocument> |
counter(String id,
long delta,
long initial,
int expiry,
PersistTo persistTo,
ReplicateTo replicateTo)
Increment or decrement a counter with the given value and a initial value if it does not exist.
|
Observable<JsonLongDocument> |
counter(String id,
long delta,
long initial,
int expiry,
ReplicateTo replicateTo)
Increment or decrement a counter with the given value and a initial value if it does not exist.
|
Observable<JsonLongDocument> |
counter(String id,
long delta,
long initial,
PersistTo persistTo)
Increment or decrement a counter with the given value and a initial value if it does not exist.
|
Observable<JsonLongDocument> |
counter(String id,
long delta,
long initial,
PersistTo persistTo,
ReplicateTo replicateTo)
Increment or decrement a counter with the given value and a initial value if it does not exist.
|
Observable<JsonLongDocument> |
counter(String id,
long delta,
long initial,
ReplicateTo replicateTo)
Increment or decrement a counter with the given value and a initial value if it does not exist.
|
Observable<JsonLongDocument> |
counter(String id,
long delta,
PersistTo persistTo)
Increment or decrement a counter with the given value or throw an exception if it does not exist yet.
|
Observable<JsonLongDocument> |
counter(String id,
long delta,
PersistTo persistTo,
ReplicateTo replicateTo)
Increment or decrement a counter with the given value or throw an exception if it does not exist yet.
|
Observable<JsonLongDocument> |
counter(String id,
long delta,
ReplicateTo replicateTo)
Increment or decrement a counter with the given value or throw an exception if it does not exist yet.
|
Observable<DocumentFragment<Long>> |
counterIn(DocumentFragment<Long> fragment,
boolean createParents,
PersistTo persistTo,
ReplicateTo replicateTo)
Increment or decrement a numerical value inside an existing
JSON document. |
CouchbaseEnvironment |
environment()
The
CouchbaseEnvironment used. |
<D extends Document<?>> |
exists(D document)
Check whether a document with the given ID does exist in the bucket.
|
Observable<Boolean> |
exists(String id)
Check whether a document with the given ID does exist in the bucket.
|
Observable<Boolean> |
existsIn(String id,
String path)
Check for the existence of a path inside of a
JSON document. |
<T> Observable<DocumentFragment<T>> |
extendIn(DocumentFragment<T> fragment,
ExtendDirection direction,
boolean createParents,
PersistTo persistTo,
ReplicateTo replicateTo)
|
<D extends Document<?>> |
get(D document)
Retrieves any type of
Document by its unique ID. |
Observable<JsonDocument> |
get(String id)
Retrieves a
JsonDocument by its unique ID. |
<D extends Document<?>> |
get(String id,
Class<D> target)
Retrieves any type of
Document by its unique ID. |
<D extends Document<?>> |
getAndLock(D document,
int lockTime)
Retrieve and lock a
Document by its unique ID. |
Observable<JsonDocument> |
getAndLock(String id,
int lockTime)
Retrieve and lock a
JsonDocument by its unique ID. |
<D extends Document<?>> |
getAndLock(String id,
int lockTime,
Class<D> target)
Retrieve and lock a
Document by its unique ID. |
<D extends Document<?>> |
getAndTouch(D document)
Retrieve and touch a
Document by its unique ID. |
Observable<JsonDocument> |
getAndTouch(String id,
int expiry)
Retrieve and touch a
JsonDocument by its unique ID. |
<D extends Document<?>> |
getAndTouch(String id,
int expiry,
Class<D> target)
Retrieve and touch a
Document by its unique ID. |
<D extends Document<?>> |
getFromReplica(D document,
ReplicaMode type)
Retrieves one or more, possibly stale, representations of a
Document by its unique ID. |
Observable<JsonDocument> |
getFromReplica(String id,
ReplicaMode type)
Retrieves one or more, possibly stale, representations of a
JsonDocument by its unique ID. |
<D extends Document<?>> |
getFromReplica(String id,
ReplicaMode type,
Class<D> target)
Retrieves one or more, possibly stale, representations of a
Document by its unique ID. |
<T> Observable<DocumentFragment<T>> |
getIn(String id,
String path,
Class<T> fragmentType)
Retrieve a fragment of an existing
JSON document, as denoted by the given path. |
<D extends Document<?>> |
insert(D document)
Insert a
Document if it does not exist already. |
<D extends Document<?>> |
insert(D document,
PersistTo persistTo)
Insert a
Document if it does not exist already and watch for durability constraints. |
<D extends Document<?>> |
insert(D document,
PersistTo persistTo,
ReplicateTo replicateTo)
Insert a
Document if it does not exist already and watch for durability constraints. |
<D extends Document<?>> |
insert(D document,
ReplicateTo replicateTo)
Insert a
Document if it does not exist already and watch for durability constraints. |
<T> Observable<DocumentFragment<T>> |
insertIn(DocumentFragment<T> fragment,
boolean createParents,
PersistTo persistTo,
ReplicateTo replicateTo)
Insert a fragment of JSON into an existing
JSON document, on the condition that no value already exist at this location. |
Observable<Integer> |
invalidateQueryCache()
Invalidates and clears the internal query cache.
|
boolean |
isClosed()
Returns true if this bucket is already closed, false if it is still open.
|
Observable<MultiLookupResult> |
lookupIn(String id,
LookupSpec... lookupSpecs)
Perform several
lookup operations inside a single existing JSON document. |
String |
name()
The name of the
Bucket. |
<D extends Document<?>> |
prepend(D document)
Prepend a
Documents content to an existing one. |
<D extends Document<?>> |
prepend(D document,
PersistTo persistTo)
Prepend a
Documents content to an existing one. |
<D extends Document<?>> |
prepend(D document,
PersistTo persistTo,
ReplicateTo replicateTo)
Prepend a
Documents content to an existing one. |
<D extends Document<?>> |
prepend(D document,
ReplicateTo replicateTo)
Prepend a
Documents content to an existing one. |
Observable<AsyncN1qlQueryResult> |
query(N1qlQuery query)
Experimental: Queries a N1QL secondary index.
|
Observable<SearchQueryResult> |
query(SearchQuery query)
Experimental: Queries a Full-Text Index
|
Observable<AsyncSpatialViewResult> |
query(SpatialViewQuery query)
Queries a Couchbase Server Spatial
View. |
Observable<AsyncN1qlQueryResult> |
query(Statement statement)
Experimental: Queries a N1QL secondary index with a simple
Statement. |
Observable<AsyncViewResult> |
query(ViewQuery query)
Queries a Couchbase Server
View. |
<D extends Document<?>> |
remove(D document)
Removes a
Document from the Server. |
<D extends Document<?>> |
remove(D document,
PersistTo persistTo)
Removes a
Document from the Server and apply a durability requirement. |
<D extends Document<?>> |
remove(D document,
PersistTo persistTo,
ReplicateTo replicateTo)
Removes a
Document from the Server and apply a durability requirement. |
<D extends Document<?>> |
remove(D document,
ReplicateTo replicateTo)
Removes a
Document from the Server and apply a durability requirement. |
Observable<JsonDocument> |
remove(String id)
Removes a
Document from the Server identified by its ID. |
<D extends Document<?>> |
remove(String id,
Class<D> target)
Removes a
Document from the Server identified by its ID. |
Observable<JsonDocument> |
remove(String id,
PersistTo persistTo)
Removes a
Document from the Server by its ID and apply a durability requirement. |
<D extends Document<?>> |
remove(String id,
PersistTo persistTo,
Class<D> target)
Removes a
Document from the Server by its ID and apply a durability requirement. |
Observable<JsonDocument> |
remove(String id,
PersistTo persistTo,
ReplicateTo replicateTo)
Removes a
Document from the Server by its ID and apply a durability requirement. |
<D extends Document<?>> |
remove(String id,
PersistTo persistTo,
ReplicateTo replicateTo,
Class<D> target)
Removes a
Document from the Server by its ID and apply a durability requirement. |
Observable<JsonDocument> |
remove(String id,
ReplicateTo replicateTo)
Removes a
Document from the Server by its ID and apply a durability requirement. |
<D extends Document<?>> |
remove(String id,
ReplicateTo replicateTo,
Class<D> target)
Removes a
Document from the Server by its ID and apply a durability requirement. |
<T> Observable<DocumentFragment<T>> |
removeIn(DocumentFragment<T> fragment,
PersistTo persistTo,
ReplicateTo replicateTo)
Removes an entry from an existing
JSON document. |
<D extends Document<?>> |
replace(D document)
Replace a
Document if it does already exist. |
<D extends Document<?>> |
replace(D document,
PersistTo persistTo)
Replace a
Document if it does exist and watch for durability constraints. |
<D extends Document<?>> |
replace(D document,
PersistTo persistTo,
ReplicateTo replicateTo)
Replace a
Document if it does exist and watch for durability constraints. |
<D extends Document<?>> |
replace(D document,
ReplicateTo replicateTo)
Replace a
Document if it does exist and watch for durability constraints. |
<T> Observable<DocumentFragment<T>> |
replaceIn(DocumentFragment<T> fragment,
PersistTo persistTo,
ReplicateTo replicateTo)
Replace a fragment of JSON with another one inside an existing
JSON document. |
Observable<AsyncRepository> |
repository()
The
Repository provides access to full object document mapping (ODM) capabilities. |
<D extends Document<?>> |
touch(D document)
Renews the expiration time of a
Document. |
Observable<Boolean> |
touch(String id,
int expiry)
Renews the expiration time of a
Document. |
<D extends Document<?>> |
unlock(D document)
Unlocks a write-locked
Document. |
Observable<Boolean> |
unlock(String id,
long cas)
Unlocks a write-locked
Document. |
<D extends Document<?>> |
upsert(D document)
Insert or overwrite a
Document. |
<D extends Document<?>> |
upsert(D document,
PersistTo persistTo)
Insert or overwrite a
Document and watch for durability constraints. |
<D extends Document<?>> |
upsert(D document,
PersistTo persistTo,
ReplicateTo replicateTo)
Insert or overwrite a
Document and watch for durability constraints. |
<D extends Document<?>> |
upsert(D document,
ReplicateTo replicateTo)
Insert or overwrite a
Document and watch for durability constraints. |
<T> Observable<DocumentFragment<T>> |
upsertIn(DocumentFragment<T> fragment,
boolean createParents,
PersistTo persistTo,
ReplicateTo replicateTo)
Upsert a fragment of JSON into an existing
JSON document. |
CouchbaseEnvironment environment()
The CouchbaseEnvironment used.
Observable<ClusterFacade> core()
Returns the underlying “core-io” library through its ClusterFacade.
Handle with care, with great power comes great responsibility. All additional checks which are normally performed by this library are skipped.
ClusterFacade from the “core-io” package.Observable<JsonDocument> get(String id)
Retrieves a JsonDocument by its unique ID.
If the document is found, a JsonDocument is returned. If the document is not found, the Observable completes without an item emitted.
The returned Observable can error under the following conditions:
BackpressureExceptionRequestCancelledExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.id - the unique ID of the document.Observable eventually containing the found JsonDocument.<D extends Document<?>> Observable<D> get(D document)
Retrieves any type of Document by its unique ID.
The document ID is taken out of the Document provided, as well as the target type to return. Note that not the same document is returned, but rather a new one of the same type with the freshly loaded properties.
If the document is found, a Document is returned. If the document is not found, the Observable completes without an item emitted.
The returned Observable can error under the following conditions:
BackpressureExceptionRequestCancelledExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.document - the source document from which the ID is taken and the type is inferred.Observable eventually containing the found Document.<D extends Document<?>> Observable<D> get(String id, Class<D> target)
Retrieves any type of Document by its unique ID.
This method differs from get(String) in that if a specific Document type is passed in, the appropriate Transcoder will be selected (and not JSON conversion).
If the document is found, a Document is returned. If the document is not found, the Observable completes without an item emitted.
The returned Observable can error under the following conditions:
BackpressureExceptionRequestCancelledExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.id - the unique ID of the document.target - the target document type to use.Observable eventually containing the found Document.Observable<Boolean> exists(String id)
Check whether a document with the given ID does exist in the bucket.
The returned Observable can error under the following conditions:
BackpressureExceptionRequestCancelledExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.id - the id of the document.<D extends Document<?>> Observable<Boolean> exists(D document)
Check whether a document with the given ID does exist in the bucket.
The returned Observable can error under the following conditions:
BackpressureExceptionRequestCancelledExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.document - the document where the ID is extracted from.Observable<JsonDocument> getFromReplica(String id, ReplicaMode type)
Retrieves one or more, possibly stale, representations of a JsonDocument by its unique ID.
Depending on the ReplicaMode selected, there can be none to four JsonDocument be returned from the Observable. If ReplicaMode.FIRST, ReplicaMode.SECOND or ReplicaMode.THIRD are selected zero or one documents are returned, if ReplicaMode.ALL is used, all configured replicas plus the master node may return a document.
If the document has not been replicated yet or if the replica or master are not available (because a node has been failed over), no response is expected from these nodes.
Since data is replicated asynchronously, all data returned from this method must be considered stale. If the appropriate ReplicateTo constraints are set on write and the operation returns successfully, then the data can be considered as non-stale.
Note that the returning JsonDocument responses can come in any order.
Because this method is considered to be a “last resort” call against the database if a regular get didn’t succeed, all errors are swallowed (but logged) and the Observable will return all successful responses.
id - id the unique ID of the document.type - the ReplicaMode to select.Observable eventually containing zero to N JsonDocuments.<D extends Document<?>> Observable<D> getFromReplica(D document, ReplicaMode type)
Retrieves one or more, possibly stale, representations of a Document by its unique ID.
The document ID is taken out of the Document provided, as well as the target type to return. Note that not the same document is returned, but rather a new one of the same type with the freshly loaded properties.
Depending on the ReplicaMode selected, there can be none to four Document be returned from the Observable. If ReplicaMode.FIRST, ReplicaMode.SECOND or ReplicaMode.THIRD are selected zero or one documents are returned, if ReplicaMode.ALL is used, all configured replicas plus the master node may return a document.
If the document has not been replicated yet or if the replica or master are not available (because a node has been failed over), no response is expected from these nodes.
Since data is replicated asynchronously, all data returned from this method must be considered stale. If the appropriate ReplicateTo constraints are set on write and the operation returns successfully, then the data can be considered as non-stale.
Note that the returning Document responses can come in any order.
The returned Observable can error under the following conditions:
Because this method is considered to be a “last resort” call against the database if a regular get didn’t succeed, all errors are swallowed (but logged) and the Observable will return all successful responses.
document - the source document from which the ID is taken and the type is inferred.type - the ReplicaMode to select.Observable eventually containing zero to N Documents.<D extends Document<?>> Observable<D> getFromReplica(String id, ReplicaMode type, Class<D> target)
Retrieves one or more, possibly stale, representations of a Document by its unique ID.
This method differs from getFromReplica(String, ReplicaMode) in that if a specific Document type is passed in, the appropriate Transcoder will be selected (and not JSON conversion).
Depending on the ReplicaMode selected, there can be none to four Document be returned from the Observable. If ReplicaMode.FIRST, ReplicaMode.SECOND or ReplicaMode.THIRD are selected zero or one documents are returned, if ReplicaMode.ALL is used, all configured replicas plus the master node may return a document.
If the document has not been replicated yet or if the replica or master are not available (because a node has been failed over), no response is expected from these nodes.
Since data is replicated asynchronously, all data returned from this method must be considered stale. If the appropriate ReplicateTo constraints are set on write and the operation returns successfully, then the data can be considered as non-stale.
Note that the returning Document responses can come in any order.
The returned Observable can error under the following conditions:
Because this method is considered to be a “last resort” call against the database if a regular get didn’t succeed, all errors are swallowed (but logged) and the Observable will return all successful responses.
id - id the unique ID of the document.type - the ReplicaMode to select.target - the target document type to use.Observable eventually containing zero to N Documents.Observable<JsonDocument> getAndLock(String id, int lockTime)
Retrieve and lock a JsonDocument by its unique ID.
If the document is found, a JsonDocument is returned. If the document is not found, the Observable completes without an item emitted.
This method works similar to get(String), but in addition it (write) locks the document for the given lock time interval. Note that this lock time is hard capped to 30 seconds, even if provided with a higher value and is not configurable. The document will unlock afterwards automatically.
Detecting an already locked document is done by checking for TemporaryLockFailureException. Note that this exception can also be raised in other conditions, always when the error is transient and retrying may help.
The returned Observable can error under the following conditions:
TemporaryLockFailureExceptionBackpressureExceptionRequestCancelledExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.id - id the unique ID of the document.lockTime - the time to write lock the document (max. 30 seconds).Observable eventually containing the found JsonDocument.<D extends Document<?>> Observable<D> getAndLock(D document, int lockTime)
Retrieve and lock a Document by its unique ID.
If the document is found, a Document is returned. If the document is not found, the Observable completes without an item emitted.
This method works similar to get(Document), but in addition it (write) locks the document for the given lock time interval. Note that this lock time is hard capped to 30 seconds, even if provided with a higher value and is not configurable. The document will unlock afterwards automatically.
Detecting an already locked document is done by checking for TemporaryLockFailureException. Note that this exception can also be raised in other conditions, always when the error is transient and retrying may help.
The returned Observable can error under the following conditions:
TemporaryLockFailureExceptionBackpressureExceptionRequestCancelledExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.document - the source document from which the ID is taken and the type is inferred.lockTime - the time to write lock the document (max. 30 seconds).Observable eventually containing the found Document.<D extends Document<?>> Observable<D> getAndLock(String id, int lockTime, Class<D> target)
Retrieve and lock a Document by its unique ID.
This method differs from getAndLock(String, int) in that if a specific Document type is passed in, the appropriate Transcoder will be selected (and not JSON conversion).
If the document is found, a Document is returned. If the document is not found, the Observable completes without an item emitted.
This method works similar to get(String), but in addition it (write) locks the document for the given lock time interval. Note that this lock time is hard capped to 30 seconds, even if provided with a higher value and is not configurable. The document will unlock afterwards automatically.
Detecting an already locked document is done by checking for TemporaryLockFailureException. Note that this exception can also be raised in other conditions, always when the error is transient and retrying may help.
The returned Observable can error under the following conditions: - In case of transient error, most probably because key is already locked: TemporaryLockFailureException - The producer outpaces the SDK: BackpressureException - The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of retrying: RequestCancelledException - The server is currently not able to process the request, retrying may help: TemporaryFailureException - The server is out of memory: CouchbaseOutOfMemoryException - Unexpected errors are caught and contained in a generic CouchbaseException.
id - id the unique ID of the document.lockTime - the time to write lock the document (max. 30 seconds).target - the target document type to use.Observable eventually containing the found Document.Observable<JsonDocument> getAndTouch(String id, int expiry)
Retrieve and touch a JsonDocument by its unique ID.
If the document is found, a JsonDocument is returned. If the document is not found, the Observable completes without an item emitted.
This method works similar to get(String), but in addition it touches the document, which will reset its configured expiration time to the value provided.
The returned Observable can error under the following conditions:
BackpressureExceptionRequestCancelledExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.id - id the unique ID of the document.expiry - the new expiration time for the document.Observable eventually containing the found JsonDocument.<D extends Document<?>> Observable<D> getAndTouch(D document)
Retrieve and touch a Document by its unique ID.
If the document is found, a Document is returned. If the document is not found, the Observable completes without an item emitted.
This method works similar to get(Document), but in addition it touches the document, which will reset its configured expiration time set on the given document itself.
The returned Observable can error under the following conditions:
BackpressureExceptionRequestCancelledExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.document - the source document from which the ID and expiry is taken and the type is inferred.Observable eventually containing the found Document.<D extends Document<?>> Observable<D> getAndTouch(String id, int expiry, Class<D> target)
Retrieve and touch a Document by its unique ID.
This method differs from getAndTouch(String, int) in that if a specific Document type is passed in, the appropriate Transcoder will be selected (and not JSON conversion).
If the document is found, a JsonDocument is returned. If the document is not found, the Observable completes without an item emitted.
This method works similar to get(String, Class), but in addition it touches the document, which will reset its configured expiration time to the value provided.
The returned Observable can error under the following conditions:
BackpressureExceptionRequestCancelledExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.id - id the unique ID of the document.expiry - the new expiration time for the document.target - the target document type to use.Observable eventually containing the found Document.<D extends Document<?>> Observable<D> insert(D document)
Insert a Document if it does not exist already.
If the given Document (identified by its unique ID) already exists, the observable errors with a DocumentAlreadyExistsException. If the operation should also override the existing Document, upsert(Document) should be used instead. It will always either return a document or fail with an error.
The returned Document contains original properties, but has the refreshed CAS value set.
This operation will return successfully if the Document has been acknowledged in the managed cache layer on the master server node. If increased data durability is a concern, insert(Document, PersistTo, ReplicateTo) should be used instead.
The returned Observable can error under the following conditions:
BackpressureExceptionRequestCancelledExceptionDocumentAlreadyExistsExceptionRequestTooBigExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.document - the Document to insert.Observable eventually containing a new Document.<D extends Document<?>> Observable<D> insert(D document, PersistTo persistTo, ReplicateTo replicateTo)
Insert a Document if it does not exist already and watch for durability constraints.
This method works exactly like insert(Document), but afterwards watches the server states if the given durability constraints are met. If this is the case, a new document is returned which contains the original properties, but has the refreshed CAS value set.
The returned Observable can error under the following conditions:
BackpressureExceptionRequestCancelledExceptionDocumentAlreadyExistsExceptionRequestTooBigExceptionDurabilityException.TemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.A DurabilityException typically happens if the given amount of replicas needed to fulfill the durability constraint cannot be met because either the bucket does not have enough replicas configured or they are not available in a failover event. As an example, if one replica is configured and ReplicateTo.TWO is used, the observable is errored with a DurabilityException. The same can happen if one replica is configured, but one node has been failed over and not yet rebalanced (hence, on a subset of the partitions there is no replica available). It is important to understand that the original insert has already happened, so the actual insert and the watching for durability constraints are two separate tasks internally.
document - the Document to insert.persistTo - the persistence constraint to watch.replicateTo - the replication constraint to watch.Observable eventually containing a new Document.<D extends Document<?>> Observable<D> insert(D document, PersistTo persistTo)
Insert a Document if it does not exist already and watch for durability constraints.
This method works exactly like insert(Document), but afterwards watches the server states if the given durability constraints are met. If this is the case, a new document is returned which contains the original properties, but has the refreshed CAS value set.
The returned Observable can error under the following conditions:
BackpressureExceptionRequestCancelledExceptionDocumentAlreadyExistsExceptionRequestTooBigExceptionDurabilityException.TemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.A DurabilityException typically happens if the given amount of replicas needed to fulfill the durability constraint cannot be met because either the bucket does not have enough replicas configured or they are not available in a failover event. As an example, if one replica is configured and ReplicateTo.TWO is used, the observable is errored with a DurabilityException. The same can happen if one replica is configured, but one node has been failed over and not yet rebalanced (hence, on a subset of the partitions there is no replica available). It is important to understand that the original insert has already happened, so the actual insert and the watching for durability constraints are two separate tasks internally.
document - the Document to insert.persistTo - the persistence constraint to watch.Observable eventually containing a new Document.<D extends Document<?>> Observable<D> insert(D document, ReplicateTo replicateTo)
Insert a Document if it does not exist already and watch for durability constraints.
This method works exactly like insert(Document), but afterwards watches the server states if the given durability constraints are met. If this is the case, a new document is returned which contains the original properties, but has the refreshed CAS value set.
The returned Observable can error under the following conditions:
BackpressureExceptionRequestCancelledExceptionDocumentAlreadyExistsExceptionRequestTooBigExceptionDurabilityException.TemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.A DurabilityException typically happens if the given amount of replicas needed to fulfill the durability constraint cannot be met because either the bucket does not have enough replicas configured or they are not available in a failover event. As an example, if one replica is configured and ReplicateTo.TWO is used, the observable is errored with a DurabilityException. The same can happen if one replica is configured, but one node has been failed over and not yet rebalanced (hence, on a subset of the partitions there is no replica available). It is important to understand that the original insert has already happened, so the actual insert and the watching for durability constraints are two separate tasks internally.
document - the Document to insert.replicateTo - the replication constraint to watch.Observable eventually containing a new Document.<D extends Document<?>> Observable<D> upsert(D document)
Insert or overwrite a Document.
If the given Document (identified by its unique ID) already exists, it will be overridden by the current one. The returned Document contains original properties, but has the refreshed CAS value set.
Please note that this method will not use the Document.cas() for optimistic concurrency checks. If this behavior is needed, the replace(Document) method needs to be used.
This operation will return successfully if the Document has been acknowledged in the managed cache layer on the master server node. If increased data durability is a concern, upsert(Document, PersistTo, ReplicateTo) should be used instead.
The returned Observable can error under the following conditions:
BackpressureExceptionRequestCancelledExceptionRequestTooBigExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.document - the Document to upsert.Observable eventually containing a new Document.<D extends Document<?>> Observable<D> upsert(D document, PersistTo persistTo, ReplicateTo replicateTo)
Insert or overwrite a Document and watch for durability constraints.
This method works exactly like upsert(Document), but afterwards watches the server states if the given durability constraints are met. If this is the case, a new document is returned which contains the original properties, but has the refreshed CAS value set.
Please note that this method will not use the Document.cas() for optimistic concurrency checks. If this behavior is needed, the replace(Document, PersistTo, ReplicateTo) method needs to be used.
The returned Observable can error under the following conditions:
BackpressureExceptionRequestCancelledExceptionRequestTooBigExceptionDurabilityException.TemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.A DurabilityException typically happens if the given amount of replicas needed to fulfill the durability constraint cannot be met because either the bucket does not have enough replicas configured or they are not available in a failover event. As an example, if one replica is configured and ReplicateTo.TWO is used, the observable is errored with a DurabilityException. The same can happen if one replica is configured, but one node has been failed over and not yet rebalanced (hence, on a subset of the partitions there is no replica available). It is important to understand that the original upsert has already happened, so the actual upsert and the watching for durability constraints are two separate tasks internally.
document - the Document to upsert.persistTo - the persistence constraint to watch.replicateTo - the replication constraint to watch.Observable eventually containing a new Document.<D extends Document<?>> Observable<D> upsert(D document, PersistTo persistTo)
Insert or overwrite a Document and watch for durability constraints.
This method works exactly like upsert(Document), but afterwards watches the server states if the given durability constraints are met. If this is the case, a new document is returned which contains the original properties, but has the refreshed CAS value set.
Please note that this method will not use the Document.cas() for optimistic concurrency checks. If this behavior is needed, the replace(Document, PersistTo) method needs to be used.
The returned Observable can error under the following conditions:
BackpressureExceptionRequestCancelledExceptionRequestTooBigExceptionDurabilityException.TemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.A DurabilityException typically happens if the given amount of replicas needed to fulfill the durability constraint cannot be met because either the bucket does not have enough replicas configured or they are not available in a failover event. As an example, if one replica is configured and ReplicateTo.TWO is used, the observable is errored with a DurabilityException. The same can happen if one replica is configured, but one node has been failed over and not yet rebalanced (hence, on a subset of the partitions there is no replica available). It is important to understand that the original upsert has already happened, so the actual upsert and the watching for durability constraints are two separate tasks internally.
document - the Document to upsert.persistTo - the persistence constraint to watch.Observable eventually containing a new Document.<D extends Document<?>> Observable<D> upsert(D document, ReplicateTo replicateTo)
Insert or overwrite a Document and watch for durability constraints.
This method works exactly like upsert(Document), but afterwards watches the server states if the given durability constraints are met. If this is the case, a new document is returned which contains the original properties, but has the refreshed CAS value set.
Please note that this method will not use the Document.cas() for optimistic concurrency checks. If this behavior is needed, the replace(Document, ReplicateTo) method needs to be used.
The returned Observable can error under the following conditions:
BackpressureExceptionRequestCancelledExceptionRequestTooBigExceptionDurabilityException.TemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.A DurabilityException typically happens if the given amount of replicas needed to fulfill the durability constraint cannot be met because either the bucket does not have enough replicas configured or they are not available in a failover event. As an example, if one replica is configured and ReplicateTo.TWO is used, the observable is errored with a DurabilityException. The same can happen if one replica is configured, but one node has been failed over and not yet rebalanced (hence, on a subset of the partitions there is no replica available). It is important to understand that the original upsert has already happened, so the actual upsert and the watching for durability constraints are two separate tasks internally.
document - the Document to upsert.replicateTo - the replication constraint to watch.Observable eventually containing a new Document.<D extends Document<?>> Observable<D> replace(D document)
Replace a Document if it does already exist.
If the given Document (identified by its unique ID) does not exist already, the method errors with a DocumentDoesNotExistException. If the operation should also insert the Document, upsert(Document) should be used instead. It will always either return a document or fail with an error.
The returned Document contains original properties, but has the refreshed CAS value set.
This operation will return successfully if the Document has been acknowledged in the managed cache layer on the master server node. If increased data durability is a concern, replace(Document, PersistTo, ReplicateTo) should be used instead.
The returned Observable can error under the following conditions:
BackpressureExceptionRequestCancelledExceptionDocumentDoesNotExistExceptionRequestTooBigExceptionCASMismatchExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.document - the Document to replace.Observable eventually containing a new Document.<D extends Document<?>> Observable<D> replace(D document, PersistTo persistTo, ReplicateTo replicateTo)
Replace a Document if it does exist and watch for durability constraints.
This method works exactly like replace(Document), but afterwards watches the server states if the given durability constraints are met. If this is the case, a new document is returned which contains the original properties, but has the refreshed CAS value set.
The returned Observable can error under the following conditions:
BackpressureExceptionRequestCancelledExceptionDocumentDoesNotExistExceptionRequestTooBigExceptionDurabilityException.CASMismatchExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.A DurabilityException typically happens if the given amount of replicas needed to fulfill the durability constraint cannot be met because either the bucket does not have enough replicas configured or they are not available in a failover event. As an example, if one replica is configured and ReplicateTo.TWO is used, the observable is errored with a DurabilityException. The same can happen if one replica is configured, but one node has been failed over and not yet rebalanced (hence, on a subset of the partitions there is no replica available). It is important to understand that the original replace has already happened, so the actual replace and the watching for durability constraints are two separate tasks internally.
document - the Document to replace.persistTo - the persistence constraint to watch.replicateTo - the replication constraint to watch.Observable eventually containing a new Document.<D extends Document<?>> Observable<D> replace(D document, PersistTo persistTo)
Replace a Document if it does exist and watch for durability constraints.
This method works exactly like replace(Document), but afterwards watches the server states if the given durability constraints are met. If this is the case, a new document is returned which contains the original properties, but has the refreshed CAS value set.
The returned Observable can error under the following conditions:
BackpressureExceptionRequestCancelledExceptionDocumentDoesNotExistExceptionRequestTooBigExceptionDurabilityException.CASMismatchExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.A DurabilityException typically happens if the given amount of replicas needed to fulfill the durability constraint cannot be met because either the bucket does not have enough replicas configured or they are not available in a failover event. As an example, if one replica is configured and ReplicateTo.TWO is used, the observable is errored with a DurabilityException. The same can happen if one replica is configured, but one node has been failed over and not yet rebalanced (hence, on a subset of the partitions there is no replica available). It is important to understand that the original replace has already happened, so the actual replace and the watching for durability constraints are two separate tasks internally.
document - the Document to replace.persistTo - the persistence constraint to watch.Observable eventually containing a new Document.<D extends Document<?>> Observable<D> replace(D document, ReplicateTo replicateTo)
Replace a Document if it does exist and watch for durability constraints.
This method works exactly like replace(Document), but afterwards watches the server states if the given durability constraints are met. If this is the case, a new document is returned which contains the original properties, but has the refreshed CAS value set.
The returned Observable can error under the following conditions:
BackpressureExceptionRequestCancelledExceptionDocumentDoesNotExistExceptionRequestTooBigExceptionDurabilityException.CASMismatchExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.A DurabilityException typically happens if the given amount of replicas needed to fulfill the durability constraint cannot be met because either the bucket does not have enough replicas configured or they are not available in a failover event. As an example, if one replica is configured and ReplicateTo.TWO is used, the observable is errored with a DurabilityException. The same can happen if one replica is configured, but one node has been failed over and not yet rebalanced (hence, on a subset of the partitions there is no replica available). It is important to understand that the original replace has already happened, so the actual replace and the watching for durability constraints are two separate tasks internally.
document - the Document to replace.replicateTo - the replication constraint to watch.Observable eventually containing a new Document.<D extends Document<?>> Observable<D> remove(D document)
Removes a Document from the Server.
The Document returned just has the document ID and its CAS value set, since the value and all other associated properties have been removed from the server.
The returned Observable can error under the following conditions:
BackpressureExceptionRequestCancelledExceptionDocumentDoesNotExistExceptionDocument and it did not match with the server: CASMismatchExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.document - the document to remove, with the ID extracted.<D extends Document<?>> Observable<D> remove(D document, PersistTo persistTo, ReplicateTo replicateTo)
Removes a Document from the Server and apply a durability requirement.
The Document returned just has the document ID and its CAS value set, since the value and all other associated properties have been removed from the server.
The returned Observable can error under the following conditions:
BackpressureExceptionRequestCancelledExceptionDurabilityException.DocumentDoesNotExistExceptionDocument and it did not match with the server: CASMismatchExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.document - the document to remove, with the ID extracted.persistTo - the persistence constraint to watch.replicateTo - the replication constraint to watch.<D extends Document<?>> Observable<D> remove(D document, PersistTo persistTo)
Removes a Document from the Server and apply a durability requirement.
The Document returned just has the document ID and its CAS value set, since the value and all other associated properties have been removed from the server.
The returned Observable can error under the following conditions:
BackpressureExceptionRequestCancelledExceptionDurabilityException.DocumentDoesNotExistExceptionDocument and it did not match with the server: CASMismatchExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.document - the document to remove, with the ID extracted.persistTo - the persistence constraint to watch.<D extends Document<?>> Observable<D> remove(D document, ReplicateTo replicateTo)
Removes a Document from the Server and apply a durability requirement.
The Document returned just has the document ID and its CAS value set, since the value and all other associated properties have been removed from the server.
The returned Observable can error under the following conditions:
BackpressureExceptionRequestCancelledExceptionDurabilityException.DocumentDoesNotExistExceptionDocument and it did not match with the server: CASMismatchExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.document - the document to remove, with the ID extracted.replicateTo - the replication constraint to watch.Observable<JsonDocument> remove(String id)
Removes a Document from the Server identified by its ID.
The Document returned just has the document ID and its CAS value set, since the value and all other associated properties have been removed from the server.
The returned Observable can error under the following conditions:
BackpressureExceptionRequestCancelledExceptionDocumentDoesNotExistExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.id - the id of the document to remove.Observable<JsonDocument> remove(String id, PersistTo persistTo, ReplicateTo replicateTo)
Removes a Document from the Server by its ID and apply a durability requirement.
The Document returned just has the document ID and its CAS value set, since the value and all other associated properties have been removed from the server.
The returned Observable can error under the following conditions:
BackpressureExceptionRequestCancelledExceptionDocumentDoesNotExistExceptionDurabilityException.TemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.id - the id of the document to remove.persistTo - the persistence constraint to watch.replicateTo - the replication constraint to watch.Observable<JsonDocument> remove(String id, PersistTo persistTo)
Removes a Document from the Server by its ID and apply a durability requirement.
The Document returned just has the document ID and its CAS value set, since the value and all other associated properties have been removed from the server.
The returned Observable can error under the following conditions:
BackpressureExceptionRequestCancelledExceptionDocumentDoesNotExistExceptionDurabilityException.TemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.id - the id of the document to remove.persistTo - the persistence constraint to watch.Observable<JsonDocument> remove(String id, ReplicateTo replicateTo)
Removes a Document from the Server by its ID and apply a durability requirement.
The Document returned just has the document ID and its CAS value set, since the value and all other associated properties have been removed from the server.
The returned Observable can error under the following conditions:
BackpressureExceptionRequestCancelledExceptionDocumentDoesNotExistExceptionDurabilityException.TemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.id - the id of the document to remove.replicateTo - the replication constraint to watch.<D extends Document<?>> Observable<D> remove(String id, Class<D> target)
Removes a Document from the Server identified by its ID.
The Document returned just has the document ID and its CAS value set, since the value and all other associated properties have been removed from the server.
The returned Observable can error under the following conditions:
BackpressureExceptionRequestCancelledExceptionDocumentDoesNotExistExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.id - the id of the document to remove.target - the target document type to use.<D extends Document<?>> Observable<D> remove(String id, PersistTo persistTo, ReplicateTo replicateTo, Class<D> target)
Removes a Document from the Server by its ID and apply a durability requirement.
The Document returned just has the document ID and its CAS value set, since the value and all other associated properties have been removed from the server.
The returned Observable can error under the following conditions:
BackpressureExceptionRequestCancelledExceptionDurabilityException.DocumentDoesNotExistExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.id - the id of the document to remove.persistTo - the persistence constraint to watch.replicateTo - the replication constraint to watch.target - the target document type to use.<D extends Document<?>> Observable<D> remove(String id, PersistTo persistTo, Class<D> target)
Removes a Document from the Server by its ID and apply a durability requirement.
The Document returned just has the document ID and its CAS value set, since the value and all other associated properties have been removed from the server.
The returned Observable can error under the following conditions:
BackpressureExceptionRequestCancelledExceptionDurabilityException.DocumentDoesNotExistExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.id - the id of the document to remove.persistTo - the persistence constraint to watch.target - the target document type to use.<D extends Document<?>> Observable<D> remove(String id, ReplicateTo replicateTo, Class<D> target)
Removes a Document from the Server by its ID and apply a durability requirement.
The Document returned just has the document ID and its CAS value set, since the value and all other associated properties have been removed from the server.
The returned Observable can error under the following conditions:
BackpressureExceptionRequestCancelledExceptionDurabilityException.DocumentDoesNotExistExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.id - the id of the document to remove.replicateTo - the replication constraint to watch.target - the target document type to use.Observable<AsyncViewResult> query(ViewQuery query)
Queries a Couchbase Server View.
The returned Observable can error under the following conditions:
BackpressureExceptionRequestCancelledExceptionViewDoesNotExistExceptionquery - the query to perform.Observable<AsyncSpatialViewResult> query(SpatialViewQuery query)
Queries a Couchbase Server Spatial View.
The returned Observable can error under the following conditions:
BackpressureExceptionRequestCancelledExceptionViewDoesNotExistExceptionquery - the spatial query to perform.Observable<AsyncN1qlQueryResult> query(Statement statement)
Experimental: Queries a N1QL secondary index with a simple Statement.
The returned Observable can error under the following conditions:
BackpressureExceptionRequestCancelledExceptionstatement - the statement in a DSL form (start with a static select() import).Observable<AsyncN1qlQueryResult> query(N1qlQuery query)
Experimental: Queries a N1QL secondary index.
The returned Observable can error under the following conditions:
BackpressureExceptionRequestCancelledExceptionquery - the full N1qlQuery.@InterfaceStability.Experimental Observable<SearchQueryResult> query(SearchQuery query)
Experimental: Queries a Full-Text Index
The returned Observable can error under the following conditions:
BackpressureExceptionRequestCancelledExceptionquery - the query builder.Observable<Boolean> unlock(String id, long cas)
Unlocks a write-locked Document.
The returned Observable can error under the following conditions:
TemporaryLockFailureExceptionBackpressureExceptionRequestCancelledExceptionDocumentDoesNotExistExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.id - the id of the document to unlock.cas - the CAS value which is mandatory to unlock it.<D extends Document<?>> Observable<Boolean> unlock(D document)
Unlocks a write-locked Document.
The returned Observable can error under the following conditions:
DocumentDoesNotExistExceptionTemporaryLockFailureExceptionBackpressureExceptionRequestCancelledExceptionDocumentDoesNotExistExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.document - the document where ID and CAS are extracted from.Observable<Boolean> touch(String id, int expiry)
Renews the expiration time of a Document.
Compared to getAndTouch(Document), this method does not actually fetch the document from the server, but it just resets its expiration time to the given value.
The returned Observable can error under the following conditions:
DocumentDoesNotExistExceptionBackpressureExceptionRequestCancelledExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.id - the id of the document.expiry - the new expiration time. 0 means no expiry.<D extends Document<?>> Observable<Boolean> touch(D document)
Renews the expiration time of a Document.
Compared to getAndTouch(Document), this method does not actually fetch the document from the server, but it just resets its expiration time to the given value.
The returned Observable can error under the following conditions:
BackpressureExceptionRequestCancelledExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.document - the document to extract the ID and expiry from.Observable<JsonLongDocument> counter(String id, long delta)
Increment or decrement a counter with the given value or throw an exception if it does not exist yet.
It is not allowed that the delta value will bring the actual value below zero.
The returned Observable can error under the following conditions:
BackpressureExceptionRequestCancelledExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionDocumentDoesNotExistException.CouchbaseException.id - the id of the document.delta - the increment or decrement amount.Document containing the resulting value.Observable<JsonLongDocument> counter(String id, long delta, PersistTo persistTo)
Increment or decrement a counter with the given value or throw an exception if it does not exist yet.
It is not allowed that the delta value will bring the actual value below zero.
The returned Observable can error under the following conditions:
BackpressureExceptionRequestCancelledExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionDurabilityException.DocumentDoesNotExistException.CouchbaseException.A DurabilityException typically happens if the given amount of replicas needed to fulfill the durability constraint cannot be met because either the bucket does not have enough replicas configured or they are not available in a failover event. As an example, if one replica is configured and ReplicateTo.TWO is used, the observable is errored with a DurabilityException. The same can happen if one replica is configured, but one node has been failed over and not yet rebalanced (hence, on a subset of the partitions there is no replica available). It is important to understand that the original increment/decrement has already happened, so the actual increment/decrement and the watching for durability constraints are two separate tasks internally.
id - the id of the document.delta - the increment or decrement amount.persistTo - the persistence constraint to watch.Document containing the resulting value.Observable<JsonLongDocument> counter(String id, long delta, ReplicateTo replicateTo)
Increment or decrement a counter with the given value or throw an exception if it does not exist yet.
It is not allowed that the delta value will bring the actual value below zero.
The returned Observable can error under the following conditions:
BackpressureExceptionRequestCancelledExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionDurabilityException.DocumentDoesNotExistException.CouchbaseException.A DurabilityException typically happens if the given amount of replicas needed to fulfill the durability constraint cannot be met because either the bucket does not have enough replicas configured or they are not available in a failover event. As an example, if one replica is configured and ReplicateTo.TWO is used, the observable is errored with a DurabilityException. The same can happen if one replica is configured, but one node has been failed over and not yet rebalanced (hence, on a subset of the partitions there is no replica available). It is important to understand that the original increment/decrement has already happened, so the actual increment/decrement and the watching for durability constraints are two separate tasks internally.
id - the id of the document.delta - the increment or decrement amount.replicateTo - the replication constraint to watch.Document containing the resulting value.Observable<JsonLongDocument> counter(String id, long delta, PersistTo persistTo, ReplicateTo replicateTo)
Increment or decrement a counter with the given value or throw an exception if it does not exist yet.
It is not allowed that the delta value will bring the actual value below zero.
The returned Observable can error under the following conditions:
BackpressureExceptionRequestCancelledExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionDurabilityException.DocumentDoesNotExistException.CouchbaseException.A DurabilityException typically happens if the given amount of replicas needed to fulfill the durability constraint cannot be met because either the bucket does not have enough replicas configured or they are not available in a failover event. As an example, if one replica is configured and ReplicateTo.TWO is used, the observable is errored with a DurabilityException. The same can happen if one replica is configured, but one node has been failed over and not yet rebalanced (hence, on a subset of the partitions there is no replica available). It is important to understand that the original increment/decrement has already happened, so the actual increment/decrement and the watching for durability constraints are two separate tasks internally.
id - the id of the document.delta - the increment or decrement amount.persistTo - the persistence constraint to watch.replicateTo - the replication constraint to watch.Document containing the resulting value.Observable<JsonLongDocument> counter(String id, long delta, long initial)
Increment or decrement a counter with the given value and a initial value if it does not exist.
It is not allowed that the delta value will bring the actual value below zero.
The returned Observable can error under the following conditions:
BackpressureExceptionRequestCancelledExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.id - the id of the document.delta - the increment or decrement amount.initial - the initial value to use if the document does not exist yet.Document containing the resulting value.Observable<JsonLongDocument> counter(String id, long delta, long initial, PersistTo persistTo)
Increment or decrement a counter with the given value and a initial value if it does not exist.
It is not allowed that the delta value will bring the actual value below zero.
The returned Observable can error under the following conditions:
BackpressureExceptionRequestCancelledExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionDurabilityException.CouchbaseException.A DurabilityException typically happens if the given amount of replicas needed to fulfill the durability constraint cannot be met because either the bucket does not have enough replicas configured or they are not available in a failover event. As an example, if one replica is configured and ReplicateTo.TWO is used, the observable is errored with a DurabilityException. The same can happen if one replica is configured, but one node has been failed over and not yet rebalanced (hence, on a subset of the partitions there is no replica available). It is important to understand that the original increment/decrement has already happened, so the actual increment/decrement and the watching for durability constraints are two separate tasks internally.
id - the id of the document.delta - the increment or decrement amount.initial - the initial value to use if the document does not exist yet.persistTo - the persistence constraint to watch.Document containing the resulting value.Observable<JsonLongDocument> counter(String id, long delta, long initial, ReplicateTo replicateTo)
Increment or decrement a counter with the given value and a initial value if it does not exist.
It is not allowed that the delta value will bring the actual value below zero.
The returned Observable can error under the following conditions:
BackpressureExceptionRequestCancelledExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionDurabilityException.CouchbaseException.A DurabilityException typically happens if the given amount of replicas needed to fulfill the durability constraint cannot be met because either the bucket does not have enough replicas configured or they are not available in a failover event. As an example, if one replica is configured and ReplicateTo.TWO is used, the observable is errored with a DurabilityException. The same can happen if one replica is configured, but one node has been failed over and not yet rebalanced (hence, on a subset of the partitions there is no replica available). It is important to understand that the original increment/decrement has already happened, so the actual increment/decrement and the watching for durability constraints are two separate tasks internally.
id - the id of the document.delta - the increment or decrement amount.initial - the initial value to use if the document does not exist yet.replicateTo - the replication constraint to watch.Document containing the resulting value.Observable<JsonLongDocument> counter(String id, long delta, long initial, PersistTo persistTo, ReplicateTo replicateTo)
Increment or decrement a counter with the given value and a initial value if it does not exist.
It is not allowed that the delta value will bring the actual value below zero.
The returned Observable can error under the following conditions:
BackpressureExceptionRequestCancelledExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionDurabilityException.CouchbaseException.A DurabilityException typically happens if the given amount of replicas needed to fulfill the durability constraint cannot be met because either the bucket does not have enough replicas configured or they are not available in a failover event. As an example, if one replica is configured and ReplicateTo.TWO is used, the observable is errored with a DurabilityException. The same can happen if one replica is configured, but one node has been failed over and not yet rebalanced (hence, on a subset of the partitions there is no replica available). It is important to understand that the original increment/decrement has already happened, so the actual increment/decrement and the watching for durability constraints are two separate tasks internally.
id - the id of the document.delta - the increment or decrement amount.initial - the initial value to use if the document does not exist yet.persistTo - the persistence constraint to watch.replicateTo - the replication constraint to watch.Document containing the resulting value.Observable<JsonLongDocument> counter(String id, long delta, long initial, int expiry)
Increment or decrement a counter with the given value and a initial value if it does not exist.
This method allows to set an expiration time for the document as well. It is not allowed that the delta value will bring the actual value below zero.
The returned Observable can error under the following conditions:
BackpressureExceptionRequestCancelledExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.id - the id of the document.delta - the increment or decrement amount.initial - the initial value to use if the document does not exist yet.expiry - the new expiration time for the document.Document containing the resulting value.Observable<JsonLongDocument> counter(String id, long delta, long initial, int expiry, PersistTo persistTo)
Increment or decrement a counter with the given value and a initial value if it does not exist.
This method allows to set an expiration time for the document as well. It is not allowed that the delta value will bring the actual value below zero.
The returned Observable can error under the following conditions:
BackpressureExceptionRequestCancelledExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionDurabilityException.CouchbaseException.A DurabilityException typically happens if the given amount of replicas needed to fulfill the durability constraint cannot be met because either the bucket does not have enough replicas configured or they are not available in a failover event. As an example, if one replica is configured and ReplicateTo.TWO is used, the observable is errored with a DurabilityException. The same can happen if one replica is configured, but one node has been failed over and not yet rebalanced (hence, on a subset of the partitions there is no replica available). It is important to understand that the original increment/decrement has already happened, so the actual increment/decrement and the watching for durability constraints are two separate tasks internally.
id - the id of the document.delta - the increment or decrement amount.initial - the initial value to use if the document does not exist yet.expiry - the new expiration time for the document.persistTo - the persistence constraint to watch.Document containing the resulting value.Observable<JsonLongDocument> counter(String id, long delta, long initial, int expiry, ReplicateTo replicateTo)
Increment or decrement a counter with the given value and a initial value if it does not exist.
This method allows to set an expiration time for the document as well. It is not allowed that the delta value will bring the actual value below zero.
The returned Observable can error under the following conditions:
BackpressureExceptionRequestCancelledExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionDurabilityException.CouchbaseException.A DurabilityException typically happens if the given amount of replicas needed to fulfill the durability constraint cannot be met because either the bucket does not have enough replicas configured or they are not available in a failover event. As an example, if one replica is configured and ReplicateTo.TWO is used, the observable is errored with a DurabilityException. The same can happen if one replica is configured, but one node has been failed over and not yet rebalanced (hence, on a subset of the partitions there is no replica available). It is important to understand that the original increment/decrement has already happened, so the actual increment/decrement and the watching for durability constraints are two separate tasks internally.
id - the id of the document.delta - the increment or decrement amount.initial - the initial value to use if the document does not exist yet.expiry - the new expiration time for the document.replicateTo - the replication constraint to watch.Document containing the resulting value.Observable<JsonLongDocument> counter(String id, long delta, long initial, int expiry, PersistTo persistTo, ReplicateTo replicateTo)
Increment or decrement a counter with the given value and a initial value if it does not exist.
This method allows to set an expiration time for the document as well. It is not allowed that the delta value will bring the actual value below zero.
The returned Observable can error under the following conditions:
BackpressureExceptionRequestCancelledExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionDurabilityException.CouchbaseException.A DurabilityException typically happens if the given amount of replicas needed to fulfill the durability constraint cannot be met because either the bucket does not have enough replicas configured or they are not available in a failover event. As an example, if one replica is configured and ReplicateTo.TWO is used, the observable is errored with a DurabilityException. The same can happen if one replica is configured, but one node has been failed over and not yet rebalanced (hence, on a subset of the partitions there is no replica available). It is important to understand that the original increment/decrement has already happened, so the actual increment/decrement and the watching for durability constraints are two separate tasks internally.
id - the id of the document.delta - the increment or decrement amount.initial - the initial value to use if the document does not exist yet.expiry - the new expiration time for the document.persistTo - the persistence constraint to watch.replicateTo - the replication constraint to watch.Document containing the resulting value.<D extends Document<?>> Observable<D> append(D document)
Append a Documents content to an existing one.
The Document returned explicitly has the Document.content() set to null, because the server does not return the appended result, so at this point the client does not know how the Document now looks like. A separate get(Document) call needs to be issued in order to get the full current content.
If the Document does not exist, it needs to be created upfront. Note that JsonDocuments in all forms are not supported, it is advised that the following ones are used:
Note that this method does not support expiration on the Document. If set, it will be ignored.
The returned Observable can error under the following conditions:
BackpressureExceptionRequestCancelledExceptionRequestTooBigExceptionDocumentDoesNotExistExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.document - the document, identified by its id, from which the content is appended to the existing one.<D extends Document<?>> Observable<D> append(D document, PersistTo persistTo)
Append a Documents content to an existing one.
The Document returned explicitly has the Document.content() set to null, because the server does not return the appended result, so at this point the client does not know how the Document now looks like. A separate get(Document) call needs to be issued in order to get the full current content.
If the Document does not exist, it needs to be created upfront. Note that JsonDocuments in all forms are not supported, it is advised that the following ones are used:
Note that this method does not support expiration on the Document. If set, it will be ignored.
The returned Observable can error under the following conditions:
BackpressureExceptionRequestCancelledExceptionRequestTooBigExceptionDocumentDoesNotExistExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionDurabilityException.CouchbaseException.A DurabilityException typically happens if the given amount of replicas needed to fulfill the durability constraint cannot be met because either the bucket does not have enough replicas configured or they are not available in a failover event. As an example, if one replica is configured and ReplicateTo.TWO is used, the observable is errored with a DurabilityException. The same can happen if one replica is configured, but one node has been failed over and not yet rebalanced (hence, on a subset of the partitions there is no replica available). It is important to understand that the original append has already happened, so the actual append and the watching for durability constraints are two separate tasks internally.
document - the document, identified by its id, from which the content is appended to the existing one.persistTo - the persistence constraint to watch.<D extends Document<?>> Observable<D> append(D document, ReplicateTo replicateTo)
Append a Documents content to an existing one.
The Document returned explicitly has the Document.content() set to null, because the server does not return the appended result, so at this point the client does not know how the Document now looks like. A separate get(Document) call needs to be issued in order to get the full current content.
If the Document does not exist, it needs to be created upfront. Note that JsonDocuments in all forms are not supported, it is advised that the following ones are used:
Note that this method does not support expiration on the Document. If set, it will be ignored.
The returned Observable can error under the following conditions:
BackpressureExceptionRequestCancelledExceptionRequestTooBigExceptionDocumentDoesNotExistExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionDurabilityException.CouchbaseException.A DurabilityException typically happens if the given amount of replicas needed to fulfill the durability constraint cannot be met because either the bucket does not have enough replicas configured or they are not available in a failover event. As an example, if one replica is configured and ReplicateTo.TWO is used, the observable is errored with a DurabilityException. The same can happen if one replica is configured, but one node has been failed over and not yet rebalanced (hence, on a subset of the partitions there is no replica available). It is important to understand that the original append has already happened, so the actual append and the watching for durability constraints are two separate tasks internally.
document - the document, identified by its id, from which the content is appended to the existing one.replicateTo - the replication constraint to watch.<D extends Document<?>> Observable<D> append(D document, PersistTo persistTo, ReplicateTo replicateTo)
Append a Documents content to an existing one.
The Document returned explicitly has the Document.content() set to null, because the server does not return the appended result, so at this point the client does not know how the Document now looks like. A separate get(Document) call needs to be issued in order to get the full current content.
If the Document does not exist, it needs to be created upfront. Note that JsonDocuments in all forms are not supported, it is advised that the following ones are used:
Note that this method does not support expiration on the Document. If set, it will be ignored.
The returned Observable can error under the following conditions:
BackpressureExceptionRequestCancelledExceptionRequestTooBigExceptionDocumentDoesNotExistExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionDurabilityException.CouchbaseException.A DurabilityException typically happens if the given amount of replicas needed to fulfill the durability constraint cannot be met because either the bucket does not have enough replicas configured or they are not available in a failover event. As an example, if one replica is configured and ReplicateTo.TWO is used, the observable is errored with a DurabilityException. The same can happen if one replica is configured, but one node has been failed over and not yet rebalanced (hence, on a subset of the partitions there is no replica available). It is important to understand that the original append has already happened, so the actual append and the watching for durability constraints are two separate tasks internally.
document - the document, identified by its id, from which the content is appended to the existing one.persistTo - the persistence constraint to watch.replicateTo - the replication constraint to watch.<D extends Document<?>> Observable<D> prepend(D document)
Prepend a Documents content to an existing one.
The Document returned explicitly has the Document.content() set to null, because the server does not return the prepended result, so at this point the client does not know how the Document now looks like. A separate get(Document) call needs to be issued in order to get the full current content.
If the Document does not exist, it needs to be created upfront. Note that JsonDocuments in all forms are not supported, it is advised that the following ones are used:
Note that this method does not support expiration on the Document. If set, it will be ignored.
The returned Observable can error under the following conditions:
BackpressureExceptionRequestCancelledExceptionRequestTooBigExceptionDocumentDoesNotExistExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.document - the document, identified by its id, from which the content is prepended to the existing one.<D extends Document<?>> Observable<D> prepend(D document, PersistTo persistTo)
Prepend a Documents content to an existing one.
The Document returned explicitly has the Document.content() set to null, because the server does not return the prepended result, so at this point the client does not know how the Document now looks like. A separate get(Document) call needs to be issued in order to get the full current content.
If the Document does not exist, it needs to be created upfront. Note that JsonDocuments in all forms are not supported, it is advised that the following ones are used:
Note that this method does not support expiration on the Document. If set, it will be ignored.
The returned Observable can error under the following conditions:
BackpressureExceptionRequestCancelledExceptionRequestTooBigExceptionDocumentDoesNotExistExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionDurabilityException.CouchbaseException.A DurabilityException typically happens if the given amount of replicas needed to fulfill the durability constraint cannot be met because either the bucket does not have enough replicas configured or they are not available in a failover event. As an example, if one replica is configured and ReplicateTo.TWO is used, the observable is errored with a DurabilityException. The same can happen if one replica is configured, but one node has been failed over and not yet rebalanced (hence, on a subset of the partitions there is no replica available). It is important to understand that the original prepend has already happened, so the actual prepend and the watching for durability constraints are two separate tasks internally.
document - the document, identified by its id, from which the content is prepended to the existing one.persistTo - the persistence constraint to watch.<D extends Document<?>> Observable<D> prepend(D document, ReplicateTo replicateTo)
Prepend a Documents content to an existing one.
The Document returned explicitly has the Document.content() set to null, because the server does not return the prepended result, so at this point the client does not know how the Document now looks like. A separate get(Document) call needs to be issued in order to get the full current content.
If the Document does not exist, it needs to be created upfront. Note that JsonDocuments in all forms are not supported, it is advised that the following ones are used:
Note that this method does not support expiration on the Document. If set, it will be ignored.
The returned Observable can error under the following conditions:
BackpressureExceptionRequestCancelledExceptionRequestTooBigExceptionDocumentDoesNotExistExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionDurabilityException.CouchbaseException.A DurabilityException typically happens if the given amount of replicas needed to fulfill the durability constraint cannot be met because either the bucket does not have enough replicas configured or they are not available in a failover event. As an example, if one replica is configured and ReplicateTo.TWO is used, the observable is errored with a DurabilityException. The same can happen if one replica is configured, but one node has been failed over and not yet rebalanced (hence, on a subset of the partitions there is no replica available). It is important to understand that the original prepend has already happened, so the actual prepend and the watching for durability constraints are two separate tasks internally.
document - the document, identified by its id, from which the content is prepended to the existing one.replicateTo - the replication constraint to watch.<D extends Document<?>> Observable<D> prepend(D document, PersistTo persistTo, ReplicateTo replicateTo)
Prepend a Documents content to an existing one.
The Document returned explicitly has the Document.content() set to null, because the server does not return the prepended result, so at this point the client does not know how the Document now looks like. A separate get(Document) call needs to be issued in order to get the full current content.
If the Document does not exist, it needs to be created upfront. Note that JsonDocuments in all forms are not supported, it is advised that the following ones are used:
Note that this method does not support expiration on the Document. If set, it will be ignored.
The returned Observable can error under the following conditions:
BackpressureExceptionRequestCancelledExceptionRequestTooBigExceptionDocumentDoesNotExistExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionDurabilityException.CouchbaseException.A DurabilityException typically happens if the given amount of replicas needed to fulfill the durability constraint cannot be met because either the bucket does not have enough replicas configured or they are not available in a failover event. As an example, if one replica is configured and ReplicateTo.TWO is used, the observable is errored with a DurabilityException. The same can happen if one replica is configured, but one node has been failed over and not yet rebalanced (hence, on a subset of the partitions there is no replica available). It is important to understand that the original prepend has already happened, so the actual prepend and the watching for durability constraints are two separate tasks internally.
document - the document, identified by its id, from which the content is prepended to the existing one.persistTo - the persistence constraint to watch.replicateTo - the replication constraint to watch.<T> Observable<DocumentFragment<T>> getIn(String id, String path, Class<T> fragmentType)
Retrieve a fragment of an existing JSON document, as denoted by the given path. The Observable will be empty if the path could not be found inside the document.
The subdocument API has the benefit of only transmitting the fragment of the document you work with on the wire, instead of the whole document. The DocumentFragment wraps the value and additional metadata like a reminder of the document’s id, the path, enclosing document’s cas (or MutationToken).
This Observable most notable error conditions are:
DocumentNotJsonExceptionDocumentDoesNotExistExceptionOther error conditions include document-level error conditions (similar to those of get(Document)) and some generic sub-document-level error conditions (all of which extend SubDocumentException, like PathTooDeepException).
id - the JSON document’s id to look into.path - the path to look for inside the JSON content.fragmentType - the type of the fragment value to be retrieved (so it can be directly casted).T - the type of the fragment value.Observable emitting the DocumentFragment corresponding to the requested value, or empty if the path could not be found.Observable<Boolean> existsIn(String id, String path)
Check for the existence of a path inside of a JSON document. For example “sub.some” will check that there is a JSON object called “sub” at the root of the document and that it contains a “some” entry (which could be a scalar, array or another sub-object).
The subdocument API has the benefit of only transmitting the fragment of the document you work with on the wire, instead of the whole document. The DocumentFragment wraps the value and additional metadata like a reminder of the document’s id, the path, enclosing document’s cas (or MutationToken).
This Observable most notable error conditions are:
DocumentNotJsonExceptionDocumentDoesNotExistExceptionOther error conditions include document-level error conditions (similar to those of get(Document)) and some generic sub-document-level error conditions (all of which extend SubDocumentException, like PathTooDeepException).
id - the JSON document’s id to look into.path - the path to look for inside the JSON content.Observable emitting true if the path could be found, false otherwise.<T> Observable<DocumentFragment<T>> upsertIn(DocumentFragment<T> fragment, boolean createParents, PersistTo persistTo, ReplicateTo replicateTo)
Upsert a fragment of JSON into an existing JSON document. The document id and path inside the JSON where this mutation should happen are given by the DocumentFragment.
If the last element of the path doesn’t exist, it will be created. Otherwise, the current value at this location in the JSON is replaced by the one in the DocumentFragment.
The subdocument API has the benefit of only transmitting the fragment of the document you work with on the wire, instead of the whole document. The returned DocumentFragment wraps the value and additional metadata like a reminder of the document’s id, the path, enclosing document’s cas (or MutationToken).
This Observable most notable error conditions are:
CASMismatchExceptionDocumentNotJsonExceptionDocumentDoesNotExistExceptioncreateParents is set to false: PathNotFoundException.PathMismatchExceptionPathInvalidExceptionDurabilityExceptionOther error conditions include document-level error conditions (similar to those of replace(Document)) and generic sub-document-level error conditions (all of which extend SubDocumentException, like PathTooDeepException).
Contrary to document-level upsert(Document), the document’s CAS is actually taken into account if provided in the fragment parameter, and the internal mutation will be rejected if the enclosing document was externally modified.
fragment - a DocumentFragment pointing to the path to mutate and containing the new value to apply.createParents - truepersistTo - the persistence constraint to watch (or NONE if not required).replicateTo - the replication constraint to watch (or NONE if not required).T - the type of the fragment value.Observable emitting the DocumentFragment corresponding to the mutated value, with updated cas metadata.<T> Observable<DocumentFragment<T>> insertIn(DocumentFragment<T> fragment, boolean createParents, PersistTo persistTo, ReplicateTo replicateTo)
Insert a fragment of JSON into an existing JSON document, on the condition that no value already exist at this location. The document id and path inside the JSON where this insertion should happen are given by the DocumentFragment.
Unless createParents is set to true, only the last element of the path is created.
The subdocument API has the benefit of only transmitting the fragment of the document you work with on the wire, instead of the whole document. The returned DocumentFragment wraps the value and additional metadata like a reminder of the document’s id, the path, enclosing document’s cas (or MutationToken).
This Observable most notable error conditions are:
CASMismatchExceptionDocumentNotJsonExceptionDocumentDoesNotExistExceptioncreateParents is set to false: PathNotFoundException.PathMismatchExceptionPathInvalidExceptionDurabilityExceptionOther error conditions include document-level error conditions (similar to those of replace(Document)) and generic sub-document-level error conditions (all of which extend SubDocumentException, like PathTooDeepException).
fragment - a DocumentFragment pointing to the path to mutate and containing the new value to insert.createParents - truepersistTo - the persistence constraint to watch (or NONE if not required).replicateTo - the replication constraint to watch (or NONE if not required).T - the type of the fragment value.Observable emitting the DocumentFragment corresponding to the mutated value, with updated cas metadata.<T> Observable<DocumentFragment<T>> replaceIn(DocumentFragment<T> fragment, PersistTo persistTo, ReplicateTo replicateTo)
Replace a fragment of JSON with another one inside an existing JSON document. There should already be a value at this location. The document id and path inside the JSON where this mutation should happen are given by the DocumentFragment.
The subdocument API has the benefit of only transmitting the fragment of the document you work with on the wire, instead of the whole document. The returned DocumentFragment wraps the value and additional metadata like a reminder of the document’s id, the path, enclosing document’s cas (or MutationToken).
This Observable most notable error conditions are:
CASMismatchExceptionDocumentNotJsonExceptionDocumentDoesNotExistExceptionPathNotFoundExceptionPathMismatchExceptionPathInvalidExceptionDurabilityExceptionOther error conditions include document-level error conditions (similar to those of replace(Document)) and generic sub-document-level error conditions (all of which extend SubDocumentException, like PathTooDeepException).
fragment - a DocumentFragment pointing to the path to mutate and containing the new value to apply.persistTo - the persistence constraint to watch (or NONE if not required).replicateTo - the replication constraint to watch (or NONE if not required).T - the type of the fragment value.Observable emitting the DocumentFragment corresponding to the mutated value, with updated cas metadata.<T> Observable<DocumentFragment<T>> extendIn(DocumentFragment<T> fragment, ExtendDirection direction, boolean createParents, PersistTo persistTo, ReplicateTo replicateTo)
Extend an array inside a JSON document, either pushing the new value at the front or at the back. The document id and path inside the JSON where this mutation should happen are given by the DocumentFragment.
The subdocument API has the benefit of only transmitting the fragment of the document you work with on the wire, instead of the whole document. The returned DocumentFragment wraps the value and additional metadata like a reminder of the document’s id, the path, enclosing document’s cas (or MutationToken).
This Observable most notable error conditions are:
CASMismatchExceptionDocumentNotJsonExceptionDocumentDoesNotExistExceptionPathNotFoundExceptionPathMismatchExceptionDurabilityExceptionOther error conditions include document-level error conditions (similar to those of replace(Document)) and generic sub-document-level error conditions (all of which extend SubDocumentException, like PathTooDeepException).
fragment - a DocumentFragment pointing to the array to mutate and containing the new value to add to the array.direction - the position in the array where to insert (start/front of array or end/back of array).createParents - true if intermediate missing nodes in the path should also be created (effectively creating a new array).persistTo - the persistence constraint to watch (or NONE if not required).replicateTo - the replication constraint to watch (or NONE if not required).T - the type of the fragment value.Observable emitting the DocumentFragment corresponding to the mutated value, with updated cas metadata.<T> Observable<DocumentFragment<T>> arrayInsertIn(DocumentFragment<T> fragment, PersistTo persistTo, ReplicateTo replicateTo)
Insert a value in an existing array inside a JSON document, at a specific index as denoted by the path (eg. “some.array[2]”). Existing values at the left of the index are shifted forward. The document id and path inside the JSON where this mutation should happen are given by the DocumentFragment. Index can be in the range 0-arraySize (inclusive).
The subdocument API has the benefit of only transmitting the fragment of the document you work with on the wire, instead of the whole document. The returned DocumentFragment wraps the value and additional metadata like a reminder of the document’s id, the path, enclosing document’s cas (or MutationToken).
This Observable most notable error conditions are:
CASMismatchExceptionDocumentNotJsonExceptionDocumentDoesNotExistExceptionPathNotFoundExceptionPathNotFoundExceptionPathInvalidExceptionPathInvalidExceptionDurabilityExceptionOther error conditions include document-level error conditions (similar to those of replace(Document)) and generic sub-document-level error conditions (all of which extend SubDocumentException, like PathTooDeepException).
fragment - a DocumentFragment pointing to the array position at which to insert and containing the new value to add to the array.persistTo - the persistence constraint to watch (or NONE if not required).replicateTo - the replication constraint to watch (or NONE if not required).T - the type of the fragment value.Observable emitting the DocumentFragment corresponding to the mutated value, with updated cas metadata.<T> Observable<DocumentFragment<T>> addUniqueIn(DocumentFragment<T> fragment, boolean createParents, PersistTo persistTo, ReplicateTo replicateTo)
Adds a value in an existing array inside a JSON document provided said value isn’t already present in the array (as checked using string comparison). This is restricted to primitive values and arrays containing only primitives (no dictionary nor sub-array).
The document id and path inside the JSON where this mutation should happen are given by the DocumentFragment.
The subdocument API has the benefit of only transmitting the fragment of the document you work with on the wire, instead of the whole document. The returned DocumentFragment wraps the value and additional metadata like a reminder of the document’s id, the path, enclosing document’s cas (or MutationToken).
This Observable most notable error conditions are:
CASMismatchExceptionDocumentNotJsonExceptionDocumentDoesNotExistExceptionPathNotFoundExceptionPathMismatchExceptionPathMismatchExceptionCannotInsertValueExceptionPathExistsExceptionDurabilityExceptionOther error conditions include document-level error conditions (similar to those of replace(Document)) and generic sub-document-level error conditions (all of which extend SubDocumentException, like PathTooDeepException).
fragment - a DocumentFragment pointing to the array in which to check and insert, containing the new value to add to the array.createParents - set to true to create intermediary missing nodes and the array if it doesn’t exist.persistTo - the persistence constraint to watch (or NONE if not required).replicateTo - the replication constraint to watch (or NONE if not required).T - the type of the fragment value.Observable emitting the DocumentFragment corresponding to the mutated value, with updated cas metadata.<T> Observable<DocumentFragment<T>> removeIn(DocumentFragment<T> fragment, PersistTo persistTo, ReplicateTo replicateTo)
Removes an entry from an existing JSON document. This can be a scalar, whole dictionary or array or specific dictionary entry or array index, as denoted by the path. The last element in an array can also be removed by using the -1 index (eg. “some.array[-1]”).
The document id and path inside the JSON where this removal should happen are given by the DocumentFragment.
The subdocument API has the benefit of only transmitting the fragment of the document you work with on the wire, instead of the whole document. The returned DocumentFragment wraps the value and additional metadata like a reminder of the document’s id, the path, enclosing document’s cas (or MutationToken).
This Observable most notable error conditions are:
CASMismatchExceptionDocumentNotJsonExceptionDocumentDoesNotExistExceptionPathNotFoundExceptionIllegalArgumentExceptionDurabilityExceptionOther error conditions include document-level error conditions (similar to those of replace(Document)) and generic sub-document-level error conditions (all of which extend SubDocumentException, like PathTooDeepException).
fragment - a DocumentFragment pointing to the path to remove (fragment value is ignored).persistTo - the persistence constraint to watch (or NONE if not required).replicateTo - the replication constraint to watch (or NONE if not required).T - the type of the fragment value.Observable emitting the DocumentFragment corresponding to the removed value, with updated cas metadata but no content.Observable<DocumentFragment<Long>> counterIn(DocumentFragment<Long> fragment, boolean createParents, PersistTo persistTo, ReplicateTo replicateTo)
Increment or decrement a numerical value inside an existing JSON document. The document id and path inside the JSON where this should happen, and the delta to apply, are given by the DocumentFragment.
If the last element of the path doesn’t exist, it is created and initialized with the delta.
The subdocument API has the benefit of only transmitting the fragment of the document you work with on the wire, instead of the whole document. The returned DocumentFragment wraps the value and additional metadata like a reminder of the document’s id, the path, enclosing document’s cas (or MutationToken).
This Observable most notable error conditions are:
CASMismatchExceptionDocumentNotJsonExceptionDocumentDoesNotExistExceptionZeroDeltaExceptionLong.MAX_VALUE or below/at Long.MIN_VALUE: DeltaTooBigExceptionNumberTooBigExceptionPathMismatchExceptionDurabilityExceptionOther error conditions include document-level error conditions (similar to those of replace(Document)) and generic sub-document-level error conditions (all of which extend SubDocumentException, like PathTooDeepException).
fragment - a DocumentFragment pointing to the numerical value to increment/decrement (fragment is the Long delta to apply) ignored).createParents - true if intermediary missing nodes in the path should be created.persistTo - the persistence constraint to watch (or NONE if not required).replicateTo - the replication constraint to watch (or NONE if not required).Observable emitting the DocumentFragment corresponding to the modified value (contains the new value of the “counter”, with updated cas metadata).Observable<MultiLookupResult> lookupIn(String id, LookupSpec... lookupSpecs)
Perform several lookup operations inside a single existing JSON document. The list of path to look for inside the JSON is represented through LookupSpecs.
Each spec will receive an answer in the form of a LookupResult, meaning that if sub-document level error conditions happen (like the path is malformed or doesn’t exist), the error condition is still represented as a LookupResult and the whole operation still succeeds.
MultiLookupResult aggregates all these results and allows to check for such a partial failure (see MultiLookupResult.hasFailure(), MultiLookupResult.isTotalFailure(), …).
The subdocument API has the benefit of only transmitting the fragment of the document you work with on the wire, instead of the whole document.
This Observable most notable error conditions are:
DocumentNotJsonExceptionDocumentDoesNotExistExceptionNullPointerExceptionIllegalArgumentExceptionEach individual LookupResult can have errors denoted by a “SUBDOC_” error status (eg. ResponseStatus.SUBDOC_PATH_MISMATCH or ResponseStatus.SUBDOC_PATH_NOT_FOUND), in which case the value is null. For Lookup.EXIST, SUBDOC_PATH_NOT_FOUND is considered a “success” where LookupResult.exists() returns false and LookupResult.value() returns false as well.
If one prefers to deal with a SubDocumentException instead of the ResponseStatus, one can use LookupResult.valueOrThrow().
One special fatal error can also happen that is represented as a LookupResult, when the value couldn’t be decoded from JSON. In that case, the ResponseStatus is ResponseStatus.FAILURE and the value() is a TranscodingException.
Other document-level error conditions are similar to those encountered during a document-level get(Document).
id - the id of the JSON document to look into.lookupSpecs - the list of lookup operations to perform (use LookupSpec's static methods)Observable of a single MultiLookupResult representing the whole list of results (1 for each spec), unless a document-level error happened (in which case an exception is propagated).Observable<Integer> invalidateQueryCache()
Invalidates and clears the internal query cache.
This method can be used to explicitly clear the internal N1QL query cache. This cache will be filled with non-adhoc query statements (query plans) to speed up those subsequent executions.
Triggering this method will wipe out the complete cache, which will not cause an interruption but rather all queries need to be re-prepared internally. This method is likely to be deprecated in the future once the server side query engine distributes its state throughout the cluster.
The returned Observable will not error out under any conditions.
Observable<AsyncBucketManager> bucketManager()
Provides access to the AsyncBucketManager for administrative access.
The manager lets you perform operations such as flushing a bucket or creating and managing design documents.
@InterfaceAudience.Public @InterfaceStability.Experimental Observable<AsyncRepository> repository()
The Repository provides access to full object document mapping (ODM) capabilities.
It allows you to work with POJO entities only and use annotations to customize the behaviour and mapping characteristics.
Observable<Boolean> close()
Closes the AsyncBucket.
Observable eventually containing a new Boolean after close.boolean isClosed()
Returns true if this bucket is already closed, false if it is still open.
Copyright © 2015 Couchbase, Inc.