Database.Haskey.Alloc.Concurrent

The module implements an page allocator with page reuse and support for multiple readers and serialized writers.

Allocator

data ConcurrentDb root

An active concurrent database.

This can be shared amongst threads.

Constructors

ConcurrentDb

Fields

• concurrentDbHandles :: ConcurrentHandles
• concurrentDbWriterLock :: RLock
• concurrentDbCurrentMeta :: TVar CurrentMetaPage
• concurrentDbMeta1 :: TVar (ConcurrentMeta root)
• concurrentDbMeta2 :: TVar (ConcurrentMeta root)
• concurrentDbReaders :: Map TxId Integer

Open, close and create databases

data ConcurrentHandles

All necessary database handles.

Constructors

ConcurrentHandles

Fields

• concurrentHandlesRoot :: FilePath
• concurrentHandlesData :: FilePath
• concurrentHandlesIndex :: FilePath
• concurrentHandlesMetadata1 :: FilePath
• concurrentHandlesMetadata2 :: FilePath
• concurrentHandlesOverflowDir :: FilePath

Instances

Show ConcurrentHandles

Methods

showsPrec :: Int -> ConcurrentHandles -> ShowS

show :: ConcurrentHandles -> String

showList :: [ConcurrentHandles] -> ShowS

ConcurrentMetaStoreM m => AllocReaderM (ConcurrentT WriterEnv ConcurrentHandles m)

Methods

readNode :: (Key key, Value val) => Height height -> NodeId height key val -> ConcurrentT WriterEnv ConcurrentHandles m (Node height key val)

readOverflow :: Value val => OverflowId -> ConcurrentT WriterEnv ConcurrentHandles m val

ConcurrentMetaStoreM m => AllocReaderM (ConcurrentT ReaderEnv ConcurrentHandles m)

Methods

readNode :: (Key key, Value val) => Height height -> NodeId height key val -> ConcurrentT ReaderEnv ConcurrentHandles m (Node height key val)

readOverflow :: Value val => OverflowId -> ConcurrentT ReaderEnv ConcurrentHandles m val

(ConcurrentMetaStoreM m, MonadIO m) => AllocM (ConcurrentT WriterEnv ConcurrentHandles m)

Methods

nodePageSize :: (Key key, Value val) => ConcurrentT WriterEnv ConcurrentHandles m (Height height -> Node height key val -> PageSize)

maxPageSize :: ConcurrentT WriterEnv ConcurrentHandles m PageSize

maxKeySize :: ConcurrentT WriterEnv ConcurrentHandles m Word64

maxValueSize :: ConcurrentT WriterEnv ConcurrentHandles m Word64

allocNode :: (Key key, Value val) => Height height -> Node height key val -> ConcurrentT WriterEnv ConcurrentHandles m (NodeId height key val)

freeNode :: Height height -> NodeId height key val -> ConcurrentT WriterEnv ConcurrentHandles m ()

allocOverflow :: Value val => val -> ConcurrentT WriterEnv ConcurrentHandles m OverflowId

freeOverflow :: OverflowId -> ConcurrentT WriterEnv ConcurrentHandles m ()

concurrentHandles :: FilePath -> ConcurrentHandles

Construct a set of ConcurrentHandles from a root directory.

lockConcurrentDb :: ConcurrentMetaStoreM m => ConcurrentHandles -> m ()

Lock the database.

This needs to be called manually, if you want exclusive access, before calling either createConcurrentDb or openConcurrentDb

Use unlockConcurrentDb using the bracket pattern to properly unlock the database.

unlockConcurrentDb :: ConcurrentMetaStoreM m => ConcurrentHandles -> m ()

Unlock the database.

createConcurrentDb :: (Root root, MonadIO m, MonadMask m, ConcurrentMetaStoreM m) => ConcurrentHandles -> root -> m (ConcurrentDb root)

Open a new concurrent database, with the given handles.

openConcurrentDb :: (Root root, MonadIO m, MonadMask m, ConcurrentMetaStoreM m) => ConcurrentHandles -> m (Maybe (ConcurrentDb root))

Open the an existing database, with the given handles.

closeConcurrentHandles :: (MonadIO m, ConcurrentMetaStoreM m) => ConcurrentHandles -> m ()

Close the handles of the database.

Manipulation and transactions

module Database.Haskey.Alloc.Transaction

transact :: (MonadIO m, MonadMask m, ConcurrentMetaStoreM m, Root root) => (forall n. (AllocM n, MonadMask n) => root -> n (Transaction root a)) -> ConcurrentDb root -> m a

Execute a write transaction, with a result.

transact_ :: (MonadIO m, MonadMask m, ConcurrentMetaStoreM m, Root root) => (forall n. (AllocM n, MonadMask n) => root -> n (Transaction root ())) -> ConcurrentDb root -> m ()

Execute a write transaction, without a result.

transactReadOnly :: (MonadIO m, MonadMask m, ConcurrentMetaStoreM m, Root root) => (forall n. (AllocReaderM n, MonadMask n) => root -> n a) -> ConcurrentDb root -> m a

Execute a read-only transaction.

Storage requirements

class Value root => Root root

User-defined data root stored inside ConcurrentMeta.

This can be a user-defined collection of Tree roots.

Instances

(Key k, Value v) => Root (Tree k v)

data ConcurrentMeta root

Meta data of the page allocator.

The root type parameter should be a user-defined collection of Tree roots, instantiating the Root type class.

To store store a single tree, use ConcurrentMeta (Tree k v).

Constructors

ConcurrentMeta

Fields

• concurrentMetaRevision :: TxId
• concurrentMetaDataNumPages :: S TypeData PageId
• concurrentMetaIndexNumPages :: S TypeIndex PageId
• concurrentMetaRoot :: root
• concurrentMetaDataFreeTree :: S TypeData FreeTree
• concurrentMetaIndexFreeTree :: S TypeIndex FreeTree
• concurrentMetaOverflowTree :: OverflowTree
• concurrentMetaDataCachedFreePages :: S TypeData [FreePage]
• concurrentMetaIndexCachedFreePages :: S TypeIndex [FreePage]

Instances

Show root => Show (ConcurrentMeta root)

Methods

showsPrec :: Int -> ConcurrentMeta root -> ShowS

show :: ConcurrentMeta root -> String

showList :: [ConcurrentMeta root] -> ShowS

Generic (ConcurrentMeta root)

Associated Types

type Rep (ConcurrentMeta root) :: * -> *

Methods

from :: ConcurrentMeta root -> Rep (ConcurrentMeta root) x

to :: Rep (ConcurrentMeta root) x -> ConcurrentMeta root

Binary root => Binary (ConcurrentMeta root)

Methods

put :: ConcurrentMeta root -> Put

get :: Get (ConcurrentMeta root)

putList :: [ConcurrentMeta root] -> Put

type Rep (ConcurrentMeta root)

type Rep (ConcurrentMeta root) = D1 (MetaData "ConcurrentMeta" "Database.Haskey.Alloc.Concurrent.Meta" "haskey-0.2.0.0-1EosJKVTIA32JYw7HhPTkM" False) (C1 (MetaCons "ConcurrentMeta" PrefixI True) ((:*:) ((:*:) ((:*:) (S1 (MetaSel (Just Symbol "concurrentMetaRevision") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 TxId)) (S1 (MetaSel (Just Symbol "concurrentMetaDataNumPages") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (S TypeData PageId)))) ((:*:) (S1 (MetaSel (Just Symbol "concurrentMetaIndexNumPages") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (S TypeIndex PageId))) (S1 (MetaSel (Just Symbol "concurrentMetaRoot") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 root)))) ((:*:) ((:*:) (S1 (MetaSel (Just Symbol "concurrentMetaDataFreeTree") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (S TypeData FreeTree))) (S1 (MetaSel (Just Symbol "concurrentMetaIndexFreeTree") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (S TypeIndex FreeTree)))) ((:*:) (S1 (MetaSel (Just Symbol "concurrentMetaOverflowTree") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 OverflowTree)) ((:*:) (S1 (MetaSel (Just Symbol "concurrentMetaDataCachedFreePages") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (S TypeData [FreePage]))) (S1 (MetaSel (Just Symbol "concurrentMetaIndexCachedFreePages") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (S TypeIndex [FreePage]))))))))

class StoreM FilePath m => ConcurrentMetaStoreM m where

A class representing the storage requirements of the page allocator.

A store supporting the page allocator should be an instance of this class.

Minimal complete definition

putConcurrentMeta, readConcurrentMeta

Methods

putConcurrentMeta :: Root root => FilePath -> ConcurrentMeta root -> m ()

Write the meta-data structure to a certain page.

readConcurrentMeta :: Root root => FilePath -> Proxy root -> m (Maybe (ConcurrentMeta root))

Try to read the meta-data structure from a handle, or return Nothing if the handle doesn't contain a meta page.

Instances

(Applicative m, Monad m, MonadIO m, MonadCatch m) => ConcurrentMetaStoreM (FileStoreT FilePath m)

Methods

putConcurrentMeta :: Root root => FilePath -> ConcurrentMeta root -> FileStoreT FilePath m ()

readConcurrentMeta :: Root root => FilePath -> Proxy * root -> FileStoreT FilePath m (Maybe (ConcurrentMeta root))

(Applicative m, Monad m, MonadIO m, MonadCatch m) => ConcurrentMetaStoreM (MemoryStoreT FilePath m)

Methods

putConcurrentMeta :: Root root => FilePath -> ConcurrentMeta root -> MemoryStoreT FilePath m ()

readConcurrentMeta :: Root root => FilePath -> Proxy * root -> MemoryStoreT FilePath m (Maybe (ConcurrentMeta root))