quasardb 3.14.2.dev3__cp311-cp311-macosx_11_0_arm64.whl → 3.14.2.dev5__cp311-cp311-macosx_11_0_arm64.whl

quasardb/concepts.hpp

@@ -1,322 +0,0 @@
-#pragma once
-
-#include "traits.hpp" // We include traits.hpp only for static_asserts below
-#include <pybind11/numpy.h>
-#include <range/v3/range/concepts.hpp>
-#include <range/v3/range/traits.hpp>
-#include <chrono>
-#include <iterator>
-#include <type_traits>
-
-namespace qdb::concepts
-{
-
-template <typename R, typename T>
-concept range_t =
-    // Ensure we are a range
-    ranges::range<R> &&
-
-    std::is_same_v<ranges::range_value_t<R>, T>;
-
-template <typename R, typename T>
-concept input_range_t =
-    // Ensure we are an input range
-    ranges::input_range<R>
-
-    // Ensure the range carries the correct type.
-    && range_t<R, T>;
-
-template <typename R, typename T>
-concept forward_range_t =
-    // Ensure we are a forward range
-    ranges::forward_range<R>
-
-    // And delegate the rest of the checks
-    && input_range_t<R, T>;
-
-template <typename R, typename T>
-concept sized_range_t =
-    // Ensure we are a sized range
-    ranges::sized_range<R>
-
-    // And delegate the rest of the checks
-    && range_t<R, T>;
-
-namespace py = pybind11;
-
-////////////////////////////////////////////////////////////////////////////////
-//
-// QuasarDB value types
-//
-// Verifies a "type" of QuasarDB value we're dealing with.
-//
-///////////////////
-
-template <typename T>
-concept qdb_point =
-    // Check for the boolean flag
-    traits::qdb_value<T>::is_qdb_point &&
-
-    // Every point should have a "primitive" counterpart, for which we do a
-    // basic 'is_qdb_primitive' assessment.
-    traits::qdb_value<typename traits::qdb_value<T>::primitive_type>::is_qdb_primitive
-
-    ;
-
-template <typename T>
-concept qdb_primitive =
-
-    // Check for the boolean flag
-    traits::qdb_value<T>::is_qdb_primitive &&
-
-    // Every primitive has a null representation
-    std::is_same_v<decltype(traits::null_value<T>()), T> &&
-
-    // Every primitive should be able to check for null validity
-    std::is_same_v<decltype(traits::is_null<T>(T{})), bool> &&
-
-    // And every primitive should have its "point" counterpart, which must
-    // be a valid qdb_point.
-    qdb_point<typename traits::qdb_value<T>::point_type>;
-
-// XXX(leon): could be enabled for debug-only, but we don't build Debug in CI,
-//            and these checks are cheap.
-
-static_assert(qdb_primitive<qdb_int_t>);
-static_assert(qdb_primitive<double>);
-static_assert(qdb_primitive<qdb_timespec_t>);
-static_assert(qdb_primitive<qdb_string_t>);
-static_assert(qdb_primitive<qdb_blob_t>);
-
-static_assert(not qdb_point<qdb_int_t>);
-static_assert(not qdb_point<double>);
-static_assert(not qdb_point<qdb_timespec_t>);
-static_assert(not qdb_point<qdb_string_t>);
-static_assert(not qdb_point<qdb_blob_t>);
-
-static_assert(qdb_point<qdb_ts_double_point>);
-static_assert(qdb_point<qdb_ts_int64_point>);
-static_assert(qdb_point<qdb_ts_timestamp_point>);
-static_assert(qdb_point<qdb_ts_blob_point>);
-static_assert(qdb_point<qdb_ts_string_point>);
-
-static_assert(not qdb_primitive<qdb_ts_double_point>);
-static_assert(not qdb_primitive<qdb_ts_int64_point>);
-static_assert(not qdb_primitive<qdb_ts_timestamp_point>);
-static_assert(not qdb_primitive<qdb_ts_blob_point>);
-static_assert(not qdb_primitive<qdb_ts_string_point>);
-
-////////////////////////////////////////////////////////////////////////////////
-//
-// Numpy / DType concepts
-//
-///////////////////
-
-template <typename Dtype>
-concept dtype = std::is_base_of_v<traits::dtype<Dtype::kind>, Dtype>
-
-                && std::is_enum_v<decltype(Dtype::kind)>
-
-    ;
-
-template <typename Dtype>
-concept fixed_width_dtype =
-    dtype<Dtype>
-
-    // Check base class
-    && std::is_base_of_v<traits::fixed_width_dtype<Dtype::kind, Dtype::size>, Dtype>;
-
-// Test dtypes against their size
-template <typename Dtype, py::ssize_t Size>
-concept dtype_of_width = fixed_width_dtype<Dtype> && Dtype::size == Size;
-
-// 64bit dtype
-template <typename Dtype>
-concept dtype64 = dtype_of_width<Dtype, 8>;
-
-// 32bit dtype
-template <typename Dtype>
-concept dtype32 = dtype_of_width<Dtype, 4>;
-
-// 16bit dtype
-template <typename Dtype>
-concept dtype16 = dtype_of_width<Dtype, 2>;
-
-// 8bit dtype
-template <typename Dtype>
-concept dtype8 = dtype_of_width<Dtype, 1>;
-
-template <typename Dtype>
-concept datetime64_dtype = fixed_width_dtype<Dtype>
-
-                           // Verify base class is datetime64_dtype
-                           && std::is_base_of_v<traits::datetime64_dtype<Dtype::precision>, Dtype>
-
-                           // datetime64 is always a 64bit object
-                           && dtype64<Dtype>
-
-                           // It needs to have a precision
-                           && std::is_enum_v<decltype(Dtype::precision)>;
-
-template <typename Dtype>
-concept variable_width_dtype =
-    dtype<Dtype>
-
-    // Verify base class
-    && std::is_base_of_v<
-        traits::variable_width_dtype<Dtype::kind, typename Dtype::stride_type, Dtype::code_point_size>,
-        Dtype>
-
-    // Verify we have a "stride_type", which is the type used to represent a single stride.
-    && Dtype::code_point_size == sizeof(typename Dtype::stride_type::value_type)
-
-    ;
-
-template <typename Dtype>
-concept object_dtype = dtype<Dtype>
-
-                       // Objects are always fixed width (64-bit pointers, effectively)
-                       && fixed_width_dtype<Dtype>
-
-                       // Verify base class
-                       && std::is_base_of_v<traits::object_dtype<typename Dtype::value_type>, Dtype>;
-
-// Trivial dtypes are useful for deciding whether you can use fast memcpy-based
-// conversions, e.g. when numpy's int64 has the exact same representation as
-// qdb_int_t.
-template <typename Dtype>
-concept trivial_dtype =
-    // Trivial dtypes are *always* fixed width
-    fixed_width_dtype<Dtype>
-
-    // The low-level numpy representation needs to be trivial; e.g. numpy represents
-    // something as int32.
-    && std::is_trivial<typename Dtype::value_type>::value
-
-    // Needs to have a quasardb representation of this type as well (e.g.
-    // dtype('int64') mapping to qdb_int_t
-    && std::is_trivial<typename Dtype::qdb_value>::value
-
-    // Sanity check: the trivial qdb_value needs to be a qdb_primitive -- if this fails,
-    // it hints at a misconfigured dtype specification.
-    && qdb_primitive<typename Dtype::qdb_value>
-
-    // Last but not least (and most important one): both the dtype's low level
-    // representation and quasardb's representation need to be equivalent.
-    && std::is_same_v<typename Dtype::value_type, typename Dtype::qdb_value>
-
-    ;
-
-template <typename Dtype>
-using delegate_from_type_t = typename Dtype::value_type;
-
-template <typename Dtype>
-using delegate_to_type_t = typename Dtype::delegate_type::value_type;
-
-template <typename Dtype>
-concept delegate_dtype =
-    // Delegates are always dtypes
-    dtype<Dtype>
-
-    // And delegates have a delegate that is also a proper dtype
-    && dtype<typename Dtype::delegate_type>
-
-    // And conversion between these types should be possible (nothrow could be
-    // left away, but that comes with certain performance disadvantages).
-    //
-    // Note that this only checks for <From, To>, e.g. if int32_t is a delegate
-    // to int64_t, it only checks whether int32_t is convertible to int64_t, not the
-    // other way around. This is intentional, because the other way around leads to
-    // loss of precision, and as such can be argued is *not* convertible, at the
-    // very least nothrow_convertible.
-    && std::is_nothrow_convertible_v<delegate_from_type_t<Dtype>, delegate_to_type_t<Dtype>>;
-
-////////////////////////////////////////////////////////////////////////////////
-//
-// Python API useful concepts, for e.g. batch writer
-//
-///////////////////
-
-template <typename T>
-concept duration = traits::is_chrono_duration<T>::value;
-
-template <typename T, typename Duration = T::duration_t>
-concept sleep_strategy =
-    // Should always be a valid chrono duration
-    duration<Duration>
-
-    // And have a sleep function that takes a duration, and returns void
-    && requires(T s, Duration duration_) {
-           {
-               s.sleep(duration_)
-           } -> std::same_as<void>;
-       };
-
-template <typename T>
-concept writer_push_strategy =
-    // Check that we can do a batch push invoke
-    requires(                                                     //
-        T t,                                                      //
-        qdb_handle_t handle,                                      //
-        qdb_exp_batch_options_t const * options,                  //
-        qdb_exp_batch_push_table_t const * tables,                //
-        qdb_exp_batch_push_table_schema_t const ** table_schemas, //
-        qdb_size_t table_count,                                   //
-        py::kwargs const & kwargs                                 //
-    ) {
-        {
-            t(handle, options, tables, table_schemas, table_count)
-        } -> std::same_as<qdb_error_t>;
-        {
-            T::from_kwargs(kwargs)
-        } -> std::same_as<T>;
-    };
-
-// Assertions
-static_assert(dtype<traits::unicode_dtype>);
-
-static_assert(variable_width_dtype<traits::unicode_dtype>);
-static_assert(fixed_width_dtype<traits::pyobject_dtype>);
-static_assert(datetime64_dtype<traits::datetime64_ns_dtype>);
-static_assert(not fixed_width_dtype<traits::unicode_dtype>);
-static_assert(not variable_width_dtype<traits::pyobject_dtype>);
-
-static_assert(not trivial_dtype<traits::datetime64_ns_dtype>);
-static_assert(not trivial_dtype<traits::pyobject_dtype>);
-static_assert(not trivial_dtype<traits::unicode_dtype>);
-static_assert(not trivial_dtype<traits::bytestring_dtype>);
-static_assert(trivial_dtype<traits::float64_dtype>);
-
-static_assert(dtype_of_width<traits::int64_dtype, 8>);
-static_assert(dtype_of_width<traits::int32_dtype, 4>);
-static_assert(dtype_of_width<traits::int16_dtype, 2>);
-
-static_assert(dtype64<traits::int64_dtype>);
-static_assert(dtype32<traits::int32_dtype>);
-static_assert(dtype16<traits::int16_dtype>);
-
-static_assert(fixed_width_dtype<traits::int64_dtype>);
-static_assert(fixed_width_dtype<traits::int32_dtype>);
-static_assert(fixed_width_dtype<traits::int16_dtype>);
-
-static_assert(trivial_dtype<traits::int64_dtype>);
-// Not trivial because they don't have a qdb-native representation, so
-// they're not trivial in the sense of how we should handle them.
-static_assert(not trivial_dtype<traits::int32_dtype>);
-static_assert(not trivial_dtype<traits::int16_dtype>);
-
-static_assert(not delegate_dtype<traits::int64_dtype>);
-static_assert(delegate_dtype<traits::int32_dtype>);
-
-static_assert(dtype_of_width<traits::float64_dtype, 8>);
-static_assert(dtype_of_width<traits::float32_dtype, 4>);
-
-static_assert(trivial_dtype<traits::float64_dtype>);
-// Not trivial because they don't have a qdb-native representation, so
-// they're not trivial in the sense of how we should handle them.
-static_assert(not trivial_dtype<traits::float32_dtype>);
-
-static_assert(fixed_width_dtype<traits::float64_dtype>);
-static_assert(fixed_width_dtype<traits::float32_dtype>);
-
-}; // namespace qdb::concepts

quasardb/continuous.cpp

@@ -1,199 +0,0 @@
-#include "continuous.hpp"
-#include <iostream>
-
-namespace qdb
-{
-
-query_continuous::query_continuous(qdb::handle_ptr h, const py::object & bools)
-    : _logger("quasardb.query_continuous")
-    , _handle{h}
-    , _callback{&query_continuous::continuous_callback}
-    , _cont_handle{nullptr}
-    , _parse_bools{bools}
-    , _previous_watermark{0}
-    , _watermark{0}
-    , _last_error{qdb_e_uninitialized}
-{}
-
-query_continuous::~query_continuous()
-{
-    stop();
-    release_results();
-}
-
-void query_continuous::run(qdb_query_continuous_mode_type_t mode,
-    std::chrono::milliseconds pace,
-    const std::string & query_string)
-{
-    qdb::qdb_throw_if_error(
-        *_handle, qdb_query_continuous(*_handle, query_string.c_str(), mode,
-                      static_cast<unsigned>(pace.count()), _callback, this, &_cont_handle));
-}
-
-void query_continuous::release_results()
-{
-    if (_results)
-    {
-        qdb_release(*_handle, _results);
-        _results = nullptr;
-    }
-}
-
-qdb_error_t query_continuous::copy_results(const qdb_query_result_t * res)
-{
-    // release whatever results we may be holding before, if we don't have any it does nothing
-    release_results();
-    if (!res) return qdb_e_ok;
-    return qdb_query_copy_results(*_handle, res, &_results);
-}
-
-int query_continuous::continuous_callback(void * p, qdb_error_t err, const qdb_query_result_t * res)
-{
-    auto pthis = static_cast<query_continuous *>(p);
-
-    try
-    {
-        std::unique_lock<std::mutex> lock{pthis->_results_mutex};
-
-        ++pthis->_watermark;
-
-        pthis->_last_error = err;
-        if (QDB_FAILURE(pthis->_last_error))
-        {
-            // signal the error, if processing end, we will get a qdb_e_interrupted which is handled
-            // in the results function
-            lock.unlock();
-            pthis->_results_cond.notify_all();
-            return 0;
-        }
-
-        // copy the results using the API convenience function
-        // there are two traps to avoid
-        // 1. we are within the context of a thread owned by the quasardb C API, calling Python
-        // functions could results in deadlocks
-        // 2. the results are valid only in the context of the callback, if we want to work on them
-        // outside we need to copy them
-        pthis->_last_error = pthis->copy_results(res);
-        if (QDB_FAILURE(pthis->_last_error))
-        {
-            pthis->release_results();
-        }
-    }
-    catch (std::system_error const & e)
-    {
-        // Nothing we can do really, this is most likely a "deadlock avoided" issue.
-        std::cerr << "Internal error: unexpected exception caught in continuous query callback: "
-                     "system_error: "
-                  << e.what() << std::endl;
-    }
-    catch (std::exception const & e)
-    {
-        // Nothing we can do really, this is most likely a "deadlock avoided" issue.
-        std::cerr << "Internal error: unexpected exception caught in continuous query callback: "
-                  << e.what() << std::endl;
-    }
-
-    pthis->_results_cond.notify_all();
-
-    return 0;
-}
-
-dict_query_result_t query_continuous::unsafe_results()
-{
-    // when we return from the condition variable we own the mutex
-    _previous_watermark.store(_watermark.load());
-
-    if (_last_error == qdb_e_interrupted) throw py::stop_iteration{};
-
-    // throw an error, user may decide to resume iteration
-    qdb::qdb_throw_if_error(*_handle, _last_error);
-
-    // safe and quick to call if _results is nullptr
-    auto res = convert_query_results(_results, _parse_bools);
-
-    release_results();
-
-    return res;
-}
-
-dict_query_result_t query_continuous::results()
-{
-    try
-    {
-        std::unique_lock<std::mutex> lock{_results_mutex};
-
-        // you need an additional mechanism to check if you need to do something with the results
-        // because condition variables can have spurious calls
-        while (_watermark == _previous_watermark)
-        {
-            // entering the condition variables releases the mutex
-            // the callback can update the values when needed
-            // every second we are going to check if the user didn't do CTRL-C
-            if (_results_cond.wait_for(lock, std::chrono::seconds{1}) == std::cv_status::timeout)
-            {
-                // if we don't do this, it will be impossible to interrupt the Python program while
-                // we wait for results
-                if (PyErr_CheckSignals() != 0)
-                {
-                    throw py::error_already_set();
-                }
-            }
-        }
-
-        return unsafe_results();
-    }
-    catch (std::system_error const & e)
-    {
-        _logger.warn("continuous query caught system error, e.what(): %s", e.what());
-        _logger.warn("continuous query caught system error, e.code(): %d", e.code());
-        return dict_query_result_t{};
-    }
-    catch (std::exception const & e)
-    {
-        _logger.warn(
-            "Internal error: unexpected exception caught while gathering results: %s", e.what());
-        return dict_query_result_t{};
-    }
-}
-
-// the difference with the call above is that we're returning immediately if there's no change
-dict_query_result_t query_continuous::probe_results()
-{
-    try
-    {
-        std::unique_lock<std::mutex> lock{_results_mutex};
-
-        // check if there's a new value
-        if (_watermark == _previous_watermark)
-        {
-            // nope return empty, don't wait, don't acquire the condition variable
-            return dict_query_result_t{};
-        }
-
-        // yes, return the value
-        return unsafe_results();
-    }
-    catch (std::system_error const & e)
-    {
-        _logger.warn("continuous query caught system error, e.what(): %s", e.what());
-        _logger.warn("continuous query caught system error, e.code(): %d", e.code());
-        return dict_query_result_t{};
-    }
-    catch (std::exception const & e)
-    {
-        _logger.warn(
-            "Internal error: unexpected exception caught while gathering results: %s", e.what());
-        return dict_query_result_t{};
-    }
-}
-
-void query_continuous::stop()
-{
-    if (_handle && _cont_handle)
-    {
-        qdb_release(*_handle, _cont_handle);
-        _cont_handle = nullptr;
-    }
-}
-
-} // namespace qdb

quasardb/continuous.hpp

@@ -1,109 +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 "query.hpp"
-#include <atomic>
-#include <condition_variable>
-#include <memory>
-
-namespace py = pybind11;
-
-namespace qdb
-{
-
-class query_continuous : public std::enable_shared_from_this<query_continuous>
-{
-public:
-    query_continuous(qdb::handle_ptr h, const py::object & bools);
-    query_continuous(const qdb::query_continuous & /*other*/) = delete;
-    ~query_continuous();
-
-    void run(qdb_query_continuous_mode_type_t mode,
-        std::chrono::milliseconds pace,
-        const std::string & query_string);
-
-private:
-    void release_results();
-    qdb_error_t copy_results(const qdb_query_result_t * res);
-    static int continuous_callback(void * p, qdb_error_t err, const qdb_query_result_t * res);
-
-private:
-    dict_query_result_t unsafe_results();
-
-public:
-    // returns the results (blocking)
-    dict_query_result_t results();
-    // returns the results (non-blocking), empty if no results available yet
-    // needed to be able to interface with other framework that can't wait for results to be available
-    // in that case you would poll probe_results(), the cost is low because it doesn't result in a
-    // remote call just acquiring the mutex and see if results have been updated
-    dict_query_result_t probe_results();
-    void stop();
-
-private:
-    qdb::logger _logger;
-
-    qdb::handle_ptr _handle;
-    qdb_query_cont_callback_t _callback;
-    qdb_query_cont_handle_t _cont_handle;
-
-    py::object _parse_bools;
-
-    mutable std::condition_variable _results_cond;
-    mutable std::mutex _results_mutex;
-    std::atomic<size_t> _previous_watermark;
-    std::atomic<size_t> _watermark;
-    qdb_error_t _last_error;
-
-    qdb_query_result_t * _results;
-};
-
-template <typename Module>
-static inline void register_continuous(Module & m)
-{
-    namespace py = pybind11;
-
-    py::class_<qdb::query_continuous, std::shared_ptr<qdb::query_continuous>>{m, "QueryContinuous"} //
-        .def(py::init<qdb::handle_ptr,
-            const py::object &>())                                   //
-        .def("run", &qdb::query_continuous::run)                     //
-        .def("results", &qdb::query_continuous::results)             //
-        .def("probe_results", &qdb::query_continuous::probe_results) //
-        .def("stop", &qdb::query_continuous::stop)                   //
-
-        // required interface to use query_continuous as an iterator
-        .def("__iter__", [](const std::shared_ptr<qdb::query_continuous> & cont) { return cont; }) //
-        .def("__next__", &qdb::query_continuous::results);                                         //
-}
-
-} // namespace qdb