TxEngine.Tx

java.lang.Object
- org.mapdb.TxEngine.Tx

All Implemented Interfaces:: Engine

Enclosing class:: TxEngine

public class TxEngine.Tx
extends java.lang.Object
implements Engine

Field Summary

Fields
Modifier and Type	Field and Description
`protected boolean`	`closed`
`protected LongConcurrentHashMap<Fun.Tuple2>`	`mod`
`protected LongConcurrentHashMap`	`old`
`private Store`	`parentEngine`
`(package private) SerializerPojo`	`pojo`
`protected java.lang.ref.Reference<TxEngine.Tx>`	`ref`
`protected java.util.Collection<java.lang.Long>`	`usedPreallocatedRecids`

Fields inherited from interface org.mapdb.Engine
CATALOG_RECID, CHECK_RECORD, CLASS_INFO_RECID, LAST_RESERVED_RECID

Constructor Summary

Constructors
Constructor and Description

Tx()

Constructors
Constructor and Description
`Tx()`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`boolean`	`canRollback()`
`boolean`	`canSnapshot()`
`void`	`clearCache()` clears any underlying cache
`void`	`close()` Close store/cache.
`void`	`closeListenerRegister(java.lang.Runnable closeListener)`
`void`	`closeListenerUnregister(java.lang.Runnable closeListener)`
`void`	`commit()` Makes all changes made since the previous commit/rollback permanent.
`void`	`compact()`
`<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 Recid must be a number returned by 'put' method.
`<A> A`	`get(long recid, Serializer<A> serializer)` Get existing record.
`private <A> A`	`getNoLock(long recid, Serializer<A> serializer)`
`SerializerPojo`	`getSerializerPojo()` Returns default serializer associated with this engine.
`Engine`	`getWrappedEngine()`
`boolean`	`isClosed()` Checks whether Engine was closed.
`boolean`	`isReadOnly()` Check if you can write into this Engine.
`long`	`preallocate()` Preallocates recid for not yet created record.
`void`	`preallocate(long[] recids)` Preallocates recids for not yet created record.
`<A> long`	`put(A value, Serializer<A> serializer)` Insert new record.
`void`	`rollback()` Undoes all changes made in the current transaction.
`Engine`	`snapshot()` Returns read-only snapshot of data in Engine.
`<A> void`	`update(long recid, A value, Serializer<A> serializer)` Update existing record with new value.

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

- Field Detail
  - old
```
protected LongConcurrentHashMap old
```
  - mod
```
protected LongConcurrentHashMap<Fun.Tuple2> mod
```
  - usedPreallocatedRecids
```
protected java.util.Collection<java.lang.Long> usedPreallocatedRecids
```
  - ref
```
protected final java.lang.ref.Reference<TxEngine.Tx> ref
```
  - closed
```
protected boolean closed
```
  - parentEngine
```
private Store parentEngine
```
  - pojo
```
SerializerPojo pojo
```
- Constructor Detail
  - Tx
```
public Tx()
```
- Method Detail
  - preallocate
```
public long preallocate()
```
    Description copied from interface: Engine
    
    Preallocates recid for not yet created record. It does not insert any data into it.
    
    Specified by:
    
    preallocate in interface Engine
    
    Returns:
    
    new recid
  - preallocate
```
public void preallocate(long[] recids)
```
    Description copied from interface: Engine
    
    Preallocates recids for not yet created record. It does not insert any data into it. This is done in batch of given size (determied by size of array in argument)
    
    Specified by:
    
    preallocate in interface Engine
    
    Parameters:
    
    recids - array to put result into
  - put
```
public <A> long put(A value,
                    Serializer<A> serializer)
```
    Description copied from interface: Engine
    
    Insert new record.
    
    Specified by:
    
    put in interface Engine
    
    Parameters:
    
    value - records to be added
    
    serializer - used to convert record into/from binary form
    
    Returns:
    
    recid (record identifier) under which record is stored.
  - 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.
  - getNoLock
```
private <A> A getNoLock(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
  - 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
  - close
```
public void close()
```
    Description copied from interface: Engine
    
    Close store/cache. This method must be called before JVM exits to flush all caches and prevent store corruption. Also it releases resources used by MapDB (disk, memory..).
    Engine can no longer be used after this method was called. If Engine is used after closing, it may throw any exception including NullPointerException
    There is an configuration option DBMaker.closeOnJvmShutdown() which uses shutdown hook to automatically close Engine when JVM shutdowns.
    
    Specified by:
    
    close in interface Engine
  - 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
  - commit
```
public void commit()
```
    Description copied from interface: Engine
    
    Makes all changes made since the previous commit/rollback permanent. In transactional mode (on by default) it means creating journal file and replaying it to storage. In other modes it may flush disk caches or do nothing at all (check your config options)
    
    Specified by:
    
    commit in interface Engine
  - rollback
```
public void rollback()
              throws java.lang.UnsupportedOperationException
```
    Description copied from interface: Engine
    
    Undoes all changes made in the current transaction. If transactions are disabled it throws UnsupportedOperationException.
    
    Specified by:
    
    rollback in interface Engine
    
    Throws:
    
    java.lang.UnsupportedOperationException - if transactions are disabled
  - 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
  - canRollback
```
public boolean canRollback()
```
    Specified by:
    
    canRollback in interface Engine
    
    Returns:
    
    true if engine supports rollback
  - canSnapshot
```
public boolean canSnapshot()
```
    Specified by:
    
    canSnapshot in interface Engine
    
    Returns:
    
    true if engine can create read-only snapshots
  - snapshot
```
public Engine snapshot()
                throws java.lang.UnsupportedOperationException
```
    Description copied from interface: Engine
    
    Returns read-only snapshot of data in Engine.
    
    Specified by:
    
    snapshot in interface Engine
    
    Throws:
    
    java.lang.UnsupportedOperationException - if snapshots are not supported/enabled
    
    See Also:
    
    EngineWrapper.canSnapshot()
  - clearCache
```
public void clearCache()
```
    Description copied from interface: Engine
    
    clears any underlying cache
    
    Specified by:
    
    clearCache in interface Engine
  - compact
```
public void compact()
```
    Specified by:
    
    compact in interface Engine
  - getSerializerPojo
```
public SerializerPojo getSerializerPojo()
```
    Description copied from interface: Engine
    
    Returns default serializer associated with this engine. The default serializer will be moved from Engine into DB, so it is deprecated now and this method will be removed.
    
    Specified by:
    
    getSerializerPojo in interface Engine
  - closeListenerRegister
```
public void closeListenerRegister(java.lang.Runnable closeListener)
```
    Specified by:
    
    closeListenerRegister in interface Engine
  - closeListenerUnregister
```
public void closeListenerUnregister(java.lang.Runnable closeListener)
```
    Specified by:
    
    closeListenerUnregister in interface Engine
  - getWrappedEngine
```
public Engine getWrappedEngine()
```

Class TxEngine.Tx

Field Summary

Fields inherited from interface org.mapdb.Engine

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

old

mod

usedPreallocatedRecids

ref

closed

parentEngine

pojo

Constructor Detail

Tx

Method Detail

preallocate

preallocate

put

get

getNoLock

update

compareAndSwap

delete

close

isClosed

commit

rollback

isReadOnly

canRollback

canSnapshot

snapshot

clearCache

compact

getSerializerPojo

closeListenerRegister

closeListenerUnregister

getWrappedEngine