quasardb 3.14.2.dev1__cp310-cp310-win32.whl → 3.14.2.dev4__cp310-cp310-win32.whl

quasardb/error.hpp

@@ -1,318 +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 "logger.hpp"
-#include "traits.hpp"
-#include <qdb/client.h>
-#include <qdb/error.h>
-#include <qdb/query.h>
-#include "detail/qdb_resource.hpp"
-#include <pybind11/pybind11.h>
-#include <iostream>
-#include <utility>
-
-namespace py = pybind11;
-
-namespace qdb
-{
-
-class exception
-{
-public:
-    exception() noexcept
-    {}
-
-    explicit exception(qdb_error_t err, std::string msg) noexcept
-        : _error{err}
-        , _msg(msg)
-    {}
-
-    virtual const char * what() const noexcept
-    {
-        return _msg.c_str();
-    }
-
-private:
-    qdb_error_t _error{qdb_e_ok};
-    std::string _msg;
-};
-
-class input_buffer_too_small_exception : public exception
-{
-public:
-    input_buffer_too_small_exception() noexcept
-        : exception(qdb_e_network_inbuf_too_small,
-            std::string(
-                "Input buffer too small: result set too large. Hint: consider increasing the buffer "
-                "size using "
-                "cluster.options().set_client_max_in_buf_size(..) prior to address this error."))
-    {}
-};
-
-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:
-    incompatible_type_exception() noexcept
-        : exception(qdb_e_incompatible_type, std::string("Incompatible type"))
-    {}
-
-    incompatible_type_exception(std::string const & what) noexcept
-        : exception(qdb_e_incompatible_type, what)
-    {}
-};
-
-class not_implemented_exception : public exception
-{
-public:
-    not_implemented_exception() noexcept
-        : exception(qdb_e_not_implemented, std::string("Method or class not implemented"))
-    {}
-
-    not_implemented_exception(std::string const & what) noexcept
-        : exception(qdb_e_incompatible_type, what)
-    {}
-};
-
-class invalid_argument_exception : public exception
-{
-public:
-    invalid_argument_exception() noexcept
-        : exception(qdb_e_invalid_argument, std::string("Invalid argument"))
-    {}
-
-    invalid_argument_exception(std::string const & what) noexcept
-        : exception(qdb_e_invalid_argument, what)
-    {}
-};
-
-class invalid_query_exception : public exception
-{
-public:
-    invalid_query_exception() noexcept
-        : exception(qdb_e_invalid_query, std::string("Invalid query"))
-    {}
-
-    invalid_query_exception(std::string const & what) noexcept
-        : exception(qdb_e_invalid_query, what)
-    {}
-};
-
-class internal_local_exception : public exception
-{
-public:
-    internal_local_exception() noexcept
-        : exception(qdb_e_internal_local, std::string("An unknown local internal error occurred"))
-    {}
-
-    internal_local_exception(std::string const & what) noexcept
-        : exception(qdb_e_internal_local, what)
-    {}
-};
-
-class alias_already_exists_exception : public exception
-{
-public:
-    alias_already_exists_exception() noexcept
-        : exception(qdb_e_alias_already_exists, std::string("Alias already exists"))
-    {}
-
-    alias_already_exists_exception(std::string const & what) noexcept
-        : exception(qdb_e_alias_already_exists, what)
-    {}
-};
-
-class alias_not_found_exception : public exception
-{
-public:
-    alias_not_found_exception() noexcept
-        : exception(qdb_e_alias_not_found, std::string("Alias not found"))
-    {}
-
-    alias_not_found_exception(std::string const & what) noexcept
-        : exception(qdb_e_alias_not_found, what)
-    {}
-};
-
-class invalid_datetime_exception : public exception
-{
-public:
-    invalid_datetime_exception() noexcept
-        : exception(qdb_e_incompatible_type,
-            std::string("Unable to interpret provided numpy datetime64. Hint: QuasarDB only works with "
-                        "nanosecond precision datetime64. "
-                        "You can correct this by explicitly casting your timestamps to the dtype "
-                        "datetime64[ns]"))
-    {}
-
-    invalid_datetime_exception(py::object o)
-        : exception(qdb_e_incompatible_type,
-            std::string("Unable to interpret provided numpy datetime64: " + (std::string)(py::str(o))
-                        + ". Hint: QuasarDB only works with nanosecond precision datetime64. You can "
-                          "correct this by explicitly casting "
-                          "your timestamps to the dtype datetime64[ns]"))
-
-    {}
-};
-
-namespace detail
-{
-
-struct no_op
-{
-    void operator()() const noexcept
-    {}
-};
-
-} // namespace detail
-
-// Allow a callable to be run just before the throw, thus making nice clean-up possible
-// (such as calls to `qdb_release`)
-// `pre_throw` defaults to a `no_op` functor that does nothing.
-template <typename PreThrowFtor = detail::no_op>
-inline void qdb_throw_if_error(
-    qdb_handle_t h, qdb_error_t err, PreThrowFtor && pre_throw = detail::no_op{})
-{
-    static_assert(
-        noexcept(std::forward<PreThrowFtor &&>(pre_throw)()), "`pre_throw` argument must be noexcept");
-
-    // HACKS(leon): we need to flush our log buffer a lot, ideally after every native qdb
-    //              call. Guess which function is invoked exactly at those moments?
-    qdb::native::flush();
-
-    if ((qdb_e_ok != err) && (qdb_e_ok_created != err)) [[unlikely]]
-    {
-        detail::qdb_resource<qdb_string_t> msg_{h, nullptr};
-        qdb_error_t err_;
-        qdb_get_last_error(h, &err_, &msg_);
-
-        if (err_ != err)
-        {
-            // Error context returned is not the same, which means this thread already made
-            // another call to the QDB API, or the QDB API itself
-
-            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);
-
-        pre_throw();
-
-        std::string msg_data_{msg_.get()->data};
-
-        switch (err)
-        {
-
-        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_};
-
-        case qdb_e_alias_not_found:
-            throw qdb::alias_not_found_exception{msg_data_};
-
-        case qdb_e_network_inbuf_too_small:
-            throw qdb::input_buffer_too_small_exception{};
-
-        case qdb_e_incompatible_type:
-            throw qdb::incompatible_type_exception{msg_data_};
-
-        case qdb_e_not_implemented:
-            throw qdb::not_implemented_exception{msg_data_};
-
-        case qdb_e_internal_local:
-            throw qdb::internal_local_exception{msg_data_};
-
-        case qdb_e_invalid_argument:
-            throw qdb::invalid_argument_exception{msg_data_};
-
-        default:
-            throw qdb::exception{err_, msg_data_};
-        };
-    }
-}
-
-template <typename PreThrowFtor = detail::no_op>
-inline void qdb_throw_if_query_error(qdb_handle_t h, qdb_error_t err, qdb_query_result_t const * result)
-{
-    if (err == qdb_e_invalid_query && result != nullptr
-        && traits::is_null(result->error_message) == false) [[unlikely]]
-    {
-        throw qdb::invalid_query_exception{
-            std::string{result->error_message.data, result->error_message.length}};
-    }
-
-    return qdb_throw_if_error(h, err);
-}
-
-template <typename Module>
-static inline void register_errors(Module & m)
-{
-    auto base_class = py::register_exception<qdb::exception>(m, "Error", PyExc_RuntimeError);
-
-    py::register_exception<qdb::input_buffer_too_small_exception>(
-        m, "InputBufferTooSmallError", base_class);
-    py::register_exception<qdb::alias_already_exists_exception>(
-        m, "AliasAlreadyExistsError", base_class);
-    py::register_exception<qdb::alias_not_found_exception>(m, "AliasNotFoundError", base_class);
-    py::register_exception<qdb::invalid_datetime_exception>(m, "InvalidDatetimeError", base_class);
-    py::register_exception<qdb::incompatible_type_exception>(m, "IncompatibleTypeError", base_class);
-    py::register_exception<qdb::not_implemented_exception>(m, "NotImplementedError", base_class);
-    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

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

@@ -1,98 +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 "error.hpp"
-#include <qdb/client.h>
-#include <memory>
-#include <string>
-
-namespace qdb
-{
-
-class handle
-{
-public:
-    handle() noexcept
-        : handle_{nullptr}
-    {}
-
-    explicit handle(qdb_handle_t h) noexcept
-        : handle_{h}
-    {}
-
-    ~handle()
-    {
-        close();
-    }
-
-    void connect(const std::string & uri);
-
-    operator qdb_handle_t() const noexcept
-    {
-        return handle_;
-    }
-
-    void close();
-
-    constexpr inline bool is_open() const
-    {
-        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};
-};
-
-using handle_ptr = std::shared_ptr<handle>;
-
-static inline handle_ptr make_handle_ptr()
-{
-    return std::make_shared<qdb::handle>(qdb_open_tcp());
-}
-
-} // namespace qdb

quasardb/integer.hpp

@@ -1,88 +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 "entry.hpp"
-#include <qdb/integer.h>
-
-namespace qdb
-{
-
-class integer_entry : public expirable_entry
-{
-public:
-    integer_entry(handle_ptr h, std::string a) noexcept
-        : expirable_entry{h, a}
-    {}
-
-public:
-    qdb_int_t get()
-    {
-        qdb_int_t result;
-        qdb::qdb_throw_if_error(*_handle, qdb_int_get(*_handle, _alias.c_str(), &result));
-        return result;
-    }
-
-    void put(qdb_int_t integer)
-    {
-        qdb::qdb_throw_if_error(
-            *_handle, qdb_int_put(*_handle, _alias.c_str(), integer, qdb_time_t{0}));
-    }
-
-    void update(qdb_int_t integer)
-    {
-        qdb::qdb_throw_if_error(
-            *_handle, qdb_int_update(*_handle, _alias.c_str(), integer, qdb_time_t{0}));
-    }
-
-    qdb_int_t add(qdb_int_t integer)
-    {
-        qdb_int_t result;
-        qdb::qdb_throw_if_error(*_handle, qdb_int_add(*_handle, _alias.c_str(), integer, &result));
-        return result;
-    }
-};
-
-template <typename Module>
-static inline void register_integer(Module & m)
-{
-    namespace py = pybind11;
-
-    py::class_<qdb::integer_entry, qdb::expirable_entry>(m, "Integer")  //
-        .def(py::init<qdb::handle_ptr, std::string>())                  //
-        .def("get", &qdb::integer_entry::get)                           //
-        .def("put", &qdb::integer_entry::put, py::arg("integer"))       //
-        .def("update", &qdb::integer_entry::update, py::arg("integer")) //
-        .def("add", &qdb::integer_entry::add, py::arg("addend"))        //
-        ;                                                               //
-}
-
-} // namespace qdb

quasardb/logger.cpp

@@ -1,106 +0,0 @@
-#include "logger.hpp"
-
-namespace py = pybind11;
-
-static std::vector<qdb::native::message_t> _buffer;
-static std::mutex _buffer_lock;
-static qdb_log_callback_id local_callback_id;
-static qdb::logger _logger;
-
-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);
-    if (error)
-    {
-        // This error is quite common the first time a callback is set, because we did
-        // not have a callback yet.
-    }
-
-    error = qdb_log_add_callback(_callback, &local_callback_id);
-    if (error)
-    {
-        // fprintf(stderr, "unable to add new callback: %s (%#x)\n", qdb_error(error), error);
-        // fflush(stderr);
-    }
-#endif
-
-    _logger = qdb::logger("quasardb.native");
-}
-
-void qdb::native::_callback(qdb_log_level_t log_level,
-    const unsigned long * date,
-    unsigned long pid,
-    unsigned long tid,
-    const char * message_buffer,
-    size_t message_size)
-{
-    message_t x{log_level,
-        {static_cast<int>(date[0]), static_cast<int>(date[1]), static_cast<int>(date[2]),
-            static_cast<int>(date[3]), static_cast<int>(date[4]), static_cast<int>(date[5])},
-        static_cast<int>(pid), static_cast<int>(tid), std::string(message_buffer, message_size)};
-
-    std::lock_guard<std::mutex> guard(_buffer_lock);
-    _buffer.push_back(x);
-}
-
-void qdb::native::flush()
-{
-
-    // TODO(leon): it would be much more appropriate to use a read/write lock here,
-    //             since the buffer is typically empty.
-    std::lock_guard<std::mutex> guard(_buffer_lock);
-
-    // BUG(leon): I don't think it's practically possible, but there might be a case
-    //            where our _buffer is somehow non-empty, but we haven't set our
-    //            _logger yet. This will cause a segfault in _do_flush().
-    if (!_buffer.empty())
-    {
-        qdb::native::_do_flush();
-    }
-}
-
-void qdb::native::_do_flush()
-{
-    // NOTE: this assumes a lock to _buffer-lock has been acquired, never call this
-    //       function directly!
-    assert(!_buffer_lock.try_lock());
-
-    // TODO(leon): we can improve native <> python vm context switching by folding all
-    //             invocations below into a single call.
-    for (auto i = _buffer.begin(); i != _buffer.end(); ++i)
-    {
-        message_t const & m = *i;
-
-        switch (m.level)
-        {
-        case qdb_log_detailed:
-        case qdb_log_debug:
-            _logger.debug(m.message);
-            break;
-
-        case qdb_log_info:
-            _logger.info(m.message);
-            break;
-
-        case qdb_log_warning:
-            _logger.warn(m.message);
-            break;
-
-        case qdb_log_error:
-            _logger.error(m.message);
-            break;
-
-        case qdb_log_panic:
-            _logger.critical(m.message);
-            break;
-        }
-    }
-
-    _buffer.clear();
-}