mdbxmou 0.3.9 → 0.3.11

package/CMakeLists.txt

@@ -23,6 +23,7 @@ add_library(${PROJECT_NAME} SHARED
     "src/querymou.cpp"
     "src/envmou.cpp" 
     "src/txnmou.cpp"
+    "src/convmou.cpp"
     "src/dbimou.cpp"
     "src/cursormou.cpp"
     "src/dbi.cpp")
@@ -63,4 +64,3 @@ string(REPLACE "\n" "" NODE_ADDON_API_DIR ${NODE_ADDON_API_DIR})
 string(REPLACE "\"" "" NODE_ADDON_API_DIR ${NODE_ADDON_API_DIR})
 target_include_directories(${PROJECT_NAME} PRIVATE ${NODE_ADDON_API_DIR} "src")
 
-

package/README.md

@@ -1,6 +1,6 @@
 # mdbxmou
 
-High-performance Node.js binding for [libmdbx](https://github.com/erthink/libmdbx) — a fast, lightweight, embedded key-value database.
+Node.js binding for [libmdbx](https://github.com/Mithril-mine/libmdbx) — a fast, lightweight, embedded key-value database.
 
 ## Features
 
@@ -345,6 +345,40 @@ const bigIntKeys = dbi.keysFrom(txn, 42n, 50);
 const equalKeys = dbi.keysFrom(txn, 5, 10, 'keyEqual');
 ```
 
+**getRange(txn, [options]) → Array<{ key, value }>**
+```javascript
+const rows = dbi.getRange(txn, { start: 10, end: 15 });
+// [
+//   { key: 10, value: ... },
+//   { key: 11, value: ... },
+//   ...
+// ]
+```
+
+**keysRange(txn, [options]) → Array**
+```javascript
+const keys = dbi.keysRange(txn, { start: 10, end: 20, limit: 5 });
+// [10, 11, 12, 13, 14]
+```
+
+**valuesRange(txn, [options]) → Array**
+```javascript
+const values = dbi.valuesRange(txn, {
+  start: 10,
+  end: 15,
+  reverse: true,
+  includeEnd: false
+});
+// values for keys 14, 13, 12, 11, 10
+```
+
+Range options:
+- `start`, `end` - inclusive bounds by default
+- `includeStart`, `includeEnd` - control bound inclusion
+- `reverse` - scan from upper bound to lower bound
+- `limit` - maximum number of returned items
+- `offset` - skip N items after initial positioning
+
 **drop(txn, [delete_db]) → void**
 ```javascript
 // Clear database contents (keep structure)
@@ -750,6 +784,60 @@ function cursorExample() {
 cursorExample();
 ```
 
+### Range Queries
+
+```javascript
+const { MDBX_Env, MDBX_Param } = require('mdbxmou');
+
+function rangeExample() {
+  const env = new MDBX_Env();
+  env.openSync({
+    path: './range-data',
+    valueFlag: MDBX_Param.valueFlag.string
+  });
+
+  const writeTxn = env.startWrite();
+  const dbi = writeTxn.createMap(MDBX_Param.keyMode.ordinal);
+  for (let i = 0; i < 10; i++) {
+    dbi.put(writeTxn, i, `value_${i}`);
+  }
+  writeTxn.commit();
+
+  const readTxn = env.startRead();
+  const readDbi = readTxn.openMap(MDBX_Param.keyMode.ordinal);
+
+  const rows = readDbi.getRange(readTxn, { start: 3, end: 6 });
+  console.log(rows);
+  // [
+  //   { key: 3, value: 'value_3' },
+  //   { key: 4, value: 'value_4' },
+  //   { key: 5, value: 'value_5' },
+  //   { key: 6, value: 'value_6' }
+  // ]
+
+  const keys = readDbi.keysRange(readTxn, {
+    start: 3,
+    end: 8,
+    offset: 1,
+    limit: 3
+  });
+  console.log(keys); // [4, 5, 6]
+
+  const values = readDbi.valuesRange(readTxn, {
+    start: 3,
+    end: 6,
+    reverse: true,
+    includeEnd: false
+  });
+  console.log(values); // ['value_5', 'value_4', 'value_3']
+
+  readTxn.commit();
+  env.closeSync();
+}
+
+rangeExample();
+```
+
 ### Query API (Advanced Async)
 
 ```javascript
@@ -869,6 +957,7 @@ node test/readme-sync-example.js
 node test/readme-async-example.js
 node test/readme-key-types.js
 node test/readme-cursor-example.js
+node test/readme-range-example.js
 node test/readme-query-example.js
 node test/readme-keys-example.js
 node test/readme-error-handling.js

package/lib/nativemou.js

@@ -1,6 +1,5 @@
-const os = require('os');
-
 const nativePath = '../build/Release/mdbxmou';
+/** @type {import("./types").MDBX_Native} */
 const nativeModule = require(nativePath);
 // Экспортируем объединенный модуль
 module.exports = nativeModule;

package/lib/types.d.ts

@@ -79,6 +79,16 @@ export interface MDBXCursorResult<K extends MDBXKey = MDBXKey, V extends MDBXVal
   value: V;
 }
 
+export interface MDBXRangeOptions<K extends MDBXKey = MDBXKey> {
+  start?: K;
+  end?: K;
+  limit?: number;
+  offset?: number;
+  reverse?: boolean;
+  includeStart?: boolean;
+  includeEnd?: boolean;
+}
+
 /**
  * Database cursor for sequential access and range queries.
  * Must be closed before transaction commit/abort.
@@ -213,6 +223,9 @@ export interface MDBX_Dbi<K extends MDBXKey = MDBXKey, V extends MDBXValue = MDB
   stat(txn: MDBX_Txn): MDBXDbiStat;
   keys(txn: MDBX_Txn): K[];
   keysFrom(txn: MDBX_Txn, fromKey: K, limit?: number, cursorMode?: MDBXCursorMode): K[];
+  getRange(txn: MDBX_Txn, options?: MDBXRangeOptions<K>): MDBXCursorResult<K, V>[];
+  keysRange(txn: MDBX_Txn, options?: MDBXRangeOptions<K>): K[];
+  valuesRange(txn: MDBX_Txn, options?: MDBXRangeOptions<K>): V[];
   drop(txn: MDBX_Txn, deleteDb?: boolean): void;
 }
 
@@ -394,9 +407,10 @@ export interface MDBX_Param {
   };
 }
 
+/** Runtime constants exported by the native module. */
 export declare const MDBX_Param: MDBX_Param;
 
 export interface MDBX_Native {
   MDBX_Env: typeof MDBX_Env;
-  MDBX_Param: MDBX_Param;
+  MDBX_Param: typeof MDBX_Param;
 }

package/package.json

@@ -50,6 +50,7 @@
   },
   "devDependencies": {
     "@types/node": "^22.10.2",
+    "msgpackr": "^1.11.9",
     "typescript": "^5.6.3"
   },
   "scripts": {
@@ -58,6 +59,8 @@
     "e4": "node ./test/e4.js",
     "e4async": "node ./test/e4async.mjs",
     "e5": "node ./test/e5.js",
+    "e7": "node ./test/e7.js",
+    "e8": "node ./test/e8.js",
     "test:types": "node ./test/types/run.mjs",
     "build": "node build.js",
     "build-dev": "node build-dev.js",
@@ -65,7 +68,7 @@
   },
   "gypfile": true,
   "name": "mdbxmou",
-  "version": "0.3.9",
+  "version": "0.3.11",
   "description": "Node bindings for mdbx",
   "repository": {
     "type": "git",

package/src/async/envmou_keys.cpp

@@ -1,10 +1,53 @@
 #include "envmou_keys.hpp"
 #include "envmou.hpp"
+#include "convmou.hpp"
 #include "dbimou.hpp"
-#include "../valuemou.hpp"
+#include "valuemou.hpp"
 
 namespace mdbxmou {
 
+namespace {
+
+template<bool Ordinal>
+void scan_keys_from(mdbx::cursor_managed& cursor, keys_line& arg0,
+    keymou& from_key, mdbx::cursor::move_operation turn_mode)
+{
+    auto& item = arg0.item;
+    auto cursor_mode = arg0.cursor_mode;
+    bool is_key_equal_mode = (cursor_mode == mdbx::cursor::move_operation::key_equal ||
+        cursor_mode == mdbx::cursor::move_operation::multi_exactkey_value_equal);
+
+    std::size_t index{};
+    cursor.scan_from([&](const mdbx::pair& f) {
+        if (index >= arg0.limit) {
+            return true;
+        }
+
+        keymou key{f.key};
+        if (is_key_equal_mode) {
+            if constexpr (Ordinal) {
+                if (arg0.id_buf != key.as_int64()) {
+                    return true;
+                }
+            } else if (from_key != key) {
+                return true;
+            }
+        }
+
+        async_key rc{};
+        if constexpr (Ordinal) {
+            rc.id_buf = key.as_uint64();
+        } else {
+            rc.key_buf.assign(key.char_ptr(), key.end_char_ptr());
+        }
+        item.push_back(std::move(rc));
+        ++index;
+        return false;
+    }, from_key, cursor_mode, turn_mode);
+}
+
+} // namespace
+
 void async_keys::Execute() 
 {
     try {
@@ -24,26 +67,14 @@ void async_keys::Execute()
 static Napi::Value write_row(Napi::Env env, const keys_line& row) 
 {
     auto& param = row.item;
-    auto key_mode = row.key_mod;
-    auto key_flag = row.key_flag;
+    convmou conv{row.key_mod, row.key_flag};
     auto js_arr = Napi::Array::New(env, param.size());
     for (std::uint32_t j = 0; j < param.size(); ++j) {
         const auto& item = param[j];
-        Napi::Value key_value;
-        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 {
-                key_value = Napi::BigInt::New(env, item.id_buf);
-            }
-        } else {
-            if (key_flag.val & base_flag::string) {
-                key_value = Napi::String::New(env, item.key_buf.data(), item.key_buf.size());
-            } else {
-                key_value = Napi::Buffer<char>::Copy(env, item.key_buf.data(), item.key_buf.size());
-            }
-        }
-        js_arr.Set(j, key_value);
+        auto key = mdbx::is_ordinal(row.key_mod) ?
+            keymou{item.id_buf} :
+            keymou{item.key_buf};
+        js_arr.Set(j, conv.convert_key(env, key));
     }
     return js_arr;
 }
@@ -140,14 +171,12 @@ void async_keys::do_keys_batch(txnmou_managed& txn,
 void async_keys::do_keys_from(txnmou_managed& txn, 
     mdbx::map_handle dbi, keys_line& arg0)
 {
-    // сыллка на массив результатов
-    auto& item = arg0.item;
-    std::size_t count = 0;
     using move_operation = mdbx::cursor::move_operation;
+    auto is_ordinal = mdbx::is_ordinal(arg0.key_mod);
 
     auto cursor = txn.open_cursor(dbi);
 
-    keymou from_key = mdbx::is_ordinal(arg0.key_mod) ?
+    keymou from_key = is_ordinal ?
         keymou{arg0.id_buf} : 
         keymou{mdbx::slice{arg0.key_buf.data(), arg0.key_buf.size()}};
 
@@ -170,50 +199,10 @@ void async_keys::do_keys_from(txnmou_managed& txn,
             break;
     }
 
-    bool is_key_equal_mode = (cursor_mode == move_operation::key_equal || 
-        cursor_mode == move_operation::multi_exactkey_value_equal);    
-
-    std::size_t index{};
-    if (mdbx::is_ordinal(arg0.key_mod)) {
-        // Создаем ключ для позиционирования
-        cursor.scan_from([&](const mdbx::pair& f) {
-            if (index >= arg0.limit) {
-                return true; // останавливаем сканирование
-            }
-            
-            keymou key{f.key};
-            if (is_key_equal_mode) {
-                if (arg0.id_buf != key.as_int64()) {
-                    return true; // останавливаем сканирование
-                }
-            }
-            
-            async_key rc{};
-            rc.id_buf = key.as_uint64();
-            item.push_back(std::move(rc));
-            index++;                            
-            return false; // продолжаем сканирование
-        }, from_key, arg0.cursor_mode, turn_mode);
+    if (is_ordinal) {
+        scan_keys_from<true>(cursor, arg0, from_key, turn_mode);
     } else {
-        // Создаем ключ для позиционирования
-        cursor.scan_from([&](const mdbx::pair& f) {
-            if (index >= arg0.limit) {
-                return true; // останавливаем сканирование
-            }
-            
-            keymou key{f.key};
-            if (is_key_equal_mode) {
-                if (from_key != key) {
-                    return true; // останавливаем сканирование
-                }
-            }
-            
-            async_key rc{};
-            rc.id_buf = key.as_uint64();
-            item.push_back(std::move(rc));
-            index++;                            
-            return false; // продолжаем сканирование
-        }, from_key, arg0.cursor_mode, turn_mode);
+        scan_keys_from<false>(cursor, arg0, from_key, turn_mode);
     }
 }
 

package/src/async/envmou_query.cpp

@@ -1,4 +1,5 @@
 #include "envmou_query.hpp"
+#include "convmou.hpp"
 #include "envmou.hpp"
 
 namespace mdbxmou {
@@ -31,28 +32,16 @@ void async_query::Execute()
 static Napi::Value write_row(Napi::Env env, const query_line& row) 
 {
     auto& param = row.item;
-    auto key_mode = row.key_mod;
-    auto key_flag = row.key_flag;
     auto mode = row.mode;
+    convmou conv{row.key_mod, row.key_flag, row.value_flag};
     auto js_arr = Napi::Array::New(env, param.size());
     for (std::size_t j = 0; j < param.size(); ++j) {
         const auto& item = param[j];
-        Napi::Value key_value;
         Napi::Object js_item = Napi::Object::New(env);
-        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 {
-                key_value = Napi::BigInt::New(env, item.id_buf);
-            }
-        } else {
-            if (key_flag.val & base_flag::string) {
-                key_value = Napi::String::New(env, item.key_buf.data(), item.key_buf.size());
-            } else {
-                key_value = Napi::Buffer<char>::Copy(env, item.key_buf.data(), item.key_buf.size());
-            }
-        }
-        js_item.Set("key", key_value);
+        auto key = mdbx::is_ordinal(row.key_mod) ?
+            keymou{item.id_buf} :
+            keymou{item.key_buf};
+        js_item.Set("key", conv.convert_key(env, key));
 
         // все методы которые должны показать value в результате
         const auto mask{query_mode::get|query_mode::upsert|
@@ -63,14 +52,8 @@ static Napi::Value write_row(Napi::Env env, const query_line& row)
             if (val_buf.empty()) {
                 js_item.Set("value", env.Null());
             } else {
-                auto value_flag = row.value_flag;
-                Napi::Value val_value;
-                if (value_flag.val & base_flag::string) {
-                    val_value = Napi::String::New(env, val_buf.data(), val_buf.size());
-                } else {
-                    val_value = Napi::Buffer<char>::Copy(env, val_buf.data(), val_buf.size());
-                }
-                js_item.Set("value", val_value);
+                js_item.Set("value",
+                    conv.convert_value(env, valuemou{val_buf}));
             }
         }
 
@@ -162,4 +145,4 @@ void async_query::do_put(txnmou_managed& txn,
     }
 }
 
-} // namespace mdbxmou
+} // namespace mdbxmou

package/src/convmou.cpp

@@ -0,0 +1,34 @@
+#include "convmou.hpp"
+
+namespace mdbxmou {
+
+Napi::Value convmou::convert_key(const Napi::Env& env, const keymou& key) const
+{
+    if (mdbx::is_ordinal(key_mode_)) {
+        return (key_flag_ & base_flag::bigint) ?
+            key.to_bigint(env) :
+            key.to_number(env);
+    }
+
+    return (key_flag_ & base_flag::string) ?
+        key.to_string(env) :
+        key.to_buffer(env);
+}
+
+Napi::Value convmou::convert_value(const Napi::Env& env, const valuemou& val) const
+{
+    return (value_flag_ & base_flag::string) ?
+        val.to_string(env) :
+        val.to_buffer(env);
+}
+
+Napi::Object convmou::make_result(const Napi::Env& env,
+    const keymou& key, const valuemou& val) const
+{
+    auto result = Napi::Object::New(env);
+    result.Set("key", convert_key(env, key));
+    result.Set("value", convert_value(env, val));
+    return result;
+}
+
+} // namespace mdbxmou

package/src/convmou.hpp

@@ -0,0 +1,30 @@
+#pragma once
+
+#include "valuemou.hpp"
+
+namespace mdbxmou {
+
+struct convmou
+{
+    key_mode key_mode_{};
+    base_flag key_flag_{};
+    base_flag value_flag_{};
+
+    convmou() = default;
+
+    convmou(key_mode key_mode, base_flag key_flag,
+        base_flag value_flag = {}) noexcept
+        : key_mode_{key_mode}
+        , key_flag_{key_flag}
+        , value_flag_{value_flag}
+    {   }
+
+    Napi::Value convert_key(const Napi::Env& env, const keymou& key) const;
+
+    Napi::Value convert_value(const Napi::Env& env, const valuemou& val) const;
+
+    Napi::Object make_result(const Napi::Env& env,
+        const keymou& key, const valuemou& val) const;
+};
+
+} // namespace mdbxmou

package/src/cursormou.cpp

@@ -72,32 +72,7 @@ namespace mdbxmou
             throw Napi::Error::New(env, mdbx_strerror(rc));
         }
 
-        // Возвращаем {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 (mdbx::is_ordinal(key_mode)) {
-            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));
-        }
-
-        return result;
+        return dbi_->get_convmou().make_result(env, key, val);
     }
 
     Napi::Value cursormou::first(const Napi::CallbackInfo &info)
@@ -224,31 +199,7 @@ namespace mdbxmou
             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 (mdbx::is_ordinal(key_mode)) {
-            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));
-        }
-
-        return result;
+        return dbi_->get_convmou().make_result(env, key, val);
     }
 
     Napi::Value cursormou::seek(const Napi::CallbackInfo &info)
@@ -338,12 +289,9 @@ namespace mdbxmou
         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;
+        auto conv = dbi_->get_convmou();
 
         keymou key{};
         valuemou val{};
@@ -351,25 +299,7 @@ namespace mdbxmou
         auto rc = mdbx_cursor_get(cursor_, key, val, start_op);
         while (MDBX_SUCCESS == rc)
         {
-            auto result = Napi::Object::New(env);
-
-            // Ключ
-            if (mdbx::is_ordinal(key_mode)) {
-                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));
-            }
+            auto result = conv.make_result(env, key, val);
 
             // Вызов callback
             auto ret = callback.Call({result});