mdbxmou 0.1.26

package/src/dbimou.cpp

@@ -0,0 +1,522 @@
+#include "dbimou.hpp"
+#include "envmou.hpp"
+#include "txnmou.hpp"
+#include "typemou.hpp"
+
+namespace mdbxmou {
+
+Napi::FunctionReference dbimou::ctor{};
+
+void dbimou::init(const char *class_name, Napi::Env env)
+{
+    auto func = DefineClass(env, class_name, {
+        InstanceMethod("put", &dbimou::put),
+        InstanceMethod("get", &dbimou::get),
+        InstanceMethod("del", &dbimou::del),
+        InstanceMethod("has", &dbimou::has),
+        InstanceMethod("forEach", &dbimou::for_each),
+        InstanceMethod("stat", &dbimou::stat),
+        InstanceMethod("keys", &dbimou::keys),
+        InstanceMethod("keysFrom", &dbimou::keys_from),
+    });
+
+    ctor = Napi::Persistent(func);
+    ctor.SuppressDestruct();
+}
+
+Napi::Value dbimou::put(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    
+    auto arg_len = info.Length();
+    if (arg_len < 2) {
+        throw Napi::Error::New(env, "put: key and value required");
+    }
+
+    try {
+        auto key = (key_mode_.val & key_mode::ordinal) ?
+            keymou::from(info[0], env, id_buf_) : 
+            keymou::from(info[0], env, key_buf_);
+        auto val = valuemou::from(info[1], env, val_buf_);
+        auto flag = static_cast<MDBX_put_flags_t>(key_mode_.val & value_mode_.val);
+        auto rc = mdbx_put(*txn_, dbi_, key, val, flag);
+        if (rc != MDBX_SUCCESS) {
+            throw Napi::Error::New(env, mdbx_strerror(rc));
+        }
+    } catch (const std::exception& e) {
+        throw Napi::Error::New(env, std::string("put: ") + e.what());
+    }
+
+    return env.Undefined();
+}
+
+Napi::Value dbimou::get(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 1) {
+        throw Napi::Error::New(env, "get: key required");
+    }
+
+    try {
+        valuemou val{};
+        auto key = (key_mode_.val & key_mode::ordinal) ?
+            keymou::from(info[0], env, id_buf_) : 
+            keymou::from(info[0], env, key_buf_);
+        auto rc = mdbx_get(*txn_, dbi_, key, val);
+        if (rc == MDBX_NOTFOUND)
+            return env.Undefined();
+        if (rc != MDBX_SUCCESS) {
+            throw Napi::Error::New(env, mdbx_strerror(rc));
+        }
+        return (value_flag_.val & base_flag::string) ? 
+            val.to_string(env) : val.to_buffer(env);
+    } catch (const std::exception& e) {
+        throw Napi::Error::New(env, std::string("get: ") + e.what());
+    }
+
+    return env.Undefined();
+}
+
+Napi::Value dbimou::del(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 1) {
+        throw Napi::Error::New(env, "del: key required");
+    }
+
+    try {
+        auto key = (key_mode_.val & key_mode::ordinal) ?
+            keymou::from(info[0], env, id_buf_) : 
+            keymou::from(info[0], env, key_buf_);
+        auto rc = mdbx_del(*txn_, dbi_, key, nullptr);
+        if (rc == MDBX_NOTFOUND) {
+            return Napi::Value::From(env, false);
+        }
+        if (rc != MDBX_SUCCESS) {
+            throw Napi::Error::New(env, mdbx_strerror(rc));
+        }
+        return Napi::Value::From(env, true);
+    } catch (const std::exception& e) {
+        throw Napi::Error::New(env, std::string("del: ") + e.what());
+    }
+
+    return env.Undefined();
+}
+
+Napi::Value dbimou::has(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    
+    if (info.Length() < 1) {
+        throw Napi::Error::New(env, "Key is required");
+    }
+
+    try {
+        auto key = (key_mode_.val & key_mode::ordinal) ?
+            keymou::from(info[0], env, id_buf_) : 
+            keymou::from(info[0], env, key_buf_);
+        auto rc = mdbx_get(*txn_, dbi_, key, nullptr);
+        if (rc == MDBX_NOTFOUND) {
+            return Napi::Value::From(env, false);
+        }
+        if (rc != MDBX_SUCCESS) {
+            throw Napi::Error::New(env, mdbx_strerror(rc));
+        }
+        return Napi::Value::From(env, true);
+    } catch (const std::exception& e) {
+        throw Napi::Error::New(env, std::string("has: ") + e.what());
+    }
+
+    return env.Undefined();
+}
+
+Napi::Value dbimou::for_each(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    
+    if (info.Length() < 1) {
+        throw Napi::TypeError::New(env, "Expected at least one argument");
+    }
+
+    // Проверяем тип вызова: forEach(fn), forEach(fromKey, fn) или forEach(fromKey, cursorMode, fn)
+    if (info.Length() == 1 && info[0].IsFunction()) {
+        // Обычный forEach(fn)
+        auto fn = info[0].As<Napi::Function>();
+        
+        MDBX_cursor* cursor_ptr;
+        auto rc = mdbx_cursor_open(*txn_, dbi_, &cursor_ptr);
+        if (rc != MDBX_SUCCESS) {
+            throw Napi::Error::New(env, mdbx_strerror(rc));
+        }
+        
+        std::size_t index{};
+
+        try {
+            cursormou_managed cursor{ cursor_ptr };
+            if (key_mode_.val & key_mode::ordinal) {
+                cursor.scan([&](const mdbx::pair& f) {
+                    keymou key{f.key};
+                    valuemou val{f.value};
+                    // Конвертируем ключ
+                    Napi::Value rc_key = (key_flag_.val & base_flag::bigint) ?
+                        key.to_bigint(env) : key.to_number(env);
+                    // Конвертируем значение
+                    Napi::Value rc_val = (value_flag_.val & base_flag::string) ?
+                        val.to_string(env) : val.to_buffer(env);
+
+                    Napi::Value result = fn.Call({ rc_key, rc_val, 
+                        Napi::Number::New(env, index) });
+
+                    index++;
+
+                    // true will stop the scan, false will continue
+                    return result.IsBoolean() ? result.ToBoolean() : false;
+                });
+            } else {
+                cursor.scan([&](const mdbx::pair& f) {
+                    keymou key{f.key};
+                    valuemou val{f.value};
+                    // Конвертируем ключ
+                    Napi::Value rc_key = (key_flag_.val & base_flag::string) ?
+                        key.to_string(env) : key.to_buffer(env);
+
+                    // Конвертируем значение
+                    Napi::Value rc_val = (value_flag_.val & base_flag::string) ?
+                        val.to_string(env) : val.to_buffer(env);
+                    
+                    Napi::Value result = fn.Call({ rc_key, rc_val, 
+                        Napi::Number::New(env, index) });
+
+                    index++;
+
+                    // true will stop the scan, false will continue
+                    return result.IsBoolean() ? result.ToBoolean() : false;
+                });
+            }
+        } catch (const std::exception& e) {
+            throw Napi::Error::New(env, std::string("forEach: ") + e.what());
+        }
+
+        return Napi::Number::New(env, index);
+        
+    } else if ((info.Length() == 2 && info[1].IsFunction()) || 
+               (info.Length() == 3 && info[2].IsFunction())) {
+        // forEach(fromKey, fn) или forEach(fromKey, cursorMode, fn) - делегируем внутреннему методу
+        return for_each_from(info);
+        
+    } else {
+        throw Napi::TypeError::New(env, "Expected function, (key, function) or (key, cursorMode, function)");
+    }
+}
+
+Napi::Value dbimou::for_each_from(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    
+    // Определяем позицию функции: info[1] или info[2]
+    Napi::Function fn;
+    if (info.Length() == 2 && info[1].IsFunction()) {
+        fn = info[1].As<Napi::Function>();
+    } else if (info.Length() == 3 && info[2].IsFunction()) {
+        fn = info[2].As<Napi::Function>();
+    } else {
+        throw Napi::TypeError::New(env, "Function argument required");
+    }
+    
+    MDBX_cursor* cursor_ptr;
+    auto rc = mdbx_cursor_open(*txn_, dbi_, &cursor_ptr);
+    if (rc != MDBX_SUCCESS) {
+        throw Napi::Error::New(env, mdbx_strerror(rc));
+    }
+    
+    try {
+        cursormou_managed cursor{ cursor_ptr };
+        
+        // Парсим начальный ключ
+        keymou from_key = mdbx::is_ordinal(key_mode_) ?
+            keymou::from(info[0], env, id_buf_) : 
+            keymou::from(info[0], env, key_buf_);
+        
+        // Парсим cursor mode (если передан)
+        using move_operation = mdbx::cursor::move_operation;
+        auto cursor_mode = move_operation::key_greater_or_equal;
+        auto turn_mode = move_operation::next;
+
+        if (info.Length() == 3 && !info[1].IsUndefined()) {
+            cursor_mode = parse_cursor_mode(info[1]);
+            
+            // Определяем направление сканирования на основе операции
+            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;
+            }
+        }
+        
+        std::size_t index{};
+        bool is_key_equal_mode = (cursor_mode == move_operation::key_equal || 
+                                  cursor_mode == move_operation::multi_exactkey_value_equal);
+        if (key_mode_.val & key_mode::ordinal) {
+            cursor.scan_from([&](const mdbx::pair& f) {
+                keymou key{f.key};
+                valuemou val{f.value};
+                if (is_key_equal_mode) {
+                    if (id_buf_ != key.as_int64()) {
+                        return true; // останавливаем сканирование
+                    }
+                }
+
+                // Конвертируем ключ
+                Napi::Value rc_key = (key_flag_.val & base_flag::bigint) ?
+                    key.to_bigint(env) : key.to_number(env);
+                // Конвертируем значение
+                Napi::Value rc_val = (value_flag_.val & base_flag::string) ?
+                    val.to_string(env) : val.to_buffer(env);
+
+                Napi::Value result = fn.Call({ rc_key, rc_val, 
+                    Napi::Number::New(env, index) });
+
+                index++;
+
+                // true will stop the scan, false will continue
+                return result.IsBoolean() ? result.ToBoolean() : false;
+            }, from_key, cursor_mode, turn_mode);
+        } else {
+            cursor.scan_from([&](const mdbx::pair& f) {
+                keymou key{f.key};
+                valuemou val{f.value};
+                if (is_key_equal_mode) {
+                    if (from_key != key) {
+                        return true; // останавливаем сканирование
+                    }
+                }
+
+                // Конвертируем ключ
+                Napi::Value rc_key = (key_flag_.val & base_flag::string) ?
+                    key.to_string(env) : key.to_buffer(env);
+
+                // Конвертируем значение
+                Napi::Value rc_val = (value_flag_.val & base_flag::string) ?
+                    val.to_string(env) : val.to_buffer(env);
+                
+                Napi::Value result = fn.Call({ rc_key, rc_val, 
+                    Napi::Number::New(env, index) });
+
+                index++;
+
+                // true will stop the scan, false will continue
+                return result.IsBoolean() ? result.ToBoolean() : false;
+            }, from_key, cursor_mode, turn_mode);
+        }
+        
+        return Napi::Number::New(env, index);
+    } catch (const std::exception& e) {
+        throw Napi::Error::New(env, std::string("forEach: ") + e.what());
+    }
+}
+
+Napi::Value dbimou::stat(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    
+    try {
+        auto stat = get_stat(*txn_, dbi_);
+        
+        Napi::Object result = Napi::Object::New(env);
+        
+        result.Set("pageSize", Napi::Number::New(env, stat.ms_psize));
+        result.Set("depth", Napi::Number::New(env, stat.ms_depth));
+        result.Set("branchPages", Napi::Number::New(env, 
+            static_cast<double>(stat.ms_branch_pages)));
+        result.Set("leafPages", Napi::Number::New(env, 
+            static_cast<double>(stat.ms_leaf_pages)));
+        result.Set("overflowPages", Napi::Number::New(env, 
+            static_cast<double>(stat.ms_overflow_pages)));
+        result.Set("entries", Napi::Number::New(env, 
+            static_cast<double>(stat.ms_entries)));
+        result.Set("modTxnId", Napi::Number::New(env, 
+            static_cast<double>(stat.ms_mod_txnid)));
+        return result;
+    } catch (const std::exception& e) {
+        throw Napi::Error::New(env, std::string("stat: ") + e.what());
+    }
+
+    return env.Undefined();
+}
+
+Napi::Value dbimou::keys(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    
+    MDBX_cursor* cursor_ptr;
+    auto rc = mdbx_cursor_open(*txn_, dbi_, &cursor_ptr);
+    if (rc != MDBX_SUCCESS) {
+        throw Napi::Error::New(env, mdbx_strerror(rc));
+    }
+
+    try {
+        cursormou_managed cursor{ cursor_ptr };
+        auto stat = get_stat(*txn_, dbi_);
+        
+        // Создаем массив для ключей
+        Napi::Array keys = Napi::Array::New(env, stat.ms_entries);
+        if (stat.ms_entries == 0) {
+            return keys;
+        }
+
+        std::size_t index{};
+        if (key_mode_.val & key_mode::ordinal) {
+            cursor.scan([&](const mdbx::pair& f) {
+                keymou key{f.key};
+                // Конвертируем ключ
+                Napi::Value rc_key = (key_flag_.val & base_flag::bigint) ?
+                    key.to_bigint(env) : key.to_number(env);
+                
+                keys.Set(index++, rc_key);
+                return false; // продолжаем сканирование
+            });
+        } else {
+            cursor.scan([&](const mdbx::pair& f) {
+                keymou key{f.key};
+                // Конвертируем ключ
+                Napi::Value rc_key = (key_flag_.val & base_flag::string) ?
+                    key.to_string(env) : key.to_buffer(env);
+                
+                keys.Set(index++, rc_key);
+                return false; // продолжаем сканирование
+            });
+        }
+
+        return keys;
+    } catch (const std::exception& e) {
+        throw Napi::Error::New(env, std::string("keys: ") + e.what());
+    }
+
+    return env.Undefined();
+}
+
+Napi::Value dbimou::keys_from(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    
+    if (info.Length() < 1) {
+        throw Napi::Error::New(env, "keysFrom: 'from' key required");
+    }
+    
+    MDBX_cursor* cursor_ptr;
+    auto rc = mdbx_cursor_open(*txn_, dbi_, &cursor_ptr);
+    if (rc != MDBX_SUCCESS) {
+        throw Napi::Error::New(env, mdbx_strerror(rc));
+    }
+
+    try {
+        cursormou_managed cursor{ cursor_ptr };
+        
+        // Парсим аргументы: from, limit, cursorMode
+        keymou from_key = mdbx::is_ordinal(key_mode_) ?
+            keymou::from(info[0], env, id_buf_) : 
+            keymou::from(info[0], env, key_buf_);
+        
+        std::size_t count = SIZE_MAX;
+        if (info.Length() > 1 && !info[1].IsUndefined()) {
+            count = info[1].As<Napi::Number>().Uint32Value();
+        }
+        
+        using move_operation = mdbx::cursor::move_operation;
+        auto cursor_mode = move_operation::key_greater_or_equal;
+        auto turn_mode = move_operation::next;
+
+        if (info.Length() > 2 && !info[2].IsUndefined()) {
+            cursor_mode = parse_cursor_mode(info[2]);
+            
+            // Определяем направление сканирования на основе операции
+            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;
+            }
+        }
+        
+        // Создаем массив для ключей
+        Napi::Array keys = Napi::Array::New(env);
+        std::size_t index{};
+        bool is_key_equal_mode = (cursor_mode == move_operation::key_equal || 
+                                  cursor_mode == move_operation::multi_exactkey_value_equal);
+        
+        if (key_mode_.val & key_mode::ordinal) {
+            cursor.scan_from([&](const mdbx::pair& f) {
+                if (index >= count) {
+                    return true; // останавливаем сканирование
+                }
+                
+                keymou key{f.key};
+                if (is_key_equal_mode) {
+                    if (id_buf_ != key.as_int64()) {
+                        return true; // останавливаем сканирование
+                    }
+                }
+
+                // Конвертируем ключ
+                Napi::Value rc_key = (key_flag_.val & base_flag::bigint) ?
+                    key.to_bigint(env) : key.to_number(env);
+                
+                keys.Set(index++, rc_key);
+                                
+                return false; // продолжаем сканирование
+            }, from_key, cursor_mode, turn_mode);
+        } else {     
+            cursor.scan_from([&](const mdbx::pair& f) {
+                if (index >= count) {
+                    return true; // останавливаем сканирование
+                }
+
+                keymou key{f.key};
+                if (is_key_equal_mode) {
+                    if (from_key != key) {
+                        return true; // останавливаем сканирование
+                    }
+                }                
+
+                // Конвертируем ключ
+                Napi::Value rc_key = (key_flag_.val & base_flag::string) ?
+                    key.to_string(env) : key.to_buffer(env);
+                
+                keys.Set(index++, rc_key);
+                
+                return false; // продолжаем сканирование
+            }, from_key, cursor_mode, turn_mode);
+        }
+        
+        return keys;
+    } catch (const std::exception& e) {
+        throw Napi::Error::New(env, std::string("keysFrom: ") + e.what());
+    }
+
+    return env.Undefined();
+}
+
+const env_arg0* dbimou::get_env_userctx(MDBX_env* e) 
+{
+    assert(e);
+    auto rc = static_cast<env_arg0*>(mdbx_env_get_userctx(e));
+    if (!rc)
+        throw std::runtime_error("env: userctx not set");
+    return rc;
+} 
+
+} // namespace mdbxmou

package/src/dbimou.hpp

@@ -0,0 +1,82 @@
+#pragma once
+
+#include "valuemou.hpp"
+#include "querymou.hpp"
+#include "env_arg0.hpp"
+#include <memory>
+
+namespace mdbxmou {
+
+class envmou;
+class txnmou;
+struct env_arg0;
+
+class dbimou final
+    : public Napi::ObjectWrap<dbimou>
+{
+    // мы должны отслеживать время жизни evn
+    envmou* env_{nullptr};
+    txnmou* txn_{nullptr};
+    MDBX_dbi dbi_{};
+    db_mode mode_{};
+    key_mode key_mode_{};
+    value_mode value_mode_{};
+    base_flag key_flag_{};
+    base_flag value_flag_{};
+    buffer_type key_buf_{};
+    buffer_type val_buf_{};
+    std::uint64_t id_buf_{};
+    
+public:
+    static inline MDBX_stat get_stat(MDBX_txn* txn, MDBX_dbi dbi) 
+    {
+        MDBX_stat stat;
+        auto rc = mdbx_dbi_stat(txn, dbi, &stat, sizeof(stat));
+        if (rc != MDBX_SUCCESS) {
+            throw std::runtime_error(mdbx_strerror(rc));
+        }
+        return stat;
+    }    
+    
+    static Napi::FunctionReference ctor;
+
+    dbimou(const Napi::CallbackInfo& info)
+        : Napi::ObjectWrap<dbimou>(info) 
+    {  }
+
+    static void init(const char *class_name, Napi::Env env);
+
+    // Основные операции (только синхронные)
+    Napi::Value put(const Napi::CallbackInfo&);
+    Napi::Value get(const Napi::CallbackInfo&);
+    Napi::Value del(const Napi::CallbackInfo&);
+    Napi::Value has(const Napi::CallbackInfo&);
+    Napi::Value for_each(const Napi::CallbackInfo&);
+    Napi::Value stat(const Napi::CallbackInfo&);
+    Napi::Value keys(const Napi::CallbackInfo&);
+    Napi::Value keys_from(const Napi::CallbackInfo&);
+
+private:
+    // Внутренний метод для forEach с начальным ключом
+    Napi::Value for_each_from(const Napi::CallbackInfo&);
+
+public:
+
+    void attach(envmou* env, txnmou* txn, MDBX_dbi dbi, 
+        db_mode mode, key_mode key_mode, value_mode value_mode, 
+        base_flag key_flag, base_flag value_flag)
+    {
+        env_ = env;
+        txn_ = txn;
+        dbi_ = dbi;
+        mode_ = mode;
+        key_mode_ = key_mode;
+        value_mode_ = value_mode;
+        key_flag_ = key_flag;
+        value_flag_ = value_flag;
+    }
+
+    static const env_arg0* get_env_userctx(MDBX_env* env_ptr);
+};
+
+} // namespace mdbxmou

package/src/env_arg0.hpp

@@ -0,0 +1,24 @@
+#pragma once
+
+#include "valuemou.hpp"
+// #include <sys/syscall.h>
+// #include <unistd.h>
+
+namespace mdbxmou {
+
+struct env_arg0 {
+    std::string path;
+    MDBX_dbi max_dbi{32};
+    mdbx::env::geometry geom{};
+    env_flag flag{};
+    mode_t file_mode{0664};
+    std::uint32_t max_readers{128};
+    base_flag key_flag{};
+    base_flag value_flag{};
+};
+
+// static inline pid_t gettid() {
+//     return static_cast<pid_t>(syscall(SYS_gettid));
+// }
+
+} // namespace mdbxmou