type cursor[link]

type cursor = ffi::cursor;

Opaque structure for navigating through a database.

type dbi[link]

type dbi = struct {
	txn: *ffi::txn,
	dbi: ffi::dbi,
};

An individual LMDB database, i.e. one key-value store.

They are only valid for the lifetime of their parent transaction.

type env[link]

type env = ffi::env;

Opaque structure for a database environment.

A DB environment supports multiple databases, all residing in the same shared-memory map.

type txn[link]

type txn = ffi::txn;

Opaque structure for a transaction handle.

type val[link]

type val = ffi::val;

Generic structure used for passing keys and data in and out of the database.

type error[link]

type error = !int;

Any error returned by LMDB.

fn dbi_open[link]

fn dbi_open(txn: *txn, name: nullable *str, flags: uint) (dbi | error);

Opens a database from a transaction.

fn env_close[link]

fn env_close(env: *env) void;

Closes an env.

fn env_create[link]

fn env_create() (*env | error);

Creates an env. The caller must free it with env_close.

fn env_open[link]

fn env_open(env: *env, path: str, flag: uint, mode: u32) (void | error);

Associates an env with a on-disk environment.

fn get[link]

fn get(dbi: dbi, key: *val) (val | error);

Get a value from the database. The returned value is only valid for the lifetime of the transaction associated with the dbi.

fn put[link]

fn put(dbi: dbi, key: *val, data: *val, flags: uint) (void | error);

Put a value into the database.

fn strerror[link]

fn strerror(err: error) str;

Create a human-readable error message from an error.

fn txn_abort[link]

fn txn_abort(txn: *txn) (void | error);

Abort a transaction, discaring anything it does.

fn txn_begin[link]

fn txn_begin(env: *env, flags: uint, parent: nullable *txn = null) (*txn | error);

Initiate a transaction.

fn txn_commit[link]

fn txn_commit(txn: *txn) (void | error);

Commiting a transaction, writing anything it does.

fn u8s_val[link]

fn u8s_val(s: []u8) val;

Convert a []u8 to a val.

fn val_u8s[link]

fn val_u8s(s: *val) []u8;

Convert a val to a []u8.