mdbxmou 0.1.26

package/deps/libmdbx/test/extra/txn.c++

@@ -0,0 +1,407 @@
+#include "mdbx.h++"
+#include MDBX_CONFIG_H
+
+#include <iostream>
+
+#if defined(ENABLE_MEMCHECK) || defined(MDBX_CI)
+#if MDBX_DEBUG || !defined(NDEBUG)
+#define RELIEF_FACTOR 16
+#else
+#define RELIEF_FACTOR 8
+#endif
+#elif MDBX_DEBUG || !defined(NDEBUG) || defined(__APPLE__) || defined(_WIN32)
+#define RELIEF_FACTOR 4
+#elif UINTPTR_MAX > 0xffffFFFFul || ULONG_MAX > 0xffffFFFFul
+#define RELIEF_FACTOR 2
+#else
+#define RELIEF_FACTOR 1
+#endif
+
+#if !defined(__cpp_lib_latch) && __cpp_lib_latch < 201907L
+
+int main(int argc, const char *argv[]) {
+  (void)argc;
+  (void)argv;
+  std::cout << "FAKE-OK (since no C++20 std::thread and/or std::latch)\n";
+  return EXIT_SUCCESS;
+}
+
+#else
+
+#include <latch>
+#include <thread>
+
+bool case0(const mdbx::path &path) {
+  mdbx::env_managed::create_parameters createParameters;
+  createParameters.geometry.make_dynamic(21 * mdbx::env::geometry::MiB, 84 * mdbx::env::geometry::MiB);
+
+  mdbx::env::operate_parameters operateParameters(100, 10);
+  operateParameters.options.no_sticky_threads = false;
+  mdbx::env_managed env(path, createParameters, operateParameters);
+  auto txn = env.start_write(false);
+  /* mdbx::map_handle testHandle = */ txn.create_map("xyz", mdbx::key_mode::usual, mdbx::value_mode::single);
+  txn.commit();
+
+  //-------------------------------------
+  txn = env.start_write();
+  MDBX_txn *c_txn = txn;
+  int err = mdbx_txn_reset(txn);
+  assert(err == MDBX_EINVAL);
+  bool ok = err == MDBX_EINVAL;
+
+  err = mdbx_txn_break(txn);
+  assert(err == MDBX_SUCCESS);
+  ok = ok && err == MDBX_SUCCESS;
+
+  err = mdbx_txn_commit(txn);
+  assert(err == MDBX_RESULT_TRUE);
+  ok = ok && err == MDBX_RESULT_TRUE;
+
+  //-------------------------------------
+  err = mdbx_txn_begin(env, nullptr, MDBX_TXN_READWRITE, &c_txn);
+  assert(err == MDBX_SUCCESS);
+  ok = ok && err == MDBX_SUCCESS;
+  assert(c_txn == (const MDBX_txn *)txn);
+
+  err = mdbx_txn_break(txn);
+  assert(err == MDBX_SUCCESS);
+  ok = ok && err == MDBX_SUCCESS;
+
+  err = mdbx_txn_reset(txn);
+  assert(err == MDBX_EINVAL);
+  ok = ok && err == MDBX_EINVAL;
+
+  err = mdbx_txn_commit(txn);
+  assert(err == MDBX_RESULT_TRUE);
+  ok = ok && err == MDBX_RESULT_TRUE;
+
+  err = mdbx_txn_abort(c_txn);
+  assert(err == MDBX_BAD_TXN);
+  ok = ok && err == MDBX_BAD_TXN;
+  //-------------------------------------
+  err = mdbx_txn_begin(env, nullptr, MDBX_TXN_READWRITE, &c_txn);
+  assert(err == MDBX_SUCCESS);
+  ok = ok && err == MDBX_SUCCESS;
+  assert(c_txn == (const MDBX_txn *)txn);
+  txn.commit();
+
+  err = mdbx_txn_reset(c_txn);
+  assert(err == MDBX_BAD_TXN);
+  ok = ok && err == MDBX_BAD_TXN;
+  err = mdbx_txn_break(c_txn);
+  assert(err == MDBX_BAD_TXN);
+  ok = ok && err == MDBX_BAD_TXN;
+  err = mdbx_txn_abort(c_txn);
+  assert(err == MDBX_BAD_TXN);
+  ok = ok && err == MDBX_BAD_TXN;
+
+  //=====================================
+
+  txn = env.start_read();
+  err = mdbx_txn_begin(env, txn, MDBX_TXN_READWRITE, &c_txn);
+  assert(err == MDBX_BAD_TXN);
+  ok = ok && err == MDBX_BAD_TXN;
+  txn.make_broken();
+  err = mdbx_txn_begin(env, txn, MDBX_TXN_READWRITE, &c_txn);
+  assert(err == MDBX_BAD_TXN);
+  ok = ok && err == MDBX_BAD_TXN;
+  txn.reset_reading();
+  err = mdbx_txn_begin(env, txn, MDBX_TXN_READWRITE, &c_txn);
+  assert(err == MDBX_BAD_TXN);
+  ok = ok && err == MDBX_BAD_TXN;
+  txn.abort();
+
+  //-------------------------------------
+
+  txn = env.start_read();
+  txn.reset_reading();
+  txn.make_broken();
+  txn.abort();
+
+  //=====================================
+
+  std::latch s(1);
+  txn = env.start_read();
+  c_txn = txn;
+
+  std::thread t([&]() {
+    s.wait();
+#if MDBX_TXN_CHECKOWNER
+    err = mdbx_txn_reset(c_txn);
+    assert(err == MDBX_THREAD_MISMATCH);
+    ok = ok && err == MDBX_THREAD_MISMATCH;
+    err = mdbx_txn_break(c_txn);
+    assert(err == MDBX_THREAD_MISMATCH);
+    ok = ok && err == MDBX_THREAD_MISMATCH;
+    err = mdbx_txn_commit(c_txn);
+    assert(err == MDBX_THREAD_MISMATCH);
+    ok = ok && err == MDBX_THREAD_MISMATCH;
+    err = mdbx_txn_abort(c_txn);
+    assert(err == MDBX_THREAD_MISMATCH);
+    ok = ok && err == MDBX_THREAD_MISMATCH;
+#endif /* MDBX_TXN_CHECKOWNER */
+
+    err = mdbx_txn_begin(env, txn, MDBX_TXN_READWRITE, &c_txn);
+#if MDBX_TXN_CHECKOWNER
+    assert(err == MDBX_THREAD_MISMATCH);
+    ok = ok && err == MDBX_THREAD_MISMATCH;
+#else
+    assert(err == MDBX_BAD_TXN);
+    ok = ok && err == MDBX_BAD_TXN;
+#endif /* MDBX_TXN_CHECKOWNER */
+  });
+
+  s.count_down();
+  t.join();
+
+  return ok;
+}
+
+bool case1(const mdbx::path &path) {
+  mdbx::env::operate_parameters operateParameters(100, 10);
+  operateParameters.options.no_sticky_threads = true;
+  operateParameters.options.nested_write_transactions = true;
+  mdbx::env_managed env(path, operateParameters);
+
+  //-------------------------------------
+  auto txn = env.start_write();
+  MDBX_txn *c_txn = txn;
+  int err = mdbx_txn_reset(txn);
+  assert(err == MDBX_EINVAL);
+  bool ok = err == MDBX_EINVAL;
+
+  err = mdbx_txn_break(txn);
+  assert(err == MDBX_SUCCESS);
+  ok = ok && err == MDBX_SUCCESS;
+
+  err = mdbx_txn_commit(txn);
+  assert(err == MDBX_RESULT_TRUE);
+  ok = ok && err == MDBX_RESULT_TRUE;
+
+  //-------------------------------------
+  err = mdbx_txn_begin(env, nullptr, MDBX_TXN_READWRITE, &c_txn);
+  assert(err == MDBX_SUCCESS);
+  ok = ok && err == MDBX_SUCCESS;
+  assert(c_txn == (const MDBX_txn *)txn);
+
+  err = mdbx_txn_break(txn);
+  assert(err == MDBX_SUCCESS);
+  ok = ok && err == MDBX_SUCCESS;
+
+  err = mdbx_txn_reset(txn);
+  assert(err == MDBX_EINVAL);
+  ok = ok && err == MDBX_EINVAL;
+
+  err = mdbx_txn_commit(txn);
+  assert(err == MDBX_RESULT_TRUE);
+  ok = ok && err == MDBX_RESULT_TRUE;
+
+  err = mdbx_txn_abort(c_txn);
+  assert(err == MDBX_BAD_TXN);
+  ok = ok && err == MDBX_BAD_TXN;
+  //-------------------------------------
+  err = mdbx_txn_begin(env, nullptr, MDBX_TXN_READWRITE, &c_txn);
+  assert(err == MDBX_SUCCESS);
+  ok = ok && err == MDBX_SUCCESS;
+  assert(c_txn == (const MDBX_txn *)txn);
+  txn.commit();
+
+  err = mdbx_txn_reset(c_txn);
+  assert(err == MDBX_BAD_TXN);
+  ok = ok && err == MDBX_BAD_TXN;
+  err = mdbx_txn_break(c_txn);
+  assert(err == MDBX_BAD_TXN);
+  ok = ok && err == MDBX_BAD_TXN;
+  err = mdbx_txn_abort(c_txn);
+  assert(err == MDBX_BAD_TXN);
+  ok = ok && err == MDBX_BAD_TXN;
+
+  //=====================================
+
+  txn = env.start_read();
+  err = mdbx_txn_begin(env, txn, MDBX_TXN_READWRITE, &c_txn);
+  assert(err == MDBX_BAD_TXN);
+  ok = ok && err == MDBX_BAD_TXN;
+  txn.make_broken();
+  err = mdbx_txn_begin(env, txn, MDBX_TXN_READWRITE, &c_txn);
+  assert(err == MDBX_BAD_TXN);
+  ok = ok && err == MDBX_BAD_TXN;
+  txn.reset_reading();
+  err = mdbx_txn_begin(env, txn, MDBX_TXN_READWRITE, &c_txn);
+  assert(err == MDBX_BAD_TXN);
+  ok = ok && err == MDBX_BAD_TXN;
+  txn.abort();
+
+  //-------------------------------------
+
+  txn = env.start_read();
+  txn.reset_reading();
+  txn.make_broken();
+  txn.abort();
+
+  //=====================================
+
+  std::latch s1(1), s2(1), s3(1);
+  txn = env.start_read();
+  c_txn = txn;
+
+  std::thread t([&]() {
+    s1.wait();
+    err = mdbx_txn_break(c_txn);
+    assert(err == MDBX_SUCCESS);
+    ok = ok && err == MDBX_SUCCESS;
+    err = mdbx_txn_reset(c_txn);
+    assert(err == MDBX_SUCCESS);
+    ok = ok && err == MDBX_SUCCESS;
+    txn.renew_reading();
+    s2.count_down();
+
+    s3.wait();
+    err = mdbx_txn_begin(env, txn, MDBX_TXN_READWRITE, &c_txn);
+    assert(err == MDBX_SUCCESS);
+    ok = ok && err == MDBX_SUCCESS;
+    err = mdbx_txn_commit(c_txn);
+    assert(err == MDBX_SUCCESS);
+    ok = ok && err == MDBX_SUCCESS;
+    c_txn = txn;
+    err = mdbx_txn_commit(c_txn);
+    assert(err == MDBX_THREAD_MISMATCH);
+    ok = ok && err == MDBX_THREAD_MISMATCH;
+    err = mdbx_txn_abort(c_txn);
+    assert(err == MDBX_THREAD_MISMATCH);
+    ok = ok && err == MDBX_THREAD_MISMATCH;
+    err = mdbx_txn_break(c_txn);
+    assert(err == MDBX_SUCCESS);
+    ok = ok && err == MDBX_SUCCESS;
+    err = mdbx_txn_reset(c_txn);
+    assert(err == MDBX_EINVAL);
+    ok = ok && err == MDBX_EINVAL;
+  });
+
+  s1.count_down();
+  s2.wait();
+  txn.commit();
+  txn = env.start_write();
+  s3.count_down();
+
+  t.join();
+  txn.abort();
+
+  return ok;
+}
+
+bool case2(const mdbx::path &path, bool no_sticky_threads) {
+  mdbx::env::operate_parameters operateParameters(100, 10);
+  operateParameters.options.no_sticky_threads = no_sticky_threads;
+  mdbx::env_managed env(path, operateParameters);
+
+  std::latch s(1);
+  std::vector<std::thread> l;
+  for (size_t n = 0; n < 8; ++n)
+    l.push_back(std::thread([&]() {
+      s.wait();
+      for (size_t i = 0; i < 1000000 / RELIEF_FACTOR; ++i) {
+        auto txn = env.start_read();
+        txn.abort();
+      }
+    }));
+
+  s.count_down();
+  for (auto &t : l)
+    t.join();
+
+  return true;
+}
+
+bool case3(const mdbx::path &path, bool no_sticky_threads) {
+  mdbx::env::remove(path);
+  mdbx::env_managed::create_parameters createParameters;
+  createParameters.geometry.make_dynamic(21 * mdbx::env::geometry::MiB, 84 * mdbx::env::geometry::MiB);
+  mdbx::env::operate_parameters operateParameters(100, 10);
+  operateParameters.options.no_sticky_threads = no_sticky_threads;
+  mdbx::env_managed env(path, createParameters, operateParameters);
+
+  mdbx::pair pair = {"key", "val"};
+  const auto N = std::thread::hardware_concurrency() * 2;
+  std::latch s0(N + 1), s1(N + 1), s2(N + 1);
+  std::vector<std::thread> l;
+
+  volatile bool ok = true;
+  for (size_t n = 0; n < N; ++n)
+    l.push_back(std::thread([&]() {
+      try {
+        s0.arrive_and_wait();
+        {
+          auto txn = env.start_read();
+          mdbx::slice value;
+          int err = mdbx_get(txn, 1, pair.key, &value);
+          if (err != MDBX_NOTFOUND) {
+            ok = false;
+            std::cerr << "Unexpected error " << err << "\n";
+          }
+        }
+
+        s1.arrive_and_wait();
+        s2.arrive_and_wait();
+        {
+          auto txn = env.start_read();
+          if (txn.get(1, pair.key) != pair.value)
+            ok = false;
+        }
+      } catch (const std::exception &ex) {
+        std::cerr << "Exception: " << ex.what() << "\n";
+        ok = false;
+      }
+    }));
+
+  s0.arrive_and_wait();
+  auto txn = env.start_write();
+  s1.arrive_and_wait();
+  txn.insert(1, pair);
+  txn.commit();
+  s2.arrive_and_wait();
+
+  for (auto &t : l)
+    t.join();
+
+  return ok;
+}
+
+int doit() {
+  mdbx::path path = "test-txn";
+  mdbx::env::remove(path);
+
+  bool ok = true;
+  ok = case0(path) && ok;
+  ok = case1(path) && ok;
+  ok = case2(path, false) && ok;
+  ok = case2(path, true) && ok;
+  ok = case3(path, false) && ok;
+  ok = case3(path, true) && ok;
+
+  std::cout << (ok ? "OK\n" : "FAIL\n");
+  return ok ? EXIT_SUCCESS : EXIT_FAILURE;
+}
+
+static char log_buffer[1024];
+
+static void logger_nofmt(MDBX_log_level_t loglevel, const char *function, int line, const char *msg,
+                         unsigned length) noexcept {
+  (void)length;
+  (void)loglevel;
+  fprintf(stdout, "%s:%u %s", function, line, msg);
+}
+
+int main(int argc, char *argv[]) {
+  (void)argc;
+  (void)argv;
+  mdbx_setup_debug_nofmt(MDBX_LOG_VERBOSE, MDBX_DBG_ASSERT, logger_nofmt, log_buffer, sizeof(log_buffer));
+  try {
+    return doit();
+  } catch (const std::exception &ex) {
+    std::cerr << "Exception: " << ex.what() << "\n";
+    return EXIT_FAILURE;
+  }
+}
+
+#endif /* __cpp_lib_latch */

package/deps/libmdbx/test/extra/upsert_alldups.c

@@ -0,0 +1,193 @@
+//
+//  libmdbx/test/extra/upsert_alldups.c
+//
+//  Created by Masatoshi Fukunaga <https://gitflic.ru/user/mah0x211>
+//  on 2023-01-31.
+//
+
+#include "mdbx.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+static int dump(MDBX_cursor *cur) {
+  MDBX_val key = {NULL, 0};
+  MDBX_val data = {NULL, 0};
+  int rc = mdbx_cursor_get(cur, &key, &data, MDBX_FIRST);
+
+  while (rc == 0) {
+    printf("(%.*s) = (%.*s)\n", (int)key.iov_len, (const char *)key.iov_base, (int)data.iov_len,
+           (const char *)data.iov_base);
+    rc = mdbx_cursor_get(cur, &key, &data, MDBX_NEXT);
+  }
+  return rc;
+}
+
+static int clear(MDBX_cursor *cur) {
+  MDBX_val key = {NULL, 0};
+  MDBX_val data = {NULL, 0};
+  int rc = mdbx_cursor_get(cur, &key, &data, MDBX_FIRST);
+
+  while (rc == 0) {
+    rc = mdbx_cursor_del(cur, MDBX_ALLDUPS);
+    if (rc)
+      return rc;
+    rc = mdbx_cursor_get(cur, &key, &data, MDBX_NEXT);
+  }
+  return (rc == MDBX_NOTFOUND) ? 0 : rc;
+}
+
+static int put(MDBX_txn *txn, MDBX_dbi dbi, const char *k, const char *v, MDBX_put_flags_t flags) {
+  MDBX_val key = {.iov_base = (void *)k, .iov_len = strlen(k)};
+  MDBX_val data = {.iov_base = (void *)v, .iov_len = strlen(v)};
+  return mdbx_put(txn, dbi, &key, &data, flags);
+}
+
+int main(int argc, const char *argv[]) {
+  (void)argc;
+  (void)argv;
+  char *errmsg = NULL;
+  MDBX_env *env = NULL;
+  MDBX_txn *txn = NULL;
+  MDBX_cursor *cur = NULL;
+  MDBX_dbi dbi = 0;
+
+  unlink("." MDBX_DATANAME);
+  unlink("." MDBX_LOCKNAME);
+
+  int rc = 0;
+  if ((rc = mdbx_env_create(&env))) {
+    errmsg = "failed to mdbx_env_create: %s\n";
+    goto Fail;
+  }
+  if ((rc = mdbx_env_open(env, ".", MDBX_NOSUBDIR | MDBX_LIFORECLAIM, 0644))) {
+    errmsg = "failed to mdbx_env_open: %s\n";
+    goto Fail;
+  }
+  if ((rc = mdbx_txn_begin(env, NULL, 0, &txn))) {
+    errmsg = "failed to mdbx_txn_begin: %s\n";
+    goto Fail;
+  }
+  if ((rc = mdbx_dbi_open(txn, NULL, MDBX_DUPSORT | MDBX_CREATE, &dbi))) {
+    errmsg = "failed to mdbx_dbi_open: %s\n";
+    goto Fail;
+  }
+  if ((rc = mdbx_cursor_open(txn, dbi, &cur))) {
+    errmsg = "failed to mdbx_cursor_open: %s\n";
+    goto Fail;
+  }
+
+#define DUMP()                                                                                                         \
+  do {                                                                                                                 \
+    if ((rc = dump(cur)) && rc != MDBX_NOTFOUND) {                                                                     \
+      errmsg = "failed to mdbx_cursor_get(FIRST): %s\n";                                                               \
+      goto Fail;                                                                                                       \
+    }                                                                                                                  \
+    puts("");                                                                                                          \
+  } while (0)
+
+#define PUTVAL(k, v, flags)                                                                                            \
+  do {                                                                                                                 \
+    if ((rc = put(txn, dbi, k, v, flags))) {                                                                           \
+      errmsg = "failed to mdbx_put: %s\n";                                                                             \
+      goto Fail;                                                                                                       \
+    }                                                                                                                  \
+  } while (0)
+
+  puts("TEST WITH MULTIPLE KEYS ====================");
+  // UPSERTING
+  // MDBX_UPSERT:
+  //   Key is absent → Insertion (Insertion)
+  //   Key exist → Wanna to add new values (Overwrite by single new value)
+  puts("insert multiple keys and values {");
+  puts("  foo = bar, baz, qux");
+  puts("  hello = world");
+  puts("}");
+  PUTVAL("foo", "bar", MDBX_UPSERT);
+  PUTVAL("foo", "baz", MDBX_UPSERT);
+  PUTVAL("foo", "qux", MDBX_UPSERT);
+  PUTVAL("hello", "world", MDBX_UPSERT);
+  DUMP();
+  //
+  // above code will output the fllowing;
+  //
+  //   insert multiple values {
+  //     foo = bar, baz, qux
+  //     hello = world
+  //   }
+  //   (foo) = (bar)
+  //   (foo) = (baz)
+  //   (foo) = (qux)
+  //   (hello) = (world)
+  //
+
+  // UPSERTING
+  // MDBX_UPSERT + MDBX_ALLDUPS:
+  //   Key exist → Replace all values with a new one (Overwrite by single new
+  //   value)
+  puts("overwrite by single new value: MDBX_UPSERT + MDBX_ALLDUPS {");
+  puts("  foo = baa");
+  puts("}");
+  PUTVAL("foo", "baa", MDBX_UPSERT | MDBX_ALLDUPS);
+  DUMP();
+  // above code will output the fllowing;
+  //   overwrite by single new value {
+  //     foo = baa
+  //   }
+  //   (foo) = (baa)
+  //   (hello) = (world)
+  if ((rc = clear(cur))) {
+    errmsg = "failed to clear: %s\n";
+    goto Fail;
+  }
+  DUMP();
+
+  puts("TEST WITH A SINGLE KEY ====================");
+  // UPSERTING
+  // MDBX_UPSERT:
+  //   Key is absent → Insertion (Insertion)
+  //   Key exist → Wanna to add new values (Overwrite by single new value)
+  puts("insert single key and multiple values {");
+  puts("  foo = bar, baz, qux");
+  puts("}");
+  PUTVAL("foo", "bar", MDBX_UPSERT);
+  PUTVAL("foo", "baz", MDBX_UPSERT);
+  PUTVAL("foo", "qux", MDBX_UPSERT);
+  DUMP();
+  //
+  // above code will output the fllowing;
+  //
+  //   insert: foo = bar, baz, qux
+  //   foo = bar
+  //   foo = baz
+  //   foo = qux
+
+  // UPSERTING
+  // MDBX_UPSERT + MDBX_ALLDUPS:
+  //   Key exist → Replace all values with a new one (Overwrite by single new
+  //   value)
+  puts("overwrite by single new value: MDBX_UPSERT + MDBX_ALLDUPS {");
+  puts("  foo = baa");
+  puts("}");
+  PUTVAL("foo", "baa", MDBX_UPSERT | MDBX_ALLDUPS);
+  DUMP();
+  // above code outputs nothing.
+  // all data associated with key has been deleted.
+  // Is it a bug? Or, am I misunderstanding how to use it?
+
+  if ((rc = mdbx_txn_commit(txn))) {
+    errmsg = "failed to mdbx_txn_commit: %s\n";
+    goto Fail;
+  }
+  mdbx_cursor_close(cur);
+  if ((rc = mdbx_env_close(env))) {
+    errmsg = "failed to mdbx_env_close: %s\n";
+    goto Fail;
+  }
+  return 0;
+
+Fail:
+  printf(errmsg, mdbx_strerror(rc));
+  return EXIT_FAILURE;
+}