wip

dashpay · Jan 17, 2025 · eec7145 · eec7145
1 parent 390d047
commit eec7145
Show file tree

Hide file tree

Showing 16 changed files with 342 additions and 739 deletions.
diff --git a/grovedb/src/batch/mod.rs b/grovedb/src/batch/mod.rs
diff --git a/grovedb/src/element/get.rs b/grovedb/src/element/get.rs
@@ -431,8 +431,10 @@ mod tests {
         let grove_version = GroveVersion::latest();
         let storage = TempStorage::new();
         let batch = StorageBatch::new();
+        let transaction = storage.start_transaction();
+
         let ctx = storage
-            .get_storage_context(SubtreePath::empty(), Some(&batch))
+            .get_transactional_storage_context(SubtreePath::empty(), Some(&batch), &transaction)
             .unwrap();
         let mut merk = Merk::open_base(
             ctx,
@@ -452,12 +454,12 @@ mod tests {
             .expect("expected successful insertion 2");
 
         storage
-            .commit_multi_context_batch(batch, None)
+            .commit_multi_context_batch(batch, Some(&transaction))
             .unwrap()
             .unwrap();
 
         let ctx = storage
-            .get_storage_context(SubtreePath::empty(), None)
+            .get_transactional_storage_context(SubtreePath::empty(), None, &transaction)
             .unwrap();
         let mut merk = Merk::open_base(
             ctx,

diff --git a/grovedb/src/estimated_costs/average_case_costs.rs b/grovedb/src/estimated_costs/average_case_costs.rs
@@ -637,10 +637,11 @@ mod test {
         let storage = RocksDbStorage::default_rocksdb_with_path(tmp_dir.path())
             .expect("cannot open rocksdb storage");
         let batch = StorageBatch::new();
+        let transaction = storage.start_transaction();
 
         let mut merk = Merk::open_base(
             storage
-                .get_storage_context(EMPTY_PATH, Some(&batch))
+                .get_transactional_storage_context(EMPTY_PATH, Some(&batch), &transaction)
                 .unwrap(),
             TreeType::NormalTree,
             None::<&fn(&[u8], &GroveVersion) -> Option<ValueDefinedCostType>>,
@@ -655,13 +656,15 @@ mod test {
 
         // this consumes the batch so storage contexts and merks will be dropped
         storage
-            .commit_multi_context_batch(batch, None)
+            .commit_multi_context_batch(batch, Some(&transaction))
             .unwrap()
             .unwrap();
 
         // Reopen merk: this time, only root node is loaded to memory
         let merk = Merk::open_base(
-            storage.get_storage_context(EMPTY_PATH, None).unwrap(),
+            storage
+                .get_transactional_storage_context(EMPTY_PATH, None, &transaction)
+                .unwrap(),
             TreeType::NormalTree,
             None::<&fn(&[u8], &GroveVersion) -> Option<ValueDefinedCostType>>,
             grove_version,

diff --git a/grovedb/src/estimated_costs/worst_case_costs.rs b/grovedb/src/estimated_costs/worst_case_costs.rs
@@ -519,7 +519,9 @@ mod test {
         // Open a merk and insert 10 elements.
         let storage = TempStorage::new();
         let batch = StorageBatch::new();
-        let mut merk = empty_path_merk(&*storage, &batch, grove_version);
+        let transaction = storage.start_transaction();
+
+        let mut merk = empty_path_merk(&*storage, &transaction, &batch, grove_version);
 
         let merk_batch = make_batch_seq(1..10);
         merk.apply::<_, Vec<_>>(merk_batch.as_slice(), &[], None, grove_version)
@@ -528,12 +530,12 @@ mod test {
 
         // this consumes the batch so storage contexts and merks will be dropped
         storage
-            .commit_multi_context_batch(batch, None)
+            .commit_multi_context_batch(batch, Some(&transaction))
             .unwrap()
             .unwrap();
 
         // Reopen merk: this time, only root node is loaded to memory
-        let merk = empty_path_merk_read_only(&*storage, grove_version);
+        let merk = empty_path_merk_read_only(&*storage, &transaction, grove_version);
 
         // To simulate worst case, we need to pick a node that:
         // 1. Is not in memory

diff --git a/grovedb/src/tests/mod.rs b/grovedb/src/tests/mod.rs
@@ -3125,10 +3125,15 @@ mod tests {
         // let mut iter = db
         //     .elements_iterator([TEST_LEAF, b"subtree1"].as_ref(), None)
         //     .expect("cannot create iterator");
+        let transaction = db.grove_db.start_transaction();
         let storage_context = db
             .grove_db
             .db
-            .get_storage_context([TEST_LEAF, b"subtree1"].as_ref().into(), None)
+            .get_transactional_storage_context(
+                [TEST_LEAF, b"subtree1"].as_ref().into(),
+                None,
+                &transaction,
+            )
             .unwrap();
         let mut iter = Element::iterator(storage_context.raw_iter()).unwrap();
         assert_eq!(
@@ -3217,7 +3222,12 @@ mod tests {
     fn test_root_subtree_has_root_key() {
         let grove_version = GroveVersion::latest();
         let db = make_test_grovedb(grove_version);
-        let storage = db.db.get_storage_context(EMPTY_PATH, None).unwrap();
+        let transaction = db.start_transaction();
+
+        let storage = db
+            .db
+            .get_transactional_storage_context(EMPTY_PATH, None, &transaction)
+            .unwrap();
         let root_merk = Merk::open_base(
             storage,
             TreeType::NormalTree,
@@ -3317,10 +3327,16 @@ mod tests {
         // Retrieve subtree instance
         // Check if it returns the same instance that was inserted
         {
+            let transaction = db.grove_db.start_transaction();
+
             let subtree_storage = db
                 .grove_db
                 .db
-                .get_storage_context([TEST_LEAF, b"key1", b"key2"].as_ref().into(), None)
+                .get_transactional_storage_context(
+                    [TEST_LEAF, b"key1", b"key2"].as_ref().into(),
+                    None,
+                    &transaction,
+                )
                 .unwrap();
             let subtree = Merk::open_layered_with_root_key(
                 subtree_storage,
@@ -3335,6 +3351,11 @@ mod tests {
                 .unwrap()
                 .unwrap();
             assert_eq!(result_element, Element::new_item(b"ayy".to_vec()));
+
+            db.grove_db
+                .commit_transaction(transaction)
+                .unwrap()
+                .unwrap();
         }
         // Insert a new tree with transaction
         let transaction = db.start_transaction();
@@ -3389,7 +3410,11 @@ mod tests {
         let subtree_storage = db
             .grove_db
             .db
-            .get_storage_context([TEST_LEAF, b"key1", b"key2"].as_ref().into(), None)
+            .get_transactional_storage_context(
+                [TEST_LEAF, b"key1", b"key2"].as_ref().into(),
+                None,
+                &transaction,
+            )
             .unwrap();
         let subtree = Merk::open_layered_with_root_key(
             subtree_storage,

diff --git a/merk/src/merk/mod.rs b/merk/src/merk/mod.rs
@@ -795,7 +795,7 @@ mod test {
 
     use grovedb_path::SubtreePath;
     use grovedb_storage::{
-        rocksdb_storage::{PrefixedRocksDbStorageContext, RocksDbStorage},
+        rocksdb_storage::{PrefixedRocksDbTransactionContext, RocksDbStorage},
         RawIterator, Storage, StorageBatch, StorageContext,
     };
     use grovedb_version::version::GroveVersion;
@@ -1027,9 +1027,11 @@ mod test {
         let tmp_dir = TempDir::new().expect("cannot open tempdir");
         let storage = RocksDbStorage::default_rocksdb_with_path(tmp_dir.path())
             .expect("cannot open rocksdb storage");
+        let transaction = storage.start_transaction();
+
         let mut merk = Merk::open_base(
             storage
-                .get_storage_context(SubtreePath::empty(), None)
+                .get_transactional_storage_context(SubtreePath::empty(), None, &transaction)
                 .unwrap(),
             TreeType::NormalTree,
             None::<&fn(&[u8], &GroveVersion) -> Option<ValueDefinedCostType>>,
@@ -1053,9 +1055,11 @@ mod test {
         let tmp_dir = TempDir::new().expect("cannot open tempdir");
         let storage = RocksDbStorage::default_rocksdb_with_path(tmp_dir.path())
             .expect("cannot open rocksdb storage");
+        let transaction = storage.start_transaction();
+
         let mut merk = Merk::open_base(
             storage
-                .get_storage_context(SubtreePath::empty(), None)
+                .get_transactional_storage_context(SubtreePath::empty(), None, &transaction)
                 .unwrap(),
             TreeType::NormalTree,
             None::<&fn(&[u8], &GroveVersion) -> Option<ValueDefinedCostType>>,
@@ -1074,7 +1078,7 @@ mod test {
     fn reopen() {
         let grove_version = GroveVersion::latest();
         fn collect(
-            mut node: RefWalker<MerkSource<PrefixedRocksDbStorageContext>>,
+            mut node: RefWalker<MerkSource<PrefixedRocksDbTransactionContext>>,
             nodes: &mut Vec<Vec<u8>>,
         ) {
             let grove_version = GroveVersion::latest();
@@ -1109,9 +1113,15 @@ mod test {
             let storage = RocksDbStorage::default_rocksdb_with_path(tmp_dir.path())
                 .expect("cannot open rocksdb storage");
             let batch = StorageBatch::new();
+            let transaction = storage.start_transaction();
+
             let mut merk = Merk::open_base(
                 storage
-                    .get_storage_context(SubtreePath::empty(), Some(&batch))
+                    .get_transactional_storage_context(
+                        SubtreePath::empty(),
+                        Some(&batch),
+                        &transaction,
+                    )
                     .unwrap(),
                 TreeType::NormalTree,
                 None::<&fn(&[u8], &GroveVersion) -> Option<ValueDefinedCostType>>,
@@ -1125,12 +1135,13 @@ mod test {
                 .unwrap();
 
             storage
-                .commit_multi_context_batch(batch, None)
+                .commit_multi_context_batch(batch, Some(&transaction))
                 .unwrap()
                 .expect("cannot commit batch");
+
             let merk = Merk::open_base(
                 storage
-                    .get_storage_context(SubtreePath::empty(), None)
+                    .get_transactional_storage_context(SubtreePath::empty(), None, &transaction)
                     .unwrap(),
                 TreeType::NormalTree,
                 None::<&fn(&[u8], &GroveVersion) -> Option<ValueDefinedCostType>>,
@@ -1144,14 +1155,19 @@ mod test {
 
             let mut nodes = vec![];
             collect(walker, &mut nodes);
+
+            storage.commit_transaction(transaction).unwrap().unwrap();
+
             nodes
         };
 
         let storage = RocksDbStorage::default_rocksdb_with_path(tmp_dir.path())
             .expect("cannot open rocksdb storage");
+        let transaction = storage.start_transaction();
+
         let merk = Merk::open_base(
             storage
-                .get_storage_context(SubtreePath::empty(), None)
+                .get_transactional_storage_context(SubtreePath::empty(), None, &transaction)
                 .unwrap(),
             TreeType::NormalTree,
             None::<&fn(&[u8], &GroveVersion) -> Option<ValueDefinedCostType>>,
@@ -1169,7 +1185,7 @@ mod test {
     }
 
     type PrefixedStorageIter<'db, 'ctx> =
-        &'ctx mut <PrefixedRocksDbStorageContext<'db> as StorageContext<'db>>::RawIterator;
+        &'ctx mut <PrefixedRocksDbTransactionContext<'db> as StorageContext<'db>>::RawIterator;
 
     #[test]
     fn reopen_iter() {
@@ -1189,9 +1205,15 @@ mod test {
             let storage = RocksDbStorage::default_rocksdb_with_path(tmp_dir.path())
                 .expect("cannot open rocksdb storage");
             let batch = StorageBatch::new();
+            let transaction = storage.start_transaction();
+
             let mut merk = Merk::open_base(
                 storage
-                    .get_storage_context(SubtreePath::empty(), Some(&batch))
+                    .get_transactional_storage_context(
+                        SubtreePath::empty(),
+                        Some(&batch),
+                        &transaction,
+                    )
                     .unwrap(),
                 TreeType::NormalTree,
                 None::<&fn(&[u8], &GroveVersion) -> Option<ValueDefinedCostType>>,
@@ -1205,14 +1227,14 @@ mod test {
                 .unwrap();
 
             storage
-                .commit_multi_context_batch(batch, None)
+                .commit_multi_context_batch(batch, Some(&transaction))
                 .unwrap()
                 .expect("cannot commit batch");
 
             let mut nodes = vec![];
             let merk = Merk::open_base(
                 storage
-                    .get_storage_context(SubtreePath::empty(), None)
+                    .get_transactional_storage_context(SubtreePath::empty(), None, &transaction)
                     .unwrap(),
                 TreeType::NormalTree,
                 None::<&fn(&[u8], &GroveVersion) -> Option<ValueDefinedCostType>>,
@@ -1221,13 +1243,18 @@ mod test {
             .unwrap()
             .expect("cannot open merk");
             collect(&mut merk.storage.raw_iter(), &mut nodes);
+
+            storage.commit_transaction(transaction).unwrap().unwrap();
+
             nodes
         };
+
         let storage = RocksDbStorage::default_rocksdb_with_path(tmp_dir.path())
             .expect("cannot open rocksdb storage");
+        let transaction = storage.start_transaction();
         let merk = Merk::open_base(
             storage
-                .get_storage_context(SubtreePath::empty(), None)
+                .get_transactional_storage_context(SubtreePath::empty(), None, &transaction)
                 .unwrap(),
             TreeType::NormalTree,
             None::<&fn(&[u8], &GroveVersion) -> Option<ValueDefinedCostType>>,
@@ -1249,9 +1276,11 @@ mod test {
         let storage = RocksDbStorage::default_rocksdb_with_path(tmp_dir.path())
             .expect("cannot open rocksdb storage");
         let batch = StorageBatch::new();
+        let transaction = storage.start_transaction();
+
         let mut merk = Merk::open_base(
             storage
-                .get_storage_context(SubtreePath::empty(), Some(&batch))
+                .get_transactional_storage_context(SubtreePath::empty(), Some(&batch), &transaction)
                 .unwrap(),
             TreeType::NormalTree,
             None::<&fn(&[u8], &GroveVersion) -> Option<ValueDefinedCostType>>,
@@ -1309,13 +1338,13 @@ mod test {
         assert_eq!(result, Some(b"b".to_vec()));
 
         storage
-            .commit_multi_context_batch(batch, None)
+            .commit_multi_context_batch(batch, Some(&transaction))
             .unwrap()
             .expect("cannot commit batch");
 
         let mut merk = Merk::open_base(
             storage
-                .get_storage_context(SubtreePath::empty(), None)
+                .get_transactional_storage_context(SubtreePath::empty(), None, &transaction)
                 .unwrap(),
             TreeType::NormalTree,
             None::<&fn(&[u8], &GroveVersion) -> Option<ValueDefinedCostType>>,