rm the deprecated batch APIs

Author: wlqm

CHANGELOG.md

@@ -132,19 +132,13 @@ These vector-like types heavily depended on reliable length tracking for indexin
 - **Expected improvement**: 10-100x faster prefix allocation under contention
 
 **4. WriteBatch API for Bulk Operations**
-- New `RocksEngine::write_batch()` method for atomic batch writes
-- Leverages RocksDB's native WriteBatch for optimal performance
-- Reduces per-operation overhead and improves throughput
-- **Use case**: Bulk inserts, transaction-like operations
+- New `Mapx::batch_entry()` method for atomic batch writes
+- Removed `Mapx::batch()` closure-based API
 
-```rust
 // Example: Batch write
-engine.write_batch(prefix, |batch| {
-    for i in 0..1000 {
-        batch.insert(&key(i), &value(i));
-    }
-});
-```
+let mut batch = engine.batch_entry();
+batch.insert(&key(i), &value(i));
+batch.commit().unwrap();
 
 **Performance Impact:**
 - **Single writes**: 5-15% faster due to reduced allocations

OPTIMIZATION_SUMMARY.md

@@ -80,28 +80,18 @@ fn set_max_key_len(&self, len: usize) {
 
 ```rust
 /// Batch write operations for better performance
-pub fn write_batch<F>(&self, meta_prefix: PreBytes, f: F)
-where
-    F: FnOnce(&mut dyn BatchTrait)
-{
-    let db = self.get_db(meta_prefix);
-    let cf = self.get_cf(meta_prefix);
-    let mut batch = RocksBatch::new(meta_prefix, cf);
-    f(&mut batch);
-    db.write(batch.inner).unwrap();
-    
-    // ... update max_keylen logic
-}
+let mut batch = map.batch_entry();
+batch.insert(&key, &value);
+batch.commit().unwrap();
 ```
 
 **Usage Example**:
 
 ```rust
-map.batch(|batch| {
-    for i in 0..1000 {
-        batch.insert(&key(i), &value(i));
-    }
-});
+// Example: Batch write
+let mut batch = map.batch_entry();
+batch.insert(&key(i), &value(i));
+batch.commit().unwrap();
 ```
 
 **Effect**:
@@ -148,7 +138,7 @@ fn alloc_prefix(&self) -> Pre {
 | Operation Type | Before | After | Improvement Source |
 | :--- | :--- | :--- | :--- |
 | Single Write | Baseline | 5-15% faster | Memory allocation optimization |
-| Batch Write | Baseline | 2-5x faster | WriteBatch API |
+| Batch Write | Baseline | 2-5x faster | batch_entry API |
 | Prefix Allocation (High Concurrency) | Baseline | 10-100x faster | Lock-free algorithm |
 
 ## 2. Benchmark Improvements
@@ -270,7 +260,7 @@ Suggested additions:
 This optimization work focused on:
 
 1. **RocksDB Engine Core Optimization** - Reduced memory allocation, lower write amplification, improved concurrency performance.
-2. **API Improvements** - Added `WriteBatch` support for batch operations.
+2. **API Improvements** - Added `batch_entry` support for batch operations.
 3. **Code Cleanup** - Removed deprecated `Vecx` related code.
 4. **Test Improvements** - Added new performance test cases.
 

core/src/basic/mapx_raw/mod.rs

@@ -310,19 +310,6 @@ impl MapxRaw {
         self.inner.remove(key.as_ref())
     }
 
-    /// Batch write operations for better performance and atomicity.
-    ///
-    /// # Arguments
-    ///
-    /// * `f` - A closure that takes a `&mut BatchTrait` and performs batch operations.
-    #[inline(always)]
-    pub fn batch<F>(&mut self, f: F)
-    where
-        F: FnOnce(&mut dyn crate::common::BatchTrait),
-    {
-        self.inner.write_batch(f);
-    }
-
     /// Start a batch operation.
     ///
     /// This method allows you to perform multiple insert/remove operations

core/src/basic/mapx_raw/test.rs

@@ -74,26 +74,30 @@ fn test_batch() {
     let mut hdr = MapxRaw::new();
     let max = 100u64;
 
-    hdr.batch(|batch| {
+    {
+        let mut batch = hdr.batch_entry();
         for i in 0..max {
             let key = to_bytes(i);
             let value = to_bytes(max + i);
             batch.insert(&key, &value);
         }
-    });
+        batch.commit().unwrap();
+    }
 
     for i in 0..max {
         let key = to_bytes(i);
         let value = to_bytes(max + i);
         assert_eq!(&pnk!(hdr.get(&key))[..], &value[..]);
     }
 
-    hdr.batch(|batch| {
+    {
+        let mut batch = hdr.batch_entry();
         for i in 0..max {
             let key = to_bytes(i);
             batch.remove(&key);
         }
-    });
+        batch.commit().unwrap();
+    }
 
     for i in 0..max {
         let key = to_bytes(i);

core/src/common/engines/mod.rs

@@ -70,11 +70,6 @@ pub trait Engine: Sized {
     /// Remove a key. Does not return the old value for performance.
     fn remove(&self, meta_prefix: PreBytes, key: &[u8]);
 
-    /// Batch write operations.
-    fn write_batch<F>(&self, meta_prefix: PreBytes, f: F)
-    where
-        F: FnOnce(&mut dyn BatchTrait);
-
     /// Alloc a batch.
     fn batch_begin<'a>(&'a self, meta_prefix: PreBytes) -> Box<dyn BatchTrait + 'a>;
 }
@@ -250,15 +245,6 @@ impl Mapx {
         VSDB.db.remove(prefix, key);
     }
 
-    #[inline(always)]
-    pub(crate) fn write_batch<F>(&mut self, f: F)
-    where
-        F: FnOnce(&mut dyn BatchTrait),
-    {
-        let prefix = self.prefix.hack_bytes();
-        VSDB.db.write_batch(prefix, f);
-    }
-
     #[inline(always)]
     pub(crate) fn batch_begin(&mut self) -> Box<dyn BatchTrait + '_> {
         let prefix = self.prefix.hack_bytes();

core/src/common/engines/parity_backend.rs

@@ -330,15 +330,6 @@ impl Engine for ParityEngine {
         db.commit([(area_idx as u8, full_key, None)]).unwrap();
     }
 
-    fn write_batch<F>(&self, meta_prefix: PreBytes, f: F)
-    where
-        F: FnOnce(&mut dyn BatchTrait),
-    {
-        let mut batch = ParityBatch::new(meta_prefix, self);
-        f(&mut batch);
-        batch.commit().unwrap();
-    }
-
     fn batch_begin<'a>(&'a self, meta_prefix: PreBytes) -> Box<dyn BatchTrait + 'a> {
         Box::new(ParityBatch::new(meta_prefix, self))
     }

core/src/common/engines/rocks_backend.rs

@@ -326,16 +326,6 @@ impl Engine for RocksEngine {
         db.delete_cf(cf, full_key).unwrap();
     }
 
-    fn write_batch<F>(&self, meta_prefix: PreBytes, f: F)
-    where
-        F: FnOnce(&mut dyn BatchTrait),
-    {
-        let cf = self.get_cf(meta_prefix);
-        let mut batch = RocksBatch::new(meta_prefix, cf, self);
-        f(&mut batch);
-        batch.commit().unwrap();
-    }
-
     fn batch_begin<'a>(&'a self, meta_prefix: PreBytes) -> Box<dyn BatchTrait + 'a> {
         let cf = self.get_cf(meta_prefix);
         Box::new(RocksBatch::new(meta_prefix, cf, self))

wrappers/benches/units/basic_mapx.rs

@@ -31,12 +31,12 @@ fn read_write(c: &mut Criterion) {
 
     group.bench_function(" batch write (100 items) ", |b| {
         b.iter(|| {
-            db.batch(|batch| {
-                for _ in 0..100 {
-                    let n = i.fetch_add(1, Ordering::SeqCst);
-                    batch.insert(&[n; 2], &vec![n; 128]);
-                }
-            });
+            let mut batch = db.batch_entry();
+            for _ in 0..100 {
+                let n = i.fetch_add(1, Ordering::SeqCst);
+                batch.insert(&[n; 2], &vec![n; 128]);
+            }
+            batch.commit().unwrap();
         })
     });
 

wrappers/benches/units/batch_vs_normal.rs

@@ -24,19 +24,7 @@ fn batch_vs_normal_write(c: &mut Criterion) {
         })
     });
 
-    // Case 2: Batch write 100 items (closure)
-    group.bench_function(" batch closure 100 ", |b| {
-        b.iter(|| {
-            db.batch(|batch| {
-                for _ in 0..100 {
-                    let n = i.fetch_add(1, Ordering::Relaxed);
-                    batch.insert(&n, &n);
-                }
-            });
-        })
-    });
-
-    // Case 3: Batch write 100 items (entry struct)
+    // Case 2: Batch write 100 items (entry struct)
     group.bench_function(" batch entry 100 ", |b| {
         b.iter(|| {
             let mut batch = db.batch_entry();

wrappers/src/basic/mapx/mod.rs

@@ -161,21 +161,6 @@ where
         self.inner.remove(key.encode())
     }
 
-    /// Batch write operations.
-    #[inline(always)]
-    pub fn batch<F>(&mut self, f: F)
-    where
-        F: FnOnce(&mut MapxBatch<K, V>),
-    {
-        self.inner.batch(|raw_batch| {
-            let mut batch = MapxBatch {
-                inner: raw_batch,
-                _marker: PhantomData,
-            };
-            f(&mut batch);
-        });
-    }
-
     /// Start a batch operation.
     ///
     /// This method allows you to perform multiple insert/remove operations