public class Transaction extends RocksObject
OptimisticTransactionDB
or a TransactionDB
To create a transaction, use
OptimisticTransactionDB.beginTransaction(org.rocksdb.WriteOptions)
or
TransactionDB.beginTransaction(org.rocksdb.WriteOptions)
It is up to the caller to synchronize access to this object.
See samples/src/main/java/OptimisticTransactionSample.java and
samples/src/main/java/TransactionSample.java for some simple
examples.Modifier and Type | Class and Description |
---|---|
static class |
Transaction.TransactionState |
static class |
Transaction.WaitingTransactions |
nativeHandle_
owningHandle_
Modifier and Type | Method and Description |
---|---|
void |
clearSnapshot()
Clears the current snapshot (i.e.
|
void |
commit()
Write all batched keys to the db atomically.
|
void |
delete(byte[] key)
Similar to
RocksDB.delete(byte[]) , but
will also perform conflict checking on the keys be written. |
void |
delete(byte[][] keyParts)
Similar to
delete(byte[]) but allows
you to specify key the in several parts that will be
concatenated together. |
void |
delete(ColumnFamilyHandle columnFamilyHandle,
byte[] key)
Similar to
delete(ColumnFamilyHandle, byte[], boolean)
but with assumeTracked = false . |
void |
delete(ColumnFamilyHandle columnFamilyHandle,
byte[][] keyParts)
Similar to
delete(ColumnFamilyHandle, byte[][], boolean)
but with assumeTracked = false . |
void |
delete(ColumnFamilyHandle columnFamilyHandle,
byte[][] keyParts,
boolean assumeTracked)
Similar to
delete(ColumnFamilyHandle, byte[]) but allows
you to specify the key in several parts that will be
concatenated together. |
void |
delete(ColumnFamilyHandle columnFamilyHandle,
byte[] key,
boolean assumeTracked)
Similar to
RocksDB.delete(ColumnFamilyHandle, byte[]) , but
will also perform conflict checking on the keys be written. |
void |
deleteUntracked(byte[] key)
Similar to
RocksDB.delete(byte[]) ,
but operates on the transactions write batch. |
void |
deleteUntracked(byte[][] keyParts)
Similar to
deleteUntracked(byte[]) but allows
you to specify the key in several parts that will be
concatenated together. |
void |
deleteUntracked(ColumnFamilyHandle columnFamilyHandle,
byte[] key)
Similar to
RocksDB.delete(ColumnFamilyHandle, byte[]) ,
but operates on the transactions write batch. |
void |
deleteUntracked(ColumnFamilyHandle columnFamilyHandle,
byte[][] keyParts)
Similar to
deleteUntracked(ColumnFamilyHandle, byte[]) but allows
you to specify the key in several parts that will be
concatenated together. |
void |
disableIndexing()
By default, all put/merge/delete operations will be indexed in the
transaction so that get/getForUpdate/getIterator can search for these
keys.
|
protected void |
disposeInternal(long handle) |
void |
enableIndexing()
Re-enables indexing after a previous call to
disableIndexing() |
byte[] |
get(ColumnFamilyHandle columnFamilyHandle,
ReadOptions readOptions,
byte[] key)
This function is similar to
RocksDB.get(ColumnFamilyHandle, ReadOptions, byte[]) except it will
also read pending changes in this transaction. |
byte[] |
get(ReadOptions readOptions,
byte[] key)
This function is similar to
RocksDB.get(ReadOptions, byte[]) except it will
also read pending changes in this transaction. |
WriteBatch |
getCommitTimeWriteBatch()
Get the Commit time Write Batch.
|
long |
getElapsedTime()
Returns the elapsed time in milliseconds since this Transaction began.
|
byte[] |
getForUpdate(ReadOptions readOptions,
byte[] key,
boolean exclusive)
Read this key and ensure that this transaction will only
be able to be committed if this key is not written outside this
transaction after it has first been read (or after the snapshot if a
snapshot is set in this transaction).
|
byte[] |
getForUpdate(ReadOptions readOptions,
ColumnFamilyHandle columnFamilyHandle,
byte[] key,
boolean exclusive)
Same as
getForUpdate(ReadOptions, ColumnFamilyHandle, byte[], boolean, boolean)
with doValidate=true. |
byte[] |
getForUpdate(ReadOptions readOptions,
ColumnFamilyHandle columnFamilyHandle,
byte[] key,
boolean exclusive,
boolean doValidate)
Read this key and ensure that this transaction will only
be able to be committed if this key is not written outside this
transaction after it has first been read (or after the snapshot if a
snapshot is set in this transaction).
|
long |
getId()
The globally unique id with which the transaction is identified.
|
long |
getID()
Get the ID of the transaction.
|
RocksIterator |
getIterator(ReadOptions readOptions)
Returns an iterator that will iterate on all keys in the default
column family including both keys in the DB and uncommitted keys in this
transaction.
|
RocksIterator |
getIterator(ReadOptions readOptions,
ColumnFamilyHandle columnFamilyHandle)
Returns an iterator that will iterate on all keys in the default
column family including both keys in the DB and uncommitted keys in this
transaction.
|
long |
getLogNumber()
Get the log number.
|
java.lang.String |
getName()
Get the name of the transaction.
|
long |
getNumDeletes()
Returns the number of deletes that have been applied to this
transaction so far.
|
long |
getNumKeys()
Returns the number of distinct Keys being tracked by this transaction.
|
long |
getNumMerges()
Returns the number of merges that have been applied to this
transaction so far.
|
long |
getNumPuts()
Returns the number of puts that have been applied to this
transaction so far.
|
Snapshot |
getSnapshot()
Returns the Snapshot created by the last call to
setSnapshot() . |
Transaction.TransactionState |
getState()
Get the execution status of the transaction.
|
Transaction.WaitingTransactions |
getWaitingTxns()
Get the list of waiting transactions.
|
WriteBatchWithIndex |
getWriteBatch()
Fetch the underlying write batch that contains all pending changes to be
committed.
|
WriteOptions |
getWriteOptions()
Return the WriteOptions that will be used during
commit() . |
boolean |
isDeadlockDetect()
Determine if a deadlock has been detected.
|
void |
merge(byte[] key,
byte[] value)
Similar to
RocksDB.merge(byte[], byte[]) , but
will also perform conflict checking on the keys be written. |
void |
merge(ColumnFamilyHandle columnFamilyHandle,
byte[] key,
byte[] value)
Similar to
merge(ColumnFamilyHandle, byte[], byte[], boolean)
but with assumeTracked = false . |
void |
merge(ColumnFamilyHandle columnFamilyHandle,
byte[] key,
byte[] value,
boolean assumeTracked)
Similar to
RocksDB.merge(ColumnFamilyHandle, byte[], byte[]) , but
will also perform conflict checking on the keys be written. |
void |
mergeUntracked(byte[] key,
byte[] value)
Similar to
RocksDB.merge(byte[], byte[]) ,
but operates on the transactions write batch. |
void |
mergeUntracked(ColumnFamilyHandle columnFamilyHandle,
byte[] key,
byte[] value)
Similar to
RocksDB.merge(ColumnFamilyHandle, byte[], byte[]) ,
but operates on the transactions write batch. |
byte[][] |
multiGet(ReadOptions readOptions,
byte[][] keys)
This function is similar to
RocksDB.multiGet(ReadOptions, List) except it will
also read pending changes in this transaction. |
byte[][] |
multiGet(ReadOptions readOptions,
java.util.List<ColumnFamilyHandle> columnFamilyHandles,
byte[][] keys)
This function is similar to
RocksDB.multiGet(ReadOptions, List, List) except it will
also read pending changes in this transaction. |
byte[][] |
multiGetForUpdate(ReadOptions readOptions,
byte[][] keys)
A multi-key version of
getForUpdate(ReadOptions, byte[], boolean) . |
byte[][] |
multiGetForUpdate(ReadOptions readOptions,
java.util.List<ColumnFamilyHandle> columnFamilyHandles,
byte[][] keys)
A multi-key version of
getForUpdate(ReadOptions, ColumnFamilyHandle, byte[], boolean) . |
void |
put(byte[][] keyParts,
byte[][] valueParts)
Similar to
put(byte[], byte[]) but allows
you to specify the key and value in several parts that will be
concatenated together |
void |
put(byte[] key,
byte[] value)
Similar to
RocksDB.put(byte[], byte[]) , but
will also perform conflict checking on the keys be written. |
void |
put(ColumnFamilyHandle columnFamilyHandle,
byte[][] keyParts,
byte[][] valueParts)
Similar to
put(ColumnFamilyHandle, byte[][], byte[][], boolean)
but with with assumeTracked = false . |
void |
put(ColumnFamilyHandle columnFamilyHandle,
byte[][] keyParts,
byte[][] valueParts,
boolean assumeTracked)
Similar to
put(ColumnFamilyHandle, byte[], byte[]) but allows
you to specify the key and value in several parts that will be
concatenated together. |
void |
put(ColumnFamilyHandle columnFamilyHandle,
byte[] key,
byte[] value)
Similar to
put(ColumnFamilyHandle, byte[], byte[], boolean)
but with assumeTracked = false . |
void |
put(ColumnFamilyHandle columnFamilyHandle,
byte[] key,
byte[] value,
boolean assumeTracked)
Similar to
RocksDB.put(ColumnFamilyHandle, byte[], byte[]) , but
will also perform conflict checking on the keys be written. |
void |
putLogData(byte[] blob)
Similar to
AbstractWriteBatch.putLogData(byte[]) |
void |
putUntracked(byte[][] keyParts,
byte[][] valueParts)
Similar to
putUntracked(byte[], byte[]) but
allows you to specify the key and value in several parts that will be
concatenated together. |
void |
putUntracked(byte[] key,
byte[] value)
Similar to
RocksDB.put(byte[], byte[]) ,
but operates on the transactions write batch. |
void |
putUntracked(ColumnFamilyHandle columnFamilyHandle,
byte[][] keyParts,
byte[][] valueParts)
Similar to
putUntracked(ColumnFamilyHandle, byte[], byte[]) but
allows you to specify the key and value in several parts that will be
concatenated together. |
void |
putUntracked(ColumnFamilyHandle columnFamilyHandle,
byte[] key,
byte[] value)
Similar to
RocksDB.put(ColumnFamilyHandle, byte[], byte[]) ,
but operates on the transactions write batch. |
void |
rebuildFromWriteBatch(WriteBatch writeBatch)
Adds the keys from the WriteBatch to the transaction
|
void |
rollback()
Discard all batched writes in this transaction.
|
void |
rollbackToSavePoint()
Undo all operations in this transaction (put, merge, delete, putLogData)
since the most recent call to
setSavePoint() and removes the most
recent setSavePoint() . |
void |
setLockTimeout(long lockTimeout)
Change the value of
TransactionOptions.getLockTimeout()
(in milliseconds) for this transaction. |
void |
setLogNumber(long logNumber)
Set the log number.
|
void |
setName(java.lang.String transactionName)
Set the name of the transaction.
|
void |
setSavePoint()
Records the state of the transaction for future calls to
rollbackToSavePoint() . |
void |
setSnapshot()
If a transaction has a snapshot set, the transaction will ensure that
any keys successfully written(or fetched via
getForUpdate(org.rocksdb.ReadOptions, org.rocksdb.ColumnFamilyHandle, byte[], boolean, boolean) ) have
not been modified outside of this transaction since the time the snapshot
was set. |
void |
setSnapshotOnNextOperation()
Similar to
setSnapshot() , but will not change the current snapshot
until put/merge/delete/getForUpdate/multiGetForUpdate is called. |
void |
setSnapshotOnNextOperation(AbstractTransactionNotifier transactionNotifier)
Similar to
setSnapshot() , but will not change the current snapshot
until put/merge/delete/getForUpdate/multiGetForUpdate is called. |
void |
setWriteOptions(WriteOptions writeOptions)
Reset the WriteOptions that will be used during
commit() . |
void |
singleDelete(byte[] key)
Similar to
RocksDB.singleDelete(byte[]) , but
will also perform conflict checking on the keys be written. |
void |
singleDelete(byte[][] keyParts)
Similar to
singleDelete(byte[]) but allows
you to specify the key in several parts that will be
concatenated together. |
void |
singleDelete(ColumnFamilyHandle columnFamilyHandle,
byte[] key)
Similar to
singleDelete(ColumnFamilyHandle, byte[], boolean)
but with assumeTracked = false . |
void |
singleDelete(ColumnFamilyHandle columnFamilyHandle,
byte[][] keyParts)
Similar to
singleDelete(ColumnFamilyHandle, byte[][], boolean)
but with assumeTracked = false . |
void |
singleDelete(ColumnFamilyHandle columnFamilyHandle,
byte[][] keyParts,
boolean assumeTracked)
Similar to
singleDelete(ColumnFamilyHandle, byte[]) but allows
you to specify the key in several parts that will be
concatenated together. |
void |
singleDelete(ColumnFamilyHandle columnFamilyHandle,
byte[] key,
boolean assumeTracked)
Similar to
RocksDB.singleDelete(ColumnFamilyHandle, byte[]) , but
will also perform conflict checking on the keys be written. |
void |
undoGetForUpdate(byte[] key)
If this key was previously fetched in this transaction using
getForUpdate(ReadOptions, byte[], boolean) /
multiGetForUpdate(ReadOptions, List, byte[][]) , calling
undoGetForUpdate(byte[]) will tell
the transaction that it no longer needs to do any conflict checking
for this key. |
void |
undoGetForUpdate(ColumnFamilyHandle columnFamilyHandle,
byte[] key)
If this key was previously fetched in this transaction using
getForUpdate(ReadOptions, ColumnFamilyHandle, byte[], boolean) /
multiGetForUpdate(ReadOptions, List, byte[][]) , calling
undoGetForUpdate(ColumnFamilyHandle, byte[]) will tell
the transaction that it no longer needs to do any conflict checking
for this key. |
disposeInternal
close, disOwnNativeHandle, isOwningHandle
dispose, finalize
public void setSnapshot()
getForUpdate(org.rocksdb.ReadOptions, org.rocksdb.ColumnFamilyHandle, byte[], boolean, boolean)
) have
not been modified outside of this transaction since the time the snapshot
was set.
If a snapshot has not been set, the transaction guarantees that keys have
not been modified since the time each key was first written (or fetched via
getForUpdate(org.rocksdb.ReadOptions, org.rocksdb.ColumnFamilyHandle, byte[], boolean, boolean)
).
Using setSnapshot()
will provide stricter isolation guarantees
at the expense of potentially more transaction failures due to conflicts
with other writes.
Calling setSnapshot()
has no effect on keys written before this
function has been called.
setSnapshot()
may be called multiple times if you would like to
change the snapshot used for different operations in this transaction.
Calling setSnapshot()
will not affect the version of Data returned
by get(...) methods. See get(org.rocksdb.ColumnFamilyHandle, org.rocksdb.ReadOptions, byte[])
for more details.public void setSnapshotOnNextOperation()
setSnapshot()
, but will not change the current snapshot
until put/merge/delete/getForUpdate/multiGetForUpdate is called.
By calling this function, the transaction will essentially call
setSnapshot()
for you right before performing the next
write/getForUpdate.
Calling setSnapshotOnNextOperation()
will not affect what
snapshot is returned by getSnapshot()
until the next
write/getForUpdate is executed.
When the snapshot is created the notifier's snapshotCreated method will
be called so that the caller can get access to the snapshot.
This is an optimization to reduce the likelihood of conflicts that
could occur in between the time setSnapshot()
is called and the
first write/getForUpdate operation. i.e. this prevents the following
race-condition:
txn1->setSnapshot();
txn2->put("A", ...);
txn2->commit();
txn1->getForUpdate(opts, "A", ...); * FAIL!public void setSnapshotOnNextOperation(AbstractTransactionNotifier transactionNotifier)
setSnapshot()
, but will not change the current snapshot
until put/merge/delete/getForUpdate/multiGetForUpdate is called.
By calling this function, the transaction will essentially call
setSnapshot()
for you right before performing the next
write/getForUpdate.
Calling setSnapshotOnNextOperation()
will not affect what
snapshot is returned by getSnapshot()
until the next
write/getForUpdate is executed.
When the snapshot is created the
AbstractTransactionNotifier.snapshotCreated(Snapshot)
method will
be called so that the caller can get access to the snapshot.
This is an optimization to reduce the likelihood of conflicts that
could occur in between the time setSnapshot()
is called and the
first write/getForUpdate operation. i.e. this prevents the following
race-condition:
txn1->setSnapshot();
txn2->put("A", ...);
txn2->commit();
txn1->getForUpdate(opts, "A", ...); * FAIL!transactionNotifier
- A handler for receiving snapshot notifications
for the transactionpublic Snapshot getSnapshot()
setSnapshot()
.
REQUIRED: The returned Snapshot is only valid up until the next time
setSnapshot()
/setSnapshotOnNextOperation()
is called,
clearSnapshot()
is called, or the Transaction is deleted.public void clearSnapshot()
setSnapshotOnNextOperation()
).
Calling clearSnapshot()
has no effect on keys written before this
function has been called.
If a reference to a snapshot was retrieved via getSnapshot()
, it
will no longer be valid and should be discarded after a call to
clearSnapshot()
.public void commit() throws RocksDBException
OptimisticTransactionDB
Status::Busy() may be returned if the transaction could not guarantee
that there are no write conflicts. Status::TryAgain() may be returned
if the memtable history size is not large enough
(See max_write_buffer_number_to_maintain).
If this transaction was created by a TransactionDB
,
Status::Expired() may be returned if this transaction has lived for
longer than TransactionOptions.getExpiration()
.RocksDBException
- if an error occurs when committing the transactionpublic void rollback() throws RocksDBException
RocksDBException
- if an error occurs when rolling back the transactionpublic void setSavePoint() throws RocksDBException
rollbackToSavePoint()
.
May be called multiple times to set multiple save points.RocksDBException
- if an error occurs whilst setting a save pointpublic void rollbackToSavePoint() throws RocksDBException
setSavePoint()
and removes the most
recent setSavePoint()
.
If there is no previous call to setSavePoint()
,
returns Status::NotFound()RocksDBException
- if an error occurs when rolling back to a save pointpublic byte[] get(ColumnFamilyHandle columnFamilyHandle, ReadOptions readOptions, byte[] key) throws RocksDBException
RocksDB.get(ColumnFamilyHandle, ReadOptions, byte[])
except it will
also read pending changes in this transaction.
Currently, this function will return Status::MergeInProgress if the most
recent write to the queried key in this batch is a Merge.
If ReadOptions.snapshot()
is not set, the current version of the
key will be read. Calling setSnapshot()
does not affect the
version of the data returned.
Note that setting ReadOptions.setSnapshot(Snapshot)
will affect
what is read from the DB but will NOT change which keys are read from this
transaction (the keys in this transaction do not yet belong to any snapshot
and will be fetched regardless).columnFamilyHandle
- ColumnFamilyHandle
instancereadOptions
- Read options.key
- the key to retrieve the value for.RocksDBException
- thrown if error happens in underlying native
library.public byte[] get(ReadOptions readOptions, byte[] key) throws RocksDBException
RocksDB.get(ReadOptions, byte[])
except it will
also read pending changes in this transaction.
Currently, this function will return Status::MergeInProgress if the most
recent write to the queried key in this batch is a Merge.
If ReadOptions.snapshot()
is not set, the current version of the
key will be read. Calling setSnapshot()
does not affect the
version of the data returned.
Note that setting ReadOptions.setSnapshot(Snapshot)
will affect
what is read from the DB but will NOT change which keys are read from this
transaction (the keys in this transaction do not yet belong to any snapshot
and will be fetched regardless).readOptions
- Read options.key
- the key to retrieve the value for.RocksDBException
- thrown if error happens in underlying native
library.public byte[][] multiGet(ReadOptions readOptions, java.util.List<ColumnFamilyHandle> columnFamilyHandles, byte[][] keys) throws RocksDBException
RocksDB.multiGet(ReadOptions, List, List)
except it will
also read pending changes in this transaction.
Currently, this function will return Status::MergeInProgress if the most
recent write to the queried key in this batch is a Merge.
If ReadOptions.snapshot()
is not set, the current version of the
key will be read. Calling setSnapshot()
does not affect the
version of the data returned.
Note that setting ReadOptions.setSnapshot(Snapshot)
will affect
what is read from the DB but will NOT change which keys are read from this
transaction (the keys in this transaction do not yet belong to any snapshot
and will be fetched regardless).readOptions
- Read options.columnFamilyHandles
- List
containing
ColumnFamilyHandle
instances.keys
- of keys for which values need to be retrieved.RocksDBException
- thrown if error happens in underlying
native library.java.lang.IllegalArgumentException
- thrown if the size of passed keys is not
equal to the amount of passed column family handles.public byte[][] multiGet(ReadOptions readOptions, byte[][] keys) throws RocksDBException
RocksDB.multiGet(ReadOptions, List)
except it will
also read pending changes in this transaction.
Currently, this function will return Status::MergeInProgress if the most
recent write to the queried key in this batch is a Merge.
If ReadOptions.snapshot()
is not set, the current version of the
key will be read. Calling setSnapshot()
does not affect the
version of the data returned.
Note that setting ReadOptions.setSnapshot(Snapshot)
will affect
what is read from the DB but will NOT change which keys are read from this
transaction (the keys in this transaction do not yet belong to any snapshot
and will be fetched regardless).readOptions
- Read options.=
ColumnFamilyHandle
instances.keys
- of keys for which values need to be retrieved.RocksDBException
- thrown if error happens in underlying
native library.public byte[] getForUpdate(ReadOptions readOptions, ColumnFamilyHandle columnFamilyHandle, byte[] key, boolean exclusive, boolean doValidate) throws RocksDBException
RocksDB.get(ColumnFamilyHandle, ReadOptions, byte[])
.
If value==nullptr, then this function will not read any data, but will
still ensure that this key cannot be written to by outside of this
transaction.
If this transaction was created by an OptimisticTransactionDB
,
getForUpdate(ReadOptions, ColumnFamilyHandle, byte[], boolean)
could cause commit()
to fail. Otherwise, it could return any error
that could be returned by
RocksDB.get(ColumnFamilyHandle, ReadOptions, byte[])
.
If this transaction was created on a TransactionDB
, an
RocksDBException
may be thrown with an accompanying Status
when:
Status.Code.Busy
if there is a write conflict,
Status.Code.TimedOut
if a lock could not be acquired,
Status.Code.TryAgain
if the memtable history size is not large
enough. See
ColumnFamilyOptions.maxWriteBufferNumberToMaintain()
Status.Code.MergeInProgress
if merge operations cannot be
resolved.readOptions
- Read options.columnFamilyHandle
- ColumnFamilyHandle
instancekey
- the key to retrieve the value for.exclusive
- true if the transaction should have exclusive access to
the key, otherwise false for shared access.doValidate
- true if it should validate the snapshot before doing the readRocksDBException
- thrown if error happens in underlying
native library.public byte[] getForUpdate(ReadOptions readOptions, ColumnFamilyHandle columnFamilyHandle, byte[] key, boolean exclusive) throws RocksDBException
getForUpdate(ReadOptions, ColumnFamilyHandle, byte[], boolean, boolean)
with doValidate=true.readOptions
- Read options.columnFamilyHandle
- ColumnFamilyHandle
instancekey
- the key to retrieve the value for.exclusive
- true if the transaction should have exclusive access to
the key, otherwise false for shared access.RocksDBException
- thrown if error happens in underlying
native library.public byte[] getForUpdate(ReadOptions readOptions, byte[] key, boolean exclusive) throws RocksDBException
RocksDB.get(ReadOptions, byte[])
.
If value==nullptr, then this function will not read any data, but will
still ensure that this key cannot be written to by outside of this
transaction.
If this transaction was created on an OptimisticTransactionDB
,
getForUpdate(ReadOptions, ColumnFamilyHandle, byte[], boolean)
could cause commit()
to fail. Otherwise, it could return any error
that could be returned by
RocksDB.get(ReadOptions, byte[])
.
If this transaction was created on a TransactionDB
, an
RocksDBException
may be thrown with an accompanying Status
when:
Status.Code.Busy
if there is a write conflict,
Status.Code.TimedOut
if a lock could not be acquired,
Status.Code.TryAgain
if the memtable history size is not large
enough. See
ColumnFamilyOptions.maxWriteBufferNumberToMaintain()
Status.Code.MergeInProgress
if merge operations cannot be
resolved.readOptions
- Read options.key
- the key to retrieve the value for.exclusive
- true if the transaction should have exclusive access to
the key, otherwise false for shared access.RocksDBException
- thrown if error happens in underlying
native library.public byte[][] multiGetForUpdate(ReadOptions readOptions, java.util.List<ColumnFamilyHandle> columnFamilyHandles, byte[][] keys) throws RocksDBException
getForUpdate(ReadOptions, ColumnFamilyHandle, byte[], boolean)
.readOptions
- Read options.columnFamilyHandles
- ColumnFamilyHandle
instanceskeys
- the keys to retrieve the values for.RocksDBException
- thrown if error happens in underlying
native library.public byte[][] multiGetForUpdate(ReadOptions readOptions, byte[][] keys) throws RocksDBException
getForUpdate(ReadOptions, byte[], boolean)
.readOptions
- Read options.keys
- the keys to retrieve the values for.RocksDBException
- thrown if error happens in underlying
native library.public RocksIterator getIterator(ReadOptions readOptions)
ReadOptions.setSnapshot(Snapshot)
will affect what is read
from the DB but will NOT change which keys are read from this transaction
(the keys in this transaction do not yet belong to any snapshot and will be
fetched regardless).
Caller is responsible for deleting the returned Iterator.
The returned iterator is only valid until commit()
,
rollback()
, or rollbackToSavePoint()
is called.readOptions
- Read options.public RocksIterator getIterator(ReadOptions readOptions, ColumnFamilyHandle columnFamilyHandle)
ReadOptions.setSnapshot(Snapshot)
will affect what is read
from the DB but will NOT change which keys are read from this transaction
(the keys in this transaction do not yet belong to any snapshot and will be
fetched regardless).
Caller is responsible for calling AbstractImmutableNativeReference.close()
on
the returned Iterator.
The returned iterator is only valid until commit()
,
rollback()
, or rollbackToSavePoint()
is called.readOptions
- Read options.columnFamilyHandle
- ColumnFamilyHandle
instancepublic void put(ColumnFamilyHandle columnFamilyHandle, byte[] key, byte[] value, boolean assumeTracked) throws RocksDBException
RocksDB.put(ColumnFamilyHandle, byte[], byte[])
, but
will also perform conflict checking on the keys be written.
If this Transaction was created on an OptimisticTransactionDB
,
these functions should always succeed.
If this Transaction was created on a TransactionDB
, an
RocksDBException
may be thrown with an accompanying Status
when:
Status.Code.Busy
if there is a write conflict,
Status.Code.TimedOut
if a lock could not be acquired,
Status.Code.TryAgain
if the memtable history size is not large
enough. See
ColumnFamilyOptions.maxWriteBufferNumberToMaintain()
columnFamilyHandle
- The column family to put the key/value intokey
- the specified key to be inserted.value
- the value associated with the specified key.assumeTracked
- true when it is expected that the key is already
tracked. More specifically, it means the the key was previous tracked
in the same savepoint, with the same exclusive flag, and at a lower
sequence number. If valid then it skips ValidateSnapshot,
throws an error otherwise.RocksDBException
- when one of the TransactionalDB conditions
described above occurs, or in the case of an unexpected errorpublic void put(ColumnFamilyHandle columnFamilyHandle, byte[] key, byte[] value) throws RocksDBException
put(ColumnFamilyHandle, byte[], byte[], boolean)
but with assumeTracked = false
.
Will also perform conflict checking on the keys be written.
If this Transaction was created on an OptimisticTransactionDB
,
these functions should always succeed.
If this Transaction was created on a TransactionDB
, an
RocksDBException
may be thrown with an accompanying Status
when:
Status.Code.Busy
if there is a write conflict,
Status.Code.TimedOut
if a lock could not be acquired,
Status.Code.TryAgain
if the memtable history size is not large
enough. See
ColumnFamilyOptions.maxWriteBufferNumberToMaintain()
columnFamilyHandle
- The column family to put the key/value intokey
- the specified key to be inserted.value
- the value associated with the specified key.RocksDBException
- when one of the TransactionalDB conditions
described above occurs, or in the case of an unexpected errorpublic void put(byte[] key, byte[] value) throws RocksDBException
RocksDB.put(byte[], byte[])
, but
will also perform conflict checking on the keys be written.
If this Transaction was created on an OptimisticTransactionDB
,
these functions should always succeed.
If this Transaction was created on a TransactionDB
, an
RocksDBException
may be thrown with an accompanying Status
when:
Status.Code.Busy
if there is a write conflict,
Status.Code.TimedOut
if a lock could not be acquired,
Status.Code.TryAgain
if the memtable history size is not large
enough. See
ColumnFamilyOptions.maxWriteBufferNumberToMaintain()
key
- the specified key to be inserted.value
- the value associated with the specified key.RocksDBException
- when one of the TransactionalDB conditions
described above occurs, or in the case of an unexpected errorpublic void put(ColumnFamilyHandle columnFamilyHandle, byte[][] keyParts, byte[][] valueParts, boolean assumeTracked) throws RocksDBException
put(ColumnFamilyHandle, byte[], byte[])
but allows
you to specify the key and value in several parts that will be
concatenated together.columnFamilyHandle
- The column family to put the key/value intokeyParts
- the specified key to be inserted.valueParts
- the value associated with the specified key.assumeTracked
- true when it is expected that the key is already
tracked. More specifically, it means the the key was previous tracked
in the same savepoint, with the same exclusive flag, and at a lower
sequence number. If valid then it skips ValidateSnapshot,
throws an error otherwise.RocksDBException
- when one of the TransactionalDB conditions
described above occurs, or in the case of an unexpected errorpublic void put(ColumnFamilyHandle columnFamilyHandle, byte[][] keyParts, byte[][] valueParts) throws RocksDBException
put(ColumnFamilyHandle, byte[][], byte[][], boolean)
but with with assumeTracked = false
.
Allows you to specify the key and value in several parts that will be
concatenated together.columnFamilyHandle
- The column family to put the key/value intokeyParts
- the specified key to be inserted.valueParts
- the value associated with the specified key.RocksDBException
- when one of the TransactionalDB conditions
described above occurs, or in the case of an unexpected errorpublic void put(byte[][] keyParts, byte[][] valueParts) throws RocksDBException
put(byte[], byte[])
but allows
you to specify the key and value in several parts that will be
concatenated togetherkeyParts
- the specified key to be inserted.valueParts
- the value associated with the specified key.RocksDBException
- when one of the TransactionalDB conditions
described above occurs, or in the case of an unexpected errorpublic void merge(ColumnFamilyHandle columnFamilyHandle, byte[] key, byte[] value, boolean assumeTracked) throws RocksDBException
RocksDB.merge(ColumnFamilyHandle, byte[], byte[])
, but
will also perform conflict checking on the keys be written.
If this Transaction was created on an OptimisticTransactionDB
,
these functions should always succeed.
If this Transaction was created on a TransactionDB
, an
RocksDBException
may be thrown with an accompanying Status
when:
Status.Code.Busy
if there is a write conflict,
Status.Code.TimedOut
if a lock could not be acquired,
Status.Code.TryAgain
if the memtable history size is not large
enough. See
ColumnFamilyOptions.maxWriteBufferNumberToMaintain()
columnFamilyHandle
- The column family to merge the key/value intokey
- the specified key to be merged.value
- the value associated with the specified key.assumeTracked
- true when it is expected that the key is already
tracked. More specifically, it means the the key was previous tracked
in the same savepoint, with the same exclusive flag, and at a lower
sequence number. If valid then it skips ValidateSnapshot,
throws an error otherwise.RocksDBException
- when one of the TransactionalDB conditions
described above occurs, or in the case of an unexpected errorpublic void merge(ColumnFamilyHandle columnFamilyHandle, byte[] key, byte[] value) throws RocksDBException
merge(ColumnFamilyHandle, byte[], byte[], boolean)
but with assumeTracked = false
.
Will also perform conflict checking on the keys be written.
If this Transaction was created on an OptimisticTransactionDB
,
these functions should always succeed.
If this Transaction was created on a TransactionDB
, an
RocksDBException
may be thrown with an accompanying Status
when:
Status.Code.Busy
if there is a write conflict,
Status.Code.TimedOut
if a lock could not be acquired,
Status.Code.TryAgain
if the memtable history size is not large
enough. See
ColumnFamilyOptions.maxWriteBufferNumberToMaintain()
columnFamilyHandle
- The column family to merge the key/value intokey
- the specified key to be merged.value
- the value associated with the specified key.RocksDBException
- when one of the TransactionalDB conditions
described above occurs, or in the case of an unexpected errorpublic void merge(byte[] key, byte[] value) throws RocksDBException
RocksDB.merge(byte[], byte[])
, but
will also perform conflict checking on the keys be written.
If this Transaction was created on an OptimisticTransactionDB
,
these functions should always succeed.
If this Transaction was created on a TransactionDB
, an
RocksDBException
may be thrown with an accompanying Status
when:
Status.Code.Busy
if there is a write conflict,
Status.Code.TimedOut
if a lock could not be acquired,
Status.Code.TryAgain
if the memtable history size is not large
enough. See
ColumnFamilyOptions.maxWriteBufferNumberToMaintain()
key
- the specified key to be merged.value
- the value associated with the specified key.RocksDBException
- when one of the TransactionalDB conditions
described above occurs, or in the case of an unexpected errorpublic void delete(ColumnFamilyHandle columnFamilyHandle, byte[] key, boolean assumeTracked) throws RocksDBException
RocksDB.delete(ColumnFamilyHandle, byte[])
, but
will also perform conflict checking on the keys be written.
If this Transaction was created on an OptimisticTransactionDB
,
these functions should always succeed.
If this Transaction was created on a TransactionDB
, an
RocksDBException
may be thrown with an accompanying Status
when:
Status.Code.Busy
if there is a write conflict,
Status.Code.TimedOut
if a lock could not be acquired,
Status.Code.TryAgain
if the memtable history size is not large
enough. See
ColumnFamilyOptions.maxWriteBufferNumberToMaintain()
columnFamilyHandle
- The column family to delete the key/value fromkey
- the specified key to be deleted.assumeTracked
- true when it is expected that the key is already
tracked. More specifically, it means the the key was previous tracked
in the same savepoint, with the same exclusive flag, and at a lower
sequence number. If valid then it skips ValidateSnapshot,
throws an error otherwise.RocksDBException
- when one of the TransactionalDB conditions
described above occurs, or in the case of an unexpected errorpublic void delete(ColumnFamilyHandle columnFamilyHandle, byte[] key) throws RocksDBException
delete(ColumnFamilyHandle, byte[], boolean)
but with assumeTracked = false
.
Will also perform conflict checking on the keys be written.
If this Transaction was created on an OptimisticTransactionDB
,
these functions should always succeed.
If this Transaction was created on a TransactionDB
, an
RocksDBException
may be thrown with an accompanying Status
when:
Status.Code.Busy
if there is a write conflict,
Status.Code.TimedOut
if a lock could not be acquired,
Status.Code.TryAgain
if the memtable history size is not large
enough. See
ColumnFamilyOptions.maxWriteBufferNumberToMaintain()
columnFamilyHandle
- The column family to delete the key/value fromkey
- the specified key to be deleted.RocksDBException
- when one of the TransactionalDB conditions
described above occurs, or in the case of an unexpected errorpublic void delete(byte[] key) throws RocksDBException
RocksDB.delete(byte[])
, but
will also perform conflict checking on the keys be written.
If this Transaction was created on an OptimisticTransactionDB
,
these functions should always succeed.
If this Transaction was created on a TransactionDB
, an
RocksDBException
may be thrown with an accompanying Status
when:
Status.Code.Busy
if there is a write conflict,
Status.Code.TimedOut
if a lock could not be acquired,
Status.Code.TryAgain
if the memtable history size is not large
enough. See
ColumnFamilyOptions.maxWriteBufferNumberToMaintain()
key
- the specified key to be deleted.RocksDBException
- when one of the TransactionalDB conditions
described above occurs, or in the case of an unexpected errorpublic void delete(ColumnFamilyHandle columnFamilyHandle, byte[][] keyParts, boolean assumeTracked) throws RocksDBException
delete(ColumnFamilyHandle, byte[])
but allows
you to specify the key in several parts that will be
concatenated together.columnFamilyHandle
- The column family to delete the key/value fromkeyParts
- the specified key to be deleted.assumeTracked
- true when it is expected that the key is already
tracked. More specifically, it means the the key was previous tracked
in the same savepoint, with the same exclusive flag, and at a lower
sequence number. If valid then it skips ValidateSnapshot,
throws an error otherwise.RocksDBException
- when one of the TransactionalDB conditions
described above occurs, or in the case of an unexpected errorpublic void delete(ColumnFamilyHandle columnFamilyHandle, byte[][] keyParts) throws RocksDBException
delete(ColumnFamilyHandle, byte[][], boolean)
but with assumeTracked = false
.
Allows you to specify the key in several parts that will be
concatenated together.columnFamilyHandle
- The column family to delete the key/value fromkeyParts
- the specified key to be deleted.RocksDBException
- when one of the TransactionalDB conditions
described above occurs, or in the case of an unexpected errorpublic void delete(byte[][] keyParts) throws RocksDBException
delete(byte[])
but allows
you to specify key the in several parts that will be
concatenated together.keyParts
- the specified key to be deletedRocksDBException
- when one of the TransactionalDB conditions
described above occurs, or in the case of an unexpected error@Experimental(value="Performance optimization for a very specific workload") public void singleDelete(ColumnFamilyHandle columnFamilyHandle, byte[] key, boolean assumeTracked) throws RocksDBException
RocksDB.singleDelete(ColumnFamilyHandle, byte[])
, but
will also perform conflict checking on the keys be written.
If this Transaction was created on an OptimisticTransactionDB
,
these functions should always succeed.
If this Transaction was created on a TransactionDB
, an
RocksDBException
may be thrown with an accompanying Status
when:
Status.Code.Busy
if there is a write conflict,
Status.Code.TimedOut
if a lock could not be acquired,
Status.Code.TryAgain
if the memtable history size is not large
enough. See
ColumnFamilyOptions.maxWriteBufferNumberToMaintain()
columnFamilyHandle
- The column family to delete the key/value fromkey
- the specified key to be deleted.assumeTracked
- true when it is expected that the key is already
tracked. More specifically, it means the the key was previous tracked
in the same savepoint, with the same exclusive flag, and at a lower
sequence number. If valid then it skips ValidateSnapshot,
throws an error otherwise.RocksDBException
- when one of the TransactionalDB conditions
described above occurs, or in the case of an unexpected error@Experimental(value="Performance optimization for a very specific workload") public void singleDelete(ColumnFamilyHandle columnFamilyHandle, byte[] key) throws RocksDBException
singleDelete(ColumnFamilyHandle, byte[], boolean)
but with assumeTracked = false
.
will also perform conflict checking on the keys be written.
If this Transaction was created on an OptimisticTransactionDB
,
these functions should always succeed.
If this Transaction was created on a TransactionDB
, an
RocksDBException
may be thrown with an accompanying Status
when:
Status.Code.Busy
if there is a write conflict,
Status.Code.TimedOut
if a lock could not be acquired,
Status.Code.TryAgain
if the memtable history size is not large
enough. See
ColumnFamilyOptions.maxWriteBufferNumberToMaintain()
columnFamilyHandle
- The column family to delete the key/value fromkey
- the specified key to be deleted.RocksDBException
- when one of the TransactionalDB conditions
described above occurs, or in the case of an unexpected error@Experimental(value="Performance optimization for a very specific workload") public void singleDelete(byte[] key) throws RocksDBException
RocksDB.singleDelete(byte[])
, but
will also perform conflict checking on the keys be written.
If this Transaction was created on an OptimisticTransactionDB
,
these functions should always succeed.
If this Transaction was created on a TransactionDB
, an
RocksDBException
may be thrown with an accompanying Status
when:
Status.Code.Busy
if there is a write conflict,
Status.Code.TimedOut
if a lock could not be acquired,
Status.Code.TryAgain
if the memtable history size is not large
enough. See
ColumnFamilyOptions.maxWriteBufferNumberToMaintain()
key
- the specified key to be deleted.RocksDBException
- when one of the TransactionalDB conditions
described above occurs, or in the case of an unexpected error@Experimental(value="Performance optimization for a very specific workload") public void singleDelete(ColumnFamilyHandle columnFamilyHandle, byte[][] keyParts, boolean assumeTracked) throws RocksDBException
singleDelete(ColumnFamilyHandle, byte[])
but allows
you to specify the key in several parts that will be
concatenated together.columnFamilyHandle
- The column family to delete the key/value fromkeyParts
- the specified key to be deleted.assumeTracked
- true when it is expected that the key is already
tracked. More specifically, it means the the key was previous tracked
in the same savepoint, with the same exclusive flag, and at a lower
sequence number. If valid then it skips ValidateSnapshot,
throws an error otherwise.RocksDBException
- when one of the TransactionalDB conditions
described above occurs, or in the case of an unexpected error@Experimental(value="Performance optimization for a very specific workload") public void singleDelete(ColumnFamilyHandle columnFamilyHandle, byte[][] keyParts) throws RocksDBException
singleDelete(ColumnFamilyHandle, byte[][], boolean)
but with assumeTracked = false
.
Allows you to specify the key in several parts that will be
concatenated together.columnFamilyHandle
- The column family to delete the key/value fromkeyParts
- the specified key to be deleted.RocksDBException
- when one of the TransactionalDB conditions
described above occurs, or in the case of an unexpected error@Experimental(value="Performance optimization for a very specific workload") public void singleDelete(byte[][] keyParts) throws RocksDBException
singleDelete(byte[])
but allows
you to specify the key in several parts that will be
concatenated together.keyParts
- the specified key to be deleted.RocksDBException
- when one of the TransactionalDB conditions
described above occurs, or in the case of an unexpected errorpublic void putUntracked(ColumnFamilyHandle columnFamilyHandle, byte[] key, byte[] value) throws RocksDBException
RocksDB.put(ColumnFamilyHandle, byte[], byte[])
,
but operates on the transactions write batch. This write will only happen
if this transaction gets committed successfully.
Unlike put(ColumnFamilyHandle, byte[], byte[])
no conflict
checking will be performed for this key.
If this Transaction was created on a TransactionDB
, this function
will still acquire locks necessary to make sure this write doesn't cause
conflicts in other transactions; This may cause a RocksDBException
with associated Status.Code.Busy
.columnFamilyHandle
- The column family to put the key/value intokey
- the specified key to be inserted.value
- the value associated with the specified key.RocksDBException
- when one of the TransactionalDB conditions
described above occurs, or in the case of an unexpected errorpublic void putUntracked(byte[] key, byte[] value) throws RocksDBException
RocksDB.put(byte[], byte[])
,
but operates on the transactions write batch. This write will only happen
if this transaction gets committed successfully.
Unlike put(byte[], byte[])
no conflict
checking will be performed for this key.
If this Transaction was created on a TransactionDB
, this function
will still acquire locks necessary to make sure this write doesn't cause
conflicts in other transactions; This may cause a RocksDBException
with associated Status.Code.Busy
.key
- the specified key to be inserted.value
- the value associated with the specified key.RocksDBException
- when one of the TransactionalDB conditions
described above occurs, or in the case of an unexpected errorpublic void putUntracked(ColumnFamilyHandle columnFamilyHandle, byte[][] keyParts, byte[][] valueParts) throws RocksDBException
putUntracked(ColumnFamilyHandle, byte[], byte[])
but
allows you to specify the key and value in several parts that will be
concatenated together.columnFamilyHandle
- The column family to put the key/value intokeyParts
- the specified key to be inserted.valueParts
- the value associated with the specified key.RocksDBException
- when one of the TransactionalDB conditions
described above occurs, or in the case of an unexpected errorpublic void putUntracked(byte[][] keyParts, byte[][] valueParts) throws RocksDBException
putUntracked(byte[], byte[])
but
allows you to specify the key and value in several parts that will be
concatenated together.keyParts
- the specified key to be inserted.valueParts
- the value associated with the specified key.RocksDBException
- when one of the TransactionalDB conditions
described above occurs, or in the case of an unexpected errorpublic void mergeUntracked(ColumnFamilyHandle columnFamilyHandle, byte[] key, byte[] value) throws RocksDBException
RocksDB.merge(ColumnFamilyHandle, byte[], byte[])
,
but operates on the transactions write batch. This write will only happen
if this transaction gets committed successfully.
Unlike merge(ColumnFamilyHandle, byte[], byte[])
no conflict
checking will be performed for this key.
If this Transaction was created on a TransactionDB
, this function
will still acquire locks necessary to make sure this write doesn't cause
conflicts in other transactions; This may cause a RocksDBException
with associated Status.Code.Busy
.columnFamilyHandle
- The column family to merge the key/value intokey
- the specified key to be merged.value
- the value associated with the specified key.RocksDBException
- when one of the TransactionalDB conditions
described above occurs, or in the case of an unexpected errorpublic void mergeUntracked(byte[] key, byte[] value) throws RocksDBException
RocksDB.merge(byte[], byte[])
,
but operates on the transactions write batch. This write will only happen
if this transaction gets committed successfully.
Unlike merge(byte[], byte[])
no conflict
checking will be performed for this key.
If this Transaction was created on a TransactionDB
, this function
will still acquire locks necessary to make sure this write doesn't cause
conflicts in other transactions; This may cause a RocksDBException
with associated Status.Code.Busy
.key
- the specified key to be merged.value
- the value associated with the specified key.RocksDBException
- when one of the TransactionalDB conditions
described above occurs, or in the case of an unexpected errorpublic void deleteUntracked(ColumnFamilyHandle columnFamilyHandle, byte[] key) throws RocksDBException
RocksDB.delete(ColumnFamilyHandle, byte[])
,
but operates on the transactions write batch. This write will only happen
if this transaction gets committed successfully.
Unlike delete(ColumnFamilyHandle, byte[])
no conflict
checking will be performed for this key.
If this Transaction was created on a TransactionDB
, this function
will still acquire locks necessary to make sure this write doesn't cause
conflicts in other transactions; This may cause a RocksDBException
with associated Status.Code.Busy
.columnFamilyHandle
- The column family to delete the key/value fromkey
- the specified key to be deleted.RocksDBException
- when one of the TransactionalDB conditions
described above occurs, or in the case of an unexpected errorpublic void deleteUntracked(byte[] key) throws RocksDBException
RocksDB.delete(byte[])
,
but operates on the transactions write batch. This write will only happen
if this transaction gets committed successfully.
Unlike delete(byte[])
no conflict
checking will be performed for this key.
If this Transaction was created on a TransactionDB
, this function
will still acquire locks necessary to make sure this write doesn't cause
conflicts in other transactions; This may cause a RocksDBException
with associated Status.Code.Busy
.key
- the specified key to be deleted.RocksDBException
- when one of the TransactionalDB conditions
described above occurs, or in the case of an unexpected errorpublic void deleteUntracked(ColumnFamilyHandle columnFamilyHandle, byte[][] keyParts) throws RocksDBException
deleteUntracked(ColumnFamilyHandle, byte[])
but allows
you to specify the key in several parts that will be
concatenated together.columnFamilyHandle
- The column family to delete the key/value fromkeyParts
- the specified key to be deleted.RocksDBException
- when one of the TransactionalDB conditions
described above occurs, or in the case of an unexpected errorpublic void deleteUntracked(byte[][] keyParts) throws RocksDBException
deleteUntracked(byte[])
but allows
you to specify the key in several parts that will be
concatenated together.keyParts
- the specified key to be deleted.RocksDBException
- when one of the TransactionalDB conditions
described above occurs, or in the case of an unexpected errorpublic void putLogData(byte[] blob)
AbstractWriteBatch.putLogData(byte[])
blob
- binary object to be insertedpublic void disableIndexing()
disableIndexing()
will turn off indexing for all future
put/merge/delete operations until enableIndexing()
is called.
If a key is put/merge/deleted after disableIndexing()
is called
and then is fetched via get/getForUpdate/getIterator, the result of the
fetch is undefined.public void enableIndexing()
disableIndexing()
public long getNumKeys()
TransactionDB
, this is the
number of keys that are currently locked by this transaction.
If this transaction was created by an OptimisticTransactionDB
,
this is the number of keys that need to be checked for conflicts at commit
time.public long getNumPuts()
public long getNumDeletes()
public long getNumMerges()
public long getElapsedTime()
public WriteBatchWithIndex getWriteBatch()
Transaction
class to
write to this transaction.public void setLockTimeout(long lockTimeout)
TransactionOptions.getLockTimeout()
(in milliseconds) for this transaction.
Has no effect on OptimisticTransactions.lockTimeout
- the timeout (in milliseconds) for locks used by this
transaction.public WriteOptions getWriteOptions()
commit()
.public void setWriteOptions(WriteOptions writeOptions)
commit()
.writeOptions
- The new WriteOptionspublic void undoGetForUpdate(ColumnFamilyHandle columnFamilyHandle, byte[] key)
getForUpdate(ReadOptions, ColumnFamilyHandle, byte[], boolean)
/
multiGetForUpdate(ReadOptions, List, byte[][])
, calling
undoGetForUpdate(ColumnFamilyHandle, byte[])
will tell
the transaction that it no longer needs to do any conflict checking
for this key.
If a key has been fetched N times via
getForUpdate(ReadOptions, ColumnFamilyHandle, byte[], boolean)
/
multiGetForUpdate(ReadOptions, List, byte[][])
, then
undoGetForUpdate(ColumnFamilyHandle, byte[])
will only have an
effect if it is also called N times. If this key has been written to in
this transaction, undoGetForUpdate(ColumnFamilyHandle, byte[])
will have no effect.
If setSavePoint()
has been called after the
getForUpdate(ReadOptions, ColumnFamilyHandle, byte[], boolean)
,
undoGetForUpdate(ColumnFamilyHandle, byte[])
will not have any
effect.
If this Transaction was created by an OptimisticTransactionDB
,
calling undoGetForUpdate(ColumnFamilyHandle, byte[])
can affect
whether this key is conflict checked at commit time.
If this Transaction was created by a TransactionDB
,
calling undoGetForUpdate(ColumnFamilyHandle, byte[])
may release
any held locks for this key.columnFamilyHandle
- ColumnFamilyHandle
instancekey
- the key to retrieve the value for.public void undoGetForUpdate(byte[] key)
getForUpdate(ReadOptions, byte[], boolean)
/
multiGetForUpdate(ReadOptions, List, byte[][])
, calling
undoGetForUpdate(byte[])
will tell
the transaction that it no longer needs to do any conflict checking
for this key.
If a key has been fetched N times via
getForUpdate(ReadOptions, byte[], boolean)
/
multiGetForUpdate(ReadOptions, List, byte[][])
, then
undoGetForUpdate(byte[])
will only have an
effect if it is also called N times. If this key has been written to in
this transaction, undoGetForUpdate(byte[])
will have no effect.
If setSavePoint()
has been called after the
getForUpdate(ReadOptions, byte[], boolean)
,
undoGetForUpdate(byte[])
will not have any
effect.
If this Transaction was created by an OptimisticTransactionDB
,
calling undoGetForUpdate(byte[])
can affect
whether this key is conflict checked at commit time.
If this Transaction was created by a TransactionDB
,
calling undoGetForUpdate(byte[])
may release
any held locks for this key.key
- the key to retrieve the value for.public void rebuildFromWriteBatch(WriteBatch writeBatch) throws RocksDBException
writeBatch
- The write batch to read fromRocksDBException
- if an error occurs whilst rebuilding from the
write batch.public WriteBatch getCommitTimeWriteBatch()
public void setLogNumber(long logNumber)
logNumber
- the log numberpublic long getLogNumber()
public void setName(java.lang.String transactionName) throws RocksDBException
transactionName
- the name of the transactionRocksDBException
- if an error occurs when setting the transaction
name.public java.lang.String getName()
public long getID()
public boolean isDeadlockDetect()
public Transaction.WaitingTransactions getWaitingTxns()
public Transaction.TransactionState getState()
@Experimental(value="NOTE: Experimental feature") public long getId()
protected final void disposeInternal(long handle)
disposeInternal
in class RocksObject