@InterfaceStability.Committed
@InterfaceAudience.Public
public interface Bucket
Defines operations that can be executed synchronously 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.
Default timeouts are always applied and can be configured through the CouchbaseEnvironment. Overloads are also available to change them on a per-call basis.
| Modifier and Type | Method and Description |
|---|---|
<D extends Document<?>> |
append(D document)
Append a
Documents content to an existing one with the default key/value timeout. |
<D extends Document<?>> |
append(D document,
long timeout,
TimeUnit timeUnit)
Append a
Documents content to an existing one with a custom timeout. |
<D extends Document<?>> |
append(D document,
PersistTo persistTo)
Append a
Documents content to an existing one with the default key/value timeout. |
<D extends Document<?>> |
append(D document,
PersistTo persistTo,
long timeout,
TimeUnit timeUnit)
Append a
Documents content to an existing one with a custom timeout. |
<D extends Document<?>> |
append(D document,
PersistTo persistTo,
ReplicateTo replicateTo)
Append a
Documents content to an existing one with the default key/value timeout. |
<D extends Document<?>> |
append(D document,
PersistTo persistTo,
ReplicateTo replicateTo,
long timeout,
TimeUnit timeUnit)
Append a
Documents content to an existing one with a custom timeout. |
<D extends Document<?>> |
append(D document,
ReplicateTo replicateTo)
Append a
Documents content to an existing one with the default key/value timeout. |
<D extends Document<?>> |
append(D document,
ReplicateTo replicateTo,
long timeout,
TimeUnit timeUnit)
Append a
Documents content to an existing one with a custom timeout. |
AsyncBucket |
async()
Provides access to the underlying asynchronous bucket interface.
|
BucketManager |
bucketManager()
Provides access to the
BucketManager for administrative access. |
Boolean |
close()
Closes this bucket with the default disconnect timeout.
|
Boolean |
close(long timeout,
TimeUnit timeUnit)
Closes this bucket with a custom timeout.
|
com.couchbase.client.core.ClusterFacade |
core()
Returns the underlying “core-io” library through its
ClusterFacade. |
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 with the default kvTimeout.
|
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 with the default key/value timeout.
|
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 with the default key/value timeout.
|
JsonLongDocument |
counter(String id,
long delta,
long initial,
int expiry,
long timeout,
TimeUnit timeUnit)
Increment or decrement a counter with the given value and a initial value if it does not exist with a custom timeout.
|
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 with the default key/value timeout.
|
JsonLongDocument |
counter(String id,
long delta,
long initial,
int expiry,
PersistTo persistTo,
long timeout,
TimeUnit timeUnit)
Increment or decrement a counter with the given value and a initial value if it does not exist with a custom timeout.
|
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 with the default key/value timeout.
|
JsonLongDocument |
counter(String id,
long delta,
long initial,
int expiry,
PersistTo persistTo,
ReplicateTo replicateTo,
long timeout,
TimeUnit timeUnit)
Increment or decrement a counter with the given value and a initial value if it does not exist with a custom timeout.
|
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 with the default key/value timeout.
|
JsonLongDocument |
counter(String id,
long delta,
long initial,
int expiry,
ReplicateTo replicateTo,
long timeout,
TimeUnit timeUnit)
Increment or decrement a counter with the given value and a initial value if it does not exist with a custom timeout.
|
JsonLongDocument |
counter(String id,
long delta,
long initial,
long timeout,
TimeUnit timeUnit)
Increment or decrement a counter with the given value and a initial value if it does not exist with a custom timeout.
|
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 with the default key/value timeout.
|
JsonLongDocument |
counter(String id,
long delta,
long initial,
PersistTo persistTo,
long timeout,
TimeUnit timeUnit)
Increment or decrement a counter with the given value and a initial value if it does not exist with a custom timeout.
|
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 with the default key/value timeout.
|
JsonLongDocument |
counter(String id,
long delta,
long initial,
PersistTo persistTo,
ReplicateTo replicateTo,
long timeout,
TimeUnit timeUnit)
Increment or decrement a counter with the given value and a initial value if it does not exist with a custom timeout.
|
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 with the default key/value timeout.
|
JsonLongDocument |
counter(String id,
long delta,
long initial,
ReplicateTo replicateTo,
long timeout,
TimeUnit timeUnit)
Increment or decrement a counter with the given value and a initial value if it does not exist with a custom timeout.
|
JsonLongDocument |
counter(String id,
long delta,
long timeout,
TimeUnit timeUnit)
Increment or decrement a counter with the given value or throw an exception if it does not exist yet with a custom timeout.
|
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 with the default kvTimeout.
|
JsonLongDocument |
counter(String id,
long delta,
PersistTo persistTo,
long timeout,
TimeUnit timeUnit)
Increment or decrement a counter with the given value or throw an exception if it does not exist yet with a custom timeout.
|
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 with the default kvTimeout.
|
JsonLongDocument |
counter(String id,
long delta,
PersistTo persistTo,
ReplicateTo replicateTo,
long timeout,
TimeUnit timeUnit)
Increment or decrement a counter with the given value or throw an exception if it does not exist yet with a custom timeout.
|
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 with the default kvTimeout.
|
JsonLongDocument |
counter(String id,
long delta,
ReplicateTo replicateTo,
long timeout,
TimeUnit timeUnit)
Increment or decrement a counter with the given value or throw an exception if it does not exist yet with a custom timeout.
|
CouchbaseEnvironment |
environment()
The
CouchbaseEnvironment used. |
<D extends Document<?>> |
exists(D document)
Check whether a document with the given ID does exist in the bucket.
|
<D extends Document<?>> |
exists(D document,
long timeout,
TimeUnit timeUnit)
Check whether a document with the given ID does exist in the bucket.
|
boolean |
exists(String id)
Check whether a document with the given ID does exist in the bucket.
|
boolean |
exists(String id,
long timeout,
TimeUnit timeUnit)
Check whether a document with the given ID does exist in the bucket.
|
<D extends Document<?>> |
get(D document)
Retrieves any type of
Document with the default key/value timeout. |
<D extends Document<?>> |
get(D document,
long timeout,
TimeUnit timeUnit)
Retrieves any type of
Document with a custom timeout. |
JsonDocument |
get(String id)
Retrieves a
JsonDocument by its unique ID with the default key/value timeout. |
<D extends Document<?>> |
get(String id,
Class<D> target)
Retrieves any type of
Document by its ID with the default key/value timeout. |
<D extends Document<?>> |
get(String id,
Class<D> target,
long timeout,
TimeUnit timeUnit)
Retrieves any type of
Document by its ID with a custom timeout. |
JsonDocument |
get(String id,
long timeout,
TimeUnit timeUnit)
Retrieves a
JsonDocument by its unique ID with a custom timeout. |
<D extends Document<?>> |
getAndLock(D document,
int lockTime)
Retrieve and lock a
Document by its unique ID with the default key/value timeout. |
<D extends Document<?>> |
getAndLock(D document,
int lockTime,
long timeout,
TimeUnit timeUnit)
Retrieve and lock a
Document by its unique ID with a custom timeout. |
JsonDocument |
getAndLock(String id,
int lockTime)
Retrieve and lock a
JsonDocument by its unique ID with the default key/value timeout. |
<D extends Document<?>> |
getAndLock(String id,
int lockTime,
Class<D> target)
Retrieve and lock a
Document by its unique ID with the default key/value timeout. |
<D extends Document<?>> |
getAndLock(String id,
int lockTime,
Class<D> target,
long timeout,
TimeUnit timeUnit)
Retrieve and lock a
Document by its unique ID with the a custom timeout. |
JsonDocument |
getAndLock(String id,
int lockTime,
long timeout,
TimeUnit timeUnit)
Retrieve and lock a
JsonDocument by its unique ID with a custom timeout. |
<D extends Document<?>> |
getAndTouch(D document)
Retrieve and touch a
Document by its unique ID with the default key/value timeout. |
<D extends Document<?>> |
getAndTouch(D document,
long timeout,
TimeUnit timeUnit)
Retrieve and touch a
Document by its unique ID with a custom timeout. |
JsonDocument |
getAndTouch(String id,
int expiry)
Retrieve and touch a
JsonDocument by its unique ID with the default key/value timeout. |
<D extends Document<?>> |
getAndTouch(String id,
int expiry,
Class<D> target)
Retrieve and touch a
Document by its unique ID with the default key/value timeout. |
<D extends Document<?>> |
getAndTouch(String id,
int expiry,
Class<D> target,
long timeout,
TimeUnit timeUnit)
Retrieve and touch a
Document by its unique ID with a custom timeout. |
JsonDocument |
getAndTouch(String id,
int expiry,
long timeout,
TimeUnit timeUnit)
Retrieve and touch a
JsonDocument by its unique ID with the a custom timeout. |
<D extends Document<?>> |
getFromReplica(D document)
Retrieves one or more, possibly stale, representations of a
JsonDocument by its unique ID with the default timeout. |
<D extends Document<?>> |
getFromReplica(D document,
long timeout,
TimeUnit timeUnit)
Retrieves one or more, possibly stale, representations of a
JsonDocument by its unique ID with a custom timeout. |
<D extends Document<?>> |
getFromReplica(D document,
ReplicaMode type)
Retrieves one or more, possibly stale, representations of a
JsonDocument by its unique ID with the default timeout. |
<D extends Document<?>> |
getFromReplica(D document,
ReplicaMode type,
long timeout,
TimeUnit timeUnit)
Retrieves one or more, possibly stale, representations of a
JsonDocument by its unique ID with a custom timeout. |
Iterator<JsonDocument> |
getFromReplica(String id)
Retrieves one or more, possibly stale, representations of a
JsonDocument by its unique ID with the default timeout. |
<D extends Document<?>> |
getFromReplica(String id,
Class<D> target)
Retrieves one or more, possibly stale, representations of a
JsonDocument by its unique ID with the default timeout. |
<D extends Document<?>> |
getFromReplica(String id,
Class<D> target,
long timeout,
TimeUnit timeUnit)
Retrieves one or more, possibly stale, representations of a
JsonDocument by its unique ID with a custom timeout. |
Iterator<JsonDocument> |
getFromReplica(String id,
long timeout,
TimeUnit timeUnit)
Retrieves one or more, possibly stale, representations of a
JsonDocument by its unique ID with a custom timeout. |
List<JsonDocument> |
getFromReplica(String id,
ReplicaMode type)
Retrieves one or more, possibly stale, representations of a
JsonDocument by its unique ID with the default timeout. |
<D extends Document<?>> |
getFromReplica(String id,
ReplicaMode type,
Class<D> target)
Retrieves one or more, possibly stale, representations of a
JsonDocument by its unique ID with the default timeout. |
<D extends Document<?>> |
getFromReplica(String id,
ReplicaMode type,
Class<D> target,
long timeout,
TimeUnit timeUnit)
Retrieves one or more, possibly stale, representations of a
JsonDocument by its unique ID with a custom timeout. |
List<JsonDocument> |
getFromReplica(String id,
ReplicaMode type,
long timeout,
TimeUnit timeUnit)
Retrieves one or more, possibly stale, representations of a
JsonDocument by its unique ID with a custom timeout. |
<D extends Document<?>> |
insert(D document)
Insert a
Document if it does not exist already with the default key/value timeout. |
<D extends Document<?>> |
insert(D document,
long timeout,
TimeUnit timeUnit)
Insert a
Document if it does not exist already with a custom timeout. |
<D extends Document<?>> |
insert(D document,
PersistTo persistTo)
Insert a
Document if it does not exist already and watch for durability constraints with the default key/value timeout. |
<D extends Document<?>> |
insert(D document,
PersistTo persistTo,
long timeout,
TimeUnit timeUnit)
Insert a
Document if it does not exist already and watch for durability constraints with a custom timeout. |
<D extends Document<?>> |
insert(D document,
PersistTo persistTo,
ReplicateTo replicateTo)
Insert a
Document if it does not exist already and watch for durability constraints with the default key/value timeout. |
<D extends Document<?>> |
insert(D document,
PersistTo persistTo,
ReplicateTo replicateTo,
long timeout,
TimeUnit timeUnit)
Insert a
Document if it does not exist already and watch for durability constraints with a custom timeout. |
<D extends Document<?>> |
insert(D document,
ReplicateTo replicateTo)
Insert a
Document if it does not exist already and watch for durability constraints with the default key/value timeout. |
<D extends Document<?>> |
insert(D document,
ReplicateTo replicateTo,
long timeout,
TimeUnit timeUnit)
Insert a
Document if it does not exist already and watch for durability constraints with a custom timeout. |
int |
invalidateQueryCache()
Invalidates and clears the internal query cache.
|
String |
name()
The name of the
Bucket. |
<D extends Document<?>> |
prepend(D document)
Prepend a
Documents content to an existing one with the default key/value timeout. |
<D extends Document<?>> |
prepend(D document,
long timeout,
TimeUnit timeUnit)
Prepend a
Documents content to an existing one with a custom timeout. |
<D extends Document<?>> |
prepend(D document,
PersistTo persistTo)
Prepend a
Documents content to an existing one with the default key/value timeout. |
<D extends Document<?>> |
prepend(D document,
PersistTo persistTo,
long timeout,
TimeUnit timeUnit)
Prepend a
Documents content to an existing one with a custom timeout. |
<D extends Document<?>> |
prepend(D document,
PersistTo persistTo,
ReplicateTo replicateTo)
Prepend a
Documents content to an existing one with the default key/value timeout. |
<D extends Document<?>> |
prepend(D document,
PersistTo persistTo,
ReplicateTo replicateTo,
long timeout,
TimeUnit timeUnit)
Prepend a
Documents content to an existing one with a custom timeout. |
<D extends Document<?>> |
prepend(D document,
ReplicateTo replicateTo)
Prepend a
Documents content to an existing one with the default key/value timeout. |
<D extends Document<?>> |
prepend(D document,
ReplicateTo replicateTo,
long timeout,
TimeUnit timeUnit)
Prepend a
Documents content to an existing one with a custom timeout. |
N1qlQueryResult |
query(N1qlQuery query)
Experimental: Queries a N1QL secondary index with the
default query timeout. |
N1qlQueryResult |
query(N1qlQuery query,
long timeout,
TimeUnit timeUnit)
Experimental: Queries a N1QL secondary index with a custom timeout.
|
SpatialViewResult |
query(SpatialViewQuery query)
Queries a Couchbase Server Spatial
View with the default view timeout. |
SpatialViewResult |
query(SpatialViewQuery query,
long timeout,
TimeUnit timeUnit)
Queries a Couchbase Server Spatial
View with a custom timeout. |
N1qlQueryResult |
query(Statement statement)
Experimental: Queries a N1QL secondary index with the
default query timeout. |
N1qlQueryResult |
query(Statement statement,
long timeout,
TimeUnit timeUnit)
Experimental: Queries a N1QL secondary index with a custom timeout.
|
ViewResult |
query(ViewQuery query)
Queries a Couchbase Server
View with the default view timeout. |
ViewResult |
query(ViewQuery query,
long timeout,
TimeUnit timeUnit)
Queries a Couchbase Server
View with a custom timeout. |
<D extends Document<?>> |
remove(D document)
Removes a
Document from the Server with the default key/value timeout. |
<D extends Document<?>> |
remove(D document,
long timeout,
TimeUnit timeUnit)
Removes a
Document from the Server with a custom timeout. |
<D extends Document<?>> |
remove(D document,
PersistTo persistTo)
Removes a
Document from the Server and apply a durability requirement with the default key/value timeout. |
<D extends Document<?>> |
remove(D document,
PersistTo persistTo,
long timeout,
TimeUnit timeUnit)
Removes a
Document from the Server and apply a durability requirement with a custom timeout. |
<D extends Document<?>> |
remove(D document,
PersistTo persistTo,
ReplicateTo replicateTo)
Removes a
Document from the Server and apply a durability requirement with the default key/value timeout. |
<D extends Document<?>> |
remove(D document,
PersistTo persistTo,
ReplicateTo replicateTo,
long timeout,
TimeUnit timeUnit)
Removes a
Document from the Server and apply a durability requirement with a custom timeout. |
<D extends Document<?>> |
remove(D document,
ReplicateTo replicateTo)
Removes a
Document from the Server and apply a durability requirement with the default key/value timeout. |
<D extends Document<?>> |
remove(D document,
ReplicateTo replicateTo,
long timeout,
TimeUnit timeUnit)
Removes a
Document from the Server and apply a durability requirement with a custom timeout. |
JsonDocument |
remove(String id)
Removes a
Document from the Server identified by its ID with the default key/value timeout. |
<D extends Document<?>> |
remove(String id,
Class<D> target)
Removes a
Document from the Server identified by its ID with the default key/value timeout. |
<D extends Document<?>> |
remove(String id,
Class<D> target,
long timeout,
TimeUnit timeUnit)
Removes a
Document from the Server identified by its ID with a custom timeout. |
JsonDocument |
remove(String id,
long timeout,
TimeUnit timeUnit)
Removes a
Document from the Server identified by its ID with a custom timeout. |
JsonDocument |
remove(String id,
PersistTo persistTo)
Removes a
Document from the Server by its ID and apply a durability requirement with the default key/value timeout. |
<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 with the default key/value timeout. |
<D extends Document<?>> |
remove(String id,
PersistTo persistTo,
Class<D> target,
long timeout,
TimeUnit timeUnit)
Removes a
Document from the Server by its ID and apply a durability requirement with a custom timeout. |
JsonDocument |
remove(String id,
PersistTo persistTo,
long timeout,
TimeUnit timeUnit)
Removes a
Document from the Server by its ID and apply a durability requirement with a custom timeout. |
JsonDocument |
remove(String id,
PersistTo persistTo,
ReplicateTo replicateTo)
Removes a
Document from the Server by its ID and apply a durability requirement with the default key/value timeout. |
<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 with the default key/value timeout. |
<D extends Document<?>> |
remove(String id,
PersistTo persistTo,
ReplicateTo replicateTo,
Class<D> target,
long timeout,
TimeUnit timeUnit)
Removes a
Document from the Server by its ID and apply a durability requirement with a custom timeout. |
JsonDocument |
remove(String id,
PersistTo persistTo,
ReplicateTo replicateTo,
long timeout,
TimeUnit timeUnit)
Removes a
Document from the Server by its ID and apply a durability requirement with a custom timeout. |
JsonDocument |
remove(String id,
ReplicateTo replicateTo)
Removes a
Document from the Server by its ID and apply a durability requirement with the default key/value timeout. |
<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 with the default key/value timeout. |
<D extends Document<?>> |
remove(String id,
ReplicateTo replicateTo,
Class<D> target,
long timeout,
TimeUnit timeUnit)
Removes a
Document from the Server by its ID and apply a durability requirement with a custom timeout. |
JsonDocument |
remove(String id,
ReplicateTo replicateTo,
long timeout,
TimeUnit timeUnit)
Removes a
Document from the Server by its ID and apply a durability requirement with a custom timeout. |
<D extends Document<?>> |
replace(D document)
Replace a
Document if it does already exist with the default key/value timeout. |
<D extends Document<?>> |
replace(D document,
long timeout,
TimeUnit timeUnit)
Replace a
Document if it does already exist with a custom timeout. |
<D extends Document<?>> |
replace(D document,
PersistTo persistTo)
Replace a
Document if it does exist and watch for durability constraints with the default key/value timeout. |
<D extends Document<?>> |
replace(D document,
PersistTo persistTo,
long timeout,
TimeUnit timeUnit)
Replace a
Document if it does exist and watch for durability constraints with a custom timeout. |
<D extends Document<?>> |
replace(D document,
PersistTo persistTo,
ReplicateTo replicateTo)
Replace a
Document if it does exist and watch for durability constraints with the default key/value timeout. |
<D extends Document<?>> |
replace(D document,
PersistTo persistTo,
ReplicateTo replicateTo,
long timeout,
TimeUnit timeUnit)
Replace a
Document if it does exist and watch for durability constraints with a custom timeout. |
<D extends Document<?>> |
replace(D document,
ReplicateTo replicateTo)
Replace a
Document if it does exist and watch for durability constraints with the default key/value timeout. |
<D extends Document<?>> |
replace(D document,
ReplicateTo replicateTo,
long timeout,
TimeUnit timeUnit)
Replace a
Document if it does exist and watch for durability constraints with a custom timeout. |
Repository |
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 with the default key/value timeout. |
<D extends Document<?>> |
touch(D document,
long timeout,
TimeUnit timeUnit)
Renews the expiration time of a
Document with a custom timeout. |
Boolean |
touch(String id,
int expiry)
Renews the expiration time of a
Document with the default key/value timeout. |
Boolean |
touch(String id,
int expiry,
long timeout,
TimeUnit timeUnit)
Renews the expiration time of a
Document with a custom timeout. |
<D extends Document<?>> |
unlock(D document)
Unlocks a write-locked
Document with the default key/value timeout. |
<D extends Document<?>> |
unlock(D document,
long timeout,
TimeUnit timeUnit)
Unlocks a write-locked
Document with a custom timeout. |
Boolean |
unlock(String id,
long cas)
Unlocks a write-locked
Document with the default key/value timeout. |
Boolean |
unlock(String id,
long cas,
long timeout,
TimeUnit timeUnit)
Unlocks a write-locked
Document with a custom timeout. |
<D extends Document<?>> |
upsert(D document)
Insert or replace a
Document with the default key/value timeout. |
<D extends Document<?>> |
upsert(D document,
long timeout,
TimeUnit timeUnit)
Insert or replace a
Document with a custom timeout. |
<D extends Document<?>> |
upsert(D document,
PersistTo persistTo)
Insert or replace a
Document and watch for durability constraints with the default key/value timeout. |
<D extends Document<?>> |
upsert(D document,
PersistTo persistTo,
long timeout,
TimeUnit timeUnit)
Insert or replace a
Document and watch for durability constraints with a custom timeout. |
<D extends Document<?>> |
upsert(D document,
PersistTo persistTo,
ReplicateTo replicateTo)
Insert or replace a
Document and watch for durability constraints with the default key/value timeout. |
<D extends Document<?>> |
upsert(D document,
PersistTo persistTo,
ReplicateTo replicateTo,
long timeout,
TimeUnit timeUnit)
Insert or replace a
Document and watch for durability constraints with a custom timeout. |
<D extends Document<?>> |
upsert(D document,
ReplicateTo replicateTo)
Insert or replace a
Document and watch for durability constraints with the default key/value timeout. |
<D extends Document<?>> |
upsert(D document,
ReplicateTo replicateTo,
long timeout,
TimeUnit timeUnit)
Insert or replace a
Document and watch for durability constraints with a custom timeout. |
AsyncBucket async()
Provides access to the underlying asynchronous bucket interface.
com.couchbase.client.core.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.CouchbaseEnvironment environment()
The CouchbaseEnvironment used.
JsonDocument get(String id)
Retrieves a JsonDocument by its unique ID with the default key/value timeout.
If the document is found, a JsonDocument is returned. If the document is not found, null is returned.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.id - the unique ID of the document.JsonDocument or null if not found.JsonDocument get(String id, long timeout, TimeUnit timeUnit)
Retrieves a JsonDocument by its unique ID with a custom timeout.
If the document is found, a JsonDocument is returned. If the document is not found, null is returned.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.id - the unique ID of the document.timeout - the custom timeout.timeUnit - the unit for the timeout.JsonDocument or null if not found.<D extends Document<?>> D get(D document)
Retrieves any type of Document with the default key/value timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.document - the source document from which the ID is taken and the type is inferred.Document or null.<D extends Document<?>> D get(D document, long timeout, TimeUnit timeUnit)
Retrieves any type of Document with a custom timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.document - the source document from which the ID is taken and the type is inferred.timeout - the custom timeout.timeUnit - the unit for the timeout.Document or null.<D extends Document<?>> D get(String id, Class<D> target)
Retrieves any type of Document by its ID with the default key/value timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.id - the id of the document.target - the target document type to use.Document or null.<D extends Document<?>> D get(String id, Class<D> target, long timeout, TimeUnit timeUnit)
Retrieves any type of Document by its ID with a custom timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.id - the id of the document.target - the target document type to use.timeout - the custom timeout.timeUnit - the unit for the timeout.Document or null.boolean exists(String id)
Check whether a document with the given ID does exist in the bucket.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.id - the id of the document.boolean exists(String id, long timeout, TimeUnit timeUnit)
Check whether a document with the given ID does exist in the bucket.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.id - the id of the document.timeout - the custom timeout.timeUnit - the unit for the timeout.<D extends Document<?>> boolean exists(D document)
Check whether a document with the given ID does exist in the bucket.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.document - the document where the ID is extracted from.<D extends Document<?>> boolean exists(D document, long timeout, TimeUnit timeUnit)
Check whether a document with the given ID does exist in the bucket.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.document - the document where the ID is extracted from.timeout - the custom timeout.timeUnit - the unit for the timeout.List<JsonDocument> getFromReplica(String id, ReplicaMode type)
Retrieves one or more, possibly stale, representations of a JsonDocument by its unique ID with the default timeout.
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, most errors are swallowed (but logged) and the Observable will return all successful responses.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionid - id the unique ID of the document.type - the ReplicaMode to select.JsonDocuments.Iterator<JsonDocument> getFromReplica(String id)
Retrieves one or more, possibly stale, representations of a JsonDocument by its unique ID with the default timeout.
This method has the ReplicaMode.ALL preselected. If you are only interested in the first (or just some) values, you can iterate and then break out of the iterator loop. Documents are pushed into the iterator as they arrive, which distinguishes this method from the List equivalents which wait until all responses arrive.
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, most errors are swallowed (but logged) and the Observable will return all successful responses.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionid - the unique ID of the document.List<JsonDocument> getFromReplica(String id, ReplicaMode type, long timeout, TimeUnit timeUnit)
Retrieves one or more, possibly stale, representations of a JsonDocument by its unique ID with a custom timeout.
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, most errors are swallowed (but logged) and the Observable will return all successful responses.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionid - id the unique ID of the document.type - the ReplicaMode to select.timeout - the custom timeout.timeUnit - the unit for the timeout.JsonDocuments.Iterator<JsonDocument> getFromReplica(String id, long timeout, TimeUnit timeUnit)
Retrieves one or more, possibly stale, representations of a JsonDocument by its unique ID with a custom timeout.
This method has the ReplicaMode.ALL preselected. If you are only interested in the first (or just some) values, you can iterate and then break out of the iterator loop. Documents are pushed into the iterator as they arrive, which distinguishes this method from the List equivalents which wait until all responses arrive.
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, most errors are swallowed (but logged) and the Observable will return all successful responses.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionid - the unique ID of the document.timeout - the custom timeout.timeUnit - the unit for the timeout.<D extends Document<?>> List<D> getFromReplica(D document, ReplicaMode type)
Retrieves one or more, possibly stale, representations of a JsonDocument by its unique ID with the default timeout.
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, most errors are swallowed (but logged) and the Observable will return all successful responses.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptiondocument - the document to extract the ID from.type - the ReplicaMode to select.JsonDocuments.<D extends Document<?>> Iterator<D> getFromReplica(D document)
Retrieves one or more, possibly stale, representations of a JsonDocument by its unique ID with the default timeout.
This method has the ReplicaMode.ALL preselected. If you are only interested in the first (or just some) values, you can iterate and then break out of the iterator loop. Documents are pushed into the iterator as they arrive, which distinguishes this method from the List equivalents which wait until all responses arrive.
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, most errors are swallowed (but logged) and the Observable will return all successful responses.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptiondocument - the document to extract the ID from.<D extends Document<?>> List<D> getFromReplica(D document, ReplicaMode type, long timeout, TimeUnit timeUnit)
Retrieves one or more, possibly stale, representations of a JsonDocument by its unique ID with a custom timeout.
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, most errors are swallowed (but logged) and the Observable will return all successful responses.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptiondocument - the document to extract the ID from.type - the ReplicaMode to select.timeout - the custom timeout.timeUnit - the unit for the timeout.JsonDocuments.<D extends Document<?>> Iterator<D> getFromReplica(D document, long timeout, TimeUnit timeUnit)
Retrieves one or more, possibly stale, representations of a JsonDocument by its unique ID with a custom timeout.
This method has the ReplicaMode.ALL preselected. If you are only interested in the first (or just some) values, you can iterate and then break out of the iterator loop. Documents are pushed into the iterator as they arrive, which distinguishes this method from the List equivalents which wait until all responses arrive.
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, most errors are swallowed (but logged) and the Observable will return all successful responses.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptiondocument - the document to extract the ID from.timeout - the custom timeout.timeUnit - the unit for the timeout.<D extends Document<?>> List<D> getFromReplica(String id, ReplicaMode type, Class<D> target)
Retrieves one or more, possibly stale, representations of a JsonDocument by its unique ID with the default timeout.
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, most errors are swallowed (but logged) and the Observable will return all successful responses.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionid - the id of the document.type - the ReplicaMode to select.JsonDocuments.<D extends Document<?>> Iterator<D> getFromReplica(String id, Class<D> target)
Retrieves one or more, possibly stale, representations of a JsonDocument by its unique ID with the default timeout.
This method has the ReplicaMode.ALL preselected. If you are only interested in the first (or just some) values, you can iterate and then break out of the iterator loop. Documents are pushed into the iterator as they arrive, which distinguishes this method from the List equivalents which wait until all responses arrive.
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, most errors are swallowed (but logged) and the Observable will return all successful responses.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionid - the unique ID of the document.target - the target document type to use.<D extends Document<?>> List<D> getFromReplica(String id, ReplicaMode type, Class<D> target, long timeout, TimeUnit timeUnit)
Retrieves one or more, possibly stale, representations of a JsonDocument by its unique ID with a custom timeout.
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, most errors are swallowed (but logged) and the Observable will return all successful responses.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionid - the id of the document.type - the ReplicaMode to select.target - the target document type to use.timeout - the custom timeout.timeUnit - the unit for the timeout.JsonDocuments.<D extends Document<?>> Iterator<D> getFromReplica(String id, Class<D> target, long timeout, TimeUnit timeUnit)
Retrieves one or more, possibly stale, representations of a JsonDocument by its unique ID with a custom timeout.
This method has the ReplicaMode.ALL preselected. If you are only interested in the first (or just some) values, you can iterate and then break out of the iterator loop. Documents are pushed into the iterator as they arrive, which distinguishes this method from the List equivalents which wait until all responses arrive.
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, most errors are swallowed (but logged) and the Observable will return all successful responses.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionid - the unique ID of the document.target - the target document type to use.timeout - the custom timeout.timeUnit - the unit for the timeout.JsonDocument getAndLock(String id, int lockTime)
Retrieve and lock a JsonDocument by its unique ID with the default key/value timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionTemporaryLockFailureExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.id - id the unique ID of the document.lockTime - the time to write lock the document (max. 30 seconds).JsonDocument or null.JsonDocument getAndLock(String id, int lockTime, long timeout, TimeUnit timeUnit)
Retrieve and lock a JsonDocument by its unique ID with a custom timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionTemporaryLockFailureExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.id - id the unique ID of the document.lockTime - the time to write lock the document (max. 30 seconds).timeout - the custom timeout.timeUnit - the unit for the timeout.JsonDocument or null.<D extends Document<?>> D getAndLock(D document, int lockTime)
Retrieve and lock a Document by its unique ID with the default key/value timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionTemporaryLockFailureExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.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).Document or null.<D extends Document<?>> D getAndLock(D document, int lockTime, long timeout, TimeUnit timeUnit)
Retrieve and lock a Document by its unique ID with a custom timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionTemporaryLockFailureExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.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).timeout - the custom timeout.timeUnit - the unit for the timeout.Document or null.<D extends Document<?>> D getAndLock(String id, int lockTime, Class<D> target)
Retrieve and lock a Document by its unique ID with the default key/value timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionTemporaryLockFailureExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.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.Document or null.<D extends Document<?>> D getAndLock(String id, int lockTime, Class<D> target, long timeout, TimeUnit timeUnit)
Retrieve and lock a Document by its unique ID with the a custom timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionTemporaryLockFailureExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.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.timeout - the custom timeout.timeUnit - the unit for the timeout.Document or null.JsonDocument getAndTouch(String id, int expiry)
Retrieve and touch a JsonDocument by its unique ID with the default key/value timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.id - id the unique ID of the document.expiry - the new expiration time for the document.JsonDocument or null.JsonDocument getAndTouch(String id, int expiry, long timeout, TimeUnit timeUnit)
Retrieve and touch a JsonDocument by its unique ID with the a custom timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.id - id the unique ID of the document.expiry - the new expiration time for the document.timeout - the custom timeout.timeUnit - the unit for the timeout.JsonDocument or null.<D extends Document<?>> D getAndTouch(D document)
Retrieve and touch a Document by its unique ID with the default key/value timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.document - the source document from which the ID and expiry is taken and the type is inferred.Document or null.<D extends Document<?>> D getAndTouch(D document, long timeout, TimeUnit timeUnit)
Retrieve and touch a Document by its unique ID with a custom timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.document - the source document from which the ID and expiry is taken and the type is inferred.timeout - the custom timeout.timeUnit - the unit for the timeout.Document or null.<D extends Document<?>> D getAndTouch(String id, int expiry, Class<D> target)
Retrieve and touch a Document by its unique ID with the default key/value timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.id - id the unique ID of the document.expiry - the new expiration time for the document.target - the target document type to use.Document or null.<D extends Document<?>> D getAndTouch(String id, int expiry, Class<D> target, long timeout, TimeUnit timeUnit)
Retrieve and touch a Document by its unique ID with a custom timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.id - id the unique ID of the document.expiry - the new expiration time for the document.target - the target document type to use.timeout - the custom timeout.timeUnit - the unit for the timeout.Document or null.<D extends Document<?>> D insert(D document)
Insert a Document if it does not exist already with the default key/value timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestTooBigExceptionRequestCancelledExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.<D extends Document<?>> D insert(D document, long timeout, TimeUnit timeUnit)
Insert a Document if it does not exist already with a custom timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestTooBigExceptionRequestCancelledExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.<D extends Document<?>> D insert(D document, PersistTo persistTo, ReplicateTo replicateTo)
Insert a Document if it does not exist already and watch for durability constraints with the default key/value timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionDocumentAlreadyExistsExceptionRequestTooBigExceptionDurabilityException.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.
<D extends Document<?>> D insert(D document, PersistTo persistTo, ReplicateTo replicateTo, long timeout, TimeUnit timeUnit)
Insert a Document if it does not exist already and watch for durability constraints with a custom timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionDocumentAlreadyExistsExceptionRequestTooBigExceptionDurabilityException.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.
<D extends Document<?>> D insert(D document, PersistTo persistTo)
Insert a Document if it does not exist already and watch for durability constraints with the default key/value timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionDocumentAlreadyExistsExceptionRequestTooBigExceptionDurabilityException.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.
<D extends Document<?>> D insert(D document, PersistTo persistTo, long timeout, TimeUnit timeUnit)
Insert a Document if it does not exist already and watch for durability constraints with a custom timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionDocumentAlreadyExistsExceptionRequestTooBigExceptionDurabilityException.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.
<D extends Document<?>> D insert(D document, ReplicateTo replicateTo)
Insert a Document if it does not exist already and watch for durability constraints with the default key/value timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionDocumentAlreadyExistsExceptionRequestTooBigExceptionDurabilityException.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.
<D extends Document<?>> D insert(D document, ReplicateTo replicateTo, long timeout, TimeUnit timeUnit)
Insert a Document if it does not exist already and watch for durability constraints with a custom timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionDocumentAlreadyExistsExceptionRequestTooBigExceptionDurabilityException.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.
<D extends Document<?>> D upsert(D document)
Insert or replace a Document with the default key/value timeout.
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.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestTooBigExceptionRequestCancelledExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.<D extends Document<?>> D upsert(D document, long timeout, TimeUnit timeUnit)
Insert or replace a Document with a custom timeout.
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.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestTooBigExceptionRequestCancelledExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.<D extends Document<?>> D upsert(D document, PersistTo persistTo, ReplicateTo replicateTo)
Insert or replace a Document and watch for durability constraints with the default key/value timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionRequestTooBigExceptionDurabilityException.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.
<D extends Document<?>> D upsert(D document, PersistTo persistTo, ReplicateTo replicateTo, long timeout, TimeUnit timeUnit)
Insert or replace a Document and watch for durability constraints with a custom timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionRequestTooBigExceptionDurabilityException.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.
<D extends Document<?>> D upsert(D document, PersistTo persistTo)
Insert or replace a Document and watch for durability constraints with the default key/value timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionRequestTooBigExceptionDurabilityException.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.
<D extends Document<?>> D upsert(D document, PersistTo persistTo, long timeout, TimeUnit timeUnit)
Insert or replace a Document and watch for durability constraints with a custom timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionRequestTooBigExceptionDurabilityException.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.
<D extends Document<?>> D upsert(D document, ReplicateTo replicateTo)
Insert or replace a Document and watch for durability constraints with the default key/value timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionRequestTooBigExceptionDurabilityException.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.
<D extends Document<?>> D upsert(D document, ReplicateTo replicateTo, long timeout, TimeUnit timeUnit)
Insert or replace a Document and watch for durability constraints with a custom timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionRequestTooBigExceptionDurabilityException.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.
<D extends Document<?>> D replace(D document)
Replace a Document if it does already exist with the default key/value timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionDocumentDoesNotExistExceptionRequestTooBigExceptionCASMismatchExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.<D extends Document<?>> D replace(D document, long timeout, TimeUnit timeUnit)
Replace a Document if it does already exist with a custom timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionDocumentDoesNotExistExceptionRequestTooBigExceptionCASMismatchExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.<D extends Document<?>> D replace(D document, PersistTo persistTo, ReplicateTo replicateTo)
Replace a Document if it does exist and watch for durability constraints with the default key/value timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionDocumentDoesNotExistExceptionRequestTooBigExceptionDurabilityException.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.
<D extends Document<?>> D replace(D document, PersistTo persistTo, ReplicateTo replicateTo, long timeout, TimeUnit timeUnit)
Replace a Document if it does exist and watch for durability constraints with a custom timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionDocumentDoesNotExistExceptionRequestTooBigExceptionDurabilityException.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.
<D extends Document<?>> D replace(D document, PersistTo persistTo)
Replace a Document if it does exist and watch for durability constraints with the default key/value timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionDocumentDoesNotExistExceptionRequestTooBigExceptionDurabilityException.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.
<D extends Document<?>> D replace(D document, PersistTo persistTo, long timeout, TimeUnit timeUnit)
Replace a Document if it does exist and watch for durability constraints with a custom timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionDocumentDoesNotExistExceptionRequestTooBigExceptionDurabilityException.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.
<D extends Document<?>> D replace(D document, ReplicateTo replicateTo)
Replace a Document if it does exist and watch for durability constraints with the default key/value timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionDocumentDoesNotExistExceptionRequestTooBigExceptionDurabilityException.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.
<D extends Document<?>> D replace(D document, ReplicateTo replicateTo, long timeout, TimeUnit timeUnit)
Replace a Document if it does exist and watch for durability constraints with a custom timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionDocumentDoesNotExistExceptionRequestTooBigExceptionDurabilityException.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.
<D extends Document<?>> D remove(D document)
Removes a Document from the Server with the default key/value timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionDocument and it did not match with the server: CASMismatchExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionDocumentDoesNotExistExceptionCouchbaseException.document - the document to remove, with the ID extracted.<D extends Document<?>> D remove(D document, long timeout, TimeUnit timeUnit)
Removes a Document from the Server with a custom timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionDocument and it did not match with the server: CASMismatchExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionDocumentDoesNotExistExceptionCouchbaseException.document - the document to remove, with the ID extracted.timeout - the custom timeout.timeUnit - the unit for the timeout.<D extends Document<?>> D remove(D document, PersistTo persistTo, ReplicateTo replicateTo)
Removes a Document from the Server and apply a durability requirement with the default key/value timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionDurabilityException.Document and it did not match with the server: CASMismatchExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionDocumentDoesNotExistExceptionCouchbaseException.document - the document to remove, with the ID extracted.persistTo - the persistence constraint to watch.replicateTo - the replication constraint to watch.<D extends Document<?>> D remove(D document, PersistTo persistTo, ReplicateTo replicateTo, long timeout, TimeUnit timeUnit)
Removes a Document from the Server and apply a durability requirement with a custom timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionDurabilityException.Document and it did not match with the server: CASMismatchExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionDocumentDoesNotExistExceptionCouchbaseException.document - the document to remove, with the ID extracted.persistTo - the persistence constraint to watch.replicateTo - the replication constraint to watch.timeout - the custom timeout.timeUnit - the unit for the timeout.<D extends Document<?>> D remove(D document, PersistTo persistTo)
Removes a Document from the Server and apply a durability requirement with the default key/value timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionDurabilityException.Document and it did not match with the server: CASMismatchExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionDocumentDoesNotExistExceptionCouchbaseException.document - the document to remove, with the ID extracted.persistTo - the persistence constraint to watch.<D extends Document<?>> D remove(D document, PersistTo persistTo, long timeout, TimeUnit timeUnit)
Removes a Document from the Server and apply a durability requirement with a custom timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionDurabilityException.Document and it did not match with the server: CASMismatchExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionDocumentDoesNotExistExceptionCouchbaseException.document - the document to remove, with the ID extracted.persistTo - the persistence constraint to watch.timeout - the custom timeout.timeUnit - the unit for the timeout.<D extends Document<?>> D remove(D document, ReplicateTo replicateTo)
Removes a Document from the Server and apply a durability requirement with the default key/value timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionDurabilityException.Document and it did not match with the server: CASMismatchExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionDocumentDoesNotExistExceptionCouchbaseException.document - the document to remove, with the ID extracted.replicateTo - the replication constraint to watch.<D extends Document<?>> D remove(D document, ReplicateTo replicateTo, long timeout, TimeUnit timeUnit)
Removes a Document from the Server and apply a durability requirement with a custom timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionDurabilityException.Document and it did not match with the server: CASMismatchExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionDocumentDoesNotExistExceptionCouchbaseException.document - the document to remove, with the ID extracted.replicateTo - the replication constraint to watch.timeout - the custom timeout.timeUnit - the unit for the timeout.JsonDocument remove(String id)
Removes a Document from the Server identified by its ID with the default key/value timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionDocumentDoesNotExistExceptionCouchbaseException.id - the id of the document to remove.JsonDocument remove(String id, long timeout, TimeUnit timeUnit)
Removes a Document from the Server identified by its ID with a custom timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionDocumentDoesNotExistExceptionCouchbaseException.id - the id of the document to remove.timeout - the custom timeout.timeUnit - the unit for the timeout.JsonDocument remove(String id, PersistTo persistTo, ReplicateTo replicateTo)
Removes a Document from the Server by its ID and apply a durability requirement with the default key/value timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionDurabilityException.TemporaryFailureExceptionCouchbaseOutOfMemoryExceptionDocumentDoesNotExistExceptionCouchbaseException.id - the id of the document to remove.persistTo - the persistence constraint to watch.replicateTo - the replication constraint to watch.JsonDocument remove(String id, PersistTo persistTo, ReplicateTo replicateTo, long timeout, TimeUnit timeUnit)
Removes a Document from the Server by its ID and apply a durability requirement with a custom timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionDurabilityException.TemporaryFailureExceptionCouchbaseOutOfMemoryExceptionDocumentDoesNotExistExceptionCouchbaseException.id - the id of the document to remove.persistTo - the persistence constraint to watch.replicateTo - the replication constraint to watch.timeout - the custom timeout.timeUnit - the unit for the timeout.JsonDocument remove(String id, PersistTo persistTo)
Removes a Document from the Server by its ID and apply a durability requirement with the default key/value timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionDurabilityException.TemporaryFailureExceptionCouchbaseOutOfMemoryExceptionDocumentDoesNotExistExceptionCouchbaseException.id - the id of the document to remove.persistTo - the persistence constraint to watch.JsonDocument remove(String id, PersistTo persistTo, long timeout, TimeUnit timeUnit)
Removes a Document from the Server by its ID and apply a durability requirement with a custom timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionDurabilityException.TemporaryFailureExceptionCouchbaseOutOfMemoryExceptionDocumentDoesNotExistExceptionCouchbaseException.id - the id of the document to remove.persistTo - the persistence constraint to watch.timeout - the custom timeout.timeUnit - the unit for the timeout.JsonDocument remove(String id, ReplicateTo replicateTo)
Removes a Document from the Server by its ID and apply a durability requirement with the default key/value timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionDurabilityException.TemporaryFailureExceptionCouchbaseOutOfMemoryExceptionDocumentDoesNotExistExceptionCouchbaseException.id - the id of the document to remove.replicateTo - the replication constraint to watch.JsonDocument remove(String id, ReplicateTo replicateTo, long timeout, TimeUnit timeUnit)
Removes a Document from the Server by its ID and apply a durability requirement with a custom timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionDurabilityException.TemporaryFailureExceptionCouchbaseOutOfMemoryExceptionDocumentDoesNotExistExceptionCouchbaseException.id - the id of the document to remove.replicateTo - the replication constraint to watch.timeout - the custom timeout.timeUnit - the unit for the timeout.<D extends Document<?>> D remove(String id, Class<D> target)
Removes a Document from the Server identified by its ID with the default key/value timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionDocumentDoesNotExistExceptionCouchbaseException.id - the id of the document to remove.target - the target document type to use.<D extends Document<?>> D remove(String id, Class<D> target, long timeout, TimeUnit timeUnit)
Removes a Document from the Server identified by its ID with a custom timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionDocumentDoesNotExistExceptionCouchbaseException.id - the id of the document to remove.target - the target document type to use.timeout - the custom timeout.timeUnit - the unit for the timeout.<D extends Document<?>> 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 with the default key/value timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionDurabilityException.TemporaryFailureExceptionCouchbaseOutOfMemoryExceptionDocumentDoesNotExistExceptionCouchbaseException.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<?>> D remove(String id, PersistTo persistTo, ReplicateTo replicateTo, Class<D> target, long timeout, TimeUnit timeUnit)
Removes a Document from the Server by its ID and apply a durability requirement with a custom timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionDurabilityException.TemporaryFailureExceptionCouchbaseOutOfMemoryExceptionDocumentDoesNotExistExceptionCouchbaseException.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.timeout - the custom timeout.timeUnit - the unit for the timeout.<D extends Document<?>> D remove(String id, PersistTo persistTo, Class<D> target)
Removes a Document from the Server by its ID and apply a durability requirement with the default key/value timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionDurabilityException.TemporaryFailureExceptionCouchbaseOutOfMemoryExceptionDocumentDoesNotExistExceptionCouchbaseException.id - the id of the document to remove.persistTo - the persistence constraint to watch.target - the target document type to use.<D extends Document<?>> D remove(String id, PersistTo persistTo, Class<D> target, long timeout, TimeUnit timeUnit)
Removes a Document from the Server by its ID and apply a durability requirement with a custom timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionDurabilityException.TemporaryFailureExceptionCouchbaseOutOfMemoryExceptionDocumentDoesNotExistExceptionCouchbaseException.id - the id of the document to remove.persistTo - the persistence constraint to watch.target - the target document type to use.timeout - the custom timeout.timeUnit - the unit for the timeout.<D extends Document<?>> D remove(String id, ReplicateTo replicateTo, Class<D> target)
Removes a Document from the Server by its ID and apply a durability requirement with the default key/value timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionDurabilityException.TemporaryFailureExceptionCouchbaseOutOfMemoryExceptionDocumentDoesNotExistExceptionCouchbaseException.id - the id of the document to remove.replicateTo - the replication constraint to watch.target - the target document type to use.<D extends Document<?>> D remove(String id, ReplicateTo replicateTo, Class<D> target, long timeout, TimeUnit timeUnit)
Removes a Document from the Server by its ID and apply a durability requirement with a custom timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionDurabilityException.TemporaryFailureExceptionCouchbaseOutOfMemoryExceptionDocumentDoesNotExistExceptionCouchbaseException.id - the id of the document to remove.replicateTo - the replication constraint to watch.target - the target document type to use.timeout - the custom timeout.timeUnit - the unit for the timeout.ViewResult query(ViewQuery query)
Queries a Couchbase Server View with the default view timeout.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionViewDoesNotExistExceptionquery - the query to perform.SpatialViewResult query(SpatialViewQuery query)
Queries a Couchbase Server Spatial View with the default view timeout.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionViewDoesNotExistExceptionquery - the query to perform.ViewResult query(ViewQuery query, long timeout, TimeUnit timeUnit)
Queries a Couchbase Server View with a custom timeout.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionViewDoesNotExistExceptionquery - the query to perform.timeout - the custom timeout.timeUnit - the unit for the timeout.SpatialViewResult query(SpatialViewQuery query, long timeout, TimeUnit timeUnit)
Queries a Couchbase Server Spatial View with a custom timeout.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionViewDoesNotExistExceptionquery - the query to perform.timeout - the custom timeout.timeUnit - the unit for the timeout.N1qlQueryResult query(Statement statement)
Experimental: Queries a N1QL secondary index with the default query timeout. Said timeout includes the time it takes to retrieve all of the rows and errors from server.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionstatement - the statement in a DSL form (start with a static select() import)N1qlQueryResult query(Statement statement, long timeout, TimeUnit timeUnit)
Experimental: Queries a N1QL secondary index with a custom timeout. Said timeout includes the time it takes to retrieve all of the rows and errors from server.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionstatement - the statement in a DSL form (start with a static select() import)timeout - the custom full timeout, including the time to retrieve all rows, errors, etc…timeUnit - the unit for the timeout.N1qlQueryResult query(N1qlQuery query)
Experimental: Queries a N1QL secondary index with the default query timeout. Said timeout includes the time it takes to retrieve all of the rows and errors from server.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionquery - the full N1qlQuery, including statement and any other additional parameter.N1qlQueryResult query(N1qlQuery query, long timeout, TimeUnit timeUnit)
Experimental: Queries a N1QL secondary index with a custom timeout. Said timeout includes the time it takes to retrieve all of the rows and errors from server.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionquery - the full N1qlQuery, including statement and any other additional parameter.timeout - the custom full timeout, including the time to retrieve all rows, errors, etc…timeUnit - the unit for the timeout.Boolean unlock(String id, long cas)
Unlocks a write-locked Document with the default key/value timeout.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionDocumentDoesNotExistExceptionTemporaryLockFailureExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.id - the id of the document to unlock.cas - the CAS value which is mandatory to unlock it.Boolean unlock(String id, long cas, long timeout, TimeUnit timeUnit)
Unlocks a write-locked Document with a custom timeout.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionDocumentDoesNotExistExceptionTemporaryLockFailureExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.id - the id of the document to unlock.cas - the CAS value which is mandatory to unlock it.timeout - the custom timeout.timeUnit - the unit for the timeout.<D extends Document<?>> Boolean unlock(D document)
Unlocks a write-locked Document with the default key/value timeout.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionDocumentDoesNotExistExceptionTemporaryLockFailureExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.document - the document where ID and CAS are extracted from.<D extends Document<?>> Boolean unlock(D document, long timeout, TimeUnit timeUnit)
Unlocks a write-locked Document with a custom timeout.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionDocumentDoesNotExistExceptionTemporaryLockFailureExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.document - the document where ID and CAS are extracted from.timeout - the custom timeout.timeUnit - the unit for the timeout.Boolean touch(String id, int expiry)
Renews the expiration time of a Document with the default key/value timeout.
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.
This method throws under the following conditions:
DocumentDoesNotExistExceptionTimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.id - the id of the document.expiry - the new expiration time. 0 means no expiry.Boolean touch(String id, int expiry, long timeout, TimeUnit timeUnit)
Renews the expiration time of a Document with a custom timeout.
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.
This method throws under the following conditions:
DocumentDoesNotExistExceptionTimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.id - the id of the document.expiry - the new expiration time. 0 means no expiry.timeout - the custom timeout.timeUnit - the unit for the timeout.<D extends Document<?>> Boolean touch(D document)
Renews the expiration time of a Document with the default key/value timeout.
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.
This method throws under the following conditions:
DocumentDoesNotExistExceptionTimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.document - the document to extract the ID and expiry from.<D extends Document<?>> Boolean touch(D document, long timeout, TimeUnit timeUnit)
Renews the expiration time of a Document with a custom timeout.
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.
This method throws under the following conditions:
DocumentDoesNotExistExceptionTimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.document - the document to extract the ID and expiry from.timeout - the custom timeout.timeUnit - the unit for the timeout.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 with the default kvTimeout.
It is not allowed that the delta value will bring the actual value below zero.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionDocumentDoesNotExistException.CouchbaseException.id - the id of the document.delta - the increment or decrement amount.Document containing the resulting value.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 with the default kvTimeout.
It is not allowed that the delta value will bring the actual value below zero.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionDurabilityException.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.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 with the default kvTimeout.
It is not allowed that the delta value will bring the actual value below zero.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionDurabilityException.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.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 with the default kvTimeout.
It is not allowed that the delta value will bring the actual value below zero.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionDurabilityException.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.JsonLongDocument counter(String id, long delta, long timeout, TimeUnit timeUnit)
Increment or decrement a counter with the given value or throw an exception if it does not exist yet with a custom timeout.
It is not allowed that the delta value will bring the actual value below zero.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionDocumentDoesNotExistException.CouchbaseException.id - the id of the document.delta - the increment or decrement amount.timeout - the custom timeout.timeUnit - the unit for the timeout.Document containing the resulting value.JsonLongDocument counter(String id, long delta, PersistTo persistTo, long timeout, TimeUnit timeUnit)
Increment or decrement a counter with the given value or throw an exception if it does not exist yet with a custom timeout.
It is not allowed that the delta value will bring the actual value below zero.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionDurabilityException.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.timeout - the custom timeout.timeUnit - the unit for the timeout.Document containing the resulting value.JsonLongDocument counter(String id, long delta, ReplicateTo replicateTo, long timeout, TimeUnit timeUnit)
Increment or decrement a counter with the given value or throw an exception if it does not exist yet with a custom timeout.
It is not allowed that the delta value will bring the actual value below zero.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionDurabilityException.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.timeout - the custom timeout.timeUnit - the unit for the timeout.Document containing the resulting value.JsonLongDocument counter(String id, long delta, PersistTo persistTo, ReplicateTo replicateTo, long timeout, TimeUnit timeUnit)
Increment or decrement a counter with the given value or throw an exception if it does not exist yet with a custom timeout.
It is not allowed that the delta value will bring the actual value below zero.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionDurabilityException.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.timeout - the custom timeout.timeUnit - the unit for the timeout.Document containing the resulting value.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 with the default key/value timeout.
It is not allowed that the delta value will bring the actual value below zero.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.id - the id of the document.delta - the increment or decrement amount.initial - the initial value.Document containing the resulting value.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 with the default key/value timeout.
It is not allowed that the delta value will bring the actual value below zero.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionDurabilityException.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.persistTo - the persistence constraint to watch.Document containing the resulting value.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 with the default key/value timeout.
It is not allowed that the delta value will bring the actual value below zero.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionDurabilityException.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.replicateTo - the replication constraint to watch.Document containing the resulting value.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 with the default key/value timeout.
It is not allowed that the delta value will bring the actual value below zero.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionDurabilityException.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.persistTo - the persistence constraint to watch.replicateTo - the replication constraint to watch.Document containing the resulting value.JsonLongDocument counter(String id, long delta, long initial, long timeout, TimeUnit timeUnit)
Increment or decrement a counter with the given value and a initial value if it does not exist with a custom timeout.
It is not allowed that the delta value will bring the actual value below zero.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.id - the id of the document.delta - the increment or decrement amount.initial - the initial value.timeout - the custom timeout.timeUnit - the unit for the timeout.Document containing the resulting value.JsonLongDocument counter(String id, long delta, long initial, PersistTo persistTo, long timeout, TimeUnit timeUnit)
Increment or decrement a counter with the given value and a initial value if it does not exist with a custom timeout.
It is not allowed that the delta value will bring the actual value below zero.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionDurabilityException.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.persistTo - the persistence constraint to watch.timeout - the custom timeout.timeUnit - the unit for the timeout.Document containing the resulting value.JsonLongDocument counter(String id, long delta, long initial, ReplicateTo replicateTo, long timeout, TimeUnit timeUnit)
Increment or decrement a counter with the given value and a initial value if it does not exist with a custom timeout.
It is not allowed that the delta value will bring the actual value below zero.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionDurabilityException.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.replicateTo - the replication constraint to watch.timeout - the custom timeout.timeUnit - the unit for the timeout.Document containing the resulting value.JsonLongDocument counter(String id, long delta, long initial, PersistTo persistTo, ReplicateTo replicateTo, long timeout, TimeUnit timeUnit)
Increment or decrement a counter with the given value and a initial value if it does not exist with a custom timeout.
It is not allowed that the delta value will bring the actual value below zero.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionDurabilityException.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.persistTo - the persistence constraint to watch.replicateTo - the replication constraint to watch.timeout - the custom timeout.timeUnit - the unit for the timeout.Document containing the resulting value.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 with the default key/value timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.id - the id of the document.delta - the increment or decrement amount.initial - the initial value.expiry - the new expiration time of the counter.Document containing the resulting value.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 with the default key/value timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionDurabilityException.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.expiry - the new expiration time of the counter.persistTo - the persistence constraint to watch.Document containing the resulting value.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 with the default key/value timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionDurabilityException.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.expiry - the new expiration time of the counter.replicateTo - the replication constraint to watch.Document containing the resulting value.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 with the default key/value timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionDurabilityException.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.expiry - the new expiration time of the counter.persistTo - the persistence constraint to watch.replicateTo - the replication constraint to watch.Document containing the resulting value.JsonLongDocument counter(String id, long delta, long initial, int expiry, long timeout, TimeUnit timeUnit)
Increment or decrement a counter with the given value and a initial value if it does not exist with a custom timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.id - the id of the document.delta - the increment or decrement amount.initial - the initial value.expiry - the new expiration time of the counter.timeout - the custom timeout.timeUnit - the unit for the timeout.Document containing the resulting value.JsonLongDocument counter(String id, long delta, long initial, int expiry, PersistTo persistTo, long timeout, TimeUnit timeUnit)
Increment or decrement a counter with the given value and a initial value if it does not exist with a custom timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionDurabilityException.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.expiry - the new expiration time of the counter.persistTo - the persistence constraint to watch.timeout - the custom timeout.timeUnit - the unit for the timeout.Document containing the resulting value.JsonLongDocument counter(String id, long delta, long initial, int expiry, ReplicateTo replicateTo, long timeout, TimeUnit timeUnit)
Increment or decrement a counter with the given value and a initial value if it does not exist with a custom timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionDurabilityException.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.expiry - the new expiration time of the counter.replicateTo - the replication constraint to watch.timeout - the custom timeout.timeUnit - the unit for the timeout.Document containing the resulting value.JsonLongDocument counter(String id, long delta, long initial, int expiry, PersistTo persistTo, ReplicateTo replicateTo, long timeout, TimeUnit timeUnit)
Increment or decrement a counter with the given value and a initial value if it does not exist with a custom timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionDurabilityException.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.expiry - the new expiration time of the counter.persistTo - the persistence constraint to watch.replicateTo - the replication constraint to watch.timeout - the custom timeout.timeUnit - the unit for the timeout.Document containing the resulting value.<D extends Document<?>> D append(D document)
Append a Documents content to an existing one with the default key/value timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionRequestTooBigExceptionDocumentDoesNotExistExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.document - the document, identified by its id, from which the content is appended to the existing one.<D extends Document<?>> D append(D document, PersistTo persistTo)
Append a Documents content to an existing one with the default key/value timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionRequestTooBigExceptionDocumentDoesNotExistExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionDurabilityException.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<?>> D append(D document, ReplicateTo replicateTo)
Append a Documents content to an existing one with the default key/value timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionRequestTooBigExceptionDocumentDoesNotExistExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionDurabilityException.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<?>> D append(D document, PersistTo persistTo, ReplicateTo replicateTo)
Append a Documents content to an existing one with the default key/value timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionRequestTooBigExceptionDocumentDoesNotExistExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionDurabilityException.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<?>> D append(D document, long timeout, TimeUnit timeUnit)
Append a Documents content to an existing one with a custom timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionRequestTooBigExceptionDocumentDoesNotExistExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.document - the document, identified by its id, from which the content is appended to the existing one.timeout - the custom timeout.timeUnit - the unit for the timeout.<D extends Document<?>> D append(D document, PersistTo persistTo, long timeout, TimeUnit timeUnit)
Append a Documents content to an existing one with a custom timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionRequestTooBigExceptionDocumentDoesNotExistExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionDurabilityException.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.timeout - the custom timeout.timeUnit - the unit for the timeout.<D extends Document<?>> D append(D document, ReplicateTo replicateTo, long timeout, TimeUnit timeUnit)
Append a Documents content to an existing one with a custom timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionRequestTooBigExceptionDocumentDoesNotExistExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionDurabilityException.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.timeout - the custom timeout.timeUnit - the unit for the timeout.<D extends Document<?>> D append(D document, PersistTo persistTo, ReplicateTo replicateTo, long timeout, TimeUnit timeUnit)
Append a Documents content to an existing one with a custom timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionRequestTooBigExceptionDocumentDoesNotExistExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionDurabilityException.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.timeout - the custom timeout.timeUnit - the unit for the timeout.<D extends Document<?>> D prepend(D document)
Prepend a Documents content to an existing one with the default key/value timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionRequestTooBigExceptionDocumentDoesNotExistExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.document - the document, identified by its id, from which the content is prepended to the existing one.<D extends Document<?>> D prepend(D document, PersistTo persistTo)
Prepend a Documents content to an existing one with the default key/value timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionRequestTooBigExceptionDocumentDoesNotExistExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionDurabilityException.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<?>> D prepend(D document, ReplicateTo replicateTo)
Prepend a Documents content to an existing one with the default key/value timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionRequestTooBigExceptionDocumentDoesNotExistExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionDurabilityException.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<?>> D prepend(D document, PersistTo persistTo, ReplicateTo replicateTo)
Prepend a Documents content to an existing one with the default key/value timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionRequestTooBigExceptionDocumentDoesNotExistExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionDurabilityException.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.<D extends Document<?>> D prepend(D document, long timeout, TimeUnit timeUnit)
Prepend a Documents content to an existing one with a custom timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionRequestTooBigExceptionDocumentDoesNotExistExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionCouchbaseException.document - the document, identified by its id, from which the content is prepended to the existing one.timeout - the custom timeout.timeUnit - the unit for the timeout.<D extends Document<?>> D prepend(D document, PersistTo persistTo, long timeout, TimeUnit timeUnit)
Prepend a Documents content to an existing one with a custom timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionRequestTooBigExceptionDocumentDoesNotExistExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionDurabilityException.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.timeout - the custom timeout.timeUnit - the unit for the timeout.<D extends Document<?>> D prepend(D document, ReplicateTo replicateTo, long timeout, TimeUnit timeUnit)
Prepend a Documents content to an existing one with a custom timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionRequestTooBigExceptionDocumentDoesNotExistExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionDurabilityException.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.timeout - the custom timeout.timeUnit - the unit for the timeout.<D extends Document<?>> D prepend(D document, PersistTo persistTo, ReplicateTo replicateTo, long timeout, TimeUnit timeUnit)
Prepend a Documents content to an existing one with a custom timeout.
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.
This method throws under the following conditions:
TimeoutException wrapped in a RuntimeExceptionBackpressureExceptionRequestCancelledExceptionRequestTooBigExceptionDocumentDoesNotExistExceptionTemporaryFailureExceptionCouchbaseOutOfMemoryExceptionDurabilityException.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.timeout - the custom timeout.timeUnit - the unit for the timeout.int 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.
This method will not throw under any conditions.
BucketManager bucketManager()
Provides access to the BucketManager for administrative access.
The manager lets you perform operations such as flushing a bucket or creating and managing design documents.
@InterfaceAudience.Public @InterfaceStability.Experimental Repository 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.
Boolean close()
Closes this bucket with the default disconnect timeout.
Copyright © 2014 Couchbase, Inc.