Uses of Class com.sleepycat.db.DatabaseException (Oracle

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

Berkeley DB
version 5.3.28

PREV NEXT

FRAMES NO FRAMES

Uses of Class
com.sleepycat.db.DatabaseException

Packages that use DatabaseException
com.sleepycat.bind.serial	Bindings that use Java serialization.
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`	`ClassCatalog.close()` Close a catalog database and release any cached resources.
`void`	`StoredClassCatalog.close()`
`ObjectStreamClass`	`ClassCatalog.getClassFormat(byte[] classID)` Return the ObjectStreamClass for the given class ID.
`ObjectStreamClass`	`StoredClassCatalog.getClassFormat(byte[] classID)`
`byte[]`	`ClassCatalog.getClassID(ObjectStreamClass classDesc)` Return the class ID for the current version of the given class description.
`byte[]`	`StoredClassCatalog.getClassID(ObjectStreamClass classFormat)`

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.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`	`HeapFullException` A HeapFullException is thrown when an attempt was made to add or update a record in a Heap database.
`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 turned off automatic internal initialization (the `ReplicationConfig.AUTOINIT` setting).
`class`	`ReplicationLeaseExpiredException` Thrown if a master lease has expired.
`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.
`protected boolean`	`MultipleEntry.append_internal(byte[] newdata, int offset, int len)`
`protected boolean`	`MultipleEntry.append_internal(byte[] newdata, int offset, int len, int recno)`
`boolean`	`MultipleDataEntry.append(byte[] data)` Append an entry to the bulk buffer.
`boolean`	`MultipleKeyDataEntry.append(byte[] key, byte[] data)` Append an entry to the bulk buffer.
`boolean`	`MultipleDataEntry.append(byte[] data, int offset, int len)` Append an entry to the bulk buffer.
`boolean`	`MultipleKeyDataEntry.append(byte[] key, int koff, int klen, byte[] data, int doff, int dlen)` Append an entry to the bulk buffer.
`boolean`	`MultipleDataEntry.append(DatabaseEntry data)` Append an entry to the bulk buffer.
`boolean`	`MultipleKeyDataEntry.append(DatabaseEntry key, DatabaseEntry data)` Append an entry to the bulk buffer.
`boolean`	`MultipleRecnoDataEntry.append(int recno, byte[] data)` Append an entry to the bulk buffer.
`boolean`	`MultipleRecnoDataEntry.append(int recno, byte[] data, int offset, int len)` Append a record number / data item pair to the bulk buffer.
`boolean`	`MultipleRecnoDataEntry.append(int recno, DatabaseEntry data)` Append an entry to the bulk buffer.
`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.
`void`	`Environment.backup(String target, BackupOptions opt)` Perform a hot back up of the open environment.
`void`	`Environment.backupDatabase(String dbfile, String target, boolean exclusiveCreate)` Perform a hot back up of a single database file contained within the environment.
`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`	`ReplicationChannel.close()` Close the channel.
`void`	`LogCursor.close()` Discard the log cursor.
`void`	`Environment.close()` Close the database environment, freeing any allocated resources and closing any underlying subsystems.
`void`	`ReplicationManagerSite.close()` Close the site.
`void`	`Database.close()` Flush any cached database information to disk, close any open cursors, free allocated resources, close underlying files, and discard the database handle.
`void`	`JoinCursor.close()` Closes the cursors that have been opened by this join cursor.
`void`	`Cursor.close()` Discard the cursor.
`void`	`Database.close(boolean noSync)` Flush any cached database information to disk, close any open cursors, free allocated resources, close underlying files, and discard the database handle.
`void`	`Environment.closeForceSync()` Close the database environment, freeing any allocated resources and closing any underlying subsystems.
`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.
`int`	`Cursor.compare(Cursor OtherCursor)` Return a comparison of the two cursors.
`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.
`OperationStatus`	`Database.deleteMultiple(Transaction txn, MultipleEntry keys)` Remove key/data pairs from the database.
`OperationStatus`	`Database.deleteMultipleKey(Transaction txn, MultipleEntry keys)` 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`	`Cursor.dup(boolean samePosition)` Creates a new cursor that uses the same transaction and locker ID as the original cursor.
`Cursor`	`SecondaryCursor.dup(boolean samePosition)` Returns a new `SecondaryCursor` for the same transaction 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 from the database.
`long`	`Sequence.get(Transaction txn, int delta)` Return the next available element in the sequence and changes the sequence value by `delta`.
`ReplicationHostAddress`	`ReplicationManagerSite.getAddress()` Get the address of the site.
`File[]`	`Environment.getArchiveDatabases()` Return the database files that need to be archived in order to recover the database from catastrophic failure.
`File[]`	`Environment.getArchiveLogFiles(boolean includeInUse)` Return an array of log files.
`boolean`	`ReplicationManagerSite.getBootstrapHelper()` Return if the site is a helper for the local site.
`CacheFile`	`Database.getCacheFile()` Return the handle for the cache file underlying the database.
`CacheFileStats[]`	`Environment.getCacheFileStats(StatsConfig config)` Return statistics for individual files in the cache.
`CacheStats`	`Environment.getCacheStats(StatsConfig config)` Returns the memory pool (that is, the buffer cache) subsystem statistics.
`EnvironmentConfig`	`Environment.getConfig()` Return this object's configuration.
`ReplicationManagerSiteConfig`	`ReplicationManagerSite.getConfig()` Get the address and configuration of the site.
`DatabaseConfig`	`Database.getConfig()` Return this Database object's configuration.
`DatabaseConfig`	`SecondaryDatabase.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.
`int`	`ReplicationManagerSite.getEid()` Get the environment id of the site.
`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.
`boolean`	`ReplicationManagerSite.getGroupCreator()` Return if the site is a group creator.
`File`	`Environment.getHome()` Return the database environment home directory.
`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.
`boolean`	`ReplicationManagerSite.getLegacy()` Return if the site is in a legacy group.
`boolean`	`ReplicationManagerSite.getLocalSite()` Return if the site is the local site.
`Lock`	`Environment.getLock(int locker, boolean noWait, DatabaseEntry object, LockRequestMode mode)` Acquire a lock from the lock table returning information about it in the Lock parameter.
`int`	`Environment.getLockerPriority(int id)` Return the deadlock priority for the given locker.
`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.
`boolean`	`ReplicationManagerSite.getPeer()` Return if the site is peer to local site.
`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`	`CacheFile.getPriority()` Return the cache priority for pages from the specified file.
`int`	`Transaction.getPriority()` Get the transaction's deadlock priority.
`CacheFilePriority`	`Cursor.getPriority()` Get the cache priority for pages referenced by the cursor.
`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.
`ReplicationManagerSite`	`Environment.getReplicationManagerLocalSite()` Return a handle for the local replication site.
`ReplicationManagerSite`	`Environment.getReplicationManagerSite(int eid)` Return a site known to the replication manager by its eid.
`ReplicationManagerSite`	`Environment.getReplicationManagerSite(String host, long port)` Return a site in the replication manager by its host and port.
`ReplicationManagerSiteInfo[]`	`Environment.getReplicationManagerSiteList()` Return an array of all the sites known to the replication manager.
`ReplicationManagerStats`	`Environment.getReplicationManagerStats(StatsConfig config)` Return the database environment's replication manager statistics.
`int`	`Environment.getReplicationNumSites()` Get the number of sites in a replication group.
`ReplicationStats`	`Environment.getReplicationStats(StatsConfig config)` Return the database environment's replication statistics.
`int`	`Environment.getReplicationTimeout(ReplicationTimeoutType type)` Gets the 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 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.
`TransactionStatus`	`Environment.isTransactionApplied(byte[] token, int maxwait)` Return whether the transaction referred to by the commit token "token" has been applied at the local replication environment.
`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)` 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.
`ReplicationChannel`	`Environment.openChannel(int eid)` Create a channel.
`Cursor`	`Database.openCursor(Transaction txn, CursorConfig config)` Return a cursor into the database.
`Cursor`	`SecondaryDatabase.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 represented by the key 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`	`Database.putMultiple(Transaction txn, MultipleEntry key, MultipleEntry data, boolean overwrite)` Store a set of key/data pairs into the database.
`OperationStatus`	`Database.putMultipleKey(Transaction txn, MultipleEntry key, boolean overwrite)` Store a set of key/data pairs into the database.
`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)` Environment recovery restores transactions that were prepared, but not yet resolved at the time of the system shut down or crash, to their state prior to the shut down or crash, including any locks previously held.
`void`	`ReplicationManagerSite.remove()` Remove the site.
`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 the database specified by the file and database parameters.
`void`	`Environment.removeDatabase(Transaction txn, String fileName, String databaseName)` Remove the database specified by the fileName and databaseName parameters.
`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 specified by the file and database parameters.
`void`	`Environment.renameDatabase(Transaction txn, String fileName, String databaseName, String newName)` Rename a database.
`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.
`void`	`ReplicationChannel.sendMessage(Set messages)` Send a message on the message channel asynchronously.
`void`	`ReplicationChannel.sendRequest(Set messages, DatabaseEntry response, long timeout)` Send request on the message channel.
`OperationStatus`	`LogCursor.set(LogSequenceNumber lsn, DatabaseEntry data)` Return a specific log record.
`void`	`ReplicationManagerSite.setBootstrapHelper(boolean helper)` Set the site to be a helper site.
`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`	`ReplicationManagerSite.setGroupCreator(boolean groupCreator)` Set the site to be a group creator.
`void`	`ReplicationManagerSite.setLegacy(boolean legacy)` Specify the site in a legacy group.
`void`	`ReplicationManagerSite.setLocalSite(boolean localSite)` Set the site to be the local site.
`void`	`Environment.setLockerPriority(int id, int priority)` Assign a deadlock priority to a locker.
`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`	`ReplicationManagerSite.setPeer(boolean peer)` Set the site to be peer to local site.
`void`	`CacheFile.setPriority(CacheFilePriority priority)` Set the cache priority for pages from the specified file.
`void`	`Cursor.setPriority(CacheFilePriority priority)` Set the cache priority for pages referenced by the DBC handle.
`void`	`Transaction.setPriority(int priority)` Set the deadlock priority for this transaction.
`void`	`Environment.setReplicationConfig(ReplicationConfig config, boolean onoff)` Configure the replication subsystem.
`void`	`Environment.setReplicationManagerMessageDispatch(ReplicationManagerMessageDispatch dispatch, int flags)` Set the message dispatch function.
`void`	`Environment.setReplicationTimeout(ReplicationTimeoutType type, int replicationTimeout)` Sets the timeout applied to the specified timeout type.
`void`	`ReplicationChannel.setTimeout(long timeout)` Sets the default timeout value for the channel.
`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.
`static void`	`Database.sortMultipleKeyAndData(MultipleDataEntry keys, MultipleDataEntry datas)` Sorts two DatabaseEntry objects with multiple key and data pairs.
`static void`	`Database.sortMultipleKeyData(MultipleKeyDataEntry entries)` Sorts a DatabaseEntry with multiple matching key/data pairs.
`static void`	`Database.sortMultipleKeyOrData(MultipleDataEntry entries)` Sorts a DatabaseEntry with multiple key or data pairs.
`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.syncCache(LogSequenceNumber logSequenceNumber)` Ensure that all modified pages in the cache are flushed to their backing files.
`void`	`Environment.syncReplication()` Forces master 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

Subclasses of DatabaseException in com.sleepycat.persist
`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

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

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.

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.

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.

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 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()
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(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<PK> keyBinding, Class<E> entityClass, EntityBinding<E> entityBinding)` Creates a primary index without using an `EntityStore`.
`SecondaryIndex(SecondaryDatabase database, Database keysDatabase, PrimaryIndex<PK,E> primaryIndex, Class<SK> secondaryKeyClass, EntryBinding<SK> 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.