From 983c8b5e6822d06b0c48ff851767e16fcd1fb96b Mon Sep 17 00:00:00 2001 From: Runxi Yu Date: Sat, 15 Mar 2025 19:23:23 +0800 Subject: [PATCH] Move the raw bindings to lmdb::ffi and remove docs --- example/get.ha | 28 ++++++++++++++-------------- example/put.ha | 28 ++++++++++++++-------------- lmdb/README | 131 ----------------------------------------------------- lmdb/cursor.ha | 76 ----------------------------------------------------- lmdb/cursor_get_operations.ha | 23 ----------------------- lmdb/dbi.ha | 46 ---------------------------------------------- lmdb/env.ha | 204 ----------------------------------------------------- lmdb/ffi/README | 4 ++++ lmdb/ffi/cursor.ha | 4 ++++ lmdb/ffi/cursor_get_operations.ha | 21 +++++++++++++++++++++ lmdb/ffi/dbi.ha | 3 +++ lmdb/ffi/env.ha | 7 +++++++ lmdb/ffi/flags_copy.ha | 1 + lmdb/ffi/flags_db.ha | 7 +++++++ lmdb/ffi/flags_env.ha | 11 +++++++++++ lmdb/ffi/flags_write.ha | 7 +++++++ lmdb/ffi/items.ha | 3 +++ lmdb/ffi/reader.ha | 1 + lmdb/ffi/return_codes.ha | 22 ++++++++++++++++++++++ lmdb/ffi/txn.ha | 3 +++ lmdb/ffi/types.ha | 9 +++++++++ lmdb/flags_copy.ha | 2 -- lmdb/flags_db.ha | 14 -------------- lmdb/flags_env.ha | 22 ---------------------- lmdb/flags_write.ha | 14 -------------- lmdb/items.ha | 84 ----------------------------------------------------- lmdb/reader.ha | 8 -------- lmdb/return_codes.ha | 50 -------------------------------------------------- lmdb/txn.ha | 62 ----------------------------------------------------- lmdb/types.ha | 35 ----------------------------------- diff --git a/example/get.ha b/example/get.ha index 5d87b4c21bbaf39241ba417d179e6ffbcecb92d8..c901eb3cd7a4fbb99a2ddc94699942384b8ab48b 100644 --- a/example/get.ha +++ b/example/get.ha @@ -1,6 +1,6 @@ use fmt; use io; -use lmdb; +use lmdb_ffi = lmdb::ffi; use strings; use types; use types::c; @@ -11,53 +11,53 @@ if (len(os::args) != 3) { abort("need two arguments (db dir, key)"); }; - const key = lmdb::val{ + const key = lmdb_ffi::val{ mv_size = len(strings::toutf8(os::args[2])), mv_data = c::unterminatedstr(os::args[2]): *opaque, }; - let val: lmdb::val = lmdb::val{ + let val: lmdb_ffi::val = lmdb_ffi::val{ mv_size = 0, mv_data = null, }; - let env: nullable *lmdb::env = null; - let rc: int = lmdb::env_create(&env); + let env: nullable *lmdb_ffi::env = null; + let rc: int = lmdb_ffi::env_create(&env); if (rc != 0) { fmt::printf("error: {}\n", rc)!; abort("failed to create env"); }; - let env: *lmdb::env = env as *lmdb::env; + let env: *lmdb_ffi::env = env as *lmdb_ffi::env; let path = c::fromstr(os::args[1]); defer free(path); - rc = lmdb::env_open(env, path, 0, 0o644); + rc = lmdb_ffi::env_open(env, path, 0, 0o644); if (rc != 0) { fmt::printf("error: {}\n", rc)!; abort("failed to open env"); }; - let txn: nullable *lmdb::txn = null; - rc = lmdb::txn_begin(env, null, 0, &txn); + let txn: nullable *lmdb_ffi::txn = null; + rc = lmdb_ffi::txn_begin(env, null, 0, &txn); if (rc != 0) { fmt::printf("error: {}\n", rc)!; abort("failed to create txn"); }; - let txn: *lmdb::txn = txn as *lmdb::txn; + let txn: *lmdb_ffi::txn = txn as *lmdb_ffi::txn; - let dbi: lmdb::dbi = 0; - rc = lmdb::dbi_open(txn, null, lmdb::CREATE, &dbi); + let dbi: lmdb_ffi::dbi = 0; + rc = lmdb_ffi::dbi_open(txn, null, lmdb_ffi::CREATE, &dbi); if (rc != 0) { fmt::printf("error: {}\n", rc)!; abort("failed to create dbi"); }; - rc = lmdb::get(txn, dbi, &key, &val); + rc = lmdb_ffi::get(txn, dbi, &key, &val); if (rc != 0) { fmt::printf("error: {}\n", rc)!; abort("failed to get"); }; - rc = lmdb::txn_abort(txn); + rc = lmdb_ffi::txn_abort(txn); if (rc != 0) { fmt::printf("error: {}\n", rc)!; abort("failed to abort"); diff --git a/example/put.ha b/example/put.ha index 9e4783b6cdd0dbaf313f315b0fa8048636e5b9d1..c432a2e0b85170cfbd6bdb818953267174b92607 100644 --- a/example/put.ha +++ b/example/put.ha @@ -1,6 +1,6 @@ use fmt; use io; -use lmdb; +use lmdb_ffi = lmdb::ffi; use strings; use types; use types::c; @@ -11,7 +11,7 @@ if (len(os::args) != 3) { abort("need two arguments (db dir, key)"); }; - const key = lmdb::val{ + const key = lmdb_ffi::val{ mv_size = len(strings::toutf8(os::args[2])), mv_data = c::unterminatedstr(os::args[2]): *opaque, }; @@ -19,49 +19,49 @@ let v = io::drain(os::stdin)!; defer free(v); - const val = lmdb::val{ + const val = lmdb_ffi::val{ mv_size = len(v), mv_data = (*(&v: *types::slice)).data: *opaque, }; - let env: nullable *lmdb::env = null; - let rc: int = lmdb::env_create(&env); + let env: nullable *lmdb_ffi::env = null; + let rc: int = lmdb_ffi::env_create(&env); if (rc != 0) { fmt::printf("error: {}\n", rc)!; abort("failed to create env"); }; - let env: *lmdb::env = env as *lmdb::env; + let env: *lmdb_ffi::env = env as *lmdb_ffi::env; let path = c::fromstr(os::args[1]); defer free(path); - rc = lmdb::env_open(env, path, 0, 0o644); + rc = lmdb_ffi::env_open(env, path, 0, 0o644); if (rc != 0) { fmt::printf("error: {}\n", rc)!; abort("failed to open env"); }; - let txn: nullable *lmdb::txn = null; - rc = lmdb::txn_begin(env, null, 0, &txn); + let txn: nullable *lmdb_ffi::txn = null; + rc = lmdb_ffi::txn_begin(env, null, 0, &txn); if (rc != 0) { fmt::printf("error: {}\n", rc)!; abort("failed to create txn"); }; - let txn: *lmdb::txn = txn as *lmdb::txn; + let txn: *lmdb_ffi::txn = txn as *lmdb_ffi::txn; - let dbi: lmdb::dbi = 0; - rc = lmdb::dbi_open(txn, null, lmdb::CREATE, &dbi); + let dbi: lmdb_ffi::dbi = 0; + rc = lmdb_ffi::dbi_open(txn, null, lmdb_ffi::CREATE, &dbi); if (rc != 0) { fmt::printf("error: {}\n", rc)!; abort("failed to create dbi"); }; - rc = lmdb::put(txn, dbi, &key, &val, 0); + rc = lmdb_ffi::put(txn, dbi, &key, &val, 0); if (rc != 0) { fmt::printf("error: {}\n", rc)!; abort("failed to put"); }; - rc = lmdb::txn_commit(txn); + rc = lmdb_ffi::txn_commit(txn); if (rc != 0) { fmt::printf("error: {}\n", rc)!; abort("failed to commit"); diff --git a/lmdb/README b/lmdb/README deleted file mode 100644 index 77afb6452e30579affb1659121f4e5e7cda7fbfd..0000000000000000000000000000000000000000 --- a/lmdb/README +++ /dev/null @@ -1,131 +0,0 @@ -Lightning Memory-Mapped Database Manager (LMDB) - -Introduction - -LMDB is a Btree-based database management library modeled loosely on the -BerkeleyDB API, but much simplified. The entire database is exposed -in a memory map, and all data fetches return data directly -from the mapped memory, so no malloc's or memcpy's occur during -data fetches. As such, the library is extremely simple because it -requires no page caching layer of its own, and it is extremely high -performance and memory-efficient. It is also fully transactional with -full ACID semantics, and when the memory map is read-only, the -database integrity cannot be corrupted by stray pointer writes from -application code. - -The library is fully thread-aware and supports concurrent read/write -access from multiple processes and threads. Data pages use a copy-on- -write strategy so no active data pages are ever overwritten, which -also provides resistance to corruption and eliminates the need of any -special recovery procedures after a system crash. Writes are fully -serialized; only one write transaction may be active at a time, which -guarantees that writers can never deadlock. The database structure is -multi-versioned so readers run with no locks; writers cannot block -readers, and readers don't block writers. - -Unlike other well-known database mechanisms which use either write-ahead -transaction logs or append-only data writes, LMDB requires no maintenance -during operation. Both write-ahead loggers and append-only databases -require periodic checkpointing and/or compaction of their log or database -files otherwise they grow without bound. LMDB tracks free pages within -the database and re-uses them for new write operations, so the database -size does not grow without bound in normal use. - -The memory map can be used as a read-only or read-write map. It is -read-only by default as this provides total immunity to corruption. -Using read-write mode offers much higher write performance, but adds -the possibility for stray application writes thru pointers to silently -corrupt the database. Of course if your application code is known to -be bug-free (...) then this is not an issue. - -Caveats - -Troubleshooting the lock file, plus semaphores on BSD systems: - -- A broken lockfile can cause sync issues. - Stale reader transactions left behind by an aborted program - cause further writes to grow the database quickly, and - stale locks can block further operation. - - Fix: Check for stale readers periodically, using the - [[reader_check]] function or the "mdb_stat" tool. - Stale writers will be cleared automatically on some systems: - - Windows - automatic - - Linux, systems using POSIX mutexes with Robust option - automatic - - not on BSD, systems using POSIX semaphores. - Otherwise just make all programs using the database close it; - the lockfile is always reset on first open of the environment. - -- On BSD systems or others configured with [[USE_POSIX_SEM]], - startup can fail due to semaphores owned by another userid. - - Fix: Open and close the database as the user which owns the - semaphores (likely last user) or as root, while no other - process is using the database. - -Restrictions/caveats (in addition to those listed for some functions): - -- Only the database owner should normally use the database on - BSD systems or when otherwise configured with [[USE_POSIX_SEM]]. - Multiple users can cause startup to fail later, as noted above. - -- There is normally no pure read-only mode, since readers need write - access to locks and lock file. Exceptions: On read-only filesystems - or with the [[NOLOCK]] flag described under [[env_open]]. - -- An LMDB configuration will often reserve considerable unused - memory address space and maybe file size for future growth. - This does not use actual memory or disk space, but users may need - to understand the difference so they won't be scared off. - -- By default, in versions before 0.9.10, unused portions of the data - file might receive garbage data from memory freed by other code. - (This does not happen when using the [[WRITEMAP]] flag.) As of - 0.9.10 the default behavior is to initialize such memory before - writing to the data file. Since there may be a slight performance - cost due to this initialization, applications may disable it using - the [[NOMEMINIT]] flag. Applications handling sensitive data - which must not be written should not use this flag. This flag is - irrelevant when using [[WRITEMAP]]. - -- A thread can only use one transaction at a time, plus any child - transactions. Each transaction belongs to one thread. See below. - The [[NOTLS]] flag changes this for read-only transactions. - -- Use an [[env]] in the process which opened it, not after - [[rt::fork]]. - -- Do not have open an LMDB database twice in the same process at - the same time. Not even from a plain [[rt::open]] call - [[rt::close]]ing it - breaks [[rt::fcntl]] advisory locking. (It is OK to reopen it after - [[rt::fork]] - [[rt::exec]], since the lockfile has [[rt::FD_CLOEXEC]] set.) - -- Avoid long-lived transactions. Read transactions prevent - reuse of pages freed by newer write transactions, thus the - database can grow quickly. Write transactions prevent - other write transactions, since writes are serialized. - -- Avoid suspending a process with active transactions. These - would then be "long-lived" as above. Also read transactions - suspended when writers commit could sometimes see wrong data. - -...when several processes can use a database concurrently: - -- Avoid aborting a process with an active transaction. - The transaction becomes "long-lived" as above until a check - for stale readers is performed or the lockfile is reset, - since the process may not remove it from the lockfile. - - This does not apply to write transactions if the system clears - stale writers, see above. - -- If you do that anyway, do a periodic check for stale readers. Or - close the environment once in a while, so the lockfile can get reset. - -- Do not use LMDB databases on remote filesystems, even between - processes on the same host. This breaks [[rt::flock]] on some OSes, - possibly memory map sync, and certainly sync between programs - on different hosts. - -- Opening a database can fail if another process is opening or - closing it at exactly the same time. diff --git a/lmdb/cursor.ha b/lmdb/cursor.ha deleted file mode 100644 index f4d583f5ff3af37bab9201fd8db5fa8dc47dee06..0000000000000000000000000000000000000000 --- a/lmdb/cursor.ha +++ /dev/null @@ -1,76 +0,0 @@ -// Create 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. -// -// - txn: A transaction handle returned by [[txn_begin]] -// - dbi: A database handle returned by [[dbi_open]] -// - cursor: Address where the new [[cursor]] handle will be stored -// - return: EINVAL on failure and 0 on success. -export @symbol("mdb_cursor_open") fn cursor_open(txn: *txn, dbi: *dbi, cursor: *nullable *cursor) int; - -// Close 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. -// -// - cursor: A cursor handle returned by [[cursor_open]] -export @symbol("mdb_cursor_close") fn cursor_close(cursor: *cursor) void; - -// Retrieve 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 the [[SET]] option, in which the key object is unchanged), and -// the address and length of the data are returned in the object to which data -// refers. -// -// See [[get]] for restrictions on using the output values. -// -// Parameters: -// - cursor: A cursor handle returned by [[cursor_open]] -// - key: The key for a retrieved item -// - data: The data of a retrieved item -// - op: A cursor operation [[cursor_op]] -// -// Return value: A non-zero error value on failure and 0 on success. -// Some possible errors are: -// - [[NOTFOUND]] - no matching key found; -// - [[EINVAL]] - an invalid parameter was specified. -export @symbol("mdb_cursor_get") fn cursor_get(cursor: *cursor, key: *val, data: *val, op: cursor_op) int; - - -// Delete 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 MDB_NEXT -// can still be used on it. -// -// Both MDB_NEXT and MDB_GET_CURRENT will return the same record after -// this operation. -// -// Parameters: -// - cursor: A cursor handle returned by [[cursor_open]] -// - flags: Options for this operation. This parameter -// must be set to 0 or one of the values described here. -// -// Flags: -// - [[NODUPDATA]] - delete all of the data items for the current key. This flag -// may only be specified if the database was opened with [[DUPSORT]]. -// -// Return value: A non-zero error value on failure and 0 on success. Some -// possible errors are: -// - EACCES - an attempt was made to write in a read-only transaction. -// - EINVAL - an invalid parameter was specified. -// -export @symbol("mdb_cursor_del") fn cursor_del(cursor: *cursor, flags: uint) int; diff --git a/lmdb/cursor_get_operations.ha b/lmdb/cursor_get_operations.ha deleted file mode 100644 index 7b6396a08f79df99d725d9a2091b8ac29e69c167..0000000000000000000000000000000000000000 --- a/lmdb/cursor_get_operations.ha +++ /dev/null @@ -1,23 +0,0 @@ -// This is the set of all operations for retrieving data -// using a cursor. -export type cursor_op = enum { - FIRST, // Position at first key/data item - FIRST_DUP, // Position at first data item of current key. Only for [[DUPSORT]] - GET_BOTH, // Position at key/data pair. Only for [[DUPSORT]] - GET_BOTH_RANGE, // position at key, nearest data. Only for [[DUPSORT]] - 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 for [[NEXT_MULTIPLE]]. Only for [[DUPFIXED]] - LAST, // Position at last key/data item - LAST_DUP, // Position at last data item of current key. Only for [[DUPSORT]] - NEXT, // Position at next data item - NEXT_DUP, // Position at next data item of current key. Only for [[DUPSORT]] - NEXT_MULTIPLE, // Return up to a page of duplicate data items from next cursor position. Move cursor to prepare for [[NEXT_MULTIPLE]]. Only for [[DUPFIXED]] - 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 for [[DUPSORT]] - 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 for [[DUPFIXED]] -}; diff --git a/lmdb/dbi.ha b/lmdb/dbi.ha deleted file mode 100644 index 61fa7ce126e0df469d0f13a051077a039b0e2921..0000000000000000000000000000000000000000 --- a/lmdb/dbi.ha +++ /dev/null @@ -1,46 +0,0 @@ -use types::c; - -// Open a database in the environment. -// -// A database handle denotes the name and parameters of a database, -// independently of whether such a database actually exists. The database -// handle may be discarded by calling [[dbi_close]]. If the database was -// already open, this function returns the old handle. 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 by [[txn_begin]] -// - name: The name of the database to open. If only a single database is -// needed in the environment, this value may be NULL. -// - flags: Special options for this database. Must be set to 0 or by -// bitwise OR'ing together one or more of the defined flags. -// - dbi: Address where the new [[dbi]] handle will be stored. -// -// Flags: -// - [[REVERSEKEY]]: Keys are compared in reverse order (from end to start) -// - [[DUPSORT]]: Duplicate keys may be used in the database -// - [[INTEGERKEY]]: Keys are binary integers in native byte order -// - [[DUPFIXED]]: Requires [[DUPSORT]]. Data items are all the same size -// - [[INTEGERDUP]]: Duplicate data items are binary integers -// - [[REVERSEDUP]]: Duplicate data items are compared in reverse order -// - [[CREATE]]: Create the named database if it does not exist -// -// Return value: A non-zero error value on failure and 0 on success. Some -// possible errors are: -// - [[NOTFOUND]]: The specified database doesn’t exist and [[CREATE]] was not specified -// - [[DBS_FULL]]: Too many databases have been opened (see [[env_set_maxdbs]]) -export @symbol("mdb_dbi_open") fn dbi_open(txn: *txn, name: const nullable *c::char, flags: uint, dbi: *dbi) int; diff --git a/lmdb/env.ha b/lmdb/env.ha deleted file mode 100644 index c236dd7d2d53291b0cf0e18ad6ead9fafd541e14..0000000000000000000000000000000000000000 --- a/lmdb/env.ha +++ /dev/null @@ -1,204 +0,0 @@ -use types::c; - -// Create an LMDB environment handle. -// -// This function allocates memory for a [[env]] structure. To release -// the allocated memory and discard the handle, call [[env_close]]. -// Before the handle may be used, it must be opened using [[env_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 -// -// Return value: A non-zero error value on failure and 0 on success. -export @symbol("mdb_env_create") fn env_create(env: *nullable *env) int; - -// Open an environment handle. -// -// If this function fails, [[env_close]] must be called to discard the [[env]] handle. -// -// Parameters: -// - env: An environment handle returned by [[env_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 by [[env_set_flags]] are also used. -// - mode: The UNIX permissions to set on created files and semaphores. This -// parameter is ignored on Windows. -// -// - [[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 the path -// 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 MDB_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 MDB_WRITEMAP on the same -// environment. This can defeat durability (#mdb_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-MDB_RDONLY commit or [[env_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 the [[WRITEMAP]] 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, unless [[env_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 with [[NOSYNC]], a system crash can then corrupt the -// database or lose the last transactions. Calling [[env_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 -// [[txn]] objects instead of to threads. I.e. [[txn_reset]] keeps -// the slot reserved for the [[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 if [[RESERVE]] 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]]. -// -// Return value: 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. -export @symbol("mdb_env_open") fn env_open(env: *env, path: const *c::char, flag: uint, mode: mode_t) int; - -// Close the environment and release 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 by [[env_create]] -export @symbol("mdb_env_close") fn env_close(env: *env) void; - -// Set 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 before [[env_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 -// return [[MAP_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 by [[env_create]] -// - size: The size in bytes -// -// Return value: 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. -export @symbol("mdb_env_set_mapsize") fn env_set_mapsize(env: *env, size_: size) int; - -// Set 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 before [[env_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 by [[env_create]] -// - dbs: The maximum number of databases -// -// Return value: 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. -export @symbol("mdb_env_set_maxdbs") fn env_set_maxdbs(env: *env, dbs: dbi) int; diff --git a/lmdb/ffi/README b/lmdb/ffi/README new file mode 100644 index 0000000000000000000000000000000000000000..80c1d1e45341d3b81ad14b92a5bc131f6a7ba489 --- /dev/null +++ b/lmdb/ffi/README @@ -0,0 +1,4 @@ +These are raw unencumbered bindings for LMDB, except that mdb_/MDB_ prefixes +have been removed, and nullable is added where necessary. + +Please refer to the official LMDB documentation at http://www.lmdb.tech/doc/ diff --git a/lmdb/ffi/cursor.ha b/lmdb/ffi/cursor.ha new file mode 100644 index 0000000000000000000000000000000000000000..1ab5a9a1bed2120fe5aaeebbc21e114e09eb704c --- /dev/null +++ b/lmdb/ffi/cursor.ha @@ -0,0 +1,4 @@ +export @symbol("mdb_cursor_open") fn cursor_open(txn: *txn, dbi: *dbi, cursor: *nullable *cursor) int; +export @symbol("mdb_cursor_close") fn cursor_close(cursor: *cursor) void; +export @symbol("mdb_cursor_get") fn cursor_get(cursor: *cursor, key: *val, data: *val, op: cursor_op) int; +export @symbol("mdb_cursor_del") fn cursor_del(cursor: *cursor, flags: uint) int; diff --git a/lmdb/ffi/cursor_get_operations.ha b/lmdb/ffi/cursor_get_operations.ha new file mode 100644 index 0000000000000000000000000000000000000000..1856922c00e412fe2a650521d113813e461d4456 --- /dev/null +++ b/lmdb/ffi/cursor_get_operations.ha @@ -0,0 +1,21 @@ +export type cursor_op = enum { + 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, +}; diff --git a/lmdb/ffi/dbi.ha b/lmdb/ffi/dbi.ha new file mode 100644 index 0000000000000000000000000000000000000000..3b0823c08cdf891db1dd23839e2fb2dc70a2618e --- /dev/null +++ b/lmdb/ffi/dbi.ha @@ -0,0 +1,3 @@ +use types::c; + +export @symbol("mdb_dbi_open") fn dbi_open(txn: *txn, name: const nullable *c::char, flags: uint, dbi: *dbi) int; diff --git a/lmdb/ffi/env.ha b/lmdb/ffi/env.ha new file mode 100644 index 0000000000000000000000000000000000000000..2287257d1508ed86e96773cb9a4042273879d515 --- /dev/null +++ b/lmdb/ffi/env.ha @@ -0,0 +1,7 @@ +use types::c; + +export @symbol("mdb_env_create") fn env_create(env: *nullable *env) int; +export @symbol("mdb_env_open") fn env_open(env: *env, path: const *c::char, flag: uint, mode: mode_t) int; +export @symbol("mdb_env_close") fn env_close(env: *env) void; +export @symbol("mdb_env_set_mapsize") fn env_set_mapsize(env: *env, size_: size) int; +export @symbol("mdb_env_set_maxdbs") fn env_set_maxdbs(env: *env, dbs: dbi) int; diff --git a/lmdb/ffi/flags_copy.ha b/lmdb/ffi/flags_copy.ha new file mode 100644 index 0000000000000000000000000000000000000000..5af3b47aa99ea151748e87a2f93fe86b269401d1 --- /dev/null +++ b/lmdb/ffi/flags_copy.ha @@ -0,0 +1 @@ +export def CP_COMPACT = 0x01; diff --git a/lmdb/ffi/flags_db.ha b/lmdb/ffi/flags_db.ha new file mode 100644 index 0000000000000000000000000000000000000000..4fdc0ba5d813a7c8e3a9e39a7322c3fa8a7e0e97 --- /dev/null +++ b/lmdb/ffi/flags_db.ha @@ -0,0 +1,7 @@ +export def REVERSEKEY = 0x02; +export def DUPSORT = 0x04; +export def INTEGERKEY = 0x08; +export def DUPFIXED = 0x10; +export def INTEGERDUP = 0x20; +export def REVERSEDUP = 0x40; +export def CREATE = 0x40000; diff --git a/lmdb/ffi/flags_env.ha b/lmdb/ffi/flags_env.ha new file mode 100644 index 0000000000000000000000000000000000000000..0de37a53787de185c29c3e3b2662bb80e0b999ca --- /dev/null +++ b/lmdb/ffi/flags_env.ha @@ -0,0 +1,11 @@ +export def FIXEDMAP = 0x01; +export def NOSUBDIR = 0x4000; +export def NOSYNC = 0x10000; +export def RDONLY = 0x20000; +export def NOMETASYNC = 0x40000; +export def WRITEMAP = 0x80000; +export def MAPASYNC = 0x100000; +export def NOTLS = 0x200000; +export def NOLOCK = 0x400000; +export def NORDAHEAD = 0x800000; +export def NOMEMINIT = 0x1000000; diff --git a/lmdb/ffi/flags_write.ha b/lmdb/ffi/flags_write.ha new file mode 100644 index 0000000000000000000000000000000000000000..7509fcb9ef192f0a727751dded6431bbcec60f3d --- /dev/null +++ b/lmdb/ffi/flags_write.ha @@ -0,0 +1,7 @@ +export def NOOVERWRITE = 0x10; +export def NODUPDATA = 0x20; +export def CURRENT = 0x40; +export def RESERVE = 0x10000; +export def APPEND = 0x20000; +export def APPENDDUP = 0x40000; +export def MULTIPLE = 0x80000; diff --git a/lmdb/ffi/items.ha b/lmdb/ffi/items.ha new file mode 100644 index 0000000000000000000000000000000000000000..c93ef40abc280f3521063e48051002b20273bf74 --- /dev/null +++ b/lmdb/ffi/items.ha @@ -0,0 +1,3 @@ +export @symbol("mdb_del") fn del(txn: *txn, dbi: dbi, key: *val, data: *val) int; +export @symbol("mdb_get") fn get(txn: *txn, dbi: dbi, key: *val, data: *val) int; +export @symbol("mdb_put") fn put(txn: *txn, dbi: dbi, key: *val, data: *val, flags: uint) int; diff --git a/lmdb/ffi/reader.ha b/lmdb/ffi/reader.ha new file mode 100644 index 0000000000000000000000000000000000000000..9c4a3f22fd13719cf7838edd769f1a75e051f532 --- /dev/null +++ b/lmdb/ffi/reader.ha @@ -0,0 +1 @@ +export @symbol("mdb_reader_check") fn reader_check(env: *env, dead: int) int; diff --git a/lmdb/ffi/return_codes.ha b/lmdb/ffi/return_codes.ha new file mode 100644 index 0000000000000000000000000000000000000000..9d6d5aae678dffe279ed1b275c3015a2fd2c65c8 --- /dev/null +++ b/lmdb/ffi/return_codes.ha @@ -0,0 +1,22 @@ +export def SUCCESS = 0; +export def KEYEXIST = (-30799); +export def NOTFOUND = (-30798); +export def PAGE_NOTFOUND = (-30797); +export def CORRUPTED = (-30796); +export def PANIC = (-30795); +export def VERSION_MISMATCH = (-30794); +export def INVALID = (-30793); +export def MAP_FULL = (-30792); +export def DBS_FULL = (-30791); +export def READERS_FULL = (-30790); +export def TLS_FULL = (-30789); +export def TXN_FULL = (-30788); +export def CURSOR_FULL = (-30787); +export def PAGE_FULL = (-30786); +export def MAP_RESIZED = (-30785); +export def INCOMPATIBLE = (-30784); +export def BAD_RSLOT = (-30783); +export def BAD_TXN = (-30782); +export def BAD_VALSIZE = (-30781); +export def BAD_DBI = (-30780); +export def LAST_ERRCODE = BAD_DBI; diff --git a/lmdb/ffi/txn.ha b/lmdb/ffi/txn.ha new file mode 100644 index 0000000000000000000000000000000000000000..84da0fc50c80b43f41979b188173be81c35f9173 --- /dev/null +++ b/lmdb/ffi/txn.ha @@ -0,0 +1,3 @@ +export @symbol("mdb_txn_begin") fn txn_begin(env: *env, parent: nullable *txn, flags: uint, txn: *nullable *txn) int; +export @symbol("mdb_txn_commit") fn txn_commit(txn: *txn) int; +export @symbol("mdb_txn_abort") fn txn_abort(txn: *txn) int; diff --git a/lmdb/ffi/types.ha b/lmdb/ffi/types.ha new file mode 100644 index 0000000000000000000000000000000000000000..f3c7eb46bf9b4ca6125a7cf799e85438c59eeb87 --- /dev/null +++ b/lmdb/ffi/types.ha @@ -0,0 +1,9 @@ +export type cursor = opaque; +export type dbi = uint; +export type env = opaque; +export type txn = opaque; +export type val = struct { + mv_size: size, + mv_data: nullable *opaque, +}; +export type mode_t = u32; diff --git a/lmdb/flags_copy.ha b/lmdb/flags_copy.ha deleted file mode 100644 index e7b124e53ac8337cb592aab247d270278b7c4091..0000000000000000000000000000000000000000 --- a/lmdb/flags_copy.ha +++ /dev/null @@ -1,2 +0,0 @@ -// Compacting copy: Omit free space from copy, and renumber all pages sequentially. -export def CP_COMPACT = 0x01; diff --git a/lmdb/flags_db.ha b/lmdb/flags_db.ha deleted file mode 100644 index db7728339325b4adafee468c2d78c903202b6626..0000000000000000000000000000000000000000 --- a/lmdb/flags_db.ha +++ /dev/null @@ -1,14 +0,0 @@ -// use reverse string keys -export def REVERSEKEY = 0x02; -// use sorted duplicates -export def DUPSORT = 0x04; -// numeric keys in native byte order: either unsigned int or size_t. The keys must all be of the same size. -export def INTEGERKEY = 0x08; -// with [[DUPSORT]], sorted dup items have fixed size -export def DUPFIXED = 0x10; -// with [[DUPSORT]], dups are [[INTEGERKEY]]-style integers -export def INTEGERDUP = 0x20; -// with [[DUPSORT]], use reverse string dups -export def REVERSEDUP = 0x40; -// create DB if not already existing -export def CREATE = 0x40000; diff --git a/lmdb/flags_env.ha b/lmdb/flags_env.ha deleted file mode 100644 index d057f030fc5e5f70c89e0ddda1265ade9d36beba..0000000000000000000000000000000000000000 --- a/lmdb/flags_env.ha +++ /dev/null @@ -1,22 +0,0 @@ -// mmap at a fixed address (experimental) -export def FIXEDMAP = 0x01; -// no environment directory -export def NOSUBDIR = 0x4000; -// don't fsync after commit -export def NOSYNC = 0x10000; -// read only -export def RDONLY = 0x20000; -// don't fsync metapage after commit -export def NOMETASYNC = 0x40000; -// use writable mmap -export def WRITEMAP = 0x80000; -// use asynchronous msync when [[WRITEMAP]] is used -export def MAPASYNC = 0x100000; -// tie reader locktable slots to [[txn]] objects instead of to threads -export def NOTLS = 0x200000; -// don't do any locking, caller must manage their own locks -export def NOLOCK = 0x400000; -// don't do readahead (no effect on Windows) -export def NORDAHEAD = 0x800000; -// don't initialize malloc'd memory before writing to datafile -export def NOMEMINIT = 0x1000000; diff --git a/lmdb/flags_write.ha b/lmdb/flags_write.ha deleted file mode 100644 index c2b4e80447abc7d787cbdbea0dd8bbf996ca6d15..0000000000000000000000000000000000000000 --- a/lmdb/flags_write.ha +++ /dev/null @@ -1,14 +0,0 @@ -// For put: Don't write if the key already exists. -export def NOOVERWRITE = 0x10; -// Only for [[DUPSORT]]: For put: don't write if the key and data pair already exist. For mdb_cursor_del: remove all duplicate data items. -export def NODUPDATA = 0x20; -// For mdb_cursor_put: overwrite the current key/data pair -export def CURRENT = 0x40; -// For put: Just reserve space for data, don't copy it. Return a pointer to the reserved space. -export def RESERVE = 0x10000; -// Data is being appended, don't split full pages. -export def APPEND = 0x20000; -// Duplicate data is being appended, don't split full pages. -export def APPENDDUP = 0x40000; -// Store multiple data items in one call. Only for [[DUPFIXED]]. -export def MULTIPLE = 0x80000; diff --git a/lmdb/items.ha b/lmdb/items.ha deleted file mode 100644 index d0fc8e904993b3047c4c8b5845ffde9f9f99a4bd..0000000000000000000000000000000000000000 --- a/lmdb/items.ha +++ /dev/null @@ -1,84 +0,0 @@ -// Delete 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. -// -// Parameters: -// - txn: A transaction handle returned by [[txn_begin]] -// - dbi: A database handle returned by [[dbi_open]] -// - key: The key to delete from the database -// - data: The data to delete -// -// Return value: A non-zero error value on failure and 0 on success. Some possible errors are: -// - EACCES: an attempt was made to write in a read-only transaction. -// - EINVAL: an invalid parameter was specified. -export @symbol("mdb_del") fn del(txn: *txn, dbi: dbi, key: *val, data: *val) int; - - -// Get 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 -// which data 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 of [[cursor_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 cause a SIGSEGV. -// Values returned from the database are valid only until a subsequent update -// operation, or the end of the transaction. -// -// Parameters: -// - txn: A transaction handle returned by [[txn_begin]] -// - dbi: A database handle returned by [[dbi_open]] -// - key: The key to search for in the database -// - data: The data corresponding to the key -// -// Return value: A non-zero error value on failure and 0 on success. Some possible errors are: -// - [[NOTFOUND]]: the key was not in the database -// - EINVAL: an invalid parameter was specified -export @symbol("mdb_get") fn get(txn: *txn, dbi: dbi, key: *val, data: *val) int; - -// Store 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 by [[txn_begin]] -// - dbi: A database handle returned by [[dbi_open]] -// - key: The key to store in the database -// - data: The data to store -// - flags: Special options for this operation. Must be set to 0 or by bitwise -// OR'ing together one or more of the values described below. -// -// Flags: -// - [[NODUPDATA]]: enter the new key/data pair only if it does not already appear -// in the database. Only valid if the database was opened with [[DUPSORT]]. -// Returns [[KEYEXIST]] if the key/data pair already appears. -// - [[NOOVERWRITE]]: enter the new key/data pair only if the key does not already -// appear in the database. Returns [[KEYEXIST]] if the key is present, -// even if the database supports duplicates. The data parameter will be set -// 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 later (before the next update or transaction end). This must not -// be specified if the database was opened with [[DUPSORT]]. -// - [[APPEND]]: append the given key/data pair to the end of the database for -// fast bulk loading when keys are already in correct order. Loading unsorted -// keys with this flag will cause a [[KEYEXIST]] error. -// - [[APPENDDUP]]: same as [[APPEND]], but for sorted duplicate data. -// -// Return value: A non-zero error value on failure and 0 on success. Some possible errors are: -// - [[MAP_FULL]]: the database is full (see [[env_set_mapsize]]) -// - [[TXN_FULL]]: the transaction has too many dirty pages -// - EACCES: an attempt was made to write in a read-only transaction -// - EINVAL: an invalid parameter was specified -export @symbol("mdb_put") fn put(txn: *txn, dbi: dbi, key: *val, data: *val, flags: uint) int; diff --git a/lmdb/reader.ha b/lmdb/reader.ha deleted file mode 100644 index 3d899fc27b7263c47919ecb3caeefcd3c4684408..0000000000000000000000000000000000000000 --- a/lmdb/reader.ha +++ /dev/null @@ -1,8 +0,0 @@ -// Check for stale entries in the reader lock table. -// -// Parameters -// - env: An environment handle returned by [[env_create]] -// - dead: Number of stale slots that were cleared -// -// Return value: 0 on success, non-zero on failure. -export @symbol("mdb_reader_check") fn reader_check(env: *env, dead: int) int; diff --git a/lmdb/return_codes.ha b/lmdb/return_codes.ha deleted file mode 100644 index 6c7765bfbef5a0c56ad6030e0386d97531c658a9..0000000000000000000000000000000000000000 --- a/lmdb/return_codes.ha +++ /dev/null @@ -1,50 +0,0 @@ -// BerkeleyDB uses -30800 to -30999, we'll go under them - -// Successful result -export def SUCCESS = 0; -// key/data pair already exists -export def KEYEXIST = (-30799); -// key/data pair not found (EOF) -export def NOTFOUND = (-30798); -// Requested page not found - this usually indicates corruption -export def PAGE_NOTFOUND = (-30797); -// Located page was wrong type -export def CORRUPTED = (-30796); -// Update of meta page failed or environment had fatal error -export def PANIC = (-30795); -// Environment version mismatch -export def VERSION_MISMATCH = (-30794); -// File is not a valid LMDB file -export def INVALID = (-30793); -// Environment mapsize reached -export def MAP_FULL = (-30792); -// Environment maxdbs reached -export def DBS_FULL = (-30791); -// Environment maxreaders reached -export def READERS_FULL = (-30790); -// Too many TLS keys in use - Windows only -export def TLS_FULL = (-30789); -// Txn has too many dirty pages -export def TXN_FULL = (-30788); -// Cursor stack too deep - internal error -export def CURSOR_FULL = (-30787); -// Page has not enough space - internal error -export def PAGE_FULL = (-30786); -// Database contents grew beyond environment mapsize -export def MAP_RESIZED = (-30785); -// Operation and DB incompatible, or DB type changed. This can mean: -// (1) The operation expects an [[DUPSORT]] / [[DUPFIXED]] database. -// (2) Opening a named DB when the unnamed DB has [[DUPSORT]] / [[INTEGERKEY]]. -// (3) Accessing a data record as a database, or vice versa. -// (4) The database was dropped and recreated with different flags. -export def INCOMPATIBLE = (-30784); -// Invalid reuse of reader locktable slot -export def BAD_RSLOT = (-30783); -// Transaction must abort, has a child, or is invalid -export def BAD_TXN = (-30782); -// Unsupported size of key/DB name/data, or wrong DUPFIXED size -export def BAD_VALSIZE = (-30781); -// The specified DBI was changed unexpectedly -export def BAD_DBI = (-30780); -// The last defined error code -export def LAST_ERRCODE = BAD_DBI; diff --git a/lmdb/txn.ha b/lmdb/txn.ha deleted file mode 100644 index 6310d83e1060b86ba482316390014a9cc0510fc3..0000000000000000000000000000000000000000 --- a/lmdb/txn.ha +++ /dev/null @@ -1,62 +0,0 @@ -// Create a transaction for use with the environment. -// -// The transaction handle may be discarded using [[txn_abort]] or [[txn_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 by [[env_create]] -// - parent: If this parameter is non-NULL, the new transaction -// will be a nested transaction, with the transaction indicated by parent -// as its parent. Transactions may be nested to any level. A parent -// transaction and its cursors may not issue any other operations than -// mdb_txn_commit and mdb_txn_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. -// - txn: Address where the new [[txn]] handle will be stored -// -// Flags -// - [[MDB_RDONLY]] -// This transaction will not perform any write operations. -// -// Return value: 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 this MDB_env's -// - mapsize and this environment's map must be resized as well. -// - See [[env_set_mapsize]]. -// - [[READERS_FULL]] - a read-only transaction was requested and -// - the reader lock table is full. See [[env_set_maxreaders]]. -// - ENOMEM - out of memory. -export @symbol("mdb_txn_begin") fn txn_begin(env: *env, parent: nullable *txn, flags: uint, txn: *nullable *txn) int; - -// Commit 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]]. -// -// Parameters -// - txn: A transaction handle returned by [[txn_begin]] -// -// Return value: 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. -export @symbol("mdb_txn_commit") fn txn_commit(txn: *txn) int; - -// Abandon 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]]. -// -// Parameters -// - txn: A transaction handle returned by [[txn_begin]] -export @symbol("mdb_txn_abort") fn txn_abort(txn: *txn) int; diff --git a/lmdb/types.ha b/lmdb/types.ha deleted file mode 100644 index f19f3d153d7dc11093b6407f50ad5a5d4c339abd..0000000000000000000000000000000000000000 --- a/lmdb/types.ha +++ /dev/null @@ -1,35 +0,0 @@ -// Opaque structure for navigating through a database -export type cursor = opaque; - -// A handle for an individual database in the DB environment. -export type dbi = uint; - -// Opaque structure for a database environment. -// -// A DB environment supports multiple databases, all residing in the same -// shared-memory map. -export type env = opaque; - -// Opaque structure for a transaction handle. -// -// All database operations require a transaction handle. Transactions may be -// read-only or read-write. -export type txn = opaque; - -// Generic structure used for passing keys and data in and out -// of the database. -// -// Values returned from the database are valid only until a subsequent -// update operation, or the end of the transaction. Do not modify or -// free them, they commonly point into the database itself. -// -// Key sizes must be between 1 and #mdb_env_get_maxkeysize() inclusive. -// The same applies to data sizes in databases with the [[DUPSORT]] flag. -// Other data items can in theory be from 0 to 0xffffffff bytes long. -export type val = struct { - mv_size: size, - mv_data: nullable *opaque, -}; - -// Unix permissions for creating files, or dummy definition for Windows -export type mode_t = u32; -- 2.48.1