quasardb 3.14.1.dev5__cp39-cp39-macosx_10_14_x86_64.whl → 3.14.1.dev6__cp39-cp39-macosx_10_14_x86_64.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/cmake_install.cmake

@@ -34,7 +34,7 @@ endif()
 
 # Set default install directory permissions.
 if(NOT DEFINED CMAKE_OBJDUMP)
-  set(CMAKE_OBJDUMP "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/objdump")
+  set(CMAKE_OBJDUMP "/usr/local/clang16/bin/llvm-objdump")
 endif()
 
 if(NOT CMAKE_INSTALL_LOCAL_ONLY)

quasardb/date/cmake_install.cmake

@@ -34,7 +34,7 @@ endif()
 
 # Set default install directory permissions.
 if(NOT DEFINED CMAKE_OBJDUMP)
-  set(CMAKE_OBJDUMP "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/objdump")
+  set(CMAKE_OBJDUMP "/usr/local/clang16/bin/llvm-objdump")
 endif()
 
 if(CMAKE_INSTALL_COMPONENT STREQUAL "Unspecified" OR NOT CMAKE_INSTALL_COMPONENT)

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/pybind11/cmake_install.cmake

@@ -34,6 +34,6 @@ endif()
 
 # Set default install directory permissions.
 if(NOT DEFINED CMAKE_OBJDUMP)
-  set(CMAKE_OBJDUMP "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/objdump")
+  set(CMAKE_OBJDUMP "/usr/local/clang16/bin/llvm-objdump")
 endif()
 

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/range-v3/cmake_install.cmake

@@ -34,7 +34,7 @@ endif()
 
 # Set default install directory permissions.
 if(NOT DEFINED CMAKE_OBJDUMP)
-  set(CMAKE_OBJDUMP "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/objdump")
+  set(CMAKE_OBJDUMP "/usr/local/clang16/bin/llvm-objdump")
 endif()
 
 if(CMAKE_INSTALL_COMPONENT STREQUAL "Unspecified" OR NOT CMAKE_INSTALL_COMPONENT)

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=Dvv6Os6bhJ5JfwkN1jAFidpkA2UfPwQTFvvWk_vhbdU,14682
+quasardb/CMakeLists.txt,sha256=gqGK-ppTl6As74kItvmRFwQATLr9vYhoSLPMq3HrPe0,14737
 quasardb/Makefile,sha256=yuJ6zNLc5d4kgnA0lNTVAKSX5wZT2K6HfBB1y-giO20,7409
 quasardb/__init__.py,sha256=LZ2jO_0RX6OCzgnDgyLK78xtYLzNzfguD8TuQju-4Ho,3707
 quasardb/batch_column.hpp,sha256=lgsf5iYSz5u1udgfhVG4QTv96DW0C2GSCgeIltw-n-w,3308
 quasardb/batch_inserter.hpp,sha256=23OxfmKG6SdD_lsTZS3v7ZPGuunRMP_4hBov8I8oybA,9555
 quasardb/blob.hpp,sha256=D7T9ECon76aIlUoQqvN2XNEzF8FQ7dh1sAvEmuvI-u4,5696
-quasardb/cluster.hpp,sha256=piKiRV4CW0tR8fhsph2_SUqRbdUiemvqWHhGwhG0Kuk,19480
-quasardb/cmake_install.cmake,sha256=IBP1GD4wGbJ_rK5fnGin5XjaTnvvWw7AdMjbXeCwuzM,1732
+quasardb/cluster.cpp,sha256=jMaqH-xL5EMSM2GM8JgZTqAlC3UY38YvZDw8cNDf-Xw,2411
+quasardb/cluster.hpp,sha256=GLZabw9awbe2nr3xPbTcgmDdeFapuGEAtYzK5aJoOEM,18854
+quasardb/cmake_install.cmake,sha256=VIl5Sw4uU0kp4MO0VjJmqtnka90XFYw_B83Vv6xAAyc,1673
 quasardb/concepts.hpp,sha256=bdfPkYLtcf0s-fc0QDz05c2dTm_gj7y2BMSceIY4dHA,9296
 quasardb/continuous.cpp,sha256=vNWtyingRC9g_2OQ7KjWm0L62fguQILXvQ14zu9OlLE,4417
 quasardb/continuous.hpp,sha256=aX90ydtKYcraoGaNfmIK97EFiqCikDwhSR-IcdjG0AE,4221
@@ -18,13 +19,16 @@ quasardb/double.hpp,sha256=lvjHILHMa0JC2egDgO2JVtiJqgcmhQfGMyafCpc0jT0,3152
 quasardb/entry.hpp,sha256=O-CDkWNqzUHKQiLz17toQFukZE6lZo3b35lRR1kjL0I,9178
 quasardb/error.hpp,sha256=QIjtxqCSdlB3RD3AMHavJDFrCFGkb46R70YY2rjGo-Q,10489
 quasardb/firehose.py,sha256=HO0GjCDg3x4cpzVSH3KZ1AJhV8lK2HJyXr9tpfnNSGI,3492
-quasardb/handle.hpp,sha256=YXNajJzM1dH51YIhFTwxaM_wXiM0a6HenqWPEw8A2M4,3204
+quasardb/handle.cpp,sha256=6x7qPFvIzGNralz7MFbUtCEXi26Q2RKzNhIywoVIOKM,507
+quasardb/handle.hpp,sha256=2n_n3FwOQRJ9KB0DMmOFC547K320JwOeSsGCHCfrZWE,2953
 quasardb/integer.hpp,sha256=_h-0PZfvlKAnCUgrzuisOsM_hS-S49MzwBJyJ-yZpyE,3216
-quasardb/libqdb_api.dylib,sha256=UBMAal52yKCwhSD7_-vjg-XsXy_gjOeQRsOJu9SM3YQ,36307992
-quasardb/logger.cpp,sha256=qGFoA9R7ZRq9QrcJELndOBTdvWE2PjTqRRc_sERjZeU,2927
+quasardb/libqdb_api.dylib,sha256=mHyqtDSeU7N9zvEKSpFhQ0sURJz-ldv4usZu2AqEHLI,33835736
+quasardb/logger.cpp,sha256=UT2dGHF_sk-UIFUAOWxdse8JlcaLnnARsZDu5AP_v4E,2950
 quasardb/logger.hpp,sha256=USIltBP4gAGQcfLCXLgKXifdk0oJwyNjIJiF8HIMlgU,7050
 quasardb/masked_array.hpp,sha256=XWzRY0ySs3-xKRxa9UJsixZqGsCNXnOhGuhDrnZOwXU,18337
-quasardb/module.cpp,sha256=FPgDf9FcSPC8vpbHOMk3FI9pgbZSce-wp8UiIAtuWF0,2107
+quasardb/metrics.cpp,sha256=7xbg65UUQysbT8AIsnLOaVbBlwxQqB8sMzFgcOw4BMI,2839
+quasardb/metrics.hpp,sha256=Ff9IkRbQ7jbzG9SXTpNnYX7lRKixhbecAn14omgBld4,3421
+quasardb/module.cpp,sha256=f705GwIRdmNO6hb_Yx-3z6QJo5WiRrRvsr54VK7iWH4,2160
 quasardb/module.hpp,sha256=NQYsuOMyTnhSufJyAFQOXiL9znXea_ch2CnDgEKm1dY,580
 quasardb/node.hpp,sha256=bE5xtaHwdDNBHPDhgh-vI3lvI9DIPjtmzRszkyZxuBI,4648
 quasardb/numpy.cpp,sha256=U1lazDCBCCKRR3ubLCf5OaHbK-kLQAZz7jLlHWSr1gw,183
@@ -34,14 +38,14 @@ quasardb/options.hpp,sha256=9v1WRQSBZEZYrzf_jHP_wgeepxhq9s-W9c1nqAmuGeY,9914
 quasardb/perf.hpp,sha256=gFJiVuE-BUigrm2267o0MacP0YwVYpxR-8ldlmlaLAA,11028
 quasardb/pool.py,sha256=4IFwot-U8GEHo8h86264uVTWge44bOH_TUkoVy3Hjac,8449
 quasardb/pytypes.hpp,sha256=buxGpg3ZUbXfAblG2jRncEsqMfjuoaNKpW2IuB8dALw,6673
-quasardb/quasardb.cpython-39-darwin.so,sha256=BSbt9E4iTZ1UZ0PUhEmVVUDrZEpg_PP0-2ii8pQ_-Xk,1083616
-quasardb/query.cpp,sha256=xYyN8ELpBC4BZQQF6phz5qXM5m6nakPWn-rPS_VNtsE,12149
+quasardb/quasardb.cpython-39-darwin.so,sha256=_t5xsZ3jcPzhztxpKnNS3-N84Om9mO2Z7GTwwq-5vfY,1031788
+quasardb/query.cpp,sha256=yi_lH0nvrSIJUO2kouz8jSeDhgOHpjcNT6HZoBlvbe8,12332
 quasardb/query.hpp,sha256=-er_n0esgo7AshmGJxEenBRuaJvZUNF-Oco_LvjdcmM,3265
 quasardb/remove_cvref.hpp,sha256=kGW27WE2GvUL9sWvVdFD6NgnVF40bzeNl74ecTlyG9c,580
 quasardb/stats.py,sha256=DKvurzur-4c5nVPjr29_Stu9mvwCynM5gGnw0gVQlt8,7387
 quasardb/string.hpp,sha256=IS9Ep-f_GX-o5XD5Dy82D5Yf1_oA93feMgH13LFDHzg,5911
-quasardb/table.cpp,sha256=F19t8OybpNLD_s0Cm_gTD4qDAxJGQfDpd7gFkA_2ZZs,9834
-quasardb/table.hpp,sha256=DR8uHcEC7LkYQ9ItB2sS6PDOjucwyX-Uz6UFzHxUrm0,11161
+quasardb/table.cpp,sha256=-zEd3u5o4FhrjxTkW8PKtVyaRZhJ7gI4TYiaaNgL65Y,10444
+quasardb/table.hpp,sha256=sVh1rHGYifvB3sIySIs4BDbu5F205TWupVyya4nB2ps,10666
 quasardb/table_cache.py,sha256=RgLOYEcgmlc5fVeOBOyjZImtYKoM1UEdzyzPc8EriQI,1507
 quasardb/table_reader.hpp,sha256=gXFJ3e9E6AzYxwfpCeqnTOyiynpWLwgB2IJJElIl9zs,6721
 quasardb/tag.hpp,sha256=QhbOSn0Qwaf1TC9GtELREQOQBmPGeKdRpgIBlPdlmq4,2655
@@ -50,7 +54,7 @@ quasardb/traits.hpp,sha256=JBF1ySxuoUM9DdSb1tZyB_lDHCXw8DEC1HlTaEXzkWQ,15764
 quasardb/ts_iterator.hpp,sha256=tiO5dqPpQrhOT0j6v2AUY5kRYDYj-gki2eBzCiYUDSs,4202
 quasardb/utils.cpp,sha256=QzmxqyTWPZ0XwxVS_wtTzfffZs3HI8MwwvW9vAHiT-Q,606
 quasardb/utils.hpp,sha256=pTkffOObpXUi2yQqOWwTNiv9eT80nndeQtySuNIN5MQ,4550
-quasardb/writer.cpp,sha256=DzjilpM0FAGUtj3GyrxYksLSYH0NEc415kuBmEnXFPg,18885
+quasardb/writer.cpp,sha256=lBy9j75n-gQfb-ufJAUBDwlrpcCYZ6eve6MNDnjuIYU,19037
 quasardb/writer.hpp,sha256=wHpIsUsWrNrM1yGOnBL8YQncASlu-129vVqASXqd0Ls,12537
 quasardb/CMakeFiles/CMakeDirectoryInformation.cmake,sha256=DNncyTE12GRv1AQRJQVQkIwP9uKsUOFqN7pXwjm_p8Q,732
 quasardb/CMakeFiles/progress.marks,sha256=micfKpFrC27mzsskJvCzIG7wdFeL5V2byU9vP-Orhqo,2
@@ -61,7 +65,7 @@ quasardb/convert/unicode.hpp,sha256=WZcLiC-tRTYS-IAKZ6l2AVbk9AUv3DBbEWbCiwh8MIY,
 quasardb/convert/util.hpp,sha256=eJhQGs0ymPn3CT48HGHndaChJg_SCOI5U1QkLccXLdQ,560
 quasardb/convert/value.hpp,sha256=YDBT8UUnMUjrP_isW70WBZMGnldT1tMVER9k5Keekhc,22685
 quasardb/date/Makefile,sha256=JY1hOA8CZIJLQFeqd6jge56HEecVXN3YnVydBzz1o0E,7434
-quasardb/date/cmake_install.cmake,sha256=oHnJK9cyLblMSb7kXbOnhIgPnqTo0xMcGNNRssw2dVo,3308
+quasardb/date/cmake_install.cmake,sha256=81aq1O6FaTVteQSnK5W-ciFjrJTRM1gbAZU1AP0bgQc,3249
 quasardb/date/dateConfigVersion.cmake,sha256=PLnZWf4r8BmNkw645Jb7mJrIe2QWSJioM6O4nY0Nwj8,2418
 quasardb/date/dateTargets.cmake,sha256=YJ_GPXSFeDNN7iShTy1Q0kkv5wdBDVkUnhBqDaq4xOg,3000
 quasardb/date/CMakeFiles/CMakeDirectoryInformation.cmake,sha256=DNncyTE12GRv1AQRJQVQkIwP9uKsUOFqN7pXwjm_p8Q,732
@@ -74,11 +78,11 @@ quasardb/extensions/writer.py,sha256=ZH6ldQrbH-DimuQTyk3mXS1OyaJIhvCmZTzFtG4hRfY
 quasardb/numpy/__init__.py,sha256=DKIe8702OedqPxSxgiOze15ulf7XZT4HL9X7Zif-j5c,28226
 quasardb/pandas/__init__.py,sha256=13Gq3sSlU5xIJ1bf-0n7yyKCWRPYBNSBAjc5VSV0j3g,16126
 quasardb/pybind11/Makefile,sha256=C4-lWSoIYTTuxzdyISKyKWHKjpRuIlMi0_NDFvdk-6g,7454
-quasardb/pybind11/cmake_install.cmake,sha256=9_JZtBJMTYlVWhS1Y45EZfqNUs1tU4DAIT14--A2DL8,1228
+quasardb/pybind11/cmake_install.cmake,sha256=b9uFDssIxtpKwp4oiOF937lN6D2fmOettcCHAdbU244,1169
 quasardb/pybind11/CMakeFiles/CMakeDirectoryInformation.cmake,sha256=DNncyTE12GRv1AQRJQVQkIwP9uKsUOFqN7pXwjm_p8Q,732
 quasardb/pybind11/CMakeFiles/progress.marks,sha256=micfKpFrC27mzsskJvCzIG7wdFeL5V2byU9vP-Orhqo,2
 quasardb/range-v3/Makefile,sha256=Uset6pLvjN1Ze0hP57MyJ6040KWXpKj9W0Dkr1WDJh8,8823
-quasardb/range-v3/cmake_install.cmake,sha256=OA0aW5UtdIU6x8iegvSPF04JAmFFMOlx_xby_ZfFHko,3417
+quasardb/range-v3/cmake_install.cmake,sha256=r7XxQwpsARjVuNCk5FgRrgcW0NScuGMp49AMfve4iUI,3358
 quasardb/range-v3/range-v3-config-version.cmake,sha256=X3UrazWN6YOziV7sKMXfydMMV1_8BziHjYAu0HMFEek,2908
 quasardb/range-v3/range-v3-config.cmake,sha256=BZrbOr8d2SSoaASpmre_rE_3YIsZrWQF8H51o9_dqEY,3554
 quasardb/range-v3/CMakeFiles/CMakeDirectoryInformation.cmake,sha256=DNncyTE12GRv1AQRJQVQkIwP9uKsUOFqN7pXwjm_p8Q,732
@@ -98,8 +102,8 @@ quasardb/utils/ostream.hpp,sha256=oqnyxurnnbiStXuFTZEewEM_SsYzB-RdUft-q2y1JcI,37
 quasardb/utils/permutation.hpp,sha256=7iyUNZQLxUEyOliRKwoVzO9pzG_b5Id4JjAHXAy5I50,1502
 quasardb/utils/stable_sort.hpp,sha256=Z1R3mWl78_Zh4O4bxCXQJHBCd7m71G-qFRcK-ll07qc,465
 quasardb/utils/unzip_view.hpp,sha256=pkwk_BTYOm_9HOjyf6Z2W2Udc9he5EJKcIbbrYcUzok,2387
-quasardb-3.14.1.dev5.dist-info/LICENSE.md,sha256=4D8uWaUfWtnVDET9cPT43pHIiwt1GHXvEr1rzz49pJw,1467
-quasardb-3.14.1.dev5.dist-info/METADATA,sha256=b7IqgloEUU9fFOhZSb7-7gpAbx2lt05u0slh4OSiiJY,1461
-quasardb-3.14.1.dev5.dist-info/WHEEL,sha256=hgZvrlQ16Hzt5qiSLL09qJyqip_-uMS7-HY4MCTupqU,110
-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=4D8uWaUfWtnVDET9cPT43pHIiwt1GHXvEr1rzz49pJw,1467
+quasardb-3.14.1.dev6.dist-info/METADATA,sha256=ta4c-1x4-NyZCo4RS3Kq56W42-bhAO_g0GqMhtZNI7U,1461
+quasardb-3.14.1.dev6.dist-info/WHEEL,sha256=hgZvrlQ16Hzt5qiSLL09qJyqip_-uMS7-HY4MCTupqU,110
+quasardb-3.14.1.dev6.dist-info/top_level.txt,sha256=wlprix4hCywuF1PkgKWYdZeJKq_kgJOqkAvukm_sZQ8,9
+quasardb-3.14.1.dev6.dist-info/RECORD,,