rdbpython 0.2.6__cp314-cp314-macosx_11_0_arm64.whl

rdbpy/include/rdb_include/slice_transform_wrapper.hpp

@@ -0,0 +1,109 @@
+#include <string>
+#include "rocksdb/slice_transform.h"
+#include "rocksdb/env.h"
+#include <stdexcept>
+
+using std::string;
+using rocksdb::SliceTransform;
+using rocksdb::Slice;
+using rocksdb::Logger;
+
+namespace py_rocks {
+    class SliceTransformWrapper: public SliceTransform {
+        public:
+            typedef Slice (*transform_func)(
+                void*,
+                Logger*,
+                string&,
+                const Slice&);
+
+            typedef bool (*in_domain_func)(
+                void*,
+                Logger*,
+                string&,
+                const Slice&);
+
+            typedef bool (*in_range_func)(
+                void*,
+                Logger*,
+                string&,
+                const Slice&);
+
+            SliceTransformWrapper(
+                string name,
+                void* ctx,
+                transform_func transfrom_callback,
+                in_domain_func in_domain_callback,
+                in_range_func in_range_callback):
+                    name(name),
+                    ctx(ctx),
+                    transfrom_callback(transfrom_callback),
+                    in_domain_callback(in_domain_callback),
+                    in_range_callback(in_range_callback)
+            {}
+
+            virtual const char* Name() const {
+                return this->name.c_str();
+            }
+
+            virtual Slice Transform(const Slice& src) const {
+                string error_msg;
+                Slice val;
+
+                val = this->transfrom_callback(
+                    this->ctx,
+                    this->info_log.get(),
+                    error_msg,
+                    src);
+
+                if (error_msg.size()) {
+                    throw std::runtime_error(error_msg.c_str());
+                }
+                return val;
+            }
+
+            virtual bool InDomain(const Slice& src) const {
+                string error_msg;
+                bool val;
+
+                val = this->in_domain_callback(
+                    this->ctx,
+                    this->info_log.get(),
+                    error_msg,
+                    src);
+
+                if (error_msg.size()) {
+                    throw std::runtime_error(error_msg.c_str());
+                }
+                return val;
+            }
+
+            virtual bool InRange(const Slice& dst) const {
+                string error_msg;
+                bool val;
+
+                val = this->in_range_callback(
+                    this->ctx,
+                    this->info_log.get(),
+                    error_msg,
+                    dst);
+
+                if (error_msg.size()) {
+                    throw std::runtime_error(error_msg.c_str());
+                }
+                return val;
+            }
+
+            void set_info_log(std::shared_ptr<Logger> info_log) {
+                this->info_log = info_log;
+            }
+
+        private:
+            string name;
+            void* ctx;
+            transform_func transfrom_callback;
+            in_domain_func in_domain_callback;
+            in_range_func in_range_callback;
+            std::shared_ptr<Logger> info_log;
+    };
+}

rdbpy/include/rdb_include/utils.hpp

@@ -0,0 +1,8 @@
+#include <vector>
+
+namespace py_rocks {
+    template <typename T>
+    const T* vector_data(std::vector<T>& v) {
+        return v.data();
+    }
+}

rdbpy/include/rdb_include/write_batch_iter_helper.hpp

@@ -0,0 +1,65 @@
+#pragma once
+
+#include <vector>
+#include "rocksdb/write_batch.h"
+
+namespace py_rocks {
+
+class RecordItemsHandler: public rocksdb::WriteBatch::Handler {
+    public:
+        enum Optype {PutRecord, MergeRecord, DeleteRecord};
+
+        class BatchItem {
+            public:
+                BatchItem(
+                    const Optype& op,
+                    uint32_t column_family_id,
+                    const rocksdb::Slice& key,
+                    const rocksdb::Slice& value):
+                        op(op),
+                        column_family_id(column_family_id),
+                        key(key),
+                        value(value)
+                {}
+
+            const Optype op;
+            uint32_t column_family_id;
+            const rocksdb::Slice key;
+            const rocksdb::Slice value;
+        };
+
+        typedef std::vector<BatchItem> BatchItems;
+
+    public:
+        /* Items is filled during iteration. */
+        RecordItemsHandler(BatchItems* items): items(items) {}
+
+        virtual rocksdb::Status PutCF(
+          uint32_t column_family_id, const Slice& key, const Slice& value) {
+            this->items->emplace_back(PutRecord, column_family_id, key, value);
+            return rocksdb::Status::OK();
+        }
+
+        virtual rocksdb::Status MergeCF(
+          uint32_t column_family_id, const Slice& key, const Slice& value) {
+            this->items->emplace_back(MergeRecord, column_family_id, key, value);
+            return rocksdb::Status::OK();
+        }
+
+        virtual rocksdb::Status DeleteCF(
+          uint32_t column_family_id, const Slice& key) {
+            this->items->emplace_back(DeleteRecord, column_family_id, key, rocksdb::Slice());
+            return rocksdb::Status::OK();
+        }
+
+    private:
+        BatchItems* items;
+};
+
+rocksdb::Status
+get_batch_items(const rocksdb::WriteBatch* batch, RecordItemsHandler::BatchItems* items) {
+    RecordItemsHandler handler(items);
+    return batch->Iterate(&handler);
+}
+
+}

rdbpy/interfaces.py

@@ -0,0 +1,77 @@
+from abc import ABCMeta, abstractmethod
+
+
+class Comparator:
+    __metaclass__ = ABCMeta
+
+    @abstractmethod
+    def compare(self, a, b):
+        pass
+
+    @abstractmethod
+    def name(self):
+        pass
+
+
+class AssociativeMergeOperator:
+    __metaclass__ = ABCMeta
+
+    @abstractmethod
+    def merge(self, key, existing_value, value):
+        pass
+
+    @abstractmethod
+    def name(self):
+        pass
+
+
+class MergeOperator:
+    __metaclass__ = ABCMeta
+
+    @abstractmethod
+    def full_merge(self, key, existing_value, operand_list):
+        pass
+
+    @abstractmethod
+    def partial_merge(self, key, left_operand, right_operand):
+        pass
+
+    @abstractmethod
+    def name(self):
+        pass
+
+
+class FilterPolicy:
+    __metaclass__ = ABCMeta
+
+    @abstractmethod
+    def name(self):
+        pass
+
+    @abstractmethod
+    def create_filter(self, keys):
+        pass
+
+    @abstractmethod
+    def key_may_match(self, key, filter_):
+        pass
+
+
+class SliceTransform:
+    __metaclass__ = ABCMeta
+
+    @abstractmethod
+    def name(self):
+        pass
+
+    @abstractmethod
+    def transform(self, src):
+        pass
+
+    @abstractmethod
+    def in_domain(self, src):
+        pass
+
+    @abstractmethod
+    def in_range(self, dst):
+        pass

rdbpy/iterator.pxd

@@ -0,0 +1,16 @@
+from libcpp cimport bool as cpp_bool
+from rdbpy.slice_ cimport Slice
+from rdbpy.status cimport Status
+
+cdef extern from "rocksdb/iterator.h" namespace "rocksdb":
+    cdef cppclass Iterator:
+        cpp_bool Valid() nogil except+
+        void SeekToFirst() nogil except+
+        void SeekToLast() nogil except+
+        void Seek(const Slice&) nogil except+
+        void Next() nogil except+
+        void Prev() nogil except+
+        void SeekForPrev(const Slice&) nogil except+
+        Slice key() nogil except+
+        Slice value() nogil except+
+        Status status() nogil except+