libmdbx

#include <mdbx.h>
#include <stdio.h>

int main(void) {
  MDBX_env *env;
  MDBX_txn *txn;
  MDBX_dbi dbi;

  mdbx_env_create(&env);
  /* MDBX_NOSUBDIR: путь — это сам файл данных */
  mdbx_env_open(env, "./mydb.mdb", MDBX_NOSUBDIR, 0664);

  /* Транзакция обязательна, даже для чтения */
  mdbx_txn_begin(env, NULL, MDBX_TXN_READWRITE, &txn);
  mdbx_dbi_open(txn, NULL, MDBX_CREATE, &dbi);

  MDBX_val key = { "answer", 6 };
  MDBX_val val = { "42", 2 };
  mdbx_put(txn, dbi, &key, &val, 0); /* 0 = UPSERT */

  mdbx_txn_commit(txn);

  MDBX_val out = { 0 };
  mdbx_txn_begin(env, NULL, MDBX_TXN_READONLY, &txn);
  mdbx_get(txn, dbi, &key, &out);
  printf("answer = %.*s\n", (int)out.iov_len, (char *)out.iov_base);
  mdbx_txn_abort(txn);

  mdbx_env_close(env);
  return 0;
}

#include <mdbx.h>
#include <stdio.h>

/* Атомарная групповая запись */
mdbx_txn_begin(env, NULL, MDBX_TXN_READWRITE, &txn);

MDBX_val a = { "alpha", 5 }, va = { "1", 1 };
MDBX_val b = { "beta",  4 }, vb = { "2", 1 };
mdbx_put(txn, dbi, &a, &va, 0);
mdbx_put(txn, dbi, &b, &vb, 0);

if (something_failed) {
  mdbx_txn_abort(txn);  /* откат: ни одна запись не применится */
} else {
  mdbx_txn_commit(txn); /* фиксация: обе записи видны атомарно */
}

/* Обход всех записей курсором в отсортированном порядке */
MDBX_cursor *cur;
mdbx_txn_begin(env, NULL, MDBX_TXN_READONLY, &txn);
mdbx_cursor_open(txn, dbi, &cur);

MDBX_val key, val;
while (mdbx_cursor_get(cur, &key, &val, MDBX_NEXT) == MDBX_SUCCESS) {
  printf("%.*s = %.*s\n",
         (int)key.iov_len, (char *)key.iov_base,
         (int)val.iov_len,  (char *)val.iov_base);
}
/* В libmdbx курсор всегда закрывается явно */
mdbx_cursor_close(cur);
mdbx_txn_abort(txn);

use libmdbx::*; // Используем привязки проекта libmdbx-rs, https://github.com/vorot93/libmdbx-rs

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Открываем (или создаём) окружение базы данных
    let db = Database::<NoWriteMap>::open("mydb.mdb")?;

    // write-транзакция: создаём таблицу и сохраняем пары ключ–значение
    {
        let txn   = db.begin_rw_txn()?;
        let table = txn.create_table(Some("records"), TableFlags::empty())?;
        txn.put(&table, "answer", "42", WriteFlags::empty())?;
        txn.put(&table, "greeting", "hello, cosmos", WriteFlags::empty())?;
        txn.commit()?;
    }

    // read-only транзакция даёт согласованный снимок данных
    let txn   = db.begin_ro_txn()?;
    let table = txn.open_table(Some("records"))?;
    if let Some(value) = txn.get::<Vec<u8>>(&table, b"answer")? {
        println!("answer = {}", String::from_utf8_lossy(&value));
    }
    Ok(())
}

use libmdbx::*;

// Атомарная групповая запись; без commit изменения откатываются
fn apply_batch(db: &Database<NoWriteMap>) -> Result<(), libmdbx::Error> {
    let txn   = db.begin_rw_txn()?;
    let table = txn.open_table(Some("records"))?;

    txn.put(&table, "alpha", "1", WriteFlags::empty())?;
    txn.put(&table, "beta",  "2", WriteFlags::empty())?;

    if something_failed {
        // без commit транзакция откатится: ни одна запись не применится
        return Ok(());
    }
    txn.commit()?; // фиксация: обе записи видны атомарно
    Ok(())
}

// Обход всех записей курсором в отсортированном порядке
fn dump(db: &Database<NoWriteMap>) -> Result<(), libmdbx::Error> {
    let txn   = db.begin_ro_txn()?;
    let table = txn.open_table(Some("records"))?;
    let mut cursor = txn.cursor(&table)?;

    for item in cursor.iter_start::<Vec<u8>, Vec<u8>>() {
        let (key, value) = item?;
        println!("{} = {}",
                 String::from_utf8_lossy(&key),
                 String::from_utf8_lossy(&value));
    }
    Ok(())
}