quasardb 3.14.2.dev0__cp312-cp312-win32.whl → 3.14.2.dev4__cp312-cp312-win32.whl

quasardb/batch_inserter.hpp

@@ -1,248 +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 "batch_column.hpp"
-#include "entry.hpp"
-#include "logger.hpp"
-#include "table.hpp"
-#include "utils.hpp"
-#include "convert/value.hpp"
-
-namespace qdb
-{
-
-class batch_inserter
-{
-
-public:
-    batch_inserter(qdb::handle_ptr h, const std::vector<batch_column_info> & ci)
-        : _logger("quasardb.batch_inserter")
-        , _handle{h}
-        , _row_count{0}
-        , _point_count{0}
-        , _min_max_ts{qdb_min_timespec, qdb_min_timespec}
-    {
-        std::vector<qdb_ts_batch_column_info_t> converted(ci.size());
-
-        std::transform(ci.cbegin(), ci.cend(), converted.begin(),
-            [](const batch_column_info & ci) -> qdb_ts_batch_column_info_t { return ci; });
-
-        qdb::qdb_throw_if_error(*_handle,
-            qdb_ts_batch_table_init(*_handle, converted.data(), converted.size(), &_batch_table));
-
-        _logger.debug("initialized batch reader with %d columns", ci.size());
-    }
-
-    // prevent copy because of the table object, use a unique_ptr of the batch in cluster
-    // to return the object
-    batch_inserter(const batch_inserter &) = delete;
-
-    ~batch_inserter()
-    {
-        if (_handle && _batch_table)
-        {
-            qdb_release(*_handle, _batch_table);
-            _batch_table = nullptr;
-        }
-    }
-
-public:
-    void start_row(py::object ts)
-    {
-        qdb_timespec_t const converted = convert::value<py::object, qdb_timespec_t>(ts);
-        qdb::qdb_throw_if_error(*_handle, qdb_ts_batch_start_row(_batch_table, &converted));
-
-        // The block below is only necessary for insert_truncate, and even then if someone
-        // does not explicitly provide a time range. It shouldn't be *too* much of a performance
-        // impact, but maybe we can somehow optimize this away?
-        if (_min_max_ts.begin == qdb_min_timespec && _min_max_ts.end == qdb_min_timespec)
-        {
-            assert(_row_count == 0); // sanity check
-
-            // First row
-            _min_max_ts.begin = converted;
-            _min_max_ts.end   = converted;
-        }
-        else
-        {
-            assert(_row_count > 0);
-            _min_max_ts.begin = std::min(converted, _min_max_ts.begin);
-            _min_max_ts.end   = std::max(converted, _min_max_ts.end);
-        }
-
-        ++_row_count;
-    }
-
-    void set_blob(std::size_t index, const py::bytes & blob)
-    {
-        std::string tmp = static_cast<std::string>(blob);
-        qdb::qdb_throw_if_error(*_handle, qdb_ts_batch_row_set_blob(_batch_table, index,
-                                              static_cast<void const *>(tmp.c_str()), tmp.length()));
-        ++_point_count;
-    }
-
-    void set_string(std::size_t index, const std::string & string)
-    {
-        qdb::qdb_throw_if_error(
-            *_handle, qdb_ts_batch_row_set_string(_batch_table, index, string.data(), string.size()));
-    }
-
-    void set_double(std::size_t index, double v)
-    {
-        qdb::qdb_throw_if_error(*_handle, qdb_ts_batch_row_set_double(_batch_table, index, v));
-        ++_point_count;
-    }
-
-    void set_int64(std::size_t index, std::int64_t v)
-    {
-        qdb::qdb_throw_if_error(*_handle, qdb_ts_batch_row_set_int64(_batch_table, index, v));
-        ++_point_count;
-    }
-
-    void set_timestamp(std::size_t index, py::object v)
-    {
-        qdb_timespec_t const converted = convert::value<py::object, qdb_timespec_t>(v);
-        qdb::qdb_throw_if_error(
-            *_handle, qdb_ts_batch_row_set_timestamp(_batch_table, index, &converted));
-        ++_point_count;
-    }
-
-    void push()
-    {
-        _logger.debug("pushing batch of %d rows with %d data points", _row_count, _point_count);
-        qdb::qdb_throw_if_error(*_handle, qdb_ts_batch_push(_batch_table));
-        _logger.debug("pushed batch of %d rows with %d data points", _row_count, _point_count);
-
-        _reset_counters();
-    }
-
-    void push_async()
-    {
-        _logger.debug("async pushing batch of %d rows with %d data points", _row_count, _point_count);
-        qdb::qdb_throw_if_error(*_handle, qdb_ts_batch_push_async(_batch_table));
-        _logger.debug("async pushed batch of %d rows with %d data points", _row_count, _point_count);
-
-        _reset_counters();
-    }
-
-    void push_fast()
-    {
-        _logger.debug("fast pushing batch of %d rows with %d data points", _row_count, _point_count);
-        qdb::qdb_throw_if_error(*_handle, qdb_ts_batch_push_fast(_batch_table));
-        _logger.debug("fast pushed batch of %d rows with %d data points", _row_count, _point_count);
-
-        _reset_counters();
-    }
-
-    void push_truncate(py::kwargs args)
-    {
-        // As we are actively removing data, let's add an additional check to ensure the user
-        // doesn't accidentally truncate his whole database without inserting anything.
-        if (_row_count == 0)
-        {
-            throw qdb::invalid_argument_exception{
-                "Batch inserter is empty: you did not provide any rows to push."};
-        }
-
-        qdb_ts_range_t tr;
-
-        if (args.contains("range"))
-        {
-            tr = convert::value<py::tuple, qdb_ts_range_t>(py::cast<py::tuple>(args["range"]));
-        }
-        else
-        {
-            tr = _min_max_ts;
-            // our range is end-exclusive, so let's move the pointer one nanosecond
-            // *after* the last element in this batch.
-            tr.end.tv_nsec++;
-        }
-        _logger.debug("truncate pushing batch of %d rows with %d data points, start timestamp = %d.%d, "
-                      "end timestamp = %d.%d",
-            _row_count, _point_count, tr.begin.tv_sec, tr.begin.tv_nsec, tr.end.tv_sec, tr.end.tv_nsec);
-
-        qdb::qdb_throw_if_error(*_handle, qdb_ts_batch_push_truncate(_batch_table, &tr, 1));
-        _logger.debug("truncate pushed batch of %d rows with %d data points", _row_count, _point_count);
-
-        _reset_counters();
-    }
-
-private:
-    void _reset_counters()
-    {
-        _row_count        = 0;
-        _point_count      = 0;
-        _min_max_ts.begin = qdb_min_timespec;
-        _min_max_ts.end   = qdb_min_timespec;
-    }
-
-private:
-    qdb::logger _logger;
-    qdb::handle_ptr _handle;
-    qdb_batch_table_t _batch_table{nullptr};
-
-    int64_t _row_count;
-    int64_t _point_count;
-
-    qdb_ts_range_t _min_max_ts;
-};
-
-// don't use shared_ptr, let Python do the reference counting, otherwise you will have an undefined
-// behavior
-using batch_inserter_ptr = std::unique_ptr<batch_inserter>;
-
-template <typename Module>
-static inline void register_batch_inserter(Module & m)
-{
-    namespace py = pybind11;
-
-    py::class_<qdb::batch_inserter>{m, "TimeSeriesBatch"}                         //
-        .def(py::init<qdb::handle_ptr, const std::vector<batch_column_info> &>()) //
-        .def("start_row", &qdb::batch_inserter::start_row,
-            "Calling this function marks the beginning of processing a new row.") //
-        .def("set_blob", &qdb::batch_inserter::set_blob)                          //
-        .def("set_string", &qdb::batch_inserter::set_string)                      //
-        .def("set_double", &qdb::batch_inserter::set_double)                      //
-        .def("set_int64", &qdb::batch_inserter::set_int64)                        //
-        .def("set_timestamp", &qdb::batch_inserter::set_timestamp)                //
-        .def("push", &qdb::batch_inserter::push, "Regular batch push")            //
-        .def("push_async", &qdb::batch_inserter::push_async,
-            "Asynchronous batch push that buffers data inside the QuasarDB daemon") //
-        .def("push_fast", &qdb::batch_inserter::push_fast,
-            "Fast, in-place batch push that is efficient when doing lots of small, incremental pushes.")
-        .def("push_truncate", &qdb::batch_inserter::push_truncate,
-            "Before inserting data, truncates any existing data. This is useful when you want your "
-            "insertions to be idempotent, e.g. in "
-            "case of a retry.");
-}
-
-} // namespace qdb

quasardb/blob.hpp

@@ -1,150 +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/blob.h>
-
-namespace qdb
-{
-
-class blob_entry : public expirable_entry
-{
-public:
-    blob_entry(handle_ptr h, std::string a) noexcept
-        : expirable_entry{h, a}
-    {}
-
-private:
-    pybind11::bytes convert_and_release_content(const void * content, qdb_size_t content_length)
-    {
-        if (!content || !content_length) return pybind11::bytes{};
-
-        std::string res(static_cast<const char *>(content), content_length);
-
-        qdb_release(*_handle, content);
-
-        return pybind11::bytes(res);
-    }
-
-public:
-    pybind11::bytes get()
-    {
-        const void * content      = nullptr;
-        qdb_size_t content_length = 0;
-
-        qdb::qdb_throw_if_error(
-            *_handle, qdb_blob_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_blob_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_blob_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_blob_remove_if(*_handle, _alias.c_str(), comparand.data(), comparand.size()));
-    }
-
-    pybind11::bytes get_and_remove()
-    {
-        const void * content      = nullptr;
-        qdb_size_t content_length = 0;
-
-        qdb::qdb_throw_if_error(
-            *_handle, qdb_blob_get_and_remove(*_handle, _alias.c_str(), &content, &content_length));
-
-        return convert_and_release_content(content, content_length);
-    }
-
-    pybind11::bytes get_and_update(const std::string & data)
-    {
-        const void * content      = nullptr;
-        qdb_size_t content_length = 0;
-
-        qdb::qdb_throw_if_error(*_handle, qdb_blob_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);
-    }
-
-    pybind11::bytes compare_and_swap(const std::string & new_value, const std::string & comparand)
-    {
-        const void * content      = nullptr;
-        qdb_size_t content_length = 0;
-
-        qdb_error_t err =
-            qdb_blob_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_blob(Module & m)
-{
-    namespace py = pybind11;
-
-    py::class_<qdb::blob_entry, qdb::expirable_entry>(m, "Blob") //
-        .def(py::init<qdb::handle_ptr, std::string>())           //
-        .def("get", &qdb::blob_entry::get)                       //
-        .def("put", &qdb::blob_entry::put, py::arg("data"))      //
-        .def("update", &qdb::blob_entry::update, py::arg("data"),
-            py::arg("expiry") = std::chrono::system_clock::time_point{})     //
-        .def("remove_if", &qdb::blob_entry::remove_if, py::arg("comparand")) //
-        .def("get_and_remove", &qdb::blob_entry::get_and_remove)             //
-        .def("get_and_update", &qdb::blob_entry::get_and_update,             //
-            py::arg("data"))                                                 //
-        .def("compare_and_swap", &qdb::blob_entry::compare_and_swap,         //
-            py::arg("new_content"), py::arg("comparand"));                   //
-}
-
-} // namespace qdb

quasardb/cluster.cpp

@@ -1,89 +0,0 @@
-#include "cluster.hpp"
-#include "metrics.hpp"
-#include <chrono>
-#include <thread>
-
-namespace qdb
-{
-
-cluster::cluster(const std::string & uri,
-    const std::string & user_name,
-    const std::string & user_private_key,
-    const std::string & cluster_public_key,
-    const std::string & user_security_file,
-    const std::string & cluster_public_key_file,
-    std::chrono::milliseconds timeout,
-    bool do_version_check)
-    : _uri{uri}
-    , _handle{make_handle_ptr()}
-    , _json_loads{pybind11::module::import("json").attr("loads")}
-    , _logger("quasardb.cluster")
-{
-    if (do_version_check == true)
-    {
-        _logger.warn(
-            "do_version_check parameter has been deprecated and a no-op. It will be removed from a "
-            "future release");
-    }
-
-    options().apply_credentials(user_name, user_private_key, cluster_public_key, //
-        user_security_file, cluster_public_key_file);
-
-    options().set_timeout(timeout);
-
-    // HACKS(leon): we need to ensure there is always one callback active
-    //              for qdb. Callbacks can be lost when the last active session
-    //              gets closed. As such, the most pragmatic place to 'check'
-    //              for this callback is when establishing a new connection.
-    qdb::native::swap_callback();
-
-    _logger.info("Connecting to cluster %s", _uri);
-    _handle->connect(_uri);
-}
-
-void cluster::close()
-{
-    _logger.info("Closing connection to cluster");
-
-    try
-    {
-        if (is_open() == true) [[likely]]
-        {
-            _handle->close();
-        }
-    }
-    catch (qdb::invalid_handle_exception const & e)
-    {
-        // This can happen if, for example, we call close() after an error occured; in those
-        // circumstances, we fully expect the connection to already be invalid, and we should
-        // not care if this specific exception is raised.
-        _logger.warn("Connection already closed");
-    }
-
-    _handle.reset();
-
-    assert(is_open() == false);
-}
-
-void cluster::wait_for_compaction()
-{
-
-    // We define this function in the .cpp file so we can avoid including chrono and thread
-    // in the header file.
-
-    using namespace std::chrono_literals;
-
-    for (;;)
-    {
-        std::uint64_t progress = compact_progress();
-
-        if (progress == 0) [[unlikely]]
-        {
-            break;
-        }
-
-        std::this_thread::sleep_for(100ms);
-    }
-}
-
-}; // namespace qdb