Display trait

cozorocks/src/bridge.rs

@@ -175,3 +175,80 @@ mod ffi {
 }
 
 pub use ffi::*;
+use std::fmt::Formatter;
+
+
+impl std::fmt::Display for StatusBridgeCode {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", match self {
+            &StatusBridgeCode::OK => "Ok",
+            &StatusBridgeCode::LOCK_ERROR => "LockError",
+            &StatusBridgeCode::EXISTING_ERROR => "ExistingError",
+            &StatusBridgeCode::NOT_FOUND_ERROR => "NotFoundError",
+            _ => "Unknown"
+        })
+    }
+}
+
+impl std::fmt::Display for StatusCode {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", match self {
+            &StatusCode::kOk => "Ok",
+            &StatusCode::kNotFound => "NotFound",
+            &StatusCode::kCorruption => "Corruption",
+            &StatusCode::kNotSupported => "NotSupported",
+            &StatusCode::kInvalidArgument => "InvalidArgument",
+            &StatusCode::kIOError => "IoError",
+            &StatusCode::kMergeInProgress => "MergeInProgress",
+            &StatusCode::kIncomplete => "Incomplete",
+            &StatusCode::kShutdownInProgress => "ShutdownInProgress",
+            &StatusCode::kTimedOut => "TimedOut",
+            &StatusCode::kAborted => "Aborted",
+            &StatusCode::kBusy => "Busy",
+            &StatusCode::kExpired => "Expired",
+            &StatusCode::kTryAgain => "TryAgain",
+            &StatusCode::kCompactionTooLarge => "CompactionTooLarge",
+            &StatusCode::kColumnFamilyDropped => "ColumnFamilyDropped",
+            &StatusCode::kMaxCode => "MaxCode",
+            _ => "Unknown"
+        })
+    }
+}
+
+impl std::fmt::Display for StatusSubCode {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", match self {
+            &StatusSubCode::kNone => "None",
+            &StatusSubCode::kMutexTimeout => "MutexTimeout",
+            &StatusSubCode::kLockTimeout => "LockTimeout",
+            &StatusSubCode::kLockLimit => "LockLimit",
+            &StatusSubCode::kNoSpace => "NoSpace",
+            &StatusSubCode::kDeadlock => "DeadLock",
+            &StatusSubCode::kStaleFile => "StaleFile",
+            &StatusSubCode::kMemoryLimit => "MemoryLimit",
+            &StatusSubCode::kSpaceLimit => "SpaceLimit",
+            &StatusSubCode::kPathNotFound => "PathNotFound",
+            &StatusSubCode::KMergeOperandsInsufficientCapacity => "MergeOperandsInsufficientCapacity",
+            &StatusSubCode::kManualCompactionPaused => "ManualCompactionPaused",
+            &StatusSubCode::kOverwritten => "Overwritten",
+            &StatusSubCode::kTxnNotPrepared => "TxnNotPrepared",
+            &StatusSubCode::kIOFenced => "IoFenced",
+            &StatusSubCode::kMaxSubCode => "MaxSubCode",
+            _ => "Unknown"
+        })
+    }
+}
+
+impl std::fmt::Display for StatusSeverity {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", match self {
+            &StatusSeverity::kNoError => "NoError",
+            &StatusSeverity::kSoftError => "SoftError",
+            &StatusSeverity::kHardError => "HardError",
+            &StatusSeverity::kFatalError => "FatalError",
+            &StatusSeverity::kUnrecoverableError => "UnrecoverableError",
+            &StatusSeverity::kMaxSeverity => "MaxSeverity",
+            _ => "Unknown"
+        })
+    }
+}

cozorocks/src/lib.rs

@@ -2,7 +2,7 @@ mod bridge;
 
 use bridge::*;
 
-use std::fmt::{Display, Formatter};
+use std::fmt::{Display, Formatter, write};
 use std::fmt::Debug;
 use std::ops::{Deref, DerefMut};
 use cxx::{let_cxx_string};
@@ -19,7 +19,7 @@ pub use bridge::ColumnFamilyHandle;
 
 impl std::fmt::Display for BridgeStatus {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        Debug::fmt(self, f)
+        write!(f, "BridgeStatus({}, {}, {}, {})", self.code, self.subcode, self.severity, self.bridge_code)
     }
 }
 
@@ -30,7 +30,7 @@ pub struct BridgeError {
 
 impl Display for BridgeError {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        Debug::fmt(self, f)
+        write!(f, "BridgeError({}, {}, {}, {})", self.status.code, self.status.subcode, self.status.severity, self.status.bridge_code)
     }
 }
 

src/db/engine.rs

@@ -3,8 +3,7 @@
 
 
 use cozorocks::*;
-use std::sync::{Arc, LockResult, Mutex, RwLock};
-use std::sync::atomic::AtomicUsize;
+use std::sync::{Arc, RwLock};
 use std::time::{SystemTime, UNIX_EPOCH};
 use uuid::Uuid;
 use uuid::v1::{Context, Timestamp};
@@ -151,7 +150,7 @@ mod tests {
             assert!(engine2.is_ok());
             let engine2 = Arc::new(Engine::new(p3.to_string(), false).unwrap());
             {
-                for i in 0..10 {
+                for _i in 0..10 {
                     let _sess = engine2.session();
                 }
                 let handles = engine2.session_handles.read().unwrap();

src/db/eval.rs

@@ -1,27 +1,27 @@
-use crate::relation::table::Table;
-use crate::relation::typing::Typing;
-use crate::relation::value::Value;
-
-pub trait Environment {
-    fn push_env(&mut self) {
-
-    }
-    fn pop_env(&mut self) {
-
-    }
-    fn define_variable(&mut self, name: &str, val: &Value, in_root: bool) {
-
-    }
-    fn define_type_alias(&mut self, name: &str, typ: &Typing, in_root: bool) {
-
-    }
-    fn define_table(&mut self, table: &Table, in_root: bool) {
-
-    }
-    fn resolve(&mut self, name: &str) {
-
-    }
-    fn delete_defined(&mut self, name: &str, in_root: bool) {
-
-    }
-}
+// use crate::relation::table::Table;
+// use crate::relation::typing::Typing;
+// use crate::relation::value::Value;
+//
+// pub trait Environment {
+//     fn push_env(&mut self) {
+//
+//     }
+//     fn pop_env(&mut self) {
+//
+//     }
+//     fn define_variable(&mut self, name: &str, val: &Value, in_root: bool) {
+//
+//     }
+//     fn define_type_alias(&mut self, name: &str, typ: &Typing, in_root: bool) {
+//
+//     }
+//     fn define_table(&mut self, table: &Table, in_root: bool) {
+//
+//     }
+//     fn resolve(&mut self, name: &str) {
+//
+//     }
+//     fn delete_defined(&mut self, name: &str, in_root: bool) {
+//
+//     }
+// }