Database.Haskey.Alloc.Concurrent.Database

This module implements data structures and functions related to the database.

Documentation

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

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.

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

Open all concurrent handles.

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.

newConcurrentDb :: (Root root, MonadIO m) => ConcurrentHandles -> ConcurrentMeta root -> m (ConcurrentDb root)

Create a new concurrent database with handles and metadata provided.

getCurrentMeta :: Root root => ConcurrentDb root -> STM (ConcurrentMeta root)

Get the current meta data.

setCurrentMeta :: (Root root, MonadIO m, ConcurrentMetaStoreM m) => ConcurrentMeta root -> ConcurrentDb root -> m ()

Write the new metadata, and switch the pointer to the current one.

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.

transactNow :: (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, without cleaning up old overflow pages.

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.

actAndCommit :: (MonadIO m, MonadMask m, ConcurrentMetaStoreM m, Root root) => ConcurrentDb root -> (forall n. (MonadIO n, MonadMask n, ConcurrentMetaStoreM n) => ConcurrentMeta root -> ConcurrentT WriterEnv ConcurrentHandles n (Maybe (ConcurrentMeta root), a)) -> m a

Run a write action that takes the current meta-data and returns new meta-data to be commited, or Nothing if the write transaction should be aborted.

cleanupAfterException :: (MonadIO m, MonadCatch m, ConcurrentMetaStoreM m) => ConcurrentHandles -> TxId -> m ()

Cleanup after an exception occurs, or after a program crash.

The TxId of the aborted transaction should be passed.

removeNewlyAllocatedOverflows :: (MonadIO m, ConcurrentMetaStoreM m) => WriterEnv ConcurrentHandles -> m ()

Remove all overflow pages that were written in the transaction.

If the transaction is aborted, all written pages should be deleted.

updateMeta :: WriterEnv ConcurrentHandles -> ConcurrentMeta root -> ConcurrentMeta root

Update the meta-data from a writer environment

saveOverflowIds :: (MonadIO m, MonadMask m, ConcurrentMetaStoreM m) => StateT (ConcurrentMeta root, WriterEnv ConcurrentHandles) m ()

Save the newly free'd overflow pages, for deletion on the next tx.

saveFreePages' :: (MonadIO m, MonadMask m, ConcurrentMetaStoreM m) => Int -> (forall a. a -> S t a) -> (forall hnds. WriterEnv hnds -> FileState t) -> (forall hnds. WriterEnv hnds -> FileState t -> WriterEnv hnds) -> StateT (ConcurrentMeta root, WriterEnv ConcurrentHandles) m ()

Save the free'd pages to the free page database

handleCachedFreePages :: (MonadIO m, MonadMask m, ConcurrentMetaStoreM m) => StateT (ConcurrentMeta root, WriterEnv ConcurrentHandles) m ()

Handle the cached free pages.

Save the cached free pages to the metadata for later use.

Update the database size.