30#if defined(__SIZEOF_INT128__) && !defined(__GLIBCXX_TYPE_INT_N_0) && defined(__clang__) && __clang_major__ < 4
31#define __GLIBCXX_BITSIZE_INT_N_0 128
32#define __GLIBCXX_TYPE_INT_N_0 __int128
35#if !defined(__cplusplus) || __cplusplus < 201103L
36#if !defined(_MSC_VER) || _MSC_VER < 1900
37#error "C++11 compiler or better is required"
39#error "Please add `/Zc:__cplusplus` to MSVC compiler options to enforce it conform ISO C++"
43#if (defined(_WIN32) || defined(_WIN64)) && MDBX_WITHOUT_MSVC_CRT
44#error "CRT is required for C++ API, the MDBX_WITHOUT_MSVC_CRT option must be disabled"
48#define __has_include(header) (0)
51#if __has_include(<version>)
73#if defined(__cpp_lib_memory_resource) && __cpp_lib_memory_resource >= 201603L
74#include <memory_resource>
77#if defined(__cpp_lib_string_view) && __cpp_lib_string_view >= 201606L
81#ifndef MDBX_USING_CXX_EXPERIMETAL_FILESYSTEM
82#ifdef INCLUDE_STD_FILESYSTEM_EXPERIMENTAL
83#define MDBX_USING_CXX_EXPERIMETAL_FILESYSTEM 1
84#elif defined(__cpp_lib_filesystem) && __cpp_lib_filesystem >= 201703L && __cplusplus >= 201703L
85#define MDBX_USING_CXX_EXPERIMETAL_FILESYSTEM 0
86#elif (!defined(_MSC_VER) || __cplusplus >= 201403L || \
87 (defined(_MSC_VER) && defined(_SILENCE_EXPERIMENTAL_FILESYSTEM_DEPRECATION_WARNING) && __cplusplus >= 201403L))
88#if defined(__cpp_lib_experimental_filesystem) && __cpp_lib_experimental_filesystem >= 201406L
89#define MDBX_USING_CXX_EXPERIMETAL_FILESYSTEM 1
90#elif defined(__cpp_lib_string_view) && __cpp_lib_string_view >= 201606L && __has_include(<experimental/filesystem>)
91#define MDBX_USING_CXX_EXPERIMETAL_FILESYSTEM 1
93#define MDBX_USING_CXX_EXPERIMETAL_FILESYSTEM 0
96#define MDBX_USING_CXX_EXPERIMETAL_FILESYSTEM 0
100#if MDBX_USING_CXX_EXPERIMETAL_FILESYSTEM
101#include <experimental/filesystem>
102#elif defined(__cpp_lib_filesystem) && __cpp_lib_filesystem >= 201703L
106#if defined(__cpp_lib_span) && __cpp_lib_span >= 202002L
110#if !defined(_MSC_VER) || defined(__clang__)
112#define MDBX_EXTERN_API_TEMPLATE(API_ATTRIBUTES, API_TYPENAME) extern template class API_ATTRIBUTES API_TYPENAME
113#define MDBX_INSTALL_API_TEMPLATE(API_ATTRIBUTES, API_TYPENAME) template class API_TYPENAME
116#define MDBX_EXTERN_API_TEMPLATE(API_ATTRIBUTES, API_TYPENAME) extern template class API_TYPENAME
117#define MDBX_INSTALL_API_TEMPLATE(API_ATTRIBUTES, API_TYPENAME) template class API_ATTRIBUTES API_TYPENAME
120#if __cplusplus >= 201103L
127#if (defined(__cpp_lib_bit_cast) && __cpp_lib_bit_cast >= 201806L) || \
128 (defined(__cpp_lib_endian) && __cpp_lib_endian >= 201907L) || \
129 (defined(__cpp_lib_bitops) && __cpp_lib_bitops >= 201907L) || \
130 (defined(__cpp_lib_int_pow2) && __cpp_lib_int_pow2 >= 202002L)
132#elif !(defined(__BYTE_ORDER__) && defined(__ORDER_LITTLE_ENDIAN__) && defined(__ORDER_BIG_ENDIAN__))
133#if defined(__BYTE_ORDER) && defined(__LITTLE_ENDIAN) && defined(__BIG_ENDIAN)
134#define __ORDER_LITTLE_ENDIAN__ __LITTLE_ENDIAN
135#define __ORDER_BIG_ENDIAN__ __BIG_ENDIAN
136#define __BYTE_ORDER__ __BYTE_ORDER
137#elif defined(_BYTE_ORDER) && defined(_LITTLE_ENDIAN) && defined(_BIG_ENDIAN)
138#define __ORDER_LITTLE_ENDIAN__ _LITTLE_ENDIAN
139#define __ORDER_BIG_ENDIAN__ _BIG_ENDIAN
140#define __BYTE_ORDER__ _BYTE_ORDER
142#define __ORDER_LITTLE_ENDIAN__ 1234
143#define __ORDER_BIG_ENDIAN__ 4321
144#if defined(__LITTLE_ENDIAN__) || (defined(_LITTLE_ENDIAN) && !defined(_BIG_ENDIAN)) || defined(__ARMEL__) || \
145 defined(__THUMBEL__) || defined(__AARCH64EL__) || defined(__MIPSEL__) || defined(_MIPSEL) || defined(__MIPSEL) || \
146 defined(_M_ARM) || defined(_M_ARM64) || defined(__e2k__) || defined(__elbrus_4c__) || defined(__elbrus_8c__) || \
147 defined(__bfin__) || defined(__BFIN__) || defined(__ia64__) || defined(_IA64) || defined(__IA64__) || \
148 defined(__ia64) || defined(_M_IA64) || defined(__itanium__) || defined(__ia32__) || defined(__CYGWIN__) || \
149 defined(_WIN64) || defined(_WIN32) || defined(__TOS_WIN__) || defined(__WINDOWS__)
150#define __BYTE_ORDER__ __ORDER_LITTLE_ENDIAN__
151#elif defined(__BIG_ENDIAN__) || (defined(_BIG_ENDIAN) && !defined(_LITTLE_ENDIAN)) || defined(__ARMEB__) || \
152 defined(__THUMBEB__) || defined(__AARCH64EB__) || defined(__MIPSEB__) || defined(_MIPSEB) || defined(__MIPSEB) || \
153 defined(__m68k__) || defined(M68000) || defined(__hppa__) || defined(__hppa) || defined(__HPPA__) || \
154 defined(__sparc__) || defined(__sparc) || defined(__370__) || defined(__THW_370__) || defined(__s390__) || \
155 defined(__s390x__) || defined(__SYSC_ZARCH__)
156#define __BYTE_ORDER__ __ORDER_BIG_ENDIAN__
163#define MDBX_CXX17_CONSTEXPR constexpr
164#elif defined(__cpp_constexpr) && __cpp_constexpr >= 201603L && \
165 ((defined(_MSC_VER) && _MSC_VER >= 1915) || (defined(__clang__) && __clang_major__ > 5) || \
166 (defined(__GNUC__) && __GNUC__ > 7) || (!defined(__GNUC__) && !defined(__clang__) && !defined(_MSC_VER)))
167#define MDBX_CXX17_CONSTEXPR constexpr
169#define MDBX_CXX17_CONSTEXPR inline
174#define MDBX_CXX20_CONSTEXPR constexpr
175#elif defined(__cpp_lib_is_constant_evaluated) && __cpp_lib_is_constant_evaluated >= 201811L && \
176 defined(__cpp_lib_constexpr_string) && __cpp_lib_constexpr_string >= 201907L
177#define MDBX_CXX20_CONSTEXPR constexpr
179#define MDBX_CXX20_CONSTEXPR inline
182#if CONSTEXPR_ENUM_FLAGS_OPERATIONS || defined(DOXYGEN)
183#define MDBX_CXX01_CONSTEXPR_ENUM MDBX_CXX01_CONSTEXPR
184#define MDBX_CXX11_CONSTEXPR_ENUM MDBX_CXX11_CONSTEXPR
185#define MDBX_CXX14_CONSTEXPR_ENUM MDBX_CXX14_CONSTEXPR
186#define MDBX_CXX17_CONSTEXPR_ENUM MDBX_CXX17_CONSTEXPR
187#define MDBX_CXX20_CONSTEXPR_ENUM MDBX_CXX20_CONSTEXPR
189#define MDBX_CXX01_CONSTEXPR_ENUM inline
190#define MDBX_CXX11_CONSTEXPR_ENUM inline
191#define MDBX_CXX14_CONSTEXPR_ENUM inline
192#define MDBX_CXX17_CONSTEXPR_ENUM inline
193#define MDBX_CXX20_CONSTEXPR_ENUM inline
197#if defined(CONSTEXPR_ASSERT)
198#define MDBX_CONSTEXPR_ASSERT(expr) CONSTEXPR_ASSERT(expr)
200#define MDBX_CONSTEXPR_ASSERT(expr) void(0)
202#define MDBX_CONSTEXPR_ASSERT(expr) ((expr) ? void(0) : [] { assert(!#expr); }())
206#if defined(DOXYGEN) || (defined(__GNUC__) || __has_builtin(__builtin_expect)) && !defined(__COVERITY__)
207#define MDBX_LIKELY(cond) __builtin_expect(!!(cond), 1)
209#define MDBX_LIKELY(x) (x)
214#if defined(DOXYGEN) || (defined(__GNUC__) || __has_builtin(__builtin_expect)) && !defined(__COVERITY__)
215#define MDBX_UNLIKELY(cond) __builtin_expect(!!(cond), 0)
217#define MDBX_UNLIKELY(x) (x)
223#define MDBX_IF_CONSTEXPR constexpr
224#elif defined(__cpp_if_constexpr) && __cpp_if_constexpr >= 201606L
225#define MDBX_IF_CONSTEXPR constexpr
227#define MDBX_IF_CONSTEXPR
230#if defined(DOXYGEN) || (__has_cpp_attribute(fallthrough) && (!defined(__clang__) || __clang__ > 4)) || \
231 __cplusplus >= 201703L
232#define MDBX_CXX17_FALLTHROUGH [[fallthrough]]
234#define MDBX_CXX17_FALLTHROUGH
237#if defined(DOXYGEN) || (__has_cpp_attribute(likely) >= 201803L && (!defined(__GNUC__) || __GNUC__ > 9))
238#define MDBX_CXX20_LIKELY [[likely]]
240#define MDBX_CXX20_LIKELY
243#ifndef MDBX_CXX20_UNLIKELY
244#if defined(DOXYGEN) || (__has_cpp_attribute(unlikely) >= 201803L && (!defined(__GNUC__) || __GNUC__ > 9))
245#define MDBX_CXX20_UNLIKELY [[unlikely]]
247#define MDBX_CXX20_UNLIKELY
251#ifndef MDBX_HAVE_CXX20_CONCEPTS
252#if defined(__cpp_concepts) && __cpp_concepts >= 202002L && defined(__cpp_lib_concepts) && __cpp_lib_concepts >= 202002L
254#define MDBX_HAVE_CXX20_CONCEPTS 1
255#elif defined(DOXYGEN)
256#define MDBX_HAVE_CXX20_CONCEPTS 1
258#define MDBX_HAVE_CXX20_CONCEPTS 0
262#ifndef MDBX_CXX20_CONCEPT
263#if MDBX_HAVE_CXX20_CONCEPTS || defined(DOXYGEN)
264#define MDBX_CXX20_CONCEPT(CONCEPT, NAME) CONCEPT NAME
266#define MDBX_CXX20_CONCEPT(CONCEPT, NAME) typename NAME
270#ifndef MDBX_ASSERT_CXX20_CONCEPT_SATISFIED
271#if MDBX_HAVE_CXX20_CONCEPTS || defined(DOXYGEN)
272#define MDBX_ASSERT_CXX20_CONCEPT_SATISFIED(CONCEPT, TYPE) static_assert(CONCEPT<TYPE>)
274#define MDBX_ASSERT_CXX20_CONCEPT_SATISFIED(CONCEPT, NAME) \
275 static_assert(true, MDBX_STRINGIFY(CONCEPT) "<" MDBX_STRINGIFY(TYPE) ">")
280#pragma warning(push, 4)
281#pragma warning(disable : 4127)
282#pragma warning(disable : 4251)
284#pragma warning(disable : 4275)
289#pragma warning(disable : 4702)
292#if defined(__LCC__) && __LCC__ >= 126
293#pragma diagnostic push
295#pragma diag_suppress 3058
297#pragma diag_suppress 3060
312#if defined(DOXYGEN) || (defined(__cpp_char8_t) && __cpp_char8_t >= 201811)
322using byte =
unsigned char;
325#if defined(__cpp_lib_endian) && __cpp_lib_endian >= 201907L
326using endian = ::std::endian;
327#elif defined(__BYTE_ORDER__) && defined(__ORDER_LITTLE_ENDIAN__) && defined(__ORDER_BIG_ENDIAN__)
328enum class endian { little = __ORDER_LITTLE_ENDIAN__, big = __ORDER_BIG_ENDIAN__, native = __BYTE_ORDER__ };
330#error "Please use a C++ compiler provides byte order information or C++20 support"
354#if defined(DOXYGEN) || \
355 (defined(__cpp_lib_memory_resource) && __cpp_lib_memory_resource >= 201603L && _GLIBCXX_USE_CXX11_ABI)
365template <
class ALLOCATOR = default_allocator,
class CAPACITY_POLICY = default_capacity_policy>
class buffer;
377template <
class ALLOCATOR = default_allocator>
378using string = ::std::basic_string<char, ::std::char_traits<char>, ALLOCATOR>;
381#if MDBX_USING_CXX_EXPERIMETAL_FILESYSTEM
383namespace filesystem = ::std::experimental::filesystem::v1;
385namespace filesystem = ::std::experimental::filesystem;
387#define MDBX_STD_FILESYSTEM_PATH ::mdbx::filesystem::path
388#elif defined(DOXYGEN) || \
389 (defined(__cpp_lib_filesystem) && __cpp_lib_filesystem >= 201703L && defined(__cpp_lib_string_view) && \
390 __cpp_lib_string_view >= 201606L && \
391 (!defined(__MAC_OS_X_VERSION_MIN_REQUIRED) || __MAC_OS_X_VERSION_MIN_REQUIRED >= 101500) && \
392 (!defined(__IPHONE_OS_VERSION_MIN_REQUIRED) || __IPHONE_OS_VERSION_MIN_REQUIRED >= 130100)) && \
393 (!defined(_MSC_VER) || __cplusplus >= 201703L)
394namespace filesystem = ::std::filesystem;
400#define MDBX_STD_FILESYSTEM_PATH ::mdbx::filesystem::path
403#ifdef MDBX_STD_FILESYSTEM_PATH
405#elif defined(_WIN32) || defined(_WIN64)
406using path = ::std::wstring;
408using path = ::std::string;
411#if defined(__SIZEOF_INT128__) || (defined(_INTEGRAL_MAX_BITS) && _INTEGRAL_MAX_BITS >= 128)
412#ifndef MDBX_U128_TYPE
413#define MDBX_U128_TYPE __uint128_t
415#ifndef MDBX_I128_TYPE
416#define MDBX_I128_TYPE __int128_t
420#if __cplusplus >= 201103L || defined(DOXYGEN)
422using duration = ::std::chrono::duration<unsigned, ::std::ratio<1, 65536>>;
433 ::std::exception_ptr captured_;
441 inline
bool is_clean() const noexcept;
442 inline
void capture() noexcept;
470 const
char *
what() const noexcept;
478 [[noreturn]]
void panic(const
char *context_where_when, const
char *func_who_what) const noexcept;
484 inline
void panic_on_failure(const
char *context_where, const
char *func_who) const noexcept;
485 inline
void success_or_panic(const
char *context_where, const
char *func_who) const noexcept;
489 static inline void throw_on_failure(
int error_code);
490 static inline bool boolean_or_throw(
int error_code);
491 static inline void success_or_throw(
int error_code,
const exception_thunk &);
492 static inline bool boolean_or_throw(
int error_code,
const exception_thunk &);
493 static inline void panic_on_failure(
int error_code,
const char *context_where,
const char *func_who)
noexcept;
494 static inline void success_or_panic(
int error_code,
const char *context_where,
const char *func_who)
noexcept;
500 using base = ::std::runtime_error;
518 fatal(const ::mdbx::error &)
noexcept;
528#define MDBX_DECLARE_EXCEPTION(NAME) \
529 struct LIBMDBX_API_TYPE NAME : public exception { \
530 NAME(const ::mdbx::error &); \
531 virtual ~NAME() noexcept; \
565#undef MDBX_DECLARE_EXCEPTION
575static MDBX_CXX14_CONSTEXPR size_t check_length(
size_t headroom,
size_t payload,
size_t tailroom);
584#if MDBX_HAVE_CXX20_CONCEPTS || defined(DOXYGEN)
591 { a.is_empty() } -> std::same_as<bool>;
592 { a.envisage_result_length() } -> std::same_as<size_t>;
593 { a.write_bytes(&array[0],
size_t(42)) } -> std::same_as<char *>;
601 { a.is_empty() } -> std::same_as<bool>;
602 { a.envisage_result_length() } -> std::same_as<size_t>;
603 { a.write_bytes(&array[0],
size_t(42)) } -> std::same_as<char *>;
612 { a.is_erroneous() } -> std::same_as<bool>;
624 const ALLOCATOR &allocator = ALLOCATOR());
626template <
class ALLOCATOR = default_allocator, MDBX_CXX20_CONCEPT(MutableByteProducer, PRODUCER)>
629template <
class ALLOCATOR = default_allocator, MDBX_CXX20_CONCEPT(ImmutableByteProducer, PRODUCER)>
664 template <
class CHAR,
class T,
class A>
673#if defined(DOXYGEN) || (defined(__cpp_lib_span) && __cpp_lib_span >= 202002L)
675 static_assert(::std::is_standard_layout<POD>::value && !::std::is_pointer<POD>::value,
676 "Must be a standard layout type!");
679 template <
typename POD> MDBX_CXX14_CONSTEXPR ::std::span<const POD>
as_span()
const {
680 static_assert(::std::is_standard_layout<POD>::value && !::std::is_pointer<POD>::value,
681 "Must be a standard layout type!");
684 return ::std::span<const POD>(
static_cast<const POD *
>(
data()),
size() /
sizeof(POD));
688 template <
typename POD> MDBX_CXX14_CONSTEXPR ::std::span<POD>
as_span() {
689 static_assert(::std::is_standard_layout<POD>::value && !::std::is_pointer<POD>::value,
690 "Must be a standard layout type!");
693 return ::std::span<POD>(
static_cast<POD *
>(
data()),
size() /
sizeof(POD));
703#if defined(DOXYGEN) || (defined(__cpp_lib_string_view) && __cpp_lib_string_view >= 201606L)
705 template <
class CHAR,
class T>
708 template <
class CHAR,
class T>
slice(::std::basic_string_view<CHAR, T> &&sv) :
slice(sv) { sv = {}; }
714 static_assert(::std::is_standard_layout<POD>::value && !::std::is_pointer<POD>::value,
715 "Must be a standard layout type!");
716 return slice(&pod,
sizeof(pod));
719 inline slice &assign(
const void *ptr,
size_t bytes);
720 inline slice &assign(
const slice &src)
noexcept;
721 inline slice &assign(const ::MDBX_val &src);
724 inline slice &assign(
const void *begin,
const void *end);
725 template <
class CHAR,
class T,
class ALLOCATOR>
slice &
assign(const ::std::basic_string<CHAR, T, ALLOCATOR> &str) {
726 return assign(str.data(), str.length() *
sizeof(CHAR));
728 inline slice &assign(
const char *c_str);
729#if defined(DOXYGEN) || (defined(__cpp_lib_string_view) && __cpp_lib_string_view >= 201606L)
730 template <
class CHAR,
class T>
slice &
assign(const ::std::basic_string_view<CHAR, T> &view) {
731 return assign(view.begin(), view.end());
733 template <
class CHAR,
class T>
slice &
assign(::std::basic_string_view<CHAR, T> &&view) {
744 operator const MDBX_val *()
const noexcept {
return this; }
746#if defined(DOXYGEN) || (defined(__cpp_lib_string_view) && __cpp_lib_string_view >= 201606L)
747 template <
class CHAR,
class T>
slice &
operator=(const ::std::basic_string_view<CHAR, T> &view) {
751 template <
class CHAR,
class T>
slice &
operator=(::std::basic_string_view<CHAR, T> &&view) {
return assign(view); }
754 template <
class CHAR =
char,
class T = ::std::
char_traits<CHAR>>
755 MDBX_CXX11_CONSTEXPR ::std::basic_string_view<CHAR, T>
string_view() const noexcept {
756 static_assert(
sizeof(CHAR) == 1,
"Must be single byte characters");
761 template <
class CHAR,
class T>
767 template <
class CHAR =
char,
class T = ::std::
char_traits<CHAR>,
class ALLOCATOR = default_allocator>
768 MDBX_CXX20_CONSTEXPR ::std::basic_string<CHAR, T, ALLOCATOR>
769 as_string(
const ALLOCATOR &allocator = ALLOCATOR())
const {
770 static_assert(
sizeof(CHAR) == 1,
"Must be single byte characters");
771 return ::std::basic_string<CHAR, T, ALLOCATOR>(
char_ptr(),
length(), allocator);
774 template <
class CHAR,
class T,
class ALLOCATOR>
780 template <
class ALLOCATOR = default_allocator>
781 inline string<ALLOCATOR> as_hex_string(
bool uppercase =
false,
unsigned wrap_width = 0,
782 const ALLOCATOR &allocator = ALLOCATOR())
const;
786 template <
class ALLOCATOR = default_allocator>
787 inline string<ALLOCATOR> as_base58_string(
unsigned wrap_width = 0,
const ALLOCATOR &allocator = ALLOCATOR())
const;
791 template <
class ALLOCATOR = default_allocator>
792 inline string<ALLOCATOR> as_base64_string(
unsigned wrap_width = 0,
const ALLOCATOR &allocator = ALLOCATOR())
const;
795 template <
class ALLOCATOR = default_allocator,
class CAPACITY_POLICY = default_capacity_policy>
797 const ALLOCATOR &allocator = ALLOCATOR())
const;
801 template <
class ALLOCATOR = default_allocator,
class CAPACITY_POLICY = default_capacity_policy>
803 const ALLOCATOR &allocator = ALLOCATOR())
const;
807 template <
class ALLOCATOR = default_allocator,
class CAPACITY_POLICY = default_capacity_policy>
809 const ALLOCATOR &allocator = ALLOCATOR())
const;
812 template <
class ALLOCATOR = default_allocator,
class CAPACITY_POLICY = default_capacity_policy>
814 const ALLOCATOR &allocator = ALLOCATOR())
const;
818 template <
class ALLOCATOR = default_allocator,
class CAPACITY_POLICY = default_capacity_policy>
820 const ALLOCATOR &allocator = ALLOCATOR())
const;
824 template <
class ALLOCATOR = default_allocator,
class CAPACITY_POLICY = default_capacity_policy>
826 const ALLOCATOR &allocator = ALLOCATOR())
const;
857#if defined(DOXYGEN) || (defined(__cpp_lib_string_view) && __cpp_lib_string_view >= 201606L)
858 template <
class CHAR,
class T>
void swap(::std::basic_string_view<CHAR, T> &view)
noexcept {
859 static_assert(
sizeof(CHAR) == 1,
"Must be single byte characters");
860 const auto temp = ::std::basic_string_view<CHAR, T>(*
this);
919 inline
void remove_prefix(
size_t n) noexcept;
923 inline
void remove_suffix(
size_t n) noexcept;
927 inline
void safe_remove_prefix(
size_t n);
931 inline
void safe_remove_suffix(
size_t n);
993 const
slice &b) noexcept;
1008 static_assert(::std::is_standard_layout<POD>::value && !::std::is_pointer<POD>::value,
1009 "Must be a standard layout type!");
1013 memcpy(&r,
data(),
sizeof(r));
1019#ifdef MDBX_U128_TYPE
1027#ifdef MDBX_I128_TYPE
1035#ifdef MDBX_U128_TYPE
1043#ifdef MDBX_I128_TYPE
1060#if defined(__cpp_lib_allocator_traits_is_always_equal) && __cpp_lib_allocator_traits_is_always_equal >= 201411L
1061 return ::std::allocator_traits<A>::is_always_equal::value;
1063 return ::std::is_empty<A>::value;
1067template <
typename T,
typename A =
typename T::allocator_type,
1068 bool PoCMA = ::std::allocator_traits<A>::propagate_on_container_move_assignment::value>
1077 assert(target->get_allocator() != source.get_allocator());
1083template <
typename T,
typename A>
struct move_assign_alloc<T, A, true> {
1084 static constexpr bool is_nothrow() noexcept {
1085 return allocator_is_always_equal<A>() || ::std::is_nothrow_move_assignable<A>::value;
1087 static constexpr bool is_moveable(T *, T &)
noexcept {
return true; }
1089 assert(target->get_allocator() != source.get_allocator());
1090 target->get_allocator() = ::std::move(source.get_allocator());
1094template <
typename T,
typename A =
typename T::allocator_type,
1095 bool PoCCA = ::std::allocator_traits<A>::propagate_on_container_copy_assignment::value>
1099 static constexpr bool is_nothrow() noexcept {
return false; }
1101 assert(target->get_allocator() != source.get_allocator());
1107template <
typename T,
typename A>
struct copy_assign_alloc<T, A, true> {
1108 static constexpr bool is_nothrow() noexcept {
1109 return allocator_is_always_equal<A>() || ::std::is_nothrow_copy_assignable<A>::value;
1111 static MDBX_CXX20_CONSTEXPR void propagate(T *target,
const T &source)
noexcept(is_nothrow()) {
1113 if (
MDBX_UNLIKELY(target->get_allocator() != source.get_allocator()))
1114 MDBX_CXX20_UNLIKELY target->get_allocator() =
1115 ::std::allocator_traits<A>::select_on_container_copy_construction(source.get_allocator());
1124template <
typename T,
typename A =
typename T::allocator_type,
1125 bool PoCS = ::std::allocator_traits<A>::propagate_on_container_swap::value>
1128template <
typename T,
typename A>
struct swap_alloc<T, A, false> {
1132 if (
MDBX_UNLIKELY(target->get_allocator() != source.get_allocator()))
1142template <
typename T,
typename A>
struct swap_alloc<T, A, true> {
1143 static constexpr bool is_nothrow() noexcept {
1144 return allocator_is_always_equal<A>() ||
1145#if defined(__cpp_lib_is_swappable) && __cpp_lib_is_swappable >= 201603L
1146 ::std::is_nothrow_swappable<A>() ||
1148 (::std::is_nothrow_move_constructible<A>::value && ::std::is_nothrow_move_assignable<A>::value);
1152 if (
MDBX_UNLIKELY(target->get_allocator() != source.get_allocator()))
1153 MDBX_CXX20_UNLIKELY ::std::swap(*target, source);
1175 static_assert(
pettiness_threshold >=
sizeof(uint64_t),
"pettiness_threshold must be > 7");
1183 if (wanna > current)
1187 if (current - wanna >
1191 return round(wanna);
1209 template <
class ALLOCATOR = default_allocator>
1215 template <
class ALLOCATOR = default_allocator,
typename CAPACITY_POLICY = default_capacity_policy>
1223 const size_t bytes =
source.length() << 1;
1233 ::std::ostream &
output(::std::ostream &out)
const;
1256 template <
class ALLOCATOR = default_allocator>
1263 template <
class ALLOCATOR = default_allocator,
typename CAPACITY_POLICY = default_capacity_policy>
1271 const size_t bytes = (
source.length() * 11 + 7) / 8;
1281 ::std::ostream &
output(::std::ostream &out)
const;
1302 template <
class ALLOCATOR = default_allocator>
1309 template <
class ALLOCATOR = default_allocator,
typename CAPACITY_POLICY = default_capacity_policy>
1317 const size_t bytes = (
source.length() + 2) / 3 * 4;
1329 ::std::ostream &
output(::std::ostream &out)
const;
1354 template <
class ALLOCATOR = default_allocator>
1360 template <
class ALLOCATOR = default_allocator,
typename CAPACITY_POLICY = default_capacity_policy>
1393 template <
class ALLOCATOR = default_allocator>
1400 template <
class ALLOCATOR = default_allocator,
typename CAPACITY_POLICY = default_capacity_policy>
1436 template <
class ALLOCATOR = default_allocator>
1443 template <
class ALLOCATOR = default_allocator,
typename CAPACITY_POLICY = default_capacity_policy>
1468template <class ALLOCATOR, typename CAPACITY_POLICY> class
buffer {
1470#if !defined(_MSC_VER) || _MSC_VER > 1900
1471 using allocator_type = typename ::std::allocator_traits<ALLOCATOR>::template rebind_alloc<uint64_t>;
1473 using allocator_type =
typename ALLOCATOR::template rebind<uint64_t>::other;
1483 ?
alignof(max_align_t) * 2
1495 using allocator_pointer =
typename allocator_traits::pointer;
1496 using allocator_const_pointer =
typename allocator_traits::const_pointer;
1498 MDBX_CXX20_CONSTEXPR ::std::pair<allocator_pointer, size_t> allocate_storage(
size_t bytes) {
1499 assert(bytes >=
sizeof(bin));
1500 constexpr size_t unit =
sizeof(
typename allocator_type::value_type);
1501 static_assert((unit & (unit - 1)) == 0,
"size of ALLOCATOR::value_type should be a power of 2");
1502 static_assert(unit > 0,
"size of ALLOCATOR::value_type must be > 0");
1503 const size_t n = (bytes + unit - 1) / unit;
1504 return ::std::make_pair(allocator_traits::allocate(get_allocator(), n), n * unit);
1507 constexpr size_t unit =
sizeof(
typename allocator_type::value_type);
1508 assert(ptr && bytes >=
sizeof(bin) && bytes >= unit && bytes % unit == 0);
1509 allocator_traits::deallocate(get_allocator(), ptr, bytes / unit);
1513#if defined(__cpp_lib_to_address) && __cpp_lib_to_address >= 201711L
1514 return static_cast<void *
>(::std::to_address(ptr));
1516 return static_cast<void *
>(::std::addressof(*ptr));
1520#if defined(__cpp_lib_to_address) && __cpp_lib_to_address >= 201711L
1521 return static_cast<const void *
>(::std::to_address(ptr));
1523 return static_cast<const void *
>(::std::addressof(*ptr));
1527 union alignas(max_align_t)
bin {
1538 << (
sizeof(
size_t ) - 1) * CHAR_BIT,
1559 static_assert((size_t(reservation_policy::inplace_storage_size_rounding) &
1560 (size_t(reservation_policy::inplace_storage_size_rounding) - 1)) == 0,
1561 "CAPACITY_POLICY::inplace_storage_size_rounding must be power of 2");
1563 return capacity_bytes <
sizeof(
bin);
1568 static_assert(std::numeric_limits<size_t>::max() - (std::numeric_limits<size_t>::max() >> CHAR_BIT) ==
1581 if (::std::is_trivial<allocator_pointer>::value)
1589 template <
bool construct_ptr>
1592 if (construct_ptr) {
1608 (void)capacity_bytes;
1620 if (ditto.is_inplace()) {
1626 new (&
allocated_ptr_) allocator_pointer(::std::move(ditto.allocated_ptr_));
1627 capacity_.bytes_ = ditto.capacity_.bytes_;
1628 ditto.make_inplace<
true>();
1634 if (ditto.is_inplace()) {
1651 if (ditto.is_allocated())
1652 ditto.make_inplace<
true>();
1660 const size_t advised = reservation_policy::advise(current, wanna);
1661 assert(advised >= wanna);
1662 return ::std::min(
size_t(
max_capacity), ::std::max(
sizeof(
bin) - 1, advised));
1676 if (bin_.is_suitable_for_inplace(
capacity))
1681 new (&bin_) bin(
pair.first,
pair.second);
1683 return bin_.address();
1687 if (bin_.is_allocated()) {
1688 deallocate_storage(bin_.allocated_ptr_, bin_.capacity_.bytes_);
1689 bin_.template make_inplace<true>();
1693 template <
bool external_content>
1695 const void *
const content,
const size_t length) {
1696 assert(wanna_capacity >= wanna_headroom + length);
1697 const size_t old_capacity = bin_.capacity();
1698 const size_t new_capacity = bin::advise_capacity(old_capacity, wanna_capacity);
1701 assert(bin_.is_inplace() == bin::is_suitable_for_inplace(new_capacity));
1702 byte *
const new_place = bin_.address() + wanna_headroom;
1705 if (external_content)
1706 memcpy(new_place, content, length);
1708 const size_t old_headroom = bin_.address() -
static_cast<const byte *
>(content);
1709 assert(old_capacity >= old_headroom + length);
1711 MDBX_CXX20_UNLIKELY ::std::memmove(new_place, content, length);
1717 if (bin::is_suitable_for_inplace(new_capacity)) {
1718 assert(bin_.is_allocated());
1719 const auto old_allocated = ::std::move(bin_.allocated_ptr_);
1720 byte *
const new_place = bin_.template make_inplace<true>() + wanna_headroom;
1723 deallocate_storage(old_allocated, old_capacity);
1727 if (!bin_.is_allocated()) {
1728 const auto pair = allocate_storage(new_capacity);
1729 assert(pair.second >= new_capacity);
1730 byte *
const new_place =
static_cast<byte *
>(to_address(pair.first)) + wanna_headroom;
1733 bin_.template make_allocated<true>(pair.first, pair.second);
1737 const auto old_allocated = ::std::move(bin_.allocated_ptr_);
1738 if (external_content)
1739 deallocate_storage(old_allocated, old_capacity);
1740 const auto pair = allocate_storage(new_capacity);
1741 assert(pair.second >= new_capacity);
1742 byte *
const new_place = bin_.template make_allocated<false>(pair.first, pair.second) + wanna_headroom;
1745 if (!external_content)
1746 deallocate_storage(old_allocated, old_capacity);
1751 assert(capacity() >= offset);
1752 return bin_.address() + offset;
1755 assert(capacity() >= offset);
1756 return bin_.address() + offset;
1759 assert(capacity() >= offset + length);
1760 return static_cast<byte *
>(memcpy(get(offset), ptr, length));
1766 silo() noexcept : allocator_type() { init(0); }
1768 silo(
const allocator_type &alloc) noexcept : allocator_type(alloc) { init(0); }
1770 MDBX_CXX20_CONSTEXPR silo(
size_t capacity,
const allocator_type &alloc) : allocator_type(alloc) { init(capacity); }
1772 MDBX_CXX20_CONSTEXPR silo(silo &&ditto)
noexcept(::std::is_nothrow_move_constructible<allocator_type>::value)
1773 : allocator_type(::std::move(ditto.get_allocator())), bin_(::std::move(ditto.bin_)) {}
1775 MDBX_CXX20_CONSTEXPR silo(
size_t capacity,
size_t headroom,
const void *ptr,
size_t length) : silo(capacity) {
1776 assert(capacity >= headroom + length);
1778 put(headroom, ptr, length);
1782 const allocator_type &alloc)
1783 : silo(capacity, alloc) {
1784 assert(capacity >= headroom + length);
1786 put(headroom, ptr, length);
1791 : silo(length, 0, ptr, length, alloc) {}
1793 ~silo() { release(); }
1797 MDBX_CXX20_CONSTEXPR void *assign(
size_t headroom,
const void *ptr,
size_t length,
size_t tailroom) {
1798 return reshape<true>(headroom + length + tailroom, headroom, ptr, length);
1800 MDBX_CXX20_CONSTEXPR void *assign(
const void *ptr,
size_t length) {
return assign(0, ptr, length, 0); }
1803 assert(ditto.get() + headroom == content.byte_ptr());
1804 if MDBX_IF_CONSTEXPR (!allocation_aware_details::allocator_is_always_equal<allocator_type>()) {
1805 if (
MDBX_UNLIKELY(get_allocator() != ditto.get_allocator()))
1806 MDBX_CXX20_UNLIKELY {
1808 allocation_aware_details::copy_assign_alloc<silo, allocator_type>::propagate(
this, ditto);
1811 content.iov_base = reshape<true>(ditto.capacity(), headroom, content.data(), content.length());
1816 assign(silo &&ditto,
size_t headroom,
1817 slice &content)
noexcept(allocation_aware_details::move_assign_alloc<silo, allocator_type>::is_nothrow()) {
1818 assert(ditto.get() + headroom == content.byte_ptr());
1819 if (allocation_aware_details::move_assign_alloc<silo, allocator_type>::is_moveable(
this, ditto)) {
1821 allocation_aware_details::move_assign_alloc<silo, allocator_type>::propagate(
this, ditto);
1823 bin_ = ::std::move(ditto.bin_);
1824 assert(get() + headroom == content.byte_ptr());
1827 content.iov_base = reshape<true>(ditto.capacity(), headroom, content.data(), content.length());
1835 return reshape<false>(whole_capacity, headroom,
nullptr, 0);
1838 content.iov_base = reshape<false>(capacity, headroom, content.iov_base, content.iov_len);
1841 swap(silo &ditto)
noexcept(allocation_aware_details::swap_alloc<silo, allocator_type>::is_nothrow()) {
1842 allocation_aware_details::swap_alloc<silo, allocator_type>::propagate(
this, ditto);
1843 ::std::swap(bin_, ditto.bin_);
1856 ::mdbx::slice slice_;
1859 assert(is_reference());
1861 slice_.iov_base = silo_.
data();
1865 return static_cast<const byte *
>(silo_.data());
1869 return silo_begin() + silo_.capacity();
1872 struct data_preserver :
public exception_thunk {
1874 data_preserver(allocator_type &allocator) : data(allocator) {}
1875 static int callback(
void *context,
MDBX_val *target,
const void *src,
size_t bytes)
noexcept {
1876 auto self =
static_cast<data_preserver *
>(context);
1877 assert(self->is_clean());
1878 assert(&self->data.slice_ == target);
1881 self->data.assign(src, bytes,
false);
1908 return size_t(
byte_ptr() - silo_begin()) < silo_.capacity();
1942 return const_cast<byte *
>(slice_.byte_ptr());
1949 return const_cast<byte *
>(slice_.end_byte_ptr());
1962 return const_cast<char *
>(slice_.char_ptr());
1969 return const_cast<char *
>(slice_.end_char_ptr());
1982 return const_cast<void *
>(slice_.data());
1989 return const_cast<void *
>(slice_.end());
2000 slice_.set_length(
bytes);
2022 : silo_(allocator), slice_(src) {
2023 if (!make_reference)
2028 :
buffer(src.slice_, make_reference, allocator) {}
2033 template <
class CHAR,
class T,
class A>
buffer(const ::std::basic_string<CHAR, T, A> &) =
delete;
2034 template <
class CHAR,
class T,
class A>
buffer(const ::std::basic_string<CHAR, T, A> &&) =
delete;
2039#if defined(DOXYGEN) || (defined(__cpp_lib_string_view) && __cpp_lib_string_view >= 201606L)
2040 template <
class CHAR,
class T>
2041 buffer(const ::std::basic_string_view<CHAR, T> &view,
bool make_reference,
2057 template <
class CHAR,
class T,
class A>
2066#if defined(DOXYGEN) || (defined(__cpp_lib_string_view) && __cpp_lib_string_view >= 201606L)
2067 template <
class CHAR,
class T>
2074 slice_.iov_base = silo_.init(check_length(head_room, tail_room));
2075 assert(slice_.iov_len == 0);
2079 slice_.iov_base = silo_.init(check_length(
capacity));
2080 assert(slice_.iov_len == 0);
2085 : silo_(allocator) {
2086 slice_.iov_base = silo_.init(check_length(head_room, src.
length(), tail_room));
2087 slice_.iov_len = src.
length();
2088 memcpy(slice_.iov_base, src.
data(), src.
length());
2092 :
buffer(head_room, src.slice_, tail_room, allocator) {}
2097 : silo_(::
std::move(src.silo_)), slice_(::
std::move(src.slice_)) {}
2103#if defined(DOXYGEN) || (defined(__cpp_lib_span) && __cpp_lib_span >= 202002L)
2105 static_assert(::std::is_standard_layout<POD>::value && !::std::is_pointer<POD>::value,
2106 "Must be a standard layout type!");
2109 template <
typename POD> MDBX_CXX14_CONSTEXPR ::std::span<const POD>
as_span()
const {
2112 template <
typename POD> MDBX_CXX14_CONSTEXPR ::std::span<POD>
as_span() {
return slice_.template
as_span<POD>(); }
2120 template <
typename POD>
2127#ifdef MDBX_U128_TYPE
2135#ifdef MDBX_I128_TYPE
2143#ifdef MDBX_U128_TYPE
2151#ifdef MDBX_I128_TYPE
2160 static buffer hex(const ::mdbx::slice &source,
bool uppercase =
false,
unsigned wrap_width = 0,
2179 template <
typename POD>
2180 static buffer hex(
const POD &pod,
bool uppercase =
false,
unsigned wrap_width = 0,
2187 template <
typename POD>
2194 template <
typename POD>
2255 void reserve(
size_t wanna_headroom,
size_t wanna_tailroom) {
2258 const size_t wanna_capacity = check_length(wanna_headroom, slice_.length(), wanna_tailroom);
2259 silo_.resize(wanna_capacity, wanna_headroom, slice_);
2272 slice_.assign(ptr,
bytes);
2277 silo_.
assign(
static_cast<const typename silo::value_type *
>(ptr), check_length(
bytes));
2283 silo_.swap(other.silo_);
2284 slice_.swap(other.slice_);
2302 return assign(src.iov_base, src.iov_len, make_reference);
2312 assign(src.iov_base, src.iov_len, make_reference);
2313 src.iov_base =
nullptr;
2318 return assign(begin,
static_cast<const byte *
>(
end) -
static_cast<const byte *
>(begin), make_reference);
2321 template <
class CHAR,
class T,
class A>
2322 buffer &
assign(const ::std::basic_string<CHAR, T, A> &str,
bool make_reference =
false) {
2323 return assign(str.data(), str.length(), make_reference);
2327 return assign(c_str, ::mdbx::strlen(c_str), make_reference);
2330#if defined(__cpp_lib_string_view) && __cpp_lib_string_view >= 201606L
2331 template <
class CHAR,
class T>
2332 buffer &assign(const ::std::basic_string_view<CHAR, T> &view,
bool make_reference =
false) {
2333 return assign(view.data(), view.length(), make_reference);
2336 template <
class CHAR,
class T> buffer &assign(::std::basic_string_view<CHAR, T> &&view,
bool make_reference =
false) {
2337 assign(view.data(), view.length(), make_reference);
2351#if defined(DOXYGEN) || (defined(__cpp_lib_string_view) && __cpp_lib_string_view >= 201606L)
2352 template <
class CHAR,
class T>
buffer &
operator=(const ::std::basic_string_view<CHAR, T> &view)
noexcept {
2357 template <
class CHAR =
char,
class T = ::std::
char_traits<CHAR>>
2359 return slice_.string_view<CHAR, T>();
2363 template <
class CHAR,
class T> operator ::std::basic_string_view<CHAR, T>() const noexcept {
2364 return string_view<CHAR, T>();
2383 template <
class CHAR =
char,
class T = ::std::
char_traits<CHAR>,
class A = legacy_allocator>
2384 MDBX_CXX20_CONSTEXPR ::std::basic_string<CHAR, T, A>
as_string(
const A &allocator = A())
const {
2385 return slice_.as_string<CHAR, T, A>(allocator);
2388 template <
class CHAR,
class T,
class A>
2395 return slice_.starts_with(prefix);
2400 return slice_.ends_with(suffix);
2404 void clear() noexcept { slice_.assign(silo_.clear(),
size_t(0)); }
2408 slice_.assign(silo_.clear_and_reserve(whole_capacity,
headroom),
size_t(0));
2484 slice_.iov_len +=
bytes;
2493 slice_.iov_base = memcpy(
static_cast<char *
>(slice_.iov_base) -
bytes, src,
bytes);
2494 slice_.iov_len +=
bytes;
2501 const size_t wanna_bytes = producer.envisage_result_length();
2508 const size_t wanna_bytes = producer.envisage_result_length();
2541 *slice_.end_byte_ptr() = uint8_t(u8);
2542 slice_.iov_len += 1;
2551 const auto ptr = slice_.end_byte_ptr();
2552 ptr[0] = uint8_t(u16);
2553 ptr[1] = uint8_t(u16 >> 8);
2554 slice_.iov_len += 2;
2561 const auto ptr = slice_.end_byte_ptr();
2562 ptr[0] = uint8_t(u24);
2563 ptr[1] = uint8_t(u24 >> 8);
2564 ptr[2] = uint8_t(u24 >> 16);
2565 slice_.iov_len += 3;
2572 const auto ptr = slice_.end_byte_ptr();
2573 ptr[0] = uint8_t(u32);
2574 ptr[1] = uint8_t(u32 >> 8);
2575 ptr[2] = uint8_t(u32 >> 16);
2576 ptr[3] = uint8_t(u32 >> 24);
2577 slice_.iov_len += 4;
2584 const auto ptr = slice_.end_byte_ptr();
2585 ptr[0] = uint8_t(u48);
2586 ptr[1] = uint8_t(u48 >> 8);
2587 ptr[2] = uint8_t(u48 >> 16);
2588 ptr[3] = uint8_t(u48 >> 24);
2589 ptr[4] = uint8_t(u48 >> 32);
2590 ptr[5] = uint8_t(u48 >> 40);
2591 slice_.iov_len += 6;
2598 const auto ptr = slice_.end_byte_ptr();
2599 ptr[0] = uint8_t(u64);
2600 ptr[1] = uint8_t(u64 >> 8);
2601 ptr[2] = uint8_t(u64 >> 16);
2602 ptr[3] = uint8_t(u64 >> 24);
2603 ptr[4] = uint8_t(u64 >> 32);
2604 ptr[5] = uint8_t(u64 >> 40);
2605 ptr[6] = uint8_t(u64 >> 48);
2606 ptr[7] = uint8_t(u64 >> 56);
2607 slice_.iov_len += 8;
2613 template <
size_t SIZE>
static buffer key_from(
const char (&text)[SIZE],
bool make_reference =
true) {
2617#if defined(DOXYGEN) || (defined(__cpp_lib_string_view) && __cpp_lib_string_view >= 201606L)
2618 template <
class CHAR,
class T>
2619 static buffer key_from(const ::std::basic_string_view<CHAR, T> &src,
bool make_reference =
false) {
2620 return buffer(src, make_reference);
2626 template <
class CHAR,
class T,
class A>
2627 static buffer key_from(const ::std::basic_string<CHAR, T, A> &src,
bool make_reference =
false) {
2628 return buffer(src, make_reference);
2666template <
class ALLOCATOR,
class CAPACITY_POLICY, MDBX_CXX20_CONCEPT(MutableByteProducer, PRODUCER)>
2677template <
class ALLOCATOR,
class CAPACITY_POLICY, MDBX_CXX20_CONCEPT(ImmutableByteProducer, PRODUCER)>
2688template <
class ALLOCATOR, MDBX_CXX20_CONCEPT(MutableByteProducer, PRODUCER)>
2693 result.resize(producer.envisage_result_length());
2694 result.resize(producer.write_bytes(
const_cast<char *
>(result.data()), result.capacity()) - result.data());
2699template <
class ALLOCATOR, MDBX_CXX20_CONCEPT(ImmutableByteProducer, PRODUCER)>
2704 result.resize(producer.envisage_result_length());
2705 result.resize(producer.write_bytes(
const_cast<char *
>(result.data()), result.capacity()) - result.data());
2712#if defined(__cpp_lib_memory_resource) && __cpp_lib_memory_resource >= 201603L && _GLIBCXX_USE_CXX11_ABI
2749 const pair &b)
noexcept;
2778 using stl_pair = ::std::pair<buffer_type, buffer_type>;
2789 :
key(
key, make_reference, allocator),
value(
value, make_reference, allocator) {}
2800 :
key(
key, make_reference, allocator),
value(
value, make_reference, allocator) {}
2821 return key.is_freestanding() &&
value.is_freestanding();
2826 return key.is_reference() ||
value.is_reference();
2832 key.make_freestanding();
2833 value.make_freestanding();
2840template <
typename BUFFER>
2899#if CONSTEXPR_ENUM_FLAGS_OPERATIONS || defined(DOXYGEN)
2981 operator bool() const noexcept {
return dbi != 0; }
3031 inline
env &operator=(
env &&other) noexcept;
3032 inline
env(
env &&other) noexcept;
3033 inline ~
env() noexcept;
3056#if INTPTR_MAX > 0x7fffFFFFl
3064#if INTPTR_MAX > 0x7fffFFFFl
3110 inline geometry &make_fixed(intptr_t size)
noexcept;
3111 inline geometry &make_dynamic(intptr_t lower = default_value, intptr_t upper = default_value)
noexcept;
3201 bool use_subdirectory =
false
3237 static inline
size_t dbsize_min(intptr_t pagesize);
3239 static inline
size_t dbsize_max(intptr_t pagesize);
3318#ifdef MDBX_STD_FILESYSTEM_PATH
3321#if defined(_WIN32) || defined(_WIN64) || defined(DOXYGEN)
3322 env &
copy(const ::std::wstring &destination,
bool compactify,
bool force_dynamic_size =
false);
3323 env &
copy(
const wchar_t *destination,
bool compactify,
bool force_dynamic_size =
false);
3325 env &
copy(const ::std::string &destination,
bool compactify,
bool force_dynamic_size =
false);
3326 env &
copy(
const char *destination,
bool compactify,
bool force_dynamic_size =
false);
3348#ifdef MDBX_STD_FILESYSTEM_PATH
3351#if defined(_WIN32) || defined(_WIN64) || defined(DOXYGEN)
3371 inline info get_info()
const;
3374 inline stat get_stat(
const txn &)
const;
3377 inline info get_info(
const txn &)
const;
3425#if __cplusplus >= 201103L || defined(DOXYGEN)
3512 inline env &set_extra_option(extra_runtime_option option, uint64_t value);
3515 inline uint64_t extra_option(extra_runtime_option option)
const;
3521 inline env &set_geometry(
const geometry &size);
3526 inline bool sync_to_disk(
bool force =
true,
bool nonblock =
false);
3575 size_t used,
size_t retained)
noexcept;
3641 using inherited =
env;
3650#ifdef MDBX_STD_FILESYSTEM_PATH
3653#if defined(_WIN32) || defined(_WIN64) || defined(DOXYGEN)
3672#ifdef MDBX_STD_FILESYSTEM_PATH
3674 bool accede =
true);
3676#if defined(_WIN32) || defined(_WIN64) || defined(DOXYGEN)
3678 bool accede =
true);
3680 bool accede =
true);
3703 MDBX_CXX20_UNLIKELY {
3704 assert(
handle_ != other.handle_);
3732 inline
txn &operator=(
txn &&other) noexcept;
3733 inline
txn(
txn &&other) noexcept;
3734 inline ~
txn() noexcept;
3747 inline uint64_t
id() const;
3756 inline
bool is_dirty(const
void *ptr) const;
3766 inline info get_info(
bool scan_reader_lock_table =
false)
const;
3775 return size_t(
get_info().txn_space_dirty);
3781 inline void reset_reading();
3784 inline void renew_reading();
3787 inline void make_broken();
3790 inline void park_reading(
bool autounpark =
true);
3794 inline bool unpark_reading(
bool restart_if_ousted =
true);
3822 inline map_handle open_map_accede(
const char *name)
const;
3824 inline map_handle open_map_accede(const ::std::string &name)
const;
3826 inline map_handle open_map_accede(const ::mdbx::slice &name)
const;
3843 bool drop_map(
const char *name,
bool throw_if_absent =
false);
3847 inline bool drop_map(const ::std::string &name,
bool throw_if_absent =
false);
3851 bool drop_map(const ::mdbx::slice &name,
bool throw_if_absent =
false);
3857 bool clear_map(
const char *name,
bool throw_if_absent =
false);
3860 inline bool clear_map(const ::std::string &name,
bool throw_if_absent =
false);
3863 bool clear_map(const ::mdbx::slice &name,
bool throw_if_absent =
false);
3874 bool rename_map(
const char *old_name,
const char *new_name,
bool throw_if_absent =
false);
3878 bool rename_map(const ::std::string &old_name, const ::std::string &new_name,
bool throw_if_absent =
false);
3882 bool rename_map(const ::mdbx::slice &old_name, const ::mdbx::slice &new_name,
bool throw_if_absent =
false);
3884#if defined(DOXYGEN) || (defined(__cpp_lib_string_view) && __cpp_lib_string_view >= 201606L)
3902 bool drop_map(const ::std::string_view &name,
bool throw_if_absent =
false) {
3907 bool clear_map(const ::std::string_view &name,
bool throw_if_absent =
false) {
3915 bool rename_map(const ::std::string_view &old_name, const ::std::string_view &new_name,
3916 bool throw_if_absent =
false) {
3997 template <
class ALLOCATOR,
typename CAPACITY_POLICY>
4004 template <
class ALLOCATOR,
typename CAPACITY_POLICY>
4010 template <
class ALLOCATOR,
typename CAPACITY_POLICY>
4032 inline void append(
map_handle map,
const slice &key,
const slice &value,
bool multivalue_order_preserved =
true);
4034 return append(map, kv.
key, kv.
value, multivalue_order_preserved);
4037 inline size_t put_multiple_samelength(
map_handle map,
const slice &key,
const size_t value_length,
4038 const void *values_array,
size_t values_count,
put_mode mode,
4039 bool allow_partial =
false);
4040 template <
typename VALUE>
4042 put_mode mode,
bool allow_partial =
false) {
4043 static_assert(::std::is_standard_layout<VALUE>::value && !::std::is_pointer<VALUE>::value &&
4044 !::std::is_array<VALUE>::value,
4045 "Must be a standard layout type!");
4048 template <
typename VALUE>
4055 inline ptrdiff_t estimate_from_first(
map_handle map,
const slice &to)
const;
4056 inline ptrdiff_t estimate_to_last(
map_handle map,
const slice &from)
const;
4068 using inherited =
txn;
4076 txn_managed(txn_managed &&) = default;
4077 txn_managed &operator=(txn_managed &&other) noexcept {
4079 MDBX_CXX20_UNLIKELY {
4080 assert(
handle_ != other.handle_);
4140 inline ~
cursor() noexcept;
4172 inline void *get_context() const noexcept;
4175 inline
cursor &set_context(
void *your_context);
4237 bool throw_notfound);
4260 template <
typename CALLABLE_PREDICATE>
4263 static int probe(
void *context,
MDBX_val *key,
MDBX_val *value,
void *arg)
noexcept {
4264 auto thunk =
static_cast<wrapper *
>(context);
4265 assert(thunk->is_clean());
4266 auto &predicate = *
static_cast<CALLABLE_PREDICATE *
>(arg);
4280 template <
typename CALLABLE_PREDICATE>
bool fullscan(CALLABLE_PREDICATE predicate,
bool backward =
false) {
4284 template <
typename CALLABLE_PREDICATE>
4288 static int probe(
void *context,
MDBX_val *key,
MDBX_val *value,
void *arg)
noexcept {
4289 auto thunk =
static_cast<wrapper *
>(context);
4290 assert(thunk->is_clean());
4291 auto &predicate = *
static_cast<CALLABLE_PREDICATE *
>(arg);
4305 template <
typename CALLABLE_PREDICATE>
4309 static int probe(
void *context,
MDBX_val *key,
MDBX_val *value,
void *arg)
noexcept {
4310 auto thunk =
static_cast<wrapper *
>(context);
4311 assert(thunk->is_clean());
4312 auto &predicate = *
static_cast<CALLABLE_PREDICATE *
>(arg);
4327 return move_result(*
this, operation, throw_notfound);
4333 return move_result(*
this, operation, key, value, throw_notfound);
4336 return move(operation, &key, &value, throw_notfound);
4415 inline bool seek(
const slice &key);
4416 inline move_result find(
const slice &key,
bool throw_notfound =
true);
4417 inline move_result lower_bound(
const slice &key,
bool throw_notfound =
false);
4418 inline move_result upper_bound(
const slice &key,
bool throw_notfound =
false);
4421 inline size_t count_multivalue()
const;
4423 inline move_result find_multivalue(
const slice &key,
const slice &value,
bool throw_notfound =
true);
4424 inline move_result lower_bound_multivalue(
const slice &key,
const slice &value,
bool throw_notfound =
false);
4425 inline move_result upper_bound_multivalue(
const slice &key,
const slice &value,
bool throw_notfound =
false);
4443 inline bool eof()
const;
4444 inline bool on_first()
const;
4445 inline bool on_last()
const;
4446 inline bool on_first_multival()
const;
4447 inline bool on_last_multival()
const;
4450 inline estimate_result
estimate(move_operation operation)
const;
4465 inline ::mdbx::txn
txn()
const;
4468 inline operator ::mdbx::txn()
const {
return txn(); }
4469 inline operator ::mdbx::map_handle()
const {
return map(); }
4473 inline void insert(
const slice &key,
slice value);
4475 inline slice insert_reserve(
const slice &key,
size_t value_length);
4479 inline slice upsert_reserve(
const slice &key,
size_t value_length);
4482 inline bool try_update(
const slice &key,
const slice &value);
4483 inline slice update_reserve(
const slice &key,
size_t value_length);
4492 inline bool erase(
bool whole_multivalue =
false);
4496 inline bool erase(
const slice &key,
bool whole_multivalue =
true);
4500 inline bool erase(
const slice &key,
const slice &value);
4502 inline size_t put_multiple_samelength(
const slice &key,
const size_t value_length,
const void *values_array,
4503 size_t values_count,
put_mode mode,
bool allow_partial =
false);
4504 template <
typename VALUE>
4506 bool allow_partial =
false) {
4507 static_assert(::std::is_standard_layout<VALUE>::value && !::std::is_pointer<VALUE>::value &&
4508 !::std::is_array<VALUE>::value,
4509 "Must be a standard layout type!");
4512 template <
typename VALUE>
4526 using inherited =
cursor;
4545 cursor_managed &
operator=(cursor_managed &&other)
noexcept {
4547 MDBX_CXX20_UNLIKELY {
4548 assert(
handle_ != other.handle_);
4571template <
class ALLOCATOR,
typename CAPACITY_POLICY>
4598#if defined(__cpp_lib_is_constant_evaluated) && __cpp_lib_is_constant_evaluated >= 201811L
4599 if (::std::is_constant_evaluated()) {
4600 for (
size_t i = 0; c_str; ++i)
4606#if defined(__cpp_lib_string_view) && __cpp_lib_string_view >= 201606L
4607 return c_str ? ::std::string_view(c_str).length() : 0;
4609 return c_str ? ::std::strlen(c_str) : 0;
4614#if defined(__cpp_lib_is_constant_evaluated) && __cpp_lib_is_constant_evaluated >= 201811L
4615 if (::std::is_constant_evaluated()) {
4616 for (
size_t i = 0; i < bytes; ++i)
4617 static_cast<byte *
>(dest)[i] =
static_cast<const byte *
>(src)[i];
4621 return ::std::memcpy(dest, src, bytes);
4625#if defined(__cpp_lib_is_constant_evaluated) && __cpp_lib_is_constant_evaluated >= 201811L
4626 if (::std::is_constant_evaluated()) {
4627 for (
size_t i = 0; i < bytes; ++i) {
4628 const int diff = int(
static_cast<const byte *
>(a)[i]) - int(
static_cast<const byte *
>(b)[i]);
4635 return ::std::memcmp(a, b, bytes);
4645 return check_length(check_length(headroom) + check_length(payload));
4649 return check_length(check_length(headroom, payload) + check_length(tailroom));
4656 captured_ = ::std::current_exception();
4661 MDBX_CXX20_UNLIKELY ::std::rethrow_exception(captured_);
4719 MDBX_CXX20_UNLIKELY
panic(context_where, func_who);
4724 MDBX_CXX20_UNLIKELY
panic(context_where, func_who);
4729 MDBX_CXX20_UNLIKELY
error(error_code).throw_exception();
4738 error rc(error_code);
4743 switch (error_code) {
4779 : ::
MDBX_val({
const_cast<void *
>(ptr), check_length(
bytes)}) {}
4782 :
slice(begin, static_cast<const
byte *>(
end) - static_cast<const
byte *>(begin)) {}
4793 iov_base =
const_cast<void *
>(ptr);
4794 iov_len = check_length(
bytes);
4799 iov_base = src.iov_base;
4800 iov_len = src.iov_len;
4813 assign(src.iov_base, src.iov_len);
4814 src.iov_base =
nullptr;
4819 return assign(begin,
static_cast<const byte *
>(
end) -
static_cast<const byte *
>(begin));
4829 const auto temp = *
this;
4835 return static_cast<const byte *
>(iov_base);
4840MDBX_CXX11_CONSTEXPR ::mdbx::byte *
slice::byte_ptr() noexcept {
return static_cast<byte *
>(iov_base); }
4863 iov_len = check_length(
bytes);
4888 assert(n <=
size());
4889 iov_base =
static_cast<byte *
>(iov_base) + n;
4900 assert(n <=
size());
4911 return length() >= prefix.length() && memcmp(
data(), prefix.data(), prefix.length()) == 0;
4915 return length() >= suffix.length() &&
4916 memcmp(
byte_ptr() +
length() - suffix.length(), suffix.data(), suffix.length()) == 0;
4920 size_t h =
length() * 3977471;
4921 for (
size_t i = 0; i <
length(); ++i)
4922 h = (h ^
static_cast<const uint8_t *
>(
data())[i]) * 1664525 + 1013904223;
4923 return h ^ 3863194411 * (h >> 11);
4973 const intptr_t diff = intptr_t(a.length()) - intptr_t(b.length());
4975 :
MDBX_UNLIKELY(a.length() == 0 || a.data() == b.data()) ? 0
4976 : memcmp(a.data(), b.data(), a.length());
4980 const size_t shortest = ::std::min(a.length(), b.length());
4983 const intptr_t diff = memcmp(a.data(), b.data(), shortest);
4987 return intptr_t(a.length()) - intptr_t(b.length());
5014template <
class ALLOCATOR>
5016 return to_hex(*
this, uppercase, wrap_width).
as_string<ALLOCATOR>(allocator);
5019template <
class ALLOCATOR>
5024template <
class ALLOCATOR>
5029template <
class ALLOCATOR,
class CAPACITY_POLICY>
5031 const ALLOCATOR &allocator)
const {
5032 return to_hex(*
this, uppercase, wrap_width).
as_buffer<ALLOCATOR, CAPACITY_POLICY>(allocator);
5035template <
class ALLOCATOR,
class CAPACITY_POLICY>
5037 return to_base58(*
this, wrap_width).
as_buffer<ALLOCATOR, CAPACITY_POLICY>(allocator);
5040template <
class ALLOCATOR,
class CAPACITY_POLICY>
5042 return to_base64(*
this, wrap_width).
as_buffer<ALLOCATOR, CAPACITY_POLICY>(allocator);
5045template <
class ALLOCATOR,
class CAPACITY_POLICY>
5047 return from_hex(*
this, ignore_spaces).
as_buffer<ALLOCATOR, CAPACITY_POLICY>(allocator);
5050template <
class ALLOCATOR,
class CAPACITY_POLICY>
5055template <
class ALLOCATOR,
class CAPACITY_POLICY>
5085 return a.key.length() == b.key.length() && a.value.length() == b.value.length() &&
5086 memcmp(a.key.data(), b.key.data(), a.key.length()) == 0 &&
5087 memcmp(a.value.data(), b.value.data(), a.value.length()) == 0;
5107 return a.key.length() != b.key.length() || a.value.length() != b.value.length() ||
5108 memcmp(a.key.data(), b.key.data(), a.key.length()) != 0 ||
5109 memcmp(a.value.data(), b.value.data(), a.value.length()) != 0;
5114template <
class ALLOCATOR,
typename CAPACITY_POLICY>
5138 other.handle_ =
nullptr;
5189 return static_cast<size_t>(result);
5196 return static_cast<size_t>(result);
5207 return static_cast<size_t>(result);
5218 return static_cast<size_t>(result);
5231 return static_cast<size_t>(result);
5242 return static_cast<size_t>(result);
5251 return static_cast<size_t>(result);
5262 return static_cast<size_t>(result);
5273 return static_cast<size_t>(result);
5284 return static_cast<size_t>(result);
5295 return static_cast<size_t>(result);
5394 unsigned seconds_16dot16;
5396 return seconds_16dot16;
5405#if __cplusplus >= 201103L
5450 size_t retained) noexcept
5457 static int cb(
void *ctx,
int number,
int slot,
mdbx_pid_t pid,
mdbx_tid_t thread, uint64_t txnid, uint64_t lag,
5458 size_t used,
size_t retained)
noexcept {
5459 reader_visitor_thunk *thunk =
static_cast<reader_visitor_thunk *
>(ctx);
5460 assert(thunk->is_clean());
5462 const reader_info info(slot, pid, thread, txnid, lag, used, retained);
5471 reader_visitor_thunk thunk(visitor);
5473 thunk.rethrow_captured();
5480 assert(dead_count >= 0);
5481 return static_cast<unsigned>(dead_count);
5494 assert(ptr !=
nullptr);
5501 assert(ptr !=
nullptr);
5508 assert(ptr !=
nullptr);
5515 assert(ptr !=
nullptr);
5527 other.handle_ =
nullptr;
5617 assert(map.
dbi != 0);
5626 assert(map.
dbi != 0);
5633 assert(map.
dbi != 0);
5640 assert(map.
dbi != 0);
5649 assert(map.
dbi != 0);
5658 assert(map.
dbi != 0);
5746 return ::mdbx_dcmp(
handle_, map.
dbi, &a, &b);
5776 return value_at_absence;
5789 return value_at_absence;
5806 return pair_result{result.key, result.value,
true};
5808 return pair_result{result.key, result.value,
false};
5830 const int err =
put(map, key, &value ,
5843 slice result(
nullptr, value_length);
5850 slice result(
nullptr, value_length);
5851 const int err =
put(map, key, &result ,
5868 slice result(
nullptr, value_length);
5890 slice result(
nullptr, value_length);
5896 slice result(
nullptr, value_length);
5937template <
class ALLOCATOR,
typename CAPACITY_POLICY>
5941 typename buffer<ALLOCATOR, CAPACITY_POLICY>::data_preserver result(allocator);
5947template <
class ALLOCATOR,
typename CAPACITY_POLICY>
5951 typename buffer<ALLOCATOR, CAPACITY_POLICY>::data_preserver result(allocator);
5958template <
class ALLOCATOR,
typename CAPACITY_POLICY>
5962 typename buffer<ALLOCATOR, CAPACITY_POLICY>::data_preserver result(allocator);
5975 const void *values_array,
size_t values_count,
put_mode mode,
5976 bool allow_partial) {
5977 MDBX_val args[2] = {{
const_cast<void *
>(values_array), value_length}, {
nullptr, values_count}};
5990 return args[1].iov_len ;
6036 other.handle_ =
nullptr;
6076 bool throw_notfound)
6078 this->
done =
cursor.move(operation, &this->key, &this->value, throw_notfound);
6089 if (!throw_notfound)
6179 return ::mdbx::txn(
txn);
6216 slice result(
nullptr, value_length);
6223 slice result(
nullptr, value_length);
6224 const int err =
put(key, &result ,
6241 slice result(
nullptr, value_length);
6263 slice result(
nullptr, value_length);
6269 slice result(
nullptr, value_length);
6294 bool found =
seek(key);
6295 return found ?
erase(whole_multivalue) : found;
6304 size_t values_count,
put_mode mode,
bool allow_partial) {
6305 MDBX_val args[2] = {{
const_cast<void *
>(values_array), value_length}, {
nullptr, values_count}};
6318 return args[1].iov_len ;
6339template <
class ALLOCATOR,
typename CAPACITY_POLICY>
6340inline string to_string(const ::mdbx::buffer<ALLOCATOR, CAPACITY_POLICY> &buffer) {
6352inline string to_string(const ::mdbx::env::geometry &value) {
6358inline string to_string(const ::mdbx::env::operate_parameters &value) {
6370inline string to_string(const ::mdbx::env::durability &value) {
6376inline string to_string(const ::mdbx::env::reclaiming_options &value) {
6382inline string to_string(const ::mdbx::env::operate_options &value) {
6388inline string to_string(const ::mdbx::env_managed::create_parameters &value) {
6421#if defined(__LCC__) && __LCC__ >= 126
6422#pragma diagnostic pop
#define MDBX_CXX11_CONSTEXPR
Definition mdbx.h:443
#define MDBX_MAYBE_UNUSED
Definition mdbx.h:509
#define MDBX_CXX14_CONSTEXPR
Definition mdbx.h:462
#define MDBX_NOTHROW_PURE_FUNCTION
The 'pure nothrow' function attribute for optimization.
Definition mdbx.h:259
mode_t mdbx_mode_t
Definition mdbx.h:174
int(* MDBX_preserve_func)(void *context, MDBX_val *target, const void *src, size_t bytes)
Definition mdbx.h:5055
#define LIBMDBX_API
Definition mdbx.h:591
#define LIBMDBX_API_TYPE
Definition mdbx.h:606
struct iovec MDBX_val
Generic structure used for passing keys and data in and out of the table. .
Definition mdbx.h:766
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)
pthread_t mdbx_tid_t
Definition mdbx.h:173
struct MDBX_env MDBX_env
Opaque structure for a database environment.
Definition mdbx.h:698
int mdbx_filehandle_t
Definition mdbx.h:171
pid_t mdbx_pid_t
Definition mdbx.h:172
@ MDBX_MAX_PAGESIZE
Definition mdbx.h:780
@ MDBX_MAXDATASIZE
Definition mdbx.h:774
@ MDBX_MAX_DBI
Definition mdbx.h:771
@ MDBX_MIN_PAGESIZE
Definition mdbx.h:777
libmdbx build information
Definition mdbx.h:634
The fours integers markers (aka "canary") associated with the environment.
Definition mdbx.h:4430
Latency of commit stages in 1/65536 of seconds units.
Definition mdbx.h:4079
Information about the environment.
Definition mdbx.h:2805
Statistics for a table in the environment.
Definition mdbx.h:2759
Information about the transaction.
Definition mdbx.h:3981
libmdbx version information,
Definition mdbx.h:616
LIBMDBX_API int mdbx_cursor_del(MDBX_cursor *cursor, MDBX_put_flags_t flags)
Delete current key/data pair.
LIBMDBX_API int mdbx_dbi_sequence(MDBX_txn *txn, MDBX_dbi dbi, uint64_t *result, uint64_t increment)
Sequence generation for a table.
LIBMDBX_API int mdbx_get_equal_or_great(const MDBX_txn *txn, MDBX_dbi dbi, MDBX_val *key, MDBX_val *data)
Get equal or great item from a table.
LIBMDBX_API int mdbx_cursor_scan(MDBX_cursor *cursor, MDBX_predicate_func *predicate, void *context, MDBX_cursor_op start_op, MDBX_cursor_op turn_op, void *arg)
Сканирует таблицу с использованием передаваемого предиката, с уменьшением сопутствующих накладных рас...
LIBMDBX_API int mdbx_canary_put(MDBX_txn *txn, const MDBX_canary *canary)
Set integers markers (aka "canary") associated with the environment.
LIBMDBX_API int mdbx_canary_get(const MDBX_txn *txn, MDBX_canary *canary)
Returns fours integers markers (aka "canary") associated with the environment.
MDBX_put_flags_t
Data changing flags.
Definition mdbx.h:1626
LIBMDBX_API int mdbx_cursor_count(const MDBX_cursor *cursor, size_t *count)
Return count values (aka duplicates) for current key.
LIBMDBX_API int mdbx_cursor_scan_from(MDBX_cursor *cursor, MDBX_predicate_func *predicate, void *context, MDBX_cursor_op from_op, MDBX_val *from_key, MDBX_val *from_value, MDBX_cursor_op turn_op, void *arg)
int MDBX_cmp_func(const MDBX_val *a, const MDBX_val *b) noexcept
A callback function used to compare two keys in a table.
Definition mdbx.h:4490
LIBMDBX_API int mdbx_del(MDBX_txn *txn, MDBX_dbi dbi, const MDBX_val *key, const MDBX_val *data)
Delete items from a table.
LIBMDBX_API int mdbx_get_ex(const MDBX_txn *txn, MDBX_dbi dbi, MDBX_val *key, MDBX_val *data, size_t *values_count)
Get items from a table and optionally number of data items for a given key.
LIBMDBX_API int mdbx_cursor_put(MDBX_cursor *cursor, const MDBX_val *key, MDBX_val *data, MDBX_put_flags_t flags)
Store by cursor.
LIBMDBX_API int mdbx_put(MDBX_txn *txn, MDBX_dbi dbi, const MDBX_val *key, MDBX_val *data, MDBX_put_flags_t flags)
Store items into a table.
LIBMDBX_API int mdbx_drop(MDBX_txn *txn, MDBX_dbi dbi, bool del)
Empty or delete and close a table.
LIBMDBX_API int mdbx_cursor_get(MDBX_cursor *cursor, MDBX_val *key, MDBX_val *data, MDBX_cursor_op op)
Retrieve by cursor.
LIBMDBX_API int mdbx_get(const MDBX_txn *txn, MDBX_dbi dbi, const MDBX_val *key, MDBX_val *data)
Get items from a table.
@ MDBX_MULTIPLE
Definition mdbx.h:1663
@ MDBX_ALLDUPS
Definition mdbx.h:1646
@ MDBX_CURRENT
Definition mdbx.h:1641
@ MDBX_APPENDDUP
Definition mdbx.h:1659
@ MDBX_APPEND
Definition mdbx.h:1654
@ MDBX_UPSERT
Definition mdbx.h:1628
@ MDBX_RESERVE
Definition mdbx.h:1650
@ MDBX_NOOVERWRITE
Definition mdbx.h:1631
LIBMDBX_API int mdbx_cursor_on_first_dup(const MDBX_cursor *cursor)
Определяет стоит ли курсор на первом или единственном мульти-значении соответствующем ключу.
LIBMDBX_API int mdbx_cursor_open(MDBX_txn *txn, MDBX_dbi dbi, MDBX_cursor **cursor)
Create a cursor handle for the specified transaction and DBI handle.
LIBMDBX_API int mdbx_cursor_unbind(MDBX_cursor *cursor)
Unbind cursor from a transaction.
LIBMDBX_API MDBX_cursor * mdbx_cursor_create(void *context)
Create a cursor handle but not bind it to transaction nor DBI-handle.
LIBMDBX_API MDBX_dbi mdbx_cursor_dbi(const MDBX_cursor *cursor)
Return the cursor's table handle.
MDBX_cursor_op
Cursor operationsThis is the set of all operations for retrieving data using a cursor.
Definition mdbx.h:1707
LIBMDBX_API int mdbx_cursor_compare(const MDBX_cursor *left, const MDBX_cursor *right, bool ignore_multival)
Сравнивает позицию курсоров.
LIBMDBX_API int mdbx_cursor_on_last_dup(const MDBX_cursor *cursor)
Определяет стоит ли курсор на последнем или единственном мульти-значении соответствующем ключу.
LIBMDBX_API int mdbx_cursor_on_first(const MDBX_cursor *cursor)
Determines whether the cursor is pointed to the first key-value pair or not.
LIBMDBX_API int mdbx_cursor_bind(MDBX_txn *txn, MDBX_cursor *cursor, MDBX_dbi dbi)
Bind cursor to specified transaction and DBI-handle.
LIBMDBX_API int mdbx_txn_release_all_cursors_ex(const MDBX_txn *txn, bool unbind, size_t *count)
Unbind or closes all cursors of a given transaction and of all its parent transactions if ones are.
struct MDBX_cursor MDBX_cursor
Opaque structure for navigating through a table.
Definition mdbx.h:728
LIBMDBX_API int mdbx_cursor_set_userctx(MDBX_cursor *cursor, void *ctx)
Set application information associated with the cursor.
LIBMDBX_API int mdbx_cursor_eof(const MDBX_cursor *cursor)
Determines whether the cursor is pointed to a key-value pair or not, i.e. was not positioned or point...
LIBMDBX_API int mdbx_cursor_close2(MDBX_cursor *cursor)
Closes a cursor handle with returning error code.
LIBMDBX_API void * mdbx_cursor_get_userctx(const MDBX_cursor *cursor)
Get the application information associated with the MDBX_cursor.
LIBMDBX_API int mdbx_cursor_renew(MDBX_txn *txn, MDBX_cursor *cursor)
Renew a cursor handle for use within the given transaction.
LIBMDBX_API void mdbx_cursor_close(MDBX_cursor *cursor)
Closes a cursor handle without returning error code.
LIBMDBX_API MDBX_txn * mdbx_cursor_txn(const MDBX_cursor *cursor)
Return the cursor's transaction handle.
LIBMDBX_API int mdbx_cursor_on_last(const MDBX_cursor *cursor)
Determines whether the cursor is pointed to the last key-value pair or not.
LIBMDBX_API int mdbx_cursor_copy(const MDBX_cursor *src, MDBX_cursor *dest)
Copy cursor position and state.
@ MDBX_SEEK_AND_GET_MULTIPLE
Definition mdbx.h:1826
@ MDBX_GET_CURRENT
Definition mdbx.h:1722
@ MDBX_GET_BOTH
Definition mdbx.h:1715
@ MDBX_TO_KEY_EQUAL
Definition mdbx.h:1803
@ MDBX_GET_BOTH_RANGE
Definition mdbx.h:1719
@ MDBX_SET_KEY
Definition mdbx.h:1762
@ MDBX_FIRST_DUP
Definition mdbx.h:1712
@ MDBX_TO_KEY_LESSER_OR_EQUAL
Definition mdbx.h:1802
@ MDBX_GET_MULTIPLE
Definition mdbx.h:1727
@ MDBX_TO_EXACT_KEY_VALUE_GREATER_THAN
Definition mdbx.h:1813
@ MDBX_NEXT_NODUP
Definition mdbx.h:1747
@ MDBX_TO_EXACT_KEY_VALUE_LESSER_OR_EQUAL
Definition mdbx.h:1810
@ MDBX_TO_EXACT_KEY_VALUE_EQUAL
Definition mdbx.h:1811
@ MDBX_TO_PAIR_LESSER_OR_EQUAL
Definition mdbx.h:1818
@ MDBX_PREV_MULTIPLE
Definition mdbx.h:1770
@ MDBX_SET_RANGE
Definition mdbx.h:1765
@ MDBX_LAST_DUP
Definition mdbx.h:1733
@ MDBX_PREV
Definition mdbx.h:1750
@ MDBX_TO_PAIR_GREATER_OR_EQUAL
Definition mdbx.h:1820
@ MDBX_TO_PAIR_GREATER_THAN
Definition mdbx.h:1821
@ MDBX_LAST
Definition mdbx.h:1730
@ MDBX_TO_KEY_LESSER_THAN
Definition mdbx.h:1801
@ MDBX_PREV_DUP
Definition mdbx.h:1753
@ MDBX_TO_EXACT_KEY_VALUE_LESSER_THAN
Definition mdbx.h:1809
@ MDBX_SET
Definition mdbx.h:1759
@ MDBX_NEXT
Definition mdbx.h:1736
@ MDBX_TO_KEY_GREATER_OR_EQUAL
Definition mdbx.h:1804
@ MDBX_TO_PAIR_LESSER_THAN
Definition mdbx.h:1817
@ MDBX_NEXT_MULTIPLE
Definition mdbx.h:1744
@ MDBX_PREV_NODUP
Definition mdbx.h:1756
@ MDBX_TO_PAIR_EQUAL
Definition mdbx.h:1819
@ MDBX_NEXT_DUP
Definition mdbx.h:1739
@ MDBX_TO_EXACT_KEY_VALUE_GREATER_OR_EQUAL
Definition mdbx.h:1812
@ MDBX_TO_KEY_GREATER_THAN
Definition mdbx.h:1805
@ MDBX_FIRST
Definition mdbx.h:1709
LIBMDBX_API int mdbx_dbi_rename(MDBX_txn *txn, MDBX_dbi dbi, const char *name)
Переименовает таблицу по DBI-дескриптору
LIBMDBX_API int mdbx_dbi_rename2(MDBX_txn *txn, MDBX_dbi dbi, const MDBX_val *name)
Переименовает таблицу по DBI-дескриптору
LIBMDBX_API int mdbx_dbi_close(MDBX_env *env, MDBX_dbi dbi)
Close a table handle. Normally unnecessary.
LIBMDBX_API int mdbx_dbi_open(MDBX_txn *txn, const char *name, MDBX_db_flags_t flags, MDBX_dbi *dbi)
Open or Create a named table in the environment.
LIBMDBX_API int mdbx_dbi_open2(MDBX_txn *txn, const MDBX_val *name, MDBX_db_flags_t flags, MDBX_dbi *dbi)
Open or Create a named table in the environment.
uint32_t MDBX_dbi
A handle for an individual table (key-value spaces) in the environment.
Definition mdbx.h:721
MDBX_db_flags_t
Table flags.
Definition mdbx.h:1576
@ MDBX_INTEGERDUP
Definition mdbx.h:1600
@ MDBX_DB_ACCEDE
Definition mdbx.h:1618
@ MDBX_DB_DEFAULTS
Definition mdbx.h:1578
@ MDBX_REVERSEKEY
Definition mdbx.h:1581
@ MDBX_DUPFIXED
Definition mdbx.h:1595
@ MDBX_INTEGERKEY
Definition mdbx.h:1591
@ MDBX_REVERSEDUP
Definition mdbx.h:1603
@ MDBX_CREATE
Definition mdbx.h:1606
@ MDBX_DUPSORT
Definition mdbx.h:1584
MDBX_log_level_t
Definition mdbx.h:841
MDBX_debug_flags_t
Runtime debug flags.
Definition mdbx.h:898
LIBMDBX_API int mdbx_env_set_hsr(MDBX_env *env, MDBX_hsr_func *hsr_callback)
Sets a Handle-Slow-Readers callback to resolve database full/overflow issue due to a reader(s) which ...
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) noexcept
A Handle-Slow-Readers callback function to resolve database full/overflow issue due to a reader(s) wh...
Definition mdbx.h:6283
MDBX_error_t
Errors and return codes.
Definition mdbx.h:1834
@ MDBX_FIRST_LMDB_ERRCODE
Definition mdbx.h:1848
@ MDBX_BAD_TXN
Definition mdbx.h:1914
@ MDBX_LAST_LMDB_ERRCODE
Definition mdbx.h:1928
@ MDBX_SUCCESS
Definition mdbx.h:1836
@ MDBX_NOTFOUND
Definition mdbx.h:1851
@ MDBX_RESULT_TRUE
Definition mdbx.h:1842
@ MDBX_BUSY
Definition mdbx.h:1932
@ MDBX_EINVAL
Definition mdbx.h:2005
@ MDBX_ENOMEM
Definition mdbx.h:2007
@ MDBX_FIRST_ADDED_ERRCODE
Definition mdbx.h:1935
@ MDBX_RESULT_FALSE
Definition mdbx.h:1839
@ MDBX_LAST_ADDED_ERRCODE
Definition mdbx.h:1984
@ MDBX_KEYEXIST
Definition mdbx.h:1845
MDBX_env_flags_t
Environment flags.
Definition mdbx.h:1017
LIBMDBX_API int mdbx_estimate_distance(const MDBX_cursor *first, const MDBX_cursor *last, ptrdiff_t *distance_items)
Estimates the distance between cursors as a number of elements.
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)
Estimates the move distance.
LIBMDBX_API int mdbx_estimate_range(const MDBX_txn *txn, MDBX_dbi dbi, const MDBX_val *begin_key, const MDBX_val *begin_data, const MDBX_val *end_key, const MDBX_val *end_data, ptrdiff_t *distance_items)
Estimates the size of a range as a number of elements.
LIBMDBX_API int mdbx_env_get_option(const MDBX_env *env, const MDBX_option_t option, uint64_t *pvalue)
Gets the value of extra runtime options from an environment.
int mdbx_env_set_syncperiod(MDBX_env *env, unsigned seconds_16dot16)
Sets relative period since the last unsteady commit to force flush the data buffers to disk,...
Definition mdbx.h:3049
MDBX_option_t
MDBX environment extra runtime options.
Definition mdbx.h:2115
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)
Set all size-related parameters of environment, including page size and the min/max size of the memor...
int mdbx_env_set_syncbytes(MDBX_env *env, size_t threshold)
Sets threshold to force flush the data buffers to disk, even any of MDBX_SAFE_NOSYNC flag in the envi...
Definition mdbx.h:2988
LIBMDBX_API int mdbx_env_set_option(MDBX_env *env, const MDBX_option_t option, uint64_t value)
Sets the value of a extra runtime options for an environment.
LIBMDBX_API int mdbx_env_set_userctx(MDBX_env *env, void *ctx)
Sets application information (a context pointer) associated with the environment.
LIBMDBX_API int mdbx_env_set_flags(MDBX_env *env, MDBX_env_flags_t flags, bool onoff)
Set environment flags.
@ MDBX_opt_txn_dp_initial
Controls the in-process initial allocation size for dirty pages list of a write transaction....
Definition mdbx.h:2220
@ MDBX_opt_txn_dp_limit
Controls the in-process limit of dirty pages for a write transaction.
Definition mdbx.h:2216
@ MDBX_opt_prefault_write_enable
Controls prevention of page-faults of reclaimed and allocated pages in the MDBX_WRITEMAP mode by clea...
Definition mdbx.h:2320
@ MDBX_opt_max_db
Controls the maximum number of named tables for the environment.
Definition mdbx.h:2124
@ MDBX_opt_merge_threshold_16dot16_percent
Controls the in-process threshold of semi-empty pages merge.
Definition mdbx.h:2287
@ MDBX_opt_sync_bytes
Controls interprocess/shared threshold to force flush the data buffers to disk, if MDBX_SAFE_NOSYNC i...
Definition mdbx.h:2147
@ MDBX_opt_spill_min_denominator
Controls the in-process how minimal part of the dirty pages should be spilled when necessary.
Definition mdbx.h:2252
@ MDBX_opt_spill_parent4child_denominator
Controls the in-process how much of the parent transaction dirty pages will be spilled while start ea...
Definition mdbx.h:2275
@ MDBX_opt_loose_limit
Controls the in-process limit to grow a cache of dirty pages for reuse in the current transaction.
Definition mdbx.h:2187
@ MDBX_opt_rp_augment_limit
Controls the in-process limit to grow a list of reclaimed/recycled page's numbers for finding a seque...
Definition mdbx.h:2174
@ MDBX_opt_max_readers
Defines the maximum number of threads/reader slots for all processes interacting with the database.
Definition mdbx.h:2141
@ MDBX_opt_spill_max_denominator
Controls the in-process how maximal part of the dirty pages may be spilled when necessary.
Definition mdbx.h:2236
@ MDBX_opt_sync_period
Controls interprocess/shared relative period since the last unsteady commit to force flush the data b...
Definition mdbx.h:2153
@ MDBX_opt_dp_reserve_limit
Controls the in-process limit of a pre-allocated memory items for dirty pages.
Definition mdbx.h:2201
@ MDBX_opt_writethrough_threshold
Controls the choosing between use write-through disk writes and usual ones with followed flush by the...
Definition mdbx.h:2315
LIBMDBX_API int mdbx_dbi_stat(const MDBX_txn *txn, MDBX_dbi dbi, MDBX_stat *stat, size_t bytes)
Retrieve statistics for a table.
LIBMDBX_API uint64_t mdbx_txn_id(const MDBX_txn *txn)
Return the transaction's ID.
LIBMDBX_API intptr_t mdbx_limits_valsize_max(intptr_t pagesize, MDBX_db_flags_t flags)
Returns maximal data size in bytes for given page size and table flags, or -1 if pagesize is invalid.
LIBMDBX_API int mdbx_env_info_ex(const MDBX_env *env, const MDBX_txn *txn, MDBX_envinfo *info, size_t bytes)
Return information about the MDBX environment.
int mdbx_env_get_maxreaders(const MDBX_env *env, unsigned *readers)
Get the maximum number of threads/reader slots for the environment.
Definition mdbx.h:3685
int mdbx_env_get_syncperiod(const MDBX_env *env, unsigned *period_seconds_16dot16)
Get relative period since the last unsteady commit to force flush the data buffers to disk,...
Definition mdbx.h:3069
LIBMDBX_API int mdbx_env_get_maxkeysize_ex(const MDBX_env *env, MDBX_db_flags_t flags)
Returns the maximum size of keys can put.
LIBMDBX_API int mdbx_env_get_maxvalsize_ex(const MDBX_env *env, MDBX_db_flags_t flags)
Returns the maximum size of data we can put.
LIBMDBX_API int mdbx_env_stat_ex(const MDBX_env *env, const MDBX_txn *txn, MDBX_stat *stat, size_t bytes)
Return statistics about the MDBX environment.
LIBMDBX_API int mdbx_env_get_pairsize4page_max(const MDBX_env *env, MDBX_db_flags_t flags)
Returns maximal size of key-value pair to fit in a single page for specified table flags.
int mdbx_env_get_syncbytes(const MDBX_env *env, size_t *threshold)
Get threshold to force flush the data buffers to disk, even any of MDBX_SAFE_NOSYNC flag in the envir...
Definition mdbx.h:3006
LIBMDBX_API intptr_t mdbx_limits_valsize4page_max(intptr_t pagesize, MDBX_db_flags_t flags)
Returns maximal data size in bytes to fit in a leaf-page or single large/overflow-page with the given...
LIBMDBX_API intptr_t mdbx_limits_txnsize_max(intptr_t pagesize)
Returns maximal write transaction size (i.e. limit for summary volume of dirty pages) in bytes for gi...
LIBMDBX_API int mdbx_dbi_dupsort_depthmask(const MDBX_txn *txn, MDBX_dbi dbi, uint32_t *mask)
Retrieve depth (bitmask) information of nested dupsort (multi-value) B+trees for given table.
LIBMDBX_API int mdbx_txn_info(const MDBX_txn *txn, MDBX_txn_info *info, bool scan_rlt)
Return information about the MDBX transaction.
LIBMDBX_API int mdbx_is_dirty(const MDBX_txn *txn, const void *ptr)
Determines whether the given address is on a dirty database page of the transaction or not.
MDBX_dbi_state_t
DBI state bits returted by mdbx_dbi_flags_ex()
Definition mdbx.h:4755
LIBMDBX_API int mdbx_env_get_valsize4page_max(const MDBX_env *env, MDBX_db_flags_t flags)
Returns maximal data size in bytes to fit in a leaf-page or single large/overflow-page for specified ...
LIBMDBX_API int mdbx_env_get_fd(const MDBX_env *env, mdbx_filehandle_t *fd)
Return the file descriptor for the given environment.
LIBMDBX_API void * mdbx_env_get_userctx(const MDBX_env *env)
Returns an application information (a context pointer) associated with the environment.
int mdbx_env_get_maxdbs(const MDBX_env *env, MDBX_dbi *dbs)
Get the maximum number of named tables for the environment.
Definition mdbx.h:3730
LIBMDBX_API intptr_t mdbx_limits_keysize_max(intptr_t pagesize, MDBX_db_flags_t flags)
Returns maximal key size in bytes for given page size and table flags, or -1 if pagesize is invalid.
LIBMDBX_API int mdbx_reader_list(const MDBX_env *env, MDBX_reader_list_func *func, void *ctx)
Enumerate the entries in the reader lock table.
LIBMDBX_API intptr_t mdbx_limits_pairsize4page_max(intptr_t pagesize, MDBX_db_flags_t flags)
Returns maximal size of key-value pair to fit in a single page with the given size and table flags,...
LIBMDBX_API intptr_t mdbx_limits_dbsize_max(intptr_t pagesize)
Returns maximal database size in bytes for given page size, or -1 if pagesize is invalid.
LIBMDBX_API intptr_t mdbx_limits_dbsize_min(intptr_t pagesize)
Returns minimal database size in bytes for given page size, or -1 if pagesize is invalid.
LIBMDBX_API int mdbx_env_get_flags(const MDBX_env *env, unsigned *flags)
Get environment flags.
LIBMDBX_API int mdbx_dbi_flags_ex(const MDBX_txn *txn, MDBX_dbi dbi, unsigned *flags, unsigned *state)
Retrieve the DB flags and status for a table handle.
LIBMDBX_API int mdbx_txn_break(MDBX_txn *txn)
Marks transaction as broken to prevent further operations.
LIBMDBX_API int mdbx_txn_set_userctx(MDBX_txn *txn, void *ctx)
Sets application information associated (a context pointer) with the transaction.
LIBMDBX_API int mdbx_txn_park(MDBX_txn *txn, bool autounpark)
Переводит читающую транзакцию в "припаркованное" состояние.
LIBMDBX_API int mdbx_txn_unpark(MDBX_txn *txn, bool restart_if_ousted)
Распарковывает ранее припаркованную читающую транзакцию.
MDBX_txn_flags_t
Definition mdbx.h:1478
LIBMDBX_API void * mdbx_txn_get_userctx(const MDBX_txn *txn)
Returns an application information (a context pointer) associated with the transaction.
int mdbx_txn_begin(MDBX_env *env, MDBX_txn *parent, MDBX_txn_flags_t flags, MDBX_txn **txn)
Create a transaction for use with the environment.
Definition mdbx.h:3950
struct MDBX_txn MDBX_txn
Opaque structure for a transaction handle.
Definition mdbx.h:709
LIBMDBX_API int mdbx_txn_reset(MDBX_txn *txn)
Reset a read-only transaction.
LIBMDBX_API int mdbx_txn_renew(MDBX_txn *txn)
Renew a read-only transaction.
LIBMDBX_API MDBX_txn_flags_t mdbx_txn_flags(const MDBX_txn *txn)
Return the transaction's flags.
@ MDBX_TXN_RDONLY
Definition mdbx.h:1489
@ MDBX_TXN_RDONLY_PREPARE
Definition mdbx.h:1498
@ MDBX_TXN_READWRITE
Definition mdbx.h:1483
@ MDBX_TXN_TRY
Definition mdbx.h:1504
bool rename_map(const ::mdbx::slice &old_name, const ::mdbx::slice &new_name, bool throw_if_absent=false)
Переименовывает таблицу ключ-значение.
MDBX_NOTHROW_PURE_FUNCTION constexpr bool is_reference() const noexcept
Checks whether the buffer just refers to data located outside the buffer, rather than stores it.
Definition mdbx.h++:1913
MDBX_CXX14_CONSTEXPR struct slice tail(size_t n) const noexcept
Definition mdbx.h++:2462
buffer & assign(const void *begin, const void *end, bool make_reference=false)
Definition mdbx.h++:2317
buffer(size_t head_room, const struct slice &src, size_t tail_room, const allocator_type &allocator=allocator_type())
Definition mdbx.h++:2083
friend class env
Definition mdbx.h++:4069
MDBX_commit_latency commit_latency
Definition mdbx.h++:4103
env_managed(const char *pathname, const operate_parameters &, bool accede=true)
MDBX_CXX14_CONSTEXPR struct slice middle(size_t from, size_t n) const noexcept
Definition mdbx.h++:2466
::MDBX_txn_info info
Definition mdbx.h++:3764
cursor_managed(void *your_context=nullptr)
Creates a new managed cursor with underlying object.
Definition mdbx.h++:4533
::MDBX_stat map_stat
Definition mdbx.h++:3921
env & set_sync_period(const duration &period)
Sets relative period since the last unsteady commit to force flush the data buffers to disk,...
MDBX_NOTHROW_PURE_FUNCTION constexpr size_t size() const noexcept
Returns the number of bytes.
Definition mdbx.h++:2375
txn_managed start_nested()
Start nested write transaction.
extra_runtime_option
MDBX environment extra runtime options.
Definition mdbx.h++:3474
@ prefault_write_enable
Controls prevention of page-faults of reclaimed and allocated pages in the MDBX_WRITEMAP mode by clea...
Definition mdbx.h++:3508
@ spill_min_denominator
Controls the in-process how minimal part of the dirty pages should be spilled when necessary.
Definition mdbx.h++:3500
@ spill_parent4child_denominator
Controls the in-process how much of the parent transaction dirty pages will be spilled while start ea...
Definition mdbx.h++:3502
@ writethrough_threshold
Controls the choosing between use write-through disk writes and usual ones with followed flush by the...
Definition mdbx.h++:3506
@ sync_bytes
Controls interprocess/shared threshold to force flush the data buffers to disk, if MDBX_SAFE_NOSYNC i...
Definition mdbx.h++:3483
@ dp_limit
Controls the in-process limit of dirty pages for a write transaction.
Definition mdbx.h++:3494
@ dp_initial
Controls the in-process initial allocation size for dirty pages list of a write transaction....
Definition mdbx.h++:3496
@ spill_max_denominator
Controls the in-process how maximal part of the dirty pages may be spilled when necessary.
Definition mdbx.h++:3498
@ merge_threshold_16dot16_percent
Controls the in-process threshold of semi-empty pages merge.
Definition mdbx.h++:3504
@ rp_augment_limit
Controls the in-process limit to grow a list of reclaimed/recycled page's numbers for finding a seque...
Definition mdbx.h++:3488
@ loose_limit
Controls the in-process limit to grow a cache of dirty pages for reuse in the current transaction.
Definition mdbx.h++:3490
@ dp_reserve_limit
Controls the in-process limit of a pre-allocated memory items for dirty pages.
Definition mdbx.h++:3492
static buffer key_from(silo &&src) noexcept
Definition mdbx.h++:2631
env_managed & operator=(env_managed &&other) noexcept
Definition mdbx.h++:3701
MDBX_CXX14_CONSTEXPR struct slice safe_middle(size_t from, size_t n) const
Definition mdbx.h++:2478
MDBX_CXX14_CONSTEXPR int64_t as_int64() const
Definition mdbx.h++:2138
constexpr allocator_type get_allocator() const
Definition mdbx.h++:1902
bool drop_map(const ::std::string_view &name, bool throw_if_absent=false)
Drop key-value map.
Definition mdbx.h++:3902
env_managed(const char *pathname, const create_parameters &, const operate_parameters &, bool accede=true)
map_handle(const map_handle &) noexcept=default
void reserve_tailroom(size_t wanna_tailroom)
Reserves space after the payload.
Definition mdbx.h++:2268
::MDBX_db_flags_t flags
Definition mdbx.h++:2984
path get_path() const
Return the path that was used for opening the environment.
static buffer hex_decode(const ::mdbx::slice &source, bool ignore_spaces=false, const allocator_type &allocator=allocator_type())
Decodes hexadecimal dump from the slice content to returned buffer.
Definition mdbx.h++:2217
int64_t as_int64_adapt() const
Definition mdbx.h++:2154
constexpr ::std::basic_string< CHAR, T, A > as_string(const A &allocator=A()) const
Definition mdbx.h++:2384
move_result to_exact_key_value_lesser_or_equal(const slice &key, const slice &value, bool throw_notfound=true)
Definition mdbx.h++:4383
move_result previous_multiple_samelength(bool throw_notfound=false)
Definition mdbx.h++:4439
buffer encode_base64(unsigned wrap_width=0, const allocator_type &allocator=allocator_type()) const
Definition mdbx.h++:2212
static buffer key_from(const double *ieee754_64bit)
Definition mdbx.h++:2637
static buffer base58(const POD &pod, unsigned wrap_width=0, const allocator_type &allocator=allocator_type())
Returns a new buffer with a Base58 dump of the given pod.
Definition mdbx.h++:2188
MDBX_NOTHROW_PURE_FUNCTION MDBX_CXX14_CONSTEXPR size_t length() const noexcept
Returns the number of bytes.
Definition mdbx.h++:1993
static bool remove(const ::std::wstring &pathname, const remove_mode mode=just_remove)
MDBX_CXX14_CONSTEXPR ::std::span< const POD > as_span() const
Definition mdbx.h++:2109
MDBX_CXX11_CONSTEXPR map_handle(MDBX_dbi dbi) noexcept
Definition mdbx.h++:2978
buffer & assign(const char *c_str, bool make_reference=false)
Definition mdbx.h++:2326
void reserve(size_t wanna_headroom, size_t wanna_tailroom)
Reserves storage space.
Definition mdbx.h++:2255
buffer & assign(const struct slice &src, bool make_reference=false)
Definition mdbx.h++:2297
void reserve_headroom(size_t wanna_headroom)
Reserves space before the payload.
Definition mdbx.h++:2265
durability
Durability level.
Definition mdbx.h++:3131
@ lazy_weak_tail
Definition mdbx.h++:3134
@ robust_synchronous
Definition mdbx.h++:3132
@ whole_fragile
Definition mdbx.h++:3135
@ half_synchronous_weak_last
Definition mdbx.h++:3133
void commit_embark_read()
Commit all the operations of a transaction into the database and then start read transaction.
constexpr buffer(const buffer &src, const allocator_type &allocator=allocator_type())
Definition mdbx.h++:2051
MDBX_CXX11_CONSTEXPR txn_managed() noexcept=default
MDBX_CXX11_CONSTEXPR bool is_null() const noexcept
Checks whether the data pointer of the buffer is nullptr.
Definition mdbx.h++:2372
::std::allocator_traits< allocator_type > allocator_traits
Definition mdbx.h++:1475
static buffer base64_decode(const ::mdbx::slice &source, bool ignore_spaces=false, const allocator_type &allocator=allocator_type())
Decodes Base64 dump from the slice content to returned buffer.
Definition mdbx.h++:2231
size_t dbsize_min() const
Returns the minimal database size in bytes for the environment.
Definition mdbx.h++:3301
buffer & append_decoded_hex(const struct slice &data, bool ignore_spaces=false)
Definition mdbx.h++:2526
map_handle & operator=(const map_handle &) noexcept=default
duration sync_period() const
Gets relative period since the last unsteady commit that used to force flush the data buffers to disk...
buffer(const ::std::basic_string_view< CHAR, T > &view, bool make_reference, const allocator_type &allocator=allocator_type())
Definition mdbx.h++:2041
MDBX_NOTHROW_PURE_FUNCTION MDBX_CXX14_CONSTEXPR size_t hash_value() const noexcept
Returns the hash value of the data.
Definition mdbx.h++:2381
MDBX_NOTHROW_PURE_FUNCTION constexpr size_t tailroom() const noexcept
Returns the number of bytes that available in currently allocated storage after the currently data en...
Definition mdbx.h++:1928
move_result seek_multiple_samelength(const slice &key, bool throw_notfound=true)
Definition mdbx.h++:4427
buffer & assign_freestanding(const void *ptr, size_t bytes)
Definition mdbx.h++:2276
constexpr void swap(buffer &other) noexcept(swap_alloc::is_nothrow())
Definition mdbx.h++:2282
buffer & operator=(const buffer &src)
Definition mdbx.h++:2343
estimate_result estimate(move_operation operation, slice &key) const
uint16_t as_uint16_adapt() const
Definition mdbx.h++:2148
buffer & append_u16(uint_fast16_t u16)
Definition mdbx.h++:2548
MDBX_NOTHROW_PURE_FUNCTION constexpr bool is_freestanding() const noexcept
Checks whether data chunk stored inside the buffer, otherwise buffer just refers to data located outs...
Definition mdbx.h++:1906
static bool remove(const char *pathname, const remove_mode mode=just_remove)
friend class cursor
Definition mdbx.h++:3725
move_result to_pair_equal(const slice &key, const slice &value, bool throw_notfound=true)
Definition mdbx.h++:4402
::MDBX_canary canary
Definition mdbx.h++:3930
env & copy(const wchar_t *destination, bool compactify, bool force_dynamic_size=false)
void safe_remove_suffix(size_t n)
Drops the last "n" bytes from the data chunk.
Definition mdbx.h++:2428
void safe_remove_prefix(size_t n)
Drops the first "n" bytes from the data chunk.
Definition mdbx.h++:2424
bool is_readwrite() const
Checks whether the transaction is read-write.
Definition mdbx.h++:3762
MDBX_CXX11_CONSTEXPR void * end() noexcept
Return a pointer to the end of the referenced data.
Definition mdbx.h++:1987
map_handle open_map_accede(const ::std::string_view &name) const
Open existing key-value map.
move_result move(move_operation operation, const slice &key, const slice &value, bool throw_notfound)
Definition mdbx.h++:4332
MDBX_CXX11_CONSTEXPR const void * data() const noexcept
Return a const pointer to the beginning of the referenced data.
Definition mdbx.h++:1973
static buffer key_from(const ::std::basic_string< CHAR, T, A > &src, bool make_reference=false)
Definition mdbx.h++:2627
env_managed(const wchar_t *pathname, const operate_parameters &, bool accede=true)
move_result to_pair_lesser_than(const slice &key, const slice &value, bool throw_notfound=true)
Definition mdbx.h++:4396
buffer base64_decode(bool ignore_spaces=false, const allocator_type &allocator=allocator_type()) const
Decodes Base64 dump from the buffer content to new returned buffer.
Definition mdbx.h++:2250
bool clear_map(const char *name, bool throw_if_absent=false)
buffer & add_header(const void *src, size_t bytes)
Definition mdbx.h++:2490
uint8_t as_uint8_adapt() const
Definition mdbx.h++:2149
MDBX_NOTHROW_PURE_FUNCTION bool starts_with(const struct slice &prefix) const noexcept
Checks if the data starts with the given prefix.
Definition mdbx.h++:2394
move_result to_pair_exact(const slice &key, const slice &value, bool throw_notfound=true)
Definition mdbx.h++:4405
buffer encode_base58(unsigned wrap_width=0, const allocator_type &allocator=allocator_type()) const
Definition mdbx.h++:2207
MDBX_CXX14_CONSTEXPR struct slice safe_tail(size_t n) const
Definition mdbx.h++:2474
void rename_map(map_handle map, const ::std::string_view &new_name)
Переименовывает таблицу ключ-значение.
env & copy(filehandle fd, bool compactify, bool force_dynamic_size=false)
Copy an environment to the specified file descriptor.
::std::basic_string_view< CHAR, T > string_view() const noexcept
Definition mdbx.h++:2358
buffer(size_t head_room, const buffer &src, size_t tail_room, const allocator_type &allocator=allocator_type())
Definition mdbx.h++:2091
buffer & assign(const ::std::basic_string< CHAR, T, A > &str, bool make_reference=false)
Definition mdbx.h++:2322
env_managed(const ::mdbx::filesystem::path &pathname, const operate_parameters &, bool accede=true)
Open existing database.
static buffer key_from_jsonInteger(const int64_t json_integer)
Definition mdbx.h++:2647
static buffer hex(const POD &pod, bool uppercase=false, unsigned wrap_width=0, const allocator_type &allocator=allocator_type())
Returns a new buffer with a hexadecimal dump of the given pod.
Definition mdbx.h++:2180
static bool remove(const ::std::string &pathname, const remove_mode mode=just_remove)
void put(const pair &kv, put_mode mode)
Definition mdbx.h++:4486
move_result current(bool throw_notfound=true) const
Definition mdbx.h++:4350
MDBX_CXX14_CONSTEXPR uint128_t as_uint128() const
Definition mdbx.h++:2128
MDBX_CXX14_CONSTEXPR ::std::span< POD > as_span()
Definition mdbx.h++:2112
env & copy(const char *destination, bool compactify, bool force_dynamic_size=false)
move_result to_previous_last_multi(bool throw_notfound=true)
Definition mdbx.h++:4341
MDBX_CXX14_CONSTEXPR buffer & set_end(const void *ptr)
Sets the length by specifying the end of the data.
Definition mdbx.h++:2005
static buffer key_from(const float ieee754_32bit)
Definition mdbx.h++:2653
static bool remove(const ::mdbx::filesystem::path &pathname, const remove_mode mode=just_remove)
Removes the environment's files in a proper and multiprocess-safe way.
bool drop_map(const char *name, bool throw_if_absent=false)
Drops key-value map using name.
MDBX_CXX11_CONSTEXPR map_handle() noexcept
Definition mdbx.h++:2977
bool is_same_or_after_than(const cursor &other, bool ignore_nested=false) const
Definition mdbx.h++:4167
size_t unbind_all_cursors() const
Unbind all cursors.
Definition mdbx.h++:3809
static buffer hex(const ::mdbx::slice &source, bool uppercase=false, unsigned wrap_width=0, const allocator_type &allocator=allocator_type())
Returns a new buffer with a hexadecimal dump of the slice content.
Definition mdbx.h++:2160
void upsert(map_handle map, const pair &kv)
Definition mdbx.h++:3985
move_result to_key_greater_or_equal(const slice &key, bool throw_notfound=true)
Definition mdbx.h++:4373
bool is_same_position(const cursor &other, bool ignore_nested=false) const
Definition mdbx.h++:4159
buffer(const buffer &src, bool make_reference, const allocator_type &allocator=allocator_type())
Definition mdbx.h++:2027
bool is_after_than(const cursor &other, bool ignore_nested=false) const
Definition mdbx.h++:4163
static buffer base58_decode(const ::mdbx::slice &source, bool ignore_spaces=false, const allocator_type &allocator=allocator_type())
Decodes Base58 dump from the slice content to returned buffer.
Definition mdbx.h++:2224
buffer & operator=(const ::std::basic_string_view< CHAR, T > &view) noexcept
Definition mdbx.h++:2352
uint32_t as_uint32_adapt() const
Definition mdbx.h++:2147
buffer(size_t head_room, size_t tail_room, const allocator_type &allocator=allocator_type())
Definition mdbx.h++:2073
constexpr buffer() noexcept=default
static buffer key_from_double(const double ieee754_64bit)
Definition mdbx.h++:2633
void remove_suffix(size_t n) noexcept
Drops the last "n" bytes from the data chunk.
Definition mdbx.h++:2420
env_managed & operator=(const env_managed &)=delete
map_handle create_map(const ::std::string_view &name, const ::mdbx::key_mode key_mode=::mdbx::key_mode::usual, const ::mdbx::value_mode value_mode=::mdbx::value_mode::single)
Create new or open existing key-value map.
Definition mdbx.h++:3894
buffer & assign(struct slice &&src, bool make_reference=false)
Definition mdbx.h++:2305
static size_t default_pagesize() noexcept
Returns default page size for current system/platform.
Definition mdbx.h++:3228
MDBX_CXX11_CONSTEXPR cursor() noexcept=default
MDBX_CXX14_CONSTEXPR uint32_t as_uint32() const
Definition mdbx.h++:2131
move_result to_next_first_multi(bool throw_notfound=true)
Definition mdbx.h++:4357
buffer & assign(const void *ptr, size_t bytes, bool make_reference=false)
Definition mdbx.h++:2293
MDBX_cursor * withdraw_handle() noexcept
Definition mdbx.h++:4555
bool clear_map(const ::mdbx::slice &name, bool throw_if_absent=false)
void clear_and_reserve(size_t whole_capacity, size_t headroom=0) noexcept
Clears the contents and reserve storage.
Definition mdbx.h++:2407
static buffer base64(const POD &pod, unsigned wrap_width=0, const allocator_type &allocator=allocator_type())
Returns a new buffer with a Base64 dump of the given pod.
Definition mdbx.h++:2195
MDBX_txn * handle_
Definition mdbx.h++:3726
void abort()
Abandon all the operations of the transaction instead of saving ones.
static buffer key_from_u64(const uint64_t unsigned_int64)
Definition mdbx.h++:2639
move_result move(move_operation operation, const slice &key, bool throw_notfound)
Definition mdbx.h++:4329
mode
Operation mode.
Definition mdbx.h++:3123
@ write_mapped_io
Definition mdbx.h++:3126
@ nested_transactions
Definition mdbx.h++:3127
@ readonly
Definition mdbx.h++:3124
@ write_file_io
Definition mdbx.h++:3125
move_result move(move_operation operation, bool throw_notfound)
Definition mdbx.h++:4326
MDBX_CXX14_CONSTEXPR ::std::span< const byte > bytes() const
Definition mdbx.h++:2114
bool scan_from(CALLABLE_PREDICATE predicate, slice &from, move_operation start=key_greater_or_equal, move_operation turn=next)
Definition mdbx.h++:4285
::MDBX_envinfo info
Information about the environment.
Definition mdbx.h++:3362
operator::mdbx::txn() const
Definition mdbx.h++:4468
MDBX_NOTHROW_PURE_FUNCTION constexpr size_t headroom() const noexcept
Returns the number of bytes that available in currently allocated storage ahead the currently beginni...
Definition mdbx.h++:1922
buffer & append_base64(const struct slice &data, unsigned wrap_width=0)
Definition mdbx.h++:2522
MDBX_env * handle_
Definition mdbx.h++:3025
static buffer key_from(const ::std::basic_string_view< CHAR, T > &src, bool make_reference=false)
Definition mdbx.h++:2619
move_result to_exact_key_value_greater_or_equal(const slice &key, const slice &value, bool throw_notfound=true)
Definition mdbx.h++:4389
buffer & append_byte(uint_fast8_t byte)
Definition mdbx.h++:2546
commit_latency commit_get_latency()
Commit all the operations of a transaction into the database and return latency information.
Definition mdbx.h++:4116
static buffer base58(const ::mdbx::slice &source, unsigned wrap_width=0, const allocator_type &allocator=allocator_type())
Returns a new buffer with a Base58 dump of the slice content.
Definition mdbx.h++:2167
bool is_same_or_before_than(const cursor &other, bool ignore_nested=false) const
Definition mdbx.h++:4155
static buffer key_from_float(const float ieee754_32bit)
Definition mdbx.h++:2651
buffer(const struct slice &src, bool make_reference, const allocator_type &allocator=allocator_type())
Definition mdbx.h++:2021
MDBX_CXX14_CONSTEXPR int128_t as_int128() const
Definition mdbx.h++:2136
move_result to_first(bool throw_notfound=true)
Definition mdbx.h++:4339
buffer hex_decode(bool ignore_spaces=false, const allocator_type &allocator=allocator_type()) const
Decodes hexadecimal dump from the buffer content to new returned buffer.
Definition mdbx.h++:2238
move_result to_last(bool throw_notfound=true)
Definition mdbx.h++:4359
buffer & operator=(const struct slice &src)
Definition mdbx.h++:2347
constexpr buffer(const void *ptr, size_t bytes, const allocator_type &allocator=allocator_type())
Definition mdbx.h++:2054
buffer(const ::mdbx::txn &txn, const struct slice &src, const allocator_type &allocator=allocator_type())
void close()
Explicitly closes the cursor.
Definition mdbx.h++:4539
MDBX_NOTHROW_PURE_FUNCTION constexpr bool empty() const noexcept
Checks whether the string is empty.
Definition mdbx.h++:2369
constexpr buffer(const ::std::basic_string< CHAR, T, A > &str, const allocator_type &allocator=allocator_type())
Definition mdbx.h++:2058
buffer & append_base58(const struct slice &data, unsigned wrap_width=0)
Definition mdbx.h++:2518
MDBX_CXX11_CONSTEXPR void * data() noexcept
Return a pointer to the beginning of the referenced data.
Definition mdbx.h++:1980
MDBX_CXX11_CONSTEXPR const struct slice & slice() const noexcept
Definition mdbx.h++:2099
bool is_pristine() const
Returns true for a freshly created database, but false if at least one transaction was committed.
move_result to_key_exact(const slice &key, bool throw_notfound=true)
Definition mdbx.h++:4370
bool is_readonly() const
Checks whether the transaction is read-only.
Definition mdbx.h++:3759
MDBX_CXX11_CONSTEXPR const char * char_ptr() const noexcept
Returns casted to const pointer to char an address of data.
Definition mdbx.h++:1953
buffer & assign(::MDBX_val &&src, bool make_reference=false)
Definition mdbx.h++:2311
static buffer key_from(const float *ieee754_32bit)
Definition mdbx.h++:2655
constexpr buffer(const ::std::basic_string_view< CHAR, T > &view, const allocator_type &allocator=allocator_type())
Definition mdbx.h++:2068
buffer & append_u48(uint_fast64_t u48)
Definition mdbx.h++:2581
move_result next_multiple_samelength(bool throw_notfound=false)
Definition mdbx.h++:4435
env_managed(const ::std::wstring &pathname, const operate_parameters &, bool accede=true)
MDBX_CXX14_CONSTEXPR uint8_t as_uint8() const
Definition mdbx.h++:2133
MDBX_CXX14_CONSTEXPR int16_t as_int16() const
Definition mdbx.h++:2140
void append(map_handle map, const pair &kv, bool multivalue_order_preserved=true)
Definition mdbx.h++:4033
cursor_managed & operator=(const cursor_managed &)=delete
default_capacity_policy reservation_policy
Definition mdbx.h++:1476
remove_mode
Deletion modes for remove().
Definition mdbx.h++:3332
@ ensure_unused
Make sure that the environment is not being used by other processes, or return an error otherwise.
Definition mdbx.h++:3342
@ wait_for_unused
Wait until other processes closes the environment before deletion.
Definition mdbx.h++:3344
@ just_remove
Just delete the environment's files and directory if any.
Definition mdbx.h++:3339
MDBX_CXX14_CONSTEXPR byte & at(size_t n)
Accesses the specified byte of data chunk with bounds checking.
Definition mdbx.h++:2450
static buffer key_from(const int64_t signed_int64)
Definition mdbx.h++:2645
MDBX_CXX11_CONSTEXPR byte * byte_ptr() noexcept
Returns casted to pointer to byte an address of data.
Definition mdbx.h++:1940
bool scan(CALLABLE_PREDICATE predicate, move_operation start=first, move_operation turn=next)
Definition mdbx.h++:4261
move_result to_current_first_multi(bool throw_notfound=true)
Definition mdbx.h++:4344
buffer & operator=(struct slice &&src)
Definition mdbx.h++:2349
buffer & add_header(const struct slice &chunk)
Definition mdbx.h++:2498
MDBX_CXX14_CONSTEXPR ::std::span< const char > chars() const
Definition mdbx.h++:2116
buffer & append_u32(uint_fast32_t u32)
Definition mdbx.h++:2569
buffer & append_decoded_base58(const struct slice &data, bool ignore_spaces=false)
Definition mdbx.h++:2530
bool scan_from(CALLABLE_PREDICATE predicate, pair &from, move_operation start=pair_greater_or_equal, move_operation turn=next)
Definition mdbx.h++:4306
uint128_t as_uint128_adapt() const
Definition mdbx.h++:2144
cursor_managed & operator=(cursor_managed &&other) noexcept
Definition mdbx.h++:4545
::MDBX_dbi_state_t state
Definition mdbx.h++:2985
MDBX_CXX14_CONSTEXPR uint16_t as_uint16() const
Definition mdbx.h++:2132
env_managed(env_managed &&)=default
bool poll_sync_to_disk()
Performs non-blocking polling of sync-to-disk thresholds.
Definition mdbx.h++:3531
void put_multiple_samelength(const slice &key, const ::std::vector< VALUE > &vector, put_mode mode)
Definition mdbx.h++:4513
cursor_managed(cursor_managed &&)=default
void commit(commit_latency &latency)
Commit all the operations of a transaction into the database and collect latency information.
Definition mdbx.h++:4111
MDBX_CXX14_CONSTEXPR byte at(size_t n) const
Accesses the specified byte of data chunk with bounds checking.
Definition mdbx.h++:2446
static bool remove(const wchar_t *pathname, const remove_mode mode=just_remove)
size_t key_max(key_mode mode) const
Returns the maximal key size in bytes for specified keys mode.
Definition mdbx.h++:3307
MDBX_CXX14_CONSTEXPR POD as_pod() const
Definition mdbx.h++:2125
move_result to_pair_lesser_or_equal(const slice &key, const slice &value, bool throw_notfound=true)
Definition mdbx.h++:4399
env & copy(const ::mdbx::filesystem::path &destination, bool compactify, bool force_dynamic_size=false)
Make a copy (backup) of an existing environment to the specified path.
static buffer key_from_i32(const int32_t signed_int32)
Definition mdbx.h++:2661
move_result get_multiple_samelength(bool throw_notfound=false)
Definition mdbx.h++:4431
move_result to_key_lesser_than(const slice &key, bool throw_notfound=true)
Definition mdbx.h++:4361
move_result to_next(bool throw_notfound=true)
Definition mdbx.h++:4358
env_managed(const ::std::string &pathname, const operate_parameters &, bool accede=true)
MDBX_CXX14_CONSTEXPR size_t operator()(::mdbx::slice const &slice) const noexcept
Definition mdbx.h++:6415
operator::mdbx::map_handle() const
Definition mdbx.h++:4469
size_t dbsize_max() const
Returns the maximal database size in bytes for the environment.
Definition mdbx.h++:3303
buffer encode_hex(bool uppercase=false, unsigned wrap_width=0, const allocator_type &allocator=allocator_type()) const
Definition mdbx.h++:2200
static buffer wrap(const POD &pod, bool make_reference=false, const allocator_type &allocator=allocator_type())
Definition mdbx.h++:2121
static buffer key_from_u32(const uint32_t unsigned_int32)
Definition mdbx.h++:2657
void remove_prefix(size_t n) noexcept
Drops the first "n" bytes from the data chunk.
Definition mdbx.h++:2416
bool drop_map(const ::mdbx::slice &name, bool throw_if_absent=false)
Drop key-value map.
size_t close_all_cursors() const
Close all cursors.
Definition mdbx.h++:3806
static buffer key_from(const uint32_t unsigned_int32)
Definition mdbx.h++:2659
buffer & assign_reference(const void *ptr, size_t bytes)
Definition mdbx.h++:2270
void commit()
Commit all the operations of a transaction into the database.
move_result to_key_greater_than(const slice &key, bool throw_notfound=true)
Definition mdbx.h++:4376
size_t get_pagesize() const
Returns pagesize of this MDBX environment.
Definition mdbx.h++:3368
void make_freestanding()
Makes buffer owning the data.
Definition mdbx.h++:2013
void put(map_handle map, const pair &kv, put_mode mode)
Definition mdbx.h++:3982
MDBX_CXX14_CONSTEXPR buffer & set_length(size_t bytes)
Set length of data.
Definition mdbx.h++:1998
env_managed(const ::std::string &pathname, const create_parameters &, const operate_parameters &, bool accede=true)
buffer & assign(const ::MDBX_val &src, bool make_reference=false)
Definition mdbx.h++:2301
MDBX_CXX14_CONSTEXPR int32_t as_int32() const
Definition mdbx.h++:2139
friend int compare_position(const cursor &left, const cursor &right, bool ignore_nested)
Definition mdbx.h++:6062
buffer(const char *c_str, bool make_reference, const allocator_type &allocator=allocator_type())
Definition mdbx.h++:2036
constexpr buffer(const struct slice &src, const allocator_type &allocator=allocator_type())
Definition mdbx.h++:2047
MDBX_CXX11_CONSTEXPR byte operator[](size_t n) const noexcept
Accesses the specified byte of data chunk.
Definition mdbx.h++:2432
void put_multiple_samelength(map_handle map, const slice &key, const ::std::vector< VALUE > &vector, put_mode mode)
Definition mdbx.h++:4049
MDBX_CXX14_CONSTEXPR struct slice safe_head(size_t n) const
Definition mdbx.h++:2470
env_managed(const wchar_t *pathname, const create_parameters &, const operate_parameters &, bool accede=true)
size_t transaction_size_max() const
Returns the maximal write transaction size (i.e. limit for summary volume of dirty pages) in bytes.
Definition mdbx.h++:3314
map_handle open_map(const ::std::string_view &name, const ::mdbx::key_mode key_mode=::mdbx::key_mode::usual, const ::mdbx::value_mode value_mode=::mdbx::value_mode::single) const
Open existing key-value map.
Definition mdbx.h++:3887
allocation_aware_details::move_assign_alloc< silo, allocator_type > move_assign_alloc
Definition mdbx.h++:1898
int32_t as_int32_adapt() const
Definition mdbx.h++:2155
buffer & assign(const buffer &src, bool make_reference=false)
Definition mdbx.h++:2291
size_t put_multiple_samelength(map_handle map, const slice &key, const VALUE *values_array, size_t values_count, put_mode mode, bool allow_partial=false)
Definition mdbx.h++:4041
MDBX_CXX11_CONSTEXPR char * end_char_ptr() noexcept
Returns casted to pointer to char an end of data.
Definition mdbx.h++:1967
allocation_aware_details::copy_assign_alloc< silo, allocator_type > copy_assign_alloc
Definition mdbx.h++:1899
bool rename_map(const ::std::string &old_name, const ::std::string &new_name, bool throw_if_absent=false)
Переименовывает таблицу ключ-значение.
buffer(const void *ptr, size_t bytes, bool make_reference, const allocator_type &allocator=allocator_type())
Definition mdbx.h++:2030
buffer & append(const struct slice &chunk)
Definition mdbx.h++:2488
MDBX_CXX14_CONSTEXPR int8_t as_int8() const
Definition mdbx.h++:2141
bool is_empty() const
Checks whether the database is empty.
MDBX_CXX11_CONSTEXPR const byte * byte_ptr() const noexcept
Definition mdbx.h++:1933
buffer & append_decoded_base64(const struct slice &data, bool ignore_spaces=false)
Definition mdbx.h++:2534
void close(bool dont_sync=false)
Explicitly closes the environment and release the memory map.
MDBX_NOTHROW_PURE_FUNCTION bool ends_with(const struct slice &suffix) const noexcept
Checks if the data ends with the given suffix.
Definition mdbx.h++:2399
move_result to_pair_greater_than(const slice &key, const slice &value, bool throw_notfound=true)
Definition mdbx.h++:4411
env & copy(const ::std::string &destination, bool compactify, bool force_dynamic_size=false)
move_operation
Definition mdbx.h++:4177
@ multi_exactkey_lowerboundvalue
Definition mdbx.h++:4192
@ multi_exactkey_value_equal
Definition mdbx.h++:4209
@ pair_greater_or_equal
Definition mdbx.h++:4217
@ key_lesser_than
Definition mdbx.h++:4199
@ next
Definition mdbx.h++:4180
@ pair_exact
Definition mdbx.h++:4216
@ multi_exactkey_value_greater_or_equal
Definition mdbx.h++:4210
@ pair_lesser_or_equal
Definition mdbx.h++:4214
@ batch_samelength
Definition mdbx.h++:4220
@ seek_key
Definition mdbx.h++:4194
@ key_lowerbound
Definition mdbx.h++:4196
@ pair_lesser_than
Definition mdbx.h++:4213
@ pair_equal
Definition mdbx.h++:4215
@ key_greater_than
Definition mdbx.h++:4203
@ batch_samelength_next
Definition mdbx.h++:4221
@ multi_find_pair
Definition mdbx.h++:4191
@ key_greater_or_equal
Definition mdbx.h++:4202
@ key_exact
Definition mdbx.h++:4195
@ key_equal
Definition mdbx.h++:4201
@ multi_currentkey_prevvalue
Definition mdbx.h++:4186
@ key_lesser_or_equal
Definition mdbx.h++:4200
@ multi_nextkey_firstvalue
Definition mdbx.h++:4189
@ get_current
Definition mdbx.h++:4182
@ multi_exactkey_value_lesser_or_equal
Definition mdbx.h++:4208
@ multi_prevkey_lastvalue
Definition mdbx.h++:4184
@ previous
Definition mdbx.h++:4181
@ last
Definition mdbx.h++:4179
@ pair_greater_than
Definition mdbx.h++:4218
@ multi_exactkey_value_lesser_than
Definition mdbx.h++:4207
@ multi_currentkey_firstvalue
Definition mdbx.h++:4185
@ first
Definition mdbx.h++:4178
@ batch_samelength_previous
Definition mdbx.h++:4222
@ multi_currentkey_nextvalue
Definition mdbx.h++:4187
@ seek_and_batch_samelength
Definition mdbx.h++:4223
@ multi_exactkey_value_greater
Definition mdbx.h++:4211
@ multi_currentkey_lastvalue
Definition mdbx.h++:4188
virtual ~env_managed() noexcept
MDBX_CXX14_CONSTEXPR uint64_t as_uint64() const
Definition mdbx.h++:2130
MDBX_CXX14_CONSTEXPR struct slice head(size_t n) const noexcept
Definition mdbx.h++:2458
bool move(move_operation operation, slice &key, slice &value, bool throw_notfound)
Definition mdbx.h++:4335
static buffer key_from(const char(&text)[SIZE], bool make_reference=true)
Definition mdbx.h++:2613
void insert(const pair &kv)
Definition mdbx.h++:4487
buffer & append(const void *src, size_t bytes)
Definition mdbx.h++:2480
cursor_managed(const cursor_managed &)=delete
env_managed(const ::std::wstring &pathname, const create_parameters &, const operate_parameters &, bool accede=true)
MDBX_CXX14_CONSTEXPR ::std::span< char > chars()
Definition mdbx.h++:2117
void upsert(const pair &kv)
Definition mdbx.h++:4489
move_result to_current_prev_multi(bool throw_notfound=true)
Definition mdbx.h++:4347
void shrink_to_fit()
Reduces memory usage by freeing unused storage space.
Definition mdbx.h++:2412
MDBX_CXX11_CONSTEXPR const char * end_char_ptr() const noexcept
Returns casted to const pointer to char an end of data.
Definition mdbx.h++:1956
int16_t as_int16_adapt() const
Definition mdbx.h++:2156
txn_managed & operator=(const txn_managed &)=delete
static buffer key_from(const int32_t signed_int32)
Definition mdbx.h++:2663
void clear() noexcept
Clears the contents and storage.
Definition mdbx.h++:2404
static buffer base64(const ::mdbx::slice &source, unsigned wrap_width=0, const allocator_type &allocator=allocator_type())
Returns a new buffer with a Base64 dump of the slice content.
Definition mdbx.h++:2173
bool clear_map(const ::std::string_view &name, bool throw_if_absent=false)
Definition mdbx.h++:3907
move_result to_exact_key_value_equal(const slice &key, const slice &value, bool throw_notfound=true)
Definition mdbx.h++:4386
MDBX_CXX11_CONSTEXPR const void * end() const noexcept
Return a const pointer to the end of the referenced data.
Definition mdbx.h++:1976
typename ::std::allocator_traits< default_allocator >::template rebind_alloc< uint64_t > allocator_type
Definition mdbx.h++:1471
bool rename_map(const char *old_name, const char *new_name, bool throw_if_absent=false)
Переименовывает таблицу ключ-значение.
env_managed(const env_managed &)=delete
static buffer key_from(const double ieee754_64bit)
Definition mdbx.h++:2635
move_result to_current_last_multi(bool throw_notfound=true)
Definition mdbx.h++:4354
MDBX_CXX11_CONSTEXPR char * char_ptr() noexcept
Returns casted to pointer to char an address of data.
Definition mdbx.h++:1960
value_result try_insert(const pair &kv)
Definition mdbx.h++:4488
size_t put_multiple_samelength(const slice &key, const VALUE *values_array, size_t values_count, put_mode mode, bool allow_partial=false)
Definition mdbx.h++:4505
move_result to_key_lesser_or_equal(const slice &key, bool throw_notfound=true)
Definition mdbx.h++:4364
MDBX_CXX11_CONSTEXPR env_managed() noexcept=default
static buffer key_from_i64(const int64_t signed_int64)
Definition mdbx.h++:2643
move_result to_pair_greater_or_equal(const slice &key, const slice &value, bool throw_notfound=true)
Definition mdbx.h++:4408
uint64_t as_uint64_adapt() const
Definition mdbx.h++:2146
size_t value_max(value_mode mode) const
Returns the maximal value size in bytes for specified values mode.
Definition mdbx.h++:3311
MDBX_cursor * handle_
Definition mdbx.h++:4132
buffer & append_u8(uint_fast8_t u8)
Definition mdbx.h++:2538
~cursor_managed() noexcept
Definition mdbx.h++:4563
buffer & append_u24(uint_fast32_t u24)
Definition mdbx.h++:2558
buffer(buffer &&src) noexcept(move_assign_alloc::is_nothrow())
Definition mdbx.h++:2096
MDBX_dbi dbi
Definition mdbx.h++:2976
buffer(const ::std::basic_string< CHAR, T, A > &&)=delete
move_result to_exact_key_value_lesser_than(const slice &key, const slice &value, bool throw_notfound=true)
Definition mdbx.h++:4380
static buffer key_from(const uint64_t unsigned_int64)
Definition mdbx.h++:2641
move_result to_current_next_multi(bool throw_notfound=true)
Definition mdbx.h++:4351
buffer & append_u64(uint_fast64_t u64)
Definition mdbx.h++:2595
MDBX_NOTHROW_PURE_FUNCTION constexpr size_t capacity() const noexcept
Returns the number of bytes that can be held in currently allocated storage.
Definition mdbx.h++:1916
MDBX_CXX11_CONSTEXPR env() noexcept=default
MDBX_CXX11_CONSTEXPR const byte * end_byte_ptr() const noexcept
Returns casted to const pointer to byte an end of data.
Definition mdbx.h++:1936
MDBX_CXX11_CONSTEXPR byte & operator[](size_t n) noexcept
Accesses the specified byte of data chunk.
Definition mdbx.h++:2439
buffer(const ::std::basic_string< CHAR, T, A > &)=delete
buffer & append_hex(const struct slice &data, bool uppercase=false, unsigned wrap_width=0)
Definition mdbx.h++:2514
MDBX_CXX14_CONSTEXPR buffer(const ::std::span< POD > &span)
Definition mdbx.h++:2104
size_t size_max() const
Returns maximal write transaction size (i.e. limit for summary volume of dirty pages) in bytes.
Definition mdbx.h++:3770
MDBX_CXX11_CONSTEXPR byte * end_byte_ptr() noexcept
Returns casted to pointer to byte an end of data.
Definition mdbx.h++:1947
buffer & operator=(buffer &&src) noexcept(move_assign_alloc::is_nothrow())
Definition mdbx.h++:2345
env & copy(const ::std::wstring &destination, bool compactify, bool force_dynamic_size=false)
move_result to_exact_key_value_greater_than(const slice &key, const slice &value, bool throw_notfound=true)
Definition mdbx.h++:4392
txn_managed(const txn_managed &)=delete
friend int compare_position_nothrow(const cursor &left, const cursor &right, bool ignore_nested) noexcept
Definition mdbx.h++:6058
static buffer clone(const buffer &src, const allocator_type &allocator=allocator_type())
Definition mdbx.h++:2287
buffer(size_t capacity, const allocator_type &allocator=allocator_type())
Definition mdbx.h++:2078
MDBX_CXX14_CONSTEXPR ::std::span< byte > bytes()
Definition mdbx.h++:2115
::MDBX_stat stat
Statistics for a database in the MDBX environment.
Definition mdbx.h++:3359
size_t value_min(value_mode mode) const noexcept
Returns the minimal value size in bytes for specified values mode.
Definition mdbx.h++:3309
value_result try_insert(map_handle map, const pair &kv)
Definition mdbx.h++:3984
buffer & append_producer(PRODUCER &producer)
Definition mdbx.h++:2500
void insert(map_handle map, const pair &kv)
Definition mdbx.h++:3983
buffer & append_producer(const PRODUCER &producer)
Definition mdbx.h++:2507
MDBX_CXX11_CONSTEXPR txn() noexcept=default
int128_t as_int128_adapt() const
Definition mdbx.h++:2152
env_managed(const ::mdbx::filesystem::path &pathname, const create_parameters &, const operate_parameters &, bool accede=true)
Create new or open existing database.
static buffer key_from(const char *src, bool make_reference=false)
Definition mdbx.h++:2624
bool rename_map(const ::std::string_view &old_name, const ::std::string_view &new_name, bool throw_if_absent=false)
Переименовывает таблицу ключ-значение.
Definition mdbx.h++:3915
move_result to_key_equal(const slice &key, bool throw_notfound=true)
Definition mdbx.h++:4367
@ pettiness_threshold
Definition mdbx.h++:1485
@ max_length
Definition mdbx.h++:1478
@ max_capacity
Definition mdbx.h++:1479
@ extra_inplace_storage
Definition mdbx.h++:1480
@ inplace_storage_size_rounding
Definition mdbx.h++:1481
move_result to_previous(bool throw_notfound=true)
Definition mdbx.h++:4340
constexpr buffer(const char *c_str, const allocator_type &allocator=allocator_type())
Definition mdbx.h++:2063
friend class txn
Definition mdbx.h++:1489
bool is_before_than(const cursor &other, bool ignore_nested=false) const
Definition mdbx.h++:4151
size_t key_min(key_mode mode) const noexcept
Returns the minimal key size in bytes for specified keys mode.
Definition mdbx.h++:3305
int8_t as_int8_adapt() const
Definition mdbx.h++:2157
size_t size_current() const
Returns current write transaction size (i.e.summary volume of dirty pages) in bytes.
Definition mdbx.h++:3773
buffer base58_decode(bool ignore_spaces=false, const allocator_type &allocator=allocator_type()) const
Decodes Base58 dump from the buffer content to new returned buffer.
Definition mdbx.h++:2244
bool fullscan(CALLABLE_PREDICATE predicate, bool backward=false)
Definition mdbx.h++:4280
The chunk of data stored inside the buffer or located outside it.
Definition mdbx.h++:1468
Unmanaged cursor.
Definition mdbx.h++:4130
Managed cursor.
Definition mdbx.h++:4525
Unmanaged database environment.
Definition mdbx.h++:3021
Managed database environment.
Definition mdbx.h++:3640
Unmanaged database transaction.
Definition mdbx.h++:3723
Managed database transaction.
Definition mdbx.h++:4067
static size_t key_min(MDBX_db_flags_t flags) noexcept
Returns the minimal key size in bytes for specified table flags.
Definition mdbx.h++:5199
polymorphic_allocator default_allocator
Definition mdbx.h++:358
MDBX_CXX11_CONSTEXPR txn(MDBX_txn *ptr) noexcept
Definition mdbx.h++:5523
buffer< ALLOCATOR, CAPACITY_POLICY > encode_base58(unsigned wrap_width=0, const ALLOCATOR &allocator=ALLOCATOR()) const
Returns a buffer with a Base58 dump of the slice content.
Definition mdbx.h++:5036
env & set_HandleSlowReaders(MDBX_hsr_func *)
Sets a Handle-Slow-Readers callback to resolve database full/overflow issue due to a reader(s) which ...
Definition mdbx.h++:5484
MDBX_CXX11_CONSTEXPR bool is_success() const noexcept
Definition mdbx.h++:4677
void * get_context() const noexcept
Returns the application context associated with the transaction.
Definition mdbx.h++:5549
static size_t value_max(intptr_t pagesize, MDBX_db_flags_t flags)
Returns the maximal value size in bytes for specified page size and table flags.
Definition mdbx.h++:5227
void replace(map_handle map, const slice &key, slice old_value, const slice &new_value)
Replaces the particular multi-value of the key with a new value.
Definition mdbx.h++:5932
void renew(::mdbx::txn &txn)
Renew/bind a cursor with a new transaction and previously used key-value map handle.
Definition mdbx.h++:6169
value_mode
Kind of the values and sorted multi-values with corresponding comparison.
Definition mdbx.h++:2890
MDBX_CXX14_CONSTEXPR void clear() noexcept
Makes the slice empty and referencing to nothing.
Definition mdbx.h++:4882
MDBX_CXX11_CONSTEXPR byte operator[](size_t n) const noexcept
Returns the nth byte in the referenced data.
Definition mdbx.h++:4926
MDBX_CXX11_CONSTEXPR_ENUM mdbx::key_mode key_mode() const noexcept
Definition mdbx.h++:5124
void reset_reading()
Reset read-only transaction.
Definition mdbx.h++:5582
void success_or_panic(const char *context_where, const char *func_who) const noexcept
Definition mdbx.h++:4722
void rethrow_captured() const
Definition mdbx.h++:4659
move_result find_multivalue(const slice &key, const slice &value, bool throw_notfound=true)
Definition mdbx.h++:6127
ptrdiff_t estimate(move_operation operation, MDBX_val *key, MDBX_val *value) const
Definition mdbx.h++:6103
MDBX_CXX14_CONSTEXPR void invalidate() noexcept
Depletes content of slice and make it invalid.
Definition mdbx.h++:4880
map_handle create_map(const char *name, const ::mdbx::key_mode key_mode=::mdbx::key_mode::usual, const ::mdbx::value_mode value_mode=::mdbx::value_mode::single)
Create new or open existing key-value map.
Definition mdbx.h++:5653
static size_t dbsize_max(intptr_t pagesize)
Returns the maximal database size in bytes for specified page size.
Definition mdbx.h++:5192
geometry & make_dynamic(intptr_t lower=default_value, intptr_t upper=default_value) noexcept
Definition mdbx.h++:5166
value_result try_update_reserve(map_handle map, const slice &key, size_t value_length)
Definition mdbx.h++:5895
value_result try_insert_reserve(map_handle map, const slice &key, size_t value_length)
Definition mdbx.h++:5849
void close_map(const map_handle &)
Close a key-value map (aka table) handle. Normally unnecessary.
Definition mdbx.h++:5446
MDBX_CXX11_CONSTEXPR byte at(size_t n) const
Returns the nth byte in the referenced data with bounds checking.
Definition mdbx.h++:4931
env & set_sync_threshold(size_t bytes)
Sets threshold to force flush the data buffers to disk, for non-sync durability modes.
Definition mdbx.h++:5377
move_result(const cursor &cursor, bool throw_notfound)
Definition mdbx.h++:6071
MDBX_CXX11_CONSTEXPR const version_info & get_version() noexcept
Returns libmdbx version information.
Definition mdbx.h++:4594
ptrdiff_t estimate_from_first(map_handle map, const slice &to) const
Definition mdbx.h++:6005
void remove_suffix(size_t n) noexcept
Drops the last "n" bytes from this slice.
Definition mdbx.h++:4899
slice & assign(const void *ptr, size_t bytes)
Definition mdbx.h++:4792
env & operator=(env &&other) noexcept
Definition mdbx.h++:5136
void unbind()
Unbind cursor from a transaction.
Definition mdbx.h++:6175
MDBX_CXX11_CONSTEXPR const void * end() const noexcept
Return a pointer to the ending of the referenced data.
Definition mdbx.h++:4854
::std::chrono::duration< unsigned, ::std::ratio< 1, 65536 > > duration
Duration in 1/65536 units of second.
Definition mdbx.h++:422
slice insert_reserve(map_handle map, const slice &key, size_t value_length)
Definition mdbx.h++:5842
string< ALLOCATOR > as_hex_string(bool uppercase=false, unsigned wrap_width=0, const ALLOCATOR &allocator=ALLOCATOR()) const
Returns a string with a hexadecimal dump of the slice content.
Definition mdbx.h++:5015
void rename_map(map_handle map, const char *new_name)
Переименовывает таблицу ключ-значение.
Definition mdbx.h++:5666
void throw_on_failure() const
Definition mdbx.h++:4699
bool try_update(const slice &key, const slice &value)
Definition mdbx.h++:6250
void update(const slice &key, const slice &value)
Definition mdbx.h++:6246
int compare_keys(map_handle map, const slice &a, const slice &b) const noexcept
Compare two keys according to a particular key-value map (aka table).
Definition mdbx.h++:5741
MDBX_CXX11_CONSTEXPR MDBX_error_t code() const noexcept
Returns error code.
Definition mdbx.h++:4687
txn & set_context(void *your_context)
Sets the application context associated with the transaction.
Definition mdbx.h++:5551
txn_managed start_write(txn &parent)
Starts write (read-write) transaction.
Definition mdbx.h++:5512
int compare_position_nothrow(const cursor &left, const cursor &right, bool ignore_nested=false) noexcept
Definition mdbx.h++:6058
env::durability get_durability() const
Returns current durability mode.
Definition mdbx.h++:5310
uint64_t sequence(map_handle map) const
Reads sequence generator associated with a key-value map (aka table).
Definition mdbx.h++:5729
void upsert(const slice &key, const slice &value)
Definition mdbx.h++:6236
MDBX_CXX11_CONSTEXPR const byte * byte_ptr() const noexcept
Returns casted to pointer to byte an address of data.
Definition mdbx.h++:4834
MDBX_CXX11_CONSTEXPR bool is_mdbx_error() const noexcept
Returns true for MDBX's errors.
Definition mdbx.h++:4689
bool is_clean() const noexcept
Definition mdbx.h++:4652
string< ALLOCATOR > as_base58_string(unsigned wrap_width=0, const ALLOCATOR &allocator=ALLOCATOR()) const
Returns a string with a Base58 dump of the slice content.
Definition mdbx.h++:5020
MDBX_CXX11_CONSTEXPR const char * end_char_ptr() const noexcept
Returns casted to pointer to char an end of data.
Definition mdbx.h++:4846
MDBX_CXX01_CONSTEXPR_ENUM bool is_reverse(key_mode mode) noexcept
Definition mdbx.h++:2883
static bool boolean_or_throw(int error_code)
Definition mdbx.h++:4742
MDBX_CXX14_CONSTEXPR slice safe_tail(size_t n) const
Returns the last "n" bytes of the slice.
Definition mdbx.h++:4958
void swap(slice &other) noexcept
Definition mdbx.h++:4828
env::operate_parameters get_operation_parameters() const
Returns current operation parameters.
Definition mdbx.h++:5300
MDBX_CXX01_CONSTEXPR_ENUM bool is_msgpack(key_mode mode) noexcept
Definition mdbx.h++:2887
::std::basic_string< char, ::std::char_traits< char >, ALLOCATOR > string
Default single-byte string.
Definition mdbx.h++:378
MDBX_NOTHROW_PURE_FUNCTION MDBX_CXX14_CONSTEXPR bool starts_with(const slice &prefix) const noexcept
Checks if the data starts with the given prefix.
Definition mdbx.h++:4910
MDBX_env_flags_t get_flags() const
Returns environment flags.
Definition mdbx.h++:5352
static size_t dbsize_min(intptr_t pagesize)
Returns the minimal database size in bytes for specified page size.
Definition mdbx.h++:5185
MDBX_CXX11_CONSTEXPR slice() noexcept
Create an empty slice.
Definition mdbx.h++:4776
static MDBX_NOTHROW_PURE_FUNCTION MDBX_CXX14_CONSTEXPR intptr_t compare_fast(const slice &a, const slice &b) noexcept
Three-way fast non-lexicographically length-based comparison.
Definition mdbx.h++:4972
MDBX_CXX11_CONSTEXPR size_t size() const noexcept
Returns the number of bytes.
Definition mdbx.h++:4876
void insert(const slice &key, slice value)
Definition mdbx.h++:6197
MDBX_CXX11_CONSTEXPR reader_info(int slot, mdbx_pid_t pid, mdbx_tid_t thread, uint64_t txnid, uint64_t lag, size_t used, size_t retained) noexcept
Definition mdbx.h++:5449
move_result lower_bound_multivalue(const slice &key, const slice &value, bool throw_notfound=false)
Definition mdbx.h++:6131
::std::pmr::string::allocator_type polymorphic_allocator
Default polymorphic allocator for modern code.
Definition mdbx.h++:357
MDBX_CXX14_CONSTEXPR slice safe_head(size_t n) const
Returns the first "n" bytes of the slice.
Definition mdbx.h++:4952
MDBX_CXX01_CONSTEXPR_ENUM bool is_usual(key_mode mode) noexcept
Definition mdbx.h++:2871
MDBX_hsr_func * get_HandleSlowReaders() const noexcept
Returns the current Handle-Slow-Readers callback used to resolve database full/overflow issue due to ...
Definition mdbx.h++:5489
cursor_managed clone(void *your_context=nullptr) const
Definition mdbx.h++:6021
~cursor() noexcept
Definition mdbx.h++:6042
~txn() noexcept
Definition mdbx.h++:5533
size_t sync_threshold() const
Gets threshold used to force flush the data buffers to disk, for non-sync durability modes.
Definition mdbx.h++:5382
MDBX_CXX11_CONSTEXPR bool is_null() const noexcept
Checks whether the slice data pointer is nullptr.
Definition mdbx.h++:4874
move_result upper_bound(const slice &key, bool throw_notfound=false)
Definition mdbx.h++:6123
inline ::mdbx::txn txn() const
Returns the cursor's transaction.
Definition mdbx.h++:6177
MDBX_CXX11_CONSTEXPR const void * data() const noexcept
Return a pointer to the beginning of the referenced data.
Definition mdbx.h++:4852
value_result try_insert_reserve(const slice &key, size_t value_length)
Definition mdbx.h++:6222
static env::operate_options options_from_flags(MDBX_env_flags_t flags) noexcept
Definition mdbx.h++:5177
map_handle map() const
Definition mdbx.h++:6182
unsigned sync_period__seconds_16dot16() const
Controls interprocess/shared relative period since the last unsteady commit to force flush the data b...
Definition mdbx.h++:5393
MDBX_CXX11_CONSTEXPR info(map_handle::flags flags, map_handle::state state) noexcept
Definition mdbx.h++:5121
MDBX_CXX11_CONSTEXPR_ENUM mdbx::value_mode value_mode() const noexcept
Definition mdbx.h++:5128
move_result find(const slice &key, bool throw_notfound=true)
Definition mdbx.h++:6115
move_result upper_bound_multivalue(const slice &key, const slice &value, bool throw_notfound=false)
Definition mdbx.h++:6135
MDBX_CXX01_CONSTEXPR_ENUM bool is_multi(value_mode mode) noexcept
Definition mdbx.h++:2951
MDBX_NOTHROW_PURE_FUNCTION bool is_base64(bool ignore_spaces=false) const noexcept
Checks whether the content of the slice is a Base64 dump.
Definition mdbx.h++:5068
void success_or_throw() const
Definition mdbx.h++:4704
buffer< ALLOCATOR, CAPACITY_POLICY > encode_base64(unsigned wrap_width=0, const ALLOCATOR &allocator=ALLOCATOR()) const
Returns a buffer with a Base64 dump of the slice content.
Definition mdbx.h++:5041
void renew_reading()
Renew read-only transaction.
Definition mdbx.h++:5586
buffer< ALLOCATOR, CAPACITY_POLICY > base64_decode(bool ignore_spaces=false, const ALLOCATOR &allocator=ALLOCATOR()) const
Decodes Base64 dump from the slice content to returned buffer.
Definition mdbx.h++:5056
bool sync_to_disk(bool force=true, bool nonblock=false)
Flush the environment data buffers.
Definition mdbx.h++:5433
MDBX_CXX11_CONSTEXPR env(MDBX_env *ptr) noexcept
Definition mdbx.h++:5134
int compare_position(const cursor &left, const cursor &right, bool ignore_nested=false)
Definition mdbx.h++:6062
static MDBX_NOTHROW_PURE_FUNCTION MDBX_CXX14_CONSTEXPR intptr_t compare_lexicographically(const pair &a, const pair &b) noexcept
Three-way lexicographically comparison.
Definition mdbx.h++:5079
size_t count_multivalue() const
Return count of duplicates for current key.
Definition mdbx.h++:6141
static size_t pagesize_max() noexcept
Returns the maximal database page size in bytes.
Definition mdbx.h++:5183
MDBX_CXX11_CONSTEXPR error(MDBX_error_t error_code) noexcept
Definition mdbx.h++:4666
bool is_dirty(const void *ptr) const
Checks whether the given data is on a dirty page.
Definition mdbx.h++:5556
slice upsert_reserve(const slice &key, size_t value_length)
Definition mdbx.h++:6240
env::mode get_mode() const
Returns current operation mode.
Definition mdbx.h++:5308
MDBX_NOTHROW_PURE_FUNCTION bool is_hex(bool ignore_spaces=false) const noexcept
Checks whether the content of the slice is a hexadecimal dump.
Definition mdbx.h++:5060
MDBX_CXX01_CONSTEXPR_ENUM bool is_samelength(key_mode mode) noexcept
Definition mdbx.h++:2879
void capture() noexcept
Definition mdbx.h++:4654
inline ::mdbx::env env() const noexcept
Returns the transaction's environment.
Definition mdbx.h++:5568
uint32_t get_tree_deepmask(map_handle map) const
Returns depth (bitmask) information of nested dupsort (multi-value) B+trees for given table.
Definition mdbx.h++:5706
bool try_update(map_handle map, const slice &key, const slice &value)
Definition mdbx.h++:5877
void safe_remove_prefix(size_t n)
Drops the first "n" bytes from this slice.
Definition mdbx.h++:4893
comparator default_comparator(key_mode mode) noexcept
Definition mdbx.h++:2998
MDBX_NOTHROW_PURE_FUNCTION bool is_base58(bool ignore_spaces=false) const noexcept
Checks whether the content of the slice is a Base58 dump.
Definition mdbx.h++:5064
slice insert_reserve(const slice &key, size_t value_length)
Definition mdbx.h++:6215
static size_t pairsize4page_max(intptr_t pagesize, MDBX_db_flags_t flags)
Returns maximal size of key-value pair to fit in a single page for specified size and table flags.
Definition mdbx.h++:5247
env & set_sync_period__seconds_16dot16(unsigned seconds_16dot16)
Sets relative period since the last unsteady commit to force flush the data buffers to disk,...
Definition mdbx.h++:5388
ptrdiff_t estimate(map_handle map, const pair &from, const pair &to) const
Definition mdbx.h++:5993
MDBX_CXX14_CONSTEXPR slice tail(size_t n) const noexcept
Returns the last "n" bytes of the slice.
Definition mdbx.h++:4942
env::reclaiming_options get_reclaiming() const
Returns current reclaiming options.
Definition mdbx.h++:5314
void drop_map(map_handle map)
Drops key-value map using handle.
Definition mdbx.h++:5662
ptrdiff_t estimate_to_last(map_handle map, const slice &from) const
Definition mdbx.h++:6011
void append(map_handle map, const slice &key, const slice &value, bool multivalue_order_preserved=true)
Adding a key-value pair, provided that ascending order of the keys and (optionally) values are preser...
Definition mdbx.h++:5969
MDBX_CXX11_CONSTEXPR bool empty() const noexcept
Checks whether the slice is empty.
Definition mdbx.h++:4872
env::operate_options get_options() const
Returns current operate options.
Definition mdbx.h++:5318
buffer< ALLOCATOR, CAPACITY_POLICY > extract(map_handle map, const slice &key, const typename buffer< ALLOCATOR, CAPACITY_POLICY >::allocator_type &allocator=buffer< ALLOCATOR, CAPACITY_POLICY >::allocator_type())
Removes and return a value of the key.
Definition mdbx.h++:5939
void park_reading(bool autounpark=true)
Park read-only transaction.
Definition mdbx.h++:5588
cursor & set_context(void *your_context)
Sets the application context associated with the cursor.
Definition mdbx.h++:6029
map_stat get_map_stat(map_handle map) const
Returns statistics for a table.
Definition mdbx.h++:5700
bool move(move_operation operation, MDBX_val *key, MDBX_val *value, bool throw_notfound) const
Definition mdbx.h++:6081
static size_t value_min(MDBX_db_flags_t flags) noexcept
Returns the minimal values size in bytes for specified table flags.
Definition mdbx.h++:5223
int compare_values(map_handle map, const slice &a, const slice &b) const noexcept
Compare two values according to a particular key-value map (aka table).
Definition mdbx.h++:5745
static env::reclaiming_options reclaiming_from_flags(MDBX_env_flags_t flags) noexcept
Definition mdbx.h++:5173
buffer< ALLOCATOR, CAPACITY_POLICY > encode_hex(bool uppercase=false, unsigned wrap_width=0, const ALLOCATOR &allocator=ALLOCATOR()) const
Returns a buffer with a hexadecimal dump of the slice content.
Definition mdbx.h++:5030
cursor & operator=(cursor &&other) noexcept
Definition mdbx.h++:6034
txn & put_canary(const canary &)
Set integers markers (aka "canary") associated with the environment.
Definition mdbx.h++:5718
slice upsert_reserve(map_handle map, const slice &key, size_t value_length)
Definition mdbx.h++:5867
MDBX_NOTHROW_PURE_FUNCTION MDBX_CXX14_CONSTEXPR bool operator<(const slice &a, const slice &b) noexcept
Definition mdbx.h++:4994
buffer< ALLOCATOR, CAPACITY_POLICY > hex_decode(bool ignore_spaces=false, const ALLOCATOR &allocator=ALLOCATOR()) const
Decodes hexadecimal dump from the slice content to returned buffer.
Definition mdbx.h++:5046
MDBX_CXX14_CONSTEXPR slice head(size_t n) const noexcept
Returns the first "n" bytes of the slice.
Definition mdbx.h++:4937
string to_string(const ::mdbx::slice &value)
Definition mdbx.h++:6333
env & set_sync_period__seconds_double(double seconds)
Sets relative period since the last unsteady commit to force flush the data buffers to disk,...
Definition mdbx.h++:5399
bool on_first() const
Definition mdbx.h++:6149
MDBX_NOTHROW_PURE_FUNCTION MDBX_CXX14_CONSTEXPR size_t hash_value() const noexcept
Returns the hash value of referenced data.
Definition mdbx.h++:4919
::MDBX_version_info version_info
libmdbx version information,
Definition mdbx.h++:334
bool eof() const
Definition mdbx.h++:6147
void make_broken()
Marks transaction as broken to prevent further operations.
Definition mdbx.h++:5584
MDBX_txn_flags_t flags() const
Returns transaction's flags.
Definition mdbx.h++:5570
void * get_context() const noexcept
Returns the application context associated with the environment.
Definition mdbx.h++:5370
MDBX_error_t put(const slice &key, slice *value, MDBX_put_flags_t flags) noexcept
Definition mdbx.h++:6189
map_handle open_map_accede(const char *name) const
Open existing key-value map.
Definition mdbx.h++:5637
txn_managed prepare_read() const
Creates but not start read transaction.
Definition mdbx.h++:5498
::MDBX_build_info build_info
libmdbx build information
Definition mdbx.h++:338
void safe_remove_suffix(size_t n)
Drops the last "n" bytes from this slice.
Definition mdbx.h++:4904
bool seek(const slice &key)
Definition mdbx.h++:6139
env & alter_flags(MDBX_env_flags_t flags, bool on_off)
Alter environment flags.
Definition mdbx.h++:5422
env & set_context(void *your_context)
Sets the application context associated with the environment.
Definition mdbx.h++:5372
static size_t transaction_size_max(intptr_t pagesize)
Returns the maximal write transaction size (i.e. limit for summary volume of dirty pages) in bytes fo...
Definition mdbx.h++:5291
MDBX_CXX11_CONSTEXPR size_t length() const noexcept
Returns the number of bytes.
Definition mdbx.h++:4860
void clear_map(map_handle map)
Clear key-value map.
Definition mdbx.h++:5664
env & set_extra_option(extra_runtime_option option, uint64_t value)
Sets the value of a extra runtime options for an environment.
Definition mdbx.h++:5411
void remove_prefix(size_t n) noexcept
Drops the first "n" bytes from this slice.
Definition mdbx.h++:4887
MDBX_CXX11_CONSTEXPR bool is_result_true() const noexcept
Definition mdbx.h++:4679
MDBX_CXX11_CONSTEXPR bool operator==(const error &a, const error &b) noexcept
Definition mdbx.h++:4673
value_result try_insert(const slice &key, slice value)
Definition mdbx.h++:6202
size_t put_multiple_samelength(const slice &key, const size_t value_length, const void *values_array, size_t values_count, put_mode mode, bool allow_partial=false)
Definition mdbx.h++:6303
static void throw_on_nullptr(const void *ptr, MDBX_error_t error_code)
Definition mdbx.h++:4727
string< ALLOCATOR > as_base64_string(unsigned wrap_width=0, const ALLOCATOR &allocator=ALLOCATOR()) const
Returns a string with a Base58 dump of the slice content.
Definition mdbx.h++:5025
::MDBX_cmp_func * comparator
Definition mdbx.h++:2997
put_mode
Key-value pairs put mode.
Definition mdbx.h++:3006
double sync_period__seconds_double() const
Controls interprocess/shared relative period since the last unsteady commit to force flush the data b...
Definition mdbx.h++:5403
::mdbx_filehandle_t filehandle
Definition mdbx.h++:380
MDBX_CXX14_CONSTEXPR slice & set_end(const void *ptr)
Sets the length by specifying the end of the slice data.
Definition mdbx.h++:4867
static MDBX_NOTHROW_PURE_FUNCTION MDBX_CXX14_CONSTEXPR intptr_t compare_fast(const pair &a, const pair &b) noexcept
Three-way fast non-lexicographically length-based comparison.
Definition mdbx.h++:5074
static size_t valsize4page_max(intptr_t pagesize, MDBX_db_flags_t flags)
Returns maximal data size in bytes to fit in a leaf-page or single large/overflow-page for specified ...
Definition mdbx.h++:5269
MDBX_CXX11_CONSTEXPR cursor(MDBX_cursor *ptr) noexcept
Definition mdbx.h++:6019
MDBX_NOTHROW_PURE_FUNCTION MDBX_CXX14_CONSTEXPR bool operator<=(const slice &a, const slice &b) noexcept
Definition mdbx.h++:5002
char8_t byte
Definition mdbx.h++:318
canary get_canary() const
Returns fours integers markers (aka "canary") associated with the environment.
Definition mdbx.h++:5723
txn & operator=(txn &&other) noexcept
Definition mdbx.h++:5525
bool erase(bool whole_multivalue=false)
Removes single key-value pair or all multi-values at the current cursor position.
Definition mdbx.h++:6281
buffer< ALLOCATOR, CAPACITY_POLICY > replace_reserve(map_handle map, const slice &key, slice &new_value, const typename buffer< ALLOCATOR, CAPACITY_POLICY >::allocator_type &allocator=buffer< ALLOCATOR, CAPACITY_POLICY >::allocator_type())
Definition mdbx.h++:5960
stat get_stat() const
Returns snapshot statistics about the MDBX environment.
Definition mdbx.h++:5322
uint64_t id() const
Return the transaction's ID.
Definition mdbx.h++:5576
value_result try_insert(map_handle map, const slice &key, slice value)
Definition mdbx.h++:5829
::std::string::allocator_type legacy_allocator
Legacy allocator but it is recommended to use polymorphic_allocator.
Definition mdbx.h++:352
MDBX_CXX11_CONSTEXPR const byte * end_byte_ptr() const noexcept
Returns casted to pointer to byte an end of data.
Definition mdbx.h++:4838
ptrdiff_t estimate(const cursor &from, const cursor &to)
Definition mdbx.h++:6109
slice update_reserve(map_handle map, const slice &key, size_t value_length)
Definition mdbx.h++:5889
MDBX_NOTHROW_PURE_FUNCTION MDBX_CXX14_CONSTEXPR bool ends_with(const slice &suffix) const noexcept
Checks if the data ends with the given suffix.
Definition mdbx.h++:4914
MDBX_CXX14_CONSTEXPR slice & set_length(size_t bytes)
Set slice length.
Definition mdbx.h++:4862
~env() noexcept
Definition mdbx.h++:5144
loop_control
Loop control constants for readers enumeration functor and other cases.
Definition mdbx.h++:2852
slice get(map_handle map, const slice &key) const
Get value by key from a key-value map (aka table).
Definition mdbx.h++:5757
size_t put_multiple_samelength(map_handle map, const slice &key, const size_t value_length, const void *values_array, size_t values_count, put_mode mode, bool allow_partial=false)
Definition mdbx.h++:5974
void update(map_handle map, const slice &key, const slice &value)
Definition mdbx.h++:5873
key_mode
Kinds of the keys and corresponding modes of comparing it.
Definition mdbx.h++:2855
txn_managed start_read() const
Starts read (read-only) transaction.
Definition mdbx.h++:5491
::mdbx::filesystem::path path
Definition mdbx.h++:404
bool on_last_multival() const
Definition mdbx.h++:6155
unsigned max_maps() const
Returns the maximum number of named tables for the environment.
Definition mdbx.h++:5364
void insert(map_handle map, const slice &key, slice value)
Definition mdbx.h++:5824
unsigned max_readers() const
Returns the maximum number of threads/reader slots for the environment.
Definition mdbx.h++:5358
static size_t key_max(intptr_t pagesize, MDBX_db_flags_t flags)
Returns the maximal key size in bytes for specified page size and table flags.
Definition mdbx.h++:5203
int enumerate_readers(VISITOR &visitor)
Enumerate readers.
Definition mdbx.h++:5454
void * get_context() const noexcept
Returns the application context associated with the cursor.
Definition mdbx.h++:6027
static size_t max_map_handles(void)
Returns the maximum opened map handles, aka DBI-handles.
Definition mdbx.h++:5298
cursor_managed open_cursor(map_handle map) const
Opens cursor for specified key-value map handle.
Definition mdbx.h++:5600
MDBX_CXX01_CONSTEXPR_ENUM bool is_ordinal(key_mode mode) noexcept
Definition mdbx.h++:2875
bool unpark_reading(bool restart_if_ousted=true)
Resume parked read-only transaction.
Definition mdbx.h++:5590
uint64_t extra_option(extra_runtime_option option) const
Gets the value of extra runtime options from an environment.
Definition mdbx.h++:5416
bool on_first_multival() const
Definition mdbx.h++:6153
MDBX_error_t put(map_handle map, const slice &key, slice *value, MDBX_put_flags_t flags) noexcept
Definition mdbx.h++:5816
void panic_on_failure(const char *context_where, const char *func_who) const noexcept
Definition mdbx.h++:4717
info get_info() const
Return snapshot information about the MDBX environment.
Definition mdbx.h++:5334
void upsert(map_handle map, const slice &key, const slice &value)
Definition mdbx.h++:5863
static size_t pagesize_min() noexcept
Returns the minimal database page size in bytes.
Definition mdbx.h++:5181
MDBX_NOTHROW_PURE_FUNCTION MDBX_CXX14_CONSTEXPR bool operator>(const slice &a, const slice &b) noexcept
Definition mdbx.h++:4998
slice update_reserve(const slice &key, size_t value_length)
Definition mdbx.h++:6262
move_result lower_bound(const slice &key, bool throw_notfound=false)
Definition mdbx.h++:6119
MDBX_CXX14_CONSTEXPR slice middle(size_t from, size_t n) const noexcept
Returns the middle "n" bytes of the slice.
Definition mdbx.h++:4947
MDBX_CXX11_CONSTEXPR bool operator!=(const error &a, const error &b) noexcept
Definition mdbx.h++:4675
unsigned check_readers()
Checks for stale readers in the lock table and return number of cleared slots.
Definition mdbx.h++:5477
bool erase(map_handle map, const slice &key)
Removes all values for given key.
Definition mdbx.h++:5908
MDBX_CXX14_CONSTEXPR slice safe_middle(size_t from, size_t n) const
Returns the middle "n" bytes of the slice.
Definition mdbx.h++:4964
bool on_last() const
Definition mdbx.h++:6151
MDBX_CXX11_CONSTEXPR const char * char_ptr() const noexcept
Returns casted to pointer to char an address of data.
Definition mdbx.h++:4844
#define MDBX_STD_FILESYSTEM_PATH
Defined if mdbx::filesystem::path is available.
Definition mdbx.h++:400
static MDBX_NOTHROW_PURE_FUNCTION MDBX_CXX14_CONSTEXPR intptr_t compare_lexicographically(const slice &a, const slice &b) noexcept
Three-way lexicographically comparison.
Definition mdbx.h++:4979
buffer< ALLOCATOR, CAPACITY_POLICY > base58_decode(bool ignore_spaces=false, const ALLOCATOR &allocator=ALLOCATOR()) const
Decodes Base58 dump from the slice content to returned buffer.
Definition mdbx.h++:5051
filehandle get_filehandle() const
Returns the file descriptor for the DXB file of MDBX environment.
Definition mdbx.h++:5346
env & set_geometry(const geometry &size)
Set all size-related parameters of environment.
Definition mdbx.h++:5427
map_handle::info get_handle_info(map_handle map) const
Returns information about key-value map (aka table) handle.
Definition mdbx.h++:5712
void bind(::mdbx::txn &txn, ::mdbx::map_handle map_handle)
Bind/renew a cursor with a new transaction and specified key-value map handle.
Definition mdbx.h++:6171
geometry & make_fixed(intptr_t size) noexcept
Definition mdbx.h++:5160
size_t release_all_cursors(bool unbind) const
Unbind or close all cursors.
Definition mdbx.h++:5606
MDBX_CXX11_CONSTEXPR bool is_failure() const noexcept
Definition mdbx.h++:4683
MDBX_CXX11_CONSTEXPR const build_info & get_build() noexcept
Returns libmdbx build information.
Definition mdbx.h++:4595
value_result try_update_reserve(const slice &key, size_t value_length)
Definition mdbx.h++:6268
map_handle open_map(const char *name, const ::mdbx::key_mode key_mode=::mdbx::key_mode::usual, const ::mdbx::value_mode value_mode=::mdbx::value_mode::single) const
Open existing key-value map.
Definition mdbx.h++:5621
buffer< default_allocator, default_capacity_policy > default_buffer
Default buffer.
Definition mdbx.h++:374
txn_managed try_start_write()
Tries to start write (read-write) transaction without blocking.
Definition mdbx.h++:5519
MDBX_CXX11_CONSTEXPR bool is_result_false() const noexcept
Definition mdbx.h++:4681
info get_info(bool scan_reader_lock_table=false) const
Returns information about the MDBX transaction.
Definition mdbx.h++:5594
pair_result get_equal_or_great(map_handle map, const slice &key) const
Get value for equal or great key from a table.
Definition mdbx.h++:5795
MDBX_NOTHROW_PURE_FUNCTION MDBX_CXX14_CONSTEXPR bool operator>=(const slice &a, const slice &b) noexcept
Definition mdbx.h++:5006
@ multi_reverse_samelength
Definition mdbx.h++:2923
@ multi_samelength
Definition mdbx.h++:2908
@ multi_ordinal
Definition mdbx.h++:2915
@ msgpack
Definition mdbx.h++:2938
@ single
Definition mdbx.h++:2891
@ multi
Definition mdbx.h++:2893
@ multi_reverse
Definition mdbx.h++:2900
@ upsert
Insert or update.
Definition mdbx.h++:3008
@ update
Update existing, don't insert new.
Definition mdbx.h++:3009
@ insert_unique
Insert only unique keys.
Definition mdbx.h++:3007
@ continue_loop
Definition mdbx.h++:2852
@ exit_loop
Definition mdbx.h++:2852
@ usual
Definition mdbx.h++:2856
@ ordinal
Definition mdbx.h++:2861
@ reverse
Definition mdbx.h++:2858
@ msgpack
Definition mdbx.h++:2866
A handle for an individual table (aka key-value space, maps or sub-database) in the environment.
Definition mdbx.h++:2975
MDBX_CXX11_CONSTEXPR size_t envisage_result_length() const noexcept
Returns the buffer size in bytes needed for Base58 dump of passed slice.
Definition mdbx.h++:1270
MDBX_CXX11_CONSTEXPR bool is_valid() const noexcept
Checks the slice is not refers to null address or has zero length.
Definition mdbx.h++:1002
MDBX_CXX14_CONSTEXPR ::std::span< const char > chars() const
Definition mdbx.h++:699
buffer< ALLOCATOR, CAPACITY_POLICY > as_buffer(const ALLOCATOR &allocator=ALLOCATOR()) const
Decodes Base58 dump from a passed slice to returned buffer.
Definition mdbx.h++:1401
buffer< ALLOCATOR, CAPACITY_POLICY > as_buffer(const ALLOCATOR &allocator=ALLOCATOR()) const
Returns a buffer with a hexadecimal dump of a passed slice.
Definition mdbx.h++:1216
constexpr slice(const ::std::basic_string< CHAR, T, A > &str)
Create a slice that refers to the contents of "str".
Definition mdbx.h++:665
const slice source
Definition mdbx.h++:1293
bool is_erroneous() const noexcept
Checks whether the content of a passed slice is a valid Base58 dump, and therefore there could be dec...
slice & assign(::std::basic_string_view< CHAR, T > &&view)
Definition mdbx.h++:733
MDBX_CXX11_CONSTEXPR slice(const slice &) noexcept=default
int8_t as_int8_adapt() const
MDBX_NOTHROW_PURE_FUNCTION constexpr bool is_reference() const noexcept
Definition mdbx.h++:2825
static MDBX_CXX11_CONSTEXPR size_t advise(const size_t current, const size_t wanna)
Definition mdbx.h++:1180
buffer< ALLOCATOR, CAPACITY_POLICY > buffer_type
Definition mdbx.h++:2774
@ max_length
Definition mdbx.h++:644
MDBX_NOTHROW_PURE_FUNCTION constexpr bool is_freestanding() const noexcept
Definition mdbx.h++:2820
slice & operator=(::std::basic_string_view< CHAR, T > &&view)
Definition mdbx.h++:751
MDBX_CXX14_CONSTEXPR ::std::span< const POD > as_span() const
Definition mdbx.h++:679
buffer_pair_spec(buffer_pair_spec &&pair) noexcept(buffer_type::move_assign_alloc::is_nothrow())
Definition mdbx.h++:2815
buffer< ALLOCATOR, CAPACITY_POLICY > as_buffer(const ALLOCATOR &allocator=ALLOCATOR()) const
Returns a buffer with a Base58 dump of a passed slice.
Definition mdbx.h++:1264
const bool ignore_spaces
Definition mdbx.h++:1385
MDBX_NOTHROW_PURE_FUNCTION bool is_printable(bool disable_utf8=false) const noexcept
Checks whether the content of the slice is printable.
void swap(::std::basic_string_view< CHAR, T > &view) noexcept
Definition mdbx.h++:858
MDBX_CXX14_CONSTEXPR uint8_t as_uint8() const
Definition mdbx.h++:1025
value_result & operator=(const value_result &) noexcept=default
MDBX_CXX11_CONSTEXPR to_base58(const slice &source, unsigned wrap_width=0) noexcept
Definition mdbx.h++:1250
buffer_type value
Definition mdbx.h++:2779
MDBX_CXX14_CONSTEXPR uint64_t as_uint64() const
Definition mdbx.h++:1022
int128_t as_int128_adapt() const
char * write_bytes(char *dest, size_t dest_size) const
Fills the destination with data decoded from Base64 dump from a passed slice.
string< ALLOCATOR > as_string(const ALLOCATOR &allocator=ALLOCATOR()) const
Decodes Base58 dump from a passed slice to returned string.
Definition mdbx.h++:1394
string< ALLOCATOR > as_string(const ALLOCATOR &allocator=ALLOCATOR()) const
Decodes Base64 dump from a passed slice to returned string.
Definition mdbx.h++:1437
slice value
Definition mdbx.h++:2718
::std::ostream & output(::std::ostream &out) const
Output Base64 dump of passed slice to the std::ostream.
MDBX_CXX11_CONSTEXPR pair_result(const slice &key, const slice &value, bool done) noexcept
Definition mdbx.h++:2763
bool is_empty() const noexcept
Checks whether a passed slice is empty, and therefore there will be no output bytes.
Definition mdbx.h++:1237
static MDBX_CXX14_CONSTEXPR slice wrap(const char(&text)[SIZE])
Definition mdbx.h++:711
MDBX_CXX14_CONSTEXPR slice(const ::std::span< POD > &span)
Definition mdbx.h++:674
buffer_pair_spec(const slice &key, const slice &value, const allocator_type &allocator=allocator_type())
Definition mdbx.h++:2796
slice value
Definition mdbx.h++:2732
::std::pair< buffer_type, buffer_type > stl_pair
Definition mdbx.h++:2778
::std::ostream & output(::std::ostream &out) const
Output hexadecimal dump of passed slice to the std::ostream.
pair_result(const pair_result &) noexcept=default
MDBX_CXX11_CONSTEXPR slice(size_t invalid_length) noexcept
Definition mdbx.h++:1052
const slice source
Definition mdbx.h++:1384
const slice source
Definition mdbx.h++:1200
const unsigned wrap_width
Definition mdbx.h++:1202
buffer_pair_spec(const txn &txn, const pair &pair, const allocator_type &allocator=allocator_type())
Definition mdbx.h++:2810
buffer< ALLOCATOR, CAPACITY_POLICY > as_buffer(const ALLOCATOR &allocator=ALLOCATOR()) const
Decodes hexadecimal dump from a passed slice to returned buffer.
Definition mdbx.h++:1361
slice & assign(const ::std::basic_string< CHAR, T, ALLOCATOR > &str)
Definition mdbx.h++:725
const bool ignore_spaces
Definition mdbx.h++:1347
char * write_bytes(char *dest, size_t dest_size) const
Fills the destination with data decoded from Base58 dump from a passed slice.
pair & operator=(const pair &) noexcept=default
bool is_empty() const noexcept
Checks whether a passed slice is empty, and therefore there will be no output bytes.
Definition mdbx.h++:1459
uint16_t as_uint16_adapt() const
static MDBX_CXX14_CONSTEXPR slice invalid() noexcept
Build an invalid slice which non-zero length and refers to null address.
Definition mdbx.h++:1005
buffer< ALLOCATOR, CAPACITY_POLICY > as_buffer(const ALLOCATOR &allocator=ALLOCATOR()) const
Returns a buffer with a Base64 dump of a passed slice.
Definition mdbx.h++:1310
buffer_pair_spec(const slice &key, const slice &value, bool make_reference, const allocator_type &allocator=allocator_type())
Definition mdbx.h++:2798
slice & operator=(const ::std::basic_string_view< CHAR, T > &view)
Definition mdbx.h++:747
std::pair< slice, slice > stl_pair
Definition mdbx.h++:2731
value_result(const value_result &) noexcept=default
MDBX_CXX11_CONSTEXPR pair_result() noexcept
Definition mdbx.h++:2762
@ pettiness_threshold
Definition mdbx.h++:1168
@ extra_inplace_storage
Definition mdbx.h++:1166
@ max_reserve
Definition mdbx.h++:1169
@ inplace_storage_size_rounding
Definition mdbx.h++:1167
string< ALLOCATOR > as_string(const ALLOCATOR &allocator=ALLOCATOR()) const
Returns a string with a hexadecimal dump of a passed slice.
Definition mdbx.h++:1210
buffer_pair_spec(const stl_pair &pair, bool make_reference, const allocator_type &allocator=allocator_type())
Definition mdbx.h++:2793
MDBX_CXX14_CONSTEXPR ::std::span< const byte > bytes() const
Definition mdbx.h++:697
buffer_type key
Definition mdbx.h++:2779
MDBX_CXX14_CONSTEXPR int16_t as_int16() const
Definition mdbx.h++:1032
MDBX_CXX14_CONSTEXPR ::std::span< char > chars()
Definition mdbx.h++:700
bool is_empty() const noexcept
Checks whether a passed slice is empty, and therefore there will be no output bytes.
Definition mdbx.h++:1284
value_result(const slice &value, bool done) noexcept
Definition mdbx.h++:2720
bool is_empty() const noexcept
Checks whether a passed slice is empty, and therefore there will be no output bytes.
Definition mdbx.h++:1417
const slice source
Definition mdbx.h++:1247
MDBX_CXX11_CONSTEXPR pair(const stl_pair &couple) noexcept
Definition mdbx.h++:2734
MDBX_CXX14_CONSTEXPR ::std::span< byte > bytes()
Definition mdbx.h++:698
MDBX_CXX14_CONSTEXPR ::std::span< POD > as_span()
Definition mdbx.h++:688
MDBX_CXX11_CONSTEXPR from_hex(const slice &source, bool ignore_spaces=false) noexcept
Definition mdbx.h++:1348
bool is_erroneous() const noexcept
Checks whether the content of a passed slice is a valid data and could be encoded or unexpectedly not...
Definition mdbx.h++:1241
uint8_t as_uint8_adapt() const
string< ALLOCATOR > as_string(const ALLOCATOR &allocator=ALLOCATOR()) const
Decodes hexadecimal dump from a passed slice to returned string.
Definition mdbx.h++:1355
buffer_pair_spec(const txn &txn, const slice &key, const slice &value, const allocator_type &allocator=allocator_type())
Definition mdbx.h++:2807
slice & assign(const ::std::basic_string_view< CHAR, T > &view)
Definition mdbx.h++:730
MDBX_CXX14_CONSTEXPR uint128_t as_uint128() const
Definition mdbx.h++:1020
bool is_empty() const noexcept
Checks whether a passed slice is empty, and therefore there will be no output bytes.
Definition mdbx.h++:1374
int32_t as_int32_adapt() const
MDBX_CXX11_CONSTEXPR size_t envisage_result_length() const noexcept
Returns the buffer size in bytes needed for hexadecimal dump of a passed slice.
Definition mdbx.h++:1222
string< ALLOCATOR > as_string(const ALLOCATOR &allocator=ALLOCATOR()) const
Returns a string with a Base64 dump of a passed slice.
Definition mdbx.h++:1303
MDBX_CXX11_CONSTEXPR size_t envisage_result_length() const noexcept
Returns the number of bytes needed for conversion Base58 dump from a passed slice to decoded data.
Definition mdbx.h++:1407
buffer_pair_spec(const buffer_type &key, const buffer_type &value, const allocator_type &allocator=allocator_type())
Definition mdbx.h++:2785
MDBX_CXX11_CONSTEXPR to_hex(const slice &source, bool uppercase=false, unsigned wrap_width=0) noexcept
Definition mdbx.h++:1203
char * write_bytes(char *dest, size_t dest_size) const
Fills the buffer by hexadecimal dump of a passed slice.
MDBX_CXX11_CONSTEXPR to_base64(const slice &source, unsigned wrap_width=0) noexcept
Definition mdbx.h++:1296
MDBX_CXX11_CONSTEXPR ::std::basic_string_view< CHAR, T > string_view() const noexcept
Return a string_view that references the same data as this slice.
Definition mdbx.h++:755
MDBX_CXX14_CONSTEXPR uint32_t as_uint32() const
Definition mdbx.h++:1023
bool done
Definition mdbx.h++:2761
::std::ostream & output(::std::ostream &out) const
Output Base58 dump of passed slice to the std::ostream.
bool is_erroneous() const noexcept
Checks whether the content of a passed slice is a valid data and could be encoded or unexpectedly not...
Definition mdbx.h++:1287
buffer_pair_spec(const pair &pair, bool make_reference, const allocator_type &allocator=allocator_type())
Definition mdbx.h++:2804
MDBX_CXX14_CONSTEXPR int8_t as_int8() const
Definition mdbx.h++:1033
buffer< ALLOCATOR, CAPACITY_POLICY > as_buffer(const ALLOCATOR &allocator=ALLOCATOR()) const
Decodes Base64 dump from a passed slice to returned buffer.
Definition mdbx.h++:1444
MDBX_CXX11_CONSTEXPR size_t envisage_result_length() const noexcept
Returns the number of bytes needed for conversion Base64 dump from a passed slice to decoded data.
Definition mdbx.h++:1450
const bool uppercase
Definition mdbx.h++:1201
static MDBX_CXX11_CONSTEXPR size_t round(const size_t value)
Definition mdbx.h++:1172
MDBX_CXX14_CONSTEXPR int64_t as_int64() const
Definition mdbx.h++:1030
void make_freestanding()
Definition mdbx.h++:2831
const bool ignore_spaces
Definition mdbx.h++:1428
pair(const pair &) noexcept=default
bool is_erroneous() const noexcept
Checks whether the content of a passed slice is a valid Base64 dump, and therefore there could be dec...
slice & operator=(const slice &) noexcept=default
uint128_t as_uint128_adapt() const
slice key
Definition mdbx.h++:2732
const slice source
Definition mdbx.h++:1427
pair_result & operator=(const pair_result &) noexcept=default
string< ALLOCATOR > as_string(const ALLOCATOR &allocator=ALLOCATOR()) const
Returns a string with a Base58 dump of a passed slice.
Definition mdbx.h++:1257
bool is_empty() const noexcept
Checks whether a passed slice is empty, and therefore there will be no output bytes.
Definition mdbx.h++:1333
MDBX_CXX14_CONSTEXPR int32_t as_int32() const
Definition mdbx.h++:1031
typename buffer_type::allocator_traits allocator_traits
Definition mdbx.h++:2776
char * write_bytes(char *dest, size_t dest_size) const
Fills the destination with data decoded from hexadecimal dump from a passed slice.
MDBX_CXX11_CONSTEXPR size_t envisage_result_length() const noexcept
Returns the number of bytes needed for conversion hexadecimal dump from a passed slice to decoded dat...
Definition mdbx.h++:1367
MDBX_CXX14_CONSTEXPR POD as_pod() const
Definition mdbx.h++:1007
static MDBX_CXX14_CONSTEXPR pair invalid() noexcept
Definition mdbx.h++:2742
int64_t as_int64_adapt() const
buffer_pair_spec(const stl_pair &pair, const allocator_type &allocator=allocator_type())
Definition mdbx.h++:2791
constexpr ::std::basic_string< CHAR, T, ALLOCATOR > as_string(const ALLOCATOR &allocator=ALLOCATOR()) const
Definition mdbx.h++:769
MDBX_CXX11_CONSTEXPR pair(const slice &key, const slice &value) noexcept
Definition mdbx.h++:2733
CAPACITY_POLICY reservation_policy
Definition mdbx.h++:2777
MDBX_CXX14_CONSTEXPR slice(const ::std::basic_string_view< CHAR, T > &sv)
Create a slice that refers to the same contents as "string_view".
Definition mdbx.h++:706
MDBX_CXX14_CONSTEXPR uint16_t as_uint16() const
Definition mdbx.h++:1024
bool is_erroneous() const noexcept
Checks whether the content of a passed slice is a valid hexadecimal dump, and therefore there could b...
MDBX_CXX11_CONSTEXPR from_base64(const slice &source, bool ignore_spaces=false) noexcept
Definition mdbx.h++:1429
const unsigned wrap_width
Definition mdbx.h++:1248
MDBX_CXX11_CONSTEXPR from_base58(const slice &source, bool ignore_spaces=false) noexcept
Definition mdbx.h++:1386
const unsigned wrap_width
Definition mdbx.h++:1294
uint32_t as_uint32_adapt() const
buffer_pair_spec(const pair &pair, const allocator_type &allocator=allocator_type())
Definition mdbx.h++:2802
char * write_bytes(char *dest, size_t dest_size) const
Fills the buffer by Base64 dump of passed slice.
buffer_pair_spec(buffer_type &&key, buffer_type &&value) noexcept(buffer_type::move_assign_alloc::is_nothrow())
Definition mdbx.h++:2813
static MDBX_CXX14_CONSTEXPR slice wrap(const POD &pod)
Definition mdbx.h++:713
MDBX_CXX11_CONSTEXPR size_t envisage_result_length() const noexcept
Returns the buffer size in bytes needed for Base64 dump of passed slice.
Definition mdbx.h++:1316
int16_t as_int16_adapt() const
MDBX_CXX14_CONSTEXPR int128_t as_int128() const
Definition mdbx.h++:1028
typename buffer_type::allocator_type allocator_type
Definition mdbx.h++:2775
bool is_erroneous() const noexcept
Checks whether the content of a passed slice is a valid data and could be encoded or unexpectedly not...
Definition mdbx.h++:1337
uint64_t as_uint64_adapt() const
constexpr buffer_pair_spec() noexcept=default
buffer_pair_spec(const buffer_type &key, const buffer_type &value, bool make_reference, const allocator_type &allocator=allocator_type())
Definition mdbx.h++:2787
slice(::std::basic_string_view< CHAR, T > &&sv)
Definition mdbx.h++:708
bool done
Definition mdbx.h++:2719
char * write_bytes(char *dest, size_t dest_size) const
Fills the buffer by Base58 dump of passed slice.
const slice source
Definition mdbx.h++:1346
buffer< ALLOCATOR, CAPACITY_POLICY > make_buffer(PRODUCER &producer, const ALLOCATOR &allocator=ALLOCATOR())
Definition mdbx.h++:2667
buffer_pair< default_buffer > default_buffer_pair
Default pair of buffers.
Definition mdbx.h++:2844
inline ::std::ostream & operator<<(::std::ostream &out, const to_hex &wrapper)
Definition mdbx.h++:1340
string< ALLOCATOR > make_string(PRODUCER &producer, const ALLOCATOR &allocator=ALLOCATOR())
Definition mdbx.h++:2689
buffer_pair_spec< typename BUFFER::allocator_type, typename BUFFER::reservation_policy > buffer_pair
Combines pair of buffers for key and value to hold an operands for certain operations.
Definition mdbx.h++:2841
Base58 decoder which satisfy SliceTranscoder concept.
Definition mdbx.h++:1383
Base64 decoder which satisfy SliceTranscoder concept.
Definition mdbx.h++:1426
Hexadecimal decoder which satisfy SliceTranscoder concept.
Definition mdbx.h++:1345
Combines pair of slices for key and value to represent result of certain operations.
Definition mdbx.h++:2730
Combines pair of slices for key and value with boolean flag to represent result of certain operations...
Definition mdbx.h++:2760
References a data located outside the slice.
Definition mdbx.h++:639
Base58 encoder which satisfy SliceTranscoder concept.
Definition mdbx.h++:1246
Base64 encoder which satisfy SliceTranscoder concept.
Definition mdbx.h++:1292
Hexadecimal encoder which satisfy SliceTranscoder concept.
Definition mdbx.h++:1199
Combines data slice with boolean flag to represent result of certain operations.
Definition mdbx.h++:2717
incompatible_operation(const ::mdbx::error &)
fatal(exception &&src) noexcept
Definition mdbx.h++:520
remote_media(const ::mdbx::error &)
dangling_map_id(const ::mdbx::error &)
fatal(const ::mdbx::error &) noexcept
reader_slot_busy(const ::mdbx::error &)
exception(const exception &)=default
MDBX_CXX11_CONSTEXPR friend bool operator!=(const error &a, const error &b) noexcept
Definition mdbx.h++:4675
::std::string message() const
Returns message for any errors.
not_found(const ::mdbx::error &)
operation_not_permitted(const ::mdbx::error &)
key_exists(const ::mdbx::error &)
permission_denied_or_not_writeable(const ::mdbx::error &)
void throw_exception() const
fatal(const exception &src) noexcept
Definition mdbx.h++:519
no_data(const ::mdbx::error &)
transaction_full(const ::mdbx::error &)
exception(exception &&)=default
db_too_large(const ::mdbx::error &)
bad_map_id(const ::mdbx::error &)
transaction_overlapping(const ::mdbx::error &)
void panic(const char *context_where_when, const char *func_who_what) const noexcept
Panics on unrecoverable errors inside destructors etc.
static void success_or_throw(int error_code)
Definition mdbx.h++:488
db_full(const ::mdbx::error &)
duplicated_lck_file(const ::mdbx::error &)
const ::mdbx::error error() const noexcept
Definition mdbx.h++:510
error(const error &)=default
virtual ~fatal() noexcept
something_busy(const ::mdbx::error &)
fatal & operator=(fatal &&)=default
const char * what() const noexcept
Returns message for MDBX's errors only and "SYSTEM" for others.
fatal(const fatal &src) noexcept
Definition mdbx.h++:521
MDBX_CXX11_CONSTEXPR friend bool operator==(const error &a, const error &b) noexcept
Definition mdbx.h++:4673
transaction_ousted(const ::mdbx::error &)
key_mismatch(const ::mdbx::error &)
db_invalid(const ::mdbx::error &)
exception & operator=(exception &&)=default
db_wanna_write_for_recovery(const ::mdbx::error &)
error & operator=(error &&)=default
bad_transaction(const ::mdbx::error &)
internal_problem(const ::mdbx::error &)
multivalue(const ::mdbx::error &)
fatal(fatal &&src) noexcept
Definition mdbx.h++:522
fatal & operator=(const fatal &)=default
max_readers_reached(const ::mdbx::error &)
db_version_mismatch(const ::mdbx::error &)
exception_thunk() noexcept=default
exception & operator=(const exception &)=default
exception(const ::mdbx::error &) noexcept
db_unable_extend(const ::mdbx::error &)
error & operator=(const error &)=default
virtual ~exception() noexcept
thread_mismatch(const ::mdbx::error &)
db_corrupted(const ::mdbx::error &)
internal_page_full(const ::mdbx::error &)
mvcc_retarded(const ::mdbx::error &)
max_maps_reached(const ::mdbx::error &)
bad_value_size(const ::mdbx::error &)
Implements error information and throwing corresponding exceptions.
Definition mdbx.h++:447
Transfers C++ exceptions thru C callbacks.
Definition mdbx.h++:432
LIBMDBX_API void throw_allocators_mismatch()
#define MDBX_DECLARE_EXCEPTION(NAME)
Definition mdbx.h++:528
LIBMDBX_API void throw_incomparable_cursors()
LIBMDBX_API void throw_out_range()
LIBMDBX_API void throw_bad_value_size()
LIBMDBX_API void throw_max_length_exceeded()
LIBMDBX_API void throw_too_small_target_buffer()
uint64_t mdbx_key_from_int64(const int64_t i64)
Definition mdbx.h:4694
LIBMDBX_API uint32_t mdbx_key_from_ptrfloat(const float *const ieee754_32bit)
LIBMDBX_API uint64_t mdbx_key_from_double(const double ieee754_64bit)
LIBMDBX_API uint32_t mdbx_key_from_float(const float ieee754_32bit)
LIBMDBX_API uint64_t mdbx_key_from_ptrdouble(const double *const ieee754_64bit)
uint32_t mdbx_key_from_int32(const int32_t i32)
Definition mdbx.h:4698
LIBMDBX_API uint64_t mdbx_key_from_jsonInteger(const int64_t json_integer)
#define MDBX_CXX20_CONSTEXPR
Definition mdbx.h++:174
#define MDBX_CXX17_FALLTHROUGH
Definition mdbx.h++:232
#define MDBX_EXTERN_API_TEMPLATE(API_ATTRIBUTES, API_TYPENAME)
Definition mdbx.h++:112
#define MDBX_ASSERT_CXX20_CONCEPT_SATISFIED(CONCEPT, TYPE)
Definition mdbx.h++:272
#define MDBX_LIKELY(cond)
Definition mdbx.h++:207
#define MDBX_CXX11_CONSTEXPR_ENUM
Definition mdbx.h++:184
#define MDBX_UNLIKELY(cond)
Definition mdbx.h++:215
#define MDBX_CXX17_CONSTEXPR
Definition mdbx.h++:163
#define MDBX_CONSTEXPR_ASSERT(expr)
Definition mdbx.h++:202
#define MDBX_IF_CONSTEXPR
Definition mdbx.h++:223
#define MDBX_CXX01_CONSTEXPR_ENUM
Definition mdbx.h++:183
#define MDBX_CXX20_LIKELY
Definition mdbx.h++:238
The libmdbx C API header file.
constexpr bool allocator_is_always_equal() noexcept
Definition mdbx.h++:1059
The libmdbx C++ API namespace.
Definition mdbx.h++:305
estimate_result(const cursor &cursor, move_operation operation)
Definition mdbx.h++:4244
estimate_result & operator=(const estimate_result &) noexcept=default
ptrdiff_t approximate_quantity
Definition mdbx.h++:4243
estimate_result(const estimate_result &) noexcept=default
estimate_result(const cursor &cursor, move_operation operation, const slice &key)
Definition mdbx.h++:4246
move_result & operator=(const move_result &) noexcept=default
move_result(const move_result &) noexcept=default
move_result(cursor &cursor, move_operation operation, const slice &key, bool throw_notfound)
Definition mdbx.h++:4234
move_result(cursor &cursor, move_operation operation, bool throw_notfound)
Definition mdbx.h++:4232
Tagged type for output to std::ostream.
Definition mdbx.h++:3072
MDBX_CXX11_CONSTEXPR size(intptr_t bytes) noexcept
Definition mdbx.h++:3074
intptr_t bytes
Definition mdbx.h++:3073
Database geometry for size management.
Definition mdbx.h++:3048
MDBX_CXX11_CONSTEXPR geometry() noexcept
Definition mdbx.h++:3112
intptr_t size_upper
The upper bound of database size in bytes.
Definition mdbx.h++:3096
intptr_t pagesize
The database page size for new database creation or default_value otherwise.
Definition mdbx.h++:3108
@ GB
bytes (0x3B9A_CA00)
Definition mdbx.h++:3055
@ minimal_value
Means "minimal acceptable".
Definition mdbx.h++:3051
@ MB
bytes (0x000F_4240)
Definition mdbx.h++:3054
@ GiB
bytes (0x4000_0000)
Definition mdbx.h++:3063
@ maximal_value
Means "maximal acceptable".
Definition mdbx.h++:3052
@ default_value
Means "keep current or use default".
Definition mdbx.h++:3050
@ kB
bytes (0x03E8)
Definition mdbx.h++:3053
@ MiB
bytes (0x0010_0000)
Definition mdbx.h++:3062
@ KiB
bytes (0x0400)
Definition mdbx.h++:3061
intptr_t growth_step
The growth step in bytes, must be greater than zero to allow the database to grow.
Definition mdbx.h++:3099
MDBX_CXX11_CONSTEXPR geometry(const geometry &) noexcept=default
intptr_t size_now
The size in bytes to setup the database size for now.
Definition mdbx.h++:3084
intptr_t shrink_threshold
The shrink threshold in bytes, must be greater than zero to allow the database to shrink.
Definition mdbx.h++:3102
intptr_t size_lower
The lower bound of database size in bytes.
Definition mdbx.h++:3079
MDBX_CXX11_CONSTEXPR geometry(intptr_t size_lower, intptr_t size_now=default_value, intptr_t size_upper=default_value, intptr_t growth_step=default_value, intptr_t shrink_threshold=default_value, intptr_t pagesize=default_value) noexcept
Definition mdbx.h++:3115
Operate options.
Definition mdbx.h++:3152
bool disable_readahead
Definition mdbx.h++:3161
bool enable_validation
Definition mdbx.h++:3165
bool no_sticky_threads
Definition mdbx.h++:3154
bool disable_clear_memory
Definition mdbx.h++:3163
bool exclusive
Definition mdbx.h++:3159
bool nested_write_transactions
Разрешает вложенные транзакции ценой отключения MDBX_WRITEMAP и увеличением накладных расходов.
Definition mdbx.h++:3157
operate_options(MDBX_env_flags_t) noexcept
MDBX_CXX14_CONSTEXPR operate_options & operator=(const operate_options &) noexcept=default
MDBX_CXX11_CONSTEXPR operate_options() noexcept
Definition mdbx.h++:3166
MDBX_CXX11_CONSTEXPR operate_options(const operate_options &) noexcept=default
Operate parameters.
Definition mdbx.h++:3174
env::durability durability
Definition mdbx.h++:3182
MDBX_CXX14_CONSTEXPR operate_parameters & operator=(const operate_parameters &) noexcept=default
env::operate_options options
Definition mdbx.h++:3184
static env::mode mode_from_flags(MDBX_env_flags_t) noexcept
MDBX_CXX11_CONSTEXPR operate_parameters(const unsigned max_maps, const unsigned max_readers=0, const env::mode mode=env::mode::write_mapped_io, env::durability durability=env::durability::robust_synchronous, const env::reclaiming_options &reclaiming=env::reclaiming_options(), const env::operate_options &options=env::operate_options()) noexcept
Definition mdbx.h++:3188
MDBX_CXX11_CONSTEXPR operate_parameters(const operate_parameters &) noexcept=default
MDBX_CXX11_CONSTEXPR operate_parameters() noexcept
Definition mdbx.h++:3186
unsigned max_readers
The maximum number of threads/reader slots for the environment. Zero means default value.
Definition mdbx.h++:3180
env::reclaiming_options reclaiming
Definition mdbx.h++:3183
env::mode mode
Definition mdbx.h++:3181
static env::durability durability_from_flags(MDBX_env_flags_t) noexcept
unsigned max_maps
The maximum number of named tables/maps for the environment. Zero means default value.
Definition mdbx.h++:3177
MDBX_env_flags_t make_flags(bool accede=true, bool use_subdirectory=false) const
Reader information.
Definition mdbx.h++:3554
mdbx_tid_t thread
The reader thread ID.
Definition mdbx.h++:3557
uint64_t transaction_lag
Definition mdbx.h++:3560
size_t bytes_used
Definition mdbx.h++:3564
uint64_t transaction_id
Definition mdbx.h++:3558
int slot
The reader lock table slot number.
Definition mdbx.h++:3555
mdbx_pid_t pid
The reader process ID.
Definition mdbx.h++:3556
size_t bytes_retained
Definition mdbx.h++:3567
Garbage reclaiming options.
Definition mdbx.h++:3139
MDBX_CXX11_CONSTEXPR reclaiming_options(const reclaiming_options &) noexcept=default
bool coalesce
Definition mdbx.h++:3143
reclaiming_options(MDBX_env_flags_t) noexcept
MDBX_CXX11_CONSTEXPR reclaiming_options() noexcept
Definition mdbx.h++:3144
MDBX_CXX14_CONSTEXPR reclaiming_options & operator=(const reclaiming_options &) noexcept=default
bool lifo
Definition mdbx.h++:3141
Additional parameters for creating a new database.
Definition mdbx.h++:3663
mdbx_mode_t file_mode_bits
Definition mdbx.h++:3665
MDBX_CXX11_CONSTEXPR create_parameters() noexcept=default
bool use_subdirectory
Definition mdbx.h++:3666
env::geometry geometry
Definition mdbx.h++:3664
map_handle::state state
Definition mdbx.h++:2988
info(const info &) noexcept=default
map_handle::flags flags
Definition mdbx.h++:2987
info & operator=(const info &) noexcept=default
capacity_holder capacity_
Definition mdbx.h++:1555
constexpr bool is_inplace() const noexcept
Definition mdbx.h++:1566
static constexpr size_t advise_capacity(const size_t current, const size_t wanna)
Definition mdbx.h++:1656
constexpr bin & operator=(const bin &ditto) noexcept
Definition mdbx.h++:1633
constexpr bin(size_t capacity_bytes=0) noexcept
Definition mdbx.h++:1605
static constexpr bool is_suitable_for_inplace(size_t capacity_bytes) noexcept
Definition mdbx.h++:1558
byte buffer_[inplace_size - sizeof(byte)]
Definition mdbx.h++:1550
constexpr bool is_allocated() const noexcept
Definition mdbx.h++:1573
inplace_flag_holder inplace_
Definition mdbx.h++:1556
constexpr bin(bin &&ditto) noexcept
Definition mdbx.h++:1619
allocator_pointer allocated_ptr_
Definition mdbx.h++:1554
constexpr bin(allocator_pointer ptr, size_t capacity_bytes) noexcept
Definition mdbx.h++:1610
size_t stub_capacity_bytes_
Definition mdbx.h++:1532
constexpr size_t capacity() const noexcept
Definition mdbx.h++:1671
byte pad_[inplace_size - sizeof(allocator_pointer)]
Definition mdbx.h++:1545
size_t bytes_
Definition mdbx.h++:1546
constexpr ~bin()
Definition mdbx.h++:1614
constexpr const byte * address() const noexcept
Definition mdbx.h++:1665
constexpr byte * make_allocated(allocator_pointer ptr, size_t capacity_bytes) noexcept
Definition mdbx.h++:1590
@ inplace_size
Definition mdbx.h++:1540
@ inplace_signature_limit
Definition mdbx.h++:1537
@ inplace_size_rounding
Definition mdbx.h++:1539
constexpr byte * address() noexcept
Definition mdbx.h++:1668
constexpr bin & operator=(bin &&ditto) noexcept
Definition mdbx.h++:1649
@ lastbyte_poison
Definition mdbx.h++:1535
@ lastbyte_inplace_signature
Definition mdbx.h++:1535
constexpr byte * make_inplace() noexcept
Definition mdbx.h++:1575
byte lastbyte_
Definition mdbx.h++:1551
allocator_pointer ptr_
Definition mdbx.h++:1531