rdbpython 0.2.6__cp314-cp314-macosx_11_0_arm64.whl

rdbpy/__init__.py

@@ -0,0 +1 @@
+from .lib_rocksdb import *

rdbpy/backup.pxd

@@ -0,0 +1,35 @@
+from libcpp cimport bool as cpp_bool
+from libcpp.string cimport string
+from libcpp.vector cimport vector
+from libc.stdint cimport uint32_t
+from libc.stdint cimport int64_t
+from libc.stdint cimport uint64_t
+
+from rdbpy.status cimport Status
+from rdbpy.db cimport DB
+from rdbpy.env cimport Env
+
+cdef extern from "rocksdb/utilities/backup_engine.h" namespace "rocksdb":
+    ctypedef uint32_t BackupID
+
+    cdef cppclass BackupEngineOptions:
+        BackupEngineOptions(const string& backup_dir)
+
+    cdef struct BackupInfo:
+        BackupID backup_id
+        int64_t timestamp
+        uint64_t size
+
+    cdef cppclass BackupEngine:
+        Status CreateNewBackup(DB*, cpp_bool) nogil except+
+        Status PurgeOldBackups(uint32_t) nogil except+
+        Status DeleteBackup(BackupID) nogil except+
+        void StopBackup() nogil except+
+        void GetBackupInfo(vector[BackupInfo]*) nogil except+
+        Status RestoreDBFromBackup(BackupID, string&, string&) nogil except+
+        Status RestoreDBFromLatestBackup(string&, string&) nogil except+
+
+    cdef Status BackupEngine_Open "rocksdb::BackupEngine::Open"(
+            Env*,
+            BackupEngineOptions&,
+            BackupEngine**)

rdbpy/cache.pxd

@@ -0,0 +1,8 @@
+from rdbpy.std_memory cimport shared_ptr
+
+cdef extern from "rocksdb/cache.h" namespace "rocksdb":
+    cdef cppclass Cache:
+        pass
+
+    cdef extern shared_ptr[Cache] NewLRUCache(size_t)
+    cdef extern shared_ptr[Cache] NewLRUCache(size_t, int)

rdbpy/comparator.pxd

@@ -0,0 +1,23 @@
+from libcpp.string cimport string
+from rdbpy.slice_ cimport Slice
+from rdbpy.logger cimport Logger
+from rdbpy.std_memory cimport shared_ptr
+
+cdef extern from "rocksdb/comparator.h" namespace "rocksdb":
+    cdef cppclass Comparator:
+        const char* Name()
+        int Compare(const Slice&, const Slice&) const
+
+    cdef extern const Comparator* BytewiseComparator() nogil except +
+
+ctypedef int (*compare_func)(
+    void*,
+    Logger*,
+    string&,
+    const Slice&,
+    const Slice&)
+
+cdef extern from "rdb_include/comparator_wrapper.hpp" namespace "py_rocks":
+    cdef cppclass ComparatorWrapper:
+        ComparatorWrapper(string, void*, compare_func) nogil except +
+        void set_info_log(shared_ptr[Logger]) nogil except+

rdbpy/db.pxd

@@ -0,0 +1,230 @@
+cimport rdbpy.options as options
+from libc.stdint cimport uint64_t, uint32_t
+from rdbpy.status cimport Status
+from libcpp cimport bool as cpp_bool
+from libcpp.string cimport string
+from libcpp.vector cimport vector
+from rdbpy.slice_ cimport Slice
+from rdbpy.snapshot cimport Snapshot
+from rdbpy.iterator cimport Iterator
+
+cdef extern from "rocksdb/write_batch.h" namespace "rocksdb":
+    cdef cppclass WriteBatch:
+        WriteBatch() nogil except+
+        WriteBatch(string) nogil except+
+        void Put(const Slice&, const Slice&) nogil except+
+        void Put(ColumnFamilyHandle*, const Slice&, const Slice&) nogil except+
+        void Merge(const Slice&, const Slice&) nogil except+
+        void Merge(ColumnFamilyHandle*, const Slice&, const Slice&) nogil except+
+        void Delete(const Slice&) nogil except+
+        void Delete(ColumnFamilyHandle*, const Slice&) nogil except+
+        void DeleteRange(const Slice&, const Slice&) nogil except+
+        void DeleteRange(ColumnFamilyHandle*, const Slice&, const Slice&) nogil except+
+        void PutLogData(const Slice&) nogil except+
+        void Clear() nogil except+
+        const string& Data() nogil except+
+        int Count() nogil except+
+
+cdef extern from "rdb_include/write_batch_iter_helper.hpp" namespace "py_rocks":
+    cdef enum BatchItemOp "RecordItemsHandler::Optype":
+        BatchItemOpPut "py_rocks::RecordItemsHandler::Optype::PutRecord"
+        BatchItemOpMerge "py_rocks::RecordItemsHandler::Optype::MergeRecord"
+        BatchItemOpDelte "py_rocks::RecordItemsHandler::Optype::DeleteRecord"
+
+    cdef cppclass BatchItem "py_rocks::RecordItemsHandler::BatchItem":
+        BatchItemOp op
+        uint32_t column_family_id
+        Slice key
+        Slice value
+
+    Status get_batch_items(WriteBatch* batch, vector[BatchItem]* items)
+
+
+cdef extern from "rocksdb/db.h" namespace "rocksdb":
+    ctypedef uint64_t SequenceNumber
+    string kDefaultColumnFamilyName
+
+    cdef struct LiveFileMetaData:
+        string name
+        int level
+        uint64_t size
+        string smallestkey
+        string largestkey
+        SequenceNumber smallest_seqno
+        SequenceNumber largest_seqno
+
+    cdef cppclass Range:
+        Range(const Slice&, const Slice&)
+
+    cdef cppclass DB:
+        Status Put(
+            const options.WriteOptions&,
+            ColumnFamilyHandle*,
+            const Slice&,
+            const Slice&) nogil except+
+
+        Status Delete(
+            const options.WriteOptions&,
+            ColumnFamilyHandle*,
+            const Slice&) nogil except+
+
+        Status DeleteRange(
+            const options.WriteOptions&,
+            ColumnFamilyHandle*,
+            const Slice&,
+            const Slice&) nogil except+
+
+        Status Merge(
+            const options.WriteOptions&,
+            ColumnFamilyHandle*,
+            const Slice&,
+            const Slice&) nogil except+
+
+        Status Write(
+            const options.WriteOptions&,
+            WriteBatch*) nogil except+
+
+        Status Get(
+            const options.ReadOptions&,
+            ColumnFamilyHandle*,
+            const Slice&,
+            string*) nogil except+
+
+        vector[Status] MultiGet(
+            const options.ReadOptions&,
+            const vector[ColumnFamilyHandle*]&,
+            const vector[Slice]&,
+            vector[string]*) nogil except+
+
+        cpp_bool KeyMayExist(
+            const options.ReadOptions&,
+            ColumnFamilyHandle*,
+            Slice&,
+            string*,
+            cpp_bool*) nogil except+
+
+        cpp_bool KeyMayExist(
+            const options.ReadOptions&,
+            ColumnFamilyHandle*,
+            Slice&,
+            string*) nogil except+
+
+        Iterator* NewIterator(
+            const options.ReadOptions&,
+            ColumnFamilyHandle*) nogil except+
+
+        void NewIterators(
+            const options.ReadOptions&,
+            vector[ColumnFamilyHandle*]&,
+            vector[Iterator*]*) nogil except+
+
+        const Snapshot* GetSnapshot() nogil except+
+
+        void ReleaseSnapshot(const Snapshot*) nogil except+
+
+        cpp_bool GetProperty(
+            ColumnFamilyHandle*,
+            const Slice&,
+            string*) nogil except+
+
+        void GetApproximateSizes(
+            ColumnFamilyHandle*,
+            const Range*
+            int,
+            uint64_t*) nogil except+
+
+        Status CompactRange(
+            const options.CompactRangeOptions&,
+            ColumnFamilyHandle*,
+            const Slice*,
+            const Slice*) nogil except+
+
+        Status CreateColumnFamily(
+            const options.ColumnFamilyOptions&,
+            const string&,
+            ColumnFamilyHandle**) nogil except+
+
+        Status DropColumnFamily(
+            ColumnFamilyHandle*) nogil except+
+
+        int NumberLevels(ColumnFamilyHandle*) nogil except+
+        int MaxMemCompactionLevel(ColumnFamilyHandle*) nogil except+
+        int Level0StopWriteTrigger(ColumnFamilyHandle*) nogil except+
+        const string& GetName() nogil except+
+        const options.Options& GetOptions(ColumnFamilyHandle*) nogil except+
+        Status Flush(const options.FlushOptions&, ColumnFamilyHandle*) nogil except+
+        Status FlushWAL(cpp_bool sync) nogil except+
+        Status DisableFileDeletions() nogil except+
+        Status EnableFileDeletions() nogil except+
+
+        Status TryCatchUpWithPrimary() nogil except+
+
+        # TODO: Status GetSortedWalFiles(VectorLogPtr& files)
+        # TODO: SequenceNumber GetLatestSequenceNumber()
+        # TODO: Status GetUpdatesSince(
+                  # SequenceNumber seq_number,
+                  # unique_ptr[TransactionLogIterator]*)
+
+        Status DeleteFile(string) nogil except+
+        void GetLiveFilesMetaData(vector[LiveFileMetaData]*) nogil except+
+        ColumnFamilyHandle* DefaultColumnFamily()
+
+
+    cdef Status DB_Open "rocksdb::DB::Open"(
+        const options.Options&,
+        const string&,
+        DB**) nogil except+
+
+    cdef Status DB_Open_ColumnFamilies "rocksdb::DB::Open"(
+        const options.Options&,
+        const string&,
+        const vector[ColumnFamilyDescriptor]&,
+        vector[ColumnFamilyHandle*]*,
+        DB**) nogil except+
+
+    cdef Status DB_OpenForReadOnly "rocksdb::DB::OpenForReadOnly"(
+        const options.Options&,
+        const string&,
+        DB**,
+        cpp_bool) nogil except+
+
+    cdef Status DB_OpenForReadOnly_ColumnFamilies "rocksdb::DB::OpenForReadOnly"(
+        const options.Options&,
+        const string&,
+        const vector[ColumnFamilyDescriptor]&,
+        vector[ColumnFamilyHandle*]*,
+        DB**,
+        cpp_bool) nogil except+
+
+    cdef Status DB_OpenAsSecondary "rocksdb::DB::OpenAsSecondary"(
+        const options.Options&,
+        const string&,
+        const string&,
+        DB**) nogil except+
+
+    cdef Status DB_OpenAsSecondary_ColumnFamilies "rocksdb::DB::OpenAsSecondary"(
+        const options.Options&,
+        const string&,
+        const string&,
+        const vector[ColumnFamilyDescriptor]&,
+        vector[ColumnFamilyHandle*]*,
+        DB**) nogil except+
+
+    cdef Status RepairDB(const string& dbname, const options.Options&)
+
+    cdef Status ListColumnFamilies "rocksdb::DB::ListColumnFamilies" (
+        const options.Options&,
+        const string&,
+        vector[string]*) nogil except+
+
+    cdef cppclass ColumnFamilyHandle:
+        const string& GetName() nogil except+
+        int GetID() nogil except+
+
+    cdef cppclass ColumnFamilyDescriptor:
+        ColumnFamilyDescriptor() nogil except+
+        ColumnFamilyDescriptor(
+	    const string&,
+            const options.ColumnFamilyOptions&) nogil except+
+        string name
+        options.ColumnFamilyOptions options

rdbpy/env.pxd

@@ -0,0 +1,5 @@
+cdef extern from "rocksdb/env.h" namespace "rocksdb":
+    cdef cppclass Env:
+        Env()
+
+    cdef Env* Env_Default "rocksdb::Env::Default"()

rdbpy/errors.py

@@ -0,0 +1,26 @@
+class NotFound(Exception):
+    pass
+
+
+class Corruption(Exception):
+    pass
+
+
+class NotSupported(Exception):
+    pass
+
+
+class InvalidArgument(Exception):
+    pass
+
+
+class RocksIOError(Exception):
+    pass
+
+
+class MergeInProgress(Exception):
+    pass
+
+
+class Incomplete(Exception):
+    pass

rdbpy/filter_policy.pxd

@@ -0,0 +1,39 @@
+from libcpp cimport bool as cpp_bool
+from libcpp.string cimport string
+from libc.string cimport const_char
+from rdbpy.slice_ cimport Slice
+from rdbpy.std_memory cimport shared_ptr
+from rdbpy.logger cimport Logger
+
+cdef extern from "rocksdb/filter_policy.h" namespace "rocksdb":
+    cdef cppclass FilterPolicy:
+        void CreateFilter(const Slice*, int, string*) nogil except+
+        cpp_bool KeyMayMatch(const Slice&, const Slice&) nogil except+
+        const_char* Name() nogil except+
+
+    cdef extern const FilterPolicy* NewBloomFilterPolicy(int) nogil except+
+
+ctypedef void (*create_filter_func)(
+    void*,
+    Logger*,
+    string&,
+    const Slice*,
+    int,
+    string*)
+
+ctypedef cpp_bool (*key_may_match_func)(
+    void*,
+    Logger*,
+    string&,
+    const Slice&,
+    const Slice&)
+
+cdef extern from "rdb_include/filter_policy_wrapper.hpp" namespace "py_rocks":
+    cdef cppclass FilterPolicyWrapper:
+        FilterPolicyWrapper(
+            string,
+            void*,
+            create_filter_func,
+            key_may_match_func) nogil except+
+
+        void set_info_log(shared_ptr[Logger]) nogil except+

rdbpy/include/rdb_include/comparator_wrapper.hpp

@@ -0,0 +1,63 @@
+#include "rocksdb/comparator.h"
+#include "rocksdb/env.h"
+#include <stdexcept>
+
+using std::string;
+using rocksdb::Comparator;
+using rocksdb::Slice;
+using rocksdb::Logger;
+
+namespace py_rocks {
+    class ComparatorWrapper: public Comparator {
+        public:
+            typedef int (*compare_func)(
+                void*,
+                Logger*,
+                string&,
+                const Slice&,
+                const Slice&);
+
+            ComparatorWrapper(
+                string name,
+                void* compare_context,
+                compare_func compare_callback):
+                    name(name),
+                    compare_context(compare_context),
+                    compare_callback(compare_callback)
+            {}
+
+            virtual int Compare(const Slice& a, const Slice& b) const {
+                string error_msg;
+                int val;
+
+                val = this->compare_callback(
+                    this->compare_context,
+                    this->info_log.get(),
+                    error_msg,
+                    a,
+                    b);
+
+                if (error_msg.size()) {
+                    throw std::runtime_error(error_msg.c_str());
+                }
+                return val;
+            }
+
+            virtual const char* Name() const {
+                return this->name.c_str();
+            }
+
+            virtual void FindShortestSeparator(string*, const Slice&) const {}
+            virtual void FindShortSuccessor(string*) const {}
+
+            void set_info_log(std::shared_ptr<Logger> info_log) {
+                this->info_log = info_log;
+            }
+
+        private:
+            string name;
+            void* compare_context;
+            compare_func compare_callback;
+            std::shared_ptr<Logger> info_log;
+    };
+}

rdbpy/include/rdb_include/filter_policy_wrapper.hpp

@@ -0,0 +1,89 @@
+#include "rocksdb/filter_policy.h"
+#include "rocksdb/env.h"
+#include <stdexcept>
+
+using std::string;
+using rocksdb::FilterPolicy;
+using rocksdb::Slice;
+using rocksdb::Logger;
+
+namespace py_rocks {
+    class FilterPolicyWrapper: public FilterPolicy {
+        public:
+            typedef void (*create_filter_func)(
+                void* ctx,
+                Logger*,
+                string&,
+                const Slice* keys,
+                int n,
+                string* dst);
+
+            typedef bool (*key_may_match_func)(
+                void* ctx,
+                Logger*,
+                string&,
+                const Slice& key,
+                const Slice& filter);
+
+            FilterPolicyWrapper(
+                string name,
+                void* ctx,
+                create_filter_func create_filter_callback,
+                key_may_match_func key_may_match_callback):
+                    name(name),
+                    ctx(ctx),
+                    create_filter_callback(create_filter_callback),
+                    key_may_match_callback(key_may_match_callback)
+            {}
+
+            virtual void
+            CreateFilter(const Slice* keys, int n, std::string* dst) const {
+                string error_msg;
+
+                this->create_filter_callback(
+                    this->ctx,
+                    this->info_log.get(),
+                    error_msg,
+                    keys,
+                    n,
+                    dst);
+
+                if (error_msg.size()) {
+                    throw std::runtime_error(error_msg.c_str());
+                }
+            }
+
+            virtual bool
+            KeyMayMatch(const Slice& key, const Slice& filter) const {
+                string error_msg;
+                bool val;
+
+                val = this->key_may_match_callback(
+                    this->ctx,
+                    this->info_log.get(),
+                    error_msg,
+                    key,
+                    filter);
+
+                if (error_msg.size()) {
+                    throw std::runtime_error(error_msg.c_str());
+                }
+                return val;
+            }
+
+            virtual const char* Name() const {
+                return this->name.c_str();
+            }
+
+            void set_info_log(std::shared_ptr<Logger> info_log) {
+                this->info_log = info_log;
+            }
+
+        private:
+            string name;
+            void* ctx;
+            create_filter_func create_filter_callback;
+            key_may_match_func key_may_match_callback;
+            std::shared_ptr<Logger> info_log;
+    };
+}

rdbpy/include/rdb_include/memtable_factories.hpp

@@ -0,0 +1,15 @@
+#include "rocksdb/memtablerep.h"
+
+using rocksdb::MemTableRepFactory;
+using rocksdb::VectorRepFactory;
+using rocksdb::SkipListFactory;
+
+namespace py_rocks {
+    MemTableRepFactory* NewVectorRepFactory(size_t count = 0) {
+        return new VectorRepFactory(count);
+    }
+
+    MemTableRepFactory* NewSkipListFactory() {
+        return new SkipListFactory();
+    }
+}

rdbpy/include/rdb_include/merge_operator_wrapper.hpp

@@ -0,0 +1,132 @@
+#include "rocksdb/merge_operator.h"
+
+using std::string;
+using std::deque;
+using rocksdb::Slice;
+using rocksdb::Logger;
+using rocksdb::MergeOperator;
+using rocksdb::AssociativeMergeOperator;
+
+namespace py_rocks {
+    class AssociativeMergeOperatorWrapper: public AssociativeMergeOperator {
+        public:
+            typedef bool (*merge_func)(
+                    void*, 
+                    const Slice& key,
+                    const Slice* existing_value,
+                    const Slice& value,
+                    std::string* new_value,
+                    Logger* logger);
+
+
+            AssociativeMergeOperatorWrapper(
+                string name,
+                void* merge_context,
+                merge_func merge_callback):
+                    name(name),
+                    merge_context(merge_context),
+                    merge_callback(merge_callback)
+            {}
+
+            virtual bool Merge(
+                const Slice& key,
+                const Slice* existing_value,
+                const Slice& value,
+                std::string* new_value,
+                Logger* logger) const 
+            {
+                return this->merge_callback(
+                    this->merge_context,
+                    key,
+                    existing_value,
+                    value,
+                    new_value,
+                    logger);
+            }
+
+            virtual const char* Name() const {
+                return this->name.c_str();
+            }
+
+        private:
+            string name;
+            void* merge_context;
+            merge_func merge_callback;
+    };
+
+    class MergeOperatorWrapper: public MergeOperator {
+        public:
+            typedef bool (*full_merge_func)(
+                void* ctx,
+                const Slice& key,
+                const Slice* existing_value,
+                const deque<string>& operand_list,
+                string* new_value,
+                Logger* logger);
+
+            typedef bool (*partial_merge_func)(
+                void* ctx,
+                const Slice& key,
+                const Slice& left_op,
+                const Slice& right_op,
+                string* new_value,
+                Logger* logger);
+
+            MergeOperatorWrapper(
+                string name,
+                void* full_merge_context,
+                void* partial_merge_context,
+                full_merge_func full_merge_callback,
+                partial_merge_func partial_merge_callback):
+                    name(name),
+                    full_merge_context(full_merge_context),
+                    partial_merge_context(partial_merge_context),
+                    full_merge_callback(full_merge_callback),
+                    partial_merge_callback(partial_merge_callback)
+            {}
+
+            virtual bool FullMerge(
+                const Slice& key,
+                const Slice* existing_value,
+                const deque<string>& operand_list,
+                string* new_value,
+                Logger* logger) const 
+            {
+                return this->full_merge_callback(
+                    this->full_merge_context,
+                    key,
+                    existing_value,
+                    operand_list,
+                    new_value,
+                    logger);
+            }
+
+            virtual bool PartialMerge (
+                const Slice& key,
+                const Slice& left_operand,
+                const Slice& right_operand,
+                string* new_value,
+                Logger* logger) const
+            {
+                return this->partial_merge_callback(
+                    this->partial_merge_context,
+                    key,
+                    left_operand,
+                    right_operand,
+                    new_value,
+                    logger);
+            }
+            
+            virtual const char* Name() const {
+                return this->name.c_str();
+            }
+
+        private:
+            string name;
+            void* full_merge_context;
+            void* partial_merge_context;
+            full_merge_func full_merge_callback;
+            partial_merge_func partial_merge_callback;
+
+        };
+}