DBMaker.Maker (mapdb 2.0-beta12 API)

java.lang.Object
- org.mapdb.DBMaker.Maker

Enclosing class:: DBMaker

public static final class DBMaker.Maker
extends Object

Field Summary

Fields
Modifier and Type	Field and Description
`protected Fun.RecordCondition`	`cacheCondition`
`protected ScheduledExecutorService`	`cacheExecutor`
`protected ScheduledExecutorService`	`executor`
`protected ScheduledExecutorService`	`metricsExecutor`
`protected Properties`	`props`
`protected ClassLoader`	`serializerClassLoader`
`protected Map<String,ClassLoader>`	`serializerClassLoaderRegistry`
`protected ScheduledExecutorService`	`storeExecutor`

Constructor Summary

Constructors
Modifier Constructor and Description

protected DBMaker.Maker()
use static factory methods, or make subclass

protected DBMaker.Maker(File file)

Constructors
Modifier	Constructor and Description
`protected`	`DBMaker.Maker()` use static factory methods, or make subclass
`protected`	`DBMaker.Maker(File file)`

Method Summary

Methods
Modifier and Type	Method and Description
`DBMaker.Maker`	`_newAppendFileDB(File file)`
`DBMaker.Maker`	`_newArchiveFileDB(File file)`
`DBMaker.Maker`	`_newFileDB(File file)`
`DBMaker.Maker`	`_newHeapDB()`
`DBMaker.Maker`	`_newMemoryDB()`
`DBMaker.Maker`	`_newMemoryDirectDB()`
`DBMaker.Maker`	`_newMemoryUnsafeDB()`
`DBMaker.Maker`	`allocateIncrement(long sizeIncrement)` Tells allocator to grow store with this size increment.
`DBMaker.Maker`	`allocateRecidReuseDisable()` Deprecated. this setting might be removed before 2.0 stable release, it is very likely it will become enabled by default
`DBMaker.Maker`	`allocateStartSize(long size)` Tells allocator to set initial store size, when new store is created.
`DBMaker.Maker`	`asyncWriteEnable()` Enables mode where all modifications are queued and written into disk on Background Writer Thread.
`DBMaker.Maker`	`asyncWriteFlushDelay(int delay)` Set flush interval for write cache, by default is 0
`DBMaker.Maker`	`asyncWriteQueueSize(int queueSize)` Set size of async Write Queue.
`DBMaker.Maker`	`cacheCondition(Fun.RecordCondition cacheCondition)` Install callback condition, which decides if some record is to be included in cache.
`DBMaker.Maker`	`cacheDisable()` Deprecated. cache is disabled by default
`DBMaker.Maker`	`cacheExecutorEnable()` Enable separate executor for cache.
`DBMaker.Maker`	`cacheExecutorEnable(ScheduledExecutorService metricsExecutor)` Enable separate executor for cache.
`DBMaker.Maker`	`cacheExecutorPeriod(long period)` Sets interval in which executor should check cache
`DBMaker.Maker`	`cacheHardRefEnable()` Enables unbounded hard reference cache.
`DBMaker.Maker`	`cacheHashTableEnable()` Fixed size cache which uses hash table.
`DBMaker.Maker`	`cacheHashTableEnable(int cacheSize)` Fixed size cache which uses hash table.
`DBMaker.Maker`	`cacheLRUEnable()` Enables Least Recently Used cache.
`DBMaker.Maker`	`cacheSize(int cacheSize)` Set cache size.
`DBMaker.Maker`	`cacheSoftRefEnable()` Enables unbounded cache which uses `SoftReference`.
`DBMaker.Maker`	`cacheWeakRefEnable()` Enables unbounded cache which uses `WeakReference`.
`DBMaker.Maker`	`checksumEnable()` Adds CRC32 checksum at end of each record to check data integrity.
`DBMaker.Maker`	`closeOnJvmShutdown()` Adds JVM shutdown hook and closes DB just before JVM;
`DBMaker.Maker`	`commitFileSyncDisable()` Deprecated. ignored in MapDB 2 for now
`DBMaker.Maker`	`compressionEnable()` Enables record compression.
`protected Store.Cache`	`createCache(boolean disableLocks, int lockScale)`
`DBMaker.Maker`	`deleteFilesAfterClose()` Try to delete files after DB is closed.
`DBMaker.Maker`	`encryptionEnable(byte[] password)` Encrypt storage using XTEA algorithm.
`DBMaker.Maker`	`encryptionEnable(String password)` Encrypt storage using XTEA algorithm.
`DBMaker.Maker`	`executorEnable()` Enables background executor
`protected Engine`	`extendSnapshotEngine(Engine engine, int lockScale)`
`protected Volume.VolumeFactory`	`extendStoreVolumeFactory(boolean index)`
`protected Engine`	`extendWrapSnapshotEngine(Engine engine)`
`DBMaker.Maker`	`fileChannelEnable()` Enable FileChannel access.
`DBMaker.Maker`	`fileLockDisable()` MapDB needs exclusive lock over storage file it is using.
`DBMaker.Maker`	`fileLockHeartbeatEnable()` MapDB needs exclusive lock over storage file it is using.
`DBMaker.Maker`	`fileMmapCleanerHackEnable()` Enables cleaner hack to close mmaped files at DB.close(), rather than Garbage Collection.
`DBMaker.Maker`	`fileMmapEnable()` Enables Memory Mapped Files, much faster storage option.
`DBMaker.Maker`	`fileMmapEnableIfSupported()` Enable Memory Mapped Files only if current JVM supports it (is 64bit).
`DBMaker.Maker`	`fileMmapPreclearDisable()` Disables preclear workaround for JVM crash.
`DBMaker.Maker`	`freeSpaceReclaimQ(int q)` Deprecated. ignored in MapDB 2 for now
`protected static boolean`	`JVMSupportsLargeMappedFiles()` Check if large files can be mapped into memory.
`DBMaker.Maker`	`lockDisable()` Disable locks.
`DBMaker.Maker`	`lockScale(int scale)` Sets concurrency scale.
`DBMaker.Maker`	`lockSingleEnable()` Disables double read-write locks and enables single read-write locks.
`DB`	`make()` constructs DB using current settings
`protected Fun.Function1<Class,String>`	`makeClassLoader()`
`Engine`	`makeEngine()` constructs Engine using current settings
`TxMaker`	`makeTxMaker()`
`DBMaker.Maker`	`metricsEnable()` Enable metrics, log at info level every 10 SECONDS
`DBMaker.Maker`	`metricsEnable(long metricsLogPeriod)`
`DBMaker.Maker`	`metricsExecutorEnable()` Enable separate executor for metrics.
`DBMaker.Maker`	`metricsExecutorEnable(ScheduledExecutorService metricsExecutor)` Enable separate executor for metrics.
`DBMaker.Maker`	`mmapFileEnable()` Deprecated. renamed to `fileMmapEnable()`
`DBMaker.Maker`	`mmapFileEnableIfSupported()` Deprecated. renamed to `fileMmapEnableIfSupported()`
`DBMaker.Maker`	`mmapFileEnablePartial()` Deprecated. mapdb 2.0 uses single file, no partial mapping possible
`protected boolean`	`propsGetBool(String key)`
`protected int`	`propsGetInt(String key, int defValue)`
`protected long`	`propsGetLong(String key, long defValue)`
`protected int`	`propsGetRafMode()`
`protected byte[]`	`propsGetXteaEncKey()`
`DBMaker.Maker`	`readOnly()` Open store in read-only mode.
`DBMaker.Maker`	`serializerClassLoader(ClassLoader classLoader)` Sets class loader used to POJO serializer to load classes during deserialization.
`DBMaker.Maker`	`serializerRegisterClass(Class... classes)` Register classes with their Class Loaders.
`DBMaker.Maker`	`serializerRegisterClass(String className, ClassLoader classLoader)` Register class with given Class Loader.
`DBMaker.Maker`	`sizeLimit(double maxSize)` Deprecated. right now not implemented, will be renamed to allocate()*
`DBMaker.Maker`	`snapshotEnable()` MapDB supports snapshots.
`DBMaker.Maker`	`storeExecutorEnable()` Enable separate executor for store (async write, compaction)
`DBMaker.Maker`	`storeExecutorEnable(ScheduledExecutorService metricsExecutor)` Enable separate executor for cache.
`DBMaker.Maker`	`storeExecutorPeriod(long period)` Sets interval in which executor should check cache
`DBMaker.Maker`	`strictDBGet()` DB Get methods such as `DB.treeMap(String)` or `DB.atomicLong(String)` auto create new record with default values, if record with given name does not exist.
`DBMaker.Maker`	`transactionDisable()` Transaction journal is enabled by default You must call DB.commit() to save your changes.

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

- Field Detail
  - cacheCondition
```
protected Fun.RecordCondition cacheCondition
```
  - executor
```
protected ScheduledExecutorService executor
```
  - metricsExecutor
```
protected ScheduledExecutorService metricsExecutor
```
  - cacheExecutor
```
protected ScheduledExecutorService cacheExecutor
```
  - storeExecutor
```
protected ScheduledExecutorService storeExecutor
```
  - serializerClassLoader
```
protected ClassLoader serializerClassLoader
```
  - serializerClassLoaderRegistry
```
protected Map<String,ClassLoader> serializerClassLoaderRegistry
```
  - props
```
protected Properties props
```
- Constructor Detail
  - DBMaker.Maker
```
protected DBMaker.Maker()
```
    use static factory methods, or make subclass
  - DBMaker.Maker
```
protected DBMaker.Maker(File file)
```
- Method Detail
  - _newHeapDB
```
public DBMaker.Maker _newHeapDB()
```
  - _newMemoryDB
```
public DBMaker.Maker _newMemoryDB()
```
  - _newMemoryDirectDB
```
public DBMaker.Maker _newMemoryDirectDB()
```
  - _newMemoryUnsafeDB
```
public DBMaker.Maker _newMemoryUnsafeDB()
```
  - _newAppendFileDB
```
public DBMaker.Maker _newAppendFileDB(File file)
```
  - _newArchiveFileDB
```
public DBMaker.Maker _newArchiveFileDB(File file)
```
  - _newFileDB
```
public DBMaker.Maker _newFileDB(File file)
```
  - executorEnable
```
public DBMaker.Maker executorEnable()
```
    Enables background executor
    
    Returns:
    this builder
  - transactionDisable
```
public DBMaker.Maker transactionDisable()
```
    Transaction journal is enabled by default You must call DB.commit() to save your changes. It is possible to disable transaction journal for better write performance In this case all integrity checks are sacrificed for faster speed.
    If transaction journal is disabled, all changes are written DIRECTLY into store. You must call DB.close() method before exit, otherwise your store WILL BE CORRUPTED
    
    Returns:
    this builder
  - metricsEnable
```
public DBMaker.Maker metricsEnable()
```
    Enable metrics, log at info level every 10 SECONDS
    
    Returns:
    this builder
  - metricsEnable
```
public DBMaker.Maker metricsEnable(long metricsLogPeriod)
```
  - metricsExecutorEnable
```
public DBMaker.Maker metricsExecutorEnable()
```
    Enable separate executor for metrics.
    
    Returns:
    this builder
  - metricsExecutorEnable
```
public DBMaker.Maker metricsExecutorEnable(ScheduledExecutorService metricsExecutor)
```
    Enable separate executor for metrics.
    
    Returns:
    this builder
  - cacheExecutorEnable
```
public DBMaker.Maker cacheExecutorEnable()
```
    Enable separate executor for cache.
    
    Returns:
    this builder
  - cacheExecutorEnable
```
public DBMaker.Maker cacheExecutorEnable(ScheduledExecutorService metricsExecutor)
```
    Enable separate executor for cache.
    
    Returns:
    this builder
  - cacheExecutorPeriod
```
public DBMaker.Maker cacheExecutorPeriod(long period)
```
    Sets interval in which executor should check cache
    
    Parameters:
    period - in ms
    
    Returns:
    this builder
  - storeExecutorEnable
```
public DBMaker.Maker storeExecutorEnable()
```
    Enable separate executor for store (async write, compaction)
    
    Returns:
    this builder
  - storeExecutorEnable
```
public DBMaker.Maker storeExecutorEnable(ScheduledExecutorService metricsExecutor)
```
    Enable separate executor for cache.
    
    Returns:
    this builder
  - storeExecutorPeriod
```
public DBMaker.Maker storeExecutorPeriod(long period)
```
    Sets interval in which executor should check cache
    
    Parameters:
    period - in ms
    
    Returns:
    this builder
  - cacheCondition
```
public DBMaker.Maker cacheCondition(Fun.RecordCondition cacheCondition)
```
    Install callback condition, which decides if some record is to be included in cache. Condition should return true for every record which should be included This could be for example useful to include only BTree Directory Nodes and leave values and Leaf nodes outside of cache. !!! Warning:!!! Cache requires **consistent** true or false. Failing to do so will result in inconsitent cache and possible data corruption. Condition is also executed several times, so it must be very fast You should only use very simple logic such as value instanceof SomeClass.
    
    Returns:
    this builder
  - cacheDisable
```
public DBMaker.Maker cacheDisable()
```
    Deprecated. cache is disabled by default
    
    /** Disable cache if enabled. Cache is disabled by default, so this method has no longer purpose.
    
    Returns:
    this builder
  - cacheHardRefEnable
```
public DBMaker.Maker cacheHardRefEnable()
```
    Enables unbounded hard reference cache. This cache is good if you have lot of available memory.
    All fetched records are added to HashMap and stored with hard reference. To prevent OutOfMemoryExceptions MapDB monitors free memory, if it is bellow 25% cache is cleared.
    
    Returns:
    this builder
  - cacheSize
```
public DBMaker.Maker cacheSize(int cacheSize)
```
    Set cache size. Interpretations depends on cache type. For fixed size caches (such as FixedHashTable cache) it is maximal number of items in cache.
    For unbounded caches (such as HardRef cache) it is initial capacity of underlying table (HashMap).
    Default cache size is 2048.
    
    Parameters:
    cacheSize - new cache size
    
    Returns:
    this builder
  - cacheHashTableEnable
```
public DBMaker.Maker cacheHashTableEnable()
```
    Fixed size cache which uses hash table. Is thread-safe and requires only minimal locking. Items are randomly removed and replaced by hash collisions.
    This is simple, concurrent, small-overhead, random cache.
    
    Returns:
    this builder
  - cacheHashTableEnable
```
public DBMaker.Maker cacheHashTableEnable(int cacheSize)
```
    Fixed size cache which uses hash table. Is thread-safe and requires only minimal locking. Items are randomly removed and replaced by hash collisions.
    This is simple, concurrent, small-overhead, random cache.
    
    Parameters:
    cacheSize - new cache size
    
    Returns:
    this builder
  - cacheWeakRefEnable
```
public DBMaker.Maker cacheWeakRefEnable()
```
    Enables unbounded cache which uses WeakReference. Items are removed from cache by Garbage Collector
    
    Returns:
    this builder
  - cacheSoftRefEnable
```
public DBMaker.Maker cacheSoftRefEnable()
```
    Enables unbounded cache which uses SoftReference. Items are removed from cache by Garbage Collector
    
    Returns:
    this builder
  - cacheLRUEnable
```
public DBMaker.Maker cacheLRUEnable()
```
    Enables Least Recently Used cache. It is fixed size cache and it removes less used items to make space.
    
    Returns:
    this builder
  - lockDisable
```
public DBMaker.Maker lockDisable()
```
    Disable locks. This will make MapDB thread unsafe. It will also disable any background thread workers.
    WARNING: this option is dangerous. With locks disabled multi-threaded access could cause data corruption and causes. MapDB does not have fail-fast iterator or any other means of protection
    
    Returns:
    this builder
  - lockSingleEnable
```
public DBMaker.Maker lockSingleEnable()
```
    Disables double read-write locks and enables single read-write locks.
    This type of locking have smaller overhead and can be faster in mostly-write scenario.
    
    Returns:
    this builder
  - lockScale
```
public DBMaker.Maker lockScale(int scale)
```
    Sets concurrency scale. More locks means better scalability with multiple cores, but also higher memory overhead
    This value has to be power of two, so it is rounded up automatically.
    
    Returns:
    this builder
  - mmapFileEnable
```
public DBMaker.Maker mmapFileEnable()
```
    Deprecated. renamed to fileMmapEnable()
  - fileMmapEnable
```
public DBMaker.Maker fileMmapEnable()
```
    Enables Memory Mapped Files, much faster storage option. However on 32bit JVM this mode could corrupt your DB thanks to 4GB memory addressing limit.
    You may experience java.lang.OutOfMemoryError: Map failed exception on 32bit JVM, if you enable this mode.
  - fileMmapCleanerHackEnable
```
public DBMaker.Maker fileMmapCleanerHackEnable()
```
    Enables cleaner hack to close mmaped files at DB.close(), rather than Garbage Collection. See relevant JVM bug. Please note that this option closes files, but could cause all sort of problems, including JVM crash.
    Memory mapped files in Java are not unmapped when file closes. Unmapping happens when DirectByteBuffer is garbage collected. Delay between file close and GC could be very long, possibly even hours. This causes file descriptor to remain open, causing all sort of problems:
    On Windows opened file can not be deleted or accessed by different process. It remains locked even after JVM process exits until Windows restart. This is causing problems during compaction etc.
    On Linux (and other systems) opened files consumes file descriptor. Eventually JVM process could run out of available file descriptors (couple of thousands) and would be unable to open new files or sockets.
    On Oracle and OpenJDK JVMs there is option to unmap files after closing. However it is not officially supported and could result in all sort of strange behaviour. In MapDB it was linked to JVM crashes, and was disabled by default in MapDB 2.0.
    
    Returns:
    this builder
  - fileMmapPreclearDisable
```
public DBMaker.Maker fileMmapPreclearDisable()
```
    Disables preclear workaround for JVM crash. This will speedup inserts on mmap files, if store is expanded. As sideffect JVM might crash if there is not enough free space. TODO document more, links
    
    Returns:
    this builder
  - fileLockDisable
```
public DBMaker.Maker fileLockDisable()
```
    MapDB needs exclusive lock over storage file it is using. When single file is used by multiple DB instances at the same time, storage file gets quickly corrupted. To prevent multiple opening MapDB uses FileChannel.lock(). If file is already locked, opening it fails with DBException.FileLocked
    In some cases file might remain locked, if DB is not closed correctly or JVM crashes. This option disables exclusive file locking. Use it if you have troubles to reopen files
    
    Returns:
    this builder
  - fileLockHeartbeatEnable
```
public DBMaker.Maker fileLockHeartbeatEnable()
```
    MapDB needs exclusive lock over storage file it is using. When single file is used by multiple DB instances at the same time, storage file gets quickly corrupted. To prevent multiple opening MapDB uses FileChannel.lock(). If file is already locked, opening it fails with DBException.FileLocked
    In some cases file might remain locked, if DB is not closed correctly or JVM crashes. This option replaces FileChannel.lock() exclusive file locking with *.lock file. This file is periodically updated by background thread. If JVM dies, the lock file gets old and eventually expires. Use it if you have troubles to reopen files.
    This method was taken from H2 database. It was originally written by Thomas Mueller and modified for MapDB purposes.
    Original description from H2 documentation:
    - If the lock file does not exist, it is created (using the atomic operation File.createNewFile). Then, the process waits a little bit (20 ms) and checks the file again. If the file was changed during this time, the operation is aborted. This protects against a race condition when one process deletes the lock file just after another one create it, and a third process creates the file again. It does not occur if there are only two writers.
    - If the file can be created, a random number is inserted together with the locking method ('file'). Afterwards, a watchdog thread is started that checks regularly (every second once by default) if the file was deleted or modified by another (challenger) thread / process. Whenever that occurs, the file is overwritten with the old data. The watchdog thread runs with high priority so that a change to the lock file does not get through undetected even if the system is very busy. However, the watchdog thread does use very little resources (CPU time), because it waits most of the time. Also, the watchdog only reads from the hard disk and does not write to it.
    - If the lock file exists and was recently modified, the process waits for some time (up to two seconds). If it was still changed, an exception is thrown (database is locked). This is done to eliminate race conditions with many concurrent writers. Afterwards, the file is overwritten with a new version (challenge). After that, the thread waits for 2 seconds. If there is a watchdog thread protecting the file, he will overwrite the change and this process will fail to lock the database. However, if there is no watchdog thread, the lock file will still be as written by this thread. In this case, the file is deleted and atomically created again. The watchdog thread is started in this case and the file is locked.
    This algorithm is tested with over 100 concurrent threads. In some cases, when there are many concurrent threads trying to lock the database, they block each other (meaning the file cannot be locked by any of them) for some time. However, the file never gets locked by two threads at the same time. However using that many concurrent threads / processes is not the common use case. Generally, an application should throw an error to the user if it cannot open a database, and not try again in a (fast) loop.
    Returns:
    this builder
  - mmapFileEnablePartial
```
public DBMaker.Maker mmapFileEnablePartial()
```
    Deprecated. mapdb 2.0 uses single file, no partial mapping possible
    
    Returns:
    this
  - mmapFileEnableIfSupported
```
public DBMaker.Maker mmapFileEnableIfSupported()
```
    Deprecated. renamed to fileMmapEnableIfSupported()
    
    Enable Memory Mapped Files only if current JVM supports it (is 64bit).
  - fileMmapEnableIfSupported
```
public DBMaker.Maker fileMmapEnableIfSupported()
```
    Enable Memory Mapped Files only if current JVM supports it (is 64bit).
  - fileChannelEnable
```
public DBMaker.Maker fileChannelEnable()
```
    Enable FileChannel access. By default MapDB uses RandomAccessFile. whic is slower and more robust. but does not allow concurrent access (parallel read and writes). RAF is still thread-safe but has global lock. FileChannel does not have global lock, and is faster compared to RAF. However memory-mapped files are probably best choice.
  - snapshotEnable
```
public DBMaker.Maker snapshotEnable()
```
    MapDB supports snapshots. TxEngine requires additional locking which has small overhead when not used. Snapshots are disabled by default. This option switches the snapshots on.
    
    Returns:
    this builder
  - asyncWriteEnable
```
public DBMaker.Maker asyncWriteEnable()
```
    Enables mode where all modifications are queued and written into disk on Background Writer Thread. So all modifications are performed in asynchronous mode and do not block.
    Enabling this mode might increase performance for single threaded apps.
    
    Returns:
    this builder
  - asyncWriteFlushDelay
```
public DBMaker.Maker asyncWriteFlushDelay(int delay)
```
    Set flush interval for write cache, by default is 0
    When BTreeMap is constructed from ordered set, tree node size is increasing linearly with each item added. Each time new key is added to tree node, its size changes and storage needs to find new place. So constructing BTreeMap from ordered set leads to large store fragmentation.
    Setting flush interval is workaround as BTreeMap node is always updated in memory (write cache) and only final version of node is stored on disk.
    
    Parameters:
    delay - flush write cache every N miliseconds
    
    Returns:
    this builder
  - asyncWriteQueueSize
```
public DBMaker.Maker asyncWriteQueueSize(int queueSize)
```
    Set size of async Write Queue. Default size is
    Using too large queue size can lead to out of memory exception.
    
    Parameters:
    queueSize - of queue
    
    Returns:
    this builder
  - deleteFilesAfterClose
```
public DBMaker.Maker deleteFilesAfterClose()
```
    Try to delete files after DB is closed. File deletion may silently fail, especially on Windows where buffer needs to be unmapped file delete.
    
    Returns:
    this builder
  - closeOnJvmShutdown
```
public DBMaker.Maker closeOnJvmShutdown()
```
    Adds JVM shutdown hook and closes DB just before JVM;
    
    Returns:
    this builder
  - compressionEnable
```
public DBMaker.Maker compressionEnable()
```
    Enables record compression.
    Make sure you enable this every time you reopen store, otherwise record de-serialization fails unpredictably.
    
    Returns:
    this builder
  - encryptionEnable
```
public DBMaker.Maker encryptionEnable(String password)
```
    Encrypt storage using XTEA algorithm.
    XTEA is sound encryption algorithm. However implementation in MapDB was not peer-reviewed. MapDB only encrypts records data, so attacker may see number of records and their sizes.
    Make sure you enable this every time you reopen store, otherwise record de-serialization fails unpredictably.
    
    Parameters:
    password - for encryption
    
    Returns:
    this builder
  - encryptionEnable
```
public DBMaker.Maker encryptionEnable(byte[] password)
```
    Encrypt storage using XTEA algorithm.
    XTEA is sound encryption algorithm. However implementation in MapDB was not peer-reviewed. MapDB only encrypts records data, so attacker may see number of records and their sizes.
    Make sure you enable this every time you reopen store, otherwise record de-serialization fails unpredictably.
    
    Parameters:
    password - for encryption
    
    Returns:
    this builder
  - checksumEnable
```
public DBMaker.Maker checksumEnable()
```
    Adds CRC32 checksum at end of each record to check data integrity. It throws 'IOException("Checksum does not match, data broken")' on de-serialization if data are corrupted
    Make sure you enable this every time you reopen store, otherwise record de-serialization fails.
    
    Returns:
    this builder
  - strictDBGet
```
public DBMaker.Maker strictDBGet()
```
    DB Get methods such as DB.treeMap(String) or DB.atomicLong(String) auto create new record with default values, if record with given name does not exist. This could be problem if you would like to enforce stricter database schema. So this parameter disables record auto creation.
    If this set, DB.getXX() will throw an exception if given name does not exist, instead of creating new record (or collection)
    
    Returns:
    this builder
  - readOnly
```
public DBMaker.Maker readOnly()
```
    Open store in read-only mode. Any modification attempt will throw UnsupportedOperationException("Read-only")
    
    Returns:
    this builder
  - sizeLimit
```
public DBMaker.Maker sizeLimit(double maxSize)
```
    Deprecated. right now not implemented, will be renamed to allocate*()
    
    Parameters:
    maxSize -
    
    Returns:
    this
  - freeSpaceReclaimQ
```
public DBMaker.Maker freeSpaceReclaimQ(int q)
```
    Deprecated. ignored in MapDB 2 for now
    
    Set free space reclaim Q. It is value from 0 to 10, indicating how eagerly MapDB searchs for free space inside store to reuse, before expanding store file. 0 means that no free space will be reused and store file will just grow (effectively append only). 10 means that MapDB tries really hard to reuse free space, even if it may hurt performance. Default value is 5;
    
    Returns:
    this builder
  - commitFileSyncDisable
```
public DBMaker.Maker commitFileSyncDisable()
```
    Deprecated. ignored in MapDB 2 for now
    
    Disables file sync on commit. This way transactions are preserved (rollback works), but commits are not 'durable' and data may be lost if store is not properly closed. File store will get properly synced when closed. Disabling this will make commits faster.
    
    Returns:
    this builder
  - allocateStartSize
```
public DBMaker.Maker allocateStartSize(long size)
```
    Tells allocator to set initial store size, when new store is created. Value is rounder up to nearest multiple of 1MB or allocation increment.
    
    Returns:
    this builder
  - allocateIncrement
```
public DBMaker.Maker allocateIncrement(long sizeIncrement)
```
    Tells allocator to grow store with this size increment. Minimal value is 1MB. Incremental size is rounded up to nearest power of two.
    
    Returns:
    this builder
  - serializerClassLoader
```
public DBMaker.Maker serializerClassLoader(ClassLoader classLoader)
```
    Sets class loader used to POJO serializer to load classes during deserialization.
    
    Returns:
    this builder
  - serializerRegisterClass
```
public DBMaker.Maker serializerRegisterClass(String className,
                                    ClassLoader classLoader)
```
    Register class with given Class Loader. This loader will be used by POJO deserializer to load and instantiate new classes. This might be needed in OSGI containers etc.
    
    Returns:
    this builder
  - serializerRegisterClass
```
public DBMaker.Maker serializerRegisterClass(Class... classes)
```
    Register classes with their Class Loaders. This loader will be used by POJO deserializer to load and instantiate new classes. This might be needed in OSGI containers etc.
    
    Returns:
    this builder
  - allocateRecidReuseDisable
```
public DBMaker.Maker allocateRecidReuseDisable()
```
    Deprecated. this setting might be removed before 2.0 stable release, it is very likely it will become enabled by default
    
    Allocator reuses recids immediately, that can cause problems to some data types. This option disables recid reusing, until they are released by compaction. This option will cause higher store fragmentation with HTreeMap, queues etc..
    
    Returns:
    this builder
  - make
```
public DB make()
```
    constructs DB using current settings
  - makeClassLoader
```
protected Fun.Function1<Class,String> makeClassLoader()
```
  - makeTxMaker
```
public TxMaker makeTxMaker()
```
  - makeEngine
```
public Engine makeEngine()
```
    constructs Engine using current settings
  - createCache
```
protected Store.Cache createCache(boolean disableLocks,
                      int lockScale)
```
  - propsGetInt
```
protected int propsGetInt(String key,
              int defValue)
```
  - propsGetLong
```
protected long propsGetLong(String key,
                long defValue)
```
  - propsGetBool
```
protected boolean propsGetBool(String key)
```
  - propsGetXteaEncKey
```
protected byte[] propsGetXteaEncKey()
```
  - JVMSupportsLargeMappedFiles
```
protected static boolean JVMSupportsLargeMappedFiles()
```
    Check if large files can be mapped into memory. For example 32bit JVM can only address 2GB and large files can not be mapped, so for 32bit JVM this function returns false.
  - propsGetRafMode
```
protected int propsGetRafMode()
```
  - extendSnapshotEngine
```
protected Engine extendSnapshotEngine(Engine engine,
                          int lockScale)
```
  - extendWrapSnapshotEngine
```
protected Engine extendWrapSnapshotEngine(Engine engine)
```
  - extendStoreVolumeFactory
```
protected Volume.VolumeFactory extendStoreVolumeFactory(boolean index)
```

Class DBMaker.Maker

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

cacheCondition

executor

metricsExecutor

cacheExecutor

storeExecutor

serializerClassLoader

serializerClassLoaderRegistry

props

Constructor Detail

DBMaker.Maker

DBMaker.Maker

Method Detail

_newHeapDB

_newMemoryDB

_newMemoryDirectDB

_newMemoryUnsafeDB

_newAppendFileDB

_newArchiveFileDB

_newFileDB

executorEnable

transactionDisable

metricsEnable

metricsEnable

metricsExecutorEnable

metricsExecutorEnable

cacheExecutorEnable

cacheExecutorEnable

cacheExecutorPeriod

storeExecutorEnable

storeExecutorEnable

storeExecutorPeriod

cacheCondition

cacheDisable

cacheHardRefEnable

cacheSize

cacheHashTableEnable

cacheHashTableEnable

cacheWeakRefEnable

cacheSoftRefEnable

cacheLRUEnable

lockDisable

lockSingleEnable

lockScale

mmapFileEnable

fileMmapEnable

fileMmapCleanerHackEnable

fileMmapPreclearDisable

fileLockDisable

fileLockHeartbeatEnable

mmapFileEnablePartial

mmapFileEnableIfSupported

fileMmapEnableIfSupported

fileChannelEnable

snapshotEnable

asyncWriteEnable

asyncWriteFlushDelay

asyncWriteQueueSize

deleteFilesAfterClose

closeOnJvmShutdown

compressionEnable

encryptionEnable

encryptionEnable

checksumEnable

strictDBGet

readOnly

sizeLimit

freeSpaceReclaimQ

commitFileSyncDisable

allocateStartSize

allocateIncrement

serializerClassLoader

serializerRegisterClass

serializerRegisterClass

allocateRecidReuseDisable