EnvironmentConfig (openAPI 2.0.1 API)

java.lang.Object
- jetbrains.exodus.AbstractConfig
- - jetbrains.exodus.env.EnvironmentConfig

```
public class EnvironmentConfig
extends AbstractConfig
```
Specifies settings of Environment. Default settings are specified by DEFAULT which is immutable. Any newly created EnvironmentConfig has the same settings as DEFAULT.
As a rule, the EnvironmentConfig instance is created along with the Environment one. E.g., creation of Environment with some tuned garbage collector settings can look as follows:
```
     final EnvironmentConfig config = new EnvironmentConfig();
     final Environment env = Environments.newInstance(""dbDirectory", config.setGcFileMinAge(3).setGcRunPeriod(60000));
 
```
Some setting are mutable at runtime and some are immutable. Immutable at runtime settings can be changed, but they won't take effect on the Environment instance. Those settings are applicable only during Environment instance creation.
Some settings can be changed only before the database is physically created on storage device. E.g., LOG_FILE_SIZE defines the size of a single Log file (.xd file) which cannot be changed for existing databases. It makes sense to choose values of such settings at design time and hardcode them.
You can define custom processing of changed settings values by AbstractConfig.addChangedSettingsListener(ConfigSettingChangeListener). Override ConfigSettingChangeListener.beforeSettingChanged(String, Object, Map) to pre-process mutations of settings and ConfigSettingChangeListener.afterSettingChanged(String, Object, Map) to post-process them.
See Also:

Environment, Environment.getEnvironmentConfig()

Field Summary

Fields
Modifier and Type	Field and Description
`static java.lang.String`	`CIPHER_BASIC_IV` Defines basic IV (initialization vector) which will be used to encrypt the database.
`static java.lang.String`	`CIPHER_ID` Defines id of StreamCipherProvider which will be used to encrypt the database.
`static java.lang.String`	`CIPHER_KEY` Defines the key which will be used to encrypt the database.
`static EnvironmentConfig`	`DEFAULT`
`static java.lang.String`	`ENV_CLOSE_FORCEDLY` If is set to `true` then Environment.close() doest't check if there are unfinished transactions.
`static java.lang.String`	`ENV_COMPACT_ON_OPEN` If is set to `true` then the Environment will compact itself on opening.
`static java.lang.String`	`ENV_FAIL_FAST_IN_READONLY` If is set to `true` and ENV_IS_READONLY is also `true` then the Environment obligatorily creates transactions for which Transaction.isReadonly() is `true`.
`static java.lang.String`	`ENV_GATHER_STATISTICS` If is set to `true` then the Environment gathers statistics.
`static java.lang.String`	`ENV_IS_READONLY` If is set to `true` then the Environment instance is read-only.
`static java.lang.String`	`ENV_MAX_PARALLEL_READONLY_TXNS` Deprecated.
`static java.lang.String`	`ENV_MAX_PARALLEL_TXNS` Defines the number of transactions that can be started in parallel.
`static java.lang.String`	`ENV_MONITOR_TXNS_CHECK_FREQ` If ENV_MONITOR_TXNS_TIMEOUT is non-zero then stuck transactions monitor starts and checks Environment's transactions with this frequency (period) specified in milliseconds.
`static java.lang.String`	`ENV_MONITOR_TXNS_EXPIRATION_TIMEOUT` Defines Transaction expiration timeout in milliseconds.
`static java.lang.String`	`ENV_MONITOR_TXNS_TIMEOUT` Defines Transaction timeout in milliseconds.
`static java.lang.String`	`ENV_READONLY_EMPTY_STORES` If is set to `true` and ENV_IS_READONLY is also `true` then Environment.openStore(String, StoreConfig, Transaction) doesn't try to create a Store, but returns an empty immutable instance instead.
`static java.lang.String`	`ENV_STOREGET_CACHE_MAX_VALUE_SIZE`
`static java.lang.String`	`ENV_STOREGET_CACHE_MIN_TREE_SIZE`
`static java.lang.String`	`ENV_STOREGET_CACHE_SIZE` Defines the size of the "store-get" cache.
`static java.lang.String`	`ENV_TXN_DOWNGRADE_AFTER_FLUSH` If is set to `true` then any upgraded Transaction will downgrade itself after Transaction.flush().
`static java.lang.String`	`ENV_TXN_REPLAY_MAX_COUNT` Defines the number of times which a Transaction can try to flush without attempts to upgrade (switch to an exclusive mode).
`static java.lang.String`	`ENV_TXN_REPLAY_TIMEOUT` Defines the number of millisecond which a Transaction can try to flush without attempts to upgrade (switch to an exclusive mode).
`static java.lang.String`	`ENV_TXN_SINGLE_THREAD_WRITES` If is set to `true` then any write operation can be performed only in the thread which the transaction was created in.
`static java.lang.String`	`ENV_TXN_TRACE_FINISH` If is set to `true` then each transaction, read/write or read-only, saves stack trace when it is finished (aborted or committed).
`static java.lang.String`	`GC_ENABLED` If is set to `true` then the database garbage collector is enabled.
`static java.lang.String`	`GC_FILES_DELETION_DELAY` Defines the number of milliseconds which deletion of any successfully cleaned `Log` file (.xd file) is postponed for.
`static java.lang.String`	`GC_FILES_INTERVAL` Deprecated.
`static java.lang.String`	`GC_MIN_FILE_AGE` Defines the minimum age of a `Log` file (.xd file) to consider it for cleaning by the database garbage collector.
`static java.lang.String`	`GC_MIN_UTILIZATION` Defines percent of minimum database utilization.
`static java.lang.String`	`GC_RENAME_FILES` If is set to `true` the database garbage collector renames files rather than deletes them.
`static java.lang.String`	`GC_RUN_EVERY` If set to nonzero value, GC is forced every this number of seconds.
`static java.lang.String`	`GC_RUN_PERIOD` Defines the number of milliseconds after which background cleaning cycle (single run of the database garbage collector) can be repeated if the previous one didn't reach required utilization.
`static java.lang.String`	`GC_START_IN` Defines the number of milliseconds which the database garbage collector is postponed for after the Environment is created.
`static java.lang.String`	`GC_TRANSACTION_ACQUIRE_TIMEOUT` Defines timeout in milliseconds which is used by the database garbage collector to acquire exclusive Transaction for its purposes if GC_USE_EXCLUSIVE_TRANSACTION is `true`.
`static java.lang.String`	`GC_TRANSACTION_TIMEOUT` Defines timeout in milliseconds which is used by the database garbage collector to reclaim non-expired data in several files inside single GC Transaction acquired exclusively.
`static java.lang.String`	`GC_USE_EXCLUSIVE_TRANSACTION` If is set to `true` the database garbage collector tries to acquire exclusive Transaction for its purposes.
`static java.lang.String`	`GC_USE_EXPIRATION_CHECKER` Deprecated.
`static java.lang.String`	`GC_UTILIZATION_FROM_FILE` If is not empty, defines full path to the file with stored utilization.
`static java.lang.String`	`GC_UTILIZATION_FROM_SCRATCH` If is set to `true` then database utilization will be computed from scratch before the first cleaning cycle (single run of the database garbage collector) is triggered, i.e.
`static java.lang.String`	`LOG_ALLOW_RAM_DISK` For DataReaderWriterProvider.DEFAULT_READER_WRITER_PROVIDER used as DataReaderWriterProvider service provider interface implementation, if is set to `true` then the database can be opened on RAM-disk.
`static java.lang.String`	`LOG_ALLOW_REMOTE` For DataReaderWriterProvider.DEFAULT_READER_WRITER_PROVIDER used as DataReaderWriterProvider service provider interface implementation, if is set to `true` then the database can be opened on a remote storage.
`static java.lang.String`	`LOG_ALLOW_REMOVABLE` For DataReaderWriterProvider.DEFAULT_READER_WRITER_PROVIDER used as DataReaderWriterProvider service provider interface implementation, if is set to `true` then the database can be opened on a removable storage.
`static java.lang.String`	`LOG_CACHE_FREE_PHYSICAL_MEMORY_THRESHOLD` If LOG_CACHE_USE_NIO is `true` defines the minimum size in bytes of free physical memory maintained by the cache memory-mapped files on the host where the JVM runs.
`static java.lang.String`	`LOG_CACHE_GENERATION_COUNT` Defines the number of generations of non-blocking LogCache.
`static java.lang.String`	`LOG_CACHE_NON_BLOCKING` If is set to `true` the LogCache uses lock-free data structures.
`static java.lang.String`	`LOG_CACHE_OPEN_FILES` Defines the maximum number of open files that LogCache maintains in order to reduce system calls to open and close files.
`static java.lang.String`	`LOG_CACHE_PAGE_SIZE` Defines the size in bytes of a single page (byte array) in the LogCache.
`static java.lang.String`	`LOG_CACHE_READ_AHEAD_MULTIPLE` Defines the number of successive pages to be read at once in case of LogCache miss.
`static java.lang.String`	`LOG_CACHE_SHARED` If is set to `true` the LogCache is shared.
`static java.lang.String`	`LOG_CACHE_USE_NIO` If is set to `true` any immutable file can be mapped in memory provided there is enough physical memory.
`static java.lang.String`	`LOG_CACHE_USE_SOFT_REFERENCES` If is set to `true` LogCache uses soft references for holding cached pages.
`static java.lang.String`	`LOG_CACHE_WARMUP` If is set to `true` LogCache will populate itself with database file pages right after the database is opened using this `EnvironmentConfig` instance.
`static java.lang.String`	`LOG_CLEAN_DIRECTORY_EXPECTED` If is set to `true` then the Log constructor fails if the database directory is not clean.
`static java.lang.String`	`LOG_CLEAR_INVALID` If is set to `true` then the Log constructor implicitly clears the database if it occurred to be invalid when opened.
`static java.lang.String`	`LOG_DATA_READER_WRITER_PROVIDER` Defines fully-qualified name of the DataReaderWriterProvider service provider interface implementation which will be used to create DataReader and DataWriter instances.
`static java.lang.String`	`LOG_DURABLE_WRITE` If is set to `true` forces file system's fsync call after each committed or flushed transaction.
`static java.lang.String`	`LOG_FILE_SIZE` Defines the maximum size in kilobytes of a single `Log` file (.xd file).
`static java.lang.String`	`LOG_FULL_FILE_READ_ONLY` If is set to `true` then each complete and immutable `Log` file (.xd file) is marked with read-only attribute.
`static java.lang.String`	`LOG_LOCK_ID` Defines the debug identifier to be written to the lock file alongside with other debug information.
`static java.lang.String`	`LOG_LOCK_TIMEOUT` Defines the number of milliseconds the Log constructor waits for the lock file.
`static java.lang.String`	`LOG_SYNC_PERIOD` Sets the period in milliseconds to force file system's fsync call that often if LOG_DURABLE_WRITE is switched off.
`static java.lang.String`	`MANAGEMENT_ENABLED` If is set to `true` then the Environment exposes two JMX managed beans.
`static java.lang.String`	`MANAGEMENT_OPERATIONS_RESTRICTED` If is set to `true` then exposed JMX managed beans cannot have operations.
`static java.lang.String`	`MEMORY_USAGE` Defines absolute value of memory in bytes that can be used by the LogCache.
`static java.lang.String`	`MEMORY_USAGE_PERCENTAGE` Defines percent of max memory (specified by the "-Xmx" java parameter) that can be used by the LogCache.
`static java.lang.String`	`META_SERVER` If set to some value different from `null`, expose created environment via given server.
`static java.lang.String`	`PROFILER_ENABLED` If is set to `true` database profiler is enabled.
`static java.lang.String`	`TREE_DUP_MAX_PAGE_SIZE` Defines the maximum size of page of duplicates sub-B+Tree.
`static java.lang.String`	`TREE_MAX_PAGE_SIZE` Defines the maximum size of page of B+Tree.
`static java.lang.String`	`TREE_NODES_CACHE_SIZE` Deprecated.
`static java.lang.String`	`USE_VERSION1_FORMAT`

Constructor Summary

Constructors
Constructor and Description

EnvironmentConfig()

EnvironmentConfig(@NotNull ConfigurationStrategy strategy)

Constructors
Constructor and Description
`EnvironmentConfig()`
`EnvironmentConfig(@NotNull ConfigurationStrategy strategy)`

Method Summary

All Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`long`	`getCipherBasicIV()` Returns basic IV (initialization vector) which will be used to encrypt the database.
`@Nullable java.lang.String`	`getCipherId()` Returns id of StreamCipherProvider which will be used to encrypt the database.
`@Nullable byte[]`	`getCipherKey()` Returns the key which will be used to encrypt the database or `null` for no encryption.
`boolean`	`getEnvCloseForcedly()` Returns `true` if Environment.close() shouldn't check if there are unfinished transactions.
`boolean`	`getEnvCompactOnOpen()` Returns `true` if the Environment will compact itself on opening.
`boolean`	`getEnvFailFastInReadonly()` If is set to `true` and ENV_IS_READONLY is also `true` then the Environment obligatorily creates transactions for which Transaction.isReadonly() is `true`.
`boolean`	`getEnvGatherStatistics()` Returns `true` if the Environment gathers statistics.
`boolean`	`getEnvIsReadonly()` Returns `true` if the Environment instance is read-only.
`int`	`getEnvMaxParallelReadonlyTxns()` Deprecated.
`int`	`getEnvMaxParallelTxns()` Returns the number of transactions that can be started in parallel.
`int`	`getEnvMonitorTxnsCheckFreq()` If ENV_MONITOR_TXNS_TIMEOUT is non-zero then stuck transactions monitor starts and checks Environment's transactions with this frequency (period) specified in milliseconds.
`int`	`getEnvMonitorTxnsExpirationTimeout()` Defines Transaction expiration timeout in milliseconds.
`int`	`getEnvMonitorTxnsTimeout()` Returns Transaction timeout in milliseconds.
`boolean`	`getEnvReadonlyEmptyStores()` If is set to `true` and ENV_IS_READONLY is also `true` then Environment.openStore(String, StoreConfig, Transaction) doesn't try to create a Store, but returns an empty immutable instance instead.
`int`	`getEnvStoreGetCacheMaxValueSize()`
`int`	`getEnvStoreGetCacheMinTreeSize()`
`int`	`getEnvStoreGetCacheSize()` Returns the size of the "store-get" cache.
`boolean`	`getEnvTxnDowngradeAfterFlush()` If is set to `true` then any upgraded Transaction will downgrade itself after Transaction.flush().
`int`	`getEnvTxnReplayMaxCount()` Returns the number of times which a Transaction can try to flush without attempts to upgrade (switch to an exclusive mode).
`long`	`getEnvTxnReplayTimeout()` Returns the number of millisecond which a Transaction can try to flush without attempts to upgrade (switch to an exclusive mode).
`boolean`	`getEnvTxnSingleThreadWrites()` If is set to `true` then any write operation can be performed only in the thread which the transaction was created in.
`int`	`getGcFileMinAge()` Returns the minimum age of a `Log` file (.xd file) to consider it for cleaning by the database garbage collector.
`int`	`getGcFilesDeletionDelay()` Returns the number of milliseconds which deletion of any successfully cleaned `Log` file (.xd file) is postponed for.
`int`	`getGcFilesInterval()` Deprecated.
`int`	`getGcMinUtilization()` Returns percent of minimum database utilization.
`boolean`	`getGcRenameFiles()` If returns `true` the database garbage collector renames files rather than deletes them.
`int`	`getGcRunEvery()` GC is forced every this number of seconds.
`int`	`getGcRunPeriod()` Returns the number of milliseconds after which background cleaning cycle (single run of the database garbage collector) can be repeated if the previous one didn't reach required utilization.
`int`	`getGcStartIn()` Returns the number of milliseconds which the database garbage collector is postponed for after the Environment is created.
`int`	`getGcTransactionAcquireTimeout()` Returns timeout in milliseconds which is used by the database garbage collector to acquire exclusive Transaction for its purposes if GC_USE_EXCLUSIVE_TRANSACTION is `true`.
`int`	`getGcTransactionTimeout()` Returns timeout in milliseconds which is used by the database garbage collector to reclaim non-expired data in several files inside single GC Transaction acquired exclusively.
`boolean`	`getGcUseExclusiveTransaction()` Returns `true` if the database garbage collector tries to acquire exclusive Transaction for its purposes.
`boolean`	`getGcUseExpirationChecker()` Deprecated.
`java.lang.String`	`getGcUtilizationFromFile()` Returns full path to the file with stored utilization.
`boolean`	`getGcUtilizationFromScratch()` Returns `true` if database utilization will be computed from scratch before the first cleaning cycle (single run of the database garbage collector) is triggered, i.e.
`long`	`getLogCacheFreePhysicalMemoryThreshold()` If LOG_CACHE_USE_NIO is `true` defines the minimum size in bytes of free physical memory maintained by the cache memory-mapped files on the host where the JVM runs.
`int`	`getLogCacheGenerationCount()` Returns the number of generations of non-blocking LogCache.
`int`	`getLogCacheOpenFilesCount()` Returns the maximum number of open files that the LogCache maintains in order to reduce system calls to open and close files.
`int`	`getLogCachePageSize()` Returns the size in bytes of a single page (byte array) in the LogCache.
`int`	`getLogCacheReadAheadMultiple()` Returns the number of successive pages to be read at once in case of LogCache miss.
`boolean`	`getLogCacheUseNio()` Returns `true` if any immutable .xd file can be mapped in memory provided there is enough physical memory.
`boolean`	`getLogCacheUseSoftReferences()` Returns `true` LogCache uses soft references for holding cached pages.
`boolean`	`getLogCacheWarmup()` Returns `true` if LogCache will populate itself with database file pages right after the database is opened using this `EnvironmentConfig` instance.
`java.lang.String`	`getLogDataReaderWriterProvider()` Returns fully-qualified name of the DataReaderWriterProvider service provide interface implementation which will be used to create DataReader and DataWriter instances.
`boolean`	`getLogDurableWrite()` Returns `true` if file system's fsync call after should be executed after each committed or flushed transaction.
`long`	`getLogFileSize()` Returns the maximum size in kilobytes of a single `Log` file (.xd file).
`java.lang.String`	`getLogLockId()` Sets the debug identifier to be written to the lock file alongside with other debug information.
`long`	`getLogLockTimeout()` Returns the number of milliseconds the `Log` constructor waits for the lock file.
`long`	`getLogSyncPeriod()` Returns the period in milliseconds to force file system's fsync call that often if LOG_DURABLE_WRITE is switched off.
`boolean`	`getManagementOperationsRestricted()` If is set to `true` then exposed JMX managed beans cannot have operations.
`java.lang.Long`	`getMemoryUsage()` Returns absolute value of memory in bytes that can be used by the LogCache if it is set.
`int`	`getMemoryUsagePercentage()` Returns percent of max memory (specified by the "-Xmx" java parameter) that can be used by the LogCache.
`MetaServer`	`getMetaServer()`
`boolean`	`getProfilerEnabled()` If is set to `true` database profiler is enabled.
`int`	`getTreeDupMaxPageSize()` Returns the maximum size of page of duplicates sub-B+Tree.
`int`	`getTreeMaxPageSize()` Returns the maximum size of page of B+Tree.
`int`	`getTreeNodesCacheSize()` Deprecated.
`boolean`	`getUseVersion1Format()`
`boolean`	`isEnvTxnTraceFinish()` If is set to `true` then each transaction, read/write or read-only, saves stack trace when it is finished (aborted or committed).
`boolean`	`isGcEnabled()` Returns `true` if the database garbage collector is enabled.
`boolean`	`isLogAllowRamDisk()` For DataReaderWriterProvider.DEFAULT_READER_WRITER_PROVIDER used as DataReaderWriterProvider service provider interface implementation, if is set to `true` then the database can be opened on RAM-disk.
`boolean`	`isLogAllowRemote()` For DataReaderWriterProvider.DEFAULT_READER_WRITER_PROVIDER used as DataReaderWriterProvider service provider interface implementation, if is set to `true` then the database can be opened on a remote storage.
`boolean`	`isLogAllowRemovable()` For DataReaderWriterProvider.DEFAULT_READER_WRITER_PROVIDER used as DataReaderWriterProvider service provider interface implementation, if is set to `true` then the database can be opened on a removable storage.
`boolean`	`isLogCacheNonBlocking()` Returns `true` if the LogCache should use lock-free data structures.
`boolean`	`isLogCacheShared()` Returns `true` if the LogCache is shared.
`boolean`	`isLogCleanDirectoryExpected()` Returns `true` if the Log constructor fails if the database directory is not clean.
`boolean`	`isLogClearInvalid()` Returns `true` if the Log constructor implicitly clears the database if it occurred to be invalid when opened.
`boolean`	`isLogFullFileReadonly()` Returns `true` if each complete and immutable `Log` file (.xd file) should marked with read-only attribute.
`boolean`	`isManagementEnabled()` Return `true` if the Environment exposes two JMX managed beans.
`EnvironmentConfig`	`setCipherBasicIV(long basicIV)` Sets basic IV (initialization vector) which will be used to encrypt the database.
`EnvironmentConfig`	`setCipherId(java.lang.String id)` Sets id of StreamCipherProvider which will be used to encrypt the database.
`EnvironmentConfig`	`setCipherKey(java.lang.String cipherKey)` Sets the key which will be used to encrypt the database.
`EnvironmentConfig`	`setEnvCloseForcedly(boolean closeForcedly)` Set `true` if Environment.close() shouldn't check if there are unfinished transactions.
`EnvironmentConfig`	`setEnvCompactOnOpen(boolean compactOnOpen)` Set `true` if the Environment should compact itself on opening Default value is `false`.
`EnvironmentConfig`	`setEnvFailFastInReadonly(boolean failFast)` If is set to `true` and ENV_IS_READONLY is also `true` then the Environment obligatorily creates transactions for which Transaction.isReadonly() is `true`.
`EnvironmentConfig`	`setEnvGatherStatistics(boolean gatherStatistics)` Set `true` if the Environment should gather statistics.
`EnvironmentConfig`	`setEnvIsReadonly(boolean isReadonly)` Set `true` to turn the Environment instance to read-only mode.
`EnvironmentConfig`	`setEnvMaxParallelReadonlyTxns(int maxParallelReadonlyTxns)` Sets the number of read-only transactions that can be started in parallel.
`EnvironmentConfig`	`setEnvMaxParallelTxns(int maxParallelTxns)` Sets the number of transactions that can be started in parallel.
`EnvironmentConfig`	`setEnvMonitorTxnsCheckFreq(int freq)` If ENV_MONITOR_TXNS_TIMEOUT is non-zero then stuck transactions monitor starts and checks Environment's transactions with this frequency (period) specified in milliseconds.
`EnvironmentConfig`	`setEnvMonitorTxnsExpirationTimeout(int timeout)` Defines Transaction expiration timeout in milliseconds.
`EnvironmentConfig`	`setEnvMonitorTxnsTimeout(int timeout)` Sets Transaction timeout in milliseconds.
`EnvironmentConfig`	`setEnvReadonlyEmptyStores(boolean readonlyEmptyStores)` If is set to `true` and ENV_IS_READONLY is also `true` then Environment.openStore(String, StoreConfig, Transaction) doesn't try to create a Store, but returns an empty immutable instance instead.
`EnvironmentConfig`	`setEnvStoreGetCacheMaxValueSize(int valueSize)`
`EnvironmentConfig`	`setEnvStoreGetCacheMinTreeSize(int treeSize)`
`EnvironmentConfig`	`setEnvStoreGetCacheSize(int storeGetCacheSize)` Sets the size of the "store-get" cache.
`EnvironmentConfig`	`setEnvTxnDowngradeAfterFlush(boolean downgrade)` If is set to `true` then any upgraded Transaction will downgrade itself after Transaction.flush().
`EnvironmentConfig`	`setEnvTxnReplayMaxCount(int count)` Sets the number of times which a Transaction can try to flush without attempts to upgrade (switch to an exclusive mode).
`EnvironmentConfig`	`setEnvTxnReplayTimeout(long timeout)` Sets the number of millisecond which a Transaction can try to flush without attempts to upgrade (switch to an exclusive mode).
`EnvironmentConfig`	`setEnvTxnSingleThreadWrites(boolean singleThreadWrites)` If is set to `true` then any write operation can be performed only in the thread which the transaction was created in.
`EnvironmentConfig`	`setEnvTxnTraceFinish(boolean traceFinish)` If is set to `true` then each transaction, read/write or read-only, saves stack trace when it is finished (aborted or committed).
`EnvironmentConfig`	`setFullFileReadonly(boolean readonly)` Set `true` if each complete and immutable `Log` file (.xd file) should marked with read-only attribute.
`EnvironmentConfig`	`setGcEnabled(boolean enabled)` Set `true` to enable the database garbage collector.
`EnvironmentConfig`	`setGcFileMinAge(int minAge)` Returns the minimum age of a `Log` file (.xd file) to consider it for cleaning by the database garbage collector.
`EnvironmentConfig`	`setGcFilesDeletionDelay(int delay)` Sets the number of milliseconds which deletion of any successfully cleaned `Log` file (.xd file) is postponed for.
`EnvironmentConfig`	`setGcFilesInterval(int files)` Deprecated.
`EnvironmentConfig`	`setGcMinUtilization(int percent)` Sets percent of minimum database utilization.
`EnvironmentConfig`	`setGcRenameFiles(boolean rename)` Set `true` if the database garbage collector should rename files rather than deletes them.
`EnvironmentConfig`	`setGcRunEvery(int seconds)` Sets GC to be forced every this number of seconds.
`EnvironmentConfig`	`setGcRunPeriod(int runPeriod)` Sets the number of milliseconds after which background cleaning cycle (single run of the database garbage collector) can be repeated if the previous one didn't reach required utilization.
`EnvironmentConfig`	`setGcStartIn(int startInMillis)` Sets the number of milliseconds which the database garbage collector is postponed for after the Environment is created.
`EnvironmentConfig`	`setGcTransactionAcquireTimeout(int txnAcquireTimeout)` Sets timeout in milliseconds which is used by the database garbage collector to acquire exclusive Transaction for its purposes if GC_USE_EXCLUSIVE_TRANSACTION is `true`.
`EnvironmentConfig`	`setGcTransactionTimeout(int txnTimeout)` Sets timeout in milliseconds which is used by the database garbage collector to reclaim non-expired data in several files inside single GC Transaction acquired exclusively.
`EnvironmentConfig`	`setGcUseExclusiveTransaction(boolean useExclusiveTransaction)` Sets `true` if the database garbage collector should try to acquire exclusive Transaction for its purposes.
`EnvironmentConfig`	`setGcUseExpirationChecker(boolean useExpirationChecker)` Deprecated.
`EnvironmentConfig`	`setGcUtilizationFromFile(java.lang.String file)` Sets full path to the file with stored utilization.
`EnvironmentConfig`	`setGcUtilizationFromScratch(boolean fromScratch)` Set `true` if database utilization should be computed from scratch before the first cleaning cycle (single run of the database garbage collector) is triggered, i.e.
`EnvironmentConfig`	`setLogAllowRamDisk(boolean allow)` For DataReaderWriterProvider.DEFAULT_READER_WRITER_PROVIDER used as DataReaderWriterProvider service provider interface implementation, if is set to `true` then the database can be opened on RAM-disk.
`EnvironmentConfig`	`setLogAllowRemote(boolean allow)` For DataReaderWriterProvider.DEFAULT_READER_WRITER_PROVIDER used as DataReaderWriterProvider service provider interface implementation, if is set to `true` then the database can be opened on a remote storage.
`EnvironmentConfig`	`setLogAllowRemovable(boolean allow)` For DataReaderWriterProvider.DEFAULT_READER_WRITER_PROVIDER used as DataReaderWriterProvider service provider interface implementation, if is set to `true` then the database can be opened on a removable storage.
`EnvironmentConfig`	`setLogCacheFreePhysicalMemoryThreshold(long freePhysicalMemoryThreshold)` If LOG_CACHE_USE_NIO is `true` sets the minimum size in bytes of free physical memory maintained by the cache memory-mapped files on the host where the JVM runs.
`EnvironmentConfig`	`setLogCacheGenerationCount(int generationCount)` Sets the number of generations of non-blocking LogCache.
`EnvironmentConfig`	`setLogCacheNonBlocking(boolean nonBlocking)` Set `true` if the LogCache should use lock-free data structures.
`EnvironmentConfig`	`setLogCacheOpenFilesCount(int files)` Sets the maximum number of open files that the LogCache maintains in order to reduce system calls to open and close files.
`EnvironmentConfig`	`setLogCachePageSize(int bytes)` Sets the size in bytes of a single page (byte array) in the LogCache.
`EnvironmentConfig`	`setLogCacheReadAheadMultiple(int readAheadMultiple)` Sets the number of successive pages to be read at once in case of LogCache miss.
`EnvironmentConfig`	`setLogCacheShared(boolean shared)` Set `true` if the LogCache should be shared.
`EnvironmentConfig`	`setLogCacheUseNio(boolean useNio)` Set `true` to allow any immutable .xd file to be mapped in memory provided there is enough physical memory.
`EnvironmentConfig`	`setLogCacheUseSoftReferences(boolean useSoftReferences)` Set `true` if LogCache should use soft references for holding cached pages.
`EnvironmentConfig`	`setLogCacheWarmup(boolean warmup)` Set `true` if LogCache should populate itself with database file pages right after the database is opened using this `EnvironmentConfig` instance.
`EnvironmentConfig`	`setLogCleanDirectoryExpected(boolean logCleanDirectoryExpected)` Set `true` if the Log constructor should fail if the database directory is not clean.
`EnvironmentConfig`	`setLogClearInvalid(boolean logClearInvalid)` Set `true` if the Log constructor should implicitly clear the database if it occurred to be invalid when opened.
`EnvironmentConfig`	`setLogDataReaderWriterProvider(@NotNull java.lang.String provider)` Sets fully-qualified name of the DataReaderWriterProvider service provide interface implementation which will be used to create DataReader and DataWriter instances.
`EnvironmentConfig`	`setLogDurableWrite(boolean durableWrite)` Sets flag whether transactions should force fsync after each commit or flush.
`EnvironmentConfig`	`setLogFileSize(long kilobytes)` Sets the maximum size in kilobytes of a single `Log` file (.xd file).
`EnvironmentConfig`	`setLogLockId(java.lang.String id)` Sets the debug identifier to be written to the lock file alongside with other debug information.
`EnvironmentConfig`	`setLogLockTimeout(long millis)` Sets the number of milliseconds the `Log` constructor waits for the lock file.
`EnvironmentConfig`	`setLogSyncPeriod(long millis)` Sets the period in milliseconds to force file system's fsync call that often if LOG_DURABLE_WRITE is switched off.
`EnvironmentConfig`	`setManagementEnabled(boolean managementEnabled)` Set `true` if the Environment should expose two JMX managed beans.
`EnvironmentConfig`	`setManagementOperationsRestricted(boolean operationsRestricted)` If isManagementEnabled() then set `false` in order to expose operations with JMX managed beans in addition to attributes.
`EnvironmentConfig`	`setMemoryUsage(long maxMemory)` Sets absolute value of memory in bytes that can be used by the LogCache.
`EnvironmentConfig`	`setMemoryUsagePercentage(int memoryUsagePercentage)` Sets percent of max memory (specified by the "-Xmx" java parameter) that can be used by the LogCache.
`EnvironmentConfig`	`setMetaServer(MetaServer metaServer)`
`EnvironmentConfig`	`setMutable(boolean isMutable)` Set `true` for making it possible to change settings of this `EnvironmentConfig` instance.
`EnvironmentConfig`	`setProfilerEnabled(boolean enabled)` Set `true` to enable database profiler.
`EnvironmentConfig`	`setSetting(@NotNull java.lang.String key, @NotNull java.lang.Object value)` Sets the value of the setting with the specified key.
`EnvironmentConfig`	`setTreeDupMaxPageSize(int pageSize)` Sets the maximum size of page of duplicates sub-B+Tree.
`EnvironmentConfig`	`setTreeMaxPageSize(int pageSize)` Sets the maximum size of page of B+Tree.
`EnvironmentConfig`	`setTreeNodesCacheSize(int cacheSize)` Deprecated.
`EnvironmentConfig`	`setUseVersion1Format(boolean useVersion1Format)`

Methods inherited from class jetbrains.exodus.AbstractConfig
addChangedSettingsListener, getSetting, getSettings, isMutable, removeChangedSettingsListener, removeSetting, resumeConfigChangeListenersForThread, setSettings, suppressConfigChangeListenersForThread

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
```
  - MEMORY_USAGE
```
public static final java.lang.String MEMORY_USAGE
```
    Defines absolute value of memory in bytes that can be used by the LogCache. By default, is not set.
    Mutable at runtime: no
    
    See Also:
    
    MEMORY_USAGE_PERCENTAGE, Constant Field Values
  - MEMORY_USAGE_PERCENTAGE
```
public static final java.lang.String MEMORY_USAGE_PERCENTAGE
```
    Defines percent of max memory (specified by the "-Xmx" java parameter) that can be used by the LogCache. Is applicable only if MEMORY_USAGE is not set. Default value is 50.
    Mutable at runtime: no
    
    See Also:
    
    MEMORY_USAGE, Constant Field Values
  - USE_VERSION1_FORMAT
```
public static final java.lang.String USE_VERSION1_FORMAT
```
    See Also:
    
    Constant Field Values
  - CIPHER_ID
```
public static final java.lang.String CIPHER_ID
```
    Defines id of StreamCipherProvider which will be used to encrypt the database. Default value is null, which means that the database won't be encrypted. The setting cannot be changed for existing databases. Default value is null.
    Mutable at runtime: no
    
    See Also:
    
    CIPHER_KEY, CIPHER_BASIC_IV, StreamCipher, StreamCipherProvider, Constant Field Values
  - CIPHER_KEY
```
public static final java.lang.String CIPHER_KEY
```
    Defines the key which will be used to encrypt the database. The key is expected to be a hex string representing a byte array which is passed to StreamCipher.init(byte[], long). Is applicable only if CIPHER_ID is not null. The setting cannot be changed for existing databases. Default value is null.
    Mutable at runtime: no
    
    See Also:
    
    CIPHER_ID, CIPHER_BASIC_IV, StreamCipher, StreamCipher.init(byte[], long), StreamCipherProvider, Constant Field Values
  - CIPHER_BASIC_IV
```
public static final java.lang.String CIPHER_BASIC_IV
```
    Defines basic IV (initialization vector) which will be used to encrypt the database. Basic IV is expected to be random (pseudo-random) and unique long value. Basic IV is used to calculate relative IVs which are passed to StreamCipher.init(byte[], long). Is applicable only if CIPHER_ID is not null. The setting cannot be changed for existing databases. Default value is 0L.
    Mutable at runtime: no
    
    See Also:
    
    CIPHER_ID, CIPHER_KEY, StreamCipher, StreamCipher.init(byte[], long), StreamCipherProvider, Constant Field Values
  - PROFILER_ENABLED
```
public static final java.lang.String PROFILER_ENABLED
```
    If is set to true database profiler is enabled. By default, it is disabled.
    Mutable at runtime: no
    
    Since:
    
    1.4.0
    
    See Also:
    
    Constant Field Values
  - LOG_DURABLE_WRITE
```
public static final java.lang.String LOG_DURABLE_WRITE
```
    If is set to true forces file system's fsync call after each committed or flushed transaction. By default, is switched off since it creates great performance overhead and can be controlled manually.
    Mutable at runtime: yes
    
    See Also:
    
    Constant Field Values
  - LOG_FILE_SIZE
```
public static final java.lang.String LOG_FILE_SIZE
```
    Defines the maximum size in kilobytes of a single Log file (.xd file). The setting cannot be changed for existing databases. Default value is 8192L.
    Mutable at runtime: no
    
    See Also:
    
    Constant Field Values
  - LOG_LOCK_TIMEOUT
```
public static final java.lang.String LOG_LOCK_TIMEOUT
```
    Defines the number of milliseconds the Log constructor waits for the lock file. Default value is 0L.
    Mutable at runtime: no
    
    See Also:
    
    Constant Field Values
  - LOG_LOCK_ID
```
public static final java.lang.String LOG_LOCK_ID
```
    Defines the debug identifier to be written to the lock file alongside with other debug information. Default value is ManagementFactory.getRuntimeMXBean().getName() which has a form of pid@hostname.
    Mutable at runtime: no
    
    See Also:
    
    Constant Field Values
  - LOG_CACHE_PAGE_SIZE
```
public static final java.lang.String LOG_CACHE_PAGE_SIZE
```
    Defines the size in bytes of a single page (byte array) in the LogCache. This number of bytes is read from MappedByteBuffer or RandomAccessFile at a time.
    If the LogCache is shared (LOG_CACHE_SHARED) all Environments should be configured to use single LogCache page size.
    Default value is 64 * 1024.
    Mutable at runtime: no
    
    See Also:
    
    Constant Field Values
  - LOG_CACHE_OPEN_FILES
```
public static final java.lang.String LOG_CACHE_OPEN_FILES
```
    Defines the maximum number of open files that LogCache maintains in order to reduce system calls to open and close files. The more open files is allowed the less system calls are performed in addition to reading or mapping files. This value can notably affect performance of database warm-up. Default value is 500. Open files cache is shared amongst all open environments.
    Mutable at runtime: no
    
    See Also:
    
    Constant Field Values
  - LOG_CACHE_USE_NIO
```
public static final java.lang.String LOG_CACHE_USE_NIO
```
    If is set to true any immutable file can be mapped in memory provided there is enough physical memory. On cache miss, LogCache at first tries to check if there is corresponding mapped byte buffer and copies cache page from the buffer, otherwise reads the page from RandomAccessFile. If is set to false then LogCache always reads RandomAccessFile on cache miss. Default value was true before version 1.2.3. As of 1.2.3, default value is false.
    Mutable at runtime: no
    
    See Also:
    
    LOG_CACHE_FREE_PHYSICAL_MEMORY_THRESHOLD, Constant Field Values
  - LOG_CACHE_FREE_PHYSICAL_MEMORY_THRESHOLD
```
public static final java.lang.String LOG_CACHE_FREE_PHYSICAL_MEMORY_THRESHOLD
```
    If LOG_CACHE_USE_NIO is true defines the minimum size in bytes of free physical memory maintained by the cache memory-mapped files on the host where the JVM runs. On cache miss, LogCache checks if corresponding file is mapped in memory, and if it is not and if free physical memory amount is greater than threshold specified by this setting, tries to map the file in memory. Default value is 1_000_000_000L bytes, i.e. ~1GB.
    Mutable at runtime: no
    
    See Also:
    
    LOG_CACHE_USE_NIO, Constant Field Values
  - LOG_CACHE_SHARED
```
public static final java.lang.String LOG_CACHE_SHARED
```
    If is set to true the LogCache is shared. Shared cache caches raw binary data (contents of .xd files) of all Environment instances created in scope of this class loader. By default, the LogCache is shared.
    Mutable at runtime: no
    
    See Also:
    
    Constant Field Values
  - LOG_CACHE_NON_BLOCKING
```
public static final java.lang.String LOG_CACHE_NON_BLOCKING
```
    If is set to true the LogCache uses lock-free data structures. Default value is true.
    Mutable at runtime: no
    
    See Also:
    
    Constant Field Values
  - LOG_CACHE_GENERATION_COUNT
```
public static final java.lang.String LOG_CACHE_GENERATION_COUNT
```
    Defines the number of generations of non-blocking LogCache. Is applicable only if LOG_CACHE_NON_BLOCKING is set to true. The higher number of generations is, the higher the cache hit rate is and CPU ticks necessary to get a single page from the cache. Default value is 2.
    Mutable at runtime: no
    
    See Also:
    
    Constant Field Values
  - LOG_CACHE_USE_SOFT_REFERENCES
```
public static final java.lang.String LOG_CACHE_USE_SOFT_REFERENCES
```
    If is set to true LogCache uses soft references for holding cached pages. The cache still uses not more memory than it is configured by MEMORY_USAGE or MEMORY_USAGE_PERCENTAGE settings, but JVM GC can reclaim memory used by the cache on a heavy load surge. On the other hand, use of soft references results in greater JVM GC load and greater general CPU consumption by the cache. So one can choose either memory-flexible, or CPU-optimal cache. Default value is false.
    Mutable at runtime: no
    
    See Also:
    
    Constant Field Values
  - LOG_CACHE_READ_AHEAD_MULTIPLE
```
public static final java.lang.String LOG_CACHE_READ_AHEAD_MULTIPLE
```
    Defines the number of successive pages to be read at once in case of LogCache miss. Reading successive pages can reduce amount of random access to database files. It can be useful in workloads like application warm-up. Default value is 1 which means that no read-ahead strategy is applied.
    Mutable at runtime: yes
    
    See Also:
    
    Constant Field Values
  - LOG_CACHE_WARMUP
```
public static final java.lang.String LOG_CACHE_WARMUP
```
    If is set to true LogCache will populate itself with database file pages right after the database is opened using this EnvironmentConfig instance. Default value is false.
    Mutable at runtime: no
    
    See Also:
    
    Constant Field Values
  - LOG_CLEAN_DIRECTORY_EXPECTED
```
public static final java.lang.String LOG_CLEAN_DIRECTORY_EXPECTED
```
    If is set to true then the Log constructor fails if the database directory is not clean. Can be useful if an applications expects that the database should always be newly created. Default value is false.
    Mutable at runtime: no
    
    See Also:
    
    Constant Field Values
  - LOG_CLEAR_INVALID
```
public static final java.lang.String LOG_CLEAR_INVALID
```
    If is set to true then the Log constructor implicitly clears the database if it occurred to be invalid when opened. Default value is false.
    Mutable at runtime: no
    
    See Also:
    
    Constant Field Values
  - LOG_SYNC_PERIOD
```
public static final java.lang.String LOG_SYNC_PERIOD
```
    Sets the period in milliseconds to force file system's fsync call that often if LOG_DURABLE_WRITE is switched off. Default value is 10000L.
    Mutable at runtime: yes
    
    See Also:
    
    LOG_DURABLE_WRITE, Constant Field Values
  - LOG_FULL_FILE_READ_ONLY
```
public static final java.lang.String LOG_FULL_FILE_READ_ONLY
```
    If is set to true then each complete and immutable Log file (.xd file) is marked with read-only attribute. Default value is true.
    Mutable at runtime: no
    
    See Also:
    
    Constant Field Values
  - LOG_ALLOW_REMOVABLE
```
public static final java.lang.String LOG_ALLOW_REMOVABLE
```
    For DataReaderWriterProvider.DEFAULT_READER_WRITER_PROVIDER used as DataReaderWriterProvider service provider interface implementation, if is set to true then the database can be opened on a removable storage. Attempt to open database on a storage of not allowed type results in StorageTypeNotAllowedException. Default value is false.
    Mutable at runtime: no
    
    Since:
    
    1.4.0
    
    See Also:
    
    Constant Field Values
  - LOG_ALLOW_REMOTE
```
public static final java.lang.String LOG_ALLOW_REMOTE
```
    For DataReaderWriterProvider.DEFAULT_READER_WRITER_PROVIDER used as DataReaderWriterProvider service provider interface implementation, if is set to true then the database can be opened on a remote storage. Attempt to open database on a storage of not allowed type results in StorageTypeNotAllowedException. Default value is false.
    Mutable at runtime: no
    
    Since:
    
    1.4.0
    
    See Also:
    
    Constant Field Values
  - LOG_ALLOW_RAM_DISK
```
public static final java.lang.String LOG_ALLOW_RAM_DISK
```
    For DataReaderWriterProvider.DEFAULT_READER_WRITER_PROVIDER used as DataReaderWriterProvider service provider interface implementation, if is set to true then the database can be opened on RAM-disk. Attempt to open database on a storage of not allowed type results in StorageTypeNotAllowedException. Default value is false.
    Mutable at runtime: no
    
    Since:
    
    1.4.0
    
    See Also:
    
    Constant Field Values
  - LOG_DATA_READER_WRITER_PROVIDER
```
public static final java.lang.String LOG_DATA_READER_WRITER_PROVIDER
```
    Defines fully-qualified name of the DataReaderWriterProvider service provider interface implementation which will be used to create DataReader and DataWriter instances. This setting can be used to customize storageL define in-memory one, in-cloud, etc. Default value is DataReaderWriterProvider.DEFAULT_READER_WRITER_PROVIDER which means that file system must be used as a storage. Several settings are applicable only to FileDataReaderWriterProvider used: LOG_DURABLE_WRITE, LOG_SYNC_PERIOD, LOG_CACHE_OPEN_FILES, LOG_FULL_FILE_READ_ONLY, LOG_CACHE_USE_NIO, LOG_CACHE_FREE_PHYSICAL_MEMORY_THRESHOLD.
    Mutable at runtime: no
    
    See Also:
    
    Constant Field Values
  - ENV_IS_READONLY
```
public static final java.lang.String ENV_IS_READONLY
```
    If is set to true then the Environment instance is read-only. Default value is false.
    Mutable at runtime: yes
    
    See Also:
    
    Constant Field Values
  - ENV_FAIL_FAST_IN_READONLY
```
public static final java.lang.String ENV_FAIL_FAST_IN_READONLY
```
    If is set to true and ENV_IS_READONLY is also true then the Environment obligatorily creates transactions for which Transaction.isReadonly() is true. Read-only transactions fail-fast with ReadonlyTransactionException on attempt to modify data. If is set to false and ENV_IS_READONLY is set to true then the Environment creates transaction that allow to accumulate changes but cannot be flushed ot committed since the Environment is read-only. Default value is true.
    Mutable at runtime: yes
    
    See Also:
    
    ENV_IS_READONLY, Constant Field Values
  - ENV_READONLY_EMPTY_STORES
```
public static final java.lang.String ENV_READONLY_EMPTY_STORES
```
    If is set to true and ENV_IS_READONLY is also true then Environment.openStore(String, StoreConfig, Transaction) doesn't try to create a Store, but returns an empty immutable instance instead. Default value is false.
    Mutable at runtime: yes
    
    See Also:
    
    ENV_IS_READONLY, Constant Field Values
  - ENV_STOREGET_CACHE_SIZE
```
public static final java.lang.String ENV_STOREGET_CACHE_SIZE
```
    Defines the size of the "store-get" cache. The "store-get" cache can increase performance of Store.get(Transaction, ByteIterable) in certain cases. Default value is 0 what means that the cache is inactive. If the setting is mutated at runtime the cache is invalidated.
    Mutable at runtime: yes
    
    See Also:
    
    Constant Field Values
  - ENV_STOREGET_CACHE_MIN_TREE_SIZE
```
public static final java.lang.String ENV_STOREGET_CACHE_MIN_TREE_SIZE
```
    See Also:
    
    Constant Field Values
  - ENV_STOREGET_CACHE_MAX_VALUE_SIZE
```
public static final java.lang.String ENV_STOREGET_CACHE_MAX_VALUE_SIZE
```
    See Also:
    
    Constant Field Values
  - ENV_CLOSE_FORCEDLY
```
public static final java.lang.String ENV_CLOSE_FORCEDLY
```
    If is set to true then Environment.close() doest't check if there are unfinished transactions. Otherwise it checks and throws ExodusException if there are. Default value is false.
    Mutable at runtime: yes
    
    See Also:
    
    Environment.close(), Constant Field Values
  - ENV_TXN_REPLAY_TIMEOUT
```
public static final java.lang.String ENV_TXN_REPLAY_TIMEOUT
```
    Defines the number of millisecond which a Transaction can try to flush without attempts to upgrade (switch to an exclusive mode). Default value is 2000L.
    Mutable at runtime: yes
    
    See Also:
    
    Transaction, ENV_TXN_REPLAY_MAX_COUNT, ENV_TXN_DOWNGRADE_AFTER_FLUSH, Constant Field Values
  - ENV_TXN_REPLAY_MAX_COUNT
```
public static final java.lang.String ENV_TXN_REPLAY_MAX_COUNT
```
    Defines the number of times which a Transaction can try to flush without attempts to upgrade (switch to an exclusive mode). Default value is 2.
    Mutable at runtime: yes
    
    See Also:
    
    Transaction, ENV_TXN_REPLAY_TIMEOUT, ENV_TXN_DOWNGRADE_AFTER_FLUSH, Constant Field Values
  - ENV_TXN_DOWNGRADE_AFTER_FLUSH
```
public static final java.lang.String ENV_TXN_DOWNGRADE_AFTER_FLUSH
```
    If is set to true then any upgraded Transaction will downgrade itself after Transaction.flush(). Default value is true.
    Mutable at runtime: yes
    
    See Also:
    
    Transaction, ENV_TXN_REPLAY_TIMEOUT, ENV_TXN_REPLAY_MAX_COUNT, Constant Field Values
  - ENV_TXN_SINGLE_THREAD_WRITES
```
public static final java.lang.String ENV_TXN_SINGLE_THREAD_WRITES
```
    If is set to true then any write operation can be performed only in the thread which the transaction was created in. Default value is false.
    Mutable at runtime: yes
    
    See Also:
    
    Transaction, Constant Field Values
  - ENV_TXN_TRACE_FINISH
```
public static final java.lang.String ENV_TXN_TRACE_FINISH
```
    If is set to true then each transaction, read/write or read-only, saves stack trace when it is finished (aborted or committed). The stack trace is then reported with TransactionFinishedException. Default value is false.
    Mutable at runtime: yes
    
    Since:
    
    1.4.0
    
    See Also:
    
    Transaction, Constant Field Values
  - ENV_MAX_PARALLEL_TXNS
```
public static final java.lang.String ENV_MAX_PARALLEL_TXNS
```
    Defines the number of transactions that can be started in parallel. By default it is unlimited.
    Mutable at runtime: no
    
    See Also:
    
    Transaction, Constant Field Values
  - ENV_MAX_PARALLEL_READONLY_TXNS
```
@Deprecated
public static final java.lang.String ENV_MAX_PARALLEL_READONLY_TXNS
```
    Deprecated.
    
    Defines the number of read-only transactions that can be started in parallel. By default it is unlimited.
    Mutable at runtime: no As of 1.4.0, is deprecated.
    
    See Also:
    
    Transaction, Transaction.isReadonly(), ENV_MAX_PARALLEL_TXNS, Constant Field Values
  - ENV_MONITOR_TXNS_TIMEOUT
```
public static final java.lang.String ENV_MONITOR_TXNS_TIMEOUT
```
    Defines Transaction timeout in milliseconds. If transaction doesn't finish in this timeout then it is reported in logs as stuck along with stack trace which it was created with. Default value is 0 which means that no timeout for a Transaction is defined. In that case, no monitor of stuck transactions is started. Otherwise it is started for each Environment, though consuming only a single Thread amongst all environments created within a single class loader.
    Mutable at runtime: no
    
    See Also:
    
    Transaction, ENV_MONITOR_TXNS_CHECK_FREQ, Constant Field Values
  - ENV_MONITOR_TXNS_EXPIRATION_TIMEOUT
```
public static final java.lang.String ENV_MONITOR_TXNS_EXPIRATION_TIMEOUT
```
    Defines Transaction expiration timeout in milliseconds. If transaction doesn't finish in this timeout then it is forced to be finished. Default value is 8 hours. 0 value means that no expiration for a Transaction is defined. In that case, no monitor of stuck transactions is started. Otherwise it is started for each Environment, though consuming only a single Thread amongst all environments created within a single class loader.
    Mutable at runtime: no
    
    See Also:
    
    Transaction, ENV_MONITOR_TXNS_CHECK_FREQ, Constant Field Values
  - ENV_MONITOR_TXNS_CHECK_FREQ
```
public static final java.lang.String ENV_MONITOR_TXNS_CHECK_FREQ
```
    If ENV_MONITOR_TXNS_TIMEOUT is non-zero then stuck transactions monitor starts and checks Environment's transactions with this frequency (period) specified in milliseconds. Default value is 60000, one minute.
    Mutable at runtime: no
    
    See Also:
    
    Transaction, ENV_MONITOR_TXNS_TIMEOUT, Constant Field Values
  - ENV_GATHER_STATISTICS
```
public static final java.lang.String ENV_GATHER_STATISTICS
```
    If is set to true then the Environment gathers statistics. If MANAGEMENT_ENABLED is also true then the statistics is exposed by the JMX managed bean. Default value is true.
    Mutable at runtime: no
    
    See Also:
    
    Environment.getStatistics(), MANAGEMENT_ENABLED, Constant Field Values
  - ENV_COMPACT_ON_OPEN
```
public static final java.lang.String ENV_COMPACT_ON_OPEN
```
    If is set to true then the Environment will compact itself on opening. Default value is false.
    Mutable at runtime: no
    
    See Also:
    
    Constant Field Values
  - TREE_MAX_PAGE_SIZE
```
public static final java.lang.String TREE_MAX_PAGE_SIZE
```
    Defines the maximum size of page of B+Tree. Default value is 128.
    Mutable at runtime: yes
    
    See Also:
    
    Constant Field Values
  - TREE_DUP_MAX_PAGE_SIZE
```
public static final java.lang.String TREE_DUP_MAX_PAGE_SIZE
```
    Defines the maximum size of page of duplicates sub-B+Tree. Default value is 8.
    Mutable at runtime: yes
    
    See Also:
    
    Constant Field Values
  - TREE_NODES_CACHE_SIZE
```
@Deprecated
public static final java.lang.String TREE_NODES_CACHE_SIZE
```
    Deprecated.
    
    As of 1.0.5, is deprecated and has no effect.
    Mutable at runtime: no
    
    See Also:
    
    Constant Field Values
  - GC_ENABLED
```
public static final java.lang.String GC_ENABLED
```
    If is set to true then the database garbage collector is enabled. Default value is true. Switching GC off makes sense only for debugging and troubleshooting purposes.
    Mutable at runtime: yes
    
    See Also:
    
    Constant Field Values
  - GC_START_IN
```
public static final java.lang.String GC_START_IN
```
    Defines the number of milliseconds which the database garbage collector is postponed for after the Environment is created. Default value is 10000.
    Mutable at runtime: no
    
    See Also:
    
    Constant Field Values
  - GC_MIN_UTILIZATION
```
public static final java.lang.String GC_MIN_UTILIZATION
```
    Defines percent of minimum database utilization. Default value is 50. That means that 50 percent of free space in raw data in Log files (.xd files) is allowed. If database utilization is less than defined (free space percent is more than 50), the database garbage collector is triggered.
    Mutable at runtime: yes
    
    See Also:
    
    Constant Field Values
  - GC_RENAME_FILES
```
public static final java.lang.String GC_RENAME_FILES
```
    If is set to true the database garbage collector renames files rather than deletes them. Default value is false. It makes sense to change this setting only for debugging and troubleshooting purposes.
    Mutable at runtime: yes
    
    See Also:
    
    Constant Field Values
  - GC_USE_EXPIRATION_CHECKER
```
@Deprecated
public static final java.lang.String GC_USE_EXPIRATION_CHECKER
```
    Deprecated.
    
    As of 1.0.2, is deprecated and has no effect.
    Mutable at runtime: no
    
    See Also:
    
    Constant Field Values
  - GC_MIN_FILE_AGE
```
public static final java.lang.String GC_MIN_FILE_AGE
```
    Defines the minimum age of a Log file (.xd file) to consider it for cleaning by the database garbage collector. The age of the last (the newest, the rightmost) Log file is 0, the age of previous file is 1, etc. Default value is 2.
    Mutable at runtime: yes
    
    See Also:
    
    Constant Field Values
  - GC_FILES_INTERVAL
```
@Deprecated
public static final java.lang.String GC_FILES_INTERVAL
```
    Deprecated.
    
    Defines the number of new Log files (.xd files) that must be created to trigger if necessary (if database utilization is not sufficient) the next background cleaning cycle (single run of the database garbage collector) after the previous cycle finished. Default value is 3, i.e. GC can start after each 3 newly created Log files.
    Mutable at runtime: yes
    
    See Also:
    
    Constant Field Values
  - GC_RUN_PERIOD
```
public static final java.lang.String GC_RUN_PERIOD
```
    Defines the number of milliseconds after which background cleaning cycle (single run of the database garbage collector) can be repeated if the previous one didn't reach required utilization. Default value is 5000.
    Mutable at runtime: yes
    
    See Also:
    
    Constant Field Values
  - GC_UTILIZATION_FROM_SCRATCH
```
public static final java.lang.String GC_UTILIZATION_FROM_SCRATCH
```
    If is set to true then database utilization will be computed from scratch before the first cleaning cycle (single run of the database garbage collector) is triggered, i.e. shortly after the database is open. In addition, can be used to compute utilization information at runtime by just modifying the setting value. Default value is false.
    Mutable at runtime: yes
    
    See Also:
    
    Constant Field Values
  - GC_UTILIZATION_FROM_FILE
```
public static final java.lang.String GC_UTILIZATION_FROM_FILE
```
    If is not empty, defines full path to the file with stored utilization. Is used on creation of an Environment to update .xd files' utilization before the first cleaning cycle (single run of the database garbage collector) is triggered. In addition, can be used to reload utilization information at runtime by just modifying the setting value. Format of the stored utilization is expected to be the same as created by the "-d" option of the Reflect tool. Default value is empty string.
    Mutable at runtime: yes
    
    See Also:
    
    Constant Field Values
  - GC_USE_EXCLUSIVE_TRANSACTION
```
public static final java.lang.String GC_USE_EXCLUSIVE_TRANSACTION
```
    If is set to true the database garbage collector tries to acquire exclusive Transaction for its purposes. In that case, GC transaction never re-plays. In order to not block background cleaner thread forever, acquisition of exclusive GC transaction is performed with a timeout controlled by the GC_TRANSACTION_ACQUIRE_TIMEOUT setting. Default value is true.
    Mutable at runtime: yes
    
    See Also:
    
    GC_TRANSACTION_ACQUIRE_TIMEOUT, GC_TRANSACTION_TIMEOUT, Transaction.isExclusive(), Constant Field Values
  - GC_TRANSACTION_ACQUIRE_TIMEOUT
```
public static final java.lang.String GC_TRANSACTION_ACQUIRE_TIMEOUT
```
    Defines timeout in milliseconds which is used by the database garbage collector to acquire exclusive Transaction for its purposes if GC_USE_EXCLUSIVE_TRANSACTION is true. Default value is 1000.
    Mutable at runtime: yes
    
    See Also:
    
    GC_USE_EXCLUSIVE_TRANSACTION, GC_TRANSACTION_TIMEOUT, Transaction.isExclusive(), Constant Field Values
  - GC_TRANSACTION_TIMEOUT
```
public static final java.lang.String GC_TRANSACTION_TIMEOUT
```
    Defines timeout in milliseconds which is used by the database garbage collector to reclaim non-expired data in several files inside single GC Transaction acquired exclusively. GC_USE_EXCLUSIVE_TRANSACTION should be true. Default value is 500.
    Mutable at runtime: yes
    
    See Also:
    
    GC_USE_EXCLUSIVE_TRANSACTION, GC_TRANSACTION_ACQUIRE_TIMEOUT, Transaction.isExclusive(), Constant Field Values
  - GC_FILES_DELETION_DELAY
```
public static final java.lang.String GC_FILES_DELETION_DELAY
```
    Defines the number of milliseconds which deletion of any successfully cleaned Log file (.xd file) is postponed for. Default value is 5000.
    Mutable at runtime: yes
    
    See Also:
    
    Constant Field Values
  - GC_RUN_EVERY
```
public static final java.lang.String GC_RUN_EVERY
```
    If set to nonzero value, GC is forced every this number of seconds. Default value is 0 which means that GC is not forced periodically.
    Mutable at runtime: yes
    
    See Also:
    
    Constant Field Values
  - MANAGEMENT_ENABLED
```
public static final java.lang.String MANAGEMENT_ENABLED
```
    If is set to true then the Environment exposes two JMX managed beans. One for environment statistics and second for controlling the EnvironmentConfig settings. Default value is true for non-Android OS, under Android it is always false.
    Mutable at runtime: no
    
    See Also:
    
    Environment.getStatistics(), Environment.getEnvironmentConfig(), Constant Field Values
  - MANAGEMENT_OPERATIONS_RESTRICTED
```
public static final java.lang.String MANAGEMENT_OPERATIONS_RESTRICTED
```
    If is set to true then exposed JMX managed beans cannot have operations. Default value is true.
    Mutable at runtime: no
    
    See Also:
    
    MANAGEMENT_ENABLED, Constant Field Values
  - META_SERVER
```
public static final java.lang.String META_SERVER
```
    If set to some value different from null, expose created environment via given server.
    Mutable at runtime: no
    
    See Also:
    
    Constant Field Values
- Constructor Detail
  - EnvironmentConfig
```
public EnvironmentConfig()
```
  - EnvironmentConfig
```
public EnvironmentConfig(@NotNull
                         @NotNull ConfigurationStrategy strategy)
```
- Method Detail
  - setSetting
```
public EnvironmentConfig setSetting(@NotNull
                                    @NotNull java.lang.String key,
                                    @NotNull
                                    @NotNull java.lang.Object value)
```
    Sets the value of the setting with the specified key.
    
    Overrides:
    
    setSetting in class AbstractConfig
    
    Parameters:
    
    key - name of the setting
    
    value - the setting value
    
    Returns:
    
    this EnvironmentConfig instance
  - setMutable
```
public EnvironmentConfig setMutable(boolean isMutable)
```
    Set true for making it possible to change settings of this EnvironmentConfig instance. EnvironmentConfig.DEFAULT is always immutable.
    
    Overrides:
    
    setMutable in class AbstractConfig
    
    Parameters:
    
    isMutable - true if this EnvironmentConfig instance can be mutated
    
    Returns:
    
    this EnvironmentConfig instance
  - getMemoryUsage
```
public java.lang.Long getMemoryUsage()
```
    Returns absolute value of memory in bytes that can be used by the LogCache if it is set. By default, is not set.
    Mutable at runtime: no
    
    Returns:
    
    absolute value of memory in bytes that can be used by the LogCache if it is set or null
    
    See Also:
    
    getMemoryUsagePercentage()
  - setMemoryUsage
```
public EnvironmentConfig setMemoryUsage(long maxMemory)
```
    Sets absolute value of memory in bytes that can be used by the LogCache. Overrides memory percent to use by the LogCache set by setMemoryUsagePercentage(int).
    Mutable at runtime: no
    
    Parameters:
    
    maxMemory - number of bytes that can be used by the LogCache
    
    Returns:
    
    absolute this EnvironmentConfig instance
    
    See Also:
    
    setMemoryUsagePercentage(int)
  - getMemoryUsagePercentage
```
public int getMemoryUsagePercentage()
```
    Returns percent of max memory (specified by the "-Xmx" java parameter) that can be used by the LogCache. Is applicable only if MEMORY_USAGE is not set. Default value is 50.
    Mutable at runtime: no
    
    Returns:
    
    percent of max memory that can be used by the LogCache
    
    See Also:
    
    getMemoryUsage()
  - setMemoryUsagePercentage
```
public EnvironmentConfig setMemoryUsagePercentage(int memoryUsagePercentage)
```
    Sets percent of max memory (specified by the "-Xmx" java parameter) that can be used by the LogCache. Is applicable only if MEMORY_USAGE is not set. Default value is 50.
    Mutable at runtime: no
    
    Parameters:
    
    memoryUsagePercentage - percent of max memory that can be used by the LogCache
    
    Returns:
    
    this EnvironmentConfig instance
    
    See Also:
    
    setMemoryUsage(long)
  - getUseVersion1Format
```
public boolean getUseVersion1Format()
```
  - setUseVersion1Format
```
public EnvironmentConfig setUseVersion1Format(boolean useVersion1Format)
```
  - getCipherId
```
@Nullable
public @Nullable java.lang.String getCipherId()
```
    Returns id of StreamCipherProvider which will be used to encrypt the database. Default value is null, which means that the database won't be encrypted. The setting cannot be changed for existing databases. Default value is null.
    Mutable at runtime: no
    
    Returns:
    
    id of StreamCipherProvider which will be used to encrypt the database
    
    See Also:
    
    getCipherKey(), getCipherBasicIV(), StreamCipher, StreamCipherProvider
  - setCipherId
```
public EnvironmentConfig setCipherId(java.lang.String id)
```
    Sets id of StreamCipherProvider which will be used to encrypt the database. Default value is null, which means that the database won't be encrypted. The setting cannot be changed for existing databases. Default value is null.
    Mutable at runtime: no
    
    Parameters:
    
    id - id of StreamCipherProvider
    
    Returns:
    
    this EnvironmentConfig instance
    
    See Also:
    
    setCipherKey(String), setCipherBasicIV(long), StreamCipher, StreamCipherProvider
  - getCipherKey
```
@Nullable
public @Nullable byte[] getCipherKey()
```
    Returns the key which will be used to encrypt the database or null for no encryption. Is applicable only if* getCipherId() returns not null. Default value is null.
    Mutable at runtime: no
    
    Returns:
    
    the key which will be used to encrypt the database or null for no encryption
    
    See Also:
    
    getCipherId(), getCipherBasicIV(), StreamCipher, StreamCipher.init(byte[], long), StreamCipherProvider
  - setCipherKey
```
public EnvironmentConfig setCipherKey(java.lang.String cipherKey)
```
    Sets the key which will be used to encrypt the database. The key is expected to be a hex string representing a byte array which is passed to StreamCipher.init(byte[], long). Is applicable only if getCipherId() returns not null. The setting cannot be changed for existing databases. Default value is null.
    Mutable at runtime: no
    
    Parameters:
    
    cipherKey - hex string representing cipher key
    
    Returns:
    
    this EnvironmentConfig instance
    
    See Also:
    
    setCipherId(String), setCipherBasicIV(long), StreamCipher, StreamCipher.init(byte[], long), StreamCipherProvider
  - getCipherBasicIV
```
public long getCipherBasicIV()
```
    Returns basic IV (initialization vector) which will be used to encrypt the database. Basic IV is expected to be random (pseudo-random) and unique long value. Basic IV is used to calculate relative IVs which are passed to StreamCipher.init(byte[], long). Is applicable only if CIPHER_ID is not null. The setting cannot be changed for existing databases. Default value is 0L.
    Mutable at runtime: no
    
    Returns:
    
    basic IV (initialization vector) which will be used to encrypt the database
    
    See Also:
    
    getCipherId(), getCipherKey(), StreamCipher, StreamCipher.init(byte[], long), StreamCipherProvider
  - setCipherBasicIV
```
public EnvironmentConfig setCipherBasicIV(long basicIV)
```
    Sets basic IV (initialization vector) which will be used to encrypt the database. Basic IV is expected to be random (pseudo-random) and unique long value. Basic IV is used to calculate relative IVs which are passed to StreamCipher.init(byte[], long). Is applicable only if CIPHER_ID is not null. The setting cannot be changed for existing databases. Default value is 0L.
    Mutable at runtime: no
    
    Parameters:
    
    basicIV - basic IV (initialization vector) which will be used to encrypt the database
    
    Returns:
    
    this EnvironmentConfig instance
    
    See Also:
    
    setCipherId(String), setCipherKey(String), StreamCipher, StreamCipher.init(byte[], long), StreamCipherProvider
  - getProfilerEnabled
```
public boolean getProfilerEnabled()
```
    If is set to true database profiler is enabled. By default, it is disabled.
    Mutable at runtime: no
    
    Returns:
    
    true if database profiler is enabled.
    
    Since:
    
    1.4.0
  - setProfilerEnabled
```
public EnvironmentConfig setProfilerEnabled(boolean enabled)
```
    Set true to enable database profiler. By default, it is disabled.
    Mutable at runtime: no
    
    Parameters:
    
    enabled - true to enable database profiler.
    
    Returns:
    
    this EnvironmentConfig instance
    
    Since:
    
    1.4.0
  - getLogDurableWrite
```
public boolean getLogDurableWrite()
```
    Returns true if file system's fsync call after should be executed after each committed or flushed transaction. By default, is switched off since it creates significant performance overhead and can be controlled manually.
    Mutable at runtime: yes
    
    Returns:
    
    true if transactions are durable
    
    See Also:
    
    getLogSyncPeriod()
  - setLogDurableWrite
```
public EnvironmentConfig setLogDurableWrite(boolean durableWrite)
```
    Sets flag whether transactions should force fsync after each commit or flush. By default, is switched off since it creates significant performance overhead and can be controlled manually.
    Mutable at runtime: yes
    
    Parameters:
    
    durableWrite - true if transactions should be durable
    
    Returns:
    
    this EnvironmentConfig instance
    
    See Also:
    
    setLogSyncPeriod(long)
  - getLogFileSize
```
public long getLogFileSize()
```
    Returns the maximum size in kilobytes of a single Log file (.xd file). The setting cannot be changed for existing databases. Default value is 8192L.
    Mutable at runtime: no
    
    Returns:
    
    maximum size in kilobytes of a single .xd file
  - setLogFileSize
```
public EnvironmentConfig setLogFileSize(long kilobytes)
```
    Sets the maximum size in kilobytes of a single Log file (.xd file). The setting cannot be changed for existing databases. Default value is 8192L.
    Mutable at runtime: no
    
    Parameters:
    
    kilobytes - maximum size in kilobytes of a single .xd file
    
    Returns:
    
    this EnvironmentConfig instance
  - getLogLockTimeout
```
public long getLogLockTimeout()
```
    Returns the number of milliseconds the Log constructor waits for the lock file. Default value is 0L, i.e. it doesn't wait and fails immediately if the lock is acquired.
    Mutable at runtime: no
    
    Returns:
    
    number of milliseconds the Log constructor waits for the lock file
  - setLogLockId
```
public EnvironmentConfig setLogLockId(java.lang.String id)
```
    Sets the debug identifier to be written to the lock file alongside with other debug information.
    Mutable at runtime: no
    
    Parameters:
    
    id - the debug identifier to be written to the lock file alongside with other debug information
    
    Returns:
    
    this EnvironmentConfig instance
  - setLogLockTimeout
```
public EnvironmentConfig setLogLockTimeout(long millis)
```
    Sets the number of milliseconds the Log constructor waits for the lock file.
    Mutable at runtime: no
    
    Parameters:
    
    millis - number of milliseconds the Log constructor should wait for the lock file
    
    Returns:
    
    this EnvironmentConfig instance
  - getLogLockId
```
public java.lang.String getLogLockId()
```
    Sets the debug identifier to be written to the lock file alongside with other debug information. Default value is ManagementFactory.getRuntimeMXBean().getName() which has a form of pid@hostname.
    Mutable at runtime: no
    
    Returns:
    
    the debug identifier to be written to the lock file alongside with other debug information or null if the default value is used
  - getLogCachePageSize
```
public int getLogCachePageSize()
```
    Returns the size in bytes of a single page (byte array) in the LogCache. This number of bytes is read from MappedByteBuffer or RandomAccessFile at a time.
    If the LogCache is shared (LOG_CACHE_SHARED) all Environments should be configured to use single LogCache page size.
    Default value is 64 * 1024.
    Mutable at runtime: no
    
    Returns:
    
    size in bytes of a single page (byte array) in the LogCache
  - setLogCachePageSize
```
public EnvironmentConfig setLogCachePageSize(int bytes)
```
    Sets the size in bytes of a single page (byte array) in the LogCache. This number of bytes is read from MappedByteBuffer or RandomAccessFile at a time.
    If the LogCache is shared (LOG_CACHE_SHARED) all Environments should be configured to use single LogCache page size.
    Default value is 64 * 1024.
    Mutable at runtime: no
    
    Parameters:
    
    bytes - size in bytes of a single page (byte array) in the LogCache
    
    Returns:
    
    this EnvironmentConfig instance
  - getLogCacheOpenFilesCount
```
public int getLogCacheOpenFilesCount()
```
    Returns the maximum number of open files that the LogCache maintains in order to reduce system calls to open and close files. The more open files is allowed the less system calls are performed in addition to reading or mapping files. This value can notably affect performance of database warm-up. Default value is 500. Open files cache is shared amongst all open environments.
    Mutable at runtime: no
    
    Returns:
    
    maximum number of open files
  - setLogCacheOpenFilesCount
```
public EnvironmentConfig setLogCacheOpenFilesCount(int files)
```
    Sets the maximum number of open files that the LogCache maintains in order to reduce system calls to open and close files. The more open files is allowed the less system calls are performed in addition to reading or mapping files. This value can notably affect performance of database warm-up. Default value is 500. Open files cache is shared amongst all open environments.
    Mutable at runtime: no
    
    Parameters:
    
    files - maximum number of open files
    
    Returns:
    
    this EnvironmentConfig instance
  - getLogCacheUseNio
```
public boolean getLogCacheUseNio()
```
    Returns true if any immutable .xd file can be mapped in memory provided there is enough physical memory. On cache miss, LogCache at first tries to check if there is corresponding mapped byte buffer and copies cache page from the buffer, otherwise reads the page from RandomAccessFile. If is set to false then LogCache always reads RandomAccessFile on cache miss. Default value was true before version 1.2.3. As of 1.2.3, default value is false.
    Mutable at runtime: no
    
    Returns:
    
    true mapping of .xd files in memory is allowed
    
    See Also:
    
    getLogCacheFreePhysicalMemoryThreshold()
  - setLogCacheUseNio
```
public EnvironmentConfig setLogCacheUseNio(boolean useNio)
```
    Set true to allow any immutable .xd file to be mapped in memory provided there is enough physical memory. On cache miss, LogCache at first tries to check if there is corresponding mapped byte buffer and copies cache page from the buffer, otherwise reads the page from RandomAccessFile. If is set to false then LogCache always reads RandomAccessFile on cache miss. Default value was true before version 1.2.3. As of 1.2.3, default value is false.
    Mutable at runtime: no
    
    Parameters:
    
    useNio - true is using NIO is allowed
    
    Returns:
    
    this EnvironmentConfig instance
  - getLogCacheFreePhysicalMemoryThreshold
```
public long getLogCacheFreePhysicalMemoryThreshold()
```
    If LOG_CACHE_USE_NIO is true defines the minimum size in bytes of free physical memory maintained by the cache memory-mapped files on the host where the JVM runs. On cache miss, LogCache checks if corresponding file is mapped in memory, and if it is not and if free physical memory amount is greater than threshold specified by this setting, tries to map the file in memory. Default value is 1_000_000_000L bytes, i.e. ~1GB.
    
    Returns:
    
    minimum size in bytes of free physical memory
  - setLogCacheFreePhysicalMemoryThreshold
```
public EnvironmentConfig setLogCacheFreePhysicalMemoryThreshold(long freePhysicalMemoryThreshold)
```
    If LOG_CACHE_USE_NIO is true sets the minimum size in bytes of free physical memory maintained by the cache memory-mapped files on the host where the JVM runs. On cache miss, LogCache checks if corresponding file is mapped in memory, and if it is not and if free physical memory amount is greater than threshold specified by this setting, tries to map the file in memory. Default value is 1_000_000_000L bytes, i.e. ~1GB.
    
    Parameters:
    
    freePhysicalMemoryThreshold - minimum size in bytes of free physical memory
    
    Returns:
    
    this EnvironmentConfig instance
  - isLogCacheShared
```
public boolean isLogCacheShared()
```
    Returns true if the LogCache is shared. Shared cache caches raw binary data (contents of .xd files) of all Environment instances created in scope of this class loader. By default, the LogCache is shared.
    Mutable at runtime: no
    
    Returns:
    
    true if the LogCache is shared
  - setLogCacheShared
```
public EnvironmentConfig setLogCacheShared(boolean shared)
```
    Set true if the LogCache should be shared. Shared cache caches raw binary data (contents of .xd files) of all Environment instances created in scope of this class loader. By default, the LogCache is shared.
    Mutable at runtime: no
    
    Parameters:
    
    shared - true if the LogCache should be shared
    
    Returns:
    
    this EnvironmentConfig instance
  - isLogCacheNonBlocking
```
public boolean isLogCacheNonBlocking()
```
    Returns true if the LogCache should use lock-free data structures. Default value is true. There is no practical sense to use "blocking" cache, so the setting will be deprecated in future.
    Mutable at runtime: no
    
    Returns:
    
    true if the LogCache should use lock-free data structures
  - setLogCacheNonBlocking
```
public EnvironmentConfig setLogCacheNonBlocking(boolean nonBlocking)
```
    Set true if the LogCache should use lock-free data structures. Default value is true. There is no practical sense to use "blocking" cache, so the setting will be deprecated in future.
    Mutable at runtime: no
    
    Parameters:
    
    nonBlocking - true if the LogCache should use lock-free data structures
    
    Returns:
    
    this EnvironmentConfig instance
  - getLogCacheGenerationCount
```
public int getLogCacheGenerationCount()
```
    Returns the number of generations of non-blocking LogCache. Is applicable only if LOG_CACHE_NON_BLOCKING is set to true. The higher number of generations is, the higher the cache hit rate is and CPU ticks necessary to get a single page from the cache. Default value is 2.
    
    Returns:
    
    number of generations of non-blocking LogCache
  - setLogCacheGenerationCount
```
public EnvironmentConfig setLogCacheGenerationCount(int generationCount)
```
    Sets the number of generations of non-blocking LogCache. Is applicable only if LOG_CACHE_NON_BLOCKING is set to true. The higher number of generations is, the higher the cache hit rate is and CPU ticks necessary to get a single page from the cache. Default value is 2.
    
    Parameters:
    
    generationCount - number of generations of non-blocking LogCache
    
    Returns:
    
    this EnvironmentConfig instance
  - getLogCacheUseSoftReferences
```
public boolean getLogCacheUseSoftReferences()
```
    Returns true LogCache uses soft references for holding cached pages. The cache still uses not more memory than it is configured by MEMORY_USAGE or MEMORY_USAGE_PERCENTAGE settings, but JVM GC can reclaim memory used by the cache on a heavy load surge. On the other hand, use of soft references results in greater JVM GC load and greater general CPU consumption by the cache. So one can choose either memory-flexible, or CPU-optimal cache. Default value is false.
    Mutable at runtime: no
    
    Returns:
    
    true if LogCache should use soft references for holding cached pages
  - setLogCacheUseSoftReferences
```
public EnvironmentConfig setLogCacheUseSoftReferences(boolean useSoftReferences)
```
    Set true if LogCache should use soft references for holding cached pages. The cache still uses not more memory than it is configured by MEMORY_USAGE or MEMORY_USAGE_PERCENTAGE settings, but JVM GC can reclaim memory used by the cache on a heavy load surge. On the other hand, use of soft references results in greater JVM GC load and greater general CPU consumption by the cache. So one can choose either memory-flexible, or CPU-optimal cache. Default value is false.
    Mutable at runtime: no
    
    Parameters:
    
    useSoftReferences - true if LogCache should use soft references for holding cached pages
    
    Returns:
    
    this EnvironmentConfig instance
  - getLogCacheReadAheadMultiple
```
public int getLogCacheReadAheadMultiple()
```
    Returns the number of successive pages to be read at once in case of LogCache miss. Reading successive pages can reduce amount of random access to database files. It can be useful in workloads like application warm-up. Default value is 1 which means that no read-ahead strategy is applied.
    
    Returns:
    
    number of successive pages to be read at once in case of LogCache miss
  - setLogCacheReadAheadMultiple
```
public EnvironmentConfig setLogCacheReadAheadMultiple(int readAheadMultiple)
```
    Sets the number of successive pages to be read at once in case of LogCache miss. Reading successive pages can reduce amount of random access to database files. It can be useful in workloads like application warm-up. Default value is 1 which means that no read-ahead strategy is applied.
    
    Parameters:
    
    readAheadMultiple - number of successive pages to be read at once in case of LogCache miss
    
    Returns:
    
    this EnvironmentConfig instance
  - getLogCacheWarmup
```
public boolean getLogCacheWarmup()
```
    Returns true if LogCache will populate itself with database file pages right after the database is opened using this EnvironmentConfig instance. Default value is false.
    Mutable at runtime: no
    
    Returns:
    
    true if LogCache will populate itself with database file pages
  - setLogCacheWarmup
```
public EnvironmentConfig setLogCacheWarmup(boolean warmup)
```
    Set true if LogCache should populate itself with database file pages right after the database is opened using this EnvironmentConfig instance. Default value is false.
    Mutable at runtime: no
    
    Parameters:
    
    warmup - true if LogCache should populate itself with database file pages
    
    Returns:
    
    this EnvironmentConfig instance
  - isLogCleanDirectoryExpected
```
public boolean isLogCleanDirectoryExpected()
```
    Returns true if the Log constructor fails if the database directory is not clean. Can be useful if an applications expects that the database should always be newly created. Default value is false.
    Mutable at runtime: no
    
    Returns:
    
    true if the Log constructor fails if the database directory is not clean
  - setLogCleanDirectoryExpected
```
public EnvironmentConfig setLogCleanDirectoryExpected(boolean logCleanDirectoryExpected)
```
    Set true if the Log constructor should fail if the database directory is not clean. Can be useful if an applications expects that the database should always be newly created. Default value is false.
    Mutable at runtime: no
    
    Parameters:
    
    logCleanDirectoryExpected - true if the Log constructor should fail if the database directory is not clean
    
    Returns:
    
    this EnvironmentConfig instance
  - isLogClearInvalid
```
public boolean isLogClearInvalid()
```
    Returns true if the Log constructor implicitly clears the database if it occurred to be invalid when opened. Default value is false.
    Mutable at runtime: no
    
    Returns:
    
    true if the Log constructor should implicitly clear invalid database
  - setLogClearInvalid
```
public EnvironmentConfig setLogClearInvalid(boolean logClearInvalid)
```
    Set true if the Log constructor should implicitly clear the database if it occurred to be invalid when opened. Default value is false.
    Mutable at runtime: no
    
    Parameters:
    
    logClearInvalid - true if the Log constructor should implicitly clear invalid database
    
    Returns:
    
    this EnvironmentConfig instance
  - getLogSyncPeriod
```
public long getLogSyncPeriod()
```
    Returns the period in milliseconds to force file system's fsync call that often if LOG_DURABLE_WRITE is switched off. Default value is 10000L.
    Mutable at runtime: yes
    
    Returns:
    
    milliseconds to force file system's fsync call that often
    
    See Also:
    
    getLogDurableWrite()
  - setLogSyncPeriod
```
public EnvironmentConfig setLogSyncPeriod(long millis)
```
    Sets the period in milliseconds to force file system's fsync call that often if LOG_DURABLE_WRITE is switched off. Default value is 10000L.
    Mutable at runtime: yes
    
    Parameters:
    
    millis - milliseconds to force file system's fsync call that often
    
    Returns:
    
    this EnvironmentConfig instance
    
    See Also:
    
    setLogDurableWrite(boolean)
  - isLogFullFileReadonly
```
public boolean isLogFullFileReadonly()
```
    Returns true if each complete and immutable Log file (.xd file) should marked with read-only attribute. Default value is true.
    Mutable at runtime: no
    
    Returns:
    
    true if each complete and immutable .xd file should marked with read-only attribute
  - setFullFileReadonly
```
public EnvironmentConfig setFullFileReadonly(boolean readonly)
```
    Set true if each complete and immutable Log file (.xd file) should marked with read-only attribute. Default value is true.
    Mutable at runtime: no
    
    Parameters:
    
    readonly - true to mark each complete and immutable .xd file with read-only attribute
    
    Returns:
    
    this EnvironmentConfig instance
  - isLogAllowRemovable
```
public boolean isLogAllowRemovable()
```
    For DataReaderWriterProvider.DEFAULT_READER_WRITER_PROVIDER used as DataReaderWriterProvider service provider interface implementation, if is set to true then the database can be opened on a removable storage. Attempt to open database on a storage of not allowed type results in StorageTypeNotAllowedException. Default value is false.
    Mutable at runtime: no
    
    Returns:
    
    true if the database can be opened on a removable storage
    
    Since:
    
    1.4.0
  - setLogAllowRemovable
```
public EnvironmentConfig setLogAllowRemovable(boolean allow)
```
    For DataReaderWriterProvider.DEFAULT_READER_WRITER_PROVIDER used as DataReaderWriterProvider service provider interface implementation, if is set to true then the database can be opened on a removable storage. Attempt to open database on a storage of not allowed type results in StorageTypeNotAllowedException. Default value is false.
    Mutable at runtime: no
    
    Parameters:
    
    allow - true to allow using database located on removable storage
    
    Returns:
    
    this EnvironmentConfig instance
    
    Since:
    
    1.4.0
  - isLogAllowRemote
```
public boolean isLogAllowRemote()
```
    For DataReaderWriterProvider.DEFAULT_READER_WRITER_PROVIDER used as DataReaderWriterProvider service provider interface implementation, if is set to true then the database can be opened on a remote storage. Attempt to open database on a storage of not allowed type results in StorageTypeNotAllowedException. Default value is false.
    Mutable at runtime: no
    
    Returns:
    
    true if the database can be opened on a remote storage
    
    Since:
    
    1.4.0
  - setLogAllowRemote
```
public EnvironmentConfig setLogAllowRemote(boolean allow)
```
    For DataReaderWriterProvider.DEFAULT_READER_WRITER_PROVIDER used as DataReaderWriterProvider service provider interface implementation, if is set to true then the database can be opened on a remote storage. Attempt to open database on a storage of not allowed type results in StorageTypeNotAllowedException. Default value is false.
    Mutable at runtime: no
    
    Parameters:
    
    allow - true to allow using database located on remote storage
    
    Returns:
    
    this EnvironmentConfig instance
    
    Since:
    
    1.4.0
  - isLogAllowRamDisk
```
public boolean isLogAllowRamDisk()
```
    For DataReaderWriterProvider.DEFAULT_READER_WRITER_PROVIDER used as DataReaderWriterProvider service provider interface implementation, if is set to true then the database can be opened on RAM-disk. Attempt to open database on a storage of not allowed type results in StorageTypeNotAllowedException. Default value is false.
    Mutable at runtime: no
    
    Returns:
    
    true if the database can be opened on RAM-disk
    
    Since:
    
    1.4.0
  - setLogAllowRamDisk
```
public EnvironmentConfig setLogAllowRamDisk(boolean allow)
```
    For DataReaderWriterProvider.DEFAULT_READER_WRITER_PROVIDER used as DataReaderWriterProvider service provider interface implementation, if is set to true then the database can be opened on RAM-disk. Attempt to open database on a storage of not allowed type results in StorageTypeNotAllowedException. Default value is false.
    Mutable at runtime: no
    
    Parameters:
    
    allow - true to allow using database located on RAM-disk
    
    Returns:
    
    this EnvironmentConfig instance
    
    Since:
    
    1.4.0
  - getLogDataReaderWriterProvider
```
public java.lang.String getLogDataReaderWriterProvider()
```
    Returns fully-qualified name of the DataReaderWriterProvider service provide interface implementation which will be used to create DataReader and DataWriter instances. This setting can be used to customize storage: define in-memory one, in-cloud, etc. Default value is DataReaderWriterProvider.DEFAULT_READER_WRITER_PROVIDER which means that file system must be used as a storage. Several settings are applicable only if FileDataReaderWriterProvider is used: LOG_DURABLE_WRITE, LOG_SYNC_PERIOD, LOG_CACHE_OPEN_FILES, LOG_FULL_FILE_READ_ONLY, LOG_CACHE_USE_NIO, LOG_CACHE_FREE_PHYSICAL_MEMORY_THRESHOLD.
    Mutable at runtime: no
    
    Returns:
    
    fully-qualified name of the DataReaderWriterProvider service provide interface implementation
  - setLogDataReaderWriterProvider
```
public EnvironmentConfig setLogDataReaderWriterProvider(@NotNull
                                                        @NotNull java.lang.String provider)
```
    Sets fully-qualified name of the DataReaderWriterProvider service provide interface implementation which will be used to create DataReader and DataWriter instances. This setting can be used to customize storage: define in-memory one, in-cloud, etc. Default value is DataReaderWriterProvider.DEFAULT_READER_WRITER_PROVIDER which means that file system must be used as a storage. Several settings are applicable only if FileDataReaderWriterProvider is used: LOG_DURABLE_WRITE, LOG_SYNC_PERIOD, LOG_CACHE_OPEN_FILES, LOG_FULL_FILE_READ_ONLY, LOG_CACHE_USE_NIO, LOG_CACHE_FREE_PHYSICAL_MEMORY_THRESHOLD.
    Mutable at runtime: no
    
    Parameters:
    
    provider - fully-qualified name of the DataReaderWriterProvider service provide interface implementation
    
    Returns:
    
    this EnvironmentConfig instance
  - getEnvIsReadonly
```
public boolean getEnvIsReadonly()
```
    Returns true if the Environment instance is read-only. Default value is false.
    Mutable at runtime: yes
    
    Returns:
    
    true if the Environment instance is read-only
  - setEnvIsReadonly
```
public EnvironmentConfig setEnvIsReadonly(boolean isReadonly)
```
    Set true to turn the Environment instance to read-only mode. Default value is false.
    Mutable at runtime: yes
    
    Parameters:
    
    isReadonly - true to turn the Environment instance to read-only mode
    
    Returns:
    
    this EnvironmentConfig instance
  - getEnvFailFastInReadonly
```
public boolean getEnvFailFastInReadonly()
```
    If is set to true and ENV_IS_READONLY is also true then the Environment obligatorily creates transactions for which Transaction.isReadonly() is true. Read-only transactions fail-fast with ReadonlyTransactionException on attempt to modify data. If is set to false and ENV_IS_READONLY is set to true then the Environment creates transaction that allow to accumulate changes but cannot be flushed ot committed since the Environment is read-only. Default value is true.
    Mutable at runtime: yes
    
    Returns:
    
    true if attempt to modify data won't fail immediately in read-only mode
  - setEnvFailFastInReadonly
```
public EnvironmentConfig setEnvFailFastInReadonly(boolean failFast)
```
    If is set to true and ENV_IS_READONLY is also true then the Environment obligatorily creates transactions for which Transaction.isReadonly() is true. Read-only transactions fail-fast with ReadonlyTransactionException on attempt to modify data. If is set to false and ENV_IS_READONLY is set to true then the Environment creates transaction that allow to accumulate changes but cannot be flushed ot committed since the Environment is read-only. Default value is true.
    Mutable at runtime: yes
    
    Parameters:
    
    failFast - true if attempt modify data shouldn fail immediately in read-only mode
    
    Returns:
    
    this EnvironmentConfig instance
  - getEnvReadonlyEmptyStores
```
public boolean getEnvReadonlyEmptyStores()
```
    If is set to true and ENV_IS_READONLY is also true then Environment.openStore(String, StoreConfig, Transaction) doesn't try to create a Store, but returns an empty immutable instance instead. Default value is false.
    Mutable at runtime: yes
    
    Returns:
    
    true if attempt to create a Store won't fail immediately in read-only mode
  - setEnvReadonlyEmptyStores
```
public EnvironmentConfig setEnvReadonlyEmptyStores(boolean readonlyEmptyStores)
```
    If is set to true and ENV_IS_READONLY is also true then Environment.openStore(String, StoreConfig, Transaction) doesn't try to create a Store, but returns an empty immutable instance instead. Default value is false.
    Mutable at runtime: yes
    
    Parameters:
    
    readonlyEmptyStores - true if attempt to create a Store shouldn't fail immediately in read-only mode
    
    Returns:
    
    this EnvironmentConfig instance
  - getEnvStoreGetCacheSize
```
public int getEnvStoreGetCacheSize()
```
    Returns the size of the "store-get" cache. The "store-get" cache can increase performance of Store.get(Transaction, ByteIterable) in certain cases. Default value is 0 what means that the cache is inactive. If the setting is mutated at runtime the cache is invalidated.
    Mutable at runtime: yes
    
    Returns:
    
    size of the "store-get" cache
  - setEnvStoreGetCacheSize
```
public EnvironmentConfig setEnvStoreGetCacheSize(int storeGetCacheSize)
```
    Sets the size of the "store-get" cache. The "store-get" cache can increase performance of Store.get(Transaction, ByteIterable) in certain cases. Default value is 0 what means that the cache is inactive. If the setting is mutated at runtime the cache is invalidated.
    Mutable at runtime: yes
    
    Parameters:
    
    storeGetCacheSize - size of the "store-get" cache
    
    Returns:
    
    this EnvironmentConfig instance
  - getEnvStoreGetCacheMinTreeSize
```
public int getEnvStoreGetCacheMinTreeSize()
```
  - setEnvStoreGetCacheMinTreeSize
```
public EnvironmentConfig setEnvStoreGetCacheMinTreeSize(int treeSize)
```
  - getEnvStoreGetCacheMaxValueSize
```
public int getEnvStoreGetCacheMaxValueSize()
```
  - setEnvStoreGetCacheMaxValueSize
```
public EnvironmentConfig setEnvStoreGetCacheMaxValueSize(int valueSize)
```
  - getEnvCloseForcedly
```
public boolean getEnvCloseForcedly()
```
    Returns true if Environment.close() shouldn't check if there are unfinished transactions. Otherwise it should check and throw ExodusException if there are. Default value is false.
    Mutable at runtime: yes
    
    Returns:
    
    true if Environment.close() shouldn't check unfinished transactions
    
    See Also:
    
    Environment.close()
  - setEnvCloseForcedly
```
public EnvironmentConfig setEnvCloseForcedly(boolean closeForcedly)
```
    Set true if Environment.close() shouldn't check if there are unfinished transactions. Set false if it should check and throw ExodusException if there are unfinished transactions. Default value is false.
    Mutable at runtime: yes
    
    Parameters:
    
    closeForcedly - true if Environment.close() should ignore unfinished transactions
    
    Returns:
    
    this EnvironmentConfig instance
    
    See Also:
    
    Environment.close()
  - getEnvTxnReplayTimeout
```
public long getEnvTxnReplayTimeout()
```
    Returns the number of millisecond which a Transaction can try to flush without attempts to upgrade (switch to an exclusive mode). Default value is 2000L.
    Mutable at runtime: yes
    
    Returns:
    
    number of millisecond which a Transaction can try to flush without attempts to upgrade
    
    See Also:
    
    Transaction, getEnvTxnReplayMaxCount()
  - setEnvTxnReplayTimeout
```
public EnvironmentConfig setEnvTxnReplayTimeout(long timeout)
```
    Sets the number of millisecond which a Transaction can try to flush without attempts to upgrade (switch to an exclusive mode). Default value is 2000L.
    Mutable at runtime: yes
    
    Parameters:
    
    timeout - number of millisecond which a Transaction can try to flush without attempts to upgrade
    
    Returns:
    
    this EnvironmentConfig instance
    
    See Also:
    
    Transaction, setEnvTxnReplayMaxCount(int)
  - getEnvTxnReplayMaxCount
```
public int getEnvTxnReplayMaxCount()
```
    Returns the number of times which a Transaction can try to flush without attempts to upgrade (switch to an exclusive mode). Default value is 2.
    Mutable at runtime: yes
    
    Returns:
    
    number of times which a Transaction can try to flush without attempts to upgrade
    
    See Also:
    
    Transaction, getEnvTxnReplayTimeout()
  - setEnvTxnReplayMaxCount
```
public EnvironmentConfig setEnvTxnReplayMaxCount(int count)
```
    Sets the number of times which a Transaction can try to flush without attempts to upgrade (switch to an exclusive mode). Default value is 2.
    Mutable at runtime: yes
    
    Parameters:
    
    count - number of times which a Transaction can try to flush without attempts to upgrade
    
    Returns:
    
    this EnvironmentConfig instance
    
    See Also:
    
    Transaction, setEnvTxnReplayTimeout(long)
  - getEnvTxnDowngradeAfterFlush
```
public boolean getEnvTxnDowngradeAfterFlush()
```
    If is set to true then any upgraded Transaction will downgrade itself after Transaction.flush(). Default value is true.
    Mutable at runtime: yes
    
    Returns:
    
    true if any upgraded Transaction will downgrade itself after flush
  - setEnvTxnDowngradeAfterFlush
```
public EnvironmentConfig setEnvTxnDowngradeAfterFlush(boolean downgrade)
```
    If is set to true then any upgraded Transaction will downgrade itself after Transaction.flush(). Default value is true.
    Mutable at runtime: yes
    
    Parameters:
    
    downgrade - true if any upgraded Transaction will downgrade itself after flush
    
    Returns:
    
    this EnvironmentConfig instance
  - getEnvTxnSingleThreadWrites
```
public boolean getEnvTxnSingleThreadWrites()
```
    If is set to true then any write operation can be performed only in the thread which the transaction was created in. Default value is false.
    Mutable at runtime: yes
    
    Returns:
    
    true if any write operation can be performed only in the thread which the transaction was created in
    
    See Also:
    
    Transaction
  - setEnvTxnSingleThreadWrites
```
public EnvironmentConfig setEnvTxnSingleThreadWrites(boolean singleThreadWrites)
```
    If is set to true then any write operation can be performed only in the thread which the transaction was created in. Default value is false.
    Mutable at runtime: yes
    
    Parameters:
    
    singleThreadWrites - true then any write operation can be performed only in the thread which the transaction was created in
    
    Returns:
    
    this EnvironmentConfig instance
  - isEnvTxnTraceFinish
```
public boolean isEnvTxnTraceFinish()
```
    If is set to true then each transaction, read/write or read-only, saves stack trace when it is finished (aborted or committed). The stack trace is then reported with TransactionFinishedException. Default value is false.
    Mutable at runtime: yes
    
    Returns:
    
    true if each transaction saves stack trace when it is finished
    
    Since:
    
    1.4.0
    
    See Also:
    
    Transaction
  - setEnvTxnTraceFinish
```
public EnvironmentConfig setEnvTxnTraceFinish(boolean traceFinish)
```
    If is set to true then each transaction, read/write or read-only, saves stack trace when it is finished (aborted or committed). The stack trace is then reported with TransactionFinishedException. Default value is false.
    Mutable at runtime: yes
    
    Parameters:
    
    traceFinish - true if each transaction should save stack trace when it is finished
    
    Returns:
    
    this EnvironmentConfig instance
    
    Since:
    
    1.4.0
    
    See Also:
    
    Transaction
  - getEnvMaxParallelTxns
```
public int getEnvMaxParallelTxns()
```
    Returns the number of transactions that can be started in parallel. By default it is unlimited.
    Mutable at runtime: no
    
    Returns:
    
    number of transactions that can be started in parallel
  - setEnvMaxParallelTxns
```
public EnvironmentConfig setEnvMaxParallelTxns(int maxParallelTxns)
```
    Sets the number of transactions that can be started in parallel. By default it is unlimited.
    Mutable at runtime: no
    
    Parameters:
    
    maxParallelTxns - number of transactions that can be started in parallel
    
    Returns:
    
    this EnvironmentConfig instance
  - getEnvMaxParallelReadonlyTxns
```
@Deprecated
public int getEnvMaxParallelReadonlyTxns()
```
    Deprecated.
    
    Returns the number of read-only transactions that can be started in parallel. By default it is unlimited.
    Mutable at runtime: no As of 1.4.0, is deprecated.
    
    Returns:
    
    number of read-only transactions that can be started in parallel
  - setEnvMaxParallelReadonlyTxns
```
public EnvironmentConfig setEnvMaxParallelReadonlyTxns(int maxParallelReadonlyTxns)
```
    Sets the number of read-only transactions that can be started in parallel. By default it is unlimited.
    Mutable at runtime: no As of 1.4.0, is deprecated.
    
    Parameters:
    
    maxParallelReadonlyTxns - number of read-only transactions that can be started in parallel
    
    Returns:
    
    this EnvironmentConfig instance
  - getEnvMonitorTxnsTimeout
```
public int getEnvMonitorTxnsTimeout()
```
    Returns Transaction timeout in milliseconds. If transaction doesn't finish in this timeout then it is reported in logs as stuck along with stack trace which it was created with. Default value is 0 which means that no timeout for a Transaction is defined. In that case, no monitor of stuck transactions is started. Otherwise it is started for each Environment, though consuming only a single Thread amongst all environments created within a single class loader.
    Mutable at runtime: no
    
    Returns:
    
    timeout of a Transaction in milliseconds
    
    See Also:
    
    getEnvMonitorTxnsCheckFreq()
  - setEnvMonitorTxnsTimeout
```
public EnvironmentConfig setEnvMonitorTxnsTimeout(int timeout)
```
    Sets Transaction timeout in milliseconds. If transaction doesn't finish in this timeout then it is reported in logs as stuck along with stack trace which it was created with. Default value is 0 which means that no timeout for a Transaction is defined. In that case, no monitor of stuck transactions is started. Otherwise it is started for each Environment, though consuming only a single Thread amongst all environments created within a single class loader.
    Mutable at runtime: no
    
    Parameters:
    
    timeout - timeout of a Transaction in milliseconds
    
    Returns:
    
    this EnvironmentConfig instance
    
    See Also:
    
    setEnvMonitorTxnsCheckFreq(int)
  - getEnvMonitorTxnsExpirationTimeout
```
public int getEnvMonitorTxnsExpirationTimeout()
```
    Defines Transaction expiration timeout in milliseconds. If transaction doesn't finish in this timeout then it is forced to be finished. Default value is 8 hours. 0 value means that no expiration for a Transaction is defined. Otherwise it is started for each Environment, though consuming only a single Thread amongst all environments created within a single class loader.
    Mutable at runtime: no
    
    Returns:
    
    expiration timeout of a Transaction in milliseconds
    
    See Also:
    
    getEnvMonitorTxnsCheckFreq()
  - setEnvMonitorTxnsExpirationTimeout
```
public EnvironmentConfig setEnvMonitorTxnsExpirationTimeout(int timeout)
```
    Defines Transaction expiration timeout in milliseconds. If transaction doesn't finish in this timeout then it is forced to be finished. Default value is 8 hours. 0 value means that no expiration for a Transaction is defined. Otherwise it is started for each Environment, though consuming only a single Thread amongst all environments created within a single class loader.
    Mutable at runtime: no
    
    Parameters:
    
    timeout - timeout of a Transaction in milliseconds
    
    Returns:
    
    this EnvironmentConfig instance
    
    See Also:
    
    setEnvMonitorTxnsCheckFreq(int)
  - getEnvMonitorTxnsCheckFreq
```
public int getEnvMonitorTxnsCheckFreq()
```
    If ENV_MONITOR_TXNS_TIMEOUT is non-zero then stuck transactions monitor starts and checks Environment's transactions with this frequency (period) specified in milliseconds. Default value is 60000, one minute.
    Mutable at runtime: no
    
    Returns:
    
    frequency (period) in milliseconds of checking stuck transactions
    
    See Also:
    
    getEnvMonitorTxnsTimeout()
  - setEnvMonitorTxnsCheckFreq
```
public EnvironmentConfig setEnvMonitorTxnsCheckFreq(int freq)
```
    If ENV_MONITOR_TXNS_TIMEOUT is non-zero then stuck transactions monitor starts and checks Environment's transactions with this frequency (period) specified in milliseconds. Default value is 60000, one minute.
    Mutable at runtime: no
    
    Parameters:
    
    freq - frequency (period) in milliseconds of checking stuck transactions
    
    Returns:
    
    this EnvironmentConfig instance
    
    See Also:
    
    setEnvMonitorTxnsTimeout(int), setEnvMonitorTxnsExpirationTimeout(int)
  - getEnvGatherStatistics
```
public boolean getEnvGatherStatistics()
```
    Returns true if the Environment gathers statistics. If MANAGEMENT_ENABLED is also true then the statistics is exposed by the JMX managed bean. Default value is true.
    Mutable at runtime: no
    
    Returns:
    
    true if the Environment gathers statistics
    
    See Also:
    
    Environment.getStatistics()
  - setEnvGatherStatistics
```
public EnvironmentConfig setEnvGatherStatistics(boolean gatherStatistics)
```
    Set true if the Environment should gather statistics. If MANAGEMENT_ENABLED is also true then the statistics is exposed by the JMX managed bean. Default value is true.
    Mutable at runtime: no
    
    Parameters:
    
    gatherStatistics - true if the Environment should gather statistics
    
    Returns:
    
    this EnvironmentConfig instance
    
    See Also:
    
    Environment.getStatistics()
  - getEnvCompactOnOpen
```
public boolean getEnvCompactOnOpen()
```
    Returns true if the Environment will compact itself on opening. Default value is false.
    Mutable at runtime: no
    
    Returns:
    
    true if the Environment will compact itself on opening
  - setEnvCompactOnOpen
```
public EnvironmentConfig setEnvCompactOnOpen(boolean compactOnOpen)
```
    Set true if the Environment should compact itself on opening Default value is false.
    Mutable at runtime: no
    
    Parameters:
    
    compactOnOpen - true if the Environment should compact itself on opening
    
    Returns:
    
    this EnvironmentConfig instance
  - getTreeMaxPageSize
```
public int getTreeMaxPageSize()
```
    Returns the maximum size of page of B+Tree. Default value is 128.
    Mutable at runtime: yes
    
    Returns:
    
    maximum size of page of B+Tree
  - setTreeMaxPageSize
```
public EnvironmentConfig setTreeMaxPageSize(int pageSize)
                                     throws InvalidSettingException
```
    Sets the maximum size of page of B+Tree. Default value is 128. Only sizes in the range [16..1024] are accepted.
    Mutable at runtime: yes
    
    Parameters:
    
    pageSize - maximum size of page of B+Tree
    
    Returns:
    
    this EnvironmentConfig instance
    
    Throws:
    
    InvalidSettingException - page size is not in the range [16..1024]
  - getTreeDupMaxPageSize
```
public int getTreeDupMaxPageSize()
```
    Returns the maximum size of page of duplicates sub-B+Tree. Default value is 8.
    Mutable at runtime: yes
    
    Returns:
    
    maximum size of page of duplicates sub-B+Tree
  - setTreeDupMaxPageSize
```
public EnvironmentConfig setTreeDupMaxPageSize(int pageSize)
                                        throws InvalidSettingException
```
    Sets the maximum size of page of duplicates sub-B+Tree. Default value is 8. Only sizes in the range [8..128] are accepted.
    Mutable at runtime: yes
    
    Parameters:
    
    pageSize - maximum size of page of duplicates sub-B+Tree
    
    Returns:
    
    this EnvironmentConfig instance
    
    Throws:
    
    InvalidSettingException - page size is not in the range [8..128]
  - getTreeNodesCacheSize
```
@Deprecated
public int getTreeNodesCacheSize()
```
    Deprecated.
    
    As of 1.0.5, is deprecated and has no effect.
    Mutable at runtime: no
    
    Returns:
    
    0
  - setTreeNodesCacheSize
```
@Deprecated
public EnvironmentConfig setTreeNodesCacheSize(int cacheSize)
```
    Deprecated.
    
    As of 1.0.5, is deprecated and has no effect.
    Mutable at runtime: no
    
    Returns:
    
    this EnvironmentConfig instance
  - isGcEnabled
```
public boolean isGcEnabled()
```
    Returns true if the database garbage collector is enabled. Default value is true. Switching GC off makes sense only for debugging and troubleshooting purposes.
    Mutable at runtime: yes
    
    Returns:
    
    true if the database garbage collector is enabled
  - setGcEnabled
```
public EnvironmentConfig setGcEnabled(boolean enabled)
```
    Set true to enable the database garbage collector. Default value is true. Switching GC off makes sense only for debugging and troubleshooting purposes.
    Mutable at runtime: yes
    
    Parameters:
    
    enabled - true to enable the database garbage collector
    
    Returns:
    
    this EnvironmentConfig instance
  - getGcStartIn
```
public int getGcStartIn()
```
    Returns the number of milliseconds which the database garbage collector is postponed for after the Environment is created. Default value is 10000.
    Mutable at runtime: no
    
    Returns:
    
    number of milliseconds which the database garbage collector is postponed for after the Environment is created
  - setGcStartIn
```
public EnvironmentConfig setGcStartIn(int startInMillis)
                               throws InvalidSettingException
```
    Sets the number of milliseconds which the database garbage collector is postponed for after the Environment is created. Default value is 10000.
    Mutable at runtime: no
    
    Parameters:
    
    startInMillis - number of milliseconds which the database garbage collector should be postponed for after the Environment is created
    
    Returns:
    
    this EnvironmentConfig instance
    
    Throws:
    
    InvalidSettingException - startInMillis is negative
  - getGcMinUtilization
```
public int getGcMinUtilization()
```
    Returns percent of minimum database utilization. Default value is 50. That means that 50 percent of free space in raw data in Log files (.xd files) is allowed. If database utilization is less than defined (free space percent is more than 50), the database garbage collector is triggered.
    Mutable at runtime: yes
    
    Returns:
    
    percent of minimum database utilization
  - setGcMinUtilization
```
public EnvironmentConfig setGcMinUtilization(int percent)
                                      throws InvalidSettingException
```
    Sets percent of minimum database utilization. Default value is 50. That means that 50 percent of free space in raw data in Log files (.xd files) is allowed. If database utilization is less than defined (free space percent is more than 50), the database garbage collector is triggered.
    Mutable at runtime: yes
    
    Parameters:
    
    percent - percent of minimum database utilization
    
    Returns:
    
    this EnvironmentConfig instance
    
    Throws:
    
    InvalidSettingException - percent is not in the range [1..90]
  - getGcRenameFiles
```
public boolean getGcRenameFiles()
```
    If returns true the database garbage collector renames files rather than deletes them. Default value is false. It makes sense to change this setting only for debugging and troubleshooting purposes.
    Mutable at runtime: yes
    
    Returns:
    
    true if the database garbage collector should rename files rather than deletes them
  - setGcRenameFiles
```
public EnvironmentConfig setGcRenameFiles(boolean rename)
```
    Set true if the database garbage collector should rename files rather than deletes them. Default value is false. It makes sense to change this setting only for debugging and troubleshooting purposes.
    Mutable at runtime: yes
    
    Parameters:
    
    rename - true if the database garbage collector should rename files rather than deletes them
    
    Returns:
    
    this EnvironmentConfig instance
  - getGcUseExpirationChecker
```
@Deprecated
public boolean getGcUseExpirationChecker()
```
    Deprecated.
    
    As of 1.0.2, is deprecated and has no effect.
    Mutable at runtime: no
    
    Returns:
    
    false
  - setGcUseExpirationChecker
```
@Deprecated
public EnvironmentConfig setGcUseExpirationChecker(boolean useExpirationChecker)
```
    Deprecated.
    
    As of 1.0.2, is deprecated and has no effect.
    Mutable at runtime: no
    
    Returns:
    
    this EnvironmentConfig instance
  - getGcFileMinAge
```
public int getGcFileMinAge()
```
    Returns the minimum age of a Log file (.xd file) to consider it for cleaning by the database garbage collector. The age of the last (the newest, the rightmost) Log file is 0, the age of previous file is 1, etc. Default value is 2.
    Mutable at runtime: yes
    
    Returns:
    
    minimum age of .xd file to consider it for cleaning by the database garbage collector
  - setGcFileMinAge
```
public EnvironmentConfig setGcFileMinAge(int minAge)
                                  throws InvalidSettingException
```
    Returns the minimum age of a Log file (.xd file) to consider it for cleaning by the database garbage collector. The age of the last (the newest, the rightmost) Log file is 0, the age of previous file is 1, etc. Default value is 2. The age cannot be less than 1.
    Mutable at runtime: yes
    
    Parameters:
    
    minAge - minimum age of .xd file to consider it for cleaning by the database garbage collector
    
    Returns:
    
    this EnvironmentConfig instance
    
    Throws:
    
    InvalidSettingException - minAge is less than 1.
  - getGcFilesInterval
```
@Deprecated
public int getGcFilesInterval()
```
    Deprecated.
    
    Returns the number of new Log files (.xd files) that must be created to trigger if necessary (if database utilization is not sufficient) the next background cleaning cycle (single run of the database garbage collector) after the previous cycle finished. Default value is 3, i.e. GC can start after each 3 newly created Log files.
    Mutable at runtime: yes
    
    Returns:
    
    number of new .xd files that must be created to trigger the next background cleaning cycle
  - setGcFilesInterval
```
@Deprecated
public EnvironmentConfig setGcFilesInterval(int files)
                                                 throws InvalidSettingException
```
    Deprecated.
    
    Sets the number of new Log files (.xd files) that must be created to trigger if necessary (if database utilization is not sufficient) the next background cleaning cycle (single run of the database garbage collector) after the previous cycle finished. Default value is 3, i.e. GC can start after each 3 newly created Log files. Cannot be less than 1.
    Mutable at runtime: yes
    
    Parameters:
    
    files - number of new .xd files that must be created to trigger the next background cleaning cycle
    
    Returns:
    
    this EnvironmentConfig instance
    
    Throws:
    
    InvalidSettingException - files is less than 1
  - getGcRunPeriod
```
public int getGcRunPeriod()
```
    Returns the number of milliseconds after which background cleaning cycle (single run of the database garbage collector) can be repeated if the previous one didn't reach required utilization. Default value is 5000.
    Mutable at runtime: yes
    
    Returns:
    
    number of milliseconds after which background cleaning cycle can be repeated if the previous one didn't reach required utilization
  - setGcRunPeriod
```
public EnvironmentConfig setGcRunPeriod(int runPeriod)
                                 throws InvalidSettingException
```
    Sets the number of milliseconds after which background cleaning cycle (single run of the database garbage collector) can be repeated if the previous one didn't reach required utilization. Default value is 5000.
    Mutable at runtime: yes
    
    Parameters:
    
    runPeriod - number of milliseconds after which background cleaning cycle can be repeated if the previous one didn't reach required utilization
    
    Returns:
    
    this EnvironmentConfig instance
    
    Throws:
    
    InvalidSettingException - runPeriod is less than 0
  - getGcUtilizationFromScratch
```
public boolean getGcUtilizationFromScratch()
```
    Returns true if database utilization will be computed from scratch before the first cleaning cycle (single run of the database garbage collector) is triggered, i.e. shortly after the database is open. In addition, can be used to compute utilization information at runtime by just modifying the setting value. Default value is false.
    Mutable at runtime: yes
    
    Returns:
    
    true if database utilization will be computed from scratch
  - setGcUtilizationFromScratch
```
public EnvironmentConfig setGcUtilizationFromScratch(boolean fromScratch)
```
    Set true if database utilization should be computed from scratch before the first cleaning cycle (single run of the database garbage collector) is triggered, i.e. shortly after the database is open. In addition, can be used to compute utilization information at runtime by just modifying the setting value. Default value is false.
    Mutable at runtime: yes
    
    Parameters:
    
    fromScratch - true if database utilization should be computed from scratch
    
    Returns:
    
    this EnvironmentConfig instance
  - getGcUtilizationFromFile
```
public java.lang.String getGcUtilizationFromFile()
```
    Returns full path to the file with stored utilization. Is used on creation of an Environment to update .xd files' utilization before the first cleaning cycle (single run of the database garbage collector) is triggered. In addition, can be used to reload utilization information at runtime by just modifying the setting value. Format of the stored utilization is expected to be the same as created by the "-d" option of the Reflect tool. Default value is empty string.
    Mutable at runtime: yes
    
    Returns:
    
    if not empty, full path to the file with stored utilization.
  - setGcUtilizationFromFile
```
public EnvironmentConfig setGcUtilizationFromFile(java.lang.String file)
```
    Sets full path to the file with stored utilization. Is used on creation of an Environment to update .xd files' utilization before the first cleaning cycle (single run of the database garbage collector) is triggered. In addition, can be used to reload utilization information at runtime by just modifying the setting value. Format of the stored utilization is expected to be the same as created by the "-d" option of the Reflect tool. Default value is empty string.
    Mutable at runtime: yes
    
    Parameters:
    
    file - full path to the file with stored utilization
    
    Returns:
    
    this EnvironmentConfig instance
  - getGcUseExclusiveTransaction
```
public boolean getGcUseExclusiveTransaction()
```
    Returns true if the database garbage collector tries to acquire exclusive Transaction for its purposes. In that case, GC transaction never re-plays. In order to not block background cleaner thread forever, acquisition of exclusive GC transaction is performed with a timeout controlled by the GC_TRANSACTION_ACQUIRE_TIMEOUT setting. Default value is true.
    Mutable at runtime: yes
    
    Returns:
    
    true if the database garbage collector tries to acquire exclusive Transaction
    
    See Also:
    
    getGcTransactionAcquireTimeout(), getGcTransactionTimeout()
  - setGcUseExclusiveTransaction
```
public EnvironmentConfig setGcUseExclusiveTransaction(boolean useExclusiveTransaction)
```
    Sets true if the database garbage collector should try to acquire exclusive Transaction for its purposes. In that case, GC transaction never re-plays. In order to not block background cleaner thread forever, acquisition of exclusive GC transaction is performed with a timeout controlled by the GC_TRANSACTION_ACQUIRE_TIMEOUT setting. Default value is true.
    Mutable at runtime: yes
    
    Parameters:
    
    useExclusiveTransaction - true if the database garbage collector should try to acquire exclusive Transaction
    
    Returns:
    
    this EnvironmentConfig instance
    
    See Also:
    
    setGcTransactionAcquireTimeout(int), setGcTransactionTimeout(int)
  - getGcTransactionAcquireTimeout
```
public int getGcTransactionAcquireTimeout()
```
    Returns timeout in milliseconds which is used by the database garbage collector to acquire exclusive Transaction for its purposes if GC_USE_EXCLUSIVE_TRANSACTION is true. Default value is 1000.
    Mutable at runtime: yes
    
    Returns:
    
    timeout in milliseconds which is used by the database garbage collector to acquire exclusive Transaction
    
    See Also:
    
    getGcUseExclusiveTransaction(), getGcTransactionTimeout()
  - setGcTransactionAcquireTimeout
```
public EnvironmentConfig setGcTransactionAcquireTimeout(int txnAcquireTimeout)
```
    Sets timeout in milliseconds which is used by the database garbage collector to acquire exclusive Transaction for its purposes if GC_USE_EXCLUSIVE_TRANSACTION is true. Default value is 1000.
    Mutable at runtime: yes
    
    Parameters:
    
    txnAcquireTimeout - timeout in milliseconds which is used by the database garbage collector to acquire exclusive Transaction
    
    Returns:
    
    this EnvironmentConfig instance
    
    See Also:
    
    setGcUseExclusiveTransaction(boolean), setGcTransactionTimeout(int)
  - getGcTransactionTimeout
```
public int getGcTransactionTimeout()
```
    Returns timeout in milliseconds which is used by the database garbage collector to reclaim non-expired data in several files inside single GC Transaction acquired exclusively. GC_USE_EXCLUSIVE_TRANSACTION should be true. Default value is 500.
    Mutable at runtime: yes
    
    Returns:
    
    timeout in milliseconds which is used by the database garbage collector to reclaim non-expired data in several files inside single Transaction acquired exclusively
    
    See Also:
    
    getGcUseExclusiveTransaction(), getGcTransactionAcquireTimeout()
  - setGcTransactionTimeout
```
public EnvironmentConfig setGcTransactionTimeout(int txnTimeout)
```
    Sets timeout in milliseconds which is used by the database garbage collector to reclaim non-expired data in several files inside single GC Transaction acquired exclusively. GC_USE_EXCLUSIVE_TRANSACTION should be true. Default value is 500.
    Mutable at runtime: yes
    
    Parameters:
    
    txnTimeout - timeout in milliseconds which is used by the database garbage collector to reclaim non-expired data in several files inside single Transaction acquired exclusively
    
    Returns:
    
    this EnvironmentConfig instance
    
    See Also:
    
    setGcUseExclusiveTransaction(boolean), setGcTransactionAcquireTimeout(int)
  - getGcFilesDeletionDelay
```
public int getGcFilesDeletionDelay()
```
    Returns the number of milliseconds which deletion of any successfully cleaned Log file (.xd file) is postponed for. Default value is 5000.
    Mutable at runtime: yes
    
    Returns:
    
    number of milliseconds which deletion of any successfully cleaned .xd file is postponed for
  - setGcFilesDeletionDelay
```
public EnvironmentConfig setGcFilesDeletionDelay(int delay)
                                          throws InvalidSettingException
```
    Sets the number of milliseconds which deletion of any successfully cleaned Log file (.xd file) is postponed for. Default value is 5000.
    Mutable at runtime: yes
    
    Parameters:
    
    delay - number of milliseconds which deletion of any successfully cleaned .xd file is postponed for
    
    Returns:
    
    this EnvironmentConfig instance
    
    Throws:
    
    InvalidSettingException - delay is less than 0.
  - getGcRunEvery
```
public int getGcRunEvery()
```
    GC is forced every this number of seconds. Default value is 0 which means that GC is not forced periodically.
    Mutable at runtime: yes
  - setGcRunEvery
```
public EnvironmentConfig setGcRunEvery(int seconds)
```
    Sets GC to be forced every this number of seconds. If the value is zero GC is not forced periodically. Default value is 0.
    Mutable at runtime: yes
  - isManagementEnabled
```
public boolean isManagementEnabled()
```
    Return true if the Environment exposes two JMX managed beans. One for environment statistics and second for controlling the EnvironmentConfig settings. Default value is true for non-Android OS, under Android it is always false.
    Mutable at runtime: no
    
    Returns:
    
    true if the Environment exposes JMX managed beans
  - setManagementEnabled
```
public EnvironmentConfig setManagementEnabled(boolean managementEnabled)
```
    Set true if the Environment should expose two JMX managed beans. One for environment statistics and second for controlling the EnvironmentConfig settings. Default value is true for non-Android OS, under Android it is always false.
    Mutable at runtime: no
    
    Parameters:
    
    managementEnabled - true if the Environment should expose JMX managed beans
    
    Returns:
    
    this EnvironmentConfig instance
  - getManagementOperationsRestricted
```
public boolean getManagementOperationsRestricted()
```
    If is set to true then exposed JMX managed beans cannot have operations. Default value is true.
    Mutable at runtime: no
    
    Returns:
    
    true if exposed JMX managed beans cannot have operations.
    
    See Also:
    
    isManagementEnabled()
  - setManagementOperationsRestricted
```
public EnvironmentConfig setManagementOperationsRestricted(boolean operationsRestricted)
```
    If isManagementEnabled() then set false in order to expose operations with JMX managed beans in addition to attributes.
    
    Parameters:
    
    operationsRestricted - false if JMX managed beans should expose operations in addition to attributes
    
    Returns:
    
    this EnvironmentConfig instance
  - setMetaServer
```
public EnvironmentConfig setMetaServer(MetaServer metaServer)
```
  - getMetaServer
```
public MetaServer getMetaServer()
```

Class EnvironmentConfig

Field Summary

Constructor Summary

Method Summary

Methods inherited from class jetbrains.exodus.AbstractConfig

Methods inherited from class java.lang.Object

Field Detail

DEFAULT

MEMORY_USAGE

MEMORY_USAGE_PERCENTAGE

USE_VERSION1_FORMAT

CIPHER_ID

CIPHER_KEY

CIPHER_BASIC_IV

PROFILER_ENABLED

LOG_DURABLE_WRITE

LOG_FILE_SIZE

LOG_LOCK_TIMEOUT

LOG_LOCK_ID

LOG_CACHE_PAGE_SIZE

LOG_CACHE_OPEN_FILES

LOG_CACHE_USE_NIO

LOG_CACHE_FREE_PHYSICAL_MEMORY_THRESHOLD

LOG_CACHE_SHARED

LOG_CACHE_NON_BLOCKING

LOG_CACHE_GENERATION_COUNT

LOG_CACHE_USE_SOFT_REFERENCES

LOG_CACHE_READ_AHEAD_MULTIPLE

LOG_CACHE_WARMUP

LOG_CLEAN_DIRECTORY_EXPECTED

LOG_CLEAR_INVALID

LOG_SYNC_PERIOD

LOG_FULL_FILE_READ_ONLY

LOG_ALLOW_REMOVABLE

LOG_ALLOW_REMOTE

LOG_ALLOW_RAM_DISK

LOG_DATA_READER_WRITER_PROVIDER

ENV_IS_READONLY

ENV_FAIL_FAST_IN_READONLY

ENV_READONLY_EMPTY_STORES

ENV_STOREGET_CACHE_SIZE

ENV_STOREGET_CACHE_MIN_TREE_SIZE

ENV_STOREGET_CACHE_MAX_VALUE_SIZE

ENV_CLOSE_FORCEDLY

ENV_TXN_REPLAY_TIMEOUT

ENV_TXN_REPLAY_MAX_COUNT

ENV_TXN_DOWNGRADE_AFTER_FLUSH

ENV_TXN_SINGLE_THREAD_WRITES

ENV_TXN_TRACE_FINISH

ENV_MAX_PARALLEL_TXNS

ENV_MAX_PARALLEL_READONLY_TXNS

ENV_MONITOR_TXNS_TIMEOUT

ENV_MONITOR_TXNS_EXPIRATION_TIMEOUT

ENV_MONITOR_TXNS_CHECK_FREQ

ENV_GATHER_STATISTICS

ENV_COMPACT_ON_OPEN

TREE_MAX_PAGE_SIZE

TREE_DUP_MAX_PAGE_SIZE

TREE_NODES_CACHE_SIZE

GC_ENABLED

GC_START_IN

GC_MIN_UTILIZATION

GC_RENAME_FILES

GC_USE_EXPIRATION_CHECKER

GC_MIN_FILE_AGE

GC_FILES_INTERVAL

GC_RUN_PERIOD

GC_UTILIZATION_FROM_SCRATCH

GC_UTILIZATION_FROM_FILE

GC_USE_EXCLUSIVE_TRANSACTION

GC_TRANSACTION_ACQUIRE_TIMEOUT

GC_TRANSACTION_TIMEOUT

GC_FILES_DELETION_DELAY

GC_RUN_EVERY

MANAGEMENT_ENABLED

MANAGEMENT_OPERATIONS_RESTRICTED

META_SERVER

Constructor Detail

EnvironmentConfig

EnvironmentConfig