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

@@ -65,7 +65,7 @@
   },
   "gypfile": true,
   "name": "mdbxmou",
-  "version": "0.3.3",
+  "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/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/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/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 {