Constructor and Description |
---|
CouchbaseBucket(AsyncBucket asyncBucket,
CouchbaseEnvironment env,
ClusterFacade core,
String name,
String username,
String password)
Create a
CouchbaseBucket that relies on the provided AsyncBucket . |
CouchbaseBucket(CouchbaseEnvironment env,
ClusterFacade core,
String name,
String username,
String password,
List<Transcoder<? extends Document,?>> customTranscoders)
Create a
CouchbaseBucket that doesn't reuse an existing AsyncBucket but rather creates one internally. |
Modifier and Type | Method and Description |
---|---|
<D extends Document<?>> |
append(D document)
Append a
Document s content to an existing one with the default key/value timeout. |
<D extends Document<?>> |
append(D document,
long timeout,
TimeUnit timeUnit)
Append a
Document s content to an existing one with a custom timeout. |
<D extends Document<?>> |
append(D document,
PersistTo persistTo)
Append a
Document s 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
Document s content to an existing one with a custom timeout. |
<D extends Document<?>> |
append(D document,
PersistTo persistTo,
ReplicateTo replicateTo)
Append a
Document s 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
Document s content to an existing one with a custom timeout. |
<D extends Document<?>> |
append(D document,
ReplicateTo replicateTo)
Append a
Document s 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
Document s 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.
|
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.
|
byte[] |
exportAnalyticsDeferredResultHandle(AnalyticsDeferredResultHandle handle)
Exports the deferred result handle to a serialized form which can be used across SDKs
|
<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. |
AnalyticsDeferredResultHandle |
importAnalyticsDeferredResultHandle(byte[] b)
Imports from json to create a
AnalyticsDeferredResultHandle . |
<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.
|
boolean |
isClosed()
Returns true if this bucket is already closed, false if it is still open.
|
<E> boolean |
listAppend(String docId,
E element)
Push an element to tail of CouchbaseList
This method throws under the following conditions:
- The producer outpaces the SDK:
BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- If the underlying couchbase document does not exist: DocumentDoesNotExistException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException . |
<E> boolean |
listAppend(String docId,
E element,
long timeout,
TimeUnit timeUnit)
Push an element to tail of CouchbaseList
This method throws under the following conditions:
- The producer outpaces the SDK:
BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- If the underlying couchbase document does not exist: DocumentDoesNotExistException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException . |
<E> boolean |
listAppend(String docId,
E element,
MutationOptionBuilder mutationOptionBuilder)
Push an element to tail of CouchbaseList with additional mutation options provided by
MutationOptionBuilder . |
<E> boolean |
listAppend(String docId,
E element,
MutationOptionBuilder mutationOptionBuilder,
long timeout,
TimeUnit timeUnit)
Push an element to tail of CouchbaseList with additional mutation options provided by
MutationOptionBuilder
This method throws under the following conditions:
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException . |
<E> E |
listGet(String docId,
int index,
Class<E> elementType)
Get element at an index in the CouchbaseList
This method throws under the following conditions:
- The producer outpaces the SDK:
BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- If the index is not found in the list PathNotFoundException
- If the underlying couchbase document does not exist: DocumentDoesNotExistException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException . |
<E> E |
listGet(String docId,
int index,
Class<E> elementType,
long timeout,
TimeUnit timeUnit)
Get element at an index in the CouchbaseList
This method throws under the following conditions:
- The producer outpaces the SDK:
BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- If the underlying couchbase document does not exist: DocumentDoesNotExistException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException . |
<E> boolean |
listPrepend(String docId,
E element)
Shift list head to element in CouchbaseList
This method throws under the following conditions:
- The producer outpaces the SDK:
BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException . |
<E> boolean |
listPrepend(String docId,
E element,
long timeout,
TimeUnit timeUnit)
Shift list head to element in CouchbaseList
This method throws under the following conditions:
- The producer outpaces the SDK:
BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- If the underlying couchbase document does not exist: DocumentDoesNotExistException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException . |
<E> boolean |
listPrepend(String docId,
E element,
MutationOptionBuilder mutationOptionBuilder)
Shift list head to element in CouchbaseList with additional mutation options provided by
MutationOptionBuilder
This method throws under the following conditions:
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException . |
<E> boolean |
listPrepend(String docId,
E element,
MutationOptionBuilder mutationOptionBuilder,
long timeout,
TimeUnit timeUnit)
Shift list head to element in CouchbaseList with additional mutation options provided by
MutationOptionBuilder
This method throws under the following conditions:
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException . |
boolean |
listRemove(String docId,
int index)
Remove an element from an index in CouchbaseList
This method throws under the following conditions:
-
IndexOutOfBoundsException if index is not found
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- If the underlying couchbase document does not exist: DocumentDoesNotExistException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException . |
boolean |
listRemove(String docId,
int index,
long timeout,
TimeUnit timeUnit)
Remove an element from an index in CouchbaseList
This method throws under the following conditions:
-
IndexOutOfBoundsException if index is not found
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- If the underlying couchbase document does not exist: DocumentDoesNotExistException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException . |
boolean |
listRemove(String docId,
int index,
MutationOptionBuilder mutationOptionBuilder)
Remove an element from an index in CouchbaseList with additional mutation options provided by
MutationOptionBuilder
This method throws under the following conditions:
- IndexOutOfBoundsException if index is not found
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- If the underlying couchbase document does not exist: DocumentDoesNotExistException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException . |
boolean |
listRemove(String docId,
int index,
MutationOptionBuilder mutationOptionBuilder,
long timeout,
TimeUnit timeUnit)
Remove an element from an index in CouchbaseList with additional mutation options provided by
MutationOptionBuilder
This method throws under the following conditions:
- IndexOutOfBoundsException if index is not found
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- If the underlying couchbase document does not exist: DocumentDoesNotExistException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException . |
<E> boolean |
listSet(String docId,
int index,
E element)
Add an element at an index in CouchbaseList
This method throws under the following conditions:
- The producer outpaces the SDK:
BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException . |
<E> boolean |
listSet(String docId,
int index,
E element,
long timeout,
TimeUnit timeUnit)
Add an element at an index in CouchbaseList
This method throws under the following conditions:
- The producer outpaces the SDK:
BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException . |
<E> boolean |
listSet(String docId,
int index,
E element,
MutationOptionBuilder mutationOptionBuilder)
Add an element at an index in CouchbaseList with additional mutation options provided by
MutationOptionBuilder
This method throws under the following conditions:
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException . |
<E> boolean |
listSet(String docId,
int index,
E element,
MutationOptionBuilder mutationOptionBuilder,
long timeout,
TimeUnit timeUnit)
Add an element at an index in CouchbaseList with additional mutation options provided by
MutationOptionBuilder
This method throws under the following conditions:
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException . |
int |
listSize(String docId)
Returns the number of elements in CouchbaseList
This method throws under the following conditions:
- The producer outpaces the SDK:
BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- If the underlying couchbase document does not exist: DocumentDoesNotExistException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException . |
int |
listSize(String docId,
long timeout,
TimeUnit timeUnit)
Returns the number of elements in CouchbaseList
This method throws under the following conditions:
- The producer outpaces the SDK:
BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- If the underlying couchbase document does not exist: DocumentDoesNotExistException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException . |
LookupInBuilder |
lookupIn(String docId)
Prepare a sub-document lookup through a
builder API . |
<V> boolean |
mapAdd(String docId,
String key,
V value)
Add a key value pair into CouchbaseMap
If the underlying document for the map does not exist, this operation will create a new document to back
the data structure.
|
<V> boolean |
mapAdd(String docId,
String key,
V value,
long timeout,
TimeUnit timeUnit)
Add a key value pair into CouchbaseMap
If the underlying document for the map does not exist, this operation will create a new document to back
the data structure.
|
<V> boolean |
mapAdd(String docId,
String key,
V value,
MutationOptionBuilder mutationOptionBuilder)
Add a key value pair into CouchbaseMap with additional mutation options provided by
MutationOptionBuilder
If the underlying document for the map does not exist, this operation will create a new document to back
the data structure. |
<V> boolean |
mapAdd(String docId,
String key,
V value,
MutationOptionBuilder mutationOptionBuilder,
long timeout,
TimeUnit timeUnit)
Add a key value pair into CouchbaseMap with additional mutation options provided by
MutationOptionBuilder
If the underlying document for the map does not exist, this operation will create a new document to back
the data structure. |
<V> V |
mapGet(String docId,
String key,
Class<V> valueType)
Get value of a key in the CouchbaseMap
This method throws under the following conditions:
- The producer outpaces the SDK:
BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- If the key is not found in the map PathNotFoundException
- If the underlying couchbase document does not exist: DocumentDoesNotExistException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException . |
<V> V |
mapGet(String docId,
String key,
Class<V> valueType,
long timeout,
TimeUnit timeUnit)
Get value of a key in the CouchbaseMap
This method throws under the following conditions:
- The producer outpaces the SDK:
BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- If the underlying couchbase document does not exist: DocumentDoesNotExistException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException . |
boolean |
mapRemove(String docId,
String key)
Remove a key value pair from CouchbaseMap
This method throws under the following conditions:
- The producer outpaces the SDK:
BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- If the underlying couchbase document does not exist: DocumentDoesNotExistException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException . |
boolean |
mapRemove(String docId,
String key,
long timeout,
TimeUnit timeUnit)
Remove a key value pair from CouchbaseMap
This method throws under the following conditions:
- The producer outpaces the SDK:
BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- If the underlying couchbase document does not exist: DocumentDoesNotExistException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException . |
boolean |
mapRemove(String docId,
String key,
MutationOptionBuilder mutationOptionBuilder)
Remove a key value pair from CouchbaseMap with additional mutation options provided by
MutationOptionBuilder . |
boolean |
mapRemove(String docId,
String key,
MutationOptionBuilder mutationOptionBuilder,
long timeout,
TimeUnit timeUnit)
Remove a key value pair from CouchbaseMap with additional mutation options provided by
MutationOptionBuilder . |
int |
mapSize(String docId)
Returns the number key value pairs in CouchbaseMap
This method throws under the following conditions:
- The producer outpaces the SDK:
BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- If the underlying couchbase document does not exist: DocumentDoesNotExistException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException . |
int |
mapSize(String docId,
long timeout,
TimeUnit timeUnit)
Returns the number key value pairs in CouchbaseMap
This method throws under the following conditions:
- The producer outpaces the SDK:
BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- If the underlying couchbase document does not exist: DocumentDoesNotExistException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException . |
MutateInBuilder |
mutateIn(String docId)
Prepare a sub-document mutation through a
builder API . |
String |
name()
The name of the
Bucket . |
PingReport |
ping()
Performs a diagnostic active "ping" call with a random report id on all services.
|
PingReport |
ping(Collection<ServiceType> services)
Performs a diagnostic active "ping" call with a random report id on all services.
|
PingReport |
ping(Collection<ServiceType> services,
long timeout,
TimeUnit timeUnit)
Performs a diagnostic active "ping" call on a list of services with a random report id.
|
PingReport |
ping(long timeout,
TimeUnit timeUnit)
Performs a diagnostic active "ping" call on all services with a random report id.
|
PingReport |
ping(String reportId)
Performs a diagnostic active "ping" call with a custom report ID on all services.
|
PingReport |
ping(String reportId,
Collection<ServiceType> services)
Performs a diagnostic active "ping" call with a custom report id on all services.
|
PingReport |
ping(String reportId,
Collection<ServiceType> services,
long timeout,
TimeUnit timeUnit)
Performs a diagnostic active "ping" call against all the services provided with a custom
report id.
|
PingReport |
ping(String reportId,
long timeout,
TimeUnit timeUnit)
Performs a diagnostic active "ping" call with a custom report ID on all services.
|
<D extends Document<?>> |
prepend(D document)
Prepend a
Document s content to an existing one with the default key/value timeout. |
<D extends Document<?>> |
prepend(D document,
long timeout,
TimeUnit timeUnit)
Prepend a
Document s content to an existing one with a custom timeout. |
<D extends Document<?>> |
prepend(D document,
PersistTo persistTo)
Prepend a
Document s 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
Document s content to an existing one with a custom timeout. |
<D extends Document<?>> |
prepend(D document,
PersistTo persistTo,
ReplicateTo replicateTo)
Prepend a
Document s 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
Document s content to an existing one with a custom timeout. |
<D extends Document<?>> |
prepend(D document,
ReplicateTo replicateTo)
Prepend a
Document s 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
Document s content to an existing one with a custom timeout. |
AnalyticsQueryResult |
query(AnalyticsQuery query)
Queries Couchbase Analytics
|
AnalyticsQueryResult |
query(AnalyticsQuery query,
long timeout,
TimeUnit timeUnit)
Queries Couchbase Analytics
|
N1qlQueryResult |
query(N1qlQuery query)
Queries a N1QL secondary index with the
default query timeout . |
N1qlQueryResult |
query(N1qlQuery query,
long timeout,
TimeUnit timeUnit)
Queries a N1QL secondary index with a custom timeout.
|
SearchQueryResult |
query(SearchQuery query)
Queries a Full-Text Index
This method throws under the following conditions:
- The producer outpaces the SDK:
BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException |
SearchQueryResult |
query(SearchQuery query,
long timeout,
TimeUnit timeUnit)
Queries a Full-Text Index
This method throws under the following conditions:
- The producer outpaces the SDK:
BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException |
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)
Queries a N1QL secondary index with the
default query timeout . |
N1qlQueryResult |
query(Statement statement,
long timeout,
TimeUnit timeUnit)
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. |
<E> E |
queuePop(String docId,
Class<E> elementType)
Removes the first element from CouchbaseQueue
This method throws under the following conditions:
- The producer outpaces the SDK:
BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- If the underlying couchbase document does not exist: DocumentDoesNotExistException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException . |
<E> E |
queuePop(String docId,
Class<E> elementType,
long timeout,
TimeUnit timeUnit)
Removes the first element from CouchbaseQueue
This method throws under the following conditions:
- The producer outpaces the SDK:
BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- If the underlying couchbase document does not exist: DocumentDoesNotExistException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException . |
<E> E |
queuePop(String docId,
Class<E> elementType,
MutationOptionBuilder mutationOptionBuilder)
Removes the first element from CouchbaseQueue with additional mutation options provided by
MutationOptionBuilder
This method throws under the following conditions:
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- If the underlying couchbase document does not exist: DocumentDoesNotExistException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException . |
<E> E |
queuePop(String docId,
Class<E> elementType,
MutationOptionBuilder mutationOptionBuilder,
long timeout,
TimeUnit timeUnit)
Removes the first element from CouchbaseQueue with additional mutation options provided by
MutationOptionBuilder
This method throws under the following conditions:
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- If the underlying couchbase document does not exist: DocumentDoesNotExistException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException . |
<E> boolean |
queuePush(String docId,
E element)
Add an element into CouchbaseQueue
This method throws under the following conditions:
- The producer outpaces the SDK:
BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- If the underlying couchbase document does not exist: DocumentDoesNotExistException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException . |
<E> boolean |
queuePush(String docId,
E element,
long timeout,
TimeUnit timeUnit)
Add an element into CouchbaseQueue
This method throws under the following conditions:
- The producer outpaces the SDK:
BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- If the underlying couchbase document does not exist: DocumentDoesNotExistException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException . |
<E> boolean |
queuePush(String docId,
E element,
MutationOptionBuilder mutationOptionBuilder)
Add an element into CouchbaseQueue with additional mutation options provided by
MutationOptionBuilder
This method throws under the following conditions:
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- If the underlying couchbase document does not exist: DocumentDoesNotExistException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException . |
<E> boolean |
queuePush(String docId,
E element,
MutationOptionBuilder mutationOptionBuilder,
long timeout,
TimeUnit timeUnit)
Add an element into CouchbaseQueue with additional mutation options provided by
MutationOptionBuilder
This method throws under the following conditions:
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- If the underlying couchbase document does not exist: DocumentDoesNotExistException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException . |
int |
queueSize(String docId)
Returns the number of elements in CouchbaseQueue
This method throws under the following conditions:
- The producer outpaces the SDK:
BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- If the underlying couchbase document does not exist: DocumentDoesNotExistException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException . |
int |
queueSize(String docId,
long timeout,
TimeUnit timeUnit)
Returns the number of elements in CouchbaseQueue
This method throws under the following conditions:
- The producer outpaces the SDK:
BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- If the underlying couchbase document does not exist: DocumentDoesNotExistException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException . |
<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. |
<E> boolean |
setAdd(String docId,
E element)
Add an element into CouchbaseSet
This method throws under the following conditions:
- The producer outpaces the SDK:
BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- If the underlying couchbase document does not exist: DocumentDoesNotExistException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException . |
<E> boolean |
setAdd(String docId,
E element,
long timeout,
TimeUnit timeUnit)
Add an element into CouchbaseSet
This method throws under the following conditions:
- The producer outpaces the SDK:
BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- If the underlying couchbase document does not exist: DocumentDoesNotExistException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException . |
<E> boolean |
setAdd(String docId,
E element,
MutationOptionBuilder mutationOptionBuilder)
Add an element into CouchbaseSet with additional mutation options provided by
MutationOptionBuilder
This method throws under the following conditions:
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- If the underlying couchbase document does not exist: DocumentDoesNotExistException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException . |
<E> boolean |
setAdd(String docId,
E element,
MutationOptionBuilder mutationOptionBuilder,
long timeout,
TimeUnit timeUnit)
Add an element into CouchbaseSet with additional mutation options provided by
MutationOptionBuilder
This method throws under the following conditions:
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- If the underlying couchbase document does not exist: DocumentDoesNotExistException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException . |
<E> boolean |
setContains(String docId,
E element)
Check if an element exists in CouchbaseSet
This method throws under the following conditions:
- The producer outpaces the SDK:
BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- If the underlying couchbase document does not exist: DocumentDoesNotExistException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException . |
<E> boolean |
setContains(String docId,
E element,
long timeout,
TimeUnit timeUnit)
Check if an element exists in CouchbaseSet
This method throws under the following conditions:
- The producer outpaces the SDK:
BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- If the underlying couchbase document does not exist: DocumentDoesNotExistException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException . |
<E> E |
setRemove(String docId,
E element)
Removes an element from CouchbaseSet
This method throws under the following conditions:
- The producer outpaces the SDK:
BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- If the underlying couchbase document does not exist: DocumentDoesNotExistException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException . |
<E> E |
setRemove(String docId,
E element,
long timeout,
TimeUnit timeUnit)
Removes an element from CouchbaseSet
This method throws under the following conditions:
- The producer outpaces the SDK:
BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- If the underlying couchbase document does not exist: DocumentDoesNotExistException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException . |
<E> E |
setRemove(String docId,
E element,
MutationOptionBuilder mutationOptionBuilder)
Removes an element from CouchbaseSet with additional mutation options provided by
MutationOptionBuilder
This method throws under the following conditions:
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- If the underlying couchbase document does not exist: DocumentDoesNotExistException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException . |
<E> E |
setRemove(String docId,
E element,
MutationOptionBuilder mutationOptionBuilder,
long timeout,
TimeUnit timeUnit)
Removes an element from CouchbaseSet with additional mutation options provided by
MutationOptionBuilder
This method throws under the following conditions:
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- If the underlying couchbase document does not exist: DocumentDoesNotExistException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException . |
int |
setSize(String docId)
Returns the number of elements in CouchbaseSet
This method throws under the following conditions:
- The producer outpaces the SDK:
BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- If the underlying couchbase document does not exist: DocumentDoesNotExistException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException . |
int |
setSize(String docId,
long timeout,
TimeUnit timeUnit)
Returns the number of elements in CouchbaseSet
This method throws under the following conditions:
- The producer outpaces the SDK:
BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- If the underlying couchbase document does not exist: DocumentDoesNotExistException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException . |
String |
toString() |
<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 overwrite a
Document with the default key/value timeout. |
<D extends Document<?>> |
upsert(D document,
long timeout,
TimeUnit timeUnit)
Insert or overwrite a
Document with a custom timeout. |
<D extends Document<?>> |
upsert(D document,
PersistTo persistTo)
Insert or overwrite 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 overwrite a
Document and watch for durability constraints with a custom timeout. |
<D extends Document<?>> |
upsert(D document,
PersistTo persistTo,
ReplicateTo replicateTo)
Insert or overwrite 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 overwrite a
Document and watch for durability constraints with a custom timeout. |
<D extends Document<?>> |
upsert(D document,
ReplicateTo replicateTo)
Insert or overwrite 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 overwrite a
Document and watch for durability constraints with a custom timeout. |
public CouchbaseBucket(CouchbaseEnvironment env, ClusterFacade core, String name, String username, String password, List<Transcoder<? extends Document,?>> customTranscoders)
CouchbaseBucket
that doesn't reuse an existing AsyncBucket
but rather creates one internally. Prefer using the alternative constructor
CouchbaseBucket(AsyncBucket, CouchbaseEnvironment, ClusterFacade, String, String, String)
if you can obtain an AsyncBucket externally.public CouchbaseBucket(AsyncBucket asyncBucket, CouchbaseEnvironment env, ClusterFacade core, String name, String username, String password)
CouchbaseBucket
that relies on the provided AsyncBucket
.public AsyncBucket async()
Bucket
public ClusterFacade core()
Bucket
ClusterFacade
.
Handle with care, with great power comes great responsibility. All additional checks which are normally performed
by this library are skipped.core
in interface Bucket
ClusterFacade
from the "core-io" package.public CouchbaseEnvironment environment()
Bucket
CouchbaseEnvironment
used.environment
in interface Bucket
public Repository repository()
Bucket
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.repository
in interface Bucket
public JsonDocument get(String id)
Bucket
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:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.get
in interface Bucket
id
- the unique ID of the document.JsonDocument
or null if not found.public JsonDocument get(String id, long timeout, TimeUnit timeUnit)
Bucket
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:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.get
in interface Bucket
id
- the unique ID of the document.timeout
- the custom timeout.timeUnit
- the unit for the timeout.JsonDocument
or null if not found.public <D extends Document<?>> D get(D document)
Bucket
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:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.public <D extends Document<?>> D get(D document, long timeout, TimeUnit timeUnit)
Bucket
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:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.public <D extends Document<?>> D get(String id, Class<D> target)
Bucket
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:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.public <D extends Document<?>> D get(String id, Class<D> target, long timeout, TimeUnit timeUnit)
Bucket
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:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.public boolean exists(String id)
Bucket
TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.public boolean exists(String id, long timeout, TimeUnit timeUnit)
Bucket
TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.public <D extends Document<?>> boolean exists(D document)
Bucket
TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.public <D extends Document<?>> boolean exists(D document, long timeout, TimeUnit timeUnit)
Bucket
TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.public List<JsonDocument> getFromReplica(String id, ReplicaMode type)
Bucket
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:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
getFromReplica
in interface Bucket
id
- id the unique ID of the document.type
- the ReplicaMode
to select.JsonDocument
s.public List<JsonDocument> getFromReplica(String id, ReplicaMode type, long timeout, TimeUnit timeUnit)
Bucket
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:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
getFromReplica
in interface Bucket
id
- id the unique ID of the document.type
- the ReplicaMode
to select.timeout
- the custom timeout.timeUnit
- the unit for the timeout.JsonDocument
s.public <D extends Document<?>> List<D> getFromReplica(D document, ReplicaMode type)
Bucket
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:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
getFromReplica
in interface Bucket
document
- the document to extract the ID from.type
- the ReplicaMode
to select.JsonDocument
s.public <D extends Document<?>> List<D> getFromReplica(D document, ReplicaMode type, long timeout, TimeUnit timeUnit)
Bucket
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:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
getFromReplica
in interface Bucket
document
- the document to extract the ID from.type
- the ReplicaMode
to select.timeout
- the custom timeout.timeUnit
- the unit for the timeout.JsonDocument
s.public <D extends Document<?>> List<D> getFromReplica(String id, ReplicaMode type, Class<D> target)
Bucket
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:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
getFromReplica
in interface Bucket
id
- the id of the document.type
- the ReplicaMode
to select.JsonDocument
s.public <D extends Document<?>> List<D> getFromReplica(String id, ReplicaMode type, Class<D> target, long timeout, TimeUnit timeUnit)
Bucket
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:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
getFromReplica
in interface Bucket
id
- 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.JsonDocument
s.public Iterator<JsonDocument> getFromReplica(String id)
Bucket
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:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
getFromReplica
in interface Bucket
id
- the unique ID of the document.public <D extends Document<?>> Iterator<D> getFromReplica(D document)
Bucket
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:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
getFromReplica
in interface Bucket
document
- the document to extract the ID from.public <D extends Document<?>> Iterator<D> getFromReplica(String id, Class<D> target)
Bucket
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:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
getFromReplica
in interface Bucket
id
- the unique ID of the document.target
- the target document type to use.public <D extends Document<?>> Iterator<D> getFromReplica(String id, Class<D> target, long timeout, TimeUnit timeUnit)
Bucket
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:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
getFromReplica
in interface Bucket
id
- the unique ID of the document.target
- the target document type to use.timeout
- the custom timeout.timeUnit
- the unit for the timeout.public <D extends Document<?>> Iterator<D> getFromReplica(D document, long timeout, TimeUnit timeUnit)
Bucket
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:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
getFromReplica
in interface Bucket
document
- the document to extract the ID from.timeout
- the custom timeout.timeUnit
- the unit for the timeout.public Iterator<JsonDocument> getFromReplica(String id, long timeout, TimeUnit timeUnit)
Bucket
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:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
getFromReplica
in interface Bucket
id
- the unique ID of the document.timeout
- the custom timeout.timeUnit
- the unit for the timeout.public JsonDocument getAndLock(String id, int lockTime)
Bucket
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 Bucket.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:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- A transient error occurred, most probably the key was already locked: TemporaryLockFailureException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.getAndLock
in interface Bucket
id
- id the unique ID of the document.lockTime
- the time to write lock the document (max. 30 seconds).JsonDocument
or null.public JsonDocument getAndLock(String id, int lockTime, long timeout, TimeUnit timeUnit)
Bucket
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 Bucket.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:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- A transient error occurred, most probably the key was already locked: TemporaryLockFailureException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.getAndLock
in interface Bucket
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.public <D extends Document<?>> D getAndLock(D document, int lockTime)
Bucket
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 Bucket.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:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- A transient error occurred, most probably the key was already locked: TemporaryLockFailureException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.getAndLock
in interface Bucket
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.public <D extends Document<?>> D getAndLock(D document, int lockTime, long timeout, TimeUnit timeUnit)
Bucket
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 Bucket.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:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- A transient error occurred, most probably the key was already locked: TemporaryLockFailureException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.getAndLock
in interface Bucket
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.public <D extends Document<?>> D getAndLock(String id, int lockTime, Class<D> target)
Bucket
Document
by its unique ID with the default key/value timeout.
This method differs from Bucket.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 Bucket.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:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- A transient error occurred, most probably the key was already locked: TemporaryLockFailureException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.getAndLock
in interface Bucket
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.public <D extends Document<?>> D getAndLock(String id, int lockTime, Class<D> target, long timeout, TimeUnit timeUnit)
Bucket
Document
by its unique ID with the a custom timeout.
This method differs from Bucket.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 Bucket.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:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- A transient error occurred, most probably the key was already locked: TemporaryLockFailureException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.getAndLock
in interface Bucket
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.public JsonDocument getAndTouch(String id, int expiry)
Bucket
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 Bucket.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:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.getAndTouch
in interface Bucket
id
- id the unique ID of the document.expiry
- the new expiration time for the document.JsonDocument
or null.public JsonDocument getAndTouch(String id, int expiry, long timeout, TimeUnit timeUnit)
Bucket
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 Bucket.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:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.getAndTouch
in interface Bucket
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.public <D extends Document<?>> D getAndTouch(D document)
Bucket
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 Bucket.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:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.getAndTouch
in interface Bucket
document
- the source document from which the ID and expiry is taken and the type is inferred.Document
or null.public <D extends Document<?>> D getAndTouch(D document, long timeout, TimeUnit timeUnit)
Bucket
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 Bucket.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:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.getAndTouch
in interface Bucket
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.public <D extends Document<?>> D getAndTouch(String id, int expiry, Class<D> target)
Bucket
Document
by its unique ID with the default key/value timeout.
This method differs from Bucket.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 Bucket.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:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.getAndTouch
in interface Bucket
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.public <D extends Document<?>> D getAndTouch(String id, int expiry, Class<D> target, long timeout, TimeUnit timeUnit)
Bucket
Document
by its unique ID with a custom timeout.
This method differs from Bucket.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 Bucket.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:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.getAndTouch
in interface Bucket
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.public <D extends Document<?>> D insert(D document)
Bucket
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
,
Bucket.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,
Bucket.insert(Document, PersistTo, ReplicateTo)
should be used instead.
This method throws under the following conditions:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The request content is too big: RequestTooBigException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.public <D extends Document<?>> D insert(D document, long timeout, TimeUnit timeUnit)
Bucket
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
,
Bucket.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,
Bucket.insert(Document, PersistTo, ReplicateTo)
should be used instead.
This method throws under the following conditions:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The request content is too big: RequestTooBigException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.public <D extends Document<?>> D insert(D document, PersistTo persistTo, ReplicateTo replicateTo)
Bucket
Document
if it does not exist already and watch for durability constraints with the default
key/value timeout.
This method works exactly like Bucket.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:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The original insert failed because the document is already stored: DocumentAlreadyExistsException
- The request content is too big: RequestTooBigException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.
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.**public <D extends Document<?>> D insert(D document, PersistTo persistTo, ReplicateTo replicateTo, long timeout, TimeUnit timeUnit)
Bucket
Document
if it does not exist already and watch for durability constraints with a custom timeout.
This method works exactly like Bucket.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:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The original insert failed because the document is already stored: DocumentAlreadyExistsException
- The request content is too big: RequestTooBigException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.
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.**public <D extends Document<?>> D insert(D document, PersistTo persistTo)
Bucket
Document
if it does not exist already and watch for durability constraints with the default
key/value timeout.
This method works exactly like Bucket.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:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The original insert failed because the document is already stored: DocumentAlreadyExistsException
- The request content is too big: RequestTooBigException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.
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.**public <D extends Document<?>> D insert(D document, PersistTo persistTo, long timeout, TimeUnit timeUnit)
Bucket
Document
if it does not exist already and watch for durability constraints with a custom timeout.
This method works exactly like Bucket.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:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The original insert failed because the document is already stored: DocumentAlreadyExistsException
- The request content is too big: RequestTooBigException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.
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.**public <D extends Document<?>> D insert(D document, ReplicateTo replicateTo)
Bucket
Document
if it does not exist already and watch for durability constraints with the default
key/value timeout.
This method works exactly like Bucket.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:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The original insert failed because the document is already stored: DocumentAlreadyExistsException
- The request content is too big: RequestTooBigException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.
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.**public <D extends Document<?>> D insert(D document, ReplicateTo replicateTo, long timeout, TimeUnit timeUnit)
Bucket
Document
if it does not exist already and watch for durability constraints with a custom timeout.
This method works exactly like Bucket.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:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The original insert failed because the document is already stored: DocumentAlreadyExistsException
- The request content is too big: RequestTooBigException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.
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.**public <D extends Document<?>> D upsert(D document)
Bucket
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.
Please note that this method will not use the Document.cas()
for optimistic concurrency checks. If
this behavior is needed, the Bucket.replace(Document)
method needs to be used.
This operation will return successfully if the Document
has been acknowledged in the managed cache layer
on the master server node. If increased data durability is a concern,
Bucket.upsert(Document, PersistTo, ReplicateTo)
should be used instead.
This method throws under the following conditions:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The request content is too big: RequestTooBigException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.public <D extends Document<?>> D upsert(D document, long timeout, TimeUnit timeUnit)
Bucket
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.
Please note that this method will not use the Document.cas()
for optimistic concurrency checks. If
this behavior is needed, the Bucket.replace(Document, long, TimeUnit)
method needs to be used.
This operation will return successfully if the Document
has been acknowledged in the managed cache layer
on the master server node. If increased data durability is a concern,
Bucket.upsert(Document, PersistTo, ReplicateTo)
should be used instead.
This method throws under the following conditions:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The request content is too big: RequestTooBigException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.public <D extends Document<?>> D upsert(D document, PersistTo persistTo, ReplicateTo replicateTo)
Bucket
Document
and watch for durability constraints with the default key/value timeout.
This method works exactly like Bucket.upsert(Document)
, but afterwards watches the server states if the given
durability constraints are met. If this is the case, a new document is returned which contains the original
properties, but has the refreshed CAS value set.
Please note that this method will not use the Document.cas()
for optimistic concurrency checks. If
this behavior is needed, the Bucket.replace(Document, PersistTo, ReplicateTo)
method needs to be used.
This method throws under the following conditions:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The request content is too big: RequestTooBigException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.
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.**public <D extends Document<?>> D upsert(D document, PersistTo persistTo, ReplicateTo replicateTo, long timeout, TimeUnit timeUnit)
Bucket
Document
and watch for durability constraints with a custom timeout.
This method works exactly like Bucket.upsert(Document)
, but afterwards watches the server states if the given
durability constraints are met. If this is the case, a new document is returned which contains the original
properties, but has the refreshed CAS value set.
Please note that this method will not use the Document.cas()
for optimistic concurrency checks. If
this behavior is needed, the Bucket.replace(Document, PersistTo, ReplicateTo, long, TimeUnit)
method needs to be used.
This method throws under the following conditions:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The request content is too big: RequestTooBigException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.
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.**public <D extends Document<?>> D upsert(D document, PersistTo persistTo)
Bucket
Document
and watch for durability constraints with the default key/value timeout.
This method works exactly like Bucket.upsert(Document)
, but afterwards watches the server states if the given
durability constraints are met. If this is the case, a new document is returned which contains the original
properties, but has the refreshed CAS value set.
Please note that this method will not use the Document.cas()
for optimistic concurrency checks. If
this behavior is needed, the Bucket.replace(Document, PersistTo)
method needs to be used.
This method throws under the following conditions:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The request content is too big: RequestTooBigException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.
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.**public <D extends Document<?>> D upsert(D document, PersistTo persistTo, long timeout, TimeUnit timeUnit)
Bucket
Document
and watch for durability constraints with a custom timeout.
This method works exactly like Bucket.upsert(Document)
, but afterwards watches the server states if the given
durability constraints are met. If this is the case, a new document is returned which contains the original
properties, but has the refreshed CAS value set.
Please note that this method will not use the Document.cas()
for optimistic concurrency checks. If
this behavior is needed, the Bucket.replace(Document, PersistTo, long, TimeUnit)
method needs to be used.
This method throws under the following conditions:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The request content is too big: RequestTooBigException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.
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.**public <D extends Document<?>> D upsert(D document, ReplicateTo replicateTo)
Bucket
Document
and watch for durability constraints with the default key/value timeout.
This method works exactly like Bucket.upsert(Document)
, but afterwards watches the server states if the given
durability constraints are met. If this is the case, a new document is returned which contains the original
properties, but has the refreshed CAS value set.
Please note that this method will not use the Document.cas()
for optimistic concurrency checks. If
this behavior is needed, the Bucket.replace(Document, ReplicateTo)
method needs to be used.
This method throws under the following conditions:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The request content is too big: RequestTooBigException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.
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.**public <D extends Document<?>> D upsert(D document, ReplicateTo replicateTo, long timeout, TimeUnit timeUnit)
Bucket
Document
and watch for durability constraints with a custom timeout.
This method works exactly like Bucket.upsert(Document)
, but afterwards watches the server states if the given
durability constraints are met. If this is the case, a new document is returned which contains the original
properties, but has the refreshed CAS value set.
Please note that this method will not use the Document.cas()
for optimistic concurrency checks. If
this behavior is needed, the Bucket.replace(Document, ReplicateTo, long, TimeUnit)
method needs to be used.
This method throws under the following conditions:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The request content is too big: RequestTooBigException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.
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.**public <D extends Document<?>> D replace(D document)
Bucket
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
,
Bucket.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,
Bucket.replace(Document, PersistTo, ReplicateTo)
should be used instead.
This method throws under the following conditions:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The original replace failed because the document does not exist: DocumentDoesNotExistException
- The request content is too big: RequestTooBigException
- A CAS value was set and it did not match with the server: CASMismatchException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.public <D extends Document<?>> D replace(D document, long timeout, TimeUnit timeUnit)
Bucket
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
,
Bucket.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,
Bucket.replace(Document, PersistTo, ReplicateTo)
should be used instead.
This method throws under the following conditions:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The original replace failed because the document does not exist: DocumentDoesNotExistException
- The request content is too big: RequestTooBigException
- A CAS value was set and it did not match with the server: CASMismatchException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.public <D extends Document<?>> D replace(D document, PersistTo persistTo, ReplicateTo replicateTo)
Bucket
Document
if it does exist and watch for durability constraints with the default key/value
timeout.
This method works exactly like Bucket.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:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The original replace failed because the document does not exist: DocumentDoesNotExistException
- The request content is too big: RequestTooBigException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- A CAS value was set and it did not match with the server: CASMismatchException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.
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.**public <D extends Document<?>> D replace(D document, PersistTo persistTo, ReplicateTo replicateTo, long timeout, TimeUnit timeUnit)
Bucket
Document
if it does exist and watch for durability constraints with a custom timeout.
This method works exactly like Bucket.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:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The original replace failed because the document does not exist: DocumentDoesNotExistException
- The request content is too big: RequestTooBigException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- A CAS value was set and it did not match with the server: CASMismatchException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.
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.**public <D extends Document<?>> D replace(D document, PersistTo persistTo)
Bucket
Document
if it does exist and watch for durability constraints with the default key/value
timeout.
This method works exactly like Bucket.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:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The original replace failed because the document does not exist: DocumentDoesNotExistException
- The request content is too big: RequestTooBigException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- A CAS value was set and it did not match with the server: CASMismatchException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.
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.**public <D extends Document<?>> D replace(D document, PersistTo persistTo, long timeout, TimeUnit timeUnit)
Bucket
Document
if it does exist and watch for durability constraints with a custom timeout.
This method works exactly like Bucket.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:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The original replace failed because the document does not exist: DocumentDoesNotExistException
- The request content is too big: RequestTooBigException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- A CAS value was set and it did not match with the server: CASMismatchException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.
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.**public <D extends Document<?>> D replace(D document, ReplicateTo replicateTo)
Bucket
Document
if it does exist and watch for durability constraints with the default key/value
timeout.
This method works exactly like Bucket.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:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The original replace failed because the document does not exist: DocumentDoesNotExistException
- The request content is too big: RequestTooBigException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- A CAS value was set and it did not match with the server: CASMismatchException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.
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.**public <D extends Document<?>> D replace(D document, ReplicateTo replicateTo, long timeout, TimeUnit timeUnit)
Bucket
Document
if it does exist and watch for durability constraints with a custom timeout.
This method works exactly like Bucket.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:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The original replace failed because the document does not exist: DocumentDoesNotExistException
- The request content is too big: RequestTooBigException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- A CAS value was set and it did not match with the server: CASMismatchException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.
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.**public <D extends Document<?>> D remove(D document)
Bucket
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:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- A CAS value was set on the Document
and it did not match with the server: CASMismatchException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- The document to remove does not exist: DocumentDoesNotExistException
- Unexpected errors are caught and contained in a generic CouchbaseException
.public <D extends Document<?>> D remove(D document, PersistTo persistTo, ReplicateTo replicateTo)
Bucket
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:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- A CAS value was set on the Document
and it did not match with the server: CASMismatchException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- The document to remove does not exist: DocumentDoesNotExistException
- Unexpected errors are caught and contained in a generic CouchbaseException
.public <D extends Document<?>> D remove(D document, PersistTo persistTo)
Bucket
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:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- A CAS value was set on the Document
and it did not match with the server: CASMismatchException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- The document to remove does not exist: DocumentDoesNotExistException
- Unexpected errors are caught and contained in a generic CouchbaseException
.public <D extends Document<?>> D remove(D document, ReplicateTo replicateTo)
Bucket
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:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- A CAS value was set on the Document
and it did not match with the server: CASMismatchException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- The document to remove does not exist: DocumentDoesNotExistException
- Unexpected errors are caught and contained in a generic CouchbaseException
.public <D extends Document<?>> D remove(D document, long timeout, TimeUnit timeUnit)
Bucket
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:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- A CAS value was set on the Document
and it did not match with the server: CASMismatchException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- The document to remove does not exist: DocumentDoesNotExistException
- Unexpected errors are caught and contained in a generic CouchbaseException
.public <D extends Document<?>> D remove(D document, PersistTo persistTo, ReplicateTo replicateTo, long timeout, TimeUnit timeUnit)
Bucket
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:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- A CAS value was set on the Document
and it did not match with the server: CASMismatchException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- The document to remove does not exist: DocumentDoesNotExistException
- Unexpected errors are caught and contained in a generic CouchbaseException
.remove
in interface Bucket
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.public <D extends Document<?>> D remove(D document, PersistTo persistTo, long timeout, TimeUnit timeUnit)
Bucket
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:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- A CAS value was set on the Document
and it did not match with the server: CASMismatchException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- The document to remove does not exist: DocumentDoesNotExistException
- Unexpected errors are caught and contained in a generic CouchbaseException
.public <D extends Document<?>> D remove(D document, ReplicateTo replicateTo, long timeout, TimeUnit timeUnit)
Bucket
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:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- A CAS value was set on the Document
and it did not match with the server: CASMismatchException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- The document to remove does not exist: DocumentDoesNotExistException
- Unexpected errors are caught and contained in a generic CouchbaseException
.public JsonDocument remove(String id)
Bucket
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:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- The document to remove does not exist: DocumentDoesNotExistException
- Unexpected errors are caught and contained in a generic CouchbaseException
.public JsonDocument remove(String id, PersistTo persistTo, ReplicateTo replicateTo)
Bucket
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:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- The document to remove does not exist: DocumentDoesNotExistException
- Unexpected errors are caught and contained in a generic CouchbaseException
.public JsonDocument remove(String id, PersistTo persistTo)
Bucket
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:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- The document to remove does not exist: DocumentDoesNotExistException
- Unexpected errors are caught and contained in a generic CouchbaseException
.public JsonDocument remove(String id, ReplicateTo replicateTo)
Bucket
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:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- The document to remove does not exist: DocumentDoesNotExistException
- Unexpected errors are caught and contained in a generic CouchbaseException
.public JsonDocument remove(String id, long timeout, TimeUnit timeUnit)
Bucket
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:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- The document to remove does not exist: DocumentDoesNotExistException
- Unexpected errors are caught and contained in a generic CouchbaseException
.public JsonDocument remove(String id, PersistTo persistTo, ReplicateTo replicateTo, long timeout, TimeUnit timeUnit)
Bucket
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:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- The document to remove does not exist: DocumentDoesNotExistException
- Unexpected errors are caught and contained in a generic CouchbaseException
.public JsonDocument remove(String id, PersistTo persistTo, long timeout, TimeUnit timeUnit)
Bucket
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:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- The document to remove does not exist: DocumentDoesNotExistException
- Unexpected errors are caught and contained in a generic CouchbaseException
.public JsonDocument remove(String id, ReplicateTo replicateTo, long timeout, TimeUnit timeUnit)
Bucket
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:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- The document to remove does not exist: DocumentDoesNotExistException
- Unexpected errors are caught and contained in a generic CouchbaseException
.public <D extends Document<?>> D remove(String id, Class<D> target)
Bucket
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:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- The document to remove does not exist: DocumentDoesNotExistException
- Unexpected errors are caught and contained in a generic CouchbaseException
.public <D extends Document<?>> D remove(String id, PersistTo persistTo, ReplicateTo replicateTo, Class<D> target)
Bucket
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:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- The document to remove does not exist: DocumentDoesNotExistException
- Unexpected errors are caught and contained in a generic CouchbaseException
.public <D extends Document<?>> D remove(String id, PersistTo persistTo, Class<D> target)
Bucket
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:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- The document to remove does not exist: DocumentDoesNotExistException
- Unexpected errors are caught and contained in a generic CouchbaseException
.public <D extends Document<?>> D remove(String id, ReplicateTo replicateTo, Class<D> target)
Bucket
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:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- The document to remove does not exist: DocumentDoesNotExistException
- Unexpected errors are caught and contained in a generic CouchbaseException
.public <D extends Document<?>> D remove(String id, Class<D> target, long timeout, TimeUnit timeUnit)
Bucket
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:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- The document to remove does not exist: DocumentDoesNotExistException
- Unexpected errors are caught and contained in a generic CouchbaseException
.public <D extends Document<?>> D remove(String id, PersistTo persistTo, ReplicateTo replicateTo, Class<D> target, long timeout, TimeUnit timeUnit)
Bucket
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:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- The document to remove does not exist: DocumentDoesNotExistException
- Unexpected errors are caught and contained in a generic CouchbaseException
.remove
in interface Bucket
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.public <D extends Document<?>> D remove(String id, PersistTo persistTo, Class<D> target, long timeout, TimeUnit timeUnit)
Bucket
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:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- The document to remove does not exist: DocumentDoesNotExistException
- Unexpected errors are caught and contained in a generic CouchbaseException
.public <D extends Document<?>> D remove(String id, ReplicateTo replicateTo, Class<D> target, long timeout, TimeUnit timeUnit)
Bucket
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:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- The document to remove does not exist: DocumentDoesNotExistException
- Unexpected errors are caught and contained in a generic CouchbaseException
.public ViewResult query(ViewQuery query)
Bucket
View
with the default view timeout
.
This method throws under the following conditions:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- If the design document or view is not found: ViewDoesNotExistException
public N1qlQueryResult query(Statement statement)
Bucket
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:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
public N1qlQueryResult query(N1qlQuery query)
Bucket
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:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
public SearchQueryResult query(SearchQuery query)
Bucket
BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
public SearchQueryResult query(SearchQuery query, long timeout, TimeUnit timeUnit)
Bucket
BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
public AnalyticsQueryResult query(AnalyticsQuery query)
Bucket
public AnalyticsQueryResult query(AnalyticsQuery query, long timeout, TimeUnit timeUnit)
Bucket
public SpatialViewResult query(SpatialViewQuery query)
Bucket
View
with the default view timeout
.
This method throws under the following conditions:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- If the design document or view is not found: ViewDoesNotExistException
public ViewResult query(ViewQuery query, long timeout, TimeUnit timeUnit)
Bucket
View
with a custom timeout.
This method throws under the following conditions:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- If the design document or view is not found: ViewDoesNotExistException
public SpatialViewResult query(SpatialViewQuery query, long timeout, TimeUnit timeUnit)
Bucket
View
with a custom timeout.
This method throws under the following conditions:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- If the design document or view is not found: ViewDoesNotExistException
public N1qlQueryResult query(Statement statement, long timeout, TimeUnit timeUnit)
Bucket
TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
query
in interface Bucket
statement
- 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.public N1qlQueryResult query(N1qlQuery query, long timeout, TimeUnit timeUnit)
Bucket
TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
query
in interface Bucket
query
- 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.public Boolean unlock(String id, long cas)
Bucket
Document
with the default key/value timeout.
This method throws under the following conditions:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The document does not exist: DocumentDoesNotExistException
- A transient error occurred, most probably the CAS value was not correct: TemporaryLockFailureException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.public <D extends Document<?>> Boolean unlock(D document)
Bucket
Document
with the default key/value timeout.
This method throws under the following conditions:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The document does not exist: DocumentDoesNotExistException
- A transient error occurred, most probably the CAS value was not correct: TemporaryLockFailureException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.public Boolean unlock(String id, long cas, long timeout, TimeUnit timeUnit)
Bucket
Document
with a custom timeout.
This method throws under the following conditions:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The document does not exist: DocumentDoesNotExistException
- A transient error occurred, most probably the CAS value was not correct: TemporaryLockFailureException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.public <D extends Document<?>> Boolean unlock(D document, long timeout, TimeUnit timeUnit)
Bucket
Document
with a custom timeout.
This method throws under the following conditions:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The document does not exist: DocumentDoesNotExistException
- A transient error occurred, most probably the CAS value was not correct: TemporaryLockFailureException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.public Boolean touch(String id, int expiry)
Bucket
Document
with the default key/value timeout.
Compared to Bucket.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:
- The document doesn't exist: DocumentDoesNotExistException
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.public <D extends Document<?>> Boolean touch(D document)
Bucket
Document
with the default key/value timeout.
Compared to Bucket.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:
- The document doesn't exist: DocumentDoesNotExistException
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.public Boolean touch(String id, int expiry, long timeout, TimeUnit timeUnit)
Bucket
Document
with a custom timeout.
Compared to Bucket.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:
- The document doesn't exist: DocumentDoesNotExistException
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.public <D extends Document<?>> Boolean touch(D document, long timeout, TimeUnit timeUnit)
Bucket
Document
with a custom timeout.
Compared to Bucket.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:
- The document doesn't exist: DocumentDoesNotExistException
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.public JsonLongDocument counter(String id, long delta)
Bucket
#counter)
or using
Bucket.insert(D)
to create a JsonLongDocument
. The value can also be modified by using Bucket.upsert(D)
with JsonLongDocument
.
It is not allowed that the delta value will bring the actual value below zero.
This method throws under the following conditions:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- If the document does not exist: DocumentDoesNotExistException
.
- Unexpected errors are caught and contained in a generic CouchbaseException
.public JsonLongDocument counter(String id, long delta, long initial)
Bucket
#counter)
or using
Bucket.insert(D)
to create a JsonLongDocument
. The value can also be modified by using Bucket.upsert(D)
with JsonLongDocument
.
It is not allowed that the delta value will bring the actual value below zero.
This method throws under the following conditions:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.public JsonLongDocument counter(String id, long delta, long initial, int expiry)
Bucket
#counter)
or using
Bucket.insert(D)
to create a JsonLongDocument
. The value can also be modified by using Bucket.upsert(D)
with JsonLongDocument
.
This method throws under the following conditions:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.public JsonLongDocument counter(String id, long delta, long timeout, TimeUnit timeUnit)
Bucket
#counter)
or using
Bucket.insert(D)
to create a JsonLongDocument
. The value can also be modified by using Bucket.upsert(D)
with JsonLongDocument
.
It is not allowed that the delta value will bring the actual value below zero.
This method throws under the following conditions:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- If the document does not exist: DocumentDoesNotExistException
.
- Unexpected errors are caught and contained in a generic CouchbaseException
.public JsonLongDocument counter(String id, long delta, long initial, long timeout, TimeUnit timeUnit)
Bucket
#counter)
or using
Bucket.insert(D)
to create a JsonLongDocument
. The value can also be modified by using Bucket.upsert(D)
with JsonLongDocument
.
It is not allowed that the delta value will bring the actual value below zero.
This method throws under the following conditions:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.public JsonLongDocument counter(String id, long delta, long initial, int expiry, long timeout, TimeUnit timeUnit)
Bucket
#counter)
or using
Bucket.insert(D)
to create a JsonLongDocument
. The value can also be modified by using Bucket.upsert(D)
with JsonLongDocument
.
This method throws under the following conditions:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.counter
in interface Bucket
id
- the id of the document.delta
- the increment or decrement amount.initial
- the initial value.expiry
- the new expiration time for the document, only used on creation.timeout
- the custom timeout.timeUnit
- the unit for the timeout.Document
containing the resulting value.public BucketManager bucketManager()
Bucket
BucketManager
for administrative access.
The manager lets you perform operations such as flushing a bucket or creating and managing design documents.bucketManager
in interface Bucket
public <D extends Document<?>> D append(D document)
Bucket
Document
s 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 Bucket.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 JsonDocument
s in all
forms are not supported, it is advised that the following ones are used:
- LegacyDocument
- StringDocument
- BinaryDocument
Note that this method does not support expiration on the Document
. If set, it will be ignored.
This method throws under the following conditions:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The request content is too big: RequestTooBigException
- If the document does not exist: DocumentDoesNotExistException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.public <D extends Document<?>> D prepend(D document)
Bucket
Document
s 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 Bucket.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 JsonDocument
s in all
forms are not supported, it is advised that the following ones are used:
- LegacyDocument
- StringDocument
- BinaryDocument
Note that this method does not support expiration on the Document
. If set, it will be ignored.
This method throws under the following conditions:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The request content is too big: RequestTooBigException
- If the document does not exist: DocumentDoesNotExistException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.public <D extends Document<?>> D append(D document, long timeout, TimeUnit timeUnit)
Bucket
Document
s 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 Bucket.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 JsonDocument
s in all
forms are not supported, it is advised that the following ones are used:
- LegacyDocument
- StringDocument
- BinaryDocument
Note that this method does not support expiration on the Document
. If set, it will be ignored.
This method throws under the following conditions:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The request content is too big: RequestTooBigException
- If the document does not exist: DocumentDoesNotExistException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.public <D extends Document<?>> D prepend(D document, long timeout, TimeUnit timeUnit)
Bucket
Document
s 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 Bucket.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 JsonDocument
s in all
forms are not supported, it is advised that the following ones are used:
- LegacyDocument
- StringDocument
- BinaryDocument
Note that this method does not support expiration on the Document
. If set, it will be ignored.
This method throws under the following conditions:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The request content is too big: RequestTooBigException
- If the document does not exist: DocumentDoesNotExistException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.public JsonLongDocument counter(String id, long delta, PersistTo persistTo)
Bucket
#counter)
or using
Bucket.insert(D)
to create a JsonLongDocument
. The value can also be modified by using Bucket.upsert(D)
with JsonLongDocument
.
It is not allowed that the delta value will bring the actual value below zero.
This method throws under the following conditions:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- If the document does not exist: DocumentDoesNotExistException
.
- Unexpected errors are caught and contained in a generic 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.**public JsonLongDocument counter(String id, long delta, ReplicateTo replicateTo)
Bucket
#counter)
or using
Bucket.insert(D)
to create a JsonLongDocument
. The value can also be modified by using Bucket.upsert(D)
with JsonLongDocument
.
It is not allowed that the delta value will bring the actual value below zero.
This method throws under the following conditions:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- If the document does not exist: DocumentDoesNotExistException
.
- Unexpected errors are caught and contained in a generic 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.**public JsonLongDocument counter(String id, long delta, PersistTo persistTo, ReplicateTo replicateTo)
Bucket
#counter)
or using
Bucket.insert(D)
to create a JsonLongDocument
. The value can also be modified by using Bucket.upsert(D)
with JsonLongDocument
.
It is not allowed that the delta value will bring the actual value below zero.
This method throws under the following conditions:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- If the document does not exist: DocumentDoesNotExistException
.
- Unexpected errors are caught and contained in a generic 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.**public JsonLongDocument counter(String id, long delta, PersistTo persistTo, long timeout, TimeUnit timeUnit)
Bucket
#counter)
or using
Bucket.insert(D)
to create a JsonLongDocument
. The value can also be modified by using Bucket.upsert(D)
with JsonLongDocument
.
It is not allowed that the delta value will bring the actual value below zero.
This method throws under the following conditions:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- If the document does not exist: DocumentDoesNotExistException
.
- Unexpected errors are caught and contained in a generic 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.**public JsonLongDocument counter(String id, long delta, ReplicateTo replicateTo, long timeout, TimeUnit timeUnit)
Bucket
#counter)
or using
Bucket.insert(D)
to create a JsonLongDocument
. The value can also be modified by using Bucket.upsert(D)
with JsonLongDocument
.
It is not allowed that the delta value will bring the actual value below zero.
This method throws under the following conditions:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- If the document does not exist: DocumentDoesNotExistException
.
- Unexpected errors are caught and contained in a generic 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.**public JsonLongDocument counter(String id, long delta, long initial, PersistTo persistTo)
Bucket
#counter)
or using
Bucket.insert(D)
to create a JsonLongDocument
. The value can also be modified by using Bucket.upsert(D)
with JsonLongDocument
.
It is not allowed that the delta value will bring the actual value below zero.
This method throws under the following conditions:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- Unexpected errors are caught and contained in a generic 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.**public JsonLongDocument counter(String id, long delta, long initial, ReplicateTo replicateTo)
Bucket
#counter)
or using
Bucket.insert(D)
to create a JsonLongDocument
. The value can also be modified by using Bucket.upsert(D)
with JsonLongDocument
.
It is not allowed that the delta value will bring the actual value below zero.
This method throws under the following conditions:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- Unexpected errors are caught and contained in a generic 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.**public JsonLongDocument counter(String id, long delta, long initial, PersistTo persistTo, ReplicateTo replicateTo)
Bucket
#counter)
or using
Bucket.insert(D)
to create a JsonLongDocument
. The value can also be modified by using Bucket.upsert(D)
with JsonLongDocument
.
It is not allowed that the delta value will bring the actual value below zero.
This method throws under the following conditions:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- Unexpected errors are caught and contained in a generic 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.**counter
in interface Bucket
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.public JsonLongDocument counter(String id, long delta, long initial, PersistTo persistTo, long timeout, TimeUnit timeUnit)
Bucket
#counter)
or using
Bucket.insert(D)
to create a JsonLongDocument
. The value can also be modified by using Bucket.upsert(D)
with JsonLongDocument
.
It is not allowed that the delta value will bring the actual value below zero.
This method throws under the following conditions:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- Unexpected errors are caught and contained in a generic 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.**counter
in interface Bucket
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.public JsonLongDocument counter(String id, long delta, long initial, ReplicateTo replicateTo, long timeout, TimeUnit timeUnit)
Bucket
#counter)
or using
Bucket.insert(D)
to create a JsonLongDocument
. The value can also be modified by using Bucket.upsert(D)
with JsonLongDocument
.
It is not allowed that the delta value will bring the actual value below zero.
This method throws under the following conditions:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- Unexpected errors are caught and contained in a generic 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.**counter
in interface Bucket
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.public JsonLongDocument counter(String id, long delta, long initial, int expiry, PersistTo persistTo)
Bucket
#counter)
or using
Bucket.insert(D)
to create a JsonLongDocument
. The value can also be modified by using Bucket.upsert(D)
with JsonLongDocument
.
This method throws under the following conditions:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- Unexpected errors are caught and contained in a generic 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.**counter
in interface Bucket
id
- the id of the document.delta
- the increment or decrement amount.initial
- the initial value.expiry
- the new expiration time for the document, only used on creation.persistTo
- the persistence constraint to watch.Document
containing the resulting value.public JsonLongDocument counter(String id, long delta, long initial, int expiry, ReplicateTo replicateTo)
Bucket
#counter)
or using
Bucket.insert(D)
to create a JsonLongDocument
. The value can also be modified by using Bucket.upsert(D)
with JsonLongDocument
.
This method throws under the following conditions:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- Unexpected errors are caught and contained in a generic 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.**counter
in interface Bucket
id
- the id of the document.delta
- the increment or decrement amount.initial
- the initial value.expiry
- the new expiration time for the document, only used on creation.replicateTo
- the replication constraint to watch.Document
containing the resulting value.public JsonLongDocument counter(String id, long delta, long initial, int expiry, PersistTo persistTo, ReplicateTo replicateTo)
Bucket
#counter)
or using
Bucket.insert(D)
to create a JsonLongDocument
. The value can also be modified by using Bucket.upsert(D)
with JsonLongDocument
.
This method throws under the following conditions:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- Unexpected errors are caught and contained in a generic 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.**counter
in interface Bucket
id
- the id of the document.delta
- the increment or decrement amount.initial
- the initial value.expiry
- the new expiration time for the document, only used on creation.persistTo
- the persistence constraint to watch.replicateTo
- the replication constraint to watch.Document
containing the resulting value.public JsonLongDocument counter(String id, long delta, long initial, int expiry, PersistTo persistTo, long timeout, TimeUnit timeUnit)
Bucket
#counter)
or using
Bucket.insert(D)
to create a JsonLongDocument
. The value can also be modified by using Bucket.upsert(D)
with JsonLongDocument
.
This method throws under the following conditions:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- Unexpected errors are caught and contained in a generic 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.**counter
in interface Bucket
id
- the id of the document.delta
- the increment or decrement amount.initial
- the initial value.expiry
- the new expiration time for the document, only used on creation.persistTo
- the persistence constraint to watch.timeout
- the custom timeout.timeUnit
- the unit for the timeout.Document
containing the resulting value.public JsonLongDocument counter(String id, long delta, long initial, int expiry, ReplicateTo replicateTo, long timeout, TimeUnit timeUnit)
Bucket
#counter)
or using
Bucket.insert(D)
to create a JsonLongDocument
. The value can also be modified by using Bucket.upsert(D)
with JsonLongDocument
.
This method throws under the following conditions:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- Unexpected errors are caught and contained in a generic 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.**counter
in interface Bucket
id
- the id of the document.delta
- the increment or decrement amount.initial
- the initial value.expiry
- the new expiration time for the document, only used on creation.replicateTo
- the replication constraint to watch.timeout
- the custom timeout.timeUnit
- the unit for the timeout.Document
containing the resulting value.public JsonLongDocument counter(String id, long delta, PersistTo persistTo, ReplicateTo replicateTo, long timeout, TimeUnit timeUnit)
Bucket
#counter)
or using
Bucket.insert(D)
to create a JsonLongDocument
. The value can also be modified by using Bucket.upsert(D)
with JsonLongDocument
.
It is not allowed that the delta value will bring the actual value below zero.
This method throws under the following conditions:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- If the document does not exist: DocumentDoesNotExistException
.
- Unexpected errors are caught and contained in a generic 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.**counter
in interface Bucket
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.public JsonLongDocument counter(String id, long delta, long initial, PersistTo persistTo, ReplicateTo replicateTo, long timeout, TimeUnit timeUnit)
Bucket
#counter)
or using
Bucket.insert(D)
to create a JsonLongDocument
. The value can also be modified by using Bucket.upsert(D)
with JsonLongDocument
.
It is not allowed that the delta value will bring the actual value below zero.
This method throws under the following conditions:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- Unexpected errors are caught and contained in a generic 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.**counter
in interface Bucket
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.public JsonLongDocument counter(String id, long delta, long initial, int expiry, PersistTo persistTo, ReplicateTo replicateTo, long timeout, TimeUnit timeUnit)
Bucket
#counter)
or using
Bucket.insert(D)
to create a JsonLongDocument
. The value can also be modified by using Bucket.upsert(D)
with JsonLongDocument
.
This method throws under the following conditions:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- Unexpected errors are caught and contained in a generic 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.**counter
in interface Bucket
id
- the id of the document.delta
- the increment or decrement amount.initial
- the initial value.expiry
- the new expiration time for the document, only used on creation.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.public <D extends Document<?>> D append(D document, PersistTo persistTo)
Bucket
Document
s 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 Bucket.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 JsonDocument
s in all
forms are not supported, it is advised that the following ones are used:
- LegacyDocument
- StringDocument
- BinaryDocument
Note that this method does not support expiration on the Document
. If set, it will be ignored.
This method throws under the following conditions:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The request content is too big: RequestTooBigException
- If the document does not exist: DocumentDoesNotExistException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- Unexpected errors are caught and contained in a generic 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.**public <D extends Document<?>> D append(D document, ReplicateTo replicateTo)
Bucket
Document
s 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 Bucket.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 JsonDocument
s in all
forms are not supported, it is advised that the following ones are used:
- LegacyDocument
- StringDocument
- BinaryDocument
Note that this method does not support expiration on the Document
. If set, it will be ignored.
This method throws under the following conditions:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The request content is too big: RequestTooBigException
- If the document does not exist: DocumentDoesNotExistException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- Unexpected errors are caught and contained in a generic 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.**public <D extends Document<?>> D append(D document, PersistTo persistTo, ReplicateTo replicateTo)
Bucket
Document
s 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 Bucket.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 JsonDocument
s in all
forms are not supported, it is advised that the following ones are used:
- LegacyDocument
- StringDocument
- BinaryDocument
Note that this method does not support expiration on the Document
. If set, it will be ignored.
This method throws under the following conditions:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The request content is too big: RequestTooBigException
- If the document does not exist: DocumentDoesNotExistException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- Unexpected errors are caught and contained in a generic 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.**append
in interface Bucket
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.public <D extends Document<?>> D append(D document, PersistTo persistTo, long timeout, TimeUnit timeUnit)
Bucket
Document
s 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 Bucket.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 JsonDocument
s in all
forms are not supported, it is advised that the following ones are used:
- LegacyDocument
- StringDocument
- BinaryDocument
Note that this method does not support expiration on the Document
. If set, it will be ignored.
This method throws under the following conditions:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The request content is too big: RequestTooBigException
- If the document does not exist: DocumentDoesNotExistException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- Unexpected errors are caught and contained in a generic 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.**append
in interface Bucket
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.public <D extends Document<?>> D append(D document, ReplicateTo replicateTo, long timeout, TimeUnit timeUnit)
Bucket
Document
s 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 Bucket.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 JsonDocument
s in all
forms are not supported, it is advised that the following ones are used:
- LegacyDocument
- StringDocument
- BinaryDocument
Note that this method does not support expiration on the Document
. If set, it will be ignored.
This method throws under the following conditions:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The request content is too big: RequestTooBigException
- If the document does not exist: DocumentDoesNotExistException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- Unexpected errors are caught and contained in a generic 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.**append
in interface Bucket
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.public <D extends Document<?>> D append(D document, PersistTo persistTo, ReplicateTo replicateTo, long timeout, TimeUnit timeUnit)
Bucket
Document
s 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 Bucket.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 JsonDocument
s in all
forms are not supported, it is advised that the following ones are used:
- LegacyDocument
- StringDocument
- BinaryDocument
Note that this method does not support expiration on the Document
. If set, it will be ignored.
This method throws under the following conditions:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The request content is too big: RequestTooBigException
- If the document does not exist: DocumentDoesNotExistException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- Unexpected errors are caught and contained in a generic 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.**append
in interface Bucket
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.public <D extends Document<?>> D prepend(D document, PersistTo persistTo)
Bucket
Document
s 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 Bucket.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 JsonDocument
s in all
forms are not supported, it is advised that the following ones are used:
- LegacyDocument
- StringDocument
- BinaryDocument
Note that this method does not support expiration on the Document
. If set, it will be ignored.
This method throws under the following conditions:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The request content is too big: RequestTooBigException
- If the document does not exist: DocumentDoesNotExistException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- Unexpected errors are caught and contained in a generic 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.**public <D extends Document<?>> D prepend(D document, ReplicateTo replicateTo)
Bucket
Document
s 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 Bucket.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 JsonDocument
s in all
forms are not supported, it is advised that the following ones are used:
- LegacyDocument
- StringDocument
- BinaryDocument
Note that this method does not support expiration on the Document
. If set, it will be ignored.
This method throws under the following conditions:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The request content is too big: RequestTooBigException
- If the document does not exist: DocumentDoesNotExistException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- Unexpected errors are caught and contained in a generic 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.**public <D extends Document<?>> D prepend(D document, PersistTo persistTo, ReplicateTo replicateTo)
Bucket
Document
s 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 Bucket.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 JsonDocument
s in all
forms are not supported, it is advised that the following ones are used:
- LegacyDocument
- StringDocument
- BinaryDocument
Note that this method does not support expiration on the Document
. If set, it will be ignored.
This method throws under the following conditions:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The request content is too big: RequestTooBigException
- If the document does not exist: DocumentDoesNotExistException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- Unexpected errors are caught and contained in a generic 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.**prepend
in interface Bucket
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.public <D extends Document<?>> D prepend(D document, PersistTo persistTo, long timeout, TimeUnit timeUnit)
Bucket
Document
s 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 Bucket.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 JsonDocument
s in all
forms are not supported, it is advised that the following ones are used:
- LegacyDocument
- StringDocument
- BinaryDocument
Note that this method does not support expiration on the Document
. If set, it will be ignored.
This method throws under the following conditions:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The request content is too big: RequestTooBigException
- If the document does not exist: DocumentDoesNotExistException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- Unexpected errors are caught and contained in a generic 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.**prepend
in interface Bucket
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.public <D extends Document<?>> D prepend(D document, ReplicateTo replicateTo, long timeout, TimeUnit timeUnit)
Bucket
Document
s 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 Bucket.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 JsonDocument
s in all
forms are not supported, it is advised that the following ones are used:
- LegacyDocument
- StringDocument
- BinaryDocument
Note that this method does not support expiration on the Document
. If set, it will be ignored.
This method throws under the following conditions:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The request content is too big: RequestTooBigException
- If the document does not exist: DocumentDoesNotExistException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- Unexpected errors are caught and contained in a generic 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.**prepend
in interface Bucket
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.public <D extends Document<?>> D prepend(D document, PersistTo persistTo, ReplicateTo replicateTo, long timeout, TimeUnit timeUnit)
Bucket
Document
s 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 Bucket.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 JsonDocument
s in all
forms are not supported, it is advised that the following ones are used:
- LegacyDocument
- StringDocument
- BinaryDocument
Note that this method does not support expiration on the Document
. If set, it will be ignored.
This method throws under the following conditions:
- The operation takes longer than the specified timeout: TimeoutException
wrapped in a RuntimeException
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The request content is too big: RequestTooBigException
- If the document does not exist: DocumentDoesNotExistException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- Unexpected errors are caught and contained in a generic 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.**prepend
in interface Bucket
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.public LookupInBuilder lookupIn(String docId)
Bucket
builder API
. You can use the builder to
describe one or several lookup operations inside an existing JsonDocument
, then execute the lookup
synchronously by calling the LookupInBuilder.execute()
method. Only the paths that you looked up
inside the document will be transferred over the wire, limiting the network overhead for large documents.lookupIn
in interface Bucket
docId
- the id of the JSON document to lookup in.LookupInBuilder.execute()
public MutateInBuilder mutateIn(String docId)
Bucket
builder API
. You can use the builder to
describe one or several mutation operations inside an existing JsonDocument
, then execute them
synchronously by calling the MutateInBuilder.execute()
method. Only the values that you want
mutated inside the document will be transferred over the wire, limiting the network overhead for large documents.
A get followed by a replace of the whole document isn't needed anymore.
Note that you can set the expiry, check the CAS and ask for durability constraints in the builder using methods
prefixed by "with": withExpiry
,
withCas
,
withDurability
.mutateIn
in interface Bucket
docId
- the id of the JSON document to mutate in.MutateInBuilder.execute()
public <V> boolean mapAdd(String docId, String key, V value)
Bucket
BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.public <V> boolean mapAdd(String docId, String key, V value, long timeout, TimeUnit timeUnit)
Bucket
BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.public <V> boolean mapAdd(String docId, String key, V value, MutationOptionBuilder mutationOptionBuilder)
Bucket
MutationOptionBuilder
If the underlying document for the map does not exist, this operation will create a new document to back
the data structure.
This method throws under the following conditions:
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- A CAS value was set and it did not match with the server: CASMismatchException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.mapAdd
in interface Bucket
docId
- document id backing the mapkey
- key to be storedvalue
- value to be storedmutationOptionBuilder
- mutation options MutationOptionBuilder
public <V> boolean mapAdd(String docId, String key, V value, MutationOptionBuilder mutationOptionBuilder, long timeout, TimeUnit timeUnit)
Bucket
MutationOptionBuilder
If the underlying document for the map does not exist, this operation will create a new document to back
the data structure.
This method throws under the following conditions:
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- A CAS value was set and it did not match with the server: CASMismatchException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.mapAdd
in interface Bucket
docId
- document id backing the mapkey
- key to be storedvalue
- value to be storedmutationOptionBuilder
- mutation options MutationOptionBuilder
timeout
- the custom timeout.timeUnit
- the unit for the timeout.public <V> V mapGet(String docId, String key, Class<V> valueType)
Bucket
BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- If the key is not found in the map PathNotFoundException
- If the underlying couchbase document does not exist: DocumentDoesNotExistException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.public <V> V mapGet(String docId, String key, Class<V> valueType, long timeout, TimeUnit timeUnit)
Bucket
BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- If the underlying couchbase document does not exist: DocumentDoesNotExistException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.public boolean mapRemove(String docId, String key)
Bucket
BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- If the underlying couchbase document does not exist: DocumentDoesNotExistException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.public boolean mapRemove(String docId, String key, long timeout, TimeUnit timeUnit)
Bucket
BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- If the underlying couchbase document does not exist: DocumentDoesNotExistException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.public boolean mapRemove(String docId, String key, MutationOptionBuilder mutationOptionBuilder)
Bucket
MutationOptionBuilder
.
This method throws under the following conditions:
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- If the underlying couchbase document does not exist: DocumentDoesNotExistException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- A CAS value was set and it did not match with the server: CASMismatchException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.public boolean mapRemove(String docId, String key, MutationOptionBuilder mutationOptionBuilder, long timeout, TimeUnit timeUnit)
Bucket
MutationOptionBuilder
.
This method throws under the following conditions:
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- If the underlying couchbase document does not exist: DocumentDoesNotExistException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- A CAS value was set and it did not match with the server: CASMismatchException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.public int mapSize(String docId)
Bucket
BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- If the underlying couchbase document does not exist: DocumentDoesNotExistException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.public int mapSize(String docId, long timeout, TimeUnit timeUnit)
Bucket
BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- If the underlying couchbase document does not exist: DocumentDoesNotExistException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.public <E> E listGet(String docId, int index, Class<E> elementType)
Bucket
BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- If the index is not found in the list PathNotFoundException
- If the underlying couchbase document does not exist: DocumentDoesNotExistException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.public <E> E listGet(String docId, int index, Class<E> elementType, long timeout, TimeUnit timeUnit)
Bucket
BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- If the underlying couchbase document does not exist: DocumentDoesNotExistException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.public <E> boolean listAppend(String docId, E element)
Bucket
BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- If the underlying couchbase document does not exist: DocumentDoesNotExistException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.listAppend
in interface Bucket
docId
- document id backing the listelement
- element to be pushed into the queuepublic <E> boolean listAppend(String docId, E element, long timeout, TimeUnit timeUnit)
Bucket
BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- If the underlying couchbase document does not exist: DocumentDoesNotExistException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.listAppend
in interface Bucket
docId
- document id backing the listelement
- element to be pushed into the queuetimeout
- the custom timeouttimeUnit
- the unit for the timeoutpublic <E> boolean listAppend(String docId, E element, MutationOptionBuilder mutationOptionBuilder)
Bucket
MutationOptionBuilder
.
This method throws under the following conditions:
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- If the underlying couchbase document does not exist: DocumentDoesNotExistException
- A CAS value was set and it did not match with the server: CASMismatchException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.listAppend
in interface Bucket
docId
- document id backing the listelement
- element to be pushed into the queuemutationOptionBuilder
- mutation options MutationOptionBuilder
public <E> boolean listAppend(String docId, E element, MutationOptionBuilder mutationOptionBuilder, long timeout, TimeUnit timeUnit)
Bucket
MutationOptionBuilder
This method throws under the following conditions:
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- If the underlying couchbase document does not exist: DocumentDoesNotExistException
- A CAS value was set and it did not match with the server: CASMismatchException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.listAppend
in interface Bucket
docId
- document id backing the listelement
- element to be pushed into the queuemutationOptionBuilder
- mutation options MutationOptionBuilder
timeout
- the custom timeouttimeUnit
- the unit for the timeoutpublic <E> boolean listPrepend(String docId, E element)
Bucket
BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- If the underlying couchbase document does not exist: DocumentDoesNotExistException
- A CAS value was set and it did not match with the server: CASMismatchException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.listPrepend
in interface Bucket
docId
- document id backing the listelement
- element to shift as head of listpublic <E> boolean listPrepend(String docId, E element, long timeout, TimeUnit timeUnit)
Bucket
BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- If the underlying couchbase document does not exist: DocumentDoesNotExistException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- A CAS value was set and it did not match with the server: CASMismatchException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.listPrepend
in interface Bucket
docId
- document id backing the listelement
- element to shift as head of listtimeout
- the custom timeouttimeUnit
- the unit for the timeoutpublic <E> boolean listPrepend(String docId, E element, MutationOptionBuilder mutationOptionBuilder)
Bucket
MutationOptionBuilder
This method throws under the following conditions:
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- A CAS value was set and it did not match with the server: CASMismatchException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.listPrepend
in interface Bucket
docId
- document id backing the listelement
- element to shift as head of listmutationOptionBuilder
- mutation options MutationOptionBuilder
public <E> boolean listPrepend(String docId, E element, MutationOptionBuilder mutationOptionBuilder, long timeout, TimeUnit timeUnit)
Bucket
MutationOptionBuilder
This method throws under the following conditions:
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- A CAS value was set and it did not match with the server: CASMismatchException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.listPrepend
in interface Bucket
docId
- document id backing the listelement
- element to shift as head of listmutationOptionBuilder
- mutation options MutationOptionBuilder
timeout
- the custom timeouttimeUnit
- the unit for the timeoutpublic boolean listRemove(String docId, int index)
Bucket
IndexOutOfBoundsException
if index is not found
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- If the underlying couchbase document does not exist: DocumentDoesNotExistException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.listRemove
in interface Bucket
docId
- document id backing the listindex
- index of the element in listpublic boolean listRemove(String docId, int index, long timeout, TimeUnit timeUnit)
Bucket
IndexOutOfBoundsException
if index is not found
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- If the underlying couchbase document does not exist: DocumentDoesNotExistException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.listRemove
in interface Bucket
docId
- document id backing the listindex
- index of the element in listtimeout
- the custom timeouttimeUnit
- the unit for the timeoutpublic boolean listRemove(String docId, int index, MutationOptionBuilder mutationOptionBuilder)
Bucket
MutationOptionBuilder
This method throws under the following conditions:
- IndexOutOfBoundsException
if index is not found
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- If the underlying couchbase document does not exist: DocumentDoesNotExistException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- A CAS value was set and it did not match with the server: CASMismatchException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.listRemove
in interface Bucket
docId
- document id backing the listindex
- index of the element in listmutationOptionBuilder
- mutation options MutationOptionBuilder
public boolean listRemove(String docId, int index, MutationOptionBuilder mutationOptionBuilder, long timeout, TimeUnit timeUnit)
Bucket
MutationOptionBuilder
This method throws under the following conditions:
- IndexOutOfBoundsException
if index is not found
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- If the underlying couchbase document does not exist: DocumentDoesNotExistException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- A CAS value was set and it did not match with the server: CASMismatchException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.listRemove
in interface Bucket
docId
- document id backing the listindex
- index of the element in listmutationOptionBuilder
- mutation options MutationOptionBuilder
timeout
- the custom timeouttimeUnit
- the unit for the timeoutpublic <E> boolean listSet(String docId, int index, E element)
Bucket
BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.public <E> boolean listSet(String docId, int index, E element, long timeout, TimeUnit timeUnit)
Bucket
BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.public <E> boolean listSet(String docId, int index, E element, MutationOptionBuilder mutationOptionBuilder)
Bucket
MutationOptionBuilder
This method throws under the following conditions:
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- A CAS value was set and it did not match with the server: CASMismatchException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.listSet
in interface Bucket
docId
- document id backing the listindex
- index in the listelement
- element to be addedmutationOptionBuilder
- mutation options MutationOptionBuilder
public <E> boolean listSet(String docId, int index, E element, MutationOptionBuilder mutationOptionBuilder, long timeout, TimeUnit timeUnit)
Bucket
MutationOptionBuilder
This method throws under the following conditions:
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- A CAS value was set and it did not match with the server: CASMismatchException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.listSet
in interface Bucket
docId
- document id backing the listindex
- index in the listelement
- element to be addedmutationOptionBuilder
- mutation options MutationOptionBuilder
timeout
- the custom timeouttimeUnit
- the unit for the timeoutpublic int listSize(String docId)
Bucket
BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- If the underlying couchbase document does not exist: DocumentDoesNotExistException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.public int listSize(String docId, long timeout, TimeUnit timeUnit)
Bucket
BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- If the underlying couchbase document does not exist: DocumentDoesNotExistException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.public <E> boolean setAdd(String docId, E element)
Bucket
BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- If the underlying couchbase document does not exist: DocumentDoesNotExistException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.public <E> boolean setAdd(String docId, E element, long timeout, TimeUnit timeUnit)
Bucket
BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- If the underlying couchbase document does not exist: DocumentDoesNotExistException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.public <E> boolean setAdd(String docId, E element, MutationOptionBuilder mutationOptionBuilder)
Bucket
MutationOptionBuilder
This method throws under the following conditions:
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- If the underlying couchbase document does not exist: DocumentDoesNotExistException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.setAdd
in interface Bucket
docId
- document id backing the setelement
- element to be pushed into the setmutationOptionBuilder
- mutation options MutationOptionBuilder
public <E> boolean setAdd(String docId, E element, MutationOptionBuilder mutationOptionBuilder, long timeout, TimeUnit timeUnit)
Bucket
MutationOptionBuilder
This method throws under the following conditions:
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- If the underlying couchbase document does not exist: DocumentDoesNotExistException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.setAdd
in interface Bucket
docId
- document id backing the setelement
- element to be pushed into the setmutationOptionBuilder
- mutation options MutationOptionBuilder
timeout
- the custom timeouttimeUnit
- the unit for the timeoutpublic <E> boolean setContains(String docId, E element)
Bucket
BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- If the underlying couchbase document does not exist: DocumentDoesNotExistException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.setContains
in interface Bucket
docId
- document id backing the setelement
- element to check for existencepublic <E> boolean setContains(String docId, E element, long timeout, TimeUnit timeUnit)
Bucket
BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- If the underlying couchbase document does not exist: DocumentDoesNotExistException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.setContains
in interface Bucket
docId
- document id backing the setelement
- element to check for existencetimeout
- the custom timeouttimeUnit
- the unit for the timeoutpublic <E> E setRemove(String docId, E element)
Bucket
BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- If the underlying couchbase document does not exist: DocumentDoesNotExistException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.public <E> E setRemove(String docId, E element, long timeout, TimeUnit timeUnit)
Bucket
BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- If the underlying couchbase document does not exist: DocumentDoesNotExistException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.public <E> E setRemove(String docId, E element, MutationOptionBuilder mutationOptionBuilder)
Bucket
MutationOptionBuilder
This method throws under the following conditions:
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- If the underlying couchbase document does not exist: DocumentDoesNotExistException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- A CAS value was set and it did not match with the server: CASMismatchException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.setRemove
in interface Bucket
docId
- document id backing the setelement
- element to be removedmutationOptionBuilder
- mutation options MutationOptionBuilder
public <E> E setRemove(String docId, E element, MutationOptionBuilder mutationOptionBuilder, long timeout, TimeUnit timeUnit)
Bucket
MutationOptionBuilder
This method throws under the following conditions:
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- If the underlying couchbase document does not exist: DocumentDoesNotExistException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- A CAS value was set and it did not match with the server: CASMismatchException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.setRemove
in interface Bucket
docId
- document id backing the setelement
- element to be removedmutationOptionBuilder
- mutation options MutationOptionBuilder
timeout
- the custom timeouttimeUnit
- the unit for the timeoutpublic int setSize(String docId)
Bucket
BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- If the underlying couchbase document does not exist: DocumentDoesNotExistException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.public int setSize(String docId, long timeout, TimeUnit timeUnit)
Bucket
BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- If the underlying couchbase document does not exist: DocumentDoesNotExistException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.public <E> boolean queuePush(String docId, E element)
Bucket
BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- If the underlying couchbase document does not exist: DocumentDoesNotExistException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.public <E> boolean queuePush(String docId, E element, long timeout, TimeUnit timeUnit)
Bucket
BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- If the underlying couchbase document does not exist: DocumentDoesNotExistException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.public <E> boolean queuePush(String docId, E element, MutationOptionBuilder mutationOptionBuilder)
Bucket
MutationOptionBuilder
This method throws under the following conditions:
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- If the underlying couchbase document does not exist: DocumentDoesNotExistException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- A CAS value was set and it did not match with the server: CASMismatchException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.queuePush
in interface Bucket
docId
- document id backing the queueelement
- element to be pushed into the queuemutationOptionBuilder
- mutation options MutationOptionBuilder
public <E> boolean queuePush(String docId, E element, MutationOptionBuilder mutationOptionBuilder, long timeout, TimeUnit timeUnit)
Bucket
MutationOptionBuilder
This method throws under the following conditions:
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- If the underlying couchbase document does not exist: DocumentDoesNotExistException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- A CAS value was set and it did not match with the server: CASMismatchException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.queuePush
in interface Bucket
docId
- document id backing the queueelement
- element to be pushed into the queuemutationOptionBuilder
- mutation options MutationOptionBuilder
timeout
- the custom timeouttimeUnit
- the unit for the timeoutpublic <E> E queuePop(String docId, Class<E> elementType)
Bucket
BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- If the underlying couchbase document does not exist: DocumentDoesNotExistException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.public <E> E queuePop(String docId, Class<E> elementType, long timeout, TimeUnit timeUnit)
Bucket
BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- If the underlying couchbase document does not exist: DocumentDoesNotExistException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.public <E> E queuePop(String docId, Class<E> elementType, MutationOptionBuilder mutationOptionBuilder)
Bucket
MutationOptionBuilder
This method throws under the following conditions:
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- If the underlying couchbase document does not exist: DocumentDoesNotExistException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- A CAS value was set and it did not match with the server: CASMismatchException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.public <E> E queuePop(String docId, Class<E> elementType, MutationOptionBuilder mutationOptionBuilder, long timeout, TimeUnit timeUnit)
Bucket
MutationOptionBuilder
This method throws under the following conditions:
- The producer outpaces the SDK: BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- If the underlying couchbase document does not exist: DocumentDoesNotExistException
- The durability constraint could not be fulfilled because of a temporary or persistent problem:
DurabilityException
.
- A CAS value was set and it did not match with the server: CASMismatchException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.public int queueSize(String docId)
Bucket
BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- If the underlying couchbase document does not exist: DocumentDoesNotExistException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.public int queueSize(String docId, long timeout, TimeUnit timeUnit)
Bucket
BackpressureException
- The operation had to be cancelled while on the wire or the retry strategy cancelled it instead of
retrying: RequestCancelledException
- If the underlying couchbase document does not exist: DocumentDoesNotExistException
- The server is currently not able to process the request, retrying may help: TemporaryFailureException
- The server is out of memory: CouchbaseOutOfMemoryException
- Unexpected errors are caught and contained in a generic CouchbaseException
.public Boolean close()
Bucket
public Boolean close(long timeout, TimeUnit timeUnit)
Bucket
public boolean isClosed()
Bucket
public int invalidateQueryCache()
Bucket
invalidateQueryCache
in interface Bucket
public PingReport ping(String reportId, long timeout, TimeUnit timeUnit)
Bucket
public PingReport ping(long timeout, TimeUnit timeUnit)
Bucket
public PingReport ping(Collection<ServiceType> services, long timeout, TimeUnit timeUnit)
Bucket
public PingReport ping(String reportId, Collection<ServiceType> services, long timeout, TimeUnit timeUnit)
Bucket
public byte[] exportAnalyticsDeferredResultHandle(AnalyticsDeferredResultHandle handle)
Bucket
exportAnalyticsDeferredResultHandle
in interface Bucket
handle
- the deferred result handlepublic AnalyticsDeferredResultHandle importAnalyticsDeferredResultHandle(byte[] b)
Bucket
AnalyticsDeferredResultHandle
.importAnalyticsDeferredResultHandle
in interface Bucket
b
- the bytes to be converted to handlepublic PingReport ping(String reportId)
Bucket
public PingReport ping()
Bucket
public PingReport ping(Collection<ServiceType> services)
Bucket
public PingReport ping(String reportId, Collection<ServiceType> services)
Bucket
Copyright © 2015 Couchbase, Inc.