quasardb 3.14.2.dev1__cp310-cp310-macosx_11_0_arm64.whl → 3.14.2.dev4__cp310-cp310-macosx_11_0_arm64.whl

quasardb/string.hpp

@@ -1,160 +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/string.h>
-#include "convert/value.hpp"
-
-namespace qdb
-{
-namespace py = pybind11;
-
-class string_entry : public expirable_entry
-{
-public:
-    string_entry(handle_ptr h, std::string a) noexcept
-        : expirable_entry{h, a}
-    {}
-
-private:
-    py::str convert_and_release_content(const char * content, qdb_size_t content_length)
-    {
-        return convert_and_release_content(qdb_string_t{content, content_length});
-    }
-
-    py::str convert_and_release_content(qdb_string_t x)
-    {
-        if (x.data == nullptr || x.length == 0)
-        {
-            return py::str{};
-        }
-
-        py::str ret = qdb::convert::value<qdb_string_t, py::str>(x);
-
-        qdb_release(*_handle, x.data);
-        return ret;
-    }
-
-public:
-    py::str get()
-    {
-        const char * content      = nullptr;
-        qdb_size_t content_length = 0;
-
-        qdb::qdb_throw_if_error(
-            *_handle, qdb_string_get(*_handle, _alias.c_str(), &content, &content_length));
-
-        return convert_and_release_content(content, content_length);
-    }
-
-    void put(const std::string & data)
-    {
-        qdb::qdb_throw_if_error(*_handle,
-            qdb_string_put(*_handle, _alias.c_str(), data.data(), data.size(), qdb_time_t{0}));
-    }
-
-    void update(const std::string & data,
-        std::chrono::system_clock::time_point expiry = std::chrono::system_clock::time_point{})
-    {
-        qdb::qdb_throw_if_error(*_handle,
-            qdb_string_update(*_handle, _alias.c_str(), data.data(), data.size(), qdb_time_t{0}));
-    }
-
-    void remove_if(const std::string & comparand)
-    {
-        qdb::qdb_throw_if_error(*_handle,
-            qdb_string_remove_if(*_handle, _alias.c_str(), comparand.data(), comparand.size()));
-    }
-
-    py::str get_and_remove()
-    {
-        const char * content      = nullptr;
-        qdb_size_t content_length = 0;
-
-        qdb::qdb_throw_if_error(
-            *_handle, qdb_string_get_and_remove(*_handle, _alias.c_str(), &content, &content_length));
-
-        return convert_and_release_content(content, content_length);
-    }
-
-    py::str get_and_update(const std::string & data)
-    {
-        const char * content      = nullptr;
-        qdb_size_t content_length = 0;
-
-        qdb::qdb_throw_if_error(
-            *_handle, qdb_string_get_and_update(*_handle, _alias.c_str(), data.data(), data.size(),
-                          qdb_time_t{0}, &content, &content_length));
-
-        return convert_and_release_content(content, content_length);
-    }
-
-    py::str compare_and_swap(const std::string & new_value, const std::string & comparand)
-    {
-        const char * content      = nullptr;
-        qdb_size_t content_length = 0;
-
-        qdb_error_t err =
-            qdb_string_compare_and_swap(*_handle, _alias.c_str(), new_value.data(), new_value.size(),
-                comparand.data(), comparand.size(), qdb_time_t{0}, &content, &content_length);
-
-        // we don't want to throw on "unmatching content", so we don't use the qdb::qdb_throw_if_error
-        // function
-        if (QDB_FAILURE(err))
-        {
-            qdb_throw_if_error(*_handle, err);
-        }
-
-        return convert_and_release_content(content, content_length);
-    }
-};
-
-template <typename Module>
-static inline void register_string(Module & m)
-{
-    namespace py = pybind11;
-
-    py::class_<qdb::string_entry, qdb::expirable_entry>(m, "String") //
-        .def(py::init<qdb::handle_ptr, std::string>())               //
-        .def("get", &qdb::string_entry::get)                         //
-        .def("put", &qdb::string_entry::put, py::arg("data"))        //
-        .def("update", &qdb::string_entry::update, py::arg("data"),
-            py::arg("expiry") = std::chrono::system_clock::time_point{})       //
-        .def("remove_if", &qdb::string_entry::remove_if, py::arg("comparand")) //
-        .def("get_and_remove", &qdb::string_entry::get_and_remove)             //
-        .def("get_and_update", &qdb::string_entry::get_and_update,             //
-            py::arg("data"))                                                   //
-        .def("compare_and_swap", &qdb::string_entry::compare_and_swap,         //
-            py::arg("new_content"), py::arg("comparand"));                     //
-}
-
-} // namespace qdb

quasardb/table.cpp

@@ -1,289 +0,0 @@
-#include "table.hpp"
-#include "dispatch.hpp"
-#include "metrics.hpp"
-#include "object_tracker.hpp"
-#include "table_reader.hpp"
-#include "traits.hpp"
-#include "convert/point.hpp"
-
-namespace qdb
-{
-
-namespace py = pybind11;
-
-namespace detail
-{
-
-template <typename Type>
-using point_type = typename traits::qdb_value<Type>::point_type;
-
-template <qdb_ts_column_type_t, concepts::dtype DType>
-struct column_inserter;
-
-#define COLUMN_INSERTER_DECL(CTYPE, DTYPE, VALUE_TYPE, FN)                                  \
-    template <>                                                                             \
-    struct column_inserter<CTYPE, DTYPE>                                                    \
-    {                                                                                       \
-        inline void operator()(handle_ptr handle,                                           \
-            std::string const & table,                                                      \
-            std::string const & column,                                                     \
-            pybind11::array const & timestamps,                                             \
-            qdb::masked_array const & values)                                               \
-        {                                                                                   \
-            handle->check_open();                                                           \
-                                                                                            \
-            qdb::object_tracker::scoped_repository ctx{};                                   \
-            qdb::object_tracker::scoped_capture capture{ctx};                               \
-            numpy::array::ensure<traits::datetime64_ns_dtype>(timestamps);                  \
-            auto xs = convert::point_array<DTYPE, VALUE_TYPE>(timestamps, values);          \
-                                                                                            \
-            qdb::qdb_throw_if_error(                                                        \
-                *handle, FN(*handle, table.c_str(), column.c_str(), xs.data(), xs.size())); \
-        };                                                                                  \
-    };
-
-COLUMN_INSERTER_DECL(qdb_ts_column_int64, traits::int64_dtype, qdb_int_t, qdb_ts_int64_insert);
-COLUMN_INSERTER_DECL(qdb_ts_column_int64, traits::int32_dtype, qdb_int_t, qdb_ts_int64_insert);
-COLUMN_INSERTER_DECL(qdb_ts_column_int64, traits::int16_dtype, qdb_int_t, qdb_ts_int64_insert);
-COLUMN_INSERTER_DECL(qdb_ts_column_double, traits::float64_dtype, double, qdb_ts_double_insert);
-COLUMN_INSERTER_DECL(qdb_ts_column_double, traits::float32_dtype, double, qdb_ts_double_insert);
-
-COLUMN_INSERTER_DECL(
-    qdb_ts_column_timestamp, traits::datetime64_ns_dtype, qdb_timespec_t, qdb_ts_timestamp_insert);
-COLUMN_INSERTER_DECL(qdb_ts_column_string, traits::unicode_dtype, qdb_string_t, qdb_ts_string_insert);
-COLUMN_INSERTER_DECL(qdb_ts_column_blob, traits::pyobject_dtype, qdb_blob_t, qdb_ts_blob_insert);
-COLUMN_INSERTER_DECL(qdb_ts_column_blob, traits::bytestring_dtype, qdb_blob_t, qdb_ts_blob_insert);
-
-#undef COLUMN_INSERTER_DECL
-
-template <qdb_ts_column_type_t ColumnType>
-inline void insert_column_dispatch(handle_ptr handle,
-    std::string const & table,
-    std::string const & column,
-    pybind11::array const & timestamps,
-    qdb::masked_array const & values)
-{
-    dispatch::by_dtype<column_inserter, ColumnType>(
-        values.dtype(), handle, table, column, timestamps, values);
-};
-
-}; // namespace detail
-
-void table::_cache_metadata() const
-{
-    _handle->check_open();
-
-    detail::qdb_resource<qdb_ts_metadata_t> metadata{*_handle};
-
-    qdb_error_t err;
-
-    {
-        metrics::scoped_capture("qdb_ts_get_metadata");
-        err = qdb_ts_get_metadata(*_handle, _alias.c_str(), &metadata);
-    }
-
-    if (err == qdb_e_alias_not_found) [[unlikely]]
-    {
-        // Can happen if table does not yet exist, do nothing.
-        return;
-    }
-
-    qdb::qdb_throw_if_error(*_handle, err);
-
-    _columns = detail::convert_columns(metadata->columns, metadata->column_count);
-
-    if (metadata->ttl == qdb_ttl_disabled)
-    {
-        _ttl = std::chrono::milliseconds{0};
-    }
-    else
-    {
-        _ttl = std::chrono::milliseconds{metadata->ttl};
-    }
-}
-
-py::object table::reader(
-    const std::vector<std::string> & columns, py::object ranges, bool dict_mode) const
-{
-    _handle->check_open();
-
-    auto ranges_ = qdb::convert_ranges(ranges);
-
-    std::vector<detail::column_info> c_columns;
-
-    if (columns.empty())
-    {
-        // This is a kludge, because technically a table can have no columns, and we're
-        // abusing it as "no argument provided". It's a highly exceptional use case, and
-        // doesn't really have any implication in practice (we just look up twice), so it
-        // should be ok.
-        c_columns = list_columns();
-    }
-    else
-    {
-        c_columns.reserve(columns.size());
-        // This transformation can probably be optimized, but it's only invoked when constructing
-        // the reader so it's unlikely to be a performance bottleneck.
-        std::transform(std::cbegin(columns), std::cend(columns), std::back_inserter(c_columns),
-            [this](const auto & col) {
-                const auto & info = column_info_by_id(col);
-                return detail::column_info{info.type, col, info.symtable};
-            });
-    }
-
-    return (dict_mode == true
-                ? py::cast(qdb::table_reader<reader::ts_dict_row>(_handle, _alias, c_columns, ranges_),
-                    py::return_value_policy::move)
-                : py::cast(qdb::table_reader<reader::ts_fast_row>(_handle, _alias, c_columns, ranges_),
-                    py::return_value_policy::move));
-}
-
-qdb_uint_t table::erase_ranges(const std::string & column, py::object ranges)
-{
-    _handle->check_open();
-
-    auto ranges_ = qdb::convert_ranges(ranges);
-
-    qdb_uint_t erased_count = 0;
-
-    qdb::qdb_throw_if_error(*_handle, qdb_ts_erase_ranges(*_handle, _alias.c_str(), column.c_str(),
-                                          ranges_.data(), ranges_.size(), &erased_count));
-
-    return erased_count;
-}
-
-// insert_ranges
-void table::blob_insert(
-    const std::string & column, const pybind11::array & timestamps, const qdb::masked_array & values)
-{
-    detail::insert_column_dispatch<qdb_ts_column_blob>(_handle, _alias, column, timestamps, values);
-}
-
-void table::string_insert(
-    const std::string & column, const pybind11::array & timestamps, qdb::masked_array const & values)
-{
-    detail::insert_column_dispatch<qdb_ts_column_string>(_handle, _alias, column, timestamps, values);
-}
-
-void table::double_insert(
-    const std::string & column, const pybind11::array & timestamps, qdb::masked_array const & values)
-{
-    detail::insert_column_dispatch<qdb_ts_column_double>(_handle, _alias, column, timestamps, values);
-}
-
-void table::int64_insert(
-    const std::string & column, const pybind11::array & timestamps, qdb::masked_array const & values)
-{
-    detail::insert_column_dispatch<qdb_ts_column_int64>(_handle, _alias, column, timestamps, values);
-}
-
-void table::timestamp_insert(
-    const std::string & column, const pybind11::array & timestamps, const qdb::masked_array & values)
-{
-    detail::insert_column_dispatch<qdb_ts_column_timestamp>(
-        _handle, _alias, column, timestamps, values);
-}
-
-// get_ranges
-
-std::pair<pybind11::array, masked_array> table::blob_get_ranges(
-    const std::string & column, py::object ranges)
-{
-    _handle->check_open();
-
-    qdb_ts_blob_point * points = nullptr;
-    qdb_size_t count           = 0;
-
-    auto ranges_ = qdb::convert_ranges(ranges);
-
-    qdb::qdb_throw_if_error(*_handle, qdb_ts_blob_get_ranges(*_handle, _alias.c_str(), column.c_str(),
-                                          ranges_.data(), ranges_.size(), &points, &count));
-
-    auto ret = convert::point_array<qdb_blob_t, traits::pyobject_dtype>(points, count);
-
-    qdb_release(*_handle, points);
-
-    return ret;
-}
-
-std::pair<pybind11::array, masked_array> table::string_get_ranges(
-    const std::string & column, py::object ranges)
-{
-    _handle->check_open();
-
-    qdb_ts_string_point * points = nullptr;
-    qdb_size_t count             = 0;
-
-    auto ranges_ = qdb::convert_ranges(ranges);
-
-    qdb::qdb_throw_if_error(*_handle, qdb_ts_string_get_ranges(*_handle, _alias.c_str(), column.c_str(),
-                                          ranges_.data(), ranges_.size(), &points, &count));
-
-    auto ret = convert::point_array<qdb_string_t, traits::unicode_dtype>(points, count);
-
-    qdb_release(*_handle, points);
-
-    return ret;
-}
-
-std::pair<pybind11::array, masked_array> table::double_get_ranges(
-    const std::string & column, py::object ranges)
-{
-    _handle->check_open();
-
-    qdb_ts_double_point * points = nullptr;
-    qdb_size_t count             = 0;
-
-    auto ranges_ = qdb::convert_ranges(ranges);
-
-    qdb::qdb_throw_if_error(*_handle, qdb_ts_double_get_ranges(*_handle, _alias.c_str(), column.c_str(),
-                                          ranges_.data(), ranges_.size(), &points, &count));
-
-    auto ret = convert::point_array<double, traits::float64_dtype>(points, count);
-
-    qdb_release(*_handle, points);
-
-    return ret;
-}
-
-std::pair<pybind11::array, masked_array> table::int64_get_ranges(
-    const std::string & column, py::object ranges)
-{
-    _handle->check_open();
-
-    qdb_ts_int64_point * points = nullptr;
-    qdb_size_t count            = 0;
-
-    auto ranges_ = qdb::convert_ranges(ranges);
-
-    qdb::qdb_throw_if_error(*_handle, qdb_ts_int64_get_ranges(*_handle, _alias.c_str(), column.c_str(),
-                                          ranges_.data(), ranges_.size(), &points, &count));
-
-    auto ret = convert::point_array<qdb_int_t, traits::int64_dtype>(points, count);
-
-    qdb_release(*_handle, points);
-
-    return ret;
-}
-
-std::pair<pybind11::array, masked_array> table::timestamp_get_ranges(
-    const std::string & column, py::object ranges)
-{
-    _handle->check_open();
-
-    qdb_ts_timestamp_point * points = nullptr;
-    qdb_size_t count                = 0;
-
-    auto ranges_ = qdb::convert_ranges(ranges);
-
-    qdb::qdb_throw_if_error(
-        *_handle, qdb_ts_timestamp_get_ranges(*_handle, _alias.c_str(), column.c_str(), ranges_.data(),
-                      ranges_.size(), &points, &count));
-
-    auto ret = convert::point_array<qdb_timespec_t, traits::datetime64_ns_dtype>(points, count);
-
-    qdb_release(*_handle, points);
-
-    return ret;
-}
-}; // namespace qdb