Package | Description |
---|---|
com.sleepycat.bind.serial |
Bindings that use Java serialization.
|
com.sleepycat.collections |
Data access based on the standard Java collections API.
|
com.sleepycat.je |
Foundation for creating environments, databases and transactions; provides
cursor based data access.
|
com.sleepycat.je.jca.ra |
Support for the Java Connector Architecture, which provides a standard
for connecting the J2EE platform to legacy enterprise information
systems (EIS), such as ERP systems, database systems, and legacy
applications not written in Java.
|
com.sleepycat.je.rep |
Berkeley DB Java Edition High Availability (JE HA) enables replication of JE
environments.
|
com.sleepycat.je.rep.arbiter |
Provides a mechanism to allow write availability for the Replication
group even when the number of replication nodes is less than majority.
|
com.sleepycat.je.rep.monitor |
BDB JE HA support for applications that need to track the composition of a
replication group, in order to do tasks such as load balancing and
request routing.
|
com.sleepycat.je.util |
Supporting utilities.
|
com.sleepycat.persist |
The Direct Persistence Layer (DPL) adds a persistent object model to the
Berkeley DB transactional engine.
|
com.sleepycat.persist.evolve |
Utilities for managing class evolution of persistent objects.
|
com.sleepycat.persist.raw |
Raw data access for general purpose tools and manual conversions.
|
Modifier and Type | Method and Description |
---|---|
void |
ClassCatalog.close()
Close a catalog database and release any cached resources.
|
void |
StoredClassCatalog.close() |
java.io.ObjectStreamClass |
ClassCatalog.getClassFormat(byte[] classID)
Return the ObjectStreamClass for the given class ID.
|
java.io.ObjectStreamClass |
StoredClassCatalog.getClassFormat(byte[] classID) |
byte[] |
ClassCatalog.getClassID(java.io.ObjectStreamClass classDesc)
Return the class ID for the current version of the given class
description.
|
byte[] |
StoredClassCatalog.getClassID(java.io.ObjectStreamClass classFormat) |
Constructor and Description |
---|
StoredClassCatalog(Database database)
Creates a catalog based on a given database.
|
Modifier and Type | Method and Description |
---|---|
Transaction |
CurrentTransaction.abortTransaction()
Aborts the transaction that is active for the current thread for this
environment and makes the parent transaction (if any) the current
transaction.
|
void |
PrimaryKeyAssigner.assignKey(DatabaseEntry keyData)
Assigns a new primary key value into the given buffer.
|
Transaction |
CurrentTransaction.beginTransaction(TransactionConfig config)
Begins a new transaction for this environment and associates it with
the current thread.
|
Transaction |
CurrentTransaction.commitTransaction()
Commits the transaction that is active for the current thread for this
environment and makes the parent transaction (if any) the current
transaction.
|
void |
TransactionRunner.run(TransactionWorker worker)
Calls the
TransactionWorker.doWork() method and, for transactional
environments, may begin and end a transaction. |
Modifier and Type | Class and Description |
---|---|
class |
DatabaseExistsException
Thrown by
Environment.openDatabase and
Environment.openSecondaryDatabase
if the database already exists and the DatabaseConfig
ExclusiveCreate parameter is true. |
class |
DatabaseNotFoundException
Thrown when an operation requires a database and that database does not
exist.
|
class |
DeadlockException
Thrown when a deadlock is detected.
|
class |
DeleteConstraintException
Thrown when an attempt is made to delete a key from a foreign key database,
when that key is referenced by a secondary database, and the secondary is
configured to cause an abort in this situation.
|
class |
DiskLimitException
Thrown when a write operation cannot be performed because a disk limit has
been violated.
|
class |
DiskOrderedCursorProducerException
Thrown by
ForwardCursor.getNext when a
DiskOrderedCursor producer thread throws an exception. |
class |
DuplicateDataException
Thrown by
Cursor.putCurrent if the old and new
data are not equal according to the configured duplicate comparator or
default comparator. |
class |
EnvironmentFailureException
Indicates that a failure has occurred that could impact the
Environment as a whole. |
class |
EnvironmentLockedException
Thrown by the
Environment constructor when an environment cannot be
opened for write access because another process has the same environment
open for write access. |
class |
EnvironmentNotFoundException
Thrown by the
Environment constructor when EnvironmentConfig
AllowCreate property is false (environment creation is not permitted), but
there are no log files in the environment directory. |
class |
EnvironmentWedgedException
Thrown by the
Environment.close() when the current process must be
shut down and restarted before re-opening the Environment. |
class |
ForeignConstraintException
Thrown when an attempt to write a primary database record would insert a
secondary record with a key that does not exist in a foreign key database,
when the secondary key is configured as a foreign key.
|
class |
LockConflictException
The common base class for all exceptions that result from record lock
conflicts during read and write operations.
|
class |
LockNotAvailableException
Thrown when a non-blocking operation fails to get a lock.
|
class |
LockNotGrantedException
Deprecated.
replaced by
LockNotAvailableException |
class |
LockTimeoutException
Thrown when multiple threads are competing for a lock and the lock timeout
interval is exceeded for the current operation.
|
class |
LogWriteException
Thrown when an
IOException or other failure occurs when writing to
the JE log. |
class |
OperationFailureException
Indicates that a failure has occurred that impacts the current operation
and/or transaction.
|
class |
RunRecoveryException
Deprecated.
replaced by
EnvironmentFailureException and Environment.isValid() . |
class |
SecondaryConstraintException
Base class for exceptions thrown when a write operation fails because of a
secondary constraint.
|
class |
SecondaryIntegrityException
Thrown when an integrity problem is detected while accessing a secondary
database, including access to secondaries while writing to a primary
database.
|
class |
SecondaryReferenceException
Base class for exceptions thrown when a read or write operation fails
because of a secondary constraint or integrity problem.
|
class |
SequenceExistsException
Thrown by
Database.openSequence if the
sequence record already exists and the SequenceConfig
ExclusiveCreate parameter is true. |
class |
SequenceIntegrityException
Thrown by
Sequence.get if the sequence record has been
deleted. |
class |
SequenceNotFoundException
Thrown by
Database.openSequence if the
sequence record does not exist and the SequenceConfig AllowCreate
parameter is false. |
class |
SequenceOverflowException
Thrown by
Sequence.get if the end of the sequence is
reached and wrapping is not configured. |
class |
ThreadInterruptedException
Thrown when
java.lang.InterruptedException (a thread interrupt) or
java.nio.channels.ClosedChannelException (which also results from a
thread interrupt) occurs in any JE method. |
class |
TransactionTimeoutException
Thrown when the transaction timeout interval is exceeded.
|
class |
UniqueConstraintException
Thrown when an attempt to write a primary database record would insert a
secondary record with a duplicate key, for secondaries that represent
one-to-one and one-to-many relationships.
|
class |
VersionMismatchException
Thrown by the Environment constructor when an environment cannot be
opened because the version of the existing log is not compatible with the
version of JE that is running.
|
class |
XAFailureException
Thrown if an attempt is made to use a
Transaction after it has been
invalidated as the result of an XA failure. |
Modifier and Type | Method and Description |
---|---|
void |
Transaction.abort()
Cause an abnormal termination of the transaction.
|
Transaction |
Environment.beginTransaction(Transaction parent,
TransactionConfig txnConfig)
Creates a new transaction in the database environment.
|
void |
Environment.checkpoint(CheckpointConfig ckptConfig)
Synchronously checkpoint the database environment.
|
int |
Environment.cleanLog()
Synchronously invokes log file (data file) cleaning until the target
disk space utilization has been reached; this method is called
periodically by the cleaner background threads.
|
boolean |
Environment.cleanLogFile()
Synchronously invokes cleaning of a single log file (data file), if
the target disk space utilization has not been reached.
|
void |
Sequence.close()
Closes a sequence.
|
void |
DiskOrderedCursor.close()
Discards the cursor.
|
void |
Environment.close()
The Environment.close method closes the Berkeley DB environment.
|
void |
JoinCursor.close()
Closes the cursors that have been opened by this join cursor.
|
void |
Transaction.commit()
End the transaction.
|
void |
Transaction.commit(Durability durability)
End the transaction using the specified durability requirements.
|
void |
Transaction.commitNoSync()
End the transaction, not writing to stable storage and not committing
synchronously.
|
void |
Transaction.commitSync()
End the transaction, writing to stable storage and committing
synchronously.
|
void |
Transaction.commitWriteNoSync()
End the transaction, writing to stable storage but not committing
synchronously.
|
void |
Environment.compress()
Synchronously invokes the compressor mechanism which compacts in memory
data structures after delete operations.
|
void |
Environment.evictMemory()
Synchronously invokes the mechanism for keeping memory usage within the
cache size boundaries.
|
long |
Sequence.get(Transaction txn,
int delta)
Returns the next available element in the sequence and changes the
sequence value by
delta . |
EnvironmentConfig |
Environment.getConfig()
Returns this object's configuration.
|
java.util.List<java.lang.String> |
Environment.getDatabaseNames()
Returns a List of database names for the database environment.
|
java.io.File |
Environment.getHome()
Returns the database environment's home directory.
|
LockStats |
Environment.getLockStats(StatsConfig config)
Deprecated.
as of 4.0.10, replaced by
Environment.getStats(StatsConfig) . |
EnvironmentMutableConfig |
Environment.getMutableConfig()
Returns database environment attributes.
|
SequenceStats |
Sequence.getStats(StatsConfig config)
Returns statistical information about the sequence.
|
EnvironmentStats |
Environment.getStats(StatsConfig config)
Returns the general database environment statistics.
|
Transaction |
Environment.getThreadTransaction()
Returns the transaction associated with this thread if implied
transactions are being used.
|
TransactionStats |
Environment.getTransactionStats(StatsConfig config)
Returns the database environment's transactional statistics.
|
boolean |
ForeignKeyNullifier.nullifyForeignKey(SecondaryDatabase secondary,
DatabaseEntry data)
Sets the foreign key reference to null in the datum of the primary
database.
|
boolean |
ForeignMultiKeyNullifier.nullifyForeignKey(SecondaryDatabase secondary,
DatabaseEntry key,
DatabaseEntry data,
DatabaseEntry secKey)
Sets the foreign key reference to null in the datum of the primary
database.
|
DiskOrderedCursor |
Environment.openDiskOrderedCursor(Database[] databases,
DiskOrderedCursorConfig config)
Create a DiskOrderedCursor to iterate over the records of a given set
of databases.
|
SecondaryDatabase |
Environment.openSecondaryDatabase(Transaction txn,
java.lang.String databaseName,
Database primaryDatabase,
SecondaryConfig dbConfig)
Opens and optionally creates a
SecondaryDatabase . |
PreloadStats |
Environment.preload(Database[] databases,
PreloadConfig config)
Preloads the cache with multiple databases.
|
void |
Transaction.setLockTimeout(long timeOut)
Deprecated.
as of 4.0, replaced by
Transaction.setLockTimeout(long,
TimeUnit) . |
void |
Transaction.setLockTimeout(long timeOut,
java.util.concurrent.TimeUnit unit)
Configures the lock request timeout value for the transaction.
|
void |
Environment.setMutableConfig(EnvironmentMutableConfig mutableConfig)
Sets database environment attributes.
|
void |
Transaction.setTxnTimeout(long timeOut)
Deprecated.
as of 4.0, replaced by
Transaction.setTxnTimeout(long,
TimeUnit) . |
void |
Transaction.setTxnTimeout(long timeOut,
java.util.concurrent.TimeUnit unit)
Configures the timeout value for the transaction lifetime.
|
void |
Environment.sync()
Synchronously flushes database environment databases to stable storage.
|
boolean |
Environment.verify(VerifyConfig config,
java.io.PrintStream out)
Returns if the database environment is consistent and correct.
|
Constructor and Description |
---|
Environment(java.io.File envHome,
EnvironmentConfig configuration)
Creates a database environment handle.
|
Modifier and Type | Method and Description |
---|---|
Database |
JEConnection.openDatabase(java.lang.String name,
DatabaseConfig config) |
SecondaryDatabase |
JEConnection.openSecondaryDatabase(java.lang.String name,
Database primaryDatabase,
SecondaryConfig config) |
void |
JEConnection.removeDatabase(java.lang.String databaseName) |
long |
JEConnection.truncateDatabase(java.lang.String databaseName,
boolean returnCount) |
Modifier and Type | Class and Description |
---|---|
class |
DatabasePreemptedException
Thrown when attempting to use a Database handle that was forcibly closed by
replication.
|
class |
GroupShutdownException
Thrown when an attempt is made to access an environment that was
shutdown by the Master as a result of a call to
ReplicatedEnvironment.shutdownGroup(long, TimeUnit) . |
class |
InsufficientAcksException
This exception is thrown at the time of a commit in a Master, if the Master
could not obtain transaction commit acknowledgments from its Replicas in
accordance with the
Durability.ReplicaAckPolicy currently in effect and within
the requested timeout interval. |
class |
InsufficientLogException
This exception indicates that the log files constituting the Environment are
insufficient and cannot be used as the basis for continuing with the
replication stream provided by the current master.
|
class |
InsufficientReplicasException
Thrown by
Environment.beginTransaction(com.sleepycat.je.Transaction, com.sleepycat.je.TransactionConfig) and Transaction.commit() when these operations are initiated at a Master which is
not in contact with a quorum of Replicas as determined by the Durability.ReplicaAckPolicy that is in effect for the operation. |
class |
LockPreemptedException
Thrown when a lock has been "stolen", or preempted, from a transaction in a
replicated environment.
|
class |
LogOverwriteException
Thrown when one or more log files are modified (overwritten) as the result
of a replication operation.
|
class |
MasterReplicaTransitionException
Deprecated.
as of JE 5.0.88 because the environment no longer needs to
restart when transitioning from master to replica.
|
class |
MasterStateException
This exception indicates that the application attempted an operation that is
not permitted when it is in the
ReplicatedEnvironment.State.MASTER
state. |
class |
MasterTransferFailureException
Thrown by
ReplicatedEnvironment.transferMaster(java.util.Set<java.lang.String>, int, java.util.concurrent.TimeUnit) if a Master Transfer
operation cannot be completed within the allotted time. |
class |
MemberNotFoundException
Thrown when an operation requires a replication group member and that member
is not present in the replication group.
|
class |
ReplicaConsistencyException
This exception is thrown by a Replica to indicate it could not meet the
consistency requirements as defined by the
ReplicaConsistencyPolicy in effect for the transaction, within
the allowed timeout period. |
class |
ReplicaStateException
This exception indicates that the application attempted an operation that is
not permitted when it is in the
ReplicatedEnvironment.State.REPLICA
state. |
class |
ReplicaWriteException
This exception indicates that an update operation or transaction commit
or abort was attempted while in the
ReplicatedEnvironment.State.REPLICA state. |
class |
RestartRequiredException
RestartRequiredException serves as the base class for all exceptions which
makes it impossible for HA to proceed without some form of corrective action
on the part of the user, followed by a restart of the application.
|
class |
RollbackException
This asynchronous exception indicates that a new master has been selected,
this
Replica 's log is ahead of the current Master ,
and in this case, the Replica was unable to rollback without a
recovery. |
class |
RollbackProhibitedException
This exception may be thrown by a Replica during the
replication stream sync-up phase of startup.
|
class |
StateChangeException
Provides a synchronous mechanism for informing an application about a change
in the state of the replication node.
|
class |
UnknownMasterException
Indicates that the underlying operation requires communication with a
Master, but that a Master was not available.
|
Modifier and Type | Method and Description |
---|---|
void |
ReplicatedEnvironment.close()
Close this ReplicatedEnvironment and release any resources used by the
handle.
|
ReplicationGroup |
ReplicatedEnvironment.getGroup()
Returns a description of the replication group as known by this node.
|
ReplicationConfig |
ReplicatedEnvironment.getRepConfig()
Return the replication configuration that has been used to create this
handle.
|
ReplicationMutableConfig |
ReplicatedEnvironment.getRepMutableConfig() |
ReplicatedEnvironmentStats |
ReplicatedEnvironment.getRepStats(StatsConfig config)
Returns statistics associated with this environment.
|
ReplicatedEnvironment.State |
ReplicatedEnvironment.getState()
Returns the current state of the node associated with this replication
environment.
|
StateChangeListener |
ReplicatedEnvironment.getStateChangeListener()
Returns the listener used to receive asynchronous replication node state
change events.
|
void |
ReplicatedEnvironment.setRepMutableConfig(ReplicationMutableConfig mutableConfig) |
void |
ReplicatedEnvironment.setStateChangeListener(StateChangeListener listener)
Sets the listener used to receive asynchronous replication node state
change events.
|
Modifier and Type | Method and Description |
---|---|
ArbiterStats |
Arbiter.getStats(StatsConfig config)
Gets the Arbiter statistics.
|
void |
Arbiter.setArbiterMutableConfig(ArbiterMutableConfig config)
Sets the Arbiter mutable attributes.
|
void |
Arbiter.shutdown()
Shutdown the Arbiter.
|
Constructor and Description |
---|
Arbiter(ArbiterConfig arbiterConfig)
An Arbiter used in elections and transaction acknowledgments.
|
Modifier and Type | Method and Description |
---|---|
ReplicationGroup |
Monitor.getGroup()
Returns the current composition of the group.
|
void |
Monitor.startListener(MonitorChangeListener newListener)
Starts the listener so it's actively listening for election results and
broadcasts of replication group changes.
|
Modifier and Type | Method and Description |
---|---|
boolean |
DbLoad.load() |
static void |
DbStat.main(java.lang.String[] argv) |
static void |
DbVerify.main(java.lang.String[] argv)
The main used by the DbVerify utility.
|
void |
DbSpace.print(java.io.PrintStream out)
Calculates utilization and prints a report to the given output stream.
|
void |
DbBackup.startBackup()
Start backup mode in order to determine the definitive backup set needed
at this point in time.
|
boolean |
DbVerify.verify(java.io.PrintStream out)
Deprecated.
as of 7.5, use
Environment.verify(com.sleepycat.je.VerifyConfig, java.io.PrintStream) or
Database.verify(com.sleepycat.je.VerifyConfig) instead. These methods allow
specifying all VerifyConfig properties. |
Constructor and Description |
---|
DbBackup(Environment env)
Creates a DbBackup helper for a full backup.
|
Modifier and Type | Class and Description |
---|---|
class |
IndexNotAvailableException
Thrown by the
getPrimaryIndex , getSecondaryIndex and getSubclassIndex when an index has not yet
been created. |
class |
StoreExistsException
Thrown by the
EntityStore constructor when the ExclusiveCreate configuration parameter is
true and the store's internal catalog database already exists. |
class |
StoreNotFoundException
Thrown by the
EntityStore constructor when the AllowCreate configuration parameter is false and
the store's internal catalog database does not exist. |
Modifier and Type | Method and Description |
---|---|
void |
EntityStore.close()
Closes all databases and sequences that were opened via this store.
|
void |
ForwardCursor.close()
Closes the cursor.
|
void |
EntityCursor.close()
Closes the cursor.
|
void |
EntityStore.closeClass(java.lang.Class entityClass)
Closes the primary and secondary databases for the given entity class
that were opened via this store.
|
boolean |
EntityIndex.contains(K key)
Checks for existence of a key in this index.
|
boolean |
EntityIndex.contains(Transaction txn,
K key,
LockMode lockMode)
Checks for existence of a key in this index.
|
long |
EntityIndex.count()
Returns a non-transactional count of the entities in this index.
|
int |
EntityCursor.count()
Returns the number of values (duplicates) for the key at the cursor
position, or returns zero if all values for the key have been deleted.
|
long |
EntityIndex.count(long memoryLimit)
Returns a non-transactional count of the entities in this index.
|
long |
EntityCursor.countEstimate()
Returns a rough estimate of the number of values (duplicates) for the
key at the cursor position, or returns zero if all values for the key
have been deleted.
|
V |
EntityCursor.current()
Returns the value at the cursor position, or null if the value at the
cursor position has been deleted.
|
V |
EntityCursor.current(LockMode lockMode)
Returns the value at the cursor position, or null if the value at the
cursor position has been deleted.
|
boolean |
EntityCursor.delete()
Deletes the entity at the cursor position.
|
boolean |
EntityIndex.delete(K key)
Deletes all entities with a given index key.
|
boolean |
EntityIndex.delete(Transaction txn,
K key)
Deletes all entities with a given index key.
|
OperationResult |
EntityIndex.delete(Transaction txn,
K key,
WriteOptions options)
Deletes all entities with a given index key, using a WriteOptions
parameter and returning an OperationResult.
|
OperationResult |
EntityCursor.delete(WriteOptions options)
Deletes the entity at the cursor position, using a WriteOptions
parameter and returning an OperationResult.
|
EntityCursor<V> |
EntityCursor.dup()
Duplicates the cursor at the cursor position.
|
EntityCursor<V> |
EntityIndex.entities()
Opens a cursor for traversing all entities in this index.
|
ForwardCursor<E> |
EntityJoin.entities()
Opens a cursor that returns the entities qualifying for the join.
|
EntityCursor<V> |
EntityIndex.entities(K fromKey,
boolean fromInclusive,
K toKey,
boolean toInclusive)
Opens a cursor for traversing entities in a key range.
|
EntityCursor<V> |
EntityIndex.entities(Transaction txn,
CursorConfig config)
Opens a cursor for traversing all entities in this index.
|
ForwardCursor<E> |
EntityJoin.entities(Transaction txn,
CursorConfig config)
Opens a cursor that returns the entities qualifying for the join.
|
EntityCursor<V> |
EntityIndex.entities(Transaction txn,
K fromKey,
boolean fromInclusive,
K toKey,
boolean toInclusive,
CursorConfig config)
Opens a cursor for traversing entities in a key range.
|
EvolveStats |
EntityStore.evolve(EvolveConfig config)
Performs conversion of unevolved objects in order to reduce lazy
conversion overhead.
|
V |
EntityCursor.first()
Moves the cursor to the first value and returns it, or returns null if
the cursor range is empty.
|
V |
EntityCursor.first(LockMode lockMode)
Moves the cursor to the first value and returns it, or returns null if
the cursor range is empty.
|
EntityResult<V> |
EntityCursor.get(Get getType,
ReadOptions options)
Moves the cursor according to the specified
Get type and returns
the value at the updated position. |
V |
EntityIndex.get(K key)
Gets an entity via a key of this index.
|
E |
PrimaryIndex.get(PK key) |
E |
SecondaryIndex.get(SK key) |
EntityResult<V> |
EntityIndex.get(Transaction txn,
K key,
Get getType,
ReadOptions options)
Gets an entity via a key of this index, using Get type and ReadOptions
parameters, and returning an EntityResult.
|
V |
EntityIndex.get(Transaction txn,
K key,
LockMode lockMode)
Gets an entity via a key of this index.
|
EntityResult<E> |
PrimaryIndex.get(Transaction txn,
PK key,
Get getType,
ReadOptions options) |
E |
PrimaryIndex.get(Transaction txn,
PK key,
LockMode lockMode) |
EntityResult<E> |
SecondaryIndex.get(Transaction txn,
SK key,
Get getType,
ReadOptions options) |
E |
SecondaryIndex.get(Transaction txn,
SK key,
LockMode lockMode) |
<PK,E> PrimaryIndex<PK,E> |
EntityStore.getPrimaryIndex(java.lang.Class<PK> primaryKeyClass,
java.lang.Class<E> entityClass)
Returns the primary index for a given entity class, opening it if
necessary.
|
<SK,PK,E> SecondaryIndex<SK,PK,E> |
EntityStore.getSecondaryIndex(PrimaryIndex<PK,E> primaryIndex,
java.lang.Class<SK> keyClass,
java.lang.String keyName)
Returns a secondary index for a given primary index and secondary key,
opening it if necessary.
|
Sequence |
EntityStore.getSequence(java.lang.String name)
Returns a named sequence for using Berkeley DB engine API directly,
opening it if necessary.
|
static java.util.Set<java.lang.String> |
EntityStore.getStoreNames(Environment env)
Returns the names of all entity stores in the given environment.
|
<SK,PK,E1,E2 extends E1> |
EntityStore.getSubclassIndex(PrimaryIndex<PK,E1> primaryIndex,
java.lang.Class<E2> entitySubclass,
java.lang.Class<SK> keyClass,
java.lang.String keyName)
Returns a secondary index for a secondary key in an entity subclass,
opening it if necessary.
|
EntityCursor<K> |
EntityIndex.keys()
Opens a cursor for traversing all keys in this index.
|
ForwardCursor<PK> |
EntityJoin.keys()
Opens a cursor that returns the primary keys of entities qualifying for
the join.
|
EntityCursor<K> |
EntityIndex.keys(K fromKey,
boolean fromInclusive,
K toKey,
boolean toInclusive)
Opens a cursor for traversing keys in a key range.
|
EntityCursor<K> |
EntityIndex.keys(Transaction txn,
CursorConfig config)
Opens a cursor for traversing all keys in this index.
|
ForwardCursor<PK> |
EntityJoin.keys(Transaction txn,
CursorConfig config)
Opens a cursor that returns the primary keys of entities qualifying for
the join.
|
EntityCursor<K> |
EntityIndex.keys(Transaction txn,
K fromKey,
boolean fromInclusive,
K toKey,
boolean toInclusive,
CursorConfig config)
Opens a cursor for traversing keys in a key range.
|
EntityIndex<SK,PK> |
SecondaryIndex.keysIndex()
Returns a read-only keys index that maps secondary key to primary key.
|
V |
EntityCursor.last()
Moves the cursor to the last value and returns it, or returns null if
the cursor range is empty.
|
V |
EntityCursor.last(LockMode lockMode)
Moves the cursor to the last value and returns it, or returns null if
the cursor range is empty.
|
V |
ForwardCursor.next()
Moves the cursor to the next value and returns it, or returns null
if there are no more values in the cursor range.
|
V |
EntityCursor.next()
Moves the cursor to the next value and returns it, or returns null
if there are no more values in the cursor range.
|
V |
ForwardCursor.next(LockMode lockMode)
Moves the cursor to the next value and returns it, or returns null
if there are no more values in the cursor range.
|
V |
EntityCursor.next(LockMode lockMode)
Moves the cursor to the next value and returns it, or returns null
if there are no more values in the cursor range.
|
V |
EntityCursor.nextDup()
Moves the cursor to the next value with the same key (duplicate) and
returns it, or returns null if no more values are present for the key at
the current position.
|
V |
EntityCursor.nextDup(LockMode lockMode)
Moves the cursor to the next value with the same key (duplicate) and
returns it, or returns null if no more values are present for the key at
the current position.
|
V |
EntityCursor.nextNoDup()
Moves the cursor to the next value with a different key and returns it,
or returns null if there are no more unique keys in the cursor range.
|
V |
EntityCursor.nextNoDup(LockMode lockMode)
Moves the cursor to the next value with a different key and returns it,
or returns null if there are no more unique keys in the cursor range.
|
V |
EntityCursor.prev()
Moves the cursor to the previous value and returns it, or returns null
if there are no preceding values in the cursor range.
|
V |
EntityCursor.prev(LockMode lockMode)
Moves the cursor to the previous value and returns it, or returns null
if there are no preceding values in the cursor range.
|
V |
EntityCursor.prevDup()
Moves the cursor to the previous value with the same key (duplicate) and
returns it, or returns null if no preceding values are present for the
key at the current position.
|
V |
EntityCursor.prevDup(LockMode lockMode)
Moves the cursor to the previous value with the same key (duplicate) and
returns it, or returns null if no preceding values are present for the
key at the current position.
|
V |
EntityCursor.prevNoDup()
Moves the cursor to the preceding value with a different key and returns
it, or returns null if there are no preceding unique keys in the cursor
range.
|
V |
EntityCursor.prevNoDup(LockMode lockMode)
Moves the cursor to the preceding value with a different key and returns
it, or returns null if there are no preceding unique keys in the cursor
range.
|
E |
PrimaryIndex.put(E entity)
Inserts an entity and returns null, or updates it if the primary key
already exists and returns the existing entity.
|
E |
PrimaryIndex.put(Transaction txn,
E entity)
Inserts an entity and returns null, or updates it if the primary key
already exists and returns the existing entity.
|
boolean |
PrimaryIndex.putNoOverwrite(E entity)
Inserts an entity and returns true, or returns false if the primary key
already exists.
|
boolean |
PrimaryIndex.putNoOverwrite(Transaction txn,
E entity)
Inserts an entity and returns true, or returns false if the primary key
already exists.
|
void |
PrimaryIndex.putNoReturn(E entity)
Inserts an entity, or updates it if the primary key already exists (does
not return the existing entity).
|
void |
PrimaryIndex.putNoReturn(Transaction txn,
E entity)
Inserts an entity, or updates it if the primary key already exists (does
not return the existing entity).
|
EntityIndex<PK,E> |
SecondaryIndex.subIndex(SK key)
Returns an index that maps primary key to entity for the subset of
entities having a given secondary key (duplicates).
|
void |
EntityStore.sync()
Flushes each modified index to disk that was opened in deferred-write
mode.
|
void |
EntityStore.truncateClass(java.lang.Class entityClass)
Deletes all instances of this entity class and its (non-entity)
subclasses.
|
void |
EntityStore.truncateClass(Transaction txn,
java.lang.Class entityClass)
Deletes all instances of this entity class and its (non-entity)
subclasses.
|
boolean |
EntityCursor.update(V entity)
Replaces the entity at the cursor position with the given entity.
|
OperationResult |
EntityCursor.update(V entity,
WriteOptions options)
Replaces the entity at the cursor position with the given entity,
using a WriteOptions parameter and returning an OperationResult.
|
Constructor and Description |
---|
EntityStore(Environment env,
java.lang.String storeName,
StoreConfig config)
Opens an entity store in a given environment.
|
PrimaryIndex(Database database,
java.lang.Class<PK> keyClass,
EntryBinding<PK> keyBinding,
java.lang.Class<E> entityClass,
EntityBinding<E> entityBinding)
Creates a primary index without using an
EntityStore . |
SecondaryIndex(SecondaryDatabase database,
Database keysDatabase,
PrimaryIndex<PK,E> primaryIndex,
java.lang.Class<SK> secondaryKeyClass,
EntryBinding<SK> secondaryKeyBinding)
Creates a secondary index without using an
EntityStore . |
Modifier and Type | Class and Description |
---|---|
class |
DeletedClassException
While reading from an index, an instance of a deleted class version was
encountered.
|
class |
IncompatibleClassException
A class has been changed incompatibly and no mutation has been configured to
handle the change or a new class version number has not been assigned.
|
Modifier and Type | Method and Description |
---|---|
void |
RawStore.close()
Closes all databases and sequences that were opened by this model.
|
PrimaryIndex<java.lang.Object,RawObject> |
RawStore.getPrimaryIndex(java.lang.String entityClass)
Opens the primary index for a given entity class.
|
SecondaryIndex<java.lang.Object,java.lang.Object,RawObject> |
RawStore.getSecondaryIndex(java.lang.String entityClass,
java.lang.String keyName)
Opens the secondary index for a given entity class and secondary key
name.
|
Constructor and Description |
---|
RawStore(Environment env,
java.lang.String storeName,
StoreConfig config)
Opens an entity store for raw data access.
|
Copyright (c) 2002, 2017 Oracle and/or its affiliates. All rights reserved.