Database.LevelDB.Streaming

High-level, Data.List-like, streaming interface to Database.LevelDB.Iterator.

This module contains types and functions to construct Streams from Iterators, and re-exports the functions operating on Streams from Data.Stream.Monadic.

Note that most of the functions from the latter module are (intentionally) conflicting with the Prelude, it is thus recommended to import this module qualified:

import Database.LevelDB -- or Database.LevelDB.Base
import qualified Database.LevelDB.Streaming as S

Documentation

data KeyRange

Constructors

KeyRange

Fields

start :: !ByteString

end :: ByteString -> Ordering

AllKeys

data Direction

Constructors

Asc

Desc

Instances

Show Direction

type Key = ByteString

type Value = ByteString

type Entry = (Key, Value)

Constructing streams

Caveats:

• remember that Iterators are not threadsafe
• consider that traversing a Stream mutates the underlying Iterator, so the above applies to the Stream as well
• because of the destructive update semantics of Iterators, the following example will (perhaps obviously) not work as expected:

withIter db def $ \ i ->
    toList $ zip (keySlice i AllKeys Asc) (keySlice i AllKeys Desc)

However, the following will work:

withIter db def $ \ i ->
    foldl (+) 0 . map (*2) . map ByteString.length $ keySlice i AllKeys Asc

Here, fusion ensures the key slice is traversed only once, while the next example will incur rewinding the Iterator and traversing it a second time:

withIter db def $ \ i ->
    let slice   = keySlice i AllKeys Asc
        count f = foldl' (\ c k -> c + f k) 0
     in liftM2 (+) (count ByteString.length slice) (count (const 1) slice)

To summarise: it is recommended to always create Streams with their own exclusive Iterator, and to not share them across threads.

keySlice :: (Applicative m, MonadIO m) => Iterator -> KeyRange -> Direction -> Stream m Key

Create a Stream which yields only the keys of the given KeyRange (in the given Direction).

entrySlice :: (Applicative m, MonadIO m) => Iterator -> KeyRange -> Direction -> Stream m Entry

Create a Stream which yields key/value pairs of the given KeyRange (in the given Direction).

Re-exports

module Data.Stream.Monadic