mdbxmou 0.3.11 → 0.3.13

package/deps/libmdbx/mdbx_stat.c

@@ -18,7 +18,7 @@
 /// \copyright SPDX-License-Identifier: Apache-2.0
 /// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2026
 
-#define MDBX_BUILD_SOURCERY 90c8567c0f319539000cf161230c67f127fd9cbcb5d35ad5b3b076b78b5dc48d_v0_13_11_0_gb862eb08
+#define MDBX_BUILD_SOURCERY a575a490fc080ca11e89ff6db9f0bd38aa830959905998cac0e45274b9e6bb0e_v0_13_12_0_gf619d43d
 
 #define LIBMDBX_INTERNALS
 #define MDBX_DEPRECATED
@@ -1499,7 +1499,7 @@ MDBX_INTERNAL int osal_lockfile(mdbx_filehandle_t fd, bool wait);
 #define MMAP_OPTION_SEMAPHORE 2
 MDBX_INTERNAL int osal_mmap(const int flags, osal_mmap_t *map, size_t size, const size_t limit, const unsigned options,
                             const pathchar_t *pathname4logging);
-MDBX_INTERNAL int osal_munmap(osal_mmap_t *map);
+MDBX_INTERNAL void osal_munmap(osal_mmap_t *map);
 #define MDBX_MRESIZE_MAY_MOVE 0x00000100
 #define MDBX_MRESIZE_MAY_UNMAP 0x00000200
 MDBX_INTERNAL int osal_mresize(const int flags, osal_mmap_t *map, size_t size, size_t limit);
@@ -3516,7 +3516,6 @@ int main(int argc, char *argv[]) {
   signal(SIGTERM, signal_handler);
 #endif /* !WINDOWS */
 
-  envname = argv[optind];
   envname = argv[optind];
   if (!quiet) {
     printf("mdbx_stat %s (%s, T-%s)\nRunning for %s...\n", mdbx_version.git.describe, mdbx_version.git.datetime,

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.13",
   "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