mdbxmou 0.1.26

package/src/querymou.cpp

@@ -0,0 +1,177 @@
+#include "querymou.hpp"
+
+namespace mdbxmou {
+
+void async_common::parse(txn_mode txn, const Napi::Object& obj)
+{
+    if (obj.Has("db")) {
+        db_name = obj.Get("db").As<Napi::String>().Utf8Value();
+        db = mdbx::slice{db_name};
+    }
+
+    if (obj.Has("dbMode")) {
+        db_mod = db_mode::parse(txn, obj.Get("dbMode").As<Napi::Number>());
+    }
+
+    if (obj.Has("keyFlag")) {
+        key_flag = base_flag::parse_key(obj.Get("keyFlag").As<Napi::Number>());
+    }
+
+    if (obj.Has("keyMode")) {
+        key_mod = parse_key_mode(obj.Env(), obj.Get("keyMode").As<Napi::Number>(), key_flag);
+    }
+
+    // парсим value
+    if (obj.Has("valueMode")) {
+        val_mod = value_mode::parse(obj.Get("valueMode").As<Napi::Number>());
+    }    
+}
+
+void async_key::parse(const async_common& common, const Napi::Value& item)
+{
+    // утснавлиаем общие параметры
+    auto key_flag = common.key_flag;
+
+    keymou key{};
+    if (common.key_mod.val & key_mode::ordinal) {
+        if (item.IsBigInt()) {
+            key = keymou{item.As<Napi::BigInt>(), id_buf};
+        } else if (item.IsNumber()) {
+            key = keymou{item.As<Napi::Number>(), id_buf};
+        }
+    } else {
+        key = (key_flag.val & base_flag::string) ?
+           keymou{item.As<Napi::String>(), item.Env(), key_buf} :
+           keymou{item.As<Napi::Buffer<char>>(), key_buf};
+    }
+}
+
+void async_keyval::parse(const query_line& common, const Napi::Object& item)
+{
+    async_key::parse(common, item);    
+    // проверяем надо ли что-то писать
+    if (common.mode.val & query_mode::write_mask) {
+        valuemou val{};
+        auto item_val = item.Get("value");
+        val = (common.value_flag.val & base_flag::string) ?
+            valuemou{item_val.As<Napi::String>(), item_val.Env(), val_buf} :
+            valuemou{item_val.As<Napi::Buffer<char>>(), val_buf};
+    }
+}
+
+void query_line::parse(txn_mode txn, const Napi::Object& obj)
+{
+    //  парсим общие параметры
+    async_common::parse(txn, obj);
+
+    if (obj.Has("valueFlag")) {
+        value_flag = base_flag::parse_value(val_mod, 
+            obj.Get("valueFlag").As<Napi::Number>());
+    }    
+
+    if (obj.Has("mode")) {
+        mode = query_mode::parse(txn, obj.Get("mode").As<Napi::Number>());
+    } else if (obj.Has("queryMode")) {
+        mode = query_mode::parse(txn, obj.Get("queryMode").As<Napi::Number>());
+    }    
+}
+
+void query_line::parse(txn_mode txn, base_flag kf, 
+        base_flag vf, const Napi::Object& obj)
+{
+    // утснавлиаем общие параметры
+    this->key_flag = kf;
+    this->value_flag = vf;
+
+    // парсим общие параметры
+    parse(txn, obj);
+
+    // Парсим элементы
+    if (obj.Has("item")) {
+        auto items_array = obj.Get("item").As<Napi::Array>();
+        auto length = items_array.Length();
+        item.reserve(length);
+        for (std::size_t i = 0; i < length; ++i) {
+            auto item_obj = items_array.Get(i).As<Napi::Object>();
+            async_keyval keyval{};
+            keyval.parse(*this, item_obj);
+            item.emplace_back(std::move(keyval));
+        }
+    } else {
+        throw std::runtime_error("query: no item");
+    }
+}
+
+query_request parse_query(txn_mode mode, base_flag key_flag, 
+        base_flag value_flag, const Napi::Value& obj)
+{
+    query_request rc{};
+    if (obj.IsArray()) {
+        auto arr = obj.As<Napi::Array>();
+        rc.reserve(arr.Length());
+        for (std::size_t i = 0; i < arr.Length(); ++i) {
+            query_line row{};
+            row.parse(mode, key_flag, value_flag, arr.Get(i).As<Napi::Object>());
+            rc.push_back(std::move(row));
+        }
+    } else if (obj.IsObject()) {
+        query_line row{};
+        row.parse(mode, key_flag, value_flag, obj.As<Napi::Object>());
+        rc.push_back(std::move(row));
+    } else {
+        throw Napi::TypeError::New(obj.Env(), "Expected array or object for query");
+    }
+    return rc;
+}
+
+void keys_line::parse(txn_mode txn, 
+    base_flag kf, const Napi::Object& obj)
+{
+    // утснавлиаем общие параметры
+    this->key_flag = kf;
+
+    // парсим общие параметры
+    async_common::parse(txn, obj);
+
+    // парсим параметры scan_from
+    if (obj.Has("from")) {
+        keymou key{};
+        has_from_key = true;
+        async_key::parse(*this, obj.Get("from"));
+    }
+    
+    if (obj.Has("limit")) {
+        auto limit_val = obj.Get("limit");
+        if (limit_val.IsNumber()) {
+            limit = limit_val.As<Napi::Number>().Uint32Value();
+        }
+    }
+    
+    if (obj.Has("cursorMode")) {
+        cursor_mode = parse_cursor_mode(obj.Get("cursorMode"));
+    }    
+}
+
+keys_request parse_keys(txn_mode txn, base_flag key_flag, 
+    base_flag value_flag, const Napi::Value& obj)
+{
+    keys_request rc{};
+    if (obj.IsArray()) {
+        auto arr = obj.As<Napi::Array>();
+        rc.reserve(arr.Length());
+        for (std::size_t i = 0; i < arr.Length(); ++i) {
+            keys_line row{};
+            row.parse(txn, key_flag, arr.Get(i).As<Napi::Object>());
+            rc.push_back(std::move(row));
+        }
+    } else if (obj.IsObject()) {
+        keys_line row{};
+        row.parse(txn, key_flag, obj.As<Napi::Object>());
+        rc.push_back(std::move(row));
+    } else {
+        throw Napi::TypeError::New(obj.Env(), "Expected array or object for query");
+    }
+    return rc;
+}
+
+} // namespace mdbxmou

package/src/querymou.hpp

@@ -0,0 +1,93 @@
+#pragma once
+
+#include "valuemou.hpp"
+#include <mdbx.h++>
+
+namespace mdbxmou {
+
+struct keys_line;
+struct query_line;
+
+struct async_common 
+{
+    // чтобы уметь открыть базу по умолчанию
+    mdbx::slice db{};
+    std::string db_name{};
+    db_mode db_mod{};
+    // тут важен для нас ordinal он влияет на option_mask
+    key_mode key_mod{};
+    base_flag key_flag{};
+    // общий используется для открытия db
+    value_mode val_mod{};
+
+    void parse(txn_mode mode, const Napi::Object& obj);
+};
+
+struct async_key 
+{
+    buffer_type key_buf{};
+    std::uint64_t id_buf{};
+    void parse(const async_common& common, const Napi::Value& item);
+    
+    void parse(const async_common& common, const Napi::Object& item)
+    {  
+        parse(common, item.Get("key"));
+    }
+};
+
+struct async_keyval
+    : async_key
+{
+    buffer_type val_buf{};
+    bool found{false};
+
+    void parse(const query_line& line, const Napi::Object& obj);
+
+    void set(const mdbx::slice& val) {
+        if (val.empty()) {
+            val_buf.clear();
+        } else {
+            val_buf.assign(val.char_ptr(), val.end_char_ptr());
+        }
+    }
+};
+
+struct query_line 
+    : async_common
+{
+    base_flag value_flag{};
+    query_mode mode{};
+
+    void parse(txn_mode mode, const Napi::Object& obj);
+
+    // буффер для запроса / ответа
+    std::vector<async_keyval> item{};
+    void parse(txn_mode txn, base_flag key_flag, 
+        base_flag value_flag, const Napi::Object& obj);
+};
+
+using query_request = std::vector<query_line>;
+query_request parse_query(txn_mode txn, base_flag key_flag, 
+        base_flag value_flag, const Napi::Value& obj);
+
+
+struct keys_line 
+    : async_common
+    , async_key
+{
+    using move_operation = mdbx::cursor::move_operation;
+    bool has_from_key{false};
+    std::size_t limit{SIZE_MAX};
+    move_operation cursor_mode{move_operation::key_greater_or_equal};  // режим курсора
+    // буффер для ответов
+    std::vector<async_key> item{};
+
+    void parse(txn_mode txn, base_flag key_flag,
+        const Napi::Object& obj);
+};
+
+using keys_request = std::vector<keys_line>;
+keys_request parse_keys(txn_mode txn, base_flag key_flag, 
+        base_flag value_flag, const Napi::Value& obj);
+
+} // namespace mdbxmou

package/src/txnmou.cpp

@@ -0,0 +1,254 @@
+#include "txnmou.hpp"
+#include "envmou.hpp"
+
+namespace mdbxmou {
+
+Napi::FunctionReference txnmou::ctor{};
+
+void txnmou::init(const char *class_name, Napi::Env env) {
+    auto func = DefineClass(env, class_name, {
+        InstanceMethod("commit", &txnmou::commit),
+        InstanceMethod("abort", &txnmou::abort),
+        InstanceMethod("openMap", &txnmou::open_map),
+        InstanceMethod("createMap", &txnmou::create_map),
+        InstanceMethod("isActive", &txnmou::is_active),
+        InstanceMethod("isTopLevel", &txnmou::is_top_level),
+#ifdef MDBX_TXN_HAS_CHILD        
+        InstanceMethod("startTransaction", &txnmou::start_transaction),
+        InstanceMethod("getChildrenCount", &txnmou::get_children_count),
+#endif
+    });
+
+    ctor = Napi::Persistent(func);
+    ctor.SuppressDestruct();
+}
+
+Napi::Value txnmou::commit(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    try {
+        check();
+#ifdef MDBX_TXN_HAS_CHILD
+        // Проверяем активные дочерние транзакции
+        cleanup_children();
+
+        if (has_active_children()) {
+            throw std::runtime_error("txn: active child exist");
+        }
+#endif // MDBX_TXN_HAS_CHILD        
+        auto rc = mdbx_txn_commit(*this);
+        if (rc != MDBX_SUCCESS) {
+            throw Napi::Error::New(env, std::string("txn: ") + mdbx_strerror(rc));
+        }
+
+        is_committed_ = true;
+        // Отключаем deleter, так как транзакция уже закоммичена
+        txn_.reset();
+    } catch (const std::exception& e) {
+        throw Napi::Error::New(env, e.what());
+    }
+    
+    return env.Undefined();
+}
+
+Napi::Value txnmou::abort(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    
+    try {
+        check();
+#ifdef MDBX_TXN_HAS_CHILD  
+        // Сначала отменяем все дочерние транзакции
+        cleanup_children();
+
+        for (const auto& child : children_) {
+            if (child && child->txn_ && !child->is_committed_ && !child->is_aborted_) {
+                try {
+                    child->abort(info);
+                } catch (...) {
+                    // Игнорируем ошибки при abort дочерних
+                }
+            }
+        }
+#endif // MDBX_TXN_HAS_CHILD
+        auto rc = mdbx_txn_abort(*this);
+        if (rc != MDBX_SUCCESS) {
+            throw Napi::Error::New(env, std::string("txn: ") + mdbx_strerror(rc));
+        }
+
+        is_aborted_ = true;
+        txn_.reset();
+    } catch (const std::exception& e) {
+        throw Napi::Error::New(env, e.what());
+    }
+    
+    return env.Undefined();
+}
+
+Napi::Value txnmou::get_dbi(const Napi::CallbackInfo& info, db_mode db_mode)
+{
+    Napi::Env env = info.Env();
+
+    try
+    {
+        if ((mode_.val & txn_mode::ro) && (db_mode.val & db_mode::create)) {
+            throw std::runtime_error("dbi: cannot open DB in read-only transaction");
+        }
+
+        key_mode key_mode{};
+        value_mode value_mode{};
+        std::string db_name{};
+        auto conf = dbimou::get_env_userctx(*env_);
+        auto key_flag = conf->key_flag;
+        auto value_flag = conf->value_flag;
+        auto arg_count = info.Length();
+        if (arg_count == 3) {
+            auto arg0 = info[0]; // db_name
+            auto arg1 = info[1]; // key_mode
+            auto arg2 = info[2]; // value_mode
+            db_name = arg0.As<Napi::String>().Utf8Value();
+            key_mode = parse_key_mode(env, arg1, key_flag);
+            value_mode = value_mode::parse(arg2);
+        } else if (arg_count == 2) {
+            // db_name + key_mode || key_mode + value_mode
+            auto arg0 = info[0]; 
+            auto arg1 = info[1]; 
+            if (arg0.IsString()) {
+                db_name = arg0.As<Napi::String>().Utf8Value();
+                key_mode = parse_key_mode(env, arg1, key_flag);
+            } else if (arg0.IsNumber()) {
+                key_mode = parse_key_mode(env, arg0, key_flag);
+                value_mode = value_mode::parse(arg1);
+            } else {
+                throw Napi::Error::New(env, "Invalid argument type for db_name or value_mode");
+            }
+        } else if (arg_count == 1) {
+            // db_name || key_mode
+            auto arg0 = info[0];
+            if (arg0.IsString()) {
+                db_name = arg0.As<Napi::String>().Utf8Value();
+            } else {
+                key_mode = parse_key_mode(env, arg0, key_flag);
+            }
+        } else {
+            throw Napi::Error::New(env, "Invalid number of arguments for get_dbi");
+        }
+
+        check();    
+
+        // создаем новый объект dbi
+        auto obj = dbimou::ctor.New({});
+        auto ptr = dbimou::Unwrap(obj);        
+
+        MDBX_dbi dbi{};
+        auto flags = static_cast<MDBX_db_flags_t>(db_mode.val|key_mode.val|value_mode.val);
+        auto rc = mdbx_dbi_open(*this, db_name.empty() ? nullptr : db_name.c_str(), flags, &dbi);
+        if (rc != MDBX_SUCCESS) {
+            throw std::runtime_error(std::string("mdbx_dbi_open ") + mdbx_strerror(rc));
+        }
+        ptr->attach(env_, this, dbi, db_mode, key_mode, 
+            value_mode, key_flag, value_flag);
+        return obj;
+    }
+    catch(const std::exception& e)
+    {
+        throw Napi::Error::New(env, std::string("txn: get_dbi ") + e.what());
+    }
+    
+    return env.Undefined();
+}
+
+Napi::Value txnmou::is_active(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    bool active = txn_ && !is_committed_ && !is_aborted_;
+    return Napi::Boolean::New(env, active);
+}
+
+Napi::Value txnmou::is_top_level(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    return Napi::Boolean::New(env, parent_ == nullptr);
+}
+
+#ifdef MDBX_TXN_HAS_CHILD   
+
+Napi::Value txnmou::start_transaction(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    // Создаем новый объект txnmou для дочерней транзакции
+    auto child_obj = ctor.New({});
+    auto child_wrapper = txnmou::Unwrap(child_obj);
+
+    int rc{MDBX_SUCCESS};
+    try {
+        check();
+
+        MDBX_txn* child_txn;
+        auto rc = mdbx_txn_begin(*env_, txn_.get(), flags_, &child_txn);
+        if (rc != MDBX_SUCCESS) {
+            std::string flag_name = (flags_ == MDBX_TXN_RDONLY) ? "read" : "write";
+            throw Napi::Error::New(env, std::string("txn ") + flag_name + ": " + mdbx_strerror(rc));
+        }
+        child_wrapper->attach(*env_, child_txn, flags_, this);
+    } catch (const std::exception& e) {
+        throw Napi::Error::New(env, e.what());
+    }  
+
+    return child_obj;
+}
+
+Napi::Value txnmou::get_children_count(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    cleanup_children();
+    
+    size_t active_count = 0;
+    for (const auto& child : children_) {
+        if (child && child->txn_ && !child->is_committed_ && !child->is_aborted_) {
+            active_count++;
+        }
+    }
+    
+    return Napi::Number::New(env, static_cast<double>(active_count));
+}
+
+#endif // MDBX_TXN_HAS_CHILD
+
+void txnmou::attach(envmou& env, MDBX_txn* txn, 
+    txn_mode mode, txnmou* parent) 
+{
+    // увеличиваем счетчик транзакций в env
+    env_ = &env;
+
+    if (parent == nullptr) {
+        // Если родительская транзакция не указана, увеличиваем счетчик
+        ++(*env_);
+    }
+
+    parent_ = parent;
+    mode_ = mode;
+    is_committed_ = false;
+    is_aborted_ = false;
+
+#ifdef MDBX_TXN_HAS_CHILD        
+    if (parent) {
+        parent->push_back(this);
+    }
+#endif  
+    txn_.reset(txn);
+}
+
+void txnmou::free_txn::operator()(MDBX_txn* txn) const noexcept {
+    if (!that.is_committed_ && !that.is_aborted_) {
+        // Автоматический abort при деструкции
+        auto rc = mdbx_txn_abort(that);
+        if (rc != MDBX_SUCCESS) {
+            fprintf(stderr, "mdbx_txn_abort code: %d, msg: %s\n", rc, mdbx_strerror(rc));
+        }
+        that.is_aborted_ = true;
+    }
+    // уменьшаем счетчик транзакций (только родительских)
+    if (that.parent_ == nullptr) {
+        //fprintf(stderr, "free_txn: --env\n");
+        --(*that.env_);
+    }
+}
+
+} // namespace mdbxmou

package/src/txnmou.hpp

@@ -0,0 +1,122 @@
+#pragma once
+
+#include "dbimou.hpp"
+
+#ifdef MDBX_TXN_HAS_CHILD   
+#include <vector>
+#endif
+
+namespace mdbxmou {
+
+class envmou;
+
+class txnmou final 
+    : public Napi::ObjectWrap<txnmou>
+{
+private:
+    envmou* env_{nullptr};
+    // транзакция
+    struct free_txn {
+        txnmou& that;
+        void operator()(MDBX_txn* txn) const noexcept;
+    };
+
+    free_txn erase_{*this};
+    std::unique_ptr<MDBX_txn, free_txn> txn_{nullptr, erase_};
+
+    // Иерархия транзакций
+    txnmou* parent_{nullptr};
+#ifdef MDBX_TXN_HAS_CHILD    
+    std::vector<txnmou*> children_{};
+#endif
+    
+    // Флаг для отслеживания состояния
+    bool is_committed_{};
+    bool is_aborted_{};
+    
+    // Сохраняем тип транзакции для создания дочерних того же типа
+    txn_mode mode_{};
+
+    void check_valid() const 
+    {
+        if (is_committed_)
+            throw std::runtime_error("txn: already committed");
+        if (is_aborted_)
+            throw std::runtime_error("txn: already aborted");
+    }
+
+    void check() const
+    {
+        check_valid();
+
+        if (!txn_)
+            throw std::runtime_error("txn: not initialized");
+    }    
+
+#ifdef MDBX_TXN_HAS_CHILD   
+    // Проверка активных дочерних транзакций
+    bool has_active_children() const {
+        for (const auto& child : children_) {
+            if (child && child->txn_ && !child->is_committed_ && !child->is_aborted_) {
+                return true;
+            }
+        }
+        return false;
+    }
+    
+    // Очистка завершенных дочерних транзакций
+    void cleanup_children() {
+        children_.erase(
+            std::remove_if(children_.begin(), children_.end(),
+                [](const txnmou* child) {
+                    return !child || child->is_committed_ || child->is_aborted_;
+                }),
+            children_.end()
+        );
+    }
+    
+    // Общий метод для создания дочерних транзакций
+    Napi::Value start_transaction(const Napi::CallbackInfo& info, MDBX_txn_flags_t flags);
+
+    void push_back(txnmou* child) {
+        children_.push_back(child);
+    }
+#endif 
+    Napi::Value get_dbi(const Napi::CallbackInfo&, db_mode);
+
+public:    
+    static Napi::FunctionReference ctor;
+
+    txnmou(const Napi::CallbackInfo& info)
+        : Napi::ObjectWrap<txnmou>(info) 
+    {   }
+
+    static void init(const char *class_name, Napi::Env env);
+
+    // Основные операции (только синхронные)
+    Napi::Value commit(const Napi::CallbackInfo&);
+    Napi::Value abort(const Napi::CallbackInfo&);
+    Napi::Value open_map(const Napi::CallbackInfo& info) {
+        return get_dbi(info, db_mode{});
+    }
+    Napi::Value create_map(const Napi::CallbackInfo& info) {
+        return get_dbi(info, {db_mode::create});
+    }
+
+    operator MDBX_txn*() const noexcept {
+        return txn_.get();
+    }
+
+#ifdef MDBX_TXN_HAS_CHILD    
+    // Работа с вложенными транзакциями
+    Napi::Value start_transaction(const Napi::CallbackInfo&);
+    Napi::Value get_children_count(const Napi::CallbackInfo&);
+#endif
+    Napi::Value is_active(const Napi::CallbackInfo&);
+    Napi::Value is_top_level(const Napi::CallbackInfo&);
+
+    void attach(envmou& env, MDBX_txn* txn, 
+        txn_mode mode, txnmou* parent = nullptr);
+};
+
+} // namespace mdbxmou