mdbx.h

Go to the documentation of this file.

 
#pragma once
#ifndef LIBMDBX_H
#define LIBMDBX_H
 
#ifdef _MSC_VER
#pragma warning(push, 1)
#pragma warning(disable : 4548) /* expression before comma has no effect;      \
                                   expected expression with side - effect */
#pragma warning(disable : 4530) /* C++ exception handler used, but unwind      \
                                 * semantics are not enabled. Specify /EHsc */
#pragma warning(disable : 4577) /* 'noexcept' used with no exception handling  \
                                 * mode specified; termination on exception is \
                                 * not guaranteed. Specify /EHsc */
#endif                          /* _MSC_VER (warnings) */
 
/* *INDENT-OFF* */
/* clang-format off */
 
/* *INDENT-ON* */
/* clang-format on */
 
#include <stdarg.h>
#include <stddef.h>
#include <stdint.h>
#if !defined(NDEBUG) && !defined(assert)
#include <assert.h>
#endif /* NDEBUG */
 
#if defined(_WIN32) || defined(_WIN64)
#include <windows.h>
#include <winnt.h>
#ifndef __mode_t_defined
typedef unsigned short mdbx_mode_t;
#else
typedef mode_t mdbx_mode_t;
#endif /* __mode_t_defined */
typedef HANDLE mdbx_filehandle_t;
typedef DWORD mdbx_pid_t;
typedef DWORD mdbx_tid_t;
#else                  /* Windows */
#include <errno.h>     /* for error codes */
#include <pthread.h>   /* for pthread_t */
#include <sys/types.h> /* for pid_t */
#include <sys/uio.h>   /* for struct iovec */
#define HAVE_STRUCT_IOVEC 1
typedef int mdbx_filehandle_t;
typedef pid_t mdbx_pid_t;
typedef pthread_t mdbx_tid_t;
typedef mode_t mdbx_mode_t;
#endif /* !Windows */
 
#ifdef _MSC_VER
#pragma warning(pop)
#endif
 
/*----------------------------------------------------------------------------*/
 
#ifndef __has_attribute
#define __has_attribute(x) (0)
#endif /* __has_attribute */
 
#ifndef __has_cpp_attribute
#define __has_cpp_attribute(x) 0
#endif /* __has_cpp_attribute */
 
#ifndef __has_feature
#define __has_feature(x) (0)
#endif /* __has_feature */
 
#ifndef __has_extension
#define __has_extension(x) (0)
#endif /* __has_extension */
 
#ifndef __has_builtin
#define __has_builtin(x) (0)
#endif /* __has_builtin */
 
#if (defined(__GNUC__) || __has_attribute(__pure__)) &&                        \
    (!defined(__clang__) /* https://bugs.llvm.org/show_bug.cgi?id=43275 */     \
     || !defined(__cplusplus) || !__has_feature(cxx_exceptions))
#define MDBX_PURE_FUNCTION __attribute__((__pure__))
#elif defined(_MSC_VER) && !defined(__clang__) && _MSC_VER >= 1920
#define MDBX_PURE_FUNCTION
#elif defined(__cplusplus) && __has_cpp_attribute(gnu::pure) &&                \
    (!defined(__clang__) || !__has_feature(cxx_exceptions))
#define MDBX_PURE_FUNCTION [[gnu::pure]]
#else
#define MDBX_PURE_FUNCTION
#endif /* MDBX_PURE_FUNCTION */
 
#if defined(__GNUC__) ||                                                       \
    (__has_attribute(__pure__) && __has_attribute(__nothrow__))
#define MDBX_NOTHROW_PURE_FUNCTION __attribute__((__pure__, __nothrow__))
#elif defined(_MSC_VER) && !defined(__clang__) && _MSC_VER >= 1920
#if __has_cpp_attribute(pure)
#define MDBX_NOTHROW_PURE_FUNCTION [[pure]]
#else
#define MDBX_NOTHROW_PURE_FUNCTION
#endif
#elif defined(__cplusplus) && __has_cpp_attribute(gnu::pure)
#if __has_cpp_attribute(gnu::nothrow)
#define MDBX_NOTHROW_PURE_FUNCTION [[gnu::pure, gnu::nothrow]]
#else
#define MDBX_NOTHROW_PURE_FUNCTION [[gnu::pure]]
#endif
#elif defined(__cplusplus) && __has_cpp_attribute(pure)
#define MDBX_NOTHROW_PURE_FUNCTION [[pure]]
#else
#define MDBX_NOTHROW_PURE_FUNCTION
#endif /* MDBX_NOTHROW_PURE_FUNCTION */
 
#if (defined(__GNUC__) || __has_attribute(__pure__)) &&                        \
    (!defined(__clang__) /* https://bugs.llvm.org/show_bug.cgi?id=43275 */     \
     || !defined(__cplusplus) || !__has_feature(cxx_exceptions))
#define MDBX_CONST_FUNCTION __attribute__((__const__))
#elif defined(_MSC_VER) && !defined(__clang__) && _MSC_VER >= 1920
#define MDBX_CONST_FUNCTION MDBX_PURE_FUNCTION
#elif defined(__cplusplus) && __has_cpp_attribute(gnu::const) &&               \
    (!defined(__clang__) || !__has_feature(cxx_exceptions))
#define MDBX_CONST_FUNCTION [[gnu::const]]
#else
#define MDBX_CONST_FUNCTION MDBX_PURE_FUNCTION
#endif /* MDBX_CONST_FUNCTION */
 
#if defined(__GNUC__) ||                                                       \
    (__has_attribute(__const__) && __has_attribute(__nothrow__))
#define MDBX_NOTHROW_CONST_FUNCTION __attribute__((__const__, __nothrow__))
#elif defined(_MSC_VER) && !defined(__clang__) && _MSC_VER >= 1920
#define MDBX_NOTHROW_CONST_FUNCTION MDBX_NOTHROW_PURE_FUNCTION
#elif defined(__cplusplus) && __has_cpp_attribute(gnu::const)
#if __has_cpp_attribute(gnu::nothrow)
#define MDBX_NOTHROW_PURE_FUNCTION [[gnu::const, gnu::nothrow]]
#else
#define MDBX_NOTHROW_PURE_FUNCTION [[gnu::const]]
#endif
#elif defined(__cplusplus) && __has_cpp_attribute(const)
#define MDBX_NOTHROW_CONST_FUNCTION [[const]]
#else
#define MDBX_NOTHROW_CONST_FUNCTION MDBX_NOTHROW_PURE_FUNCTION
#endif /* MDBX_NOTHROW_CONST_FUNCTION */
 
#ifndef MDBX_DEPRECATED /* may be predefined to avoid warnings "deprecated" */
#ifdef __deprecated
#define MDBX_DEPRECATED __deprecated
#elif defined(__GNUC__) || __has_attribute(__deprecated__)
#define MDBX_DEPRECATED __attribute__((__deprecated__))
#elif defined(_MSC_VER)
#define MDBX_DEPRECATED __declspec(deprecated)
#else
#define MDBX_DEPRECATED
#endif
#endif /* MDBX_DEPRECATED */
 
#ifndef __dll_export
#if defined(_WIN32) || defined(_WIN64) || defined(__CYGWIN__) ||               \
    defined(__MINGW__) || defined(__MINGW32__) || defined(__MINGW64__)
#if defined(__GNUC__) || __has_attribute(__dllexport__)
#define __dll_export __attribute__((__dllexport__))
#elif defined(_MSC_VER)
#define __dll_export __declspec(dllexport)
#else
#define __dll_export
#endif
#elif defined(__GNUC__) || __has_attribute(__visibility__)
#define __dll_export __attribute__((__visibility__("default")))
#else
#define __dll_export
#endif
#endif /* __dll_export */
 
#ifndef __dll_import
#if defined(_WIN32) || defined(_WIN64) || defined(__CYGWIN__) ||               \
    defined(__MINGW__) || defined(__MINGW32__) || defined(__MINGW64__)
#if defined(__GNUC__) || __has_attribute(__dllimport__)
#define __dll_import __attribute__((__dllimport__))
#elif defined(_MSC_VER)
#define __dll_import __declspec(dllimport)
#else
#define __dll_import
#endif
#else
#define __dll_import
#endif
#endif /* __dll_import */
 
#if defined(LIBMDBX_INTERNALS) && !defined(LIBMDBX_NO_EXPORTS_LEGACY_API)
#define LIBMDBX_INLINE_API(TYPE, NAME, ARGS)                                   \
  /* proto of exported which uses common impl */ LIBMDBX_API TYPE NAME ARGS;   \
  /* definition of common impl */ static __inline TYPE __inline_##NAME ARGS
#else
#define LIBMDBX_INLINE_API(TYPE, NAME, ARGS) static __inline TYPE NAME ARGS
#endif /* LIBMDBX_INLINE_API */
 
#ifndef MDBX_STRINGIFY
#define MDBX_STRINGIFY_HELPER(x) #x
#define MDBX_STRINGIFY(x) MDBX_STRINGIFY_HELPER(x)
#endif /* MDBX_STRINGIFY */
 
/*----------------------------------------------------------------------------*/
 
#ifndef __cplusplus
#ifndef bool
#define bool _Bool
#endif
#ifndef true
#define true (1)
#endif
#ifndef false
#define false (0)
#endif
#endif /* bool without __cplusplus */
 
#if !defined(DOXYGEN) && (!defined(__cpp_noexcept_function_type) ||            \
                          __cpp_noexcept_function_type < 201510L)
#define MDBX_CXX17_NOEXCEPT
#else
#define MDBX_CXX17_NOEXCEPT noexcept
#endif /* MDBX_CXX17_NOEXCEPT */
 
/* Workaround for old compilers without properly support for constexpr. */
#if !defined(__cplusplus)
#define MDBX_CXX01_CONSTEXPR __inline
#define MDBX_CXX01_CONSTEXPR_VAR const
#elif !defined(DOXYGEN) &&                                                     \
    ((__cplusplus < 201103L && defined(__cpp_constexpr) &&                     \
      __cpp_constexpr < 200704L) ||                                            \
     (defined(__LCC__) && __LCC__ < 124) ||                                    \
     (defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ < 407) &&          \
      !defined(__clang__) && !defined(__LCC__)) ||                             \
     (defined(_MSC_VER) && _MSC_VER < 1910) ||                                 \
     (defined(__clang__) && __clang_major__ < 4))
#define MDBX_CXX01_CONSTEXPR inline
#define MDBX_CXX01_CONSTEXPR_VAR const
#else
#define MDBX_CXX01_CONSTEXPR constexpr
#define MDBX_CXX01_CONSTEXPR_VAR constexpr
#endif /* MDBX_CXX01_CONSTEXPR */
 
#if !defined(__cplusplus)
#define MDBX_CXX11_CONSTEXPR __inline
#define MDBX_CXX11_CONSTEXPR_VAR const
#elif !defined(DOXYGEN) &&                                                     \
    (!defined(__cpp_constexpr) || __cpp_constexpr < 201304L ||                 \
     (defined(__LCC__) && __LCC__ < 124) ||                                    \
     (defined(__GNUC__) && __GNUC__ < 6 && !defined(__clang__) &&              \
      !defined(__LCC__)) ||                                                    \
     (defined(_MSC_VER) && _MSC_VER < 1910) ||                                 \
     (defined(__clang__) && __clang_major__ < 5))
#define MDBX_CXX11_CONSTEXPR inline
#define MDBX_CXX11_CONSTEXPR_VAR const
#else
#define MDBX_CXX11_CONSTEXPR constexpr
#define MDBX_CXX11_CONSTEXPR_VAR constexpr
#endif /* MDBX_CXX11_CONSTEXPR */
 
#if !defined(__cplusplus)
#define MDBX_CXX14_CONSTEXPR __inline
#define MDBX_CXX14_CONSTEXPR_VAR const
#elif defined(DOXYGEN) ||                                                      \
    defined(__cpp_constexpr) && __cpp_constexpr >= 201304L &&                  \
        ((defined(_MSC_VER) && _MSC_VER >= 1910) ||                            \
         (defined(__clang__) && __clang_major__ > 4) ||                        \
         (defined(__GNUC__) && __GNUC__ > 6) ||                                \
         (!defined(__GNUC__) && !defined(__clang__) && !defined(_MSC_VER)))
#define MDBX_CXX14_CONSTEXPR constexpr
#define MDBX_CXX14_CONSTEXPR_VAR constexpr
#else
#define MDBX_CXX14_CONSTEXPR inline
#define MDBX_CXX14_CONSTEXPR_VAR const
#endif /* MDBX_CXX14_CONSTEXPR */
 
#if defined(__noreturn)
#define MDBX_NORETURN __noreturn
#elif defined(_Noreturn)
#define MDBX_NORETURN _Noreturn
#elif defined(__GNUC__) || __has_attribute(__noreturn__)
#define MDBX_NORETURN __attribute__((__noreturn__))
#elif defined(_MSC_VER) && !defined(__clang__)
#define MDBX_NORETURN __declspec(noreturn)
#else
#define MDBX_NORETURN
#endif /* MDBX_NORETURN */
 
#ifndef MDBX_PRINTF_ARGS
#if defined(__GNUC__) || __has_attribute(__format__)
#if defined(__MINGW__) || defined(__MINGW32__) || defined(__MINGW64__)
#define MDBX_PRINTF_ARGS(format_index, first_arg)                              \
  __attribute__((__format__(__gnu_printf__, format_index, first_arg)))
#else
#define MDBX_PRINTF_ARGS(format_index, first_arg)                              \
  __attribute__((__format__(__printf__, format_index, first_arg)))
#endif /* MinGW */
#else
#define MDBX_PRINTF_ARGS(format_index, first_arg)
#endif
#endif /* MDBX_PRINTF_ARGS */
 
#if defined(DOXYGEN) ||                                                        \
    (defined(__cplusplus) && __cplusplus >= 201603 &&                          \
     __has_cpp_attribute(maybe_unused) &&                                      \
     __has_cpp_attribute(maybe_unused) >= 201603) ||                           \
    (!defined(__cplusplus) && defined(__STDC_VERSION__) &&                     \
     __STDC_VERSION__ > 202005L)
#define MDBX_MAYBE_UNUSED [[maybe_unused]]
#elif defined(__GNUC__) || __has_attribute(__unused__)
#define MDBX_MAYBE_UNUSED __attribute__((__unused__))
#else
#define MDBX_MAYBE_UNUSED
#endif /* MDBX_MAYBE_UNUSED */
 
#if __has_attribute(no_sanitize)
#define MDBX_NOSANITIZE_ENUM __attribute((__no_sanitize__("enum")))
#else
#define MDBX_NOSANITIZE_ENUM
#endif /* MDBX_NOSANITIZE_ENUM */
 
/* Oh, below are some songs and dances since:
 *  - C++ requires explicit definition of the necessary operators.
 *  - the proper implementation of DEFINE_ENUM_FLAG_OPERATORS for C++ required
 *    the constexpr feature which is broken in most old compilers;
 *  - DEFINE_ENUM_FLAG_OPERATORS may be defined broken as in the Windows SDK. */
#ifndef DEFINE_ENUM_FLAG_OPERATORS
 
#ifdef __cplusplus
#if !defined(__cpp_constexpr) || __cpp_constexpr < 200704L ||                  \
    (defined(__LCC__) && __LCC__ < 124) ||                                     \
    (defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ < 407) &&           \
     !defined(__clang__) && !defined(__LCC__)) ||                              \
    (defined(_MSC_VER) && _MSC_VER < 1910) ||                                  \
    (defined(__clang__) && __clang_major__ < 4)
/* The constexpr feature is not available or (may be) broken */
#define CONSTEXPR_ENUM_FLAGS_OPERATIONS 0
#else
/* C always allows these operators for enums */
#define CONSTEXPR_ENUM_FLAGS_OPERATIONS 1
#endif /* __cpp_constexpr */
 
#define DEFINE_ENUM_FLAG_OPERATORS(ENUM)                                       \
  extern "C++" {                                                               \
  MDBX_NOSANITIZE_ENUM MDBX_CXX01_CONSTEXPR ENUM operator|(ENUM a, ENUM b) {   \
    return ENUM(unsigned(a) | unsigned(b));                                    \
  }                                                                            \
  MDBX_NOSANITIZE_ENUM MDBX_CXX14_CONSTEXPR ENUM &operator|=(ENUM &a,          \
                                                             ENUM b) {         \
    return a = a | b;                                                          \
  }                                                                            \
  MDBX_NOSANITIZE_ENUM MDBX_CXX01_CONSTEXPR ENUM operator&(ENUM a, ENUM b) {   \
    return ENUM(unsigned(a) & unsigned(b));                                    \
  }                                                                            \
  MDBX_NOSANITIZE_ENUM MDBX_CXX01_CONSTEXPR ENUM operator&(ENUM a,             \
                                                           unsigned b) {       \
    return ENUM(unsigned(a) & b);                                              \
  }                                                                            \
  MDBX_NOSANITIZE_ENUM MDBX_CXX01_CONSTEXPR ENUM operator&(unsigned a,         \
                                                           ENUM b) {           \
    return ENUM(a & unsigned(b));                                              \
  }                                                                            \
  MDBX_NOSANITIZE_ENUM MDBX_CXX14_CONSTEXPR ENUM &operator&=(ENUM &a,          \
                                                             ENUM b) {         \
    return a = a & b;                                                          \
  }                                                                            \
  MDBX_NOSANITIZE_ENUM MDBX_CXX14_CONSTEXPR ENUM &operator&=(ENUM &a,          \
                                                             unsigned b) {     \
    return a = a & b;                                                          \
  }                                                                            \
  MDBX_CXX01_CONSTEXPR unsigned operator~(ENUM a) { return ~unsigned(a); }     \
  MDBX_NOSANITIZE_ENUM MDBX_CXX01_CONSTEXPR ENUM operator^(ENUM a, ENUM b) {   \
    return ENUM(unsigned(a) ^ unsigned(b));                                    \
  }                                                                            \
  MDBX_NOSANITIZE_ENUM MDBX_CXX14_CONSTEXPR ENUM &operator^=(ENUM &a,          \
                                                             ENUM b) {         \
    return a = a ^ b;                                                          \
  }                                                                            \
  }
#else /* __cplusplus */
/* nope for C since it always allows these operators for enums */
#define DEFINE_ENUM_FLAG_OPERATORS(ENUM)
#define CONSTEXPR_ENUM_FLAGS_OPERATIONS 1
#endif /* !__cplusplus */
 
#elif !defined(CONSTEXPR_ENUM_FLAGS_OPERATIONS)
 
#ifdef __cplusplus
/* DEFINE_ENUM_FLAG_OPERATORS may be defined broken as in the Windows SDK */
#define CONSTEXPR_ENUM_FLAGS_OPERATIONS 0
#else
/* C always allows these operators for enums */
#define CONSTEXPR_ENUM_FLAGS_OPERATIONS 1
#endif
 
#endif /* DEFINE_ENUM_FLAG_OPERATORS */
 
/*----------------------------------------------------------------------------*/
 
#ifdef __cplusplus
extern "C" {
#endif
 
/* MDBX version 0.11.x */
#define MDBX_VERSION_MAJOR 0
#define MDBX_VERSION_MINOR 11
 
#ifndef LIBMDBX_API
#if defined(LIBMDBX_EXPORTS)
#define LIBMDBX_API __dll_export
#elif defined(LIBMDBX_IMPORTS)
#define LIBMDBX_API __dll_import
#else
#define LIBMDBX_API
#endif
#endif /* LIBMDBX_API */
 
#ifdef __cplusplus
#if defined(__clang__) || __has_attribute(type_visibility)
#define LIBMDBX_API_TYPE LIBMDBX_API __attribute__((type_visibility("default")))
#else
#define LIBMDBX_API_TYPE LIBMDBX_API
#endif
#else
#define LIBMDBX_API_TYPE
#endif /* LIBMDBX_API_TYPE */
 
#if defined(LIBMDBX_IMPORTS)
#define LIBMDBX_VERINFO_API __dll_import
#else
#define LIBMDBX_VERINFO_API __dll_export
#endif /* LIBMDBX_VERINFO_API */
 
extern LIBMDBX_VERINFO_API const struct MDBX_version_info {
  uint8_t major;     
  uint8_t minor;     
  uint16_t release;  
  uint32_t revision; 
  struct {
    const char *datetime; 
    const char *tree;     
    const char *commit;   
    const char *describe; 
  } git;                  
  const char *sourcery;   
}  mdbx_version;
 
extern LIBMDBX_VERINFO_API const struct MDBX_build_info {
  const char *datetime; 
  const char *target;   
  const char *options;  
  const char *compiler; 
  const char *flags;    
}  mdbx_build;
 
#if (defined(_WIN32) || defined(_WIN64)) && !MDBX_BUILD_SHARED_LIBRARY
/* MDBX internally uses global and thread local storage destructors to
 * automatically (de)initialization, releasing reader lock table slots
 * and so on.
 *
 * If MDBX builded as a DLL this is done out-of-the-box by DllEntry() function,
 * which called automatically by Windows core with passing corresponding reason
 * argument.
 *
 * Otherwise, if MDBX was builded not as a DLL, some black magic
 * may be required depending of Windows version:
 *
 *  - Modern Windows versions, including Windows Vista and later, provides
 *    support for "TLS Directory" (e.g .CRT$XL[A-Z] sections in executable
 *    or dll file). In this case, MDBX capable of doing all automatically,
 *    therefore you DON'T NEED to call mdbx_module_handler()
 *    so the MDBX_MANUAL_MODULE_HANDLER defined as 0.
 *
 *  - Obsolete versions of Windows, prior to Windows Vista, REQUIRES calling
 *    mdbx_module_handler() manually from corresponding DllMain() or WinMain()
 *    of your DLL or application,
 *    so the MDBX_MANUAL_MODULE_HANDLER defined as 1.
 *
 * Therefore, building MDBX as a DLL is recommended for all version of Windows.
 * So, if you doubt, just build MDBX as the separate DLL and don't care about
 * the MDBX_MANUAL_MODULE_HANDLER. */
 
#ifndef _WIN32_WINNT
#error Non-dll build libmdbx requires target Windows version \
  to be explicitly defined via _WIN32_WINNT for properly \
  handling thread local storage destructors.
#endif /* _WIN32_WINNT */
 
#if _WIN32_WINNT >= 0x0600 /* Windows Vista */
/* As described above mdbx_module_handler() is NOT needed for Windows Vista
 * and later. */
#define MDBX_MANUAL_MODULE_HANDLER 0
#else
/* As described above mdbx_module_handler() IS REQUIRED for Windows versions
 * prior to Windows Vista. */
#define MDBX_MANUAL_MODULE_HANDLER 1
void LIBMDBX_API NTAPI mdbx_module_handler(PVOID module, DWORD reason,
                                           PVOID reserved);
#endif
 
#endif /* Windows && !DLL && MDBX_MANUAL_MODULE_HANDLER */
 
/* OPACITY STRUCTURES *********************************************************/
 
#ifndef __cplusplus
typedef struct MDBX_env MDBX_env;
#else
struct MDBX_env;
#endif
 
#ifndef __cplusplus
typedef struct MDBX_txn MDBX_txn;
#else
struct MDBX_txn;
#endif
 
typedef uint32_t MDBX_dbi;
 
#ifndef __cplusplus
typedef struct MDBX_cursor MDBX_cursor;
#else
struct MDBX_cursor;
#endif
 
#ifndef HAVE_STRUCT_IOVEC
struct iovec {
  void *iov_base; 
  size_t iov_len; 
};
#define HAVE_STRUCT_IOVEC
#endif /* HAVE_STRUCT_IOVEC */
 
#if defined(__sun) || defined(__SVR4) || defined(__svr4__)
/* The `iov_len` is signed on Sun/Solaris.
 * So define custom MDBX_val to avoid a lot of warnings. */
struct MDBX_val {
  void *iov_base; 
  size_t iov_len; 
};
#ifndef __cplusplus
typedef struct MDBX_val MDBX_val;
#endif
#else  /* SunOS */
typedef struct iovec MDBX_val;
#endif /* ! SunOS */
 
enum MDBX_constants {
  MDBX_MAX_DBI = UINT32_C(32765),
 
  MDBX_MAXDATASIZE = UINT32_C(0x7fff0000),
 
  MDBX_MIN_PAGESIZE = 256,
 
  MDBX_MAX_PAGESIZE = 65536,
};
 
/* THE FILES *******************************************************************
 * At the file system level, the environment corresponds to a pair of files. */
 
#define MDBX_LOCKNAME "/mdbx.lck"
 
#define MDBX_DATANAME "/mdbx.dat"
 
#define MDBX_LOCK_SUFFIX "-lck"
 
/* DEBUG & LOGGING ************************************************************/
 
enum MDBX_log_level_t {
  MDBX_LOG_FATAL = 0,
 
  MDBX_LOG_ERROR = 1,
 
  MDBX_LOG_WARN = 2,
 
  MDBX_LOG_NOTICE = 3,
 
  MDBX_LOG_VERBOSE = 4,
 
  MDBX_LOG_DEBUG = 5,
 
  MDBX_LOG_TRACE = 6,
 
  MDBX_LOG_EXTRA = 7,
 
#ifdef ENABLE_UBSAN
  MDBX_LOG_MAX = 7 /* avoid UBSAN false-positive trap by a tests */,
#endif /* ENABLE_UBSAN */
 
  MDBX_LOG_DONTCHANGE = -1
};
#ifndef __cplusplus
typedef enum MDBX_log_level_t MDBX_log_level_t;
#endif
 
enum MDBX_debug_flags_t {
  MDBX_DBG_NONE = 0,
 
  MDBX_DBG_ASSERT = 1,
 
  MDBX_DBG_AUDIT = 2,
 
  MDBX_DBG_JITTER = 4,
 
  MDBX_DBG_DUMP = 8,
 
  MDBX_DBG_LEGACY_MULTIOPEN = 16,
 
  MDBX_DBG_LEGACY_OVERLAP = 32,
 
  MDBX_DBG_DONT_UPGRADE = 64,
 
#ifdef ENABLE_UBSAN
  MDBX_DBG_MAX = ((unsigned)MDBX_LOG_MAX) << 16 |
                 127 /* avoid UBSAN false-positive trap by a tests */,
#endif /* ENABLE_UBSAN */
 
  MDBX_DBG_DONTCHANGE = -1
};
#ifndef __cplusplus
typedef enum MDBX_debug_flags_t MDBX_debug_flags_t;
#else
DEFINE_ENUM_FLAG_OPERATORS(MDBX_debug_flags_t)
#endif
 
typedef void MDBX_debug_func(MDBX_log_level_t loglevel, const char *function,
                             int line, const char *fmt,
                             va_list args) MDBX_CXX17_NOEXCEPT;
 
#define MDBX_LOGGER_DONTCHANGE ((MDBX_debug_func *)(intptr_t)-1)
 
LIBMDBX_API int mdbx_setup_debug(MDBX_log_level_t log_level,
                                 MDBX_debug_flags_t debug_flags,
                                 MDBX_debug_func *logger);
 
typedef void MDBX_assert_func(const MDBX_env *env, const char *msg,
                              const char *function,
                              unsigned line) MDBX_CXX17_NOEXCEPT;
 
LIBMDBX_API int mdbx_env_set_assert(MDBX_env *env, MDBX_assert_func *func);
 
LIBMDBX_API const char *mdbx_dump_val(const MDBX_val *key, char *const buf,
                                      const size_t bufsize);
 
LIBMDBX_API void mdbx_panic(const char *fmt, ...) MDBX_PRINTF_ARGS(1, 2);
 
enum MDBX_env_flags_t {
  MDBX_ENV_DEFAULTS = 0,
 
  MDBX_NOSUBDIR = UINT32_C(0x4000),
 
  MDBX_RDONLY = UINT32_C(0x20000),
 
  MDBX_EXCLUSIVE = UINT32_C(0x400000),
 
  MDBX_ACCEDE = UINT32_C(0x40000000),
 
  MDBX_WRITEMAP = UINT32_C(0x80000),
 
  MDBX_NOTLS = UINT32_C(0x200000),
 
  MDBX_NORDAHEAD = UINT32_C(0x800000),
 
  MDBX_NOMEMINIT = UINT32_C(0x1000000),
 
  MDBX_COALESCE = UINT32_C(0x2000000),
 
  MDBX_LIFORECLAIM = UINT32_C(0x4000000),
 
  MDBX_PAGEPERTURB = UINT32_C(0x8000000),
 
  /* SYNC MODES****************************************************************/
  MDBX_SYNC_DURABLE = 0,
 
  MDBX_NOMETASYNC = UINT32_C(0x40000),
 
  MDBX_SAFE_NOSYNC = UINT32_C(0x10000),
 
  MDBX_MAPASYNC = MDBX_SAFE_NOSYNC,
 
  MDBX_UTTERLY_NOSYNC = MDBX_SAFE_NOSYNC | UINT32_C(0x100000),
 
};
#ifndef __cplusplus
 
typedef enum MDBX_env_flags_t MDBX_env_flags_t;
#else
DEFINE_ENUM_FLAG_OPERATORS(MDBX_env_flags_t)
#endif
 
enum MDBX_txn_flags_t {
  MDBX_TXN_READWRITE = 0,
 
  MDBX_TXN_RDONLY = MDBX_RDONLY,
 
#if CONSTEXPR_ENUM_FLAGS_OPERATIONS || defined(DOXYGEN)
  MDBX_TXN_RDONLY_PREPARE = MDBX_RDONLY | MDBX_NOMEMINIT,
#else
  MDBX_TXN_RDONLY_PREPARE = uint32_t(MDBX_RDONLY) | uint32_t(MDBX_NOMEMINIT),
#endif
 
  MDBX_TXN_TRY = UINT32_C(0x10000000),
 
  MDBX_TXN_NOMETASYNC = MDBX_NOMETASYNC,
 
  MDBX_TXN_NOSYNC = MDBX_SAFE_NOSYNC
};
#ifndef __cplusplus
typedef enum MDBX_txn_flags_t MDBX_txn_flags_t;
#else
DEFINE_ENUM_FLAG_OPERATORS(MDBX_txn_flags_t)
#endif
 
enum MDBX_db_flags_t {
  MDBX_DB_DEFAULTS = 0,
 
  MDBX_REVERSEKEY = UINT32_C(0x02),
 
  MDBX_DUPSORT = UINT32_C(0x04),
 
  MDBX_INTEGERKEY = UINT32_C(0x08),
 
  MDBX_DUPFIXED = UINT32_C(0x10),
 
  MDBX_INTEGERDUP = UINT32_C(0x20),
 
  MDBX_REVERSEDUP = UINT32_C(0x40),
 
  MDBX_CREATE = UINT32_C(0x40000),
 
  MDBX_DB_ACCEDE = MDBX_ACCEDE
};
#ifndef __cplusplus
 
typedef enum MDBX_db_flags_t MDBX_db_flags_t;
#else
DEFINE_ENUM_FLAG_OPERATORS(MDBX_db_flags_t)
#endif
 
enum MDBX_put_flags_t {
  MDBX_UPSERT = 0,
 
  MDBX_NOOVERWRITE = UINT32_C(0x10),
 
  MDBX_NODUPDATA = UINT32_C(0x20),
 
  MDBX_CURRENT = UINT32_C(0x40),
 
  MDBX_ALLDUPS = UINT32_C(0x80),
 
  MDBX_RESERVE = UINT32_C(0x10000),
 
  MDBX_APPEND = UINT32_C(0x20000),
 
  MDBX_APPENDDUP = UINT32_C(0x40000),
 
  MDBX_MULTIPLE = UINT32_C(0x80000)
};
#ifndef __cplusplus
 
typedef enum MDBX_put_flags_t MDBX_put_flags_t;
#else
DEFINE_ENUM_FLAG_OPERATORS(MDBX_put_flags_t)
#endif
 
enum MDBX_copy_flags_t {
  MDBX_CP_DEFAULTS = 0,
 
  MDBX_CP_COMPACT = 1u,
 
  MDBX_CP_FORCE_DYNAMIC_SIZE = 2u
};
#ifndef __cplusplus
 
typedef enum MDBX_copy_flags_t MDBX_copy_flags_t;
#else
DEFINE_ENUM_FLAG_OPERATORS(MDBX_copy_flags_t)
#endif
 
enum MDBX_cursor_op {
  MDBX_FIRST,
 
  MDBX_FIRST_DUP,
 
  MDBX_GET_BOTH,
 
  MDBX_GET_BOTH_RANGE,
 
  MDBX_GET_CURRENT,
 
  MDBX_GET_MULTIPLE,
 
  MDBX_LAST,
 
  MDBX_LAST_DUP,
 
  MDBX_NEXT,
 
  MDBX_NEXT_DUP,
 
  MDBX_NEXT_MULTIPLE,
 
  MDBX_NEXT_NODUP,
 
  MDBX_PREV,
 
  MDBX_PREV_DUP,
 
  MDBX_PREV_NODUP,
 
  MDBX_SET,
 
  MDBX_SET_KEY,
 
  MDBX_SET_RANGE,
 
  MDBX_PREV_MULTIPLE,
 
  MDBX_SET_LOWERBOUND,
 
  MDBX_SET_UPPERBOUND
};
#ifndef __cplusplus
 
typedef enum MDBX_cursor_op MDBX_cursor_op;
#endif
 
enum MDBX_error_t {
  MDBX_SUCCESS = 0,
 
  MDBX_RESULT_FALSE = MDBX_SUCCESS,
 
  MDBX_RESULT_TRUE = -1,
 
  MDBX_KEYEXIST = -30799,
 
  MDBX_FIRST_LMDB_ERRCODE = MDBX_KEYEXIST,
 
  MDBX_NOTFOUND = -30798,
 
  MDBX_PAGE_NOTFOUND = -30797,
 
  MDBX_CORRUPTED = -30796,
 
  MDBX_PANIC = -30795,
 
  MDBX_VERSION_MISMATCH = -30794,
 
  MDBX_INVALID = -30793,
 
  MDBX_MAP_FULL = -30792,
 
  MDBX_DBS_FULL = -30791,
 
  MDBX_READERS_FULL = -30790,
 
  MDBX_TXN_FULL = -30788,
 
  MDBX_CURSOR_FULL = -30787,
 
  MDBX_PAGE_FULL = -30786,
 
  MDBX_UNABLE_EXTEND_MAPSIZE = -30785,
 
  MDBX_INCOMPATIBLE = -30784,
 
  MDBX_BAD_RSLOT = -30783,
 
  MDBX_BAD_TXN = -30782,
 
  MDBX_BAD_VALSIZE = -30781,
 
  MDBX_BAD_DBI = -30780,
 
  MDBX_PROBLEM = -30779,
 
  MDBX_LAST_LMDB_ERRCODE = MDBX_PROBLEM,
 
  MDBX_BUSY = -30778,
 
  MDBX_FIRST_ADDED_ERRCODE = MDBX_BUSY,
 
  MDBX_EMULTIVAL = -30421,
 
  MDBX_EBADSIGN = -30420,
 
  MDBX_WANNA_RECOVERY = -30419,
 
  MDBX_EKEYMISMATCH = -30418,
 
  MDBX_TOO_LARGE = -30417,
 
  MDBX_THREAD_MISMATCH = -30416,
 
  MDBX_TXN_OVERLAPPING = -30415,
 
  /* The last of MDBX-added error codes */
  MDBX_LAST_ADDED_ERRCODE = MDBX_TXN_OVERLAPPING,
 
#if defined(_WIN32) || defined(_WIN64)
  MDBX_ENODATA = ERROR_HANDLE_EOF,
  MDBX_EINVAL = ERROR_INVALID_PARAMETER,
  MDBX_EACCESS = ERROR_ACCESS_DENIED,
  MDBX_ENOMEM = ERROR_OUTOFMEMORY,
  MDBX_EROFS = ERROR_FILE_READ_ONLY,
  MDBX_ENOSYS = ERROR_NOT_SUPPORTED,
  MDBX_EIO = ERROR_WRITE_FAULT,
  MDBX_EPERM = ERROR_INVALID_FUNCTION,
  MDBX_EINTR = ERROR_CANCELLED,
  MDBX_ENOFILE = ERROR_FILE_NOT_FOUND,
  MDBX_EREMOTE = ERROR_REMOTE_STORAGE_MEDIA_ERROR
#else /* Windows */
#ifdef ENODATA
  MDBX_ENODATA = ENODATA,
#else
  MDBX_ENODATA = 9919 /* for compatibility with LLVM's C++ libraries/headers */,
#endif /* ENODATA */
  MDBX_EINVAL = EINVAL,
  MDBX_EACCESS = EACCES,
  MDBX_ENOMEM = ENOMEM,
  MDBX_EROFS = EROFS,
  MDBX_ENOSYS = ENOSYS,
  MDBX_EIO = EIO,
  MDBX_EPERM = EPERM,
  MDBX_EINTR = EINTR,
  MDBX_ENOFILE = ENOENT,
  MDBX_EREMOTE = ENOTBLK
#endif /* !Windows */
};
#ifndef __cplusplus
 
typedef enum MDBX_error_t MDBX_error_t;
#endif
 
MDBX_DEPRECATED static __inline int MDBX_MAP_RESIZED_is_deprecated() {
  return MDBX_UNABLE_EXTEND_MAPSIZE;
}
#define MDBX_MAP_RESIZED MDBX_MAP_RESIZED_is_deprecated()
 
LIBMDBX_API const char *mdbx_strerror(int errnum);
 
LIBMDBX_API const char *mdbx_strerror_r(int errnum, char *buf, size_t buflen);
MDBX_NOTHROW_PURE_FUNCTION LIBMDBX_API const char *mdbx_liberr2str(int errnum);
 
#if defined(_WIN32) || defined(_WIN64) || defined(DOXYGEN)
 
LIBMDBX_API const char *mdbx_strerror_ANSI2OEM(int errnum);
 
LIBMDBX_API const char *mdbx_strerror_r_ANSI2OEM(int errnum, char *buf,
                                                 size_t buflen);
#endif /* Bit of Windows' madness */
 
LIBMDBX_API int mdbx_env_create(MDBX_env **penv);
 
enum MDBX_option_t {
  MDBX_opt_max_db,
 
  MDBX_opt_max_readers,
 
  MDBX_opt_sync_bytes,
 
  MDBX_opt_sync_period,
 
  MDBX_opt_rp_augment_limit,
 
  MDBX_opt_loose_limit,
 
  MDBX_opt_dp_reserve_limit,
 
  MDBX_opt_txn_dp_limit,
 
  MDBX_opt_txn_dp_initial,
 
  MDBX_opt_spill_max_denominator,
 
  MDBX_opt_spill_min_denominator,
 
  MDBX_opt_spill_parent4child_denominator,
 
  MDBX_opt_merge_threshold_16dot16_percent,
};
#ifndef __cplusplus
 
typedef enum MDBX_option_t MDBX_option_t;
#endif
 
LIBMDBX_API int mdbx_env_set_option(MDBX_env *env, const MDBX_option_t option,
                                    uint64_t value);
 
LIBMDBX_API int mdbx_env_get_option(const MDBX_env *env,
                                    const MDBX_option_t option,
                                    uint64_t *pvalue);
 
LIBMDBX_API int mdbx_env_open(MDBX_env *env, const char *pathname,
                              MDBX_env_flags_t flags, mdbx_mode_t mode);
 
enum MDBX_env_delete_mode_t {
  MDBX_ENV_JUST_DELETE = 0,
  MDBX_ENV_ENSURE_UNUSED = 1,
  MDBX_ENV_WAIT_FOR_UNUSED = 2,
};
#ifndef __cplusplus
 
typedef enum MDBX_env_delete_mode_t MDBX_env_delete_mode_t;
#endif
 
LIBMDBX_API int mdbx_env_delete(const char *pathname,
                                MDBX_env_delete_mode_t mode);
 
LIBMDBX_API int mdbx_env_copy(MDBX_env *env, const char *dest,
                              MDBX_copy_flags_t flags);
 
LIBMDBX_API int mdbx_env_copy2fd(MDBX_env *env, mdbx_filehandle_t fd,
                                 MDBX_copy_flags_t flags);
 
struct MDBX_stat {
  uint32_t ms_psize; 
  uint32_t ms_depth; 
  uint64_t ms_branch_pages;   
  uint64_t ms_leaf_pages;     
  uint64_t ms_overflow_pages; 
  uint64_t ms_entries;        
  uint64_t ms_mod_txnid; 
};
#ifndef __cplusplus
 
typedef struct MDBX_stat MDBX_stat;
#endif
 
LIBMDBX_API int mdbx_env_stat_ex(const MDBX_env *env, const MDBX_txn *txn,
                                 MDBX_stat *stat, size_t bytes);
 
MDBX_DEPRECATED inline int mdbx_env_stat(const MDBX_env *env, MDBX_stat *stat,
                                    size_t bytes) {
  return mdbx_env_stat_ex(env, NULL, stat, bytes);
}
 
struct MDBX_envinfo {
  struct {
    uint64_t lower;   
    uint64_t upper;   
    uint64_t current; 
    uint64_t shrink;  
    uint64_t grow;    
  } mi_geo;
  uint64_t mi_mapsize;             
  uint64_t mi_last_pgno;           
  uint64_t mi_recent_txnid;        
  uint64_t mi_latter_reader_txnid; 
  uint64_t mi_self_latter_reader_txnid; 
  uint64_t mi_meta0_txnid, mi_meta0_sign;
  uint64_t mi_meta1_txnid, mi_meta1_sign;
  uint64_t mi_meta2_txnid, mi_meta2_sign;
  uint32_t mi_maxreaders;   
  uint32_t mi_numreaders;   
  uint32_t mi_dxb_pagesize; 
  uint32_t mi_sys_pagesize; 
  struct {
    struct {
      uint64_t x, y;
    } current, meta0, meta1, meta2;
  } mi_bootid;
 
  uint64_t mi_unsync_volume;
  uint64_t mi_autosync_threshold;
  uint32_t mi_since_sync_seconds16dot16;
  uint32_t mi_autosync_period_seconds16dot16;
  uint32_t mi_since_reader_check_seconds16dot16;
  uint32_t mi_mode;
 
  struct {
    uint64_t newly;   
    uint64_t cow;     
    uint64_t clone;   
    uint64_t split;   
    uint64_t merge;   
    uint64_t spill;   
    uint64_t unspill; 
    uint64_t wops;    
  } mi_pgop_stat;
};
#ifndef __cplusplus
 
typedef struct MDBX_envinfo MDBX_envinfo;
#endif
 
LIBMDBX_API int mdbx_env_info_ex(const MDBX_env *env, const MDBX_txn *txn,
                                 MDBX_envinfo *info, size_t bytes);
MDBX_DEPRECATED inline int mdbx_env_info(const MDBX_env *env, MDBX_envinfo *info,
                                    size_t bytes) {
  return mdbx_env_info_ex(env, NULL, info, bytes);
}
 
LIBMDBX_API int mdbx_env_sync_ex(MDBX_env *env, bool force, bool nonblock);
 
inline int mdbx_env_sync(MDBX_env * env) {
  return mdbx_env_sync_ex(env, true, false);
}
 
inline int mdbx_env_sync_poll(MDBX_env * env) {
  return mdbx_env_sync_ex(env, false, true);
}
 
inline int mdbx_env_set_syncbytes(MDBX_env * env, size_t threshold) {
  return mdbx_env_set_option(env, MDBX_opt_sync_bytes, threshold);
}
 
inline int mdbx_env_get_syncbytes(const MDBX_env *env, size_t *threshold) {
  int rc = MDBX_EINVAL;
  if (threshold) {
    uint64_t proxy = 0;
    rc = mdbx_env_get_option(env, MDBX_opt_sync_bytes, &proxy);
#ifdef assert
    assert(proxy <= SIZE_MAX);
#endif /* assert */
    *threshold = (size_t)proxy;
  }
  return rc;
}
 
inline int mdbx_env_set_syncperiod(MDBX_env * env, unsigned seconds_16dot16) {
  return mdbx_env_set_option(env, MDBX_opt_sync_period, seconds_16dot16);
}
 
inline int mdbx_env_get_syncperiod(const MDBX_env *env, unsigned *period_seconds_16dot16) {
  int rc = MDBX_EINVAL;
  if (period_seconds_16dot16) {
    uint64_t proxy = 0;
    rc = mdbx_env_get_option(env, MDBX_opt_sync_period, &proxy);
#ifdef assert
    assert(proxy <= UINT32_MAX);
#endif /* assert */
    *period_seconds_16dot16 = (unsigned)proxy;
  }
  return rc;
}
 
LIBMDBX_API int mdbx_env_close_ex(MDBX_env *env, bool dont_sync);
 
inline int mdbx_env_close(MDBX_env * env) {
  return mdbx_env_close_ex(env, false);
}
 
LIBMDBX_API int mdbx_env_set_flags(MDBX_env *env, MDBX_env_flags_t flags,
                                   bool onoff);
 
LIBMDBX_API int mdbx_env_get_flags(const MDBX_env *env, unsigned *flags);
 
LIBMDBX_API int mdbx_env_get_path(const MDBX_env *env, const char **dest);
 
LIBMDBX_API int mdbx_env_get_fd(const MDBX_env *env, mdbx_filehandle_t *fd);
 
LIBMDBX_API int mdbx_env_set_geometry(MDBX_env *env, intptr_t size_lower,
                                      intptr_t size_now, intptr_t size_upper,
                                      intptr_t growth_step,
                                      intptr_t shrink_threshold,
                                      intptr_t pagesize);
 
MDBX_DEPRECATED inline int mdbx_env_set_mapsize(MDBX_env * env, size_t size) {
  return mdbx_env_set_geometry(env, size, size, size, -1, -1, -1);
}
 
LIBMDBX_API int mdbx_is_readahead_reasonable(size_t volume,
                                             intptr_t redundancy);
 
MDBX_NOTHROW_CONST_FUNCTION inline intptr_t mdbx_limits_pgsize_min(void) {
  return MDBX_MIN_PAGESIZE;
}
 
MDBX_NOTHROW_CONST_FUNCTION inline intptr_t mdbx_limits_pgsize_max(void) {
  return MDBX_MAX_PAGESIZE;
}
 
MDBX_NOTHROW_CONST_FUNCTION LIBMDBX_API intptr_t
mdbx_limits_dbsize_min(intptr_t pagesize);
 
MDBX_NOTHROW_CONST_FUNCTION LIBMDBX_API intptr_t
mdbx_limits_dbsize_max(intptr_t pagesize);
 
MDBX_NOTHROW_CONST_FUNCTION LIBMDBX_API intptr_t
mdbx_limits_keysize_max(intptr_t pagesize, MDBX_db_flags_t flags);
 
MDBX_NOTHROW_CONST_FUNCTION LIBMDBX_API intptr_t
mdbx_limits_valsize_max(intptr_t pagesize, MDBX_db_flags_t flags);
 
MDBX_NOTHROW_CONST_FUNCTION LIBMDBX_API intptr_t
mdbx_limits_txnsize_max(intptr_t pagesize);
 
inline int mdbx_env_set_maxreaders(MDBX_env * env, unsigned readers) {
  return mdbx_env_set_option(env, MDBX_opt_max_readers, readers);
}
 
inline int mdbx_env_get_maxreaders(const MDBX_env *env, unsigned *readers) {
  int rc = MDBX_EINVAL;
  if (readers) {
    uint64_t proxy = 0;
    rc = mdbx_env_get_option(env, MDBX_opt_max_readers, &proxy);
    *readers = (unsigned)proxy;
  }
  return rc;
}
 
inline int mdbx_env_set_maxdbs(MDBX_env * env, MDBX_dbi dbs) {
  return mdbx_env_set_option(env, MDBX_opt_max_db, dbs);
}
 
inline int mdbx_env_get_maxdbs(const MDBX_env *env, MDBX_dbi *dbs) {
  int rc = MDBX_EINVAL;
  if (dbs) {
    uint64_t proxy = 0;
    rc = mdbx_env_get_option(env, MDBX_opt_max_db, &proxy);
    *dbs = (MDBX_dbi)proxy;
  }
  return rc;
}
 
MDBX_NOTHROW_PURE_FUNCTION LIBMDBX_API size_t mdbx_default_pagesize(void);
 
LIBMDBX_API int mdbx_get_sysraminfo(intptr_t *page_size, intptr_t *total_pages,
                                    intptr_t *avail_pages);
 
MDBX_NOTHROW_PURE_FUNCTION LIBMDBX_API int
mdbx_env_get_maxkeysize_ex(const MDBX_env *env, MDBX_db_flags_t flags);
 
MDBX_NOTHROW_PURE_FUNCTION LIBMDBX_API int
mdbx_env_get_maxvalsize_ex(const MDBX_env *env, MDBX_db_flags_t flags);
 
MDBX_NOTHROW_PURE_FUNCTION MDBX_DEPRECATED LIBMDBX_API int
mdbx_env_get_maxkeysize(const MDBX_env *env);
 
LIBMDBX_API int mdbx_env_set_userctx(MDBX_env *env, void *ctx);
 
MDBX_NOTHROW_PURE_FUNCTION LIBMDBX_API void *
mdbx_env_get_userctx(const MDBX_env *env);
 
LIBMDBX_API int mdbx_txn_begin_ex(MDBX_env *env, MDBX_txn *parent,
                                  MDBX_txn_flags_t flags, MDBX_txn **txn,
                                  void *context);
 
inline int mdbx_txn_begin(MDBX_env * env, MDBX_txn *parent, MDBX_txn_flags_t flags,
                    MDBX_txn **txn) {
  return mdbx_txn_begin_ex(env, parent, flags, txn, NULL);
}
 
LIBMDBX_API int mdbx_txn_set_userctx(MDBX_txn *txn, void *ctx);
 
MDBX_NOTHROW_PURE_FUNCTION LIBMDBX_API void *
mdbx_txn_get_userctx(const MDBX_txn *txn);
 
struct MDBX_txn_info {
  uint64_t txn_id;
 
  uint64_t txn_reader_lag;
 
  uint64_t txn_space_used;
 
  uint64_t txn_space_limit_soft;
 
  uint64_t txn_space_limit_hard;
 
  uint64_t txn_space_retired;
 
  uint64_t txn_space_leftover;
 
  uint64_t txn_space_dirty;
};
#ifndef __cplusplus
 
typedef struct MDBX_txn_info MDBX_txn_info;
#endif
 
LIBMDBX_API int mdbx_txn_info(const MDBX_txn *txn, MDBX_txn_info *info,
                              bool scan_rlt);
 
MDBX_NOTHROW_PURE_FUNCTION LIBMDBX_API MDBX_env *
mdbx_txn_env(const MDBX_txn *txn);
 
MDBX_NOTHROW_PURE_FUNCTION LIBMDBX_API int mdbx_txn_flags(const MDBX_txn *txn);
 
MDBX_NOTHROW_PURE_FUNCTION LIBMDBX_API uint64_t
mdbx_txn_id(const MDBX_txn *txn);
 
struct MDBX_commit_latency {
  uint32_t preparation;
  uint32_t gc;
  uint32_t audit;
  uint32_t write;
  uint32_t sync;
  uint32_t ending;
  uint32_t whole;
};
#ifndef __cplusplus
 
typedef struct MDBX_commit_latency MDBX_commit_latency;
#endif
 
LIBMDBX_API int mdbx_txn_commit_ex(MDBX_txn *txn, MDBX_commit_latency *latency);
 
inline int mdbx_txn_commit(MDBX_txn * txn) {
  return mdbx_txn_commit_ex(txn, NULL);
}
 
LIBMDBX_API int mdbx_txn_abort(MDBX_txn *txn);
 
LIBMDBX_API int mdbx_txn_break(MDBX_txn *txn);
 
LIBMDBX_API int mdbx_txn_reset(MDBX_txn *txn);
 
LIBMDBX_API int mdbx_txn_renew(MDBX_txn *txn);
 
struct MDBX_canary {
  uint64_t x, y, z, v;
};
#ifndef __cplusplus
 
typedef struct MDBX_canary MDBX_canary;
#endif
 
LIBMDBX_API int mdbx_canary_put(MDBX_txn *txn, const MDBX_canary *canary);
 
LIBMDBX_API int mdbx_canary_get(const MDBX_txn *txn, MDBX_canary *canary);
 
typedef int(MDBX_cmp_func)(const MDBX_val *a,
                           const MDBX_val *b) MDBX_CXX17_NOEXCEPT;
 
LIBMDBX_API int mdbx_dbi_open(MDBX_txn *txn, const char *name,
                              MDBX_db_flags_t flags, MDBX_dbi *dbi);
 
MDBX_DEPRECATED LIBMDBX_API int
mdbx_dbi_open_ex(MDBX_txn *txn, const char *name, MDBX_db_flags_t flags,
                 MDBX_dbi *dbi, MDBX_cmp_func *keycmp, MDBX_cmp_func *datacmp);
 
MDBX_NOTHROW_CONST_FUNCTION LIBMDBX_API uint64_t
mdbx_key_from_jsonInteger(const int64_t json_integer);
 
MDBX_NOTHROW_CONST_FUNCTION LIBMDBX_API uint64_t
mdbx_key_from_double(const double ieee754_64bit);
 
MDBX_NOTHROW_PURE_FUNCTION LIBMDBX_API uint64_t
mdbx_key_from_ptrdouble(const double *const ieee754_64bit);
 
MDBX_NOTHROW_CONST_FUNCTION LIBMDBX_API uint32_t
mdbx_key_from_float(const float ieee754_32bit);
 
MDBX_NOTHROW_PURE_FUNCTION LIBMDBX_API uint32_t
mdbx_key_from_ptrfloat(const float *const ieee754_32bit);
 
MDBX_NOTHROW_CONST_FUNCTION inline uint64_t mdbx_key_from_int64(const int64_t i64) {
  return UINT64_C(0x8000000000000000) + i64;
}
 
MDBX_NOTHROW_CONST_FUNCTION inline uint32_t mdbx_key_from_int32(const int32_t i32) {
  return UINT32_C(0x80000000) + i32;
}
MDBX_NOTHROW_PURE_FUNCTION LIBMDBX_API int64_t
mdbx_jsonInteger_from_key(const MDBX_val);
 
MDBX_NOTHROW_PURE_FUNCTION LIBMDBX_API double
mdbx_double_from_key(const MDBX_val);
 
MDBX_NOTHROW_PURE_FUNCTION LIBMDBX_API float
mdbx_float_from_key(const MDBX_val);
 
MDBX_NOTHROW_PURE_FUNCTION LIBMDBX_API int32_t
mdbx_int32_from_key(const MDBX_val);
 
MDBX_NOTHROW_PURE_FUNCTION LIBMDBX_API int64_t
mdbx_int64_from_key(const MDBX_val);
LIBMDBX_API int mdbx_dbi_stat(MDBX_txn *txn, MDBX_dbi dbi, MDBX_stat *stat,
                              size_t bytes);
 
LIBMDBX_API int mdbx_dbi_dupsort_depthmask(MDBX_txn *txn, MDBX_dbi dbi,
                                           uint32_t *mask);
 
enum MDBX_dbi_state_t {
  MDBX_DBI_DIRTY = 0x01,
  MDBX_DBI_STALE = 0x02,
  MDBX_DBI_FRESH = 0x04,
  MDBX_DBI_CREAT = 0x08,
};
#ifndef __cplusplus
 
typedef enum MDBX_dbi_state_t MDBX_dbi_state_t;
#else
DEFINE_ENUM_FLAG_OPERATORS(MDBX_dbi_state_t)
#endif
 
LIBMDBX_API int mdbx_dbi_flags_ex(MDBX_txn *txn, MDBX_dbi dbi, unsigned *flags,
                                  unsigned *state);
inline int mdbx_dbi_flags(MDBX_txn * txn, MDBX_dbi dbi, unsigned *flags) {
  unsigned state;
  return mdbx_dbi_flags_ex(txn, dbi, flags, &state);
}
 
LIBMDBX_API int mdbx_dbi_close(MDBX_env *env, MDBX_dbi dbi);
 
LIBMDBX_API int mdbx_drop(MDBX_txn *txn, MDBX_dbi dbi, bool del);
 
LIBMDBX_API int mdbx_get(MDBX_txn *txn, MDBX_dbi dbi, const MDBX_val *key,
                         MDBX_val *data);
 
LIBMDBX_API int mdbx_get_ex(MDBX_txn *txn, MDBX_dbi dbi, MDBX_val *key,
                            MDBX_val *data, size_t *values_count);
 
LIBMDBX_API int mdbx_get_equal_or_great(MDBX_txn *txn, MDBX_dbi dbi,
                                        MDBX_val *key, MDBX_val *data);
 
LIBMDBX_API int mdbx_put(MDBX_txn *txn, MDBX_dbi dbi, const MDBX_val *key,
                         MDBX_val *data, MDBX_put_flags_t flags);
 
LIBMDBX_API int mdbx_replace(MDBX_txn *txn, MDBX_dbi dbi, const MDBX_val *key,
                             MDBX_val *new_data, MDBX_val *old_data,
                             MDBX_put_flags_t flags);
 
typedef int (*MDBX_preserve_func)(void *context, MDBX_val *target,
                                  const void *src, size_t bytes);
LIBMDBX_API int mdbx_replace_ex(MDBX_txn *txn, MDBX_dbi dbi,
                                const MDBX_val *key, MDBX_val *new_data,
                                MDBX_val *old_data, MDBX_put_flags_t flags,
                                MDBX_preserve_func preserver,
                                void *preserver_context);
 
LIBMDBX_API int mdbx_del(MDBX_txn *txn, MDBX_dbi dbi, const MDBX_val *key,
                         const MDBX_val *data);
 
LIBMDBX_API MDBX_cursor *mdbx_cursor_create(void *context);
 
LIBMDBX_API int mdbx_cursor_set_userctx(MDBX_cursor *cursor, void *ctx);
 
MDBX_NOTHROW_PURE_FUNCTION LIBMDBX_API void *
mdbx_cursor_get_userctx(const MDBX_cursor *cursor);
 
LIBMDBX_API int mdbx_cursor_bind(MDBX_txn *txn, MDBX_cursor *cursor,
                                 MDBX_dbi dbi);
 
LIBMDBX_API int mdbx_cursor_open(MDBX_txn *txn, MDBX_dbi dbi,
                                 MDBX_cursor **cursor);
 
LIBMDBX_API void mdbx_cursor_close(MDBX_cursor *cursor);
 
LIBMDBX_API int mdbx_cursor_renew(MDBX_txn *txn, MDBX_cursor *cursor);
 
MDBX_NOTHROW_PURE_FUNCTION LIBMDBX_API MDBX_txn *
mdbx_cursor_txn(const MDBX_cursor *cursor);
 
LIBMDBX_API MDBX_dbi mdbx_cursor_dbi(const MDBX_cursor *cursor);
 
LIBMDBX_API int mdbx_cursor_copy(const MDBX_cursor *src, MDBX_cursor *dest);
 
LIBMDBX_API int mdbx_cursor_get(MDBX_cursor *cursor, MDBX_val *key,
                                MDBX_val *data, MDBX_cursor_op op);
 
LIBMDBX_API int mdbx_cursor_get_batch(MDBX_cursor *cursor, size_t *count,
                                      MDBX_val *pairs, size_t limit,
                                      MDBX_cursor_op op);
 
LIBMDBX_API int mdbx_cursor_put(MDBX_cursor *cursor, const MDBX_val *key,
                                MDBX_val *data, MDBX_put_flags_t flags);
 
LIBMDBX_API int mdbx_cursor_del(MDBX_cursor *cursor, MDBX_put_flags_t flags);
 
LIBMDBX_API int mdbx_cursor_count(const MDBX_cursor *cursor, size_t *pcount);
 
MDBX_NOTHROW_PURE_FUNCTION LIBMDBX_API int
mdbx_cursor_eof(const MDBX_cursor *cursor);
 
MDBX_NOTHROW_PURE_FUNCTION LIBMDBX_API int
mdbx_cursor_on_first(const MDBX_cursor *cursor);
 
MDBX_NOTHROW_PURE_FUNCTION LIBMDBX_API int
mdbx_cursor_on_last(const MDBX_cursor *cursor);
 
LIBMDBX_API int mdbx_estimate_distance(const MDBX_cursor *first,
                                       const MDBX_cursor *last,
                                       ptrdiff_t *distance_items);
 
LIBMDBX_API int mdbx_estimate_move(const MDBX_cursor *cursor, MDBX_val *key,
                                   MDBX_val *data, MDBX_cursor_op move_op,
                                   ptrdiff_t *distance_items);
 
LIBMDBX_API int mdbx_estimate_range(MDBX_txn *txn, MDBX_dbi dbi,
                                    MDBX_val *begin_key, MDBX_val *begin_data,
                                    MDBX_val *end_key, MDBX_val *end_data,
                                    ptrdiff_t *distance_items);
 
#define MDBX_EPSILON ((MDBX_val *)((ptrdiff_t)-1))
 
MDBX_NOTHROW_PURE_FUNCTION LIBMDBX_API int mdbx_is_dirty(const MDBX_txn *txn,
                                                         const void *ptr);
 
LIBMDBX_API int mdbx_dbi_sequence(MDBX_txn *txn, MDBX_dbi dbi, uint64_t *result,
                                  uint64_t increment);
 
MDBX_NOTHROW_PURE_FUNCTION LIBMDBX_API int mdbx_cmp(const MDBX_txn *txn,
                                                    MDBX_dbi dbi,
                                                    const MDBX_val *a,
                                                    const MDBX_val *b);
 
MDBX_NOTHROW_CONST_FUNCTION LIBMDBX_API MDBX_cmp_func *
mdbx_get_keycmp(MDBX_db_flags_t flags);
 
MDBX_NOTHROW_PURE_FUNCTION LIBMDBX_API int mdbx_dcmp(const MDBX_txn *txn,
                                                     MDBX_dbi dbi,
                                                     const MDBX_val *a,
                                                     const MDBX_val *b);
 
MDBX_NOTHROW_CONST_FUNCTION LIBMDBX_API MDBX_cmp_func *
mdbx_get_datacmp(MDBX_db_flags_t flags);
 
typedef int(MDBX_reader_list_func)(void *ctx, int num, int slot, mdbx_pid_t pid,
                                   mdbx_tid_t thread, uint64_t txnid,
                                   uint64_t lag, size_t bytes_used,
                                   size_t bytes_retained) MDBX_CXX17_NOEXCEPT;
 
LIBMDBX_API int mdbx_reader_list(const MDBX_env *env,
                                 MDBX_reader_list_func *func, void *ctx);
 
LIBMDBX_API int mdbx_reader_check(MDBX_env *env, int *dead);
 
MDBX_DEPRECATED LIBMDBX_API int mdbx_txn_straggler(const MDBX_txn *txn,
                                                   int *percent);
 
LIBMDBX_API int mdbx_thread_register(const MDBX_env *env);
 
LIBMDBX_API int mdbx_thread_unregister(const MDBX_env *env);
 
typedef int(MDBX_hsr_func)(const MDBX_env *env, const MDBX_txn *txn,
                           mdbx_pid_t pid, mdbx_tid_t tid, uint64_t laggard,
                           unsigned gap, size_t space,
                           int retry) MDBX_CXX17_NOEXCEPT;
 
LIBMDBX_API int mdbx_env_set_hsr(MDBX_env *env, MDBX_hsr_func *hsr_callback);
 
MDBX_NOTHROW_PURE_FUNCTION LIBMDBX_API MDBX_hsr_func *
mdbx_env_get_hsr(const MDBX_env *env);
 
enum MDBX_page_type_t {
  MDBX_page_broken,
  MDBX_page_meta,
  MDBX_page_large,
  MDBX_page_branch,
  MDBX_page_leaf,
  MDBX_page_dupfixed_leaf,
  MDBX_subpage_leaf,
  MDBX_subpage_dupfixed_leaf,
  MDBX_subpage_broken,
};
#ifndef __cplusplus
typedef enum MDBX_page_type_t MDBX_page_type_t;
#endif
 
#define MDBX_PGWALK_MAIN ((const char *)((ptrdiff_t)0))
 
#define MDBX_PGWALK_GC ((const char *)((ptrdiff_t)-1))
 
#define MDBX_PGWALK_META ((const char *)((ptrdiff_t)-2))
 
typedef int MDBX_pgvisitor_func(
    const uint64_t pgno, const unsigned number, void *const ctx, const int deep,
    const char *const dbi, const size_t page_size, const MDBX_page_type_t type,
    const MDBX_error_t err, const size_t nentries, const size_t payload_bytes,
    const size_t header_bytes, const size_t unused_bytes) MDBX_CXX17_NOEXCEPT;
 
LIBMDBX_API int mdbx_env_pgwalk(MDBX_txn *txn, MDBX_pgvisitor_func *visitor,
                                void *ctx, bool dont_check_keys_ordering);
 
LIBMDBX_API int mdbx_env_open_for_recovery(MDBX_env *env, const char *pathname,
                                           unsigned target_meta,
                                           bool writeable);
 
LIBMDBX_API int mdbx_env_turn_for_recovery(MDBX_env *env, unsigned target_meta);
 
/**** Attribute support functions for Nexenta (scheduled for removal)
 * *****************************************************************/
#if defined(MDBX_NEXENTA_ATTRS) || defined(DOXYGEN)
 
typedef uint_fast64_t mdbx_attr_t;
 
LIBMDBX_API int mdbx_cursor_put_attr(MDBX_cursor *cursor, MDBX_val *key,
                                     MDBX_val *data, mdbx_attr_t attr,
                                     MDBX_put_flags_t flags);
 
LIBMDBX_API int mdbx_put_attr(MDBX_txn *txn, MDBX_dbi dbi, MDBX_val *key,
                              MDBX_val *data, mdbx_attr_t attr,
                              MDBX_put_flags_t flags);
 
LIBMDBX_API int mdbx_set_attr(MDBX_txn *txn, MDBX_dbi dbi, MDBX_val *key,
                              MDBX_val *data, mdbx_attr_t attr);
 
LIBMDBX_API int mdbx_cursor_get_attr(MDBX_cursor *cursor, MDBX_val *key,
                                     MDBX_val *data, mdbx_attr_t *pattr,
                                     MDBX_cursor_op op);
 
LIBMDBX_API int mdbx_get_attr(MDBX_txn *txn, MDBX_dbi dbi, MDBX_val *key,
                              MDBX_val *data, mdbx_attr_t *pattr);
#endif /* MDBX_NEXENTA_ATTRS */
 
/*******************************************************************************
 * Workaround for mmaped-lookahead-cross-page-boundary bug
 * in an obsolete versions of Elbrus's libc and kernels. */
#if defined(__e2k__) && defined(MDBX_E2K_MLHCPB_WORKAROUND) &&                 \
    MDBX_E2K_MLHCPB_WORKAROUND
LIBMDBX_API int mdbx_e2k_memcmp_bug_workaround(const void *s1, const void *s2,
                                               size_t n);
LIBMDBX_API int mdbx_e2k_strcmp_bug_workaround(const char *s1, const char *s2);
LIBMDBX_API int mdbx_e2k_strncmp_bug_workaround(const char *s1, const char *s2,
                                                size_t n);
LIBMDBX_API size_t mdbx_e2k_strlen_bug_workaround(const char *s);
LIBMDBX_API size_t mdbx_e2k_strnlen_bug_workaround(const char *s,
                                                   size_t maxlen);
#ifdef __cplusplus
namespace std {
inline int mdbx_e2k_memcmp_bug_workaround(const void *s1, const void *s2,
                                          size_t n) {
  return ::mdbx_e2k_memcmp_bug_workaround(s1, s2, n);
}
inline int mdbx_e2k_strcmp_bug_workaround(const char *s1, const char *s2) {
  return ::mdbx_e2k_strcmp_bug_workaround(s1, s2);
}
inline int mdbx_e2k_strncmp_bug_workaround(const char *s1, const char *s2,
                                           size_t n) {
  return ::mdbx_e2k_strncmp_bug_workaround(s1, s2, n);
}
inline size_t mdbx_e2k_strlen_bug_workaround(const char *s) {
  return ::mdbx_e2k_strlen_bug_workaround(s);
}
inline size_t mdbx_e2k_strnlen_bug_workaround(const char *s, size_t maxlen) {
  return ::mdbx_e2k_strnlen_bug_workaround(s, maxlen);
}
} // namespace std
#endif /* __cplusplus */
 
#include <string.h>
#include <strings.h>
#undef memcmp
#define memcmp mdbx_e2k_memcmp_bug_workaround
#undef bcmp
#define bcmp mdbx_e2k_memcmp_bug_workaround
#undef strcmp
#define strcmp mdbx_e2k_strcmp_bug_workaround
#undef strncmp
#define strncmp mdbx_e2k_strncmp_bug_workaround
#undef strlen
#define strlen mdbx_e2k_strlen_bug_workaround
#undef strnlen
#define strnlen mdbx_e2k_strnlen_bug_workaround
#endif /* MDBX_E2K_MLHCPB_WORKAROUND */
 
#ifdef __cplusplus
} /* extern "C" */
#endif
 
#endif /* LIBMDBX_H */