mdbxmou 0.3.11 → 0.3.12

package/README.md

@@ -7,7 +7,7 @@ Node.js binding for [libmdbx](https://github.com/Mithril-mine/libmdbx) — a fas
 - **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);
@@ -355,6 +374,12 @@ const rows = dbi.getRange(txn, { start: 10, end: 15 });
 // ]
 ```
 
+**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 });
@@ -378,6 +403,7 @@ Range options:
 - `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
@@ -461,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**
@@ -595,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
 
@@ -815,6 +849,9 @@ function rangeExample() {
   //   { 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,
@@ -838,6 +875,44 @@ function rangeExample() {
 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
@@ -856,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" }) }
@@ -981,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
@@ -1027,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
@@ -202,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;
@@ -224,6 +224,7 @@ export interface MDBX_Dbi<K extends MDBXKey = MDBXKey, V extends MDBXValue = MDB
   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;
@@ -264,6 +265,7 @@ export interface MDBXQueryRequest {
   dbi: MDBX_Dbi;
   mode?: number;
   queryMode?: number;
+  putFlag?: number;
   item: MDBXQueryItem[];
 }
 
@@ -374,6 +376,8 @@ export interface MDBX_Param {
 
   readonly valueFlag: {
     readonly string: number;
+    readonly number: number;
+    readonly bigint: number;
   };
 
   readonly dbMode: {
@@ -389,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

@@ -61,6 +61,7 @@
     "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",
@@ -68,7 +69,7 @@
   },
   "gypfile": true,
   "name": "mdbxmou",
-  "version": "0.3.11",
+  "version": "0.3.12",
   "description": "Node bindings for mdbx",
   "repository": {
     "type": "git",

package/src/async/envmou_keys.cpp

@@ -67,7 +67,7 @@ void async_keys::Execute()
 static Napi::Value write_row(Napi::Env env, const keys_line& row) 
 {
     auto& param = row.item;
-    convmou conv{row.key_mod, 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];

package/src/async/envmou_query.cpp

@@ -13,9 +13,9 @@ void async_query::Execute()
         {
             mdbx::map_handle dbi{req.id};
             auto mode = req.mode;
-            if (mode.val & query_mode::get) {
+            if (mode.is_get()) {
                 do_get(txn, dbi, req);
-            } else if (mode.val & query_mode::del) {
+            } else if (mode.is_del()) {
                 do_del(txn, dbi, req);
             } else {
                 do_put(txn, dbi, req);
@@ -33,7 +33,7 @@ static Napi::Value write_row(Napi::Env env, const query_line& row)
 {
     auto& param = row.item;
     auto mode = row.mode;
-    convmou conv{row.key_mod, row.key_flag, row.value_flag};
+    convmou conv{row.key_mod, row.val_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];
@@ -43,13 +43,11 @@ static Napi::Value write_row(Napi::Env env, const query_line& row)
             keymou{item.key_buf};
         js_item.Set("key", conv.convert_key(env, key));
 
-        // все методы которые должны показать value в результате
-        const auto mask{query_mode::get|query_mode::upsert|
-            query_mode::update|query_mode::insert_unique};
-        if (mode.val & mask) 
-        {
+        if (mode.is_get() || mode.is_write()) {
             auto& val_buf = item.val_buf;
-            if (val_buf.empty()) {
+            if (is_ordinal(row.val_mod) && mode.is_write() && val_buf.empty()) {
+                js_item.Set("value", conv.convert_value(env, valuemou{item.val_num}));
+            } else if (val_buf.empty()) {
                 js_item.Set("value", env.Null());
             } else {
                 js_item.Set("value",
@@ -58,7 +56,7 @@ static Napi::Value write_row(Napi::Env env, const query_line& row)
         }
 
         // выдадим флаги удаления и успешности
-        if (mode.val & query_mode::del) {
+        if (mode.is_del()) {
             js_item.Set("found", Napi::Boolean::New(env, item.found));
         }
         js_arr.Set(static_cast<uint32_t>(j), js_item);
@@ -133,15 +131,18 @@ void async_query::do_get(const txnmou_managed& txn,
 void async_query::do_put(txnmou_managed& txn, 
     mdbx::map_handle dbi, query_line& arg0)
 {
-    auto mode = arg0.mode;
+    auto flags = static_cast<MDBX_put_flags_t>(
+        arg0.mode.write_flags() | arg0.put_flags.val);
     // очищаем put флаги
     auto key_mode = arg0.key_mod;
     for (auto& q : arg0.item) 
     {
         auto key = mdbx::is_ordinal(key_mode) ?
             keymou{q.id_buf} : keymou{q.key_buf};
-        mdbx::slice val{q.val_buf.data(), q.val_buf.size()};
-        txn.put(dbi, key, val, mode);
+        valuemou val = is_ordinal(arg0.val_mod) ?
+            valuemou{q.val_num} :
+            valuemou{q.val_buf};
+        mdbx::error::success_or_throw(txn.put(dbi, key, &val, flags));
     }
 }
 

package/src/convmou.cpp

@@ -1,7 +1,18 @@
 #include "convmou.hpp"
+#include "dbimou.hpp"
 
 namespace mdbxmou {
 
+convmou convmou::for_dbi(const dbimou& dbi) noexcept
+{
+    return {
+        dbi.get_key_mode(),
+        dbi.get_value_mode(),
+        dbi.get_key_flag(),
+        dbi.get_value_flag()
+    };
+}
+
 Napi::Value convmou::convert_key(const Napi::Env& env, const keymou& key) const
 {
     if (mdbx::is_ordinal(key_mode_)) {
@@ -17,6 +28,12 @@ Napi::Value convmou::convert_key(const Napi::Env& env, const keymou& key) const
 
 Napi::Value convmou::convert_value(const Napi::Env& env, const valuemou& val) const
 {
+    if (is_ordinal(value_mode_)) {
+        return (value_flag_ & base_flag::bigint) ?
+            val.to_bigint(env) :
+            val.to_number(env);
+    }
+
     return (value_flag_ & base_flag::string) ?
         val.to_string(env) :
         val.to_buffer(env);

package/src/convmou.hpp

@@ -4,20 +4,16 @@
 
 namespace mdbxmou {
 
+class dbimou;
+
 struct convmou
 {
     key_mode key_mode_{};
+    value_mode value_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}
-    {   }
+    static convmou for_dbi(const dbimou& dbi) noexcept;
 
     Napi::Value convert_key(const Napi::Env& env, const keymou& key) const;
 

package/src/cursormou.cpp

@@ -230,7 +230,8 @@ namespace mdbxmou
             keymou::from(info[0], env, key_num_) : 
             keymou::from(info[0], env, key_buf_);
 
-        valuemou val = valuemou::from(info[1], env, val_buf_);
+        valuemou val = valuemou::from(info[1], env, val_buf_, val_num_,
+            is_ordinal(dbi_->get_value_mode()));
 
         // Опциональный флаг put_mode (по умолчанию MDBX_UPSERT)
         MDBX_put_flags_t flags = MDBX_UPSERT;

package/src/cursormou.hpp

@@ -20,6 +20,7 @@ private:
     buffer_type key_buf_{};
     buffer_type val_buf_{};
     std::uint64_t key_num_{};
+    std::uint64_t val_num_{};
 
     // Внутренний хелпер для навигации
     Napi::Value move(const Napi::Env& env, MDBX_cursor_op op);

package/src/dbimou.cpp

@@ -165,14 +165,13 @@ MDBX_cursor_op range_turn_op(const range_options& options)
     return options.reverse ? MDBX_PREV : MDBX_NEXT;
 }
 
-Napi::Array collect_range(const Napi::Env& env, dbimou& self, txnmou& txn, const range_options& options, range_output output)
+template<class Fn>
+std::size_t scan_range(dbimou& self, txnmou& txn, const range_options& options, Fn&& fn)
 {
-    Napi::Array result = Napi::Array::New(env);
     if (options.limit == 0) {
-        return result;
+        return 0;
     }
 
-    auto conv = self.get_convmou();
     auto cursor = self.open_cursor(txn);
     mdbx::slice key{};
     mdbx::slice value{};
@@ -186,7 +185,7 @@ Napi::Array collect_range(const Napi::Env& env, dbimou& self, txnmou& txn, const
     }
 
     if (!cursor_get(cursor, range_start_op(options), key, value)) {
-        return result;
+        return 0;
     }
 
     std::size_t skipped{};
@@ -201,17 +200,8 @@ Napi::Array collect_range(const Napi::Env& env, dbimou& self, txnmou& txn, const
         if (skipped < options.offset) {
             ++skipped;
         } else {
-            switch (output) {
-                case range_output::items: {
-                    result.Set(index, conv.make_result(env, keymou{key}, valuemou{value}));
-                    break;
-                }
-                case range_output::keys:
-                    result.Set(index, conv.convert_key(env, keymou{key}));
-                    break;
-                case range_output::values:
-                    result.Set(index, conv.convert_value(env, valuemou{value}));
-                    break;
+            if (fn(keymou{key}, valuemou{value}, index)) {
+                break;
             }
 
             ++index;
@@ -225,9 +215,39 @@ Napi::Array collect_range(const Napi::Env& env, dbimou& self, txnmou& txn, const
         }
     }
 
+    return index;
+}
+
+Napi::Array collect_range(const Napi::Env& env, dbimou& self, txnmou& txn, const range_options& options, range_output output)
+{
+    Napi::Array result = Napi::Array::New(env);
+    auto conv = self.get_convmou();
+    scan_range(self, txn, options, [&](const keymou& key, const valuemou& value, std::size_t index) {
+        switch (output) {
+            case range_output::items:
+                result.Set(index, conv.make_result(env, key, value));
+                break;
+            case range_output::keys:
+                result.Set(index, conv.convert_key(env, key));
+                break;
+            case range_output::values:
+                result.Set(index, conv.convert_value(env, value));
+                break;
+        }
+        return false;
+    });
     return result;
 }
 
+std::size_t count_range(dbimou& self, txnmou& txn, range_options options)
+{
+    options.offset = 0;
+    options.limit = std::numeric_limits<std::size_t>::max();
+    return scan_range(self, txn, options, [](const keymou&, const valuemou&, std::size_t) {
+        return false;
+    });
+}
+
 Napi::Value run_range_query(const Napi::CallbackInfo& info, dbimou& self, const char* method_name, range_output output)
 {
     Napi::Env env = info.Env();
@@ -247,6 +267,26 @@ Napi::Value run_range_query(const Napi::CallbackInfo& info, dbimou& self, const
     }
 }
 
+Napi::Value run_range_count(const Napi::CallbackInfo& info, dbimou& self, const char* method_name)
+{
+    Napi::Env env = info.Env();
+    if (info.Length() < 1) {
+        throw Napi::TypeError::New(env, std::string(method_name) + ": txnmou required");
+    }
+
+    auto txn = txnmou::unwrap_checked(env, info[0], method_name);
+
+    try {
+        auto options = info.Length() > 1 ?
+            parse_range_options(env, info[1], self) :
+            range_options{};
+        auto count = count_range(self, *txn, options);
+        return Napi::Number::New(env, static_cast<double>(count));
+    } catch (const std::exception& e) {
+        throw Napi::Error::New(env, std::string(method_name) + ": " + e.what());
+    }
+}
+
 } // namespace
 
 Napi::FunctionReference dbimou::ctor{};
@@ -263,6 +303,7 @@ void dbimou::init(const char *class_name, Napi::Env env)
         InstanceMethod("keys", &dbimou::keys),
         InstanceMethod("keysFrom", &dbimou::keys_from),
         InstanceMethod("getRange", &dbimou::get_range),
+        InstanceMethod("getCount", &dbimou::get_count),
         InstanceMethod("keysRange", &dbimou::keys_range),
         InstanceMethod("valuesRange", &dbimou::values_range),
         InstanceMethod("drop", &dbimou::drop),
@@ -294,8 +335,15 @@ Napi::Value dbimou::put(const Napi::CallbackInfo& info)
             keymou::from(info[1], env, t) : 
             keymou::from(info[1], env, key_buf_);
 
-        auto val = valuemou::from(info[2], env, val_buf_);
-        dbi::put(*txn, key, val, *this);
+        auto val = valuemou::from(info[2], env, val_buf_, val_num_, is_ordinal(value_mode_));
+        MDBX_put_flags_t flags = MDBX_UPSERT;
+        if (arg_len > 3 && !info[3].IsUndefined() && !info[3].IsNull()) {
+            if (!info[3].IsNumber()) {
+                throw Napi::TypeError::New(env, "put: flags must be a number");
+            }
+            flags = put_flag::parse(info[3]);
+        }
+        dbi::put(*txn, key, val, flags);
     } catch (const std::exception& e) {
         throw Napi::Error::New(env, std::string("put: ") + e.what());
     }
@@ -709,6 +757,11 @@ Napi::Value dbimou::get_range(const Napi::CallbackInfo& info)
     return run_range_query(info, *this, "getRange", range_output::items);
 }
 
+Napi::Value dbimou::get_count(const Napi::CallbackInfo& info)
+{
+    return run_range_count(info, *this, "getCount");
+}
+
 Napi::Value dbimou::keys_range(const Napi::CallbackInfo& info)
 {
     return run_range_query(info, *this, "keysRange", range_output::keys);

package/src/dbimou.hpp

@@ -25,6 +25,7 @@ class dbimou final
 
     buffer_type key_buf_{};
     buffer_type val_buf_{};
+    std::uint64_t val_num_{};
     
 public:   
     static Napi::FunctionReference ctor;
@@ -73,6 +74,7 @@ public:
     Napi::Value keys(const Napi::CallbackInfo&);
     Napi::Value keys_from(const Napi::CallbackInfo&);
     Napi::Value get_range(const Napi::CallbackInfo&);
+    Napi::Value get_count(const Napi::CallbackInfo&);
     Napi::Value keys_range(const Napi::CallbackInfo&);
     Napi::Value values_range(const Napi::CallbackInfo&);
     Napi::Value drop(const Napi::CallbackInfo&);
@@ -124,7 +126,7 @@ public:
     }
 
     convmou get_convmou() const noexcept {
-        return {key_mode_, key_flag_, value_flag_};
+        return convmou::for_dbi(*this);
     }
 };
 

package/src/modulemou.cpp

@@ -80,6 +80,8 @@ Napi::Object Init(Napi::Env env, Napi::Object exports)
 
     Napi::Object value_flag = Napi::Object::New(env);
     MDBXMOU_DECLARE_FLAG_NAME(value_flag, "string", base_flag::string);
+    MDBXMOU_DECLARE_FLAG_NAME(value_flag, "number", base_flag::number);
+    MDBXMOU_DECLARE_FLAG_NAME(value_flag, "bigint", base_flag::bigint);
     mdbx_mou.Set("valueFlag", value_flag);
 
     using mdbxmou::db_mode;
@@ -97,6 +99,18 @@ Napi::Object Init(Napi::Env env, Napi::Object exports)
     MDBXMOU_DECLARE_FLAG_NAME(queryMode, "del", query_mode::del);
     mdbx_mou.Set("queryMode", queryMode);
 
+    using mdbxmou::put_flag;
+    Napi::Object putFlag = Napi::Object::New(env);
+    MDBXMOU_DECLARE_FLAG_NAME(putFlag, "noOverwrite", put_flag::no_overwrite);
+    MDBXMOU_DECLARE_FLAG_NAME(putFlag, "noDupData", put_flag::no_dup_data);
+    MDBXMOU_DECLARE_FLAG_NAME(putFlag, "current", put_flag::current);
+    MDBXMOU_DECLARE_FLAG_NAME(putFlag, "allDups", put_flag::all_dups);
+    MDBXMOU_DECLARE_FLAG_NAME(putFlag, "reserve", put_flag::reserve);
+    MDBXMOU_DECLARE_FLAG_NAME(putFlag, "append", put_flag::append);
+    MDBXMOU_DECLARE_FLAG_NAME(putFlag, "appendDup", put_flag::append_dup);
+    MDBXMOU_DECLARE_FLAG_NAME(putFlag, "multiple", put_flag::multiple);
+    mdbx_mou.Set("putFlag", putFlag);
+
     using move_operation = mdbx::cursor::move_operation;
     Napi::Object cursor_mode = Napi::Object::New(env);
     MDBXMOU_DECLARE_FLAG_NAME(cursor_mode, "first", move_operation::first);

package/src/querymou.cpp

@@ -23,20 +23,11 @@ dbimou* async_common::parse(const Napi::Object& arg0)
 
 void async_key::parse(const async_common& common, const Napi::Value& item)
 {
-    // утснавлиаем общие параметры
-    auto key_flag = common.key_flag;
-
     keymou key{};
     if (mdbx::is_ordinal(common.key_mod)) {
-        if (item.IsBigInt()) {
-            key = keymou{item.As<Napi::BigInt>(), id_buf};
-        } else if (item.IsNumber()) {
-            key = keymou{item.As<Napi::Number>(), id_buf};
-        }
+        key = keymou::from(item, item.Env(), id_buf);
     } else {
-        key = (key_flag & base_flag::string) ?
-           keymou{item.As<Napi::String>(), item.Env(), key_buf} :
-           keymou{item.As<Napi::Buffer<char>>(), key_buf};
+        key = keymou::from(item, item.Env(), key_buf);
     }
 }
 
@@ -44,12 +35,14 @@ void async_keyval::parse(const query_line& common, const Napi::Object& item)
 {
     async_key::parse(common, item);    
     // проверяем надо ли что-то писать
-    if (common.mode.val & query_mode::write_mask) {
+    if (common.mode.is_write()) {
         valuemou val{};
         auto item_val = item.Get("value");
-        val = (common.value_flag & base_flag::string) ?
-            valuemou{item_val.As<Napi::String>(), item_val.Env(), val_buf} :
-            valuemou{item_val.As<Napi::Buffer<char>>(), val_buf};
+        val = is_ordinal(common.val_mod) ?
+            valuemou::from(item_val, item_val.Env(), val_num) :
+            (common.value_flag & base_flag::string) ?
+                valuemou{item_val.As<Napi::String>(), item_val.Env(), val_buf} :
+                valuemou{item_val.As<Napi::Buffer<char>>(), val_buf};
     }
 }
 
@@ -63,6 +56,13 @@ void query_line::parse(txn_mode txn, const Napi::Object& arg0)
     } else if (arg0.Has("queryMode")) {
         mode = query_mode::parse(txn, arg0.Get("queryMode").As<Napi::Number>());
     }
+    if (arg0.Has("putFlag")) {
+        put_flags = put_flag::parse_query(arg0.Get("putFlag"));
+        if (!mode.is_write()) {
+            throw Napi::TypeError::New(arg0.Env(),
+                "query putFlag requires write queryMode");
+        }
+    }
     auto items_array = arg0.Get("item").As<Napi::Array>();
     auto item_len = items_array.Length();
     if (item_len > 0) {

package/src/querymou.hpp

@@ -39,6 +39,7 @@ struct async_keyval
     : async_key
 {
     buffer_type val_buf{};
+    std::uint64_t val_num{};
     bool found{false};
 
     void parse(const query_line& line, const Napi::Object& obj);
@@ -57,6 +58,7 @@ struct query_line
 {
     base_flag value_flag{};
     query_mode mode{};
+    put_flag put_flags{};
     // буффер для запроса / ответа
     std::vector<async_keyval> item{};
     void parse(txn_mode txn, const Napi::Object& arg0);
@@ -83,4 +85,4 @@ struct keys_line
 using keys_request = std::vector<keys_line>;
 keys_request parse_keys(const Napi::Value& obj);
 
-} // namespace mdbxmou
+} // namespace mdbxmou

package/src/txnmou.cpp

@@ -159,7 +159,7 @@ Napi::Value txnmou::get_dbi(const Napi::Object& arg0, db_mode db_mode)
     if (arg0.Has("valueMode")) {
         auto value = arg0.Get("valueMode");
         if (!value.IsUndefined() && !value.IsNull()) {
-            value_mode = value_mode::parse(value);
+            value_mode = parse_value_mode(value, value_flag);
         }
     }
 
@@ -189,7 +189,7 @@ Napi::Value txnmou::get_dbi(const Napi::CallbackInfo& info, db_mode db_mode)
         auto arg2 = info[2]; // value_mode
         db_name = arg0.As<Napi::String>().Utf8Value();
         key_mode = parse_key_mode(env, arg1, key_flag);
-        value_mode = value_mode::parse(arg2);
+        value_mode = parse_value_mode(arg2, value_flag);
     } else if (arg_count == 2) {
         // db_name + key_mode || key_mode + value_mode
         auto arg0 = info[0];
@@ -199,7 +199,7 @@ Napi::Value txnmou::get_dbi(const Napi::CallbackInfo& info, db_mode db_mode)
             key_mode = parse_key_mode(env, arg1, key_flag);
         } else {
             key_mode = parse_key_mode(env, arg0, key_flag);
-            value_mode = value_mode::parse(arg1);
+            value_mode = parse_value_mode(arg1, value_flag);
         }
     } else if (arg_count == 1) {
         // db_name || key_mode

package/src/typemou.hpp

@@ -171,19 +171,80 @@ struct query_mode
     };
     int val{get};
 
+    bool is_get() const noexcept {
+        return (val & get) != 0;
+    }
+
+    bool is_del() const noexcept {
+        return (val & del) != 0;
+    }
+
+    bool is_write() const noexcept {
+        return !is_get() && !is_del();
+    }
+
     static inline query_mode parse(const txn_mode& mode, const Napi::Value& arg0) {
         query_mode rc{arg0.As<Napi::Number>().Int32Value() & mask};
-        if ((mode.val & txn_mode::ro) && (rc.val & (del|write_mask))) {
+        if ((rc.is_get() || rc.is_del()) && (rc.val & write_mask)) {
+            throw std::runtime_error(
+                "queryMode must be one of get/del/upsert/update/insertUnique");
+        }
+        if (rc.is_get() && rc.is_del()) {
+            throw std::runtime_error(
+                "queryMode must be one of get/del/upsert/update/insertUnique");
+        }
+        if ((mode.val & txn_mode::ro) && (rc.is_del() || rc.is_write())) {
             throw std::runtime_error("rw query in read-only transaction");
         }
         return rc;
     }
 
+    int write_flags() const noexcept {
+        return val & write_mask;
+    }
+
     operator mdbx::put_mode() const noexcept {
         return static_cast<mdbx::put_mode>(val & write_mask);
     }    
 };
 
+struct put_flag
+{
+    enum type : int {
+        no_overwrite = MDBX_NOOVERWRITE,
+        no_dup_data = MDBX_NODUPDATA,
+        current = MDBX_CURRENT,
+        all_dups = MDBX_ALLDUPS,
+        reserve = MDBX_RESERVE,
+        append = MDBX_APPEND,
+        append_dup = MDBX_APPENDDUP,
+        multiple = MDBX_MULTIPLE,
+        query_mask = MDBX_NOOVERWRITE | MDBX_NODUPDATA | MDBX_CURRENT |
+            MDBX_APPEND | MDBX_APPENDDUP,
+        mask = MDBX_NOOVERWRITE | MDBX_NODUPDATA | MDBX_CURRENT |
+            MDBX_ALLDUPS | MDBX_RESERVE | MDBX_APPEND |
+            MDBX_APPENDDUP | MDBX_MULTIPLE
+    };
+    int val{};
+
+    static inline put_flag parse(const Napi::Value& arg0) {
+        return {arg0.As<Napi::Number>().Int32Value() & mask};
+    }
+
+    static inline put_flag parse_query(const Napi::Value& arg0) {
+        put_flag rc = parse(arg0);
+        if (rc.val & ~query_mask) {
+            throw Napi::TypeError::New(arg0.Env(),
+                "query putFlag supports only noOverwrite/noDupData/current/append/appendDup");
+        }
+        return rc;
+    }
+
+    operator MDBX_put_flags_t() const noexcept {
+        return static_cast<MDBX_put_flags_t>(val & mask);
+    }
+};
+
 struct key_mode
 {
     enum type : int {
@@ -223,6 +284,11 @@ struct value_mode
     }
 };
 
+static inline bool is_ordinal(const value_mode& mode) noexcept
+{
+    return (mode.val & static_cast<int>(MDBX_INTEGERDUP)) != 0;
+}
+
 
 struct base_flag
 {
@@ -231,7 +297,7 @@ struct base_flag
         number = 4,
         bigint = 8,
         mask_key = string | number | bigint,
-        mask_val = string
+        mask_val = string | number | bigint
     };
     int val{};
 
@@ -270,11 +336,12 @@ struct base_flag
     }
 
     static inline void validate_value(const Napi::Value& arg0, int value) {
-        if (value == 0 || value == string) {
+        if (value == 0 || value == string ||
+            value == number || value == bigint) {
             return;
         }
         throw Napi::Error::New(arg0.Env(),
-            "valueFlag must be 0 or string");
+            "valueFlag must be 0, string, number or bigint");
     }
 
     static inline base_flag parse_key(const Napi::Value& arg0) {
@@ -287,7 +354,11 @@ struct base_flag
         const Napi::Value& arg0) {
         auto value = arg0.As<Napi::Number>().Int32Value() & mask_val;
         validate_value(arg0, value);
-        return {value};
+        base_flag rc{value};
+        if (is_ordinal(mode) && !rc.is_numeric()) {
+            rc = number;
+        }
+        return rc;
     }
 
     static inline base_flag parse_value(const Napi::Value& arg0) {
@@ -327,6 +398,15 @@ static inline key_mode parse_key_mode(Napi::Env env, const Napi::Value& arg0, ba
     return mode;
 }
 
+static inline value_mode parse_value_mode(const Napi::Value& arg0, base_flag& value_flag)
+{
+    auto mode = value_mode::parse(arg0);
+    if (is_ordinal(mode) && !value_flag.is_numeric()) {
+        value_flag = base_flag::number;
+    }
+    return mode;
+}
+
 struct db_mode
 {
     enum type : int {

package/src/valuemou.hpp

@@ -29,6 +29,10 @@ struct valuemou
         : mdbx::slice{arg0.data(), arg0.size()}
     {   }
 
+    valuemou(const std::uint64_t& arg0) noexcept
+        : mdbx::slice{&arg0, sizeof(arg0)}
+    {   }
+
     valuemou(const Napi::Buffer<char>& arg0, buffer_type& mem)
     {   
         auto ptr = arg0.Data();
@@ -59,6 +63,28 @@ struct valuemou
         assign(mem.data(), mem.size());
     }
 
+    valuemou(const Napi::Number& arg0,
+        const Napi::Env& env, std::uint64_t& mem)
+    {
+        auto value = arg0.Int64Value();
+        if (value < 0) {
+            throw Napi::Error::New(env, "Number negative");
+        }
+        mem = static_cast<std::uint64_t>(value);
+        assign(&mem, sizeof(mem));
+    }
+
+    valuemou(const Napi::BigInt& arg0,
+        const Napi::Env& env, std::uint64_t& mem)
+    {
+        bool looseless;
+        mem = arg0.Uint64Value(&looseless);
+        if (!looseless) {
+            throw Napi::Error::New(env, "BigInt !looseless");
+        }
+        assign(&mem, sizeof(mem));
+    }
+
     static inline valuemou from(const Napi::Value& arg0, 
         const Napi::Env& env, buffer_type& mem)
     {
@@ -70,6 +96,23 @@ struct valuemou
         return {arg0.As<Napi::String>(), env, mem};
     }
 
+    static inline valuemou from(const Napi::Value& arg0,
+        const Napi::Env& env, std::uint64_t& mem)
+    {
+        if (arg0.IsBigInt()) {
+            return {arg0.As<Napi::BigInt>(), env, mem};
+        } else if (!arg0.IsNumber()) {
+            throw Napi::Error::New(env, "value must be a Number or BigInt");
+        }
+        return {arg0.As<Napi::Number>(), env, mem};
+    }
+
+    static inline valuemou from(const Napi::Value& arg0,
+        const Napi::Env& env, buffer_type& buf, std::uint64_t& num, bool ordinal)
+    {
+        return ordinal ? from(arg0, env, num) : from(arg0, env, buf);
+    }
+
     Napi::Value to_string(const Napi::Env& env) const
     {
         return Napi::String::New(env, 
@@ -81,92 +124,38 @@ struct valuemou
         return Napi::Buffer<char>::Copy(env, 
             char_ptr(), length());
     }
+
+    Napi::Value to_number(const Napi::Env& env) const
+    {
+        return Napi::Number::New(env, static_cast<double>(as_int64()));
+    }
+
+    Napi::Value to_bigint(const Napi::Env& env) const
+    {
+        return Napi::BigInt::New(env, as_uint64());
+    }
 };
 
 struct keymou final
     : valuemou
 {
+    using valuemou::valuemou;
+
     keymou() = default;
     keymou(const keymou&) = default;
     keymou& operator=(const keymou&) = default;
     keymou(keymou&&) = default;
     keymou& operator=(keymou&&) = default;
 
-    keymou(const valuemou& arg0) noexcept
-        : valuemou{arg0}
-    {   }
-
-    keymou(const mdbx::slice& arg0) noexcept
-        : valuemou{arg0}
-    {   }
-
-    keymou(const Napi::Buffer<char>& arg0)
-        : valuemou{arg0}
-    {   }
-
-    keymou(const buffer_type& arg0) noexcept
-        : valuemou{arg0}
-    {   }    
-
-    keymou(const std::uint64_t& arg0) noexcept
-        : valuemou{mdbx::slice{&arg0, sizeof(arg0)}}
-    {   }
-
-    keymou(const Napi::Buffer<char>& arg0, buffer_type& mem)
-        : valuemou{arg0, mem}
-    {   }
-
-    keymou(const Napi::String& arg0, 
-        const Napi::Env& env, buffer_type& mem)
-        : valuemou{arg0, env, mem}
-    {   }
-
-    keymou(const Napi::Number& arg0, std::uint64_t& mem)
-    {   
-        auto value = arg0.Int64Value();
-        if (value < 0) {
-            throw std::runtime_error("Number negative");
-        }
-        mem = static_cast<std::uint64_t>(value);
-        assign(&mem, sizeof(mem));
-    }    
-
-    keymou(const Napi::Number& arg0, 
-        const Napi::Env& env, std::uint64_t& mem)
-    {   
-        auto value = arg0.Int64Value();
-        if (value < 0) {
-            throw Napi::Error::New(env, "Number negative");
-        }
-        mem = static_cast<std::uint64_t>(value);
-        assign(&mem, sizeof(mem));
-    }
-
-    keymou(const Napi::BigInt& arg0,std::uint64_t& mem)
-    {   
-        bool looseless;
-        mem = arg0.Uint64Value(&looseless);
-        if (!looseless) {
-            throw std::runtime_error("BigInt !looseless");
-        }
-        assign(&mem, sizeof(mem));
-    }    
-
-    keymou(const Napi::BigInt& arg0, 
-        const Napi::Env& env, std::uint64_t& mem)
-    {   
-        bool looseless;
-        mem = arg0.Uint64Value(&looseless);
-        if (!looseless) {
-            throw Napi::Error::New(env, "BigInt !looseless");
-        }
-        assign(&mem, sizeof(mem));
-    }
-
     static inline keymou from(const Napi::Value& arg0, 
         const Napi::Env& env, buffer_type& mem)
     {
-        return {valuemou::from(arg0, env, mem)};
+        if (arg0.IsBuffer()) {
+            return {arg0.As<Napi::Buffer<char>>()};
+        } else if (!arg0.IsString()) {
+            throw Napi::Error::New(env, "key must be a Buffer or String");
+        }
+        return {arg0.As<Napi::String>(), env, mem};
     }    
 
     static inline keymou from(const Napi::Value& arg0, 
@@ -190,16 +179,6 @@ struct keymou final
         }
         return from(arg0, env, num);
     }
-
-    Napi::Value to_number(const Napi::Env& env) const
-    {
-        return Napi::Number::New(env, static_cast<double>(as_int64()));
-    }
-
-    Napi::Value to_bigint(const Napi::Env& env) const
-    {
-        return Napi::BigInt::New(env, as_uint64());
-    }
 };
 
-} // mdbxmou
+} // mdbxmou