quasardb 3.14.2.dev0__cp310-cp310-win_amd64.whl → 3.14.2.dev4__cp310-cp310-win_amd64.whl

quasardb/metrics.cpp

@@ -1,103 +0,0 @@
-#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

@@ -1,112 +0,0 @@
-/*
- *
- * Official Python API
- *
- * Copyright (c) 2009-2024, 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,76 +0,0 @@
-#include "module.hpp"
-#include "cluster.hpp"
-#include "metrics.hpp"
-#include "node.hpp"
-#include "writer.hpp"
-#include <functional>
-#include <list>
-
-namespace qdb
-{
-/**
- * This approach is inspired from pybind11, where we keep a global static variable
- * of initializers for components/modules that which to register with our global
- * quasardb module.
- *
- * It has the downside of module initialization order essentially being random, which
- * is fine for our use case. It allows decoupling of code in many places.
- */
-std::list<std::function<void(py::module_ &)>> & initializers()
-{
-    static std::list<std::function<void(py::module_ &)>> inits;
-    return inits;
-}
-
-submodule_initializer::submodule_initializer(initialize_fn init)
-{
-    initializers().emplace_back(init);
-}
-
-submodule_initializer::submodule_initializer(const char * submodule_name, initialize_fn init)
-{
-    initializers().emplace_back([=](py::module_ & parent) { init(parent); });
-}
-
-}; // namespace qdb
-
-PYBIND11_MODULE(quasardb, m)
-{
-    m.doc() = "QuasarDB Official Python API";
-    m.def("version", &qdb_version, "Return version number");
-    m.def("build", &qdb_build, "Return build number");
-    m.attr("never_expires") = std::chrono::system_clock::time_point{};
-
-    qdb::register_errors(m);
-    qdb::register_cluster(m);
-    qdb::register_node(m);
-    qdb::register_options(m);
-    qdb::register_perf(m);
-    qdb::register_entry(m);
-    qdb::register_double(m);
-    qdb::register_integer(m);
-    qdb::register_blob(m);
-    qdb::register_string(m);
-    qdb::register_timestamp(m);
-    qdb::register_direct_blob(m);
-    qdb::register_direct_integer(m);
-    qdb::register_tag(m);
-    qdb::register_query(m);
-    qdb::register_continuous(m);
-    qdb::register_table(m);
-    qdb::register_batch_column(m);
-    qdb::register_batch_inserter(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);
-    qdb::reader::register_ts_row(m);
-
-    for (const auto & initializer : qdb::initializers())
-    {
-        initializer(m);
-    }
-}

quasardb/module.hpp

@@ -1,24 +0,0 @@
-#pragma once
-
-#include <pybind11/pybind11.h>
-
-namespace qdb
-{
-
-namespace py = pybind11;
-
-class submodule_initializer
-{
-    using initialize_fn = void (*)(py::module_ &);
-
-public:
-    explicit submodule_initializer(initialize_fn init);
-    submodule_initializer(const char * submodule_name, initialize_fn init);
-};
-
-}; // namespace qdb
-
-#define QDB_REGISTER_MODULE(name, variable)                  \
-    void qdb_submodule_##name(py::module_ &);                \
-    submodule_initializer name(#name, qdb_submodule_##name); \
-    void qdb_submodule_##name(py::module_ &(variable))

quasardb/node.hpp

@@ -1,123 +0,0 @@
-/*
- *
- * Official Python API
- *
- * Copyright (c) 2009-2024, 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 "direct_blob.hpp"
-#include "direct_handle.hpp"
-#include "direct_integer.hpp"
-#include "options.hpp"
-#include "utils.hpp"
-#include <memory>
-
-namespace qdb
-{
-
-class node
-{
-public:
-    /**
-     * Construct a direct node connection directly, possibly with security credentials.
-     */
-    node(const std::string & node_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 = {})
-        : _uri{node_uri}
-        , _handle{make_handle_ptr()}
-        , _direct_handle{make_direct_handle_ptr()}
-    {
-        qdb::options{_handle}.apply_credentials(user_name, user_private_key, cluster_public_key,
-            user_security_file, cluster_public_key_file);
-        _direct_handle->connect(_handle, node_uri);
-    }
-
-    /**
-     * Construct a direct node from a cluster handle, reusing its security credentials if applicable.
-     */
-    node(const std::string & node_uri, handle_ptr handle)
-        : _uri{node_uri}
-        , _handle{handle}
-        , _direct_handle{make_direct_handle_ptr()}
-    {
-        _direct_handle->connect(_handle, node_uri);
-    }
-
-    std::vector<std::string> prefix_get(const std::string & prefix, qdb_int_t max_count)
-    {
-        const char ** result = nullptr;
-        size_t count         = 0;
-
-        // don't throw if no prefix is found
-        const qdb_error_t err =
-            qdb_direct_prefix_get(*_direct_handle, prefix.c_str(), max_count, &result, &count);
-        qdb_throw_if_error(*_handle, err);
-
-        return convert_strings_and_release(_handle, result, count);
-    }
-
-    qdb::direct_blob_entry blob(const std::string & alias)
-    {
-        return qdb::direct_blob_entry{_handle, _direct_handle, alias};
-    }
-
-    qdb::direct_integer_entry integer(const std::string & alias)
-    {
-        return qdb::direct_integer_entry{_handle, _direct_handle, alias};
-    }
-
-private:
-    std::string _uri;
-    handle_ptr _handle;
-    direct_handle_ptr _direct_handle;
-};
-
-template <typename Module>
-static inline void register_node(Module & m)
-{
-    namespace py = pybind11;
-
-    py::class_<qdb::node>(m, "Node")
-        .def(py::init<std::string const &, std::string const &, std::string const &, std::string const &,
-                std::string const &, std::string const &>(),
-            py::arg("uri"),                                     //
-            py::arg("user_name")          = std::string{},      //
-            py::arg("user_private_key")   = std::string{},      //
-            py::arg("cluster_public_key") = std::string{},      //
-            py::arg("user_security_file")      = std::string{}, //
-            py::arg("cluster_public_key_file") = std::string{}) //
-        .def("prefix_get", &qdb::node::prefix_get)
-        .def("blob", &qdb::node::blob)
-        .def("integer", &qdb::node::integer);
-}
-
-} // namespace qdb

quasardb/numpy.cpp

@@ -1,6 +0,0 @@
-#include "numpy.hpp"
-#include "convert/value.hpp"
-
-qdb::numpy::datetime64::datetime64(qdb_timespec_t const & ts)
-    : datetime64(convert::value<qdb_timespec_t, std::int64_t>(ts))
-{}