quasardb 3.14.2.dev0__cp311-cp311-macosx_11_0_arm64.whl → 3.14.2.dev4__cp311-cp311-macosx_11_0_arm64.whl

quasardb/table.hpp

@@ -1,325 +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 "masked_array.hpp"
-#include "detail/ts_column.hpp"
-
-namespace qdb
-{
-
-class table : public entry
-{
-public:
-    table(handle_ptr h, std::string a)
-        : entry{h, a}
-        , _has_indexed_columns(false)
-    {
-        _cache_metadata();
-    }
-
-public:
-    std::string repr() const
-    {
-        return "<quasardb.Table name='" + get_name() + "'>";
-    }
-
-    /**
-     * Retrieves (and caches) table metadata. This mainly involves column information.
-     */
-    void retrieve_metadata()
-    {
-        _cache_metadata();
-    }
-
-    void create(const std::vector<detail::column_info> & columns,
-        std::chrono::milliseconds shard_size = std::chrono::hours{24},
-        std::chrono::milliseconds ttl        = std::chrono::milliseconds::zero())
-    {
-        _handle->check_open();
-
-        qdb_duration_t ttl_ = qdb_ttl_disabled;
-        if (ttl != std::chrono::milliseconds::zero())
-        {
-            ttl_ = ttl.count();
-        }
-
-        const auto c_columns = detail::convert_columns_ex(columns);
-        qdb::qdb_throw_if_error(*_handle, qdb_ts_create_ex(*_handle, _alias.c_str(), shard_size.count(),
-                                              c_columns.data(), c_columns.size(), ttl_));
-    }
-
-    void insert_columns(const std::vector<detail::column_info> & columns)
-    {
-        _handle->check_open();
-
-        const auto c_columns = detail::convert_columns_ex(columns);
-        qdb::qdb_throw_if_error(*_handle,
-            qdb_ts_insert_columns_ex(*_handle, _alias.c_str(), c_columns.data(), c_columns.size()));
-    }
-
-    std::vector<detail::column_info> list_columns() const
-    {
-        if (_columns.has_value()) [[likely]]
-        {
-            return _columns.value();
-        }
-
-        _cache_metadata();
-
-        if (_columns.has_value()) [[likely]]
-        {
-            return _columns.value();
-        }
-
-        throw qdb::alias_not_found_exception{};
-    }
-
-    detail::indexed_column_info column_info_by_id(const std::string & alias) const
-    {
-        if (_has_indexed_columns == false)
-        {
-            // It's important to note that if additional columns are added during
-            // the lifetime of this object, we will not pick up on this in our cache.
-            _indexed_columns     = detail::index_columns(list_columns());
-            _has_indexed_columns = true;
-        }
-
-        detail::indexed_columns_t::const_iterator i = _indexed_columns.find(alias);
-        if (i == _indexed_columns.end())
-            throw qdb::exception{qdb_e_out_of_bounds, std::string("Column not found: ") + alias};
-
-        return i->second;
-    }
-
-    detail::column_info column_info_by_index(qdb_size_t idx) const
-    {
-        auto cols = list_columns();
-
-        // Not strictly necessary, but avoids an "ugly" exception being thrown when
-        // using .at() below.
-        if (cols.size() <= idx) [[unlikely]]
-        {
-            throw qdb::exception{
-                qdb_e_out_of_bounds, std::string("Column index out of bounds: ") + std::to_string(idx)};
-        }
-
-        return cols.at(idx);
-    }
-
-    std::string column_id_by_index(qdb_size_t idx) const
-    {
-        return column_info_by_index(idx).name;
-    }
-
-    qdb_ts_column_type_t column_type_by_index(qdb_size_t idx) const
-    {
-        return column_info_by_index(idx).type;
-    }
-
-    qdb_size_t column_index_by_id(const std::string & alias) const
-    {
-        return column_info_by_id(alias).index;
-    }
-
-    qdb_ts_column_type_t column_type_by_id(const std::string & alias) const
-    {
-        return column_info_by_id(alias).type;
-    }
-
-    py::object reader(
-        const std::vector<std::string> & columns, py::object obj_ranges, bool dict_mode) const;
-
-    /**
-     * Returns true if this table has a TTL assigned.
-     */
-    inline bool has_ttl() const
-    {
-        if (_ttl.has_value()) [[likely]]
-        {
-            return _ttl.value() != std::chrono::milliseconds::zero();
-        }
-
-        _cache_metadata();
-
-        if (_ttl.has_value()) [[likely]]
-        {
-            return _ttl.value() != std::chrono::milliseconds::zero();
-        }
-
-        throw qdb::alias_not_found_exception{};
-    }
-
-    inline std::chrono::milliseconds get_ttl() const
-    {
-        if (_ttl.has_value()) [[likely]]
-        {
-            return _ttl.value();
-        }
-
-        _cache_metadata();
-
-        if (_ttl.has_value()) [[likely]]
-        {
-            return _ttl.value();
-        }
-
-        throw qdb::alias_not_found_exception{};
-    }
-
-private:
-    /**
-     * Loads column info / metadata from server and caches it locally.
-     */
-    void _cache_metadata() const;
-
-    /**
-     * Loads column info / metadata from server if not yet cached locally.
-     */
-    void _maybe_cache_metadata() const
-    {
-        if (_columns.has_value() == false) [[unlikely]]
-        {
-            // We expect _ttl and _columns to have the same state
-            assert(_ttl.has_value() == false);
-            _cache_metadata();
-        }
-    }
-
-public:
-    qdb_uint_t erase_ranges(const std::string & column, py::object ranges);
-
-public:
-    void blob_insert(const std::string & column,
-        const pybind11::array & timestamps,
-        const qdb::masked_array & values);
-    void string_insert(const std::string & column,
-        const pybind11::array & timestamps,
-        qdb::masked_array const & values);
-    void double_insert(const std::string & column,
-        const pybind11::array & timestamps,
-        qdb::masked_array const & values);
-    void int64_insert(const std::string & column,
-        const pybind11::array & timestamps,
-        qdb::masked_array const & values);
-    void timestamp_insert(const std::string & column,
-        const pybind11::array & timestamps,
-        const qdb::masked_array & values);
-
-public:
-    std::pair<pybind11::array, masked_array> blob_get_ranges(
-        const std::string & column, py::object ranges);
-
-    std::pair<pybind11::array, masked_array> string_get_ranges(
-        const std::string & column, py::object ranges);
-
-    std::pair<pybind11::array, masked_array> double_get_ranges(
-        const std::string & column, py::object ranges);
-
-    std::pair<pybind11::array, masked_array> int64_get_ranges(
-        const std::string & column, py::object ranges);
-
-    std::pair<pybind11::array, masked_array> timestamp_get_ranges(
-        const std::string & column, py::object ranges);
-
-    py::object subscribe(py::object conn)
-    {
-        auto firehose = py::module::import("quasardb.firehose");
-        auto xs       = firehose.attr("subscribe")(conn, get_name());
-        return xs;
-    }
-
-private:
-    mutable bool _has_indexed_columns;
-    mutable detail::indexed_columns_t _indexed_columns;
-
-    mutable std::optional<std::vector<detail::column_info>> _columns;
-    mutable std::optional<std::chrono::milliseconds> _ttl;
-};
-
-template <typename Module>
-static inline void register_table(Module & m)
-{
-    namespace py = pybind11;
-
-    py::enum_<qdb_ts_column_type_t>{m, "ColumnType", py::arithmetic(), "Column type"} //
-        .value("Uninitialized", qdb_ts_column_uninitialized)                          //
-        .value("Double", qdb_ts_column_double)                                        //
-        .value("Blob", qdb_ts_column_blob)                                            //
-        .value("String", qdb_ts_column_string)                                        //
-        .value("Symbol", qdb_ts_column_symbol)                                        //
-        .value("Int64", qdb_ts_column_int64)                                          //
-        .value("Timestamp", qdb_ts_column_timestamp);                                 //
-
-    py::class_<qdb::table, qdb::entry>{m, "Table", "Table representation"} //
-        .def(py::init<qdb::handle_ptr, std::string>())                     //
-        .def("__repr__", &qdb::table::repr)                                //
-        .def("create", &qdb::table::create, py::arg("columns"),            //
-            py::arg("shard_size") = std::chrono::hours{24},                //
-            py::arg("ttl")        = std::chrono::milliseconds::zero())            //
-        .def("get_name", &qdb::table::get_name)                            //
-        .def("retrieve_metadata", &qdb::table::retrieve_metadata)          //
-        .def("column_index_by_id", &qdb::table::column_index_by_id)        //
-        .def("column_type_by_id", &qdb::table::column_type_by_id)          //
-        .def("column_info_by_index", &qdb::table::column_info_by_index)    //
-        .def("column_type_by_index", &qdb::table::column_type_by_index)    //
-        .def("column_id_by_index", &qdb::table::column_id_by_index)        //
-        .def("insert_columns", &qdb::table::insert_columns)                //
-        .def("list_columns", &qdb::table::list_columns)                    //
-        .def("has_ttl", &qdb::table::has_ttl)                              //
-        .def("get_ttl", &qdb::table::get_ttl)                              //
-
-        // We cannot initialize columns with all columns by default, because i don't
-        // see a way to figure out the `this` address for qdb_ts_reader for the default
-        // arguments, and we need it to call qdb::table::list_columns().
-        .def("reader", &qdb::table::reader, py::arg("columns") = std::vector<std::string>(),
-            py::arg("ranges") = py::none{}, py::arg("dict") = false)
-        .def("subscribe", &qdb::table::subscribe)               //
-        .def("erase_ranges", &qdb::table::erase_ranges)         //
-        .def("blob_insert", &qdb::table::blob_insert)           //
-        .def("string_insert", &qdb::table::string_insert)       //
-        .def("double_insert", &qdb::table::double_insert)       //
-        .def("int64_insert", &qdb::table::int64_insert)         //
-        .def("timestamp_insert", &qdb::table::timestamp_insert) //
-        .def("blob_get_ranges", &qdb::table::blob_get_ranges, py::arg("column"),
-            py::arg("ranges") = py::none{}) //
-        .def("string_get_ranges", &qdb::table::string_get_ranges, py::arg("column"),
-            py::arg("ranges") = py::none{}) //
-        .def("double_get_ranges", &qdb::table::double_get_ranges, py::arg("column"),
-            py::arg("ranges") = py::none{}) //
-        .def("int64_get_ranges", &qdb::table::int64_get_ranges, py::arg("column"),
-            py::arg("ranges") = py::none{}) //
-        .def("timestamp_get_ranges", &qdb::table::timestamp_get_ranges, py::arg("column"),
-            py::arg("ranges") = py::none{}); //
-}
-
-} // namespace qdb

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

quasardb/tag.hpp

@@ -1,77 +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"
-
-namespace qdb
-{
-
-class tag : public entry
-{
-public:
-    tag(qdb::handle_ptr h, const std::string & alias)
-        : entry{h, alias}
-    {}
-
-public:
-    std::vector<std::string> get_entries()
-    {
-        const char ** aliases = nullptr;
-        size_t count          = 0;
-
-        qdb::qdb_throw_if_error(*_handle, qdb_get_tagged(*_handle, _alias.c_str(), &aliases, &count));
-
-        return convert_strings_and_release(_handle, aliases, count);
-    }
-
-    qdb_uint_t count()
-    {
-        qdb_uint_t count = 0;
-
-        qdb::qdb_throw_if_error(*_handle, qdb_get_tagged_count(*_handle, _alias.c_str(), &count));
-
-        return count;
-    }
-};
-
-template <typename Module>
-static inline void register_tag(Module & m)
-{
-    namespace py = pybind11;
-
-    py::class_<qdb::tag, qdb::entry>(m, "Tag")         //
-        .def(py::init<qdb::handle_ptr, std::string>()) //
-        .def("get_entries", &qdb::tag::get_entries)    //
-        .def("count", &qdb::tag::count);               //
-}
-
-} // namespace qdb