rename

cozorocks/bridge/common.h

@@ -19,7 +19,7 @@
 using namespace rocksdb;
 using namespace std;
 
-struct RdbStatus;
+struct RocksDbStatus;
 struct DbOpts;
 
 typedef Status::Code StatusCode;

cozorocks/bridge/db.cpp

@@ -6,7 +6,7 @@
 #include "db.h"
 #include "cozorocks/src/bridge/mod.rs.h"
 
-shared_ptr<RocksDbBridge> open_db(const DbOpts &opts, RdbStatus &status) {
+shared_ptr<RocksDbBridge> open_db(const DbOpts &opts, RocksDbStatus &status) {
     auto options = make_unique<Options>();
     if (opts.prepare_for_bulk_load) {
         options->PrepareForBulkLoad();

cozorocks/bridge/db.h

@@ -79,6 +79,6 @@ public:
     bool can_different_bytes_be_equal;
 };
 
-shared_ptr<RocksDbBridge> open_db(const DbOpts &opts, RdbStatus &status);
+shared_ptr<RocksDbBridge> open_db(const DbOpts &opts, RocksDbStatus &status);
 
 #endif //COZOROCKS_DB_H

cozorocks/bridge/iter.h

@@ -106,7 +106,7 @@ struct IterBridge {
         iter->Prev();
     }
 
-    inline void status(RdbStatus &status) const {
+    inline void status(RocksDbStatus &status) const {
         write_status(iter->status(), status);
     }
 

cozorocks/bridge/status.cpp

@@ -5,7 +5,7 @@
 #include "status.h"
 #include "cozorocks/src/bridge/mod.rs.h"
 
-void write_status(const Status &rstatus, RdbStatus &status) {
+void write_status(const Status &rstatus, RocksDbStatus &status) {
     status.code = rstatus.code();
     status.subcode = rstatus.subcode();
     status.severity = rstatus.severity();
@@ -14,8 +14,8 @@ void write_status(const Status &rstatus, RdbStatus &status) {
     }
 }
 
-RdbStatus convert_status(const Status &status) {
-    RdbStatus ret;
+RocksDbStatus convert_status(const Status &status) {
+    RocksDbStatus ret;
     write_status(status, ret);
     return ret;
 }

cozorocks/bridge/status.h

@@ -7,8 +7,8 @@
 
 #include "common.h"
 
-void write_status(const Status &rstatus, RdbStatus &status);
+void write_status(const Status &rstatus, RocksDbStatus &status);
 
-RdbStatus convert_status(const Status &status);
+RocksDbStatus convert_status(const Status &status);
 
 #endif //COZOROCKS_STATUS_H

cozorocks/bridge/tx.h

@@ -87,7 +87,7 @@ struct TxBridge {
 
     void start();
 
-    inline unique_ptr<PinnableSlice> get(RustBytes key, bool for_update, RdbStatus &status) {
+    inline unique_ptr<PinnableSlice> get(RustBytes key, bool for_update, RocksDbStatus &status) {
         Slice key_ = convert_slice(key);
         auto ret = make_unique<PinnableSlice>();
         if (for_update) {
@@ -100,27 +100,27 @@ struct TxBridge {
         return ret;
     }
 
-    inline void put(RustBytes key, RustBytes val, RdbStatus &status) {
+    inline void put(RustBytes key, RustBytes val, RocksDbStatus &status) {
         write_status(tx->Put(convert_slice(key), convert_slice(val)), status);
     }
 
-    inline void del(RustBytes key, RdbStatus &status) {
+    inline void del(RustBytes key, RocksDbStatus &status) {
         write_status(tx->Delete(convert_slice(key)), status);
     }
 
-    inline void commit(RdbStatus &status) {
+    inline void commit(RocksDbStatus &status) {
         write_status(tx->Commit(), status);
     }
 
-    inline void rollback(RdbStatus &status) {
+    inline void rollback(RocksDbStatus &status) {
         write_status(tx->Rollback(), status);
     }
 
-    inline void rollback_to_savepoint(RdbStatus &status) {
+    inline void rollback_to_savepoint(RocksDbStatus &status) {
         write_status(tx->RollbackToSavePoint(), status);
     }
 
-    inline void pop_savepoint(RdbStatus &status) {
+    inline void pop_savepoint(RocksDbStatus &status) {
         write_status(tx->PopSavePoint(), status);
     }
 

cozorocks/src/bridge/db.rs

@@ -116,8 +116,8 @@ impl<'a> DbBuilder<'a> {
         self.opts.destroy_on_exit = destroy;
         self
     }
-    pub fn build(self) -> Result<RocksDb, RdbStatus> {
-        let mut status = RdbStatus::default();
+    pub fn build(self) -> Result<RocksDb, RocksDbStatus> {
+        let mut status = RocksDbStatus::default();
         let result = open_db(&self.opts, &mut status);
         if status.is_ok() {
             Ok(RocksDb { inner: result })

cozorocks/src/bridge/iter.rs

@@ -101,13 +101,13 @@ impl DbIter {
         self.inner.pin_mut().prev();
     }
     #[inline]
-    pub fn status(&self) -> RdbStatus {
-        let mut status = RdbStatus::default();
+    pub fn status(&self) -> RocksDbStatus {
+        let mut status = RocksDbStatus::default();
         self.inner.status(&mut status);
         status
     }
     #[inline]
-    pub fn key(&self) -> Result<Option<&[u8]>, RdbStatus> {
+    pub fn key(&self) -> Result<Option<&[u8]>, RocksDbStatus> {
         if self.is_valid() {
             Ok(Some(self.inner.key()))
         } else {
@@ -120,7 +120,7 @@ impl DbIter {
         }
     }
     #[inline]
-    pub fn val(&self) -> Result<Option<&[u8]>, RdbStatus> {
+    pub fn val(&self) -> Result<Option<&[u8]>, RocksDbStatus> {
         if self.is_valid() {
             Ok(Some(self.inner.val()))
         } else {
@@ -133,7 +133,7 @@ impl DbIter {
         }
     }
     #[inline]
-    pub fn pair(&self) -> Result<Option<(&[u8], &[u8])>, RdbStatus> {
+    pub fn pair(&self) -> Result<Option<(&[u8], &[u8])>, RocksDbStatus> {
         if self.is_valid() {
             Ok(Some((self.inner.key(), self.inner.val())))
         } else {

cozorocks/src/bridge/mod.rs

@@ -8,7 +8,7 @@ pub(crate) mod tx;
 #[cxx::bridge]
 pub(crate) mod ffi {
     #[derive(Debug)]
-    pub struct DbOpts<'a> {
+    struct DbOpts<'a> {
         pub db_path: &'a str,
         pub optimistic: bool,
         pub prepare_for_bulk_load: bool,
@@ -34,7 +34,7 @@ pub(crate) mod ffi {
     }
 
     #[derive(Clone, Debug, Eq, PartialEq)]
-    pub struct RdbStatus {
+    pub struct RocksDbStatus {
         pub code: StatusCode,
         pub subcode: StatusSubCode,
         pub severity: StatusSeverity,
@@ -110,7 +110,7 @@ pub(crate) mod ffi {
 
         type RocksDbBridge;
         fn get_db_path(self: &RocksDbBridge) -> &CxxString;
-        fn open_db(builder: &DbOpts, status: &mut RdbStatus) -> SharedPtr<RocksDbBridge>;
+        fn open_db(builder: &DbOpts, status: &mut RocksDbStatus) -> SharedPtr<RocksDbBridge>;
         fn transact(self: &RocksDbBridge) -> UniquePtr<TxBridge>;
 
         type TxBridge;
@@ -125,14 +125,14 @@ pub(crate) mod ffi {
             self: Pin<&mut TxBridge>,
             key: &[u8],
             for_update: bool,
-            status: &mut RdbStatus,
+            status: &mut RocksDbStatus,
         ) -> UniquePtr<PinnableSlice>;
-        fn put(self: Pin<&mut TxBridge>, key: &[u8], val: &[u8], status: &mut RdbStatus);
-        fn del(self: Pin<&mut TxBridge>, key: &[u8], status: &mut RdbStatus);
-        fn commit(self: Pin<&mut TxBridge>, status: &mut RdbStatus);
-        fn rollback(self: Pin<&mut TxBridge>, status: &mut RdbStatus);
-        fn rollback_to_savepoint(self: Pin<&mut TxBridge>, status: &mut RdbStatus);
-        fn pop_savepoint(self: Pin<&mut TxBridge>, status: &mut RdbStatus);
+        fn put(self: Pin<&mut TxBridge>, key: &[u8], val: &[u8], status: &mut RocksDbStatus);
+        fn del(self: Pin<&mut TxBridge>, key: &[u8], status: &mut RocksDbStatus);
+        fn commit(self: Pin<&mut TxBridge>, status: &mut RocksDbStatus);
+        fn rollback(self: Pin<&mut TxBridge>, status: &mut RocksDbStatus);
+        fn rollback_to_savepoint(self: Pin<&mut TxBridge>, status: &mut RocksDbStatus);
+        fn pop_savepoint(self: Pin<&mut TxBridge>, status: &mut RocksDbStatus);
         fn set_savepoint(self: Pin<&mut TxBridge>);
         fn iterator(self: Pin<&mut TxBridge>) -> UniquePtr<IterBridge>;
 
@@ -158,16 +158,16 @@ pub(crate) mod ffi {
         fn is_valid(self: &IterBridge) -> bool;
         fn next(self: Pin<&mut IterBridge>);
         fn prev(self: Pin<&mut IterBridge>);
-        fn status(self: &IterBridge, status: &mut RdbStatus);
+        fn status(self: &IterBridge, status: &mut RocksDbStatus);
         fn key(self: &IterBridge) -> &[u8];
         fn val(self: &IterBridge) -> &[u8];
     }
 }
 
-impl Default for ffi::RdbStatus {
+impl Default for ffi::RocksDbStatus {
     #[inline]
     fn default() -> Self {
-        ffi::RdbStatus {
+        ffi::RocksDbStatus {
             code: ffi::StatusCode::kOk,
             subcode: ffi::StatusSubCode::kNone,
             severity: ffi::StatusSeverity::kNoError,
@@ -176,9 +176,9 @@ impl Default for ffi::RdbStatus {
     }
 }
 
-impl Error for ffi::RdbStatus {}
+impl Error for ffi::RocksDbStatus {}
 
-impl Display for ffi::RdbStatus {
+impl Display for ffi::RocksDbStatus {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         if self.message.is_empty() {
             write!(f, "RocksDB error: {:?}", self)
@@ -188,7 +188,7 @@ impl Display for ffi::RdbStatus {
     }
 }
 
-impl ffi::RdbStatus {
+impl ffi::RocksDbStatus {
     #[inline(always)]
     pub fn is_ok(&self) -> bool {
         self.code == ffi::StatusCode::kOk

cozorocks/src/bridge/tx.rs

@@ -82,8 +82,8 @@ impl Tx {
         self.inner.pin_mut().clear_snapshot()
     }
     #[inline]
-    pub fn put(&mut self, key: &[u8], val: &[u8]) -> Result<(), RdbStatus> {
-        let mut status = RdbStatus::default();
+    pub fn put(&mut self, key: &[u8], val: &[u8]) -> Result<(), RocksDbStatus> {
+        let mut status = RocksDbStatus::default();
         self.inner.pin_mut().put(key, val, &mut status);
         if status.is_ok() {
             Ok(())
@@ -92,8 +92,8 @@ impl Tx {
         }
     }
     #[inline]
-    pub fn del(&mut self, key: &[u8]) -> Result<(), RdbStatus> {
-        let mut status = RdbStatus::default();
+    pub fn del(&mut self, key: &[u8]) -> Result<(), RocksDbStatus> {
+        let mut status = RocksDbStatus::default();
         self.inner.pin_mut().del(key, &mut status);
         if status.is_ok() {
             Ok(())
@@ -102,8 +102,8 @@ impl Tx {
         }
     }
     #[inline]
-    pub fn get(&mut self, key: &[u8], for_update: bool) -> Result<Option<PinSlice>, RdbStatus> {
-        let mut status = RdbStatus::default();
+    pub fn get(&mut self, key: &[u8], for_update: bool) -> Result<Option<PinSlice>, RocksDbStatus> {
+        let mut status = RocksDbStatus::default();
         let ret = self.inner.pin_mut().get(key, for_update, &mut status);
         match status.code {
             StatusCode::kOk => Ok(Some(PinSlice { inner: ret })),
@@ -112,8 +112,8 @@ impl Tx {
         }
     }
     #[inline]
-    pub fn commit(&mut self) -> Result<(), RdbStatus> {
-        let mut status = RdbStatus::default();
+    pub fn commit(&mut self) -> Result<(), RocksDbStatus> {
+        let mut status = RocksDbStatus::default();
         self.inner.pin_mut().commit(&mut status);
         if status.is_ok() {
             Ok(())
@@ -122,8 +122,8 @@ impl Tx {
         }
     }
     #[inline]
-    pub fn rollback(&mut self) -> Result<(), RdbStatus> {
-        let mut status = RdbStatus::default();
+    pub fn rollback(&mut self) -> Result<(), RocksDbStatus> {
+        let mut status = RocksDbStatus::default();
         self.inner.pin_mut().rollback(&mut status);
         if status.is_ok() {
             Ok(())
@@ -132,8 +132,8 @@ impl Tx {
         }
     }
     #[inline]
-    pub fn rollback_to_save(&mut self) -> Result<(), RdbStatus> {
-        let mut status = RdbStatus::default();
+    pub fn rollback_to_save(&mut self) -> Result<(), RocksDbStatus> {
+        let mut status = RocksDbStatus::default();
         self.inner.pin_mut().rollback_to_savepoint(&mut status);
         if status.is_ok() {
             Ok(())
@@ -146,8 +146,8 @@ impl Tx {
         self.inner.pin_mut().set_savepoint();
     }
     #[inline]
-    pub fn pop_save(&mut self) -> Result<(), RdbStatus> {
-        let mut status = RdbStatus::default();
+    pub fn pop_save(&mut self) -> Result<(), RocksDbStatus> {
+        let mut status = RocksDbStatus::default();
         self.inner.pin_mut().pop_savepoint(&mut status);
         if status.is_ok() {
             Ok(())

cozorocks/src/lib.rs

@@ -5,8 +5,7 @@ mod tests;
 
 pub use bridge::db::DbBuilder;
 pub use bridge::db::RocksDb;
-pub use bridge::ffi::DbOpts;
-pub use bridge::ffi::RdbStatus;
+pub use bridge::ffi::RocksDbStatus;
 pub use bridge::ffi::StatusCode;
 pub use bridge::ffi::StatusSeverity;
 pub use bridge::ffi::StatusSubCode;