Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| Berkeley DB Java Edition version 4.0.103
PREV NEXT | FRAMES NO FRAMES

## Uses of Class
com.sleepycat.je.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.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.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
`void` | `StoredClassCatalog.close()`
`void` | `ClassCatalog.close()` Close a catalog database and release any cached resources.
`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.

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

Subclasses of DatabaseException in com.sleepycat.je
`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` Deprecated. temporarily until true deadlock detection is implemented. Presently, {code DeadlockException} is replaced by `LockConflictException` as the common base class for lock conflict exceptions.
`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` | `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`
`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 {code EnvironmentConfig AllowCreate} property is false (environment creation is not permitted), but there are no log files in the environment directory.
`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 thread.
`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 multiple threads are competing for a lock and the transaction timeout interval is exceeded for the current thread.
`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
`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 database environment log cleaning.
`void` | `Database.close()` Discards the database handle.
`void` | `Environment.close()` The Environment.close method closes the Berkeley DB environment.
`void` | `Cursor.close()` Discards the cursor.
`void` | `Sequence.close()` Closes a sequence.
`void` | `JoinCursor.close()` Closes the cursors that have been opened by this join cursor.
`void` | `SecondaryDatabase.close()` Closes a secondary database and dis-associates it from its primary database.
`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.
`long` | `Database.count()` Counts the key/data pairs in the database.
`int` | `Cursor.count()` Returns a count of the number of data items for the key to which the cursor refers.
`OperationStatus` | `SecondaryCursor.delete()` Delete the key/data pair to which the cursor refers from the primary database and all secondary indices.
`OperationStatus` | `Cursor.delete()` Deletes the key/data pair to which the cursor refers.
`OperationStatus` | `Database.delete(Transaction txn, DatabaseEntry key)` Removes key/data pairs from the database.
`OperationStatus` | `SecondaryDatabase.delete(Transaction txn, DatabaseEntry key)` Deletes the primary key/data pair associated with the specified secondary key.
`SecondaryCursor` | `SecondaryCursor.dup(boolean samePosition)` Returns a new `SecondaryCursor` for the same transaction as the original cursor.
`Cursor` | `Cursor.dup(boolean samePosition)` Returns a new cursor with the same transaction and locker ID as the original cursor.
`SecondaryCursor` | `SecondaryCursor.dupSecondary(boolean samePosition)` Deprecated. As of JE 4.0.13, replaced by `Cursor.dup(boolean)`.
`void` | `Environment.evictMemory()` Synchronously invokes the mechanism for keeping memory usage within the cache size boundaries.
`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.
`OperationStatus` | `SecondaryDatabase.get(Transaction txn, DatabaseEntry key, DatabaseEntry data, LockMode lockMode)`
`long` | `Sequence.get(Transaction txn, int delta)` Returns the next available element in the sequence and changes the sequence value by `delta`.
`DatabaseConfig` | `Database.getConfig()` Returns this Database object's configuration.
`EnvironmentConfig` | `Environment.getConfig()` Returns this object's configuration.
`SecondaryConfig` | `SecondaryDatabase.getConfig()` Returns a copy of the secondary configuration of this database.
`OperationStatus` | `SecondaryCursor.getCurrent(DatabaseEntry key, DatabaseEntry pKey, DatabaseEntry data, LockMode lockMode)` Returns the key/data pair to which the cursor refers.
`OperationStatus` | `SecondaryCursor.getCurrent(DatabaseEntry key, DatabaseEntry data, LockMode lockMode)`
`OperationStatus` | `Cursor.getCurrent(DatabaseEntry key, DatabaseEntry data, LockMode lockMode)` Returns the key/data pair to which the cursor refers.
`String` | `Database.getDatabaseName()` Returns the database name.
`List<String>` | `Environment.getDatabaseNames()` Returns a List of database names for the database environment.
`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` | `SecondaryCursor.getFirst(DatabaseEntry key, DatabaseEntry data, LockMode lockMode)`
`OperationStatus` | `Cursor.getFirst(DatabaseEntry key, DatabaseEntry data, LockMode lockMode)` Moves the cursor to the first key/data pair of the database, and returns that pair.
`File` | `Environment.getHome()` Returns the database environment's home directory.
`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` | `SecondaryCursor.getLast(DatabaseEntry key, DatabaseEntry data, LockMode lockMode)`
`OperationStatus` | `Cursor.getLast(DatabaseEntry key, DatabaseEntry data, LockMode lockMode)` Moves the cursor to the last key/data pair of the database, and returns that pair.
`LockStats` | `Environment.getLockStats(StatsConfig config)` Deprecated. as of 4.0.10, replaced by `Environment.getStats(StatsConfig)`.
`EnvironmentMutableConfig` | `Environment.getMutableConfig()` Returns database environment attributes.
`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` | `SecondaryCursor.getNext(DatabaseEntry key, DatabaseEntry data, LockMode lockMode)`
`OperationStatus` | `Cursor.getNext(DatabaseEntry key, DatabaseEntry data, LockMode lockMode)` Moves the cursor to the next key/data pair and returns that pair.
`OperationStatus` | `JoinCursor.getNext(DatabaseEntry key, DatabaseEntry data, LockMode lockMode)` Returns the next primary key and data resulting from the join operation.
`OperationStatus` | `JoinCursor.getNext(DatabaseEntry key, LockMode lockMode)` Returns the next primary key resulting from the join operation.
`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` | `SecondaryCursor.getNextDup(DatabaseEntry key, DatabaseEntry data, LockMode lockMode)`
`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, moves the cursor to the next key/data pair of the database and returns 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` | `SecondaryCursor.getNextNoDup(DatabaseEntry key, DatabaseEntry data, LockMode lockMode)`
`OperationStatus` | `Cursor.getNextNoDup(DatabaseEntry key, DatabaseEntry data, LockMode lockMode)` Moves the cursor to the next non-duplicate key/data pair and returns that pair.
`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` | `SecondaryCursor.getPrev(DatabaseEntry key, DatabaseEntry data, LockMode lockMode)`
`OperationStatus` | `Cursor.getPrev(DatabaseEntry key, DatabaseEntry data, LockMode lockMode)` Moves the cursor to the previous key/data pair and returns that pair.
`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` | `SecondaryCursor.getPrevDup(DatabaseEntry key, DatabaseEntry data, LockMode lockMode)`
`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, moves the cursor to the previous key/data pair of the database and returns 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` | `SecondaryCursor.getPrevNoDup(DatabaseEntry key, DatabaseEntry data, LockMode lockMode)`
`OperationStatus` | `Cursor.getPrevNoDup(DatabaseEntry key, DatabaseEntry data, LockMode lockMode)` Moves the cursor to the previous non-duplicate key/data pair and returns that pair.
`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)` Moves 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)` Moves 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` | `SecondaryCursor.getSearchKey(DatabaseEntry key, DatabaseEntry data, LockMode lockMode)`
`OperationStatus` | `Cursor.getSearchKey(DatabaseEntry key, DatabaseEntry data, LockMode lockMode)` Moves the cursor to the given key of the database, and returns 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` | `SecondaryCursor.getSearchKeyRange(DatabaseEntry key, DatabaseEntry data, LockMode lockMode)`
`OperationStatus` | `Cursor.getSearchKeyRange(DatabaseEntry key, DatabaseEntry data, LockMode lockMode)` Moves the cursor to the closest matching key of the database, and returns the data item associated with the matching key.
`SecondaryConfig` | `SecondaryDatabase.getSecondaryConfig()` Deprecated. As of JE 4.0.13, replaced by `SecondaryDatabase.getConfig()`.
`List<SecondaryDatabase>` | `Database.getSecondaryDatabases()` Returns a list of all `SecondaryDatabase` objects associated with a primary database.
`DatabaseStats` | `Database.getStats(StatsConfig config)` Returns database statistics.
`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.
`JoinCursor` | `Database.join(Cursor[] cursors, JoinConfig config)` Creates a specialized join cursor for use in performing equality or natural joins on secondary indices.
`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.
`Cursor` | `Database.openCursor(Transaction txn, CursorConfig cursorConfig)` Returns a cursor into the database.
`SecondaryCursor` | `SecondaryDatabase.openCursor(Transaction txn, CursorConfig cursorConfig)` Obtain a cursor on a database, returning a `SecondaryCursor`.
`SecondaryCursor` | `SecondaryDatabase.openSecondaryCursor(Transaction txn, CursorConfig cursorConfig)` Deprecated. As of JE 4.0.13, replaced by `SecondaryDatabase.openCursor(com.sleepycat.je.Transaction, com.sleepycat.je.CursorConfig)`.
`SecondaryDatabase` | `Environment.openSecondaryDatabase(Transaction txn, String databaseName, Database primaryDatabase, SecondaryConfig dbConfig)` Opens and optionally creates a `SecondaryDatabase`.
`void` | `Database.preload(long maxBytes)` Deprecated. As of JE 2.0.83, replaced by `Database.preload(PreloadConfig)`.
`void` | `Database.preload(long maxBytes, long maxMillisecs)` Deprecated. As of JE 2.0.101, replaced by `Database.preload(PreloadConfig)`.
`PreloadStats` | `Database.preload(PreloadConfig config)` Preloads the cache.
`OperationStatus` | `Cursor.put(DatabaseEntry key, DatabaseEntry data)` Stores a key/data pair into the database.
`OperationStatus` | `Database.put(Transaction txn, DatabaseEntry key, DatabaseEntry data)` Stores the 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.putNoDupData(DatabaseEntry key, DatabaseEntry data)` Stores a key/data pair into the database.
`OperationStatus` | `Database.putNoDupData(Transaction txn, DatabaseEntry key, DatabaseEntry data)` Stores the key/data pair into the database if it does not already appear in the database.
`OperationStatus` | `Cursor.putNoOverwrite(DatabaseEntry key, DatabaseEntry data)` Stores a key/data pair into the database.
`OperationStatus` | `Database.putNoOverwrite(Transaction txn, DatabaseEntry key, DatabaseEntry data)` Stores the key/data pair into the database if the key does not already appear in the database.
`void` | `Database.removeSequence(Transaction txn, DatabaseEntry key)` Removes the sequence from the database.
`void` | `Transaction.setLockTimeout(long timeOut)` Deprecated. as of 4.0, replaced by `Transaction.setLockTimeout(long, TimeUnit)`.
`void` | `Transaction.setLockTimeout(long timeOut, 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, TimeUnit unit)` Configures the timeout value for the transaction lifetime.
`void` | `Database.sync()` Flushes any cached information for this database to disk; only applicable for deferred-write databases.
`void` | `Environment.sync()` Synchronously flushes database environment databases to stable storage.
`DatabaseStats` | `Database.verify(VerifyConfig config)` Verifies the integrity of the database.
`boolean` | `Environment.verify(VerifyConfig config, PrintStream out)` Returns if the database environment is consistent and correct.

Constructors in com.sleepycat.je that throw DatabaseException
`Environment(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
`Database` | `JEConnection.openDatabase(String name, DatabaseConfig config)`
`SecondaryDatabase` | `JEConnection.openSecondaryDatabase(String name, Database primaryDatabase, SecondaryConfig config)`
`void` | `JEConnection.removeDatabase(String databaseName)`
`long` | `JEConnection.truncateDatabase(String databaseName, boolean returnCount)`

Uses of DatabaseException in com.sleepycat.je.rep

Subclasses of DatabaseException in com.sleepycat.je.rep
`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.
`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` | `MasterStateException` This exception indicates that the application attempted an operation that is not permitted when it is in the `Replicator.State.Master state`.
`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` | `ReplicaWriteException` This exception indicates that an update operation 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
`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.monitor

Methods in com.sleepycat.je.rep.monitor that throw DatabaseException
`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
`boolean` | `DbLoad.load()`
`static void` | `DbVerify.main(String[] argv)` The main used by the DbVerify utility.
`void` | `DbSpace.print(PrintStream out)`
`void` | `DbBackup.startBackup()` Start backup mode in order to determine the definitive backup set needed at this point in time.
`boolean` | `DbVerify.verify(PrintStream out)` Verifies a database and write errors found to a stream.

Constructors in com.sleepycat.je.util that throw DatabaseException
`DbBackup(Environment env)` Creates a DbBackup helper for a full backup.
`DbBackup(Environment env, long lastFileInPrevBackup)` Creates a DbBackup helper for an incremental backup.

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` | `ForwardCursor.close()` Closes the cursor.
`void` | `EntityCursor.close()` Closes the cursor.
`void` | `EntityStore.close()` Closes all databases and sequences that were opened via this store.
`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.
`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.
`long` | `EntityIndex.count()` Returns a non-transactional count of the entities in this index.
`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.
`static Set<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, 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.sync()` Flushes each modified index to disk that was opened in deferred-write mode.
`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.evolve

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

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| Berkeley DB Java Edition version 4.0.103
PREV NEXT | FRAMES NO FRAMES

Copyright (c) 2004-2010 Oracle. All rights reserved.