feat: complete example

.github/workflows/ci.yml

@@ -44,7 +44,7 @@ jobs:
       - name: Run cargo test
         uses: actions-rs/cargo@v1
         with:
-          command: test
+          command: test --all-features
   # 2
   fmt:
     name: Rust fmt

examples/declare.rs

@@ -1,21 +1,64 @@
-use morseldb::morsel_record;
+use std::ops::Bound;
+
+use futures_util::stream::StreamExt;
+
+use morseldb::executor::tokio::TokioExecutor;
+use morseldb::{morsel_record, Projection, DB};
 
 // Tips: must be public
 #[morsel_record]
-pub struct Post {
+pub struct User {
     #[primary_key]
     name: String,
-    vu8: u8,
-    vu16: u16,
-    vu32: u32,
-    vu64: u64,
-    vi8: i8,
-    vi16: i16,
-    vi32: i32,
-    vi64: i64,
-    vbool: bool,
+    // email: Option<String>,
+    age: u8,
 }
 
-fn main() {
-    println!("Hello, world!");
+#[tokio::main]
+async fn main() {
+    let db = DB::<User, _>::new("./db_path/users".into(), TokioExecutor::default())
+        .await
+        .unwrap();
+
+    {
+        // morseldb supports transaction
+        let mut txn = db.transaction().await;
+
+        // set with owned value
+        txn.set(User {
+            name: "Alice".into(),
+            // email: None,
+            age: 22,
+        });
+
+        // get from primary key
+        let name = "Alice".into();
+        let user = txn.get(&name, Projection::All).await.unwrap();
+        assert!(user.is_some());
+        assert_eq!(user.unwrap().get().age, Some(22));
+
+        let upper = "Blob".into();
+        let mut scan = txn
+            .scan((Bound::Included(&name), Bound::Excluded(&upper)))
+            .await
+            .projection(vec![1])
+            .take()
+            .await
+            .unwrap();
+        loop {
+            let user = scan.next().await.transpose().unwrap();
+            match user {
+                Some(entry) => {
+                    assert_eq!(
+                        entry.value(),
+                        Some(UserRef {
+                            name: "Alice",
+                            age: Some(22),
+                        })
+                    );
+                }
+                None => break,
+            }
+        }
+    }
 }

src/lib.rs

@@ -56,7 +56,8 @@ where
     R: Record + Send,
     E: Executor,
 {
-    pub async fn new(option: Arc<DbOption>, executor: E) -> Result<Self, WriteError<R>> {
+    pub async fn new(option: DbOption, executor: E) -> Result<Self, WriteError<R>> {
+        let option = Arc::new(option);
         E::create_dir_all(&option.path).await?;
 
         let schema = Arc::new(RwLock::new(Schema::default()));
@@ -507,7 +508,7 @@ pub(crate) mod tests {
     }
 
     pub(crate) async fn get_test_record_batch<E: Executor>(
-        option: Arc<DbOption>,
+        option: DbOption,
         executor: E,
     ) -> RecordBatch {
         let db: DB<Test, E> = DB::new(option, executor).await.unwrap();

src/ondisk/sstable.rs

@@ -157,7 +157,7 @@ pub(crate) mod tests {
     async fn write_sstable() {
         let temp_dir = tempfile::tempdir().unwrap();
         let record_batch = get_test_record_batch::<TokioExecutor>(
-            Arc::new(DbOption::from(temp_dir.path())),
+            DbOption::from(temp_dir.path()),
             TokioExecutor::new(),
         )
         .await;
@@ -184,7 +184,7 @@ pub(crate) mod tests {
     async fn projection_query() {
         let temp_dir = tempfile::tempdir().unwrap();
         let record_batch = get_test_record_batch::<TokioExecutor>(
-            Arc::new(DbOption::from(temp_dir.path())),
+            DbOption::from(temp_dir.path()),
             TokioExecutor::new(),
         )
         .await;
@@ -255,7 +255,7 @@ pub(crate) mod tests {
     async fn projection_scan() {
         let temp_dir = tempfile::tempdir().unwrap();
         let record_batch = get_test_record_batch::<TokioExecutor>(
-            Arc::new(DbOption::from(temp_dir.path())),
+            DbOption::from(temp_dir.path()),
             TokioExecutor::new(),
         )
         .await;

src/stream/mod.rs

@@ -55,7 +55,7 @@ where
         }
     }
 
-    pub(crate) fn value(&self) -> Option<R::Ref<'_>> {
+    pub fn value(&self) -> Option<R::Ref<'_>> {
         match self {
             Entry::Transaction((_, value)) => value.as_ref().map(R::as_record_ref),
             Entry::Mutable(entry) => entry.value().as_ref().map(R::as_record_ref),

src/transaction.rs

@@ -85,7 +85,7 @@ where
                     if entry.value().is_none() {
                         None
                     } else {
-                        TransactionEntry::Stream(entry).into()
+                        Some(TransactionEntry::Stream(entry))
                     }
                 }),
         })
@@ -159,12 +159,12 @@ impl<'entry, R> TransactionEntry<'entry, R>
 where
     R: Record,
 {
-    pub fn get(&self) -> Option<R::Ref<'_>> {
+    pub fn get(&self) -> R::Ref<'_> {
         match self {
-            TransactionEntry::Stream(entry) => entry.value(),
+            TransactionEntry::Stream(entry) => entry.value().unwrap(),
             TransactionEntry::Local(value) => {
                 // Safety: shorter lifetime must be safe
-                Some(unsafe { transmute::<R::Ref<'entry>, R::Ref<'_>>(*value) })
+                unsafe { transmute::<R::Ref<'entry>, R::Ref<'_>>(*value) }
             }
         }
     }
@@ -202,12 +202,10 @@ mod tests {
     async fn transaction_read_write() {
         let temp_dir = TempDir::new().unwrap();
 
-        let db = DB::<String, TokioExecutor>::new(
-            Arc::new(DbOption::from(temp_dir.path())),
-            TokioExecutor::new(),
-        )
-        .await
-        .unwrap();
+        let db =
+            DB::<String, TokioExecutor>::new(DbOption::from(temp_dir.path()), TokioExecutor::new())
+                .await
+                .unwrap();
         {
             let mut txn1 = db.transaction().await;
             txn1.set("foo".to_string());
@@ -238,12 +236,10 @@ mod tests {
     async fn write_conflicts() {
         let temp_dir = TempDir::new().unwrap();
 
-        let db = DB::<String, TokioExecutor>::new(
-            Arc::new(DbOption::from(temp_dir.path())),
-            TokioExecutor::new(),
-        )
-        .await
-        .unwrap();
+        let db =
+            DB::<String, TokioExecutor>::new(DbOption::from(temp_dir.path()), TokioExecutor::new())
+                .await
+                .unwrap();
 
         let mut txn = db.transaction().await;
         txn.set(0.to_string());
@@ -273,12 +269,10 @@ mod tests {
     async fn transaction_projection() {
         let temp_dir = TempDir::new().unwrap();
 
-        let db = DB::<Test, TokioExecutor>::new(
-            Arc::new(DbOption::from(temp_dir.path())),
-            TokioExecutor::new(),
-        )
-        .await
-        .unwrap();
+        let db =
+            DB::<Test, TokioExecutor>::new(DbOption::from(temp_dir.path()), TokioExecutor::new())
+                .await
+                .unwrap();
 
         let mut txn1 = db.transaction().await;
         txn1.set(Test {
@@ -290,9 +284,9 @@ mod tests {
         let key = 0.to_string();
         let entry = txn1.get(&key, Projection::All).await.unwrap().unwrap();
 
-        assert_eq!(entry.get().unwrap().vstring, 0.to_string());
-        assert_eq!(entry.get().unwrap().vu32, Some(0));
-        assert_eq!(entry.get().unwrap().vbool, Some(true));
+        assert_eq!(entry.get().vstring, 0.to_string());
+        assert_eq!(entry.get().vu32, Some(0));
+        assert_eq!(entry.get().vbool, Some(true));
         drop(entry);
 
         txn1.commit().await.unwrap();