quasardb 3.14.2.dev0__cp311-cp311-macosx_11_0_arm64.whl → 3.14.2.dev2__cp311-cp311-macosx_11_0_arm64.whl

quasardb/continuous.cpp

@@ -1,25 +1,19 @@
 #include "continuous.hpp"
+#include <iostream>
 
 namespace qdb
 {
 
-query_continuous::query_continuous(qdb::handle_ptr h,
-    qdb_query_continuous_mode_type_t mode,
-    std::chrono::milliseconds pace,
-    const std::string & query_string,
-    const py::object & bools)
-    : _handle{h}
+query_continuous::query_continuous(qdb::handle_ptr h, const py::object & bools)
+    : _logger("quasardb.query_continuous")
+    , _handle{h}
     , _callback{&query_continuous::continuous_callback}
     , _cont_handle{nullptr}
     , _parse_bools{bools}
     , _previous_watermark{0}
     , _watermark{0}
     , _last_error{qdb_e_uninitialized}
-{
-    qdb::qdb_throw_if_error(
-        *_handle, qdb_query_continuous(*_handle, query_string.c_str(), mode,
-                      static_cast<unsigned>(pace.count()), _callback, this, &_cont_handle));
-}
+{}
 
 query_continuous::~query_continuous()
 {
@@ -27,6 +21,15 @@ query_continuous::~query_continuous()
     release_results();
 }
 
+void query_continuous::run(qdb_query_continuous_mode_type_t mode,
+    std::chrono::milliseconds pace,
+    const std::string & query_string)
+{
+    qdb::qdb_throw_if_error(
+        *_handle, qdb_query_continuous(*_handle, query_string.c_str(), mode,
+                      static_cast<unsigned>(pace.count()), _callback, this, &_cont_handle));
+}
+
 void query_continuous::release_results()
 {
     if (_results)
@@ -48,6 +51,7 @@ int query_continuous::continuous_callback(void * p, qdb_error_t err, const qdb_q
 {
     auto pthis = static_cast<query_continuous *>(p);
 
+    try
     {
         std::unique_lock<std::mutex> lock{pthis->_results_mutex};
 
@@ -56,8 +60,8 @@ int query_continuous::continuous_callback(void * p, qdb_error_t err, const qdb_q
         pthis->_last_error = err;
         if (QDB_FAILURE(pthis->_last_error))
         {
-            // signal the error, if processing end, we will get a qdb_e_interrupted which is handled in
-            // the results function
+            // signal the error, if processing end, we will get a qdb_e_interrupted which is handled
+            // in the results function
             lock.unlock();
             pthis->_results_cond.notify_all();
             return 0;
@@ -75,6 +79,19 @@ int query_continuous::continuous_callback(void * p, qdb_error_t err, const qdb_q
             pthis->release_results();
         }
     }
+    catch (std::system_error const & e)
+    {
+        // Nothing we can do really, this is most likely a "deadlock avoided" issue.
+        std::cerr << "Internal error: unexpected exception caught in continuous query callback: "
+                     "system_error: "
+                  << e.what() << std::endl;
+    }
+    catch (std::exception const & e)
+    {
+        // Nothing we can do really, this is most likely a "deadlock avoided" issue.
+        std::cerr << "Internal error: unexpected exception caught in continuous query callback: "
+                  << e.what() << std::endl;
+    }
 
     pthis->_results_cond.notify_all();
 
@@ -101,40 +118,73 @@ dict_query_result_t query_continuous::unsafe_results()
 
 dict_query_result_t query_continuous::results()
 {
-    std::unique_lock<std::mutex> lock{_results_mutex};
-
-    // you need an additional mechanism to check if you need to do something with the results
-    // because condition variables can have spurious calls
-    while (_watermark == _previous_watermark)
+    try
     {
-        // entering the condition variables releases the mutex
-        // the callback can update the values when needed
-        // every second we are going to check if the user didn't do CTRL-C
-        if (_results_cond.wait_for(lock, std::chrono::seconds{1}) == std::cv_status::timeout)
+        std::unique_lock<std::mutex> lock{_results_mutex};
+
+        // you need an additional mechanism to check if you need to do something with the results
+        // because condition variables can have spurious calls
+        while (_watermark == _previous_watermark)
         {
-            // if we don't do this, it will be impossible to interrupt the Python program while we wait
-            // for results
-            if (PyErr_CheckSignals() != 0) throw py::error_already_set();
+            // entering the condition variables releases the mutex
+            // the callback can update the values when needed
+            // every second we are going to check if the user didn't do CTRL-C
+            if (_results_cond.wait_for(lock, std::chrono::seconds{1}) == std::cv_status::timeout)
+            {
+                // if we don't do this, it will be impossible to interrupt the Python program while
+                // we wait for results
+                if (PyErr_CheckSignals() != 0)
+                {
+                    throw py::error_already_set();
+                }
+            }
         }
-    }
 
-    return unsafe_results();
+        return unsafe_results();
+    }
+    catch (std::system_error const & e)
+    {
+        _logger.warn("continuous query caught system error, e.what(): %s", e.what());
+        _logger.warn("continuous query caught system error, e.code(): %d", e.code());
+        return dict_query_result_t{};
+    }
+    catch (std::exception const & e)
+    {
+        _logger.warn(
+            "Internal error: unexpected exception caught while gathering results: %s", e.what());
+        return dict_query_result_t{};
+    }
 }
 
 // the difference with the call above is that we're returning immediately if there's no change
 dict_query_result_t query_continuous::probe_results()
 {
-    std::unique_lock<std::mutex> lock{_results_mutex};
+    try
+    {
+        std::unique_lock<std::mutex> lock{_results_mutex};
 
-    // check if there's a new value
-    if (_watermark == _previous_watermark)
+        // check if there's a new value
+        if (_watermark == _previous_watermark)
+        {
+            // nope return empty, don't wait, don't acquire the condition variable
+            return dict_query_result_t{};
+        }
+
+        // yes, return the value
+        return unsafe_results();
+    }
+    catch (std::system_error const & e)
     {
-        // nope return empty, don't wait, don't acquire the condition variable
+        _logger.warn("continuous query caught system error, e.what(): %s", e.what());
+        _logger.warn("continuous query caught system error, e.code(): %d", e.code());
+        return dict_query_result_t{};
+    }
+    catch (std::exception const & e)
+    {
+        _logger.warn(
+            "Internal error: unexpected exception caught while gathering results: %s", e.what());
         return dict_query_result_t{};
     }
-
-    // yes, return the value
-    return unsafe_results();
 }
 
 void query_continuous::stop()

quasardb/continuous.hpp

@@ -30,6 +30,7 @@
  */
 #pragma once
 
+#include "logger.hpp"
 #include "query.hpp"
 #include <atomic>
 #include <condition_variable>
@@ -43,14 +44,14 @@ namespace qdb
 class query_continuous : public std::enable_shared_from_this<query_continuous>
 {
 public:
-    query_continuous(qdb::handle_ptr h,
-        qdb_query_continuous_mode_type_t mode,
-        std::chrono::milliseconds pace,
-        const std::string & query_string,
-        const py::object & bools);
+    query_continuous(qdb::handle_ptr h, const py::object & bools);
     query_continuous(const qdb::query_continuous & /*other*/) = delete;
     ~query_continuous();
 
+    void run(qdb_query_continuous_mode_type_t mode,
+        std::chrono::milliseconds pace,
+        const std::string & query_string);
+
 private:
     void release_results();
     qdb_error_t copy_results(const qdb_query_result_t * res);
@@ -70,6 +71,8 @@ public:
     void stop();
 
 private:
+    qdb::logger _logger;
+
     qdb::handle_ptr _handle;
     qdb_query_cont_callback_t _callback;
     qdb_query_cont_handle_t _cont_handle;
@@ -91,9 +94,9 @@ static inline void register_continuous(Module & m)
     namespace py = pybind11;
 
     py::class_<qdb::query_continuous, std::shared_ptr<qdb::query_continuous>>{m, "QueryContinuous"} //
-        .def(py::init<qdb::handle_ptr, qdb_query_continuous_mode_type_t, std::chrono::milliseconds,
-            const std::string &,
+        .def(py::init<qdb::handle_ptr,
             const py::object &>())                                   //
+        .def("run", &qdb::query_continuous::run)                     //
         .def("results", &qdb::query_continuous::results)             //
         .def("probe_results", &qdb::query_continuous::probe_results) //
         .def("stop", &qdb::query_continuous::stop)                   //

quasardb/convert/array.hpp

@@ -79,8 +79,8 @@ struct convert_array;
 //
 /////
 template <typename From, typename To>
-requires(concepts::dtype<From> && !concepts::delegate_dtype<From> && concepts::qdb_primitive<To>) struct
-    convert_array<From, To>
+    requires(concepts::dtype<From> && !concepts::delegate_dtype<From> && concepts::qdb_primitive<To>)
+struct convert_array<From, To>
 {
     using value_type = typename From::value_type;
     static constexpr value_converter<From, To> const xform_{};
@@ -105,7 +105,8 @@ requires(concepts::dtype<From> && !concepts::delegate_dtype<From> && concepts::q
 //
 /////
 template <typename From, typename To>
-requires(concepts::delegate_dtype<From> && concepts::qdb_primitive<To>) struct convert_array<From, To>
+    requires(concepts::delegate_dtype<From> && concepts::qdb_primitive<To>)
+struct convert_array<From, To>
 {
     // Source value_type, e.g. std::int32_t
     using value_type = typename From::value_type;
@@ -144,7 +145,8 @@ requires(concepts::delegate_dtype<From> && concepts::qdb_primitive<To>) struct c
 //
 /////
 template <typename From, typename To>
-requires(concepts::qdb_primitive<From> && !concepts::delegate_dtype<To>) struct convert_array<From, To>
+    requires(concepts::qdb_primitive<From> && !concepts::delegate_dtype<To>)
+struct convert_array<From, To>
 {
     static constexpr value_converter<From, To> const xform_{};
 
@@ -168,7 +170,8 @@ requires(concepts::qdb_primitive<From> && !concepts::delegate_dtype<To>) struct
 //
 /////
 template <typename From, typename To>
-requires(concepts::qdb_primitive<From> && concepts::delegate_dtype<To>) struct convert_array<From, To>
+    requires(concepts::qdb_primitive<From> && concepts::delegate_dtype<To>)
+struct convert_array<From, To>
 {
     // Destination value_type, e.g. std::int32_t
     using value_type = typename To::value_type;
@@ -252,6 +255,19 @@ static inline constexpr std::vector<To> array(py::array const & xs)
     return ranges::to<std::vector>(detail::to_range<From>(xs) | detail::convert_array<From, To>{}());
 }
 
+// qdb -> numpy
+template <concepts::qdb_primitive From, concepts::dtype To, ranges::input_range R>
+    requires(concepts::input_range_t<R, From>)
+static inline py::array array(R && xs)
+{
+    if (ranges::empty(xs)) [[unlikely]]
+    {
+        return {};
+    };
+
+    return detail::to_array<To>(xs | detail::convert_array<From, To>{}());
+}
+
 // numpy -> qdb
 template <concepts::dtype From, concepts::qdb_primitive To>
 static inline constexpr void masked_array(qdb::masked_array const & xs, std::vector<To> & dst)
@@ -268,7 +284,8 @@ static inline constexpr std::vector<To> masked_array(qdb::masked_array const & x
 
 // qdb -> numpy
 template <concepts::qdb_primitive From, concepts::dtype To, ranges::input_range R>
-requires(concepts::input_range_t<R, From>) static inline qdb::masked_array masked_array(R && xs)
+    requires(concepts::input_range_t<R, From>)
+static inline qdb::masked_array masked_array(R && xs)
 {
     if (ranges::empty(xs)) [[unlikely]]
     {

quasardb/convert/value.hpp

@@ -32,6 +32,7 @@
 
 #include "../concepts.hpp"
 #include "../error.hpp"
+#include "../numpy.hpp"
 #include "../object_tracker.hpp"
 #include "../pytypes.hpp"
 #include "../traits.hpp"
@@ -334,8 +335,9 @@ struct value_converter<clock_t::time_point, qdb::pydatetime>
         auto micros = std::chrono::duration_cast<microseconds_t>(since_epoch);
 
         return qdb::pydatetime::from_date_and_time(static_cast<int>(ymd.year()),
-            static_cast<unsigned>(ymd.month()), static_cast<unsigned>(ymd.day()), static_cast<int>(hms.hours().count()),
-            static_cast<int>(hms.minutes().count()), static_cast<int>(hms.seconds().count()), static_cast<int>(micros.count()));
+            static_cast<unsigned>(ymd.month()), static_cast<unsigned>(ymd.day()),
+            static_cast<int>(hms.hours().count()), static_cast<int>(hms.minutes().count()),
+            static_cast<int>(hms.seconds().count()), static_cast<int>(micros.count()));
     }
 };
 
@@ -378,6 +380,23 @@ struct value_converter<qdb::pydatetime, qdb_timespec_t>
     }
 };
 
+/**
+ * Creates a numpy datetime64[ns] out of a nanosecond-precision int64
+ */
+template <>
+struct value_converter<std::int64_t, qdb::numpy::datetime64>
+{
+    inline qdb::numpy::datetime64 operator()(std::int64_t const & x) const
+    {
+        return qdb::numpy::datetime64{x};
+    }
+};
+
+/**
+ * Creates a nanosecond precision int64 out of a qdb_timespec_t. The resulting
+ * integer represents the amount of nanoseconds since epoch, which is the
+ * same representation numpy uses internally.
+ */
 template <>
 struct value_converter<qdb_timespec_t, std::int64_t>
 {
@@ -388,6 +407,21 @@ struct value_converter<qdb_timespec_t, std::int64_t>
     }
 };
 
+/**
+ * Convenience wrapper which directly converts timespecs to numpy datetime64
+ */
+template <>
+struct value_converter<qdb_timespec_t, qdb::numpy::datetime64>
+{
+    value_converter<std::int64_t, qdb::numpy::datetime64> int64_to_datetime64_{};
+    value_converter<qdb_timespec_t, std::int64_t> ts_to_int64_{};
+
+    inline qdb::numpy::datetime64 operator()(qdb_timespec_t const & x) const
+    {
+        return int64_to_datetime64_(ts_to_int64_(x));
+    }
+};
+
 template <>
 struct value_converter<qdb_timespec_t, traits::datetime64_ns_dtype>
     : public value_converter<qdb_timespec_t, std::int64_t>
@@ -419,12 +453,38 @@ struct value_converter<traits::bytestring_dtype, qdb_string_t>
         requires(ranges::sized_range<R> && ranges::contiguous_range<R>)
     inline qdb_string_t operator()(R && x) const
     {
-        std::size_t n     = (ranges::size(x) + 1) * sizeof(char_t);
-        char_t const * x_ = ranges::data(x);
-        char_t * tmp      = qdb::object_tracker::alloc<char_t>(n);
+        std::size_t n_chars = ranges::size(x);
+        std::size_t n_bytes = (n_chars + 1) * sizeof(char_t);
+        char_t const * x_   = ranges::data(x);
+        char_t * tmp        = qdb::object_tracker::alloc<char_t>(n_bytes);
+
+        std::memcpy((void *)(tmp), x_, n_bytes);
 
-        std::memcpy((void *)(tmp), x_, ranges::size(x) + 1);
-        return qdb_string_t{tmp, ranges::size(x)};
+        // For safety purposes, always null-terminate the output string.
+        tmp[n_chars] = '\0';
+        assert(tmp[n_chars] == '\0');
+
+        return qdb_string_t{tmp, n_chars};
+    }
+};
+
+template <>
+struct value_converter<std::string, qdb_string_t>
+{
+    value_converter<traits::bytestring_dtype, qdb_string_t> delegate_{};
+
+    inline qdb_string_t operator()(std::string const & x) const
+    {
+        return delegate_(x);
+    }
+};
+
+template <>
+struct value_converter<qdb_string_t, std::string>
+{
+    inline std::string operator()(qdb_string_t const & x) const
+    {
+        return {x.data, x.length};
     }
 };
 
@@ -600,6 +660,17 @@ struct value_converter<qdb_string_t, traits::unicode_dtype>
     }
 };
 
+template <>
+struct value_converter<qdb_ts_range_t, py::tuple>
+{
+    value_converter<qdb_timespec_t, qdb::numpy::datetime64> delegate_{};
+
+    inline py::tuple operator()(qdb_ts_range_t const & x) const
+    {
+        return py::make_tuple(delegate_(x.begin), delegate_(x.end));
+    }
+};
+
 template <>
 struct value_converter<py::object, qdb_blob_t>
 {

quasardb/date/CMakeFiles/CMakeDirectoryInformation.cmake

@@ -1,5 +1,5 @@
 # CMAKE generated file: DO NOT EDIT!
-# Generated by "Unix Makefiles" Generator, CMake Version 3.24
+# Generated by "Unix Makefiles" Generator, CMake Version 3.29
 
 # Relative path conversion top directories.
 set(CMAKE_RELATIVE_PATH_TOP_SOURCE "/Users/teamcity/buildAgent/work/938b0bdf6727d1ad/thirdparty")

quasardb/date/CMakeFiles/Export/a52b05f964b070ee926bcad51d3288af/dateTargets.cmake

@@ -3,11 +3,11 @@
 if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8)
    message(FATAL_ERROR "CMake >= 2.8.0 required")
 endif()
-if(CMAKE_VERSION VERSION_LESS "2.8.3")
-   message(FATAL_ERROR "CMake >= 2.8.3 required")
+if(CMAKE_VERSION VERSION_LESS "3.1.0")
+   message(FATAL_ERROR "CMake >= 3.1.0 required")
 endif()
 cmake_policy(PUSH)
-cmake_policy(VERSION 2.8.3...3.22)
+cmake_policy(VERSION 3.1.0...3.27)
 #----------------------------------------------------------------
 # Generated CMake target import file.
 #----------------------------------------------------------------
@@ -64,10 +64,6 @@ set_target_properties(date::date PROPERTIES
   INTERFACE_SOURCES "${_IMPORT_PREFIX}/include/date/date.h"
 )
 
-if(CMAKE_VERSION VERSION_LESS 3.1.0)
-  message(FATAL_ERROR "This file relies on consumers using CMake 3.1.0 or greater.")
-endif()
-
 # Load information for each installed configuration.
 file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/dateTargets-*.cmake")
 foreach(_cmake_config_file IN LISTS _cmake_config_files)
@@ -81,9 +77,12 @@ set(_IMPORT_PREFIX)
 
 # Loop over all imported files and verify that they actually exist
 foreach(_cmake_target IN LISTS _cmake_import_check_targets)
-  foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}")
-    if(NOT EXISTS "${_cmake_file}")
-      message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file
+  if(CMAKE_VERSION VERSION_LESS "3.28"
+      OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target}
+      OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}")
+    foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}")
+      if(NOT EXISTS "${_cmake_file}")
+        message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file
    \"${_cmake_file}\"
 but this file does not exist.  Possible reasons include:
 * The file was deleted, renamed, or moved to another location.
@@ -92,8 +91,9 @@ but this file does not exist.  Possible reasons include:
    \"${CMAKE_CURRENT_LIST_FILE}\"
 but not all the files it references.
 ")
-    endif()
-  endforeach()
+      endif()
+    endforeach()
+  endif()
   unset(_cmake_file)
   unset("_cmake_import_check_files_for_${_cmake_target}")
 endforeach()

quasardb/date/Makefile

@@ -1,5 +1,5 @@
 # CMAKE generated file: DO NOT EDIT!
-# Generated by "Unix Makefiles" Generator, CMake Version 3.24
+# Generated by "Unix Makefiles" Generator, CMake Version 3.29
 
 # Default target executed when no arguments are given to make.
 default_target: all
@@ -67,7 +67,7 @@ CMAKE_BINARY_DIR = /Users/teamcity/buildAgent/work/938b0bdf6727d1ad/build/temp.m
 
 # Special rule for the target edit_cache
 edit_cache:
-	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --cyan "Running CMake cache editor..."
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Running CMake cache editor..."
 	/opt/local/bin/ccmake -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR)
 .PHONY : edit_cache
 
@@ -77,7 +77,7 @@ edit_cache/fast: edit_cache
 
 # Special rule for the target rebuild_cache
 rebuild_cache:
-	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --cyan "Running CMake to regenerate build system..."
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Running CMake to regenerate build system..."
 	/opt/local/bin/cmake --regenerate-during-build -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR)
 .PHONY : rebuild_cache
 
@@ -87,7 +87,7 @@ rebuild_cache/fast: rebuild_cache
 
 # Special rule for the target list_install_components
 list_install_components:
-	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --cyan "Available install components are: \"Unspecified\""
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Available install components are: \"Unspecified\""
 .PHONY : list_install_components
 
 # Special rule for the target list_install_components
@@ -96,37 +96,37 @@ list_install_components/fast: list_install_components
 
 # Special rule for the target install
 install: preinstall
-	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --cyan "Install the project..."
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Install the project..."
 	/opt/local/bin/cmake -P cmake_install.cmake
 .PHONY : install
 
 # Special rule for the target install
 install/fast: preinstall/fast
-	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --cyan "Install the project..."
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Install the project..."
 	/opt/local/bin/cmake -P cmake_install.cmake
 .PHONY : install/fast
 
 # Special rule for the target install/local
 install/local: preinstall
-	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --cyan "Installing only the local directory..."
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Installing only the local directory..."
 	/opt/local/bin/cmake -DCMAKE_INSTALL_LOCAL_ONLY=1 -P cmake_install.cmake
 .PHONY : install/local
 
 # Special rule for the target install/local
 install/local/fast: preinstall/fast
-	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --cyan "Installing only the local directory..."
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Installing only the local directory..."
 	/opt/local/bin/cmake -DCMAKE_INSTALL_LOCAL_ONLY=1 -P cmake_install.cmake
 .PHONY : install/local/fast
 
 # Special rule for the target install/strip
 install/strip: preinstall
-	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --cyan "Installing the project stripped..."
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Installing the project stripped..."
 	/opt/local/bin/cmake -DCMAKE_INSTALL_DO_STRIP=1 -P cmake_install.cmake
 .PHONY : install/strip
 
 # Special rule for the target install/strip
 install/strip/fast: preinstall/fast
-	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --cyan "Installing the project stripped..."
+	@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Installing the project stripped..."
 	/opt/local/bin/cmake -DCMAKE_INSTALL_DO_STRIP=1 -P cmake_install.cmake
 .PHONY : install/strip/fast
 

quasardb/date/dateConfigVersion.cmake

@@ -52,7 +52,14 @@ else()
 endif()
 
 
-# if the installed project requested no architecture check, don't perform the check
-if("FALSE")
+# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it:
+if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "")
   return()
 endif()
+
+# check that the installed version has the same 32/64bit-ness as the one which is currently searching:
+if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8")
+  math(EXPR installedBits "8 * 8")
+  set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)")
+  set(PACKAGE_VERSION_UNSUITABLE TRUE)
+endif()

quasardb/date/dateTargets.cmake

@@ -3,11 +3,11 @@
 if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8)
    message(FATAL_ERROR "CMake >= 2.8.0 required")
 endif()
-if(CMAKE_VERSION VERSION_LESS "2.8.3")
-   message(FATAL_ERROR "CMake >= 2.8.3 required")
+if(CMAKE_VERSION VERSION_LESS "3.0.0")
+   message(FATAL_ERROR "CMake >= 3.0.0 required")
 endif()
 cmake_policy(PUSH)
-cmake_policy(VERSION 2.8.3...3.22)
+cmake_policy(VERSION 3.0.0...3.27)
 #----------------------------------------------------------------
 # Generated CMake target import file.
 #----------------------------------------------------------------
@@ -15,10 +15,6 @@ cmake_policy(VERSION 2.8.3...3.22)
 # Commands may need to know the format version.
 set(CMAKE_IMPORT_FILE_VERSION 1)
 
-if(CMAKE_VERSION VERSION_LESS 3.0.0)
-  message(FATAL_ERROR "This file relies on consumers using CMake 3.0.0 or greater.")
-endif()
-
 # Protect against multiple inclusion, which would fail when already imported targets are added once more.
 set(_cmake_targets_defined "")
 set(_cmake_targets_not_defined "")

quasardb/detail/retry.cpp

@@ -0,0 +1,30 @@
+#include "retry.hpp"
+#include <pybind11/chrono.h>
+
+namespace qdb::detail
+{
+
+void register_retry_options(py::module_ & m)
+{
+    namespace py = pybind11;
+
+    py::class_<retry_options>{m, "RetryOptions"}                                      //
+        .def(py::init<std::size_t, std::chrono::milliseconds, std::size_t, double>(), //
+            py::arg("retries") = std::size_t{3},                                      //
+            py::kw_only(),                                                            //
+            py::arg("delay")    = std::chrono::milliseconds{3000},                    //
+            py::arg("exponent") = std::size_t{2},                                     //
+            py::arg("jitter")   = double{0.1}                                         //
+            )                                                                         //
+                                                                                      //
+        .def_readwrite("retries_left", &retry_options::retries_left)                  //
+        .def_readwrite("delay", &retry_options::delay)                                //
+        .def_readwrite("exponent", &retry_options::exponent)                          //
+        .def_readwrite("jitter", &retry_options::jitter)                              //
+                                                                                      //
+        .def("has_next", &retry_options::has_next)                                    //
+        .def("next", &retry_options::next)                                            //
+        ;
+}
+
+}; // namespace qdb::detail