mdbxmou 0.1.26

package/lib/mdbx_worker.js

@@ -0,0 +1,195 @@
+"use strict";
+const { parentPort } = require("worker_threads");
+const MDBX = require("./nativemou.js");
+const { MDBX_Env } = MDBX;
+
+// Хранилища
+let env = null;
+const txns = new Map();   // txnId -> { txn, write }
+const dbis = new Map();   // dbiId -> { txnId, dbi }
+
+function ok(id, result) { parentPort.postMessage({ id, ok: true, result }); }
+function fail(id, error) { parentPort.postMessage({ id, ok: false, error }); }
+
+async function handler(msg) {
+  const { id, cmd, params } = msg;
+  try {
+    switch (cmd) {
+      case "env_open":
+        if (env) throw new Error("already open");
+        env = new MDBX_Env();
+        await env.openSync(params || {});
+        return ok(id, true);
+
+      case "env_close":
+        if (env) {
+          env.closeSync();
+          env = null;
+          txns.clear();
+          dbis.clear();
+        }
+        return ok(id, true);
+
+      case "txn_begin": {
+        if (!env) throw new Error("env not open");
+        const { txnId, mode } = params;
+        if (txns.has(txnId)) throw new Error("txn exists");
+        const txn = (mode === "write") ? env.startWrite() : env.startRead();
+        txns.set(txnId, { txn, write: mode === "write" });
+        return ok(id, true);
+      }
+
+      case "txn_commit": {
+        const { txnId } = params;
+        const t = txns.get(txnId);
+        if (!t) throw new Error("no txn");
+        t.txn.commit();
+        txns.delete(txnId);
+        // удалить связанные dbi
+        for (const [k, v] of dbis) if (v.txnId === txnId) dbis.delete(k);
+        return ok(id, true);
+      }
+
+      case "txn_abort": {
+        const { txnId } = params;
+        const t = txns.get(txnId);
+        if (!t) return ok(id, true);
+        if (t.txn.abort) t.txn.abort();
+        txns.delete(txnId);
+        for (const [k, v] of dbis) if (v.txnId === txnId) dbis.delete(k);
+        return ok(id, true);
+      }
+
+      case "map_open": {
+        const { txnId, dbiId, name, keyMode, valMode, flags, create } = params;
+        const t = txns.get(txnId);
+        if (!t) throw new Error("no txn");
+        let dbi;
+        if (create) {
+          // createMap принимает (keyMode, valueMode)
+          if (valMode !== undefined && valMode !== 0) {
+            dbi = t.txn.createMap(keyMode, valMode);
+          } else {
+            dbi = t.txn.createMap(keyMode);
+          }
+        } else {
+          // openMap для чтения принимает только keyMode
+          dbi = t.txn.openMap(keyMode);
+        }
+        dbis.set(dbiId, { txnId, dbi });
+        return ok(id, { meta: { name: name || "", keyMode, valMode } });
+      }
+
+      case "dbi_put": {
+        const { txnId, dbiId, key, value, flags = 0 } = params;
+        const d = dbis.get(dbiId);
+        if (!d || d.txnId !== txnId) throw new Error("no dbi");
+        d.dbi.put(key, value, flags);
+        return ok(id, true);
+      }
+
+      case "dbi_get": {
+        const { txnId, dbiId, key } = params;
+        const d = dbis.get(dbiId);
+        if (!d || d.txnId !== txnId) throw new Error("no dbi");
+        const val = d.dbi.get(key);
+        // Если val это Buffer, преобразуем в строку для удобства
+        const result = (val && Buffer.isBuffer(val)) ? val.toString() : val;
+        return ok(id, result);
+      }
+
+      case "dbi_del": {
+        const { txnId, dbiId, key } = params;
+        const d = dbis.get(dbiId);
+        if (!d || d.txnId !== txnId) throw new Error("no dbi");
+        const r = d.dbi.del(key);
+        return ok(id, r);
+      }
+
+      case "dbi_stat": {
+        const { txnId, dbiId } = params;
+        const d = dbis.get(dbiId);
+        if (!d || d.txnId !== txnId) throw new Error("no dbi");
+        return ok(id, d.dbi.stat());
+      }
+
+      case "dbi_iter_all": {
+        const { txnId, dbiId } = params;
+        const d = dbis.get(dbiId);
+        if (!d || d.txnId !== txnId) throw new Error("no dbi");
+        const out = [];
+        d.dbi.forEach((k, v) => {
+          out.push({ key: k, value: v });
+          return true;
+        });
+        return ok(id, out);
+      }
+
+      case "dbi_get_batch": {
+        // Групповое чтение множества ключей
+        const { txnId, dbiId, keys } = params;
+        const d = dbis.get(dbiId);
+        if (!d || d.txnId !== txnId) throw new Error("no dbi");
+        
+        const results = [];
+        for (const key of keys) {
+          try {
+            const val = d.dbi.get(key);
+            if (val !== undefined && val !== null) {
+              const result = (val && Buffer.isBuffer(val)) ? val.toString() : val;
+              results.push({ key, value: result, found: true });
+            } else {
+              results.push({ key, value: null, found: false });
+            }
+          } catch (e) {
+            results.push({ key, value: null, found: false });
+          }
+        }
+        return ok(id, results);
+      }
+
+      case "dbi_put_batch": {
+        // Групповая запись множества пар ключ-значение
+        const { txnId, dbiId, items, flags = 0 } = params;
+        const d = dbis.get(dbiId);
+        if (!d || d.txnId !== txnId) throw new Error("no dbi");
+        
+        const results = [];
+        for (const item of items) {
+          try {
+            d.dbi.put(item.key, item.value, flags);
+            results.push({ key: item.key, success: true });
+          } catch (e) {
+            results.push({ key: item.key, success: false, error: e.message });
+          }
+        }
+        return ok(id, results);
+      }
+
+      case "dbi_del_batch": {
+        // Групповое удаление множества ключей
+        const { txnId, dbiId, keys } = params;
+        const d = dbis.get(dbiId);
+        if (!d || d.txnId !== txnId) throw new Error("no dbi");
+        
+        const results = [];
+        for (const key of keys) {
+          try {
+            const r = d.dbi.del(key);
+            results.push({ key, deleted: r });
+          } catch (e) {
+            results.push({ key, deleted: false, error: e.message });
+          }
+        }
+        return ok(id, results);
+      }
+
+      default:
+        throw new Error("unknown cmd " + cmd);
+    }
+  } catch (e) {
+    return fail(id, e.message || String(e));
+  }
+}
+
+parentPort.on("message", handler);

package/lib/nativemou.js

@@ -0,0 +1,6 @@
+const os = require('os');
+
+const nativePath = '../build/Release/mdbxmou';
+const nativeModule = require(nativePath);
+// Экспортируем объединенный модуль
+module.exports = nativeModule;

package/package.json

@@ -0,0 +1,38 @@
+{
+  "main": "lib/nativemou.js",
+  "dependencies": {
+    "cmake-js": "^7.3.1",
+    "node-addon-api": "^8.5.0"
+  },
+  "scripts": {
+    "e3": "node ./test/e3.js",
+    "e4": "node ./test/e4.js",
+    "e5": "node ./test/e5.js",
+    "test": "node ./test/e3.js && node ./test/e4.js && node ./test/e5.js",
+    "build": "node build.js",
+    "install": "node build.js"
+  },
+  "gypfile": true,
+  "name": "mdbxmou",
+  "version": "0.1.26",
+  "description": "Node bindings for mdbx",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ikonopistsev/mdbxmou.git"
+  },
+  "keywords": [
+    "mdbx",
+    "libmdbx",
+    "database",
+    "db",
+    "kv",
+    "bindings",
+    "embedded"
+  ],
+  "author": "Igor Ikonopistsev",
+  "license": "Apache-2.0",
+  "bugs": {
+    "url": "https://github.com/ikonopistsev/mdbxmou/issues"
+  },
+  "homepage": "https://github.com/ikonopistsev/mdbxmou#readme"
+}

package/src/async/envmou_close.cpp

@@ -0,0 +1,34 @@
+#include "envmou_close.hpp"
+#include "envmou.hpp"
+
+namespace mdbxmou {
+
+void async_close::Execute() 
+{
+    // выдадим идентфикатор потока для лога (thread_id)
+    // fprintf(stderr, "TRACE: async_close id=%d\n", gettid());
+
+    try {
+        that_.do_close();
+    } catch (const std::exception& e) {
+        SetError(e.what());
+    }
+}
+
+void async_close::OnOK() 
+{
+    auto env = Env();
+
+    that_.unlock();
+
+    deferred_.Resolve(env.Undefined());
+}
+
+void async_close::OnError(const Napi::Error& e) 
+{
+    that_.unlock();
+
+    deferred_.Reject(e.Value());
+}    
+
+} // namespace mdbxmou

package/src/async/envmou_close.hpp

@@ -0,0 +1,32 @@
+#pragma once
+
+#include <napi.h>
+#include <mdbx.h++>
+
+namespace mdbxmou {
+
+class envmou;
+
+class async_close final
+    : public Napi::AsyncWorker 
+{
+    Napi::Promise::Deferred deferred_;
+    envmou& that_;
+
+public:
+    async_close(Napi::Env env, envmou& t)
+        : Napi::AsyncWorker(env)
+        , deferred_(Napi::Promise::Deferred::New(env))
+        , that_(t)
+    {   }
+
+    void Execute() override;    
+    void OnOK() override;
+    void OnError(const Napi::Error& e) override;
+
+    Napi::Promise GetPromise() const { 
+        return deferred_.Promise(); 
+    }   
+};
+
+} // namespace mdbxmou

package/src/async/envmou_copy_to.cpp

@@ -0,0 +1,29 @@
+#include "envmou_copy_to.hpp"
+#include "envmou.hpp"
+
+namespace mdbxmou {
+
+void async_copy::Execute() 
+{
+    // выдадим идентфикатор потока для лога (thread_id)
+    // fprintf(stderr, "TRACE: async_copy id=%d\n", gettid());
+
+    auto rc = mdbx_env_copy(that_, dest_.c_str(), flags_);
+    if (rc != MDBX_SUCCESS) {
+        SetError(mdbx_strerror(rc));
+    }
+}
+
+void async_copy::OnOK() 
+{
+    that_.unlock();
+    deferred_.Resolve(Env().Undefined());
+}
+
+void async_copy::OnError(const Napi::Error& e) 
+{
+    that_.unlock();
+    deferred_.Reject(e.Value());
+}    
+
+} // namespace mdbxmou

package/src/async/envmou_copy_to.hpp

@@ -0,0 +1,38 @@
+#pragma once
+#include <napi.h>
+#include <mdbx.h++>
+
+namespace mdbxmou {
+
+class envmou;
+
+class async_copy 
+    : public Napi::AsyncWorker 
+{
+    Napi::Promise::Deferred deferred_;
+    envmou& that_;
+    std::string dest_{};
+    MDBX_copy_flags_t flags_{MDBX_CP_DEFAULTS};
+
+public:
+    async_copy(Napi::Env env, envmou& t, 
+        std::string dest, MDBX_copy_flags_t flags)
+        : Napi::AsyncWorker(env)
+        , deferred_(Napi::Promise::Deferred::New(env))
+        , that_(t)
+        , dest_(std::move(dest))
+        , flags_(flags) 
+    {   }
+
+    void Execute() override;
+
+    void OnOK() override;
+
+    void OnError(const Napi::Error& e) override;
+
+    Napi::Promise GetPromise() const { 
+        return deferred_.Promise(); 
+    }
+};
+
+} // namespace mdbxmou

package/src/async/envmou_keys.cpp

@@ -0,0 +1,201 @@
+#include "envmou_keys.hpp"
+#include "envmou.hpp"
+#include "dbimou.hpp"
+
+namespace mdbxmou {
+
+void async_keys::Execute() 
+{
+    try {
+        // стартуем транзакцию
+        auto txn = start_transaction();
+        for (auto& req : query_) 
+        {
+            mdbx::map_handle dbi{};
+            auto db_mode = req.db_mod;
+            if (db_mode.val & db_mode::accede) {
+                dbi = txn.open_map_accede(req.db);
+            } else {
+                dbi = txn.open_map(req.db, req.key_mod, req.val_mod);
+            }
+            do_keys(txn, dbi, req);
+        }
+
+        txn.commit();
+    } catch (const std::exception& e) {
+        SetError(e.what());
+    } catch (...) {
+        SetError("async_keys::Execute");
+    }
+}
+
+static Napi::Value write_row(Napi::Env env, const keys_line& row) 
+{
+    auto& param = row.item;
+    auto key_mode = row.key_mod;
+    auto key_flag = row.key_flag;
+    auto js_arr = Napi::Array::New(env, param.size());
+    for (std::size_t j = 0; j < param.size(); ++j) {
+        const auto& item = param[j];
+        if (key_mode.val & key_mode::ordinal) {
+            js_arr.Set(j, (key_flag.val & base_flag::number) ?
+                Napi::Number::New(env, item.id_buf) : Napi::BigInt::New(env, item.id_buf));
+        } else {
+            js_arr.Set(j, (key_flag.val & base_flag::string) ?
+                Napi::String::New(env, item.key_buf.data(), item.key_buf.size()) :
+                Napi::Buffer<char>::Copy(env, item.key_buf.data(), item.key_buf.size()));
+        }
+    }
+    return js_arr;
+}
+
+void async_keys::OnOK() 
+{
+    auto env = Env();
+
+    --env_;
+
+    if (single_ && (query_.size() == 1)) {
+        const auto& row = query_[0];
+        deferred_.Resolve(write_row(env, row));
+        return;
+    }
+
+    Napi::Array result = Napi::Array::New(env, query_.size());
+    for (std::size_t i = 0; i < query_.size(); ++i) {
+        Napi::Object js_row = Napi::Object::New(env);
+        const auto& row = query_[i];
+        if (!row.db.empty()) {
+            js_row.Set("db", Napi::String::New(env, row.db_name));
+        }
+        result.Set(i, write_row(env, row));
+    }
+
+    deferred_.Resolve(result);
+}
+
+void async_keys::OnError(const Napi::Error& e) 
+{
+    --env_;
+
+    deferred_.Reject(e.Value());
+}
+
+txnmou_managed async_keys::start_transaction()
+{
+    MDBX_txn *ptr;
+    mdbx::error::success_or_throw(::mdbx_txn_begin(env_, nullptr, txn_mode_, &ptr));
+    return { ptr };
+}
+
+void async_keys::do_keys(txnmou_managed& txn, 
+    mdbx::map_handle dbi, keys_line& arg0)
+{
+    auto& item = arg0.item;
+    if (!arg0.has_from_key) {
+        // Обычный режим - получаем все ключи
+        auto stat = dbimou::get_stat(txn, dbi);
+        item.reserve(stat.ms_entries);
+        
+        auto cursor = txn.open_cursor(dbi);        
+        if (mdbx::is_ordinal(arg0.key_mod)) {
+            cursor.scan([&](const mdbx::pair& f) {
+                async_key rc{};
+                rc.id_buf = f.key.as_uint64();
+                item.push_back(std::move(rc));
+                return false;
+            });
+        } else {
+            cursor.scan([&](const mdbx::pair& f) {
+                async_key rc{};
+                rc.key_buf.assign(f.key.char_ptr(), f.key.end_char_ptr());
+                item.push_back(std::move(rc));
+                return false;
+            });
+        }
+    } else {
+        do_keys_from(txn, dbi, arg0);
+    }
+}
+
+void async_keys::do_keys_from(txnmou_managed& txn, 
+    mdbx::map_handle dbi, keys_line& arg0)
+{
+    // сыллка на массив результатов
+    auto& item = arg0.item;
+    std::size_t count = 0;
+    using move_operation = mdbx::cursor::move_operation;
+
+    auto cursor = txn.open_cursor(dbi);
+
+    keymou from_key = mdbx::is_ordinal(arg0.key_mod) ?
+        keymou{arg0.id_buf} : 
+        keymou{mdbx::slice{arg0.key_buf.data(), arg0.key_buf.size()}};
+
+    // Определяем направление сканирования
+    auto turn_mode = move_operation::next;
+    auto cursor_mode = arg0.cursor_mode;
+    switch (cursor_mode) {
+        case move_operation::key_lesser_than:
+        case move_operation::key_lesser_or_equal:
+        case move_operation::multi_exactkey_value_lesser_than:
+        case move_operation::multi_exactkey_value_lesser_or_equal:
+            turn_mode = move_operation::previous;
+            break;
+        case move_operation::key_equal:
+        case move_operation::multi_exactkey_value_equal:
+            turn_mode = move_operation::next;
+            break;
+        default:
+            turn_mode = move_operation::next;
+            break;
+    }
+
+    bool is_key_equal_mode = (cursor_mode == move_operation::key_equal || 
+        cursor_mode == move_operation::multi_exactkey_value_equal);    
+
+    std::size_t index{};
+    if (mdbx::is_ordinal(arg0.key_mod)) {
+        // Создаем ключ для позиционирования
+        cursor.scan_from([&](const mdbx::pair& f) {
+            if (index >= arg0.limit) {
+                return true; // останавливаем сканирование
+            }
+            
+            keymou key{f.key};
+            if (is_key_equal_mode) {
+                if (arg0.id_buf != key.as_int64()) {
+                    return true; // останавливаем сканирование
+                }
+            }
+            
+            async_key rc{};
+            rc.id_buf = key.as_uint64();
+            item.push_back(std::move(rc));
+            index++;                            
+            return false; // продолжаем сканирование
+        }, from_key, arg0.cursor_mode, turn_mode);
+    } else {
+        // Создаем ключ для позиционирования
+        cursor.scan_from([&](const mdbx::pair& f) {
+            if (index >= arg0.limit) {
+                return true; // останавливаем сканирование
+            }
+            
+            keymou key{f.key};
+            if (is_key_equal_mode) {
+                if (from_key != key) {
+                    return true; // останавливаем сканирование
+                }
+            }
+            
+            async_key rc{};
+            rc.id_buf = key.as_uint64();
+            item.push_back(std::move(rc));
+            index++;                            
+            return false; // продолжаем сканирование
+        }, from_key, arg0.cursor_mode, turn_mode);
+    }
+}
+
+} // namespace mdbxmou

package/src/async/envmou_keys.hpp

@@ -0,0 +1,50 @@
+#pragma once
+
+#include "querymou.hpp"
+
+namespace mdbxmou {
+
+class envmou;
+
+class async_keys
+    : public Napi::AsyncWorker 
+{
+    Napi::Promise::Deferred deferred_;
+    envmou& env_;
+    txn_mode txn_mode_{};
+    // действия для выполнения
+    keys_request query_{};
+    // упрощенный режим 1 массив
+    bool single_{false};
+
+public:
+    async_keys(Napi::Env env, envmou& e, 
+        txn_mode txn_mode, keys_request query, bool single = false)
+        : Napi::AsyncWorker{env}
+        , deferred_{Napi::Promise::Deferred::New(env)}
+        , env_{e}
+        , txn_mode_{txn_mode}
+        , query_{std::move(query)}
+        , single_{single}
+    {   }
+
+    void Execute() override;
+
+    void OnOK() override;
+
+    void OnError(const Napi::Error& e) override;
+
+    Napi::Promise GetPromise() const { 
+        return deferred_.Promise(); 
+    }
+
+    txnmou_managed start_transaction();
+
+    void do_keys(txnmou_managed& txn, 
+        mdbx::map_handle dbi, keys_line& arg0);
+
+    void do_keys_from(txnmou_managed& txn, 
+        mdbx::map_handle dbi, keys_line& arg0);
+};
+
+} // namespace mdbxmou

package/src/async/envmou_open.cpp

@@ -0,0 +1,38 @@
+#include "envmou_open.hpp"
+#include "envmou.hpp"
+
+namespace mdbxmou {
+
+void async_open::Execute() 
+{
+    // выдадим идентфикатор потока для лога (thread_id)
+    // fprintf(stderr, "TRACE: async_open id=%d\n", gettid());
+
+    try {
+        auto e = envmou::create_and_open(arg0_);
+        that_.attach(e, arg0_);
+    } catch (const std::exception& e) {
+        SetError(e.what());
+    }
+}
+
+void async_open::OnOK() 
+{
+    // выдадим идентфикатор потока для лога (thread_id)
+    // fprintf(stderr, "TRACE: async_open OnOK id=%d\n", gettid());
+
+    auto env = Env();
+
+    that_.unlock();
+
+    deferred_.Resolve(env.Undefined());
+}
+
+void async_open::OnError(const Napi::Error& e) 
+{
+    that_.unlock();
+
+    deferred_.Reject(e.Value());
+}    
+
+} // namespace mdbxmou

package/src/async/envmou_open.hpp

@@ -0,0 +1,33 @@
+#pragma once
+
+#include "env_arg0.hpp"
+
+namespace mdbxmou {
+
+class envmou;
+
+class async_open final
+    : public Napi::AsyncWorker 
+{
+    Napi::Promise::Deferred deferred_;
+    envmou& that_;
+    env_arg0 arg0_{};
+
+public:
+    async_open(Napi::Env env, envmou& t, const env_arg0& a)
+        : Napi::AsyncWorker(env)
+        , deferred_(Napi::Promise::Deferred::New(env))
+        , that_(t)
+        , arg0_(a)
+    {   }
+
+    void Execute() override;    
+    void OnOK() override;
+    void OnError(const Napi::Error& e) override;
+
+    Napi::Promise GetPromise() const { 
+        return deferred_.Promise(); 
+    }    
+};
+
+} // namespace mdbxmou