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.

• 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

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

Create a new writer.

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 FreePage

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

Constructors

FreePage PageId

Instances

Eq FreePage

Methods

(==) :: FreePage -> FreePage -> Bool

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

Ord FreePage

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

Methods

showsPrec :: Int -> FreePage -> ShowS

show :: FreePage -> String

showList :: [FreePage] -> ShowS

Binary FreePage

Methods

put :: FreePage -> Put

get :: Get FreePage

putList :: [FreePage] -> Put

newtype Dirty

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

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

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

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.

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