quasardb 3.14.2.dev1__cp311-cp311-win32.whl → 3.14.2.dev3__cp311-cp311-win32.whl

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/table_reader.hpp

@@ -1,220 +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 "numpy.hpp"
-#include <qdb/ts.h>
-#include "detail/ts_column.hpp"
-#include "reader/ts_row.hpp"
-#include <pybind11/numpy.h>
-#include <pybind11/stl_bind.h>
-
-namespace py = pybind11;
-
-namespace qdb
-{
-
-using ts_columns_t = std::vector<detail::column_info>;
-
-template <typename RowType>
-class table_reader_iterator;
-
-template <typename RowType>
-bool operator==(
-    const table_reader_iterator<RowType> & lhs, const table_reader_iterator<RowType> & rhs) noexcept;
-
-template <typename RowType>
-class table_reader_iterator
-{
-public:
-    using value_type = RowType;
-    using reference  = const value_type &;
-
-    friend bool operator==<RowType>(
-        const table_reader_iterator<RowType> &, const table_reader_iterator<RowType> &) noexcept;
-
-public:
-    table_reader_iterator()
-        : _handle{nullptr}
-        , _local_table{nullptr}
-        , _the_row{_handle, _local_table, _columns}
-    {}
-
-    table_reader_iterator(handle_ptr h, qdb_local_table_t local_table, const ts_columns_t & columns)
-        : _handle{h}
-        , _local_table{local_table}
-        , _columns{columns}
-        , _the_row{_handle, _local_table, _columns}
-    {
-        // Immediately try to move to the first row
-        ++(*this);
-    }
-
-    bool operator!=(const table_reader_iterator & rhs) const noexcept
-    {
-        return !(*this == rhs);
-    }
-
-    reference operator*() const noexcept
-    {
-        return _the_row;
-    }
-
-    table_reader_iterator & operator++()
-    {
-        _handle->check_open();
-
-        qdb_error_t err = qdb_ts_table_next_row(_local_table, &_the_row.mutable_timestamp());
-
-        if (err == qdb_e_iterator_end)
-        {
-            // As seen in the default constructor and operator==, an empty _local_table
-            // designates an end-iterator.
-            _local_table = nullptr;
-        }
-        else
-        {
-            qdb::qdb_throw_if_error(*_handle, err);
-        }
-
-        return *this;
-    }
-
-private:
-    handle_ptr _handle;
-    qdb_local_table_t _local_table;
-    ts_columns_t _columns;
-    value_type _the_row;
-};
-
-template <typename RowType>
-bool operator==(
-    const table_reader_iterator<RowType> & lhs, const table_reader_iterator<RowType> & rhs) noexcept
-{
-    // Our .end() iterator is recognized by a null local table, and we'll
-    // ignore the actual row object.
-    if (lhs._local_table == nullptr || rhs._local_table == nullptr)
-    {
-        return lhs._local_table == rhs._local_table;
-    }
-    else
-    {
-        return lhs._local_table == rhs._local_table && lhs._the_row == rhs._the_row;
-    }
-}
-
-template <typename RowType>
-class table_reader
-{
-public:
-    using iterator = table_reader_iterator<RowType>;
-
-public:
-    table_reader(qdb::handle_ptr h,
-        const std::string & t,
-        const ts_columns_t & c,
-        const std::vector<qdb_ts_range_t> & r)
-        : _handle{h}
-        , _columns{c}
-        , _local_table{nullptr}
-    {
-        _handle->check_open();
-
-        auto c_columns = convert_columns(c);
-
-        qdb::qdb_throw_if_error(*_handle, qdb_ts_local_table_init(*_handle, t.c_str(), c_columns.data(),
-                                              c_columns.size(), &_local_table));
-
-        qdb::qdb_throw_if_error(*_handle, qdb_ts_table_stream_ranges(_local_table, r.data(), r.size()));
-    }
-
-    // since our reader models a stateful generator, we prevent copies
-    table_reader(const table_reader &) = delete;
-
-    // since our reader models a stateful generator, we prevent moves
-    table_reader(table_reader && rhs)
-        : _handle(rhs._handle)
-        , _columns(rhs._columns)
-        , _local_table(rhs._local_table)
-    {
-        rhs._handle      = nullptr;
-        rhs._local_table = nullptr;
-        rhs._columns.clear();
-    }
-
-    ~table_reader()
-    {
-        if (_handle && _local_table)
-        {
-            qdb_release(*_handle, _local_table);
-            _local_table = nullptr;
-        }
-    }
-
-    constexpr iterator begin() const
-    {
-        return iterator(_handle, _local_table, _columns);
-    }
-
-    constexpr iterator end() const
-    {
-        return iterator();
-    }
-
-private:
-    qdb::handle_ptr _handle;
-    ts_columns_t _columns;
-    qdb_local_table_t _local_table;
-};
-
-template <typename Module>
-static inline void register_table_reader(Module & m)
-{
-    py::class_<qdb::table_reader<reader::ts_fast_row>>{m, "TimeSeriesFastReader"}
-        .def(py::init<qdb::handle_ptr, const std::string &, const ts_columns_t &,
-            const std::vector<qdb_ts_range_t> &>())
-
-        .def(
-            "__iter__",
-            [](table_reader<reader::ts_fast_row> & r) { return py::make_iterator(r.begin(), r.end()); },
-            py::keep_alive<0, 1>());
-
-    py::class_<qdb::table_reader<reader::ts_dict_row>>{m, "TimeSeriesDictReader"}
-        .def(py::init<qdb::handle_ptr, const std::string &, const ts_columns_t &,
-            const std::vector<qdb_ts_range_t> &>())
-
-        .def(
-            "__iter__",
-            [](table_reader<reader::ts_dict_row> & r) { return py::make_iterator(r.begin(), r.end()); },
-            py::keep_alive<0, 1>());
-}
-
-} // namespace qdb