diff --git a/cozorocks/bridge/cozorocks.cc b/cozorocks/bridge/cozorocks.cc index d310571b..91abd1db 100644 --- a/cozorocks/bridge/cozorocks.cc +++ b/cozorocks/bridge/cozorocks.cc @@ -19,50 +19,52 @@ BridgeStatus IteratorBridge::status() const { return s; } -unique_ptr> TransactionBridge::multiget_txn( - const ColumnFamilyHandle &cf, - rust::Slice> keys, - rust::Slice statuses) const { - auto cpp_keys = vector(); - cpp_keys.reserve(keys.size()); - for (auto key: keys) { - auto cpp_key = convert_slice(key); - cpp_keys.push_back(cpp_key); - } - auto ret = make_unique>(keys.size()); - auto cpp_statuses = vector(keys.size()); - inner->MultiGet(*r_ops, - const_cast(&cf), - keys.size(), - cpp_keys.data(), - ret->data(), - cpp_statuses.data()); - for (size_t i = 0; i < cpp_statuses.size(); ++i) { - write_status(std::move(cpp_statuses[i]), statuses[i]); - } - return ret; -} - -unique_ptr> TransactionBridge::multiget_raw( - const ColumnFamilyHandle &cf, - rust::Slice> keys, - rust::Slice statuses) const { - auto cpp_keys = vector(); - cpp_keys.reserve(keys.size()); - for (auto key: keys) { - auto cpp_key = convert_slice(key); - cpp_keys.push_back(cpp_key); - } - auto ret = make_unique>(keys.size()); - auto cpp_statuses = vector(keys.size()); - raw_db->MultiGet(*r_ops, - const_cast(&cf), - keys.size(), - cpp_keys.data(), - ret->data(), - cpp_statuses.data()); - for (size_t i = 0; i < cpp_statuses.size(); ++i) { - write_status(std::move(cpp_statuses[i]), statuses[i]); - } - return ret; -} \ No newline at end of file +//unique_ptr> TransactionBridge::multiget_txn( +//// const ColumnFamilyHandle &cf, +// rust::Slice> keys, +// rust::Slice statuses) const { +// auto cpp_keys = vector(); +// cpp_keys.reserve(keys.size()); +// for (auto key: keys) { +// auto cpp_key = convert_slice(key); +// cpp_keys.push_back(cpp_key); +// } +// auto ret = make_unique>(keys.size()); +// auto cpp_statuses = vector(keys.size()); +// inner->MultiGet(*r_ops, +// raw_db->DefaultColumnFamily(), +//// const_cast(&cf), +// keys.size(), +// cpp_keys.data(), +// ret->data(), +// cpp_statuses.data()); +// for (size_t i = 0; i < cpp_statuses.size(); ++i) { +// write_status(std::move(cpp_statuses[i]), statuses[i]); +// } +// return ret; +//} +// +//unique_ptr> TransactionBridge::multiget_raw( +//// const ColumnFamilyHandle &cf, +// rust::Slice> keys, +// rust::Slice statuses) const { +// auto cpp_keys = vector(); +// cpp_keys.reserve(keys.size()); +// for (auto key: keys) { +// auto cpp_key = convert_slice(key); +// cpp_keys.push_back(cpp_key); +// } +// auto ret = make_unique>(keys.size()); +// auto cpp_statuses = vector(keys.size()); +// raw_db->MultiGet(*r_ops, +// raw_db->DefaultColumnFamily(), +//// const_cast(&cf), +// keys.size(), +// cpp_keys.data(), +// ret->data(), +// cpp_statuses.data()); +// for (size_t i = 0; i < cpp_statuses.size(); ++i) { +// write_status(std::move(cpp_statuses[i]), statuses[i]); +// } +// return ret; +//} \ No newline at end of file diff --git a/cozorocks/bridge/cozorocks.h b/cozorocks/bridge/cozorocks.h index 77a50640..fa07fc8d 100644 --- a/cozorocks/bridge/cozorocks.h +++ b/cozorocks/bridge/cozorocks.h @@ -215,13 +215,12 @@ struct IteratorBridge { inner->SeekForPrev(k); } - inline std::shared_ptr key_raw() const { -// std::cout << "c++ get " << inner->key().size() << std::endl; - return std::make_shared(inner->key()); + inline std::unique_ptr key_raw() const { + return std::make_unique(inner->key()); } - inline std::shared_ptr value_raw() const { - return std::make_shared(inner->value()); + inline std::unique_ptr value_raw() const { + return std::make_unique(inner->value()); } inline void refresh(BridgeStatus &status) const { @@ -246,6 +245,14 @@ inline unique_ptr new_optimistic_transaction_optio return ret; } +inline void reset_pinnable_slice(PinnableSlice &slice) { + slice.Reset(); +} + +unique_ptr new_pinnable_slice() { + return make_unique(); +} + struct TransactionBridge { DB *raw_db; unique_ptr inner; @@ -282,193 +289,123 @@ struct TransactionBridge { write_status(inner->PopSavePoint(), status); } - unique_ptr> multiget_txn( - const ColumnFamilyHandle &cf, - rust::Slice> keys, - rust::Slice statuses) const; - - unique_ptr> multiget_raw( - const ColumnFamilyHandle &cf, - rust::Slice> keys, - rust::Slice statuses) const; - - - inline shared_ptr get_txn( - const ColumnFamilyHandle &cf, + inline void get_txn( rust::Slice key, + PinnableSlice &pinnable_val, BridgeStatus &status ) const { - auto pinnable_val = std::make_shared(); - write_status( - inner->Get(*r_ops, - const_cast(&cf), - convert_slice(key), - &*pinnable_val), - status - ); - return pinnable_val; + write_status(inner->Get(*r_ops, convert_slice(key), &pinnable_val), status); } - inline shared_ptr get_for_update_txn( - const ColumnFamilyHandle &cf, + inline void get_for_update_txn( rust::Slice key, + PinnableSlice &pinnable_val, BridgeStatus &status ) const { - auto pinnable_val = std::make_shared(); write_status( inner->GetForUpdate(*r_ops, - const_cast(&cf), + raw_db->DefaultColumnFamily(), convert_slice(key), - &*pinnable_val), + &pinnable_val), status ); - return pinnable_val; } - inline std::shared_ptr get_raw( - const ColumnFamilyHandle &cf, + inline void get_raw( rust::Slice key, + PinnableSlice &pinnable_val, BridgeStatus &status ) const { - auto pinnable_val = std::make_shared(); write_status( raw_db->Get(*r_ops, - const_cast(&cf), + raw_db->DefaultColumnFamily(), convert_slice(key), - &*pinnable_val), + &pinnable_val), status ); - return pinnable_val; } inline void put_txn( - const ColumnFamilyHandle &cf, rust::Slice key, rust::Slice val, BridgeStatus &status ) const { - write_status( - inner->Put(const_cast(&cf), - convert_slice(key), - convert_slice(val)), - status - ); + write_status(inner->Put(convert_slice(key), convert_slice(val)), status); } inline void put_raw( - const ColumnFamilyHandle &cf, rust::Slice key, rust::Slice val, BridgeStatus &status ) const { auto k = convert_slice(key); auto v = convert_slice(val); -// std::cout << "c++ put " << key.size() << " " << k.size() << std::endl; - write_status( - raw_db->Put( - *raw_w_ops, - const_cast(&cf), - k, - v), - status - ); + write_status(raw_db->Put(*raw_w_ops, k, v), status); } inline void del_txn( - const ColumnFamilyHandle &cf, rust::Slice key, BridgeStatus &status ) const { - write_status( - inner->Delete(const_cast(&cf), - convert_slice(key)), - status - ); + write_status(inner->Delete(convert_slice(key)), status); } inline void del_raw( - const ColumnFamilyHandle &cf, rust::Slice key, BridgeStatus &status ) const { - write_status( - raw_db->Delete( - *raw_w_ops, - const_cast(&cf), - convert_slice(key)), - status - ); + write_status(raw_db->Delete(*raw_w_ops, convert_slice(key)), status); } inline void del_range_raw( - const ColumnFamilyHandle &cf, rust::Slice start_key, rust::Slice end_key, BridgeStatus &status ) const { write_status( raw_db->GetRootDB()->DeleteRange( - *raw_w_ops, const_cast(&cf), + *raw_w_ops, + raw_db->DefaultColumnFamily(), convert_slice(start_key), convert_slice(end_key)), status); } - inline void flush_raw(const ColumnFamilyHandle &cf, const FlushOptions &options, BridgeStatus &status) const { - write_status(raw_db->Flush(options, const_cast(&cf)), status); + inline void flush_raw(const FlushOptions &options, BridgeStatus &status) const { + write_status(raw_db->Flush(options), status); } - inline void compact_all_raw(const ColumnFamilyHandle &cf, BridgeStatus &status) const { + inline void compact_all_raw(BridgeStatus &status) const { auto options = CompactRangeOptions(); options.change_level = true; options.target_level = 0; options.exclusive_manual_compaction = false; - write_status(raw_db->CompactRange(options, const_cast(&cf), nullptr, nullptr), status); + write_status(raw_db->CompactRange(options, + raw_db->DefaultColumnFamily(), + nullptr, nullptr), status); } - inline std::unique_ptr iterator_txn( - const ColumnFamilyHandle &cf) const { + inline std::unique_ptr iterator_txn() const { return std::make_unique( - inner->GetIterator(*r_ops, const_cast(&cf))); + inner->GetIterator(*r_ops)); } - inline std::unique_ptr iterator_raw( - const ColumnFamilyHandle &cf) const { + inline std::unique_ptr iterator_raw() const { return std::make_unique( - raw_db->NewIterator(*raw_r_ops, const_cast(&cf))); + raw_db->NewIterator(*raw_r_ops)); } }; -inline tuple, vector> -get_cf_data(const Options &options, - const string &path) { - auto cf_names = std::vector(); - DB::ListColumnFamilies(options, path, &cf_names); - if (cf_names.empty()) { - cf_names.push_back(kDefaultColumnFamilyName); - } - - std::vector column_families; - - for (auto el: cf_names) { - column_families.push_back(ColumnFamilyDescriptor( - el, options)); - } - return std::make_tuple(cf_names, column_families); -} struct TDBBridge { mutable unique_ptr db; mutable TransactionDB *tdb; mutable OptimisticTransactionDB *odb; - mutable unordered_map> handles; - mutable Lock handle_lock; bool is_odb; TDBBridge(StackableDB *db_, TransactionDB *tdb_, - OptimisticTransactionDB *odb_, - unordered_map> &&handles_) : - db(db_), tdb(tdb_), odb(odb_), handles(handles_), handle_lock() { + OptimisticTransactionDB *odb_) : + db(db_), tdb(tdb_), odb(odb_) { is_odb = (tdb_ == nullptr); } @@ -513,64 +450,6 @@ struct TDBBridge { ret->inner = unique_ptr(txn); return ret; } - - inline shared_ptr get_cf_handle_raw(const string &name) const { - ReadLock r_lock(handle_lock); - try { - return handles.at(name); - } catch (const std::out_of_range &) { - return shared_ptr(nullptr); - } - } - - inline shared_ptr get_default_cf_handle_raw() const { - return handles.at("default"); - } - - inline shared_ptr - create_column_family_raw(const Options &options, const string &name, BridgeStatus &status) const { - { - ReadLock r_lock(handle_lock); - if (handles.find(name) != handles.end()) { - write_status_impl(status, StatusCode::kMaxCode, StatusSubCode::kMaxSubCode, - StatusSeverity::kSoftError, - 2); - return shared_ptr(nullptr); - } - } - { - WriteLock w_lock(handle_lock); - ColumnFamilyHandle *handle; - auto s = db->CreateColumnFamily(options, name, &handle); - write_status(std::move(s), status); - auto ret = shared_ptr(handle); - handles[name] = ret; - return ret; - } - } - - inline void drop_column_family_raw(const string &name, BridgeStatus &status) const { - WriteLock w_lock(handle_lock); - auto cf_it = handles.find(name); - if (cf_it != handles.end()) { - auto s = db->DropColumnFamily(cf_it->second.get()); - handles.erase(cf_it); - write_status(std::move(s), status); - } else { - write_status_impl(status, StatusCode::kMaxCode, StatusSubCode::kMaxSubCode, StatusSeverity::kSoftError, - 3); - } - // When should we call DestroyColumnFamilyHandle? - } - - inline unique_ptr> get_column_family_names_raw() const { - ReadLock r_lock(handle_lock); - auto ret = make_unique>(); - for (auto entry: handles) { - ret->push_back(entry.first); - } - return ret; - } }; inline unique_ptr new_tdb_options() { @@ -593,64 +472,34 @@ void set_allow_write_stall(FlushOptions &options, bool v) { options.allow_write_stall = v; } -inline unique_ptr +inline shared_ptr open_tdb_raw(const Options &options, const TransactionDBOptions &txn_db_options, const string &path, BridgeStatus &status) { - auto cf_info = get_cf_data(options, path); - auto cf_names = std::get<0>(cf_info); - auto column_families = std::get<1>(cf_info); - - std::vector handles; TransactionDB *txn_db = nullptr; - Status s = TransactionDB::Open(options, txn_db_options, path, - column_families, &handles, - &txn_db); + Status s = TransactionDB::Open(options, txn_db_options, path, &txn_db); auto ok = s.ok(); write_status(std::move(s), status); - unordered_map> handle_map; - if (ok) { - assert(handles.size() == cf_names.size()); - for (size_t i = 0; i < handles.size(); ++i) { - handle_map[cf_names[i]] = shared_ptr(handles[i]); - } - } - - return make_unique(txn_db, txn_db, nullptr, std::move(handle_map)); + return make_shared(txn_db, txn_db, nullptr); } -inline unique_ptr -open_odb_raw(const Options &options, - const OptimisticTransactionDBOptions &txn_db_options, - const string &path, - BridgeStatus &status) { - auto cf_info = get_cf_data(options, path); - auto cf_names = std::get<0>(cf_info); - auto column_families = std::get<1>(cf_info); - - - std::vector handles; +inline shared_ptr +open_odb_raw(const Options &options, const string &path, BridgeStatus &status) { OptimisticTransactionDB *txn_db = nullptr; - Status s = OptimisticTransactionDB::Open(options, txn_db_options, path, - column_families, &handles, + Status s = OptimisticTransactionDB::Open(options, + path, &txn_db); auto ok = s.ok(); write_status(std::move(s), status); unordered_map> handle_map; - if (ok) { - assert(handles.size() == cf_names.size()); - for (size_t i = 0; i < handles.size(); ++i) { - handle_map[cf_names[i]] = shared_ptr(handles[i]); - } - } - return make_unique(txn_db, nullptr, txn_db, std::move(handle_map)); + return make_shared(txn_db, nullptr, txn_db); } \ No newline at end of file diff --git a/cozorocks/src/bridge.rs b/cozorocks/src/bridge.rs index 3d339529..6f9c006c 100644 --- a/cozorocks/src/bridge.rs +++ b/cozorocks/src/bridge.rs @@ -76,6 +76,8 @@ mod ffi { type Slice; type PinnableSlice; + fn reset_pinnable_slice(o: Pin<&mut PinnableSlice>); + fn new_pinnable_slice() -> UniquePtr; fn convert_slice_back(s: &Slice) -> &[u8]; fn convert_pinnable_slice_back(s: &PinnableSlice) -> &[u8]; @@ -131,8 +133,8 @@ mod ffi { fn is_valid(self: &IteratorBridge) -> bool; fn do_seek(self: &IteratorBridge, key: &[u8]); fn do_seek_for_prev(self: &IteratorBridge, key: &[u8]); - fn key_raw(self: &IteratorBridge) -> SharedPtr; - fn value_raw(self: &IteratorBridge) -> SharedPtr; + fn key_raw(self: &IteratorBridge) -> UniquePtr; + fn value_raw(self: &IteratorBridge) -> UniquePtr; fn status(self: &IteratorBridge) -> BridgeStatus; fn refresh(self: &IteratorBridge, status: &mut BridgeStatus); @@ -145,78 +147,58 @@ mod ffi { fn pop_savepoint(self: &TransactionBridge, status: &mut BridgeStatus); fn get_txn( self: &TransactionBridge, - cf: &ColumnFamilyHandle, key: &[u8], + slice: Pin<&mut PinnableSlice>, status: &mut BridgeStatus, - ) -> SharedPtr; + ); fn get_for_update_txn( self: &TransactionBridge, - cf: &ColumnFamilyHandle, key: &[u8], + slice: Pin<&mut PinnableSlice>, status: &mut BridgeStatus, - ) -> SharedPtr; + ); fn get_raw( self: &TransactionBridge, - cf: &ColumnFamilyHandle, key: &[u8], + slice: Pin<&mut PinnableSlice>, status: &mut BridgeStatus, - ) -> SharedPtr; + ); fn put_txn( self: &TransactionBridge, - cf: &ColumnFamilyHandle, key: &[u8], val: &[u8], status: &mut BridgeStatus, ); fn put_raw( self: &TransactionBridge, - cf: &ColumnFamilyHandle, key: &[u8], val: &[u8], status: &mut BridgeStatus, ); fn del_txn( self: &TransactionBridge, - cf: &ColumnFamilyHandle, key: &[u8], status: &mut BridgeStatus, ); fn del_raw( self: &TransactionBridge, - cf: &ColumnFamilyHandle, key: &[u8], status: &mut BridgeStatus, ); fn del_range_raw( self: &TransactionBridge, - cf: &ColumnFamilyHandle, start_key: &[u8], end_key: &[u8], status: &mut BridgeStatus, ); fn flush_raw( self: &TransactionBridge, - cf: &ColumnFamilyHandle, options: &FlushOptions, status: &mut BridgeStatus, ); - fn compact_all_raw( - self: &TransactionBridge, - cf: &ColumnFamilyHandle, - status: &mut BridgeStatus, - ); - fn iterator_txn( - self: &TransactionBridge, - cf: &ColumnFamilyHandle, - ) -> UniquePtr; - fn iterator_raw( - self: &TransactionBridge, - cf: &ColumnFamilyHandle, - ) -> UniquePtr; - // fn multiget_txn(self: &TransactionBridge, cf: &ColumnFamilyHandle, - // keys: &[&[u8]], statuses: &mut [BridgeStatus]) -> UniquePtr>; - // fn multiget_raw(self: &TransactionBridge, cf: &ColumnFamilyHandle, - // keys: &[&[u8]], statuses: &mut [BridgeStatus]) -> UniquePtr>; + fn compact_all_raw(self: &TransactionBridge, status: &mut BridgeStatus); + fn iterator_txn(self: &TransactionBridge) -> UniquePtr; + fn iterator_raw(self: &TransactionBridge) -> UniquePtr; pub type ColumnFamilyHandle; @@ -237,28 +219,18 @@ mod ffi { raw_r_ops: UniquePtr, txn_options: UniquePtr, ) -> UniquePtr; - fn get_cf_handle_raw(self: &TDBBridge, name: &CxxString) -> SharedPtr; - fn get_default_cf_handle_raw(self: &TDBBridge) -> SharedPtr; - fn create_column_family_raw( - self: &TDBBridge, - options: &Options, - name: &CxxString, - status: &mut BridgeStatus, - ) -> SharedPtr; - fn drop_column_family_raw(self: &TDBBridge, name: &CxxString, status: &mut BridgeStatus); - fn get_column_family_names_raw(self: &TDBBridge) -> UniquePtr>; fn open_tdb_raw( options: &Options, txn_options: &TransactionDBOptions, path: &CxxString, status: &mut BridgeStatus, - ) -> UniquePtr; + ) -> SharedPtr; fn open_odb_raw( options: &Options, - txn_options: &OptimisticTransactionDBOptions, + // txn_options: &OptimisticTransactionDBOptions, path: &CxxString, status: &mut BridgeStatus, - ) -> UniquePtr; + ) -> SharedPtr; } } diff --git a/cozorocks/src/lib.rs b/cozorocks/src/lib.rs index 79cff7b5..992bc406 100644 --- a/cozorocks/src/lib.rs +++ b/cozorocks/src/lib.rs @@ -1,744 +1,743 @@ mod bridge; use bridge::*; - -pub use bridge::BridgeStatus; -pub use bridge::ColumnFamilyHandle; -pub use bridge::PinnableSlice; -pub use bridge::Slice; -pub use bridge::StatusBridgeCode; -pub use bridge::StatusCode; -pub use bridge::StatusSeverity; -pub use bridge::StatusSubCode; -use cxx::let_cxx_string; -pub use cxx::{SharedPtr, UniquePtr}; -use std::fmt::Debug; -use std::fmt::{Display, Formatter}; -use std::marker::PhantomData; -use std::ops::{Deref, DerefMut}; - -impl std::fmt::Display for BridgeStatus { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!( - f, - "BridgeStatus({}, {}, {}, {})", - self.code, self.subcode, self.severity, self.bridge_code - ) - } -} - -#[derive(Debug)] -pub struct BridgeError { - pub status: BridgeStatus, -} - -impl Display for BridgeError { - fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { - write!( - f, - "BridgeError({}, {}, {}, {})", - self.status.code, self.status.subcode, self.status.severity, self.status.bridge_code - ) - } -} - -impl std::error::Error for BridgeError {} - -impl Default for BridgeStatus { - #[inline] - fn default() -> Self { - BridgeStatus { - code: StatusCode::kOk, - subcode: StatusSubCode::kNone, - severity: StatusSeverity::kNoError, - bridge_code: StatusBridgeCode::OK, - } - } -} - -impl BridgeStatus { - #[inline] - fn check_err(self, data: T) -> Result { - let err: Option = self.into(); - match err { - Some(e) => Err(e), - None => Ok(data), - } - } -} - -impl From for Option { - #[inline] - fn from(s: BridgeStatus) -> Self { - if s.severity == StatusSeverity::kNoError - && s.bridge_code == StatusBridgeCode::OK - && s.code == StatusCode::kOk - { - None - } else { - Some(BridgeError { status: s }) - } - } -} - -type Result = std::result::Result; - -#[derive(Clone)] -pub enum SlicePtr { - Plain(SharedPtr), - Pinnable(SharedPtr), -} - -impl AsRef<[u8]> for SlicePtr { - #[inline] - fn as_ref(&self) -> &[u8] { - match self { - SlicePtr::Plain(s) => convert_slice_back(s), - SlicePtr::Pinnable(s) => convert_pinnable_slice_back(s), - } - } -} - -pub struct RustComparatorPtr(UniquePtr); - -impl RustComparatorPtr { - #[inline] - pub fn new(name: &str, cmp: fn(&[u8], &[u8]) -> i8, diff_bytes_can_equal: bool) -> Self { - Self(new_rust_comparator(name, cmp, diff_bytes_can_equal)) - } -} - -impl Deref for RustComparatorPtr { - type Target = UniquePtr; - - #[inline] - fn deref(&self) -> &Self::Target { - &self.0 - } -} - -pub struct OptionsPtr(UniquePtr); - -impl Deref for OptionsPtr { - type Target = UniquePtr; - - #[inline] - fn deref(&self) -> &Self::Target { - &self.0 - } -} - -impl DerefMut for OptionsPtr { - #[inline] - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.0 - } -} - -impl OptionsPtr { - #[inline] - pub fn default() -> Self { - Self(new_options()) - } - #[inline] - pub fn prepare_for_bulk_load(&mut self) -> &mut Self { - prepare_for_bulk_load(self.pin_mut()); - self - } - #[inline] - pub fn increase_parallelism(&mut self) -> &mut Self { - increase_parallelism(self.pin_mut()); - self - } - #[inline] - pub fn optimize_level_style_compaction(&mut self) -> &mut Self { - optimize_level_style_compaction(self.pin_mut()); - self - } - #[inline] - pub fn set_create_if_missing(&mut self, v: bool) -> &mut Self { - set_create_if_missing(self.pin_mut(), v); - self - } - #[inline] - pub fn set_comparator(&mut self, cmp: &RustComparatorPtr) -> &mut Self { - set_comparator(self.pin_mut(), cmp); - self - } - #[inline] - pub fn set_paranoid_checks(&mut self, v: bool) -> &mut Self { - set_paranoid_checks(self.pin_mut(), v); - self - } - #[inline] - pub fn set_bloom_filter(&mut self, bits_per_key: f64, whole_key_filtering: bool) -> &mut Self { - set_bloom_filter(self.pin_mut(), bits_per_key, whole_key_filtering); - self - } - #[inline] - pub fn set_capped_prefix_extractor(&mut self, cap_len: usize) -> &mut Self { - set_capped_prefix_extractor(self.pin_mut(), cap_len); - self - } - #[inline] - pub fn set_fixed_prefix_extractor(&mut self, prefix_len: usize) -> &mut Self { - set_fixed_prefix_extractor(self.pin_mut(), prefix_len); - self - } -} - -pub struct ReadOptionsPtr(UniquePtr); - -impl Deref for ReadOptionsPtr { - type Target = UniquePtr; - - #[inline] - fn deref(&self) -> &Self::Target { - &self.0 - } -} - -impl DerefMut for ReadOptionsPtr { - #[inline] - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.0 - } -} - -impl ReadOptionsPtr { - #[inline] - pub fn default() -> Self { - Self(new_read_options()) - } - #[inline] - pub fn set_verify_checksums(&mut self, v: bool) -> &mut Self { - set_verify_checksums(self.pin_mut(), v); - self - } - #[inline] - pub fn set_total_order_seek(&mut self, v: bool) -> &mut Self { - set_total_order_seek(self.pin_mut(), v); - self - } - #[inline] - pub fn set_prefix_same_as_start(&mut self, v: bool) -> &mut Self { - set_prefix_same_as_start(self.pin_mut(), v); - self - } - #[inline] - pub fn set_auto_prefix_mode(&mut self, v: bool) -> &mut Self { - set_auto_prefix_mode(self.pin_mut(), v); - self - } -} - -pub struct WriteOptionsPtr(UniquePtr); - -impl Deref for WriteOptionsPtr { - type Target = UniquePtr; - - #[inline] - fn deref(&self) -> &Self::Target { - &self.0 - } -} - -impl DerefMut for WriteOptionsPtr { - #[inline] - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.0 - } -} - -impl WriteOptionsPtr { - #[inline] - pub fn default() -> Self { - Self(new_write_options()) - } - #[inline] - pub fn set_disable_wal(&mut self, v: bool) -> &mut Self { - set_disable_wal(self.pin_mut(), v); - self - } -} - -pub struct FlushOptionsPtr(UniquePtr); - -impl Deref for FlushOptionsPtr { - type Target = UniquePtr; - #[inline] - fn deref(&self) -> &Self::Target { - &self.0 - } -} - -impl FlushOptionsPtr { - #[inline] - pub fn default() -> Self { - Self(new_flush_options()) - } - #[inline] - pub fn set_allow_write_stall(&mut self, v: bool) -> &mut Self { - set_allow_write_stall(self.0.pin_mut(), v); - self - } - #[inline] - pub fn set_flush_wait(&mut self, v: bool) -> &mut Self { - set_flush_wait(self.0.pin_mut(), v); - self - } -} - -pub struct PTxnOptionsPtr(UniquePtr); - -impl Deref for PTxnOptionsPtr { - type Target = UniquePtr; - - #[inline] - fn deref(&self) -> &Self::Target { - &self.0 - } -} - -impl DerefMut for PTxnOptionsPtr { - #[inline] - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.0 - } -} - -impl PTxnOptionsPtr { - #[inline] - pub fn default() -> Self { - Self(new_transaction_options()) - } - #[inline] - pub fn set_deadlock_detect(&mut self, v: bool) -> &mut Self { - set_deadlock_detect(self.pin_mut(), v); - self - } -} - -pub struct OTxnOptionsPtr(UniquePtr); - -impl Deref for OTxnOptionsPtr { - type Target = UniquePtr; - - #[inline] - fn deref(&self) -> &Self::Target { - &self.0 - } -} - -impl DerefMut for OTxnOptionsPtr { - #[inline] - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.0 - } -} - -impl OTxnOptionsPtr { - #[inline] - pub fn new(cmp: &RustComparatorPtr) -> Self { - Self(new_optimistic_transaction_options(cmp)) - } -} - -pub struct PTxnDBOptionsPtr(UniquePtr); - -impl Deref for PTxnDBOptionsPtr { - type Target = UniquePtr; - - #[inline] - fn deref(&self) -> &Self::Target { - &self.0 - } -} - -impl DerefMut for PTxnDBOptionsPtr { - #[inline] - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.0 - } -} - -impl PTxnDBOptionsPtr { - #[inline] - pub fn default() -> Self { - Self(new_tdb_options()) - } -} - -pub struct OTxnDBOptionsPtr(UniquePtr); - -impl Deref for OTxnDBOptionsPtr { - type Target = UniquePtr; - - #[inline] - fn deref(&self) -> &Self::Target { - &self.0 - } -} - -impl DerefMut for OTxnDBOptionsPtr { - #[inline] - fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.0 - } -} - -impl OTxnDBOptionsPtr { - #[inline] - pub fn default() -> Self { - Self(new_odb_options()) - } -} - -pub struct IteratorPtr<'a> { - inner: UniquePtr, - txn: PhantomData<&'a TransactionPtr>, -} - -impl<'a> Deref for IteratorPtr<'a> { - type Target = UniquePtr; - - #[inline] - fn deref(&self) -> &Self::Target { - &self.inner - } -} - -impl<'a> IteratorPtr<'a> { - #[inline] - pub fn to_first(&self) { - IteratorBridge::seek_to_first(self) - } - #[inline] - pub fn to_last(&self) { - IteratorBridge::seek_to_last(self) - } - #[inline] - pub fn next(&self) { - IteratorBridge::next(self) - } - #[inline] - pub fn is_valid(&self) -> bool { - IteratorBridge::is_valid(self) - } - #[inline] - pub fn seek(&self, key: impl AsRef<[u8]>) { - IteratorBridge::do_seek(self, key.as_ref()) - } - #[inline] - pub fn seek_for_prev(&self, key: impl AsRef<[u8]>) { - IteratorBridge::do_seek_for_prev(self, key.as_ref()) - } - #[inline] - pub fn refresh(&self) -> Result<()> { - let mut status = BridgeStatus::default(); - IteratorBridge::refresh(self, &mut status); - status.check_err(()) - } - - #[inline] - /// # Safety - /// `next()` must not be called on the iterator when the returned value is still used - pub unsafe fn key(&self) -> Option { - if self.is_valid() { - Some(SlicePtr::Plain(IteratorBridge::key_raw(self))) - } else { - None - } - } - #[inline] - /// # Safety - /// `next()` must not be called on the iterator when the returned value is still used - pub unsafe fn val(&self) -> Option { - if self.is_valid() { - Some(SlicePtr::Plain(IteratorBridge::value_raw(self))) - } else { - None - } - } - #[inline] - /// # Safety - /// `next()` must not be called on the iterator when the returned value is still used - pub unsafe fn pair(&self) -> Option<(SlicePtr, SlicePtr)> { - if self.is_valid() { - Some(( - SlicePtr::Plain(IteratorBridge::key_raw(self)), - SlicePtr::Plain(IteratorBridge::value_raw(self)), - )) - } else { - None - } - } - #[inline] - pub fn status(&self) -> BridgeStatus { - IteratorBridge::status(self) - } -} - -pub struct TransactionPtr(UniquePtr); - -impl Deref for TransactionPtr { - type Target = UniquePtr; - #[inline] - fn deref(&self) -> &Self::Target { - &self.0 - } -} - -impl TransactionPtr { - #[inline] - pub fn null() -> Self { - TransactionPtr(UniquePtr::null()) - } - #[inline] - pub fn set_snapshot(&self) { - TransactionBridge::set_snapshot(self) - } - #[inline] - pub fn commit(&self) -> Result<()> { - let mut status = BridgeStatus::default(); - TransactionBridge::commit(self, &mut status); - status.check_err(()) - } - #[inline] - pub fn rollback(&self) -> Result<()> { - let mut status = BridgeStatus::default(); - TransactionBridge::rollback(self, &mut status); - status.check_err(()) - } - #[inline] - pub fn set_savepoint(&self) { - TransactionBridge::set_savepoint(self); - } - #[inline] - pub fn rollback_to_savepoint(&self) -> Result<()> { - let mut status = BridgeStatus::default(); - TransactionBridge::rollback_to_savepoint(self, &mut status); - status.check_err(()) - } - #[inline] - pub fn pop_savepoint(&self) -> Result<()> { - let mut status = BridgeStatus::default(); - TransactionBridge::pop_savepoint(self, &mut status); - status.check_err(()) - } - #[inline] - pub fn get( - &self, - transact: bool, - cf: &ColumnFamilyHandle, - key: impl AsRef<[u8]>, - ) -> Result> { - let mut status = BridgeStatus::default(); - let res = if transact { - let ret = self.get_txn(cf, key.as_ref(), &mut status); - status.check_err(SlicePtr::Pinnable(ret)) - } else { - let ret = self.get_raw(cf, key.as_ref(), &mut status); - status.check_err(SlicePtr::Pinnable(ret)) - }; - match res { - Ok(r) => Ok(Some(r)), - Err(e) if e.status.code == StatusCode::kNotFound => Ok(None), - res => res.map(|_| None), - } - } - #[inline] - pub fn get_for_update( - &self, - cf: &ColumnFamilyHandle, - key: impl AsRef<[u8]>, - ) -> Result { - let mut status = BridgeStatus::default(); - let ret = self.get_for_update_txn(cf, key.as_ref(), &mut status); - status.check_err(SlicePtr::Pinnable(ret)) - } - #[inline] - pub fn del( - &self, - transact: bool, - cf: &ColumnFamilyHandle, - key: impl AsRef<[u8]>, - ) -> Result<()> { - let mut status = BridgeStatus::default(); - if transact { - let ret = self.del_txn(cf, key.as_ref(), &mut status); - status.check_err(ret) - } else { - let ret = self.del_raw(cf, key.as_ref(), &mut status); - status.check_err(ret) - } - } - #[inline] - pub fn del_range( - &self, - cf: &ColumnFamilyHandle, - start_key: impl AsRef<[u8]>, - end_key: impl AsRef<[u8]>, - ) -> Result<()> { - let mut status = BridgeStatus::default(); - let ret = self.del_range_raw(cf, start_key.as_ref(), end_key.as_ref(), &mut status); - status.check_err(ret) - } - #[inline] - pub fn flush(&self, cf: &ColumnFamilyHandle, options: FlushOptionsPtr) -> Result<()> { - let mut status = BridgeStatus::default(); - self.flush_raw(cf, &options, &mut status); - status.check_err(()) - } - #[inline] - pub fn compact_all(&self, cf: &ColumnFamilyHandle) -> Result<()> { - let mut status = BridgeStatus::default(); - self.compact_all_raw(cf, &mut status); - status.check_err(()) - } - #[inline] - pub fn put( - &self, - transact: bool, - cf: &ColumnFamilyHandle, - key: impl AsRef<[u8]>, - val: impl AsRef<[u8]>, - ) -> Result<()> { - let mut status = BridgeStatus::default(); - if transact { - let ret = self.put_txn(cf, key.as_ref(), val.as_ref(), &mut status); - status.check_err(ret) - } else { - let ret = self.put_raw(cf, key.as_ref(), val.as_ref(), &mut status); - status.check_err(ret) - } - } - #[inline] - pub fn iterator(&self, transact: bool, cf: &ColumnFamilyHandle) -> IteratorPtr { - if transact { - IteratorPtr { - inner: self.iterator_txn(cf), - txn: PhantomData, - } - } else { - IteratorPtr { - inner: self.iterator_raw(cf), - txn: PhantomData, - } - } - } -} - -pub struct DBPtr(UniquePtr); - -impl Deref for DBPtr { - type Target = UniquePtr; - - #[inline] - fn deref(&self) -> &Self::Target { - &self.0 - } -} - -unsafe impl Send for DBPtr {} - -unsafe impl Sync for DBPtr {} - -pub enum TransactOptions { - Pessimistic(PTxnOptionsPtr), - Optimistic(OTxnOptionsPtr), -} - -pub enum TDBOptions { - Pessimistic(PTxnDBOptionsPtr), - Optimistic(OTxnDBOptionsPtr), -} - -impl DBPtr { - pub fn open( - options: &OptionsPtr, - t_options: &TDBOptions, - path: impl AsRef, - ) -> Result { - let_cxx_string!(cname = path.as_ref()); - let mut status = BridgeStatus::default(); - let ret = match t_options { - TDBOptions::Pessimistic(o) => open_tdb_raw(options, o, &cname, &mut status), - TDBOptions::Optimistic(o) => open_odb_raw(options, o, &cname, &mut status), - }; - status.check_err(Self(ret)) - } - - #[inline] - pub fn make_transaction( - &self, - options: TransactOptions, - read_ops: ReadOptionsPtr, - raw_read_ops: ReadOptionsPtr, - write_ops: WriteOptionsPtr, - raw_write_ops: WriteOptionsPtr, - ) -> TransactionPtr { - TransactionPtr(match options { - TransactOptions::Optimistic(o) => self.begin_o_transaction( - write_ops.0, - raw_write_ops.0, - read_ops.0, - raw_read_ops.0, - o.0, - ), - TransactOptions::Pessimistic(o) => self.begin_t_transaction( - write_ops.0, - raw_write_ops.0, - read_ops.0, - raw_read_ops.0, - o.0, - ), - }) - } - #[inline] - pub fn get_cf(&self, name: impl AsRef) -> Option> { - let_cxx_string!(cname = name.as_ref()); - let spt = self.get_cf_handle_raw(&cname); - if spt.is_null() { - None - } else { - Some(spt) - } - } - #[inline] - pub fn default_cf(&self) -> SharedPtr { - self.get_default_cf_handle_raw() - } - #[inline] - pub fn create_cf( - &self, - options: &OptionsPtr, - name: impl AsRef, - ) -> Result> { - let_cxx_string!(name = name.as_ref()); - let mut status = BridgeStatus::default(); - let ret = self.create_column_family_raw(options, &name, &mut status); - status.check_err(ret) - } - #[inline] - pub fn drop_cf(&self, name: impl AsRef) -> Result<()> { - let_cxx_string!(name = name.as_ref()); - let mut status = BridgeStatus::default(); - self.drop_column_family_raw(&name, &mut status); - status.check_err(()) - } - #[inline] - pub fn cf_names(&self) -> Vec { - self.get_column_family_names_raw() - .iter() - .map(|v| v.to_string_lossy().to_string()) - .collect() - } - pub fn drop_non_default_cfs(&self) { - for name in self.cf_names() { - if name != "default" { - self.drop_cf(name).unwrap(); - } - } - } -} +// +// pub use bridge::BridgeStatus; +// pub use bridge::ColumnFamilyHandle; +// pub use bridge::PinnableSlice; +// pub use bridge::Slice; +// pub use bridge::StatusBridgeCode; +// pub use bridge::StatusCode; +// pub use bridge::StatusSeverity; +// pub use bridge::StatusSubCode; +// use cxx::let_cxx_string; +// pub use cxx::{SharedPtr, UniquePtr}; +// use std::fmt::Debug; +// use std::fmt::{Display, Formatter}; +// use std::marker::PhantomData; +// use std::ops::{Deref, DerefMut}; +// +// impl std::fmt::Display for BridgeStatus { +// fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { +// write!( +// f, +// "BridgeStatus({}, {}, {}, {})", +// self.code, self.subcode, self.severity, self.bridge_code +// ) +// } +// } +// +// #[derive(Debug)] +// pub struct BridgeError { +// pub status: BridgeStatus, +// } +// +// impl Display for BridgeError { +// fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { +// write!( +// f, +// "BridgeError({}, {}, {}, {})", +// self.status.code, self.status.subcode, self.status.severity, self.status.bridge_code +// ) +// } +// } +// +// impl std::error::Error for BridgeError {} +// +// impl Default for BridgeStatus { +// #[inline] +// fn default() -> Self { +// BridgeStatus { +// code: StatusCode::kOk, +// subcode: StatusSubCode::kNone, +// severity: StatusSeverity::kNoError, +// bridge_code: StatusBridgeCode::OK, +// } +// } +// } +// +// impl BridgeStatus { +// #[inline] +// fn check_err(self, data: T) -> Result { +// let err: Option = self.into(); +// match err { +// Some(e) => Err(e), +// None => Ok(data), +// } +// } +// } +// +// impl From for Option { +// #[inline] +// fn from(s: BridgeStatus) -> Self { +// if s.severity == StatusSeverity::kNoError +// && s.bridge_code == StatusBridgeCode::OK +// && s.code == StatusCode::kOk +// { +// None +// } else { +// Some(BridgeError { status: s }) +// } +// } +// } +// +// type Result = std::result::Result; +// +// pub enum SlicePtr { +// Plain(UniquePtr), +// Pinnable(UniquePtr), +// } +// +// impl AsRef<[u8]> for SlicePtr { +// #[inline] +// fn as_ref(&self) -> &[u8] { +// match self { +// SlicePtr::Plain(s) => convert_slice_back(s), +// SlicePtr::Pinnable(s) => convert_pinnable_slice_back(s), +// } +// } +// } +// +// pub struct RustComparatorPtr(UniquePtr); +// +// impl RustComparatorPtr { +// #[inline] +// pub fn new(name: &str, cmp: fn(&[u8], &[u8]) -> i8, diff_bytes_can_equal: bool) -> Self { +// Self(new_rust_comparator(name, cmp, diff_bytes_can_equal)) +// } +// } +// +// impl Deref for RustComparatorPtr { +// type Target = UniquePtr; +// +// #[inline] +// fn deref(&self) -> &Self::Target { +// &self.0 +// } +// } +// +// pub struct OptionsPtr(UniquePtr); +// +// impl Deref for OptionsPtr { +// type Target = UniquePtr; +// +// #[inline] +// fn deref(&self) -> &Self::Target { +// &self.0 +// } +// } +// +// impl DerefMut for OptionsPtr { +// #[inline] +// fn deref_mut(&mut self) -> &mut Self::Target { +// &mut self.0 +// } +// } +// +// impl OptionsPtr { +// #[inline] +// pub fn default() -> Self { +// Self(new_options()) +// } +// #[inline] +// pub fn prepare_for_bulk_load(&mut self) -> &mut Self { +// prepare_for_bulk_load(self.pin_mut()); +// self +// } +// #[inline] +// pub fn increase_parallelism(&mut self) -> &mut Self { +// increase_parallelism(self.pin_mut()); +// self +// } +// #[inline] +// pub fn optimize_level_style_compaction(&mut self) -> &mut Self { +// optimize_level_style_compaction(self.pin_mut()); +// self +// } +// #[inline] +// pub fn set_create_if_missing(&mut self, v: bool) -> &mut Self { +// set_create_if_missing(self.pin_mut(), v); +// self +// } +// #[inline] +// pub fn set_comparator(&mut self, cmp: &RustComparatorPtr) -> &mut Self { +// set_comparator(self.pin_mut(), cmp); +// self +// } +// #[inline] +// pub fn set_paranoid_checks(&mut self, v: bool) -> &mut Self { +// set_paranoid_checks(self.pin_mut(), v); +// self +// } +// #[inline] +// pub fn set_bloom_filter(&mut self, bits_per_key: f64, whole_key_filtering: bool) -> &mut Self { +// set_bloom_filter(self.pin_mut(), bits_per_key, whole_key_filtering); +// self +// } +// #[inline] +// pub fn set_capped_prefix_extractor(&mut self, cap_len: usize) -> &mut Self { +// set_capped_prefix_extractor(self.pin_mut(), cap_len); +// self +// } +// #[inline] +// pub fn set_fixed_prefix_extractor(&mut self, prefix_len: usize) -> &mut Self { +// set_fixed_prefix_extractor(self.pin_mut(), prefix_len); +// self +// } +// } +// +// pub struct ReadOptionsPtr(UniquePtr); +// +// impl Deref for ReadOptionsPtr { +// type Target = UniquePtr; +// +// #[inline] +// fn deref(&self) -> &Self::Target { +// &self.0 +// } +// } +// +// impl DerefMut for ReadOptionsPtr { +// #[inline] +// fn deref_mut(&mut self) -> &mut Self::Target { +// &mut self.0 +// } +// } +// +// impl ReadOptionsPtr { +// #[inline] +// pub fn default() -> Self { +// Self(new_read_options()) +// } +// #[inline] +// pub fn set_verify_checksums(&mut self, v: bool) -> &mut Self { +// set_verify_checksums(self.pin_mut(), v); +// self +// } +// #[inline] +// pub fn set_total_order_seek(&mut self, v: bool) -> &mut Self { +// set_total_order_seek(self.pin_mut(), v); +// self +// } +// #[inline] +// pub fn set_prefix_same_as_start(&mut self, v: bool) -> &mut Self { +// set_prefix_same_as_start(self.pin_mut(), v); +// self +// } +// #[inline] +// pub fn set_auto_prefix_mode(&mut self, v: bool) -> &mut Self { +// set_auto_prefix_mode(self.pin_mut(), v); +// self +// } +// } +// +// pub struct WriteOptionsPtr(UniquePtr); +// +// impl Deref for WriteOptionsPtr { +// type Target = UniquePtr; +// +// #[inline] +// fn deref(&self) -> &Self::Target { +// &self.0 +// } +// } +// +// impl DerefMut for WriteOptionsPtr { +// #[inline] +// fn deref_mut(&mut self) -> &mut Self::Target { +// &mut self.0 +// } +// } +// +// impl WriteOptionsPtr { +// #[inline] +// pub fn default() -> Self { +// Self(new_write_options()) +// } +// #[inline] +// pub fn set_disable_wal(&mut self, v: bool) -> &mut Self { +// set_disable_wal(self.pin_mut(), v); +// self +// } +// } +// +// pub struct FlushOptionsPtr(UniquePtr); +// +// impl Deref for FlushOptionsPtr { +// type Target = UniquePtr; +// #[inline] +// fn deref(&self) -> &Self::Target { +// &self.0 +// } +// } +// +// impl FlushOptionsPtr { +// #[inline] +// pub fn default() -> Self { +// Self(new_flush_options()) +// } +// #[inline] +// pub fn set_allow_write_stall(&mut self, v: bool) -> &mut Self { +// set_allow_write_stall(self.0.pin_mut(), v); +// self +// } +// #[inline] +// pub fn set_flush_wait(&mut self, v: bool) -> &mut Self { +// set_flush_wait(self.0.pin_mut(), v); +// self +// } +// } +// +// pub struct PTxnOptionsPtr(UniquePtr); +// +// impl Deref for PTxnOptionsPtr { +// type Target = UniquePtr; +// +// #[inline] +// fn deref(&self) -> &Self::Target { +// &self.0 +// } +// } +// +// impl DerefMut for PTxnOptionsPtr { +// #[inline] +// fn deref_mut(&mut self) -> &mut Self::Target { +// &mut self.0 +// } +// } +// +// impl PTxnOptionsPtr { +// #[inline] +// pub fn default() -> Self { +// Self(new_transaction_options()) +// } +// #[inline] +// pub fn set_deadlock_detect(&mut self, v: bool) -> &mut Self { +// set_deadlock_detect(self.pin_mut(), v); +// self +// } +// } +// +// pub struct OTxnOptionsPtr(UniquePtr); +// +// impl Deref for OTxnOptionsPtr { +// type Target = UniquePtr; +// +// #[inline] +// fn deref(&self) -> &Self::Target { +// &self.0 +// } +// } +// +// impl DerefMut for OTxnOptionsPtr { +// #[inline] +// fn deref_mut(&mut self) -> &mut Self::Target { +// &mut self.0 +// } +// } +// +// impl OTxnOptionsPtr { +// #[inline] +// pub fn new(cmp: &RustComparatorPtr) -> Self { +// Self(new_optimistic_transaction_options(cmp)) +// } +// } +// +// pub struct PTxnDBOptionsPtr(UniquePtr); +// +// impl Deref for PTxnDBOptionsPtr { +// type Target = UniquePtr; +// +// #[inline] +// fn deref(&self) -> &Self::Target { +// &self.0 +// } +// } +// +// impl DerefMut for PTxnDBOptionsPtr { +// #[inline] +// fn deref_mut(&mut self) -> &mut Self::Target { +// &mut self.0 +// } +// } +// +// impl PTxnDBOptionsPtr { +// #[inline] +// pub fn default() -> Self { +// Self(new_tdb_options()) +// } +// } +// +// pub struct OTxnDBOptionsPtr(UniquePtr); +// +// impl Deref for OTxnDBOptionsPtr { +// type Target = UniquePtr; +// +// #[inline] +// fn deref(&self) -> &Self::Target { +// &self.0 +// } +// } +// +// impl DerefMut for OTxnDBOptionsPtr { +// #[inline] +// fn deref_mut(&mut self) -> &mut Self::Target { +// &mut self.0 +// } +// } +// +// impl OTxnDBOptionsPtr { +// #[inline] +// pub fn default() -> Self { +// Self(new_odb_options()) +// } +// } +// +// pub struct IteratorPtr<'a> { +// inner: UniquePtr, +// txn: PhantomData<&'a TransactionPtr>, +// } +// +// impl<'a> Deref for IteratorPtr<'a> { +// type Target = UniquePtr; +// +// #[inline] +// fn deref(&self) -> &Self::Target { +// &self.inner +// } +// } +// +// impl<'a> IteratorPtr<'a> { +// #[inline] +// pub fn to_first(&self) { +// IteratorBridge::seek_to_first(self) +// } +// #[inline] +// pub fn to_last(&self) { +// IteratorBridge::seek_to_last(self) +// } +// #[inline] +// pub fn next(&self) { +// IteratorBridge::next(self) +// } +// #[inline] +// pub fn is_valid(&self) -> bool { +// IteratorBridge::is_valid(self) +// } +// #[inline] +// pub fn seek(&self, key: impl AsRef<[u8]>) { +// IteratorBridge::do_seek(self, key.as_ref()) +// } +// #[inline] +// pub fn seek_for_prev(&self, key: impl AsRef<[u8]>) { +// IteratorBridge::do_seek_for_prev(self, key.as_ref()) +// } +// #[inline] +// pub fn refresh(&self) -> Result<()> { +// let mut status = BridgeStatus::default(); +// IteratorBridge::refresh(self, &mut status); +// status.check_err(()) +// } +// +// #[inline] +// /// # Safety +// /// `next()` must not be called on the iterator when the returned value is still used +// pub unsafe fn key(&self) -> Option { +// if self.is_valid() { +// Some(SlicePtr::Plain(IteratorBridge::key_raw(self))) +// } else { +// None +// } +// } +// #[inline] +// /// # Safety +// /// `next()` must not be called on the iterator when the returned value is still used +// pub unsafe fn val(&self) -> Option { +// if self.is_valid() { +// Some(SlicePtr::Plain(IteratorBridge::value_raw(self))) +// } else { +// None +// } +// } +// #[inline] +// /// # Safety +// /// `next()` must not be called on the iterator when the returned value is still used +// pub unsafe fn pair(&self) -> Option<(SlicePtr, SlicePtr)> { +// if self.is_valid() { +// Some(( +// SlicePtr::Plain(IteratorBridge::key_raw(self)), +// SlicePtr::Plain(IteratorBridge::value_raw(self)), +// )) +// } else { +// None +// } +// } +// #[inline] +// pub fn status(&self) -> BridgeStatus { +// IteratorBridge::status(self) +// } +// } +// +// pub struct TransactionPtr(UniquePtr); +// +// impl Deref for TransactionPtr { +// type Target = UniquePtr; +// #[inline] +// fn deref(&self) -> &Self::Target { +// &self.0 +// } +// } +// +// impl TransactionPtr { +// #[inline] +// pub fn null() -> Self { +// TransactionPtr(UniquePtr::null()) +// } +// #[inline] +// pub fn set_snapshot(&self) { +// TransactionBridge::set_snapshot(self) +// } +// #[inline] +// pub fn commit(&self) -> Result<()> { +// let mut status = BridgeStatus::default(); +// TransactionBridge::commit(self, &mut status); +// status.check_err(()) +// } +// #[inline] +// pub fn rollback(&self) -> Result<()> { +// let mut status = BridgeStatus::default(); +// TransactionBridge::rollback(self, &mut status); +// status.check_err(()) +// } +// #[inline] +// pub fn set_savepoint(&self) { +// TransactionBridge::set_savepoint(self); +// } +// #[inline] +// pub fn rollback_to_savepoint(&self) -> Result<()> { +// let mut status = BridgeStatus::default(); +// TransactionBridge::rollback_to_savepoint(self, &mut status); +// status.check_err(()) +// } +// #[inline] +// pub fn pop_savepoint(&self) -> Result<()> { +// let mut status = BridgeStatus::default(); +// TransactionBridge::pop_savepoint(self, &mut status); +// status.check_err(()) +// } +// #[inline] +// pub fn get( +// &self, +// transact: bool, +// cf: &ColumnFamilyHandle, +// key: impl AsRef<[u8]>, +// ) -> Result> { +// let mut status = BridgeStatus::default(); +// let res = if transact { +// let ret = self.get_txn(cf, key.as_ref(), &mut status); +// status.check_err(SlicePtr::Pinnable(ret)) +// } else { +// let ret = self.get_raw(cf, key.as_ref(), &mut status); +// status.check_err(SlicePtr::Pinnable(ret)) +// }; +// match res { +// Ok(r) => Ok(Some(r)), +// Err(e) if e.status.code == StatusCode::kNotFound => Ok(None), +// res => res.map(|_| None), +// } +// } +// #[inline] +// pub fn get_for_update( +// &self, +// cf: &ColumnFamilyHandle, +// key: impl AsRef<[u8]>, +// ) -> Result { +// let mut status = BridgeStatus::default(); +// let ret = self.get_for_update_txn(cf, key.as_ref(), &mut status); +// status.check_err(SlicePtr::Pinnable(ret)) +// } +// #[inline] +// pub fn del( +// &self, +// transact: bool, +// cf: &ColumnFamilyHandle, +// key: impl AsRef<[u8]>, +// ) -> Result<()> { +// let mut status = BridgeStatus::default(); +// if transact { +// let ret = self.del_txn(cf, key.as_ref(), &mut status); +// status.check_err(ret) +// } else { +// let ret = self.del_raw(cf, key.as_ref(), &mut status); +// status.check_err(ret) +// } +// } +// #[inline] +// pub fn del_range( +// &self, +// cf: &ColumnFamilyHandle, +// start_key: impl AsRef<[u8]>, +// end_key: impl AsRef<[u8]>, +// ) -> Result<()> { +// let mut status = BridgeStatus::default(); +// let ret = self.del_range_raw(cf, start_key.as_ref(), end_key.as_ref(), &mut status); +// status.check_err(ret) +// } +// #[inline] +// pub fn flush(&self, cf: &ColumnFamilyHandle, options: FlushOptionsPtr) -> Result<()> { +// let mut status = BridgeStatus::default(); +// self.flush_raw(cf, &options, &mut status); +// status.check_err(()) +// } +// #[inline] +// pub fn compact_all(&self, cf: &ColumnFamilyHandle) -> Result<()> { +// let mut status = BridgeStatus::default(); +// self.compact_all_raw(cf, &mut status); +// status.check_err(()) +// } +// #[inline] +// pub fn put( +// &self, +// transact: bool, +// cf: &ColumnFamilyHandle, +// key: impl AsRef<[u8]>, +// val: impl AsRef<[u8]>, +// ) -> Result<()> { +// let mut status = BridgeStatus::default(); +// if transact { +// let ret = self.put_txn(cf, key.as_ref(), val.as_ref(), &mut status); +// status.check_err(ret) +// } else { +// let ret = self.put_raw(cf, key.as_ref(), val.as_ref(), &mut status); +// status.check_err(ret) +// } +// } +// #[inline] +// pub fn iterator(&self, transact: bool, cf: &ColumnFamilyHandle) -> IteratorPtr { +// if transact { +// IteratorPtr { +// inner: self.iterator_txn(cf), +// txn: PhantomData, +// } +// } else { +// IteratorPtr { +// inner: self.iterator_raw(cf), +// txn: PhantomData, +// } +// } +// } +// } +// +// pub struct DBPtr(SharedPtr); +// +// impl Deref for DBPtr { +// type Target = SharedPtr; +// +// #[inline] +// fn deref(&self) -> &Self::Target { +// &self.0 +// } +// } +// +// unsafe impl Send for DBPtr {} +// +// unsafe impl Sync for DBPtr {} +// +// pub enum TransactOptions { +// Pessimistic(PTxnOptionsPtr), +// Optimistic(OTxnOptionsPtr), +// } +// +// pub enum TDBOptions { +// Pessimistic(PTxnDBOptionsPtr), +// Optimistic(OTxnDBOptionsPtr), +// } +// +// impl DBPtr { +// pub fn open( +// options: &OptionsPtr, +// t_options: &TDBOptions, +// path: impl AsRef, +// ) -> Result { +// let_cxx_string!(cname = path.as_ref()); +// let mut status = BridgeStatus::default(); +// let ret = match t_options { +// TDBOptions::Pessimistic(o) => open_tdb_raw(options, o, &cname, &mut status), +// TDBOptions::Optimistic(o) => open_odb_raw(options, o, &cname, &mut status), +// }; +// status.check_err(Self(ret)) +// } +// +// #[inline] +// pub fn make_transaction( +// &self, +// options: TransactOptions, +// read_ops: ReadOptionsPtr, +// raw_read_ops: ReadOptionsPtr, +// write_ops: WriteOptionsPtr, +// raw_write_ops: WriteOptionsPtr, +// ) -> TransactionPtr { +// TransactionPtr(match options { +// TransactOptions::Optimistic(o) => self.begin_o_transaction( +// write_ops.0, +// raw_write_ops.0, +// read_ops.0, +// raw_read_ops.0, +// o.0, +// ), +// TransactOptions::Pessimistic(o) => self.begin_t_transaction( +// write_ops.0, +// raw_write_ops.0, +// read_ops.0, +// raw_read_ops.0, +// o.0, +// ), +// }) +// } +// #[inline] +// pub fn get_cf(&self, name: impl AsRef) -> Option> { +// let_cxx_string!(cname = name.as_ref()); +// let spt = self.get_cf_handle_raw(&cname); +// if spt.is_null() { +// None +// } else { +// Some(spt) +// } +// } +// #[inline] +// pub fn default_cf(&self) -> SharedPtr { +// self.get_default_cf_handle_raw() +// } +// #[inline] +// pub fn create_cf( +// &self, +// options: &OptionsPtr, +// name: impl AsRef, +// ) -> Result> { +// let_cxx_string!(name = name.as_ref()); +// let mut status = BridgeStatus::default(); +// let ret = self.create_column_family_raw(options, &name, &mut status); +// status.check_err(ret) +// } +// #[inline] +// pub fn drop_cf(&self, name: impl AsRef) -> Result<()> { +// let_cxx_string!(name = name.as_ref()); +// let mut status = BridgeStatus::default(); +// self.drop_column_family_raw(&name, &mut status); +// status.check_err(()) +// } +// #[inline] +// pub fn cf_names(&self) -> Vec { +// self.get_column_family_names_raw() +// .iter() +// .map(|v| v.to_string_lossy().to_string()) +// .collect() +// } +// pub fn drop_non_default_cfs(&self) { +// for name in self.cf_names() { +// if name != "default" { +// self.drop_cf(name).unwrap(); +// } +// } +// } +// } diff --git a/src/db.rs b/src/db.rs index 1c159322..bdc94034 100644 --- a/src/db.rs +++ b/src/db.rs @@ -1,10 +1,16 @@ -pub mod cnf_transform; -pub mod ddl; -pub mod engine; -pub mod env; -pub mod eval; -pub mod iterator; -pub mod mutation; -pub mod plan; -pub mod query; -pub mod table; +// pub mod cnf_transform; +// pub mod ddl; +// pub mod engine; +// pub mod env; +// pub mod eval; +// pub mod iterator; +// pub mod mutation; +// pub mod plan; +// pub mod query; +// pub mod table; + + +pub struct DBInstance { + pub(crate) main_db: (), + session_handles: (), +} \ No newline at end of file diff --git a/src/lib.rs b/src/lib.rs index e0934285..30f96621 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -5,3 +5,4 @@ pub(crate) mod data; pub(crate) mod logger; pub(crate) mod parser; +pub(crate) mod db;