Store (mapdb 2.0-beta10 API)

java.lang.Object
- org.mapdb.Store

All Implemented Interfaces:

Closeable, AutoCloseable, Engine

Direct Known Subclasses:

StoreAppend, StoreArchive, StoreDirect, StoreHeap
```
public abstract class Store
extends Object
implements Engine
```

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`Store.Cache` Cache implementation, part of `Store` class.
`static class`	`Store.LongList`
`static class`	`Store.LongLongMap` Open Hash Map which uses primitive long as values and keys.
`static class`	`Store.LongObjectMap<V>` Open Hash Map which uses primitive long as keys.
`static class`	`Store.LongObjectObjectMap<V1,V2>` Open Hash Map which uses primitive long as keys.
`static class`	`Store.LongQueue` Queue of primitive long.
`static class`	`Store.MemoryBarrierLessLock` Lock which blocks parallel execution, but does not use MemoryBarrier (and does not flush CPU cache)
`static class`	`Store.ReadWriteSingleLock` fake read/write lock which in fact locks on single write lock

Nested classes/interfaces inherited from interface org.mapdb.Engine
Engine.CloseOnJVMShutdown, Engine.ReadOnly, Engine.ReadOnlyWrapper

Field Summary

Fields
Modifier and Type	Field and Description
`protected Store.Cache[]`	`caches`
`protected boolean`	`checksum`
`protected boolean`	`closed`
`protected ReentrantLock`	`commitLock` protects lifecycle methods such as commit, rollback and close()
`protected boolean`	`compress`
`protected boolean`	`deserializeExtra`
`protected boolean`	`encrypt`
`protected EncryptionXTEA`	`encryptionXTEA`
`protected static long`	`FEAT_COMP_LZF`
`protected static long`	`FEAT_CRC`
`protected static long`	`FEAT_ENC_XTEA`
`protected boolean`	`fileLockDisable`
`protected DataIO.HeartbeatFileLock`	`fileLockHeartbeat`
`protected String`	`fileName`
`protected static long`	`HEAD_CHECKSUM`
`protected static long`	`HEAD_FEATURES`
`static int`	`LOCKING_STRATEGY_NOLOCK`
`static int`	`LOCKING_STRATEGY_READWRITELOCK`
`static int`	`LOCKING_STRATEGY_WRITELOCK`
`protected int`	`lockMask`
`protected ReadWriteLock[]`	`locks` protects data from being overwritten while read
`protected int`	`lockScale`
`protected static Logger`	`LOG`
`protected ThreadLocal<CompressLZF>`	`LZF`
`protected AtomicLong`	`metricsDataRead`
`protected AtomicLong`	`metricsDataWrite`
`protected AtomicLong`	`metricsRecordRead`
`protected AtomicLong`	`metricsRecordWrite`
`static Lock`	`NOLOCK` fake lock
`protected boolean`	`readonly`
`protected AtomicReference<DataIO.DataOutputByteArray>`	`recycledDataOut`
`protected boolean`	`snapshotEnable`
`protected ReentrantLock`	`structuralLock` protects structural layout of records.
`protected Volume.VolumeFactory`	`volumeFactory`

Fields inherited from interface org.mapdb.Engine
CLOSED_ENGINE, RECID_CLASS_CATALOG, RECID_FIRST, RECID_LAST_RESERVED, RECID_NAME_CATALOG, RECID_RECORD_CHECK

Constructor Summary

Constructors
Modifier	Constructor and Description
`protected`	`Store(String fileName, Volume.VolumeFactory volumeFactory, Store.Cache cache, int lockScale, int lockingStrategy, boolean checksum, boolean compress, byte[] password, boolean readonly, boolean snapshotEnable, boolean fileLockDisable, DataIO.HeartbeatFileLock fileLockHeartbeat)`

Method Summary

Methods
Modifier and Type	Method and Description
`protected void`	`assertReadLocked(long recid)`
`protected void`	`assertWriteLocked(int segment)`
`abstract void`	`backup(OutputStream out, boolean incremental)`
`abstract void`	`backupRestore(InputStream[] in)`
`boolean`	`canSnapshot()`
`protected void`	`checkFeaturesBitmap(long feat)`
`void`	`clearCache()` clears any underlying cache
`<A> boolean`	`compareAndSwap(long recid, A expectedOldValue, A newValue, Serializer<A> serializer)` Updates existing record in atomic (Compare And Swap) manner.
`<A> void`	`delete(long recid, Serializer<A> serializer)` Remove existing record from store/cache
`protected abstract <A> void`	`delete2(long recid, Serializer<A> serializer)`
`protected <A> A`	`deserialize(Serializer<A> serializer, int size, DataInput input)`
`abstract boolean`	`fileLoad()` If underlying storage is memory-mapped-file, this method will try to load and precache all file data into disk cache.
`static Store`	`forDB(DB db)` traverses Engine wrappers and returns underlying `Store`
`static Store`	`forEngine(Engine e)` traverses Engine wrappers and returns underlying `Store`
`<A> A`	`get(long recid, Serializer<A> serializer)` Get existing record.
`protected abstract <A> A`	`get2(long recid, Serializer<A> serializer)`
`abstract long`	`getCurrSize()`
`abstract long`	`getFreeSize()`
`Engine`	`getWrappedEngine()` if this is wrapper return underlying engine, or null
`void`	`init()`
`boolean`	`isClosed()` Checks whether Engine was closed.
`boolean`	`isReadOnly()` Check if you can write into this Engine.
`protected int`	`lockPos(long recid)`
`protected long`	`longParityGet(long value)`
`protected long`	`longParitySet(long value)`
`protected long`	`makeFeaturesBitmap()`
`void`	`metricsCollect(Map<String,Long> map)` puts metrics into given map
`protected DataIO.DataOutputByteArray`	`newDataOut2()`
`protected <A> DataIO.DataOutputByteArray`	`serialize(A value, Serializer<A> serializer)`
`<A> void`	`update(long recid, A value, Serializer<A> serializer)` Update existing record with new value.
`protected abstract void`	`update2(long recid, DataIO.DataOutputByteArray out)`

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

Methods inherited from interface org.mapdb.Engine
canRollback, close, commit, compact, preallocate, put, rollback, snapshot

- Field Detail
  - LOG
```
protected static final Logger LOG
```
  - FEAT_COMP_LZF
```
protected static final long FEAT_COMP_LZF
```
    See Also:
    Constant Field Values
  - FEAT_ENC_XTEA
```
protected static final long FEAT_ENC_XTEA
```
    See Also:
    Constant Field Values
  - FEAT_CRC
```
protected static final long FEAT_CRC
```
    See Also:
    Constant Field Values
  - HEAD_CHECKSUM
```
protected static final long HEAD_CHECKSUM
```
    See Also:
    Constant Field Values
  - HEAD_FEATURES
```
protected static final long HEAD_FEATURES
```
    See Also:
    Constant Field Values
  - structuralLock
```
protected final ReentrantLock structuralLock
```
    protects structural layout of records. Memory allocator is single threaded under this lock
  - commitLock
```
protected final ReentrantLock commitLock
```
    protects lifecycle methods such as commit, rollback and close()
  - locks
```
protected final ReadWriteLock[] locks
```
    protects data from being overwritten while read
  - lockScale
```
protected final int lockScale
```
  - lockMask
```
protected final int lockMask
```
  - closed
```
protected volatile boolean closed
```
  - readonly
```
protected final boolean readonly
```
  - fileName
```
protected final String fileName
```
  - volumeFactory
```
protected final Volume.VolumeFactory volumeFactory
```
  - checksum
```
protected final boolean checksum
```
  - compress
```
protected final boolean compress
```
  - encrypt
```
protected final boolean encrypt
```
  - encryptionXTEA
```
protected final EncryptionXTEA encryptionXTEA
```
  - LZF
```
protected final ThreadLocal<CompressLZF> LZF
```
  - snapshotEnable
```
protected final boolean snapshotEnable
```
  - fileLockDisable
```
protected final boolean fileLockDisable
```
  - metricsDataWrite
```
protected final AtomicLong metricsDataWrite
```
  - metricsRecordWrite
```
protected final AtomicLong metricsRecordWrite
```
  - metricsDataRead
```
protected final AtomicLong metricsDataRead
```
  - metricsRecordRead
```
protected final AtomicLong metricsRecordRead
```
  - deserializeExtra
```
protected final boolean deserializeExtra
```
  - fileLockHeartbeat
```
protected DataIO.HeartbeatFileLock fileLockHeartbeat
```
  - caches
```
protected final Store.Cache[] caches
```
  - LOCKING_STRATEGY_READWRITELOCK
```
public static final int LOCKING_STRATEGY_READWRITELOCK
```
    See Also:
    Constant Field Values
  - LOCKING_STRATEGY_WRITELOCK
```
public static final int LOCKING_STRATEGY_WRITELOCK
```
    See Also:
    Constant Field Values
  - LOCKING_STRATEGY_NOLOCK
```
public static final int LOCKING_STRATEGY_NOLOCK
```
    See Also:
    Constant Field Values
  - recycledDataOut
```
protected final AtomicReference<DataIO.DataOutputByteArray> recycledDataOut
```
  - NOLOCK
```
public static final Lock NOLOCK
```
    fake lock
- Constructor Detail
  - Store
```
protected Store(String fileName,
     Volume.VolumeFactory volumeFactory,
     Store.Cache cache,
     int lockScale,
     int lockingStrategy,
     boolean checksum,
     boolean compress,
     byte[] password,
     boolean readonly,
     boolean snapshotEnable,
     boolean fileLockDisable,
     DataIO.HeartbeatFileLock fileLockHeartbeat)
```
- Method Detail
  - init
```
public void init()
```
  - checkFeaturesBitmap
```
protected void checkFeaturesBitmap(long feat)
```
  - makeFeaturesBitmap
```
protected long makeFeaturesBitmap()
```
  - get
```
public <A> A get(long recid,
        Serializer<A> serializer)
```
    Description copied from interface: Engine
    
    Get existing record.
    Recid must be a number returned by 'put' method. Behaviour for invalid recid (random number or already deleted record) is not defined, typically it returns null or throws 'EndOfFileException'
    
    Specified by:
    
    get in interface Engine
    
    Parameters:
    recid - (record identifier) under which record was persisted
    serializer - used to deserialize record from binary form
    
    Returns:
    record matching given recid, or null if record is not found under given recid.
  - get2
```
protected abstract <A> A get2(long recid,
         Serializer<A> serializer)
```
  - update
```
public <A> void update(long recid,
              A value,
              Serializer<A> serializer)
```
    Description copied from interface: Engine
    
    Update existing record with new value.
    Recid must be a number returned by 'put' method. Behaviour for invalid recid (random number or already deleted record) is not defined, typically it throws 'EndOfFileException', but it may also corrupt store.
    
    Specified by:
    
    update in interface Engine
    
    Parameters:
    recid - (record identifier) under which record was persisted.
    value - new record value to be stored
    serializer - used to serialize record into binary form
  - serialize
```
protected <A> DataIO.DataOutputByteArray serialize(A value,
                                       Serializer<A> serializer)
```
  - newDataOut2
```
protected DataIO.DataOutputByteArray newDataOut2()
```
  - deserialize
```
protected <A> A deserialize(Serializer<A> serializer,
                int size,
                DataInput input)
```
  - update2
```
protected abstract void update2(long recid,
           DataIO.DataOutputByteArray out)
```
  - compareAndSwap
```
public <A> boolean compareAndSwap(long recid,
                         A expectedOldValue,
                         A newValue,
                         Serializer<A> serializer)
```
    Description copied from interface: Engine
    Updates existing record in atomic (Compare And Swap) manner. Value is modified only if old value matches expected value. There are three ways to match values, MapDB may use any of them:
    1. Equality check oldValue==expectedOldValue when old value is found in instance cache
    2. Deserializing oldValue using serializer and checking oldValue.equals(expectedOldValue)
    3. Serializing expectedOldValue using serializer and comparing binary array with already serialized oldValue
    Recid must be a number returned by 'put' method. Behaviour for invalid recid (random number or already deleted record) is not defined, typically it throws 'EndOfFileException', but it may also corrupt store.
    Specified by:
    
    compareAndSwap in interface Engine
    
    Parameters:
    recid - (record identifier) under which record was persisted.
    expectedOldValue - old value to be compared with existing record
    newValue - to be written if values are matching
    serializer - used to serialize record into binary form
    
    Returns:
    true if values matched and newValue was written
  - delete
```
public <A> void delete(long recid,
              Serializer<A> serializer)
```
    Description copied from interface: Engine
    
    Remove existing record from store/cache
    Recid must be a number returned by 'put' method. Behaviour for invalid recid (random number or already deleted record) is not defined, typically it throws 'EndOfFileException', but it may also corrupt store.
    
    Specified by:
    
    delete in interface Engine
    
    Parameters:
    recid - (record identifier) under which was record persisted
    serializer - which may be used in some circumstances to deserialize and store old object
  - delete2
```
protected abstract <A> void delete2(long recid,
               Serializer<A> serializer)
```
  - lockPos
```
protected final int lockPos(long recid)
```
  - assertReadLocked
```
protected void assertReadLocked(long recid)
```
  - assertWriteLocked
```
protected void assertWriteLocked(int segment)
```
  - isClosed
```
public boolean isClosed()
```
    Description copied from interface: Engine
    
    Checks whether Engine was closed.
    
    Specified by:
    
    isClosed in interface Engine
    
    Returns:
    true if engine was closed
  - isReadOnly
```
public boolean isReadOnly()
```
    Description copied from interface: Engine
    
    Check if you can write into this Engine. It may be readonly in some cases (snapshot, read-only files).
    
    Specified by:
    
    isReadOnly in interface Engine
    
    Returns:
    true if engine is read-only
  - forDB
```
public static Store forDB(DB db)
```
    traverses Engine wrappers and returns underlying Store
  - forEngine
```
public static Store forEngine(Engine e)
```
    traverses Engine wrappers and returns underlying Store
  - getCurrSize
```
public abstract long getCurrSize()
```
  - getFreeSize
```
public abstract long getFreeSize()
```
  - fileLoad
```
public abstract boolean fileLoad()
```
    If underlying storage is memory-mapped-file, this method will try to load and precache all file data into disk cache. Most likely it will call MappedByteBuffer.load(), but could also read content of entire file etc This method will not pin data into memory, they might be removed at any time.
    
    Returns:
    true if this method did something, false if underlying storage does not support loading, or is already in-memory
  - clearCache
```
public void clearCache()
```
    Description copied from interface: Engine
    
    clears any underlying cache
    
    Specified by:
    
    clearCache in interface Engine
  - metricsCollect
```
public void metricsCollect(Map<String,Long> map)
```
    puts metrics into given map
  - backup
```
public abstract void backup(OutputStream out,
          boolean incremental)
```
  - backupRestore
```
public abstract void backupRestore(InputStream[] in)
```
  - getWrappedEngine
```
public Engine getWrappedEngine()
```
    Description copied from interface: Engine
    
    if this is wrapper return underlying engine, or null
    
    Specified by:
    
    getWrappedEngine in interface Engine
  - canSnapshot
```
public boolean canSnapshot()
```
    Specified by:
    
    canSnapshot in interface Engine
    
    Returns:
    true if engine can create read-only snapshots
  - longParitySet
```
protected final long longParitySet(long value)
```
  - longParityGet
```
protected final long longParityGet(long value)
```

Class Store

Nested Class Summary

Nested classes/interfaces inherited from interface org.mapdb.Engine

Field Summary

Fields inherited from interface org.mapdb.Engine

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface org.mapdb.Engine

Field Detail

LOG

FEAT_COMP_LZF

FEAT_ENC_XTEA

FEAT_CRC

HEAD_CHECKSUM

HEAD_FEATURES

structuralLock

commitLock

locks

lockScale

lockMask

closed

readonly

fileName

volumeFactory

checksum

compress

encrypt

encryptionXTEA

LZF

snapshotEnable

fileLockDisable

metricsDataWrite

metricsRecordWrite

metricsDataRead

metricsRecordRead

deserializeExtra

fileLockHeartbeat

caches

LOCKING_STRATEGY_READWRITELOCK

LOCKING_STRATEGY_WRITELOCK

LOCKING_STRATEGY_NOLOCK

recycledDataOut

NOLOCK

Constructor Detail

Store

Method Detail

init

checkFeaturesBitmap

makeFeaturesBitmap

get

get2

update

serialize

newDataOut2

deserialize

update2

compareAndSwap

delete

delete2

lockPos

assertReadLocked

assertWriteLocked

isClosed

isReadOnly

forDB

forEngine

getCurrSize

getFreeSize

fileLoad

clearCache

metricsCollect

backup

backupRestore

getWrappedEngine

canSnapshot

longParitySet

longParityGet