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.
fileStateDirtyPages :: !(Set PageId)
Pages written to in this transaction.
fileStateFreeTree :: !(S stateType FreeTree)
The root of the free tree, might change during a transaction.
fileStateCachedFreePages :: !(S stateType [FreePage])
All pages that are immediately ready for reuse in this and any subsequent transactions.

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.
writerQueryFreeTreeOn :: !Bool
Whether or not querying free pages from the free is enabled.
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 [FreePage] -> S TypeIndex [FreePage] -> S TypeData FreeTree -> S TypeIndex FreeTree -> WriterEnv hnd Source #

Create a new writer.

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 FreePage Source #

Wrapper around PageId indicating it is free and can be reused in any transaction.

Constructors

FreePage PageId

Instances

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

newtype Dirty Source #

Wrapper around PageId indicating that it is dirty, i.e. written to in this transaction.

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 #

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

touchPage :: MonadState (WriterEnv hnd) m => S stateType PageId -> 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.