com.sleepycat.db

## Class EnvironmentConfig

- java.lang.Object
- - com.sleepycat.db.EnvironmentConfig

All Implemented Interfaces:
  java.lang.Cloneable

    public class EnvironmentConfig
    extends java.lang.Object
    implements java.lang.Cloneable

Specifies the attributes of an environment.

To change the default settings for a database environment, an application creates a configuration object, customizes settings and uses it for environment construction. The set methods of this class validate the configuration values when the method is invoked. An IllegalArgumentException is thrown if the value is not valid for that attribute.

All commonly used environment attributes have convenience setter/getter methods defined in this class. For example, to change the default transaction timeout setting for an environment, the application should do the following:

>         // customize an environment configuration
>         EnvironmentConfig envConfig = new EnvironmentConfig();
>         envConfig.setTxnTimeout(10000);  // will throw if timeout value is invalid
>         // Open the environment.
>         Environment myEnvironment = new Environment(home, envConfig);

Environment configuration follows this order of precedence:

1. Configuration parameters specified in <environment home>/je.properties take first precedence.
2. Configuration parameters set in the EnvironmentConfig object used at Environment construction are next.
3. Any configuration parameters not set by the application are set to system defaults.

An EnvironmentConfig can be used to specify both mutable and immutable environment properties. Immutable properties may be specified when the first Environment handle (instance) is opened for a given physical environment. When more handles are opened for the same environment, the following rules apply:

1. Immutable properties must equal the original values specified when constructing an Environment handle for an already open environment. When a mismatch occurs, an exception is thrown.
2. Mutable properties are ignored when constructing an Environment handle for an already open environment.

After an Environment has been constructed, its mutable properties may be changed using `Environment.setConfig(com.sleepycat.db.EnvironmentConfig)`.

### Field Summary

Fields
`static EnvironmentConfig` `DEFAULT`

### Constructor Summary

Constructors
Constructor and Description
`EnvironmentConfig()` Create an EnvironmentConfig initialized with the system default settings.

### Method Summary

Methods
`void` `addDataDir(java.io.File dataDir)` Set the path of a directory to be used as the location of the access method database files.
`void` `addDataDir(java.lang.String dataDir)` Deprecated. replaced by `addDataDir(java.io.File)`
`void` `addReplicationManagerSite(ReplicationManagerSiteConfig repmgrSiteConfig)` Configure a site in a replication group.
`boolean` `getAllowCreate()` Return true if the database environment is configured to create any underlying files, as necessary.
`BackupHandler` `getBackupHandler()` Return the `BackupHandler` used to override default hot backup behavior.
`int` `getBackupReadCount()` Return the number of pages to read before pausing during the hot backup.
`int` `getBackupReadSleep()` Return the number of microseconds to sleep between batches of reads during a hot backup.
`int` `getBackupSize()` Return the size of the buffer, in megabytes, to read from the database during a hot backup.
`boolean` `getBackupWriteDirect()` Return return true if direct I/O is used when writing pages to the disk during a hot backup.
`java.io.File` `getBlobDir()` Returns the path of a directory where blobs are stored.
`int` `getBlobThreshold()` Return the environment wide default blob threshold value.
`int` `getCacheCount()` Return the number of shared memory buffer pools, that is, the number of cache regions.
`long` `getCacheMax()` Return the maximum size of the cache.
`int` `getCachePageSize()` Returns the environment's current page size setting.
`long` `getCacheSize()` Return the size of the shared memory buffer pool, that is, the cache.
`int` `getCacheTableSize()` Returns the environment's current table size setting.
`boolean` `getCDBLockAllDatabases()` Return true if the Concurrent Data Store applications are configured to perform locking on an environment-wide basis rather than on a per-database basis.
`java.io.File` `getCreateDir()` Returns the path of a directory to be used as the location to create the access method database files.
`java.io.File[]` `getDataDirs()` Return the array of data directories.
`boolean` `getDirectDatabaseIO()` Return true if the database environment has been configured to not buffer database files.
`boolean` `getDirectLogIO()` Return true if the database environment has been configured to not buffer log files.
`boolean` `getDsyncDatabases()` Return true if the database environment has been configured to flush database writes to the backing disk before returning from the write system call.
`boolean` `getDsyncLog()` Return true if the database environment has been configured to flush log writes to the backing disk before returning from the write system call.
`boolean` `getEncrypted()` Return the database environment has been configured to perform encryption.
`ErrorHandler` `getErrorHandler()` Return the function to be called if an error occurs.
`java.lang.String` `getErrorPrefix()` Return the prefix string that appears before error messages.
`java.io.OutputStream` `getErrorStream()` Return the OutputStream for displaying error messages.
`EventHandler` `getEventHandler()` Return the object's methods to be called when a triggered event occurs.
`FeedbackHandler` `getFeedbackHandler()` Return the object's methods to be called to provide feedback.
`boolean` `getHotbackupInProgress()` Return true if a "hot backup" is in progress.
`boolean` `getInitializeCache()` Return true if the database environment is configured with a shared memory buffer pool.
`boolean` `getInitializeCDB()` Return true if the database environment is configured for the Concurrent Data Store product.
`boolean` `getInitializeLocking()` Return true if the database environment is configured for locking.
`boolean` `getInitializeLogging()` Return true if the database environment is configured for logging.
`boolean` `getInitializeRegions()` Return true if the database environment has been configured to page-fault shared regions into memory when initially creating or joining a database environment.
`boolean` `getInitializeReplication()` Return true if the database environment is configured for replication.
`int` `getInitialMutexes()` Return the number of mutexes allocated when an environment is created.
`boolean` `getJoinEnvironment()` Return the handle is configured to join an existing environment.
`byte[][]` `getLockConflicts()` Return the locking conflicts matrix.
`LockDetectMode` `getLockDetectMode()` Return true if the deadlock detector is configured to run whenever a lock conflict occurs.
`boolean` `getLockDown()` Return true if the database environment is configured to lock shared environment files and memory-mapped databases into memory.
`int` `getLockPartitions()` Returns the number of lock table partitions in the Berkeley DB environment.
`int` `getLockTableSize()` Return the lock hash table size.
`long` `getLockTimeout()` Return the database environment lock timeout value, in microseconds; a timeout of 0 means no timeout is set.
`boolean` `getLogAutoRemove()` Return true if the system has been configured to to automatically remove log files that are no longer needed.
`boolean` `getLogBlobContent()` Return true if full logging of blob data is enabled.
`int` `getLogBufferSize()` Return the size of the in-memory log buffer, in bytes.
`java.io.File` `getLogDirectory()` Return the path of a directory to be used as the location of logging files.
`int` `getLogFileMode()` Return the absolute file mode for created log files.
`boolean` `getLogInMemory()` Return true if the database environment is configured to maintain transaction logs in memory rather than on disk.
`LogRecordHandler` `getLogRecordHandler()` Return the handler for application-specific log records.
`int` `getLogRegionSize()` Return the size of the underlying logging subsystem region.
`boolean` `getLogZero()` Return true if the database environment is configured to zero all pages of new log files upon their creation.
`int` `getMaxLockers()` Return the maximum number of lockers.
`int` `getMaxLockObjects()` Return the maximum number of locked objects.
`int` `getMaxLocks()` Return the maximum number of locks.
`int` `getMaxLogFileSize()` Return the maximum size of a single file in the log, in bytes.
`int` `getMaxMutexes()` Return the total number of mutexes allocated.
`int` `getMaxOpenFiles()` Return the maximum number of file descriptors that will be opened concurrently..
`int` `getMaxWrite()` Return the maximum number of sequential write operations.
`long` `getMaxWriteSleep()` Return the microseconds to pause before scheduling further write operations.
`MessageHandler` `getMessageHandler()` Return the function to be called with an informational message.
`java.io.OutputStream` `getMessageStream()` Return the OutputStream for displaying informational messages.
`java.io.File` `getMetadataDir()` Return the path of a directory to be used as the location to store the persistent metadata.
`long` `getMMapSize()` Return the maximum file size, in bytes, for a file to be mapped into the process address space.
`long` `getMode()` Return the mode to use when creating underlying files and shared memory segments.
`boolean` `getMultiversion()` Return true if the handle is configured to open all databases for multiversion concurrency control.
`int` `getMutexAlignment()` Return the mutex alignment, in bytes.
`int` `getMutexIncrement()` Return the number of additional mutexes to allocate.
`int` `getMutexTestAndSetSpins()` Return the test-and-set spin count.
`boolean` `getNoLocking()` Return true if the system has been configured to grant all requested mutual exclusion mutexes and database locks without regard for their actual availability.
`boolean` `getNoMMap()` Return true if the system has been configured to copy read-only database files into the local cache instead of potentially mapping them into process memory.
`boolean` `getNoPanic()` Return true if the system has been configured to ignore any panic state in the database environment.
`boolean` `getOverwrite()` Return true if the system has been configured to overwrite files stored in encrypted formats before deleting them.
`PanicHandler` `getPanicHandler()` Return the function to be called if the database environment panics.
`boolean` `getPrivate()` Return true if the database environment is configured to only be accessed by a single process.
`int` `getRegionMemoryInitialSize(RegionResourceType resource)` Return the inital memory configuration for a region resource.
`long` `getRegionMemoryMax()` Return the maximum amount of memory that can be used by shared structures in the main environment region.
`boolean` `getRegister()` Return true if the check for process failure when the environment is opened.
`int` `getReplicationClockskewFast()` Return the current clock skew value for the fastest clock in the group of sites.
`int` `getReplicationClockskewSlow()` Return the current clock skew value for the slowest clock in the group of sites.
`boolean` `getReplicationInMemory()` Return true if internal replication information is stored in memory only.
`long` `getReplicationLimit()` Return the transmit limit in bytes for a single call to `Environment.processReplicationMessage`.
`ReplicationManagerAckPolicy` `getReplicationManagerAckPolicy()` Get the network Ack policy used by the replication manager.
`int` `getReplicationNumSites()` Get the total number of sites configured in this EnvironmentConfig object.
`int` `getReplicationPriority()` Get the current environment's priority.
`int` `getReplicationRequestMax()` Get the threshold for the maximum amount of time that a client waits before requesting retransmission of a missed message.
`int` `getReplicationRequestMin()` Get the threshold for the minimum amount of time that a client waits before requesting retransmission of a missed message.
`ReplicationTransport` `getReplicationTransport()` Return the replication callback function used to transmit data using the replication application's communication infrastructure.
`ReplicationViewHandler` `getReplicationViewHandler()` Return the function name used by replication views to determine whether a database file is replicated to the local site.
`boolean` `getRunFatalRecovery()` Return the handle is configured to run catastrophic recovery on the database environment before opening it for use.
`boolean` `getRunRecovery()` Return the handle is configured to run normal recovery on the database environment before opening it for use.
`long` `getSegmentId()` Return the base segment ID.
`boolean` `getSystemMemory()` Return true if the database environment is configured to allocate memory from system shared memory instead of from memory backed by the filesystem.
`java.io.File` `getTemporaryDirectory()` Return the path of a directory to be used as the location of temporary files.
`int` `getTestAndSetSpins()` Deprecated. replaced by `getMutexTestAndSetSpins()`
`boolean` `getThreaded()` Return true if the handle is configured to be free-threaded.
`boolean` `getTransactional()` Return true if the database environment is configured for transactions.
`int` `getTxnMaxActive()` Return the minimum number of simultaneously active transactions supported by the database environment.
`boolean` `getTxnNoSync()` Return true if the system has been configured to not write or synchronously flush the log on transaction commit.
`boolean` `getTxnNotDurable()` Return true if the system has been configured to not write log records.
`boolean` `getTxnNoWait()` Return true if the transactions have been configured to not wait for locks by default.
`boolean` `getTxnSnapshot()` Return true if the handle is configured to run all transactions at snapshot isolation.
`long` `getTxnTimeout()` Return the database environment transaction timeout value, in microseconds; a timeout of 0 means no timeout is set.
`java.util.Date` `getTxnTimestamp()` Return the time to which recovery will be done, or 0 if recovery will be done to the most current possible date.
`boolean` `getTxnWriteNoSync()` Return true if the system has been configured to write, but not synchronously flush, the log on transaction commit.
`boolean` `getUseEnvironment()` Return true if the database environment is configured to accept information from the process environment when naming files.
`boolean` `getUseEnvironmentRoot()` Return true if the database environment is configured to accept information from the process environment when naming files if the process has appropriate permissions.
`boolean` `getVerbose(VerboseConfig flag)` Return if the database environment is configured to display a given type of verbose information.
`boolean` `getVerboseDeadlock()` Deprecated. replaced by `getVerbose(com.sleepycat.db.VerboseConfig)`
`boolean` `getVerboseRecovery()` Deprecated. replaced by `getVerbose(com.sleepycat.db.VerboseConfig)`
`boolean` `getVerboseRegister()` Deprecated. replaced by `getVerbose(com.sleepycat.db.VerboseConfig)`
`boolean` `getVerboseReplication()` Deprecated. replaced by `getVerbose(com.sleepycat.db.VerboseConfig)`
`boolean` `getVerboseWaitsFor()` Deprecated. replaced by `getVerbose(com.sleepycat.db.VerboseConfig)`
`boolean` `getYieldCPU()` Return true if the system has been configured to yield the processor immediately after each page or mutex acquisition.
`void` `setAllowCreate(boolean allowCreate)` Configure the database environment to create any underlying files, as necessary.
`void` `setBackupHandler(BackupHandler backupHandler)` Sets the `BackupHandler` interface to be used when performing hot backups.
`void` `setBackupReadCount(int count)` Configures the number of pages to read during a hot backup before pausing.
`void` `setBackupReadSleep(int sleep)` Configures the number of microseconds to sleep between batches of reads during a hot backup.
`void` `setBackupSize(int size)` Configures the size of the buffer, in bytes, to read from the database during a hot backup.
`void` `setBackupWriteDirect(boolean writeDirect)` Configures whether direct I/O is used when writing pages to the disk during a hot backup.
`void` `setBlobDir(java.io.File dir)` Sets the path of a directory where blobs are stored.
`void` `setBlobThreshold(int value)` Set the default blob threshold for databases opened in this environment.
`void` `setCacheCount(int cacheCount)` Set the number of shared memory buffer pools, that is, the number of caches.
`void` `setCacheMax(long cacheMax)` Set the maximum cache size in bytes.
`void` `setCachePageSize(int mpPageSize)` Sets the page size used to allocate the hash table and the number of mutexes expected to be needed by the buffer pool.
`void` `setCacheSize(long cacheSize)` Set the size of the shared memory buffer pool, that is, the size of the cache.
`void` `setCacheTableSize(int mpTableSize)` Overrides the calculated hash table size.
`void` `setCDBLockAllDatabases(boolean cdbLockAllDatabases)` Configure Concurrent Data Store applications to perform locking on an environment-wide basis rather than on a per-database basis.
`void` `setCreateDir(java.io.File dir)` Sets the path of a directory to be used as the location to create the access method database files.
`void` `setDirectDatabaseIO(boolean directDatabaseIO)` Configure the database environment to not buffer database files.
`void` `setDirectLogIO(boolean directLogIO)` Configure the database environment to not buffer log files.
`void` `setDsyncDatabases(boolean dsyncDatabases)` Configure the database environment to flush database writes to the backing disk before returning from the write system call, rather than flushing database writes explicitly in a separate system call, as necessary.
`void` `setDsyncLog(boolean dsyncLog)` Configure the database environment to flush log writes to the backing disk before returning from the write system call, rather than flushing log writes explicitly in a separate system call.
`void` `setEncrypted(java.lang.String password)` Set the password used to perform encryption and decryption.
`void` `setErrorHandler(ErrorHandler errorHandler)` Set the function to be called if an error occurs.
`void` `setErrorPrefix(java.lang.String errorPrefix)` Set the prefix string that appears before error messages.
`void` `setErrorStream(java.io.OutputStream errorStream)` Set an OutputStream for displaying error messages.
`void` `setEventHandler(EventHandler eventHandler)` Set an object whose methods are to be called when a triggered event occurs.
`void` `setFeedbackHandler(FeedbackHandler feedbackHandler)` Set an object whose methods are called to provide feedback.
`void` `setHotbackupInProgress(boolean hotbackup)` When a "hot backup" copy of a database environment is taken, this attribute should be configured in the environment prior to copying.
`void` `setInitializeCache(boolean initializeCache)` Configure a shared memory buffer pool in the database environment.
`void` `setInitializeCDB(boolean initializeCDB)` Configure the database environment for the Concurrent Data Store product.
`void` `setInitializeLocking(boolean initializeLocking)` Configure the database environment for locking.
`void` `setInitializeLogging(boolean initializeLogging)` Configure the database environment for logging.
`void` `setInitializeRegions(boolean initializeRegions)` Configure the database environment to page-fault shared regions into memory when initially creating or joining a database environment.
`void` `setInitializeReplication(boolean initializeReplication)` Configure the database environment for replication.
`void` `setInitialMutexes(int initMutexes)` Set the number of mutexes to allocate when an environment is created.
`void` `setJoinEnvironment(boolean joinEnvironment)` Configure the handle to join an existing environment.
`void` `setLockConflicts(byte[][] lockConflicts)` Configure the locking conflicts matrix.
`void` `setLockDetectMode(LockDetectMode lockDetectMode)` Configure if the deadlock detector is to be run whenever a lock conflict occurs.
`void` `setLockDown(boolean lockDown)` Configure the database environment to lock shared environment files and memory-mapped databases into memory.
`void` `setLockPartitions(int partitions)` Set the number of lock table partitions in the Berkeley DB environment.
`void` `setLockTableSize(int lockTableSize)` Set the size for the hash table that contains references to locks.
`void` `setLockTimeout(long lockTimeout)` Set the timeout value for the database environment locks.
`void` `setLogAutoRemove(boolean logAutoRemove)` Configure the system to automatically remove log files that are no longer needed.
`void` `setLogBlobContent(boolean logBlobContent)` Enable full logging of blob data.
`void` `setLogBufferSize(int logBufferSize)` Set the size of the in-memory log buffer, in bytes.
`void` `setLogDirectory(java.io.File logDirectory)` Set the path of a directory to be used as the location of logging files.
`void` `setLogFileMode(int logFileMode)` Set the absolute file mode for created log files.
`void` `setLogInMemory(boolean logInMemory)` If set, maintain transaction logs in memory rather than on disk.
`void` `setLogRecordHandler(LogRecordHandler logRecordHandler)` Set a function to process application-specific log records.
`void` `setLogRegionSize(int logRegionSize)` Set the size of the underlying logging area of the database environment, in bytes.
`void` `setLogZero(boolean logZero)` If set, zero all pages of a log file when that log file is created.
`void` `setMaxLockers(int maxLockers)` Set the maximum number of locking entities supported by the database environment.
`void` `setMaxLockObjects(int maxLockObjects)` Set the maximum number of locked objects supported by the database environment.
`void` `setMaxLocks(int maxLocks)` Set the maximum number of locks supported by the database environment.
`void` `setMaxLogFileSize(int maxLogFileSize)` Set the maximum size of a single file in the log, in bytes.
`void` `setMaxMutexes(int maxMutexes)` Set the total number of mutexes to allocate.
`void` `setMaxOpenFiles(int maxOpenFiles)` Limit the number of file descriptors the library will open concurrently when flushing dirty pages from the cache.
`void` `setMaxWrite(int maxWrite, long maxWriteSleep)` Limit the number of sequential write operations scheduled by the library when flushing dirty pages from the cache.
`void` `setMessageHandler(MessageHandler messageHandler)` Set a function to be called with an informational message.
`void` `setMessageStream(java.io.OutputStream messageStream)` Set an OutputStream for displaying informational messages.
`void` `setMetadataDir(java.io.File dir)` Set the path of a directory to be used as the location to store the persistent metadata files.
`void` `setMMapSize(long mmapSize)` Set the maximum file size, in bytes, for a file to be mapped into the process address space.
`void` `setMode(int mode)` Configure the database environment to use a specific mode when creating underlying files and shared memory segments.
`void` `setMultiversion(boolean multiversion)` Configure the database environment to open all databases that are not using the queue access method for multiversion concurrency control.
`void` `setMutexAlignment(int mutexAlignment)` Set the mutex alignment, in bytes.
`void` `setMutexIncrement(int mutexIncrement)` Increase the number of mutexes to allocate.
`void` `setMutexTestAndSetSpins(int mutexTestAndSetSpins)` Specify the number of times that test-and-set mutexes should spin without blocking.
`void` `setNoLocking(boolean noLocking)` Configure the system to grant all requested mutual exclusion mutexes and database locks without regard for their actual availability.
`void` `setNoMMap(boolean noMMap)` Configure the system to copy read-only database files into the local cache instead of potentially mapping them into process memory.
`void` `setNoPanic(boolean noPanic)` Configure the system to ignore any panic state in the database environment.
`void` `setOverwrite(boolean overwrite)` Configure the system to overwrite files stored in encrypted formats before deleting them.
`void` `setPanicHandler(PanicHandler panicHandler)` Set the function to be called if the database environment panics.
`void` `setPrivate(boolean isPrivate)` Configure the database environment to only be accessed by a single process (although that process may be multithreaded).
`void` `setRegionMemoryInitialSize(RegionResourceType resource, int count)` Assign an initial count for a particular resource within the shared region of Berkeley DB.
`void` `setRegionMemoryMax(long regionMemoryMax)` This method sets the maximum amount of memory to be used by shared structures in the main environment region.
`void` `setRegister(boolean register)` Check if a process has failed while using the database environment, that is, if a process has exited with an open `Environment` handle.
`void` `setReplicationClockskew(int replicationClockskewFast, int replicationClockskewSlow)` Sets the clock skew ratio among replication group members based on the fastest and slowest measurements among the group for use with master leases.
`void` `setReplicationInMemory(boolean replicationInMemory)` If set, store internal replication information in memory only.
`void` `setReplicationLimit(long replicationLimit)` Impose a byte-count limit on the amount of data that will be transmitted from a site in a single call to `Environment.processReplicationMessage`.
`void` `setReplicationManagerAckPolicy(ReplicationManagerAckPolicy repmgrAckPolicy)` Set the network Ack policy used by the replication manager.
`void` `setReplicationNumSites(int replicationNumSites)` Set the total number of sites the replication group is configured for.
`void` `setReplicationPriority(int replicationPriority)` Set the current environment's priority.
`void` `setReplicationRequestMax(int replicationRequestMax)` Set a threshold for the maximum time that a client waits before requesting retransmission of a missing message.
`void` `setReplicationRequestMin(int replicationRequestMin)` Set a threshold for the minimum time that a client waits before requesting retransmission of a missing message.
`void` `setReplicationTransport(int envid, ReplicationTransport replicationTransport)` Initialize the communication infrastructure for a database environment participating in a replicated application.
`void` `setReplicationView(ReplicationViewHandler repViewHandler)` Set the function to be used by replication views to determine whether a database file is replicated to the local site.
`void` `setRunFatalRecovery(boolean runFatalRecovery)` Configure to run catastrophic recovery on this environment before opening it for normal use.
`void` `setRunRecovery(boolean runRecovery)` Configure to run normal recovery on this environment before opening it for normal use.
`void` `setSegmentId(long segmentId)` Specify a base segment ID for database environment shared memory regions created in system memory on VxWorks or systems supporting X/Open-style shared memory interfaces; for example, UNIX systems supporting `shmget` and related System V IPC interfaces.
`void` `setSystemMemory(boolean systemMemory)` Configure the database environment to allocate memory from system shared memory instead of from memory backed by the filesystem.
`void` `setTemporaryDirectory(java.io.File temporaryDirectory)` Set the path of a directory to be used as the location of temporary files.
`void` `setTemporaryDirectory(java.lang.String temporaryDirectory)` Deprecated. replaced by `setTemporaryDirectory(java.io.File)`
`void` `setTestAndSetSpins(int mutexTestAndSetSpins)` Deprecated. replaced by `setMutexTestAndSetSpins(int)`
`void` `setThreaded(boolean threaded)` Configure the handle to be free-threaded; that is, usable by multiple threads within a single address space.
`void` `setTransactional(boolean transactional)` Configure the database environment for transactions.
`void` `setTxnMaxActive(int txnMaxActive)` Configure the database environment to support at least txnMaxActive active transactions.
`void` `setTxnNoSync(boolean txnNoSync)` Configure the system to not write or synchronously flush the log on transaction commit.
`void` `setTxnNotDurable(boolean txnNotDurable)` Configure the system to not write log records.
`void` `setTxnNoWait(boolean txnNoWait)` If a lock is unavailable for any Berkeley DB operation performed in the context of a transaction, cause the operation to throw `LockNotGrantedException` without waiting for the lock.
`void` `setTxnSnapshot(boolean txnSnapshot)` Configure the database environment to run transactions at snapshot isolation by default.
`void` `setTxnTimeout(long txnTimeout)` Set the timeout value for the database environment transactions.
`void` `setTxnTimestamp(java.util.Date txnTimestamp)` Recover to the specified time rather than to the most current possible date.
`void` `setTxnWriteNoSync(boolean txnWriteNoSync)` Configure the system to write, but not synchronously flush, the log on transaction commit.
`void` `setUseEnvironment(boolean useEnvironment)` Configure the database environment to accept information from the process environment when naming files, regardless of the status of the process.
`void` `setUseEnvironmentRoot(boolean useEnvironmentRoot)` Configure the database environment to accept information from the process environment when naming files, if the process has appropriate permissions (for example, users with a user-ID of 0 on UNIX systems).
`void` `setVerbose(VerboseConfig flag, boolean enable)` Display verbose information.
`void` `setVerboseDeadlock(boolean verboseDeadlock)` Deprecated. replaced by `setVerbose(com.sleepycat.db.VerboseConfig, boolean)`
`void` `setVerboseRecovery(boolean verboseRecovery)` Deprecated. replaced by `setVerbose(com.sleepycat.db.VerboseConfig, boolean)`
`void` `setVerboseRegister(boolean verboseRegister)` Deprecated. replaced by `setVerbose(com.sleepycat.db.VerboseConfig, boolean)`
`void` `setVerboseReplication(boolean verboseReplication)` Deprecated. replaced by `setVerbose(com.sleepycat.db.VerboseConfig, boolean)`
`void` `setVerboseWaitsFor(boolean verboseWaitsFor)` Deprecated. replaced by `setVerbose(com.sleepycat.db.VerboseConfig, boolean)`
`void` `setYieldCPU(boolean yieldCPU)` Configure the system to yield the processor immediately after each page or mutex acquisition.

### Methods inherited from class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

### Field Detail

#### DEFAULT

    public static final EnvironmentConfig DEFAULT

### Constructor Detail

#### EnvironmentConfig

    public EnvironmentConfig()

Create an EnvironmentConfig initialized with the system default settings.

### Method Detail

#### setAllowCreate

    public void setAllowCreate(boolean allowCreate)

Configure the database environment to create any underlying files, as necessary.

Parameters:
  `allowCreate` - If true, configure the database environment to create any underlying files, as necessary.

#### getAllowCreate

    public boolean getAllowCreate()

Return true if the database environment is configured to create any underlying files, as necessary.

This method may be called at any time during the life of the application.

Returns:
  True if the database environment is configured to create any underlying files, as necessary.

#### setBlobDir

    public void setBlobDir(java.io.File dir)

Sets the path of a directory where blobs are stored.

The blobs of each `Database` opened within this `Environment` are stored under this directory.

This path can not be set after opening the environment.

Parameters:
  `dir` - The path of a directory where blobs are stored.

#### getBlobDir

    public java.io.File getBlobDir()

Returns the path of a directory where blobs are stored.

The blobs of each `Database` opened within this `Environment` are stored under this directory.

Returns:
  The path of a directory where blobs are stored.

#### setBlobThreshold

    public void setBlobThreshold(int value)

Set the default blob threshold for databases opened in this environment. The blob threshold is the size in bytes which is used to determine when a data item will be stored as a blob.

Any data item that is equal to or larger in size than the threshold value will automatically be stored as a blob.

It is illegal to enable blob in the environment if any of `EnvironmentConfig.setTxnSnapshot`, `EnvironmentConfig.setInitializeReplication`, and `EnvironmentConfig.setMultiversion` is called with true value.

This threshold value can be set any time before and after opening the environment.

Parameters:
  `value` - The size in bytes which is used to determine when a data item will be stored as a blob. If 0, databases opened in the environment will default to never using blob.

#### getBlobThreshold

    public int getBlobThreshold()

Return the environment wide default blob threshold value. The blob threshold is the size in bytes which is used to determine when a data item will be stored as a blob.

Returns:
  The blob threshold value in bytes beyond which data items are stored as blobs. If 0, databases opened in the environment will default to never using blobs.

#### setCacheSize

    public void setCacheSize(long cacheSize)

Set the size of the shared memory buffer pool, that is, the size of the cache.

The cache should be the size of the normal working data set of the application, with some small amount of additional memory for unusual situations. (Note: the working set is not the same as the number of pages accessed simultaneously, and is usually much larger.)

The default cache size is 256KB, and may not be specified as less than 20KB. Any cache size less than 500MB is automatically increased by 25% to account for buffer pool overhead; cache sizes larger than 500MB are used as specified. The current maximum size of a single cache is 4GB. (All sizes are in powers-of-two, that is, 256KB is 2^18 not 256,000.)

The database environment's cache size may also be set using the environment's DB_CONFIG file. The syntax of the entry in that file is a single line with the string "set_cachesize", one or more whitespace characters, and the cache size specified in three parts: the gigabytes of cache, the additional bytes of cache, and the number of caches, also separated by whitespace characters. For example, "set_cachesize 2 524288000 3" would create a 2.5GB logical cache, split between three physical caches. Because the DB_CONFIG file is read when the database environment is opened, it will silently overrule configuration done before that time.

This method configures a database environment, including all threads of control accessing the database environment, not only the operations performed using a specified `Environment` handle.

This method may not be called after the environment has been opened. If joining an existing database environment, any information specified to this method will be ignored.

This method may be called at any time during the life of the application.

Parameters:
  `cacheSize` - The size of the shared memory buffer pool, that is, the size of the cache.

Throws:
  `DatabaseException` - if a failure occurs.

#### getCacheSize

    public long getCacheSize()

Return the size of the shared memory buffer pool, that is, the cache.

This method may be called at any time during the life of the application.

Returns:
  The size of the shared memory buffer pool, that is, the cache.

#### setCacheMax

    public void setCacheMax(long cacheMax)

Set the maximum cache size in bytes. The specified size is rounded to the nearest multiple of the cache region size, which is the initial cache size divded by the number of regions specified to `setCacheCount(int)`. If no value is specified, it defaults to the initial cache size.

#### getCacheMax

    public long getCacheMax()

Return the maximum size of the cache.

This method may be called at any time during the life of the application.

Returns:
  The maximum size of the cache.

#### setCacheCount

    public void setCacheCount(int cacheCount)

Set the number of shared memory buffer pools, that is, the number of caches.

It is possible to specify caches larger than 4GB and/or large enough they cannot be allocated contiguously on some architectures. For example, some releases of Solaris limit the amount of memory that may be allocated contiguously by a process. This method allows applications to break the cache broken up into a number of equally sized, separate pieces of memory.

The database environment's cache size may also be set using the environment's DB_CONFIG file. The syntax of the entry in that file is a single line with the string "set_cachesize", one or more whitespace characters, and the cache size specified in three parts: the gigabytes of cache, the additional bytes of cache, and the number of caches, also separated by whitespace characters. For example, "set_cachesize 2 524288000 3" would create a 2.5GB logical cache, split between three physical caches. Because the DB_CONFIG file is read when the database environment is opened, it will silently overrule configuration done before that time.

This method configures a database environment, including all threads of control accessing the database environment, not only the operations performed using a specified `Environment` handle.

This method may not be called after the environment has been opened. If joining an existing database environment, any information specified to this method will be ignored.

This method may be called at any time during the life of the application.

Parameters:
  `cacheCount` - The number of shared memory buffer pools, that is, the number of caches.

Throws:
  `DatabaseException` - if a failure occurs.

#### getCacheCount

    public int getCacheCount()

Return the number of shared memory buffer pools, that is, the number of cache regions.

This method may be called at any time during the life of the application.

Returns:
  The number of shared memory buffer pools, that is, the number of cache regions.

#### setCDBLockAllDatabases

    public void setCDBLockAllDatabases(boolean cdbLockAllDatabases)

Configure Concurrent Data Store applications to perform locking on an environment-wide basis rather than on a per-database basis.

This method only affects the specified `Environment` handle (and any other library handles opened within the scope of that handle). For consistent behavior across the environment, all `Environment` handles opened in the database environment must either call this method or the configuration should be specified in the database environment's DB_CONFIG configuration file.

This method may not be called after the environment has been opened.

Parameters:
  `cdbLockAllDatabases` - If true, configure Concurrent Data Store applications to perform locking on an environment-wide basis rather than on a per-database basis.

#### getCDBLockAllDatabases

    public boolean getCDBLockAllDatabases()

Return true if the Concurrent Data Store applications are configured to perform locking on an environment-wide basis rather than on a per-database basis.

This method may be called at any time during the life of the application.

Returns:
  True if the Concurrent Data Store applications are configured to perform locking on an environment-wide basis rather than on a per-database basis.

#### setCreateDir

    public void setCreateDir(java.io.File dir)

Sets the path of a directory to be used as the location to create the access method database files. When the open function is used to create a file it will be created relative to this path.

#### getCreateDir

    public java.io.File getCreateDir()

Returns the path of a directory to be used as the location to create the access method database files.

Returns:
  The path of a directory to be used as the location to create the access method database files.

#### addDataDir

    public void addDataDir(java.io.File dataDir)

Set the path of a directory to be used as the location of the access method database files.

Paths specified to `Environment.openDatabase` and `Environment.openSecondaryDatabase` will be searched relative to this path. Paths set using this method are additive, and specifying more than one will result in each specified directory being searched for database files. If any directories are specified, created database files will always be created in the first path specified.

If no database directories are specified, database files must be named either by absolute paths or relative to the environment home directory.

The database environment's data directories may also be set using the environment's DB_CONFIG file. The syntax of the entry in that file is a single line with the string "set_data_dir", one or more whitespace characters, and the directory name.

This method configures only operations performed using a single a `Environment` handle, not an entire database environment.

This method may not be called after the environment has been opened. If joining an existing database environment, the information specified to this method must be consistent with the existing environment or corruption can occur.

Parameters:
  `dataDir` - A directory to be used as a location for database files. On Windows platforms, this argument will be interpreted as a UTF-8 string, which is equivalent to ASCII for Latin characters.

#### addDataDir

    public void addDataDir(java.lang.String dataDir)

Deprecated. replaced by `addDataDir(java.io.File)`

#### getDataDirs

    public java.io.File[] getDataDirs()

Return the array of data directories.

This method may be called at any time during the life of the application.

Returns:
  The array of data directories.

#### setDirectDatabaseIO

    public void setDirectDatabaseIO(boolean directDatabaseIO)

Configure the database environment to not buffer database files.

This is intended to avoid to avoid double caching.

This method only affects the specified `Environment` handle (and any other library handles opened within the scope of that handle). For consistent behavior across the environment, all `Environment` handles opened in the database environment must either call this method or the configuration should be specified in the database environment's DB_CONFIG configuration file.

This method may be called at any time during the life of the application.

Parameters:
  `directDatabaseIO` - If true, configure the database environment to not buffer database files.

#### getDirectDatabaseIO

    public boolean getDirectDatabaseIO()

Return true if the database environment has been configured to not buffer database files.

This method may be called at any time during the life of the application.

Returns:
  True if the database environment has been configured to not buffer database files.

#### setDirectLogIO

    public void setDirectLogIO(boolean directLogIO)

Configure the database environment to not buffer log files.

This is intended to avoid to avoid double caching.

This method only affects the specified `Environment` handle (and any other library handles opened within the scope of that handle). For consistent behavior across the environment, all `Environment` handles opened in the database environment must either call this method or the configuration should be specified in the database environment's DB_CONFIG configuration file.

This method may be called at any time during the life of the application.

Parameters:
  `directLogIO` - If true, configure the database environment to not buffer log files.

#### getDirectLogIO

    public boolean getDirectLogIO()

Return true if the database environment has been configured to not buffer log files.

This method may be called at any time during the life of the application.

Returns:
  True if the database environment has been configured to not buffer log files.

#### setDsyncDatabases

    public void setDsyncDatabases(boolean dsyncDatabases)

Configure the database environment to flush database writes to the backing disk before returning from the write system call, rather than flushing database writes explicitly in a separate system call, as necessary.

This is only available on some systems (for example, systems supporting the m4_posix1_name standard O_DSYNC flag, or systems supporting the Win32 FILE_FLAG_WRITE_THROUGH flag). This flag may result in inaccurate file modification times and other file-level information for Berkeley DB database files. This flag will almost certainly result in a performance decrease on most systems. This flag is only applicable to certain filesysystem (for example, the Veritas VxFS filesystem), where the filesystem's support for trickling writes back to stable storage behaves badly (or more likely, has been misconfigured).

This method only affects the specified `Environment` handle (and any other library handles opened within the scope of that handle). For consistent behavior across the environment, all `Environment` handles opened in the database environment must either call this method or the configuration should be specified in the database environment's DB_CONFIG configuration file.

This method may be called at any time during the life of the application.

Parameters:
  `dsyncDatabases` - If true, configure the database environment to flush database writes to the backing disk before returning from the write system call, rather than flushing log writes explicitly in a separate system call.

#### getDsyncDatabases

    public boolean getDsyncDatabases()

Return true if the database environment has been configured to flush database writes to the backing disk before returning from the write system call.

This method may be called at any time during the life of the application.

Returns:
  True if the database environment has been configured to flush database writes to the backing disk before returning from the write system call.

#### setDsyncLog

    public void setDsyncLog(boolean dsyncLog)

Configure the database environment to flush log writes to the backing disk before returning from the write system call, rather than flushing log writes explicitly in a separate system call.

This configuration is only available on some systems (for example, systems supporting the POSIX standard O_DSYNC flag, or systems supporting the Win32 FILE_FLAG_WRITE_THROUGH flag). This configuration may result in inaccurate file modification times and other file-level information for Berkeley DB log files. This configuration may offer a performance increase on some systems and a performance decrease on others.

This method only affects the specified `Environment` handle (and any other library handles opened within the scope of that handle). For consistent behavior across the environment, all `Environment` handles opened in the database environment must either call this method or the configuration should be specified in the database environment's DB_CONFIG configuration file.

This method may be called at any time during the life of the application.

Parameters:
  `dsyncLog` - If true, configure the database environment to flush log writes to the backing disk before returning from the write system call, rather than flushing log writes explicitly in a separate system call.

#### getDsyncLog

    public boolean getDsyncLog()

Return true if the database environment has been configured to flush log writes to the backing disk before returning from the write system call.

This method may be called at any time during the life of the application.

Returns:
  True if the database environment has been configured to flush log writes to the backing disk before returning from the write system call.

#### setEncrypted

    public void setEncrypted(java.lang.String password)

Set the password used to perform encryption and decryption.

Berkeley DB uses the Rijndael/AES (also known as the Advanced Encryption Standard and Federal Information Processing Standard (FIPS) 197) algorithm for encryption or decryption.

#### getEncrypted

    public boolean getEncrypted()

Return the database environment has been configured to perform encryption.

This method may be called at any time during the life of the application.

Returns:
  The database environment has been configured to perform encryption.

#### setErrorHandler

    public void setErrorHandler(ErrorHandler errorHandler)

Set the function to be called if an error occurs.

When an error occurs in the Berkeley DB library, an exception is thrown. In some cases, however, the error information returned to the application may be insufficient to completely describe the cause of the error, especially during initial application debugging.

The `EnvironmentConfig.setErrorHandler` and `DatabaseConfig.setErrorHandler` methods are used to enhance the mechanism for reporting error messages to the application. In some cases, when an error occurs, Berkeley DB will invoke the ErrorHandler's object error method. It is up to this method to display the error message in an appropriate manner.

Alternatively, applications can use `EnvironmentConfig.setErrorStream` and `DatabaseConfig.setErrorStream` to display the additional information via an output stream. Applications should not mix these approaches.

This error-logging enhancement does not slow performance or significantly increase application size, and may be run during normal operation as well as during application debugging.

This method may be called at any time during the life of the application.

Parameters:
  `errorHandler` - The function to be called if an error occurs.

#### getErrorHandler

    public ErrorHandler getErrorHandler()

Return the function to be called if an error occurs.

This method may be called at any time during the life of the application.

Returns:
  The function to be called if an error occurs.

#### setErrorPrefix

    public void setErrorPrefix(java.lang.String errorPrefix)

Set the prefix string that appears before error messages.

This method may be called at any time during the life of the application.

Parameters:
  `errorPrefix` - The prefix string that appears before error messages.

#### getErrorPrefix

    public java.lang.String getErrorPrefix()

Return the prefix string that appears before error messages.

This method may be called at any time during the life of the application.

Returns:
  The prefix string that appears before error messages.

#### setErrorStream

    public void setErrorStream(java.io.OutputStream errorStream)

Set an OutputStream for displaying error messages.

When an error occurs in the Berkeley DB library, an exception is thrown. In some cases, however, the error information returned to the application may be insufficient to completely describe the cause of the error, especially during initial application debugging.

The `EnvironmentConfig.setErrorStream` and `DatabaseConfig.setErrorStream` methods are used to enhance the mechanism for reporting error messages to the application by setting a OutputStream to be used for displaying additional Berkeley DB error messages. In some cases, when an error occurs, Berkeley DB will output an additional error message to the specified stream.

The error message will consist of the prefix string and a colon (":") (if a prefix string was previously specified using `EnvironmentConfig.setErrorPrefix` or `DatabaseConfig.setErrorPrefix`), an error string, and a trailing newline character.

Setting errorStream to null unconfigures the interface.

Alternatively, applications can use `EnvironmentConfig.setErrorHandler` and `DatabaseConfig.setErrorHandler` to capture the additional error information in a way that does not use output streams. Applications should not mix these approaches.

This error-logging enhancement does not slow performance or significantly increase application size, and may be run during normal operation as well as during application debugging.

This method may be called at any time during the life of the application.

Parameters:
  `errorStream` - The application-specified OutputStream for error messages.

#### getErrorStream

    public java.io.OutputStream getErrorStream()

Return the OutputStream for displaying error messages.

This method may be called at any time during the life of the application.

Returns:
  The OutputStream for displaying error messages.

#### getBackupReadCount

    public int getBackupReadCount()

Return the number of pages to read before pausing during the hot backup.

Returns:
  The number of pages to read before pausing.

#### setBackupReadCount

    public void setBackupReadCount(int count)

Configures the number of pages to read during a hot backup before pausing.

Increasing this value increases the amount of I/O the backup process performs for any given time interval. If your application is already heavily I/O bound, setting this value to a lower number may help to improve your overall data throughput by reducing the I/O demands placed on your system. By default, all pages are read without a pause.

This method configures the behavior of the `Environment.backup` and `Environment.backupDatabase` methods. It may be called at any time during the life of the application.

Parameters:
  `count` - The number of pages to read before pausing.

#### getBackupReadSleep

    public int getBackupReadSleep()

Return the number of microseconds to sleep between batches of reads during a hot backup.

Returns:
  The number of microseconds to sleep.

#### setBackupReadSleep

    public void setBackupReadSleep(int sleep)

Configures the number of microseconds to sleep between batches of reads during a hot backup.

Increasing this value decreases the amount of I/O the backup process performs for any given time interval. If your application is already heavily I/O bound, setting this value to a higher number may help to improve your overall data throughput by reducing the I/O demands placed on your system.

This method configures the behavior of the `Environment.backup` and `Environment.backupDatabase` methods. It may be called at any time during the life of the application.

Parameters:
  `sleep` - The number of microseconds to sleep.

#### getBackupSize

    public int getBackupSize()

Return the size of the buffer, in megabytes, to read from the database during a hot backup.

Returns:
  The size of the buffer in megabytes.

#### setBackupSize

    public void setBackupSize(int size)

Configures the size of the buffer, in bytes, to read from the database during a hot backup.

This method configures the behavior of the `Environment.backup` and `Environment.backupDatabase` methods. It may be called at any time during the life of the application.

Parameters:
  `size` - The size of the buffer in bytes. Default is 1 megabyte.

#### getBackupWriteDirect

    public boolean getBackupWriteDirect()

Return return true if direct I/O is used when writing pages to the disk during a hot backup.

Returns:
  The environment's current direct I/O for hot backup setting.

#### setBackupWriteDirect

    public void setBackupWriteDirect(boolean writeDirect)

Configures whether direct I/O is used when writing pages to the disk during a hot backup.

For some environments, direct I/O can provide faster write throughput, but usually it is slower because the OS buffer pool offers asynchronous activity.

This method configures the behavior of the `Environment.backup` and `Environment.backupDatabase` methods. It may be called at any time during the life of the application.

Parameters:
  `writeDirect` - If true, use direct I/O when writing database pages; if false, do not use direct I/O.

#### setBackupHandler

    public void setBackupHandler(BackupHandler backupHandler)

Sets the `BackupHandler` interface to be used when performing hot backups.

The `BackupHandler` interface is used to override the default behavior used by the `Environment.backup` and `Environment.backupDatabase` methods.

This method may be called at any time during the life of the application.

This method configures operations performed using the Environment handle, not all operations performed on the underlying database environment.

Parameters:
  `backupHandler` - The `BackupHandler` interface to use when performing hot backups.

#### getBackupHandler

    public BackupHandler getBackupHandler()

Return the `BackupHandler` used to override default hot backup behavior.

Returns:
  The `BackupHandler` interface to use when performing hot backups.

#### setEventHandler

    public void setEventHandler(EventHandler eventHandler)

Set an object whose methods are to be called when a triggered event occurs.

Parameters:
  `eventHandler` - An object whose methods are called when event callbacks are initiated from within Berkeley DB.

#### getEventHandler

    public EventHandler getEventHandler()

Return the object's methods to be called when a triggered event occurs.

This method may be called at any time during the life of the application.

Returns:
  The object's methods to be called when a triggered event occurs.

#### setFeedbackHandler

    public void setFeedbackHandler(FeedbackHandler feedbackHandler)

Set an object whose methods are called to provide feedback.

Some operations performed by the Berkeley DB library can take non-trivial amounts of time. This method can be used by applications to monitor progress within these operations. When an operation is likely to take a long time, Berkeley DB will call the object's methods with progress information.

It is up to the object's methods to display this information in an appropriate manner.

This method configures only operations performed using a single a `Environment` handle

This method may be called at any time during the life of the application.

Parameters:
  `feedbackHandler` - An object whose methods are called to provide feedback.

#### getFeedbackHandler

    public FeedbackHandler getFeedbackHandler()

Return the object's methods to be called to provide feedback.

This method may be called at any time during the life of the application.

Returns:
  The object's methods to be called to provide feedback.

#### setHotbackupInProgress

    public void setHotbackupInProgress(boolean hotbackup)

When a "hot backup" copy of a database environment is taken, this attribute should be configured in the environment prior to copying. If any transactions with the bulk insert optimization enabled (i.e., started with the Bulk configuration attribute) are in progress, setting the HotBackupInProgress attribute will force a checkpoint in the environment. After this attribute is set, the bulk insert optimization is disabled, until the attribute is reset. Using this protocol allows a hot backup procedure to make a consistent copy of the database even when bulk transactions are ongoing. Please see the discussion of hot backups in the Getting Started With Transactions Guide, and the description of the Bulk attribute in `TransactionConfig` for more information.

Parameters:
  `hotbackup` - If true, set the HotBackupInProgress attribute; if false, reset it.

#### getHotbackupInProgress

    public boolean getHotbackupInProgress()

Return true if a "hot backup" is in progress.

Returns:
  The environment's current HotBackupInProgress setting.

#### setInitializeCache

    public void setInitializeCache(boolean initializeCache)

Configure a shared memory buffer pool in the database environment.

This subsystem should be used whenever an application is using any Berkeley DB access method.

Parameters:
  `initializeCache` - If true, configure a shared memory buffer pool in the database environment.

#### getInitializeCache

    public boolean getInitializeCache()

Return true if the database environment is configured with a shared memory buffer pool.

This method may be called at any time during the life of the application.

Returns:
  True if the database environment is configured with a shared memory buffer pool.

#### setInitializeCDB

    public void setInitializeCDB(boolean initializeCDB)

Configure the database environment for the Concurrent Data Store product.

In this mode, Berkeley DB provides multiple reader/single writer access. The only other subsystem that should be specified for this handle is a cache.

Parameters:
  `initializeCDB` - If true, configure the database environment for the Concurrent Data Store product.

#### getInitializeCDB

    public boolean getInitializeCDB()

Return true if the database environment is configured for the Concurrent Data Store product.

This method may be called at any time during the life of the application.

Returns:
  True if the database environment is configured for the Concurrent Data Store product.

#### setInitializeLocking

    public void setInitializeLocking(boolean initializeLocking)

Configure the database environment for locking.

Locking should be used when multiple processes or threads are going to be reading and writing a database, so they do not interfere with each other. If all threads are accessing the database(s) read-only, locking is unnecessary. When locking is configured, it is usually necessary to run a deadlock detector, as well.

Parameters:
  `initializeLocking` - If true, configure the database environment for locking.

#### getInitializeLocking

    public boolean getInitializeLocking()

Return true if the database environment is configured for locking.

This method may be called at any time during the life of the application.

Returns:
  True if the database environment is configured for locking.

#### setInitializeLogging

    public void setInitializeLogging(boolean initializeLogging)

Configure the database environment for logging.

Logging should be used when recovery from application or system failure is necessary. If the log region is being created and log files are already present, the log files are reviewed; subsequent log writes are appended to the end of the log, rather than overwriting current log entries.

Parameters:
  `initializeLogging` - If true, configure the database environment for logging.

#### getInitializeLogging

    public boolean getInitializeLogging()

Return true if the database environment is configured for logging.

This method may be called at any time during the life of the application.

Returns:
  True if the database environment is configured for logging.

#### setInitializeRegions

    public void setInitializeRegions(boolean initializeRegions)

Configure the database environment to page-fault shared regions into memory when initially creating or joining a database environment.

In some applications, the expense of page-faulting the underlying shared memory regions can affect performance. For example, if the page-fault occurs while holding a lock, other lock requests can convoy, and overall throughput may decrease. This method configures Berkeley DB to page-fault shared regions into memory when initially creating or joining a database environment. In addition, Berkeley DB will write the shared regions when creating an environment, forcing the underlying virtual memory and filesystems to instantiate both the necessary memory and the necessary disk space. This can also avoid out-of-disk space failures later on.

This method only affects the specified `Environment` handle (and any other library handles opened within the scope of that handle). For consistent behavior across the environment, all `Environment` handles opened in the database environment must either call this method or the configuration should be specified in the database environment's DB_CONFIG configuration file.

This method may be called at any time during the life of the application.

Parameters:
  `initializeRegions` - If true, configure the database environment to page-fault shared regions into memory when initially creating or joining a database environment.

#### getInitializeRegions

    public boolean getInitializeRegions()

Return true if the database environment has been configured to page-fault shared regions into memory when initially creating or joining a database environment.

This method may be called at any time during the life of the application.

Returns:
  True if the database environment has been configured to page-fault shared regions into memory when initially creating or joining a database environment.

#### setInitializeReplication

    public void setInitializeReplication(boolean initializeReplication)

Configure the database environment for replication.

Replication requires both locking and transactions.

Parameters:
  `initializeReplication` - If true, configure the database environment for replication.

#### getInitializeReplication

    public boolean getInitializeReplication()

Return true if the database environment is configured for replication.

This method may be called at any time during the life of the application.

Returns:
  True if the database environment is configured for replication.

#### setJoinEnvironment

    public void setJoinEnvironment(boolean joinEnvironment)

Configure the handle to join an existing environment.

This option allows applications to join an existing environment without knowing which subsystems the environment supports.

Parameters:
  `joinEnvironment` - If true, configure the handle to join an existing environment.

#### getJoinEnvironment

    public boolean getJoinEnvironment()

Return the handle is configured to join an existing environment.

This method may be called at any time during the life of the application.

Returns:
  The handle is configured to join an existing environment.

#### setLockConflicts

    public void setLockConflicts(byte[][] lockConflicts)

Configure the locking conflicts matrix.

If the locking conflicts matrix is never configured, a standard conflicts array is used.

This method configures a database environment, including all threads of control accessing the database environment, not only the operations performed using a specified `Environment` handle.

This method may not be called after the environment has been opened. If joining an existing database environment, any information specified to this method will be ignored.

Parameters:
  `lockConflicts` - The locking conflicts matrix. A non-0 value for an array element indicates the requested_mode and held_mode conflict:

  >             lockConflicts[requested_mode][held_mode]

  The not-granted mode must be represented by 0.

#### getLockConflicts

    public byte[][] getLockConflicts()

Return the locking conflicts matrix.

This method may be called at any time during the life of the application.

Returns:
  The locking conflicts matrix.

#### setLockDetectMode

    public void setLockDetectMode(LockDetectMode lockDetectMode)

Configure if the deadlock detector is to be run whenever a lock conflict occurs.

The database environment's deadlock detector configuration may also be set using the environment's DB_CONFIG file. The syntax of the entry in that file is a single line with the string "set_lk_detect", one or more whitespace characters, and the method `detect` parameter as a string; for example, "set_lk_detect DB_LOCK_OLDEST". Because the DB_CONFIG file is read when the database environment is opened, it will silently overrule configuration done before that time.

This method configures a database environment, including all threads of control accessing the database environment, not only the operations performed using a specified `Environment` handle.

Although the method may be called at any time during the life of the application, it should normally be called before opening the database environment.

Parameters:
  `lockDetectMode` - The lock request(s) to be rejected. As transactions acquire locks on behalf of a single locker ID, rejecting a lock request associated with a transaction normally requires the transaction be aborted.

#### getLockDetectMode

    public LockDetectMode getLockDetectMode()

Return true if the deadlock detector is configured to run whenever a lock conflict occurs.

This method may be called at any time during the life of the application.

Returns:
  True if the deadlock detector is configured to run whenever a lock conflict occurs.

#### setLockDown

    public void setLockDown(boolean lockDown)

Configure the database environment to lock shared environment files and memory-mapped databases into memory.

Parameters:
  `lockDown` - If true, configure the database environment to lock shared environment files and memory-mapped databases into memory.

#### getLockDown

    public boolean getLockDown()

Return true if the database environment is configured to lock shared environment files and memory-mapped databases into memory.

This method may be called at any time during the life of the application.

Returns:
  True if the database environment is configured to lock shared environment files and memory-mapped databases into memory.

#### setLockTimeout

    public void setLockTimeout(long lockTimeout)

Set the timeout value for the database environment locks.

Lock timeouts are checked whenever a thread of control blocks on a lock or when deadlock detection is performed. The lock may have been requested explicitly through the Lock subsystem interfaces, or it may be a lock requested by the database access methods underlying the application. As timeouts are only checked when the lock request first blocks or when deadlock detection is performed, the accuracy of the timeout depends on how often deadlock detection is performed.

Timeout values specified for the database environment may be overridden on a per-lock basis by `Environment.lockVector`.

This method configures a database environment, including all threads of control accessing the database environment, not only the operations performed using a specified `Environment` handle.

This method may be called at any time during the life of the application.

Parameters:
  `lockTimeout` - The timeout value, specified as an unsigned 32-bit number of microseconds, limiting the maximum timeout to roughly 71 minutes.

Throws:
  `java.lang.IllegalArgumentException` - if an invalid parameter was specified.

  `DatabaseException` - if a failure occurs.

#### getLockTimeout

    public long getLockTimeout()

Return the database environment lock timeout value, in microseconds; a timeout of 0 means no timeout is set.

This method may be called at any time during the life of the application.

Returns:
  The database environment lock timeout value, in microseconds; a timeout of 0 means no timeout is set.

#### setLogAutoRemove

    public void setLogAutoRemove(boolean logAutoRemove)

Configure the system to automatically remove log files that are no longer needed.

Automatic log file removal is likely to make catastrophic recovery impossible.

Replication Manager applications operate in a group-aware manner for log file removal, and automatic log file removal simplifies the application.

Replication Base API applications will rarely want to configure automatic log file removal as it increases the likelihood a master will be unable to satisfy a client's request for a recent log record.

This method configures a database environment, including all threads of control accessing the database environment, not only the operations performed using a specified `Environment` handle.

This method may be called at any time during the life of the application.

Parameters:
  `logAutoRemove` - If true, configure the system to automatically remove log files that are no longer needed.

#### getLogAutoRemove

    public boolean getLogAutoRemove()

Return true if the system has been configured to to automatically remove log files that are no longer needed.

This method may be called at any time during the life of the application.

Returns:
  True if the system has been configured to to automatically remove log files that are no longer needed.

#### setLogBlobContent

    public void setLogBlobContent(boolean logBlobContent)

Enable full logging of blob data. Required for HA and the hotbackup utility.

Parameters:
  `logBlobContent` - If true, enable full logging of blob data.

#### getLogBlobContent

    public boolean getLogBlobContent()

Return true if full logging of blob data is enabled.

This method may be called at any time during the life of the application.

Returns:
  True if full logging of blob data is enabled.

#### setLogInMemory

    public void setLogInMemory(boolean logInMemory)

If set, maintain transaction logs in memory rather than on disk. This means that transactions exhibit the ACI (atomicity, consistency, and isolation) properties, but not D (durability); that is, database integrity will be maintained, but if the application or system fails, integrity will not persist. All database files must be verified and/or restored from a replication group master or archival backup after application or system failure.

When in-memory logs are configured and no more log buffer space is available, Berkeley DB methods will throw a `DatabaseException`. When choosing log buffer and file sizes for in-memory logs, applications should ensure the in-memory log buffer size is large enough that no transaction will ever span the entire buffer, and avoid a state where the in-memory buffer is full and no space can be freed because a transaction that started in the first log "file" is still active.

This method configures a database environment, including all threads of control accessing the database environment, not only the operations performed using a specified `Environment` handle.

This method may not be called after the environment has been opened. If joining an existing database environment, any information specified to this method will be ignored.

Parameters:
  `logInMemory` - If true, maintain transaction logs in memory rather than on disk.

#### getLogInMemory

    public boolean getLogInMemory()

Return true if the database environment is configured to maintain transaction logs in memory rather than on disk.

This method may be called at any time during the life of the application.

Returns:
  True if the database environment is configured to maintain transaction logs in memory rather than on disk.

#### setLogRecordHandler

    public void setLogRecordHandler(LogRecordHandler logRecordHandler)

Set a function to process application-specific log records.

This method configures only operations performed using a single a `Environment` handle, not an entire database environment.

This method may not be called after the environment has been opened. If joining an existing database environment, the information specified to this method must be consistent with the existing environment or corruption can occur.

Parameters:
  `logRecordHandler` - The handler for application-specific log records.

#### getLogRecordHandler

    public LogRecordHandler getLogRecordHandler()

Return the handler for application-specific log records.

This method may be called at any time during the life of the application.

Returns:
  The handler for application-specific log records.

#### setLogZero

    public void setLogZero(boolean logZero)

If set, zero all pages of a log file when that log file is created. This has been shown to provide greater transaction throughput in some environments. The log file will be zeroed by the thread which needs to re-create the new log file. Other threads may not write to the log file while this is happening.

This method configures the database environment, including all threads of control accessing the database environment.

This method may not be called after the environment has been opened.

Parameters:
  `logZero` - If true, zero all pages of new log files upon their creation.

#### getLogZero

    public boolean getLogZero()

Return true if the database environment is configured to zero all pages of new log files upon their creation.

This method may be called at any time during the life of the application.

Returns:
  True if the database environment is configured to pre-zero log pages.

#### getRegionMemoryInitialSize

    public int getRegionMemoryInitialSize(RegionResourceType resource)

Return the inital memory configuration for a region resource.

Parameters:
  `resource` - The resource type to get initial sizing for.

Returns:
  The initial amount of memory allocated for the requested resource.

#### setRegionMemoryInitialSize

    public void setRegionMemoryInitialSize(RegionResourceType resource,
                                  int count)

Assign an initial count for a particular resource within the shared region of Berkeley DB. The shared region is used to hold resources that are shared amongst processes in Berkeley DB. The default values are generally satisfactory.

Parameters:
  `resource` - The resource type to configure.
  `count` - The initial number of objects of a particular type to allocate.

#### getRegionMemoryMax

    public long getRegionMemoryMax()

Return the maximum amount of memory that can be used by shared structures in the main environment region.

Returns:
  The maximum amount of memory that could be used by the main region.

#### setRegionMemoryMax

    public void setRegionMemoryMax(long regionMemoryMax)

This method sets the maximum amount of memory to be used by shared structures in the main environment region. These are the structures other than mutexes and the page cache (memory pool). If the region files are in memory mapped files, or if DB_PRIVATE is specified, the memory specified by this method is not allocated completely at startup. As memory is needed, the shared region will be extended or, in the case of DB_PRIVATE, more memory will be allocated using the system malloc call. For memory mapped files, a mapped region will be allocated to this size but the underlying file will only be allocated sufficient memory to hold the initial allocation of shared memory structures as set by `EnvironmentConfig.setRegionMemoryInitialSize`.

If no memory maximum is specified then it is calculated from defaults, initial settings or (deprecated) maximum settings of the various shared structures. In the case of environments created with DB_PRIVATE, no maximum need be set and the shared structure allocation will grow as needed until the process memory limit is exhausted.

Parameters:
  `regionMemoryMax` - The total amount of memory that can be used by the main region.

#### setReplicationInMemory

    public void setReplicationInMemory(boolean replicationInMemory)

If set, store internal replication information in memory only. By default, replication creates files in the environment home directory to preserve some internal information. If this configuration flag is turned on, replication only stores this internal information in-memory and cannot keep persistent state across a site crash or reboot.

This configuration flag can only be turned on before the environment is opened. Its value cannot be changed while the environment is open.

Parameters:
  `replicationInMemory` - If true, store internal replication information in memory only.

#### getReplicationInMemory

    public boolean getReplicationInMemory()

Return true if internal replication information is stored in memory only.

This method may be called at any time during the life of the application.

Returns:
  True if internal replication information is stored in memory only.

#### setReplicationManagerAckPolicy

    public void setReplicationManagerAckPolicy(ReplicationManagerAckPolicy repmgrAckPolicy)

Set the network Ack policy used by the replication manager.

Parameters:
  `repmgrAckPolicy` - The network Ack policy used by the replication manager.

#### getReplicationManagerAckPolicy

    public ReplicationManagerAckPolicy getReplicationManagerAckPolicy()

Get the network Ack policy used by the replication manager.

Returns:
  The network Ack policy used by the replication manager.

#### addReplicationManagerSite

    public void addReplicationManagerSite(ReplicationManagerSiteConfig repmgrSiteConfig)

Configure a site in a replication group. This could be called more than once, to set local site and remote sites.

Parameters:
  `repmgrSiteConfig` - The configuration of a site site

#### setLockPartitions

    public void setLockPartitions(int partitions)

Set the number of lock table partitions in the Berkeley DB environment.

#### getLockPartitions

    public int getLockPartitions()

Returns the number of lock table partitions in the Berkeley DB environment.

#### setMaxLocks

    public void setMaxLocks(int maxLocks)

Set the maximum number of locks supported by the database environment.

This value is used during environment creation to estimate how much space to allocate for various lock-table data structures. The default value is 1000 locks.

The database environment's maximum number of locks may also be set using the environment's DB_CONFIG file. The syntax of the entry in that file is a single line with the string "set_lk_max_locks", one or more whitespace characters, and the number of locks. Because the DB_CONFIG file is read when the database environment is opened, it will silently overrule configuration done before that time.

This method configures a database environment, including all threads of control accessing the database environment, not only the operations performed using a specified `Environment` handle.

This method may not be called after the environment has been opened. If joining an existing database environment, any information specified to this method will be ignored.

Parameters:
  `maxLocks` - The maximum number of locks supported by the database environment.

#### getMaxLocks

    public int getMaxLocks()

Return the maximum number of locks.

This method may be called at any time during the life of the application.

Returns:
  The maximum number of locks.

#### setLockTableSize

    public void setLockTableSize(int lockTableSize)

Set the size for the hash table that contains references to locks. It's important to make this large enough so that there is not increased contention in the system as it grows.

This method may not be called after the environment has been opened. If joining an existing database environment, any information specified to this method will be ignored.

Parameters:
  `lockTableSize` - The size of the hash table to allocate.

#### getLockTableSize

    public int getLockTableSize()

Return the lock hash table size.

This method may be called at any time during the life of the application.

Returns:
  The lock hash table size.

#### setMaxLockers

    public void setMaxLockers(int maxLockers)

Set the maximum number of locking entities supported by the database environment.

This value is used during environment creation to estimate how much space to allocate for various lock-table data structures. The default value is 1000 lockers.

The database environment's maximum number of lockers may also be set using the environment's DB_CONFIG file. The syntax of the entry in that file is a single line with the string "set_lk_max_lockers", one or more whitespace characters, and the number of lockers. Because the DB_CONFIG file is read when the database environment is opened, it will silently overrule configuration done before that time.

This method configures a database environment, including all threads of control accessing the database environment, not only the operations performed using a specified `Environment` handle.

This method may not be called after the environment has been opened. If joining an existing database environment, any information specified to this method will be ignored.

Parameters:
  `maxLockers` - The maximum number simultaneous locking entities supported by the database environment.

#### getMaxLockers

    public int getMaxLockers()

Return the maximum number of lockers.

This method may be called at any time during the life of the application.

Returns:
  The maximum number of lockers.

#### setMaxLockObjects

    public void setMaxLockObjects(int maxLockObjects)

Set the maximum number of locked objects supported by the database environment.

This value is used during environment creation to estimate how much space to allocate for various lock-table data structures. The default value is 1000 objects.

The database environment's maximum number of objects may also be set using the environment's DB_CONFIG file. The syntax of the entry in that file is a single line with the string "set_lk_max_objects", one or more whitespace characters, and the number of objects. Because the DB_CONFIG file is read when the database environment is opened, it will silently overrule configuration done before that time.

This method configures a database environment, including all threads of control accessing the database environment, not only the operations performed using a specified `Environment` handle.

This method may not be called after the environment has been opened. If joining an existing database environment, any information specified to this method will be ignored.

Parameters:
  `maxLockObjects` - The maximum number of locked objects supported by the database environment.

#### getMaxLockObjects

    public int getMaxLockObjects()

Return the maximum number of locked objects.

This method may be called at any time during the life of the application.

Returns:
  The maximum number of locked objects.

#### setMaxLogFileSize

    public void setMaxLogFileSize(int maxLogFileSize)

Set the maximum size of a single file in the log, in bytes.

By default, or if the maxLogFileSize parameter is set to 0, a size of 10MB is used. If no size is specified by the application, the size last specified for the database region will be used, or if no database region previously existed, the default will be used. Because `LogSequenceNumber` file offsets are unsigned four-byte values, the set value may not be larger than the maximum unsigned four-byte value.

The database environment's log file size may also be set using the environment's DB_CONFIG file. The syntax of the entry in that file is a single line with the string "set_lg_max", one or more whitespace characters, and the size in bytes. Because the DB_CONFIG file is read when the database environment is opened, it will silently overrule configuration done before that time.

This method configures a database environment, including all threads of control accessing the database environment, not only the operations performed using a specified `Environment` handle.

This method may be called at any time during the life of the application.

Parameters:
  `maxLogFileSize` - The maximum size of a single file in the log, in bytes.

#### getMaxLogFileSize

    public int getMaxLogFileSize()

Return the maximum size of a single file in the log, in bytes.

This method may be called at any time during the life of the application.

Returns:
  The maximum size of a single file in the log, in bytes.

#### setLogBufferSize

    public void setLogBufferSize(int logBufferSize)

Set the size of the in-memory log buffer, in bytes.

Log information is stored in-memory until the storage space fills up or transaction commit forces the information to be flushed to stable storage. In the presence of long-running transactions or transactions producing large amounts of data, larger buffer sizes can increase throughput.

By default, or if the value is set to 0, a size of 32K is used.

The database environment's log buffer size may also be set using the environment's DB_CONFIG file. The syntax of the entry in that file is a single line with the string "set_lg_bsize", one or more whitespace characters, and the size in bytes. Because the DB_CONFIG file is read when the database environment is opened, it will silently overrule configuration done before that time.

This method configures a database environment, including all threads of control accessing the database environment, not only the operations performed using a specified `Environment` handle.

This method may not be called after the environment has been opened. If joining an existing database environment, any information specified to this method will be ignored.

Parameters:
  `logBufferSize` - The size of the in-memory log buffer, in bytes.

#### getLogBufferSize

    public int getLogBufferSize()

Return the size of the in-memory log buffer, in bytes.

This method may be called at any time during the life of the application.

Returns:
  The size of the in-memory log buffer, in bytes.

#### setLogDirectory

    public void setLogDirectory(java.io.File logDirectory)

Set the path of a directory to be used as the location of logging files.

Log files created by the Log Manager subsystem will be created in this directory. If no logging directory is specified, log files are created in the environment home directory.

For the greatest degree of recoverability from system or application failure, database files and log files should be located on separate physical devices.

The database environment's logging directory may also be set using the environment's DB_CONFIG file. The syntax of the entry in that file is a single line with the string "set_lg_dir", one or more whitespace characters, and the directory name. Because the DB_CONFIG file is read when the database environment is opened, it will silently overrule configuration done before that time.

This method configures only operations performed using a single a `Environment` handle, not an entire database environment.

This method may not be called after the environment has been opened. If joining an existing database environment, the information specified to this method must be consistent with the existing environment or corruption can occur.

Parameters:
  `logDirectory` - The directory used to store the logging files. On Windows platforms, this argument will be interpreted as a UTF-8 string, which is equivalent to ASCII for Latin characters.

#### getLogDirectory

    public java.io.File getLogDirectory()

Return the path of a directory to be used as the location of logging files.

This method may be called at any time during the life of the application.

Returns:
  The path of a directory to be used as the location of logging files.

#### setLogFileMode

    public void setLogFileMode(int logFileMode)

Set the absolute file mode for created log files. This method is only useful for the rare Berkeley DB application that does not control its umask value.

Normally, if Berkeley DB applications set their umask appropriately, all processes in the application suite will have read permission on the log files created by any process in the application suite. However, if the Berkeley DB application is a library, a process using the library might set its umask to a value preventing other processes in the application suite from reading the log files it creates. In this rare case, this method can be used to set the mode of created log files to an absolute value.

Parameters:
  `logFileMode` - The absolute mode of the created log file.

#### getLogFileMode

    public int getLogFileMode()

Return the absolute file mode for created log files.

This method may be called at any time during the life of the application.

Returns:
  The absolute file mode for created log files.

#### setLogRegionSize

    public void setLogRegionSize(int logRegionSize)

Set the size of the underlying logging area of the database environment, in bytes.

By default, or if the value is set to 0, the default size is 60KB. The log region is used to store filenames, and so may need to be increased in size if a large number of files will be opened and registered with the specified database environment's log manager.

The database environment's log region size may also be set using the environment's DB_CONFIG file. The syntax of the entry in that file is a single line with the string "set_lg_regionmax", one or more whitespace characters, and the size in bytes. Because the DB_CONFIG file is read when the database environment is opened, it will silently overrule configuration done before that time.

This method configures a database environment, including all threads of control accessing the database environment, not only the operations performed using a specified `Environment` handle.

This method may not be called after the environment has been opened. If joining an existing database environment, any information specified to this method will be ignored.

Parameters:
  `logRegionSize` - The size of the logging area in the database environment, in bytes.

#### getLogRegionSize

    public int getLogRegionSize()

Return the size of the underlying logging subsystem region.

This method may be called at any time during the life of the application.

Returns:
  The size of the underlying logging subsystem region.

#### setMaxOpenFiles

    public void setMaxOpenFiles(int maxOpenFiles)

Limit the number of file descriptors the library will open concurrently when flushing dirty pages from the cache.

Parameters:
  `maxOpenFiles` - The maximum number of file descriptors that may be concurrently opened by the library when flushing dirty pages from the cache.

#### getMaxOpenFiles

    public int getMaxOpenFiles()

Return the maximum number of file descriptors that will be opened concurrently..

This method may be called at any time during the life of the application.

Returns:
  The maximum number of file descriptors that will be opened concurrently..

#### setMaxWrite

    public void setMaxWrite(int maxWrite,
                   long maxWriteSleep)

Limit the number of sequential write operations scheduled by the library when flushing dirty pages from the cache.

Parameters:
  `maxWrite` - The maximum number of sequential write operations scheduled by the library when flushing dirty pages from the cache.
  `maxWriteSleep` - The number of microseconds the thread of control should pause before scheduling further write operations.

#### getMaxWrite

    public int getMaxWrite()

Return the maximum number of sequential write operations.

This method may be called at any time during the life of the application.

Returns:
  The maximum number of sequential write operations.

#### getMaxWriteSleep

    public long getMaxWriteSleep()

Return the microseconds to pause before scheduling further write operations.

This method may be called at any time during the life of the application.

Returns:
  The microseconds to pause before scheduling further write operations.

#### setMessageHandler

    public void setMessageHandler(MessageHandler messageHandler)

Set a function to be called with an informational message.

There are interfaces in the Berkeley DB library which either directly output informational messages or statistical information, or configure the library to output such messages when performing other operations, `EnvironmentConfig.setVerboseDeadlock` for example.

The `EnvironmentConfig.setMessageHandler` and `DatabaseConfig.setMessageHandler` methods are used to display these messages for the application.

Setting messageHandler to null unconfigures the interface.

Alternatively, you can use `EnvironmentConfig.setMessageStream` and `DatabaseConfig.setMessageStream` to send the additional information directly to an output streams. You should not mix these approaches.

This method may be called at any time during the life of the application.

Parameters:
  `messageHandler` - The application-specified function for informational messages.

#### getMessageHandler

    public MessageHandler getMessageHandler()

Return the function to be called with an informational message.

This method may be called at any time during the life of the application.

Returns:
  The function to be called with an informational message.

#### setMessageStream

    public void setMessageStream(java.io.OutputStream messageStream)

Set an OutputStream for displaying informational messages.

There are interfaces in the Berkeley DB library which either directly output informational messages or statistical information, or configure the library to output such messages when performing other operations, `EnvironmentConfig.setVerboseDeadlock` for example.

The `EnvironmentConfig.setMessageStream` and `DatabaseConfig.setMessageStream` methods are used to display these messages for the application. In this case, the message will include a trailing newline character.

Setting messageStream to null unconfigures the interface.

Alternatively, you can use `EnvironmentConfig.setMessageHandler` and `DatabaseConfig.setMessageHandler` to capture the additional information in a way that does not use output streams. You should not mix these approaches.

This method may be called at any time during the life of the application.

Parameters:
  `messageStream` - The application-specified OutputStream for informational messages.

#### getMessageStream

    public java.io.OutputStream getMessageStream()

Return the OutputStream for displaying informational messages.

This method may be called at any time during the life of the application.

Returns:
  The an OutputStream for displaying informational messages.

#### setMetadataDir

    public void setMetadataDir(java.io.File dir)

Set the path of a directory to be used as the location to store the persistent metadata files.

Parameters:
  `dir` - The path of metadata directory.

#### getMetadataDir

    public java.io.File getMetadataDir()

Return the path of a directory to be used as the location to store the persistent metadata.

Returns:
  The the path of metadata directory.

#### setMMapSize

    public void setMMapSize(long mmapSize)

Set the maximum file size, in bytes, for a file to be mapped into the process address space.

If no value is specified, it defaults to 10MB.

Files that are opened read-only in the pool (and that satisfy a few other criteria) are, by default, mapped into the process address space instead of being copied into the local cache. This can result in better-than-usual performance because available virtual memory is normally much larger than the local cache, and page faults are faster than page copying on many systems. However, it can cause resource starvation in the presence of limited virtual memory, and it can result in immense process sizes in the presence of large databases.

Parameters:
  `mmapSize` - The maximum file size, in bytes, for a file to be mapped into the process address space.

  This method configures only operations performed using a single a `Environment` handle, not an entire database environment.

  This method may be called at any time during the life of the application.

#### getMMapSize

    public long getMMapSize()

Return the maximum file size, in bytes, for a file to be mapped into the process address space.

Returns:
  The maximum file size, in bytes, for a file to be mapped into the process address space.

#### setCachePageSize

    public void setCachePageSize(int mpPageSize)

Sets the page size used to allocate the hash table and the number of mutexes expected to be needed by the buffer pool.

This method may be called only before the environment is opened.

Parameters:
  `mpPageSize` - The expected page size to use. Generally, it is set to the expected average page size for all the data pages that are in the buffer pool.

#### getCachePageSize

    public int getCachePageSize()

Returns the environment's current page size setting.

Returns:
  The current setting for the environment's expected page size use.

#### setCacheTableSize

    public void setCacheTableSize(int mpTableSize)

Overrides the calculated hash table size.

The table size is then adjusted to a nearby prime number to enhance the hashing algorithm.

This method may be called only before the environment is opened.

Parameters:
  `mpTableSize` - Specifies the size of the buffer pool hash table, which is then internally adjusted to a nearby prime number.

#### getCacheTableSize

    public int getCacheTableSize()

Returns the environment's current table size setting.

Returns:
  The current setting for the environment's table size.

#### setMode

    public void setMode(int mode)

Configure the database environment to use a specific mode when creating underlying files and shared memory segments.

On UNIX systems or in POSIX environments, files created in the database environment are created with the specified mode (as modified by the process' umask value at the time of creation).

On UNIX systems or in POSIX environments, system shared memory segments created by the library are created with the specified mode, unmodified by the process' umask value.

If is 0, the library will use a default mode of readable and writable by both owner and group.

Created files are owned by the process owner; the group ownership of created files is based on the system and directory defaults, and is not further specified by the library.

Parameters:
  `mode` - The mode to use when creating underlying files and shared memory segments.

#### getMode

    public long getMode()

Return the mode to use when creating underlying files and shared memory segments.

This method may be called at any time during the life of the application.

Returns:
  The mode to use when creating underlying files and shared memory segments.

#### setMultiversion

    public void setMultiversion(boolean multiversion)

Configure the database environment to open all databases that are not using the queue access method for multiversion concurrency control. See `DatabaseConfig.setMultiversion(boolean)` for more information.

This method may be called at any time during the life of the application.

Parameters:
  `multiversion` - If true, all databases that are not using the queue access method will be opened for multiversion concurrency control.

#### getMultiversion

    public boolean getMultiversion()

Return true if the handle is configured to open all databases for multiversion concurrency control.

This method may be called at any time during the life of the application.

Returns:
  True if the handle is configured to open all databases for multiversion concurrency control.

#### setNoLocking

    public void setNoLocking(boolean noLocking)

Configure the system to grant all requested mutual exclusion mutexes and database locks without regard for their actual availability.

This functionality should never be used for purposes other than debugging.

This method only affects the specified `Environment` handle (and any other library handles opened within the scope of that handle).

This method may be called at any time during the life of the application.

Parameters:
  `noLocking` - If true, configure the system to grant all requested mutual exclusion mutexes and database locks without regard for their actual availability.

#### getNoLocking

    public boolean getNoLocking()

Return true if the system has been configured to grant all requested mutual exclusion mutexes and database locks without regard for their actual availability.

This method may be called at any time during the life of the application.

Returns:
  True if the system has been configured to grant all requested mutual exclusion mutexes and database locks without regard for their actual availability.

#### setNoMMap

    public void setNoMMap(boolean noMMap)

Configure the system to copy read-only database files into the local cache instead of potentially mapping them into process memory.

This method only affects the specified `Environment` handle (and any other library handles opened within the scope of that handle). For consistent behavior across the environment, all `Environment` handles opened in the database environment must either call this method or the configuration should be specified in the database environment's DB_CONFIG configuration file.

This method may be called at any time during the life of the application.

Parameters:
  `noMMap` - If true, configure the system to copy read-only database files into the local cache instead of potentially mapping them into process memory.

#### getNoMMap

    public boolean getNoMMap()

Return true if the system has been configured to copy read-only database files into the local cache instead of potentially mapping them into process memory.

This method may be called at any time during the life of the application.

Returns:
  True if the system has been configured to copy read-only database files into the local cache instead of potentially mapping them into process memory.

#### setNoPanic

    public void setNoPanic(boolean noPanic)

Configure the system to ignore any panic state in the database environment.

Database environments in a panic state normally refuse all attempts to call Berkeley DB functions, throwing `RunRecoveryException`. This functionality should never be used for purposes other than debugging.

This method only affects the specified `Environment` handle (and any other library handles opened within the scope of that handle).

This method may be called at any time during the life of the application.

Parameters:
  `noPanic` - If true, configure the system to ignore any panic state in the database environment.

#### getNoPanic

    public boolean getNoPanic()

Return true if the system has been configured to ignore any panic state in the database environment.

This method may be called at any time during the life of the application.

Returns:
  True if the system has been configured to ignore any panic state in the database environment.

#### setOverwrite

    public void setOverwrite(boolean overwrite)

Configure the system to overwrite files stored in encrypted formats before deleting them.

Berkeley DB overwrites files using alternating 0xff, 0x00 and 0xff byte patterns. For file overwriting to be effective, the underlying file must be stored on a fixed-block filesystem. Systems with journaling or logging filesystems will require operating system support and probably modification of the Berkeley DB sources.

This method only affects the specified `Environment` handle (and any other library handles opened within the scope of that handle).

This method may be called at any time during the life of the application.

Parameters:
  `overwrite` - If true, configure the system to overwrite files stored in encrypted formats before deleting them.

#### getOverwrite

    public boolean getOverwrite()

Return true if the system has been configured to overwrite files stored in encrypted formats before deleting them.

This method may be called at any time during the life of the application.

Returns:
  True if the system has been configured to overwrite files stored in encrypted formats before deleting them.

#### setPanicHandler

    public void setPanicHandler(PanicHandler panicHandler)

Set the function to be called if the database environment panics.

Errors can occur in the Berkeley DB library where the only solution is to shut down the application and run recovery (for example, if Berkeley DB is unable to allocate heap memory). In such cases, the Berkeley DB methods will throw a `RunRecoveryException`. It is often easier to simply exit the application when such errors occur rather than gracefully return up the stack. This method specifies a function to be called when `RunRecoveryException` is about to be thrown from a Berkeley DB method.

This method may be called at any time during the life of the application.

Parameters:
  `panicHandler` - The function to be called if the database environment panics.

#### getPanicHandler

    public PanicHandler getPanicHandler()

Return the function to be called if the database environment panics.

This method may be called at any time during the life of the application.

Returns:
  The function to be called if the database environment panics.

#### setReplicationView

    public void setReplicationView(ReplicationViewHandler repViewHandler)

Set the function to be used by replication views to determine whether a database file is replicated to the local site.

Parameters:
  `repViewHandler` - The function name to determine whether a database file is replicated. If null, the replication view is a full view and all database files are replicated to the local site. Otherwise it is a partial view and only some database files are replicated to the local site.

#### getReplicationViewHandler

    public ReplicationViewHandler getReplicationViewHandler()

Return the function name used by replication views to determine whether a database file is replicated to the local site.

Returns:
  The function name used by replication views to determine whether a database file is replicated to the local site. If null, the replication view is a full view and all database files are replicated to the local site. Otherwise it is a partial view and only some database files are replicated to the local site.

#### setPrivate

    public void setPrivate(boolean isPrivate)

Configure the database environment to only be accessed by a single process (although that process may be multithreaded).

This has two effects on the database environment. First, all underlying data structures are allocated from per-process memory instead of from shared memory that is potentially accessible to more than a single process. Second, mutexes are only configured to work between threads.

Use of this flag means that multiple handles cannot be simultaneously opened for the environment, even within the same process. For example, if both a server application and a Berkeley DB utility are expected to access the environment at the same time, then do not configure the database environment as private.

Parameters:
  `isPrivate` - If true, configure the database environment to only be accessed by a single process.

#### getPrivate

    public boolean getPrivate()

Return true if the database environment is configured to only be accessed by a single process.

This method may be called at any time during the life of the application.

Returns:
  True if the database environment is configured to only be accessed by a single process.

#### setReplicationClockskew

    public void setReplicationClockskew(int replicationClockskewFast,
                               int replicationClockskewSlow)

Sets the clock skew ratio among replication group members based on the fastest and slowest measurements among the group for use with master leases. Calling this method is optional, the default values for clock skew assume no skew. The user must also configure leases via the `Environment.setReplicationConfig(com.sleepycat.db.ReplicationConfig, boolean)` method. Additionally, the user must also set the master lease timeout via the `Environment.setReplicationTimeout(com.sleepycat.db.ReplicationTimeoutType, int)` method and, if using the base replication API, the number of sites in the replication group via the (@link #setReplicationNumSites} method. These methods may be called in any order. For a description of the clock skew values, see Clock skew. For a description of master leases, see Master leases.

These arguments can be used to express either raw measurements of a clock timing experiment or a percentage across machines. For instance a group of sites have a 2% variance, then `replicationClockskewFast` should be given as 102, and `replicationClockskewSlow` should be set at 100. Or, for a 0.03% difference, you can use 10003 and 10000 respectively.

The database environment's replication subsystem may also be configured using the environment's DB_CONFIG file. The syntax of the entry in that file is a single line with the string "rep_set_clockskew", one or more whitespace characters, and the clockskew specified in two parts: the replicationClockskewFast and the replicationClockskewSlow. For example, "rep_set_clockskew 102 100". Because the DB_CONFIG file is read when the database environment is opened, it will silently overrule configuration done before that time.

This method configures a database environment, not only operations performed using the specified `Environment` handle.

This method may not be called after the `Environment.replicationManagerStart(int, com.sleepycat.db.ReplicationManagerStartPolicy)` or `Environment.startReplication(com.sleepycat.db.DatabaseEntry, boolean)` methods are called.

Parameters:
  `replicationClockskewFast` - The value, relative to the `replicationClockskewSlow`, of the fastest clock in the group of sites.
  `replicationClockskewSlow` - The value of the slowest clock in the group of sites.

#### getReplicationClockskewFast

    public int getReplicationClockskewFast()

Return the current clock skew value for the fastest clock in the group of sites.

This method may be called at any time during the life of the application.

Returns:
  The current clock skew value for the fastest clock in the group of sites.

#### getReplicationClockskewSlow

    public int getReplicationClockskewSlow()

Return the current clock skew value for the slowest clock in the group of sites.

This method may be called at any time during the life of the application.

Returns:
  The current clock skew value for the slowest clock in the group of sites.

#### setReplicationLimit

    public void setReplicationLimit(long replicationLimit)

Impose a byte-count limit on the amount of data that will be transmitted from a site in a single call to `Environment.processReplicationMessage`.

This method configures a database environment, including all threads of control accessing the database environment, not only the operations performed using a specified `Environment` handle.

This method may be called at any time during the life of the application.

Parameters:
  `replicationLimit` - The maximum number of bytes that will be sent in a single call to `Environment.processReplicationMessage`.

#### getReplicationLimit

    public long getReplicationLimit()

Return the transmit limit in bytes for a single call to `Environment.processReplicationMessage`.

This method may be called at any time during the life of the application.

Returns:
  The transmit limit in bytes for a single call to `Environment.processReplicationMessage`.

#### setReplicationRequestMin

    public void setReplicationRequestMin(int replicationRequestMin)

Set a threshold for the minimum time that a client waits before requesting retransmission of a missing message. Specifically, if the client detects a gap in the sequence of incoming log records or database pages, Berkeley DB will wait for at least `replicationRequestMin` microseconds before requesting retransmission of the missing record. Berkeley DB will double that amount before requesting the same missing record again, and so on, up to a maximum threshold, set by `setReplicationRequestMax(int)`.

These values are thresholds only. Replication Manager applications use these values to determine when to automatically request retransmission of missing messages. For Base API applications, Berkeley DB has no thread available in the library as a timer, the threshold is only checked when a thread enters the Berkeley DB library to process an incoming replication message. Any amount of time may have passed since the last message arrived and Berkeley DB only checks whether the amount of time since a request was made is beyond the threshold value or not.

By default the minimum is 40000 and the maximum is 1280000 (1.28 seconds). These defaults are fairly arbitrary and the application likely needs to adjust these. The values should be based on expected load and performance characteristics of the master and client host platforms and transport infrastructure as well as round-trip message time.

Parameters:
  `replicationRequestMin` - The minimum amount of time the client waits before requesting retransmission of a missing message.

#### getReplicationRequestMin

    public int getReplicationRequestMin()

Get the threshold for the minimum amount of time that a client waits before requesting retransmission of a missed message.

Returns:
  The threshold for the minimum amount of time that a client waits before requesting retransmission of a missed message.

#### setReplicationRequestMax

    public void setReplicationRequestMax(int replicationRequestMax)

Set a threshold for the maximum time that a client waits before requesting retransmission of a missing message. Specifically, if the client detects a gap in the sequence of incoming log records or database pages, Berkeley DB will wait for at least the minimum threshold, set by `setReplicationRequestMin(int)`, before requesting retransmission of the missing record. Berkeley DB will double that amount before requesting the same missing record again, and so on, up to `replicationRequestMax`.

These values are thresholds only. Since Berkeley DB has no thread available in the library as a timer, the threshold is only checked when a thread enters the Berkeley DB library to process an incoming replication message. Any amount of time may have passed since the last message arrived and Berkeley DB only checks whether the amount of time since a request was made is beyond the threshold value or not.

By default the minimum is 40000 and the maximum is 1280000 (1.28 seconds). These defaults are fairly arbitrary and the application likely needs to adjust these. The values should be based on expected load and performance characteristics of the master and client host platforms and transport infrastructure as well as round-trip message time.

Parameters:
  `replicationRequestMax` - The maximum amount of time the client waits before requesting retransmission of a missing message.

#### getReplicationRequestMax

    public int getReplicationRequestMax()

Get the threshold for the maximum amount of time that a client waits before requesting retransmission of a missed message.

Returns:
  The threshold for the maximum amount of time that a client waits before requesting retransmission of a missed message.

#### setReplicationTransport

    public void setReplicationTransport(int envid,
                               ReplicationTransport replicationTransport)

Initialize the communication infrastructure for a database environment participating in a replicated application.

This method configures only operations performed using a single a `Environment` handle, not an entire database environment.

This method may be called at any time during the life of the application.

Parameters:
  `envid` - The local environment's ID. It must be a positive integer and uniquely identify this Berkeley DB database environment.

  `replicationTransport` - The callback function is used to transmit data using the replication application's communication infrastructure.

#### getReplicationTransport

    public ReplicationTransport getReplicationTransport()

Return the replication callback function used to transmit data using the replication application's communication infrastructure.

Returns:
  The replication callback function used to transmit data using the replication application's communication infrastructure.

#### setRegister

    public void setRegister(boolean register)

Check if a process has failed while using the database environment, that is, if a process has exited with an open `Environment` handle. (For this check to be accurate, all processes using the environment must specify this flag when opening the environment.) If recovery needs to be run for any reason and either `setRunRecovery(boolean)` or `setRunFatalRecovery(boolean)` are also specified, recovery will be performed and the open will proceed normally. If recovery needs to be run and no recovery flag is specified, a `RunRecoveryException` will be thrown. If recovery does not need to be run, the recovery flags will be ignored. See Architecting Transactional Data Store applications) for more information.

Parameters:
  `register` - If true, check for process failure when the environment is opened.

#### getRegister

    public boolean getRegister()

Return true if the check for process failure when the environment is opened.

This method may be called at any time during the life of the application.

Returns:
  True if the check for process failure when the environment is opened.

#### setRunFatalRecovery

    public void setRunFatalRecovery(boolean runFatalRecovery)

Configure to run catastrophic recovery on this environment before opening it for normal use.

A standard part of the recovery process is to remove the existing database environment and create a new one. Applications running recovery must be prepared to re-create the environment because underlying shared regions will be removed and re-created.

If the thread of control performing recovery does not specify the correct database environment initialization information (for example, the correct memory pool cache size), the result can be an application running in an environment with incorrect cache and other subsystem sizes. For this reason, the thread of control performing recovery should specify correct configuration information before recovering the environment; or it should remove the environment after recovery is completed, leaving creation of a correctly sized environment to a subsequent call.

All recovery processing must be single-threaded; that is, only a single thread of control may perform recovery or access a database environment while recovery is being performed. Because it is not an error to run recovery for an environment for which no recovery is required, it is reasonable programming practice for the thread of control responsible for performing recovery and creating the environment to always specify recovery during startup.

This method returns successfully if recovery is run no log files exist, so it is necessary to ensure that all necessary log files are present before running recovery.

Parameters:
  `runFatalRecovery` - If true, configure to run catastrophic recovery on this environment before opening it for normal use.

#### getRunFatalRecovery

    public boolean getRunFatalRecovery()

Return the handle is configured to run catastrophic recovery on the database environment before opening it for use.

This method may be called at any time during the life of the application.

Returns:
  The handle is configured to run catastrophic recovery on the database environment before opening it for use.

#### setRunRecovery

    public void setRunRecovery(boolean runRecovery)

Configure to run normal recovery on this environment before opening it for normal use.

A standard part of the recovery process is to remove the existing database environment and create a new one. Applications running recovery must be prepared to re-create the environment because underlying shared regions will be removed and re-created.

If the thread of control performing recovery does not specify the correct database environment initialization information (for example, the correct memory pool cache size), the result can be an application running in an environment with incorrect cache and other subsystem sizes. For this reason, the thread of control performing recovery should specify correct configuration information before recovering the environment; or it should remove the environment after recovery is completed, leaving creation of a correctly sized environment to a subsequent call.

All recovery processing must be single-threaded; that is, only a single thread of control may perform recovery or access a database environment while recovery is being performed. Because it is not an error to run recovery for an environment for which no recovery is required, it is reasonable programming practice for the thread of control responsible for performing recovery and creating the environment to always specify recovery during startup.

This method returns successfully if recovery is run no log files exist, so it is necessary to ensure that all necessary log files are present before running recovery.

Parameters:
  `runRecovery` - If true, configure to run normal recovery on this environment before opening it for normal use.

#### getRunRecovery

    public boolean getRunRecovery()

Return the handle is configured to run normal recovery on the database environment before opening it for use.

This method may be called at any time during the life of the application.

Returns:
  The handle is configured to run normal recovery on the database environment before opening it for use.

#### setSystemMemory

    public void setSystemMemory(boolean systemMemory)

Configure the database environment to allocate memory from system shared memory instead of from memory backed by the filesystem.

Parameters:
  `systemMemory` - If true, configure the database environment to allocate memory from system shared memory instead of from memory backed by the filesystem.

#### getSystemMemory

    public boolean getSystemMemory()

Return true if the database environment is configured to allocate memory from system shared memory instead of from memory backed by the filesystem.

This method may be called at any time during the life of the application.

Returns:
  True if the database environment is configured to allocate memory from system shared memory instead of from memory backed by the filesystem.

#### setSegmentId

    public void setSegmentId(long segmentId)

Specify a base segment ID for database environment shared memory regions created in system memory on VxWorks or systems supporting X/Open-style shared memory interfaces; for example, UNIX systems supporting `shmget` and related System V IPC interfaces.

This base segment ID will be used when database environment shared memory regions are first created. It will be incremented a small integer value each time a new shared memory region is created; that is, if the base ID is 35, the first shared memory region created will have a segment ID of 35, and the next one will have a segment ID between 36 and 40 or so. A database environment always creates a master shared memory region; an additional shared memory region for each of the subsystems supported by the environment (Locking, Logging, Memory Pool and Transaction); plus an additional shared memory region for each additional memory pool cache that is supported. Already existing regions with the same segment IDs will be removed.

The intent behind this method is two-fold: without it, applications have no way to ensure that two Berkeley DB applications don't attempt to use the same segment IDs when creating different database environments. In addition, by using the same segment IDs each time the environment is created, previously created segments will be removed, and the set of segments on the system will not grow without bound. The database environment's base segment ID may also be set using the environment's DB_CONFIG file. The syntax of the entry in that file is a single line with the string "set_shm_key", one or more whitespace characters, and the ID. Because the DB_CONFIG file is read when the database environment is opened, it will silently overrule configuration done before that time.

This method configures only operations performed using a single a `Environment` handle, not an entire database environment.

This method may not be called after the environment has been opened. If joining an existing database environment, the information specified to this method must be consistent with the existing environment or corruption can occur.

Parameters:
  `segmentId` - The base segment ID for the database environment.

#### getSegmentId

    public long getSegmentId()

Return the base segment ID.

This method may be called at any time during the life of the application.

Returns:
  The base segment ID.

#### setTemporaryDirectory

    public void setTemporaryDirectory(java.io.File temporaryDirectory)

Set the path of a directory to be used as the location of temporary files.

The files created to back in-memory access method databases will be created relative to this path. These temporary files can be quite large, depending on the size of the database.

If no directory is specified, the following alternatives are checked in the specified order. The first existing directory path is used for all temporary files.

> 1. The value of the environment variable TMPDIR.
> 2. The value of the environment variable TEMP.
> 3. The value of the environment variable TMP.
> 4. The value of the environment variable TempFolder.
> 5. The value returned by the GetTempPath interface.
> 6. The directory /var/tmp.
> 7. The directory /usr/tmp.
> 8. The directory /temp.
> 9. The directory /tmp.
> 10. The directory C:/temp.
> 11. The directory C:/tmp. </ol</blockquote>

>     Note: the environment variables are only checked if the database environment has been configured with one of `EnvironmentConfig.setUseEnvironment` or `EnvironmentConfig.setUseEnvironmentRoot`.

>     Note: the GetTempPath interface is only checked on Win/32 platforms.

>     The database environment's temporary file directory may also be set using the environment's DB_CONFIG file. The syntax of the entry in that file is a single line with the string "set_tmp_dir", one or more whitespace characters, and the directory name. Because the DB_CONFIG file is read when the database environment is opened, it will silently overrule configuration done before that time.

>     This method configures only operations performed using a single a `Environment` handle, not an entire database environment.

>     This method may not be called after the environment has been opened. If joining an existing database environment, the information specified to this method must be consistent with the existing environment or corruption can occur.

Parameters:
  `temporaryDirectory` - The directory to be used to store temporary files. On Windows platforms, this argument will be interpreted as a UTF-8 string, which is equivalent to ASCII for Latin characters.

#### setTemporaryDirectory

    public void setTemporaryDirectory(java.lang.String temporaryDirectory)

Deprecated. replaced by `setTemporaryDirectory(java.io.File)`

#### getTemporaryDirectory

    public java.io.File getTemporaryDirectory()

Return the path of a directory to be used as the location of temporary files.

This method may be called at any time during the life of the application.

Returns:
  The path of a directory to be used as the location of temporary files.

#### setMutexAlignment

    public void setMutexAlignment(int mutexAlignment)

Set the mutex alignment, in bytes.

It is sometimes advantageous to align mutexes on specific byte boundaries in order to minimize cache line collisions. This method specifies an alignment for mutexes allocated by Berkeley DB.

The database environment's mutex alignment may also be set using the environment's DB_CONFIG file. The syntax of the entry in that file is a single line with the string "mutex_set_align", one or more whitespace characters, and the mutex alignment in bytes. Because the DB_CONFIG file is read when the database environment is opened, it will silently overrule configuration done before that time.

This method configures a database environment, including all threads of control accessing the database environment, not only the operations performed using a specified `Environment` handle.

This method may not be called after the environment has been opened. If joining an existing database environment, any information specified to this method will be ignored.

Parameters:
  `mutexAlignment` - mutex alignment, in bytes. The mutex alignment must be a power-of-two.

#### getMutexAlignment

    public int getMutexAlignment()

Return the mutex alignment, in bytes.

This method may be called at any time during the life of the application.

Returns:
  The mutex alignment, in bytes.

#### setMutexIncrement

    public void setMutexIncrement(int mutexIncrement)

Increase the number of mutexes to allocate.

Berkeley DB allocates a default number of mutexes based on the initial configuration of the database environment. That default calculation may be too small if the application has an unusual need for mutexes (for example, if the application opens an unexpectedly large number of databases) or too large (if the application is trying to minimize its memory footprint). This method configure the number of additional mutexes to allocate.

Calling this method discards any value previously set using the `setMaxMutexes(int)` method.

This method configures a database environment, including all threads of control accessing the database environment, not only the operations performed using a specified `Environment` handle.

This method may not be called after the environment has been opened. If joining an existing database environment, any information specified to this method will be ignored.

Parameters:
  `mutexIncrement` - The number of additional mutexes to allocate.

#### getMutexIncrement

    public int getMutexIncrement()

Return the number of additional mutexes to allocate.

This method may be called at any time during the life of the application.

Returns:
  The number of additional mutexes to allocate.

#### setInitialMutexes

    public void setInitialMutexes(int initMutexes)

Set the number of mutexes to allocate when an environment is created.

Berkeley DB allocates a default number of mutexes based on the initial configuration of the database environment. That default calculation may be too small if the application has an unusual need for mutexes (for example, if the application opens an unexpectedly large number of databases) or too large (if the application is trying to minimize its memory footprint). This method configure the number of initial mutexes to allocate.

Calling this method discards any value previously set using the `setInitialMutexes(int)` method.

This method configures a database environment, including all threads of control accessing the database environment, not only the operations performed using a specified `Environment` handle.

This method may not be called after the environment has been opened. If joining an existing database environment, any information specified to this method will be ignored.

Parameters:
  `initMutexes` - The number of mutexes allocated when an environment is created.

#### getInitialMutexes

    public int getInitialMutexes()

Return the number of mutexes allocated when an environment is created.

This method may be called at any time during the life of the application.

Returns:
  The number of mutexes allocated when an environment is created.

#### setMaxMutexes

    public void setMaxMutexes(int maxMutexes)

Set the total number of mutexes to allocate.

Berkeley DB allocates a default number of mutexes based on the initial configuration of the database environment. That default calculation may be too small if the application has an unusual need for mutexes (for example, if the application opens an unexpectedly large number of databases) or too large (if the application is trying to minimize its memory footprint). This method is used to specify an absolute number of mutexes to allocate.

Calling this method discards any value previously set using the `setMutexIncrement(int)` method.

The database environment's total number of mutexes may also be set using the environment's DB_CONFIG file. The syntax of the entry in that file is a single line with the string "mutex_set_max", one or more whitespace characters, and the total number of mutexes. Because the DB_CONFIG file is read when the database environment is opened, it will silently overrule configuration done before that time.

This method configures a database environment, including all threads of control accessing the database environment, not only the operations performed using a specified `Environment` handle.

This method may not be called after the environment has been opened. If joining an existing database environment, any information specified to this method will be ignored.

Parameters:
  `maxMutexes` - The absolute number of mutexes to allocate.

#### getMaxMutexes

    public int getMaxMutexes()

Return the total number of mutexes allocated.

This method may be called at any time during the life of the application.

Returns:
  The total number of mutexes allocated.

#### setMutexTestAndSetSpins

    public void setMutexTestAndSetSpins(int mutexTestAndSetSpins)

Specify the number of times that test-and-set mutexes should spin without blocking. The value defaults to 1 on uniprocessor systems and to 50 times the number of processors on multiprocessor systems.

The database environment's test-and-set spin count may also be set using the environment's DB_CONFIG file. The syntax of the entry in that file is a single line with the string "set_tas_spins", one or more whitespace characters, and the number of spins. Because the DB_CONFIG file is read when the database environment is opened, it will silently overrule configuration done before that time.

This method configures only operations performed using a single a `Environment` handle, not an entire database environment.

This method may be called at any time during the life of the application.

Parameters:
  `mutexTestAndSetSpins` - The number of spins test-and-set mutexes should execute before blocking.

#### getMutexTestAndSetSpins

    public int getMutexTestAndSetSpins()

Return the test-and-set spin count.

This method may be called at any time during the life of the application.

Returns:
  The test-and-set spin count.

#### setReplicationNumSites

    public void setReplicationNumSites(int replicationNumSites)

Set the total number of sites the replication group is configured for.

This method cannot be called by replication manager applications.

Note that this value is not automatically populated via a call to `Environment.getConfig()`, explicit initialization is required for all objects.

Parameters:
  `replicationNumSites` - The total number of sites in the replication group.

#### getReplicationNumSites

    public int getReplicationNumSites()

Get the total number of sites configured in this EnvironmentConfig object.

This method cannot be called by replication manager applications.

Note that most applications will be looking for the `Environment.getReplicationNumSites()` method which returns the number of sites in the replication group as defined by the underlying environment object.

Returns:
  The total number of sites configured in the EnvironmentConfig object.

#### setReplicationPriority

    public void setReplicationPriority(int replicationPriority)

Set the current environment's priority. Priority is used to determine which replicated site will be selected as master when an election occurs.

Parameters:
  `replicationPriority` - The database environment priority.

#### getReplicationPriority

    public int getReplicationPriority()

Get the current environment's priority. Priority is used to determine which replicated site will be selected as master when an election occurs.

Returns:
  The database environment priority.

#### setTestAndSetSpins

    public void setTestAndSetSpins(int mutexTestAndSetSpins)

Deprecated. replaced by `setMutexTestAndSetSpins(int)`
Set the number of times test-and-set mutexes should spin before blocking.

The value defaults to 1 on uniprocessor systems and to 50 times the number of processors on multiprocessor systems.

This method configures only operations performed using a single a `Environment` handle, not an entire database environment.

This method may be called at any time during the life of the application.

Parameters:
  `mutexTestAndSetSpins` - The number of times test-and-set mutexes should spin before blocking.

#### getTestAndSetSpins

    public int getTestAndSetSpins()

Deprecated. replaced by `getMutexTestAndSetSpins()`
Return the number of times test-and-set mutexes should spin before blocking.

This method may be called at any time during the life of the application.

Returns:
  The number of times test-and-set mutexes should spin before blocking.

#### setThreaded

    public void setThreaded(boolean threaded)

Configure the handle to be free-threaded; that is, usable by multiple threads within a single address space.

This is the default; threading is always assumed in Java, so no special configuration is required.

Parameters:
  `threaded` - If true, configure the handle to be free-threaded.

#### getThreaded

    public boolean getThreaded()

Return true if the handle is configured to be free-threaded.

This method may be called at any time during the life of the application.

Returns:
  True if the handle is configured to be free-threaded.

#### setTransactional

    public void setTransactional(boolean transactional)

Configure the database environment for transactions.

This configuration option should be used when transactional guarantees such as atomicity of multiple operations and durability are important.

Parameters:
  `transactional` - If true, configure the database environment for transactions.

#### getTransactional

    public boolean getTransactional()

Return true if the database environment is configured for transactions.

This method may be called at any time during the life of the application.

Returns:
  True if the database environment is configured for transactions.

#### setTxnNoSync

    public void setTxnNoSync(boolean txnNoSync)

Configure the system to not write or synchronously flush the log on transaction commit.

This means that transactions exhibit the ACI (atomicity, consistency, and isolation) properties, but not D (durability); that is, database integrity will be maintained, but if the application or system fails, it is possible some number of the most recently committed transactions may be undone during recovery. The number of transactions at risk is governed by how many log updates can fit into the log buffer, how often the operating system flushes dirty buffers to disk, and how often the log is checkpointed.

This method only affects the specified `Environment` handle (and any other library handles opened within the scope of that handle). For consistent behavior across the environment, all `Environment` handles opened in the database environment must either call this method or the configuration should be specified in the database environment's DB_CONFIG configuration file.

This method may be called at any time during the life of the application.

Parameters:
  `txnNoSync` - If true, configure the system to not write or synchronously flush the log on transaction commit.

#### getTxnNoSync

    public boolean getTxnNoSync()

Return true if the system has been configured to not write or synchronously flush the log on transaction commit.

This method may be called at any time during the life of the application.

Returns:
  True if the system has been configured to not write or synchronously flush the log on transaction commit.

#### setTxnNoWait

    public void setTxnNoWait(boolean txnNoWait)

If a lock is unavailable for any Berkeley DB operation performed in the context of a transaction, cause the operation to throw `LockNotGrantedException` without waiting for the lock.

This method only affects the specified `Environment` handle (and any other library handles opened within the scope of that handle). For consistent behavior across the environment, all `Environment` handles opened in the database environment must either call this method or the configuration should be specified in the database environment's DB_CONFIG configuration file.

This method may be called at any time during the life of the application.

Parameters:
  `txnNoWait` - If true, configure transactions to not wait for locks by default.

#### getTxnNoWait

    public boolean getTxnNoWait()

Return true if the transactions have been configured to not wait for locks by default.

This method may be called at any time during the life of the application.

Returns:
  True if the transactions have been configured to not wait for locks by default.

#### setTxnNotDurable

    public void setTxnNotDurable(boolean txnNotDurable)

Configure the system to not write log records.

This means that transactions exhibit the ACI (atomicity, consistency, and isolation) properties, but not D (durability); that is, database integrity will be maintained, but if the application or system fails, integrity will not persist. All database files must be verified and/or restored from backup after a failure. In order to ensure integrity after application shut down, all database handles must be closed without specifying noSync, or all database changes must be flushed from the database environment cache using the `Environment.checkpoint`.

This method only affects the specified `Environment` handle (and any other library handles opened within the scope of that handle). For consistent behavior across the environment, all `Environment` handles opened in the database environment must either call this method or the configuration should be specified in the database environment's DB_CONFIG configuration file.

This method may be called at any time during the life of the application.

Parameters:
  `txnNotDurable` - If true, configure the system to not write log records.

#### getTxnNotDurable

    public boolean getTxnNotDurable()

Return true if the system has been configured to not write log records.

This method may be called at any time during the life of the application.

Returns:
  True if the system has been configured to not write log records.

#### setTxnSnapshot

    public void setTxnSnapshot(boolean txnSnapshot)

Configure the database environment to run transactions at snapshot isolation by default. See `TransactionConfig.setSnapshot(boolean)` for more information.

This method may be called at any time during the life of the application.

Parameters:
  `txnSnapshot` - If true, configure the system to default to snapshot isolation.

#### getTxnSnapshot

    public boolean getTxnSnapshot()

Return true if the handle is configured to run all transactions at snapshot isolation.

This method may be called at any time during the life of the application.

Returns:
  True if the handle is configured to run all transactions at snapshot isolation.

#### setTxnMaxActive

    public void setTxnMaxActive(int txnMaxActive)

Configure the database environment to support at least txnMaxActive active transactions.

This value bounds the size of the memory allocated for transactions. Child transactions are counted as active until they either commit or abort.

When all of the memory available in the database environment for transactions is in use, calls to `Environment.beginTransaction` will fail (until some active transactions complete). If this interface is never called, the database environment is configured to support at least 20 active transactions.

The database environment's number of active transactions may also be set using the environment's DB_CONFIG file. The syntax of the entry in that file is a single line with the string "set_tx_max", one or more whitespace characters, and the number of transactions. Because the DB_CONFIG file is read when the database environment is opened, it will silently overrule configuration done before that time.

This method configures a database environment, including all threads of control accessing the database environment, not only the operations performed using a specified `Environment` handle.

This method may not be called after the environment has been opened. If joining an existing database environment, any information specified to this method will be ignored.

Parameters:
  `txnMaxActive` - The minimum number of simultaneously active transactions supported by the database environment.

#### getTxnMaxActive

    public int getTxnMaxActive()

Return the minimum number of simultaneously active transactions supported by the database environment.

This method may be called at any time during the life of the application.

Returns:
  The minimum number of simultaneously active transactions supported by the database environment.

#### setTxnTimeout

    public void setTxnTimeout(long txnTimeout)

Set the timeout value for the database environment transactions.

Transaction timeouts are checked whenever a thread of control blocks on a lock or when deadlock detection is performed. The lock is one requested on behalf of a transaction, normally by the database access methods underlying the application. As timeouts are only checked when the lock request first blocks or when deadlock detection is performed, the accuracy of the timeout depends on how often deadlock detection is performed.

Timeout values specified for the database environment may be overridden on a per-transaction basis by `Transaction.setTxnTimeout`.

This method configures a database environment, including all threads of control accessing the database environment, not only the operations performed using a specified `Environment` handle.

This method may be called at any time during the life of the application.

Parameters:
  `txnTimeout` - The timeout value, specified as an unsigned 32-bit number of microseconds, limiting the maximum timeout to roughly 71 minutes.

Throws:
  `java.lang.IllegalArgumentException` - if an invalid parameter was specified.

  `DatabaseException` - if a failure occurs.

#### getTxnTimeout

    public long getTxnTimeout()

Return the database environment transaction timeout value, in microseconds; a timeout of 0 means no timeout is set.

This method may be called at any time during the life of the application.

Returns:
  The database environment transaction timeout value, in microseconds; a timeout of 0 means no timeout is set.

#### setTxnTimestamp

    public void setTxnTimestamp(java.util.Date txnTimestamp)

Recover to the specified time rather than to the most current possible date.

Once a database environment has been upgraded to a new version of Berkeley DB involving a log format change, it is no longer possible to recover to a specific time before that upgrade.

This method configures only operations performed using a single a `Environment` handle, not an entire database environment.

This method may not be called after the environment has been opened.

Parameters:
  `txnTimestamp` - The recovery timestamp. Only the seconds (not the milliseconds) of the timestamp are used.

#### getTxnTimestamp

    public java.util.Date getTxnTimestamp()

Return the time to which recovery will be done, or 0 if recovery will be done to the most current possible date.

Returns:
  The time to which recovery will be done, or 0 if recovery will be done to the most current possible date.

#### setTxnWriteNoSync

    public void setTxnWriteNoSync(boolean txnWriteNoSync)

Configure the system to write, but not synchronously flush, the log on transaction commit.

This means that transactions exhibit the ACI (atomicity, consistency, and isolation) properties, but not D (durability); that is, database integrity will be maintained, but if the system fails, it is possible some number of the most recently committed transactions may be undone during recovery. The number of transactions at risk is governed by how often the system flushes dirty buffers to disk and how often the log is checkpointed.

This method only affects the specified `Environment` handle (and any other library handles opened within the scope of that handle). For consistent behavior across the environment, all `Environment` handles opened in the database environment must either call this method or the configuration should be specified in the database environment's DB_CONFIG configuration file.

This method may be called at any time during the life of the application.

Parameters:
  `txnWriteNoSync` - If true, configure the system to write, but not synchronously flush, the log on transaction commit.

#### getTxnWriteNoSync

    public boolean getTxnWriteNoSync()

Return true if the system has been configured to write, but not synchronously flush, the log on transaction commit.

This method may be called at any time during the life of the application.

Returns:
  True if the system has been configured to write, but not synchronously flush, the log on transaction commit.

#### setUseEnvironment

    public void setUseEnvironment(boolean useEnvironment)

Configure the database environment to accept information from the process environment when naming files, regardless of the status of the process.

Because permitting users to specify which files are used can create security problems, environment information will be used in file naming for all users only if configured to do so.

Parameters:
  `useEnvironment` - If true, configure the database environment to accept information from the process environment when naming files.

#### getUseEnvironment

    public boolean getUseEnvironment()

Return true if the database environment is configured to accept information from the process environment when naming files.

This method may be called at any time during the life of the application.

Returns:
  True if the database environment is configured to accept information from the process environment when naming files.

#### setUseEnvironmentRoot

    public void setUseEnvironmentRoot(boolean useEnvironmentRoot)

Configure the database environment to accept information from the process environment when naming files, if the process has appropriate permissions (for example, users with a user-ID of 0 on UNIX systems).

Because permitting users to specify which files are used can create security problems, environment information will be used in file naming for all users only if configured to do so.

Parameters:
  `useEnvironmentRoot` - If true, configure the database environment to accept information from the process environment when naming files if the process has appropriate permissions.

#### getUseEnvironmentRoot

    public boolean getUseEnvironmentRoot()

Return true if the database environment is configured to accept information from the process environment when naming files if the process has appropriate permissions.

This method may be called at any time during the life of the application.

Returns:
  True if the database environment is configured to accept information from the process environment when naming files if the process has appropriate permissions.

#### setVerbose

    public void setVerbose(VerboseConfig flag,
                  boolean enable)

Display verbose information.

This method may be called at any time during the life of the application.

Parameters:
  `flag` - The type of verbose information being configured.

  `enable` - If true, display additional information.

#### getVerbose

    public boolean getVerbose(VerboseConfig flag)

Return if the database environment is configured to display a given type of verbose information.

This method may be called at any time during the life of the application.

Parameters:
  `flag` - The type of verbose information being queried.

Returns:
  If the database environment is configured to display additional information of the specified type.

#### setVerboseDeadlock

    public void setVerboseDeadlock(boolean verboseDeadlock)

Deprecated. replaced by `setVerbose(com.sleepycat.db.VerboseConfig, boolean)`
Display additional information when doing deadlock detection.

This method may be called at any time during the life of the application.

Parameters:
  `verboseDeadlock` - If true, display additional information when doing deadlock detection.

#### getVerboseDeadlock

    public boolean getVerboseDeadlock()

Deprecated. replaced by `getVerbose(com.sleepycat.db.VerboseConfig)`
Return if the database environment is configured to display additional information when doing deadlock detection.

This method may be called at any time during the life of the application.

Returns:
  If the database environment is configured to display additional information when doing deadlock detection.

#### setVerboseRecovery

    public void setVerboseRecovery(boolean verboseRecovery)

Deprecated. replaced by `setVerbose(com.sleepycat.db.VerboseConfig, boolean)`
Display additional information when performing recovery.

This method may be called at any time during the life of the application.

Parameters:
  `verboseRecovery` - If true, display additional information when performing recovery.

#### getVerboseRecovery

    public boolean getVerboseRecovery()

Deprecated. replaced by `getVerbose(com.sleepycat.db.VerboseConfig)`
Return if the database environment is configured to display additional information when performing recovery.

This method may be called at any time during the life of the application.

Returns:
  If the database environment is configured to display additional information when performing recovery.

#### setVerboseRegister

    public void setVerboseRegister(boolean verboseRegister)

Deprecated. replaced by `setVerbose(com.sleepycat.db.VerboseConfig, boolean)`
Display additional information concerning support for the `setRegister(boolean)` method.

This method may be called at any time during the life of the application.

Parameters:
  `verboseRegister` - If true, display additional information concerning support for the `setRegister(boolean)` method

#### getVerboseRegister

    public boolean getVerboseRegister()

Deprecated. replaced by `getVerbose(com.sleepycat.db.VerboseConfig)`
Return if the database environment is configured to display additional information concerning support for the `setRegister(boolean)` method.

This method may be called at any time during the life of the application.

Returns:
  If the database environment is configured to display additional information concerning support for the `setRegister(boolean)` method.

#### setVerboseReplication

    public void setVerboseReplication(boolean verboseReplication)

Deprecated. replaced by `setVerbose(com.sleepycat.db.VerboseConfig, boolean)`
Display additional information when processing replication messages.

Note, to get complete replication logging when debugging replication applications, you must also configure and build the Berkeley DB library with the --enable-diagnostic configuration option as well as call this method.

This method may be called at any time during the life of the application.

Parameters:
  `verboseReplication` - If true, display additional information when processing replication messages.

#### getVerboseReplication

    public boolean getVerboseReplication()

Deprecated. replaced by `getVerbose(com.sleepycat.db.VerboseConfig)`
Return if the database environment is configured to display additional information when processing replication messages.

This method may be called at any time during the life of the application.

Returns:
  If the database environment is configured to display additional information when processing replication messages.

#### setVerboseWaitsFor

    public void setVerboseWaitsFor(boolean verboseWaitsFor)

Deprecated. replaced by `setVerbose(com.sleepycat.db.VerboseConfig, boolean)`
Display the waits-for table when doing deadlock detection.

This method may be called at any time during the life of the application.

Parameters:
  `verboseWaitsFor` - If true, display the waits-for table when doing deadlock detection.

#### getVerboseWaitsFor

    public boolean getVerboseWaitsFor()

Deprecated. replaced by `getVerbose(com.sleepycat.db.VerboseConfig)`
Return if the database environment is configured to display the waits-for table when doing deadlock detection.

This method may be called at any time during the life of the application.

Returns:
  If the database environment is configured to display the waits-for table when doing deadlock detection.

#### setYieldCPU

    public void setYieldCPU(boolean yieldCPU)

Configure the system to yield the processor immediately after each page or mutex acquisition.

This functionality should never be used for purposes other than stress testing.

This method only affects the specified `Environment` handle (and any other library handles opened within the scope of that handle). For consistent behavior across the environment, all `Environment` handles opened in the database environment must either call this method or the configuration should be specified in the database environment's DB_CONFIG configuration file.

This method may be called at any time during the life of the application.

Parameters:
  `yieldCPU` - If true, configure the system to yield the processor immediately after each page or mutex acquisition.

#### getYieldCPU

    public boolean getYieldCPU()

Return true if the system has been configured to yield the processor immediately after each page or mutex acquisition.

This method may be called at any time during the life of the application.

Returns:
  True if the system has been configured to yield the processor immediately after each page or mutex acquisition.