Berkeley DB version 4.7.25

## Uses of Class
com.sleepycat.db.DatabaseException

Packages that use DatabaseException
com.sleepycat.bind.serial: Bindings that use Java serialization.
com.sleepycat.bind.tuple: Bindings that use sequences of primitive fields, or tuples.
com.sleepycat.collections: Data access based on the standard Java collections API.
com.sleepycat.db: Berkeley DB Java API [reference guide] [Java programming notes].
com.sleepycat.persist: The Direct Persistence Layer (DPL) adds a persistent object model to the Berkeley DB transactional engine.
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
`void` `StoredClassCatalog.close()`
`void` `ClassCatalog.close()` Close a catalog database and release any cached resources.
`boolean` `TupleSerialKeyCreator.createSecondaryKey(SecondaryDatabase db, DatabaseEntry primaryKeyEntry, DatabaseEntry dataEntry, DatabaseEntry indexKeyEntry)`
`boolean` `SerialSerialKeyCreator.createSecondaryKey(SecondaryDatabase db, DatabaseEntry primaryKeyEntry, DatabaseEntry dataEntry, DatabaseEntry indexKeyEntry)`
`ObjectStreamClass` `StoredClassCatalog.getClassFormat(byte[] classID)`
`ObjectStreamClass` `ClassCatalog.getClassFormat(byte[] classID)` Return the ObjectStreamClass for the given class ID.
`byte[]` `StoredClassCatalog.getClassID(ObjectStreamClass classFormat)`
`byte[]` `ClassCatalog.getClassID(ObjectStreamClass classDesc)` Return the class ID for the current version of the given class description.
`boolean` `TupleSerialKeyCreator.nullifyForeignKey(SecondaryDatabase db, DatabaseEntry dataEntry)`
`boolean` `SerialSerialKeyCreator.nullifyForeignKey(SecondaryDatabase db, DatabaseEntry dataEntry)`

Constructors in com.sleepycat.bind.serial that throw DatabaseException
`StoredClassCatalog(Database database)` Creates a catalog based on a given database.

Uses of DatabaseException in com.sleepycat.bind.tuple

Methods in com.sleepycat.bind.tuple that throw DatabaseException
`boolean` `TupleTupleKeyCreator.createSecondaryKey(SecondaryDatabase db, DatabaseEntry primaryKeyEntry, DatabaseEntry dataEntry, DatabaseEntry indexKeyEntry)`
`boolean` `TupleTupleKeyCreator.nullifyForeignKey(SecondaryDatabase db, DatabaseEntry dataEntry)`

Uses of DatabaseException in com.sleepycat.collections

Methods in com.sleepycat.collections that throw DatabaseException
`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 data 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.db

Subclasses of DatabaseException in com.sleepycat.db
`class` `DeadlockException` DeadlockException is thrown to a thread of control when multiple threads competing for a lock are deadlocked, when a lock request has timed out or when a lock request would need to block and the transaction has been configured to not wait for locks.
`class` `LockNotGrantedException` A LockNotGrantedException is thrown when a lock requested using the `Environment.getLock` or `Environment.lockVector` methods, where the noWait flag or lock timers were configured, could not be granted before the wait-time expired.
`class` `MemoryException` This exception is thrown when a `DatabaseEntry` passed to a `Database` or `Cursor` method is not large enough to hold a value being returned.
`class` `ReplicationDuplicateMasterException` The replication group has more than one master.
`class` `ReplicationHandleDeadException` Thrown when a database handle has been invalidated because a replication election unrolled a committed transaction.
`class` `ReplicationHoldElectionException` An election is needed.
`class` `ReplicationJoinFailureException` Thrown if a new master has been chosen but the client is unable to synchronize with the new master (possibly because the client has been configured with the `ReplicationConfig.NOAUTOINIT` setting to turn-off automatic internal initialization).
`class` `ReplicationLeaseExpiredException` Thrown if a master lease has expired.
`class` `ReplicationLeaseTimeoutException` Thrown if a master lease has timed out.
`class` `ReplicationLockoutException` Thrown when an operation was blocked by client/master synchronization.
`class` `ReplicationSiteUnavailableException` Thrown if replication group was unable to elect a master, or was unable to complete the election in the specified timeout period.
`class` `RunRecoveryException` Thrown when the database environment needs to be recovered.
`class` `VersionMismatchException` Thrown if the version of the Berkeley DB library doesn't match the version that created the database environment.

Methods in com.sleepycat.db with parameters of type DatabaseException
`void` `PanicHandler.panic(Environment environment, DatabaseException e)` A function to be called if the database environment panics.

Methods in com.sleepycat.db that throw DatabaseException
`void` `Transaction.abort()` Cause an abnormal termination of the transaction.
`OperationStatus` `Database.append(Transaction txn, DatabaseEntry key, DatabaseEntry data)` Append the key/data pair to the end of the database.
`void` `RecordNumberAppender.appendRecordNumber(Database db, DatabaseEntry data, int recno)` A callback function to modify the stored database based on the generated key.
`Transaction` `Environment.beginCDSGroup()` Allocate a locker ID in an environment configured for Berkeley DB Concurrent Data Store applications.
`Transaction` `Environment.beginTransaction(Transaction parent, TransactionConfig config)` Create a new transaction in the database environment.
`void` `Environment.checkpoint(CheckpointConfig config)` Synchronously checkpoint the database environment.
`void` `Sequence.close()` Close a sequence.
`void` `LogCursor.close()`
`void` `JoinCursor.close()` Closes the cursors that have been opened by this join cursor.
`void` `Environment.close()` Close the database environment, freeing any allocated resources and closing any underlying subsystems.
`void` `Database.close()` Flush any cached database information to disk and discard the database handle.
`void` `Cursor.close()`
`void` `Database.close(boolean noSync)` Flush any cached database information to disk and discard the database handle.
`void` `Transaction.commit()` End the transaction.
`void` `Transaction.commitNoSync()` End the transaction, not committing synchronously.
`void` `Transaction.commitSync()` End the transaction, committing synchronously.
`void` `Transaction.commitWriteNoSync()` End the transaction, writing but not flushing the log.
`CompactStats` `Database.compact(Transaction txn, DatabaseEntry start, DatabaseEntry stop, DatabaseEntry end, CompactConfig config)` Compact a Btree or Recno database or returns unused Btree, Hash or Recno database pages to the underlying filesystem.
`OperationStatus` `Database.consume(Transaction txn, DatabaseEntry key, DatabaseEntry data, boolean wait)` Return the record number and data from the available record closest to the head of the queue, and delete the record.
`int` `Cursor.count()` Return a count of the number of data items for the key to which the cursor refers.
`int` `Environment.createLockerID()` Allocate a locker ID.
`boolean` `SecondaryKeyCreator.createSecondaryKey(SecondaryDatabase secondary, DatabaseEntry key, DatabaseEntry data, DatabaseEntry result)` Creates a secondary key entry, given a primary key and data entry.
`void` `SecondaryMultiKeyCreator.createSecondaryKeys(SecondaryDatabase secondary, DatabaseEntry key, DatabaseEntry data, Set results)` Creates a secondary key entry, given a primary key and data entry.
`OperationStatus` `Cursor.delete()` Delete the key/data pair to which the cursor refers.
`OperationStatus` `Database.delete(Transaction txn, DatabaseEntry key)` Remove key/data pairs from the database.
`int` `Environment.detectDeadlocks(LockDetectMode mode)` Run one iteration of the deadlock detector.
`void` `Transaction.discard()` Free up all the per-process resources associated with the specified `Transaction` handle, neither committing nor aborting the transaction.
`Cursor` `SecondaryCursor.dup(boolean samePosition)` Returns a new `SecondaryCursor` for the same transaction as the original cursor.
`Cursor` `Cursor.dup(boolean samePosition)` Return a new cursor with the same transaction and locker ID as the original cursor.
`SecondaryCursor` `SecondaryCursor.dupSecondary(boolean samePosition)` Returns a new copy of the cursor as a `SecondaryCursor`.
`void` `Environment.electReplicationMaster(int nsites, int nvotes)` Hold an election for the master of a replication group.
`OperationStatus` `Database.exists(Transaction txn, DatabaseEntry key)` Checks if the specified key appears in the database.
`void` `Environment.flushReplication()` Internal method: re-push the last log record to all clients, in case they've lost messages and don't know it.
`void` `Environment.freeLockerID(int id)` Free a locker ID.
`OperationStatus` `SecondaryDatabase.get(Transaction txn, DatabaseEntry key, DatabaseEntry pKey, DatabaseEntry data, LockMode lockMode)` Retrieves the key/data pair with the given key.
`OperationStatus` `Database.get(Transaction txn, DatabaseEntry key, DatabaseEntry data, LockMode lockMode)` Retrieves the key/data pair with the given key.
`long` `Sequence.get(Transaction txn, int delta)` Return the next available element in the sequence and changes the sequence value by `delta`.
`File[]` `Environment.getArchiveDatabases()`
`File[]` `Environment.getArchiveLogFiles(boolean includeInUse)`
`CacheFile` `Database.getCacheFile()` Return the handle for the cache file underlying the database.
`CacheFileStats[]` `Environment.getCacheFileStats(StatsConfig config)`
`CacheStats` `Environment.getCacheStats(StatsConfig config)`
`DatabaseConfig` `SecondaryDatabase.getConfig()` Return this Database object's configuration.
`EnvironmentConfig` `Environment.getConfig()` Return this object's configuration.
`DatabaseConfig` `Database.getConfig()` Return this Database object's configuration.
`OperationStatus` `SecondaryCursor.getCurrent(DatabaseEntry key, DatabaseEntry pKey, DatabaseEntry data, LockMode lockMode)` Returns the key/data pair to which the cursor refers.
`OperationStatus` `Cursor.getCurrent(DatabaseEntry key, DatabaseEntry data, LockMode lockMode)` Returns the key/data pair to which the cursor refers.
`OperationStatus` `LogCursor.getCurrent(LogSequenceNumber lsn, DatabaseEntry data)` Return the LogSequenceNumber and log record to which the log cursor currently refers.
`Database` `Sequence.getDatabase()` Return the Database handle associated with this sequence.
`String` `Database.getDatabaseFile()` Return the database's underlying file name.
`String` `Database.getDatabaseName()` Return the database name.
`Environment` `Database.getEnvironment()` Return the `Environment` handle for the database environment underlying the `Database`.
`OperationStatus` `SecondaryCursor.getFirst(DatabaseEntry key, DatabaseEntry pKey, DatabaseEntry data, LockMode lockMode)` Move the cursor to the first key/data pair of the database, and return that pair.
`OperationStatus` `Cursor.getFirst(DatabaseEntry key, DatabaseEntry data, LockMode lockMode)` Move the cursor to the first key/data pair of the database, and return that pair.
`OperationStatus` `LogCursor.getFirst(LogSequenceNumber lsn, DatabaseEntry data)` Return the first LogSequenceNumber and log record.
`File` `Environment.getHome()`
`int` `Transaction.getId()` Return the transaction's unique ID.
`DatabaseEntry` `Sequence.getKey()` Return the DatabaseEntry used to open this sequence.
`KeyRange` `Database.getKeyRange(Transaction txn, DatabaseEntry key)` Return an estimate of the proportion of keys in the database less than, equal to, and greater than the specified key.
`OperationStatus` `SecondaryCursor.getLast(DatabaseEntry key, DatabaseEntry pKey, DatabaseEntry data, LockMode lockMode)` Move the cursor to the last key/data pair of the database, and return that pair.
`OperationStatus` `Cursor.getLast(DatabaseEntry key, DatabaseEntry data, LockMode lockMode)` Move the cursor to the last key/data pair of the database, and return that pair.
`OperationStatus` `LogCursor.getLast(LogSequenceNumber lsn, DatabaseEntry data)` Return the last LogSequenceNumber and log record.
`Lock` `Environment.getLock(int locker, boolean noWait, DatabaseEntry object, LockRequestMode mode)` Acquire a lock from the lock table.
`LockStats` `Environment.getLockStats(StatsConfig config)` Return the database environment's locking statistics.
`String` `Environment.getLogFileName(LogSequenceNumber lsn)` Return the name of the log file that contains the log record specified by a LogSequenceNumber object.
`LogStats` `Environment.getLogStats(StatsConfig config)` Return the database environment's logging statistics.
`long` `CacheFile.getMaximumSize()` Return the maximum size for the file backing the database, or 0 if no maximum file size has been configured.
`MutexStats` `Environment.getMutexStats(StatsConfig config)` Return the database environment's mutex statistics.
`String` `Transaction.getName()` Get the user visible name for the transaction.
`OperationStatus` `SecondaryCursor.getNext(DatabaseEntry key, DatabaseEntry pKey, DatabaseEntry data, LockMode lockMode)` Move the cursor to the next key/data pair and return that pair.
`OperationStatus` `JoinCursor.getNext(DatabaseEntry key, DatabaseEntry data, LockMode lockMode)` Returns the next primary key and data resulting from the join operation.
`OperationStatus` `Cursor.getNext(DatabaseEntry key, DatabaseEntry data, LockMode lockMode)` Move the cursor to the next key/data pair and return that pair.
`OperationStatus` `JoinCursor.getNext(DatabaseEntry key, LockMode lockMode)` Returns the next primary key resulting from the join operation.
`OperationStatus` `LogCursor.getNext(LogSequenceNumber lsn, DatabaseEntry data)` Return the next LogSequenceNumber and log record.
`OperationStatus` `SecondaryCursor.getNextDup(DatabaseEntry key, DatabaseEntry pKey, DatabaseEntry data, LockMode lockMode)` If the next key/data pair of the database is a duplicate data record for the current key/data pair, move the cursor to the next key/data pair of the database and return that pair.
`OperationStatus` `Cursor.getNextDup(DatabaseEntry key, DatabaseEntry data, LockMode lockMode)` If the next key/data pair of the database is a duplicate data record for the current key/data pair, move the cursor to the next key/data pair of the database and return that pair.
`OperationStatus` `SecondaryCursor.getNextNoDup(DatabaseEntry key, DatabaseEntry pKey, DatabaseEntry data, LockMode lockMode)` Move the cursor to the next non-duplicate key/data pair and return that pair.
`OperationStatus` `Cursor.getNextNoDup(DatabaseEntry key, DatabaseEntry data, LockMode lockMode)` Move the cursor to the next non-duplicate key/data pair and return that pair.
`boolean` `CacheFile.getNoFile()` Return true if the opening of backing temporary files for in-memory databases has been disallowed.
`OperationStatus` `SecondaryCursor.getPrev(DatabaseEntry key, DatabaseEntry pKey, DatabaseEntry data, LockMode lockMode)` Move the cursor to the previous key/data pair and return that pair.
`OperationStatus` `Cursor.getPrev(DatabaseEntry key, DatabaseEntry data, LockMode lockMode)` Move the cursor to the previous key/data pair and return that pair.
`OperationStatus` `LogCursor.getPrev(LogSequenceNumber lsn, DatabaseEntry data)` Return the previous LogSequenceNumber and log record.
`OperationStatus` `SecondaryCursor.getPrevDup(DatabaseEntry key, DatabaseEntry pKey, DatabaseEntry data, LockMode lockMode)` If the previous key/data pair of the database is a duplicate data record for the current key/data pair, move the cursor to the previous key/data pair of the database and return that pair.
`OperationStatus` `Cursor.getPrevDup(DatabaseEntry key, DatabaseEntry data, LockMode lockMode)` If the previous key/data pair of the database is a duplicate data record for the current key/data pair, move the cursor to the previous key/data pair of the database and return that pair.
`OperationStatus` `SecondaryCursor.getPrevNoDup(DatabaseEntry key, DatabaseEntry pKey, DatabaseEntry data, LockMode lockMode)` Move the cursor to the previous non-duplicate key/data pair and return that pair.
`OperationStatus` `Cursor.getPrevNoDup(DatabaseEntry key, DatabaseEntry data, LockMode lockMode)` Move the cursor to the previous non-duplicate key/data pair and return that pair.
`CacheFilePriority` `Cursor.getPriority()` Get the cache priority for pages referenced by the cursor.
`CacheFilePriority` `CacheFile.getPriority()` Return the cache priority for pages from the specified file.
`OperationStatus` `SecondaryCursor.getRecordNumber(DatabaseEntry secondaryRecno, DatabaseEntry primaryRecno, LockMode lockMode)` Return the record number associated with the cursor.
`OperationStatus` `Cursor.getRecordNumber(DatabaseEntry data, LockMode lockMode)` Return the record number associated with the cursor.
`boolean` `Environment.getReplicationConfig(ReplicationConfig config)` Get the configuration of the replication subsystem.
`ReplicationManagerSiteInfo[]` `Environment.getReplicationManagerSiteList()` Return an array of all sites known to the replication manager.
`ReplicationManagerStats` `Environment.getReplicationManagerStats(StatsConfig config)` Return the database environment's replication manager statistics.
`ReplicationStats` `Environment.getReplicationStats(StatsConfig config)` Return the database environment's replication statistics.
`int` `Environment.getReplicationTimeout(ReplicationTimeoutType type)` Get the network timeout applied to the specified timeout type.
`OperationStatus` `SecondaryCursor.getSearchBoth(DatabaseEntry key, DatabaseEntry pKey, DatabaseEntry data, LockMode lockMode)` Move the cursor to the specified secondary and primary key, where both the primary and secondary key items must match.
`OperationStatus` `Cursor.getSearchBoth(DatabaseEntry key, DatabaseEntry data, LockMode lockMode)` Move the cursor to the specified key/data pair, where both the key and data items must match.
`OperationStatus` `SecondaryDatabase.getSearchBoth(Transaction txn, DatabaseEntry key, DatabaseEntry pKey, DatabaseEntry data, LockMode lockMode)` Retrieves the key/data pair with the specified secondary and primary key, that is, both the primary and secondary key items must match.
`OperationStatus` `Database.getSearchBoth(Transaction txn, DatabaseEntry key, DatabaseEntry data, LockMode lockMode)` Retrieves the key/data pair with the given key and data value, that is, both the key and data items must match.
`OperationStatus` `SecondaryCursor.getSearchBothRange(DatabaseEntry key, DatabaseEntry pKey, DatabaseEntry data, LockMode lockMode)` Move the cursor to the specified secondary key and closest matching primary key of the database.
`OperationStatus` `Cursor.getSearchBothRange(DatabaseEntry key, DatabaseEntry data, LockMode lockMode)` Move the cursor to the specified key and closest matching data item of the database.
`OperationStatus` `SecondaryCursor.getSearchKey(DatabaseEntry key, DatabaseEntry pKey, DatabaseEntry data, LockMode lockMode)` Move the cursor to the given key of the database, and return the datum associated with the given key.
`OperationStatus` `Cursor.getSearchKey(DatabaseEntry key, DatabaseEntry data, LockMode lockMode)` Move the cursor to the given key of the database, and return the datum associated with the given key.
`OperationStatus` `SecondaryCursor.getSearchKeyRange(DatabaseEntry key, DatabaseEntry pKey, DatabaseEntry data, LockMode lockMode)` Move the cursor to the closest matching key of the database, and return the data item associated with the matching key.
`OperationStatus` `Cursor.getSearchKeyRange(DatabaseEntry key, DatabaseEntry data, LockMode lockMode)` Move the cursor to the closest matching key of the database, and return the data item associated with the matching key.
`OperationStatus` `SecondaryCursor.getSearchRecordNumber(DatabaseEntry secondaryRecno, DatabaseEntry pKey, DatabaseEntry data, LockMode lockMode)` Move the cursor to the specific numbered record of the database, and return the associated key/data pair.
`OperationStatus` `Cursor.getSearchRecordNumber(DatabaseEntry key, DatabaseEntry data, LockMode lockMode)` Move the cursor to the specific numbered record of the database, and return the associated key/data pair.
`OperationStatus` `SecondaryDatabase.getSearchRecordNumber(Transaction txn, DatabaseEntry key, DatabaseEntry pKey, DatabaseEntry data, LockMode lockMode)` Retrieves the key/data pair associated with the specific numbered record of the database.
`OperationStatus` `Database.getSearchRecordNumber(Transaction txn, DatabaseEntry key, DatabaseEntry data, LockMode lockMode)` Retrieves the key/data pair associated with the specific numbered record of the database.
`SecondaryConfig` `SecondaryDatabase.getSecondaryConfig()` Returns a copy of the secondary configuration of this database.
`SequenceStats` `Sequence.getStats(StatsConfig config)` Return statistical information about the sequence.
`DatabaseStats` `Database.getStats(Transaction txn, StatsConfig config)` Return database statistics.
`TransactionStats` `Environment.getTransactionStats(StatsConfig config)` Return the database environment's transactional statistics.
`boolean` `CacheFile.getUnlink()` Return true if the file will be removed when the last reference to it is closed.
`JoinCursor` `Database.join(Cursor[] cursors, JoinConfig config)` Creates a specialized join cursor for use in performing equality or natural joins on secondary indices.
`void` `Environment.lockVector(int locker, boolean noWait, LockRequest[] list)` Atomically obtain and release one or more locks from the lock table.
`void` `Environment.logFlush(LogSequenceNumber lsn)` Flush log records to stable storage.
`void` `Environment.logPrint(Transaction txn, String message)` Append an informational message to the Berkeley DB database environment log files.
`LogSequenceNumber` `Environment.logPut(DatabaseEntry data, boolean flush)` Append a record to the log.
`boolean` `ForeignKeyNullifier.nullifyForeignKey(SecondaryDatabase secondary, DatabaseEntry data)`
`boolean` `ForeignMultiKeyNullifier.nullifyForeignKey(SecondaryDatabase secondary, DatabaseEntry key, DatabaseEntry data, DatabaseEntry secKey)`
`Cursor` `SecondaryDatabase.openCursor(Transaction txn, CursorConfig config)` Return a cursor into the database.
`Cursor` `Database.openCursor(Transaction txn, CursorConfig config)` Return a cursor into the database.
`Database` `Environment.openDatabase(Transaction txn, String fileName, String databaseName, DatabaseConfig config)` Open a database.
`LogCursor` `Environment.openLogCursor()` Return a log cursor.
`SecondaryCursor` `SecondaryDatabase.openSecondaryCursor(Transaction txn, CursorConfig config)` Obtain a cursor on a database, returning a `SecondaryCursor`.
`SecondaryDatabase` `Environment.openSecondaryDatabase(Transaction txn, String fileName, String databaseName, Database primaryDatabase, SecondaryConfig config)` Open a database.
`Sequence` `Database.openSequence(Transaction txn, DatabaseEntry key, SequenceConfig config)` Open a sequence in the database.
`void` `Environment.panic(boolean onoff)` Set the panic state for the database environment.
`void` `Transaction.prepare(byte[] gid)` Initiate the beginning of a two-phase commit.
`ReplicationStatus` `Environment.processReplicationMessage(DatabaseEntry control, DatabaseEntry rec, int envid)` Process an incoming replication message sent by a member of the replication group to the local database environment.
`OperationStatus` `Cursor.put(DatabaseEntry key, DatabaseEntry data)` Store a key/data pair into the database.
`OperationStatus` `Database.put(Transaction txn, DatabaseEntry key, DatabaseEntry data)` Store the key/data pair into the database.
`OperationStatus` `Cursor.putAfter(DatabaseEntry key, DatabaseEntry data)` Store a key/data pair into the database.
`OperationStatus` `Cursor.putBefore(DatabaseEntry key, DatabaseEntry data)` Store a key/data pair into the database.
`OperationStatus` `Cursor.putCurrent(DatabaseEntry data)` Replaces the data in the key/data pair at the current cursor position.
`OperationStatus` `Cursor.putKeyFirst(DatabaseEntry key, DatabaseEntry data)` Store a key/data pair into the database.
`OperationStatus` `Cursor.putKeyLast(DatabaseEntry key, DatabaseEntry data)` Store a key/data pair into the database.
`void` `Environment.putLock(Lock lock)` Release a lock.
`OperationStatus` `Cursor.putNoDupData(DatabaseEntry key, DatabaseEntry data)` Store a key/data pair into the database.
`OperationStatus` `Database.putNoDupData(Transaction txn, DatabaseEntry key, DatabaseEntry data)` Store the key/data pair into the database if it does not already appear in the database.
`OperationStatus` `Cursor.putNoOverwrite(DatabaseEntry key, DatabaseEntry data)` Store a key/data pair into the database.
`OperationStatus` `Database.putNoOverwrite(Transaction txn, DatabaseEntry key, DatabaseEntry data)` Store the key/data pair into the database if the key does not already appear in the database.
`PreparedTransaction[]` `Environment.recover(int count, boolean continued)`
`static void` `Environment.remove(File home, boolean force, EnvironmentConfig config)` Destroy a database environment.
`static void` `Database.remove(String fileName, String databaseName, DatabaseConfig config)` Remove a database.
`void` `Environment.removeDatabase(Transaction txn, String fileName, String databaseName)` Remove a database.
`void` `Environment.removeOldLogFiles()` Remove log files that are no longer needed.
`void` `Database.removeSequence(Transaction txn, DatabaseEntry key, SequenceConfig config)` Remove the sequence from the database.
`static void` `Database.rename(String fileName, String oldDatabaseName, String newDatabaseName, DatabaseConfig config)` Rename a database.
`void` `Environment.renameDatabase(Transaction txn, String fileName, String databaseName, String newName)` Rename a database.
`void` `EnvironmentConfig.replicationManagerAddRemoteSite(ReplicationHostAddress repmgrRemoteAddr, boolean isPeer)` Add a remote site to a replication group.
`void` `Environment.replicationManagerStart(int nthreads, ReplicationManagerStartPolicy policy)` Starts the replication manager.
`void` `Environment.resetFileID(String filename, boolean encrypted)` Allows database files to be copied, and then the copy used in the same database environment as the original.
`void` `Environment.resetLogSequenceNumber(String filename, boolean encrypted)` Allows database files to be moved from one transactional database environment to another.
`int` `ReplicationTransport.send(Environment environment, DatabaseEntry control, DatabaseEntry rec, LogSequenceNumber lsn, int envid, boolean noBuffer, boolean permanent, boolean anywhere, boolean isRetry)` The callback used when Berkeley DB needs to transmit a replication message.
`OperationStatus` `LogCursor.set(LogSequenceNumber lsn, DatabaseEntry data)` Return a specific log record.
`void` `Database.setConfig(DatabaseConfig config)` Change the settings in an existing database handle.
`void` `Environment.setConfig(EnvironmentConfig config)` Change the settings in an existing environment handle.
`void` `Transaction.setLockTimeout(long timeOut)` Configure the lock request timeout value for the transaction.
`void` `CacheFile.setMaximumSize(long bytes)` Set the maximum size for the file backing the database.
`void` `Transaction.setName(String name)` Set the user visible name for the transaction.
`void` `CacheFile.setNoFile(boolean onoff)` Disallow opening backing temporary files for in-memory databases, even if they expand to fill the entire cache.
`void` `Cursor.setPriority(CacheFilePriority priority)` Set the cache priority for pages referenced by the DBC handle.
`void` `CacheFile.setPriority(CacheFilePriority priority)` Set the cache priority for pages from the specified file.
`void` `Environment.setReplicationConfig(ReplicationConfig config, boolean onoff)` Configure the replication subsystem.
`void` `Environment.setReplicationTimeout(ReplicationTimeoutType type, int replicationTimeout)` Set the network timeout applied to the specified timeout type.
`void` `Transaction.setTxnTimeout(long timeOut)` Configure the timeout value for the transaction lifetime.
`void` `CacheFile.setUnlink(boolean onoff)` Remove the file when the last reference to it is closed.
`void` `Environment.startReplication(DatabaseEntry cdata, boolean master)` Configure the database environment as a client or master in a group of replicated database environments.
`void` `Database.sync()` Flush any cached information to disk.
`void` `Environment.syncReplication()` Forces synchronization to begin for this client.
`int` `Environment.trickleCacheWrite(int percent)` Ensure that a specified percent of the pages in the shared memory pool are clean, by writing dirty pages to their backing files.
`int` `Database.truncate(Transaction txn, boolean countRecords)` Empty the database, discarding all records it contains.
`static void` `Database.upgrade(String fileName, DatabaseConfig config)` Upgrade all of the databases included in the specified file.
`static boolean` `Database.verify(String fileName, String databaseName, PrintStream dumpStream, VerifyConfig verifyConfig, DatabaseConfig dbConfig)` Return if all of the databases in a file are uncorrupted.
`int` `LogCursor.version()` Get the log file version.

Constructors in com.sleepycat.db that throw DatabaseException
`Database(String filename, String databaseName, DatabaseConfig config)` Open a database.
`Environment(File home, EnvironmentConfig config)` Create a database environment handle.
`SecondaryDatabase(String fileName, String databaseName, Database primaryDatabase, SecondaryConfig config)` Open a database.

Uses of DatabaseException in com.sleepycat.persist

Methods in com.sleepycat.persist that throw DatabaseException
`void` `ForwardCursor.close()` Closes the cursor.
`void` `EntityStore.close()` Closes all databases and sequences that were opened via this store.
`void` `EntityCursor.close()` Closes the cursor.
`void` `EntityStore.closeClass(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, Returns one or zero if the underlying index has unique keys.
`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.
`EntityCursor<V>` `EntityCursor.dup()` Duplicates the cursor at the cursor position.
`ForwardCursor<E>` `EntityJoin.entities()` Opens a cursor that returns the entities qualifying for the join.
`EntityCursor<V>` `EntityIndex.entities()` Opens a cursor for traversing all entities in this index.
`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(Transaction txn, CursorConfig config)` Opens a cursor that returns the entities qualifying for the join.
`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.
`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.
`V` `EntityIndex.get(K key)` Gets an entity via a key of this index.
`E` `PrimaryIndex.get(PK key)`
`E` `SecondaryIndex.get(SK key)`
`V` `EntityIndex.get(Transaction txn, K key, LockMode lockMode)` Gets an entity via a key of this index.
`E` `PrimaryIndex.get(Transaction txn, PK key, LockMode lockMode)`
`E` `SecondaryIndex.get(Transaction txn, SK key, LockMode lockMode)`

`

`<PK,E> PrimaryIndex<PK,E>`

`

`EntityStore.getPrimaryIndex(Class<PK> primaryKeyClass, 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, Class<SK> keyClass, String keyName)`
Returns a secondary index for a given primary index and secondary key, opening it if necessary.

`Sequence` `EntityStore.getSequence(String name)` Returns a named sequence for using Berkeley DB engine API directly, opening it if necessary.

`

`<SK,PK,E1,E2 extends E1> SecondaryIndex<SK,PK,E2>`

`

`EntityStore.getSubclassIndex(PrimaryIndex<PK,E1> primaryIndex, Class<E2> entitySubclass, Class<SK> keyClass, String keyName)`
Returns a secondary index for a secondary key in an entity subclass, opening it if necessary.

`ForwardCursor<PK>` `EntityJoin.keys()` Opens a cursor that returns the primary keys of entities qualifying for the join.
`EntityCursor<K>` `EntityIndex.keys()` Opens a cursor for traversing all keys in this index.
`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(Transaction txn, CursorConfig config)` Opens a cursor that returns the primary keys of entities qualifying for the join.
`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.
`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.truncateClass(Class entityClass)` Deletes all instances of this entity class and its (non-entity) subclasses.
`void` `EntityStore.truncateClass(Transaction txn, 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.

Constructors in com.sleepycat.persist that throw DatabaseException
`EntityStore(Environment env, String storeName, StoreConfig config)` Opens an entity store in a given environment.
`PrimaryIndex(Database database, Class<PK> keyClass, EntryBinding keyBinding, Class<E> entityClass, EntityBinding entityBinding)` Creates a primary index without using an `EntityStore`.
`SecondaryIndex(SecondaryDatabase database, Database keysDatabase, PrimaryIndex<PK,E> primaryIndex, Class<SK> secondaryKeyClass, EntryBinding secondaryKeyBinding)` Creates a secondary index without using an `EntityStore`.

Uses of DatabaseException in com.sleepycat.persist.raw

Methods in com.sleepycat.persist.raw that throw DatabaseException
`void` `RawStore.close()` Closes all databases and sequences that were opened by this model.
`PrimaryIndex<Object,RawObject>` `RawStore.getPrimaryIndex(String entityClass)` Opens the primary index for a given entity class.
`SecondaryIndex<Object,Object,RawObject>` `RawStore.getSecondaryIndex(String entityClass, String keyName)` Opens the secondary index for a given entity class and secondary key name.

Constructors in com.sleepycat.persist.raw that throw DatabaseException
`RawStore(Environment env, String storeName, StoreConfig config)` Opens an entity store for raw data access.

Berkeley DB version 4.7.25

Copyright (c) 1996,2008 Oracle. All rights reserved.