Safe Haskell	None
Language	Haskell2010

Database.Haskey.Alloc.Concurrent.Environment

Description

Environments of a read or write transaction.

Synopsis

Documentation

data StateType Source #

Constructors

TypeData
TypeIndex

data S t a where Source #

Wrapper around a type to indicate it belongs to a file with either data/leaf nodes or index nodes.

Constructors

DataState :: a -> S TypeData a
IndexState :: a -> S TypeIndex a

Instances

Functor (S t) Source #
Methods fmap :: (a -> b) -> S t a -> S t b # (<$) :: a -> S t b -> S t a #
Show a => Show (S t a) Source #
Methods showsPrec :: Int -> S t a -> ShowS # show :: S t a -> String # showList :: [S t a] -> ShowS #
Binary a => Binary (S TypeData a) Source #
Methods put :: S TypeData a -> Put # get :: Get (S TypeData a) # putList :: [S TypeData a] -> Put #
Binary a => Binary (S TypeIndex a) Source #
Methods put :: S TypeIndex a -> Put # get :: Get (S TypeIndex a) # putList :: [S TypeIndex a] -> Put #

getSValue :: S t a -> a Source #

newtype ReaderEnv hnds Source #

Constructors

ReaderEnv
Fields readerHnds :: hnds

Instances

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 #

data FileState stateType Source #

Constructors

FileState

Fields

fileStateNewlyFreedPages :: ![NewlyFreed]
Pages free'd in this transaction, not ready for reuse until the transaction is commited.
fileStateOriginalNumPages :: !(S stateType PageId)
The original number of pages in the file, before the transaction started.
fileStateNewNumPages :: !(S stateType PageId)
The new uncommited number of pages in the file.
All pages in the range fileStateOriginalNumPages to fileStateNewNumPages (excluding) are freshly allocated in the ongoing transaction.
fileStateFreedDirtyPages :: !(S stateType (Set DirtyFree))
Pages freshly allocated AND free'd in this transaction. Immediately ready for reuse.
fileStateFreeTree :: !(S stateType FreeTree)
The root of the free tree, might change during a transaction.
fileStateDirtyReusablePages :: !(Set DirtyOldFree)
All pages queried from the free page database for fileStateReusablePagesTxId, and actually used once already.
fileStateReusablePages :: ![OldFree]
Pages queried from the free pages database and ready for immediate reuse.
fileStateReusablePagesTxId :: !(Maybe TxId)
The TxId of the pages in fileStateReusablePages, or Nothing if no pages were queried yet from the free database.

data WriterEnv hnds Source #

Constructors

WriterEnv

Fields

writerHnds :: !hnds
writerTxId :: !TxId
writerReaders :: Map TxId Integer
writerIndexFileState :: FileState TypeIndex
State of the file with index nodes.
writerDataFileState :: FileState TypeData
State of the file with data/leaf nodes.
writerReusablePagesOn :: !Bool
Used to turn of querying the free page database for free pages.
writerDirtyOverflows :: !(Set DirtyOverflow)
Newly allocated overflow pages in this transaction.
writerOverflowCounter :: !Word32
Counts how many overflow pages were already allocated in this transaction.
writerRemovedOverflows :: ![OldOverflow]
Old overflow pages that were removed in this transaction and should be deleted when no longer in use.

Instances

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, 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 () #

newWriter :: hnd -> TxId -> Map TxId Integer -> S TypeData PageId -> S TypeIndex PageId -> S TypeData (Set DirtyFree) -> S TypeIndex (Set DirtyFree) -> S TypeData FreeTree -> S TypeIndex FreeTree -> WriterEnv hnd Source #

Create a new writer.

newtype Fresh Source #

Wrapper around PageId indicating it is a fresh page, allocated at the end of the database.

Constructors

Fresh PageId

Instances

Eq Fresh Source #
Methods (==) :: Fresh -> Fresh -> Bool # (/=) :: Fresh -> Fresh -> Bool #
Ord Fresh Source #
Methods compare :: Fresh -> Fresh -> Ordering # (<) :: Fresh -> Fresh -> Bool # (<=) :: Fresh -> Fresh -> Bool # (>) :: Fresh -> Fresh -> Bool # (>=) :: Fresh -> Fresh -> Bool # max :: Fresh -> Fresh -> Fresh # min :: Fresh -> Fresh -> Fresh #
Show Fresh Source #
Methods showsPrec :: Int -> Fresh -> ShowS # show :: Fresh -> String # showList :: [Fresh] -> ShowS #

newtype NewlyFreed Source #

Wrapper around PageId indicating it is newly free'd and cannot be reused in the same transaction.

Constructors

NewlyFreed PageId

Instances

Eq NewlyFreed Source #
Methods (==) :: NewlyFreed -> NewlyFreed -> Bool # (/=) :: NewlyFreed -> NewlyFreed -> Bool #
Ord NewlyFreed Source #
Methods compare :: NewlyFreed -> NewlyFreed -> Ordering # (<) :: NewlyFreed -> NewlyFreed -> Bool # (<=) :: NewlyFreed -> NewlyFreed -> Bool # (>) :: NewlyFreed -> NewlyFreed -> Bool # (>=) :: NewlyFreed -> NewlyFreed -> Bool # max :: NewlyFreed -> NewlyFreed -> NewlyFreed # min :: NewlyFreed -> NewlyFreed -> NewlyFreed #
Show NewlyFreed Source #
Methods showsPrec :: Int -> NewlyFreed -> ShowS # show :: NewlyFreed -> String # showList :: [NewlyFreed] -> ShowS #

newtype Dirty Source #

Wrapper around PageId indicating it is a dirty page.

Constructors

Dirty PageId

Instances

Eq Dirty Source #
Methods (==) :: Dirty -> Dirty -> Bool # (/=) :: Dirty -> Dirty -> Bool #
Ord Dirty Source #
Methods compare :: Dirty -> Dirty -> Ordering # (<) :: Dirty -> Dirty -> Bool # (<=) :: Dirty -> Dirty -> Bool # (>) :: Dirty -> Dirty -> Bool # (>=) :: Dirty -> Dirty -> Bool # max :: Dirty -> Dirty -> Dirty # min :: Dirty -> Dirty -> Dirty #
Show Dirty Source #
Methods showsPrec :: Int -> Dirty -> ShowS # show :: Dirty -> String # showList :: [Dirty] -> ShowS #

newtype DirtyFree Source #

Wrapper around PageId indicating the page is dirty and free for reuse.

Constructors

DirtyFree PageId

Instances

Eq DirtyFree Source #
Methods (==) :: DirtyFree -> DirtyFree -> Bool # (/=) :: DirtyFree -> DirtyFree -> Bool #
Ord DirtyFree Source #
Methods compare :: DirtyFree -> DirtyFree -> Ordering # (<) :: DirtyFree -> DirtyFree -> Bool # (<=) :: DirtyFree -> DirtyFree -> Bool # (>) :: DirtyFree -> DirtyFree -> Bool # (>=) :: DirtyFree -> DirtyFree -> Bool # max :: DirtyFree -> DirtyFree -> DirtyFree # min :: DirtyFree -> DirtyFree -> DirtyFree #
Show DirtyFree Source #
Methods showsPrec :: Int -> DirtyFree -> ShowS # show :: DirtyFree -> String # showList :: [DirtyFree] -> ShowS #
Binary DirtyFree Source #
Methods put :: DirtyFree -> Put # get :: Get DirtyFree # putList :: [DirtyFree] -> Put #

newtype OldFree Source #

Wrapper around PageId inidcating it was fetched from the free database and is ready for reuse.

Constructors

OldFree PageId

Instances

Eq OldFree Source #
Methods (==) :: OldFree -> OldFree -> Bool # (/=) :: OldFree -> OldFree -> Bool #
Ord OldFree Source #
Methods compare :: OldFree -> OldFree -> Ordering # (<) :: OldFree -> OldFree -> Bool # (<=) :: OldFree -> OldFree -> Bool # (>) :: OldFree -> OldFree -> Bool # (>=) :: OldFree -> OldFree -> Bool # max :: OldFree -> OldFree -> OldFree # min :: OldFree -> OldFree -> OldFree #
Show OldFree Source #
Methods showsPrec :: Int -> OldFree -> ShowS # show :: OldFree -> String # showList :: [OldFree] -> ShowS #

newtype DirtyOldFree Source #

Wrapper around PageId indicating it wa fetched from the free database and is actually dirty.

Constructors

DirtyOldFree PageId

Instances

Eq DirtyOldFree Source #
Methods (==) :: DirtyOldFree -> DirtyOldFree -> Bool # (/=) :: DirtyOldFree -> DirtyOldFree -> Bool #
Ord DirtyOldFree Source #
Methods compare :: DirtyOldFree -> DirtyOldFree -> Ordering # (<) :: DirtyOldFree -> DirtyOldFree -> Bool # (<=) :: DirtyOldFree -> DirtyOldFree -> Bool # (>) :: DirtyOldFree -> DirtyOldFree -> Bool # (>=) :: DirtyOldFree -> DirtyOldFree -> Bool # max :: DirtyOldFree -> DirtyOldFree -> DirtyOldFree # min :: DirtyOldFree -> DirtyOldFree -> DirtyOldFree #
Show DirtyOldFree Source #
Methods showsPrec :: Int -> DirtyOldFree -> ShowS # show :: DirtyOldFree -> String # showList :: [DirtyOldFree] -> ShowS #

data SomeFreePage Source #

A sum type repesenting any type of free page, that can immediately be used to write something to.

Constructors

FreshFreePage Fresh
DirtyFreePage DirtyFree
OldFreePage OldFree

getSomeFreePageId :: SomeFreePage -> PageId Source #

freePage :: (Functor m, MonadState (WriterEnv hnd) m) => S stateType PageId -> m () Source #

Try to free a page, given a set of dirty pages.

If the page was dirty, a DirtyFree page is added to the environment, if not a NewlyFreed page is added to the environment.

Btw, give me lenses...

updateFileState :: FileState t -> (forall a. a -> S t a) -> Maybe Dirty -> Maybe DirtyOldFree -> PageId -> FileState t Source #

dirty :: (Functor m, MonadState (WriterEnv hnd) m) => S stateType PageId -> m (Maybe Dirty) Source #

Get a Dirty page, by first proving it is in fact dirty.

dirtyOldFree :: (Functor m, MonadState (WriterEnv hnd) m) => S stateType PageId -> m (Maybe DirtyOldFree) Source #

Get a DirtyOldFree page, by first proving it is in fact a dirty old free page.

touchPage :: MonadState (WriterEnv hnd) m => S stateType SomeFreePage -> m () Source #

Touch a fresh page, make it dirty.

We really need lenses...

newtype DirtyOverflow Source #

Wrapper around OverflowId indicating that it is dirty.

Constructors

DirtyOverflow OverflowId

Instances

Eq DirtyOverflow Source #
Methods (==) :: DirtyOverflow -> DirtyOverflow -> Bool # (/=) :: DirtyOverflow -> DirtyOverflow -> Bool #
Ord DirtyOverflow Source #
Methods compare :: DirtyOverflow -> DirtyOverflow -> Ordering # (<) :: DirtyOverflow -> DirtyOverflow -> Bool # (<=) :: DirtyOverflow -> DirtyOverflow -> Bool # (>) :: DirtyOverflow -> DirtyOverflow -> Bool # (>=) :: DirtyOverflow -> DirtyOverflow -> Bool # max :: DirtyOverflow -> DirtyOverflow -> DirtyOverflow # min :: DirtyOverflow -> DirtyOverflow -> DirtyOverflow #
Show DirtyOverflow Source #
Methods showsPrec :: Int -> DirtyOverflow -> ShowS # show :: DirtyOverflow -> String # showList :: [DirtyOverflow] -> ShowS #

newtype OldOverflow Source #

Wrapper around OverflowId indicating that it is an overflow page from a previous transaction.

Constructors

OldOverflow OverflowId

Instances

Eq OldOverflow Source #
Methods (==) :: OldOverflow -> OldOverflow -> Bool # (/=) :: OldOverflow -> OldOverflow -> Bool #
Ord OldOverflow Source #
Methods compare :: OldOverflow -> OldOverflow -> Ordering # (<) :: OldOverflow -> OldOverflow -> Bool # (<=) :: OldOverflow -> OldOverflow -> Bool # (>) :: OldOverflow -> OldOverflow -> Bool # (>=) :: OldOverflow -> OldOverflow -> Bool # max :: OldOverflow -> OldOverflow -> OldOverflow # min :: OldOverflow -> OldOverflow -> OldOverflow #
Show OldOverflow Source #
Methods showsPrec :: Int -> OldOverflow -> ShowS # show :: OldOverflow -> String # showList :: [OldOverflow] -> ShowS #

touchOverflow :: MonadState (WriterEnv hnd) m => OverflowId -> m () Source #

Touch a fresh overflow page, making it dirty.

overflowType :: MonadState (WriterEnv hnd) m => OverflowId -> m (Either DirtyOverflow OldOverflow) Source #

Get the type of the overflow page.

removeOldOverflow :: MonadState (WriterEnv hdn) m => OldOverflow -> m () Source #

Free an old overflow page.