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

quasardb/object_tracker.hpp

@@ -1,283 +0,0 @@
-#pragma once
-
-#include <any>
-#include <cassert>
-#include <iostream>
-#include <memory>
-#include <stack>
-#include <typeindex>
-#include <unordered_map>
-#include <unordered_set>
-
-namespace qdb::object_tracker
-{
-
-////////////////////////////////////////////////////////////////////////////////
-//
-// Implementation
-//
-///////////////////
-
-namespace detail
-{
-
-////////////////////////////////////////////////////////////////////////////////
-//
-// Trackable objects
-//
-///////////////////
-//
-// Typically we don't really care about the type of the underlying pointers
-// we track, and would like to just use `void *`; this makes the code a lot
-// simpler.
-//
-// There's a problem, however: we cannot invoke `delete` on void * because
-// the compiler wouldn't know which destructor to call.
-//
-// The code below deal with this mess: it's able to "wrap" any typed unique_ptr
-// in something which can best be considered a std::unique_ptr<void>, but
-// uses the original, type-based deleter.
-//
-// Not sure if evil hack or elaborate genius, but it works.
-//
-///////////////////
-
-using void_delete_fn = std::function<void(void *)>;
-
-template <typename T, typename DT>
-inline auto deleter_of() noexcept -> void_delete_fn
-{
-    // Magic is here: we make a `void *` deleter function, which under-the-hood
-    // invokes the original deleter.
-    return [](void * x) -> void { DT{}(static_cast<T *>(x)); };
-};
-
-using trackable_object = std::unique_ptr<void, void_delete_fn>;
-
-template <typename T, typename DT>
-inline trackable_object make_trackable_object(std::unique_ptr<T, DT> && x)
-{
-    return trackable_object{x.release(), deleter_of<T, DT>()};
-};
-
-template <typename T, typename DT = std::default_delete<T>>
-inline trackable_object make_trackable_object(T * x)
-{
-    return make_trackable_object(std::unique_ptr<T>{x});
-};
-
-////////////////////////////////////////////////////////////////////////////////
-//
-// Repository
-//
-///////////////////
-//
-// The repository contains all tracked objects. It maintains a container of tracked
-// objects, which are effectively unique_ptr<void>, and as such automatically released
-// upon destruction.
-//
-// Intended use is to immediately pass the pointer to immediately track:
-//
-//   char * buf = qdb::object_tracker::track<char>(new char[32]);
-//
-// or, even better:
-//
-//   char * buf = qdb::object_tracker::alloc<char>(32);
-//
-///////////////////
-
-class repository
-{
-private:
-    using container_t = std::vector<trackable_object>;
-
-public:
-    repository()  = default;
-    ~repository() = default;
-
-    repository(repository const &)             = delete;
-    repository(repository && other)            = delete;
-    repository & operator=(repository const &) = delete;
-
-public:
-    [[nodiscard]] static inline repository & instance() noexcept
-    {
-        static repository instance_;
-        // If this assertion fails it implies a component tries to have its objects
-        // tracked but there is no collector being able to track these yet.
-        //
-        // Ensure you have a `collector` with its scoped wrapped around the rest of
-        // the code that wants its objects tracked.
-        return instance_;
-    };
-
-    /**
-     * Swaps the tracked objects of `this` repo with the tracked objects of another
-     * repository.
-     *
-     * Used by `scoped_repository` to temporarily "claim" the global scope, and to
-     * release it back again later.
-     */
-    static inline void swap(repository & x) noexcept
-    {
-        std::swap(instance().xs_, x.xs_);
-    };
-
-public:
-    // Delegate functions
-
-    [[nodiscard]] inline void * track(trackable_object && x) noexcept
-    {
-        void * ptr = x.get();
-        xs_.push_back(std::move(x));
-
-        return ptr;
-    };
-
-    template <typename T>
-    requires(!std::is_pointer_v<T>) [[nodiscard]] inline T * track(T * x) noexcept
-    {
-        return static_cast<T *>(track(make_trackable_object(std::unique_ptr<T>{x})));
-    };
-
-    /**
-     * Allocates `n` bytes and immediately tracks it. n is the amount of bytes to allocate, *not* the
-     * amount of objects of sizeof(T) to allocate.
-     */
-    template <typename T>
-    [[nodiscard]] inline T * alloc(std::size_t n) noexcept
-    {
-        return track<T>((T *)::operator new(n));
-    };
-
-public:
-    // Inspection / management functions
-
-    [[nodiscard]] inline std::size_t size() const noexcept
-    {
-        return xs_.size();
-    };
-
-    [[nodiscard]] inline bool empty() const noexcept
-    {
-        return xs_.empty();
-    };
-
-private:
-    container_t xs_;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-//
-// Scoped Repository
-//
-///////////////////
-//
-// Wraps a repository that automatically releases everything when it goes out
-// of scope.
-//
-// Intended use case:
-// * Attach a scoped_repository to the object that initiates a query/request, *and*
-//   stays alive as long as any pointers are still being referenced.
-// * In conjunction with `scoped_capture`, captures all tracked pointers during
-//   its scope;
-// * only once e.g. the scoped_repository goes completely out of scope, does the cleanup
-//   happen.
-//
-// You would attach this scoped_repository to e.g. a `query_result` structure.
-//
-///////////////////
-
-class scoped_repository
-{
-    friend class scoped_capture;
-
-public:
-    scoped_repository() = default;
-
-    ~scoped_repository(){};
-
-    [[nodiscard]] inline std::size_t size() const noexcept
-    {
-        return repo_.size();
-    };
-
-    [[nodiscard]] inline bool empty() const noexcept
-    {
-        return repo_.empty();
-    };
-
-    inline void swap()
-    {
-        repository::swap(repo_);
-    };
-
-private:
-    repository repo_;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-//
-// Scoped Capture
-//
-///////////////////
-//
-// During its scope, redirects all new tracked objects to the provided repository.
-// You would typically put this around the code that invokes conversion or any
-// other components that can create tracked objects.
-//
-// *WARNING*: Multiple scoped_captures being active at the same time is unsupported.
-//            Keep these scopes as small as possible, and do *not* use them in async
-//            code.
-//
-///////////////////
-
-class scoped_capture
-{
-public:
-    inline scoped_capture(scoped_repository & ctx)
-        : ctx_{ctx}
-    {
-        // This is where the magic happens: we 'claim' the global scope by swapping
-        // our local scope with the global one...
-        ctx_.swap();
-    };
-
-    inline ~scoped_capture()
-    {
-        // ... and we release it back by putting the global scope back in place.
-        ctx_.swap();
-    };
-
-private:
-    scoped_repository & ctx_;
-};
-}; // namespace detail
-
-////////////////////////////////////////////////////////////////////////////////
-//
-// Public interface
-//
-///////////////////
-
-template <typename T>
-inline T * track(T * x)
-{
-    return detail::repository::instance().track<T>(x);
-};
-
-template <typename T, typename DT>
-inline T * track(std::unique_ptr<T, DT> && x)
-{
-    return detail::repository::instance().track<T>(std::forward<std::unique_ptr<T, DT> &&>(x));
-};
-
-template <typename T>
-inline T * alloc(std::size_t n)
-{
-    return detail::repository::instance().alloc<T>(n);
-};
-
-using scoped_repository = qdb::object_tracker::detail::scoped_repository;
-using scoped_capture    = qdb::object_tracker::detail::scoped_capture;
-}; // namespace qdb::object_tracker

quasardb/options.hpp

@@ -1,244 +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 "handle.hpp"
-#include <qdb/option.h>
-#include <chrono>
-
-namespace qdb
-{
-
-class options
-{
-public:
-    explicit options(qdb::handle_ptr h)
-        : _handle{h}
-    {}
-
-public:
-    /**
-     * Applies credentials if provided, throws exception when credentials are invalid.
-     */
-    void apply_credentials(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)
-    {
-        // must specify keys or files or nothing
-        auto empty_keys  = user_name.empty() && user_private_key.empty() && cluster_public_key.empty();
-        auto empty_files = user_security_file.empty() && cluster_public_key_file.empty();
-
-        if (!empty_keys && !empty_files)
-            throw qdb::exception{qdb_e_invalid_argument,
-                "Either key or file security settings must be provided, or none at all"};
-
-        if (!empty_keys)
-        {
-            if (user_name.empty() || user_private_key.empty() || cluster_public_key.empty())
-                throw qdb::exception{qdb_e_invalid_argument,
-                    "Either all keys security settings must be provided, or none at all"};
-
-            set_user_credentials(user_name, user_private_key);
-            set_cluster_public_key(cluster_public_key);
-        }
-        else if (!empty_files)
-        {
-            if (user_security_file.empty() || cluster_public_key_file.empty())
-                throw qdb::exception{qdb_e_invalid_argument,
-                    "Either all files security settings must be provided, or none at all"};
-
-            set_file_credential(user_security_file, cluster_public_key_file);
-        }
-    };
-
-    void set_timeout(std::chrono::milliseconds ms)
-    {
-        qdb::qdb_throw_if_error(
-            *_handle, qdb_option_set_timeout(*_handle, static_cast<int>(ms.count())));
-    }
-
-    std::chrono::milliseconds get_timeout()
-    {
-        int ms = 0;
-
-        qdb::qdb_throw_if_error(*_handle, qdb_option_get_timeout(*_handle, &ms));
-
-        return std::chrono::milliseconds{ms};
-    }
-
-    void set_client_soft_memory_limit(std::size_t limit)
-    {
-        qdb::qdb_throw_if_error(*_handle,
-            qdb_option_set_client_soft_memory_limit(*_handle, static_cast<qdb_uint_t>(limit)));
-    }
-
-    void set_stabilization_max_wait(std::chrono::milliseconds ms)
-    {
-        qdb::qdb_throw_if_error(
-            *_handle, qdb_option_set_stabilization_max_wait(*_handle, static_cast<int>(ms.count())));
-    }
-
-    std::chrono::milliseconds get_stabilization_max_wait()
-    {
-        int ms = 0;
-
-        qdb::qdb_throw_if_error(*_handle, qdb_option_get_stabilization_max_wait(*_handle, &ms));
-
-        return std::chrono::milliseconds{ms};
-    }
-
-    void set_max_cardinality(qdb_uint_t cardinality)
-    {
-        qdb::qdb_throw_if_error(*_handle, qdb_option_set_max_cardinality(*_handle, cardinality));
-    }
-
-    void set_compression(qdb_compression_t level)
-    {
-        qdb::qdb_throw_if_error(*_handle, qdb_option_set_compression(*_handle, level));
-    }
-
-    void set_encryption(qdb_encryption_t algo)
-    {
-        qdb::qdb_throw_if_error(*_handle, qdb_option_set_encryption(*_handle, algo));
-    }
-
-    void set_cluster_public_key(const std::string & key)
-    {
-        qdb::qdb_throw_if_error(*_handle, qdb_option_set_cluster_public_key(*_handle, key.c_str()));
-    }
-
-    void set_user_credentials(const std::string & user, const std::string & private_key)
-    {
-        qdb::qdb_throw_if_error(
-            *_handle, qdb_option_set_user_credentials(*_handle, user.c_str(), private_key.c_str()));
-    }
-
-    void set_file_credential(
-        const std::string & user_security_file, const std::string & cluster_public_key_file)
-    {
-        qdb::qdb_throw_if_error(
-            *_handle, qdb_option_load_security_files(
-                          *_handle, cluster_public_key_file.c_str(), user_security_file.c_str()));
-    }
-
-    void set_client_max_in_buf_size(size_t max_size)
-    {
-        qdb::qdb_throw_if_error(*_handle, qdb_option_set_client_max_in_buf_size(*_handle, max_size));
-    }
-
-    size_t get_client_max_in_buf_size()
-    {
-        size_t buf_size = 0;
-        qdb::qdb_throw_if_error(*_handle, qdb_option_get_client_max_in_buf_size(*_handle, &buf_size));
-        return buf_size;
-    }
-
-    size_t get_cluster_max_in_buf_size()
-    {
-        size_t buf_size = 0;
-        qdb::qdb_throw_if_error(*_handle, qdb_option_get_cluster_max_in_buf_size(*_handle, &buf_size));
-        return buf_size;
-    }
-
-    void set_client_max_parallelism(size_t max_parallelism)
-    {
-        qdb::qdb_throw_if_error(
-            *_handle, qdb_option_set_client_max_parallelism(*_handle, max_parallelism));
-    }
-
-    size_t get_client_max_parallelism()
-    {
-        size_t max_parallelism = 0;
-        qdb::qdb_throw_if_error(
-            *_handle, qdb_option_get_client_max_parallelism(*_handle, &max_parallelism));
-        return max_parallelism;
-    }
-
-    void set_query_max_length(size_t query_max_length)
-    {
-        qdb::qdb_throw_if_error(*_handle, qdb_option_set_query_max_length(*_handle, query_max_length));
-    }
-
-    size_t get_query_max_length()
-    {
-        size_t query_max_length = 0;
-        qdb::qdb_throw_if_error(*_handle, qdb_option_get_query_max_length(*_handle, &query_max_length));
-        return query_max_length;
-    }
-
-private:
-    qdb::handle_ptr _handle;
-};
-
-template <typename Module>
-static inline void register_options(Module & m)
-{
-    namespace py = pybind11;
-
-    py::class_<qdb::options> o(m, "Options"); //
-
-    // None is reserved keyword in Python
-    py::enum_<qdb_compression_t>{o, "Compression", py::arithmetic(), "Compression type"} //
-        .value("Disabled", qdb_comp_none)                                                //
-        .value("Fast", qdb_comp_fast)                                                    //
-        .value("Best", qdb_comp_best);                                                   //
-
-    py::enum_<qdb_encryption_t>{o, "Encryption", py::arithmetic(), "Encryption type"} //
-        .value("Disabled", qdb_crypt_none)                                            //
-        .value("AES256GCM", qdb_crypt_aes_gcm_256);                                   //
-
-    o.def(py::init<qdb::handle_ptr>())                                                    //
-        .def("set_timeout", &qdb::options::set_timeout)                                   //
-        .def("get_timeout", &qdb::options::get_timeout)                                   //
-        .def("set_stabilization_max_wait", &qdb::options::set_stabilization_max_wait)     //
-        .def("get_stabilization_max_wait", &qdb::options::get_stabilization_max_wait)     //
-        .def("set_max_cardinality", &qdb::options::set_max_cardinality)                   //
-        .def("set_compression", &qdb::options::set_compression)                           //
-        .def("set_encryption", &qdb::options::set_encryption)                             //
-        .def("set_cluster_public_key", &qdb::options::set_cluster_public_key)             //
-        .def("set_user_credentials", &qdb::options::set_user_credentials)                 //
-        .def("set_client_max_in_buf_size", &qdb::options::set_client_max_in_buf_size)     //
-        .def("get_client_max_in_buf_size", &qdb::options::get_client_max_in_buf_size)     //
-        .def("get_cluster_max_in_buf_size", &qdb::options::get_cluster_max_in_buf_size)   //
-        .def("set_client_max_parallelism", &qdb::options::set_client_max_parallelism,     //
-            py::arg("parallelism"))                                                       //
-        .def("get_client_max_parallelism", &qdb::options::get_client_max_parallelism)     //
-        .def("set_query_max_length", &qdb::options::set_query_max_length,                 //
-            py::arg("query_max_length"))                                                  //
-        .def("get_query_max_length", &qdb::options::get_query_max_length)                 //
-        .def("set_client_soft_memory_limit", &qdb::options::set_client_soft_memory_limit, //
-            py::arg("limit"))                                                             //
-        ;
-}
-
-} // namespace qdb