quasardb 3.13.6__cp39-cp39-win_amd64.whl → 3.13.7__cp39-cp39-win_amd64.whl

quasardb/detail/qdb_resource.hpp

@@ -2,7 +2,7 @@
  *
  * Official Python API
  *
- * Copyright (c) 2009-2022, quasardb SAS. All rights reserved.
+ * Copyright (c) 2009-2023, quasardb SAS. All rights reserved.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -30,7 +30,7 @@
  */
 #pragma once
 
-#include "../handle.hpp"
+#include <qdb/client.h> // for qdb_handle_t
 
 namespace qdb
 {
@@ -49,14 +49,14 @@ public:
     /**
      * Default constructor, initializes nullpointer.
      */
-    qdb_resource(qdb::handle_ptr h)
+    qdb_resource(qdb_handle_t h)
         : qdb_resource(h, nullptr)
     {}
 
     /**
      * Constructor and immediately initialize with pointer.
      */
-    qdb_resource(qdb::handle_ptr h, ValueType * p)
+    qdb_resource(qdb_handle_t h, ValueType * p)
         : h_(h)
         , p_(p)
     {}
@@ -68,7 +68,7 @@ public:
     {
         if (p_ != nullptr)
         {
-            qdb_release(*h_, p_);
+            qdb_release(h_, p_);
         }
 
         p_ = nullptr;
@@ -110,7 +110,7 @@ public:
     }
 
 private:
-    qdb::handle_ptr h_;
+    qdb_handle_t h_;
     ValueType * p_;
 };
 

quasardb/detail/ts_column.hpp

@@ -2,7 +2,7 @@
  *
  * Official Python API
  *
- * Copyright (c) 2009-2022, quasardb SAS. All rights reserved.
+ * Copyright (c) 2009-2023, quasardb SAS. All rights reserved.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without

quasardb/direct_blob.hpp

@@ -2,7 +2,7 @@
  *
  * Official Python API
  *
- * Copyright (c) 2009-2022, quasardb SAS. All rights reserved.
+ * Copyright (c) 2009-2023, quasardb SAS. All rights reserved.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without

quasardb/direct_handle.hpp

@@ -2,7 +2,7 @@
  *
  * Official Python API
  *
- * Copyright (c) 2009-2022, quasardb SAS. All rights reserved.
+ * Copyright (c) 2009-2023, quasardb SAS. All rights reserved.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without

quasardb/direct_integer.hpp

@@ -2,7 +2,7 @@
  *
  * Official Python API
  *
- * Copyright (c) 2009-2022, quasardb SAS. All rights reserved.
+ * Copyright (c) 2009-2023, quasardb SAS. All rights reserved.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without

quasardb/{version.cpp → double.hpp}

@@ -2,7 +2,7 @@
  *
  * Official Python API
  *
- * Copyright (c) 2009-2022, quasardb SAS. All rights reserved.
+ * Copyright (c) 2009-2023, quasardb SAS. All rights reserved.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -28,42 +28,60 @@
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-#include "version.hpp"
-#include <regex>
-#include <sstream>
-#include <stdexcept>
+#pragma once
 
-static std::pair<int, int> get_version_pair(const char * version)
+#include "entry.hpp"
+#include <qdb/double.h>
+
+namespace qdb
+{
+
+class double_entry : public expirable_entry
 {
-    std::regex re("([0-9]+)\\.([0-9]+)\\..*");
-    std::cmatch m;
-    if (!std::regex_match(version, m, re))
+public:
+    double_entry(handle_ptr h, std::string a) noexcept
+        : expirable_entry{h, a}
+    {}
+
+public:
+    double get()
     {
-        std::ostringstream sstr;
-        sstr << "Got an invalid QuasarDB C API version string (" << version << ").";
-        throw std::invalid_argument(sstr.str());
+        double result;
+        qdb::qdb_throw_if_error(*_handle, qdb_double_get(*_handle, _alias.c_str(), &result));
+        return result;
     }
-    const auto major = std::stoi(m[1].str());
-    const auto minor = std::stoi(m[2].str());
-    return std::make_pair(major, minor);
-}
 
-namespace qdb
-{
+    void put(double val)
+    {
+        qdb::qdb_throw_if_error(*_handle, qdb_double_put(*_handle, _alias.c_str(), val, qdb_time_t{0}));
+    }
 
-const char * const qdb_c_api_version = QDB_PY_VERSION;
+    void update(double val)
+    {
+        qdb::qdb_throw_if_error(
+            *_handle, qdb_double_update(*_handle, _alias.c_str(), val, qdb_time_t{0}));
+    }
 
-void check_qdb_c_api_version(const char * candidate)
-{
-    const auto ver_c   = get_version_pair(candidate);
-    const auto ver_ref = get_version_pair(qdb_c_api_version);
-    if (ver_c != ver_ref)
+    double add(double val)
     {
-        std::ostringstream sstr;
-        sstr << "QuasarDB C API version mismatch. Expected " << ver_ref.first << '.' << ver_ref.second
-             << " but got " << ver_c.first << '.' << ver_c.second << " instead.";
-        throw std::runtime_error(sstr.str());
+        double result;
+        qdb::qdb_throw_if_error(*_handle, qdb_double_add(*_handle, _alias.c_str(), val, &result));
+        return result;
     }
+};
+
+template <typename Module>
+static inline void register_double(Module & m)
+{
+    namespace py = pybind11;
+
+    py::class_<qdb::double_entry, qdb::expirable_entry>(m, "Double")  //
+        .def(py::init<qdb::handle_ptr, std::string>())                //
+        .def("get", &qdb::double_entry::get)                          //
+        .def("put", &qdb::double_entry::put, py::arg("double"))       //
+        .def("update", &qdb::double_entry::update, py::arg("double")) //
+        .def("add", &qdb::double_entry::add, py::arg("addend"))       //
+        ;                                                             //
 }
 
 } // namespace qdb

quasardb/entry.hpp

@@ -2,7 +2,7 @@
  *
  * Official Python API
  *
- * Copyright (c) 2009-2022, quasardb SAS. All rights reserved.
+ * Copyright (c) 2009-2023, quasardb SAS. All rights reserved.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without

quasardb/error.hpp

@@ -2,7 +2,7 @@
  *
  * Official Python API
  *
- * Copyright (c) 2009-2022, quasardb SAS. All rights reserved.
+ * Copyright (c) 2009-2023, quasardb SAS. All rights reserved.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -35,6 +35,7 @@
 #include <qdb/client.h>
 #include <qdb/error.h>
 #include <qdb/query.h>
+#include "detail/qdb_resource.hpp"
 #include <pybind11/pybind11.h>
 #include <iostream>
 #include <utility>
@@ -209,7 +210,7 @@ inline void qdb_throw_if_error(
 
     if ((qdb_e_ok != err) && (qdb_e_ok_created != err)) [[unlikely]]
     {
-        qdb_string_t msg_;
+        detail::qdb_resource<qdb_string_t> msg_{h, nullptr};
         qdb_error_t err_;
         qdb_get_last_error(h, &err_, &msg_);
 
@@ -220,38 +221,41 @@ inline void qdb_throw_if_error(
             throw qdb::exception{err, qdb_error(err)};
         }
         assert(err_ == err);
+        assert(msg_ != nullptr);
 
         pre_throw();
 
+        std::string msg_data_{msg_.get()->data};
+
         switch (err)
         {
 
         case qdb_e_invalid_query:
-            throw qdb::invalid_query_exception{msg_.data};
+            throw qdb::invalid_query_exception{msg_data_};
 
         case qdb_e_alias_already_exists:
-            throw qdb::alias_already_exists_exception{msg_.data};
+            throw qdb::alias_already_exists_exception{msg_data_};
 
         case qdb_e_alias_not_found:
-            throw qdb::alias_not_found_exception{msg_.data};
+            throw qdb::alias_not_found_exception{msg_data_};
 
         case qdb_e_network_inbuf_too_small:
             throw qdb::input_buffer_too_small_exception{};
 
         case qdb_e_incompatible_type:
-            throw qdb::incompatible_type_exception{msg_.data};
+            throw qdb::incompatible_type_exception{msg_data_};
 
         case qdb_e_not_implemented:
-            throw qdb::not_implemented_exception{msg_.data};
+            throw qdb::not_implemented_exception{msg_data_};
 
         case qdb_e_internal_local:
-            throw qdb::internal_local_exception{msg_.data};
+            throw qdb::internal_local_exception{msg_data_};
 
         case qdb_e_invalid_argument:
-            throw qdb::invalid_argument_exception{msg_.data};
+            throw qdb::invalid_argument_exception{msg_data_};
 
         default:
-            throw qdb::exception{err_, msg_.data};
+            throw qdb::exception{err_, msg_data_};
         };
     }
 }

quasardb/handle.hpp

@@ -2,7 +2,7 @@
  *
  * Official Python API
  *
- * Copyright (c) 2009-2022, quasardb SAS. All rights reserved.
+ * Copyright (c) 2009-2023, quasardb SAS. All rights reserved.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without

quasardb/integer.hpp

@@ -2,7 +2,7 @@
  *
  * Official Python API
  *
- * Copyright (c) 2009-2022, quasardb SAS. All rights reserved.
+ * Copyright (c) 2009-2023, quasardb SAS. All rights reserved.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without

quasardb/logger.hpp

@@ -2,7 +2,7 @@
  *
  * Official Python API
  *
- * Copyright (c) 2009-2022, quasardb SAS. All rights reserved.
+ * Copyright (c) 2009-2023, quasardb SAS. All rights reserved.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without

quasardb/masked_array.hpp

@@ -2,7 +2,7 @@
  *
  * Official Python API
  *
- * Copyright (c) 2009-2022, quasardb SAS. All rights reserved.
+ * Copyright (c) 2009-2023, quasardb SAS. All rights reserved.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without

quasardb/module.cpp

@@ -0,0 +1,73 @@
+#include "module.hpp"
+#include "cluster.hpp"
+#include "node.hpp"
+#include <functional>
+#include <list>
+
+namespace qdb
+{
+/**
+ * This approach is inspired from pybind11, where we keep a global static variable
+ * of initializers for components/modules that which to register with our global
+ * quasardb module.
+ *
+ * It has the downside of module initialization order essentially being random, which
+ * is fine for our use case. It allows decoupling of code in many places.
+ */
+std::list<std::function<void(py::module_ &)>> & initializers()
+{
+    static std::list<std::function<void(py::module_ &)>> inits;
+    return inits;
+}
+
+submodule_initializer::submodule_initializer(initialize_fn init)
+{
+    initializers().emplace_back(init);
+}
+
+submodule_initializer::submodule_initializer(const char * submodule_name, initialize_fn init)
+{
+    initializers().emplace_back([=](py::module_ & parent) { init(parent); });
+}
+
+}; // namespace qdb
+
+PYBIND11_MODULE(quasardb, m)
+{
+    m.doc() = "QuasarDB Official Python API";
+    m.def("version", &qdb_version, "Return version number");
+    m.def("build", &qdb_build, "Return build number");
+    m.attr("never_expires") = std::chrono::system_clock::time_point{};
+
+    qdb::register_errors(m);
+    qdb::register_cluster(m);
+    qdb::register_node(m);
+    qdb::register_options(m);
+    qdb::register_perf(m);
+    qdb::register_entry(m);
+    qdb::register_double(m);
+    qdb::register_integer(m);
+    qdb::register_blob(m);
+    qdb::register_string(m);
+    qdb::register_timestamp(m);
+    qdb::register_direct_blob(m);
+    qdb::register_direct_integer(m);
+    qdb::register_tag(m);
+    qdb::register_query(m);
+    qdb::register_continuous(m);
+    qdb::register_table(m);
+    qdb::register_batch_column(m);
+    qdb::register_batch_inserter(m);
+    qdb::register_pinned_writer(m);
+    qdb::register_table_reader(m);
+    qdb::register_masked_array(m);
+
+    qdb::detail::register_ts_column(m);
+    qdb::reader::register_ts_value(m);
+    qdb::reader::register_ts_row(m);
+
+    for (const auto & initializer : qdb::initializers())
+    {
+        initializer(m);
+    }
+}

quasardb/module.hpp

@@ -0,0 +1,24 @@
+#pragma once
+
+#include <pybind11/pybind11.h>
+
+namespace qdb
+{
+
+namespace py = pybind11;
+
+class submodule_initializer
+{
+    using initialize_fn = void (*)(py::module_ &);
+
+public:
+    explicit submodule_initializer(initialize_fn init);
+    submodule_initializer(const char * submodule_name, initialize_fn init);
+};
+
+}; // namespace qdb
+
+#define QDB_REGISTER_MODULE(name, variable)                  \
+    void qdb_submodule_##name(py::module_ &);                \
+    submodule_initializer name(#name, qdb_submodule_##name); \
+    void qdb_submodule_##name(py::module_ &(variable))

quasardb/node.hpp

@@ -2,7 +2,7 @@
  *
  * Official Python API
  *
- * Copyright (c) 2009-2022, quasardb SAS. All rights reserved.
+ * Copyright (c) 2009-2023, quasardb SAS. All rights reserved.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -47,14 +47,17 @@ public:
      * Construct a direct node connection directly, possibly with security credentials.
      */
     node(const std::string & node_uri,
-        const std::string & user_name          = {},
-        const std::string & user_private_key   = {},
-        const std::string & cluster_public_key = {})
+        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 = {})
         : _uri{node_uri}
         , _handle{make_handle_ptr()}
         , _direct_handle{make_direct_handle_ptr()}
     {
-        qdb::options{_handle}.apply_credentials(user_name, user_private_key, cluster_public_key);
+        qdb::options{_handle}.apply_credentials(user_name, user_private_key, cluster_public_key,
+            user_security_file, cluster_public_key_file);
         _direct_handle->connect(_handle, node_uri);
     }
 
@@ -104,12 +107,14 @@ static inline void register_node(Module & m)
     namespace py = pybind11;
 
     py::class_<qdb::node>(m, "Node")
-        .def(py::init<std::string const &, std::string const &, std::string const &,
-                 std::string const &>(),
-            py::arg("uri"),                                //
-            py::arg("user_name")          = std::string{}, //
-            py::arg("user_private_key")   = std::string{}, //
-            py::arg("cluster_public_key") = std::string{}) //
+        .def(py::init<std::string const &, std::string const &, std::string const &, std::string const &,
+                std::string const &, std::string const &>(),
+            py::arg("uri"),                                     //
+            py::arg("user_name")          = std::string{},      //
+            py::arg("user_private_key")   = std::string{},      //
+            py::arg("cluster_public_key") = std::string{},      //
+            py::arg("user_security_file")      = std::string{}, //
+            py::arg("cluster_public_key_file") = std::string{}) //
         .def("prefix_get", &qdb::node::prefix_get)
         .def("blob", &qdb::node::blob)
         .def("integer", &qdb::node::integer);

quasardb/numpy/__init__.py

@@ -81,6 +81,19 @@ class IncompatibleDtypeErrors(TypeError):
     def msg(self):
         return "\n".join(x.msg() for x in self.xs)
 
+class InvalidDataCardinalityError(ValueError):
+    """
+    Raised when the provided data arrays doesn't match the table's columns.
+    """
+    def __init__(self, data, cinfos):
+        self.data = data
+        self.cinfos = cinfos
+        super().__init__(self.msg())
+
+    def msg(self):
+        return "Provided data array length '{}' exceeds amount of table columns '{}', unable to map data to columns".format(len(self.data), len(self.cinfos))
+
+
 # Based on QuasarDB column types, which dtype do we accept?
 # First entry will always be the 'preferred' dtype, other ones
 # those that we can natively convert in native code.
@@ -259,6 +272,42 @@ def _coerce_deduplicate(deduplicate, deduplication_mode, columns):
 
     return deduplicate
 
+def _clean_nulls(xs, dtype):
+    """
+    Numpy's masked arrays have a downside that in case they're not able to convert a (masked!) value to
+    the desired dtype, they raise an error. So, for example, if I have a masked array of objects that
+    look like this
+
+    xs: [1.234 <pd.NA> 5.678]
+    mask: [1 0 1]
+
+    even though pd.NA is not "visible", because it cannot be converted to a float(), the operation will
+    fail!
+
+    This function fixes this by replacing the null values with an acceptable value that can always be
+    converted to the desired dtype.
+    """
+
+    assert ma.isMA(xs)
+
+    if xs.dtype is not np.dtype('object'):
+        return xs
+
+    fill_value = None
+    if dtype == np.float64 or dtype == np.float32 or dtype == np.float16:
+        fill_value = float('nan')
+    elif dtype == np.int64 or dtype == np.int32 or dtype == np.int16:
+        fill_value = -1
+    elif dtype == np.dtype('datetime64[ns]'):
+        fill_value = np.datetime64('nat')
+
+    mask = xs.mask
+    xs_ = xs.filled(fill_value)
+
+    return ma.array(xs_, mask=mask)
+
+
+
 def _coerce_data(data, dtype):
     """
     Coerces each numpy array of `data` to the dtype present in `dtype`.
@@ -271,25 +320,34 @@ def _coerce_data(data, dtype):
         data_ = data[i]
 
         if dtype_ is not None and dtypes_equal(data_.dtype, dtype_) == False:
+            data_ = _clean_nulls(data_, dtype_)
+
+            assert ma.isMA(data_)
+
             logger.debug("data for column with offset %d was provided in dtype '%s', but need '%s': converting data...", i, data_.dtype, dtype_)
 
-            logger.debug("type of data[%d] after: %s", i, type(data[i]))
-            logger.debug("size of data[%d] after: %s", i, ma.size(data[i]))
-            logger.debug("data of data[%d] after: %s", i, data[i])
+            logger.debug("dtype of data[%d] before: %s", i, data_.dtype)
+            logger.debug("type of data[%d] after: %s", i, type(data_))
+            logger.debug("size of data[%d] after: %s", i, ma.size(data_))
+            logger.debug("data of data[%d] after: %s", i, data_)
 
             try:
                 data[i] = data_.astype(dtype_)
             except TypeError as err:
                 # One 'bug' is that, if everything is masked, the underlying data type can be
                 # pretty much anything.
-                if not _is_all_masked(data_):
+                if _is_all_masked(data_):
+                    logger.debug("array completely empty, re-initializing to empty array of '%s'", dtype_)
+                    data[i] = ma.masked_all(ma.size(data_),
+                                            dtype=dtype_)
+
+                # Another 'bug' is that when the input data is objects, we may have null-like values (like pd.NA)
+                # that cannot easily be converted to, say, float.
+                else:
                     logger.error("An error occured while coercing input data type from dtype '%s' to dtype '%s': ", data_.dtype, dtype_)
                     logger.exception(err)
                     raise err
 
-                logger.debug("array completely empty, re-initializing to empty array of '%s'", dtype_)
-                data[i] = ma.masked_all(ma.size(data_),
-                                        dtype=dtype_)
             assert data[i].dtype.kind == dtype_.kind
 
             logger.debug("type of data[%d] after: %s", i, type(data[i]))
@@ -321,6 +379,13 @@ def _ensure_list(xs, cinfos):
     if isinstance(xs, list):
         return xs
 
+    if isinstance(xs, np.ndarray):
+        ret = []
+        for x in xs:
+            ret.append(x)
+
+        return ret
+
     # As we only accept list-likes or dicts as input data, it *must* be a dict at this
     # point
     assert isinstance(xs, dict)
@@ -612,6 +677,10 @@ def write_arrays(
         dtype = _add_desired_dtypes(dtype, cinfos)
 
     data = _ensure_list(data, cinfos)
+
+    if len(data) != len(cinfos):
+        raise InvalidDataCardinalityError(data, cinfos)
+
     data = ensure_ma(data, dtype=dtype)
     data = _coerce_data(data, dtype)
 

quasardb/numpy.hpp

@@ -2,7 +2,7 @@
  *
  * Official Python API
  *
- * Copyright (c) 2009-2022, quasardb SAS. All rights reserved.
+ * Copyright (c) 2009-2023, quasardb SAS. All rights reserved.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without

quasardb/options.hpp

@@ -2,7 +2,7 @@
  *
  * Official Python API
  *
- * Copyright (c) 2009-2022, quasardb SAS. All rights reserved.
+ * Copyright (c) 2009-2023, quasardb SAS. All rights reserved.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -50,21 +50,35 @@ public:
      */
     void apply_credentials(const std::string & user_name,
         const std::string & user_private_key,
-        const std::string & cluster_public_key)
+        const std::string & cluster_public_key,
+        const std::string & user_security_file,
+        const std::string & cluster_public_key_file)
     {
-        // must specify everything or nothing
-        if (user_name.empty() != user_private_key.empty())
-            throw qdb::exception{qdb_e_invalid_argument,
-                "Either all security settings must be provided, or none at all"};
-        if (user_name.empty() != cluster_public_key.empty())
+        // 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 all security settings must be provided, or none at all"};
+                "Either key or file security settings must be provided, or none at all"};
 
-        if (!user_name.empty())
+        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)
@@ -123,6 +137,14 @@ public:
             *_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));