Uses of Class
com.sleepycat.je.DatabaseException

Packages that use DatabaseException

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.

Uses of DatabaseException in com.sleepycat.bind.serial

Methods in com.sleepycat.bind.serial that throw DatabaseException

Modifier and Type	Method	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)

Constructors in com.sleepycat.bind.serial that throw DatabaseException

Constructor	Description
StoredClassCatalog(Database database)	Creates a catalog based on a given database.

Uses of DatabaseException in com.sleepycat.collections

Methods in com.sleepycat.collections that throw DatabaseException

Modifier and Type	Method	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.

Uses of DatabaseException in com.sleepycat.je

Subclasses of DatabaseException in com.sleepycat.je

Modifier and Type	Class	Description
class	CorruptSecondariesException	Thrown by Environment.openDatabase if one or more corrupt SecondaryDatabases are detected.
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.

Methods in com.sleepycat.je that throw DatabaseException

Modifier and Type	Method	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	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	Sequence.close()	Closes a sequence.
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.
EnvironmentStats	Environment.getStats(StatsConfig config)	Returns the general database environment statistics.
SequenceStats	Sequence.getStats(StatsConfig config)	Returns statistical information about the sequence.
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.

Constructors in com.sleepycat.je that throw DatabaseException

Constructor	Description
Environment(java.io.File envHome, EnvironmentConfig configuration)	Creates a database environment handle.

Uses of DatabaseException in com.sleepycat.je.jca.ra

Methods in com.sleepycat.je.jca.ra that throw DatabaseException

Modifier and Type	Method	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)

Uses of DatabaseException in com.sleepycat.je.rep

Subclasses of DatabaseException in com.sleepycat.je.rep

Modifier and Type	Class	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.

Methods in com.sleepycat.je.rep that throw DatabaseException

Modifier and Type	Method	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.

Uses of DatabaseException in com.sleepycat.je.rep.arbiter

Methods in com.sleepycat.je.rep.arbiter that throw DatabaseException

Modifier and Type	Method	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.

Constructors in com.sleepycat.je.rep.arbiter that throw DatabaseException

Constructor	Description
Arbiter(ArbiterConfig arbiterConfig)	An Arbiter used in elections and transaction acknowledgments.

Uses of DatabaseException in com.sleepycat.je.rep.monitor

Methods in com.sleepycat.je.rep.monitor that throw DatabaseException

Modifier and Type	Method	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.

Uses of DatabaseException in com.sleepycat.je.util

Methods in com.sleepycat.je.util that throw DatabaseException

Modifier and Type	Method	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.

Constructors in com.sleepycat.je.util that throw DatabaseException

Constructor	Description
DbBackup(Environment env)	Creates a DbBackup helper for a full backup.

Uses of DatabaseException in com.sleepycat.persist

Subclasses of DatabaseException in com.sleepycat.persist

Modifier and Type	Class	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.

Methods in com.sleepycat.persist that throw DatabaseException

Modifier and Type	Method	Description
void	EntityCursor.close()	Closes the cursor.
void	EntityStore.close()	Closes all databases and sequences that were opened via this store.
void	ForwardCursor.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(Transaction txn, K key, LockMode lockMode)	Checks for existence of a key in this index.
boolean	EntityIndex.contains(K key)	Checks for existence of a key 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()	Returns a non-transactional count of the entities in this index.
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.
OperationResult	EntityCursor.delete(WriteOptions options)	Deletes the entity at the cursor position, using a WriteOptions parameter and returning an OperationResult.
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.
boolean	EntityIndex.delete(K key)	Deletes all entities with a given index key.
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.
EntityCursor<V>	EntityIndex.entities(Transaction txn, CursorConfig config)	Opens a cursor for traversing all entities in this index.
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.
EntityCursor<V>	EntityIndex.entities(K fromKey, boolean fromInclusive, K toKey, boolean toInclusive)	Opens a cursor for traversing entities in a key range.
ForwardCursor<E>	EntityJoin.entities()	Opens a cursor that returns the entities qualifying for the join.
ForwardCursor<E>	EntityJoin.entities(Transaction txn, CursorConfig config)	Opens a cursor that returns the entities qualifying for the join.
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.
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.
V	EntityIndex.get(K key)	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)
E	PrimaryIndex.get(PK key)
EntityResult<E>	SecondaryIndex.get(Transaction txn, SK key, Get getType, ReadOptions options)
E	SecondaryIndex.get(Transaction txn, SK key, LockMode lockMode)
E	SecondaryIndex.get(SK key)
<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> SecondaryIndex<SK,PK,E2>	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.
EntityCursor<K>	EntityIndex.keys(Transaction txn, CursorConfig config)	Opens a cursor for traversing all keys in this index.
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.
EntityCursor<K>	EntityIndex.keys(K fromKey, boolean fromInclusive, K toKey, boolean toInclusive)	Opens a cursor for traversing keys in a key range.
ForwardCursor<PK>	EntityJoin.keys()	Opens a cursor that returns the primary keys of entities qualifying for the join.
ForwardCursor<PK>	EntityJoin.keys(Transaction txn, CursorConfig config)	Opens a cursor that returns the primary keys of entities qualifying for the join.
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	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	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	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	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.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(Transaction txn, 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(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(Transaction txn, E entity)	Inserts an entity and returns true, or returns false if the primary key already exists.
boolean	PrimaryIndex.putNoOverwrite(E entity)	Inserts an entity and returns true, or returns false if the primary key already exists.
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).
void	PrimaryIndex.putNoReturn(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(Transaction txn, java.lang.Class entityClass)	Deletes all instances of this entity class and its (non-entity) subclasses.
void	EntityStore.truncateClass(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.

Constructors in com.sleepycat.persist that throw DatabaseException

Constructor	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.

Uses of DatabaseException in com.sleepycat.persist.evolve

Subclasses of DatabaseException in com.sleepycat.persist.evolve

Modifier and Type	Class	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.

Uses of DatabaseException in com.sleepycat.persist.raw

Methods in com.sleepycat.persist.raw that throw DatabaseException

Modifier and Type	Method	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.

Constructors in com.sleepycat.persist.raw that throw DatabaseException

Constructor	Description
RawStore(Environment env, java.lang.String storeName, StoreConfig config)	Opens an entity store for raw data access.