quasardb 3.14.2.dev3__cp312-cp312-win_amd64.whl → 3.14.2.dev5__cp312-cp312-win_amd64.whl

quasardb/error.hpp

@@ -1,393 +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 out_of_bounds_exception : public exception
-{
-public:
-    out_of_bounds_exception() noexcept
-        : exception(qdb_e_out_of_bounds, std::string("The requested operation is out of bounds"))
-    {}
-
-    out_of_bounds_exception(std::string const & what) noexcept
-        : exception(qdb_e_out_of_bounds, what)
-    {}
-};
-
-class uninitialized_exception : public exception
-{
-public:
-    uninitialized_exception() noexcept
-        : exception(qdb_e_uninitialized,
-            std::string("The requested operation is unavailable because the resource is uninitialized"))
-    {}
-
-    uninitialized_exception(std::string const & what) noexcept
-        : exception(qdb_e_uninitialized, what)
-    {}
-};
-
-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 try_again_exception : public exception
-{
-public:
-    try_again_exception() noexcept
-        : exception(qdb_e_try_again,
-            std::string("The operation could not be completed at this time, please try again"))
-    {}
-
-    try_again_exception(std::string const & what) noexcept
-        : exception(qdb_e_try_again, what)
-    {}
-};
-
-class async_pipeline_full_exception : public exception
-{
-public:
-    async_pipeline_full_exception() noexcept
-        : exception(qdb_e_async_pipe_full,
-            std::string("The async pipelines are currently full, please try again later or slow down "
-                        "your ingestion speed."))
-    {}
-
-    async_pipeline_full_exception(std::string const & what) noexcept
-        : exception(qdb_e_async_pipe_full, 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) [[unlikely]]
-        {
-            // 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{};
-
-            case qdb_e_invalid_argument:
-                throw qdb::invalid_argument_exception{};
-
-            case qdb_e_try_again:
-                throw qdb::try_again_exception{};
-
-            case qdb_e_async_pipe_full:
-                throw qdb::async_pipeline_full_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_out_of_bounds:
-            throw qdb::out_of_bounds_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_};
-
-        case qdb_e_try_again:
-            throw qdb::try_again_exception{msg_data_};
-
-        case qdb_e_async_pipe_full:
-            throw qdb::async_pipeline_full_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::uninitialized_exception>(m, "UninitializedError", 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);
-    py::register_exception<qdb::try_again_exception>(m, "TryAgainError", base_class);
-    py::register_exception<qdb::async_pipeline_full_exception>(m, "AsyncPipelineFullError", base_class);
-    py::register_exception<qdb::out_of_bounds_exception>(m, "OutOfBoundsError", 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