quasardb 3.14.1.dev5__cp311-cp311-win32.whl → 3.14.1.dev6__cp311-cp311-win32.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

@@ -72,58 +72,10 @@ 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);
-
-        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);
-    }
+        bool do_version_check                       = false);
 
 public:
-    void 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 close();
 
     bool is_open() const
     {
@@ -463,6 +415,37 @@ public:
                                               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()
     {
@@ -558,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/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

@@ -54,26 +54,14 @@ public:
         close();
     }
 
-    void connect(const std::string & uri)
-    {
-        qdb::qdb_throw_if_error(handle_, qdb_connect(handle_, uri.c_str()));
-    }
+    void connect(const std::string & uri);
 
     operator qdb_handle_t() const noexcept
     {
         return handle_;
     }
 
-    void close()
-    {
-        if (handle_ != nullptr)
-        {
-            qdb_close(handle_);
-            handle_ = nullptr;
-        }
-
-        assert(handle_ == nullptr);
-    }
+    void close();
 
     constexpr inline bool is_open() const
     {

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/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"
@@ -68,6 +69,31 @@ 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
 {

quasardb/table.hpp

@@ -68,7 +68,7 @@ public:
 
         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)
@@ -156,25 +156,7 @@ private:
     /**
      * Loads column info / metadata from server and caches it locally.
      */
-    void _cache_columns() const
-    {
-        _handle->check_open();
-
-        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/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"
@@ -491,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.dev5.dist-info → quasardb-3.14.1.dev6.dist-info}/METADATA

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

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

@@ -1,11 +1,12 @@
-quasardb/CMakeLists.txt,sha256=jnXrpKZ--3pw62Vp2jY5k9xy0y407cUGO2prou4AwJc,15178
+quasardb/CMakeLists.txt,sha256=Rdpd6_7EfVD7F81k7OgxH57cVFIGZzz57O2haCTSrs8,15237
 quasardb/INSTALL.vcxproj,sha256=igx9QMhw7GKbtl7m9AUJzzHk3RV9kvEXEDX_UOmycpQ,10474
 quasardb/INSTALL.vcxproj.filters,sha256=Xm5F8TURw0nCCxxMXBNje2S9J801701KiUrUxpDyPAE,561
 quasardb/__init__.py,sha256=S5HGH9idLoUES_9XSqHnEixEC6VKwzcubJlnVvWi22E,3801
 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=gon_Lke89G8JrkLgKn7W59E_U7afRuW1084bmiHDZuM,20044
+quasardb/cluster.cpp,sha256=ytPCLRZVA7eTZgqIbLWKsmiugYLq80v9rSuoksKTE3c,2500
+quasardb/cluster.hpp,sha256=AYZY2myVI1eeG3Cxe7yCPb7Kmlh1Ij_go4ryZdIEJHc,19405
 quasardb/cmake_install.cmake,sha256=J7WxmTDGwr5PnXPmoBjSdu6o1SsGfmVAr7OkQoTUkxo,1497
 quasardb/concepts.hpp,sha256=Ao-UKFVjh7kRqeqsYXioV1LXiKXBR_1l54hRvUCjxKU,9574
 quasardb/continuous.cpp,sha256=18-VX7BZA60wkUq75ADU7yfgmwzT_CkG_tEAKxAVkLU,4566
@@ -19,12 +20,15 @@ quasardb/double.hpp,sha256=SW1z9QW09mC_8ggvleMZolivu2BHjF157IVKT_Jw638,3239
 quasardb/entry.hpp,sha256=IE6uL341x6U5dos40LhVKSJPuYZwod-oRy4PoF5a_80,9451
 quasardb/error.hpp,sha256=b3BvBn0wYqHlrkH48pZod6CMjtxFu6l7SQjt88zXlwc,10807
 quasardb/firehose.py,sha256=DHYsew-aL1j5PKZonH30CrhXnwHEX1XIAhGbPrzd4PY,3593
-quasardb/handle.hpp,sha256=oDVs8usYE9j2_Z6GOE2QWpPqTavAbINt5TI6gRRaPUw,3314
+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
@@ -34,15 +38,15 @@ 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=XoKW_l4BjOH6Q6kZE8HqORVsOxTy1ZxS9_lPU3pxrPQ,13127680
-quasardb/quasardb.cp311-win32.pyd,sha256=MdmF_X6OjNEhkTCC5EsIjnWAw8YplJ00PU44dEhwpX8,1185792
-quasardb/query.cpp,sha256=s3T2eaNBgJ93hEEOQbEx21sLabg16mMSuUQMwHXar7g,12558
+quasardb/qdb_api.dll,sha256=l0QgXq9kl0_0yV_hzXOaBUE9JUw5ZKxxD_Hio82ySLw,13801984
+quasardb/quasardb.cp311-win32.pyd,sha256=q9dMvJ5uADK2S027oR_g2-1au_KbRTowtGEdNbTLrvU,1200640
+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=248bX3WVZHVjEwq7_cDwi3MJbaQTnp6FOH49S_6ln24,10089
-quasardb/table.hpp,sha256=benynk0tUhXcHigMFQDo6ha-rbYP72PgGe-09ihs2GM,11454
+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=UYqpLtdMFr4MKho0A9y6sKb1-KoNLtYPdypl6zOrwm0,6941
 quasardb/tag.hpp,sha256=gIs8LDa4o0JJBGuSQXsnyVeORax7KH0jHCyt0Zx6JMs,2732
@@ -51,7 +55,7 @@ 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=PiYq0ZsDmZNYxEaV4TVVqUFg94cd5D21xJq8X_MmGMw,19415
+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
@@ -107,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.dev5.dist-info/LICENSE.md,sha256=yqGeNifkwT_AQEPv0TwLxEdD9TgORqUjS01rgzG5EGY,1477
-quasardb-3.14.1.dev5.dist-info/METADATA,sha256=ijjZcc9R53mL0R1kzOyileYL3K7wb-sTIvVV2l78U7g,1496
-quasardb-3.14.1.dev5.dist-info/WHEEL,sha256=dTOErEcdB767H0LwzWU4sSGTzJRs59N_0uVyL1DFkVM,98
-quasardb-3.14.1.dev5.dist-info/top_level.txt,sha256=wlprix4hCywuF1PkgKWYdZeJKq_kgJOqkAvukm_sZQ8,9
-quasardb-3.14.1.dev5.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=dTOErEcdB767H0LwzWU4sSGTzJRs59N_0uVyL1DFkVM,98
+quasardb-3.14.1.dev6.dist-info/top_level.txt,sha256=wlprix4hCywuF1PkgKWYdZeJKq_kgJOqkAvukm_sZQ8,9
+quasardb-3.14.1.dev6.dist-info/RECORD,,