DatabaseImpl (starrocks-bdb-je 18.3.17 API)

java.lang.Object
- com.sleepycat.je.dbi.DatabaseImpl

All Implemented Interfaces:

Loggable, Cloneable
```
public class DatabaseImpl
extends Object
implements Loggable, Cloneable
```
The underlying object for a given database.

Constructor Summary

Constructors
Constructor and Description
`DatabaseImpl()` Create an empty database object for initialization from the log.
`DatabaseImpl(Locker locker, String dbName, DatabaseId id, EnvironmentImpl envImpl, DatabaseConfig dbConfig)` Create a database object for a new database.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addReferringHandle(Database db)` Add a referring handle
`boolean`	`allowReplicaWrite()` Used to determine whether to throw ReplicaWriteException when a write to this database is attempted.
`boolean`	`allowsKeyUpdates()`
`static Object`	`bytesToObject(byte[] bytes, String label, ClassLoader loader)` Converts an arbitrary serialized byte array to an object.
`void`	`clearDbFileSummaries()` If `readFromLog(java.nio.ByteBuffer, int)` has read the file summaries from an old MapLN, we only need it if the MapLN is deleted (for recovery replay).
`void`	`clearKeyPrefixing()`
`static byte[]`	`comparatorToBytes(Comparator<byte[]> comparator, boolean byClassName, String comparatorType)` Converts a comparator object to a serialized byte array, converting to a class name String object if byClassName is true.
`int`	`compareEntries(DatabaseEntry entry1, DatabaseEntry entry2, boolean duplicates)`
`long`	`count(long memoryLimit)` Count entries in the database including dups, but don't dirty the cache.
`void`	`countObsoleteOldVersionDb(BaseUtilizationTracker tracker, long mapLnLsn)` When an old version (version LT 16) MapLN deletion is replayed by recovery, we must count it obsolete using the DbFileSummary metadata that was maintained in this older version.
`void`	`dumpLog(StringBuilder sb, boolean verbose)` Write the object into the string buffer for log dumping.
`String`	`dumpString(int nSpaces)`
`Database`	`findPrimaryDatabase()` For this secondary database return the primary that it is associated with, or null if not associated with any primary.
`int`	`getBinDeltaPercent()`
`Comparator<byte[]>`	`getBtreeComparator()` This comparator should not be used directly for comparisons.
`boolean`	`getBtreeComparatorByClass()`
`DbType`	`getDbType()`
`CacheMode`	`getDefaultCacheMode()` Returns the default cache mode for this database.
`Comparator<byte[]>`	`getDuplicateComparator()` This comparator should not be used directly for comparisons.
`boolean`	`getDuplicateComparatorByClass()`
`boolean`	`getDupsConverted()`
`EnvironmentImpl`	`getEnv()`
`DatabaseId`	`getId()`
`Comparator<byte[]>`	`getKeyComparator()` Should always be used when comparing keys for this database.
`boolean`	`getKeyPrefixing()`
`int`	`getLogSize()` This log entry type is configured to perform marshaling (getLogSize and writeToLog) under the write log mutex.
`String`	`getName()` Returns the DB name.
`int`	`getNodeMaxTreeEntries()`
`Set<Database>`	`getReferringHandles()` Returns a copy of the referring database handles.
`ReplicationContext`	`getRepContext()` Return a ReplicationContext that will indicate if this operation should broadcast data records for this database as part the replication stream.
`boolean`	`getSortedDuplicates()`
`static boolean`	`getSortedDuplicates(byte flagVal)`
`long`	`getTransactionId()`
`Tree`	`getTree()`
`List<Trigger>`	`getTriggers()` This method should be the only method used to obtain triggers after reading the MapLN from the log.
`void`	`handleClosed(boolean doSyncDw, boolean deleteTempDb)` Called after a handle onto this DB is closed.
`boolean`	`hasBtreeBinaryEqualityComparator()`
`boolean`	`hasDuplicateBinaryEqualityComparator()`
`boolean`	`hasOpenHandles()` Returns whether one or more handles are open.
`boolean`	`hasUserTriggers()`
`static Comparator<byte[]>`	`instantiateComparator(Class<? extends Comparator<byte[]>> comparatorClass, String comparatorType)` Used both to read from the log and to validate a comparator when set in DatabaseConfig.
`boolean`	`isCheckpointNeeded()` Returns whether this database's MapLN must be flushed during a checkpoint.
`boolean`	`isDeferredWriteMode()`
`boolean`	`isDeleteFinished()` Returns true if this database is deleted and all cleanup/extinction is finished.
`boolean`	`isDeleting()` Returns true if this database is being deleted.
`boolean`	`isDirty()` Returns whether this database has new (unflushed) utilization info or the root LSN was modified after it was last logged.
`boolean`	`isDurableDeferredWrite()`
`boolean`	`isInternalDb()`
`boolean`	`isInUse()` Returns whether this DB is in use and cannot be evicted.
`boolean`	`isLNImmediatelyObsolete()` Returns whether all LNs in this DB are "immediately obsolete", meaning two things: 1) They are counted obsolete when logged and can be ignored by the cleaner entirely.
`boolean`	`isReplicated()`
`boolean`	`isTemporary()`
`static boolean`	`isTemporary(byte flagVal)`
`boolean`	`isTransactional()`
`boolean`	`logicalEquals(Loggable other)`
`int`	`noteWriteHandleClose()` Decrements the write count and returns the updated value.
`int`	`noteWriteHandleOpen()` Increments the write count and returns the updated value.
`static byte[]`	`objectToBytes(Object obj, String label)` Converts an arbitrary object to a serialized byte array.
`PreloadStats`	`preload(PreloadConfig config)` Preload the cache, using up to maxBytes bytes or maxMillsecs msec.
`void`	`readFromLog(ByteBuffer itemBuffer, int entryVersion)` Initialize this object from the data in itemBuf.
`void`	`removeReferringHandle(Database db)` Decrement the reference count.
`boolean`	`setBtreeComparator(Comparator<byte[]> comparator, boolean byClassName)` Set the btree comparison function for this database.
`void`	`setCacheMode(CacheMode mode)` Sets the default mode for this database (all handles).
`void`	`setConfigProperties(Locker locker, String dbName, DatabaseConfig dbConfig, EnvironmentImpl envImpl)`
`void`	`setDeferredWrite(boolean durableDeferredWrite)` Sets the deferred write property for the first opened handle.
`void`	`setDeleteFinished()` The delete cleanup is finished.
`void`	`setDeleteStarted()` The delete cleanup is starting.
`void`	`setDirty()` Sets dirty in order to force the MapLN to be flushed later.
`boolean`	`setDuplicateComparator(Comparator<byte[]> comparator, boolean byClassName)` Set the duplicate comparison function for this database.
`void`	`setDupsConverted()`
`void`	`setEnvironmentImpl(EnvironmentImpl envImpl)` Set the db environment after reading in the DatabaseImpl from the log.
`void`	`setIsReplicatedBit()`
`void`	`setKeyPrefixing()`
`void`	`setKnownSecondary()`
`void`	`setNameAndType(String name)`
`void`	`setNodeMaxTreeEntries(int newNodeMaxTreeEntries)`
`void`	`setSortedDuplicates()`
`void`	`setTransactional(boolean transactional)` Sets the transactional property for the first opened handle.
`boolean`	`setTriggers(Locker locker, String dbName, List<Trigger> newTriggers, boolean overridePersistentTriggers)` Sets the list of triggers associated with the database.
`BtreeStats`	`stat(StatsConfig config)`
`void`	`sync(boolean flushLog)` Flush all dirty nodes for this database to disk.
`boolean`	`unknownReplicated()`
`BtreeStats`	`verify(VerifyConfig config)`
`void`	`writeToLog(ByteBuffer logBuffer)` Serialize this object into the buffer.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - DatabaseImpl
```
public DatabaseImpl(Locker locker,
                    String dbName,
                    DatabaseId id,
                    EnvironmentImpl envImpl,
                    DatabaseConfig dbConfig)
             throws DatabaseException
```
    Create a database object for a new database.
    
    Throws:
    
    DatabaseException
  - DatabaseImpl
```
public DatabaseImpl()
```
    Create an empty database object for initialization from the log. Note that the rest of the initialization comes from readFromLog().
- Method Detail
  - setConfigProperties
```
public void setConfigProperties(Locker locker,
                                String dbName,
                                DatabaseConfig dbConfig,
                                EnvironmentImpl envImpl)
```
  - setNameAndType
```
public void setNameAndType(String name)
```
  - setKnownSecondary
```
public void setKnownSecondary()
```
  - getTree
```
public Tree getTree()
```
    Returns:
    
    the database tree.
  - getId
```
public DatabaseId getId()
```
    Returns:
    
    the database id.
  - isTransactional
```
public boolean isTransactional()
```
    Returns:
    
    true if this database is transactional.
  - setTransactional
```
public void setTransactional(boolean transactional)
```
    Sets the transactional property for the first opened handle.
  - isTemporary
```
public boolean isTemporary()
```
    Returns:
    
    true if this database is temporary.
  - isTemporary
```
public static boolean isTemporary(byte flagVal)
```
  - isInternalDb
```
public boolean isInternalDb()
```
  - getDbType
```
public DbType getDbType()
```
  - isDurableDeferredWrite
```
public boolean isDurableDeferredWrite()
```
    Returns:
    
    true if this database was user configured for durable deferred write mode.
  - isDeferredWriteMode
```
public boolean isDeferredWriteMode()
```
    Returns:
    
    true if write operations are not logged immediately. This is true if the user configured a durable DW database or a temporary database.
  - setDeferredWrite
```
public void setDeferredWrite(boolean durableDeferredWrite)
```
    Sets the deferred write property for the first opened handle.
  - getSortedDuplicates
```
public boolean getSortedDuplicates()
```
    Returns:
    
    true if duplicates are allowed in this database.
  - getSortedDuplicates
```
public static boolean getSortedDuplicates(byte flagVal)
```
  - setSortedDuplicates
```
public void setSortedDuplicates()
```
  - getDupsConverted
```
public boolean getDupsConverted()
```
  - setDupsConverted
```
public void setDupsConverted()
```
  - isLNImmediatelyObsolete
```
public boolean isLNImmediatelyObsolete()
```
    Returns whether all LNs in this DB are "immediately obsolete", meaning two things: 1) They are counted obsolete when logged and can be ignored by the cleaner entirely. 2) As a consequence, they cannot be fetched by LSN, except under special circumstances where they are known to exist. Currently, this is synonymous with whether all LNs in this DB must have zero length data, and partial comparators are not used. Currently only duplicate DBs are known to have zero length LNs, since there is no way in the API to specify that LNs are immutable. In the future we will also support "immediately obsolete" LNs that are mutable and embedded in the BIN in other ways, e.g., tiny data may be stored with the key. Note that deleted LNs (the logged deletion, not the prior version) are always immediately obsolete also. See LNLogEntry.isImmediatelyObsolete.
  - getTriggers
```
public List<Trigger> getTriggers()
```
    This method should be the only method used to obtain triggers after reading the MapLN from the log. It unmarshalls the triggers lazily here to avoid a call to getName() during recovery, when the DbTree is not yet instantiated.
  - hasUserTriggers
```
public boolean hasUserTriggers()
```
  - getKeyPrefixing
```
public boolean getKeyPrefixing()
```
    Returns:
    
    true if key prefixing is enabled in this database.
  - setKeyPrefixing
```
public void setKeyPrefixing()
```
  - clearKeyPrefixing
```
public void clearKeyPrefixing()
```
  - isReplicated
```
public boolean isReplicated()
```
    Returns:
    
    true if this database is replicated. Note that we only need to check the IS_REPLICATED_BIT, because we require that we never have both IS_REPLICATED and NOT_REPLICATED set at the same time.
  - unknownReplicated
```
public boolean unknownReplicated()
```
    Returns:
    
    true if this database is replicated.
  - setIsReplicatedBit
```
public void setIsReplicatedBit()
```
  - getNodeMaxTreeEntries
```
public int getNodeMaxTreeEntries()
```
  - setNodeMaxTreeEntries
```
public void setNodeMaxTreeEntries(int newNodeMaxTreeEntries)
```
  - allowReplicaWrite
```
public boolean allowReplicaWrite()
```
    Used to determine whether to throw ReplicaWriteException when a write to this database is attempted. For the most part, writes on a replica are not allowed to any replicated DB. However, an exception is the DB naming DB. The naming DB contains a mixture of LNs for replicated and non-replicated databases. Here, we allow all writes to the naming DB. DB naming operations for replicated databases on a replica, such as the creation of a replicated DB on a replica, are prohibited by DbTree methods (dbCreate, dbRemove, etc). [#20543]
  - setCacheMode
```
public void setCacheMode(CacheMode mode)
```
    Sets the default mode for this database (all handles). May be null to use Environment default.
  - getDefaultCacheMode
```
public CacheMode getDefaultCacheMode()
```
    Returns the default cache mode for this database. If the database has a null cache mode and is not an internal database, the Environment default is returned. Null is never returned. CacheMode.DYNAMIC may be returned.
  - setDuplicateComparator
```
public boolean setDuplicateComparator(Comparator<byte[]> comparator,
                                      boolean byClassName)
                               throws DatabaseException
```
    Set the duplicate comparison function for this database.
    
    Parameters:
    
    comparator - - The Duplicate Comparison function.
    
    Returns:
    
    true if the comparator was actually changed
    
    Throws:
    
    DatabaseException
  - setTriggers
```
public boolean setTriggers(Locker locker,
                           String dbName,
                           List<Trigger> newTriggers,
                           boolean overridePersistentTriggers)
```
    Sets the list of triggers associated with the database.
    
    Parameters:
    
    dbName - pass it in since it may not be available during database creation
    
    newTriggers - the triggers to associate with the database
    
    overridePersistentTriggers - whether to overwrite persistent triggers
    
    Returns:
    
    true if a PersistentTrigger was changed, and therefore may need to be stored.
  - setBtreeComparator
```
public boolean setBtreeComparator(Comparator<byte[]> comparator,
                                  boolean byClassName)
                           throws DatabaseException
```
    Set the btree comparison function for this database.
    
    Parameters:
    
    comparator - - The btree Comparison function.
    
    Returns:
    
    true if the comparator was actually changed
    
    Throws:
    
    DatabaseException
  - getBtreeComparator
```
public Comparator<byte[]> getBtreeComparator()
```
    This comparator should not be used directly for comparisons. Use getKeyComparator instead.
    
    Returns:
    
    the btree Comparator object.
  - getDuplicateComparator
```
public Comparator<byte[]> getDuplicateComparator()
```
    This comparator should not be used directly for comparisons. Use getKeyComparator instead.
    
    Returns:
    
    the duplicate Comparator object.
  - getKeyComparator
```
public Comparator<byte[]> getKeyComparator()
```
    Should always be used when comparing keys for this database. For a duplicates database, the data is part two of the two-part database key. Therefore, the duplicates comparator and btree comparator are used for comparing keys. This synthetic comparator will call both of the other two user-defined comparators as necessary.
  - getBtreeComparatorByClass
```
public boolean getBtreeComparatorByClass()
```
    Returns:
    
    whether Comparator is set by class name, not by serializable Comparator object.
  - getDuplicateComparatorByClass
```
public boolean getDuplicateComparatorByClass()
```
    Returns:
    
    whether Comparator is set by class name, not by serializable Comparator object.
  - allowsKeyUpdates
```
public boolean allowsKeyUpdates()
```
  - hasBtreeBinaryEqualityComparator
```
public boolean hasBtreeBinaryEqualityComparator()
```
    Returns:
    
    whether Comparator implements BinaryEqualityComparator.
  - hasDuplicateBinaryEqualityComparator
```
public boolean hasDuplicateBinaryEqualityComparator()
```
    Returns:
    
    whether Comparator implements BinaryEqualityComparator.
  - setEnvironmentImpl
```
public void setEnvironmentImpl(EnvironmentImpl envImpl)
```
    Set the db environment after reading in the DatabaseImpl from the log.
  - getEnv
```
public EnvironmentImpl getEnv()
```
  - hasOpenHandles
```
public boolean hasOpenHandles()
```
    Returns whether one or more handles are open.
  - addReferringHandle
```
public void addReferringHandle(Database db)
```
    Add a referring handle
  - removeReferringHandle
```
public void removeReferringHandle(Database db)
```
    Decrement the reference count.
  - getReferringHandles
```
public Set<Database> getReferringHandles()
```
    Returns a copy of the referring database handles.
  - handleClosed
```
public void handleClosed(boolean doSyncDw,
                         boolean deleteTempDb)
                  throws DatabaseException
```
    Called after a handle onto this DB is closed.
    
    Throws:
    
    DatabaseException
  - noteWriteHandleOpen
```
public int noteWriteHandleOpen()
```
    Increments the write count and returns the updated value.
    
    Returns:
    
    updated write count
  - noteWriteHandleClose
```
public int noteWriteHandleClose()
```
    Decrements the write count and returns the updated value.
    
    Returns:
    
    updated write count
  - isInUse
```
public boolean isInUse()
```
    Returns whether this DB is in use and cannot be evicted. Called by MapLN.isEvictable while holding a write-lock on the MapLN and a latch on its parent BIN. [#13415] When isInUse returns false (while holding a write-lock on the MapLN and a latch on the parent BIN), it guarantees that the database object is not in use and cannot be acquired by another thread (via DbTree.createDb/getDb) until both the MapLN lock and BIN latch are released. This guarantee is due to the fact that DbTree.createDb/getDb only increment the use count while holding a read-lock on the MapLN. Therefore, it is safe to evict the MapLN when isInUse returns false. When isInUse returns true, it is possible that another thread may decrement the use count at any time, since no locking or latching is performed when calling DbTree.releaseDb (which calls decrementUseCount). Therefore, it is not guaranteed that the MapLN is in use when isInUse returns true. A true result means: the DB may be in use, so it is not safe to evict it.
  - sync
```
public void sync(boolean flushLog)
          throws DatabaseException
```
    Flush all dirty nodes for this database to disk.
    
    Throws:
    
    UnsupportedOperationException - via Database.sync.
    
    DatabaseException
  - findPrimaryDatabase
```
public Database findPrimaryDatabase()
```
    For this secondary database return the primary that it is associated with, or null if not associated with any primary. Note that not all handles need be associated with a primary.
  - getName
```
public String getName()
```
    Returns the DB name. If a rename txn is open, the old (last committed) value is returned; i.e., an uncommitted value is never returned. Null may be returned, but only during recovery before upgrading the MapLNs to log version 16.
  - clearDbFileSummaries
```
public void clearDbFileSummaries()
```
    If readFromLog(java.nio.ByteBuffer, int) has read the file summaries from an old MapLN, we only need it if the MapLN is deleted (for recovery replay). In other cases, call this method to clear it.
  - isDirty
```
public boolean isDirty()
```
    Returns whether this database has new (unflushed) utilization info or the root LSN was modified after it was last logged.
  - setDirty
```
public void setDirty()
```
    Sets dirty in order to force the MapLN to be flushed later. This flag is used when utilization is changed, the root LSN is changed, etc, in order to cause the MapLN to be flushed during the next checkpoint, or when utilization info is logged.
  - isCheckpointNeeded
```
public boolean isCheckpointNeeded()
```
    Returns whether this database's MapLN must be flushed during a checkpoint.
  - isDeleting
```
public boolean isDeleting()
```
    Returns true if this database is being deleted. The NameLN for this DB has been deleted so it is inaccessible to applications. However, delete cleanup/extinction may still be in progress. Note that the checkpointer should flush a node even if isDeleting might return true for the node's DB. This is necessary to avoid loss of obsolete info. See ExtinctionScanner.DatabaseExtinction.
  - isDeleteFinished
```
public boolean isDeleteFinished()
```
    Returns true if this database is deleted and all cleanup/extinction is finished. This method is intended for assertions in the Evictor, to check that no IN for such a DB is on the INList. This method never returns true for a DB that is isInUse(), i.e., for which DbTree.getDb(com.sleepycat.je.txn.Locker, java.lang.String, com.sleepycat.je.txn.HandleLocker, boolean) has been called and DbTree.releaseDb(com.sleepycat.je.dbi.DatabaseImpl) has not yet been called. See check in incrementUseCount().
  - setDeleteStarted
```
public void setDeleteStarted()
```
    The delete cleanup is starting. Set this before releasing any write locks held for a db operation.
  - setDeleteFinished
```
public void setDeleteFinished()
```
    The delete cleanup is finished. Set this after the async extinction process is complete and the MapLN is deleted.
  - countObsoleteOldVersionDb
```
public void countObsoleteOldVersionDb(BaseUtilizationTracker tracker,
                                      long mapLnLsn)
```
    When an old version (version LT 16) MapLN deletion is replayed by recovery, we must count it obsolete using the DbFileSummary metadata that was maintained in this older version. For version 16 and above, DB extinction is used instead.
  - stat
```
public BtreeStats stat(StatsConfig config)
                throws DatabaseException
```
    Throws:
    
    DatabaseException
  - verify
```
public BtreeStats verify(VerifyConfig config)
                  throws DatabaseException
```
    Throws:
    
    DatabaseException
  - preload
```
public PreloadStats preload(PreloadConfig config)
                     throws DatabaseException
```
    Preload the cache, using up to maxBytes bytes or maxMillsecs msec.
    
    Throws:
    
    IllegalArgumentException - via Database.preload
    
    DatabaseException
  - count
```
public long count(long memoryLimit)
           throws DatabaseException
```
    Count entries in the database including dups, but don't dirty the cache.
    
    Throws:
    
    DatabaseException
  - dumpString
```
public String dumpString(int nSpaces)
```
  - getLogSize
```
public int getLogSize()
```
    This log entry type is configured to perform marshaling (getLogSize and writeToLog) under the write log mutex. Otherwise, the size could change in between calls to these two methods as the result of utilizaton tracking.
    
    Specified by:
    
    getLogSize in interface Loggable
    
    Returns:
    
    number of bytes used to store this object.
    
    See Also:
    
    Loggable.getLogSize()
  - writeToLog
```
public void writeToLog(ByteBuffer logBuffer)
```
    Description copied from interface: Loggable
    
    Serialize this object into the buffer.
    
    Specified by:
    
    writeToLog in interface Loggable
    
    Parameters:
    
    logBuffer - is the destination buffer
    
    See Also:
    
    Loggable.writeToLog(java.nio.ByteBuffer)
  - readFromLog
```
public void readFromLog(ByteBuffer itemBuffer,
                        int entryVersion)
```
    Description copied from interface: Loggable
    
    Initialize this object from the data in itemBuf.
    
    Specified by:
    
    readFromLog in interface Loggable
    
    Parameters:
    
    itemBuffer - the source buffer
    
    entryVersion - the log version of the data
    
    See Also:
    
    Loggable.readFromLog(java.nio.ByteBuffer, int)
  - dumpLog
```
public void dumpLog(StringBuilder sb,
                    boolean verbose)
```
    Description copied from interface: Loggable
    
    Write the object into the string buffer for log dumping. Each object should be dumped without indentation or new lines and should be valid XML.
    
    Specified by:
    
    dumpLog in interface Loggable
    
    Parameters:
    
    sb - destination string buffer
    
    verbose - if true, dump the full, verbose version
    
    See Also:
    
    Loggable.dumpLog(java.lang.StringBuilder, boolean)
  - getTransactionId
```
public long getTransactionId()
```
    Specified by:
    
    getTransactionId in interface Loggable
    
    Returns:
    
    the transaction id embedded within this loggable object. Objects that have no transaction id should return 0.
    
    See Also:
    
    Loggable.getTransactionId()
  - logicalEquals
```
public boolean logicalEquals(Loggable other)
```
    Specified by:
    
    logicalEquals in interface Loggable
    
    Returns:
    
    true if these two loggable items are logically the same. Used for replication testing.
    
    See Also:
    
    Always return false, this item should never be compared.
  - instantiateComparator
```
public static Comparator<byte[]> instantiateComparator(Class<? extends Comparator<byte[]>> comparatorClass,
                                                       String comparatorType)
```
    Used both to read from the log and to validate a comparator when set in DatabaseConfig.
  - comparatorToBytes
```
public static byte[] comparatorToBytes(Comparator<byte[]> comparator,
                                       boolean byClassName,
                                       String comparatorType)
```
    Converts a comparator object to a serialized byte array, converting to a class name String object if byClassName is true.
    
    Throws:
    
    EnvironmentFailureException - if the object cannot be serialized.
  - objectToBytes
```
public static byte[] objectToBytes(Object obj,
                                   String label)
```
    Converts an arbitrary object to a serialized byte array. Assumes that the object given is non-null.
  - bytesToObject
```
public static Object bytesToObject(byte[] bytes,
                                   String label,
                                   ClassLoader loader)
```
    Converts an arbitrary serialized byte array to an object. Assumes that the byte array given is non-null and has a non-zero length.
  - compareEntries
```
public int compareEntries(DatabaseEntry entry1,
                          DatabaseEntry entry2,
                          boolean duplicates)
```
  - getBinDeltaPercent
```
public int getBinDeltaPercent()
```
  - getRepContext
```
public ReplicationContext getRepContext()
```
    Return a ReplicationContext that will indicate if this operation should broadcast data records for this database as part the replication stream.

Class DatabaseImpl

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

DatabaseImpl

DatabaseImpl

Method Detail

setConfigProperties

setNameAndType

setKnownSecondary

getTree

getId

isTransactional

setTransactional

isTemporary

isTemporary

isInternalDb

getDbType

isDurableDeferredWrite

isDeferredWriteMode

setDeferredWrite

getSortedDuplicates

getSortedDuplicates

setSortedDuplicates

getDupsConverted

setDupsConverted

isLNImmediatelyObsolete

getTriggers

hasUserTriggers

getKeyPrefixing

setKeyPrefixing

clearKeyPrefixing

isReplicated

unknownReplicated

setIsReplicatedBit

getNodeMaxTreeEntries

setNodeMaxTreeEntries

allowReplicaWrite

setCacheMode

getDefaultCacheMode

setDuplicateComparator

setTriggers

setBtreeComparator

getBtreeComparator

getDuplicateComparator

getKeyComparator

getBtreeComparatorByClass

getDuplicateComparatorByClass

allowsKeyUpdates

hasBtreeBinaryEqualityComparator

hasDuplicateBinaryEqualityComparator

setEnvironmentImpl

getEnv

hasOpenHandles

addReferringHandle

removeReferringHandle

getReferringHandles

handleClosed

noteWriteHandleOpen

noteWriteHandleClose

isInUse

sync

findPrimaryDatabase

getName

clearDbFileSummaries

isDirty

setDirty

isCheckpointNeeded

isDeleting

isDeleteFinished

setDeleteStarted

setDeleteFinished

countObsoleteOldVersionDb

stat

verify

preload

count

dumpString

getLogSize