# All Classes

All Classes Interface Summary Class Summary Enum Summary Exception Summary Annotation Types Summary
AnnotationModel: The default annotation-based entity model.
BackupHandler: An interface that can optionally be used to override the default behavior performed by the `Environment.backup` and `Environment.backupDatabase` methods.
BackupOptions: Options for `Environment.backup(java.lang.String, com.sleepycat.db.BackupOptions)` operations.
BigDecimalBinding: A concrete `TupleBinding` for an unsorted `BigDecimal` value.
BigIntegerBinding: A concrete `TupleBinding` for a `BigInteger` value.
BooleanBinding: A concrete `TupleBinding` for a `Boolean` primitive wrapper or a `boolean` primitive.
BtreeCompressor: An interface specifying how Btree compression works.
BtreePrefixCalculator: An interface specifying how Btree prefixes should be calculated.
BtreeStats: The BtreeStats object is used to return Btree or Recno database statistics.
ByteArrayBinding: A pass-through `EntryBinding` that uses the entry's byte array as the key or data object.
ByteBinding: A concrete `TupleBinding` for a `Byte` primitive wrapper or a `byte` primitive.
CacheFile: This class allows applications to modify settings for a `Database` using the `Database.getCacheFile`.
CacheFilePriority: Priorities that can be assigned to files in the cache.
CacheFileStats: Statistics for a file in the cache.
CacheStats: Cache statistics for a database environment.
CharacterBinding: A concrete `TupleBinding` for a `Character` primitive wrapper or a `char` primitive.
CheckpointConfig: Specifies the attributes of an application invoked checkpoint operation.
ClassCatalog: A catalog of class description information for use during object serialization.
ClassMetadata: The metadata for a persistent class.
ClassResolver: Implements policies for loading user-supplied classes.
ClassResolver.Stream: A specialized ObjectInputStream that supports use of a user-specified ClassLoader.
CompactConfig: Configuration for `Database.compact(com.sleepycat.db.Transaction, com.sleepycat.db.DatabaseEntry, com.sleepycat.db.DatabaseEntry, com.sleepycat.db.DatabaseEntry, com.sleepycat.db.CompactConfig)` operations.
CompactStats: Statistics returned by a `Database.compact(com.sleepycat.db.Transaction, com.sleepycat.db.DatabaseEntry, com.sleepycat.db.DatabaseEntry, com.sleepycat.db.DatabaseEntry, com.sleepycat.db.CompactConfig)` operation.
ConfigBeanInfoBase
Conversion: Converts an old version of an object value to conform to the current class or field definition.
Converter: A mutation for converting an old version of an object value to conform to the current class or field definition.
CurrentTransaction: Provides access to the current transaction for the current thread within the context of a Berkeley DB environment.
Cursor: A database cursor.
CursorConfig: Specify the attributes of database cursor.
Database: Creates a database handle for a single Berkeley DB database.
DatabaseConfig: Specify the attributes of a database.
DatabaseEntry: Encodes database key and data items as a byte array.
DatabaseException: The root of all database exceptions.
DatabaseNamer: Determines the file names to use for primary and secondary databases.
DatabaseStats: Statistics for a single database.
DatabaseStream: A database stream.
DatabaseStreamConfig: Specify the attributes of database stream.
DatabaseType: Database types.
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.
DeleteAction: Specifies the action to take when a related entity is deleted having a primary key value that exists as a secondary key value for this entity.
DeletedClassException: While reading from an index, an instance of a deleted class version was encountered.
Deleter: A mutation for deleting an entity class or field.
DoubleBinding: A concrete `TupleBinding` for an unsorted `Double` primitive wrapper or an unsorted `double` primitive.
Entity: Indicates a persistent entity class.
EntityBinding<E>: A binding between a key-value entry pair and an entity object.
EntityConverter: A subclass of Converter that allows specifying keys to be deleted.
EntityCursor<V>: Traverses entity values or key values and allows deleting or updating the entity at the current cursor position.
EntityIndex<K,​V>: The interface for accessing keys and entities via a primary or secondary index.
EntityJoin<PK,​E>: Performs an equality join on two or more secondary keys.
EntityMetadata: The metadata for a persistent entity class.
EntityModel: The base class for classes that provide entity model metadata.
EntityStore: A store for managing persistent entity objects.
EntryBinding<E>: A binding between a key or data entry and a key or data object.
Environment: A database environment.
EnvironmentConfig: Specifies the attributes of an environment.
ErrorBuffer
ErrorHandler: An interface specifying a callback function to be called when an error occurs in the Berkeley DB library.
EventHandler: An interface classs with prototype definitions of all event functions that can be called via the Berkeley DB event callback mechanism.
EventHandlerAdapter: An abstract class that implements `EventHandler`, used to specify a callback function to be called when an event is sent from the Berkeley DB library.
EvolveConfig: Configuration properties for eager conversion of unevolved objects.
EvolveConfigBeanInfo
EvolveEvent: The event passed to the EvolveListener interface during eager entity evolution.
EvolveInternal: Internal access class that should not be used by applications.
EvolveListener: The listener interface called during eager entity evolution.
EvolveStats: Statistics accumulated during eager entity evolution.
ExceptionUnwrapper: Unwraps nested exceptions by calling the `getCause()` method for exceptions that implement the `ExceptionWrapper` interface.
ExceptionWrapper: Interface implemented by exceptions that can contain nested exceptions.
FastInputStream: A replacement for ByteArrayInputStream that does not synchronize every byte read.
FastOutputStream: A replacement for ByteArrayOutputStream that does not synchronize every byte read.
FeedbackHandler: An interface specifying a function to be called to provide feedback.
FieldMetadata: The metadata for a key field.
FloatBinding: A concrete `TupleBinding` for an unsorted `Float` primitive wrapper or an unsorted `float` primitive.
ForeignKeyDeleteAction: The action taken when a referenced record in the foreign key database is deleted.
ForeignKeyNullifier: The interface implemented for setting single-valued foreign keys to null.
ForeignMultiKeyNullifier: The interface implemented for setting multi-valued foreign keys to null.
ForwardCursor<V>: Cursor operations limited to traversing forward.
Hasher: An application-specified, database hash function.
HashStats: The HashStats object is used to return Hash database statistics.
HeapFullException: A HeapFullException is thrown when an attempt was made to add or update a record in a Heap database.
HeapRecordId: Content used for the key in a Heap database record.
HeapStats: The HeapStats object is used to return Heap database statistics.
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.
IndexNotAvailableException: Thrown by the `getPrimaryIndex`, `getSecondaryIndex` and `getSubclassIndex` when an index has not yet been created.
IntegerBinding: A concrete `TupleBinding` for a `Integer` primitive wrapper or an `int` primitive.
IOExceptionWrapper: An IOException that can contain nested exceptions.
JoinConfig: The configuration properties of a `JoinCursor`.
JoinCursor: A specialized join cursor for use in performing equality or natural joins on secondary indices.
KeyField: Indicates the sorting position of a key field in a composite key class when the `Comparable` interface is not implemented.
KeyRange: An object that returns status from the `Database.getKeyRange` method.
Lock: The locking interfaces for the database environment are methods of the `Environment` handle.
LockDetectMode: Deadlock detection modes.
LockMode: Locking modes for database operations.
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.
LockOperation: Operations that can be performed on locks.
LockRequest: The LockRequest object is used to encapsulate a single lock request.
LockRequestMode: When using the default lock conflict matrix, the LockRequestMode class defines the set of possible lock modes.
LockStats: Lock statistics for a database environment.
LogCursor: The LogCursor object is the handle for a cursor into the log files, supporting sequential access to the records stored in log files.
LogRecordHandler: A function to process application-specific log records.
LogSequenceNumber: The LogSequenceNumber object is a log sequence number which specifies a unique location in a log file.
LogStats: Log statistics for a database environment.
LogVerifyConfig: Specify the attributes of a database.
LongBinding: A concrete `TupleBinding` for a `Long` primitive wrapper or a `long` primitive.
MapEntryParameter<K,​V>: A simple `Map.Entry` implementation that can be used as in input parameter.
MarshalledTupleEntry: A marshalling interface implemented by key, data or entity classes that are represented as tuples.
MarshalledTupleKeyEntity: A marshalling interface implemented by entity classes that represent keys as tuples.
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.
MessageHandler: An interface specifying a callback function to be called to display informational messages.
MetaCheckSumFailException: A MetaCheckSumFailException is thrown when a checksum mismatch is detected on a database metadata page.
ModelInternal: Internal access class that should not be used by applications.
MultipleDataEntry: A DatabaseEntry that holds multiple data items returned by a single `Database` or `Cursor` get call.
MultipleEntry: An abstract class representing a DatabaseEntry that holds multiple results returned by a single `Cursor` get method.
MultipleKeyDataEntry: A DatabaseEntry that holds multiple key/data pairs returned by a single `Database` or `Cursor` get call.
MultipleKeyNIODataEntry: A DatabaseEntry that holds multiple key/data pairs returned by a single `Database` or `Cursor` get call.
MultipleNIODataEntry: A DatabaseEntry that holds multiple data items returned by a single `Database` or `Cursor` get call.
MultipleRecnoDataEntry: A DatabaseEntry that holds multiple record number/data pairs returned by a single `Database` or `Cursor` get call.
MultipleRecnoNIODataEntry: A DatabaseEntry that holds multiple record number/data pairs returned by a single `Database` or `Cursor` get call.
Mutation: The base class for all mutations.
Mutations: A collection of mutations for configuring class evolution.
MutexStats: Statistics about mutexes in a Berkeley DB database environment, returned by `Environment.getMutexStats(com.sleepycat.db.StatsConfig)`
NotPersistent: Overrides the default rules for field persistence and defines a field as being non-persistent even when it is not declared with the `transient` keyword.
NotTransient: Overrides the default rules for field persistence and defines a field as being persistent even when it is declared with the `transient` keyword.
OperationStatus: Status values from database operations.
PackedInteger: Static methods for reading and writing packed integers.
PackedIntegerBinding: A concrete `TupleBinding` for an unsorted `Integer` primitive wrapper or an unsorted `int` primitive, that stores the value in the smallest number of bytes possible.
PackedLongBinding: A concrete `TupleBinding` for an unsorted `Long` primitive wrapper or an unsorted `long` primitive, that stores the value in the smallest number of bytes possible.
PanicHandler: An interface specifying a function to be called if the database environment panics.
PartitionHandler: An interface specifying how to set up database partitioning.
Persistent: Identifies a persistent class that is not an `Entity` class or a simple type.
PersistentProxy<T>: Implemented by a proxy class to represent the persistent state of a (non-persistent) proxied class.
PreparedTransaction: The PreparedTransaction object is used to encapsulate a single prepared, but not yet resolved, transaction.
PrimaryIndex<PK,​E>: The primary index for an entity class and its primary key.
PrimaryKey: Indicates the primary key field of an entity class.
PrimaryKeyAssigner: An interface implemented to assign new primary key values.
PrimaryKeyMetadata: The metadata for a primary key field.
QueueStats: The QueueStats object is used to return Queue database statistics.
RawField: The definition of a field in a `RawType`.
RawObject: A raw instance that can be used with a `RawStore` or `Conversion`.
RawStore: Provides access to the raw data in a store for use by general purpose tools.
RawType: The type definition for a simple or complex persistent type, or an array of persistent types.
RecordNumberAppender: An interface specifying a callback function that modifies stored data based on a generated key.
RecordNumberBinding: An `EntryBinding` that treats a record number key entry as a `Long` key object.
RecoveryOperation: The recovery operation being performed when `LogRecordHandler.handleLogRecord` is called.
RegionResourceType: Advanced configuration is possible for various systems that use shared memory (regions) for cross process sharing.
Relationship: Defines the relationship between instances of the entity class and the secondary keys.
Renamer: A mutation for renaming a class or field without changing the instance or field value.
ReplicationChannel: A ReplicationChannel handle is used to manage a channel in a replication group.
ReplicationConfig: Settings that configure Berkeley DB replication.
ReplicationDuplicateMasterException: The replication group has more than one master.
ReplicationHandleDeadException: Thrown when a database handle has been invalidated because a replication election unrolled a committed transaction.
ReplicationHoldElectionException: An election is needed.
ReplicationHostAddress: A simple wrapper class to hold information needed to define a host in a replication group.
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).
ReplicationLeaseExpiredException: Thrown if a master lease has expired.
ReplicationLockoutException: Thrown when an operation was blocked by client/master synchronization.
ReplicationManagerAckPolicy: A class that provides definitions for the types of network ack policy to use when transmitting messages between replication sites using the Replication Manager.
ReplicationManagerConnectionStatus: Describes the connection status of a replication site.
ReplicationManagerMessageDispatch
ReplicationManagerSite: A ReplicationManagerSite handle is used to manage a site in a replication group.
ReplicationManagerSiteConfig: Specifies the attributes of a site in the replication group.
ReplicationManagerSiteInfo: A simple wrapper class to hold information needed to define a replication site.
ReplicationManagerStartPolicy: This class provides definitions of the various start policies thatcan be specified when starting a replication client using the`Environment.replicationManagerStart` call.
ReplicationManagerStats: Replication Manager statistics for a database environment.
ReplicationSiteUnavailableException: Thrown if replication group was unable to elect a master, or was unable to complete the election in the specified timeout period.
ReplicationStats: Replication statistics for a database environment.
ReplicationStatus: The return status from processing a replication message.
ReplicationTimeoutType: The ReplicationTimeoutType defines the types of timeouts that can beconfigured for the Berkeley Db replication functionality.
ReplicationTransport: An interface specifying a replication transmit function, which sends information to other members of the replication group.
ReplicationViewHandler: An interface specifying a callback function to be used by replication views.
RunRecoveryException: Thrown when the database environment needs to be recovered.
RuntimeExceptionWrapper: A RuntimeException that can contain nested exceptions.
SecondaryConfig: The configuration properties of a `SecondaryDatabase` extend those of a primary `Database`.
SecondaryCursor: A database cursor for a secondary database.
SecondaryDatabase: A secondary database handle.
SecondaryIndex<SK,​PK,​E>: The secondary index for an entity class and a secondary key.
SecondaryKey: Indicates a secondary key field of an entity class.
SecondaryKeyCreator: The interface implemented for extracting single-valued secondary keys from primary records.
SecondaryKeyMetadata: The metadata for a secondary key field.
SecondaryMultiKeyCreator: The interface implemented for extracting multi-valued secondary keys from primary records.
Sequence: A Sequence handle is used to manipulate a sequence record in a database.
SequenceConfig: Specify the attributes of a sequence.
SequenceStats: A SequenceStats object is used to return sequence statistics.
SerialBase: A base class for serial bindings creators that provides control over the allocation of the output buffer.
SerialBinding<E>: A concrete `EntryBinding` that treats a key or data entry as a serialized object.
SerialInput: A specialized `ObjectInputStream` that gets class description information from a `ClassCatalog`.
SerialOutput: A specialized `ObjectOutputStream` that stores class description information in a `ClassCatalog`.
SerialSerialBinding<K,​D,​E>: An abstract `EntityBinding` that treats an entity's key entry and data entry as serialized objects.
SerialSerialKeyCreator<PK,​D,​SK>: A abstract key creator that uses a serial key and a serial data entry.
ShortBinding: A concrete `TupleBinding` for a `Short` primitive wrapper or a `short` primitive.
Slice: An interface specifying in which slice database records are read or written based on the given key.
SliceCorruptException: Thrown when a slice environment or database is missing or corrupt.
SortedBigDecimalBinding: A concrete `TupleBinding` for a sorted `BigDecimal` value.
SortedDoubleBinding: A concrete `TupleBinding` for a sorted `Double` primitive wrapper or a sorted `double` primitive.
SortedFloatBinding: A concrete `TupleBinding` for a sorted `Float` primitive wrapper or sorted a `float` primitive.
SortedPackedIntegerBinding: A concrete `TupleBinding` for a sorted `Integer` primitive wrapper or a sorted `int` primitive, that stores the value in the smallest number of bytes possible.
SortedPackedLongBinding: A concrete `TupleBinding` for a sorted `Long` primitive wrapper or a sorted `long` primitive, that stores the value in the smallest number of bytes possible.
StatsConfig: Specifies the attributes of a statistics retrieval operation.
StoreConfig: Configuration properties used with an `EntityStore` or `RawStore`.
StoreConfigBeanInfo
StoredClassCatalog: A `ClassCatalog` that is stored in a `Database`.
StoredCollection<E>: A abstract base class for all stored collections.
StoredCollections: Static methods operating on collections and maps.
StoredContainer: A abstract base class for all stored collections and maps.
StoredEntrySet<K,​V>: The Set returned by Map.entrySet().
StoredIterator<E>: The Iterator returned by all stored collections.
StoredKeySet<K>: The Set returned by Map.keySet() and which can also be constructed directly if a Map is not needed.
StoredList<E>: A List view of a `Database`.
StoredMap<K,​V>: A Map view of a `Database`.
StoredSortedEntrySet<K,​V>: The SortedSet returned by Map.entrySet().
StoredSortedKeySet<K>: The SortedSet returned by Map.keySet() and which can also be constructed directly if a Map is not needed.
StoredSortedMap<K,​V>: A SortedMap view of a `Database`.
StoredSortedValueSet<E>: The SortedSet returned by Map.values() and which can also be constructed directly if a Map is not needed.
StoredValueSet<E>: The Set returned by Map.values() and Map.duplicates(), and which can also be constructed directly if a Map is not needed.
StoreExistsException: Thrown by the `EntityStore` constructor when the `ExclusiveCreate` configuration parameter is true and the store's internal catalog database already exists.
StoreNotFoundException: Thrown by the `EntityStore` constructor when the `AllowCreate` configuration parameter is false and the store's internal catalog database does not exist.
StringBinding: A concrete `TupleBinding` for a simple `String` value.
Transaction: The Transaction object is the handle for a transaction.
TransactionConfig: Specifies the attributes of a database environment transaction.
TransactionRunner: Starts a transaction, calls `TransactionWorker.doWork()`, and handles transaction retry and exceptions.
TransactionStats: Transaction statistics for a database environment.
TransactionStats.Active
TransactionStatus: Status values from transaction application checking operations.
TransactionWorker: The interface implemented to perform the work within a transaction.
TupleBase<E>: A base class for tuple bindings and tuple key creators that provides control over the allocation of the output buffer.
TupleBinding<E>: An abstract `EntryBinding` that treats a key or data entry as a tuple; it includes predefined bindings for Java primitive types.
TupleInput: An `InputStream` with `DataInput`-like methods for reading tuple fields.
TupleInputBinding: A concrete `EntryBinding` that uses the `TupleInput` object as the key or data object.
TupleMarshalledBinding<E extends MarshalledTupleEntry>: A concrete `TupleBinding` that delegates to the `MarshalledTupleEntry` interface of the data or key object.
TupleOutput: An `OutputStream` with `DataOutput`-like methods for writing tuple fields.
TupleSerialBinding<D,​E>: An abstract `EntityBinding` that treats an entity's key entry as a tuple and its data entry as a serialized object.
TupleSerialFactory: Creates stored collections having tuple keys and serialized entity values.
TupleSerialKeyCreator<D>: A abstract key creator that uses a tuple key and a serial data entry.
TupleSerialMarshalledBinding<E extends MarshalledTupleKeyEntity>: A concrete `TupleSerialBinding` that delegates to the `MarshalledTupleKeyEntity` interface of the entity class.
TupleSerialMarshalledKeyCreator<D extends MarshalledTupleKeyEntity>: A concrete key creator that works in conjunction with a `TupleSerialMarshalledBinding`.
TupleTupleBinding<E>: An abstract `EntityBinding` that treats an entity's key entry and data entry as tuples.
TupleTupleKeyCreator<E>: An abstract key creator that uses a tuple key and a tuple data entry.
TupleTupleMarshalledBinding<E extends MarshalledTupleEntry & MarshalledTupleKeyEntity>: A concrete `TupleTupleBinding` that delegates to the `MarshalledTupleEntry` and `MarshalledTupleKeyEntity` interfaces of the entity class.
TupleTupleMarshalledKeyCreator<E extends MarshalledTupleEntry & MarshalledTupleKeyEntity>: A concrete key creator that works in conjunction with a `TupleTupleMarshalledBinding`.
UtfOps: UTF operations with more flexibility than is provided by DataInput and DataOutput.
VerboseConfig: Specifies the attributes of a verification operation.
VerifyConfig: Specifies the attributes of a verification operation.
VersionMismatchException: Thrown if the version of the Berkeley DB library doesn't match the version that created the database environment.