mdbxmou 0.3.11 → 0.3.13

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

package/deps/libmdbx/.github/workflows/ci-android.yml

@@ -1,38 +0,0 @@
-name: ci-android
-
-env:
-  CI: GITHUB
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.head_ref || github.ref }}
-  cancel-in-progress: true
-
-on: [push]
-
-jobs:
-  ci-job:
-    runs-on: ${{ matrix.os }}
-    strategy:
-      fail-fast: false
-      matrix:
-        ndk: [r26d, r27c]
-        target: [arm64-v8a, "armeabi-v7a with NEON", x86_64]
-        build-type: [Debug, Release]
-        os: [ubuntu-latest]
-        exclude:
-          - ndk: r26d
-            build-type: Debug
-    steps:
-    - uses: actions/checkout@v4
-    - uses: nttld/setup-ndk@v1
-      id: setup-ndk
-      with:
-        ndk-version: ${{ matrix.ndk }}
-        add-to-path: true
-    - name: ci-step
-      env:
-        ANDROID_NDK_HOME: ${{ steps.setup-ndk.outputs.ndk-path }}
-        CI_MAKE_TARGET: ""
-      shell: bash
-      run: |
-        . ci.sh "-DANDROID_ABI=${{ matrix.target }}|-DCMAKE_TOOLCHAIN_FILE:PATH=${{ steps.setup-ndk.outputs.ndk-path }}/build/cmake/android.toolchain.cmake|-DCMAKE_BUILD_TYPE=${{ matrix.build-type }}"

package/deps/libmdbx/.github/workflows/ci-mingw.yml

@@ -1,40 +0,0 @@
-name: ci-mingw
-
-env:
-  CI: GITHUB
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.head_ref || github.ref }}
-  cancel-in-progress: true
-
-on: [push]
-
-jobs:
-  ci-job:
-    runs-on: ${{ matrix.os }}
-    strategy:
-      fail-fast: false
-      matrix:
-        build-type: [Debug, Release]
-        dll: [ON, OFF]
-        without_crt: [ON, OFF]
-        os: [windows-latest]
-        exclude:
-          - build-type: Debug
-            dll: OFF
-          - build-type: Release
-            without_crt: ON
-    steps:
-    - uses: actions/checkout@v4
-#    - name: Update mingw64
-#      run: choco upgrade mingw -y --no-progress
-    - name: ci-step
-      shell: bash
-      env:
-        CI_MAKE_TARGET: smoke
-      run: |
-        echo "initial-PATH=$PATH" && \
-        export "PATH=/c/mingw64/bin:/c/programdata/mingw64/mingw64/bin:$PATH" && \
-        export MDBX_BUILD_OPTIONS=$(if [ "${{ matrix.build-type }}" = 'Debug' ]; then echo '-DMDBX_FORCE_ASSERTIONS=1'; else echo '-DNDEBUG=1'; fi) && \
-        export MDBX_BUILD_CXX=$(if [ "${{ matrix.without_crt }}" = 'OFF' ]; then echo 'YES'; else echo 'NO'; fi) && \
-        . ci.sh "-G|MinGW Makefiles|-DCMAKE_BUILD_TYPE=${{ matrix.build-type }}|-DMDBX_BUILD_SHARED_LIBRARY:BOOL=${{ matrix.dll }}|-DMDBX_WITHOUT_MSVC_CRT:BOOL=${{ matrix.without_crt }}"

package/deps/libmdbx/.github/workflows/ci-posix.yml

@@ -1,34 +0,0 @@
-name: ci-posix
-
-env:
-  CI: GITHUB
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.head_ref || github.ref }}
-  cancel-in-progress: true
-
-on: [push]
-
-jobs:
-  ci-job:
-    runs-on: ${{ matrix.os }}
-    strategy:
-      fail-fast: false
-      matrix:
-        os: [ubuntu-24.04, macos-14, macos-26]
-        build-type: [Debug, Release]
-#        alloy: [ON, OFF]
-        cxx: [ON, OFF]
-#        exclude:
-#          - os: macos-14
-#            cxx: OFF
-#            alloy: ON
-    steps:
-    - uses: actions/checkout@v4
-    - name: ci-step
-      shell: bash
-      run: |
-        export CI_MAKE_TARGET=$(if [ "$(uname)" = 'Linux' ]; then echo 'check'; elif [ "${{ matrix.build-type }}" != 'Debug' ]; then echo 'test'; else echo 'smoke'; fi) && \
-        export MDBX_BUILD_OPTIONS=$(if [ "${{ matrix.build-type }}" = 'Debug' ]; then echo '-DMDBX_FORCE_ASSERTIONS=1'; else echo '-DNDEBUG=1'; fi) && \
-        export MDBX_BUILD_CXX=$(if [ "${{ matrix.cxx }}" = 'ON' ]; then echo 'YES'; else echo 'NO'; fi) && \
-        . ci.sh "-DCMAKE_BUILD_TYPE=${{ matrix.build-type }}|-DMDBX_BUILD_CXX:BOOL=${{ matrix.cxx }}"

package/deps/libmdbx/.github/workflows/ci-wincxx.yml

@@ -1,45 +0,0 @@
-name: ci-wincxx
-
-env:
-  CI: GITHUB
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.head_ref || github.ref }}
-  cancel-in-progress: true
-
-on: [push]
-
-jobs:
-  ci-job:
-    strategy:
-      fail-fast: false
-      matrix:
-        toolset: [v142, v143]
-        cxx: [11, 14, 17, 20]
-        target: [Win32, x64, ARM64]
-        build-type: [Debug, Release]
-        os: [windows-latest, windows-2022]
-        exclude:
-          - os: windows-latest
-            toolset: v142
-          - os: windows-latest
-            cxx: 11
-          - os: windows-2022
-            toolset: v143
-          - os: windows-2022
-            cxx: 20
-#          - target: x64
-#            build-type: Debug
-          - target: ARM64
-            toolset: v142
-    runs-on: ${{ matrix.os }}
-    steps:
-    - uses: actions/checkout@v4
-    - name: ci-step
-      env:
-        CI_MAKE_TARGET: ""
-        CXXSTD: "-std=gnu++${{ matrix.cxx }}"
-      shell: bash
-      run: |
-        . ci.sh "-A|${{ matrix.target }}|-T|${{ matrix.toolset }}|-DCMAKE_BUILD_TYPE=${{ matrix.build-type }}|-DCMAKE_CXX_STANDARD=${{ matrix.cxx }}" \
-          "--config|${{ matrix.build-type }}" "--build-config|${{ matrix.build-type }}"

package/deps/libmdbx/.github/workflows/ci-windows.yml

@@ -1,32 +0,0 @@
-name: ci-windows
-
-env:
-  CI: GITHUB
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.head_ref || github.ref }}
-  cancel-in-progress: true
-
-on: [push]
-
-jobs:
-  ci-job:
-    strategy:
-      fail-fast: false
-      matrix:
-        toolset: [v143]
-        dll: [ON, OFF]
-        without_crt: [ON, OFF]
-        target: [x64, Win32]
-        build-type: [Debug, Release]
-        os: [windows-latest]
-    runs-on: ${{ matrix.os }}
-    steps:
-    - uses: actions/checkout@v4
-    - name: ci-step
-      env:
-        CI_MAKE_TARGET: ""
-      shell: bash
-      run: |
-        . ci.sh "-A|${{ matrix.target }}|-T|${{ matrix.toolset }}|-DCMAKE_BUILD_TYPE=${{ matrix.build-type }}|-DMDBX_BUILD_SHARED_LIBRARY:BOOL=${{ matrix.dll }}|-DMDBX_WITHOUT_MSVC_CRT:BOOL=${{ matrix.without_crt }}" \
-          "--config|${{ matrix.build-type }}" "--build-config|${{ matrix.build-type }}"

package/deps/libmdbx/ci.sh

@@ -1,86 +0,0 @@
-#!/usr/bin/env bash
-#
-# This script is temporary, is not part of libmdbx, and is used only for CI testing.
-#
-#######################################################################################
-
-function failure() {
-	echo "Oops, $* failed ;(" >&2
-	exit 2
-}
-
-export ci_script_recursion="$((++ci_script_recursion))"
-if [ $ci_script_recursion -gt 3 ]; then
-     failure "WTF: ci_script_recursion = $ci_script_recursion ?"
-fi
-
-IFS='|' read -r -a config_args <<< "${1:-}"
-IFS='|' read -r -a build_args <<< "${2:-}"
-IFS='|' read -r -a test_args <<< "${3:-}"
-set -euxo pipefail
-
-function provide_toolchain {
-	set +ex
-	export CC="$((which ${CC:-cc} || which gcc || which clang || which true) 2>/dev/null)"
-	export CXX="$((which ${CXX:-c++} || which g++ || which clang++ || which true) 2>/dev/null)"
-	echo "CC: ${CC} => $($CC --version | head -1)"
-	echo "CXX: ${CXX} => $($CXX --version | head -1)"
-	CMAKE="$(which cmake 2>/dev/null)"
-	if [ -z "${CMAKE}" -o -z "$(which ninja 2>/dev/null)" ]; then
-		SUDO=$(which sudo 2>&-)
-		if [ -n "$(which apt 2>/dev/null)" ]; then
-			${SUDO} apt update && sudo apt install -y cmake ninja-build libgtest-dev
-		elif [ -n "$(which dnf 2>/dev/null)" ]; then
-			${SUDO} dnf install -y cmake ninja-build gtest-devel
-		elif [ -n "$(which yum 2>/dev/null)" ]; then
-			${SUDO} yum install -y cmake ninja-build gtest-devel
-		fi
-		CMAKE="$(which cmake 2>/dev/null) | echo false"
-	fi
-	CMAKE_VERSION=$(eval expr $("${CMAKE}" --version | sed -n 's/cmake version \([0-9]\{1,\}\)\.\([0-9]\{1,\}\)\.\([0-9]\{1,\}\)/\10000 + \200 + \3/p' || echo '00000'))
-	echo "CMAKE: ${CMAKE} => $(""${CMAKE}"" --version | head -1) ($CMAKE_VERSION)"
-	set -euxo pipefail
-}
-
-function default_test {
-	GTEST_SHUFFLE=1 GTEST_RUNTIME_LIMIT=99 MALLOC_CHECK_=7 MALLOC_PERTURB_=42 \
-	ctest --output-on-failure --parallel 3 --schedule-random --no-tests=error \
-	"${test_args[@]+"${test_args[@]}"}"
-}
-
-function default_build {
-	local cmake_use_ninja=""
-	if "${CMAKE}" --help | grep -iq ninja && [ -n "$(which ninja 2>/dev/null)" ] && echo " ${config_args[@]+"${config_args[@]}"}" | grep -qv -e ' -[GTA] '; then
-		echo "NINJA: $(which ninja 2>/dev/null) => $(ninja --version | head -1)"
-		cmake_use_ninja="-G Ninja"
-	fi
-	"${CMAKE}" ${cmake_use_ninja} "${config_args[@]+"${config_args[@]}"}" .. && "${CMAKE}" --build . --verbose "${build_args[@]+"${build_args[@]}"}"
-}
-
-function default_ci {
-	provide_toolchain
-	local skipped=true
-	local ok=true
-	if [ -e CMakeLists.txt -a $CMAKE_VERSION -ge 30002 ]; then
-		skipped=false
-		mkdir @ci-cmake-build && (cd @ci-cmake-build && default_build && default_test && echo "Done (cmake)") || ok=false
-	fi
-	if [ -n "$CC" -a -n "${CI_MAKE_TARGET=test}" ] && [ -e GNUmakefile -o -e Makefile -o -e makefile ]; then
-		skipped=false
-		make -j2 all && make ${CI_MAKE_TARGET} && echo "Done (make)" || ok=false
-	fi
-	if [ $skipped = "true" ]; then
-		echo "Skipped since CMAKE_VERSION ($CMAKE_VERSION) < 3.0.2 and no Makefile"
-	elif [ $ok != "true" ]; then
-		exit 1
-	fi
-}
-
-git clean -x -f -d || echo "ignore 'git clean' error"
-git describe --tags || git show --oneline -s
-
-if [ -z "${CI_ACTION:-}" ]; then
-	CI_ACTION=default_ci
-fi
-
-$CI_ACTION || failure $CI_ACTION

package/deps/libmdbx/packages/archlinux/.SRCINFO

@@ -1,16 +0,0 @@
-pkgbase = libmdbx
-	pkgdesc = One of the fastest compact key-value ACID database without WAL, which surpasses the legendary LMDB in terms of reliability, features and performance. At the end of 2024 MDBX was chosen by all modern Ethereum frontiers/nodes as a storage engine.
-	pkgver = 0.13.10
-	pkgrel = 2
-	url = https://libmdbx.dqdkfa.ru/
-	arch = x86_64
-	arch = i686
-	arch = ARM
-	arch = aarch64
-	arch = powerpc64le
-	license = Apache-2
-	depends = glibc
-	source = libmdbx-0.13.10.tar.xz::https://libmdbx.dqdkfa.ru/release/libmdbx-amalgamated-0.13.10.tar.xz
-	sha256sums = e6c9af085390c41d101fce0a72794c77159e1e271e41077ea0fd4270b43cc56c
-
-pkgname = libmdbx

package/deps/libmdbx/packages/archlinux/PKGBUILD

@@ -1,38 +0,0 @@
-# Maintainer: Леонид Юрьев (Leonid Yuriev) <leo@yuriev.ru>
-# Contributor: Леонид Юрьев (Leonid Yuriev) <leo@yuriev.ru>
-# Contributor: Noel Kuntze <noel.kuntze@thermi.consulting>
-pkgname=libmdbx
-pkgver=0.13.10
-pkgrel=2
-pkgdesc="One of the fastest compact key-value ACID database without WAL, which surpasses the legendary LMDB in terms of reliability, features and performance. At the end of 2024 MDBX was chosen by all modern Ethereum frontiers/nodes as a storage engine."
-url="https://libmdbx.dqdkfa.ru/"
-arch=('x86_64' 'i686' 'ARM' 'aarch64' 'powerpc64le')
-license=('Apache-2')
-depends=('glibc')
-subpackages="$pkgname-dev $pkgname-doc $pkgname-dbg"
-source=("$pkgname-$pkgver.tar.xz::https://libmdbx.dqdkfa.ru/release/libmdbx-amalgamated-$pkgver.tar.xz")
-sha256sums=('e6c9af085390c41d101fce0a72794c77159e1e271e41077ea0fd4270b43cc56c')
-
-build() {
-	make -C "$srcdir" \
-		DESTDIR="$pkgdir" prefix=/usr \
-		CFLAGS="$CFLAGS -std=gnu11 -ffunction-sections -fPIC -fvisibility=hidden -pthread" \
-		CXXFLAGS="$CXXFLAGS -std=gnu++20 -ffunction-sections -fPIC -fvisibility=hidden -pthread" \
-		lib-shared tools
-}
-
-check() {
-	echo "  Testing a storage engine is a very voluminous and complex task that requires many hours of processor time."
-	echo "  Any simple tests will only verify the success of the build and create an unjustified illusion."
-	echo "  Therefore, full-fledged testing of libmdbx is performed during development and releasing, but the test framework used for this purpose is not included in the amalgamated source code of libmdbx releases."
-	echo "  The users are invited to use their own integration and functional tests, and if necessary to test libmdbx itself use a whole source code from the git repository."
-}
-
-package() {
-	make -C "$srcdir" \
-		DESTDIR="$pkgdir" prefix=/usr \
-		CFLAGS="$CFLAGS -std=gnu11 -ffunction-sections -fPIC -fvisibility=hidden -pthread" \
-		CXXFLAGS="$CXXFLAGS -std=gnu++20 -ffunction-sections -fPIC -fvisibility=hidden -pthread" \
-		install-no-strip
-}
-