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

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

@@ -21,7 +21,9 @@ use datafusion::physical_plan::{
 use futures_util::{stream, TryStreamExt};
 use serde_json::Value as JsonValue;
 
-use crate::live_state::{LiveStateFilter, LiveStateReader, LiveStateRow, LiveStateScanRequest};
+use crate::live_state::{
+    LiveStateFilter, LiveStateReader, LiveStateScanRequest, MaterializedLiveStateRow,
+};
 use crate::sql2::dml::{InsertExec, InsertSink};
 use crate::sql2::record_batch::record_batch_with_row_count;
 use crate::sql2::write_normalization::{InsertCell, SqlCell, UpdateAssignmentValues};
@@ -29,7 +31,8 @@ use crate::sql2::{
     SqlWriteContext, WriteAccess, WriteContextLiveStateReader, WriteContextVersionRefReader,
 };
 use crate::transaction::types::{
-    LogicalPrimaryKey, StageRow, StageRowOrigin, StageWrite, StageWriteMode, StageWriteOperation,
+    LogicalPrimaryKey, TransactionWrite, TransactionWriteMode, TransactionWriteOperation,
+    TransactionWriteOrigin, TransactionWriteRow,
 };
 use crate::version::{
     version_descriptor_stage_row, version_descriptor_tombstone_row, version_ref_stage_row,
@@ -268,8 +271,8 @@ impl InsertSink for LixVersionInsertSink {
 
         if !rows.is_empty() {
             self.write_ctx
-                .stage_write(StageWrite::Rows {
-                    mode: StageWriteMode::Insert,
+                .stage_write(TransactionWrite::Rows {
+                    mode: TransactionWriteMode::Insert,
                     rows,
                 })
                 .await
@@ -397,8 +400,8 @@ impl ExecutionPlan for LixVersionDeleteExec {
 
             if !rows.is_empty() {
                 write_ctx
-                    .stage_write(StageWrite::Rows {
-                        mode: StageWriteMode::Replace,
+                    .stage_write(TransactionWrite::Rows {
+                        mode: TransactionWriteMode::Replace,
                         rows,
                     })
                     .await
@@ -540,8 +543,8 @@ impl ExecutionPlan for LixVersionUpdateExec {
 
             if !rows.is_empty() {
                 write_ctx
-                    .stage_write(StageWrite::Rows {
-                        mode: StageWriteMode::Replace,
+                    .stage_write(TransactionWrite::Rows {
+                        mode: TransactionWriteMode::Replace,
                         rows,
                     })
                     .await
@@ -717,7 +720,7 @@ struct VersionDescriptor {
     hidden: bool,
 }
 
-fn parse_descriptor(row: &LiveStateRow) -> Result<VersionDescriptor, LixError> {
+fn parse_descriptor(row: &MaterializedLiveStateRow) -> Result<VersionDescriptor, LixError> {
     let snapshot = parse_snapshot(row, "lix_version_descriptor")?;
     let id = snapshot
         .get("id")
@@ -741,7 +744,7 @@ fn parse_descriptor(row: &LiveStateRow) -> Result<VersionDescriptor, LixError> {
     Ok(VersionDescriptor { id, name, hidden })
 }
 
-fn parse_snapshot(row: &LiveStateRow, schema_key: &str) -> Result<JsonValue, LixError> {
+fn parse_snapshot(row: &MaterializedLiveStateRow, schema_key: &str) -> Result<JsonValue, LixError> {
     let snapshot_content = row.snapshot_content.as_deref().ok_or_else(|| {
         LixError::new(
             "LIX_ERROR_UNKNOWN",
@@ -903,7 +906,10 @@ fn version_update_rows_from_batch(
         .collect()
 }
 
-fn version_stage_rows(row: VersionRow, origin: Option<StageRowOrigin>) -> Vec<StageRow> {
+fn version_stage_rows(
+    row: VersionRow,
+    origin: Option<TransactionWriteOrigin>,
+) -> Vec<TransactionWriteRow> {
     vec![
         with_origin(
             version_descriptor_stage_row(&row.id, &row.name, row.hidden),
@@ -913,33 +919,42 @@ fn version_stage_rows(row: VersionRow, origin: Option<StageRowOrigin>) -> Vec<St
     ]
 }
 
-fn version_tombstone_rows(row: VersionRow) -> Vec<StageRow> {
-    let origin = Some(lix_version_origin(StageWriteOperation::Delete, &row.id));
+fn version_tombstone_rows(row: VersionRow) -> Vec<TransactionWriteRow> {
+    let origin = Some(lix_version_origin(
+        TransactionWriteOperation::Delete,
+        &row.id,
+    ));
     vec![
         with_origin(version_descriptor_tombstone_row(&row.id), origin.clone()),
         with_origin(version_ref_tombstone_row(&row.id), origin),
     ]
 }
 
-fn version_insert_stage_rows(row: VersionRow) -> Vec<StageRow> {
-    let origin = lix_version_origin(StageWriteOperation::Insert, &row.id);
+fn version_insert_stage_rows(row: VersionRow) -> Vec<TransactionWriteRow> {
+    let origin = lix_version_origin(TransactionWriteOperation::Insert, &row.id);
     version_stage_rows(row, Some(origin))
 }
 
-fn version_update_stage_rows(row: VersionRow) -> Vec<StageRow> {
-    let origin = lix_version_origin(StageWriteOperation::Update, &row.id);
+fn version_update_stage_rows(row: VersionRow) -> Vec<TransactionWriteRow> {
+    let origin = lix_version_origin(TransactionWriteOperation::Update, &row.id);
     version_stage_rows(row, Some(origin))
 }
 
-fn with_origin(mut row: StageRow, origin: Option<StageRowOrigin>) -> StageRow {
+fn with_origin(
+    mut row: TransactionWriteRow,
+    origin: Option<TransactionWriteOrigin>,
+) -> TransactionWriteRow {
     row.origin = origin;
     row
 }
 
-fn lix_version_origin(operation: StageWriteOperation, version_id: &str) -> StageRowOrigin {
-    StageRowOrigin {
+fn lix_version_origin(
+    action: TransactionWriteOperation,
+    version_id: &str,
+) -> TransactionWriteOrigin {
+    TransactionWriteOrigin {
         surface: "lix_version".to_string(),
-        operation,
+        operation: action,
         primary_key: Some(LogicalPrimaryKey {
             columns: vec!["id".to_string()],
             values: vec![version_id.to_string()],
@@ -1013,11 +1028,11 @@ fn required_string_value(
     batch: &RecordBatch,
     row_index: usize,
     column_name: &str,
-    operation: &str,
+    action: &str,
 ) -> Result<String> {
-    optional_string_value(batch, row_index, column_name, operation)?.ok_or_else(|| {
+    optional_string_value(batch, row_index, column_name, action)?.ok_or_else(|| {
         DataFusionError::Execution(format!(
-            "{operation} lix_version requires non-null text column '{column_name}'"
+            "{action} lix_version requires non-null text column '{column_name}'"
         ))
     })
 }
@@ -1026,7 +1041,7 @@ fn optional_string_value(
     batch: &RecordBatch,
     row_index: usize,
     column_name: &str,
-    operation: &str,
+    action: &str,
 ) -> Result<Option<String>> {
     match optional_scalar_value(batch, row_index, column_name)? {
         None
@@ -1038,7 +1053,7 @@ fn optional_string_value(
         | Some(ScalarValue::Utf8View(Some(value)))
         | Some(ScalarValue::LargeUtf8(Some(value))) => Ok(Some(value)),
         Some(other) => Err(DataFusionError::Execution(format!(
-            "{operation} lix_version expected text-compatible column '{column_name}', got {other:?}"
+            "{action} lix_version expected text-compatible column '{column_name}', got {other:?}"
         ))),
     }
 }
@@ -1047,11 +1062,11 @@ fn required_bool_value(
     batch: &RecordBatch,
     row_index: usize,
     column_name: &str,
-    operation: &str,
+    action: &str,
 ) -> Result<bool> {
-    optional_bool_value(batch, row_index, column_name, operation)?.ok_or_else(|| {
+    optional_bool_value(batch, row_index, column_name, action)?.ok_or_else(|| {
         DataFusionError::Execution(format!(
-            "{operation} lix_version requires non-null boolean column '{column_name}'"
+            "{action} lix_version requires non-null boolean column '{column_name}'"
         ))
     })
 }
@@ -1060,13 +1075,13 @@ fn optional_bool_value(
     batch: &RecordBatch,
     row_index: usize,
     column_name: &str,
-    operation: &str,
+    action: &str,
 ) -> Result<Option<bool>> {
     match optional_scalar_value(batch, row_index, column_name)? {
         None | Some(ScalarValue::Null) | Some(ScalarValue::Boolean(None)) => Ok(None),
         Some(ScalarValue::Boolean(Some(value))) => Ok(Some(value)),
         Some(other) => Err(DataFusionError::Execution(format!(
-            "{operation} lix_version expected boolean column '{column_name}', got {other:?}"
+            "{action} lix_version expected boolean column '{column_name}', got {other:?}"
         ))),
     }
 }

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

@@ -50,12 +50,12 @@ impl VersionBinding {
         }
     }
 
-    pub(crate) fn require_active_version_id(&self, operation: &str) -> Result<String, LixError> {
+    pub(crate) fn require_active_version_id(&self, action: &str) -> Result<String, LixError> {
         match self {
             Self::Active { version_id } => Ok(version_id.clone()),
             Self::Explicit => Err(LixError::new(
                 "LIX_ERROR_UNKNOWN",
-                format!("{operation} is only supported for active-version SQL surfaces"),
+                format!("{action} is only supported for active-version SQL surfaces"),
             )),
         }
     }
@@ -65,7 +65,7 @@ pub(crate) fn resolve_write_version_scope(
     explicit_global: Option<bool>,
     explicit_version_id: Option<String>,
     fallback_version_id: Option<&str>,
-    operation: &str,
+    action: &str,
     surface: &str,
 ) -> Result<WriteVersionScope, DataFusionError> {
     if explicit_global == Some(true) {
@@ -86,7 +86,7 @@ pub(crate) fn resolve_write_version_scope(
     let version_id = explicit_version_id
         .or_else(|| fallback_version_id.map(ToOwned::to_owned))
         .ok_or_else(|| {
-            DataFusionError::Execution(format!("{operation} requires lixcol_version_id"))
+            DataFusionError::Execution(format!("{action} requires lixcol_version_id"))
         })?;
     if explicit_global == Some(false) && version_id == GLOBAL_VERSION_ID {
         return Err(DataFusionError::Execution(format!(