leveldb-haskell-0.6.5: Haskell bindings to LevelDB

Copyright(c) 2014 Kim Altintop
LicenseBSD3
Maintainerkim.altintop@gmail.com
Stabilityexperimental
Portabilitynon-portable
Safe HaskellNone
LanguageHaskell2010

Database.LevelDB.Streaming

Contents

Description

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

Synopsis

Documentation

data KeyRange Source #

Constructors

KeyRange 
AllKeys 

data Direction Source #

Constructors

Asc 
Desc 

type Entry = (Key, Value) Source #

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

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

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

Re-exports