quasardb 3.14.2.dev0__cp38-cp38-macosx_11_0_arm64.whl → 3.14.2.dev4__cp38-cp38-macosx_11_0_arm64.whl

quasardb/reader/ts_row.hpp

@@ -1,281 +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 "ts_value.hpp"
-#include <qdb/ts.h>
-#include <detail/ts_column.hpp>
-#include <pybind11/numpy.h>
-#include <pybind11/stl_bind.h>
-#include <numpy.hpp>
-
-namespace py = pybind11;
-
-namespace qdb
-{
-
-namespace reader
-{
-
-using ts_columns_t = std::vector<detail::column_info>;
-
-class ts_row
-{
-public:
-    // We need a default constructor to due being copied as part of an iterator.
-    ts_row() noexcept = default;
-
-    ts_row(handle_ptr handle, qdb_local_table_t local_table) noexcept
-        : _handle{handle}
-        , _local_table{local_table}
-    {}
-
-    bool operator==(const ts_row & rhs) const noexcept
-    {
-        auto tie = [](const auto & ts) { return std::tie(ts.tv_sec, ts.tv_nsec); };
-
-        // Since our row doesn't hold any intrinsic data itself and is merely
-        // an indirection to the data in the local table, it doesn't make a lot
-        // of sense to compare it with another other than comparing the timestamps
-        // and the local table references.
-        return (tie(_timestamp) == tie(rhs._timestamp)) && (_local_table == rhs._local_table);
-    }
-
-    numpy::datetime64 timestamp() const noexcept
-    {
-        return numpy::datetime64(_timestamp);
-    }
-
-    /**
-     * Not exposed through Python, but allows the read_row operation to write the underlying
-     * timestamp object directly.
-     */
-    qdb_timespec_t & mutable_timestamp() noexcept
-    {
-        return _timestamp;
-    }
-
-protected:
-    handle_ptr _handle{nullptr};
-    qdb_local_table_t _local_table{nullptr};
-    qdb_timespec_t _timestamp;
-};
-
-/**
- * Our 'fast' row is a pure, lazy list-type row that uses a column's offset for
- * constant-time access to the column values. E.g. row[0], row[1] which will return
- * a (short-lived) ts_value.
- */
-class ts_fast_row : public ts_row
-{
-public:
-    ts_fast_row() noexcept = default;
-
-    ts_fast_row(handle_ptr handle, qdb_local_table_t local_table, const ts_columns_t & columns) noexcept
-        : ts_row(handle, local_table)
-        , _columns(columns)
-    {}
-
-    std::vector<py::object> copy() const
-    {
-        int64_t size = _columns.size() + 1;
-        std::vector<py::object> res;
-        res.reserve(size);
-
-        for (auto index = 0; index < size; ++index)
-        {
-            // By first casting the value, we create a copy of the concrete type
-            // (e.g. the int64 or the blob) rather than the reference into the local
-            // table.
-            res.push_back(get_item(index));
-        }
-
-        return res;
-    }
-
-    py::object get_item(uint64_t index) const
-    {
-        if (index == 0)
-        {
-            // TODO(leon): we construct this object every time; should be without any heap
-            // allocations,but can we do without this?
-            return timestamp();
-        }
-        else
-        {
-            uint64_t col_index = index - 1;
-            if (col_index > _columns.size())
-            {
-                throw py::index_error();
-            }
-            return py::cast(ts_value(_handle, _local_table, col_index, _columns.at(col_index).type),
-                py::return_value_policy::move);
-        }
-    }
-
-    void set_item(int64_t /* index */, int64_t /* value */)
-    {
-        // not implemented
-    }
-
-    std::string repr() const
-    {
-        // This is inefficient because we first cast everything to Python objects, get the
-        // string representation and then cast back to c++ strings, but it's correct and
-        // effective, and it's used for debugging purposes only.
-        auto xs = copy();
-        std::string kvs =
-            std::accumulate(xs.cbegin(), xs.cend(), std::string(), [](std::string acc, auto x) {
-                std::string s = py::str(x);
-                return acc.empty() ? s : std::move(acc) + ", " + s;
-            });
-
-        return "[" + std::move(kvs) + "]";
-    }
-
-private:
-    ts_columns_t _columns;
-};
-
-/**
- * Our 'dict' row is a much slower, dict-based row type that provides very convenient
- * access to the columns by their name. It does, however,  index each and every row's
- * columns eagerly, and as such will exhibit much worse performance.
- */
-class ts_dict_row : public ts_row
-{
-public:
-    ts_dict_row() noexcept = default;
-
-    ts_dict_row(handle_ptr handle, qdb_local_table_t local_table, const ts_columns_t & columns)
-        : ts_row(handle, local_table)
-        , _indexed_columns(detail::index_columns(columns))
-    {
-        // We store '$timestamp' as a magic, uninitialized column. This column type
-        // is then recorgnized by get_item()
-        _indexed_columns.insert(detail::indexed_columns_t::value_type("$timestamp", {}));
-    }
-
-    ts_dict_row(const ts_dict_row & rhs) noexcept
-        : ts_row(rhs._handle, rhs._local_table)
-        , _indexed_columns(rhs._indexed_columns)
-    {}
-
-    std::map<std::string, py::object> copy() const
-    {
-        using map_type = std::map<std::string, py::object>;
-        map_type res;
-
-        for (const auto & c : _indexed_columns)
-        {
-            qdb_size_t index = c.second.index;
-
-            // By first casting the value, we create a copy of the concrete type
-            // (e.g. the int64 or the blob) rather than the reference into the local
-            // table.
-            if (c.second.type == qdb_ts_column_uninitialized)
-            {
-                // assert (i.first == "$timestamp")
-                res.insert(map_type::value_type(c.first, timestamp()));
-            }
-            else
-                res.insert(map_type::value_type(
-                    c.first, py::cast(ts_value(_handle, _local_table, index, c.second.type))));
-        }
-
-        return res;
-    }
-
-    py::object get_item(const std::string & alias) const
-    {
-        auto c = _indexed_columns.find(alias);
-        if (c == _indexed_columns.end())
-        {
-            throw pybind11::key_error();
-        }
-
-        const auto & indexed_column = c->second;
-        if (c->second.type == qdb_ts_column_uninitialized)
-        {
-            // assert(alias == "$timestamp")
-            return timestamp();
-        }
-        else
-        {
-            return py::cast(ts_value(_handle, _local_table, indexed_column.index, indexed_column.type),
-                py::return_value_policy::move);
-        }
-    }
-
-    void set_item(const std::string & /* alias */, const std::string & /* value */) const noexcept
-    {
-        // not implemented
-    }
-
-    std::string repr() const
-    {
-        // Same as ts_fast_row::repr, this is inefficient but it's ok
-        auto xs = copy();
-        std::string items =
-            std::accumulate(xs.cbegin(), xs.cend(), std::string(), [](std::string acc, const auto & x) {
-                std::string s = "'" + x.first + "': " + std::string(py::str(x.second));
-                return acc.empty() ? s : std::move(acc) + ", " + s;
-            });
-
-        return "{" + std::move(items) + "}";
-    }
-
-private:
-    detail::indexed_columns_t _indexed_columns;
-};
-
-template <typename Module>
-static inline void register_ts_row(Module & m)
-{
-    py::bind_vector<std::vector<py::object>>(m, "VectorObject");
-
-    py::class_<ts_fast_row>{m, "TimeSeriesReaderFastRow"}
-        .def("__repr__", &ts_fast_row::repr)
-        .def("__getitem__", &ts_fast_row::get_item, py::return_value_policy::move)
-        .def("__setitem__", &ts_fast_row::set_item)
-        .def("timestamp", &ts_fast_row::timestamp)
-        .def("copy", &ts_fast_row::copy);
-
-    py::class_<ts_dict_row>{m, "TimeSeriesReaderDictRow"}
-        .def("__repr__", &ts_dict_row::repr)
-        .def("__getitem__", &ts_dict_row::get_item, py::return_value_policy::move)
-        .def("__setitem__", &ts_dict_row::set_item)
-        .def("timestamp", &ts_dict_row::timestamp)
-        .def("copy", &ts_dict_row::copy);
-}
-
-} // namespace reader
-} // namespace qdb

quasardb/reader/ts_value.hpp

@@ -1,245 +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 "../numpy.hpp"
-#include <qdb/ts.h>
-#include <pybind11/numpy.h>
-#include <pybind11/stl_bind.h>
-
-namespace py = pybind11;
-
-namespace qdb
-{
-namespace reader
-{
-
-/**
- * Our value class points to a specific index in a local table, and provides
- * the necessary conversion functions. It does not hold any value of itself.
- */
-class ts_value
-{
-public:
-    ts_value() noexcept
-        : _logger("quasardb.reader.ts_value")
-        , _local_table{nullptr}
-        , _index{-1}
-        , _type{qdb_ts_column_uninitialized}
-    {}
-
-    ts_value(handle_ptr handle,
-        qdb_local_table_t local_table,
-        int64_t index,
-        qdb_ts_column_type_t type) noexcept
-        : _logger("quasardb.reader.ts_value")
-        , _handle(handle)
-        , _local_table{local_table}
-        , _index{index}
-        , _type{type}
-    {}
-
-    ts_value(const ts_value & rhs) noexcept
-        : _logger("quasardb.reader.ts_value")
-        , _handle(rhs._handle)
-        , _local_table{rhs._local_table}
-        , _index{rhs._index}
-        , _type{rhs._type}
-    {}
-
-    ts_value(ts_value && rhs) noexcept
-        : _logger("quasardb.reader.ts_value")
-        , _handle(rhs._handle)
-        , _local_table{rhs._local_table}
-        , _index{rhs._index}
-        , _type{rhs._type} {};
-
-    /**
-     * Coerce this value to a Python value, used by the automatic type caster
-     * defined at the bottom.
-     */
-    py::handle cast() const
-    {
-        switch (_type)
-        {
-        case qdb_ts_column_uninitialized:
-            break;
-
-        case qdb_ts_column_double:
-            return double_();
-        case qdb_ts_column_blob:
-            return blob();
-        case qdb_ts_column_symbol: //! *FALLTHROUGH*
-        case qdb_ts_column_string:
-            return string();
-        case qdb_ts_column_int64:
-            return int64();
-        case qdb_ts_column_timestamp:
-            return timestamp();
-        };
-
-        throw std::runtime_error(
-            "Unable to cast QuasarDB type to Python type, unrecognized type: " + std::to_string(_type));
-    }
-
-private:
-    py::handle int64() const
-    {
-        std::int64_t v;
-
-        auto res = qdb_ts_row_get_int64(_local_table, _index, &v);
-        if (res == qdb_e_element_not_found)
-        {
-            Py_RETURN_NONE;
-            // notreached
-        }
-
-        qdb::qdb_throw_if_error(*_handle, res);
-
-        return PyLong_FromLongLong(v);
-    }
-
-    py::handle blob() const
-    {
-        qdb::release_guard<const void *> v(_handle);
-        qdb_size_t l = 0;
-
-        auto res = qdb_ts_row_get_blob(_local_table, _index, v.ptr(), &l);
-        if (res == qdb_e_element_not_found)
-        {
-            Py_RETURN_NONE;
-            // notreached
-        }
-
-        qdb::qdb_throw_if_error(*_handle, res);
-        return PyByteArray_FromStringAndSize(
-            static_cast<const char *>(v.get()), static_cast<Py_ssize_t>(l));
-    }
-
-    py::handle string() const
-    {
-        qdb::release_guard<const char *> v(_handle);
-        qdb_size_t l = 0;
-
-        auto res = qdb_ts_row_get_string(_local_table, _index, v.ptr(), &l);
-        if (res == qdb_e_element_not_found)
-        {
-            Py_RETURN_NONE;
-            // notreached
-        }
-
-        qdb::qdb_throw_if_error(*_handle, res);
-        return PyUnicode_FromStringAndSize(v.get(), static_cast<Py_ssize_t>(l));
-    }
-
-    py::handle double_() const
-    {
-        double v = 0.0;
-        auto res = qdb_ts_row_get_double(_local_table, _index, &v);
-        if (res == qdb_e_element_not_found)
-        {
-            Py_RETURN_NONE;
-            // notreached
-        }
-
-        qdb::qdb_throw_if_error(*_handle, res);
-        return PyFloat_FromDouble(v);
-    }
-
-    py::handle timestamp() const
-    {
-        qdb_timespec_t v;
-        auto res = qdb_ts_row_get_timestamp(_local_table, _index, &v);
-        if (res == qdb_e_element_not_found)
-        {
-            Py_RETURN_NONE;
-            // notreached
-        }
-
-        qdb::qdb_throw_if_error(*_handle, res);
-        return qdb::numpy::datetime64(v);
-    }
-
-private:
-    qdb::logger _logger;
-    handle_ptr _handle;
-    qdb_local_table_t _local_table;
-    int64_t _index;
-    qdb_ts_column_type_t _type;
-};
-
-template <typename Module>
-static inline void register_ts_value(Module & m)
-{
-    py::class_<ts_value>{m, "TimeSeriesReaderValue"};
-}
-
-} // namespace reader
-} // namespace qdb
-
-namespace pybind11
-{
-namespace detail
-{
-
-/**
- * Implements custom type caster for our ts_value class, so that conversion
- * to and from native python types is completely transparent.
- */
-template <>
-struct type_caster<qdb::reader::ts_value>
-{
-public:
-    /**
-     * Note that this macro magically sets a member variable called 'value'.
-     */
-    PYBIND11_TYPE_CASTER(qdb::reader::ts_value, _("qdb::reader::ts_value"));
-
-    /**
-     * We do not support Python->C++
-     */
-    bool load(handle src, bool) const noexcept
-    {
-        return false;
-    }
-
-    /**
-     * C++->Python
-     */
-    static handle cast(qdb::reader::ts_value src, return_value_policy /* policy */, handle /* parent */)
-    {
-        return src.cast();
-    }
-};
-
-} // namespace detail
-} // namespace pybind11

quasardb/remove_cvref.hpp

@@ -1,31 +0,0 @@
-#pragma once
-
-#include <type_traits>
-
-namespace qdb
-{
-
-// TODO(C++20): Use std::remove_cvref after upgrading GCC to version 9+ (ARM builds use GCC 8.3).
-// #if (__cplusplus > 201703L) && defined(_LIBCPP_STD_VER) && (_LIBCPP_STD_VER > 17)
-// #define QDB_HAS_REMOVE_CVREF
-// #endif
-
-#ifdef QDB_HAS_REMOVE_CVREF
-
-using std::remove_cvref;
-using std::remove_cvref_t;
-
-#else
-
-template <class T>
-struct remove_cvref
-{
-    typedef std::remove_cv_t<std::remove_reference_t<T>> type;
-};
-
-template <class T>
-using remove_cvref_t = typename remove_cvref<T>::type;
-
-#endif
-
-} // namespace qdb