Safe Haskell	Safe-Inferred
Language	GHC2021

Database.LSMTree.Internal.Snapshot

Contents

Snapshot metadata
Levels snapshot format
MergeTree snapshot format
Conversion to levels snapshot format
Conversion to merging tree snapshot format
Write buffer
Run
Opening snapshot formats
- Levels format
- Merging Tree format
Hard links

Synopsis

newtype SnapshotLabel = SnapshotLabel Text
data SnapshotMetaData = SnapshotMetaData {
- snapMetaLabel :: !SnapshotLabel
- snapMetaConfig :: !TableConfig
- snapWriteBuffer :: !RunNumber
- snapMetaLevels :: !(SnapLevels SnapshotRun)
- snapMergingTree :: !(Maybe (SnapMergingTree SnapshotRun))
}
newtype SnapLevels r = SnapLevels {
- getSnapLevels :: Vector (SnapLevel r)
}
data SnapLevel r = SnapLevel {
- snapIncoming :: !(SnapIncomingRun r)
- snapResidentRuns :: !(Vector r)
}
data SnapIncomingRun r
- = SnapIncomingMergingRun !MergePolicyForLevel !NominalDebt !NominalCredits !(SnapMergingRun LevelMergeType r)
- | SnapIncomingSingleRun !r
data SnapMergingRun t r
- = SnapCompletedMerge !MergeDebt !r
- | SnapOngoingMerge !RunParams !MergeCredits !(Vector r) !t
newtype SnapMergingTree r = SnapMergingTree (SnapMergingTreeState r)
data SnapMergingTreeState r
- = SnapCompletedTreeMerge !r
- | SnapPendingTreeMerge !(SnapPendingMerge r)
- | SnapOngoingTreeMerge !(SnapMergingRun TreeMergeType r)
data SnapPendingMerge r
- = SnapPendingLevelMerge ![SnapPreExistingRun r] !(Maybe (SnapMergingTree r))
- | SnapPendingUnionMerge ![SnapMergingTree r]
data SnapPreExistingRun r
- = SnapPreExistingRun !r
- | SnapPreExistingMergingRun !(SnapMergingRun LevelMergeType r)
toSnapLevels :: (PrimMonad m, MonadMVar m) => Levels m h -> m (SnapLevels (Ref (Run m h)))
toSnapMergingTree :: (PrimMonad m, MonadMVar m) => Ref (MergingTree m h) -> m (SnapMergingTree (Ref (Run m h)))
snapshotWriteBuffer :: (MonadMVar m, MonadSTM m, MonadST m, MonadMask m) => HasFS m h -> HasBlockIO m h -> UniqCounter m -> UniqCounter m -> ActionRegistry m -> ActiveDir -> NamedSnapshotDir -> WriteBuffer -> Ref (WriteBufferBlobs m h) -> m WriteBufferFsPaths
openWriteBuffer :: (MonadMVar m, MonadMask m, MonadSTM m, MonadST m) => ActionRegistry m -> ResolveSerialisedValue -> HasFS m h -> HasBlockIO m h -> RefCtx -> UniqCounter m -> ActiveDir -> WriteBufferFsPaths -> m (WriteBuffer, Ref (WriteBufferBlobs m h))
data SnapshotRun = SnapshotRun {
- snapRunNumber :: !RunNumber
- snapRunCaching :: !RunDataCaching
- snapRunIndex :: !IndexType
}
snapshotRun :: (MonadMask m, PrimMonad m) => HasFS m h -> HasBlockIO m h -> UniqCounter m -> ActionRegistry m -> NamedSnapshotDir -> Ref (Run m h) -> m SnapshotRun
openRun :: (MonadMask m, MonadSTM m, MonadST m) => HasFS m h -> HasBlockIO m h -> RefCtx -> UniqCounter m -> ActionRegistry m -> NamedSnapshotDir -> ActiveDir -> Salt -> SnapshotRun -> m (Ref (Run m h))
fromSnapLevels :: forall m h. (MonadMask m, MonadMVar m, MonadSTM m, MonadST m) => HasFS m h -> HasBlockIO m h -> RefCtx -> Salt -> UniqCounter m -> TableConfig -> ResolveSerialisedValue -> ActionRegistry m -> ActiveDir -> SnapLevels (Ref (Run m h)) -> m (Levels m h)
fromSnapMergingTree :: forall m h. (MonadMask m, MonadMVar m, MonadSTM m, MonadST m) => HasFS m h -> HasBlockIO m h -> RefCtx -> Salt -> UniqCounter m -> ResolveSerialisedValue -> ActiveDir -> ActionRegistry m -> SnapMergingTree (Ref (Run m h)) -> m (Ref (MergingTree m h))
hardLinkRunFiles :: (MonadMask m, PrimMonad m) => HasFS m h -> HasBlockIO m h -> ActionRegistry m -> RunFsPaths -> RunFsPaths -> m ()

Snapshot metadata

newtype SnapshotLabel Source #

Custom, user-supplied text that is included in the metadata.

The main use case for a SnapshotLabel is for the user to supply textual information about the key/value/blob type for the table that corresponds to the snapshot. This information is used to dynamically check that a snapshot is opened at the correct key/value/blob type.

Constructors

SnapshotLabel Text

Instances

Instances details

IsString SnapshotLabel Source #
Instance details Defined in Database.LSMTree.Internal.Snapshot Methods fromString :: String -> SnapshotLabel #
Show SnapshotLabel Source #
Instance details Defined in Database.LSMTree.Internal.Snapshot Methods showsPrec :: Int -> SnapshotLabel -> ShowS # show :: SnapshotLabel -> String # showList :: [SnapshotLabel] -> ShowS #
NFData SnapshotLabel Source #
Instance details Defined in Database.LSMTree.Internal.Snapshot Methods rnf :: SnapshotLabel -> () #
Eq SnapshotLabel Source #
Instance details Defined in Database.LSMTree.Internal.Snapshot Methods (==) :: SnapshotLabel -> SnapshotLabel -> Bool # (/=) :: SnapshotLabel -> SnapshotLabel -> Bool #
DecodeVersioned SnapshotLabel Source #
Instance details Defined in Database.LSMTree.Internal.Snapshot.Codec Methods decodeVersioned :: SnapshotVersion -> Decoder s SnapshotLabel Source #
Encode SnapshotLabel Source #
Instance details Defined in Database.LSMTree.Internal.Snapshot.Codec Methods encode :: SnapshotLabel -> Encoding Source #

data SnapshotMetaData Source #

Constructors

SnapshotMetaData

Fields

snapMetaLabel :: !SnapshotLabel
See SnapshotLabel.
One could argue that the SnapshotName could be used to to hold this type information, but the file name of snapshot metadata is not guarded by a checksum, whereas the contents of the file are. Therefore using the SnapshotLabel is safer.
snapMetaConfig :: !TableConfig
The TableConfig for the snapshotted table.
snapWriteBuffer :: !RunNumber
The write buffer.
snapMetaLevels :: !(SnapLevels SnapshotRun)
The shape of the levels of the LSM tree.
snapMergingTree :: !(Maybe (SnapMergingTree SnapshotRun))
The state of tree merging of the LSM tree.

Instances

Instances details

NFData SnapshotMetaData Source #
Instance details Defined in Database.LSMTree.Internal.Snapshot Methods rnf :: SnapshotMetaData -> () #
Eq SnapshotMetaData Source #
Instance details Defined in Database.LSMTree.Internal.Snapshot Methods (==) :: SnapshotMetaData -> SnapshotMetaData -> Bool # (/=) :: SnapshotMetaData -> SnapshotMetaData -> Bool #
DecodeVersioned SnapshotMetaData Source #
Instance details Defined in Database.LSMTree.Internal.Snapshot.Codec Methods decodeVersioned :: SnapshotVersion -> Decoder s SnapshotMetaData Source #
Encode SnapshotMetaData Source #
Instance details Defined in Database.LSMTree.Internal.Snapshot.Codec Methods encode :: SnapshotMetaData -> Encoding Source #

Levels snapshot format

newtype SnapLevels r Source #

Constructors

SnapLevels
Fields getSnapLevels :: Vector (SnapLevel r)

Instances

Instances details

Foldable SnapLevels Source #
Instance details Defined in Database.LSMTree.Internal.Snapshot Methods fold :: Monoid m => SnapLevels m -> m # foldMap :: Monoid m => (a -> m) -> SnapLevels a -> m # foldMap' :: Monoid m => (a -> m) -> SnapLevels a -> m # foldr :: (a -> b -> b) -> b -> SnapLevels a -> b # foldr' :: (a -> b -> b) -> b -> SnapLevels a -> b # foldl :: (b -> a -> b) -> b -> SnapLevels a -> b # foldl' :: (b -> a -> b) -> b -> SnapLevels a -> b # foldr1 :: (a -> a -> a) -> SnapLevels a -> a # foldl1 :: (a -> a -> a) -> SnapLevels a -> a # toList :: SnapLevels a -> [a] # null :: SnapLevels a -> Bool # length :: SnapLevels a -> Int # elem :: Eq a => a -> SnapLevels a -> Bool # maximum :: Ord a => SnapLevels a -> a # minimum :: Ord a => SnapLevels a -> a # sum :: Num a => SnapLevels a -> a # product :: Num a => SnapLevels a -> a #
Traversable SnapLevels Source #
Instance details Defined in Database.LSMTree.Internal.Snapshot Methods traverse :: Applicative f => (a -> f b) -> SnapLevels a -> f (SnapLevels b) # sequenceA :: Applicative f => SnapLevels (f a) -> f (SnapLevels a) # mapM :: Monad m => (a -> m b) -> SnapLevels a -> m (SnapLevels b) # sequence :: Monad m => SnapLevels (m a) -> m (SnapLevels a) #
Functor SnapLevels Source #
Instance details Defined in Database.LSMTree.Internal.Snapshot Methods fmap :: (a -> b) -> SnapLevels a -> SnapLevels b # (<$) :: a -> SnapLevels b -> SnapLevels a #
NFData r => NFData (SnapLevels r) Source #
Instance details Defined in Database.LSMTree.Internal.Snapshot Methods rnf :: SnapLevels r -> () #
Eq r => Eq (SnapLevels r) Source #
Instance details Defined in Database.LSMTree.Internal.Snapshot Methods (==) :: SnapLevels r -> SnapLevels r -> Bool # (/=) :: SnapLevels r -> SnapLevels r -> Bool #
DecodeVersioned r => DecodeVersioned (SnapLevels r) Source #
Instance details Defined in Database.LSMTree.Internal.Snapshot.Codec Methods decodeVersioned :: SnapshotVersion -> Decoder s (SnapLevels r) Source #
Encode r => Encode (SnapLevels r) Source #
Instance details Defined in Database.LSMTree.Internal.Snapshot.Codec Methods encode :: SnapLevels r -> Encoding Source #

data SnapLevel r Source #

Constructors

SnapLevel
Fields snapIncoming :: !(SnapIncomingRun r) snapResidentRuns :: !(Vector r)

Instances

Instances details

Foldable SnapLevel Source #
Instance details Defined in Database.LSMTree.Internal.Snapshot Methods fold :: Monoid m => SnapLevel m -> m # foldMap :: Monoid m => (a -> m) -> SnapLevel a -> m # foldMap' :: Monoid m => (a -> m) -> SnapLevel a -> m # foldr :: (a -> b -> b) -> b -> SnapLevel a -> b # foldr' :: (a -> b -> b) -> b -> SnapLevel a -> b # foldl :: (b -> a -> b) -> b -> SnapLevel a -> b # foldl' :: (b -> a -> b) -> b -> SnapLevel a -> b # foldr1 :: (a -> a -> a) -> SnapLevel a -> a # foldl1 :: (a -> a -> a) -> SnapLevel a -> a # toList :: SnapLevel a -> [a] # null :: SnapLevel a -> Bool # length :: SnapLevel a -> Int # elem :: Eq a => a -> SnapLevel a -> Bool # maximum :: Ord a => SnapLevel a -> a # minimum :: Ord a => SnapLevel a -> a # sum :: Num a => SnapLevel a -> a # product :: Num a => SnapLevel a -> a #
Traversable SnapLevel Source #
Instance details Defined in Database.LSMTree.Internal.Snapshot Methods traverse :: Applicative f => (a -> f b) -> SnapLevel a -> f (SnapLevel b) # sequenceA :: Applicative f => SnapLevel (f a) -> f (SnapLevel a) # mapM :: Monad m => (a -> m b) -> SnapLevel a -> m (SnapLevel b) # sequence :: Monad m => SnapLevel (m a) -> m (SnapLevel a) #
Functor SnapLevel Source #
Instance details Defined in Database.LSMTree.Internal.Snapshot Methods fmap :: (a -> b) -> SnapLevel a -> SnapLevel b # (<$) :: a -> SnapLevel b -> SnapLevel a #
NFData r => NFData (SnapLevel r) Source #
Instance details Defined in Database.LSMTree.Internal.Snapshot Methods rnf :: SnapLevel r -> () #
Eq r => Eq (SnapLevel r) Source #
Instance details Defined in Database.LSMTree.Internal.Snapshot Methods (==) :: SnapLevel r -> SnapLevel r -> Bool # (/=) :: SnapLevel r -> SnapLevel r -> Bool #
DecodeVersioned r => DecodeVersioned (SnapLevel r) Source #
Instance details Defined in Database.LSMTree.Internal.Snapshot.Codec Methods decodeVersioned :: SnapshotVersion -> Decoder s (SnapLevel r) Source #
Encode r => Encode (SnapLevel r) Source #
Instance details Defined in Database.LSMTree.Internal.Snapshot.Codec Methods encode :: SnapLevel r -> Encoding Source #

data SnapIncomingRun r Source #

Note that for snapshots of incoming runs, we store only the merge debt and nominal credits, not the nominal debt or the merge credits. The rationale is a bit subtle.

The nominal debt does not need to be stored because it can be derived based on the table's write buffer capacity (which is stored in the snapshot's TableConfig), and on the level number that the merge is at (which also known from the snapshot structure).

The merge credits can be recalculated from the combination of the nominal debt, nominal credits and merge debt.

The merge debt is always the sum of the size of the input runs, so at first glance this seems redundant. However for completed merges we no longer have the input runs, so we must store the merge debt if we are to perfectly round trip the snapshot. This is a nice simple property to have though it is probably not 100% essential. We could weaken the round trip property to allow forgetting the merge debt and credit of completed merges (and set them both to zero).

Constructors

SnapIncomingMergingRun
Fields !MergePolicyForLevel !NominalDebt !NominalCredits The nominal credits supplied, and that need to be supplied on snapshot open. !(SnapMergingRun LevelMergeType r)
SnapIncomingSingleRun !r

Instances

Instances details

Foldable SnapIncomingRun Source #
Instance details Defined in Database.LSMTree.Internal.Snapshot Methods fold :: Monoid m => SnapIncomingRun m -> m # foldMap :: Monoid m => (a -> m) -> SnapIncomingRun a -> m # foldMap' :: Monoid m => (a -> m) -> SnapIncomingRun a -> m # foldr :: (a -> b -> b) -> b -> SnapIncomingRun a -> b # foldr' :: (a -> b -> b) -> b -> SnapIncomingRun a -> b # foldl :: (b -> a -> b) -> b -> SnapIncomingRun a -> b # foldl' :: (b -> a -> b) -> b -> SnapIncomingRun a -> b # foldr1 :: (a -> a -> a) -> SnapIncomingRun a -> a # foldl1 :: (a -> a -> a) -> SnapIncomingRun a -> a # toList :: SnapIncomingRun a -> [a] # null :: SnapIncomingRun a -> Bool # length :: SnapIncomingRun a -> Int # elem :: Eq a => a -> SnapIncomingRun a -> Bool # maximum :: Ord a => SnapIncomingRun a -> a # minimum :: Ord a => SnapIncomingRun a -> a # sum :: Num a => SnapIncomingRun a -> a # product :: Num a => SnapIncomingRun a -> a #
Traversable SnapIncomingRun Source #
Instance details Defined in Database.LSMTree.Internal.Snapshot Methods traverse :: Applicative f => (a -> f b) -> SnapIncomingRun a -> f (SnapIncomingRun b) # sequenceA :: Applicative f => SnapIncomingRun (f a) -> f (SnapIncomingRun a) # mapM :: Monad m => (a -> m b) -> SnapIncomingRun a -> m (SnapIncomingRun b) # sequence :: Monad m => SnapIncomingRun (m a) -> m (SnapIncomingRun a) #
Functor SnapIncomingRun Source #
Instance details Defined in Database.LSMTree.Internal.Snapshot Methods fmap :: (a -> b) -> SnapIncomingRun a -> SnapIncomingRun b # (<$) :: a -> SnapIncomingRun b -> SnapIncomingRun a #
NFData r => NFData (SnapIncomingRun r) Source #
Instance details Defined in Database.LSMTree.Internal.Snapshot Methods rnf :: SnapIncomingRun r -> () #
Eq r => Eq (SnapIncomingRun r) Source #
Instance details Defined in Database.LSMTree.Internal.Snapshot Methods (==) :: SnapIncomingRun r -> SnapIncomingRun r -> Bool # (/=) :: SnapIncomingRun r -> SnapIncomingRun r -> Bool #
DecodeVersioned r => DecodeVersioned (SnapIncomingRun r) Source #
Instance details Defined in Database.LSMTree.Internal.Snapshot.Codec Methods decodeVersioned :: SnapshotVersion -> Decoder s (SnapIncomingRun r) Source #
Encode r => Encode (SnapIncomingRun r) Source #
Instance details Defined in Database.LSMTree.Internal.Snapshot.Codec Methods encode :: SnapIncomingRun r -> Encoding Source #

data SnapMergingRun t r Source #

Constructors

SnapCompletedMerge !MergeDebt !r
SnapOngoingMerge !RunParams !MergeCredits !(Vector r) !t

Instances

Instances details

Foldable (SnapMergingRun t) Source #
Instance details Defined in Database.LSMTree.Internal.Snapshot Methods fold :: Monoid m => SnapMergingRun t m -> m # foldMap :: Monoid m => (a -> m) -> SnapMergingRun t a -> m # foldMap' :: Monoid m => (a -> m) -> SnapMergingRun t a -> m # foldr :: (a -> b -> b) -> b -> SnapMergingRun t a -> b # foldr' :: (a -> b -> b) -> b -> SnapMergingRun t a -> b # foldl :: (b -> a -> b) -> b -> SnapMergingRun t a -> b # foldl' :: (b -> a -> b) -> b -> SnapMergingRun t a -> b # foldr1 :: (a -> a -> a) -> SnapMergingRun t a -> a # foldl1 :: (a -> a -> a) -> SnapMergingRun t a -> a # toList :: SnapMergingRun t a -> [a] # null :: SnapMergingRun t a -> Bool # length :: SnapMergingRun t a -> Int # elem :: Eq a => a -> SnapMergingRun t a -> Bool # maximum :: Ord a => SnapMergingRun t a -> a # minimum :: Ord a => SnapMergingRun t a -> a # sum :: Num a => SnapMergingRun t a -> a # product :: Num a => SnapMergingRun t a -> a #
Traversable (SnapMergingRun t) Source #
Instance details Defined in Database.LSMTree.Internal.Snapshot Methods traverse :: Applicative f => (a -> f b) -> SnapMergingRun t a -> f (SnapMergingRun t b) # sequenceA :: Applicative f => SnapMergingRun t (f a) -> f (SnapMergingRun t a) # mapM :: Monad m => (a -> m b) -> SnapMergingRun t a -> m (SnapMergingRun t b) # sequence :: Monad m => SnapMergingRun t (m a) -> m (SnapMergingRun t a) #
Functor (SnapMergingRun t) Source #
Instance details Defined in Database.LSMTree.Internal.Snapshot Methods fmap :: (a -> b) -> SnapMergingRun t a -> SnapMergingRun t b # (<$) :: a -> SnapMergingRun t b -> SnapMergingRun t a #
(NFData t, NFData r) => NFData (SnapMergingRun t r) Source #
Instance details Defined in Database.LSMTree.Internal.Snapshot Methods rnf :: SnapMergingRun t r -> () #
(Eq r, Eq t) => Eq (SnapMergingRun t r) Source #
Instance details Defined in Database.LSMTree.Internal.Snapshot Methods (==) :: SnapMergingRun t r -> SnapMergingRun t r -> Bool # (/=) :: SnapMergingRun t r -> SnapMergingRun t r -> Bool #
(DecodeVersioned t, DecodeVersioned r) => DecodeVersioned (SnapMergingRun t r) Source #
Instance details Defined in Database.LSMTree.Internal.Snapshot.Codec Methods decodeVersioned :: SnapshotVersion -> Decoder s (SnapMergingRun t r) Source #
(Encode t, Encode r) => Encode (SnapMergingRun t r) Source #
Instance details Defined in Database.LSMTree.Internal.Snapshot.Codec Methods encode :: SnapMergingRun t r -> Encoding Source #

MergeTree snapshot format

newtype SnapMergingTree r Source #

Constructors

SnapMergingTree (SnapMergingTreeState r)

Instances

Instances details

Foldable SnapMergingTree Source #
Instance details Defined in Database.LSMTree.Internal.Snapshot Methods fold :: Monoid m => SnapMergingTree m -> m # foldMap :: Monoid m => (a -> m) -> SnapMergingTree a -> m # foldMap' :: Monoid m => (a -> m) -> SnapMergingTree a -> m # foldr :: (a -> b -> b) -> b -> SnapMergingTree a -> b # foldr' :: (a -> b -> b) -> b -> SnapMergingTree a -> b # foldl :: (b -> a -> b) -> b -> SnapMergingTree a -> b # foldl' :: (b -> a -> b) -> b -> SnapMergingTree a -> b # foldr1 :: (a -> a -> a) -> SnapMergingTree a -> a # foldl1 :: (a -> a -> a) -> SnapMergingTree a -> a # toList :: SnapMergingTree a -> [a] # null :: SnapMergingTree a -> Bool # length :: SnapMergingTree a -> Int # elem :: Eq a => a -> SnapMergingTree a -> Bool # maximum :: Ord a => SnapMergingTree a -> a # minimum :: Ord a => SnapMergingTree a -> a # sum :: Num a => SnapMergingTree a -> a # product :: Num a => SnapMergingTree a -> a #
Traversable SnapMergingTree Source #
Instance details Defined in Database.LSMTree.Internal.Snapshot Methods traverse :: Applicative f => (a -> f b) -> SnapMergingTree a -> f (SnapMergingTree b) # sequenceA :: Applicative f => SnapMergingTree (f a) -> f (SnapMergingTree a) # mapM :: Monad m => (a -> m b) -> SnapMergingTree a -> m (SnapMergingTree b) # sequence :: Monad m => SnapMergingTree (m a) -> m (SnapMergingTree a) #
Functor SnapMergingTree Source #
Instance details Defined in Database.LSMTree.Internal.Snapshot Methods fmap :: (a -> b) -> SnapMergingTree a -> SnapMergingTree b # (<$) :: a -> SnapMergingTree b -> SnapMergingTree a #
NFData r => NFData (SnapMergingTree r) Source #
Instance details Defined in Database.LSMTree.Internal.Snapshot Methods rnf :: SnapMergingTree r -> () #
Eq r => Eq (SnapMergingTree r) Source #
Instance details Defined in Database.LSMTree.Internal.Snapshot Methods (==) :: SnapMergingTree r -> SnapMergingTree r -> Bool # (/=) :: SnapMergingTree r -> SnapMergingTree r -> Bool #
DecodeVersioned r => DecodeVersioned (SnapMergingTree r) Source #
Instance details Defined in Database.LSMTree.Internal.Snapshot.Codec Methods decodeVersioned :: SnapshotVersion -> Decoder s (SnapMergingTree r) Source #
Encode r => Encode (SnapMergingTree r) Source #
Instance details Defined in Database.LSMTree.Internal.Snapshot.Codec Methods encode :: SnapMergingTree r -> Encoding Source #

data SnapMergingTreeState r Source #

Constructors

SnapCompletedTreeMerge !r
SnapPendingTreeMerge !(SnapPendingMerge r)
SnapOngoingTreeMerge !(SnapMergingRun TreeMergeType r)

Instances

Instances details

Foldable SnapMergingTreeState Source #
Instance details Defined in Database.LSMTree.Internal.Snapshot Methods fold :: Monoid m => SnapMergingTreeState m -> m # foldMap :: Monoid m => (a -> m) -> SnapMergingTreeState a -> m # foldMap' :: Monoid m => (a -> m) -> SnapMergingTreeState a -> m # foldr :: (a -> b -> b) -> b -> SnapMergingTreeState a -> b # foldr' :: (a -> b -> b) -> b -> SnapMergingTreeState a -> b # foldl :: (b -> a -> b) -> b -> SnapMergingTreeState a -> b # foldl' :: (b -> a -> b) -> b -> SnapMergingTreeState a -> b # foldr1 :: (a -> a -> a) -> SnapMergingTreeState a -> a # foldl1 :: (a -> a -> a) -> SnapMergingTreeState a -> a # toList :: SnapMergingTreeState a -> [a] # null :: SnapMergingTreeState a -> Bool # length :: SnapMergingTreeState a -> Int # elem :: Eq a => a -> SnapMergingTreeState a -> Bool # maximum :: Ord a => SnapMergingTreeState a -> a # minimum :: Ord a => SnapMergingTreeState a -> a # sum :: Num a => SnapMergingTreeState a -> a # product :: Num a => SnapMergingTreeState a -> a #
Traversable SnapMergingTreeState Source #
Instance details Defined in Database.LSMTree.Internal.Snapshot Methods traverse :: Applicative f => (a -> f b) -> SnapMergingTreeState a -> f (SnapMergingTreeState b) # sequenceA :: Applicative f => SnapMergingTreeState (f a) -> f (SnapMergingTreeState a) # mapM :: Monad m => (a -> m b) -> SnapMergingTreeState a -> m (SnapMergingTreeState b) # sequence :: Monad m => SnapMergingTreeState (m a) -> m (SnapMergingTreeState a) #
Functor SnapMergingTreeState Source #
Instance details Defined in Database.LSMTree.Internal.Snapshot Methods fmap :: (a -> b) -> SnapMergingTreeState a -> SnapMergingTreeState b # (<$) :: a -> SnapMergingTreeState b -> SnapMergingTreeState a #
NFData r => NFData (SnapMergingTreeState r) Source #
Instance details Defined in Database.LSMTree.Internal.Snapshot Methods rnf :: SnapMergingTreeState r -> () #
Eq r => Eq (SnapMergingTreeState r) Source #
Instance details Defined in Database.LSMTree.Internal.Snapshot Methods (==) :: SnapMergingTreeState r -> SnapMergingTreeState r -> Bool # (/=) :: SnapMergingTreeState r -> SnapMergingTreeState r -> Bool #
DecodeVersioned r => DecodeVersioned (SnapMergingTreeState r) Source #
Instance details Defined in Database.LSMTree.Internal.Snapshot.Codec Methods decodeVersioned :: SnapshotVersion -> Decoder s (SnapMergingTreeState r) Source #
Encode r => Encode (SnapMergingTreeState r) Source #
Instance details Defined in Database.LSMTree.Internal.Snapshot.Codec Methods encode :: SnapMergingTreeState r -> Encoding Source #

data SnapPendingMerge r Source #

Constructors

SnapPendingLevelMerge ![SnapPreExistingRun r] !(Maybe (SnapMergingTree r))
SnapPendingUnionMerge ![SnapMergingTree r]

Instances

Instances details

Foldable SnapPendingMerge Source #
Instance details Defined in Database.LSMTree.Internal.Snapshot Methods fold :: Monoid m => SnapPendingMerge m -> m # foldMap :: Monoid m => (a -> m) -> SnapPendingMerge a -> m # foldMap' :: Monoid m => (a -> m) -> SnapPendingMerge a -> m # foldr :: (a -> b -> b) -> b -> SnapPendingMerge a -> b # foldr' :: (a -> b -> b) -> b -> SnapPendingMerge a -> b # foldl :: (b -> a -> b) -> b -> SnapPendingMerge a -> b # foldl' :: (b -> a -> b) -> b -> SnapPendingMerge a -> b # foldr1 :: (a -> a -> a) -> SnapPendingMerge a -> a # foldl1 :: (a -> a -> a) -> SnapPendingMerge a -> a # toList :: SnapPendingMerge a -> [a] # null :: SnapPendingMerge a -> Bool # length :: SnapPendingMerge a -> Int # elem :: Eq a => a -> SnapPendingMerge a -> Bool # maximum :: Ord a => SnapPendingMerge a -> a # minimum :: Ord a => SnapPendingMerge a -> a # sum :: Num a => SnapPendingMerge a -> a # product :: Num a => SnapPendingMerge a -> a #
Traversable SnapPendingMerge Source #
Instance details Defined in Database.LSMTree.Internal.Snapshot Methods traverse :: Applicative f => (a -> f b) -> SnapPendingMerge a -> f (SnapPendingMerge b) # sequenceA :: Applicative f => SnapPendingMerge (f a) -> f (SnapPendingMerge a) # mapM :: Monad m => (a -> m b) -> SnapPendingMerge a -> m (SnapPendingMerge b) # sequence :: Monad m => SnapPendingMerge (m a) -> m (SnapPendingMerge a) #
Functor SnapPendingMerge Source #
Instance details Defined in Database.LSMTree.Internal.Snapshot Methods fmap :: (a -> b) -> SnapPendingMerge a -> SnapPendingMerge b # (<$) :: a -> SnapPendingMerge b -> SnapPendingMerge a #
NFData r => NFData (SnapPendingMerge r) Source #
Instance details Defined in Database.LSMTree.Internal.Snapshot Methods rnf :: SnapPendingMerge r -> () #
Eq r => Eq (SnapPendingMerge r) Source #
Instance details Defined in Database.LSMTree.Internal.Snapshot Methods (==) :: SnapPendingMerge r -> SnapPendingMerge r -> Bool # (/=) :: SnapPendingMerge r -> SnapPendingMerge r -> Bool #
DecodeVersioned r => DecodeVersioned (SnapPendingMerge r) Source #
Instance details Defined in Database.LSMTree.Internal.Snapshot.Codec Methods decodeVersioned :: SnapshotVersion -> Decoder s (SnapPendingMerge r) Source #
Encode r => Encode (SnapPendingMerge r) Source #
Instance details Defined in Database.LSMTree.Internal.Snapshot.Codec Methods encode :: SnapPendingMerge r -> Encoding Source #

data SnapPreExistingRun r Source #

Constructors

SnapPreExistingRun !r
SnapPreExistingMergingRun !(SnapMergingRun LevelMergeType r)

Instances

Instances details

Foldable SnapPreExistingRun Source #
Instance details Defined in Database.LSMTree.Internal.Snapshot Methods fold :: Monoid m => SnapPreExistingRun m -> m # foldMap :: Monoid m => (a -> m) -> SnapPreExistingRun a -> m # foldMap' :: Monoid m => (a -> m) -> SnapPreExistingRun a -> m # foldr :: (a -> b -> b) -> b -> SnapPreExistingRun a -> b # foldr' :: (a -> b -> b) -> b -> SnapPreExistingRun a -> b # foldl :: (b -> a -> b) -> b -> SnapPreExistingRun a -> b # foldl' :: (b -> a -> b) -> b -> SnapPreExistingRun a -> b # foldr1 :: (a -> a -> a) -> SnapPreExistingRun a -> a # foldl1 :: (a -> a -> a) -> SnapPreExistingRun a -> a # toList :: SnapPreExistingRun a -> [a] # null :: SnapPreExistingRun a -> Bool # length :: SnapPreExistingRun a -> Int # elem :: Eq a => a -> SnapPreExistingRun a -> Bool # maximum :: Ord a => SnapPreExistingRun a -> a # minimum :: Ord a => SnapPreExistingRun a -> a # sum :: Num a => SnapPreExistingRun a -> a # product :: Num a => SnapPreExistingRun a -> a #
Traversable SnapPreExistingRun Source #
Instance details Defined in Database.LSMTree.Internal.Snapshot Methods traverse :: Applicative f => (a -> f b) -> SnapPreExistingRun a -> f (SnapPreExistingRun b) # sequenceA :: Applicative f => SnapPreExistingRun (f a) -> f (SnapPreExistingRun a) # mapM :: Monad m => (a -> m b) -> SnapPreExistingRun a -> m (SnapPreExistingRun b) # sequence :: Monad m => SnapPreExistingRun (m a) -> m (SnapPreExistingRun a) #
Functor SnapPreExistingRun Source #
Instance details Defined in Database.LSMTree.Internal.Snapshot Methods fmap :: (a -> b) -> SnapPreExistingRun a -> SnapPreExistingRun b # (<$) :: a -> SnapPreExistingRun b -> SnapPreExistingRun a #
NFData r => NFData (SnapPreExistingRun r) Source #
Instance details Defined in Database.LSMTree.Internal.Snapshot Methods rnf :: SnapPreExistingRun r -> () #
Eq r => Eq (SnapPreExistingRun r) Source #
Instance details Defined in Database.LSMTree.Internal.Snapshot Methods (==) :: SnapPreExistingRun r -> SnapPreExistingRun r -> Bool # (/=) :: SnapPreExistingRun r -> SnapPreExistingRun r -> Bool #
DecodeVersioned r => DecodeVersioned (SnapPreExistingRun r) Source #
Instance details Defined in Database.LSMTree.Internal.Snapshot.Codec Methods decodeVersioned :: SnapshotVersion -> Decoder s (SnapPreExistingRun r) Source #
Encode r => Encode (SnapPreExistingRun r) Source #
Instance details Defined in Database.LSMTree.Internal.Snapshot.Codec Methods encode :: SnapPreExistingRun r -> Encoding Source #

Conversion to levels snapshot format

toSnapLevels :: (PrimMonad m, MonadMVar m) => Levels m h -> m (SnapLevels (Ref (Run m h))) Source #

Conversion to merging tree snapshot format

toSnapMergingTree :: (PrimMonad m, MonadMVar m) => Ref (MergingTree m h) -> m (SnapMergingTree (Ref (Run m h))) Source #

Write buffer

snapshotWriteBuffer :: (MonadMVar m, MonadSTM m, MonadST m, MonadMask m) => HasFS m h -> HasBlockIO m h -> UniqCounter m -> UniqCounter m -> ActionRegistry m -> ActiveDir -> NamedSnapshotDir -> WriteBuffer -> Ref (WriteBufferBlobs m h) -> m WriteBufferFsPaths Source #

openWriteBuffer :: (MonadMVar m, MonadMask m, MonadSTM m, MonadST m) => ActionRegistry m -> ResolveSerialisedValue -> HasFS m h -> HasBlockIO m h -> RefCtx -> UniqCounter m -> ActiveDir -> WriteBufferFsPaths -> m (WriteBuffer, Ref (WriteBufferBlobs m h)) Source #

Run

data SnapshotRun Source #

Information needed to open a Run from disk using snapshotRun and openRun.

TODO: one could imagine needing only the RunNumber to identify the files on disk, and the other parameters being stored with the run itself, rather than needing to be supplied.

Constructors

SnapshotRun
Fields snapRunNumber :: !RunNumber snapRunCaching :: !RunDataCaching snapRunIndex :: !IndexType

Instances

Instances details

NFData SnapshotRun Source #
Instance details Defined in Database.LSMTree.Internal.Snapshot Methods rnf :: SnapshotRun -> () #
Eq SnapshotRun Source #
Instance details Defined in Database.LSMTree.Internal.Snapshot Methods (==) :: SnapshotRun -> SnapshotRun -> Bool # (/=) :: SnapshotRun -> SnapshotRun -> Bool #
DecodeVersioned SnapshotRun Source #
Instance details Defined in Database.LSMTree.Internal.Snapshot.Codec Methods decodeVersioned :: SnapshotVersion -> Decoder s SnapshotRun Source #
Encode SnapshotRun Source #
Instance details Defined in Database.LSMTree.Internal.Snapshot.Codec Methods encode :: SnapshotRun -> Encoding Source #

snapshotRun :: (MonadMask m, PrimMonad m) => HasFS m h -> HasBlockIO m h -> UniqCounter m -> ActionRegistry m -> NamedSnapshotDir -> Ref (Run m h) -> m SnapshotRun Source #

snapshotRun _ _ snapUc _ targetDir run creates hard links for all files associated with the run, and puts the new directory entries in the targetDir directory. The entries are renamed using snapUc.

openRun :: (MonadMask m, MonadSTM m, MonadST m) => HasFS m h -> HasBlockIO m h -> RefCtx -> UniqCounter m -> ActionRegistry m -> NamedSnapshotDir -> ActiveDir -> Salt -> SnapshotRun -> m (Ref (Run m h)) Source #

openRun _ _ uniqCounter _ sourceDir targetDir _ snaprun takes all run files that are referenced by snaprun, and hard links them from sourceDir into targetDir with new, unique names (using uniqCounter). Each set of (hard linked) files that represents a run is opened and verified, returning Run as a result.

The result must ultimately be released using releaseRef.

Opening snapshot formats

Levels format

fromSnapLevels :: forall m h. (MonadMask m, MonadMVar m, MonadSTM m, MonadST m) => HasFS m h -> HasBlockIO m h -> RefCtx -> Salt -> UniqCounter m -> TableConfig -> ResolveSerialisedValue -> ActionRegistry m -> ActiveDir -> SnapLevels (Ref (Run m h)) -> m (Levels m h) Source #

Duplicates runs and re-creates merging runs.

Merging Tree format

fromSnapMergingTree :: forall m h. (MonadMask m, MonadMVar m, MonadSTM m, MonadST m) => HasFS m h -> HasBlockIO m h -> RefCtx -> Salt -> UniqCounter m -> ResolveSerialisedValue -> ActiveDir -> ActionRegistry m -> SnapMergingTree (Ref (Run m h)) -> m (Ref (MergingTree m h)) Source #

Converts a snapshot of a merging tree of runs to a real merging tree.

Returns a new reference. Input runs remain owned by the caller.

Hard links

hardLinkRunFiles :: (MonadMask m, PrimMonad m) => HasFS m h -> HasBlockIO m h -> ActionRegistry m -> RunFsPaths -> RunFsPaths -> m () Source #

hardLinkRunFiles _ _ _ sourcePaths targetPaths creates a hard link for each sourcePaths path using the corresponding targetPaths path as the name for the new directory entry.