Class LMDB
- java.lang.Object
-
- org.lwjgl.util.lmdb.LMDB
-
public class LMDB extends java.lang.Object
Contains bindings to LMDB, the Symas Lightning Memory-Mapped Database.Getting Started
LMDB is compact, fast, powerful, and robust and implements a simplified variant of the BerkeleyDB (BDB) API.
Everything starts with an environment, created by
env_create
. Once created, this environment must also be opened withenv_open
.env_open
gets passed a name which is interpreted as a directory path. Note that this directory must exist already, it is not created for you. Within that directory, a lock file and a storage file will be generated. If you don't want to use a directory, you can pass theNOSUBDIR
option, in which case the path you provided is used directly as the data file, and another file with a "-lock" suffix added will be used for the lock file.Once the environment is open, a transaction can be created within it using
txn_begin
. Transactions may be read-write or read-only, and read-write transactions may be nested. A transaction must only be used by one thread at a time. Transactions are always required, even for read-only access. The transaction provides a consistent view of the data.Once a transaction has been created, a database can be opened within it using
dbi_open
. If only one database will ever be used in the environment, aNULL
can be passed as the database name. For named databases, theCREATE
flag must be used to create the database if it doesn't already exist. Also,env_set_maxdbs
must be called afterenv_create
and beforeenv_open
to set the maximum number of named databases you want to support.Note: a single transaction can open multiple databases. Generally databases should only be opened once, by the first transaction in the process. After the first transaction completes, the database handles can freely be used by all subsequent transactions.
Within a transaction,
get
andput
can store single key/value pairs if that is all you need to do (but seeCursors
below if you want to do more).A key/value pair is expressed as two
MDBVal
structures. This struct has two fields,mv_size
andmv_data
. The data is avoid
pointer to an array ofmv_size
bytes.Because LMDB is very efficient (and usually zero-copy), the data returned in an
MDBVal
structure may be memory-mapped straight from disk. In other words look but do not touch (orfree()
for that matter). Once a transaction is closed, the values can no longer be used, so make a copy if you need to keep them after that.Cursors
To do more powerful things, we must use a cursor.
Within the transaction, a cursor can be created with
cursor_open
. With this cursor we can store/retrieve/delete (multiple) values usingcursor_get
,cursor_put
, andcursor_del
.cursor_get
positions itself depending on the cursor operation requested, and for some operations, on the supplied key. For example, to list all key/value pairs in a database, use operationFIRST
for the first call tocursor_get
, andNEXT
on subsequent calls, until the end is hit.To retrieve all keys starting from a specified key value, use
SET
.When using
cursor_put
, either the function will position the cursor for you based on thekey
, or you can use operationCURRENT
to use the current position of the cursor. Note thatkey
must then match the current position's key.Summarizing the Opening
So we have a cursor in a transaction which opened a database in an environment which is opened from a filesystem after it was separately created.
Or, we create an environment, open it from a filesystem, create a transaction within it, open a database within that transaction, and create a cursor within all of the above.
Threads and Processes
LMDB uses POSIX locks on files, and these locks have issues if one process opens a file multiple times. Because of this, do not
env_open
a file multiple times from a single process. Instead, share the LMDB environment that has opened the file across all threads. Otherwise, if a single process opens the same environment multiple times, closing it once will remove all the locks held on it, and the other instances will be vulnerable to corruption from other processes.Also note that a transaction is tied to one thread by default using Thread Local Storage. If you want to pass read-only transactions across threads, you can use the
NOTLS
option on the environment.Transactions, Rollbacks, etc.
To actually get anything done, a transaction must be committed using
txn_commit
. Alternatively, all of a transaction's operations can be discarded usingtxn_abort
. In a read-only transaction, any cursors will not automatically be freed. In a read-write transaction, all cursors will be freed and must not be used again.For read-only transactions, obviously there is nothing to commit to storage. The transaction still must eventually be aborted to close any database handle(s) opened in it, or committed to keep the database handles around for reuse in new transactions.
In addition, as long as a transaction is open, a consistent view of the database is kept alive, which requires storage. A read-only transaction that no longer requires this consistent view should be terminated (committed or aborted) when the view is no longer needed (but see below for an optimization).
There can be multiple simultaneously active read-only transactions but only one that can write. Once a single read-write transaction is opened, all further attempts to begin one will block until the first one is committed or aborted. This has no effect on read-only transactions, however, and they may continue to be opened at any time.
Duplicate Keys
get
andput
respectively have no and only some support for multiple key/value pairs with identical keys. If there are multiple values for a key,get
will only return the first value.When multiple values for one key are required, pass the
DUPSORT
flag todbi_open
. In anDUPSORT
database, by defaultput
will not replace the value for a key if the key existed already. Instead it will add the new value to the key. In addition,del
will pay attention to the value field too, allowing for specific values of a key to be deleted.Finally, additional cursor operations become available for traversing through and retrieving duplicate values.
Some Optimization
If you frequently begin and abort read-only transactions, as an optimization, it is possible to only reset and renew a transaction.
txn_reset
releases any old copies of data kept around for a read-only transaction. To reuse this reset transaction, calltxn_renew
on it. Any cursors in this transaction must also be renewed usingcursor_renew
.Note that
txn_reset
is similar totxn_abort
and will close any databases you opened within the transaction.To permanently free a transaction, reset or not, use
txn_abort
.Cleaning Up
For read-only transactions, any cursors created within it must be closed using
cursor_close
.It is very rarely necessary to close a database handle, and in general they should just be left open.
-
-
Field Summary
Fields Modifier and Type Field Description static int
MDB_APPEND
MDB_APPENDDUPWrite flags.static int
MDB_BAD_DBI
MDB_BAD_RSLOT
MDB_BAD_TXN
MDB_BAD_VALSIZE
MDB_CORRUPTEDReturn codes.static int
MDB_CP_COMPACT
Copy flags.static int
MDB_CREATE
Database flags.static int
MDB_CURRENT
Write flags.static int
MDB_CURSOR_FULL
MDB_DBS_FULLReturn codes.static int
MDB_DUPFIXED
MDB_DUPSORTDatabase flags.static int
MDB_FIRST
MDB_FIRST_DUPMDB_cursor_opstatic int
MDB_FIXEDMAP
Environment flags.static int
MDB_GET_BOTH
MDB_GET_BOTH_RANGE
MDB_GET_CURRENT
MDB_GET_MULTIPLEMDB_cursor_opstatic int
MDB_INCOMPATIBLE
Return codes.static int
MDB_INTEGERDUP
MDB_INTEGERKEYDatabase flags.static int
MDB_INVALID
MDB_KEYEXISTReturn codes.static int
MDB_LAST
MDB_LAST_DUPMDB_cursor_opstatic int
MDB_LAST_ERRCODE
MDB_MAP_FULL
MDB_MAP_RESIZEDReturn codes.static int
MDB_MAPASYNC
Environment flags.static int
MDB_MULTIPLE
Write flags.static int
MDB_NEXT
MDB_NEXT_DUP
MDB_NEXT_MULTIPLE
MDB_NEXT_NODUPMDB_cursor_opstatic int
MDB_NODUPDATA
Write flags.static int
MDB_NOLOCK
MDB_NOMEMINIT
MDB_NOMETASYNCEnvironment flags.static int
MDB_NOOVERWRITE
Write flags.static int
MDB_NORDAHEAD
MDB_NOSUBDIR
MDB_NOSYNCEnvironment flags.static int
MDB_NOTFOUND
Return codes.static int
MDB_NOTLS
Environment flags.static int
MDB_PAGE_FULL
MDB_PAGE_NOTFOUND
MDB_PANICReturn codes.static int
MDB_PREV
MDB_PREV_DUP
MDB_PREV_MULTIPLE
MDB_PREV_NODUPMDB_cursor_opstatic int
MDB_RDONLY
Environment flags.static int
MDB_READERS_FULL
Return codes.static int
MDB_RESERVE
Write flags.static int
MDB_REVERSEDUP
MDB_REVERSEKEYDatabase flags.static int
MDB_SET
MDB_SET_KEY
MDB_SET_RANGEMDB_cursor_opstatic int
MDB_SUCCESS
MDB_TLS_FULL
MDB_TXN_FULL
MDB_VERSION_MISMATCHReturn codes.static int
MDB_WRITEMAP
Environment flags.
-
Method Summary
All Methods Static Methods Concrete Methods Modifier and Type Method Description static int
mdb_cmp(long txn, int dbi, MDBVal a, MDBVal b)
Compares two data items according to a particular database.static void
mdb_cursor_close(long cursor)
Closes a cursor handle.static int
mdb_cursor_count(long cursor, org.lwjgl.PointerBuffer countp)
Returns count of duplicates for current key.static int
mdb_cursor_dbi(long cursor)
Return the cursor's database handle.static int
mdb_cursor_del(long cursor, int flags)
Deletes current key/data pair.static int
mdb_cursor_get(long cursor, MDBVal key, MDBVal data, int op)
Retrieves by cursor.static int
mdb_cursor_open(long txn, int dbi, org.lwjgl.PointerBuffer cursor)
Creates a cursor handle.static int
mdb_cursor_put(long cursor, MDBVal key, MDBVal data, int flags)
Stores by cursor.static int
mdb_cursor_renew(long txn, long cursor)
Renews a cursor handle.static long
mdb_cursor_txn(long cursor)
Returns the cursor's transaction handle.static void
mdb_dbi_close(long env, int dbi)
Closes a database handle.static int
mdb_dbi_flags(long txn, int dbi, int[] flags)
Array version of:dbi_flags
static int
mdb_dbi_flags(long txn, int dbi, java.nio.IntBuffer flags)
Retrieve the DB flags for a database handle.static int
mdb_dbi_open(long txn, java.lang.CharSequence name, int flags, int[] dbi)
Array version of:dbi_open
static int
mdb_dbi_open(long txn, java.lang.CharSequence name, int flags, java.nio.IntBuffer dbi)
Opens a database in the environment.static int
mdb_dbi_open(long txn, java.nio.ByteBuffer name, int flags, int[] dbi)
Array version of:dbi_open
static int
mdb_dbi_open(long txn, java.nio.ByteBuffer name, int flags, java.nio.IntBuffer dbi)
Opens a database in the environment.static int
mdb_dcmp(long txn, int dbi, MDBVal a, MDBVal b)
Compares two data items according to a particular database.static int
mdb_del(long txn, int dbi, MDBVal key, MDBVal data)
Deletes items from a database.static int
mdb_drop(long txn, int dbi, boolean del)
Empties or deletes+closes a database.static void
mdb_env_close(long env)
Closes the environment and releases the memory map.static int
mdb_env_copy(long env, java.lang.CharSequence path)
Copies an LMDB environment to the specified path.static int
mdb_env_copy(long env, java.nio.ByteBuffer path)
Copies an LMDB environment to the specified path.static int
mdb_env_copy2(long env, java.lang.CharSequence path, int flags)
Copies an LMDB environment to the specified path, with options.static int
mdb_env_copy2(long env, java.nio.ByteBuffer path, int flags)
Copies an LMDB environment to the specified path, with options.static int
mdb_env_create(org.lwjgl.PointerBuffer env)
Creates an LMDB environment handle.static int
mdb_env_get_flags(long env, int[] flags)
Array version of:env_get_flags
static int
mdb_env_get_flags(long env, java.nio.IntBuffer flags)
Gets environment flags.static int
mdb_env_get_maxkeysize(long env)
Gets the maximum size of keys andDUPSORT
data we can write.static int
mdb_env_get_maxreaders(long env, int[] readers)
Array version of:env_get_maxreaders
static int
mdb_env_get_maxreaders(long env, java.nio.IntBuffer readers)
Gets the maximum number of threads/reader slots for the environment.static int
mdb_env_get_path(long env, org.lwjgl.PointerBuffer path)
Returns the path that was used inenv_open
.static long
mdb_env_get_userctx(long env)
Gets the application information associated with theMDB_env
.static int
mdb_env_info(long env, MDBEnvInfo stat)
Returns information about the LMDB environment.static int
mdb_env_open(long env, java.lang.CharSequence path, int flags, int mode)
Opens an environment handle.static int
mdb_env_open(long env, java.nio.ByteBuffer path, int flags, int mode)
Opens an environment handle.static int
mdb_env_set_flags(long env, int flags, boolean onoff)
Sets environment flags.static int
mdb_env_set_mapsize(long env, long size)
Sets the size of the memory map to use for this environment.static int
mdb_env_set_maxdbs(long env, int dbs)
Sets the maximum number of named databases for the environment.static int
mdb_env_set_maxreaders(long env, int readers)
Sets the maximum number of threads/reader slots for the environment.static int
mdb_env_set_userctx(long env, long ctx)
Set application information associated with theMDB_env
.static int
mdb_env_stat(long env, MDBStat stat)
Returns statistics about the LMDB environment.static int
mdb_env_sync(long env, boolean force)
Flushes the data buffers to disk.static int
mdb_get(long txn, int dbi, MDBVal key, MDBVal data)
Gets items from a database.static int
mdb_put(long txn, int dbi, MDBVal key, MDBVal data, int flags)
Stores items into a database.static int
mdb_reader_check(long env, int[] dead)
Array version of:reader_check
static int
mdb_reader_check(long env, java.nio.IntBuffer dead)
Checks for stale entries in the reader lock table.static int
mdb_reader_list(long env, MDBMsgFuncI func, long ctx)
Dumps the entries in the reader lock table.static int
mdb_set_compare(long txn, int dbi, MDBCmpFuncI cmp)
Sets a custom key comparison function for a database.static int
mdb_set_dupsort(long txn, int dbi, MDBCmpFuncI cmp)
Sets a custom data comparison function for aDUPSORT
database.static int
mdb_set_relctx(long txn, int dbi, long ctx)
Sets a context pointer for aFIXEDMAP
database's relocation function.static int
mdb_set_relfunc(long txn, int dbi, MDBRelFuncI rel)
Sets a relocation function for aFIXEDMAP
database.static int
mdb_stat(long txn, int dbi, MDBStat stat)
Retrieves statistics for a database.static java.lang.String
mdb_strerror(int err)
Returns a string describing a given error code.static void
mdb_txn_abort(long txn)
Abandons all the operations of the transaction instead of saving them.static int
mdb_txn_begin(long env, long parent, int flags, org.lwjgl.PointerBuffer txn)
Creates a transaction for use with the environment.static int
mdb_txn_commit(long txn)
Commits all the operations of a transaction into the database.static long
mdb_txn_env(long txn)
Returns the transaction'sMDB_env
.static long
mdb_txn_id(long txn)
Returns the transaction's ID.static int
mdb_txn_renew(long txn)
Renews a read-only transaction.static void
mdb_txn_reset(long txn)
Resets a read-only transaction.static java.lang.String
mdb_version(int[] major, int[] minor, int[] patch)
Array version of:version
static java.lang.String
mdb_version(java.nio.IntBuffer major, java.nio.IntBuffer minor, java.nio.IntBuffer patch)
Returns the LMDB library version information.static int
nmdb_cmp(long txn, int dbi, long a, long b)
Unsafe version of:cmp
static void
nmdb_cursor_close(long cursor)
Unsafe version of:cursor_close
static int
nmdb_cursor_count(long cursor, long countp)
Unsafe version of:cursor_count
static int
nmdb_cursor_dbi(long cursor)
Unsafe version of:cursor_dbi
static int
nmdb_cursor_del(long cursor, int flags)
Unsafe version of:cursor_del
static int
nmdb_cursor_get(long cursor, long key, long data, int op)
Unsafe version of:cursor_get
static int
nmdb_cursor_open(long txn, int dbi, long cursor)
Unsafe version of:cursor_open
static int
nmdb_cursor_put(long cursor, long key, long data, int flags)
Unsafe version of:cursor_put
static int
nmdb_cursor_renew(long txn, long cursor)
Unsafe version of:cursor_renew
static long
nmdb_cursor_txn(long cursor)
Unsafe version of:cursor_txn
static void
nmdb_dbi_close(long env, int dbi)
Unsafe version of:dbi_close
static int
nmdb_dbi_flags(long txn, int dbi, int[] flags)
Array version of:nmdb_dbi_flags(long, int, long)
static int
nmdb_dbi_flags(long txn, int dbi, long flags)
Unsafe version of:dbi_flags
static int
nmdb_dbi_open(long txn, long name, int flags, int[] dbi)
Array version of:nmdb_dbi_open(long, long, int, long)
static int
nmdb_dbi_open(long txn, long name, int flags, long dbi)
Unsafe version of:dbi_open
static int
nmdb_dcmp(long txn, int dbi, long a, long b)
Unsafe version of:dcmp
static int
nmdb_del(long txn, int dbi, long key, long data)
Unsafe version of:del
static int
nmdb_drop(long txn, int dbi, int del)
Unsafe version of:drop
static void
nmdb_env_close(long env)
Unsafe version of:env_close
static int
nmdb_env_copy(long env, long path)
Unsafe version of:env_copy
static int
nmdb_env_copy2(long env, long path, int flags)
Unsafe version of:env_copy2
static int
nmdb_env_create(long env)
Unsafe version of:env_create
static int
nmdb_env_get_flags(long env, int[] flags)
Array version of:nmdb_env_get_flags(long, long)
static int
nmdb_env_get_flags(long env, long flags)
Unsafe version of:env_get_flags
static int
nmdb_env_get_maxkeysize(long env)
Unsafe version of:env_get_maxkeysize
static int
nmdb_env_get_maxreaders(long env, int[] readers)
Array version of:nmdb_env_get_maxreaders(long, long)
static int
nmdb_env_get_maxreaders(long env, long readers)
Unsafe version of:env_get_maxreaders
static int
nmdb_env_get_path(long env, long path)
Unsafe version of:env_get_path
static long
nmdb_env_get_userctx(long env)
Unsafe version of:env_get_userctx
static int
nmdb_env_info(long env, long stat)
Unsafe version of:env_info
static int
nmdb_env_open(long env, long path, int flags, int mode)
Unsafe version of:env_open
static int
nmdb_env_set_flags(long env, int flags, int onoff)
Unsafe version of:env_set_flags
static int
nmdb_env_set_mapsize(long env, long size)
Unsafe version of:env_set_mapsize
static int
nmdb_env_set_maxdbs(long env, int dbs)
Unsafe version of:env_set_maxdbs
static int
nmdb_env_set_maxreaders(long env, int readers)
Unsafe version of:env_set_maxreaders
static int
nmdb_env_set_userctx(long env, long ctx)
Unsafe version of:env_set_userctx
static int
nmdb_env_stat(long env, long stat)
Unsafe version of:env_stat
static int
nmdb_env_sync(long env, int force)
Unsafe version of:env_sync
static int
nmdb_get(long txn, int dbi, long key, long data)
Unsafe version of:get
static int
nmdb_put(long txn, int dbi, long key, long data, int flags)
Unsafe version of:put
static int
nmdb_reader_check(long env, int[] dead)
Array version of:nmdb_reader_check(long, long)
static int
nmdb_reader_check(long env, long dead)
Unsafe version of:reader_check
static int
nmdb_reader_list(long env, long func, long ctx)
Unsafe version of:reader_list
static int
nmdb_set_compare(long txn, int dbi, long cmp)
Unsafe version of:set_compare
static int
nmdb_set_dupsort(long txn, int dbi, long cmp)
Unsafe version of:set_dupsort
static int
nmdb_set_relctx(long txn, int dbi, long ctx)
Unsafe version of:set_relctx
static int
nmdb_set_relfunc(long txn, int dbi, long rel)
Unsafe version of:set_relfunc
static int
nmdb_stat(long txn, int dbi, long stat)
Unsafe version of:stat
static long
nmdb_strerror(int err)
Unsafe version of:strerror
static void
nmdb_txn_abort(long txn)
Unsafe version of:txn_abort
static int
nmdb_txn_begin(long env, long parent, int flags, long txn)
Unsafe version of:txn_begin
static int
nmdb_txn_commit(long txn)
Unsafe version of:txn_commit
static long
nmdb_txn_env(long txn)
Unsafe version of:txn_env
static long
nmdb_txn_id(long txn)
Unsafe version of:txn_id
static int
nmdb_txn_renew(long txn)
Unsafe version of:txn_renew
static void
nmdb_txn_reset(long txn)
Unsafe version of:txn_reset
static long
nmdb_version(int[] major, int[] minor, int[] patch)
Array version of:nmdb_version(long, long, long)
static long
nmdb_version(long major, long minor, long patch)
Unsafe version of:version
-
-
-
Field Detail
-
MDB_FIXEDMAP, MDB_NOSUBDIR, MDB_NOSYNC, MDB_RDONLY, MDB_NOMETASYNC, MDB_WRITEMAP, MDB_MAPASYNC, MDB_NOTLS, MDB_NOLOCK, MDB_NORDAHEAD, MDB_NOMEMINIT
Environment flags.Enum values:
FIXEDMAP
- mmap at a fixed address (experimental).NOSUBDIR
- No environment directory.NOSYNC
- Don't fsync after commit.RDONLY
- Read only.NOMETASYNC
- Don't fsync metapage after commit.WRITEMAP
- Use writable mmap.MAPASYNC
- Use asynchronous msync whenWRITEMAP
is used.NOTLS
- Tie reader locktable slots toMDB_txn
objects instead of to threads.NOLOCK
- Don't do any locking, caller must manage their own locks.NORDAHEAD
- Don't do readahead (no effect on Windows).NOMEMINIT
- Don't initialize malloc'd memory before writing to datafile.
-
MDB_REVERSEKEY, MDB_DUPSORT, MDB_INTEGERKEY, MDB_DUPFIXED, MDB_INTEGERDUP, MDB_REVERSEDUP, MDB_CREATE
Database flags.Enum values:
REVERSEKEY
- Use reverse string keys.DUPSORT
- Use sorted duplicates.INTEGERKEY
- Numeric keys in native byte order: eitherunsigned int
orsize_t
. The keys must all be of the same size.DUPFIXED
- WithDUPSORT
, sorted dup items have fixed size.INTEGERDUP
- WithDUPSORT
, dups areINTEGERKEY
-style integers.REVERSEDUP
- WithDUPSORT
, use reverse string dups.CREATE
- Create DB if not already existing.
-
MDB_NOOVERWRITE, MDB_NODUPDATA, MDB_CURRENT, MDB_RESERVE, MDB_APPEND, MDB_APPENDDUP, MDB_MULTIPLE
Write flags.Enum values:
NOOVERWRITE
- Don't write if the key already exists.NODUPDATA
- Remove all duplicate data items.CURRENT
- Overwrite the current key/data pair.RESERVE
- Just reserve space for data, don't copy it. Return a pointer to the reserved space.APPEND
- Data is being appended, don't split full pages.APPENDDUP
- Duplicate data is being appended, don't split full pages.MULTIPLE
- Store multiple data items in one call. Only forDUPFIXED
.
-
MDB_CP_COMPACT
Copy flags.Enum values:
CP_COMPACT
- Omit free space from copy, and renumber all pages sequentially.
-
MDB_FIRST, MDB_FIRST_DUP, MDB_GET_BOTH, MDB_GET_BOTH_RANGE, MDB_GET_CURRENT, MDB_GET_MULTIPLE, MDB_LAST, MDB_LAST_DUP, MDB_NEXT, MDB_NEXT_DUP, MDB_NEXT_MULTIPLE, MDB_NEXT_NODUP, MDB_PREV, MDB_PREV_DUP, MDB_PREV_NODUP, MDB_SET, MDB_SET_KEY, MDB_SET_RANGE, MDB_PREV_MULTIPLE
MDB_cursor_opEnum values:
FIRST
- Position at first key/data item.FIRST_DUP
- Position at first data item of current key. Only forDUPSORT
.GET_BOTH
- Position at key/data pair. Only forDUPSORT
.GET_BOTH_RANGE
- position at key, nearest data. Only forDUPSORT
.GET_CURRENT
- Return key/data at current cursor position.GET_MULTIPLE
- Return up to a page of duplicate data items from current cursor position. Move cursor to prepare forNEXT_MULTIPLE
. Only forDUPFIXED
.LAST
- Position at last key/data item.LAST_DUP
- Position at last data item of current key. Only forDUPSORT
.NEXT
- Position at next data item.NEXT_DUP
- Position at next data item of current key. Only forDUPSORT
.NEXT_MULTIPLE
- Return up to a page of duplicate data items from next cursor position. Move cursor to prepare forNEXT_MULTIPLE
. Only forDUPFIXED
.NEXT_NODUP
- Position at first data item of next key.PREV
- Position at previous data item.PREV_DUP
- Position at previous data item of current key. Only forDUPSORT
.PREV_NODUP
- Position at last data item of previous key.SET
- Position at specified key.SET_KEY
- Position at specified key, return key + data.SET_RANGE
- Position at first key greater than or equal to specified key.PREV_MULTIPLE
- Position at previous page and return up to a page of duplicate data items. Only forDUPFIXED
.
-
MDB_SUCCESS, MDB_KEYEXIST, MDB_NOTFOUND, MDB_PAGE_NOTFOUND, MDB_CORRUPTED, MDB_PANIC, MDB_VERSION_MISMATCH, MDB_INVALID, MDB_MAP_FULL, MDB_DBS_FULL, MDB_READERS_FULL, MDB_TLS_FULL, MDB_TXN_FULL, MDB_CURSOR_FULL, MDB_PAGE_FULL, MDB_MAP_RESIZED, MDB_INCOMPATIBLE, MDB_BAD_RSLOT, MDB_BAD_TXN, MDB_BAD_VALSIZE, MDB_BAD_DBI, MDB_LAST_ERRCODE
Return codes.Enum values:
SUCCESS
- Successful result.KEYEXIST
- Key/data pair already exists.NOTFOUND
- Key/data pair not found (EOF).PAGE_NOTFOUND
- Requested page not found - this usually indicates corruption.CORRUPTED
- Located page was wrong type.PANIC
- Update of meta page failed or environment had fatal error.VERSION_MISMATCH
- Environment version mismatch.INVALID
- File is not a valid LMDB file.MAP_FULL
- Environment mapsize reached.DBS_FULL
- Environment maxdbs reached.READERS_FULL
- Environment maxreaders reached.TLS_FULL
- Too many TLS keys in use - Windows only.TXN_FULL
- Txn has too many dirty pages.CURSOR_FULL
- Cursor stack too deep - internal error.PAGE_FULL
- Page has not enough space - internal error.MAP_RESIZED
- Database contents grew beyond environment mapsize.INCOMPATIBLE
- The operation expects anDUPSORT
/DUPFIXED
database. Opening a named DB when the unnamed DB hasDUPSORT
/INTEGERKEY
. Accessing a data record as a database, or vice versa. The database was dropped and recreated with different flags.BAD_RSLOT
- Invalid reuse of reader locktable slot.BAD_TXN
- Transaction must abort, has a child, or is invalid.BAD_VALSIZE
- Unsupported size of key/DB name/data, or wrongDUPFIXED
size.BAD_DBI
- The specified DBI was changed unexpectedly.LAST_ERRCODE
- The last defined error code.
-
-
Method Detail
-
nmdb_version
public static long nmdb_version(long major, long minor, long patch)
Unsafe version of:version
-
mdb_version
@Nullable public static java.lang.String mdb_version(@Nullable java.nio.IntBuffer major, @Nullable java.nio.IntBuffer minor, @Nullable java.nio.IntBuffer patch)
Returns the LMDB library version information.- Parameters:
major
- if non-NULL
, the library major version number is copied hereminor
- if non-NULL
, the library minor version number is copied herepatch
- if non-NULL
, the library patch version number is copied here- Returns:
- the library version as a string
-
nmdb_strerror
public static long nmdb_strerror(int err)
Unsafe version of:strerror
-
mdb_strerror
public static java.lang.String mdb_strerror(int err)
Returns a string describing a given error code.This function is a superset of the ANSI C X3.159-1989 (ANSI C) strerror(3) function. If the error code is greater than or equal to 0, then the string returned by the system function strerror(3) is returned. If the error code is less than 0, an error string corresponding to the LMDB library error is returned.
- Parameters:
err
- the error code- Returns:
- the description of the error
-
nmdb_env_create
public static int nmdb_env_create(long env)
Unsafe version of:env_create
-
mdb_env_create
public static int mdb_env_create(org.lwjgl.PointerBuffer env)
Creates an LMDB environment handle.This function allocates memory for a
MDB_env
structure. To release the allocated memory and discard the handle, callenv_close
. Before the handle may be used, it must be opened usingenv_open
. Various other options may also need to be set before opening the handle, e.g.env_set_mapsize
,env_set_maxreaders
,env_set_maxdbs
, depending on usage requirements.- Parameters:
env
- the address where the new handle will be stored- Returns:
- a non-zero error value on failure and 0 on success
-
nmdb_env_open
public static int nmdb_env_open(long env, long path, int flags, int mode)
Unsafe version of:env_open
-
mdb_env_open
public static int mdb_env_open(long env, java.nio.ByteBuffer path, int flags, int mode) public static int mdb_env_open(long env, java.lang.CharSequence path, int flags, int mode)
Opens an environment handle.If this function fails,
env_close
must be called to discard theMDB_env
handle.- Parameters:
env
- an environment handle returned byenv_create
path
- the directory in which the database files reside. This directory must already exist and be writable.flags
- Special options for this environment. This parameter must be set to 0 or by bitwise OR'ing together one or more of the values described here. Flags set byenv_set_flags
are also used.FIXEDMAP
Use a fixed address for the mmap region. This flag must be specified when creating the environment, and is stored persistently in the environment. If successful, the memory map will always reside at the same virtual address and pointers used to reference data items in the database will be constant across multiple invocations. This option may not always work, depending on how the operating system has allocated memory to shared libraries and other uses.
The feature is highly experimental.
NOSUBDIR
By default, LMDB creates its environment in a directory whose pathname is given in
path
, and creates its data and lock files under that directory. With this option,path
is used as-is for the database main data file. The database lock file is thepath
with "-lock" appended.RDONLY
Open the environment in read-only mode. No write operations will be allowed. LMDB will still modify the lock file - except on read-only filesystems, where LMDB does not use locks.
WRITEMAP
Use a writeable memory map unless
RDONLY
is set. This uses fewer mallocs but loses protection from application bugs like wild pointer writes and other bad updates into the database. This may be slightly faster for DBs that fit entirely in RAM, but is slower for DBs larger than RAM.Incompatible with nested transactions.
Do not mix processes with and without
WRITEMAP
on the same environment. This can defeat durability (env_sync
etc).NOMETASYNC
Flush system buffers to disk only once per transaction, omit the metadata flush. Defer that until the system flushes files to disk, or next non-
RDONLY
commit orenv_sync
. This optimization maintains database integrity, but a system crash may undo the last committed transaction. I.e. it preserves the ACI (atomicity, consistency, isolation) but not D (durability) database property.This flag may be changed at any time using
env_set_flags
.NOSYNC
Don't flush system buffers to disk when committing a transaction. This optimization means a system crash can corrupt the database or lose the last transactions if buffers are not yet flushed to disk. The risk is governed by how often the system flushes dirty buffers to disk and how often
env_sync
is called. However, if the filesystem preserves write order and theWRITEMAP
flag is not used, transactions exhibit ACI (atomicity, consistency, isolation) properties and only lose D (durability). I.e. database integrity is maintained, but a system crash may undo the final transactions. Note that (NOSYNC
|WRITEMAP
) leaves the system with no hint for when to write transactions to disk, unlessenv_sync
is called. (MAPASYNC
|WRITEMAP
) may be preferable.This flag may be changed at any time using
env_set_flags
.MAPASYNC
When using
WRITEMAP
, use asynchronous flushes to disk. As withNOSYNC
, a system crash can then corrupt the database or lose the last transactions. Callingenv_sync
ensures on-disk database integrity until next commit.This flag may be changed at any time using
env_set_flags
.NOTLS
Don't use Thread-Local Storage. Tie reader locktable slots to
MDB_txn
objects instead of to threads. I.e.txn_reset
keeps the slot reseved for theMDB_txn
object. A thread may use parallel read-only transactions. A read-only transaction may span threads if the user synchronizes its use. Applications that multiplex many user threads over individual OS threads need this option. Such an application must also serialize the write transactions in an OS thread, since LMDB's write locking is unaware of the user threads.NOLOCK
Don't do any locking. If concurrent access is anticipated, the caller must manage all concurrency itself. For proper operation the caller must enforce single-writer semantics, and must ensure that no readers are using old transactions while a writer is active. The simplest approach is to use an exclusive lock so that no readers may be active at all when a writer begins.
NORDAHEAD
Turn off readahead. Most operating systems perform readahead on read requests by default. This option turns it off if the OS supports it. Turning it off may help random read performance when the DB is larger than RAM and system RAM is full.
The option is not implemented on Windows.
NOMEMINIT
Don't initialize malloc'd memory before writing to unused spaces in the data file. By default, memory for pages written to the data file is obtained using malloc. While these pages may be reused in subsequent transactions, freshly malloc'd pages will be initialized to zeroes before use. This avoids persisting leftover data from other code (that used the heap and subsequently freed the memory) into the data file. Note that many other system libraries may allocate and free memory from the heap for arbitrary uses. E.g., stdio may use the heap for file I/O buffers. This initialization step has a modest performance cost so some applications may want to disable it using this flag. This option can be a problem for applications which handle sensitive data like passwords, and it makes memory checkers like Valgrind noisy. This flag is not needed with
WRITEMAP
, which writes directly to the mmap instead of using malloc for pages. The initialization is also skipped ifRESERVE
is used; the caller is expected to overwrite all of the memory that was reserved in that case.This flag may be changed at any time using
env_set_flags
.
mode
- The UNIX permissions to set on created files and semaphores.This parameter is ignored on Windows.
- Returns:
- a non-zero error value on failure and 0 on success. Some possible errors are:
VERSION_MISMATCH
- the version of the LMDB library doesn't match the version that created the database environment.INVALID
- the environment file headers are corrupted.ENOENT
- the directory specified by the path parameter doesn't exist.EACCES
- the user didn't have permission to access the environment files.EAGAIN
- the environment was locked by another process.
-
nmdb_env_copy
public static int nmdb_env_copy(long env, long path)
Unsafe version of:env_copy
-
mdb_env_copy
public static int mdb_env_copy(long env, java.nio.ByteBuffer path) public static int mdb_env_copy(long env, java.lang.CharSequence path)
Copies an LMDB environment to the specified path.This function may be used to make a backup of an existing environment. No lockfile is created, since it gets recreated at need.
This call can trigger significant file size growth if run in parallel with write transactions, because it employs a read-only transaction.
- Parameters:
env
- an environment handle returned byenv_create
. It must have already been opened successfully.path
- the directory in which the copy will reside. This directory must already exist and be writable but must otherwise be empty.- Returns:
- a non-zero error value on failure and 0 on success
-
nmdb_env_copy2
public static int nmdb_env_copy2(long env, long path, int flags)
Unsafe version of:env_copy2
-
mdb_env_copy2
public static int mdb_env_copy2(long env, java.nio.ByteBuffer path, int flags) public static int mdb_env_copy2(long env, java.lang.CharSequence path, int flags)
Copies an LMDB environment to the specified path, with options.This function may be used to make a backup of an existing environment. No lockfile is created, since it gets recreated at need.
This call can trigger significant file size growth if run in parallel with write transactions, because it employs a read-only transaction.
- Parameters:
env
- an environment handle returned byenv_create
. It must have already been opened successfully.path
- the directory in which the copy will reside. This directory must already exist and be writable but must otherwise be empty.flags
- special options for this operation. This parameter must be set to 0 or by bitwise OR'ing together one or more of the values described here.CP_COMPACT
- Perform compaction while copying: omit free pages and sequentially renumber all pages in output. This option consumes more CPU and runs more slowly than the default.
-
nmdb_env_stat
public static int nmdb_env_stat(long env, long stat)
Unsafe version of:env_stat
-
mdb_env_stat
public static int mdb_env_stat(long env, MDBStat stat)
Returns statistics about the LMDB environment.- Parameters:
env
- an environment handle returned byenv_create
stat
- the address of anMDBStat
structure where the statistics will be copied- Returns:
- a non-zero error value on failure and 0 on success
-
nmdb_env_info
public static int nmdb_env_info(long env, long stat)
Unsafe version of:env_info
-
mdb_env_info
public static int mdb_env_info(long env, MDBEnvInfo stat)
Returns information about the LMDB environment.- Parameters:
env
- an environment handle returned byenv_create
stat
- the address of anMDBEnvInfo
structure where the information will be copied- Returns:
- a non-zero error value on failure and 0 on success
-
nmdb_env_sync
public static int nmdb_env_sync(long env, int force)
Unsafe version of:env_sync
-
mdb_env_sync
public static int mdb_env_sync(long env, boolean force)
Flushes the data buffers to disk.Data is always written to disk when
txn_commit
is called, but the operating system may keep it buffered. LMDB always flushes the OS buffers upon commit as well, unless the environment was opened withNOSYNC
or in partNOMETASYNC
. This call is not valid if the environment was opened withRDONLY
.- Parameters:
env
- an environment handle returned byenv_create
force
- if non-zero, force a synchronous flush. Otherwise if the environment has theNOSYNC
flag set the flushes will be omitted, and withMAPASYNC
they will be asynchronous.- Returns:
- a non-zero error value on failure and 0 on success. Some possible errors are:
EACCES
- the environment is read-only.EINVAL
- an invalid parameter was specified.EIO
- an error occurred during synchronization.
-
nmdb_env_close
public static void nmdb_env_close(long env)
Unsafe version of:env_close
-
mdb_env_close
public static void mdb_env_close(long env)
Closes the environment and releases the memory map.Only a single thread may call this function. All transactions, databases, and cursors must already be closed before calling this function. Attempts to use any such handles after calling this function will cause a SIGSEGV. The environment handle will be freed and must not be used again after this call.
- Parameters:
env
- an environment handle returned byenv_create
-
nmdb_env_set_flags
public static int nmdb_env_set_flags(long env, int flags, int onoff)
Unsafe version of:env_set_flags
-
mdb_env_set_flags
public static int mdb_env_set_flags(long env, int flags, boolean onoff)
Sets environment flags.This may be used to set some flags in addition to those from
env_open
, or to unset these flags. If several threads change the flags at the same time, the result is undefined.- Parameters:
env
- an environment handle returned byenv_create
flags
- the flags to change, bitwise OR'ed togetheronoff
- a non-zero value sets the flags, zero clears them.- Returns:
- a non-zero error value on failure and 0 on success. Some possible errors are:
EINVAL
- an invalid parameter was specified.
-
nmdb_env_get_flags
public static int nmdb_env_get_flags(long env, long flags)
Unsafe version of:env_get_flags
-
mdb_env_get_flags
public static int mdb_env_get_flags(long env, java.nio.IntBuffer flags)
Gets environment flags.- Parameters:
env
- an environment handle returned byenv_create
flags
- the address of an integer to store the flags- Returns:
- a non-zero error value on failure and 0 on success
-
nmdb_env_get_path
public static int nmdb_env_get_path(long env, long path)
Unsafe version of:env_get_path
-
mdb_env_get_path
public static int mdb_env_get_path(long env, org.lwjgl.PointerBuffer path)
Returns the path that was used inenv_open
.- Parameters:
env
- an environment handle returned byenv_create
path
- address of a string pointer to contain the path. This is the actual string in the environment, not a copy. It should not be altered in any way.- Returns:
- a non-zero error value on failure and 0 on success
-
nmdb_env_set_mapsize
public static int nmdb_env_set_mapsize(long env, long size)
Unsafe version of:env_set_mapsize
-
mdb_env_set_mapsize
public static int mdb_env_set_mapsize(long env, long size)
Sets the size of the memory map to use for this environment.The size should be a multiple of the OS page size. The default is 10485760 bytes. The size of the memory map is also the maximum size of the database. The value should be chosen as large as possible, to accommodate future growth of the database.
This function should be called after
env_create
and beforeenv_open
. It may be called at later times if no transactions are active in this process. Note that the library does not check for this condition, the caller must ensure it explicitly.The new size takes effect immediately for the current process but will not be persisted to any others until a write transaction has been committed by the current process. Also, only mapsize increases are persisted into the environment.
If the mapsize is increased by another process, and data has grown beyond the range of the current mapsize,
txn_begin
will returnMAP_RESIZED
. This function may be called with a size of zero to adopt the new size.Any attempt to set a size smaller than the space already consumed by the environment will be silently changed to the current size of the used space.
- Parameters:
env
- an environment handle returned byenv_create
size
- the size in bytes- Returns:
- a non-zero error value on failure and 0 on success. Some possible errors are:
EINVAL
- an invalid parameter was specified, or the environment has an active write transaction.
-
nmdb_env_set_maxreaders
public static int nmdb_env_set_maxreaders(long env, int readers)
Unsafe version of:env_set_maxreaders
-
mdb_env_set_maxreaders
public static int mdb_env_set_maxreaders(long env, int readers)
Sets the maximum number of threads/reader slots for the environment.This defines the number of slots in the lock table that is used to track readers in the environment. The default is 126.
Starting a read-only transaction normally ties a lock table slot to the current thread until the environment closes or the thread exits. If
NOTLS
is in use,txn_begin
instead ties the slot to theMDB_txn
object until it or theMDB_env
object is destroyed.This function may only be called after
env_create
and beforeenv_open
.- Parameters:
env
- an environment handle returned byenv_create
readers
- the maximum number of reader lock table slots- Returns:
- a non-zero error value on failure and 0 on success. Some possible errors are:
EINVAL
- an invalid parameter was specified, or the environment is already open.
-
nmdb_env_get_maxreaders
public static int nmdb_env_get_maxreaders(long env, long readers)
Unsafe version of:env_get_maxreaders
-
mdb_env_get_maxreaders
public static int mdb_env_get_maxreaders(long env, java.nio.IntBuffer readers)
Gets the maximum number of threads/reader slots for the environment.- Parameters:
env
- an environment handle returned byenv_create
readers
- address of an integer to store the number of readers- Returns:
- a non-zero error value on failure and 0 on success
-
nmdb_env_set_maxdbs
public static int nmdb_env_set_maxdbs(long env, int dbs)
Unsafe version of:env_set_maxdbs
-
mdb_env_set_maxdbs
public static int mdb_env_set_maxdbs(long env, int dbs)
Sets the maximum number of named databases for the environment.This function is only needed if multiple databases will be used in the environment. Simpler applications that use the environment as a single unnamed database can ignore this option.
This function may only be called after
env_create
and beforeenv_open
.Currently a moderate number of slots are cheap but a huge number gets expensive: 7-120 words per transaction, and every
dbi_open
does a linear search of the opened slots.- Parameters:
env
- an environment handle returned byenv_create
dbs
- the maximum number of databases- Returns:
- a non-zero error value on failure and 0 on success. Some possible errors are:
EINVAL
- an invalid parameter was specified, or the environment is already open.
-
nmdb_env_get_maxkeysize
public static int nmdb_env_get_maxkeysize(long env)
Unsafe version of:env_get_maxkeysize
-
mdb_env_get_maxkeysize
public static int mdb_env_get_maxkeysize(long env)
Gets the maximum size of keys andDUPSORT
data we can write.Depends on the compile-time constant
MAXKEYSIZE
. Default 511.- Parameters:
env
- an environment handle returned byenv_create
-
nmdb_env_set_userctx
public static int nmdb_env_set_userctx(long env, long ctx)
Unsafe version of:env_set_userctx
-
mdb_env_set_userctx
public static int mdb_env_set_userctx(long env, long ctx)
Set application information associated with theMDB_env
.- Parameters:
env
- an environment handle returned byenv_create
ctx
- an arbitrary pointer for whatever the application needs
-
nmdb_env_get_userctx
public static long nmdb_env_get_userctx(long env)
Unsafe version of:env_get_userctx
-
mdb_env_get_userctx
public static long mdb_env_get_userctx(long env)
Gets the application information associated with theMDB_env
.- Parameters:
env
- an environment handle returned byenv_create
-
nmdb_txn_begin
public static int nmdb_txn_begin(long env, long parent, int flags, long txn)
Unsafe version of:txn_begin
-
mdb_txn_begin
public static int mdb_txn_begin(long env, long parent, int flags, org.lwjgl.PointerBuffer txn)
Creates a transaction for use with the environment.The transaction handle may be discarded using
txn_abort
ortxn_commit
.A transaction and its cursors must only be used by a single thread, and a thread may only have a single transaction at a time. If
NOTLS
is in use, this does not apply to read-only transactions.Cursors may not span transactions.
- Parameters:
env
- an environment handle returned byenv_create
parent
- if this parameter is non-NULL
, the new transaction will be a nested transaction, with the transaction indicated byparent
as its parent. Transactions may be nested to any level. A parent transaction and its cursors may not issue any other operations thantxn_commit
andtxn_abort
while it has active child transactions.flags
- special options for this transaction. This parameter must be set to 0 or by bitwise OR'ing together one or more of the values described here.RDONLY
- This transaction will not perform any write operations.
txn
- address where the newMDB_txn
handle will be stored- Returns:
- a non-zero error value on failure and 0 on success. Some possible errors are:
PANIC
- a fatal error occurred earlier and the environment must be shut down.MAP_RESIZED
- another process wrote data beyond thisMDB_env
's mapsize and this environment's map must be resized as well. Seeenv_set_mapsize
.READERS_FULL
- a read-only transaction was requested and the reader lock table is full. Seeenv_set_maxreaders
.ENOMEM
- out of memory.
-
nmdb_txn_env
public static long nmdb_txn_env(long txn)
Unsafe version of:txn_env
-
mdb_txn_env
public static long mdb_txn_env(long txn)
Returns the transaction'sMDB_env
.- Parameters:
txn
- a transaction handle returned bytxn_begin
.
-
nmdb_txn_id
public static long nmdb_txn_id(long txn)
Unsafe version of:txn_id
-
mdb_txn_id
public static long mdb_txn_id(long txn)
Returns the transaction's ID.This returns the identifier associated with this transaction. For a read-only transaction, this corresponds to the snapshot being read; concurrent readers will frequently have the same transaction ID.
- Parameters:
txn
- a transaction handle returned bytxn_begin
.- Returns:
- a transaction ID, valid if input is an active transaction
-
nmdb_txn_commit
public static int nmdb_txn_commit(long txn)
Unsafe version of:txn_commit
-
mdb_txn_commit
public static int mdb_txn_commit(long txn)
Commits all the operations of a transaction into the database.The transaction handle is freed. It and its cursors must not be used again after this call, except with
cursor_renew
.Earlier documentation incorrectly said all cursors would be freed. Only write-transactions free cursors.
- Parameters:
txn
- a transaction handle returned bytxn_begin
.- Returns:
- a non-zero error value on failure and 0 on success. Some possible errors are:
EINVAL
- an invalid parameter was specified.ENOSPC
- no more disk space.EIO
- a low-level I/O error occurred while writing.ENOMEM
- out of memory.
-
nmdb_txn_abort
public static void nmdb_txn_abort(long txn)
Unsafe version of:txn_abort
-
mdb_txn_abort
public static void mdb_txn_abort(long txn)
Abandons all the operations of the transaction instead of saving them.The transaction handle is freed. It and its cursors must not be used again after this call, except with
cursor_renew
.Earlier documentation incorrectly said all cursors would be freed. Only write-transactions free cursors. "
- Parameters:
txn
- a transaction handle returned bytxn_begin
.
-
nmdb_txn_reset
public static void nmdb_txn_reset(long txn)
Unsafe version of:txn_reset
-
mdb_txn_reset
public static void mdb_txn_reset(long txn)
Resets a read-only transaction.Aborts the transaction like
txn_abort
, but keeps the transaction handle.txn_renew
may reuse the handle. This saves allocation overhead if the process will start a new read-only transaction soon, and also locking overhead ifNOTLS
is in use. The reader table lock is released, but the table slot stays tied to its thread orMDB_txn
. Usetxn_abort
to discard a reset handle, and to free its lock table slot ifNOTLS
is in use.Cursors opened within the transaction must not be used again after this call, except with
cursor_renew
.Reader locks generally don't interfere with writers, but they keep old versions of database pages allocated. Thus they prevent the old pages from being reused when writers commit new data, and so under heavy load the database size may grow much more rapidly than otherwise.
- Parameters:
txn
- a transaction handle returned bytxn_begin
.
-
nmdb_txn_renew
public static int nmdb_txn_renew(long txn)
Unsafe version of:txn_renew
-
mdb_txn_renew
public static int mdb_txn_renew(long txn)
Renews a read-only transaction.This acquires a new reader lock for a transaction handle that had been released by
txn_reset
. It must be called before a reset transaction may be used again.- Parameters:
txn
- a transaction handle returned bytxn_begin
.
-
nmdb_dbi_open
public static int nmdb_dbi_open(long txn, long name, int flags, long dbi)
Unsafe version of:dbi_open
-
mdb_dbi_open
public static int mdb_dbi_open(long txn, @Nullable java.nio.ByteBuffer name, int flags, java.nio.IntBuffer dbi) public static int mdb_dbi_open(long txn, @Nullable java.lang.CharSequence name, int flags, java.nio.IntBuffer dbi)
Opens a database in the environment.A database handle denotes the name and parameters of a database, independently of whether such a database exists. The database handle may be discarded by calling
dbi_close
. The old database handle is returned if the database was already open. The handle may only be closed once.The database handle will be private to the current transaction until the transaction is successfully committed. If the transaction is aborted the handle will be closed automatically. After a successful commit the handle will reside in the shared environment, and may be used by other transactions.
This function must not be called from multiple concurrent transactions in the same process. A transaction that uses this function must finish (either commit or abort) before any other transaction in the process may use this function.
To use named databases (with
name
!=NULL
),env_set_maxdbs
must be called before opening the environment. Database names are keys in the unnamed database, and may be read but not written.- Parameters:
txn
- a transaction handle returned bytxn_begin
.name
- the name of the database to open. If only a single database is needed in the environment, this value may beNULL
.flags
- special options for this database. This parameter must be set to 0 or by bitwise OR'ing together one or more of the values described here.REVERSEKEY
Keys are strings to be compared in reverse order, from the end of the strings to the beginning. By default, Keys are treated as strings and compared from beginning to end.
DUPSORT
Duplicate keys may be used in the database. (Or, from another perspective, keys may have multiple data items, stored in sorted order.) By default keys must be unique and may have only a single data item.
INTEGERKEY
Keys are binary integers in native byte order, either
unsigned int
orsize_t
, and will be sorted as such. The keys must all be of the same size.DUPFIXED
This flag may only be used in combination with
DUPSORT
. This option tells the library that the data items for this database are all the same size, which allows further optimizations in storage and retrieval. When all data items are the same size, theGET_MULTIPLE
,NEXT_MULTIPLE
andPREV_MULTIPLE
cursor operations may be used to retrieve multiple items at once.INTEGERDUP
This option specifies that duplicate data items are binary integers, similar to
INTEGERKEY
keys.REVERSEDUP
This option specifies that duplicate data items should be compared as strings in reverse order.
CREATE
Create the named database if it doesn't exist. This option is not allowed in a read-only transaction or a read-only environment.
dbi
- address where the newMDB_dbi
handle will be stored- Returns:
- a non-zero error value on failure and 0 on success. Some possible errors are:
NOTFOUND
- the specified database doesn't exist in the environment andCREATE
was not specified.DBS_FULL
- too many databases have been opened. Seeenv_set_maxdbs
.
-
nmdb_stat
public static int nmdb_stat(long txn, int dbi, long stat)
Unsafe version of:stat
-
mdb_stat
public static int mdb_stat(long txn, int dbi, MDBStat stat)
Retrieves statistics for a database.
-
nmdb_dbi_flags
public static int nmdb_dbi_flags(long txn, int dbi, long flags)
Unsafe version of:dbi_flags
-
mdb_dbi_flags
public static int mdb_dbi_flags(long txn, int dbi, java.nio.IntBuffer flags)
Retrieve the DB flags for a database handle.
-
nmdb_dbi_close
public static void nmdb_dbi_close(long env, int dbi)
Unsafe version of:dbi_close
-
mdb_dbi_close
public static void mdb_dbi_close(long env, int dbi)
Closes a database handle. Normally unnecessary. Use with care:This call is not mutex protected. Handles should only be closed by a single thread, and only if no other threads are going to reference the database handle or one of its cursors any further. Do not close a handle if an existing transaction has modified its database. Doing so can cause misbehavior from database corruption to errors like
BAD_VALSIZE
(since the DB name is gone).Closing a database handle is not necessary, but lets
dbi_open
reuse the handle value. Usually it's better to set a biggerenv_set_maxdbs
, unless that value would be large.- Parameters:
env
- an environment handle returned byenv_create
dbi
- a database handle returned bydbi_open
-
nmdb_drop
public static int nmdb_drop(long txn, int dbi, int del)
Unsafe version of:drop
-
mdb_drop
public static int mdb_drop(long txn, int dbi, boolean del)
Empties or deletes+closes a database.See
dbi_close
for restrictions about closing the DB handle.
-
nmdb_set_compare
public static int nmdb_set_compare(long txn, int dbi, long cmp)
Unsafe version of:set_compare
-
mdb_set_compare
public static int mdb_set_compare(long txn, int dbi, MDBCmpFuncI cmp)
Sets a custom key comparison function for a database.The comparison function is called whenever it is necessary to compare a key specified by the application with a key currently stored in the database. If no comparison function is specified, and no special key flags were specified with
dbi_open
, the keys are compared lexically, with shorter keys collating before longer keys.This function must be called before any data access functions are used, otherwise data corruption may occur. The same comparison function must be used by every program accessing the database, every time the database is used.
- Parameters:
txn
- a transaction handle returned bytxn_begin
.dbi
- a database handle returned bydbi_open
cmp
- anMDBCmpFunc
function
-
nmdb_set_dupsort
public static int nmdb_set_dupsort(long txn, int dbi, long cmp)
Unsafe version of:set_dupsort
-
mdb_set_dupsort
public static int mdb_set_dupsort(long txn, int dbi, MDBCmpFuncI cmp)
Sets a custom data comparison function for aDUPSORT
database.This comparison function is called whenever it is necessary to compare a data item specified by the application with a data item currently stored in the database.
This function only takes effect if the database was opened with the
DUPSORT
flag.If no comparison function is specified, and no special key flags were specified with
dbi_open
, the data items are compared lexically, with shorter items collating before longer items.This function must be called before any data access functions are used, otherwise data corruption may occur. The same comparison function must be used by every program accessing the database, every time the database is used.
- Parameters:
txn
- a transaction handle returned bytxn_begin
.dbi
- a database handle returned bydbi_open
cmp
- anMDBCmpFunc
function
-
nmdb_set_relfunc
public static int nmdb_set_relfunc(long txn, int dbi, long rel)
Unsafe version of:set_relfunc
-
mdb_set_relfunc
public static int mdb_set_relfunc(long txn, int dbi, MDBRelFuncI rel)
Sets a relocation function for aFIXEDMAP
database.The relocation function is called whenever it is necessary to move the data of an item to a different position in the database (e.g. through tree balancing operations, shifts as a result of adds or deletes, etc.). It is intended to allow address/position-dependent data items to be stored in a database in an environment opened with the
FIXEDMAP
option.Currently the relocation feature is unimplemented and setting this function has no effect.
- Parameters:
txn
- a transaction handle returned bytxn_begin
.dbi
- a database handle returned bydbi_open
rel
- anMDBRelFunc
function
-
nmdb_set_relctx
public static int nmdb_set_relctx(long txn, int dbi, long ctx)
Unsafe version of:set_relctx
-
mdb_set_relctx
public static int mdb_set_relctx(long txn, int dbi, long ctx)
Sets a context pointer for aFIXEDMAP
database's relocation function.See
set_relfunc
andMDBRelFunc
for more details.- Parameters:
txn
- a transaction handle returned bytxn_begin
.dbi
- a database handle returned bydbi_open
ctx
- an arbitrary pointer for whatever the application needs. It will be passed to the callback function set byMDBRelFunc
as itsrelctx
parameter whenever the callback is invoked.
-
nmdb_get
public static int nmdb_get(long txn, int dbi, long key, long data)
Unsafe version of:get
-
mdb_get
public static int mdb_get(long txn, int dbi, MDBVal key, MDBVal data)
Gets items from a database.This function retrieves key/data pairs from the database. The address and length of the data associated with the specified
key
are returned in the structure to whichdata
refers.If the database supports duplicate keys (
DUPSORT
) then the first data item for the key will be returned. Retrieval of other items requires the use ofcursor_get
.The memory pointed to by the returned values is owned by the database. The caller need not dispose of the memory, and may not modify it in any way. For values returned in a read-only transaction any modification attempts will cause a SIGSEGV.
Values returned from the database are valid only until a subsequent update operation, or the end of the transaction.
-
nmdb_put
public static int nmdb_put(long txn, int dbi, long key, long data, int flags)
Unsafe version of:put
-
mdb_put
public static int mdb_put(long txn, int dbi, MDBVal key, MDBVal data, int flags)
Stores items into a database.This function stores key/data pairs in the database. The default behavior is to enter the new key/data pair, replacing any previously existing key if duplicates are disallowed, or adding a duplicate data item if duplicates are allowed (
DUPSORT
).- Parameters:
txn
- a transaction handle returned bytxn_begin
.dbi
- a database handle returned bydbi_open
key
- the key to store in the databasedata
- the data to storeflags
- special options for this operation. This parameter must be set to 0 or by bitwise OR'ing together one or more of the values described here.NODUPDATA
- enter the new key/data pair only if it does not already appear in the database. This flag may only be specified if the database was opened withDUPSORT
. The function will returnKEYEXIST
if the key/data pair already appears in the database.NOOVERWRITE
- enter the new key/data pair only if the key does not already appear in the database. The function will returnKEYEXIST
if the key already appears in the database, even if the database supports duplicates (DUPSORT
). Thedata
parameter will be set to point to the existing item.RESERVE
- reserve space for data of the given size, but don't copy the given data. Instead, return a pointer to the reserved space, which the caller can fill in later - before the next update operation or the transaction ends. This saves an extra memcpy if the data is being generated later.LMDB does nothing else with this memory, the caller is expected to modify all of the space requested. This flag must not be specified if the database was opened with
DUPSORT
.APPEND
- append the given key/data pair to the end of the database. This option allows fast bulk loading when keys are already known to be in the correct order. Loading unsorted keys with this flag will cause aKEYEXIST
error.APPENDDUP
- as above, but for sorted dup data.
-
nmdb_del
public static int nmdb_del(long txn, int dbi, long key, long data)
Unsafe version of:del
-
mdb_del
public static int mdb_del(long txn, int dbi, MDBVal key, @Nullable MDBVal data)
Deletes items from a database.This function removes key/data pairs from the database. If the database does not support sorted duplicate data items (
DUPSORT
) the data parameter is ignored.If the database supports sorted duplicates and the data parameter is
NULL
, all of the duplicate data items for the key will be deleted. Otherwise, if the data parameter is non-NULL
only the matching data item will be deleted.This function will return
NOTFOUND
if the specified key/data pair is not in the database.
-
nmdb_cursor_open
public static int nmdb_cursor_open(long txn, int dbi, long cursor)
Unsafe version of:cursor_open
-
mdb_cursor_open
public static int mdb_cursor_open(long txn, int dbi, org.lwjgl.PointerBuffer cursor)
Creates a cursor handle.A cursor is associated with a specific transaction and database. A cursor cannot be used when its database handle is closed. Nor when its transaction has ended, except with
cursor_renew
.It can be discarded with
cursor_close
.A cursor in a write-transaction can be closed before its transaction ends, and will otherwise be closed when its transaction ends.
A cursor in a read-only transaction must be closed explicitly, before or after its transaction ends. It can be reused with
cursor_renew
before finally closing it.Earlier documentation said that cursors in every transaction were closed when the transaction committed or aborted.
-
nmdb_cursor_close
public static void nmdb_cursor_close(long cursor)
Unsafe version of:cursor_close
-
mdb_cursor_close
public static void mdb_cursor_close(long cursor)
Closes a cursor handle.The cursor handle will be freed and must not be used again after this call. Its transaction must still be live if it is a write-transaction.
- Parameters:
cursor
- a cursor handle returned bycursor_open
-
nmdb_cursor_renew
public static int nmdb_cursor_renew(long txn, long cursor)
Unsafe version of:cursor_renew
-
mdb_cursor_renew
public static int mdb_cursor_renew(long txn, long cursor)
Renews a cursor handle.A cursor is associated with a specific transaction and database. Cursors that are only used in read-only transactions may be re-used, to avoid unnecessary malloc/free overhead. The cursor may be associated with a new read-only transaction, and referencing the same database handle as it was created with. This may be done whether the previous transaction is live or dead.
- Parameters:
txn
- a transaction handle returned bytxn_begin
.cursor
- a cursor handle returned bycursor_open
-
nmdb_cursor_txn
public static long nmdb_cursor_txn(long cursor)
Unsafe version of:cursor_txn
-
mdb_cursor_txn
public static long mdb_cursor_txn(long cursor)
Returns the cursor's transaction handle.- Parameters:
cursor
- a cursor handle returned bycursor_open
-
nmdb_cursor_dbi
public static int nmdb_cursor_dbi(long cursor)
Unsafe version of:cursor_dbi
-
mdb_cursor_dbi
public static int mdb_cursor_dbi(long cursor)
Return the cursor's database handle.- Parameters:
cursor
- a cursor handle returned bycursor_open
-
nmdb_cursor_get
public static int nmdb_cursor_get(long cursor, long key, long data, int op)
Unsafe version of:cursor_get
-
mdb_cursor_get
public static int mdb_cursor_get(long cursor, MDBVal key, MDBVal data, int op)
Retrieves by cursor.This function retrieves key/data pairs from the database. The address and length of the key are returned in the object to which
key
refers (except for the case of theSET
option, in which thekey
object is unchanged), and the address and length of the data are returned in the object to whichdata
refers.See
get
for restrictions on using the output values.- Parameters:
cursor
- a cursor handle returned bycursor_open
key
- the key for a retrieved itemdata
- the data of a retrieved itemop
- a cursor operationMDB_cursor_op
. One of:FIRST
FIRST_DUP
GET_BOTH
GET_BOTH_RANGE
GET_CURRENT
GET_MULTIPLE
LAST
LAST_DUP
NEXT
NEXT_DUP
NEXT_MULTIPLE
NEXT_NODUP
PREV
PREV_DUP
PREV_NODUP
SET
SET_KEY
SET_RANGE
PREV_MULTIPLE
-
nmdb_cursor_put
public static int nmdb_cursor_put(long cursor, long key, long data, int flags)
Unsafe version of:cursor_put
-
mdb_cursor_put
public static int mdb_cursor_put(long cursor, MDBVal key, MDBVal data, int flags)
Stores by cursor.This function stores key/data pairs into the database. The cursor is positioned at the new item, or on failure usually near it.
Earlier documentation incorrectly said errors would leave the state of the cursor unchanged.
- Parameters:
cursor
- a cursor handle returned bycursor_open
key
- the key operated ondata
- the data operated onflags
- options for this operation. This parameter must be set to 0 or one of the values described here.CURRENT
- replace the item at the current cursor position. Thekey
parameter must still be provided, and must match it. If using sorted duplicates (DUPSORT
) the data item must still sort into the same place. This is intended to be used when the new data is the same size as the old. Otherwise it will simply perform a delete of the old record followed by an insert.NODUPDATA
- enter the new key/data pair only if it does not already appear in the database. This flag may only be specified if the database was opened withDUPSORT
. The function will returnKEYEXIST
if the key/data pair already appears in the database.NOOVERWRITE
- enter the new key/data pair only if the key does not already appear in the database. The function will returnKEYEXIST
if the key already appears in the database, even if the database supports duplicates (DUPSORT
).RESERVE
- reserve space for data of the given size, but don't copy the given data. Instead, return a pointer to the reserved space, which the caller can fill in later - before the next update operation or the transaction ends. This saves an extra memcpy if the data is being generated later. This flag must not be specified if the database was opened withDUPSORT
.APPEND
- append the given key/data pair to the end of the database. No key comparisons are performed. This option allows fast bulk loading when keys are already known to be in the correct order. Loading unsorted keys with this flag will cause aKEYEXIST
error.APPENDDUP
- as above, but for sorted dup data.MULTIPLE
- store multiple contiguous data elements in a single request. This flag may only be specified if the database was opened withDUPFIXED
. Thedata
argument must be an array of twoMDBVal
. Themv_size
of the firstMDBVal
must be the size of a single data element. Themv_data
of the firstMDBVal
must point to the beginning of the array of contiguous data elements. Themv_size
of the secondMDBVal
must be the count of the number of data elements to store. On return this field will be set to the count of the number of elements actually written. Themv_data
of the secondMDBVal
is unused.
-
nmdb_cursor_del
public static int nmdb_cursor_del(long cursor, int flags)
Unsafe version of:cursor_del
-
mdb_cursor_del
public static int mdb_cursor_del(long cursor, int flags)
Deletes current key/data pair.This function deletes the key/data pair to which the cursor refers.
This does not invalidate the cursor, so operations such as
NEXT
can still be used on it. BothNEXT
andGET_CURRENT
will return the same record after this operation.- Parameters:
cursor
- a cursor handle returned bycursor_open
flags
- options for this operation. This parameter must be set to 0 or one of the values described here.
-
nmdb_cursor_count
public static int nmdb_cursor_count(long cursor, long countp)
Unsafe version of:cursor_count
-
mdb_cursor_count
public static int mdb_cursor_count(long cursor, org.lwjgl.PointerBuffer countp)
Returns count of duplicates for current key.This call is only valid on databases that support sorted duplicate data items
DUPSORT
.- Parameters:
cursor
- a cursor handle returned bycursor_open
countp
- address where the count will be stored
-
nmdb_cmp
public static int nmdb_cmp(long txn, int dbi, long a, long b)
Unsafe version of:cmp
-
mdb_cmp
public static int mdb_cmp(long txn, int dbi, MDBVal a, MDBVal b)
Compares two data items according to a particular database.This returns a comparison as if the two data items were keys in the specified database.
-
nmdb_dcmp
public static int nmdb_dcmp(long txn, int dbi, long a, long b)
Unsafe version of:dcmp
-
mdb_dcmp
public static int mdb_dcmp(long txn, int dbi, MDBVal a, MDBVal b)
Compares two data items according to a particular database.This returns a comparison as if the two items were data items of the specified database. The database must have the
DUPSORT
flag.
-
nmdb_reader_list
public static int nmdb_reader_list(long env, long func, long ctx)
Unsafe version of:reader_list
-
mdb_reader_list
public static int mdb_reader_list(long env, MDBMsgFuncI func, long ctx)
Dumps the entries in the reader lock table.- Parameters:
env
- an environment handle returned byenv_create
func
- anMDBMsgFunc
functionctx
- anything the message function needs
-
nmdb_reader_check
public static int nmdb_reader_check(long env, long dead)
Unsafe version of:reader_check
-
mdb_reader_check
public static int mdb_reader_check(long env, java.nio.IntBuffer dead)
Checks for stale entries in the reader lock table.- Parameters:
env
- an environment handle returned byenv_create
dead
- number of stale slots that were cleared
-
nmdb_version
public static long nmdb_version(int[] major, int[] minor, int[] patch)
Array version of:nmdb_version(long, long, long)
-
mdb_version
@Nullable public static java.lang.String mdb_version(@Nullable int[] major, @Nullable int[] minor, @Nullable int[] patch)
Array version of:version
-
nmdb_env_get_flags
public static int nmdb_env_get_flags(long env, int[] flags)
Array version of:nmdb_env_get_flags(long, long)
-
mdb_env_get_flags
public static int mdb_env_get_flags(long env, int[] flags)
Array version of:env_get_flags
-
nmdb_env_get_maxreaders
public static int nmdb_env_get_maxreaders(long env, int[] readers)
Array version of:nmdb_env_get_maxreaders(long, long)
-
mdb_env_get_maxreaders
public static int mdb_env_get_maxreaders(long env, int[] readers)
Array version of:env_get_maxreaders
-
nmdb_dbi_open
public static int nmdb_dbi_open(long txn, long name, int flags, int[] dbi)
Array version of:nmdb_dbi_open(long, long, int, long)
-
mdb_dbi_open
public static int mdb_dbi_open(long txn, @Nullable java.nio.ByteBuffer name, int flags, int[] dbi) public static int mdb_dbi_open(long txn, @Nullable java.lang.CharSequence name, int flags, int[] dbi)
Array version of:dbi_open
-
nmdb_dbi_flags
public static int nmdb_dbi_flags(long txn, int dbi, int[] flags)
Array version of:nmdb_dbi_flags(long, int, long)
-
mdb_dbi_flags
public static int mdb_dbi_flags(long txn, int dbi, int[] flags)
Array version of:dbi_flags
-
nmdb_reader_check
public static int nmdb_reader_check(long env, int[] dead)
Array version of:nmdb_reader_check(long, long)
-
mdb_reader_check
public static int mdb_reader_check(long env, int[] dead)
Array version of:reader_check
-
-