quasardb 3.14.1.dev4__cp39-cp39-win_amd64.whl → 3.14.1.dev6__cp39-cp39-win_amd64.whl

quasardb/CMakeLists.txt

@@ -325,6 +325,7 @@ set(QDB_FILES
   batch_inserter.hpp
   blob.hpp
   cluster.hpp
+  cluster.cpp
   concepts.hpp
   continuous.cpp
   continuous.hpp
@@ -333,9 +334,12 @@ set(QDB_FILES
   error.hpp
   entry.hpp
   handle.hpp
+  handle.cpp
   logger.hpp
   logger.cpp
   masked_array.hpp
+  metrics.hpp
+  metrics.cpp
   module.hpp
   module.cpp
   node.hpp

quasardb/cluster.cpp

@@ -0,0 +1,89 @@
+#include "cluster.hpp"
+#include "metrics.hpp"
+#include <chrono>
+#include <thread>
+
+namespace qdb
+{
+
+cluster::cluster(const std::string & uri,
+    const std::string & user_name,
+    const std::string & user_private_key,
+    const std::string & cluster_public_key,
+    const std::string & user_security_file,
+    const std::string & cluster_public_key_file,
+    std::chrono::milliseconds timeout,
+    bool do_version_check)
+    : _uri{uri}
+    , _handle{make_handle_ptr()}
+    , _json_loads{pybind11::module::import("json").attr("loads")}
+    , _logger("quasardb.cluster")
+{
+    if (do_version_check == true)
+    {
+        _logger.warn(
+            "do_version_check parameter has been deprecated and a no-op. It will be removed from a "
+            "future release");
+    }
+
+    options().apply_credentials(user_name, user_private_key, cluster_public_key, //
+        user_security_file, cluster_public_key_file);
+
+    options().set_timeout(timeout);
+
+    // HACKS(leon): we need to ensure there is always one callback active
+    //              for qdb. Callbacks can be lost when the last active session
+    //              gets closed. As such, the most pragmatic place to 'check'
+    //              for this callback is when establishing a new connection.
+    qdb::native::swap_callback();
+
+    _logger.info("Connecting to cluster %s", _uri);
+    _handle->connect(_uri);
+}
+
+void cluster::close()
+{
+    _logger.info("Closing connection to cluster");
+
+    try
+    {
+        if (is_open() == true) [[likely]]
+        {
+            _handle->close();
+        }
+    }
+    catch (qdb::invalid_handle_exception const & e)
+    {
+        // This can happen if, for example, we call close() after an error occured; in those
+        // circumstances, we fully expect the connection to already be invalid, and we should
+        // not care if this specific exception is raised.
+        _logger.warn("Connection already closed");
+    }
+
+    _handle.reset();
+
+    assert(is_open() == false);
+}
+
+void cluster::wait_for_compaction()
+{
+
+    // We define this function in the .cpp file so we can avoid including chrono and thread
+    // in the header file.
+
+    using namespace std::chrono_literals;
+
+    for (;;)
+    {
+        std::uint64_t progress = compact_progress();
+
+        if (progress == 0) [[unlikely]]
+        {
+            break;
+        }
+
+        std::this_thread::sleep_for(100ms);
+    }
+}
+
+}; // namespace qdb

quasardb/cluster.hpp

@@ -57,6 +57,7 @@
 #include <pybind11/operators.h>
 #include <pybind11/stl.h>
 #include <chrono>
+#include <iostream>
 
 namespace qdb
 {
@@ -71,39 +72,30 @@ public:
         const std::string & user_security_file      = {},
         const std::string & cluster_public_key_file = {},
         std::chrono::milliseconds timeout           = std::chrono::minutes{1},
-        bool do_version_check                       = false)
-        : _uri{uri}
-        , _handle{make_handle_ptr()}
-        , _json_loads{pybind11::module::import("json").attr("loads")}
-        , _logger("quasardb.cluster")
-    {
-        if (do_version_check == true)
-        {
-            _logger.warn(
-                "do_version_check parameter has been deprecated and a no-op. It will be removed from a "
-                "future release");
-        }
-
-        options().apply_credentials(user_name, user_private_key, cluster_public_key, //
-            user_security_file, cluster_public_key_file);
+        bool do_version_check                       = false);
 
-        options().set_timeout(timeout);
-
-        // HACKS(leon): we need to ensure there is always one callback active
-        //              for qdb. Callbacks can be lost when the last active session
-        //              gets closed. As such, the most pragmatic place to 'check'
-        //              for this callback is when establishing a new connection.
-        qdb::native::swap_callback();
+public:
+    void close();
 
-        _logger.info("Connecting to cluster %s", _uri);
-        _handle->connect(_uri);
+    bool is_open() const
+    {
+        return _handle.get() != nullptr && _handle->is_open();
     }
 
-public:
-    void close()
+    /**
+     * Throws exception if the connection is not open. Should be invoked before any operation
+     * is done on the handle, as the QuasarDB C API only checks for a canary presence in the
+     * handle's memory arena. If a compiler is optimizing enough, the handle can be closed but
+     * the canary still present in memory, so it's UB.
+     *
+     * As such, we should check on a higher level.
+     */
+    void check_open() const
     {
-        _logger.info("Closing connection to cluster");
-        _handle.reset();
+        if (is_open() == false) [[unlikely]]
+        {
+            throw qdb::invalid_handle_exception{};
+        }
     }
 
     void tidy_memory()
@@ -153,11 +145,6 @@ public:
         return *this;
     }
 
-    bool is_open() const
-    {
-        return _handle.get() != nullptr;
-    }
-
     void exit(pybind11::object type, pybind11::object value, pybind11::object traceback)
     {
         return close();
@@ -165,6 +152,8 @@ public:
 
     pybind11::object node_config(const std::string & uri)
     {
+        check_open();
+
         const char * content      = nullptr;
         qdb_size_t content_length = 0;
 
@@ -176,6 +165,8 @@ public:
 
     pybind11::object node_status(const std::string & uri)
     {
+        check_open();
+
         const char * content      = nullptr;
         qdb_size_t content_length = 0;
 
@@ -187,6 +178,8 @@ public:
 
     pybind11::object node_topology(const std::string & uri)
     {
+        check_open();
+
         const char * content      = nullptr;
         qdb_size_t content_length = 0;
 
@@ -199,64 +192,88 @@ public:
 public:
     qdb::tag tag(const std::string & alias)
     {
+        check_open();
+
         return qdb::tag{_handle, alias};
     }
 
     qdb::blob_entry blob(const std::string & alias)
     {
+        check_open();
+
         return qdb::blob_entry{_handle, alias};
     }
 
     qdb::string_entry string(const std::string & alias)
     {
+        check_open();
+
         return qdb::string_entry{_handle, alias};
     }
 
     qdb::integer_entry integer(const std::string & alias)
     {
+        check_open();
+
         return qdb::integer_entry{_handle, alias};
     }
 
     qdb::double_entry double_(const std::string & alias)
     {
+        check_open();
+
         return qdb::double_entry{_handle, alias};
     }
 
     qdb::timestamp_entry timestamp(const std::string & alias)
     {
+        check_open();
+
         return qdb::timestamp_entry{_handle, alias};
     }
 
     qdb::table table(const std::string & alias)
     {
+        check_open();
+
         return qdb::table{_handle, alias};
     }
 
     // the batch_inserter_ptr is non-copyable
     qdb::batch_inserter_ptr inserter(const std::vector<batch_column_info> & ci)
     {
+        check_open();
+
         return std::make_unique<qdb::batch_inserter>(_handle, ci);
     }
 
     // the batch_inserter_ptr is non-copyable
     qdb::writer_ptr writer()
     {
+        check_open();
+
         return std::make_unique<qdb::writer>(_handle);
     }
 
     // the batch_inserter_ptr is non-copyable
     qdb::writer_ptr pinned_writer()
     {
+        check_open();
+
         return writer();
     }
 
     qdb::options options()
     {
+        check_open();
+
         return qdb::options{_handle};
     }
 
     qdb::perf perf()
     {
+        check_open();
+
         return qdb::perf{_handle};
     }
 
@@ -268,6 +285,8 @@ public:
 public:
     std::vector<std::string> prefix_get(const std::string & prefix, qdb_int_t max_count)
     {
+        check_open();
+
         const char ** result = nullptr;
         size_t count         = 0;
 
@@ -283,6 +302,8 @@ public:
 
     qdb_uint_t prefix_count(const std::string & prefix)
     {
+        check_open();
+
         qdb_uint_t count = 0;
 
         const qdb_error_t err = qdb_prefix_count(*_handle, prefix.c_str(), &count);
@@ -294,22 +315,30 @@ public:
 public:
     qdb::find_query find(const std::string & query_string)
     {
+        check_open();
+
         return qdb::find_query{_handle, query_string};
     }
 
     py::object query(const std::string & query_string, const py::object & blobs)
     {
+        check_open();
+
         return py::cast(qdb::dict_query(_handle, query_string, blobs));
     }
 
     py::object query_numpy(const std::string & query_string)
     {
+        check_open();
+
         return py::cast(qdb::numpy_query(_handle, query_string));
     }
 
     std::shared_ptr<qdb::query_continuous> query_continuous_full(
         const std::string & query_string, std::chrono::milliseconds pace, const py::object & blobs)
     {
+        check_open();
+
         return std::make_shared<qdb::query_continuous>(
             _handle, qdb_query_continuous_full, pace, query_string, blobs);
     }
@@ -317,6 +346,8 @@ public:
     std::shared_ptr<qdb::query_continuous> query_continuous_new_values(
         const std::string & query_string, std::chrono::milliseconds pace, const py::object & blobs)
     {
+        check_open();
+
         return std::make_shared<qdb::query_continuous>(
             _handle, qdb_query_continuous_new_values_only, pace, query_string, blobs);
     }
@@ -324,6 +355,8 @@ public:
 public:
     std::vector<std::string> suffix_get(const std::string & suffix, qdb_int_t max_count)
     {
+        check_open();
+
         const char ** result = nullptr;
         size_t count         = 0;
 
@@ -339,6 +372,8 @@ public:
 
     qdb_uint_t suffix_count(const std::string & suffix)
     {
+        check_open();
+
         qdb_uint_t count = 0;
 
         const qdb_error_t err = qdb_suffix_count(*_handle, suffix.c_str(), &count);
@@ -350,31 +385,72 @@ public:
 public:
     void purge_all(std::chrono::milliseconds timeout_ms)
     {
+        check_open();
+
         qdb::qdb_throw_if_error(
             *_handle, qdb_purge_all(*_handle, static_cast<int>(timeout_ms.count())));
     }
 
     void purge_cache(std::chrono::milliseconds timeout_ms)
     {
+        check_open();
+
         qdb::qdb_throw_if_error(
             *_handle, qdb_purge_cache(*_handle, static_cast<int>(timeout_ms.count())));
     }
 
     void wait_for_stabilization(std::chrono::milliseconds timeout_ms)
     {
+        check_open();
+
         qdb::qdb_throw_if_error(
             *_handle, qdb_wait_for_stabilization(*_handle, static_cast<int>(timeout_ms.count())));
     }
 
     void trim_all(std::chrono::milliseconds pause_ms, std::chrono::milliseconds timeout_ms)
     {
+        check_open();
+
         qdb::qdb_throw_if_error(*_handle, qdb_trim_all(*_handle, static_cast<int>(pause_ms.count()),
                                               static_cast<int>(timeout_ms.count())));
     }
 
+    void compact_full()
+    {
+        check_open();
+
+        qdb_compact_params_t params{};
+        params.options = qdb_compact_full;
+
+        qdb::qdb_throw_if_error(*_handle, qdb_cluster_compact(*_handle, &params));
+    }
+
+    // Returns 0 when finished / no compaction running
+    std::uint64_t compact_progress()
+    {
+        check_open();
+
+        std::uint64_t progress;
+
+        qdb::qdb_throw_if_error(*_handle, qdb_cluster_get_compact_progress(*_handle, &progress));
+
+        return progress;
+    }
+
+    void compact_abort()
+    {
+        check_open();
+
+        qdb::qdb_throw_if_error(*_handle, qdb_cluster_abort_compact(*_handle));
+    }
+
+    void wait_for_compaction();
+
 public:
     std::vector<std::string> endpoints()
     {
+        check_open();
+
         qdb_remote_node_t * endpoints = nullptr;
         qdb_size_t count              = 0;
 
@@ -465,6 +541,10 @@ static inline void register_cluster(Module & m)
         .def("purge_all", &qdb::cluster::purge_all)                                           //
         .def("trim_all", &qdb::cluster::trim_all)                                             //
         .def("purge_cache", &qdb::cluster::purge_cache)                                       //
+        .def("compact_full", &qdb::cluster::compact_full)                                     //
+        .def("compact_progress", &qdb::cluster::compact_progress)                             //
+        .def("compact_abort", &qdb::cluster::compact_abort)                                   //
+        .def("wait_for_compaction", &qdb::cluster::wait_for_compaction)                       //
         .def("endpoints", &qdb::cluster::endpoints);                                          //
 }
 

quasardb/error.hpp

@@ -78,6 +78,17 @@ public:
     {}
 };
 
+class invalid_handle_exception : public exception
+{
+public:
+    invalid_handle_exception() noexcept
+        : exception(qdb_e_invalid_handle,
+            std::string("Invalid handle: the connection to the cluster has been closed. Please "
+                        "re-establish a new connection"
+                        "with the QuasarDB cluster."))
+    {}
+};
+
 class incompatible_type_exception : public exception
 {
 public:
@@ -218,7 +229,15 @@ inline void qdb_throw_if_error(
         {
             // Error context returned is not the same, which means this thread already made
             // another call to the QDB API, or the QDB API itself
-            throw qdb::exception{err, qdb_error(err)};
+
+            switch (err)
+            {
+            case qdb_e_not_connected:
+            case qdb_e_invalid_handle:
+                throw qdb::invalid_handle_exception{};
+            default:
+                throw qdb::exception{err, qdb_error(err)};
+            }
         }
         assert(err_ == err);
         assert(msg_ != nullptr);
@@ -233,6 +252,10 @@ inline void qdb_throw_if_error(
         case qdb_e_invalid_query:
             throw qdb::invalid_query_exception{msg_data_};
 
+        case qdb_e_not_connected:
+        case qdb_e_invalid_handle:
+            throw qdb::invalid_handle_exception{};
+
         case qdb_e_alias_already_exists:
             throw qdb::alias_already_exists_exception{msg_data_};
 
@@ -289,6 +312,7 @@ static inline void register_errors(Module & m)
     py::register_exception<qdb::internal_local_exception>(m, "InternalLocalError", base_class);
     py::register_exception<qdb::invalid_argument_exception>(m, "InvalidArgumentError", base_class);
     py::register_exception<qdb::invalid_query_exception>(m, "InvalidQueryError", base_class);
+    py::register_exception<qdb::invalid_handle_exception>(m, "InvalidHandleError", base_class);
 }
 
 } // namespace qdb

quasardb/handle.cpp

@@ -0,0 +1,29 @@
+#include "handle.hpp"
+#include "metrics.hpp"
+
+namespace qdb
+{
+
+void handle::connect(const std::string & uri)
+{
+    qdb_error_t err;
+    {
+        metrics::scoped_capture{"qdb_connect"};
+        err = qdb_connect(handle_, uri.c_str());
+    }
+    qdb::qdb_throw_if_error(handle_, err);
+}
+
+void handle::close()
+{
+    if (handle_ != nullptr)
+    {
+        metrics::scoped_capture{"qdb_close"};
+        qdb_close(handle_);
+        handle_ = nullptr;
+    }
+
+    assert(handle_ == nullptr);
+}
+
+}; // namespace qdb

quasardb/handle.hpp

@@ -42,33 +42,50 @@ class handle
 {
 public:
     handle() noexcept
+        : handle_{nullptr}
     {}
 
     explicit handle(qdb_handle_t h) noexcept
-        : _handle{h}
+        : handle_{h}
     {}
 
     ~handle()
     {
-        if (_handle)
-        {
-            qdb_close(_handle);
-            _handle = nullptr;
-        }
+        close();
     }
 
-    void connect(const std::string & uri)
+    void connect(const std::string & uri);
+
+    operator qdb_handle_t() const noexcept
     {
-        qdb::qdb_throw_if_error(_handle, qdb_connect(_handle, uri.c_str()));
+        return handle_;
     }
 
-    operator qdb_handle_t() const noexcept
+    void close();
+
+    constexpr inline bool is_open() const
     {
-        return _handle;
+        return handle_ != nullptr;
+    }
+
+    /**
+     * Throws exception if the connection is not open. Should be invoked before any operation
+     * is done on the handle, as the QuasarDB C API only checks for a canary presence in the
+     * handle's memory arena. If a compiler is optimizing enough, the handle can be closed but
+     * the canary still present in memory, so it's UB.
+     *
+     * As such, we should check on a higher level.
+     */
+    inline void check_open() const
+    {
+        if (is_open() == false) [[unlikely]]
+        {
+            throw qdb::invalid_handle_exception{};
+        }
     }
 
 private:
-    qdb_handle_t _handle{nullptr};
+    qdb_handle_t handle_{nullptr};
 };
 
 using handle_ptr = std::shared_ptr<handle>;

quasardb/logger.cpp

@@ -11,6 +11,8 @@ void qdb::native::swap_callback()
 {
     // Potential race condition avoidance!
     std::lock_guard<std::mutex> guard(_buffer_lock);
+
+#ifndef NDEBUG
     qdb_error_t error;
 
     error = qdb_log_remove_callback(local_callback_id);
@@ -26,6 +28,7 @@ void qdb::native::swap_callback()
         // fprintf(stderr, "unable to add new callback: %s (%#x)\n", qdb_error(error), error);
         // fflush(stderr);
     }
+#endif
 
     _logger = qdb::logger("quasardb.native");
 }

quasardb/metrics.cpp

@@ -0,0 +1,103 @@
+#include "metrics.hpp"
+#include <mutex>
+
+namespace qdb
+{
+
+static metrics_container_t metrics_totals_ = metrics_container_t{};
+static std::mutex metrics_lock_            = std::mutex{};
+
+metrics::scoped_capture::~scoped_capture()
+{
+    using std::chrono::nanoseconds;
+
+    time_point_t stop = clock_t::now();
+
+    auto duration = std::chrono::duration_cast<nanoseconds>(stop - start_);
+
+    metrics::record(test_id_, duration.count());
+}
+
+metrics::measure::measure()
+    : start_{metrics::totals()}
+{}
+
+metrics_container_t metrics::measure::get() const
+{
+    metrics_container_t cur = metrics::totals();
+
+    metrics_container_t ret{};
+
+    for (auto i : cur)
+    {
+        assert(ret.find(i.first) == ret.end());
+
+        metrics_container_t::const_iterator prev = start_.find(i.first);
+
+        if (prev == start_.end())
+        {
+            // Previously, metric didn't exist yet, as such it's entirely new
+            // and all accumulated time was within the scope.
+            ret.emplace(i.first, i.second);
+        }
+        else if (i.second > prev->second)
+        {
+            // Accumulated time actually increased, record difference
+            ret.emplace(i.first, i.second - prev->second);
+        }
+        else
+        {
+            // Integrity check: we can only increase totals over time, never decrease
+            assert(i.second == prev->second);
+        }
+    };
+
+    return ret;
+};
+
+/* static */ void metrics::record(std::string const & test_id, std::uint64_t nsec)
+{
+    std::lock_guard<std::mutex> guard(metrics_lock_);
+
+    metrics_container_t::iterator pos = metrics_totals_.lower_bound(test_id);
+
+    if (pos == metrics_totals_.end() || pos->first != test_id) [[unlikely]]
+    {
+        pos = metrics_totals_.emplace_hint(pos, test_id, 0);
+
+        assert(pos->second == 0);
+    }
+
+    assert(pos->first == test_id);
+    pos->second += nsec;
+}
+
+/* static */ metrics_container_t metrics::totals()
+{
+    std::lock_guard<std::mutex> guard(metrics_lock_);
+    return metrics_totals_;
+}
+
+/* static */ void metrics::clear()
+{
+    std::lock_guard<std::mutex> guard(metrics_lock_);
+    metrics_totals_.clear();
+}
+
+void register_metrics(py::module_ & m)
+{
+
+    py::module_ metrics_module =
+        m.def_submodule("metrics", "Keep track of low-level performance metrics")
+            .def("totals", &qdb::metrics::totals)
+            .def("clear", &qdb::metrics::clear);
+
+    auto metrics_measure = py::class_<qdb::metrics::measure>(
+        metrics_module, "Measure", "Track all metrics within a block of code")
+                               .def(py::init())
+                               .def("__enter__", &qdb::metrics::measure::enter)
+                               .def("__exit__", &qdb::metrics::measure::exit)
+                               .def("get", &qdb::metrics::measure::get);
+};
+
+}; // namespace qdb

quasardb/metrics.hpp

@@ -0,0 +1,112 @@
+/*
+ *
+ * Official Python API
+ *
+ * Copyright (c) 2009-2023, quasardb SAS. All rights reserved.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *    * Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *    * Redistributions in binary form must reproduce the above copyright
+ *      notice, this list of conditions and the following disclaimer in the
+ *      documentation and/or other materials provided with the distribution.
+ *    * Neither the name of quasardb nor the names of its contributors may
+ *      be used to endorse or promote products derived from this software
+ *      without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY QUASARDB AND CONTRIBUTORS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#pragma once
+
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include <cassert>
+#include <chrono>
+#include <map>
+#include <string>
+
+namespace qdb
+{
+namespace py              = pybind11;
+using metrics_container_t = std::map<std::string, std::uint64_t>;
+
+class metrics
+{
+private:
+public:
+    /**
+     * Utility fixture that automatically records timings for a certain block of code.
+     * This is intended to be used from native C++ code only.
+     */
+    class scoped_capture
+    {
+        using clock_t      = std::chrono::high_resolution_clock;
+        using time_point_t = std::chrono::time_point<clock_t>;
+
+    public:
+        scoped_capture(std::string const & test_id) noexcept
+            : test_id_{test_id}
+            , start_{clock_t::now()} {};
+        ~scoped_capture();
+
+    private:
+        std::string test_id_;
+        time_point_t start_;
+    };
+
+    /**
+     * Utility class that's exposed to Python which can be used to record metrics in
+     * a scope. It makes it easy to track the difference between the beginning and end
+     * of execution.
+     */
+    class measure
+    {
+    public:
+        measure();
+        ~measure(){};
+
+    public:
+        measure enter()
+        {
+            // No-op, all initialization is done in the constructor.
+            return *this;
+        }
+
+        void exit(py::object /* type */, py::object /* value */, py::object /* traceback */)
+        {}
+
+        metrics_container_t get() const;
+
+    private:
+        metrics_container_t start_;
+    };
+
+public:
+    metrics() noexcept {};
+
+    ~metrics() noexcept {};
+
+public:
+    static void record(std::string const & test_id, std::uint64_t nsec);
+
+    static metrics_container_t totals();
+    static void clear();
+
+private:
+};
+
+void register_metrics(py::module_ & m);
+
+} // namespace qdb

quasardb/module.cpp

@@ -1,5 +1,6 @@
 #include "module.hpp"
 #include "cluster.hpp"
+#include "metrics.hpp"
 #include "node.hpp"
 #include "writer.hpp"
 #include <functional>
@@ -62,6 +63,7 @@ PYBIND11_MODULE(quasardb, m)
     qdb::register_table_reader(m);
     qdb::register_masked_array(m);
     qdb::register_writer(m);
+    qdb::register_metrics(m);
 
     qdb::detail::register_ts_column(m);
     qdb::reader::register_ts_value(m);

quasardb/options.hpp

@@ -184,6 +184,18 @@ public:
         return max_parallelism;
     }
 
+    void set_query_max_length(size_t query_max_length)
+    {
+        qdb::qdb_throw_if_error(*_handle, qdb_option_set_query_max_length(*_handle, query_max_length));
+    }
+
+    size_t get_query_max_length()
+    {
+        size_t query_max_length = 0;
+        qdb::qdb_throw_if_error(*_handle, qdb_option_get_query_max_length(*_handle, &query_max_length));
+        return query_max_length;
+    }
+
 private:
     qdb::handle_ptr _handle;
 };
@@ -221,6 +233,9 @@ static inline void register_options(Module & m)
         .def("set_client_max_parallelism", &qdb::options::set_client_max_parallelism,     //
             py::arg("parallelism"))                                                       //
         .def("get_client_max_parallelism", &qdb::options::get_client_max_parallelism)     //
+        .def("set_query_max_length", &qdb::options::set_query_max_length,                 //
+            py::arg("query_max_length"))                                                  //
+        .def("get_query_max_length", &qdb::options::get_query_max_length)                 //
         .def("set_client_soft_memory_limit", &qdb::options::set_client_soft_memory_limit, //
             py::arg("limit"))                                                             //
         ;

quasardb/query.cpp

@@ -31,6 +31,7 @@
 
 #include "query.hpp"
 #include "masked_array.hpp"
+#include "metrics.hpp"
 #include "numpy.hpp"
 #include "traits.hpp"
 #include "utils.hpp"
@@ -390,7 +391,12 @@ numpy_query_result_t numpy_query_results(const qdb_query_result_t * r)
 dict_query_result_t dict_query(qdb::handle_ptr h, const std::string & q, const py::object & blobs)
 {
     detail::qdb_resource<qdb_query_result_t> r{*h};
-    qdb_error_t err = qdb_query(*h, q.c_str(), &r);
+
+    qdb_error_t err;
+    {
+        metrics::scoped_capture capture{"qdb_query"};
+        err = qdb_query(*h, q.c_str(), &r);
+    }
 
     qdb::qdb_throw_if_query_error(*h, err, r.get());
 
@@ -400,7 +406,12 @@ dict_query_result_t dict_query(qdb::handle_ptr h, const std::string & q, const p
 numpy_query_result_t numpy_query(qdb::handle_ptr h, const std::string & q)
 {
     detail::qdb_resource<qdb_query_result_t> r{*h};
-    qdb_error_t err = qdb_query(*h, q.c_str(), &r);
+
+    qdb_error_t err;
+    {
+        metrics::scoped_capture capture{"qdb_query"};
+        err = qdb_query(*h, q.c_str(), &r);
+    }
     qdb::qdb_throw_if_query_error(*h, err, r.get());
 
     return numpy_query_results(r);

quasardb/table.cpp

@@ -1,5 +1,6 @@
 #include "table.hpp"
 #include "dispatch.hpp"
+#include "metrics.hpp"
 #include "object_tracker.hpp"
 #include "table_reader.hpp"
 #include "traits.hpp"
@@ -29,6 +30,8 @@ struct column_inserter;
             pybind11::array const & timestamps,                                             \
             qdb::masked_array const & values)                                               \
         {                                                                                   \
+            handle->check_open();                                                           \
+                                                                                            \
             qdb::object_tracker::scoped_repository ctx{};                                   \
             qdb::object_tracker::scoped_capture capture{ctx};                               \
             numpy::array::ensure<traits::datetime64_ns_dtype>(timestamps);                  \
@@ -66,9 +69,36 @@ inline void insert_column_dispatch(handle_ptr handle,
 
 }; // namespace detail
 
+void table::_cache_columns() const
+{
+    _handle->check_open();
+
+    detail::qdb_resource<qdb_ts_column_info_ex_t> columns{*_handle};
+    qdb_size_t count = 0;
+
+    qdb_error_t err;
+
+    {
+        metrics::scoped_capture("qdb_ts_list_columns");
+        err = qdb_ts_list_columns_ex(*_handle, _alias.c_str(), &columns, &count);
+    }
+
+    if (err == qdb_e_alias_not_found) [[unlikely]]
+    {
+        // Can happen if table does not yet exist, do nothing.
+        return;
+    }
+
+    qdb::qdb_throw_if_error(*_handle, err);
+
+    _columns = detail::convert_columns(columns.get(), count);
+}
+
 py::object table::reader(
     const std::vector<std::string> & columns, py::object ranges, bool dict_mode) const
 {
+    _handle->check_open();
+
     auto ranges_ = qdb::convert_ranges(ranges);
 
     std::vector<detail::column_info> c_columns;
@@ -102,6 +132,8 @@ py::object table::reader(
 
 qdb_uint_t table::erase_ranges(const std::string & column, py::object ranges)
 {
+    _handle->check_open();
+
     auto ranges_ = qdb::convert_ranges(ranges);
 
     qdb_uint_t erased_count = 0;
@@ -149,6 +181,8 @@ void table::timestamp_insert(
 std::pair<pybind11::array, masked_array> table::blob_get_ranges(
     const std::string & column, py::object ranges)
 {
+    _handle->check_open();
+
     qdb_ts_blob_point * points = nullptr;
     qdb_size_t count           = 0;
 
@@ -167,6 +201,8 @@ std::pair<pybind11::array, masked_array> table::blob_get_ranges(
 std::pair<pybind11::array, masked_array> table::string_get_ranges(
     const std::string & column, py::object ranges)
 {
+    _handle->check_open();
+
     qdb_ts_string_point * points = nullptr;
     qdb_size_t count             = 0;
 
@@ -185,6 +221,8 @@ std::pair<pybind11::array, masked_array> table::string_get_ranges(
 std::pair<pybind11::array, masked_array> table::double_get_ranges(
     const std::string & column, py::object ranges)
 {
+    _handle->check_open();
+
     qdb_ts_double_point * points = nullptr;
     qdb_size_t count             = 0;
 
@@ -203,6 +241,8 @@ std::pair<pybind11::array, masked_array> table::double_get_ranges(
 std::pair<pybind11::array, masked_array> table::int64_get_ranges(
     const std::string & column, py::object ranges)
 {
+    _handle->check_open();
+
     qdb_ts_int64_point * points = nullptr;
     qdb_size_t count            = 0;
 
@@ -221,6 +261,8 @@ std::pair<pybind11::array, masked_array> table::int64_get_ranges(
 std::pair<pybind11::array, masked_array> table::timestamp_get_ranges(
     const std::string & column, py::object ranges)
 {
+    _handle->check_open();
+
     qdb_ts_timestamp_point * points = nullptr;
     qdb_size_t count                = 0;
 

quasardb/table.hpp

@@ -40,7 +40,7 @@ namespace qdb
 class table : public entry
 {
 public:
-    table(handle_ptr h, std::string a) noexcept
+    table(handle_ptr h, std::string a)
         : entry{h, a}
         , _has_indexed_columns(false)
     {
@@ -64,13 +64,17 @@ public:
     void create(const std::vector<detail::column_info> & columns,
         std::chrono::milliseconds shard_size = std::chrono::hours{24})
     {
+        _handle->check_open();
+
         const auto c_columns = detail::convert_columns_ex(columns);
         qdb::qdb_throw_if_error(*_handle, qdb_ts_create_ex(*_handle, _alias.c_str(), shard_size.count(),
-                                              c_columns.data(), c_columns.size()));
+                                              c_columns.data(), c_columns.size(), qdb_ttl_disabled));
     }
 
     void insert_columns(const std::vector<detail::column_info> & columns)
     {
+        _handle->check_open();
+
         const auto c_columns = detail::convert_columns_ex(columns);
         qdb::qdb_throw_if_error(*_handle,
             qdb_ts_insert_columns_ex(*_handle, _alias.c_str(), c_columns.data(), c_columns.size()));
@@ -152,23 +156,7 @@ private:
     /**
      * Loads column info / metadata from server and caches it locally.
      */
-    void _cache_columns() const
-    {
-        detail::qdb_resource<qdb_ts_column_info_ex_t> columns{*_handle};
-        qdb_size_t count = 0;
-
-        auto err = qdb_ts_list_columns_ex(*_handle, _alias.c_str(), &columns, &count);
-
-        if (err == qdb_e_alias_not_found) [[unlikely]]
-        {
-            // Can happen if table does not yet exist, do nothing.
-            return;
-        }
-
-        qdb::qdb_throw_if_error(*_handle, err);
-
-        _columns = detail::convert_columns(columns.get(), count);
-    }
+    void _cache_columns() const;
 
     /**
      * Loads column info / metadata from server if not yet cached locally.

quasardb/table_reader.hpp

@@ -88,8 +88,10 @@ public:
         return _the_row;
     }
 
-    table_reader_iterator & operator++() noexcept
+    table_reader_iterator & operator++()
     {
+        _handle->check_open();
+
         qdb_error_t err = qdb_ts_table_next_row(_local_table, &_the_row.mutable_timestamp());
 
         if (err == qdb_e_iterator_end)
@@ -144,6 +146,8 @@ public:
         , _columns{c}
         , _local_table{nullptr}
     {
+        _handle->check_open();
+
         auto c_columns = convert_columns(c);
 
         qdb::qdb_throw_if_error(*_handle, qdb_ts_local_table_init(*_handle, t.c_str(), c_columns.data(),

quasardb/writer.cpp

@@ -1,6 +1,7 @@
 #include "writer.hpp"
 #include "concepts.hpp"
 #include "dispatch.hpp"
+#include "metrics.hpp"
 #include "numpy.hpp"
 #include "traits.hpp"
 #include "convert/array.hpp"
@@ -460,6 +461,8 @@ void writer::_push_impl(writer::staged_tables_t & staged_tables,
     detail::deduplicate_options deduplicate_options,
     qdb_ts_range_t * ranges)
 {
+    _handle->check_open();
+
     if (staged_tables.empty())
     {
         throw qdb::invalid_argument_exception{"No data written to batch writer."};
@@ -489,6 +492,9 @@ void writer::_push_impl(writer::staged_tables_t & staged_tables,
             batch_table.data.column_count, table_name);
     }
 
+    // Make sure to measure the time it takes to do the actual push
+    qdb::metrics::scoped_capture capture{"qdb_batch_push"};
+
     qdb::qdb_throw_if_error(
         *_handle, qdb_exp_batch_push(*_handle, mode, batch.data(), nullptr, batch.size()));
 }

{quasardb-3.14.1.dev4.dist-info → quasardb-3.14.1.dev6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: quasardb
-Version: 3.14.1.dev4
+Version: 3.14.1.dev6
 Summary: Python API for quasardb
 Home-page: https://www.quasardb.net/
 Author: quasardb SAS

{quasardb-3.14.1.dev4.dist-info → quasardb-3.14.1.dev6.dist-info}/RECORD

@@ -1,12 +1,12 @@
-quasardb/CMakeLists.txt,sha256=jnXrpKZ--3pw62Vp2jY5k9xy0y407cUGO2prou4AwJc,15178
+quasardb/CMakeLists.txt,sha256=Rdpd6_7EfVD7F81k7OgxH57cVFIGZzz57O2haCTSrs8,15237
 quasardb/INSTALL.vcxproj,sha256=wXGzzzxKqlbKbm3sC-67s1p7BBbJHU2ToOIcyYKryk4,10405
 quasardb/INSTALL.vcxproj.filters,sha256=Zi6Rf6BuzpXIana9k87Eha4xNbqM5Scj8SMuy1cBI7k,564
 quasardb/__init__.py,sha256=S5HGH9idLoUES_9XSqHnEixEC6VKwzcubJlnVvWi22E,3801
-quasardb/add_boost_test.cmake,sha256=A-r1WMqPO12BwWA1N-nGwtdemRWBNIOmH_eBy0pLn6w,1208
 quasardb/batch_column.hpp,sha256=txW9kYMgQzJiJlM5nD7LIVuAZpyidpS4MopPGKE95u0,3388
 quasardb/batch_inserter.hpp,sha256=bM73Z-IKow89GqoYaxDLDd0YuaN5Il4C5TjIVx9bI-Y,9803
 quasardb/blob.hpp,sha256=PObdSJxKNLIihBCLBxQHHH20t7VOmZG02wOfy8rB1-w,5846
-quasardb/cluster.hpp,sha256=f_8UKUdIBBaGBsBJUEMNRQYbAgHtOeLdcoAWexNMZp8,18107
+quasardb/cluster.cpp,sha256=ytPCLRZVA7eTZgqIbLWKsmiugYLq80v9rSuoksKTE3c,2500
+quasardb/cluster.hpp,sha256=AYZY2myVI1eeG3Cxe7yCPb7Kmlh1Ij_go4ryZdIEJHc,19405
 quasardb/cmake_install.cmake,sha256=xWyEkkQzuazTRxgmMiJa6JJ3UtWPMsU8oNIwF96u3WY,1500
 quasardb/concepts.hpp,sha256=Ao-UKFVjh7kRqeqsYXioV1LXiKXBR_1l54hRvUCjxKU,9574
 quasardb/continuous.cpp,sha256=18-VX7BZA60wkUq75ADU7yfgmwzT_CkG_tEAKxAVkLU,4566
@@ -18,41 +18,44 @@ quasardb/direct_integer.hpp,sha256=jHwNnAcB9wodgju8SBOsyPKWlifM094kENKSwySrSb8,3
 quasardb/dispatch.hpp,sha256=YWqTq9ehXWpphJ9piWwrKUzy3IgA5d9An0loAYQsUlg,5508
 quasardb/double.hpp,sha256=SW1z9QW09mC_8ggvleMZolivu2BHjF157IVKT_Jw638,3239
 quasardb/entry.hpp,sha256=IE6uL341x6U5dos40LhVKSJPuYZwod-oRy4PoF5a_80,9451
-quasardb/error.hpp,sha256=0Wkkw6se9MLbHBHFO9hHsuG2u2z473ZEPLySGXUv3Pk,9994
+quasardb/error.hpp,sha256=b3BvBn0wYqHlrkH48pZod6CMjtxFu6l7SQjt88zXlwc,10807
 quasardb/firehose.py,sha256=DHYsew-aL1j5PKZonH30CrhXnwHEX1XIAhGbPrzd4PY,3593
-quasardb/handle.hpp,sha256=Sv8ICG6795uVz4h5b6V94Lryd08QQ1Qo6QMmvR7wCUA,2498
+quasardb/handle.cpp,sha256=oyhzAj1k8UFhpLhwU5RL4cbdqt82KZexWacMFz5uXA0,536
+quasardb/handle.hpp,sha256=o26dxmrXtfbxgj66QgKjW8wviUPbcZvmIAZ4L4CcdoQ,3051
 quasardb/integer.hpp,sha256=H5x8SEqlyI2nQZL9iv4GnCL0uWYuq8l8YYUzI83t0aE,3304
-quasardb/logger.cpp,sha256=TK5W1xIwIoXy7pLeCXkq2PEU8x6O8xXQ8w4GWDbmPbU,3030
+quasardb/logger.cpp,sha256=UThEO2V6UI-tbpG9suud7olmMjIMfHr3tNt-nM48DIE,3056
 quasardb/logger.hpp,sha256=4trngfo31-OizuEkQUoYob77PVeXC283tPGaX3JRpPY,7278
 quasardb/masked_array.hpp,sha256=nfuvkFZnNoGqqtJzBZ95h4e4PguhIr5kj3tVO4y8W4U,18988
-quasardb/module.cpp,sha256=LzTi_RQNTakymc2rCkH9PqywW_0phl7R7A3lAS65ytg,2181
+quasardb/metrics.cpp,sha256=NuEBVYlIHQRgmPy4g9Eosq1Q28Z1jySSZHKDAMLURIA,2942
+quasardb/metrics.hpp,sha256=oz_XDbcMCJ9fiaYi043rFakM-mmzsuONskDfMPDf4_U,3533
+quasardb/module.cpp,sha256=Nx0d3xyqCb2Red1WgsGUotaXxX6NHoDCcp9PnUzmcB0,2236
 quasardb/module.hpp,sha256=-zRcQ_lgVz4IEP3tokX4AeA33DYJ3jsq8vWX6OnE0Ic,604
 quasardb/node.hpp,sha256=_rcwUA9mOFW7b7I3B3Ll3aaBO0RoKV3LS19JITaIi6A,4771
 quasardb/numpy.cpp,sha256=0brRs6lnIpsCNvpu3twIcjizy3lMOvCBT0O4rjKAn0I,189
 quasardb/numpy.hpp,sha256=j2xGIFn98L4AAirxnkF6JaAwUBL1McfUBNsf4tlKPA0,15668
 quasardb/object_tracker.hpp,sha256=m0S0vp3WX2kFsr6cE8iPmXXO-3qRo4lcVc6TgFa-MbM,7709
-quasardb/options.hpp,sha256=T-Wy4PYSQv7LQY2R2-93ay4NVbNgsn2iIzOP3bbIpbk,9470
+quasardb/options.hpp,sha256=hXNBVTQdrDwWkxGyFBOuRGYyJoD_IpqpitJPbDnabi0,10158
 quasardb/perf.hpp,sha256=C7dM0ZZZ4Ln5pDnZpvvUMgdwLUp4Tom51JuZICSYGGI,11364
 quasardb/pool.py,sha256=lqVZPFejmNHU7EdyeoPkl7yy_-N3BRyuLhNTzIdtg8g,8743
 quasardb/pytypes.hpp,sha256=YTc6xdmxMGMWtrZHitAl3vudZxYctOX1NwL-QDuzz1g,6894
-quasardb/qdb_api.dll,sha256=X8WDNYJm4guBpzqBRgdrr2vrCm33dt1bjZBolRKPc5g,14224384
-quasardb/quasardb.cp39-win_amd64.pyd,sha256=sfgn8yDP7Z8MqyP51rsnePX4snv1kE8kVUExxGojAWs,1303040
-quasardb/query.cpp,sha256=s3T2eaNBgJ93hEEOQbEx21sLabg16mMSuUQMwHXar7g,12558
+quasardb/qdb_api.dll,sha256=JZRkdNtMmCDpr7_ZSkHYX1PWi3N5fH74SSh0D-7RWMk,15067136
+quasardb/quasardb.cp39-win_amd64.pyd,sha256=QKiV_3n0uKZopH3b2QqWacBlCp9etVGmWfMVELgm9Rw,1329152
+quasardb/query.cpp,sha256=FhsA93s-mXqw6WnzQgYLooy02P-haTEHkTMpdgMbdKw,12752
 quasardb/query.hpp,sha256=dBFJ0FVNJN-WdCwbHU1iNbEzDHarGGDQaZ5gto-xwkY,3357
 quasardb/remove_cvref.hpp,sha256=vKUecNoA2-BIiZeP8NuO3GgBOMF-OVSn_43LJCuDozA,611
 quasardb/stats.py,sha256=LDV4F5KTpEXa5sS_syFo_TYn9_W2X1D32Eb43GLutOs,7620
 quasardb/string.hpp,sha256=xgvRf1TXy3nl45WeCHHhtO8toUYZ2Zo7RuvTAntIgZM,6071
-quasardb/table.cpp,sha256=MJkgJ4I9cmORDMgD4lmuOu6UhsqKwI2x33ah3ZllfB8,9689
-quasardb/table.hpp,sha256=ynFnBXFPeiR2d0e4UWa_uNzt8vm-amaRxXR04qZd2bw,11361
+quasardb/table.cpp,sha256=_LAltQoycIzkqg4Id4u5MHN9Uy4OD-wWZMtdxzReMDs,10725
+quasardb/table.hpp,sha256=bu3n9jjNW_dH01vbXkCbl4TmwfbyQS_0a4_fitbcrUI,10941
 quasardb/table_cache.py,sha256=t7FFQkms7pFlYDkOhCcLnLS8bWglZjlzX3Qs6gyBG6Q,1559
-quasardb/table_reader.hpp,sha256=VpfHxecDa10n3VSoUAoLRaGgrsAvZSuWe_UHZhgUK3E,6882
+quasardb/table_reader.hpp,sha256=UYqpLtdMFr4MKho0A9y6sKb1-KoNLtYPdypl6zOrwm0,6941
 quasardb/tag.hpp,sha256=gIs8LDa4o0JJBGuSQXsnyVeORax7KH0jHCyt0Zx6JMs,2732
 quasardb/timestamp.hpp,sha256=f2TLql7D-gTQbJMUdC9QKbHpbnkMPoDi0dHAF2IVrqc,3889
 quasardb/traits.hpp,sha256=RLSJBeZbFsWRQAsZSm6GbV2a2-5jounsJ_TX0iSvyHI,16383
 quasardb/ts_iterator.hpp,sha256=faP1HVGYbWubKr98yhkS6gqvyMiKWkl3tgedJfj2u1E,4395
 quasardb/utils.cpp,sha256=PkuVxrj1cQfeVujA-kefx9-P0B6IJNtYDQzedCAMjKY,634
 quasardb/utils.hpp,sha256=ZedlY9Ahdphyi8tm2CySYb2k1RJTaDFqDBy3dvg-rJ8,4724
-quasardb/writer.cpp,sha256=n1PZg9oxRwKqZu9Lrac-3D2U2xrGbI6oDLTXm69l7zU,19385
+quasardb/writer.cpp,sha256=5jPLFvOcJydiyBSbbtB-SDspKVoXcV9squEOQLuOvp0,19571
 quasardb/writer.hpp,sha256=08S7HDgdCajNSwro4i0i1lzyvUkHFh6M1vn8TJpAz_A,12933
 quasardb/CMakeFiles/generate.stamp,sha256=MC9-mgyGPAS3QAZa3gHSQ8dYfXJy_Hn7AChwEoqVWOs,55
 quasardb/CMakeFiles/generate.stamp.depend,sha256=uY8FV-ceJ2Kk-6JfOnsIesDV7jKoUNfkKHNY2Nf7_E8,117
@@ -108,8 +111,8 @@ quasardb/utils/ostream.hpp,sha256=KYFwqXuZoxuZblHUM-z5xrd74P2Y5zWJqVpaQ9oedAo,39
 quasardb/utils/permutation.hpp,sha256=BwJzgZmpS4G-oS7249GvnUFj_cmqSAbF2Fzb8wuihLo,1552
 quasardb/utils/stable_sort.hpp,sha256=luIK9T76mT0NyDxpLxXjTt1eSSKEOY29jRANJNysJCo,489
 quasardb/utils/unzip_view.hpp,sha256=nn6BSAI_cGsKgBh8WXhAUJ6Zzn3N0AnhtE6ePmhPeQM,2476
-quasardb-3.14.1.dev4.dist-info/LICENSE.md,sha256=yqGeNifkwT_AQEPv0TwLxEdD9TgORqUjS01rgzG5EGY,1477
-quasardb-3.14.1.dev4.dist-info/METADATA,sha256=vFyrQJQn8LZcBb7JkP8Dcch62XVCbLdITCYSDilksN8,1496
-quasardb-3.14.1.dev4.dist-info/WHEEL,sha256=J_4V_gB-O6Y7Pn6lk91K27JaIhI-q07YM5J8Ufzqla4,100
-quasardb-3.14.1.dev4.dist-info/top_level.txt,sha256=wlprix4hCywuF1PkgKWYdZeJKq_kgJOqkAvukm_sZQ8,9
-quasardb-3.14.1.dev4.dist-info/RECORD,,
+quasardb-3.14.1.dev6.dist-info/LICENSE.md,sha256=yqGeNifkwT_AQEPv0TwLxEdD9TgORqUjS01rgzG5EGY,1477
+quasardb-3.14.1.dev6.dist-info/METADATA,sha256=E41lG6VbSKiA00UKf7Xkp6_zRTbJhIxReJ3HZs62N-o,1496
+quasardb-3.14.1.dev6.dist-info/WHEEL,sha256=J_4V_gB-O6Y7Pn6lk91K27JaIhI-q07YM5J8Ufzqla4,100
+quasardb-3.14.1.dev6.dist-info/top_level.txt,sha256=wlprix4hCywuF1PkgKWYdZeJKq_kgJOqkAvukm_sZQ8,9
+quasardb-3.14.1.dev6.dist-info/RECORD,,

quasardb/add_boost_test.cmake

@@ -1,43 +0,0 @@
-function(add_boost_test_executable NAME COMPONENT)
-    add_executable(${NAME}
-        ${ARGN}
-    )
-
-    # set_target_properties(${NAME} PROPERTIES
-    #     DEBUG_POSTFIX ${CMAKE_DEBUG_POSTFIX})
-
-    target_link_libraries(${NAME}
-        boost_unit_test_framework
-    )
-
-    if($<CONFIG:SanitizeValgrind>)
-        add_test(
-            NAME ${NAME}
-            COMMAND
-                valgrind>
-                $<$<PLATFORM_ID:Darwin>:--dsymutil=yes>
-                --gen-suppressions=all
-                ./${NAME}
-                --log_level=test_suite
-                --report_level=detailed
-                --build_info=yes
-                --detect_memory_leaks=0
-        )
-    else()
-        add_test(
-            NAME ${NAME}
-            COMMAND
-                ${NAME}
-                --log_level=test_suite
-                --report_level=detailed
-                --build_info=yes
-                --detect_memory_leaks=0
-        )
-    endif()
-
-    install(TARGETS ${NAME}
-        RUNTIME DESTINATION bin COMPONENT ${COMPONENT}
-        LIBRARY DESTINATION lib COMPONENT ${COMPONENT}
-        ARCHIVE DESTINATION lib COMPONENT ${COMPONENT}
-    )
-endfunction()