mdbxmou 0.2.4 → 0.2.6

package/src/txnmou.cpp

@@ -12,11 +12,6 @@ void txnmou::init(const char *class_name, Napi::Env env) {
         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);
@@ -28,22 +23,14 @@ Napi::Value txnmou::commit(const Napi::CallbackInfo& info) {
 
     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();
+        dec_counter();
+        txn_.release();
     } catch (const std::exception& e) {
         throw Napi::Error::New(env, e.what());
     }
@@ -56,27 +43,14 @@ Napi::Value txnmou::abort(const Napi::CallbackInfo& info) {
     
     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();
+        dec_counter();
+        txn_.release();
     } catch (const std::exception& e) {
         throw Napi::Error::New(env, e.what());
     }
@@ -84,6 +58,14 @@ Napi::Value txnmou::abort(const Napi::CallbackInfo& info) {
     return env.Undefined();
 }
 
+// Уменьшает счетчик транзакций
+void txnmou::dec_counter() noexcept
+{
+    if (env_) {
+        --(*env_);
+    }
+}
+
 Napi::Value txnmou::get_dbi(const Napi::CallbackInfo& info, db_mode db_mode)
 {
     Napi::Env env = info.Env();
@@ -115,7 +97,7 @@ Napi::Value txnmou::get_dbi(const Napi::CallbackInfo& info, db_mode db_mode)
             if (arg0.IsString()) {
                 db_name = arg0.As<Napi::String>().Utf8Value();
                 key_mode = parse_key_mode(env, arg1, key_flag);
-            } else if (arg0.IsNumber()) {
+            } else if (arg0.IsNumber() || arg0.IsBigInt()) {
                 key_mode = parse_key_mode(env, arg0, key_flag);
                 value_mode = value_mode::parse(arg1);
             } else {
@@ -126,25 +108,25 @@ Napi::Value txnmou::get_dbi(const Napi::CallbackInfo& info, db_mode db_mode)
             auto arg0 = info[0];
             if (arg0.IsString()) {
                 db_name = arg0.As<Napi::String>().Utf8Value();
-            } else {
+            } else if (arg0.IsNumber() || arg0.IsBigInt()) {
                 key_mode = parse_key_mode(env, arg0, key_flag);
+            } else {
+                throw Napi::Error::New(env, "Invalid argument type: expected string (db_name) or number (key_mode)");
             }
-        } else {
-            throw Napi::Error::New(env, "Invalid number of arguments for get_dbi");
         }
+        // arg_count == 0: используем значения по умолчанию (строковый ключ, default db)
 
         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));
         }
+        // создаем новый объект dbi
+        auto obj = dbimou::ctor.New({});
+        auto ptr = dbimou::Unwrap(obj);
         ptr->attach(dbi, db_mode, key_mode, 
             value_mode, key_flag, value_flag);
         return obj;
@@ -159,96 +141,16 @@ Napi::Value txnmou::get_dbi(const Napi::CallbackInfo& info, db_mode db_mode)
 
 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));
+    return Napi::Boolean::New(env, txn_ != nullptr);
 }
 
-#endif // MDBX_TXN_HAS_CHILD
-
-void txnmou::attach(envmou& env, MDBX_txn* txn, 
-    txn_mode mode, txnmou* parent) 
+void txnmou::attach(envmou& env, MDBX_txn* txn, txn_mode mode) 
 {
-    // увеличиваем счетчик транзакций в 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  
+    
+    ++(*env_);
     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

@@ -2,10 +2,6 @@
 
 #include "dbimou.hpp"
 
-#ifdef MDBX_TXN_HAS_CHILD   
-#include <vector>
-#endif
-
 namespace mdbxmou {
 
 class envmou;
@@ -14,74 +10,21 @@ 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_{};
+    envmou* env_{nullptr};    
 
-    void check_valid() const 
-    {
-        if (is_committed_)
-            throw std::runtime_error("txn: already committed");
-        if (is_aborted_)
-            throw std::runtime_error("txn: already aborted");
-    }
+    std::unique_ptr<MDBX_txn, 
+        txnmou_managed::free_txn> txn_{};
+    txn_mode mode_{};
 
-    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;
-            }
+    void check() const {
+        if (!txn_) {
+            throw std::runtime_error("txn: inactive");
         }
-        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 dec_counter() noexcept;
 
-    void push_back(txnmou* child) {
-        children_.push_back(child);
-    }
-#endif 
     Napi::Value get_dbi(const Napi::CallbackInfo&, db_mode);
 
 public:    
@@ -91,9 +34,16 @@ public:
         : Napi::ObjectWrap<txnmou>(info) 
     {   }
 
+    ~txnmou() {
+        if (txn_) {
+            dec_counter();
+        }
+    }
+
+    //void Finalize(Napi::Env env) { fprintf(stderr, "txnmou::Finalize %p\n", this); }
+
     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) {
@@ -107,16 +57,9 @@ public:
         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);
+    void attach(envmou& env, MDBX_txn* txn, txn_mode mode);
 };
 
 } // namespace mdbxmou

package/src/typemou.hpp

@@ -10,21 +10,97 @@ namespace mdbxmou {
 using buffer_type = std::vector<char>;
 
 struct txnmou_managed final
-    : mdbx::txn_managed
+    : mdbx::txn
 {
-    txnmou_managed(MDBX_txn* txn)
-    {  
-        txn::handle_ = txn; 
+    // свободу txn
+    struct free_txn
+    {
+        void operator()(MDBX_txn *txn) const noexcept {
+            mdbx_txn_abort(txn);
+        }
+    };
+
+    std::unique_ptr<MDBX_txn, free_txn> guard_;
+
+    txnmou_managed(MDBX_txn* txn) noexcept
+        : mdbx::txn(txn)
+        , guard_(txn)
+    {   }
+    
+    // Move конструктор
+    txnmou_managed(txnmou_managed&& other) noexcept
+        : mdbx::txn(other.txn::handle_)
+        , guard_(std::move(other.guard_))
+    {
+        other.txn::handle_ = nullptr;
+    }
+    
+    // Запрет копирования
+    txnmou_managed(const txnmou_managed&) = delete;
+    txnmou_managed& operator=(const txnmou_managed&) = delete;
+    
+    ~txnmou_managed() noexcept {
+        // guard_ автоматически откатит транзакцию
+        txn::handle_ = nullptr;
+    }
+    
+    // Commit транзакции
+    void commit() {
+        if (guard_) {
+            auto rc = ::mdbx_txn_commit(guard_.release());
+            txn::handle_ = nullptr;
+            if (rc != MDBX_SUCCESS) {
+                throw std::runtime_error(::mdbx_strerror(rc));
+            }
+        }
+    }
+    
+    // Abort транзакции
+    void abort() {
+        if (guard_) {
+            auto rc = ::mdbx_txn_abort(guard_.release());
+            txn::handle_ = nullptr;
+            if (rc != MDBX_SUCCESS) {
+                throw std::runtime_error(::mdbx_strerror(rc));
+            }
+        }
     }
 };
 
 struct cursormou_managed final
-    : mdbx::cursor_managed
+    : mdbx::cursor
 {
-    cursormou_managed(MDBX_cursor* cursor) noexcept
-    {  
-        cursor::handle_ = cursor; 
-    }    
+    // свободу курсору
+    struct free_cursor
+    {
+        void operator()(MDBX_cursor* c) const noexcept {
+            if (c) ::mdbx_cursor_close(c);
+        }
+    };
+
+    std::unique_ptr<MDBX_cursor, free_cursor> guard_;
+
+    explicit cursormou_managed(MDBX_cursor* cursor) noexcept
+        : mdbx::cursor(cursor)
+        , guard_(cursor)
+    {   }
+    
+    // Move конструктор
+    cursormou_managed(cursormou_managed&& other) noexcept
+        : mdbx::cursor(other.cursor::handle_)
+        , guard_(std::move(other.guard_))
+    {
+        other.cursor::handle_ = nullptr;
+    }
+    
+    // Запрет копирования
+    cursormou_managed(const cursormou_managed&) = delete;
+    cursormou_managed& operator=(const cursormou_managed&) = delete;
+    
+    ~cursormou_managed() noexcept {
+        // guard_ автоматически закроет курсор
+        cursor::handle_ = nullptr;
+    }
 };
 
 struct env_flag {

package/src/valuemou.hpp

@@ -38,9 +38,8 @@ public:
         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);
@@ -48,6 +47,8 @@ public:
             throw Napi::Error::New(env, "napi_get_value_string_utf8 copyout");
         }
 
+        mem.resize(length);
+
         assign(mem.data(), mem.size());
     }