Split benched.rs into separate Neo4j and Doublets modules

Addresses user feedback requesting clear separation of Neo4j and Doublets
logic. The benched.rs file contained mixed implementations for both databases.

Changes:
- Removed rust/src/benched.rs (contained both Neo4j and Doublets impls)
- Added rust/src/benched/mod.rs with common Benched trait
- Added rust/src/benched/doublets_benched.rs with Doublets implementations
- Added rust/src/benched/neo4j_benched.rs with Neo4j implementations

This provides complete separation between Neo4j and Doublets code across
all source files for easier side-by-side comparison.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <[email protected]>

Author: konard

rust/src/benched.rs

@@ -0,0 +1,119 @@
+//! # Doublets Benched Implementations
+//!
+//! This module contains the [`Benched`] trait implementations for all Doublets
+//! storage backends.
+//!
+//! ## Storage Backends
+//!
+//! | Type                         | Storage        | Description                      |
+//! |------------------------------|----------------|----------------------------------|
+//! | `unit::Store` + `FileMapped` | Non-volatile   | Memory-mapped file storage       |
+//! | `unit::Store` + `Alloc`      | Volatile       | In-memory storage                |
+//! | `split::Store` + `FileMapped`| Non-volatile   | Split data/index file storage    |
+//! | `split::Store` + `Alloc`     | Volatile       | Split data/index in-memory       |
+//!
+//! ## Implementation Details
+//!
+//! All Doublets implementations clean up by calling `delete_all()` in `unfork()`,
+//! which removes all links from the storage for the next benchmark iteration.
+
+use std::alloc::Global;
+
+use doublets::{
+    data::LinkType,
+    mem::{Alloc, FileMapped},
+    split::{self, DataPart, IndexPart},
+    unit::{self, LinkPart},
+    Doublets,
+};
+
+use super::Benched;
+use crate::map_file;
+
+/// Doublets United (unit) store with non-volatile (file-mapped) storage.
+///
+/// ## Setup
+/// ```rust,ignore
+/// let store = unit::Store::<usize, FileMapped<LinkPart<_>>>::setup("united.links")?;
+/// ```
+///
+/// ## Cleanup
+/// Calls `delete_all()` to remove all links between iterations.
+impl<T: LinkType> Benched for unit::Store<T, FileMapped<LinkPart<T>>> {
+    type Builder<'a> = &'a str;
+
+    fn setup(builder: Self::Builder<'_>) -> crate::Result<Self> {
+        Self::new(map_file(builder)?).map_err(Into::into)
+    }
+
+    unsafe fn unfork(&mut self) {
+        let _ = self.delete_all();
+    }
+}
+
+/// Doublets United (unit) store with volatile (in-memory) storage.
+///
+/// ## Setup
+/// ```rust,ignore
+/// let store = unit::Store::<usize, Alloc<LinkPart<_>, Global>>::setup(())?;
+/// ```
+///
+/// ## Cleanup
+/// Calls `delete_all()` to remove all links between iterations.
+impl<T: LinkType> Benched for unit::Store<T, Alloc<LinkPart<T>, Global>> {
+    type Builder<'a> = ();
+
+    fn setup(_: Self::Builder<'_>) -> crate::Result<Self> {
+        Self::new(Alloc::new(Global)).map_err(Into::into)
+    }
+
+    unsafe fn unfork(&mut self) {
+        let _ = self.delete_all();
+    }
+}
+
+/// Doublets Split store with non-volatile (file-mapped) storage.
+///
+/// ## Setup
+/// ```rust,ignore
+/// let store = split::Store::<usize, FileMapped<_>, FileMapped<_>>::setup(
+///     ("split_index.links", "split_data.links")
+/// )?;
+/// ```
+///
+/// ## Cleanup
+/// Calls `delete_all()` to remove all links between iterations.
+impl<T: LinkType> Benched for split::Store<T, FileMapped<DataPart<T>>, FileMapped<IndexPart<T>>> {
+    type Builder<'a> = (&'a str, &'a str);
+
+    fn setup((data, index): Self::Builder<'_>) -> crate::Result<Self> {
+        Self::new(map_file(data)?, map_file(index)?).map_err(Into::into)
+    }
+
+    unsafe fn unfork(&mut self) {
+        let _ = self.delete_all();
+    }
+}
+
+/// Doublets Split store with volatile (in-memory) storage.
+///
+/// ## Setup
+/// ```rust,ignore
+/// let store = split::Store::<usize, Alloc<DataPart<_>, _>, Alloc<IndexPart<_>, _>>::setup(())?;
+/// ```
+///
+/// ## Cleanup
+/// Calls `delete_all()` to remove all links between iterations.
+impl<T: LinkType> Benched
+    for split::Store<T, Alloc<DataPart<T>, Global>, Alloc<IndexPart<T>, Global>>
+{
+    type Builder<'a> = ();
+
+    fn setup(_: Self::Builder<'_>) -> crate::Result<Self> {
+        Self::new(Alloc::new(Global), Alloc::new(Global)).map_err(Into::into)
+    }
+
+    unsafe fn unfork(&mut self) {
+        let _ = self.delete_all();
+    }
+}

rust/src/benched/doublets_benched.rs

@@ -0,0 +1,44 @@
+//! # Benchmark Lifecycle Management
+//!
+//! This module defines the [`Benched`] trait that provides setup/teardown lifecycle
+//! for benchmark iterations. Both Neo4j and Doublets storage backends implement
+//! this trait to enable fair benchmarking.
+//!
+//! ## Module Structure
+//!
+//! The implementations are split into separate files for clear comparison:
+//!
+//! - **[`doublets_benched`]** - Doublets storage backend implementations
+//! - **[`neo4j_benched`]** - Neo4j storage backend implementations
+
+mod doublets_benched;
+mod neo4j_benched;
+
+use crate::Fork;
+
+/// Trait for types that can be benchmarked.
+///
+/// Provides the setup/teardown lifecycle for benchmark iterations:
+/// - [`Benched::setup`] - Initialize the storage backend
+/// - [`Benched::fork`] - Create an isolated environment for a single iteration
+/// - [`Benched::unfork`] - Clean up after the iteration
+pub trait Benched: Sized {
+    /// Builder parameter type for constructing this storage.
+    type Builder<'params>;
+
+    /// Set up a new storage backend for benchmarking.
+    fn setup<'a>(builder: Self::Builder<'a>) -> crate::Result<Self>;
+
+    /// Create a fork for a single benchmark iteration.
+    ///
+    /// This allows each iteration to run in isolation without affecting others.
+    fn fork(&mut self) -> Fork<Self> {
+        Fork(self)
+    }
+
+    /// Clean up after a benchmark iteration.
+    ///
+    /// # Safety
+    /// This method may perform unsafe operations like clearing all data.
+    unsafe fn unfork(&mut self);
+}

rust/src/benched/mod.rs

@@ -0,0 +1,87 @@
+//! # Neo4j Benched Implementations
+//!
+//! This module contains the [`Benched`] trait implementations for all Neo4j
+//! storage backends.
+//!
+//! ## Storage Backends
+//!
+//! | Type                        | Mode            | Description                      |
+//! |-----------------------------|-----------------|----------------------------------|
+//! | `Exclusive<Client>`         | Non-transaction | Direct HTTP API calls            |
+//! | `Exclusive<Transaction>`    | Transaction     | Transaction wrapper (same impl)  |
+//!
+//! ## Implementation Details
+//!
+//! Neo4j implementations clean up by executing:
+//! ```cypher
+//! MATCH (l:Link) DETACH DELETE l
+//! ```
+//!
+//! This removes all Link nodes from the database for the next benchmark iteration.
+
+use doublets::data::LinkType;
+
+use super::Benched;
+use crate::{Client, Exclusive, Fork, Sql, Transaction};
+
+/// Neo4j client (non-transactional mode).
+///
+/// ## Setup
+/// ```rust,ignore
+/// let client = Exclusive::<Client<usize>>::setup(())?;
+/// ```
+///
+/// ## Fork Behavior
+/// Creates the schema (constraints/indexes) before each iteration.
+///
+/// ## Cleanup
+/// Executes `MATCH (l:Link) DETACH DELETE l` to remove all nodes.
+impl<T: LinkType> Benched for Exclusive<Client<T>> {
+    type Builder<'a> = ();
+
+    fn setup(_: Self::Builder<'_>) -> crate::Result<Self> {
+        unsafe { Ok(Exclusive::new(crate::connect()?)) }
+    }
+
+    fn fork(&mut self) -> Fork<Self> {
+        let _ = self.create_table();
+        Fork(self)
+    }
+
+    unsafe fn unfork(&mut self) {
+        let _ = self.drop_table();
+    }
+}
+
+/// Neo4j transaction wrapper.
+///
+/// ## Setup
+/// ```rust,ignore
+/// let client = connect()?;
+/// let transaction = Exclusive::<Transaction<'_, usize>>::setup(&client)?;
+/// ```
+///
+/// ## Fork Behavior
+/// Cleans up any existing data before each iteration to ensure isolation.
+///
+/// ## Cleanup
+/// Executes `MATCH (l:Link) DETACH DELETE l` to remove all nodes.
+impl<'a, T: LinkType> Benched for Exclusive<Transaction<'a, T>> {
+    type Builder<'b> = &'a Client<T>;
+
+    fn setup(builder: Self::Builder<'_>) -> crate::Result<Self> {
+        let transaction = Transaction::new(builder)?;
+        unsafe { Ok(Exclusive::new(transaction)) }
+    }
+
+    fn fork(&mut self) -> Fork<Self> {
+        // Clean up any existing data before benchmark to ensure isolation
+        let _ = self.drop_table();
+        Fork(self)
+    }
+
+    unsafe fn unfork(&mut self) {
+        // Clean up after benchmark iteration
+        let _ = self.drop_table();
+    }
+}