mdbxmou 0.3.10 → 0.3.12

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,13 +1,13 @@
 # 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
 
 - **Synchronous API** — Direct MDBX operations in main thread
 - **Asynchronous API** — Background operations with async/await
 - **Transactions** — ACID transactions with read/write modes
-- **Multiple key/value types** — String, binary, ordinal (integer) keys
+- **Multiple key/value types** — String, binary, ordinal keys and ordinal duplicate values
 - **Batch operations** — Efficient multi-key read/write
 - **Memory-mapped** — High-performance memory-mapped I/O
 
@@ -86,6 +86,8 @@ Options:
 - `keyFlag` - Default key encoding for all operations (optional, defaults to Buffer)
   - Only `string` can be set (ordinal mode uses `number`/`bigint` separately)
 - `valueFlag` - Default value encoding for all operations (optional, defaults to Buffer)
+  - `string` affects normal string values
+  - `number` and `bigint` are meaningful for `valueMode.multiOrdinal`
 - `maxDbi` - Maximum number of databases (optional, default `32`)
 - `mode` - Filesystem permissions mode (optional, default `0664`)
 - `geometry` - Map size/geometry options (optional)
@@ -190,14 +192,21 @@ const txn = env.startRead();
 ```javascript
 const result = await env.query([
   {
-    dbMode: MDBX_Param.dbMode.accede,
-    keyMode: MDBX_Param.keyMode.ordinal,
+    dbi,
     mode: MDBX_Param.queryMode.get,
     item: [{ key: 1 }, { key: 2 }]
+  },
+  {
+    dbi,
+    mode: MDBX_Param.queryMode.upsert,
+    putFlag: MDBX_Param.putFlag.noOverwrite,
+    item: [{ key: 3, value: "v3" }]
   }
 ]);
 ```
 
+`query()` uses the passed `dbi` and inherits key/value settings from it. `queryMode` selects the operation (`get`, `del`, or base write mode), and optional `putFlag` adds write-only MDBX flags. In `query()` only `noOverwrite`, `noDupData`, `current`, `append`, and `appendDup` are supported.
+
 ### Transaction
 
 #### Methods
@@ -271,6 +280,8 @@ const dbi = txn.openMap({
 > - `keyMode: BigInt(number)` → keys returned as `BigInt`
 > - When you pass `keyMode.ordinal` as a positional argument (Number/BigInt), it also updates `keyFlag` to number/bigint unless a numeric keyFlag was already set in env or explicitly provided.
 
+> **Note**: When `valueMode.multiOrdinal` is used and `valueFlag` is not specified, values are returned as `number` by default. Set `valueFlag: MDBX_Param.valueFlag.bigint` if you need `BigInt` on read.
+
 **commit()**
 ```javascript
 txn.commit();
@@ -285,10 +296,16 @@ txn.abort();
 
 #### Methods
 
-**put(txn, key, value)**
+**put(txn, key, value, [flags])**
 ```javascript
 dbi.put(txn, 123, "value");
 dbi.put(txn, "key", Buffer.from("binary data"));
+
+// Insert only if key does not exist
+dbi.put(txn, 123, "value", MDBX_Param.putFlag.noOverwrite);
+
+// Fast append for sorted inserts
+dbi.put(txn, 124, "value", MDBX_Param.putFlag.append);
 ```
 
 **get(txn, key) → value**
@@ -297,6 +314,8 @@ const value = dbi.get(txn, 123);
 const binary = dbi.get(txn, "key");
 ```
 
+For `valueMode.multiOrdinal`, `get()` returns the first duplicate value for the key, decoded as `number` by default.
+
 **del(txn, key) → boolean**
 ```javascript
 const deleted = dbi.del(txn, 123);
@@ -345,6 +364,47 @@ 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: ... },
+//   ...
+// ]
+```
+
+**getCount(txn, [options]) → number**
+```javascript
+const total = dbi.getCount(txn, { start: 10, end: 20 });
+// 11
+```
+
+**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
+- `getCount()` ignores `offset` and `limit` and returns the total size of the bounded range
+
 **drop(txn, [delete_db]) → void**
 ```javascript
 // Clear database contents (keep structure)
@@ -427,7 +487,7 @@ Insert or update a record at cursor position.
 cursor.put('newKey', 'newValue');
 
 // With flags (MDBX_NOOVERWRITE, etc.)
-cursor.put('key', 'value', MDBX_Param.queryMode.insertUnique);
+cursor.put('key', 'value', MDBX_Param.putFlag.noOverwrite);
 ```
 
 **del([flags]) → boolean**
@@ -561,12 +621,20 @@ txn.commit();
 ### Value Modes (MDBX_Param.valueMode)
 
 - **single** - Single value per key (default)
-- **multi** - Multiple values per key (dupsort)
+- **multi** - `MDBX_DUPSORT`, multiple values per key
+- **multiReverse** - `MDBX_DUPSORT | MDBX_REVERSEDUP`
+- **multiSamelength** - `MDBX_DUPSORT | MDBX_DUPFIXED`
+- **multiOrdinal** - `MDBX_DUPSORT | MDBX_DUPFIXED | MDBX_INTEGERDUP`
+- **multiReverseSamelength** - `MDBX_DUPSORT | MDBX_REVERSEDUP | MDBX_DUPFIXED`
 
 ### Value Flags (MDBX_Param.valueFlag)
 
-- **binary** - Raw binary data (default)
+- **binary** - Raw binary data (default, represented by `0`)
 - **string** - UTF-8 strings
+- **number** - Numeric decode for ordinal duplicate values
+- **bigint** - BigInt decode for ordinal duplicate values
+
+`valueFlag.number` and `valueFlag.bigint` matter primarily for `valueMode.multiOrdinal`. For ordinary values, use Buffer (default) or `valueFlag.string`.
 
 ## Examples
 
@@ -750,6 +818,101 @@ 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 total = readDbi.getCount(readTxn, { start: 3, end: 8 });
+  console.log(total); // 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();
+```
+
+### MultiOrdinal Values
+
+```javascript
+const { MDBX_Env, MDBX_Param } = require('mdbxmou');
+
+function multiOrdinalExample() {
+  const env = new MDBX_Env();
+  env.openSync({ path: './multi-ordinal-data' });
+
+  const writeTxn = env.startWrite();
+  const dbi = writeTxn.createMap({
+    name: 'dup-ids',
+    keyMode: MDBX_Param.keyMode.ordinal,
+    valueMode: MDBX_Param.valueMode.multiOrdinal
+  });
+
+  dbi.put(writeTxn, 5, 30);
+  dbi.put(writeTxn, 5, 10);
+  dbi.put(writeTxn, 5, 20n);
+  writeTxn.commit();
+
+  const readTxn = env.startRead();
+  const readDbi = readTxn.openMap({
+    name: 'dup-ids',
+    keyMode: MDBX_Param.keyMode.ordinal,
+    valueMode: MDBX_Param.valueMode.multiOrdinal
+  });
+
+  console.log(readDbi.get(readTxn, 5)); // 10
+  console.log(readDbi.valuesRange(readTxn, { start: 5, end: 5 })); // [10, 20, 30]
+
+  readTxn.commit();
+  env.closeSync();
+}
+
+multiOrdinalExample();
+```
+
 ### Query API (Advanced Async)
 
 ```javascript
@@ -768,7 +931,8 @@ async function queryExample() {
   const results = await env.query([
     {
       dbi,
-      mode: MDBX_Param.queryMode.insertUnique,
+      mode: MDBX_Param.queryMode.upsert,
+      putFlag: MDBX_Param.putFlag.noOverwrite,
       item: [
         { key: 1, value: JSON.stringify({ name: "Alice" }) },
         { key: 2, value: JSON.stringify({ name: "Bob" }) }
@@ -869,6 +1033,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
@@ -892,7 +1057,21 @@ MDBX_Param.keyFlag.number     // Number type (used with ordinal mode)
 MDBX_Param.keyFlag.bigint     // BigInt type (used with ordinal mode)
 // Default - Buffer representation
 
+// Value modes
+MDBX_Param.valueMode.multi                 // MDBX_DUPSORT
+MDBX_Param.valueMode.multiReverse          // MDBX_DUPSORT | MDBX_REVERSEDUP
+MDBX_Param.valueMode.multiSamelength       // MDBX_DUPSORT | MDBX_DUPFIXED
+MDBX_Param.valueMode.multiOrdinal          // MDBX_DUPSORT | MDBX_DUPFIXED | MDBX_INTEGERDUP
+MDBX_Param.valueMode.multiReverseSamelength // MDBX_DUPSORT | MDBX_REVERSEDUP | MDBX_DUPFIXED
+
+// Value flags (optional, control value representation)
+MDBX_Param.valueFlag.string   // UTF-8 string values
+MDBX_Param.valueFlag.number   // Number values for multiOrdinal
+MDBX_Param.valueFlag.bigint   // BigInt values for multiOrdinal
+// Default - Buffer representation
+
 Note: For ordinal (integer) keys, use keyFlag.number or keyFlag.bigint to specify the data type.
+For `valueMode.multiOrdinal`, values are returned as `number` by default, or as `bigint` when `valueFlag.bigint` is used.
 ```
 
 ### Environment Flags
@@ -938,11 +1117,23 @@ Note: For ordinal (integer) keys, use keyFlag.number or keyFlag.bigint to specif
 
 ### Query Modes
 - `MDBX_Param.queryMode.get` - Read operations
-- `MDBX_Param.queryMode.upsert` - Write operations (insert or update)
-- `MDBX_Param.queryMode.update` - Update existing (MDBX_CURRENT)
-- `MDBX_Param.queryMode.insertUnique` - Insert unique (MDBX_NOOVERWRITE)
+- `MDBX_Param.queryMode.upsert` - Base write mode (insert or update)
+- `MDBX_Param.queryMode.update` - Base write mode with `MDBX_CURRENT`
+- `MDBX_Param.queryMode.insertUnique` - Base write mode with `MDBX_NOOVERWRITE`
 - `MDBX_Param.queryMode.del` - Delete operations
 
+### Put Flags
+- `MDBX_Param.putFlag.noOverwrite` - `MDBX_NOOVERWRITE`
+- `MDBX_Param.putFlag.noDupData` - `MDBX_NODUPDATA`
+- `MDBX_Param.putFlag.current` - `MDBX_CURRENT`
+- `MDBX_Param.putFlag.allDups` - `MDBX_ALLDUPS`
+- `MDBX_Param.putFlag.reserve` - `MDBX_RESERVE`
+- `MDBX_Param.putFlag.append` - `MDBX_APPEND`
+- `MDBX_Param.putFlag.appendDup` - `MDBX_APPENDDUP`
+- `MDBX_Param.putFlag.multiple` - `MDBX_MULTIPLE`
+
+For `env.query()` write requests, only `noOverwrite`, `noDupData`, `current`, `append`, and `appendDup` are supported.
+
 ### Cursor Modes
 - `MDBX_Param.cursorMode.first` - First key
 - `MDBX_Param.cursorMode.last` - Last key  

package/lib/async.d.mts

@@ -1,4 +1,6 @@
-import type { MDBXDbiStat, MDBXEnvOpenOptions, MDBXKey, MDBXValue } from "./types.js";
+import type { MDBXDbiStat, MDBXEnvOpenOptions, MDBXKey } from "./types.js";
+
+type MDBXAsyncValue = Buffer | string;
 
 export interface MDBXAsyncMapOpenOptions {
   name?: string;
@@ -35,15 +37,15 @@ export interface MDBXAsyncDelBatchResultItem {
 export declare class MDBX_Async_Dbi {
   readonly meta: MDBXAsyncDbiMeta;
 
-  put(key: MDBXKey, value: MDBXValue, flags?: number): Promise<boolean>;
+  put(key: MDBXKey, value: MDBXAsyncValue, flags?: number): Promise<boolean>;
   get(key: MDBXKey): Promise<string | null | undefined>;
   del(key: MDBXKey): Promise<boolean>;
   stat(): Promise<MDBXDbiStat>;
 
-  forEach(cb: (key: MDBXKey, value: MDBXValue, index: number) => void): Promise<void>;
+  forEach(cb: (key: MDBXKey, value: MDBXAsyncValue, index: number) => void): Promise<void>;
 
   getBatch(keys: MDBXKey[]): Promise<MDBXAsyncGetBatchResultItem[]>;
-  putBatch(items: Array<{ key: MDBXKey; value: MDBXValue }>, flags?: number): Promise<MDBXAsyncPutBatchResultItem[]>;
+  putBatch(items: Array<{ key: MDBXKey; value: MDBXAsyncValue }>, flags?: number): Promise<MDBXAsyncPutBatchResultItem[]>;
   delBatch(keys: MDBXKey[]): Promise<MDBXAsyncDelBatchResultItem[]>;
 }
 

package/lib/types.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 
 export type MDBXKey = Buffer | string | number | bigint;
-export type MDBXValue = Buffer | string;
+export type MDBXValue = Buffer | string | number | bigint;
 
 export type MDBXCursorMode =
   | number
@@ -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.
@@ -192,7 +202,7 @@ export interface MDBX_Dbi<K extends MDBXKey = MDBXKey, V extends MDBXValue = MDB
   readonly keyFlag: number;
   readonly valueFlag: number;
 
-  put(txn: MDBX_Txn, key: K, value: MDBXValue): void;
+  put(txn: MDBX_Txn, key: K, value: MDBXValue, flags?: number): void;
   get(txn: MDBX_Txn, key: K): V | undefined;
   del(txn: MDBX_Txn, key: K): boolean;
   has(txn: MDBX_Txn, key: K): boolean;
@@ -213,6 +223,10 @@ 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>[];
+  getCount(txn: MDBX_Txn, options?: MDBXRangeOptions<K>): number;
+  keysRange(txn: MDBX_Txn, options?: MDBXRangeOptions<K>): K[];
+  valuesRange(txn: MDBX_Txn, options?: MDBXRangeOptions<K>): V[];
   drop(txn: MDBX_Txn, deleteDb?: boolean): void;
 }
 
@@ -251,6 +265,7 @@ export interface MDBXQueryRequest {
   dbi: MDBX_Dbi;
   mode?: number;
   queryMode?: number;
+  putFlag?: number;
   item: MDBXQueryItem[];
 }
 
@@ -361,6 +376,8 @@ export interface MDBX_Param {
 
   readonly valueFlag: {
     readonly string: number;
+    readonly number: number;
+    readonly bigint: number;
   };
 
   readonly dbMode: {
@@ -376,6 +393,17 @@ export interface MDBX_Param {
     readonly del: number;
   };
 
+  readonly putFlag: {
+    readonly noOverwrite: number;
+    readonly noDupData: number;
+    readonly current: number;
+    readonly allDups: number;
+    readonly reserve: number;
+    readonly append: number;
+    readonly appendDup: number;
+    readonly multiple: number;
+  };
+
   readonly cursorMode: {
     readonly first: number;
     readonly last: number;

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,9 @@
     "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",
+    "e9": "node ./test/e9.js",
     "test:types": "node ./test/types/run.mjs",
     "build": "node build.js",
     "build-dev": "node build-dev.js",
@@ -65,7 +69,7 @@
   },
   "gypfile": true,
   "name": "mdbxmou",
-  "version": "0.3.10",
+  "version": "0.3.12",
   "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);
     }
 }