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

package/dist-engine-src/src/session/optimization9_sql2_bench.rs

@@ -0,0 +1,100 @@
+use crate::functions::FunctionContext;
+use crate::session::context::{SessionContext, SessionSqlExecutionContext};
+use crate::sql2::{self, SqlLogicalPlan};
+use crate::storage::StorageReadScope;
+use crate::transaction::open_transaction;
+use crate::{LixError, SqlQueryResult, Value};
+
+/// Opaque read plan used by the Optimization 9 SQL2 diagnostic benchmark.
+///
+/// This module is gated behind `storage-benches` and exists only to split SQL2
+/// planning cost from SQL2 execution cost without widening the normal session
+/// API.
+pub struct PreparedReadPlan {
+    plan: SqlLogicalPlan,
+    read_scope:
+        StorageReadScope<Box<dyn crate::storage::StorageReadTransaction + Send + Sync + 'static>>,
+    runtime_functions: FunctionContext,
+}
+
+pub async fn plan_read_only(session: &SessionContext, sql: &str) -> Result<(), LixError> {
+    let prepared = prepare_read_plan(session, sql).await?;
+    drop(prepared.plan);
+    drop(prepared.runtime_functions);
+    prepared.read_scope.rollback().await
+}
+
+pub async fn plan_write_only(session: &SessionContext, sql: &str) -> Result<(), LixError> {
+    session.ensure_open()?;
+    let opened = open_transaction(
+        &session.mode,
+        session.storage.clone(),
+        std::sync::Arc::clone(&session.live_state),
+        std::sync::Arc::clone(&session.tracked_state),
+        std::sync::Arc::clone(&session.binary_cas),
+        std::sync::Arc::clone(&session.commit_store),
+        std::sync::Arc::clone(&session.version_ctx),
+        std::sync::Arc::clone(&session.catalog_context),
+    )
+    .await?;
+    let mut transaction = opened.transaction;
+    let runtime_functions = opened.runtime_functions;
+    let plan = sql2::create_write_logical_plan(&mut transaction, sql).await?;
+    drop(plan);
+    drop(runtime_functions);
+    transaction.rollback().await
+}
+
+pub async fn prepare_read_plan(
+    session: &SessionContext,
+    sql: &str,
+) -> Result<PreparedReadPlan, LixError> {
+    session.ensure_open()?;
+    let read_scope = StorageReadScope::new(session.storage.begin_read_transaction().await?);
+    let mut read_store = read_scope.store();
+    let live_state: std::sync::Arc<dyn crate::live_state::LiveStateReader> =
+        std::sync::Arc::new(session.live_state.reader(read_store.clone()));
+    let runtime_functions = FunctionContext::prepare(live_state.as_ref()).await?;
+    let functions = runtime_functions.provider();
+    let active_version_id = session
+        .active_version_id_from_reader(&mut read_store)
+        .await?;
+    let visible_schemas = session
+        .catalog_context
+        .schema_jsons_for_sql_read_planning(live_state.as_ref(), &active_version_id)
+        .await?;
+    let ctx = SessionSqlExecutionContext {
+        active_version_id: &active_version_id,
+        read_store,
+        live_state: std::sync::Arc::clone(&session.live_state),
+        binary_cas: std::sync::Arc::clone(&session.binary_cas),
+        commit_store: std::sync::Arc::clone(&session.commit_store),
+        version_ctx: std::sync::Arc::clone(&session.version_ctx),
+        visible_schemas,
+        functions: functions.clone(),
+    };
+    let plan = sql2::create_logical_plan(&ctx, sql).await?;
+    drop(ctx);
+    drop(live_state);
+
+    Ok(PreparedReadPlan {
+        plan,
+        read_scope,
+        runtime_functions,
+    })
+}
+
+pub async fn execute_read_plan(
+    prepared: PreparedReadPlan,
+    params: &[Value],
+) -> Result<SqlQueryResult, LixError> {
+    let PreparedReadPlan {
+        plan,
+        read_scope,
+        runtime_functions,
+    } = prepared;
+    let result = sql2::execute_logical_plan(plan, params).await;
+    read_scope.rollback().await?;
+    drop(runtime_functions);
+    result
+}

package/dist-engine-src/src/session/switch_version.rs

@@ -2,15 +2,14 @@ use std::sync::Arc;
 
 use serde_json::json;
 
-use crate::transaction::types::StageRow;
-use crate::version::VersionRefReader;
+use crate::transaction::types::{TransactionJson, TransactionWriteRow};
+use crate::version::{VersionLifecycle, VersionOperation, VersionReferenceRole};
 use crate::LixError;
 use crate::GLOBAL_VERSION_ID;
 
 use super::context::{SessionContext, SessionMode, WORKSPACE_VERSION_KEY};
 
 const KEY_VALUE_SCHEMA_KEY: &str = "lix_key_value";
-const KEY_VALUE_SCHEMA_VERSION: &str = "1";
 
 /// Options for switching a session to another version.
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -40,17 +39,16 @@ impl SessionContext {
         let next_mode = self
             .with_write_transaction(|transaction| {
                 Box::pin(async move {
-                    let head = {
+                    {
                         let reader = transaction.version_ref_reader();
-                        reader.load_head_commit_id(&version_id).await?
+                        VersionLifecycle::new(&reader)
+                            .require_existing_commit_id(
+                                &version_id,
+                                VersionOperation::SwitchVersion,
+                                VersionReferenceRole::Target,
+                            )
+                            .await?
                     };
-                    if head.is_none() {
-                        return Err(LixError::version_not_found(
-                            version_id.clone(),
-                            "switch_version",
-                            "target",
-                        ));
-                    }
 
                     match current_mode {
                         SessionMode::Pinned { .. } => Ok(SessionMode::Pinned {
@@ -73,9 +71,9 @@ impl SessionContext {
             Arc::clone(&self.live_state),
             Arc::clone(&self.tracked_state),
             Arc::clone(&self.binary_cas),
-            Arc::clone(&self.changelog),
+            Arc::clone(&self.commit_store),
             Arc::clone(&self.version_ctx),
-            Arc::clone(&self.schema_registry),
+            Arc::clone(&self.catalog_context),
             self.closed_flag(),
         );
         Ok((
@@ -87,20 +85,19 @@ impl SessionContext {
     }
 }
 
-fn workspace_version_stage_row(version_id: &str) -> Result<StageRow, LixError> {
-    Ok(StageRow {
+fn workspace_version_stage_row(version_id: &str) -> Result<TransactionWriteRow, LixError> {
+    Ok(TransactionWriteRow {
         entity_id: Some(crate::entity_identity::EntityIdentity::single(
             WORKSPACE_VERSION_KEY,
         )),
         schema_key: KEY_VALUE_SCHEMA_KEY.to_string(),
         file_id: None,
-        snapshot_content: Some(encode_snapshot(json!({
+        snapshot: Some(TransactionJson::from_value_unchecked(json!({
             "key": WORKSPACE_VERSION_KEY,
             "value": version_id,
-        }))?),
+        }))),
         metadata: None,
         origin: None,
-        schema_version: KEY_VALUE_SCHEMA_VERSION.to_string(),
         created_at: None,
         updated_at: None,
         global: true,
@@ -110,12 +107,3 @@ fn workspace_version_stage_row(version_id: &str) -> Result<StageRow, LixError> {
         version_id: GLOBAL_VERSION_ID.to_string(),
     })
 }
-
-fn encode_snapshot(value: serde_json::Value) -> Result<String, LixError> {
-    serde_json::to_string(&value).map_err(|error| {
-        LixError::new(
-            "LIX_ERROR_UNKNOWN",
-            format!("engine2 switch_version snapshot serialization failed: {error}"),
-        )
-    })
-}

package/dist-engine-src/src/sql2/change_provider.rs

@@ -18,17 +18,18 @@ use datafusion::physical_plan::{
 };
 use futures_util::stream;
 
-use crate::changelog::{materialize_change, ChangelogScanRequest, MaterializedCanonicalChange};
+use crate::commit_store::ChangeScanRequest;
 use crate::serialize_row_metadata;
 use crate::LixError;
 
 use super::record_batch::record_batch_with_row_count;
 use super::result_metadata::json_field;
-use super::SqlChangelogQuerySource;
+use super::SqlCommitStoreQuerySource;
+use crate::commit_store::{materialize_change, MaterializedChange};
 
 pub(crate) async fn register_lix_change_provider(
     session: &datafusion::prelude::SessionContext,
-    query_source: SqlChangelogQuerySource,
+    query_source: SqlCommitStoreQuerySource,
 ) -> Result<(), LixError> {
     session
         .register_table("lix_change", Arc::new(LixChangeProvider::new(query_source)))
@@ -38,7 +39,7 @@ pub(crate) async fn register_lix_change_provider(
 
 struct LixChangeProvider {
     schema: SchemaRef,
-    query_source: SqlChangelogQuerySource,
+    query_source: SqlCommitStoreQuerySource,
 }
 
 impl std::fmt::Debug for LixChangeProvider {
@@ -48,7 +49,7 @@ impl std::fmt::Debug for LixChangeProvider {
 }
 
 impl LixChangeProvider {
-    fn new(query_source: SqlChangelogQuerySource) -> Self {
+    fn new(query_source: SqlCommitStoreQuerySource) -> Self {
         Self {
             schema: lix_change_schema(),
             query_source,
@@ -97,7 +98,7 @@ impl TableProvider for LixChangeProvider {
 }
 
 struct LixChangeScanExec {
-    query_source: SqlChangelogQuerySource,
+    query_source: SqlCommitStoreQuerySource,
     schema: SchemaRef,
     projection: Option<Vec<usize>>,
     limit: Option<usize>,
@@ -112,7 +113,7 @@ impl std::fmt::Debug for LixChangeScanExec {
 
 impl LixChangeScanExec {
     fn new(
-        query_source: SqlChangelogQuerySource,
+        query_source: SqlCommitStoreQuerySource,
         schema: SchemaRef,
         projection: Option<Vec<usize>>,
         limit: Option<usize>,
@@ -191,8 +192,8 @@ impl ExecutionPlan for LixChangeScanExec {
         let stream = stream::once(async move {
             let mut json_reader = query_source.json_reader;
             let canonical_changes = query_source
-                .changelog_reader
-                .scan_changes(&ChangelogScanRequest { limit })
+                .commit_store_reader
+                .scan_changes(&ChangeScanRequest { limit })
                 .await
                 .map_err(lix_error_to_datafusion_error)?;
             let mut changes = Vec::with_capacity(canonical_changes.len());
@@ -214,7 +215,6 @@ enum ChangeColumn {
     Id,
     EntityId,
     SchemaKey,
-    SchemaVersion,
     FileId,
     Metadata,
     CreatedAt,
@@ -224,9 +224,8 @@ enum ChangeColumn {
 fn lix_change_schema() -> SchemaRef {
     Arc::new(Schema::new(vec![
         Field::new("id", DataType::Utf8, false),
-        Field::new("entity_id", DataType::Utf8, false),
+        json_field("entity_id", false),
         Field::new("schema_key", DataType::Utf8, false),
-        Field::new("schema_version", DataType::Utf8, false),
         Field::new("file_id", DataType::Utf8, true),
         json_field("metadata", true),
         Field::new("created_at", DataType::Utf8, false),
@@ -239,7 +238,6 @@ fn change_projection_for_scan(projection: Option<&Vec<usize>>) -> Vec<ChangeColu
         ChangeColumn::Id,
         ChangeColumn::EntityId,
         ChangeColumn::SchemaKey,
-        ChangeColumn::SchemaVersion,
         ChangeColumn::FileId,
         ChangeColumn::Metadata,
         ChangeColumn::CreatedAt,
@@ -262,7 +260,7 @@ fn projected_schema(schema: &SchemaRef, projection: Option<&Vec<usize>>) -> Sche
 
 fn change_record_batch(
     projection: &[ChangeColumn],
-    changes: &[MaterializedCanonicalChange],
+    changes: &[MaterializedChange],
 ) -> Result<RecordBatch> {
     let arrays = projection
         .iter()
@@ -274,7 +272,7 @@ fn change_record_batch(
                     .map(|row| {
                         Some(
                             row.entity_id
-                                .as_string()
+                                .as_json_array_text()
                                 .expect("canonical change entity identity should project"),
                         )
                     })
@@ -283,9 +281,6 @@ fn change_record_batch(
             ChangeColumn::SchemaKey => {
                 string_array(changes.iter().map(|row| Some(row.schema_key.as_str())))
             }
-            ChangeColumn::SchemaVersion => {
-                string_array(changes.iter().map(|row| Some(row.schema_version.as_str())))
-            }
             ChangeColumn::FileId => string_array(changes.iter().map(|row| row.file_id.as_deref())),
             ChangeColumn::Metadata => Arc::new(StringArray::from(
                 changes
@@ -312,9 +307,8 @@ fn change_schema(projection: &[ChangeColumn]) -> SchemaRef {
             .iter()
             .map(|column| match column {
                 ChangeColumn::Id => Field::new("id", DataType::Utf8, false),
-                ChangeColumn::EntityId => Field::new("entity_id", DataType::Utf8, false),
+                ChangeColumn::EntityId => json_field("entity_id", false),
                 ChangeColumn::SchemaKey => Field::new("schema_key", DataType::Utf8, false),
-                ChangeColumn::SchemaVersion => Field::new("schema_version", DataType::Utf8, false),
                 ChangeColumn::FileId => Field::new("file_id", DataType::Utf8, true),
                 ChangeColumn::Metadata => json_field("metadata", true),
                 ChangeColumn::CreatedAt => Field::new("created_at", DataType::Utf8, false),

package/dist-engine-src/src/sql2/classify.rs

@@ -1,5 +1,7 @@
+use datafusion::sql::parser::Statement as DataFusionStatement;
 use datafusion::sql::sqlparser::ast::{
-    FromTable, ObjectName, Query, SetExpr, Statement, TableFactor, TableObject, TableWithJoins,
+    FromTable, ObjectName, Query, SetExpr, Statement as SqlStatement, TableFactor, TableObject,
+    TableWithJoins,
 };
 use datafusion::sql::sqlparser::dialect::GenericDialect;
 use datafusion::sql::sqlparser::parser::Parser;
@@ -31,17 +33,29 @@ pub(crate) fn validate_supported_statement_ast(sql: &str) -> Result<(), LixError
     validate_supported_ast_statement(statement)
 }
 
-pub(crate) fn dml_target_table_names(sql: &str) -> Result<Vec<String>, LixError> {
-    let statements = parse_sql_statements(sql)?;
-    let [statement] = statements.as_slice() else {
-        return Ok(Vec::new());
-    };
+pub(crate) fn validate_supported_datafusion_statement_ast(
+    statement: &DataFusionStatement,
+) -> Result<(), LixError> {
+    match statement {
+        DataFusionStatement::Statement(statement) => validate_supported_ast_statement(statement),
+        DataFusionStatement::Explain(explain) => {
+            validate_supported_datafusion_statement_ast(explain.statement.as_ref())
+        }
+        _ => Err(unsupported_sql_error(format!(
+            "SQL statement is not supported by Lix SQL: {statement}"
+        ))),
+    }
+}
+
+pub(crate) fn datafusion_statement_dml_target_table_names(
+    statement: &DataFusionStatement,
+) -> Vec<String> {
     let mut targets = Vec::new();
-    collect_dml_target_table_names(statement, &mut targets);
-    Ok(targets)
+    collect_datafusion_statement_dml_target_table_names(statement, &mut targets);
+    targets
 }
 
-fn parse_sql_statements(sql: &str) -> Result<Vec<Statement>, LixError> {
+fn parse_sql_statements(sql: &str) -> Result<Vec<SqlStatement>, LixError> {
     Parser::parse_sql(&GenericDialect {}, sql).map_err(|error| {
         LixError::new(
             LixError::CODE_PARSE_ERROR,
@@ -50,19 +64,37 @@ fn parse_sql_statements(sql: &str) -> Result<Vec<Statement>, LixError> {
     })
 }
 
-fn collect_dml_target_table_names(statement: &Statement, targets: &mut Vec<String>) {
+fn collect_datafusion_statement_dml_target_table_names(
+    statement: &DataFusionStatement,
+    targets: &mut Vec<String>,
+) {
+    match statement {
+        DataFusionStatement::Statement(statement) => {
+            collect_dml_target_table_names(statement, targets);
+        }
+        DataFusionStatement::Explain(explain) => {
+            collect_datafusion_statement_dml_target_table_names(
+                explain.statement.as_ref(),
+                targets,
+            );
+        }
+        _ => {}
+    }
+}
+
+fn collect_dml_target_table_names(statement: &SqlStatement, targets: &mut Vec<String>) {
     match statement {
-        Statement::Insert(insert) => {
+        SqlStatement::Insert(insert) => {
             if let TableObject::TableName(name) = &insert.table {
                 if let Some(table_name) = object_name_table_part(name) {
                     targets.push(table_name);
                 }
             }
         }
-        Statement::Update(update) => {
+        SqlStatement::Update(update) => {
             collect_table_with_joins_target(&update.table, targets);
         }
-        Statement::Delete(delete) => {
+        SqlStatement::Delete(delete) => {
             let tables = match &delete.from {
                 FromTable::WithFromKeyword(tables) | FromTable::WithoutKeyword(tables) => tables,
             };
@@ -70,7 +102,7 @@ fn collect_dml_target_table_names(statement: &Statement, targets: &mut Vec<Strin
                 collect_table_with_joins_target(table, targets);
             }
         }
-        Statement::Explain { statement, .. } => {
+        SqlStatement::Explain { statement, .. } => {
             collect_dml_target_table_names(statement.as_ref(), targets);
         }
         _ => {}
@@ -86,28 +118,31 @@ fn collect_table_with_joins_target(table: &TableWithJoins, targets: &mut Vec<Str
 }
 
 fn object_name_table_part(name: &ObjectName) -> Option<String> {
-    name.0
-        .last()
-        .and_then(|part| part.as_ident())
-        .map(|ident| ident.value.clone())
+    name.0.last().and_then(|part| part.as_ident()).map(|ident| {
+        if ident.quote_style.is_some() {
+            ident.value.clone()
+        } else {
+            ident.value.to_ascii_lowercase()
+        }
+    })
 }
 
-fn classify_ast_statement(statement: &Statement) -> SqlStatementKind {
+fn classify_ast_statement(statement: &SqlStatement) -> SqlStatementKind {
     match statement {
-        Statement::Insert(_) | Statement::Update(_) | Statement::Delete(_) => {
+        SqlStatement::Insert(_) | SqlStatement::Update(_) | SqlStatement::Delete(_) => {
             SqlStatementKind::Write
         }
-        Statement::Query(_) => SqlStatementKind::Read,
-        Statement::Explain { statement, .. } => classify_ast_statement(statement.as_ref()),
+        SqlStatement::Query(_) => SqlStatementKind::Read,
+        SqlStatement::Explain { statement, .. } => classify_ast_statement(statement.as_ref()),
         _ => SqlStatementKind::Other,
     }
 }
 
-fn validate_supported_ast_statement(statement: &Statement) -> Result<(), LixError> {
+fn validate_supported_ast_statement(statement: &SqlStatement) -> Result<(), LixError> {
     match statement {
-        Statement::Query(query) => validate_supported_query(query),
-        Statement::Insert(_) | Statement::Update(_) | Statement::Delete(_) => Ok(()),
-        Statement::Explain { statement, .. } => validate_supported_ast_statement(statement),
+        SqlStatement::Query(query) => validate_supported_query(query),
+        SqlStatement::Insert(_) | SqlStatement::Update(_) | SqlStatement::Delete(_) => Ok(()),
+        SqlStatement::Explain { statement, .. } => validate_supported_ast_statement(statement),
         _ => Err(unsupported_sql_error(format!(
             "SQL statement is not supported by Lix SQL: {statement}"
         ))),

package/dist-engine-src/src/sql2/context.rs

@@ -6,26 +6,27 @@ use serde_json::Value as JsonValue;
 use tokio::sync::Mutex;
 
 use crate::binary_cas::{BlobBytesBatch, BlobDataReader, BlobHash};
-use crate::changelog::ChangelogReader;
 use crate::commit_graph::CommitGraphReader;
+use crate::commit_store::CommitStoreReader;
 use crate::functions::FunctionProviderHandle;
 use crate::json_store::JsonStoreReader;
 use crate::live_state::{
-    LiveStateFilter, LiveStateReader, LiveStateRow, LiveStateRowRequest, LiveStateScanRequest,
+    LiveStateFilter, LiveStateReader, LiveStateRowRequest, LiveStateScanRequest,
+    MaterializedLiveStateRow,
 };
 use crate::storage::{ScopedStorageReader, StorageReadTransaction};
-use crate::transaction::types::{StageWrite, StageWriteOutcome};
+use crate::transaction::types::{TransactionWrite, TransactionWriteOutcome};
 use crate::version::{VersionHead, VersionRefReader};
 use crate::LixError;
 
 pub(crate) type SqlReadStore =
     ScopedStorageReader<Box<dyn StorageReadTransaction + Send + Sync + 'static>>;
-pub(crate) type SqlChangelogQuerySource = ChangelogQuerySource<SqlReadStore>;
+pub(crate) type SqlCommitStoreQuerySource = CommitStoreQuerySource<SqlReadStore>;
 pub(crate) type SqlJsonReader = JsonStoreReader<ScopedStorageReader<SqlReadStore>>;
 
 #[derive(Clone)]
-pub(crate) struct ChangelogQuerySource<S> {
-    pub(crate) changelog_reader: Arc<dyn ChangelogReader>,
+pub(crate) struct CommitStoreQuerySource<S> {
+    pub(crate) commit_store_reader: Arc<CommitStoreReader<ScopedStorageReader<S>>>,
     pub(crate) json_reader: JsonStoreReader<ScopedStorageReader<S>>,
 }
 
@@ -43,7 +44,7 @@ pub(crate) trait SqlExecutionContext {
     fn active_version_id(&self) -> &str;
     fn live_state(&self) -> Arc<dyn LiveStateReader>;
     fn functions(&self) -> FunctionProviderHandle;
-    fn changelog_query_source(&self) -> SqlChangelogQuerySource;
+    fn commit_store_query_source(&self) -> SqlCommitStoreQuerySource;
     fn commit_graph(&self) -> Box<dyn CommitGraphReader>;
     fn version_ref(&self) -> Arc<dyn VersionRefReader>;
     fn blob_reader(&self) -> Arc<dyn BlobDataReader>;
@@ -52,9 +53,9 @@ pub(crate) trait SqlExecutionContext {
 
 /// Write-capable SQL runtime boundary.
 ///
-/// Providers that mutate engine2 state should target this shape instead of
+/// Providers that mutate engine state should target this shape instead of
 /// reaching through session/backend escape hatches. The request and write
-/// payloads stay in the existing engine2 forms so this boundary centralizes
+/// payloads stay in the existing engine forms so this boundary centralizes
 /// authority without adding another translation layer.
 #[async_trait]
 #[allow(dead_code)]
@@ -68,11 +69,14 @@ pub(crate) trait SqlWriteExecutionContext {
     async fn scan_live_state(
         &mut self,
         request: &LiveStateScanRequest,
-    ) -> Result<Vec<LiveStateRow>, LixError>;
+    ) -> Result<Vec<MaterializedLiveStateRow>, LixError>;
 
     async fn load_version_head(&mut self, version_id: &str) -> Result<Option<String>, LixError>;
 
-    async fn stage_write(&mut self, write: StageWrite) -> Result<StageWriteOutcome, LixError>;
+    async fn stage_write(
+        &mut self,
+        write: TransactionWrite,
+    ) -> Result<TransactionWriteOutcome, LixError>;
 }
 
 #[derive(Clone)]
@@ -123,7 +127,7 @@ impl SqlWriteContext {
     pub(crate) async fn scan_live_state(
         &self,
         request: &LiveStateScanRequest,
-    ) -> Result<Vec<LiveStateRow>, LixError> {
+    ) -> Result<Vec<MaterializedLiveStateRow>, LixError> {
         let _guard = self.gate.lock().await;
         unsafe {
             self.ptr
@@ -170,8 +174,8 @@ impl SqlWriteContext {
 
     pub(crate) async fn stage_write(
         &self,
-        write: StageWrite,
-    ) -> Result<StageWriteOutcome, LixError> {
+        write: TransactionWrite,
+    ) -> Result<TransactionWriteOutcome, LixError> {
         let _guard = self.gate.lock().await;
         unsafe {
             self.ptr
@@ -219,12 +223,12 @@ impl WriteAccess {
 
     pub(crate) fn require_write(
         &self,
-        operation: &str,
+        action: &str,
     ) -> Result<SqlWriteContext, datafusion::error::DataFusionError> {
         match self {
             Self::Write { ctx } => Ok(ctx.clone()),
             Self::ReadOnly => Err(datafusion::error::DataFusionError::Execution(format!(
-                "{operation} requires a write transaction"
+                "{action} requires a write transaction"
             ))),
         }
     }
@@ -249,14 +253,14 @@ impl LiveStateReader for WriteContextLiveStateReader {
     async fn scan_rows(
         &self,
         request: &LiveStateScanRequest,
-    ) -> Result<Vec<LiveStateRow>, LixError> {
+    ) -> Result<Vec<MaterializedLiveStateRow>, LixError> {
         self.ctx.scan_live_state(request).await
     }
 
     async fn load_row(
         &self,
         request: &LiveStateRowRequest,
-    ) -> Result<Option<LiveStateRow>, LixError> {
+    ) -> Result<Option<MaterializedLiveStateRow>, LixError> {
         let mut rows = self
             .ctx
             .scan_live_state(&LiveStateScanRequest {