Database.Haskey.Alloc.Concurrent.Environment

Environments of a read or write transaction.

Documentation

data StateType

Constructors

TypeData

TypeIndex

data S t a where

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)

Methods

fmap :: (a -> b) -> S t a -> S t b

(<$) :: a -> S t b -> S t a

Show a => Show (S t a)

Methods

showsPrec :: Int -> S t a -> ShowS

show :: S t a -> String

showList :: [S t a] -> ShowS

Binary a => Binary (S TypeData a)

Methods

put :: S TypeData a -> Put

get :: Get (S TypeData a)

putList :: [S TypeData a] -> Put

Binary a => Binary (S TypeIndex a)

Methods

put :: S TypeIndex a -> Put

get :: Get (S TypeIndex a)

putList :: [S TypeIndex a] -> Put

getSValue :: S t a -> a

newtype ReaderEnv hnds

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

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

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

Create a new writer.

newtype Fresh

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

Constructors

Fresh PageId

Instances

Eq Fresh

Methods

(==) :: Fresh -> Fresh -> Bool

(/=) :: Fresh -> Fresh -> Bool

Ord Fresh

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

Methods

showsPrec :: Int -> Fresh -> ShowS

show :: Fresh -> String

showList :: [Fresh] -> ShowS

newtype NewlyFreed

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

Constructors

NewlyFreed PageId

Instances

Eq NewlyFreed

Methods

(==) :: NewlyFreed -> NewlyFreed -> Bool

(/=) :: NewlyFreed -> NewlyFreed -> Bool

Ord NewlyFreed

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

Methods

showsPrec :: Int -> NewlyFreed -> ShowS

show :: NewlyFreed -> String

showList :: [NewlyFreed] -> ShowS

newtype Dirty

Wrapper around PageId indicating it is a dirty page.

Constructors

Dirty PageId

Instances

Eq Dirty

Methods

(==) :: Dirty -> Dirty -> Bool

(/=) :: Dirty -> Dirty -> Bool

Ord Dirty

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

Methods

showsPrec :: Int -> Dirty -> ShowS

show :: Dirty -> String

showList :: [Dirty] -> ShowS

newtype DirtyFree

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

Constructors

DirtyFree PageId

Instances

Eq DirtyFree

Methods

(==) :: DirtyFree -> DirtyFree -> Bool

(/=) :: DirtyFree -> DirtyFree -> Bool

Ord DirtyFree

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

Methods

showsPrec :: Int -> DirtyFree -> ShowS

show :: DirtyFree -> String

showList :: [DirtyFree] -> ShowS

Binary DirtyFree

Methods

put :: DirtyFree -> Put

get :: Get DirtyFree

putList :: [DirtyFree] -> Put

newtype OldFree

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

Constructors

OldFree PageId

Instances

Eq OldFree

Methods

(==) :: OldFree -> OldFree -> Bool

(/=) :: OldFree -> OldFree -> Bool

Ord OldFree

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

Methods

showsPrec :: Int -> OldFree -> ShowS

show :: OldFree -> String

showList :: [OldFree] -> ShowS

newtype DirtyOldFree

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

Constructors

DirtyOldFree PageId

Instances

Eq DirtyOldFree

Methods

(==) :: DirtyOldFree -> DirtyOldFree -> Bool

(/=) :: DirtyOldFree -> DirtyOldFree -> Bool

Ord DirtyOldFree

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

Methods

showsPrec :: Int -> DirtyOldFree -> ShowS

show :: DirtyOldFree -> String

showList :: [DirtyOldFree] -> ShowS

data SomeFreePage

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

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

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

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

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)

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

Touch a fresh page, make it dirty.

We really need lenses...

newtype DirtyOverflow

Wrapper around OverflowId indicating that it is dirty.

Constructors

DirtyOverflow OverflowId

Instances

Eq DirtyOverflow

Methods

(==) :: DirtyOverflow -> DirtyOverflow -> Bool

(/=) :: DirtyOverflow -> DirtyOverflow -> Bool

Ord DirtyOverflow

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

Methods

showsPrec :: Int -> DirtyOverflow -> ShowS

show :: DirtyOverflow -> String

showList :: [DirtyOverflow] -> ShowS

newtype OldOverflow

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

Constructors

OldOverflow OverflowId

Instances

Eq OldOverflow

Methods

(==) :: OldOverflow -> OldOverflow -> Bool

(/=) :: OldOverflow -> OldOverflow -> Bool

Ord OldOverflow

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

Methods

showsPrec :: Int -> OldOverflow -> ShowS

show :: OldOverflow -> String

showList :: [OldOverflow] -> ShowS

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

Touch a fresh overflow page, making it dirty.

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

Get the type of the overflow page.

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

Free an old overflow page.