mdbxmou 0.3.3 → 0.3.5

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/package.json

@@ -65,7 +65,7 @@
   },
   "gypfile": true,
   "name": "mdbxmou",
-  "version": "0.3.3",
+  "version": "0.3.5",
   "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 {
 
@@ -29,7 +30,7 @@ static Napi::Value write_row(Napi::Env env, const keys_line& row)
     for (std::uint32_t j = 0; j < param.size(); ++j) {
         const auto& item = param[j];
         Napi::Value key_value;
-        if (key_mode.val & key_mode::ordinal) {
+        if (mdbx::is_ordinal(key_mode)) {
             if (key_flag.val & base_flag::number) {
                 key_value = Napi::Number::New(env, static_cast<double>(item.id_buf));
             } else {
@@ -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;
+    auto is_ordinal = mdbx::is_ordinal(arg0.key_mod);
+
+    auto cursor = dbi::open_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

@@ -39,7 +39,7 @@ static Napi::Value write_row(Napi::Env env, const query_line& row)
         const auto& item = param[j];
         Napi::Value key_value;
         Napi::Object js_item = Napi::Object::New(env);
-        if (key_mode.val & key_mode::ordinal) {
+        if (mdbx::is_ordinal(key_mode)) {
             if (key_flag.val & base_flag::number) {
                 key_value = Napi::Number::New(env, static_cast<double>(item.id_buf));
             } else {
@@ -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

@@ -80,7 +80,7 @@ namespace mdbxmou
         auto value_flag = dbi_->get_value_flag();
 
         // Ключ
-        if (key_mode.val & key_mode::ordinal) {
+        if (mdbx::is_ordinal(key_mode)) {
             if (key_flag.val & base_flag::bigint) {
                 result.Set("key", key.to_bigint(env));
             } else {
@@ -210,7 +210,7 @@ namespace mdbxmou
 
         auto key_mode = dbi_->get_key_mode();
 
-        keymou key = (key_mode.val & key_mode::ordinal) ? 
+        keymou key = (mdbx::is_ordinal(key_mode)) ? 
             keymou::from(info[0], env, key_num_) : 
             keymou::from(info[0], env, key_buf_);
 
@@ -231,7 +231,7 @@ namespace mdbxmou
         auto value_flag = dbi_->get_value_flag();
 
         // Ключ
-        if (key_mode.val & key_mode::ordinal) {
+        if (mdbx::is_ordinal(key_mode)) {
             if (key_flag.val & base_flag::bigint) {
                 result.Set("key", key.to_bigint(env));
             } else {
@@ -275,7 +275,7 @@ namespace mdbxmou
 
         auto key_mode = dbi_->get_key_mode();
 
-        keymou key = (key_mode.val & key_mode::ordinal) ? 
+        keymou key = (mdbx::is_ordinal(key_mode)) ? 
             keymou::from(info[0], env, key_num_) : 
             keymou::from(info[0], env, key_buf_);
 
@@ -354,7 +354,7 @@ namespace mdbxmou
             auto result = Napi::Object::New(env);
 
             // Ключ
-            if (key_mode.val & key_mode::ordinal) {
+            if (mdbx::is_ordinal(key_mode)) {
                 if (key_flag.val & base_flag::bigint) {
                     result.Set("key", key.to_bigint(env));
                 } else {

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 open_cursor(txn, mdbx::map_handle{id_});
+}
+
+cursormou_managed dbi::open_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 open_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

@@ -48,7 +48,7 @@ Napi::Value dbimou::put(const Napi::CallbackInfo& info)
     auto txn = Napi::ObjectWrap<txnmou>::Unwrap(arg0);
     try {
         std::uint64_t t;
-        auto key = (key_mode_.val & key_mode::ordinal) ?
+        auto key = mdbx::is_ordinal(key_mode_) ?
             keymou::from(info[1], env, t) : 
             keymou::from(info[1], env, key_buf_);
 
@@ -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) {
@@ -76,7 +77,7 @@ Napi::Value dbimou::get(const Napi::CallbackInfo& info) {
 
     try {
         std::uint64_t t;
-        auto key = (key_mode_.val & key_mode::ordinal) ?
+        auto key = mdbx::is_ordinal(key_mode_) ?
             keymou::from(info[1], env, t) : 
             keymou::from(info[1], env, key_buf_);
         
@@ -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) {
@@ -109,7 +111,7 @@ Napi::Value dbimou::del(const Napi::CallbackInfo& info) {
 
     try {
         std::uint64_t t;
-        auto key = (key_mode_.val & key_mode::ordinal) ?
+        auto key = mdbx::is_ordinal(key_mode_) ?
             keymou::from(info[1], env, t) : 
             keymou::from(info[1], env, key_buf_);
         
@@ -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) {
@@ -137,7 +140,7 @@ Napi::Value dbimou::has(const Napi::CallbackInfo& info) {
 
     try {
         std::uint64_t t;
-        auto key = (key_mode_.val & key_mode::ordinal) ?
+        auto key = mdbx::is_ordinal(key_mode_) ?
             keymou::from(info[1], env, t) : 
             keymou::from(info[1], env, key_buf_);
 
@@ -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) {
@@ -169,16 +173,16 @@ Napi::Value dbimou::for_each(const Napi::CallbackInfo& info) {
         auto fn = info[1].As<Napi::Function>();
         
         try {
-            auto cursor = dbi::open_cursor(*txn);
-            auto stat = dbi::get_stat(*txn);
+            auto stat = get_stat(*txn);
             
             // Проверяем, есть ли записи в базе данных
             if (stat.ms_entries == 0) {
                 return Napi::Number::New(env, 0);
             }
-            
+
+            auto cursor = open_cursor(*txn);
             uint32_t index{};
-            if (key_mode_.val & key_mode::ordinal) {
+            if (mdbx::is_ordinal(key_mode_)) {
                 cursor.scan([&](const mdbx::pair& f) {
                     keymou key{f.key};
                     valuemou val{f.value};
@@ -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)) });
 
@@ -234,7 +238,8 @@ Napi::Value dbimou::for_each(const Napi::CallbackInfo& info) {
     }
 }
 
-Napi::Value dbimou::for_each_from(const Napi::CallbackInfo& info) {
+Napi::Value dbimou::for_each_from(const Napi::CallbackInfo& info) 
+{
     Napi::Env env = info.Env();
     auto arg_len = info.Length();
     
@@ -270,7 +275,7 @@ Napi::Value dbimou::for_each_from(const Napi::CallbackInfo& info) {
         
         // Парсим начальный ключ
         std::uint64_t t;
-        keymou from_key = (key_mode_.val & key_mode::ordinal) ?
+        keymou from_key = (mdbx::is_ordinal(key_mode_)) ?
             keymou::from(info[1], env, t) : 
             keymou::from(info[1], env, key_buf_);
         
@@ -304,7 +309,7 @@ Napi::Value dbimou::for_each_from(const Napi::CallbackInfo& info) {
         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) {
+        if (mdbx::is_ordinal(key_mode_)) {
             cursor.scan_from([&](const mdbx::pair& f) {
                 keymou key{f.key};
                 valuemou val{f.value};
@@ -320,7 +325,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 +351,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)) });
 
@@ -363,7 +368,8 @@ Napi::Value dbimou::for_each_from(const Napi::CallbackInfo& info) {
     }
 }
 
-Napi::Value dbimou::stat(const Napi::CallbackInfo& info) {
+Napi::Value dbimou::stat(const Napi::CallbackInfo& info) 
+{
     Napi::Env env = info.Env();
     auto arg_len = info.Length();
     if (arg_len < 1) {
@@ -401,7 +407,8 @@ Napi::Value dbimou::stat(const Napi::CallbackInfo& info) {
     return env.Undefined();
 }
 
-Napi::Value dbimou::keys(const Napi::CallbackInfo& info) {
+Napi::Value dbimou::keys(const Napi::CallbackInfo& info) 
+{
     Napi::Env env = info.Env();
     auto arg_len = info.Length();
     if (arg_len < 1) {
@@ -415,8 +422,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 +430,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);
-                
+        auto is_ordinal = mdbx::is_ordinal(key_mode_);
+        auto is_bigint = key_flag_.val & base_flag::bigint;
+        auto 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;
@@ -455,7 +472,8 @@ Napi::Value dbimou::keys(const Napi::CallbackInfo& info) {
     return env.Undefined();
 }
 
-Napi::Value dbimou::keys_from(const Napi::CallbackInfo& info) {
+Napi::Value dbimou::keys_from(const Napi::CallbackInfo& info) 
+{
     Napi::Env env = info.Env();
     auto arg_len = info.Length();
     if (arg_len < 2) {
@@ -473,7 +491,7 @@ Napi::Value dbimou::keys_from(const Napi::CallbackInfo& info) {
         
         // Парсим аргументы: txn, from, limit, cursorMode
         std::uint64_t t;
-        keymou from_key = (key_mode_.val & key_mode::ordinal) ?
+        keymou from_key = (mdbx::is_ordinal(key_mode_)) ?
             keymou::from(info[1], env, t) : 
             keymou::from(info[1], env, key_buf_);
         
@@ -514,7 +532,7 @@ Napi::Value dbimou::keys_from(const Napi::CallbackInfo& info) {
         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) {
+        if (mdbx::is_ordinal(key_mode_)) {
             cursor.scan_from([&](const mdbx::pair& f) {
                 if (index >= count) {
                     return true; // останавливаем сканирование
@@ -566,7 +584,8 @@ Napi::Value dbimou::keys_from(const Napi::CallbackInfo& info) {
     return env.Undefined();
 }
 
-Napi::Value dbimou::drop(const Napi::CallbackInfo& info) {
+Napi::Value dbimou::drop(const Napi::CallbackInfo& info) 
+{
     Napi::Env env = info.Env();
     if (info.Length() < 1) {
         throw Napi::TypeError::New(env, "First argument must be a transaction");

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);
@@ -27,7 +27,7 @@ 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 (mdbx::is_ordinal(common.key_mod)) {
         if (item.IsBigInt()) {
             key = keymou{item.As<Napi::BigInt>(), id_buf};
         } else if (item.IsNumber()) {

package/src/txnmou.cpp

@@ -70,21 +70,102 @@ void txnmou::dec_counter() noexcept
     }
 }
 
-Napi::Value txnmou::get_dbi(const Napi::CallbackInfo& info, db_mode db_mode)
+Napi::Value txnmou::get_dbi(const char* name, base_flag key_flag, 
+    base_flag value_flag, key_mode key_mode, value_mode value_mode, 
+    db_mode db_mode)
 {
-    Napi::Env env = info.Env();
+    Napi::Env env = Env();
 
     if ((mode_.val & txn_mode::ro) && (db_mode.val & db_mode::create)) {
         throw Napi::Error::New(env, "dbi: cannot open DB in read-only transaction");
     }
 
+    if (!txn_) {
+        throw Napi::Error::New(env, "txn already completed");
+    }
+
+    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, (name && name[0]) ? name : nullptr, flags, &dbi);
+    if (rc != MDBX_SUCCESS) {
+        throw Napi::Error::New(env, 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;
+}
+
+Napi::Value txnmou::get_dbi(const Napi::Object& arg0, db_mode db_mode)
+{
+    auto env = arg0.Env();
+    auto conf = get_env_userctx(*env_);
+    auto key_flag = conf->key_flag;
+    auto value_flag = conf->value_flag;
     key_mode key_mode{};
     value_mode value_mode{};
     std::string db_name{};
+
+    if (arg0.Has("name")) {
+        auto value = arg0.Get("name");
+        if (!value.IsUndefined() && !value.IsNull()) {
+            if (!value.IsString()) {
+                throw Napi::Error::New(env, "dbi: name must be string");
+            }
+            db_name = value.As<Napi::String>().Utf8Value();
+        }
+    }
+
+    if (arg0.Has("keyFlag")) {
+        auto value = arg0.Get("keyFlag");
+        if (!value.IsUndefined() && !value.IsNull()) {
+            key_flag = base_flag::parse_key(value);
+        }
+    }
+
+    if (arg0.Has("valueFlag")) {
+        auto value = arg0.Get("valueFlag");
+        if (!value.IsUndefined() && !value.IsNull()) {
+            value_flag = base_flag::parse_value(value);
+        }
+    }
+
+    if (arg0.Has("keyMode")) {
+        auto value = arg0.Get("keyMode");
+        if (!value.IsUndefined() && !value.IsNull()) {
+            key_mode = parse_key_mode(env, value, key_flag);
+        }
+    }
+
+    if (arg0.Has("valueMode")) {
+        auto value = arg0.Get("valueMode");
+        if (!value.IsUndefined() && !value.IsNull()) {
+            value_mode = value_mode::parse(value);
+        }
+    }
+
+    return get_dbi(db_name.empty() ? nullptr : db_name.c_str(), 
+        key_flag, value_flag, key_mode, value_mode, db_mode);
+}
+
+Napi::Value txnmou::get_dbi(const Napi::CallbackInfo& info, db_mode db_mode)
+{
+    Napi::Env env = info.Env();
+
     auto conf = get_env_userctx(*env_);
     auto key_flag = conf->key_flag;
     auto value_flag = conf->value_flag;
+    key_mode key_mode{};
+    value_mode value_mode{};
+    std::string db_name{};
     auto arg_count = info.Length();
+
+    if (arg_count == 1 && info[0].IsObject()) {
+        return get_dbi(info[0].As<Napi::Object>(), db_mode);
+    }
+
     if (arg_count == 3) {
         auto arg0 = info[0]; // db_name
         auto arg1 = info[1]; // key_mode
@@ -94,8 +175,8 @@ Napi::Value txnmou::get_dbi(const Napi::CallbackInfo& info, db_mode db_mode)
         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]; 
+        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);
@@ -116,24 +197,10 @@ Napi::Value txnmou::get_dbi(const Napi::CallbackInfo& info, db_mode db_mode)
             throw Napi::Error::New(env, "Invalid argument type: expected string (db_name) or number (key_mode)");
         }
     }
-    // arg_count == 0: используем значения по умолчанию (строковый ключ, default db)
-
-    if (!txn_) {
-        throw Napi::Error::New(env, "txn already completed");
-    }
+    // arg_count == 0: значения по умолчанию (key/value = buffer, если env не задавал флаги)
 
-    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 Napi::Error::New(env, 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;
+    return get_dbi(db_name.empty() ? nullptr : db_name.c_str(), 
+        key_flag, value_flag, key_mode, value_mode, db_mode);
 }
 
 Napi::Value txnmou::open_cursor(const Napi::CallbackInfo& info) {
@@ -178,4 +245,4 @@ void txnmou::attach(envmou& env, MDBX_txn* txn, txn_mode mode)
     txn_.reset(txn);
 }
 
-} // namespace mdbxmou
+} // namespace mdbxmou

package/src/txnmou.hpp

@@ -27,7 +27,10 @@ private:
     // Уменьшает счетчик транзакций
     void dec_counter() noexcept;
 
-    Napi::Value get_dbi(const Napi::CallbackInfo&, db_mode);
+    Napi::Value get_dbi(const char* name, base_flag key_flag, base_flag value_flag,
+        key_mode key_mode, value_mode value_mode, db_mode db_mode);
+    Napi::Value get_dbi(const Napi::Object& arg0, db_mode db_mode);
+    Napi::Value get_dbi(const Napi::CallbackInfo& info, db_mode db_mode);
 
 public:    
     static Napi::FunctionReference ctor;

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 {
@@ -218,7 +246,7 @@ static inline key_mode parse_key_mode(Napi::Env env, const Napi::Value& arg0, ba
             throw Napi::Error::New(env, "BigInt value lossless conversion failed");
         }
         mode.val = static_cast<int>(value);
-        if (mode.val & key_mode::ordinal) {
+        if (mdbx::is_ordinal(mode)) {
             // только если цифровой key_flag не был задан
             if (key_flag.val <= base_flag::string) {
                 key_flag.val = base_flag::bigint;
@@ -226,7 +254,7 @@ static inline key_mode parse_key_mode(Napi::Env env, const Napi::Value& arg0, ba
         }
     } else if (arg0.IsNumber()) {
         mode = key_mode::parse(arg0);
-        if (mode.val & key_mode::ordinal) {
+        if (mdbx::is_ordinal(mode)) {
             // только если цифровой key_flag не был задан
             if (key_flag.val <= base_flag::string) {
                 key_flag.val = base_flag::number;