DB (mapdb 2.0-beta10 API)

java.lang.Object
- org.mapdb.DB

All Implemented Interfaces:

Closeable, AutoCloseable
```
public class DB
extends Object
implements Closeable
```
A database with easy access to named maps and other collections.

Author:

Jan Kotek

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`DB.BTreeMapMaker`
`class`	`DB.BTreeSetMaker`
`static class`	`DB.HTreeMapMaker`
`class`	`DB.HTreeSetMaker`
`protected static class`	`DB.IdentityWrapper` changes object hash and equals method to use identity
`protected static interface`	`DB.Keys`

Field Summary

Fields
Modifier and Type	Field and Description
`protected ScheduledExecutorService`	`cacheExecutor`
`protected SortedMap<String,Object>`	`catalog` view over named records
`protected ReadWriteLock`	`consistencyLock`
`protected boolean`	`deleteFilesAfterClose`
`protected Engine`	`engine` Engine which provides persistence for this DB
`protected ScheduledExecutorService`	`executor`
`protected static Logger`	`LOG`
`static String`	`METRICS_CACHE_HIT`
`static String`	`METRICS_CACHE_MISS`
`static String`	`METRICS_DATA_READ`
`static String`	`METRICS_DATA_WRITE`
`static String`	`METRICS_RECORD_READ`
`static String`	`METRICS_RECORD_WRITE`
`protected ScheduledExecutorService`	`metricsExecutor`
`protected Map<String,WeakReference<?>>`	`namesInstanciated` already loaded named collections.
`protected Map<DB.IdentityWrapper,String>`	`namesLookup`
`protected SerializerPojo`	`serializerPojo`
`protected ScheduledExecutorService`	`storeExecutor`
`protected boolean`	`strictDBGet`
`protected Set<String>`	`unknownClasses`

Constructor Summary

Constructors
Constructor and Description
`DB(Engine engine)` Construct new DB.
`DB(Engine engine, boolean strictDBGet, boolean deleteFilesAfterClose, ScheduledExecutorService executor, boolean lockDisable, ScheduledExecutorService metricsExecutor, long metricsLogInterval, ScheduledExecutorService storeExecutor, ScheduledExecutorService cacheExecutor, Fun.Function1<Class,String> classLoader)`

Method Summary

Methods
Modifier and Type	Method and Description
`Atomic.Boolean`	`atomicBoolean(String name)`
`Atomic.Boolean`	`atomicBooleanCreate(String name, boolean initValue)`
`Atomic.Integer`	`atomicInteger(String name)`
`Atomic.Integer`	`atomicIntegerCreate(String name, int initValue)`
`Atomic.Long`	`atomicLong(String name)`
`Atomic.Long`	`atomicLongCreate(String name, long initValue)`
`Atomic.String`	`atomicString(String name)`
`Atomic.String`	`atomicStringCreate(String name, String initValue)`
`<E> Atomic.Var<E>`	`atomicVar(String name)`
`<E> Atomic.Var<E>`	`atomicVar(String name, Serializer<E> serializer)`
`<E> Atomic.Var<E>`	`atomicVarCreate(String name, E initValue, Serializer<E> serializer)`
`<A> A`	`catGet(String name)`
`<A> A`	`catGet(String name, A init)`
`<A> A`	`catPut(String name, A value)`
`<A> A`	`catPut(String name, A value, A retValueIfNull)`
`void`	`checkNameNotExists(String name)` Checks that object with given name does not exist yet.
`void`	`checkNotClosed()`
`protected <K> K`	`checkPlaceholder(String nameCatParam, K fromConstructor)`
`void`	`checkShouldCreate(String name)`
`void`	`checkType(String type, String expected)`
`void`	`close()` Closes database.
`void`	`commit()` Commit changes made on collections loaded by this DB
`void`	`compact()` Perform storage maintenance.
`ReadWriteLock`	`consistencyLock()` Returns consistency lock which groups operation together and ensures consistency.
`Atomic.Boolean`	`createAtomicBoolean(String name, boolean initValue)` Deprecated. method renamed, use `atomicBooleanCreate(String, boolean)`
`Atomic.Integer`	`createAtomicInteger(String name, int initValue)` Deprecated. method renamed, use `atomicIntegerCreate(String, int)`
`Atomic.Long`	`createAtomicLong(String name, long initValue)` Deprecated. method renamed, use `atomicLongCreate(String, long)`
`Atomic.String`	`createAtomicString(String name, String initValue)` Deprecated. method renamed, use `atomicStringCreate(String, String)`
`<E> Atomic.Var<E>`	`createAtomicVar(String name, E initValue, Serializer<E> serializer)` Deprecated. method renamed, use `atomicVarCreate(String, Object, Serializer)`
`<E> BlockingQueue<E>`	`createCircularQueue(String name, Serializer<E> serializer, long size)` Deprecated. queues API is going to be reworked
`DB.HTreeMapMaker`	`createHashMap(String name)` Deprecated. method renamed, use `hashMapCreate(String)`
`DB.HTreeSetMaker`	`createHashSet(String name)` Deprecated. method renamed, use `hashSetCreate(String)`
`<E> BlockingQueue<E>`	`createQueue(String name, Serializer<E> serializer, boolean useLocks)` Deprecated. queues API is going to be reworked
`<E> BlockingQueue<E>`	`createStack(String name, Serializer<E> serializer, boolean useLocks)` Deprecated. queues API is going to be reworked
`DB.BTreeMapMaker`	`createTreeMap(String name)` Deprecated. method renamed, use `treeMapCreate(String)`
`DB.BTreeSetMaker`	`createTreeSet(String name)` Deprecated. method renamed, use `treeSetCreate(String)`
`void`	`delete(String name)` delete record/collection with given name
`boolean`	`exists(String name)`
`protected BTreeKeySerializer<?,?>`	`fillNulls(BTreeKeySerializer<?,?> keySerializer)` Replace nulls in tuple serializers with default (Comparable) values
`<E> E`	`get(String name)` return record with given name or null if name does not exist
`Map<String,Object>`	`getAll()` return map of all named collections/records
`Atomic.Boolean`	`getAtomicBoolean(String name)` Deprecated. method renamed, use `atomicBoolean(String)`
`Atomic.Integer`	`getAtomicInteger(String name)` Deprecated. method renamed, use `atomicInteger(String)`
`Atomic.Long`	`getAtomicLong(String name)` Deprecated. method renamed, use `atomicLong(String)`
`Atomic.String`	`getAtomicString(String name)` Deprecated. method renamed, use `atomicString(String)`
`<E> Atomic.Var<E>`	`getAtomicVar(String name)` Deprecated. method renamed, use `atomicVar(String)`
`SortedMap<String,Object>`	`getCatalog()` Get Name Catalog.
`<E> BlockingQueue<E>`	`getCircularQueue(String name)` Deprecated. queues API is going to be reworked
`Serializer`	`getDefaultSerializer()`
`Engine`	`getEngine()`
`Object`	`getFromWeakCollection(String name)` All collections are weakly referenced to prevent two instances of the same collection in memory.
`<K,V> HTreeMap<K,V>`	`getHashMap(String name)` Deprecated. method renamed, use `hashMap(String)`
`<K,V> HTreeMap<K,V>`	`getHashMap(String name, Fun.Function1<V,K> valueCreator)` Deprecated. method renamed, use `hashMap(String,Serializer, Serializer, org.mapdb.Fun.Function1)`
`<K> Set<K>`	`getHashSet(String name)` Deprecated. method renamed, use `hashSet(String)`
`String`	`getNameForObject(Object obj)` Get name for object.
`<E> BlockingQueue<E>`	`getQueue(String name)` Deprecated. queues API is going to be reworked
`<E> BlockingQueue<E>`	`getStack(String name)` Deprecated. queues API is going to be reworked
`<K,V> BTreeMap<K,V>`	`getTreeMap(String name)` Deprecated. method renamed, use `treeMap(String)`
`<K> NavigableSet<K>`	`getTreeSet(String name)` Deprecated. method renamed, use `treeSet(String)`
`<K,V> HTreeMap<K,V>`	`hashMap(String name)` Opens existing or creates new Hash Tree Map.
`<K,V> HTreeMap<K,V>`	`hashMap(String name, Serializer<K> keySerializer, Serializer<V> valueSerializer)` Opens existing or creates new Hash Tree Map.
`<K,V> HTreeMap<K,V>`	`hashMap(String name, Serializer<K> keySerializer, Serializer<V> valueSerializer, Fun.Function1<V,K> valueCreator)` Opens existing or creates new Hash Tree Map.
`protected <K,V> HTreeMap<K,V>`	`hashMapCreate(DB.HTreeMapMaker m)` Creates new HashMap with more specific arguments
`DB.HTreeMapMaker`	`hashMapCreate(String name)` Returns new builder for HashMap with given name
`<K> Set<K>`	`hashSet(String name)` Opens existing or creates new Hash Tree Set.
`<K> Set<K>`	`hashSet(String name, Serializer<K> serializer)`
`protected <K> Set<K>`	`hashSetCreate(DB.HTreeSetMaker m)`
`DB.HTreeSetMaker`	`hashSetCreate(String name)` Creates new HashSet
`boolean`	`isClosed()`
`Map<String,Long>`	`metricsGet()`
`void`	`metricsLog()`
`<V> V`	`namedPut(String name, Object ret)`
`protected void`	`reinit()`
`void`	`rename(String oldName, String newName)` rename named record into newName
`void`	`rollback()` Rollback changes made on collections loaded by this DB
`protected Object`	`serializableOrPlaceHolder(Object o)`
`DB`	`snapshot()` Make readonly snapshot view of DB and all of its collection Collections loaded by this instance are not affected (are still mutable).
`<K,V> BTreeMap<K,V>`	`treeMap(String name)` Opens existing or creates new B-linked-tree Map.
`<K,V> BTreeMap<K,V>`	`treeMap(String name, BTreeKeySerializer keySerializer, Serializer<V> valueSerializer)`
`<K,V> BTreeMap<K,V>`	`treeMap(String name, Serializer<K> keySerializer, Serializer<V> valueSerializer)`
`protected <K,V> BTreeMap<K,V>`	`treeMapCreate(DB.BTreeMapMaker m)`
`DB.BTreeMapMaker`	`treeMapCreate(String name)` Returns new builder for TreeMap with given name
`<K> NavigableSet<K>`	`treeSet(String name)` Opens existing or creates new B-linked-tree Set.
`<K> NavigableSet<K>`	`treeSet(String name, BTreeKeySerializer serializer)`
`<K> NavigableSet<K>`	`treeSet(String name, Serializer serializer)`
`<K> NavigableSet<K>`	`treeSetCreate(DB.BTreeSetMaker m)`
`DB.BTreeSetMaker`	`treeSetCreate(String name)` Creates new TreeSet.

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

- Field Detail
  - LOG
```
protected static final Logger LOG
```
  - METRICS_DATA_WRITE
```
public static final String METRICS_DATA_WRITE
```
    See Also:
    Constant Field Values
  - METRICS_RECORD_WRITE
```
public static final String METRICS_RECORD_WRITE
```
    See Also:
    Constant Field Values
  - METRICS_DATA_READ
```
public static final String METRICS_DATA_READ
```
    See Also:
    Constant Field Values
  - METRICS_RECORD_READ
```
public static final String METRICS_RECORD_READ
```
    See Also:
    Constant Field Values
  - METRICS_CACHE_HIT
```
public static final String METRICS_CACHE_HIT
```
    See Also:
    Constant Field Values
  - METRICS_CACHE_MISS
```
public static final String METRICS_CACHE_MISS
```
    See Also:
    Constant Field Values
  - strictDBGet
```
protected final boolean strictDBGet
```
  - deleteFilesAfterClose
```
protected final boolean deleteFilesAfterClose
```
  - engine
```
protected Engine engine
```
    Engine which provides persistence for this DB
  - namesInstanciated
```
protected Map<String,WeakReference<?>> namesInstanciated
```
    already loaded named collections. It is important to keep collections as singletons, because of 'in-memory' locking
  - namesLookup
```
protected Map<DB.IdentityWrapper,String> namesLookup
```
  - catalog
```
protected SortedMap<String,Object> catalog
```
    view over named records
  - executor
```
protected ScheduledExecutorService executor
```
  - serializerPojo
```
protected SerializerPojo serializerPojo
```
  - metricsExecutor
```
protected ScheduledExecutorService metricsExecutor
```
  - storeExecutor
```
protected ScheduledExecutorService storeExecutor
```
  - cacheExecutor
```
protected ScheduledExecutorService cacheExecutor
```
  - unknownClasses
```
protected final Set<String> unknownClasses
```
  - consistencyLock
```
protected final ReadWriteLock consistencyLock
```
- Constructor Detail
  - DB
```
public DB(Engine engine)
```
    Construct new DB. It is just thin layer over Engine which does the real work.
    
    Parameters:
    engine -
  - DB
```
public DB(Engine engine,
  boolean strictDBGet,
  boolean deleteFilesAfterClose,
  ScheduledExecutorService executor,
  boolean lockDisable,
  ScheduledExecutorService metricsExecutor,
  long metricsLogInterval,
  ScheduledExecutorService storeExecutor,
  ScheduledExecutorService cacheExecutor,
  Fun.Function1<Class,String> classLoader)
```
- Method Detail
  - metricsLog
```
public void metricsLog()
```
  - metricsGet
```
public Map<String,Long> metricsGet()
```
  - reinit
```
protected void reinit()
```
  - catGet
```
public <A> A catGet(String name,
           A init)
```
  - catGet
```
public <A> A catGet(String name)
```
  - catPut
```
public <A> A catPut(String name,
           A value)
```
  - catPut
```
public <A> A catPut(String name,
           A value,
           A retValueIfNull)
```
  - getNameForObject
```
public String getNameForObject(Object obj)
```
    Get name for object. DB keeps weak reference to all objects it instanciated
    
    Parameters:
    obj - object to get name for
    
    Returns:
    name for this object, if it has name and was instanciated by this DB
  - getHashMap
```
public <K,V> HTreeMap<K,V> getHashMap(String name)
```
    Deprecated. method renamed, use hashMap(String)
  - hashMap
```
public <K,V> HTreeMap<K,V> hashMap(String name)
```
    Opens existing or creates new Hash Tree Map. This collection perform well under concurrent access. Is best for large keys and large values.
    
    Parameters:
    name - of the map
    
    Returns:
    map
  - getHashMap
```
public <K,V> HTreeMap<K,V> getHashMap(String name,
                             Fun.Function1<V,K> valueCreator)
```
    Deprecated. method renamed, use hashMap(String,Serializer, Serializer, org.mapdb.Fun.Function1)
  - hashMap
```
public <K,V> HTreeMap<K,V> hashMap(String name,
                          Serializer<K> keySerializer,
                          Serializer<V> valueSerializer)
```
    Opens existing or creates new Hash Tree Map. This collection perform well under concurrent access. Is best for large keys and large values.
    
    Parameters:
    name - of map
    keySerializer - serializer used on keys
    valueSerializer - serializer used on values
    
    Returns:
    map
  - hashMap
```
public <K,V> HTreeMap<K,V> hashMap(String name,
                          Serializer<K> keySerializer,
                          Serializer<V> valueSerializer,
                          Fun.Function1<V,K> valueCreator)
```
    Opens existing or creates new Hash Tree Map. This collection perform well under concurrent access. Is best for large keys and large values.
    
    Parameters:
    name - of map
    keySerializer - serializer used on keys
    valueSerializer - serializer used on values
    valueCreator - if value is not found, new is created and placed into map.
    
    Returns:
    map
  - checkPlaceholder
```
protected <K> K checkPlaceholder(String nameCatParam,
                     K fromConstructor)
```
  - namedPut
```
public <V> V namedPut(String name,
             Object ret)
```
  - createHashMap
```
public DB.HTreeMapMaker createHashMap(String name)
```
    Deprecated. method renamed, use hashMapCreate(String)
  - hashMapCreate
```
public DB.HTreeMapMaker hashMapCreate(String name)
```
    Returns new builder for HashMap with given name
    
    Parameters:
    name - of map to create
    
    Returns:
    maker, call .make() to create map
    
    Throws:
    
    IllegalArgumentException - if name is already used
  - hashMapCreate
```
protected <K,V> HTreeMap<K,V> hashMapCreate(DB.HTreeMapMaker m)
```
    Creates new HashMap with more specific arguments
    
    Returns:
    newly created map
    
    Throws:
    
    IllegalArgumentException - if name is already used
  - serializableOrPlaceHolder
```
protected Object serializableOrPlaceHolder(Object o)
```
  - getHashSet
```
public <K> Set<K> getHashSet(String name)
```
    Deprecated. method renamed, use hashSet(String)
  - hashSet
```
public <K> Set<K> hashSet(String name)
```
    Opens existing or creates new Hash Tree Set.
    
    Parameters:
    name - of the Set
    
    Returns:
    set
  - hashSet
```
public <K> Set<K> hashSet(String name,
                 Serializer<K> serializer)
```
  - createHashSet
```
public DB.HTreeSetMaker createHashSet(String name)
```
    Deprecated. method renamed, use hashSetCreate(String)
  - hashSetCreate
```
public DB.HTreeSetMaker hashSetCreate(String name)
```
    Creates new HashSet
    
    Parameters:
    name - of set to create
  - hashSetCreate
```
protected <K> Set<K> hashSetCreate(DB.HTreeSetMaker m)
```
  - getTreeMap
```
public <K,V> BTreeMap<K,V> getTreeMap(String name)
```
    Deprecated. method renamed, use treeMap(String)
  - treeMap
```
public <K,V> BTreeMap<K,V> treeMap(String name)
```
    Opens existing or creates new B-linked-tree Map. This collection performs well under concurrent access. Only trade-off are deletes, which causes tree fragmentation. It is ordered and best suited for small keys and values.
    
    Parameters:
    name - of map
    
    Returns:
    map
  - treeMap
```
public <K,V> BTreeMap<K,V> treeMap(String name,
                          Serializer<K> keySerializer,
                          Serializer<V> valueSerializer)
```
  - treeMap
```
public <K,V> BTreeMap<K,V> treeMap(String name,
                          BTreeKeySerializer keySerializer,
                          Serializer<V> valueSerializer)
```
  - createTreeMap
```
public DB.BTreeMapMaker createTreeMap(String name)
```
    Deprecated. method renamed, use treeMapCreate(String)
  - treeMapCreate
```
public DB.BTreeMapMaker treeMapCreate(String name)
```
    Returns new builder for TreeMap with given name
    
    Parameters:
    name - of map to create
    
    Returns:
    maker, call .make() to create map
    
    Throws:
    
    IllegalArgumentException - if name is already used
  - treeMapCreate
```
protected <K,V> BTreeMap<K,V> treeMapCreate(DB.BTreeMapMaker m)
```
  - fillNulls
```
protected BTreeKeySerializer<?,?> fillNulls(BTreeKeySerializer<?,?> keySerializer)
```
    Replace nulls in tuple serializers with default (Comparable) values
    
    Parameters:
    keySerializer - with nulls
    
    Returns:
    keySerializers which does not contain any nulls
  - getCatalog
```
public SortedMap<String,Object> getCatalog()
```
    Get Name Catalog. It is metatable which contains information about named collections and records. Each collection constructor takes number of parameters, this map contains those parameters. _Note:_ Do not modify this map, unless you know what you are doing!
    
    Returns:
    Name Catalog
  - getTreeSet
```
public <K> NavigableSet<K> getTreeSet(String name)
```
    Deprecated. method renamed, use treeSet(String)
  - treeSet
```
public <K> NavigableSet<K> treeSet(String name)
```
    Opens existing or creates new B-linked-tree Set.
    
    Parameters:
    name - of set
    
    Returns:
    set
  - treeSet
```
public <K> NavigableSet<K> treeSet(String name,
                          Serializer serializer)
```
  - treeSet
```
public <K> NavigableSet<K> treeSet(String name,
                          BTreeKeySerializer serializer)
```
  - createTreeSet
```
public DB.BTreeSetMaker createTreeSet(String name)
```
    Deprecated. method renamed, use treeSetCreate(String)
  - treeSetCreate
```
public DB.BTreeSetMaker treeSetCreate(String name)
```
    Creates new TreeSet.
    
    Parameters:
    name - of set to create
    
    Returns:
    maker used to construct set
    
    Throws:
    
    IllegalArgumentException - if name is already used
  - treeSetCreate
```
public <K> NavigableSet<K> treeSetCreate(DB.BTreeSetMaker m)
```
  - getQueue
```
public <E> BlockingQueue<E> getQueue(String name)
```
    Deprecated. queues API is going to be reworked
    
    Why are queues methods deprecated?
    I am not really happy with current implementation. But I also have no time to rewrite them in 2.0. So current version is going to stay in 2.0 with deprecated flag.
    I am not sure what will happen in 2.1. Most likely I will redesign and extend Queues to include blocking, counted, full-dequeue implementation, multiple/single consumers/producers... etc. API will switch to some sort of Maker style pattern.
    In case of new queue framework, I might keep old implementation, but move it to separate JAR. So storage format will not change, but it will use different API to instantiate Queues.
    But there is also small chance I will remove deprecation flag and keep current implementation. I am not going to leave MapDB without at least some sort of Queue support.
    So feel free to use current implementation, it will be supported for 2.0 lifecycle (probably 6+ months). But once 2.1 release with long-term support is out, there might be some migration needed.
    Hope this makes sense
  - createQueue
```
public <E> BlockingQueue<E> createQueue(String name,
                               Serializer<E> serializer,
                               boolean useLocks)
```
    Deprecated. queues API is going to be reworked
    
    Why are queues methods deprecated?
    I am not really happy with current implementation. But I also have no time to rewrite them in 2.0. So current version is going to stay in 2.0 with deprecated flag.
    I am not sure what will happen in 2.1. Most likely I will redesign and extend Queues to include blocking, counted, full-dequeue implementation, multiple/single consumers/producers... etc. API will switch to some sort of Maker style pattern.
    In case of new queue framework, I might keep old implementation, but move it to separate JAR. So storage format will not change, but it will use different API to instantiate Queues.
    But there is also small chance I will remove deprecation flag and keep current implementation. I am not going to leave MapDB without at least some sort of Queue support.
    So feel free to use current implementation, it will be supported for 2.0 lifecycle (probably 6+ months). But once 2.1 release with long-term support is out, there might be some migration needed.
    Hope this makes sense
  - getStack
```
public <E> BlockingQueue<E> getStack(String name)
```
    Deprecated. queues API is going to be reworked
    
    Why are queues methods deprecated?
    I am not really happy with current implementation. But I also have no time to rewrite them in 2.0. So current version is going to stay in 2.0 with deprecated flag.
    I am not sure what will happen in 2.1. Most likely I will redesign and extend Queues to include blocking, counted, full-dequeue implementation, multiple/single consumers/producers... etc. API will switch to some sort of Maker style pattern.
    In case of new queue framework, I might keep old implementation, but move it to separate JAR. So storage format will not change, but it will use different API to instantiate Queues.
    But there is also small chance I will remove deprecation flag and keep current implementation. I am not going to leave MapDB without at least some sort of Queue support.
    So feel free to use current implementation, it will be supported for 2.0 lifecycle (probably 6+ months). But once 2.1 release with long-term support is out, there might be some migration needed.
    Hope this makes sense
  - createStack
```
public <E> BlockingQueue<E> createStack(String name,
                               Serializer<E> serializer,
                               boolean useLocks)
```
    Deprecated. queues API is going to be reworked
    
    Why are queues methods deprecated?
    I am not really happy with current implementation. But I also have no time to rewrite them in 2.0. So current version is going to stay in 2.0 with deprecated flag.
    I am not sure what will happen in 2.1. Most likely I will redesign and extend Queues to include blocking, counted, full-dequeue implementation, multiple/single consumers/producers... etc. API will switch to some sort of Maker style pattern.
    In case of new queue framework, I might keep old implementation, but move it to separate JAR. So storage format will not change, but it will use different API to instantiate Queues.
    But there is also small chance I will remove deprecation flag and keep current implementation. I am not going to leave MapDB without at least some sort of Queue support.
    So feel free to use current implementation, it will be supported for 2.0 lifecycle (probably 6+ months). But once 2.1 release with long-term support is out, there might be some migration needed.
    Hope this makes sense
  - getCircularQueue
```
public <E> BlockingQueue<E> getCircularQueue(String name)
```
    Deprecated. queues API is going to be reworked
    
    Why are queues methods deprecated?
    I am not really happy with current implementation. But I also have no time to rewrite them in 2.0. So current version is going to stay in 2.0 with deprecated flag.
    I am not sure what will happen in 2.1. Most likely I will redesign and extend Queues to include blocking, counted, full-dequeue implementation, multiple/single consumers/producers... etc. API will switch to some sort of Maker style pattern.
    In case of new queue framework, I might keep old implementation, but move it to separate JAR. So storage format will not change, but it will use different API to instantiate Queues.
    But there is also small chance I will remove deprecation flag and keep current implementation. I am not going to leave MapDB without at least some sort of Queue support.
    So feel free to use current implementation, it will be supported for 2.0 lifecycle (probably 6+ months). But once 2.1 release with long-term support is out, there might be some migration needed.
    Hope this makes sense
  - createCircularQueue
```
public <E> BlockingQueue<E> createCircularQueue(String name,
                                       Serializer<E> serializer,
                                       long size)
```
    Deprecated. queues API is going to be reworked
    
    Why are queues methods deprecated?
    I am not really happy with current implementation. But I also have no time to rewrite them in 2.0. So current version is going to stay in 2.0 with deprecated flag.
    I am not sure what will happen in 2.1. Most likely I will redesign and extend Queues to include blocking, counted, full-dequeue implementation, multiple/single consumers/producers... etc. API will switch to some sort of Maker style pattern.
    In case of new queue framework, I might keep old implementation, but move it to separate JAR. So storage format will not change, but it will use different API to instantiate Queues.
    But there is also small chance I will remove deprecation flag and keep current implementation. I am not going to leave MapDB without at least some sort of Queue support.
    So feel free to use current implementation, it will be supported for 2.0 lifecycle (probably 6+ months). But once 2.1 release with long-term support is out, there might be some migration needed.
    Hope this makes sense
  - createAtomicLong
```
public Atomic.Long createAtomicLong(String name,
                           long initValue)
```
    Deprecated. method renamed, use atomicLongCreate(String, long)
  - atomicLongCreate
```
public Atomic.Long atomicLongCreate(String name,
                           long initValue)
```
  - getAtomicLong
```
public Atomic.Long getAtomicLong(String name)
```
    Deprecated. method renamed, use atomicLong(String)
  - atomicLong
```
public Atomic.Long atomicLong(String name)
```
  - createAtomicInteger
```
public Atomic.Integer createAtomicInteger(String name,
                                 int initValue)
```
    Deprecated. method renamed, use atomicIntegerCreate(String, int)
  - atomicIntegerCreate
```
public Atomic.Integer atomicIntegerCreate(String name,
                                 int initValue)
```
  - getAtomicInteger
```
public Atomic.Integer getAtomicInteger(String name)
```
    Deprecated. method renamed, use atomicInteger(String)
  - atomicInteger
```
public Atomic.Integer atomicInteger(String name)
```
  - createAtomicBoolean
```
public Atomic.Boolean createAtomicBoolean(String name,
                                 boolean initValue)
```
    Deprecated. method renamed, use atomicBooleanCreate(String, boolean)
  - atomicBooleanCreate
```
public Atomic.Boolean atomicBooleanCreate(String name,
                                 boolean initValue)
```
  - getAtomicBoolean
```
public Atomic.Boolean getAtomicBoolean(String name)
```
    Deprecated. method renamed, use atomicBoolean(String)
  - atomicBoolean
```
public Atomic.Boolean atomicBoolean(String name)
```
  - checkShouldCreate
```
public void checkShouldCreate(String name)
```
  - createAtomicString
```
public Atomic.String createAtomicString(String name,
                               String initValue)
```
    Deprecated. method renamed, use atomicStringCreate(String, String)
  - atomicStringCreate
```
public Atomic.String atomicStringCreate(String name,
                               String initValue)
```
  - getAtomicString
```
public Atomic.String getAtomicString(String name)
```
    Deprecated. method renamed, use atomicString(String)
  - atomicString
```
public Atomic.String atomicString(String name)
```
  - createAtomicVar
```
public <E> Atomic.Var<E> createAtomicVar(String name,
                                E initValue,
                                Serializer<E> serializer)
```
    Deprecated. method renamed, use atomicVarCreate(String, Object, Serializer)
  - atomicVarCreate
```
public <E> Atomic.Var<E> atomicVarCreate(String name,
                                E initValue,
                                Serializer<E> serializer)
```
  - getAtomicVar
```
public <E> Atomic.Var<E> getAtomicVar(String name)
```
    Deprecated. method renamed, use atomicVar(String)
  - atomicVar
```
public <E> Atomic.Var<E> atomicVar(String name)
```
  - atomicVar
```
public <E> Atomic.Var<E> atomicVar(String name,
                          Serializer<E> serializer)
```
  - get
```
public <E> E get(String name)
```
    return record with given name or null if name does not exist
  - exists
```
public boolean exists(String name)
```
  - delete
```
public void delete(String name)
```
    delete record/collection with given name
  - getAll
```
public Map<String,Object> getAll()
```
    return map of all named collections/records
  - rename
```
public void rename(String oldName,
          String newName)
```
    rename named record into newName
    
    Parameters:
    oldName - current name of record/collection
    newName - new name of record/collection
    
    Throws:
    
    NoSuchElementException - if oldName does not exist
  - checkNameNotExists
```
public void checkNameNotExists(String name)
```
    Checks that object with given name does not exist yet.
    
    Parameters:
    name - to check
    
    Throws:
    
    IllegalArgumentException - if name is already used
  - close
```
public void close()
```
    Closes database. All other methods will throw 'IllegalAccessError' after this method was called.
    !! it is necessary to call this method before JVM exits!!
    
    Specified by:
    
    close in interface Closeable
    
    Specified by:
    
    close in interface AutoCloseable
  - getFromWeakCollection
```
public Object getFromWeakCollection(String name)
```
    All collections are weakly referenced to prevent two instances of the same collection in memory. This is mainly for locking, two instances of the same lock would not simply work.
  - checkNotClosed
```
public void checkNotClosed()
```
  - isClosed
```
public boolean isClosed()
```
    Returns:
    true if DB is closed and can no longer be used
  - commit
```
public void commit()
```
    Commit changes made on collections loaded by this DB
    
    See Also:
    Engine.commit()
  - rollback
```
public void rollback()
```
    Rollback changes made on collections loaded by this DB
    
    See Also:
    Engine.rollback()
  - compact
```
public void compact()
```
    Perform storage maintenance. Typically compact underlying storage and reclaim unused space.
    NOTE: MapDB does not have smart defragmentation algorithms. So compaction usually recreates entire store from scratch. This may require additional disk space.
  - snapshot
```
public DB snapshot()
```
    Make readonly snapshot view of DB and all of its collection Collections loaded by this instance are not affected (are still mutable). You have to load new collections from DB returned by this method
    
    Returns:
    readonly snapshot view
  - getDefaultSerializer
```
public Serializer getDefaultSerializer()
```
    Returns:
    default serializer used in this DB, it handles POJO and other stuff.
  - getEngine
```
public Engine getEngine()
```
    Returns:
    underlying engine which takes care of persistence for this DB.
  - checkType
```
public void checkType(String type,
             String expected)
```
  - consistencyLock
```
public ReadWriteLock consistencyLock()
```
    Returns consistency lock which groups operation together and ensures consistency. Operations which depends on each other are performed under read lock. Snapshots, close etc are performed under write-lock.
    
    Returns:

Class DB

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

LOG

METRICS_DATA_WRITE

METRICS_RECORD_WRITE

METRICS_DATA_READ

METRICS_RECORD_READ

METRICS_CACHE_HIT

METRICS_CACHE_MISS

strictDBGet

deleteFilesAfterClose

engine

namesInstanciated

namesLookup

catalog

executor

serializerPojo

metricsExecutor

storeExecutor

cacheExecutor

unknownClasses

consistencyLock

Constructor Detail

DB

DB

Method Detail

metricsLog

metricsGet

reinit

catGet

catGet

catPut

catPut

getNameForObject

getHashMap

hashMap

getHashMap

hashMap

hashMap

checkPlaceholder

namedPut

createHashMap

hashMapCreate

hashMapCreate

serializableOrPlaceHolder

getHashSet

hashSet

hashSet

createHashSet

hashSetCreate

hashSetCreate

getTreeMap

treeMap

treeMap

treeMap

createTreeMap

treeMapCreate

treeMapCreate

fillNulls

getCatalog

getTreeSet

treeSet

treeSet

treeSet

createTreeSet

treeSetCreate

treeSetCreate

getQueue

createQueue

getStack

createStack

getCircularQueue

createCircularQueue

createAtomicLong

atomicLongCreate