From 3adae6db1348dabcbcf2266e43447442a7f898c6 Mon Sep 17 00:00:00 2001 From: Ziyang Hu Date: Fri, 15 Apr 2022 12:41:11 +0800 Subject: [PATCH] simplify types --- cozo-rocks/include/cozorocks.h | 20 ++--- cozo-rocks/src/lib.rs | 156 +++++++++++++++++++-------------- 2 files changed, 102 insertions(+), 74 deletions(-) diff --git a/cozo-rocks/include/cozorocks.h b/cozo-rocks/include/cozorocks.h index a5af1ac2..3867eb11 100644 --- a/cozo-rocks/include/cozorocks.h +++ b/cozo-rocks/include/cozorocks.h @@ -26,11 +26,11 @@ std::unique_ptr new_db(); struct ReadOptionsBridge { mutable RDB::ReadOptions inner; - inline void set_verify_checksums(bool v) const { + inline void do_set_verify_checksums(bool v) const { inner.verify_checksums = v; } - inline void set_total_order_seek(bool v) const { + inline void do_set_total_order_seek(bool v) const { inner.total_order_seek = v; } }; @@ -39,7 +39,7 @@ struct WriteOptionsBridge { mutable RDB::WriteOptions inner; public: - inline void set_disable_wal(bool v) const { + inline void do_set_disable_wal(bool v) const { inner.disableWAL = v; } }; @@ -79,23 +79,23 @@ struct OptionsBridge { mutable RustComparator cmp_obj; public: - inline void prepare_for_bulk_load() const { + inline void do_prepare_for_bulk_load() const { inner.PrepareForBulkLoad(); } - inline void increase_parallelism() const { + inline void do_increase_parallelism() const { inner.IncreaseParallelism(); } - inline void optimize_level_style_compaction() const { + inline void do_optimize_level_style_compaction() const { inner.OptimizeLevelStyleCompaction(); }; - inline void set_create_if_missing(bool v) const { + inline void do_set_create_if_missing(bool v) const { inner.create_if_missing = v; } - inline void set_comparator(rust::Str name, RustComparatorFn f) const { + inline void do_set_comparator(rust::Str name, RustComparatorFn f) const { cmp_obj = RustComparator(); cmp_obj.set_name(name); cmp_obj.set_fn(f); @@ -168,12 +168,12 @@ struct IteratorBridge { return inner->Valid(); } - inline void seek(rust::Slice key) const { + inline void do_seek(rust::Slice key) const { auto k = RDB::Slice(reinterpret_cast(key.data()), key.size()); inner->Seek(k); } - inline void seek_for_prev(rust::Slice key) const { + inline void do_seek_for_prev(rust::Slice key) const { auto k = RDB::Slice(reinterpret_cast(key.data()), key.size()); inner->SeekForPrev(k); } diff --git a/cozo-rocks/src/lib.rs b/cozo-rocks/src/lib.rs index 9a3fa123..c7c41912 100644 --- a/cozo-rocks/src/lib.rs +++ b/cozo-rocks/src/lib.rs @@ -1,14 +1,14 @@ #[cxx::bridge] mod ffi { #[derive(Copy, Clone, Debug, Eq, PartialEq)] - struct Status { + pub struct Status { code: StatusCode, subcode: StatusSubCode, severity: StatusSeverity, } #[derive(Copy, Clone, Debug, Eq, PartialEq)] - enum StatusCode { + pub enum StatusCode { kOk = 0, kNotFound = 1, kCorruption = 2, @@ -29,7 +29,7 @@ mod ffi { } #[derive(Copy, Clone, Debug, Eq, PartialEq)] - enum StatusSubCode { + pub enum StatusSubCode { kNone = 0, kMutexTimeout = 1, kLockTimeout = 2, @@ -49,7 +49,7 @@ mod ffi { } #[derive(Copy, Clone, Debug, Eq, PartialEq)] - enum StatusSeverity { + pub enum StatusSeverity { kNoError = 0, kSoftError = 1, kHardError = 2, @@ -66,27 +66,27 @@ mod ffi { type StatusSeverity; type PinnableSliceBridge; - fn as_bytes(self: &PinnableSliceBridge) -> &[u8]; + pub fn as_bytes(self: &PinnableSliceBridge) -> &[u8]; type SliceBridge; - fn as_bytes(self: &SliceBridge) -> &[u8]; + pub fn as_bytes(self: &SliceBridge) -> &[u8]; type ReadOptionsBridge; fn new_read_options() -> UniquePtr; - fn set_verify_checksums(self: &ReadOptionsBridge, v: bool); - fn set_total_order_seek(self: &ReadOptionsBridge, v: bool); + pub fn do_set_verify_checksums(self: &ReadOptionsBridge, v: bool); + pub fn do_set_total_order_seek(self: &ReadOptionsBridge, v: bool); type WriteOptionsBridge; fn new_write_options() -> UniquePtr; - fn set_disable_wal(self: &WriteOptionsBridge, v: bool); + pub fn do_set_disable_wal(self: &WriteOptionsBridge, v: bool); type OptionsBridge; fn new_options() -> UniquePtr; - fn prepare_for_bulk_load(self: &OptionsBridge); - fn increase_parallelism(self: &OptionsBridge); - fn optimize_level_style_compaction(self: &OptionsBridge); - fn set_create_if_missing(self: &OptionsBridge, v: bool); - fn set_comparator(self: &OptionsBridge, name: &str, compare: fn(&[u8], &[u8]) -> i8); + pub fn do_prepare_for_bulk_load(self: &OptionsBridge); + pub fn do_increase_parallelism(self: &OptionsBridge); + pub fn do_optimize_level_style_compaction(self: &OptionsBridge); + pub fn do_set_create_if_missing(self: &OptionsBridge, v: bool); + pub fn do_set_comparator(self: &OptionsBridge, name: &str, compare: fn(&[u8], &[u8]) -> i8); type DBBridge; fn list_column_families(options: &OptionsBridge, path: &[u8]) -> UniquePtr>; @@ -100,101 +100,110 @@ mod ffi { type WriteBatchBridge; type IteratorBridge; - fn seek_to_first(self: &IteratorBridge); - fn seek_to_last(self: &IteratorBridge); - fn next(self: &IteratorBridge); - fn is_valid(self: &IteratorBridge) -> bool; - fn seek(self: &IteratorBridge, key: &[u8]); - fn seek_for_prev(self: &IteratorBridge, key: &[u8]); - fn key(self: &IteratorBridge) -> UniquePtr; - fn value(self: &IteratorBridge) -> UniquePtr; - fn status(self: &IteratorBridge) -> Status; + pub fn seek_to_first(self: &IteratorBridge); + pub fn seek_to_last(self: &IteratorBridge); + pub fn next(self: &IteratorBridge); + pub fn is_valid(self: &IteratorBridge) -> bool; + fn do_seek(self: &IteratorBridge, key: &[u8]); + fn do_seek_for_prev(self: &IteratorBridge, key: &[u8]); + pub fn key(self: &IteratorBridge) -> UniquePtr; + pub fn value(self: &IteratorBridge) -> UniquePtr; + pub fn status(self: &IteratorBridge) -> Status; } } +pub use ffi::{Status, StatusCode, StatusSubCode, StatusSeverity}; use std::collections::BTreeMap; use cxx::UniquePtr; -pub use ffi::*; +use ffi::*; -pub struct Options { - bridge: UniquePtr, +pub type Options = UniquePtr; + +pub trait OptionsTrait { + fn prepare_for_bulk_load(self) -> Self; + fn increase_parallelism(self) -> Self; + fn optimize_level_style_compaction(self) -> Self; + fn set_create_if_missing(self, v: bool) -> Self; + fn set_comparator(self, name: &str, compare: fn(&[u8], &[u8]) -> i8) -> Self; + fn default() -> Self; } -impl Options { +impl OptionsTrait for Options { #[inline] - pub fn prepare_for_bulk_load(self) -> Self { - self.bridge.prepare_for_bulk_load(); + fn prepare_for_bulk_load(self) -> Self { + self.do_prepare_for_bulk_load(); self } #[inline] - pub fn increase_parallelism(self) -> Self { - self.bridge.increase_parallelism(); + fn increase_parallelism(self) -> Self { + self.do_increase_parallelism(); self } #[inline] - pub fn optimize_level_style_compaction(self) -> Self { - self.bridge.optimize_level_style_compaction(); + fn optimize_level_style_compaction(self) -> Self { + self.do_optimize_level_style_compaction(); self } #[inline] - pub fn set_create_if_missing(self, v: bool) -> Self { - self.bridge.set_create_if_missing(v); + fn set_create_if_missing(self, v: bool) -> Self { + self.do_set_create_if_missing(v); self } #[inline] - pub fn set_comparator(self, name: &str, compare: fn(&[u8], &[u8]) -> i8) -> Self { - self.bridge.set_comparator(name, compare); + fn set_comparator(self, name: &str, compare: fn(&[u8], &[u8]) -> i8) -> Self { + self.do_set_comparator(name, compare); self } -} -impl Default for Options { #[inline] fn default() -> Self { - Self { bridge: new_options() } + new_options() } } -pub struct ReadOptions { - bridge: UniquePtr, +pub type ReadOptions = UniquePtr; + +pub trait ReadOptionsTrait { + fn set_total_order_seek(self, v: bool) -> Self; + fn set_verify_checksums(self, v: bool) -> Self; + fn default() -> Self; } -impl ReadOptions { - pub fn set_total_order_seek(self, v: bool) -> Self { - self.bridge.set_total_order_seek(v); +impl ReadOptionsTrait for ReadOptions { + fn set_total_order_seek(self, v: bool) -> Self { + self.do_set_total_order_seek(v); self } - pub fn set_verify_checksums(self, v: bool) -> Self { - self.bridge.set_total_order_seek(v); + fn set_verify_checksums(self, v: bool) -> Self { + self.do_set_verify_checksums(v); self } -} -impl Default for ReadOptions { fn default() -> Self { - Self { bridge: new_read_options() } + new_read_options() } } -pub struct WriteOptions { - bridge: UniquePtr, +pub type WriteOptions = UniquePtr; + +pub trait WriteOptionsTrait { + fn set_disable_wal(self, v: bool) -> Self; + fn default() -> Self; } -impl WriteOptions { +impl WriteOptionsTrait for WriteOptions { #[inline] - pub fn set_disable_wal(&self, v: bool) { - self.bridge.set_disable_wal(v); + fn set_disable_wal(self, v: bool) -> Self { + self.do_set_disable_wal(v); + self } -} - -impl Default for WriteOptions { fn default() -> Self { - Self { bridge: new_write_options() } + new_write_options() } } @@ -202,6 +211,20 @@ pub type PinnableSlice = UniquePtr; pub type Slice = UniquePtr; pub type Iterator = UniquePtr; +pub trait IteratorTrait { + fn seek(&self, key: impl AsRef<[u8]>); + fn seek_for_prev(&self, key: impl AsRef<[u8]>); +} + +impl IteratorTrait for Iterator { + fn seek(&self, key: impl AsRef<[u8]>) { + self.do_seek(key.as_ref()); + } + fn seek_for_prev(&self, key: impl AsRef<[u8]>) { + self.do_seek_for_prev(key.as_ref()) + } +} + pub struct DB { bridge: UniquePtr, pub options: Options, @@ -224,7 +247,7 @@ fn get_path_bytes(path: &std::path::Path) -> &[u8] { impl DB { #[inline] pub fn list_column_families(options: &Options, path: impl AsRef) -> Vec { - let results = list_column_families(&options.bridge, get_path_bytes(path.as_ref())); + let results = list_column_families(&options, get_path_bytes(path.as_ref())); results.iter().map(|s| s.to_string_lossy().into_owned()).collect() } @@ -232,7 +255,7 @@ impl DB { pub fn open(options: Options, path: impl AsRef) -> Result { let mut status = Status::default(); let bridge = open_db( - &options.bridge, + &options, get_path_bytes(path.as_ref()), &mut status, ); @@ -254,7 +277,7 @@ impl DB { #[inline] pub fn put(&self, key: impl AsRef<[u8]>, val: impl AsRef<[u8]>, cf: usize, options: Option<&WriteOptions>) -> Result { let mut status = Status::default(); - self.bridge.put(&options.unwrap_or(&self.default_write_options).bridge, cf, + self.bridge.put(options.unwrap_or(&self.default_write_options), cf, key.as_ref(), val.as_ref(), &mut status); if status.code == StatusCode::kOk { @@ -268,7 +291,7 @@ impl DB { pub fn get(&self, key: impl AsRef<[u8]>, cf: usize, options: Option<&ReadOptions>) -> Result, Status> { let mut status = Status::default(); let slice = self.bridge.get( - &options.unwrap_or(&self.default_read_options).bridge, cf, + options.unwrap_or(&self.default_read_options), cf, key.as_ref(), &mut status); match status.code { StatusCode::kOk => Ok(Some(slice)), @@ -279,7 +302,12 @@ impl DB { #[inline] pub fn iterator(&self, cf: usize, options: Option<&ReadOptions>) -> Iterator { - self.bridge.iterator(&options.unwrap_or(&self.default_read_options).bridge, cf) + self.bridge.iterator(options.unwrap_or(&self.default_read_options), cf) + } + + #[inline] + pub fn write_batch(&self) -> UniquePtr { + self.bridge.write_batch() } }