Database.Haskey.Alloc.Concurrent

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

Allocator

data ConcurrentDb k v

An active concurrent database.

This can be shared amongst threads.

Constructors

ConcurrentDb

Fields

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

Open, close and create databases

data ConcurrentHandles

All necessary database handles.

Constructors

ConcurrentHandles

Fields

• 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.

createConcurrentDb :: (Key k, Value v, MonadIO m, ConcurrentMetaStoreM m) => ConcurrentHandles -> m (ConcurrentDb k v)

Open a new concurrent database, with the given handles.

openConcurrentDb :: (Key k, Value v, MonadIO m, MonadMask m, ConcurrentMetaStoreM m) => ConcurrentHandles -> m (Maybe (ConcurrentDb k v))

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, Key key, Value val) => (forall n. (AllocM n, MonadMask n) => Tree key val -> n (Transaction key val a)) -> ConcurrentDb key val -> m a

Execute a write transaction, with a result.

transact_ :: (MonadIO m, MonadMask m, ConcurrentMetaStoreM m, Key k, Value v) => (forall n. (AllocM n, MonadMask n) => Tree k v -> n (Transaction k v ())) -> ConcurrentDb k v -> m ()

Execute a write transaction, without a result.

transactReadOnly :: (MonadIO m, MonadMask m, ConcurrentMetaStoreM m, Key key, Value val) => (forall n. (AllocReaderM n, MonadMask m) => Tree key val -> n a) -> ConcurrentDb key val -> m a

Execute a read-only transaction.

Storage requirements

data ConcurrentMeta k v

Meta data of the page allocator.

Constructors

ConcurrentMeta

Fields

• concurrentMetaRevision :: TxId
• concurrentMetaDataNumPages :: S TypeData PageId
• concurrentMetaIndexNumPages :: S TypeIndex PageId
• concurrentMetaTree :: Tree k v
• concurrentMetaDataFreeTree :: S TypeData FreeTree
• concurrentMetaIndexFreeTree :: S TypeIndex FreeTree
• concurrentMetaOverflowTree :: OverflowTree
• concurrentMetaDataFreshUnusedPages :: S TypeData (Set DirtyFree)
• concurrentMetaIndexFreshUnusedPages :: S TypeIndex (Set DirtyFree)

Instances

(Show k, Show v) => Show (ConcurrentMeta k v)

Methods

showsPrec :: Int -> ConcurrentMeta k v -> ShowS

show :: ConcurrentMeta k v -> String

showList :: [ConcurrentMeta k v] -> ShowS

Generic (ConcurrentMeta k v)

Associated Types

type Rep (ConcurrentMeta k v) :: * -> *

Methods

from :: ConcurrentMeta k v -> Rep (ConcurrentMeta k v) x

to :: Rep (ConcurrentMeta k v) x -> ConcurrentMeta k v

(Binary k, Binary v) => Binary (ConcurrentMeta k v)

Methods

put :: ConcurrentMeta k v -> Put

get :: Get (ConcurrentMeta k v)

putList :: [ConcurrentMeta k v] -> Put

type Rep (ConcurrentMeta k v)

type Rep (ConcurrentMeta k v) = D1 (MetaData "ConcurrentMeta" "Database.Haskey.Alloc.Concurrent.Meta" "haskey-0.1.0.1-GzE5NfiBJHFJQHWUYXDJlg" 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 "concurrentMetaTree") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Tree k v))))) ((:*:) ((:*:) (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 "concurrentMetaDataFreshUnusedPages") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (S TypeData (Set DirtyFree)))) (S1 (MetaSel (Just Symbol "concurrentMetaIndexFreshUnusedPages") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (S TypeIndex (Set DirtyFree)))))))))

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 :: (Key k, Value v) => FilePath -> ConcurrentMeta k v -> m ()

Write the meta-data structure to a certain page.

readConcurrentMeta :: (Key k, Value v) => FilePath -> Proxy k -> Proxy v -> m (Maybe (ConcurrentMeta k v))

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 :: (Key k, Value v) => FilePath -> ConcurrentMeta k v -> FileStoreT FilePath m ()

readConcurrentMeta :: (Key k, Value v) => FilePath -> Proxy * k -> Proxy * v -> FileStoreT FilePath m (Maybe (ConcurrentMeta k v))

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

Methods

putConcurrentMeta :: (Key k, Value v) => FilePath -> ConcurrentMeta k v -> MemoryStoreT FilePath m ()

readConcurrentMeta :: (Key k, Value v) => FilePath -> Proxy * k -> Proxy * v -> MemoryStoreT FilePath m (Maybe (ConcurrentMeta k v))