mdbxmou 0.3.2 → 0.3.4

package/CMakeLists.txt

@@ -47,6 +47,13 @@ if(MSVC)
     target_link_libraries(${PROJECT_NAME} ntdll.lib)
 endif()
 
+# Batch read limit for mdbx_cursor_get_batch (pairs count = limit / 2)
+if(NOT DEFINED MDBXMOU_BATCH_LIMIT)
+    set(MDBXMOU_BATCH_LIMIT 512)
+endif()
+add_definitions(-DMDBXMOU_BATCH_LIMIT=${MDBXMOU_BATCH_LIMIT})
+message(STATUS "MDBXMOU_BATCH_LIMIT: ${MDBXMOU_BATCH_LIMIT}")
+
 # Include N-API wrappers
 execute_process(COMMAND node -p "require('node-addon-api').include"
     WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}

package/README.md

@@ -88,6 +88,58 @@ Options:
 
 Note: When `keyFlag` or `valueFlag` are set at environment level, they become defaults for all subsequent operations unless explicitly overridden.
 
+### Key Type Configuration
+
+The library uses a two-level system for configuring key types:
+
+#### Level 1: Environment (`keyFlag`)
+
+When opening the environment, `keyFlag` controls how **string/binary keys** are returned:
+
+| `keyFlag` value | String/Binary keys returned as |
+|-----------------|-------------------------------|
+| `0` (default)   | `Buffer`                      |
+| `keyFlag.string` (2) | `String`                 |
+
+```javascript
+// Keys returned as Buffer (default)
+await env.open({ path: './data' });
+
+// Keys returned as String
+await env.open({ 
+  path: './data',
+  keyFlag: MDBX_Param.keyFlag.string 
+});
+```
+
+#### Level 2: Database (`keyMode`)
+
+When opening/creating a database, the **argument type** determines how **ordinal (integer) keys** are returned:
+
+| Argument type | Ordinal keys returned as |
+|---------------|-------------------------|
+| `Number`      | `Number`                |
+| `BigInt`      | `BigInt`                |
+
+```javascript
+// Ordinal keys as Number
+const dbi = txn.openMap(MDBX_Param.keyMode.ordinal);        // keyMode.ordinal = 8
+dbi.keys(txn);  // [0, 1, 2, 3, ...]
+
+// Ordinal keys as BigInt  
+const dbi = txn.openMap(BigInt(MDBX_Param.keyMode.ordinal)); // BigInt(8)
+dbi.keys(txn);  // [0n, 1n, 2n, 3n, ...]
+```
+
+#### Summary
+
+| Key type | Configuration level | Option | Result type |
+|----------|--------------------|--------------------|-------------|
+| String/Binary | env.open() | `keyFlag: 0` | `Buffer` |
+| String/Binary | env.open() | `keyFlag: keyFlag.string` | `String` |
+| Ordinal | openMap/createMap | `keyMode.ordinal` (Number) | `Number` |
+| Ordinal | openMap/createMap | `BigInt(keyMode.ordinal)` | `BigInt` |
+
 **close() → Promise**
 ```javascript
 await env.close();

package/lib/types.d.ts

@@ -147,6 +147,36 @@ export interface MDBX_Cursor<K extends MDBXKey = MDBXKey, V extends MDBXValue =
    */
   forEach(callback: (item: MDBXCursorResult<K, V>) => boolean | void, backward?: boolean): void;
   
+  /** 
+   * Check if cursor is at end-of-data (beyond first or last record).
+   * @returns true if cursor has no valid position
+   */
+  eof(): boolean;
+  
+  /** 
+   * Check if cursor is on first record in database.
+   * @returns true if on first record
+   */
+  onFirst(): boolean;
+  
+  /** 
+   * Check if cursor is on last record in database.
+   * @returns true if on last record
+   */
+  onLast(): boolean;
+  
+  /** 
+   * Check if cursor is on first value of current key (DUPSORT databases).
+   * @returns true if on first value for current key
+   */
+  onFirstMultival(): boolean;
+  
+  /** 
+   * Check if cursor is on last value of current key (DUPSORT databases).
+   * @returns true if on last value for current key
+   */
+  onLastMultival(): boolean;
+  
   /** 
    * Close cursor. Must be called before transaction commit/abort.
    * Safe to call multiple times.

package/package.json

@@ -65,7 +65,7 @@
   },
   "gypfile": true,
   "name": "mdbxmou",
-  "version": "0.3.2",
+  "version": "0.3.4",
   "description": "Node bindings for mdbx",
   "repository": {
     "type": "git",

package/src/async/envmou_close.cpp

@@ -5,9 +5,6 @@ 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) {

package/src/async/envmou_copy_to.cpp

@@ -5,9 +5,6 @@ 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));

package/src/async/envmou_keys.cpp

@@ -1,6 +1,7 @@
 #include "envmou_keys.hpp"
 #include "envmou.hpp"
 #include "dbimou.hpp"
+#include "../valuemou.hpp"
 
 namespace mdbxmou {
 
@@ -92,27 +93,50 @@ void async_keys::do_keys(txnmou_managed& txn,
         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;
-            });
-        }
+        // Используем batch версию для лучшей производительности
+        do_keys_batch(txn, dbi, arg0);
     } else {
         do_keys_from(txn, dbi, arg0);
     }
 }
 
+// Batch версия - читает ключи блоками через cursormou_managed::get_batch
+void async_keys::do_keys_batch(txnmou_managed& txn, 
+    mdbx::map_handle dbi, keys_line& arg0)
+{
+    auto& item = arg0.item;
+    const bool is_ordinal = mdbx::is_ordinal(arg0.key_mod);
+    
+    auto cursor = dbi::get_cursor(txn, dbi);
+
+    // Буфер для batch - MDBXMOU_BATCH_LIMIT/2 пар (key, value)
+#ifndef MDBXMOU_BATCH_LIMIT
+#define MDBXMOU_BATCH_LIMIT 512
+#endif
+    std::array<mdbx::slice, MDBXMOU_BATCH_LIMIT> pairs;
+
+    // Первый вызов с MDBX_FIRST
+    size_t count = cursor.get_batch(pairs, MDBX_FIRST);
+    
+    while (count > 0) {
+        // pairs[0] = key1, pairs[1] = value1, pairs[2] = key2, ...
+        for (size_t i = 0; i < count; i += 2) {
+            keymou key{pairs[i]};
+            async_key key_item{};
+            if (is_ordinal) {
+                key_item.id_buf = key.as_uint64();
+            } else {
+                // Ключ - строка/буфер
+                key_item.key_buf.assign(key.char_ptr(), key.end_char_ptr());
+            }
+            item.push_back(std::move(key_item));
+        }
+        
+        // Следующий batch
+        count = cursor.get_batch(pairs, MDBX_NEXT);
+    }
+}
+
 void async_keys::do_keys_from(txnmou_managed& txn, 
     mdbx::map_handle dbi, keys_line& arg0)
 {

package/src/async/envmou_keys.hpp

@@ -43,6 +43,9 @@ public:
     void do_keys(txnmou_managed& txn, 
         mdbx::map_handle dbi, keys_line& arg0);
 
+    void do_keys_batch(txnmou_managed& txn, 
+        mdbx::map_handle dbi, keys_line& arg0);
+
     void do_keys_from(txnmou_managed& txn, 
         mdbx::map_handle dbi, keys_line& arg0);
 };

package/src/async/envmou_open.cpp

@@ -5,9 +5,6 @@ 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_);
@@ -18,9 +15,6 @@ void async_open::Execute()
 
 void async_open::OnOK() 
 {
-    // выдадим идентфикатор потока для лога (thread_id)
-    // fprintf(stderr, "TRACE: async_open OnOK id=%d\n", gettid());
-
     auto env = Env();
 
     that_.unlock();

package/src/async/envmou_query.cpp

@@ -141,7 +141,7 @@ void async_query::do_get(const txnmou_managed& txn,
     {
         auto key = mdbx::is_ordinal(key_mode) ?
             keymou{q.id_buf} : keymou{q.key_buf};
-        mdbx::slice abs{};
+        mdbx::slice abs;
         valuemou val{txn.get(dbi, key, abs)};
         q.set(val);
     }

package/src/cursormou.cpp

@@ -2,272 +2,234 @@
 #include "dbimou.hpp"
 #include "txnmou.hpp"
 
-namespace mdbxmou {
-
-Napi::FunctionReference cursormou::ctor{};
-
-void cursormou::init(const char *class_name, Napi::Env env)
-{
-    auto func = DefineClass(env, class_name, {
-        InstanceMethod("first", &cursormou::first),
-        InstanceMethod("last", &cursormou::last),
-        InstanceMethod("next", &cursormou::next),
-        InstanceMethod("prev", &cursormou::prev),
-        InstanceMethod("seek", &cursormou::seek),
-        InstanceMethod("seekGE", &cursormou::seek_ge),
-        InstanceMethod("current", &cursormou::current),
-        InstanceMethod("put", &cursormou::put),
-        InstanceMethod("del", &cursormou::del),
-        InstanceMethod("forEach", &cursormou::for_each),
-        InstanceMethod("close", &cursormou::close),
-    });
-
-    ctor = Napi::Persistent(func);
-    ctor.SuppressDestruct();
-}
-
-void cursormou::do_close() noexcept
+namespace mdbxmou
 {
-    if (cursor_) {
-        ::mdbx_cursor_close(std::exchange(cursor_, nullptr));
-        if (txn_) {
-            --(*txn_);
-        }
-    }
-}
 
-cursormou::~cursormou() 
-{
-    do_close();
-}
+    Napi::FunctionReference cursormou::ctor{};
 
-void cursormou::attach(txnmou& txn, dbimou& dbi, MDBX_cursor* cursor)
-{
-    txn_ = &txn;
-    dbi_ = &dbi;
-    cursor_ = cursor;
-    ++(*txn_);
-}
-
-// Внутренний хелпер для навигации
-Napi::Value cursormou::move(const Napi::Env& env, MDBX_cursor_op op)
-{
-    if (!cursor_) {
-        throw Napi::Error::New(env, "cursor closed");
-    }
-    
-    keymou key{};
-    valuemou val{};   
-    auto rc = mdbx_cursor_get(cursor_, key, val, op);
-    if (rc == MDBX_NOTFOUND) {
-        return env.Undefined();
-    }
-    
-    if (rc != MDBX_SUCCESS) {
-        throw Napi::Error::New(env, mdbx_strerror(rc));
+    void cursormou::init(const char *class_name, Napi::Env env)
+    {
+        auto func = DefineClass(env, class_name, {
+            InstanceMethod("first", &cursormou::first),
+            InstanceMethod("last", &cursormou::last),
+            InstanceMethod("next", &cursormou::next),
+            InstanceMethod("prev", &cursormou::prev),
+            InstanceMethod("seek", &cursormou::seek),
+            InstanceMethod("seekGE", &cursormou::seek_ge),
+            InstanceMethod("current", &cursormou::current),
+            InstanceMethod("eof", &cursormou::eof),
+            InstanceMethod("onFirst", &cursormou::on_first),
+            InstanceMethod("onLast", &cursormou::on_last),
+            InstanceMethod("onFirstMultival", &cursormou::on_first_multival),
+            InstanceMethod("onLastMultival", &cursormou::on_last_multival),
+            InstanceMethod("put", &cursormou::put),
+            InstanceMethod("del", &cursormou::del),
+            InstanceMethod("forEach", &cursormou::for_each),
+            InstanceMethod("close", &cursormou::close),
+        });
+
+        ctor = Napi::Persistent(func);
+        ctor.SuppressDestruct();
     }
-    
-    // Возвращаем {key, value}
-    auto result = Napi::Object::New(env);
-    
-    auto key_mode = dbi_->get_key_mode();
-    auto key_flag = dbi_->get_key_flag();
-    auto value_flag = dbi_->get_value_flag();
-    
-    // Ключ
-    if (key_mode.val & key_mode::ordinal) {
-        if (key_flag.val & base_flag::bigint) {
-            result.Set("key", key.to_bigint(env));
-        } else {
-            result.Set("key", key.to_number(env));
+
+    void cursormou::do_close() noexcept
+    {
+        if (cursor_) {
+            ::mdbx_cursor_close(std::exchange(cursor_, nullptr));
+            if (txn_) {
+                --(*txn_);
+            }
         }
-    } else {
-        result.Set("key", key.to_string(env));
     }
-    
-    // Значение
-    if (value_flag.val & base_flag::string) {
-        result.Set("value", val.to_string(env));
-    } else {
-        result.Set("value", val.to_buffer(env));
+
+    cursormou::~cursormou()
+    {
+        do_close();
     }
-    
-    return result;
-}
 
-Napi::Value cursormou::first(const Napi::CallbackInfo& info) {
-    return move(info.Env(), MDBX_FIRST);
-}
+    void cursormou::attach(txnmou &txn, dbimou &dbi, MDBX_cursor *cursor)
+    {
+        txn_ = &(++txn);
+        dbi_ = &dbi;
+        cursor_ = cursor;
+    }
 
-Napi::Value cursormou::last(const Napi::CallbackInfo& info) {
-    return move(info.Env(), MDBX_LAST);
-}
+    // Внутренний хелпер для навигации
+    Napi::Value cursormou::move(const Napi::Env &env, MDBX_cursor_op op)
+    {
+        if (!cursor_) {
+            throw Napi::Error::New(env, "cursor closed");
+        }
 
-Napi::Value cursormou::next(const Napi::CallbackInfo& info) {
-    return move(info.Env(), MDBX_NEXT);
-}
+        keymou key{};
+        valuemou val{};
+        auto rc = mdbx_cursor_get(cursor_, key, val, op);
+        if (rc == MDBX_NOTFOUND) {
+            return env.Undefined();
+        }
 
-Napi::Value cursormou::prev(const Napi::CallbackInfo& info) {
-    return move(info.Env(), MDBX_PREV);
-}
+        if (rc != MDBX_SUCCESS) {
+            throw Napi::Error::New(env, mdbx_strerror(rc));
+        }
 
-Napi::Value cursormou::current(const Napi::CallbackInfo& info) {
-    return move(info.Env(), MDBX_GET_CURRENT);
-}
+        // Возвращаем {key, value}
+        auto result = Napi::Object::New(env);
 
-// Хелпер для поиска
-Napi::Value cursormou::seek_impl(const Napi::CallbackInfo& info, MDBX_cursor_op op)
-{
-    Napi::Env env = info.Env();
-    
-    if (!cursor_) {
-        throw Napi::Error::New(env, "cursor closed");
-    }
-    
-    if (info.Length() < 1) {
-        throw Napi::Error::New(env, "key required");
-    }
-    
-    auto key_mode = dbi_->get_key_mode();
-    
-    keymou key = (key_mode.val & key_mode::ordinal) ?
-        keymou::from(info[0], env, key_num_) : 
-        keymou::from(info[0], env, key_buf_);
-    
-    valuemou val{};
-    auto rc = mdbx_cursor_get(cursor_, key, val, op);
-    if (MDBX_NOTFOUND == rc) {
-        return env.Undefined();
-    }
+        auto key_mode = dbi_->get_key_mode();
+        auto key_flag = dbi_->get_key_flag();
+        auto value_flag = dbi_->get_value_flag();
 
-    if (MDBX_SUCCESS != rc) {
-        throw Napi::Error::New(env, mdbx_strerror(rc));
-    }
-    
-    // Возвращаем {key, value}
-    auto result = Napi::Object::New(env);
-    
-    auto key_flag = dbi_->get_key_flag();
-    auto value_flag = dbi_->get_value_flag();
-    
-    // Ключ
-    if (key_mode.val & key_mode::ordinal) {
-        if (key_flag.val & base_flag::bigint) {
-            result.Set("key", key.to_bigint(env));
+        // Ключ
+        if (key_mode.val & key_mode::ordinal) {
+            if (key_flag.val & base_flag::bigint) {
+                result.Set("key", key.to_bigint(env));
+            } else {
+                result.Set("key", key.to_number(env));
+            }
         } else {
-            result.Set("key", key.to_number(env));
+            result.Set("key", key.to_string(env));
         }
-    } else {
-        result.Set("key", key.to_string(env));
-    }
-    
-    // Значение
-    if (value_flag.val & base_flag::string) {
-        result.Set("value", val.to_string(env));
-    } else {
-        result.Set("value", val.to_buffer(env));
+
+        // Значение
+        if (value_flag.val & base_flag::string) {
+            result.Set("value", val.to_string(env));
+        } else {
+            result.Set("value", val.to_buffer(env));
+        }
+
+        return result;
     }
-    
-    return result;
-}
-
-Napi::Value cursormou::seek(const Napi::CallbackInfo& info) {
-    return seek_impl(info, MDBX_SET_KEY);
-}
-
-Napi::Value cursormou::seek_ge(const Napi::CallbackInfo& info) {
-    return seek_impl(info, MDBX_SET_RANGE);
-}
-
-Napi::Value cursormou::put(const Napi::CallbackInfo& info) {
-    Napi::Env env = info.Env();
-    
-    if (!cursor_) {
-        throw Napi::Error::New(env, "cursor closed");
+
+    Napi::Value cursormou::first(const Napi::CallbackInfo &info)
+    {
+        return move(info.Env(), MDBX_FIRST);
     }
-    
-    if (info.Length() < 2) {
-        throw Napi::Error::New(env, "key and value required");
+
+    Napi::Value cursormou::last(const Napi::CallbackInfo &info)
+    {
+        return move(info.Env(), MDBX_LAST);
     }
-    
-    auto key_mode = dbi_->get_key_mode();
-    
-    keymou key = (key_mode.val & key_mode::ordinal) ?
-        keymou::from(info[0], env, key_num_) : 
-        keymou::from(info[0], env, key_buf_);
-    
-    valuemou val = valuemou::from(info[1], env, val_buf_);
-    
-    // Опциональный флаг put_mode (по умолчанию MDBX_UPSERT)
-    MDBX_put_flags_t flags = MDBX_UPSERT;
-    if (info.Length() > 2 && info[2].IsNumber()) {
-        flags = static_cast<MDBX_put_flags_t>(info[2].As<Napi::Number>().Int32Value());
+
+    Napi::Value cursormou::next(const Napi::CallbackInfo &info)
+    {
+        return move(info.Env(), MDBX_NEXT);
     }
-    
-    auto rc = mdbx_cursor_put(cursor_, key, val, flags);
-    if (MDBX_SUCCESS != rc) {
-        throw Napi::Error::New(env, mdbx_strerror(rc));
+
+    Napi::Value cursormou::prev(const Napi::CallbackInfo &info)
+    {
+        return move(info.Env(), MDBX_PREV);
     }
-    
-    return env.Undefined();
-}
-
-Napi::Value cursormou::del(const Napi::CallbackInfo& info) {
-    Napi::Env env = info.Env();
-    
-    if (!cursor_) {
-        throw Napi::Error::New(env, "cursor closed");
+
+    Napi::Value cursormou::current(const Napi::CallbackInfo &info)
+    {
+        return move(info.Env(), MDBX_GET_CURRENT);
     }
-    
-    // Опциональный флаг (MDBX_NODUPDATA для удаления только текущего значения в multi-value)
-    MDBX_put_flags_t flags = MDBX_CURRENT;
-    if (info.Length() > 0 && info[0].IsNumber()) {
-        flags = static_cast<MDBX_put_flags_t>(info[0].As<Napi::Number>().Int32Value());
+
+    Napi::Value cursormou::eof(const Napi::CallbackInfo &info)
+    {
+        Napi::Env env = info.Env();
+        if (!cursor_) {
+            throw Napi::Error::New(env, "cursor closed");
+        }
+        auto rc = ::mdbx_cursor_eof(cursor_);
+        if (rc == MDBX_RESULT_TRUE)
+            return Napi::Boolean::New(env, true);
+        if (rc == MDBX_RESULT_FALSE)
+            return Napi::Boolean::New(env, false);
+        throw Napi::Error::New(env, mdbx_strerror(rc));
     }
-    
-    auto rc = mdbx_cursor_del(cursor_, flags);
-    if (MDBX_NOTFOUND == rc) {
-        return Napi::Boolean::New(env, false);
+
+    Napi::Value cursormou::on_first(const Napi::CallbackInfo &info)
+    {
+        Napi::Env env = info.Env();
+        if (!cursor_) {
+            throw Napi::Error::New(env, "cursor closed");
+        }
+        auto rc = ::mdbx_cursor_on_first(cursor_);
+        if (rc == MDBX_RESULT_TRUE)
+            return Napi::Boolean::New(env, true);
+        if (rc == MDBX_RESULT_FALSE)
+            return Napi::Boolean::New(env, false);
+        throw Napi::Error::New(env, mdbx_strerror(rc));
     }
-    
-    if (MDBX_SUCCESS != rc) {
+
+    Napi::Value cursormou::on_last(const Napi::CallbackInfo &info)
+    {
+        Napi::Env env = info.Env();
+        if (!cursor_) {
+            throw Napi::Error::New(env, "cursor closed");
+        }
+        auto rc = ::mdbx_cursor_on_last(cursor_);
+        if (rc == MDBX_RESULT_TRUE)
+            return Napi::Boolean::New(env, true);
+        if (rc == MDBX_RESULT_FALSE)
+            return Napi::Boolean::New(env, false);
         throw Napi::Error::New(env, mdbx_strerror(rc));
     }
-    
-    return Napi::Boolean::New(env, true);
-}
-
-// forEach(callback, backward = false)
-// callback({key, value}) => true продолжить, false/undefined остановить
-Napi::Value cursormou::for_each(const Napi::CallbackInfo& info) {
-    Napi::Env env = info.Env();
-    
-    if (!cursor_) {
-        throw Napi::Error::New(env, "cursor closed");
+
+    Napi::Value cursormou::on_first_multival(const Napi::CallbackInfo &info)
+    {
+        Napi::Env env = info.Env();
+        if (!cursor_) {
+            throw Napi::Error::New(env, "cursor closed");
+        }
+        auto rc = ::mdbx_cursor_on_first_dup(cursor_);
+        if (rc == MDBX_RESULT_TRUE)
+            return Napi::Boolean::New(env, true);
+        if (rc == MDBX_RESULT_FALSE)
+            return Napi::Boolean::New(env, false);
+        throw Napi::Error::New(env, mdbx_strerror(rc));
     }
-    
-    if (info.Length() < 1 || !info[0].IsFunction()) {
-        throw Napi::TypeError::New(env, "forEach: callback function required");
+
+    Napi::Value cursormou::on_last_multival(const Napi::CallbackInfo &info)
+    {
+        Napi::Env env = info.Env();
+        if (!cursor_) {
+            throw Napi::Error::New(env, "cursor closed");
+        }
+        auto rc = ::mdbx_cursor_on_last_dup(cursor_);
+        if (rc == MDBX_RESULT_TRUE)
+            return Napi::Boolean::New(env, true);
+        if (rc == MDBX_RESULT_FALSE)
+            return Napi::Boolean::New(env, false);
+        throw Napi::Error::New(env, mdbx_strerror(rc));
     }
-    
-    auto callback = info[0].As<Napi::Function>();
-    bool backward = info.Length() > 1 && info[1].ToBoolean().Value();
-    
-    auto key_mode = dbi_->get_key_mode();
-    auto key_flag = dbi_->get_key_flag();
-    auto value_flag = dbi_->get_value_flag();
-    
-    MDBX_cursor_op start_op = backward ? MDBX_LAST : MDBX_FIRST;
-    MDBX_cursor_op move_op = backward ? MDBX_PREV : MDBX_NEXT;
-    
-    keymou key{};
-    valuemou val{};
-    // Первое позиционирование
-    auto rc = mdbx_cursor_get(cursor_, key, val, start_op);
-    while (MDBX_SUCCESS == rc) 
+
+    // Хелпер для поиска
+    Napi::Value cursormou::seek_impl(const Napi::CallbackInfo &info, MDBX_cursor_op op)
     {
+        Napi::Env env = info.Env();
+
+        if (!cursor_) {
+            throw Napi::Error::New(env, "cursor closed");
+        }
+
+        if (info.Length() < 1) {
+            throw Napi::Error::New(env, "key required");
+        }
+
+        auto key_mode = dbi_->get_key_mode();
+
+        keymou key = (key_mode.val & key_mode::ordinal) ? 
+            keymou::from(info[0], env, key_num_) : 
+            keymou::from(info[0], env, key_buf_);
+
+        valuemou val{};
+        auto rc = mdbx_cursor_get(cursor_, key, val, op);
+        if (MDBX_NOTFOUND == rc) {
+            return env.Undefined();
+        }
+
+        if (MDBX_SUCCESS != rc) {
+            throw Napi::Error::New(env, mdbx_strerror(rc));
+        }
+
+        // Возвращаем {key, value}
         auto result = Napi::Object::New(env);
-        
+
+        auto key_flag = dbi_->get_key_flag();
+        auto value_flag = dbi_->get_value_flag();
+
         // Ключ
         if (key_mode.val & key_mode::ordinal) {
             if (key_flag.val & base_flag::bigint) {
@@ -278,36 +240,160 @@ Napi::Value cursormou::for_each(const Napi::CallbackInfo& info) {
         } else {
             result.Set("key", key.to_string(env));
         }
-        
+
         // Значение
         if (value_flag.val & base_flag::string) {
             result.Set("value", val.to_string(env));
         } else {
             result.Set("value", val.to_buffer(env));
         }
-        
-        // Вызов callback
-        auto ret = callback.Call({result});
-        
-        // true stops the scan, false/undefined continues (same as dbi.forEach)
-        if (ret.IsBoolean() && ret.As<Napi::Boolean>().Value()) {
-            break;
+
+        return result;
+    }
+
+    Napi::Value cursormou::seek(const Napi::CallbackInfo &info)
+    {
+        return seek_impl(info, MDBX_SET_KEY);
+    }
+
+    Napi::Value cursormou::seek_ge(const Napi::CallbackInfo &info)
+    {
+        return seek_impl(info, MDBX_SET_RANGE);
+    }
+
+    Napi::Value cursormou::put(const Napi::CallbackInfo &info)
+    {
+        Napi::Env env = info.Env();
+
+        if (!cursor_) {
+            throw Napi::Error::New(env, "cursor closed");
+        }
+
+        if (info.Length() < 2) {
+            throw Napi::Error::New(env, "key and value required");
+        }
+
+        auto key_mode = dbi_->get_key_mode();
+
+        keymou key = (key_mode.val & key_mode::ordinal) ? 
+            keymou::from(info[0], env, key_num_) : 
+            keymou::from(info[0], env, key_buf_);
+
+        valuemou val = valuemou::from(info[1], env, val_buf_);
+
+        // Опциональный флаг put_mode (по умолчанию MDBX_UPSERT)
+        MDBX_put_flags_t flags = MDBX_UPSERT;
+        if (info.Length() > 2 && info[2].IsNumber()) {
+            flags = static_cast<MDBX_put_flags_t>(info[2].As<Napi::Number>().Int32Value());
+        }
+
+        auto rc = mdbx_cursor_put(cursor_, key, val, flags);
+        if (MDBX_SUCCESS != rc) {
+            throw Napi::Error::New(env, mdbx_strerror(rc));
         }
-        
-        // Следующий элемент
-        rc = mdbx_cursor_get(cursor_, key, val, move_op);
+
+        return env.Undefined();
     }
-    
-    if (rc != MDBX_SUCCESS && rc != MDBX_NOTFOUND) {
-        throw Napi::Error::New(env, mdbx_strerror(rc));
+
+    Napi::Value cursormou::del(const Napi::CallbackInfo &info)
+    {
+        Napi::Env env = info.Env();
+
+        if (!cursor_) {
+            throw Napi::Error::New(env, "cursor closed");
+        }
+
+        // Опциональный флаг (MDBX_NODUPDATA для удаления только текущего значения в multi-value)
+        MDBX_put_flags_t flags = MDBX_CURRENT;
+        if (info.Length() > 0 && info[0].IsNumber()) {
+            flags = static_cast<MDBX_put_flags_t>(info[0].As<Napi::Number>().Int32Value());
+        }
+
+        auto rc = mdbx_cursor_del(cursor_, flags);
+        if (MDBX_NOTFOUND == rc) {
+            return Napi::Boolean::New(env, false);
+        }
+
+        if (MDBX_SUCCESS != rc) {
+            throw Napi::Error::New(env, mdbx_strerror(rc));
+        }
+
+        return Napi::Boolean::New(env, true);
+    }
+
+    // forEach(callback, backward = false)
+    // callback({key, value}) => true продолжить, false/undefined остановить
+    Napi::Value cursormou::for_each(const Napi::CallbackInfo &info)
+    {
+        Napi::Env env = info.Env();
+
+        if (!cursor_) {
+            throw Napi::Error::New(env, "cursor closed");
+        }
+
+        if (info.Length() < 1 || !info[0].IsFunction()) {
+            throw Napi::TypeError::New(env, "forEach: callback function required");
+        }
+
+        auto callback = info[0].As<Napi::Function>();
+        bool backward = info.Length() > 1 && info[1].ToBoolean().Value();
+
+        auto key_mode = dbi_->get_key_mode();
+        auto key_flag = dbi_->get_key_flag();
+        auto value_flag = dbi_->get_value_flag();
+
+        MDBX_cursor_op start_op = backward ? MDBX_LAST : MDBX_FIRST;
+        MDBX_cursor_op move_op = backward ? MDBX_PREV : MDBX_NEXT;
+
+        keymou key{};
+        valuemou val{};
+        // Первое позиционирование
+        auto rc = mdbx_cursor_get(cursor_, key, val, start_op);
+        while (MDBX_SUCCESS == rc)
+        {
+            auto result = Napi::Object::New(env);
+
+            // Ключ
+            if (key_mode.val & key_mode::ordinal) {
+                if (key_flag.val & base_flag::bigint) {
+                    result.Set("key", key.to_bigint(env));
+                } else {
+                    result.Set("key", key.to_number(env));
+                }
+            } else {
+                result.Set("key", key.to_string(env));
+            }
+
+            // Значение
+            if (value_flag.val & base_flag::string) {
+                result.Set("value", val.to_string(env));
+            } else {
+                result.Set("value", val.to_buffer(env));
+            }
+
+            // Вызов callback
+            auto ret = callback.Call({result});
+
+            // true stops the scan, false/undefined continues (same as dbi.forEach)
+            if (ret.IsBoolean() && ret.ToBoolean()) {
+                break;
+            }
+
+            // Следующий элемент
+            rc = mdbx_cursor_get(cursor_, key, val, move_op);
+        }
+
+        if (rc != MDBX_SUCCESS && rc != MDBX_NOTFOUND) {
+            throw Napi::Error::New(env, mdbx_strerror(rc));
+        }
+
+        return env.Undefined();
+    }
+
+    Napi::Value cursormou::close(const Napi::CallbackInfo &info)
+    {
+        do_close();
+        return info.Env().Undefined();
     }
-    
-    return env.Undefined();
-}
-
-Napi::Value cursormou::close(const Napi::CallbackInfo& info) {
-    do_close();
-    return info.Env().Undefined();
-}
 
 } // namespace mdbxmou

package/src/cursormou.hpp

@@ -53,6 +53,13 @@ public:
     // Текущая позиция
     Napi::Value current(const Napi::CallbackInfo&);
     
+    // Статус курсора
+    Napi::Value eof(const Napi::CallbackInfo&);
+    Napi::Value on_first(const Napi::CallbackInfo&);
+    Napi::Value on_last(const Napi::CallbackInfo&);
+    Napi::Value on_first_multival(const Napi::CallbackInfo&);
+    Napi::Value on_last_multival(const Napi::CallbackInfo&);
+    
     // Модификация
     Napi::Value put(const Napi::CallbackInfo&);
     Napi::Value del(const Napi::CallbackInfo&);

package/src/dbi.cpp

@@ -46,11 +46,16 @@ bool dbi::del(MDBX_txn* txn, const keymou& key)
 
 
 cursormou_managed dbi::open_cursor(MDBX_txn* txn) const
+{
+    return get_cursor(txn, mdbx::map_handle{ id_ });
+}
+
+cursormou_managed dbi::get_cursor(MDBX_txn* txn, mdbx::map_handle dbi)
 {
     MDBX_cursor* cursor_ptr;
-    auto rc = mdbx_cursor_open(txn, id_, &cursor_ptr);
+    auto rc = mdbx_cursor_open(txn, dbi.dbi, &cursor_ptr);
     if (rc != MDBX_SUCCESS) {
-        throw std::runtime_error(mdbx_strerror(rc));
+        mdbx::error::throw_exception(rc);
     }
     return cursormou_managed{ cursor_ptr };
 }

package/src/dbi.hpp

@@ -37,6 +37,9 @@ public:
     bool del(MDBX_txn* txn, const keymou& key);
 
     cursormou_managed open_cursor(MDBX_txn* txn) const;
+    
+    // Static version for map_handle
+    static cursormou_managed get_cursor(MDBX_txn* txn, mdbx::map_handle dbi);
 
     // Drop database or delete it
     void drop(MDBX_txn* txn, bool delete_db = false);

package/src/dbimou.cpp

@@ -61,7 +61,8 @@ Napi::Value dbimou::put(const Napi::CallbackInfo& info)
     return env.Undefined();
 }
 
-Napi::Value dbimou::get(const Napi::CallbackInfo& info) {
+Napi::Value dbimou::get(const Napi::CallbackInfo& info) 
+{
     Napi::Env env = info.Env();
     auto arg_len = info.Length();
     if (arg_len < 2) {
@@ -94,7 +95,8 @@ Napi::Value dbimou::get(const Napi::CallbackInfo& info) {
     return env.Undefined();
 }
 
-Napi::Value dbimou::del(const Napi::CallbackInfo& info) {
+Napi::Value dbimou::del(const Napi::CallbackInfo& info) 
+{
     Napi::Env env = info.Env();
     auto arg_len = info.Length();
     if (arg_len < 2) {
@@ -122,7 +124,8 @@ Napi::Value dbimou::del(const Napi::CallbackInfo& info) {
     return env.Undefined();
 }
 
-Napi::Value dbimou::has(const Napi::CallbackInfo& info) {
+Napi::Value dbimou::has(const Napi::CallbackInfo& info) 
+{
     Napi::Env env = info.Env();
     auto arg_len = info.Length();
     if (arg_len < 2) {
@@ -150,7 +153,8 @@ Napi::Value dbimou::has(const Napi::CallbackInfo& info) {
     return env.Undefined();
 }
 
-Napi::Value dbimou::for_each(const Napi::CallbackInfo& info) {
+Napi::Value dbimou::for_each(const Napi::CallbackInfo& info) 
+{
     Napi::Env env = info.Env();
     auto arg_len = info.Length();
     if (arg_len < 2) {
@@ -188,7 +192,7 @@ Napi::Value dbimou::for_each(const Napi::CallbackInfo& info) {
                     // Конвертируем значение
                     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, static_cast<double>(index)) });
 
@@ -208,7 +212,7 @@ Napi::Value dbimou::for_each(const Napi::CallbackInfo& info) {
                     // Конвертируем значение
                     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, static_cast<double>(index)) });
 
@@ -320,7 +324,7 @@ Napi::Value dbimou::for_each_from(const Napi::CallbackInfo& info) {
                 // Конвертируем значение
                 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, static_cast<double>(index)) });
 
@@ -346,7 +350,7 @@ Napi::Value dbimou::for_each_from(const Napi::CallbackInfo& info) {
                 // Конвертируем значение
                 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, static_cast<double>(index)) });
 
@@ -415,8 +419,7 @@ Napi::Value dbimou::keys(const Napi::CallbackInfo& info) {
     auto txn = Napi::ObjectWrap<txnmou>::Unwrap(arg0);
     
     try {
-        auto cursor = dbi::open_cursor(*txn);
-        auto stat = dbi::get_stat(*txn);
+        auto stat = get_stat(*txn);
         
         // Создаем массив для ключей
         Napi::Array keys = Napi::Array::New(env, stat.ms_entries);
@@ -424,27 +427,38 @@ Napi::Value dbimou::keys(const Napi::CallbackInfo& info) {
             return keys;
         }
 
+        // Используем batch версию для лучшей производительности
+        auto cursor = open_cursor(*txn);
+
+        // Буфер для batch - MDBXMOU_BATCH_LIMIT/2 пар (key, value)
+#ifndef MDBXMOU_BATCH_LIMIT
+#define MDBXMOU_BATCH_LIMIT 512
+#endif // MDBXMOU_BATCH_LIMIT
+        std::array<mdbx::slice, MDBXMOU_BATCH_LIMIT> pairs;
+
         uint32_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);
-                
+        const bool is_ordinal = key_mode_.val & key_mode::ordinal;
+        const bool is_bigint = key_flag_.val & base_flag::bigint;
+        const bool is_string = key_flag_.val & base_flag::string;
+        
+        // Первый вызов с MDBX_FIRST
+        size_t count = cursor.get_batch(pairs, MDBX_FIRST);
+        
+        while (count > 0) {
+            // pairs[0] = key1, pairs[1] = value1, pairs[2] = key2, ...
+            for (size_t i = 0; i < count; i += 2) {
+                keymou key{pairs[i]};
+                Napi::Value rc_key;
+                if (is_ordinal) {
+                    rc_key = is_bigint ? key.to_bigint(env) : key.to_number(env);
+                } else {
+                    rc_key = is_string ? key.to_string(env) : key.to_buffer(env);
+                }
                 keys.Set(index++, rc_key);
-                return false; // продолжаем сканирование
-            });
+            }
+            
+            // Следующий batch
+            count = cursor.get_batch(pairs, MDBX_NEXT);
         }
 
         return keys;

package/src/envmou.cpp

@@ -193,11 +193,6 @@ MDBX_env* envmou::create_and_open(const env_arg0& arg0)
         throw std::runtime_error(mdbx_strerror(rc));
     }
 
-#ifdef _WIN32
-    auto id = static_cast<std::uint32_t>(GetCurrentThreadId());
-#else
-    auto id = static_cast<std::uint32_t>(pthread_self());
-#endif
     // выдадим параметры mode, flag и id потока в котором открывается env
     rc = mdbx_env_open(env, arg0.path.c_str(), arg0.flag, arg0.file_mode);
     if (rc != MDBX_SUCCESS) {

package/src/querymou.cpp

@@ -5,7 +5,7 @@ namespace mdbxmou {
 
 dbimou* async_common::parse(const Napi::Object& arg0)
 {
-    dbimou* dbi = nullptr;
+    dbimou* dbi{};
     // если просто передали dbi
     if (arg0.InstanceOf(dbimou::ctor.Value())) {
         dbi = Napi::ObjectWrap<dbimou>::Unwrap(arg0);

package/src/txnmou.cpp

@@ -155,8 +155,7 @@ Napi::Value txnmou::open_cursor(const Napi::CallbackInfo& info) {
     auto* dbi = dbimou::Unwrap(arg0);
     
     MDBX_cursor* cursor{};
-    int rc = mdbx_cursor_open(txn_.get(), dbi->get_id(), &cursor);
-    
+    auto rc = mdbx_cursor_open(txn_.get(), dbi->get_id(), &cursor);
     if (rc != MDBX_SUCCESS) {
         throw Napi::Error::New(env, std::string("mdbx_cursor_open: ") + mdbx_strerror(rc));
     }
@@ -174,10 +173,8 @@ Napi::Value txnmou::is_active(const Napi::CallbackInfo& info) {
 
 void txnmou::attach(envmou& env, MDBX_txn* txn, txn_mode mode) 
 {
-    env_ = &env;
+    env_ = &(++env);
     mode_ = mode;
-    
-    ++(*env_);
     txn_.reset(txn);
 }
 

package/src/txnmou.hpp

@@ -46,6 +46,7 @@ public:
 
     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{});
     }
@@ -60,9 +61,17 @@ public:
     }
 
     // Cursor counting
-    txnmou& operator++() noexcept { ++cursor_count_; return *this; }
-    txnmou& operator--() noexcept { --cursor_count_; return *this; }
-    std::size_t cursor_count() const noexcept { return cursor_count_; }
+    txnmou& operator++() noexcept { 
+        ++cursor_count_; return *this; 
+    }
+    
+    txnmou& operator--() noexcept { 
+        --cursor_count_; return *this; 
+    }
+    
+    std::size_t cursor_count() const noexcept { 
+        return cursor_count_; 
+    }
 
     Napi::Value is_active(const Napi::CallbackInfo&);
 

package/src/typemou.hpp

@@ -4,6 +4,7 @@
 #include <mdbx.h++>
 #include <cstdint>
 #include <vector>
+#include <array>
 #include <utility>
 
 namespace mdbxmou {
@@ -70,6 +71,33 @@ struct cursormou_managed final
             ::mdbx_cursor_close(cursor::handle_);
         }
     }
+
+    /// \brief Batch read using mdbx_cursor_get_batch
+    /// \param[out] pairs Array of mdbx::slice to fill (key0, val0, key1, val1, ...)
+    /// \param[in] limit Maximum number of slice elements in pairs array
+    /// \param[in] op Cursor operation (MDBX_FIRST or MDBX_NEXT only)
+    /// \return Number of items read (key+value count), 0 if end of data
+    /// \throws mdbx::exception on error
+    size_t get_batch(mdbx::slice* pairs, size_t limit, MDBX_cursor_op op) 
+    {
+        size_t count{};
+        auto rc = ::mdbx_cursor_get_batch(cursor::handle_, &count, pairs, limit, op);
+        if (rc == MDBX_SUCCESS || rc == MDBX_RESULT_TRUE) {
+            return count;
+        }
+        if (rc == MDBX_NOTFOUND || rc == MDBX_ENODATA) {
+            return 0;
+        }
+        mdbx::error::throw_exception(rc);
+        return 0; // unreachable
+    }
+    
+    /// \brief Batch read with std::array
+    template<size_t N>
+    size_t get_batch(std::array<mdbx::slice, N>& pairs, MDBX_cursor_op op) 
+    {
+        return get_batch(pairs.data(), N, op);
+    }
 };
 
 struct env_flag {