lmdb

<h1>LMDB API</h1>

This CHICKEN binding for LMDB consists of a single module in a shared
library of the same name. You can load the library and import the module
using

<verbatim>
  (import lmdb)
</verbatim>

<h2>Database Environments</h2>

<verbatim>
  current-database-environment
</verbatim>

A parameter holding the current database environment pointer or
<tt>#f</tt>.

<verbatim>
  (database-environment? OBJECT) => BOOLEAN
</verbatim>

Type predicate for database environments.

<verbatim>
  (open-database-environment
   PATH
   [#:mode MODE]
   [#:max-databases MAXDBS]
   [#:max-readers MAXREADERS]
   [#:max-size MAPSIZE]
   [#:fixed-map]
   [#:no-subdirectory]
   [#:read-only]
   [#:write-map]
   [#:no-meta-sync]
   [#:no-sync]
   [#:map-async]
   [#:no-lock]
   [#:no-read-ahead])
  =>
  ENVIRONMENT
</verbatim>

Creates a database environment and configures various settings through
setup methods and the open method.

Unless <tt>#:no-subdirectory</tt> is specified or the given
<tt>PATH</tt> already exists, <tt>PATH</tt> is created as a directory
to contain the database environment.

Sets <tt>current-database-environment</tt> to the newly created
environment.

<verbatim>
  (close-database-environment [ENVIRONMENT]) => VOID
</verbatim>

Closes a database environment and destroys the handle. If no
<tt>ENVIRONMENT</tt> is specified explicitly, closes the current
environment and sets <tt>current-database-environment</tt> to
<tt>#f</tt>.

<verbatim>
  (copy-database-environment PATH [ENVIRONMENT] [#:compact]) => VOID
</verbatim>

Copies a database environment to a new <tt>PATH</tt>, optionally
compacting the data. If no <tt>ENVIRONMENT</tt> is specified
explicitly, the current environment is copied.

<verbatim>
  (with-transaction THUNK [#:read-only]) => (values ...)
</verbatim>

Wraps a call to <tt>THUNK</tt> in a transaction. Returns whatever
<tt>(THUNK)</tt> returns.

The transaction can optionally be configured as read-only. Read-only
transactions may be nested.

All database operations below have to be executed within a transaction.

The transaction is committed upon normal return from <tt>(THUNK)</tt>
and aborted if <tt>(THUNK)</tt> throws an exception.

<h2>Databases</h2>

<verbatim>
  (database? OBJECT) => BOOLEAN
</verbatim>

Type predicate for databases.

<verbatim>
  (open-database
   [NAME]
   [#:reverse-key]
   [#:duplicate-sort]
   [#:integer-key]
   [#:duplicate-fixed]
   [#:integer-duplicate]
   [#:reverse-duplicate]
   [#:create])
  =>
  DATABASE
</verbatim>

Opens a database and configures various flags.

The name of the database can be omitted if the environment was opened
without <tt>#:max-databases</tt> and consists of only a single default
database.

If a named database does not exist, <tt>#:create</tt> must be specified
when it is first opened.

<verbatim>
  (close-database DATABASE [ENVIRONMENT]) => VOID
</verbatim>

Closes a database. If the <tt>ENVIRONMENT</tt> containing the database
is not specified explicitly, the current environment is assumed.

<verbatim>
  (database-ref DATABASE KEY [DEFAULT]) => VALUE
</verbatim>

Extracts a record with the given <tt>KEY</tt> from the database. If no
record is found and <tt>DEFAULT</tt> is given, it is invoked in case it
is a procedure and returned otherwise. An error is signalled if no
record is found and <tt>DEFAULT</tt> is not given.

Database keys can be strings or blobs. Values extracted from the
database are returned as strings.

<verbatim>
  (database-set!
   DATABASE KEY VALUE
   [#:no-duplicate]
   [#:no-overwrite]
   [#:append]
   [#:append/duplicate])
  =>
  VOID

  (set! (database-ref DATABASE KEY) VALUE) => VOID
</verbatim>

Stores a record in the database with several optional flags modifying
the behaviour.

For databases configured with support for multiple values per key, new
values are normally added to the set of existing ones. For databases
with one value per key, existing records are replaced.

Database keys and values can be strings or blobs.

<verbatim>
  (database-exists? DATABASE KEY) => BOOLEAN
</verbatim>

Checks whether a key exists in the database.

Database keys can be strings or blobs.

<verbatim>
  (database-delete! DATABASE KEY [VALUE]) => VOID
</verbatim>

Deletes a record from the database. An error is signalled if no record
is found.

For databases configured with support for multiple values per key, the
<tt>VALUE</tt> to delete can be specified explicitly. For databases
with one value per key, <tt>VALUE</tt> is ignored.

Database keys and values can be strings or blobs.

<verbatim>
  (database-fold
   PROC SEED DATABASE
   [#:from START] [#:to< | #:to<= LIMIT])
  =>
  (PROC KEY VALUE (... (PROC KEY VALUE SEED)))
</verbatim>

Folds over the records in the database. If <tt>START</tt> is given,
only fold over the records with keys greater or equal to
<tt>START</tt>. If <tt>LIMIT</tt> is given, only fold over the records
with keys less than (or equal) to <tt>LIMIT</tt>.

<verbatim>
  (database-walk
   PROC DATABASE
   [#:from START] [#:to< | #:to<= LIMIT])
  =>
  VOID
</verbatim>

Like <tt>database-fold</tt>, but discarding the result.

<verbatim>
  (database->alist
   DATABASE
   [#:from START] [#:to< | #:to<= LIMIT] [#:duplicate-list])
  =>
  ALIST
</verbatim>

Convert the records in the database to an association list. If
<tt>START</tt> is given, only list the records with keys greater or
equal to <tt>START</tt>. If <tt>LIMIT</tt> is given, only list the
records with keys less than (or equal) to <tt>LIMIT</tt>.

Optionally, multiple values for the same key may be folded into lists
rather than producing multiple pairs with the same key in the
association list.

<verbatim>
  (alist->database
   ALIST [NAME]
   [#:reverse-key]
   [#:duplicate-sort]
   [#:integer-key]
   [#:duplicate-fixed]
   [#:integer-duplicate]
   [#:reverse-duplicate]
   [#:create]
   [#:no-duplicate]
   [#:no-overwrite]
   [#:append]
   [#:append/duplicate])
  =>
  DATABASE
</verbatim>

Convert an association list into records in a database. The procedure
accepts the combined flag arguments of <tt>open-database</tt> and
<tt>database-set!</tt>. The procedure returns a new handle to the
database indicated by the given <tt>NAME</tt> or to the default
database.

<tt>ALIST</tt> must contain pairs of keys and values. Keys can be
strings or blobs. Values can be strings, blobs or lists of strings and
blobs. If a value is a list, all its elements are inserted into the
database with the same key.

If <tt>ALIST</tt> was generated by <tt>database->alist</tt>, it is safe
to pass <tt>#:append</tt> or <tt>#:append/duplicate</tt> to this
procedure.