{-|
Module      : Mdbx.Database
Copyright   : (c) 2021 Francisco Vallarino
License     : BSD-3-Clause (see the LICENSE file)
Maintainer  : fjvallarino@gmail.com
Stability   : experimental
Portability : non-portable

High level API to create, update, delete and query an MDBX database.
-}
module Mdbx.Database (
  -- * Get
  getItem,
  getItems,
  -- * Query
  getRange,
  -- * Save
  putItem,
  putItems,
  -- * Delete
  delItem,
  delItems
) where

import Control.Monad (forM, forM_, void)
import Control.Monad.IO.Class (MonadIO, liftIO)
import Data.Function (fix)
import Data.Maybe (catMaybes, fromJust)

import Mdbx.API
import Mdbx.Types

-- | Returns the value associated with the given key, if any.
getItem
  :: (MonadIO m, MonadFail m, MdbxItem k, MdbxItem v)
  => MdbxEnv       -- ^ The environment.
  -> MdbxDbi       -- ^ The database.
  -> k             -- ^ The key to lookup.
  -> m (Maybe v)   -- ^ The matching value, if any.
getItem :: MdbxEnv -> MdbxDbi -> k -> m (Maybe v)
getItem MdbxEnv
env MdbxDbi
dbi k
key = do
  MdbxTxn
txn <- MdbxEnv -> Maybe MdbxTxn -> [MdbxTxnFlags] -> m MdbxTxn
forall (m :: * -> *).
(MonadIO m, MonadFail m) =>
MdbxEnv -> Maybe MdbxTxn -> [MdbxTxnFlags] -> m MdbxTxn
txnBegin MdbxEnv
env Maybe MdbxTxn
forall a. Maybe a
Nothing [MdbxTxnFlags
MdbxTxnRdonly]

  Maybe v
resp <- IO (Maybe v) -> m (Maybe v)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe v) -> m (Maybe v)) -> IO (Maybe v) -> m (Maybe v)
forall a b. (a -> b) -> a -> b
$ k -> (MdbxVal -> IO (Maybe v)) -> IO (Maybe v)
forall i b. MdbxItem i => i -> (MdbxVal -> IO b) -> IO b
toMdbxVal k
key ((MdbxVal -> IO (Maybe v)) -> IO (Maybe v))
-> (MdbxVal -> IO (Maybe v)) -> IO (Maybe v)
forall a b. (a -> b) -> a -> b
$ \MdbxVal
mkey -> do
    Maybe MdbxVal
mval <- MdbxTxn -> MdbxDbi -> MdbxVal -> IO (Maybe MdbxVal)
forall (m :: * -> *).
(MonadIO m, MonadFail m) =>
MdbxTxn -> MdbxDbi -> MdbxVal -> m (Maybe MdbxVal)
itemGet MdbxTxn
txn MdbxDbi
dbi MdbxVal
mkey
    (MdbxVal -> IO v) -> Maybe MdbxVal -> IO (Maybe v)
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM MdbxVal -> IO v
forall i. MdbxItem i => MdbxVal -> IO i
fromMdbxVal Maybe MdbxVal
mval
  m () -> m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (m () -> m ()) -> m () -> m ()
forall a b. (a -> b) -> a -> b
$ MdbxTxn -> m ()
forall (m :: * -> *). (MonadIO m, MonadFail m) => MdbxTxn -> m ()
txnCommit MdbxTxn
txn
  Maybe v -> m (Maybe v)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe v
resp

{-|
Returns the values associated to a list of keys. Returned length may not match
that of provided keys in case some of them are not found.
-}
getItems
  :: (MonadIO m, MonadFail m, MdbxItem k, MdbxItem v)
  => MdbxEnv       -- ^ The environment.
  -> MdbxDbi       -- ^ The database.
  -> [k]           -- ^ The keys to lookup.
  -> m [v]         -- ^ The matching values. Length may not match that of keys.
getItems :: MdbxEnv -> MdbxDbi -> [k] -> m [v]
getItems MdbxEnv
env MdbxDbi
dbi [k]
keys = do
  MdbxTxn
txn <- MdbxEnv -> Maybe MdbxTxn -> [MdbxTxnFlags] -> m MdbxTxn
forall (m :: * -> *).
(MonadIO m, MonadFail m) =>
MdbxEnv -> Maybe MdbxTxn -> [MdbxTxnFlags] -> m MdbxTxn
txnBegin MdbxEnv
env Maybe MdbxTxn
forall a. Maybe a
Nothing [MdbxTxnFlags
MdbxTxnRdonly]

  [Maybe v]
resp <- [k] -> (k -> m (Maybe v)) -> m [Maybe v]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
t a -> (a -> m b) -> m (t b)
forM [k]
keys ((k -> m (Maybe v)) -> m [Maybe v])
-> (k -> m (Maybe v)) -> m [Maybe v]
forall a b. (a -> b) -> a -> b
$ \k
key ->
    IO (Maybe v) -> m (Maybe v)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe v) -> m (Maybe v)) -> IO (Maybe v) -> m (Maybe v)
forall a b. (a -> b) -> a -> b
$ k -> (MdbxVal -> IO (Maybe v)) -> IO (Maybe v)
forall i b. MdbxItem i => i -> (MdbxVal -> IO b) -> IO b
toMdbxVal k
key ((MdbxVal -> IO (Maybe v)) -> IO (Maybe v))
-> (MdbxVal -> IO (Maybe v)) -> IO (Maybe v)
forall a b. (a -> b) -> a -> b
$ \MdbxVal
mkey -> do
      Maybe MdbxVal
mval <- MdbxTxn -> MdbxDbi -> MdbxVal -> IO (Maybe MdbxVal)
forall (m :: * -> *).
(MonadIO m, MonadFail m) =>
MdbxTxn -> MdbxDbi -> MdbxVal -> m (Maybe MdbxVal)
itemGet MdbxTxn
txn MdbxDbi
dbi MdbxVal
mkey
      (MdbxVal -> IO v) -> Maybe MdbxVal -> IO (Maybe v)
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM MdbxVal -> IO v
forall i. MdbxItem i => MdbxVal -> IO i
fromMdbxVal Maybe MdbxVal
mval
  m () -> m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (m () -> m ()) -> m () -> m ()
forall a b. (a -> b) -> a -> b
$ MdbxTxn -> m ()
forall (m :: * -> *). (MonadIO m, MonadFail m) => MdbxTxn -> m ()
txnCommit MdbxTxn
txn
  [v] -> m [v]
forall (m :: * -> *) a. Monad m => a -> m a
return ([v] -> m [v]) -> [v] -> m [v]
forall a b. (a -> b) -> a -> b
$ [Maybe v] -> [v]
forall a. [Maybe a] -> [a]
catMaybes [Maybe v]
resp

-- | Returns the list of values whose keys lie between the provided range.
getRange
  :: (MonadIO m, MonadFail m, MdbxItem k, MdbxItem v)
  => MdbxEnv       -- ^ The environment.
  -> MdbxDbi       -- ^ The database.
  -> k             -- ^ The start of the range (inclusive).
  -> k             -- ^ The end of the range (inclusive).
  -> m [v]         -- ^ The matching values.
getRange :: MdbxEnv -> MdbxDbi -> k -> k -> m [v]
getRange MdbxEnv
env MdbxDbi
dbi k
start k
end = do
  MdbxTxn
txn <- MdbxEnv -> Maybe MdbxTxn -> [MdbxTxnFlags] -> m MdbxTxn
forall (m :: * -> *).
(MonadIO m, MonadFail m) =>
MdbxEnv -> Maybe MdbxTxn -> [MdbxTxnFlags] -> m MdbxTxn
txnBegin MdbxEnv
env Maybe MdbxTxn
forall a. Maybe a
Nothing [MdbxTxnFlags
MdbxTxnRdonly]
  MdbxCursor
cursor <- MdbxTxn -> MdbxDbi -> m MdbxCursor
forall (m :: * -> *).
(MonadIO m, MonadFail m) =>
MdbxTxn -> MdbxDbi -> m MdbxCursor
cursorOpen MdbxTxn
txn MdbxDbi
dbi

  [v]
pairs <- IO [v] -> m [v]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [v] -> m [v]) -> IO [v] -> m [v]
forall a b. (a -> b) -> a -> b
$ k -> (MdbxVal -> IO [v]) -> IO [v]
forall i b. MdbxItem i => i -> (MdbxVal -> IO b) -> IO b
toMdbxVal k
start ((MdbxVal -> IO [v]) -> IO [v]) -> (MdbxVal -> IO [v]) -> IO [v]
forall a b. (a -> b) -> a -> b
$ \MdbxVal
skey ->
    IO [v] -> IO [v]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [v] -> IO [v]) -> IO [v] -> IO [v]
forall a b. (a -> b) -> a -> b
$ k -> (MdbxVal -> IO [v]) -> IO [v]
forall i b. MdbxItem i => i -> (MdbxVal -> IO b) -> IO b
toMdbxVal k
end ((MdbxVal -> IO [v]) -> IO [v]) -> (MdbxVal -> IO [v]) -> IO [v]
forall a b. (a -> b) -> a -> b
$ \MdbxVal
ekey -> do
      Maybe (MdbxVal, MdbxVal)
pair1 <- MdbxCursor -> MdbxVal -> IO (Maybe (MdbxVal, MdbxVal))
forall (m :: * -> *).
(MonadIO m, MonadFail m) =>
MdbxCursor -> MdbxVal -> m (Maybe (MdbxVal, MdbxVal))
cursorRange MdbxCursor
cursor MdbxVal
skey
      ((((Maybe (MdbxVal, MdbxVal), [v]) -> IO [v])
  -> (Maybe (MdbxVal, MdbxVal), [v]) -> IO [v])
 -> (Maybe (MdbxVal, MdbxVal), [v]) -> IO [v])
-> (Maybe (MdbxVal, MdbxVal), [v])
-> (((Maybe (MdbxVal, MdbxVal), [v]) -> IO [v])
    -> (Maybe (MdbxVal, MdbxVal), [v]) -> IO [v])
-> IO [v]
forall a b c. (a -> b -> c) -> b -> a -> c
flip (((Maybe (MdbxVal, MdbxVal), [v]) -> IO [v])
 -> (Maybe (MdbxVal, MdbxVal), [v]) -> IO [v])
-> (Maybe (MdbxVal, MdbxVal), [v]) -> IO [v]
forall a. (a -> a) -> a
fix (Maybe (MdbxVal, MdbxVal)
pair1, []) ((((Maybe (MdbxVal, MdbxVal), [v]) -> IO [v])
  -> (Maybe (MdbxVal, MdbxVal), [v]) -> IO [v])
 -> IO [v])
-> (((Maybe (MdbxVal, MdbxVal), [v]) -> IO [v])
    -> (Maybe (MdbxVal, MdbxVal), [v]) -> IO [v])
-> IO [v]
forall a b. (a -> b) -> a -> b
$ \(Maybe (MdbxVal, MdbxVal), [v]) -> IO [v]
loop (Maybe (MdbxVal, MdbxVal)
pair, [v]
items) -> do
        Bool
isValid <- MdbxTxn
-> MdbxDbi -> MdbxVal -> Maybe (MdbxVal, MdbxVal) -> IO Bool
forall (m :: * -> *).
(MonadIO m, MonadFail m) =>
MdbxTxn -> MdbxDbi -> MdbxVal -> Maybe (MdbxVal, MdbxVal) -> m Bool
pairLEKey MdbxTxn
txn MdbxDbi
dbi MdbxVal
ekey Maybe (MdbxVal, MdbxVal)
pair

        if Bool
isValid
          then do
            v
val <- MdbxVal -> IO v
forall i. MdbxItem i => MdbxVal -> IO i
fromMdbxVal (MdbxVal -> IO v)
-> (Maybe (MdbxVal, MdbxVal) -> MdbxVal)
-> Maybe (MdbxVal, MdbxVal)
-> IO v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (MdbxVal, MdbxVal) -> MdbxVal
forall a b. (a, b) -> b
snd ((MdbxVal, MdbxVal) -> MdbxVal)
-> (Maybe (MdbxVal, MdbxVal) -> (MdbxVal, MdbxVal))
-> Maybe (MdbxVal, MdbxVal)
-> MdbxVal
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Maybe (MdbxVal, MdbxVal) -> (MdbxVal, MdbxVal)
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe (MdbxVal, MdbxVal) -> IO v)
-> Maybe (MdbxVal, MdbxVal) -> IO v
forall a b. (a -> b) -> a -> b
$ Maybe (MdbxVal, MdbxVal)
pair
            Maybe (MdbxVal, MdbxVal)
newPair <- MdbxCursor -> IO (Maybe (MdbxVal, MdbxVal))
forall (m :: * -> *).
(MonadIO m, MonadFail m) =>
MdbxCursor -> m (Maybe (MdbxVal, MdbxVal))
cursorNext MdbxCursor
cursor

            (Maybe (MdbxVal, MdbxVal), [v]) -> IO [v]
loop (Maybe (MdbxVal, MdbxVal)
newPair, v
val v -> [v] -> [v]
forall a. a -> [a] -> [a]
: [v]
items)
          else [v] -> IO [v]
forall (m :: * -> *) a. Monad m => a -> m a
return [v]
items

  m () -> m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (m () -> m ()) -> m () -> m ()
forall a b. (a -> b) -> a -> b
$ MdbxTxn -> m ()
forall (m :: * -> *). (MonadIO m, MonadFail m) => MdbxTxn -> m ()
txnCommit MdbxTxn
txn
  [v] -> m [v]
forall (m :: * -> *) a. Monad m => a -> m a
return ([v] -> m [v]) -> [v] -> m [v]
forall a b. (a -> b) -> a -> b
$ [v] -> [v]
forall a. [a] -> [a]
reverse [v]
pairs

-- | Saves the given key/value pair.
putItem
  :: (MonadIO m, MonadFail m, MdbxItem k, MdbxItem v)
  => MdbxEnv       -- ^ The environment.
  -> MdbxDbi       -- ^ The database.
  -> k             -- ^ The key.
  -> v             -- ^ The value.
  -> m ()
putItem :: MdbxEnv -> MdbxDbi -> k -> v -> m ()
putItem MdbxEnv
env MdbxDbi
dbi k
key v
item = do
  MdbxTxn
txn <- MdbxEnv -> Maybe MdbxTxn -> [MdbxTxnFlags] -> m MdbxTxn
forall (m :: * -> *).
(MonadIO m, MonadFail m) =>
MdbxEnv -> Maybe MdbxTxn -> [MdbxTxnFlags] -> m MdbxTxn
txnBegin MdbxEnv
env Maybe MdbxTxn
forall a. Maybe a
Nothing []
  IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ k -> (MdbxVal -> IO ()) -> IO ()
forall i b. MdbxItem i => i -> (MdbxVal -> IO b) -> IO b
toMdbxVal k
key ((MdbxVal -> IO ()) -> IO ()) -> (MdbxVal -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \MdbxVal
mkey ->
    IO () -> IO ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> IO ()) -> IO () -> IO ()
forall a b. (a -> b) -> a -> b
$ v -> (MdbxVal -> IO ()) -> IO ()
forall i b. MdbxItem i => i -> (MdbxVal -> IO b) -> IO b
toMdbxVal v
item ((MdbxVal -> IO ()) -> IO ()) -> (MdbxVal -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \MdbxVal
mitem ->
      MdbxTxn -> MdbxDbi -> MdbxVal -> MdbxVal -> [MdbxPutFlags] -> IO ()
forall (m :: * -> *).
(MonadIO m, MonadFail m) =>
MdbxTxn -> MdbxDbi -> MdbxVal -> MdbxVal -> [MdbxPutFlags] -> m ()
itemPut MdbxTxn
txn MdbxDbi
dbi MdbxVal
mkey MdbxVal
mitem []
  m () -> m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (m () -> m ()) -> m () -> m ()
forall a b. (a -> b) -> a -> b
$ MdbxTxn -> m ()
forall (m :: * -> *). (MonadIO m, MonadFail m) => MdbxTxn -> m ()
txnCommit MdbxTxn
txn

-- | Saves the given key/value pairs. Runs in a single transaction.
putItems
  :: (MonadIO m, MonadFail m, MdbxItem k, MdbxItem v)
  => MdbxEnv       -- ^ The environment.
  -> MdbxDbi       -- ^ The database.
  -> [(k, v)]      -- ^ The list of key/value pairs.
  -> m ()
putItems :: MdbxEnv -> MdbxDbi -> [(k, v)] -> m ()
putItems MdbxEnv
env MdbxDbi
dbi [(k, v)]
items = do
  MdbxTxn
txn <- MdbxEnv -> Maybe MdbxTxn -> [MdbxTxnFlags] -> m MdbxTxn
forall (m :: * -> *).
(MonadIO m, MonadFail m) =>
MdbxEnv -> Maybe MdbxTxn -> [MdbxTxnFlags] -> m MdbxTxn
txnBegin MdbxEnv
env Maybe MdbxTxn
forall a. Maybe a
Nothing []
  [(k, v)] -> ((k, v) -> m ()) -> m ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
t a -> (a -> m b) -> m ()
forM_ [(k, v)]
items (((k, v) -> m ()) -> m ()) -> ((k, v) -> m ()) -> m ()
forall a b. (a -> b) -> a -> b
$ \(k
key, v
item) ->
    IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ k -> (MdbxVal -> IO ()) -> IO ()
forall i b. MdbxItem i => i -> (MdbxVal -> IO b) -> IO b
toMdbxVal k
key ((MdbxVal -> IO ()) -> IO ()) -> (MdbxVal -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \MdbxVal
mkey ->
      IO () -> IO ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> IO ()) -> IO () -> IO ()
forall a b. (a -> b) -> a -> b
$ v -> (MdbxVal -> IO ()) -> IO ()
forall i b. MdbxItem i => i -> (MdbxVal -> IO b) -> IO b
toMdbxVal v
item ((MdbxVal -> IO ()) -> IO ()) -> (MdbxVal -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \MdbxVal
mitem ->
        MdbxTxn -> MdbxDbi -> MdbxVal -> MdbxVal -> [MdbxPutFlags] -> IO ()
forall (m :: * -> *).
(MonadIO m, MonadFail m) =>
MdbxTxn -> MdbxDbi -> MdbxVal -> MdbxVal -> [MdbxPutFlags] -> m ()
itemPut MdbxTxn
txn MdbxDbi
dbi MdbxVal
mkey MdbxVal
mitem []
  m () -> m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (m () -> m ()) -> m () -> m ()
forall a b. (a -> b) -> a -> b
$ MdbxTxn -> m ()
forall (m :: * -> *). (MonadIO m, MonadFail m) => MdbxTxn -> m ()
txnCommit MdbxTxn
txn

-- | Deletes the item associated with the given key, if any.
delItem
  :: (MonadIO m, MonadFail m, MdbxItem k)
  => MdbxEnv       -- ^ The environment.
  -> MdbxDbi       -- ^ The database.
  -> k             -- ^ The key to delete.
  -> m ()
delItem :: MdbxEnv -> MdbxDbi -> k -> m ()
delItem MdbxEnv
env MdbxDbi
dbi k
key = do
  MdbxTxn
txn <- MdbxEnv -> Maybe MdbxTxn -> [MdbxTxnFlags] -> m MdbxTxn
forall (m :: * -> *).
(MonadIO m, MonadFail m) =>
MdbxEnv -> Maybe MdbxTxn -> [MdbxTxnFlags] -> m MdbxTxn
txnBegin MdbxEnv
env Maybe MdbxTxn
forall a. Maybe a
Nothing []
  IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ k -> (MdbxVal -> IO ()) -> IO ()
forall i b. MdbxItem i => i -> (MdbxVal -> IO b) -> IO b
toMdbxVal k
key ((MdbxVal -> IO ()) -> IO ()) -> (MdbxVal -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \MdbxVal
mkey ->
    MdbxTxn -> MdbxDbi -> MdbxVal -> Maybe MdbxVal -> IO ()
forall (m :: * -> *).
(MonadIO m, MonadFail m) =>
MdbxTxn -> MdbxDbi -> MdbxVal -> Maybe MdbxVal -> m ()
itemDel MdbxTxn
txn MdbxDbi
dbi MdbxVal
mkey Maybe MdbxVal
forall a. Maybe a
Nothing
  m () -> m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (m () -> m ()) -> m () -> m ()
forall a b. (a -> b) -> a -> b
$ MdbxTxn -> m ()
forall (m :: * -> *). (MonadIO m, MonadFail m) => MdbxTxn -> m ()
txnCommit MdbxTxn
txn

{-|
Deletes the items associated with the given keys, if any. Runs in a single
transaction.
-}
delItems
  :: (MonadIO m, MonadFail m, MdbxItem k)
  => MdbxEnv       -- ^ The environment.
  -> MdbxDbi       -- ^ The database.
  -> [k]           -- ^ The keys to delete.
  -> m ()
delItems :: MdbxEnv -> MdbxDbi -> [k] -> m ()
delItems MdbxEnv
env MdbxDbi
dbi [k]
keys = do
  MdbxTxn
txn <- MdbxEnv -> Maybe MdbxTxn -> [MdbxTxnFlags] -> m MdbxTxn
forall (m :: * -> *).
(MonadIO m, MonadFail m) =>
MdbxEnv -> Maybe MdbxTxn -> [MdbxTxnFlags] -> m MdbxTxn
txnBegin MdbxEnv
env Maybe MdbxTxn
forall a. Maybe a
Nothing []
  [k] -> (k -> m ()) -> m ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
t a -> (a -> m b) -> m ()
forM_ [k]
keys ((k -> m ()) -> m ()) -> (k -> m ()) -> m ()
forall a b. (a -> b) -> a -> b
$ \k
key ->
    IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ k -> (MdbxVal -> IO ()) -> IO ()
forall i b. MdbxItem i => i -> (MdbxVal -> IO b) -> IO b
toMdbxVal k
key ((MdbxVal -> IO ()) -> IO ()) -> (MdbxVal -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \MdbxVal
mkey ->
      MdbxTxn -> MdbxDbi -> MdbxVal -> Maybe MdbxVal -> IO ()
forall (m :: * -> *).
(MonadIO m, MonadFail m) =>
MdbxTxn -> MdbxDbi -> MdbxVal -> Maybe MdbxVal -> m ()
itemDel MdbxTxn
txn MdbxDbi
dbi MdbxVal
mkey Maybe MdbxVal
forall a. Maybe a
Nothing
  m () -> m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (m () -> m ()) -> m () -> m ()
forall a b. (a -> b) -> a -> b
$ MdbxTxn -> m ()
forall (m :: * -> *). (MonadIO m, MonadFail m) => MdbxTxn -> m ()
txnCommit MdbxTxn
txn

-- Helpers

-- | Checks if the key of the key/value pair is lower than the provided key.
pairLEKey
  :: (MonadIO m, MonadFail m)
  => MdbxTxn       -- ^ The active transaction.
  -> MdbxDbi       -- ^ The database.
  -> MdbxVal       -- ^ The reference key.
  -> Maybe (MdbxVal, MdbxVal)  -- ^ The key/value pair to check
  -> m Bool        -- ^ True if the key/value is lower or equal than the key.
pairLEKey :: MdbxTxn -> MdbxDbi -> MdbxVal -> Maybe (MdbxVal, MdbxVal) -> m Bool
pairLEKey MdbxTxn
txn MdbxDbi
dbi MdbxVal
end Maybe (MdbxVal, MdbxVal)
Nothing = Bool -> m Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
False
pairLEKey MdbxTxn
txn MdbxDbi
dbi MdbxVal
end (Just (MdbxVal
key, MdbxVal
_)) = (Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
0) (Int -> Bool) -> m Int -> m Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> MdbxTxn -> MdbxDbi -> MdbxVal -> MdbxVal -> m Int
forall (m :: * -> *).
MonadIO m =>
MdbxTxn -> MdbxDbi -> MdbxVal -> MdbxVal -> m Int
keyCmp MdbxTxn
txn MdbxDbi
dbi MdbxVal
key MdbxVal
end