@lix-js/sdk 0.6.0-preview.3 → 0.6.0-preview.5

package/dist-engine-src/src/tracked_state/bench_support.rs

@@ -0,0 +1,394 @@
+use crate::entity_pk::EntityPk;
+use crate::json_store::{JsonStoreContext, JsonWritePlacementRef, NormalizedJsonRef};
+use crate::storage::{
+    StorageBackend, StorageBackendRead, StorageBackendReadOf, StorageContext, StorageRead,
+    StorageReadOptions, StorageReadScope, StorageWriteOptions, StorageWriteSetStats,
+};
+use crate::tracked_state::{
+    TrackedStateContext, TrackedStateDeltaRef, TrackedStateFilter, TrackedStateKey,
+    TrackedStateReadColumns, TrackedStateScanRequest,
+};
+
+#[derive(Clone)]
+pub struct BenchTrackedRow {
+    pub schema_key: String,
+    pub file_id: Option<String>,
+    pub entity_pk: String,
+    pub value: Vec<u8>,
+    pub updated_value: Vec<u8>,
+}
+
+pub struct BenchTrackedFixture<B: StorageBackend> {
+    storage: StorageContext<B>,
+    context: TrackedStateContext,
+    rows: Vec<BenchTrackedRow>,
+    current_commit_id: Option<String>,
+    next_commit_index: usize,
+}
+
+#[derive(Clone, Debug)]
+pub struct BenchWriteAccounting {
+    pub logical_rows: usize,
+    pub staged_puts: u64,
+    pub staged_deletes: u64,
+    pub touched_spaces: u64,
+    pub backend_calls: u64,
+    pub put_batches: u64,
+    pub delete_batches: u64,
+    pub written_bytes: u64,
+}
+
+#[derive(Clone, Debug)]
+pub struct BenchLayoutAccounting {
+    pub space_id: u32,
+    pub space: &'static str,
+    pub rows: u64,
+    pub key_bytes: u64,
+    pub value_bytes: u64,
+}
+
+struct BenchWriteOutcome {
+    logical_rows: usize,
+    stats: StorageWriteSetStats,
+}
+
+impl BenchWriteOutcome {
+    fn accounting(&self) -> BenchWriteAccounting {
+        BenchWriteAccounting {
+            logical_rows: self.logical_rows,
+            staged_puts: self.stats.staged_puts,
+            staged_deletes: self.stats.staged_deletes,
+            touched_spaces: self.stats.touched_spaces,
+            backend_calls: self.stats.backend_calls,
+            put_batches: self.stats.put_batches,
+            delete_batches: self.stats.delete_batches,
+            written_bytes: self.stats.written_bytes,
+        }
+    }
+}
+
+struct BenchRead<R> {
+    inner: StorageReadScope<R>,
+}
+
+impl<R> BenchRead<R> {
+    fn new(inner: StorageReadScope<R>) -> Self {
+        Self { inner }
+    }
+}
+
+// The storage bench runs these fixtures on one thread. This wrapper lets the
+// tracked-state internals use their existing `Send + Sync` reader bound with
+// test backends such as SQLite whose read handle is not `Sync`.
+unsafe impl<R: Send> Send for BenchRead<R> {}
+unsafe impl<R: Send> Sync for BenchRead<R> {}
+
+impl<R> StorageRead for BenchRead<R>
+where
+    R: StorageBackendRead,
+{
+    type BackendRead = R;
+
+    fn backend_read(&self) -> &Self::BackendRead {
+        self.inner.backend_read()
+    }
+}
+
+impl<B> BenchTrackedFixture<B>
+where
+    B: StorageBackend,
+    for<'a> StorageBackendReadOf<'a, B>: Send,
+{
+    pub fn new(storage: StorageContext<B>, rows: Vec<BenchTrackedRow>) -> Self {
+        Self {
+            storage,
+            context: TrackedStateContext::new(),
+            rows,
+            current_commit_id: None,
+            next_commit_index: 0,
+        }
+    }
+
+    pub async fn seed(&mut self) -> usize {
+        self.insert_all().await
+    }
+
+    pub async fn insert_all(&mut self) -> usize {
+        self.insert_all_accounting().await.logical_rows
+    }
+
+    pub async fn insert_all_accounting(&mut self) -> BenchWriteAccounting {
+        let rows = self.rows.clone();
+        self.stage_rows(rows, None).await.accounting()
+    }
+
+    pub async fn update_all(&mut self) -> usize {
+        self.update_all_accounting().await.logical_rows
+    }
+
+    pub async fn update_all_accounting(&mut self) -> BenchWriteAccounting {
+        let rows = self
+            .rows
+            .iter()
+            .cloned()
+            .map(|mut row| {
+                row.value = row.updated_value.clone();
+                row
+            })
+            .collect::<Vec<_>>();
+        self.stage_rows(rows, self.current_commit_id.clone())
+            .await
+            .accounting()
+    }
+
+    pub async fn update_one_by_pk(&mut self) -> usize {
+        self.update_one_by_pk_accounting().await.logical_rows
+    }
+
+    pub async fn update_one_by_pk_accounting(&mut self) -> BenchWriteAccounting {
+        let mut row = self.rows[self.rows.len() / 2].clone();
+        row.value = row.updated_value.clone();
+        self.stage_rows(vec![row], self.current_commit_id.clone())
+            .await
+            .accounting()
+    }
+
+    pub async fn delete_all(&mut self) -> usize {
+        self.delete_all_accounting().await.logical_rows
+    }
+
+    pub async fn delete_all_accounting(&mut self) -> BenchWriteAccounting {
+        let rows = self
+            .rows
+            .iter()
+            .cloned()
+            .map(|mut row| {
+                row.value.clear();
+                row
+            })
+            .collect::<Vec<_>>();
+        self.stage_rows_as_deletes(rows, self.current_commit_id.clone())
+            .await
+            .accounting()
+    }
+
+    pub async fn delete_one_by_pk(&mut self) -> usize {
+        self.delete_one_by_pk_accounting().await.logical_rows
+    }
+
+    pub async fn delete_one_by_pk_accounting(&mut self) -> BenchWriteAccounting {
+        let mut row = self.rows[self.rows.len() / 2].clone();
+        row.value.clear();
+        self.stage_rows_as_deletes(vec![row], self.current_commit_id.clone())
+            .await
+            .accounting()
+    }
+
+    pub async fn read_all(&self) -> usize {
+        let read = BenchRead::new(
+            self.storage
+                .begin_read(StorageReadOptions::default())
+                .expect("begin tracked-state read"),
+        );
+        let mut reader = self.context.reader(read);
+        let rows = reader
+            .scan_rows_at_commit(
+                self.current_commit_id(),
+                &TrackedStateScanRequest {
+                    filter: TrackedStateFilter::default(),
+                    read_columns: TrackedStateReadColumns::default(),
+                    limit: None,
+                },
+            )
+            .await
+            .expect("scan tracked-state rows");
+        assert_eq!(rows.len(), self.rows.len());
+        rows.len()
+    }
+
+    pub async fn read_all_by_pk(&self) -> usize {
+        let keys = self.rows.iter().map(row_key).collect::<Vec<_>>();
+        self.read_by_pk(&keys).await
+    }
+
+    pub async fn read_one_by_pk(&self) -> usize {
+        let key = row_key(&self.rows[self.rows.len() / 2]);
+        self.read_by_pk(&[key]).await
+    }
+
+    async fn read_by_pk(&self, keys: &[TrackedStateKey]) -> usize {
+        let read = BenchRead::new(
+            self.storage
+                .begin_read(StorageReadOptions::default())
+                .expect("begin tracked-state read"),
+        );
+        let mut reader = self.context.reader(read);
+        let rows = reader
+            .load_rows_at_commit(self.current_commit_id(), keys)
+            .await
+            .expect("load tracked-state rows");
+        assert!(rows.iter().all(Option::is_some));
+        rows.len()
+    }
+
+    async fn stage_rows(
+        &mut self,
+        rows: Vec<BenchTrackedRow>,
+        parent_commit_id: Option<String>,
+    ) -> BenchWriteOutcome {
+        self.stage_rows_inner(rows, parent_commit_id, false).await
+    }
+
+    async fn stage_rows_as_deletes(
+        &mut self,
+        rows: Vec<BenchTrackedRow>,
+        parent_commit_id: Option<String>,
+    ) -> BenchWriteOutcome {
+        self.stage_rows_inner(rows, parent_commit_id, true).await
+    }
+
+    async fn stage_rows_inner(
+        &mut self,
+        rows: Vec<BenchTrackedRow>,
+        parent_commit_id: Option<String>,
+        deleted: bool,
+    ) -> BenchWriteOutcome {
+        let commit_id = self.next_commit_id();
+        let mut writes = self.storage.new_write_set();
+        let owned = rows
+            .into_iter()
+            .enumerate()
+            .map(|(index, row)| OwnedDelta::new(row, &commit_id, index, deleted, &mut writes))
+            .collect::<Vec<_>>();
+        let deltas = owned.iter().map(OwnedDelta::as_ref).collect::<Vec<_>>();
+        {
+            let read = BenchRead::new(
+                self.storage
+                    .begin_read(StorageReadOptions::default())
+                    .expect("begin tracked-state write read"),
+            );
+            let mut writer = self.context.writer(&read, &mut writes);
+            writer
+                .stage_commit_root(&commit_id, parent_commit_id.as_deref(), deltas)
+                .await
+                .expect("stage tracked-state commit root");
+        }
+        let (_commit, stats) = self
+            .storage
+            .commit_write_set(writes, StorageWriteOptions::default())
+            .expect("commit tracked-state writes");
+        assert!(
+            stats.staged_puts > 0,
+            "tracked-state write should stage physical puts"
+        );
+        self.current_commit_id = Some(commit_id);
+        BenchWriteOutcome {
+            logical_rows: owned.len(),
+            stats,
+        }
+    }
+
+    pub fn layout_accounting(&self) -> Vec<BenchLayoutAccounting> {
+        let read = BenchRead::new(
+            self.storage
+                .begin_read(StorageReadOptions::default())
+                .expect("begin tracked-state layout accounting read"),
+        );
+        crate::storage_bench::layout_accounting(&read)
+            .into_iter()
+            .map(|space| BenchLayoutAccounting {
+                space_id: space.space_id,
+                space: space.space,
+                rows: space.rows,
+                key_bytes: space.key_bytes,
+                value_bytes: space.value_bytes,
+            })
+            .collect()
+    }
+
+    fn next_commit_id(&mut self) -> String {
+        self.next_commit_index += 1;
+        format!("tracked-crud-commit-{}", self.next_commit_index)
+    }
+
+    fn current_commit_id(&self) -> &str {
+        self.current_commit_id
+            .as_deref()
+            .expect("tracked-state fixture should be seeded")
+    }
+}
+
+struct OwnedDelta {
+    change_id: String,
+    commit_id: String,
+    entity_pk: EntityPk,
+    schema_key: String,
+    file_id: Option<String>,
+    snapshot_ref: Option<crate::json_store::JsonRef>,
+    metadata_ref: Option<crate::json_store::JsonRef>,
+    deleted: bool,
+    created_at: String,
+    updated_at: String,
+}
+
+impl OwnedDelta {
+    fn new(
+        row: BenchTrackedRow,
+        commit_id: &str,
+        index: usize,
+        deleted: bool,
+        writes: &mut crate::storage::StorageWriteSet,
+    ) -> Self {
+        let snapshot_ref = if deleted {
+            None
+        } else {
+            let json = std::str::from_utf8(&row.value)
+                .expect("tracked-state bench row payload should be UTF-8 JSON");
+            let mut json_writer = JsonStoreContext::new().writer();
+            let refs = json_writer
+                .stage_batch(
+                    writes,
+                    JsonWritePlacementRef::OutOfBand,
+                    [NormalizedJsonRef::new(json)],
+                )
+                .expect("stage tracked-state bench JSON payload");
+            Some(refs[0])
+        };
+        let change_id = format!("tracked-crud-change-{commit_id}-{index}");
+        Self {
+            change_id,
+            commit_id: commit_id.to_string(),
+            entity_pk: EntityPk::single(row.entity_pk),
+            schema_key: row.schema_key,
+            file_id: row.file_id,
+            snapshot_ref,
+            metadata_ref: None,
+            deleted,
+            created_at: "2026-05-19T00:00:00.000Z".to_string(),
+            updated_at: "2026-05-19T00:00:00.000Z".to_string(),
+        }
+    }
+
+    fn as_ref(&self) -> TrackedStateDeltaRef<'_> {
+        TrackedStateDeltaRef {
+            schema_key: &self.schema_key,
+            file_id: self.file_id.as_deref(),
+            entity_pk: &self.entity_pk,
+            change_id: &self.change_id,
+            commit_id: &self.commit_id,
+            snapshot_ref: self.snapshot_ref.as_ref(),
+            metadata_ref: self.metadata_ref.as_ref(),
+            deleted: self.deleted,
+            created_at: &self.created_at,
+            updated_at: &self.updated_at,
+        }
+    }
+}
+
+fn row_key(row: &BenchTrackedRow) -> TrackedStateKey {
+    TrackedStateKey {
+        schema_key: row.schema_key.clone(),
+        entity_pk: EntityPk::single(row.entity_pk.clone()),
+        file_id: row.file_id.clone(),
+    }
+}