module Database.LSMTree.Extras.ReferenceImpl (
    -- * Page types
    Key (..),
    Value (..),
    Operation (..),
    BlobRef (..),
    PageSerialised,
    PageIntermediate,

    -- * Page size
    PageSize (..),
    pageSizeEmpty,
    pageSizeAddElem,

    -- * Encoding and decoding
    DiskPageSize(..),
    encodePage,
    decodePage,
    serialisePage,
    deserialisePage,

    -- * Overflow pages
    pageOverflowPrefixSuffixLen,
    pageDiskPages,
    pageSerialisedChunks,

    -- * Conversions to real implementation types
    toRawPage,
    toRawPageMaybeOverfull,
    toEntry,
    toEntryPrefix,
    toSerialisedKey,
    toSerialisedValue,
    toBlobSpan,

    -- * Conversions from real implementation types
    fromRawPage,
    fromEntry,
    fromEntryPrefix,
    fromSerialisedKey,
    fromSerialisedValue,
    fromSerialisedValuePrefix,
    fromRawOverflowPages,
    fromBlobSpan,

    -- * Test case types and generators
    PageContentFits(..),
    pageContentFitsInvariant,
    PageContentOrdered(..),
    pageContentOrderedInvariant,
    PageContentMaybeOverfull(..),
    PageContentSingle(..),

    -- ** Generators and shrinkers
    genPageContentFits,
    genPageContentMaybeOverfull,
    genPageContentSingle,
    genPageContentNearFull,
    genPageContentMedium,
    MinKeySize(..),
    noMinKeySize,
    orderdKeyOps,
    shrinkKeyOps,
    shrinkOrderedKeyOps,
) where

import qualified Data.ByteString as BS
import qualified Data.ByteString.Short as SBS
import           Data.Maybe (fromMaybe, isJust)
import           Data.Primitive.ByteArray (ByteArray (..))

import           Database.LSMTree.Internal.BlobRef (BlobSpan (..))
import           Database.LSMTree.Internal.Entry (Entry)
import qualified Database.LSMTree.Internal.Entry as Entry
import qualified Database.LSMTree.Internal.RawBytes as RB
import           Database.LSMTree.Internal.RawOverflowPage
import           Database.LSMTree.Internal.RawPage
import           Database.LSMTree.Internal.Serialise
import           FormatPage

import           Test.QuickCheck

-- | A test case consisting of a key\/operation sequence that is guaranteed to
-- either fit into a single 4k disk page, or be a single entry that spans a
-- one primary 4k disk page and zero or more overflow disk pages.
--
-- The keys /are not/ ordered.
--
newtype PageContentFits = PageContentFits [(Key, Operation)]
  deriving stock (PageContentFits -> PageContentFits -> Bool
(PageContentFits -> PageContentFits -> Bool)
-> (PageContentFits -> PageContentFits -> Bool)
-> Eq PageContentFits
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PageContentFits -> PageContentFits -> Bool
== :: PageContentFits -> PageContentFits -> Bool
$c/= :: PageContentFits -> PageContentFits -> Bool
/= :: PageContentFits -> PageContentFits -> Bool
Eq, Int -> PageContentFits -> ShowS
[PageContentFits] -> ShowS
PageContentFits -> String
(Int -> PageContentFits -> ShowS)
-> (PageContentFits -> String)
-> ([PageContentFits] -> ShowS)
-> Show PageContentFits
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PageContentFits -> ShowS
showsPrec :: Int -> PageContentFits -> ShowS
$cshow :: PageContentFits -> String
show :: PageContentFits -> String
$cshowList :: [PageContentFits] -> ShowS
showList :: [PageContentFits] -> ShowS
Show)

-- | A test case consisting of a key\/operation sequence that is guaranteed to
-- either fit into a single 4k disk page, or be a single entry that spans a
-- one primary 4k disk page and zero or more overflow disk pages.
--
-- The keys /are/ in strictly ascending order.
--
newtype PageContentOrdered = PageContentOrdered [(Key, Operation)]
  deriving stock (PageContentOrdered -> PageContentOrdered -> Bool
(PageContentOrdered -> PageContentOrdered -> Bool)
-> (PageContentOrdered -> PageContentOrdered -> Bool)
-> Eq PageContentOrdered
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PageContentOrdered -> PageContentOrdered -> Bool
== :: PageContentOrdered -> PageContentOrdered -> Bool
$c/= :: PageContentOrdered -> PageContentOrdered -> Bool
/= :: PageContentOrdered -> PageContentOrdered -> Bool
Eq, Int -> PageContentOrdered -> ShowS
[PageContentOrdered] -> ShowS
PageContentOrdered -> String
(Int -> PageContentOrdered -> ShowS)
-> (PageContentOrdered -> String)
-> ([PageContentOrdered] -> ShowS)
-> Show PageContentOrdered
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PageContentOrdered -> ShowS
showsPrec :: Int -> PageContentOrdered -> ShowS
$cshow :: PageContentOrdered -> String
show :: PageContentOrdered -> String
$cshowList :: [PageContentOrdered] -> ShowS
showList :: [PageContentOrdered] -> ShowS
Show)

-- | A test case consisting of a key\/operation sequence that is /not/
-- guaranteed to fit into a a 4k disk page.
--
-- These test cases are useful for checking the boundary conditions for what
-- can fit into a disk page.
--
-- The keys /are not/ ordered.
--
newtype PageContentMaybeOverfull = PageContentMaybeOverfull [(Key, Operation)]
  deriving stock (PageContentMaybeOverfull -> PageContentMaybeOverfull -> Bool
(PageContentMaybeOverfull -> PageContentMaybeOverfull -> Bool)
-> (PageContentMaybeOverfull -> PageContentMaybeOverfull -> Bool)
-> Eq PageContentMaybeOverfull
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PageContentMaybeOverfull -> PageContentMaybeOverfull -> Bool
== :: PageContentMaybeOverfull -> PageContentMaybeOverfull -> Bool
$c/= :: PageContentMaybeOverfull -> PageContentMaybeOverfull -> Bool
/= :: PageContentMaybeOverfull -> PageContentMaybeOverfull -> Bool
Eq, Int -> PageContentMaybeOverfull -> ShowS
[PageContentMaybeOverfull] -> ShowS
PageContentMaybeOverfull -> String
(Int -> PageContentMaybeOverfull -> ShowS)
-> (PageContentMaybeOverfull -> String)
-> ([PageContentMaybeOverfull] -> ShowS)
-> Show PageContentMaybeOverfull
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PageContentMaybeOverfull -> ShowS
showsPrec :: Int -> PageContentMaybeOverfull -> ShowS
$cshow :: PageContentMaybeOverfull -> String
show :: PageContentMaybeOverfull -> String
$cshowList :: [PageContentMaybeOverfull] -> ShowS
showList :: [PageContentMaybeOverfull] -> ShowS
Show)

-- | A tests case consisting of a single key\/operation pair.
--
data PageContentSingle = PageContentSingle Key Operation
  deriving stock (PageContentSingle -> PageContentSingle -> Bool
(PageContentSingle -> PageContentSingle -> Bool)
-> (PageContentSingle -> PageContentSingle -> Bool)
-> Eq PageContentSingle
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PageContentSingle -> PageContentSingle -> Bool
== :: PageContentSingle -> PageContentSingle -> Bool
$c/= :: PageContentSingle -> PageContentSingle -> Bool
/= :: PageContentSingle -> PageContentSingle -> Bool
Eq, Int -> PageContentSingle -> ShowS
[PageContentSingle] -> ShowS
PageContentSingle -> String
(Int -> PageContentSingle -> ShowS)
-> (PageContentSingle -> String)
-> ([PageContentSingle] -> ShowS)
-> Show PageContentSingle
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PageContentSingle -> ShowS
showsPrec :: Int -> PageContentSingle -> ShowS
$cshow :: PageContentSingle -> String
show :: PageContentSingle -> String
$cshowList :: [PageContentSingle] -> ShowS
showList :: [PageContentSingle] -> ShowS
Show)

instance Arbitrary PageContentFits where
    arbitrary :: Gen PageContentFits
arbitrary =
      [(Key, Operation)] -> PageContentFits
PageContentFits ([(Key, Operation)] -> PageContentFits)
-> Gen [(Key, Operation)] -> Gen PageContentFits
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
        DiskPageSize -> MinKeySize -> Gen [(Key, Operation)]
genPageContentFits DiskPageSize
DiskPage4k MinKeySize
noMinKeySize

    shrink :: PageContentFits -> [PageContentFits]
shrink (PageContentFits [(Key, Operation)]
kops) =
      ([(Key, Operation)] -> PageContentFits)
-> [[(Key, Operation)]] -> [PageContentFits]
forall a b. (a -> b) -> [a] -> [b]
map [(Key, Operation)] -> PageContentFits
PageContentFits ([(Key, Operation)] -> [[(Key, Operation)]]
shrinkKeyOps [(Key, Operation)]
kops)

pageContentFitsInvariant :: PageContentFits -> Bool
pageContentFitsInvariant :: PageContentFits -> Bool
pageContentFitsInvariant (PageContentFits [(Key, Operation)]
kops) =
    Maybe PageSize -> Bool
forall a. Maybe a -> Bool
isJust (DiskPageSize -> [(Key, Operation)] -> Maybe PageSize
calcPageSize DiskPageSize
DiskPage4k [(Key, Operation)]
kops)

instance Arbitrary PageContentOrdered where
    arbitrary :: Gen PageContentOrdered
arbitrary =
      [(Key, Operation)] -> PageContentOrdered
PageContentOrdered ([(Key, Operation)] -> PageContentOrdered)
-> ([(Key, Operation)] -> [(Key, Operation)])
-> [(Key, Operation)]
-> PageContentOrdered
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [(Key, Operation)] -> [(Key, Operation)]
orderdKeyOps ([(Key, Operation)] -> PageContentOrdered)
-> Gen [(Key, Operation)] -> Gen PageContentOrdered
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
        DiskPageSize -> MinKeySize -> Gen [(Key, Operation)]
genPageContentFits DiskPageSize
DiskPage4k MinKeySize
noMinKeySize

    shrink :: PageContentOrdered -> [PageContentOrdered]
shrink (PageContentOrdered [(Key, Operation)]
kops) =
      ([(Key, Operation)] -> PageContentOrdered)
-> [[(Key, Operation)]] -> [PageContentOrdered]
forall a b. (a -> b) -> [a] -> [b]
map [(Key, Operation)] -> PageContentOrdered
PageContentOrdered ([(Key, Operation)] -> [[(Key, Operation)]]
shrinkOrderedKeyOps [(Key, Operation)]
kops)

-- | Stricly increasing, so no duplicates.
pageContentOrderedInvariant :: PageContentOrdered -> Bool
pageContentOrderedInvariant :: PageContentOrdered -> Bool
pageContentOrderedInvariant (PageContentOrdered [(Key, Operation)]
kops) =
    PageContentFits -> Bool
pageContentFitsInvariant ([(Key, Operation)] -> PageContentFits
PageContentFits [(Key, Operation)]
kops)
 Bool -> Bool -> Bool
&& let ks :: [Key]
ks = ((Key, Operation) -> Key) -> [(Key, Operation)] -> [Key]
forall a b. (a -> b) -> [a] -> [b]
map (Key, Operation) -> Key
forall a b. (a, b) -> a
fst [(Key, Operation)]
kops
     in [Bool] -> Bool
forall (t :: * -> *). Foldable t => t Bool -> Bool
and ((Key -> Key -> Bool) -> [Key] -> [Key] -> [Bool]
forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
zipWith Key -> Key -> Bool
forall a. Ord a => a -> a -> Bool
(<) [Key]
ks (Int -> [Key] -> [Key]
forall a. Int -> [a] -> [a]
drop Int
1 [Key]
ks))

instance Arbitrary PageContentMaybeOverfull where
    arbitrary :: Gen PageContentMaybeOverfull
arbitrary =
      [(Key, Operation)] -> PageContentMaybeOverfull
PageContentMaybeOverfull ([(Key, Operation)] -> PageContentMaybeOverfull)
-> Gen [(Key, Operation)] -> Gen PageContentMaybeOverfull
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
        DiskPageSize -> MinKeySize -> Gen [(Key, Operation)]
genPageContentMaybeOverfull DiskPageSize
DiskPage4k MinKeySize
noMinKeySize

    shrink :: PageContentMaybeOverfull -> [PageContentMaybeOverfull]
shrink (PageContentMaybeOverfull [(Key, Operation)]
kops) =
      ([(Key, Operation)] -> PageContentMaybeOverfull)
-> [[(Key, Operation)]] -> [PageContentMaybeOverfull]
forall a b. (a -> b) -> [a] -> [b]
map [(Key, Operation)] -> PageContentMaybeOverfull
PageContentMaybeOverfull ([(Key, Operation)] -> [[(Key, Operation)]]
shrinkKeyOps [(Key, Operation)]
kops)

instance Arbitrary PageContentSingle where
    arbitrary :: Gen PageContentSingle
arbitrary =
      (Key -> Operation -> PageContentSingle)
-> (Key, Operation) -> PageContentSingle
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry Key -> Operation -> PageContentSingle
PageContentSingle ((Key, Operation) -> PageContentSingle)
-> Gen (Key, Operation) -> Gen PageContentSingle
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
        DiskPageSize -> MinKeySize -> Gen (Key, Operation)
genPageContentSingle DiskPageSize
DiskPage4k MinKeySize
noMinKeySize

    shrink :: PageContentSingle -> [PageContentSingle]
shrink (PageContentSingle Key
k Operation
op) =
      ((Key, Operation) -> PageContentSingle)
-> [(Key, Operation)] -> [PageContentSingle]
forall a b. (a -> b) -> [a] -> [b]
map ((Key -> Operation -> PageContentSingle)
-> (Key, Operation) -> PageContentSingle
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry Key -> Operation -> PageContentSingle
PageContentSingle) ((Key, Operation) -> [(Key, Operation)]
forall a. Arbitrary a => a -> [a]
shrink (Key
k, Operation
op))

-------------------------------------------------------------------------------
-- Conversions between reference and real implementation types
--

-- | Convert from 'PageContentFits' (from the reference implementation)
-- to 'RawPage' (from the real implementation).
--
toRawPage :: PageContentFits -> (RawPage, [RawOverflowPage])
toRawPage :: PageContentFits -> (RawPage, [RawOverflowPage])
toRawPage (PageContentFits [(Key, Operation)]
kops) =
    (RawPage, [RawOverflowPage])
-> Maybe (RawPage, [RawOverflowPage])
-> (RawPage, [RawOverflowPage])
forall a. a -> Maybe a -> a
fromMaybe (RawPage, [RawOverflowPage])
forall {a}. a
overfull (PageContentMaybeOverfull -> Maybe (RawPage, [RawOverflowPage])
toRawPageMaybeOverfull ([(Key, Operation)] -> PageContentMaybeOverfull
PageContentMaybeOverfull [(Key, Operation)]
kops))
  where
    overfull :: a
overfull =
      String -> a
forall a. HasCallStack => String -> a
error (String -> a) -> String -> a
forall a b. (a -> b) -> a -> b
$ String
"toRawPage: encountered overfull page, but PageContentFits is "
           String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
"supposed to be guaranteed to fit, i.e. not to be overfull."

toRawPageMaybeOverfull :: PageContentMaybeOverfull
                       -> Maybe (RawPage, [RawOverflowPage])
toRawPageMaybeOverfull :: PageContentMaybeOverfull -> Maybe (RawPage, [RawOverflowPage])
toRawPageMaybeOverfull (PageContentMaybeOverfull [(Key, Operation)]
kops) = do
    ByteString
serialised <- PageIntermediate -> ByteString
serialisePage (PageIntermediate -> ByteString)
-> Maybe PageIntermediate -> Maybe ByteString
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> DiskPageSize -> [(Key, Operation)] -> Maybe PageIntermediate
encodePage DiskPageSize
DiskPage4k [(Key, Operation)]
kops
    (ByteString
page : [ByteString]
overflowPages) <- [ByteString] -> Maybe [ByteString]
forall a. a -> Maybe a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (DiskPageSize -> ByteString -> [ByteString]
pageSerialisedChunks DiskPageSize
DiskPage4k ByteString
serialised)
    (RawPage, [RawOverflowPage]) -> Maybe (RawPage, [RawOverflowPage])
forall a. a -> Maybe a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ByteString -> RawPage
makeRawPageBS ByteString
page, (ByteString -> RawOverflowPage)
-> [ByteString] -> [RawOverflowPage]
forall a b. (a -> b) -> [a] -> [b]
map ByteString -> RawOverflowPage
makeRawOverflowPageBS [ByteString]
overflowPages)

makeRawPageBS :: BS.ByteString -> RawPage
makeRawPageBS :: ByteString -> RawPage
makeRawPageBS ByteString
bs =
    case ByteString -> ShortByteString
SBS.toShort ByteString
bs of
      SBS.SBS ByteArray#
ba -> ByteArray -> Int -> RawPage
makeRawPage (ByteArray# -> ByteArray
ByteArray ByteArray#
ba) Int
0

makeRawOverflowPageBS :: BS.ByteString -> RawOverflowPage
makeRawOverflowPageBS :: ByteString -> RawOverflowPage
makeRawOverflowPageBS ByteString
bs =
    case ByteString -> ShortByteString
SBS.toShort ByteString
bs of
      SBS.SBS ByteArray#
ba -> ByteArray -> Int -> Int -> RawOverflowPage
makeRawOverflowPage (ByteArray# -> ByteArray
ByteArray ByteArray#
ba) Int
0 (ByteString -> Int
BS.length ByteString
bs)

fromRawPage :: (RawPage, [RawOverflowPage]) -> PageContentFits
fromRawPage :: (RawPage, [RawOverflowPage]) -> PageContentFits
fromRawPage (RawPage
page, [RawOverflowPage]
overflowPages)
  | RawPage -> Word16
rawPageNumKeys RawPage
page Word16 -> Word16 -> Bool
forall a. Eq a => a -> a -> Bool
== Word16
1
  = [(Key, Operation)] -> PageContentFits
PageContentFits ([(Key, Operation)] -> PageContentFits)
-> ((Key, Operation) -> [(Key, Operation)])
-> (Key, Operation)
-> PageContentFits
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((Key, Operation) -> [(Key, Operation)] -> [(Key, Operation)]
forall a. a -> [a] -> [a]
:[]) ((Key, Operation) -> PageContentFits)
-> (Key, Operation) -> PageContentFits
forall a b. (a -> b) -> a -> b
$
      case RawPage -> Word16 -> RawPageIndex (Entry SerialisedValue BlobSpan)
rawPageIndex RawPage
page Word16
0 of
        IndexEntry SerialisedKey
k Entry SerialisedValue BlobSpan
e ->
          (SerialisedKey -> Key
fromSerialisedKey SerialisedKey
k, Entry SerialisedValue BlobSpan -> Operation
fromEntry Entry SerialisedValue BlobSpan
e)

        IndexEntryOverflow SerialisedKey
k Entry SerialisedValue BlobSpan
e Word32
suffixlen ->
          ( SerialisedKey -> Key
fromSerialisedKey SerialisedKey
k
          , Entry SerialisedValue BlobSpan
-> Int -> [RawOverflowPage] -> Operation
fromEntryPrefix Entry SerialisedValue BlobSpan
e (Word32 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word32
suffixlen) [RawOverflowPage]
overflowPages
          )

        RawPageIndex (Entry SerialisedValue BlobSpan)
IndexNotPresent -> String -> (Key, Operation)
forall a. HasCallStack => String -> a
error String
"fromRawPage: 'rawPageIndex page 0' fails"

  | Bool
otherwise
  = [(Key, Operation)] -> PageContentFits
PageContentFits
      [ case RawPage -> Word16 -> RawPageIndex (Entry SerialisedValue BlobSpan)
rawPageIndex RawPage
page (Int -> Word16
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i) of
          IndexEntry SerialisedKey
k Entry SerialisedValue BlobSpan
e -> (SerialisedKey -> Key
fromSerialisedKey SerialisedKey
k, Entry SerialisedValue BlobSpan -> Operation
fromEntry Entry SerialisedValue BlobSpan
e)
          RawPageIndex (Entry SerialisedValue BlobSpan)
_              -> String -> (Key, Operation)
forall a. HasCallStack => String -> a
error String
"fromRawPage: 'rawPageIndex page i' fails"
      | Int
i <- [Int
0 .. Word16 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral (RawPage -> Word16
rawPageNumKeys RawPage
page) Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1 :: Int] ]

toEntry :: Operation -> Entry SerialisedValue BlobSpan
toEntry :: Operation -> Entry SerialisedValue BlobSpan
toEntry Operation
op =
    case Operation
op of
      Insert Value
v Maybe BlobRef
Nothing ->
        SerialisedValue -> Entry SerialisedValue BlobSpan
forall v b. v -> Entry v b
Entry.Insert (Value -> SerialisedValue
toSerialisedValue Value
v)

      Insert Value
v (Just BlobRef
b) ->
        SerialisedValue -> BlobSpan -> Entry SerialisedValue BlobSpan
forall v b. v -> b -> Entry v b
Entry.InsertWithBlob (Value -> SerialisedValue
toSerialisedValue Value
v) (BlobRef -> BlobSpan
toBlobSpan BlobRef
b)

      Mupsert Value
v ->
        SerialisedValue -> Entry SerialisedValue BlobSpan
forall v b. v -> Entry v b
Entry.Mupdate (Value -> SerialisedValue
toSerialisedValue Value
v)

      Operation
Delete ->
        Entry SerialisedValue BlobSpan
forall v b. Entry v b
Entry.Delete

toEntryPrefix :: Operation -> Int -> Entry SerialisedValue BlobSpan
toEntryPrefix :: Operation -> Int -> Entry SerialisedValue BlobSpan
toEntryPrefix Operation
op Int
prefixlen =
    case Operation
op of
      Insert Value
v Maybe BlobRef
Nothing ->
        SerialisedValue -> Entry SerialisedValue BlobSpan
forall v b. v -> Entry v b
Entry.Insert (Value -> SerialisedValue
toSerialisedValue (Int -> Value -> Value
takeValue Int
prefixlen Value
v))

      Insert Value
v (Just BlobRef
b) ->
        SerialisedValue -> BlobSpan -> Entry SerialisedValue BlobSpan
forall v b. v -> b -> Entry v b
Entry.InsertWithBlob (Value -> SerialisedValue
toSerialisedValue (Int -> Value -> Value
takeValue Int
prefixlen Value
v))
                             (BlobRef -> BlobSpan
toBlobSpan BlobRef
b)

      Mupsert Value
v ->
        SerialisedValue -> Entry SerialisedValue BlobSpan
forall v b. v -> Entry v b
Entry.Mupdate (Value -> SerialisedValue
toSerialisedValue (Int -> Value -> Value
takeValue Int
prefixlen Value
v))

      Operation
Delete ->
        Entry SerialisedValue BlobSpan
forall v b. Entry v b
Entry.Delete
  where
    takeValue :: Int -> Value -> Value
takeValue Int
n (Value ByteString
v) = ByteString -> Value
Value (Int -> ByteString -> ByteString
BS.take Int
n ByteString
v)

fromEntry :: Entry SerialisedValue BlobSpan -> Operation
fromEntry :: Entry SerialisedValue BlobSpan -> Operation
fromEntry Entry SerialisedValue BlobSpan
e =
    case Entry SerialisedValue BlobSpan
e of
      Entry.Insert SerialisedValue
v ->
        Value -> Maybe BlobRef -> Operation
Insert (SerialisedValue -> Value
fromSerialisedValue SerialisedValue
v) Maybe BlobRef
forall a. Maybe a
Nothing

      Entry.InsertWithBlob SerialisedValue
v BlobSpan
b ->
        Value -> Maybe BlobRef -> Operation
Insert (SerialisedValue -> Value
fromSerialisedValue SerialisedValue
v) (BlobRef -> Maybe BlobRef
forall a. a -> Maybe a
Just (BlobSpan -> BlobRef
fromBlobSpan BlobSpan
b))

      Entry.Mupdate SerialisedValue
v ->
        Value -> Operation
Mupsert (SerialisedValue -> Value
fromSerialisedValue SerialisedValue
v)

      Entry SerialisedValue BlobSpan
Entry.Delete ->
        Operation
Delete

fromEntryPrefix :: Entry SerialisedValue BlobSpan
                -> Int
                -> [RawOverflowPage]
                -> Operation
fromEntryPrefix :: Entry SerialisedValue BlobSpan
-> Int -> [RawOverflowPage] -> Operation
fromEntryPrefix Entry SerialisedValue BlobSpan
e Int
suffix [RawOverflowPage]
overflow =
    case Entry SerialisedValue BlobSpan
e of
      Entry.Insert SerialisedValue
v ->
        Value -> Maybe BlobRef -> Operation
Insert (SerialisedValue -> Int -> [RawOverflowPage] -> Value
fromSerialisedValuePrefix SerialisedValue
v Int
suffix [RawOverflowPage]
overflow) Maybe BlobRef
forall a. Maybe a
Nothing

      Entry.InsertWithBlob SerialisedValue
v BlobSpan
b ->
        Value -> Maybe BlobRef -> Operation
Insert (SerialisedValue -> Int -> [RawOverflowPage] -> Value
fromSerialisedValuePrefix SerialisedValue
v Int
suffix [RawOverflowPage]
overflow)
               (BlobRef -> Maybe BlobRef
forall a. a -> Maybe a
Just (BlobSpan -> BlobRef
fromBlobSpan BlobSpan
b))

      Entry.Mupdate SerialisedValue
v ->
        Value -> Operation
Mupsert (SerialisedValue -> Int -> [RawOverflowPage] -> Value
fromSerialisedValuePrefix SerialisedValue
v Int
suffix [RawOverflowPage]
overflow)

      Entry SerialisedValue BlobSpan
Entry.Delete ->
        Operation
Delete

toSerialisedKey :: Key -> SerialisedKey
toSerialisedKey :: Key -> SerialisedKey
toSerialisedKey (Key ByteString
k) = RawBytes -> SerialisedKey
SerialisedKey (ByteString -> RawBytes
RB.fromByteString ByteString
k)

toSerialisedValue :: Value -> SerialisedValue
toSerialisedValue :: Value -> SerialisedValue
toSerialisedValue (Value ByteString
v) = RawBytes -> SerialisedValue
SerialisedValue (ByteString -> RawBytes
RB.fromByteString ByteString
v)

fromSerialisedKey :: SerialisedKey -> Key
fromSerialisedKey :: SerialisedKey -> Key
fromSerialisedKey (SerialisedKey RawBytes
k) = ByteString -> Key
Key (RawBytes -> ByteString
RB.toByteString RawBytes
k)

fromSerialisedValue :: SerialisedValue -> Value
fromSerialisedValue :: SerialisedValue -> Value
fromSerialisedValue (SerialisedValue RawBytes
v) = ByteString -> Value
Value (RawBytes -> ByteString
RB.toByteString RawBytes
v)

fromSerialisedValuePrefix :: SerialisedValue -> Int -> [RawOverflowPage]
                          -> Value
fromSerialisedValuePrefix :: SerialisedValue -> Int -> [RawOverflowPage] -> Value
fromSerialisedValuePrefix (SerialisedValue RawBytes
v) Int
suffixlen [RawOverflowPage]
overflowPages =
    ByteString -> Value
Value (ByteString -> Value) -> ByteString -> Value
forall a b. (a -> b) -> a -> b
$ RawBytes -> ByteString
RB.toByteString RawBytes
v
         ByteString -> ByteString -> ByteString
forall a. Semigroup a => a -> a -> a
<> Int -> ByteString -> ByteString
BS.take Int
suffixlen ([RawOverflowPage] -> ByteString
fromRawOverflowPages [RawOverflowPage]
overflowPages)

fromRawOverflowPages :: [RawOverflowPage] -> BS.ByteString
fromRawOverflowPages :: [RawOverflowPage] -> ByteString
fromRawOverflowPages =
    RawBytes -> ByteString
RB.toByteString
  (RawBytes -> ByteString)
-> ([RawOverflowPage] -> RawBytes)
-> [RawOverflowPage]
-> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [RawBytes] -> RawBytes
forall a. Monoid a => [a] -> a
mconcat
  ([RawBytes] -> RawBytes)
-> ([RawOverflowPage] -> [RawBytes])
-> [RawOverflowPage]
-> RawBytes
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (RawOverflowPage -> RawBytes) -> [RawOverflowPage] -> [RawBytes]
forall a b. (a -> b) -> [a] -> [b]
map RawOverflowPage -> RawBytes
rawOverflowPageRawBytes

toBlobSpan :: BlobRef -> BlobSpan
toBlobSpan :: BlobRef -> BlobSpan
toBlobSpan  (BlobRef Word64
x Word32
y) = Word64 -> Word32 -> BlobSpan
BlobSpan Word64
x Word32
y

fromBlobSpan :: BlobSpan -> BlobRef
fromBlobSpan :: BlobSpan -> BlobRef
fromBlobSpan  (BlobSpan Word64
x Word32
y) = Word64 -> Word32 -> BlobRef
BlobRef Word64
x Word32
y