mdbxmou 0.1.26

package/src/typemou.hpp

@@ -0,0 +1,239 @@
+#pragma once
+
+#include <napi.h>
+#include <mdbx.h++>
+#include <cstdint>
+#include <vector>
+
+namespace mdbxmou {
+
+using buffer_type = std::vector<char>;
+
+struct txnmou_managed final
+    : public mdbx::txn_managed
+{
+    txnmou_managed(MDBX_txn* txn)
+    {  
+        txn::handle_ = txn; 
+    }
+};
+
+struct cursormou_managed final
+    : public mdbx::cursor_managed
+{
+    cursormou_managed(MDBX_cursor* cursor) noexcept
+    {  
+        cursor::handle_ = cursor; 
+    }    
+};
+
+struct env_flag {
+    enum type : int {
+        validation = MDBX_VALIDATION,
+        rdonly = MDBX_RDONLY,
+        exclusive = MDBX_EXCLUSIVE,
+        accede = MDBX_ACCEDE,
+        writemap = MDBX_WRITEMAP,
+        nostickythreads = MDBX_NOSTICKYTHREADS,
+        nordahead = MDBX_NORDAHEAD,
+        nomeminit = MDBX_NOMEMINIT,
+        liforeclaim = MDBX_LIFORECLAIM,
+        nometasync = MDBX_NOMETASYNC,
+        safe_nosync = MDBX_SAFE_NOSYNC,
+        utterly_nosync = MDBX_UTTERLY_NOSYNC,
+        mask = MDBX_VALIDATION | MDBX_RDONLY | MDBX_EXCLUSIVE | MDBX_ACCEDE |
+               MDBX_WRITEMAP | MDBX_NOSTICKYTHREADS | MDBX_NORDAHEAD |
+               MDBX_NOMEMINIT | MDBX_LIFORECLAIM | MDBX_NOMETASYNC |
+               MDBX_SAFE_NOSYNC | MDBX_UTTERLY_NOSYNC
+    };
+    int val{};
+
+    static inline env_flag parse(const Napi::Value& arg0) {
+        return {arg0.As<Napi::Number>().Int32Value() & mask};
+    }
+
+    operator MDBX_env_flags() const noexcept {
+        return static_cast<MDBX_env_flags>(val & mask);
+    }
+};
+
+struct txn_mode {
+    enum type : int {
+        ro = MDBX_TXN_RDONLY
+    };
+    int val{};
+
+    static inline txn_mode parse(const Napi::Value& arg0) {
+        return {arg0.As<Napi::Number>().Int32Value() & ro};
+    }
+    
+    operator MDBX_txn_flags() const noexcept {
+        return static_cast<MDBX_txn_flags>(val & ro);
+    }
+};
+
+struct query_mode
+{
+    enum type : int {
+        get = 0x10000000,
+        del = 0x20000000,
+        upsert = MDBX_UPSERT,
+        update = MDBX_CURRENT,
+        insert_unique = MDBX_NOOVERWRITE,
+        write_mask = upsert | update | insert_unique,
+        mask = get | del | upsert | update | insert_unique
+    };
+    int val{get};
+
+    static inline query_mode parse(const txn_mode& mode, const Napi::Value& arg0) {
+        query_mode rc{arg0.As<Napi::Number>().Int32Value() & mask};
+        if ((mode.val & txn_mode::ro) && (rc.val & (del|upsert|update|insert_unique))) {
+            throw std::runtime_error("rw query in read-only transaction");
+        }
+        return rc;
+    }
+
+    operator mdbx::put_mode() const noexcept {
+        return static_cast<mdbx::put_mode>(val & write_mask);
+    }    
+};
+
+struct key_mode
+{
+    enum type : int {
+        reverse = MDBX_REVERSEKEY,
+        ordinal = MDBX_INTEGERKEY,
+        mask = MDBX_REVERSEKEY | MDBX_INTEGERKEY
+    };
+    int val{};
+
+    static inline key_mode parse(const Napi::Value& arg0) {
+        return {arg0.As<Napi::Number>().Int32Value() & mask};
+    }
+
+    operator mdbx::key_mode() const noexcept {
+        return static_cast<mdbx::key_mode>(val & mask);
+    }
+};
+
+struct value_mode
+{
+    enum type : int {
+        multi = MDBX_DUPSORT,
+        multi_reverse = MDBX_DUPSORT | MDBX_REVERSEDUP,
+        multi_samelength = MDBX_DUPSORT | MDBX_DUPFIXED,
+        multi_ordinal = MDBX_DUPSORT | MDBX_DUPFIXED | MDBX_INTEGERDUP,
+        multi_reverse_samelength = MDBX_DUPSORT | MDBX_REVERSEDUP | MDBX_DUPFIXED,
+        mask = MDBX_DUPSORT | MDBX_REVERSEDUP | MDBX_DUPFIXED | MDBX_INTEGERDUP
+    };
+    int val{};
+
+    static inline value_mode parse(const Napi::Value& arg0) {
+        return {arg0.As<Napi::Number>().Int32Value() & mask};
+    }
+
+    operator mdbx::value_mode() const noexcept {
+        return static_cast<mdbx::value_mode>(val & mask);
+    }
+};
+
+
+struct base_flag
+{
+    enum type : int {
+        string = 2,
+        number = 4,
+        bigint = 8,
+        mask_key = string | number | bigint,
+        mask_val = string
+    };
+    int val{};
+
+    static inline base_flag parse_key(const Napi::Value& arg0) {
+        return {arg0.As<Napi::Number>().Int32Value() & mask_key};
+    }      
+
+    static inline base_flag parse_value(const value_mode& mode, 
+        const Napi::Value& arg0) {
+        return {arg0.As<Napi::Number>().Int32Value() & mask_val};
+    }
+
+    static inline base_flag parse_value(const Napi::Value& arg0) {
+        return {arg0.As<Napi::Number>().Int32Value() & mask_val};
+    }    
+};
+
+static inline key_mode parse_key_mode(Napi::Env env, const Napi::Value& arg0, base_flag& key_flag) 
+{
+    key_mode mode{};
+    if (arg0.IsBigInt()) {
+        bool lossless;
+        auto value = arg0.As<Napi::BigInt>().Int64Value(&lossless);
+        if (!lossless) {
+            throw Napi::Error::New(env, "BigInt value lossless conversion failed");
+        }
+        mode.val = static_cast<int>(value);
+        if (mode.val & key_mode::ordinal) {
+            // только если цифровой key_flag не был задан
+            if (key_flag.val <= base_flag::string) {
+                key_flag.val = base_flag::bigint;
+            }
+        }
+    } else if (arg0.IsNumber()) {
+        mode = key_mode::parse(arg0);
+        if (mode.val & key_mode::ordinal) {
+            // только если цифровой key_flag не был задан
+            if (key_flag.val <= base_flag::string) {
+                key_flag.val = base_flag::number;
+            }
+        }
+    } else {
+        throw Napi::Error::New(env, "Invalid argument type for key mode");
+    }
+    return mode;
+}
+
+struct db_mode
+{
+    enum type : int {
+        create = MDBX_CREATE,
+        accede = MDBX_ACCEDE,
+        mask = MDBX_CREATE | MDBX_ACCEDE
+    };
+    int val{};
+
+    static inline db_mode parse(const txn_mode& mode, const Napi::Value& arg0) {
+        db_mode rc{arg0.As<Napi::Number>().Int32Value() & mask};
+        if ((mode.val & txn_mode::ro) && (rc.val & db_mode::create)) {
+            throw std::runtime_error("create DB in read-only transaction");
+        }
+        return rc;
+    }
+};
+
+static inline auto parse_cursor_mode(const Napi::Value& arg0) {
+    using move_operation = mdbx::cursor::move_operation;
+    if (arg0.IsString()) {
+        std::string mode = arg0.As<Napi::String>().Utf8Value();
+        if (mode == "first") return move_operation::first;
+        if (mode == "last") return move_operation::last;
+        if (mode == "next") return move_operation::next;
+        if (mode == "prev") return move_operation::previous;
+        if (mode == "keyLesser" || mode == "key_lesser_than") 
+            return move_operation::key_lesser_than;
+        if (mode == "keyLesserOrEqual" || mode == "key_lesser_or_equal") 
+            return move_operation::key_lesser_or_equal;
+        if (mode == "keyEqual" || mode == "key_equal") 
+            return move_operation::key_equal;
+        if (mode == "keyGreaterOrEqual" || mode == "key_greater_or_equal") 
+            return move_operation::key_greater_or_equal;
+        if (mode == "keyGreater" || mode == "key_greater_than") 
+            return move_operation::key_greater_than;
+        // Если не найдено, используем по умолчанию
+        return move_operation::key_greater_or_equal;
+    }
+    return static_cast<move_operation>(
+        arg0.As<Napi::Number>().Int32Value());
+}
+
+} // namespace mdbxmou

package/src/valuemou.hpp

@@ -0,0 +1,194 @@
+#pragma once
+
+#include "typemou.hpp"
+
+namespace mdbxmou {
+
+class valuemou
+    : public mdbx::slice
+{
+public:
+    valuemou() = default;
+
+    valuemou(const mdbx::slice& arg0) noexcept
+        : mdbx::slice{arg0}
+    {   }
+
+    valuemou(const Napi::Buffer<char>& arg0) noexcept
+        : mdbx::slice{arg0.Data(), arg0.Length()}
+    {   }
+
+    valuemou(const buffer_type& arg0) noexcept
+        : mdbx::slice{arg0.data(), arg0.size()}
+    {   }
+
+    valuemou(const Napi::Buffer<char>& arg0, buffer_type& mem)
+    {   
+        auto ptr = arg0.Data();
+        mem.assign(ptr, ptr + arg0.Length());
+        assign(mem.data(), mem.size());
+    }
+
+    valuemou(const Napi::String& arg0, 
+        const Napi::Env& env, buffer_type& mem)
+    {   
+        size_t length;
+        auto status =
+            napi_get_value_string_utf8(env, arg0, nullptr, 0, &length);
+        if (status != napi_ok) {
+            throw Napi::Error::New(env, "napi_get_value_string_utf8 length");
+        }
+
+        mem.reserve(length + 1);
+        mem.resize(length);
+
+        status = napi_get_value_string_utf8(
+            env, arg0, mem.data(), mem.capacity(), nullptr);
+        if (status != napi_ok) {
+            throw Napi::Error::New(env, "napi_get_value_string_utf8 copyout");
+        }
+
+        assign(mem.data(), mem.size());
+    }
+
+    static inline valuemou from(const Napi::Value& arg0, 
+        const Napi::Env& env, buffer_type& mem)
+    {
+        if (arg0.IsBuffer()) {
+            return {arg0.As<Napi::Buffer<char>>()};
+        } else if (!arg0.IsString()) {
+            throw Napi::Error::New(env, "unsupported value");
+        }
+        return {arg0.As<Napi::String>(), env, mem};
+    }
+
+    Napi::Value to_string(const Napi::Env& env) const
+    {
+        return Napi::String::New(env, 
+            char_ptr(), length());
+    }
+
+    Napi::Value to_buffer(const Napi::Env& env) const
+    {
+        return Napi::Buffer<char>::Copy(env, 
+            char_ptr(), length());
+    }
+};
+
+class keymou final
+    : public valuemou
+{
+public:    
+    keymou() = default;
+
+    keymou(const valuemou& arg0) noexcept
+        : valuemou{arg0}
+    {   }
+
+    keymou(const mdbx::slice& arg0) noexcept
+        : valuemou{arg0}
+    {   }
+
+    keymou(const Napi::Buffer<char>& arg0)
+        : valuemou{arg0}
+    {   }
+
+    keymou(const buffer_type& arg0) noexcept
+        : valuemou{arg0}
+    {   }    
+
+    keymou(const std::uint64_t& arg0) noexcept
+        : valuemou{mdbx::slice{&arg0, sizeof(arg0)}}
+    {   }
+
+    keymou(const Napi::Buffer<char>& arg0, buffer_type& mem)
+        : valuemou{arg0, mem}
+    {   }
+
+    keymou(const Napi::String& arg0, 
+        const Napi::Env& env, buffer_type& mem)
+        : valuemou{arg0, env, mem}
+    {   }
+
+    keymou(const Napi::Number& arg0, std::uint64_t& mem)
+    {   
+        auto value = arg0.Int64Value();
+        if (value < 0) {
+            throw std::runtime_error("Number negative");
+        }
+        mem = static_cast<std::uint64_t>(value);
+        assign(&mem, sizeof(mem));
+    }    
+
+    keymou(const Napi::Number& arg0, 
+        const Napi::Env& env, std::uint64_t& mem)
+    {   
+        auto value = arg0.Int64Value();
+        if (value < 0) {
+            throw Napi::Error::New(env, "Number negative");
+        }
+        mem = static_cast<std::uint64_t>(value);
+        assign(&mem, sizeof(mem));
+    }
+
+    keymou(const Napi::BigInt& arg0,std::uint64_t& mem)
+    {   
+        bool looseless;
+        mem = arg0.Uint64Value(&looseless);
+        if (!looseless) {
+            throw std::runtime_error("BigInt !looseless");
+        }
+        assign(&mem, sizeof(mem));
+    }    
+
+    keymou(const Napi::BigInt& arg0, 
+        const Napi::Env& env, std::uint64_t& mem)
+    {   
+        bool looseless;
+        mem = arg0.Uint64Value(&looseless);
+        if (!looseless) {
+            throw Napi::Error::New(env, "BigInt !looseless");
+        }
+        assign(&mem, sizeof(mem));
+    }
+
+    static inline keymou from(const Napi::Value& arg0, 
+        const Napi::Env& env, buffer_type& mem)
+    {
+        return {valuemou::from(arg0, env, mem)};
+    }    
+
+    static inline keymou from(const Napi::Value& arg0, 
+        const Napi::Env& env, std::uint64_t& mem)
+    {
+        if (arg0.IsBigInt()) {
+            return {arg0.As<Napi::BigInt>(), env, mem};
+        } else if (!arg0.IsNumber()) {
+            throw Napi::Error::New(env, "key must be a Number or BigInt");
+        }
+        return {arg0.As<Napi::Number>(), env, mem};
+    }
+
+    static inline keymou from(const Napi::Value& arg0, 
+        const Napi::Env& env, buffer_type& buf, std::uint64_t& num)
+    {
+        if (arg0.IsBuffer() || arg0.IsString()) {
+            return from(arg0, env, buf);
+        } else if (!(arg0.IsNumber() || arg0.IsBigInt())) {
+            throw Napi::Error::New(env, "key must be a Buffer,String,Number or BigInt");
+        }
+        return from(arg0, env, num);
+    }
+
+    Napi::Value to_number(const Napi::Env& env) const
+    {
+        return Napi::Number::New(env, as_int64());
+    }
+
+    Napi::Value to_bigint(const Napi::Env& env) const
+    {
+        return Napi::BigInt::New(env, as_uint64());
+    }
+};
+
+} // mdbxmou

package/test/async.js

@@ -0,0 +1,67 @@
+"use strict";
+const fs = require("fs");
+const { MDBX_Async_Env } = require("../lib/mdbx_evn_async.js");
+const MDBX = require("../lib/nativemou.js");
+const { MDBX_Param } = MDBX;
+
+(async () => {
+  const testPath = "async-test-db";
+  await fs.promises.rm(testPath, { recursive: true, force: true }).catch(() => {});
+  
+  // Создаем среду с параметрами и количеством worker'ов
+  const envOptions = { 
+    path: testPath, 
+    envFlag: MDBX_Param.envFlag.nostickythreads 
+  };
+  const env = new MDBX_Async_Env(1);
+  
+  // Обработка сигналов для корректного завершения
+  const cleanup = async () => {
+    console.log("\nReceived interrupt signal, cleaning up...");
+    try {
+      await env.terminate();
+      console.log("Cleanup completed");
+    } catch (e) {
+      console.error("Cleanup error:", e.message);
+    }
+    process.exit(0);
+  };
+  
+  process.on('SIGINT', cleanup);
+  process.on('SIGTERM', cleanup);
+  
+  try {
+    await env.open({ path: testPath });
+
+    const { keyMode } = MDBX_Param;
+
+    // write txn
+    const w = await env.startWrite();
+    const dbi = await w.openMap({ keyMode: keyMode.ordinal, create: true });
+    await dbi.put(1n, "one");
+    await dbi.put(2n, "two");
+    await w.commit();
+
+    // read txn – может уйти в другой worker
+    const r = await env.startRead();
+    const dbi2 = await r.openMap({ keyMode: keyMode.ordinal });
+    const v = await dbi2.get(2n);
+    console.log("get(2) =", v);
+    await r.commit();
+
+    await env.close();
+    console.log("Database closed");
+    
+    // Завершаем все worker'ы
+    await env.terminate();
+    console.log("Workers terminated");
+  } catch (error) {
+    console.error("Test failed:", error);
+    try {
+      await env.terminate();
+    } catch (e) {
+      console.error("Cleanup error:", e.message);
+    }
+    process.exit(1);
+  }
+})();

package/test/e3.js

@@ -0,0 +1,38 @@
+"use strict";
+
+const fs = require('fs');
+const MDBX = require('../lib/nativemou.js');
+const { MDBX_Env, MDBX_Param } = MDBX;
+
+const test = async () => {
+  const db_dir = 'e3';
+
+  await fs.promises.rm(db_dir, { recursive: true, force: true });
+
+  console.log("MDBX_Param:", MDBX_Param);
+  // получаем константы
+  const { keyMode } = MDBX_Param;
+
+  const db = new MDBX_Env();
+
+  console.log('Opening database...');
+
+  await db.open({
+      path: db_dir
+    });
+
+  console.log('Start write');
+  const count = 100000;
+  for (let i = 0; i < count; i++) {
+    const txn = db.startWrite();
+    const dbi = txn.createMap(keyMode.ordinal);
+    dbi.put(i, `value_${i}`);
+    txn.commit();
+  }
+  
+  console.log('Write finish');
+
+  await db.close();
+}
+
+test().catch(console.error);

package/test/e4.js

@@ -0,0 +1,89 @@
+"use strict";
+
+const fs = require('fs');
+const MDBX = require('../lib/nativemou.js');
+const { MDBX_Env, MDBX_Param } = MDBX;
+
+const test = async () => {
+  const path4 = 'e4';
+  const path5 = 'e5';
+
+  console.log("MDBX_Param:", MDBX_Param);
+
+  await Promise.all([
+    fs.promises.rm(path4, { recursive: true, force: true }),
+    fs.promises.rm(path5, { recursive: true, force: true })
+  ]);
+
+  const db4 = new MDBX_Env();
+  const db5 = new MDBX_Env();
+
+  console.log('Opening database...');
+
+  const { valueFlag } = MDBX_Param;
+  await Promise.all([
+    db4.open({
+      path: path4,
+      valueFlag: valueFlag.string
+    }),
+    db5.open({
+      path: path5,
+    })
+  ]);
+
+  console.log('Start write test...');
+  const count = 10;
+  const { keyMode } = MDBX_Param;
+  const txn = db4.startWrite();
+  // при изменении типа ключей надо указывать MDBX_CREATE если базы еще нет
+  const dbi = txn.createMap(keyMode.ordinal);
+  for (let i = 0; i < count; i++) {
+    dbi.put(i, `value_${i}`);
+  }
+  txn.commit();
+  console.log('Start write finish');
+
+  await Promise.all([await db4.close(), await db5.close()]);
+
+  //await db.copyTo('e4_copy_async');
+
+  await db4.open({
+    path: path4,
+    valueFlag: valueFlag.string
+  });
+
+  let val = "";
+  {
+    const txn = db4.startRead();
+    // для read транакций не нужно указывать MDBX_CREATE иначе будет Permission denied
+    const dbi = txn.openMap(BigInt(keyMode.ordinal));
+    const stat = dbi.stat();
+    for (let i = 0; i < count; i++) {
+      val = dbi.get(i);
+    }
+    console.log('last value:', val.toString());
+    console.log('stat:', JSON.stringify(stat));
+    txn.commit();
+  }
+
+  {
+    const txn = db4.startRead();
+    const dbi = txn.openMap(BigInt(keyMode.ordinal));
+    dbi.forEach((key, value) => {
+      console.log(key, value);
+    });
+    txn.commit();
+  }
+
+
+  const { queryMode, dbMode, keyFlag } = MDBX_Param;
+  const result = await db4.query([
+    { dbMode: dbMode.accede, keyMode: keyMode.ordinal, mode: queryMode.get, item: [{ key: 0 }, { key: 1n }, { key: 2n }] },
+    { dbMode: dbMode.accede, keyMode: keyMode.ordinal, mode: queryMode.get, item: [{ key: 3n }, { key: 4n }, { key: 5n }] }
+  ]);
+  console.log('query', JSON.stringify(result));
+
+  await db4.close();
+}
+
+test().catch(console.error);