Database.LevelDB.Base

LevelDB Haskell binding.

The API closely follows the C-API of LevelDB. For more information, see: http://leveldb.googlecode.com

Exported Types

data DB

Database handle

Instances

Eq DB

data BatchOp

Batch operation

Constructors

Put ByteString ByteString

Del ByteString

Instances

Eq BatchOp

Show BatchOp

newtype Comparator

User-defined comparator

Constructors

Comparator (ByteString -> ByteString -> Ordering)

data Compression

Compression setting

Constructors

NoCompression

Snappy

Instances

Eq Compression

Show Compression

data Options

Options when opening a database

Constructors

Options

Fields

blockRestartInterval :: !Int

Number of keys between restart points for delta encoding of keys.

This parameter can be changed dynamically. Most clients should leave this parameter alone.

Default: 16

blockSize :: !Int

Approximate size of user data packed per block.

Note that the block size specified here corresponds to uncompressed data. The actual size of the unit read from disk may be smaller if compression is enabled.

This parameter can be changed dynamically.

Default: 4k

cacheSize :: !Int

Control over blocks (user data is stored in a set of blocks, and a block is the unit of reading from disk).

If > 0, use the specified cache (in bytes) for blocks. If 0, leveldb will automatically create and use an 8MB internal cache.

Default: 0

comparator :: !(Maybe Comparator)

Comparator used to defined the order of keys in the table.

If Nothing, the default comparator is used, which uses lexicographic bytes-wise ordering.

NOTE: the client must ensure that the comparator supplied here has the same name and orders keys exactly the same as the comparator provided to previous open calls on the same DB.

Default: Nothing

compression :: !Compression

Compress blocks using the specified compression algorithm.

This parameter can be changed dynamically.

Default: Snappy

createIfMissing :: !Bool

If true, the database will be created if it is missing.

Default: False

errorIfExists :: !Bool

It true, an error is raised if the database already exists.

Default: False

maxOpenFiles :: !Int

Number of open files that can be used by the DB.

You may need to increase this if your database has a large working set (budget one open file per 2MB of working set).

Default: 1000

paranoidChecks :: !Bool

If true, the implementation will do aggressive checking of the data it is processing and will stop early if it detects any errors.

This may have unforeseen ramifications: for example, a corruption of one DB entry may cause a large number of entries to become unreadable or for the entire DB to become unopenable.

Default: False

writeBufferSize :: !Int

Amount of data to build up in memory (backed by an unsorted log on disk) before converting to a sorted on-disk file.

Larger values increase performance, especially during bulk loads. Up to to write buffers may be held in memory at the same time, so you may with to adjust this parameter to control memory usage. Also, a larger write buffer will result in a longer recovery time the next time the database is opened.

Default: 4MB

filterPolicy :: !(Maybe (Either BloomFilter FilterPolicy))

Instances

Default Options

data ReadOptions

Options for read operations

Constructors

ReadOptions

Fields

verifyCheckSums :: !Bool

If true, all data read from underlying storage will be verified against corresponding checksuyms.

Default: False

fillCache :: !Bool

Should the data read for this iteration be cached in memory? Callers may with to set this field to false for bulk scans.

Default: True

useSnapshot :: !(Maybe Snapshot)

If Just, read as of the supplied snapshot (which must belong to the DB that is being read and which must not have been released). If Nothing, use an implicit snapshot of the state at the beginning of this read operation.

Default: Nothing

Instances

Eq ReadOptions

Default ReadOptions

data Snapshot

Snapshot handle

Instances

Eq Snapshot

type WriteBatch = [BatchOp]

data WriteOptions

Options for write operations

Constructors

WriteOptions

Fields

sync :: !Bool

If true, the write will be flushed from the operating system buffer cache (by calling WritableFile::Sync()) before the write is considered complete. If this flag is true, writes will be slower.

If this flag is false, and the machine crashes, some recent writes may be lost. Note that if it is just the process that crashes (i.e., the machine does not reboot), no writes will be lost even if sync==false.

In other words, a DB write with sync==false has similar crash semantics as the "write()" system call. A DB write with sync==true has similar crash semantics to a "write()" system call followed by "fsync()".

Default: False

Instances

Eq WriteOptions

Show WriteOptions

Default WriteOptions

type Range = (ByteString, ByteString)

Defaults

defaultOptions :: Options

defaultReadOptions :: ReadOptions

defaultWriteOptions :: WriteOptions

Basic Database Manipulations

withDB :: (MonadMask m, MonadIO m) => FilePath -> Options -> (DB -> m a) -> m a

Run an action with a DB.

withDB path opts = bracket (open path opts) unsafeClose

Note that the DB handle will be released promptly when this function exits.

open :: MonadIO m => FilePath -> Options -> m DB

Open a database.

The returned handle has a finalizer attached which will free the underlying pointers once it goes out of scope. Note, however, that finalizers are not guaranteed to run, and may not run promptly if they do. Use unsafeClose to free the handle immediately, but ensure it is not used after that (otherwise, the program will segault). Alternatively, use the Database.LevelDB.MonadResource API, which will take care of resource management automatically.

put :: MonadIO m => DB -> WriteOptions -> ByteString -> ByteString -> m ()

Write a key/value pair.

delete :: MonadIO m => DB -> WriteOptions -> ByteString -> m ()

Delete a key/value pair.

write :: MonadIO m => DB -> WriteOptions -> WriteBatch -> m ()

Perform a batch mutation.

get :: MonadIO m => DB -> ReadOptions -> ByteString -> m (Maybe ByteString)

Read a value by key.

withSnapshot :: (MonadMask m, MonadIO m) => DB -> (Snapshot -> m a) -> m a

Run an action with a Snapshot of the database.

createSnapshot :: MonadIO m => DB -> m Snapshot

Create a snapshot of the database.

The returned Snapshot should be released with releaseSnapshot.

releaseSnapshot :: MonadIO m => DB -> Snapshot -> m ()

Release a snapshot.

The handle will be invalid after calling this action and should no longer be used.

Filter Policy / Bloom Filter

data FilterPolicy

User-defined filter policy

Constructors

FilterPolicy

Fields

fpName :: String

createFilter :: [ByteString] -> ByteString

keyMayMatch :: ByteString -> ByteString -> Bool

data BloomFilter

Represents the built-in Bloom Filter

createBloomFilter :: MonadIO m => Int -> m BloomFilter

releaseBloomFilter :: MonadIO m => BloomFilter -> m ()

Administrative Functions

data Property

Properties exposed by LevelDB

Constructors

NumFilesAtLevel Int

Stats

SSTables

Instances

Eq Property

Show Property

getProperty :: MonadIO m => DB -> Property -> m (Maybe ByteString)

Get a DB property.

destroy :: MonadIO m => FilePath -> Options -> m ()

Destroy the given LevelDB database.

The database must not be in use during this operation.

repair :: MonadIO m => FilePath -> Options -> m ()

Repair the given LevelDB database.

approximateSize :: MonadIO m => DB -> Range -> m Int64

Inspect the approximate sizes of the different levels.

compactRange :: MonadIO m => DB -> Range -> m ()

Compact the underlying storage for the given Range. In particular this means discarding deleted and overwritten data as well as rearranging the data to reduce the cost of operations accessing the data.

version :: MonadIO m => m (Int, Int)

Return the runtime version of the underlying LevelDB library as a (major, minor) pair.

Iteration

module Database.LevelDB.Iterator