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

package/dist-engine-src/src/sql2/test_support/generators.rs

@@ -0,0 +1,354 @@
+//! Deterministic sql2 statement generators for differential tests.
+
+#[cfg(test)]
+use std::borrow::Cow;
+
+#[cfg(test)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) enum DifferentialExpectation {
+    /// Semantic regression coverage. The candidate runs in normal auto mode,
+    /// so this proves sql2 behavior but does not prove fast execution.
+    SemanticParityMayFallback,
+    /// Physical fast-path coverage. The candidate must produce a fast write
+    /// plan, and the test fails if optimization declines the statement.
+    FastRequiredParity,
+}
+
+#[cfg(test)]
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub(crate) struct DifferentialSqlCase {
+    pub(crate) seed: Cow<'static, str>,
+    pub(crate) setup_sql: &'static [&'static str],
+    pub(crate) transaction_setup_sql: &'static [&'static str],
+    pub(crate) sql: Cow<'static, str>,
+    pub(crate) params: &'static [DifferentialParam],
+    pub(crate) probes: &'static [DifferentialProbe],
+    pub(crate) expectation: DifferentialExpectation,
+    pub(crate) expected_execution: ExpectedExecution,
+}
+
+#[cfg(test)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) enum ExpectedExecution {
+    Ok,
+    Err { code: &'static str },
+}
+
+#[cfg(test)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) enum DifferentialParam {
+    Json(&'static str),
+}
+
+#[cfg(test)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(crate) enum DifferentialProbe {
+    LixStateActive {
+        schema_key: &'static str,
+        entity_pks: &'static [&'static str],
+    },
+    LixStateByBranch {
+        schema_key: &'static str,
+        entity_pks: &'static [&'static str],
+        branch_ids: &'static [&'static str],
+    },
+    RegisteredSchemaActive,
+    RegisteredSchemaByBranch {
+        branch_ids: &'static [&'static str],
+    },
+}
+
+#[cfg(test)]
+const SEED_LIX_STATE_ROW_SQL: &str = "INSERT INTO lix_state (entity_pk, schema_key, file_id, snapshot_content, global, untracked) VALUES (lix_json('[\"diff-key\"]'), 'lix_key_value', NULL, lix_json('{\"key\":\"diff-key\",\"value\":\"base\"}'), false, true)";
+
+#[cfg(test)]
+const SETUP_SEED_LIX_STATE_ROW: &[&str] = &[SEED_LIX_STATE_ROW_SQL];
+
+#[cfg(test)]
+const EMPTY_PARAMS: &[DifferentialParam] = &[];
+
+#[cfg(test)]
+pub(crate) const ACTIVE_BRANCH_PROBE_ID: &str = "__active_branch__";
+
+#[cfg(test)]
+const LIX_KEY_VALUE_PROBE: &[DifferentialProbe] = &[DifferentialProbe::LixStateActive {
+    schema_key: "lix_key_value",
+    entity_pks: &["diff-key", "global-diff", "tx-diff", "dup"],
+}];
+
+#[cfg(test)]
+const LIX_KEY_VALUE_BRANCHED_PROBE: &[DifferentialProbe] = &[
+    DifferentialProbe::LixStateActive {
+        schema_key: "lix_key_value",
+        entity_pks: &["diff-key", "global-diff", "tx-diff", "dup"],
+    },
+    DifferentialProbe::LixStateByBranch {
+        schema_key: "lix_key_value",
+        entity_pks: &["diff-key", "global-diff", "tx-diff", "dup"],
+        branch_ids: &[ACTIVE_BRANCH_PROBE_ID, "global", "branch-a", "branch-b"],
+    },
+];
+
+#[cfg(test)]
+const REGISTERED_SCHEMA_PROBE: &[DifferentialProbe] = &[
+    DifferentialProbe::RegisteredSchemaActive,
+    DifferentialProbe::RegisteredSchemaByBranch {
+        branch_ids: &[ACTIVE_BRANCH_PROBE_ID, "global", "branch-a", "branch-b"],
+    },
+];
+
+#[cfg(test)]
+const LIX_KEY_VALUE_AND_REGISTERED_SCHEMA_PROBES: &[DifferentialProbe] = &[
+    DifferentialProbe::LixStateActive {
+        schema_key: "lix_key_value",
+        entity_pks: &["diff-key", "global-diff", "tx-diff", "dup"],
+    },
+    DifferentialProbe::RegisteredSchemaActive,
+];
+
+#[cfg(test)]
+const STAGED_TX_INSERT_SQL: &str = "INSERT INTO lix_state (entity_pk, schema_key, file_id, snapshot_content, global, untracked) VALUES (lix_json('[\"tx-diff\"]'), 'lix_key_value', NULL, lix_json('{\"key\":\"tx-diff\",\"value\":\"base\"}'), false, true)";
+
+#[cfg(test)]
+const TX_SETUP_STAGED_LIX_STATE_ROW: &[&str] = &[STAGED_TX_INSERT_SQL];
+
+#[cfg(test)]
+const PARAM_METADATA_JSON: &[DifferentialParam] =
+    &[DifferentialParam::Json("{\"seen\":\"param\"}")];
+
+#[cfg(test)]
+const PARAM_ENTITY_PK_AND_METADATA: &[DifferentialParam] = &[
+    DifferentialParam::Json("[\"diff-key\"]"),
+    DifferentialParam::Json("{\"seen\":\"param\"}"),
+];
+
+#[cfg(test)]
+pub(crate) fn deterministic_repro_cases() -> Vec<DifferentialSqlCase> {
+    vec![
+        DifferentialSqlCase {
+            seed: "known/unresolvable-assignment-target".into(),
+            setup_sql: &[],
+            transaction_setup_sql: &[],
+            sql: "UPDATE lix_state SET no_such_column = 'x' WHERE false".into(),
+            params: EMPTY_PARAMS,
+            probes: LIX_KEY_VALUE_AND_REGISTERED_SCHEMA_PROBES,
+            expectation: DifferentialExpectation::SemanticParityMayFallback,
+            expected_execution: ExpectedExecution::Err {
+                code: "LIX_COLUMN_NOT_FOUND",
+            },
+        },
+        DifferentialSqlCase {
+            seed: "known/base-entity-branch-override".into(),
+            setup_sql: &[],
+            transaction_setup_sql: &[],
+            sql: "UPDATE lix_registered_schema SET value = lix_json('{\"x-lix-key\":\"x\",\"type\":\"object\"}') WHERE lixcol_branch_id = 'branch-b'".into(),
+            params: EMPTY_PARAMS,
+            probes: REGISTERED_SCHEMA_PROBE,
+            expectation: DifferentialExpectation::SemanticParityMayFallback,
+            expected_execution: ExpectedExecution::Err {
+                code: "LIX_COLUMN_NOT_FOUND",
+            },
+        },
+        DifferentialSqlCase {
+            seed: "known/base-entity-insert-hidden-branch-column".into(),
+            setup_sql: &[],
+            transaction_setup_sql: &[],
+            sql: "INSERT INTO lix_registered_schema (value, lixcol_branch_id) VALUES (lix_json('{\"x-lix-key\":\"x\",\"type\":\"object\"}'), 'branch-b')".into(),
+            params: EMPTY_PARAMS,
+            probes: REGISTERED_SCHEMA_PROBE,
+            expectation: DifferentialExpectation::SemanticParityMayFallback,
+            expected_execution: ExpectedExecution::Err {
+                code: "LIX_COLUMN_NOT_FOUND",
+            },
+        },
+        DifferentialSqlCase {
+            seed: "known/unknown-typed-entity-insert-column".into(),
+            setup_sql: &[],
+            transaction_setup_sql: &[],
+            sql: "INSERT INTO lix_registered_schema (value, unknown_column) VALUES (lix_json('{\"x-lix-key\":\"x\",\"type\":\"object\"}'), 'x')".into(),
+            params: EMPTY_PARAMS,
+            probes: REGISTERED_SCHEMA_PROBE,
+            expectation: DifferentialExpectation::SemanticParityMayFallback,
+            expected_execution: ExpectedExecution::Err {
+                code: "LIX_COLUMN_NOT_FOUND",
+            },
+        },
+        DifferentialSqlCase {
+            seed: "known/by-branch-update-without-branch-predicate".into(),
+            setup_sql: &[],
+            transaction_setup_sql: &[],
+            sql: "UPDATE lix_registered_schema_by_branch SET value = lix_json('{\"x-lix-key\":\"x\",\"type\":\"object\"}')".into(),
+            params: EMPTY_PARAMS,
+            probes: REGISTERED_SCHEMA_PROBE,
+            expectation: DifferentialExpectation::SemanticParityMayFallback,
+            expected_execution: ExpectedExecution::Err {
+                code: "LIX_UNSUPPORTED_SQL",
+            },
+        },
+        DifferentialSqlCase {
+            seed: "known/by-branch-delete-without-branch-predicate".into(),
+            setup_sql: &[],
+            transaction_setup_sql: &[],
+            sql: "DELETE FROM lix_registered_schema_by_branch".into(),
+            params: EMPTY_PARAMS,
+            probes: REGISTERED_SCHEMA_PROBE,
+            expectation: DifferentialExpectation::SemanticParityMayFallback,
+            expected_execution: ExpectedExecution::Err {
+                code: "LIX_UNSUPPORTED_SQL",
+            },
+        },
+        DifferentialSqlCase {
+            seed: "known/repeated-contradictory-predicates".into(),
+            setup_sql: SETUP_SEED_LIX_STATE_ROW,
+            transaction_setup_sql: &[],
+            sql: "UPDATE lix_state SET metadata = lix_json('{\"seen\":true}') WHERE schema_key = 'lix_key_value' AND schema_key = 'other_schema'".into(),
+            params: EMPTY_PARAMS,
+            probes: LIX_KEY_VALUE_PROBE,
+            expectation: DifferentialExpectation::SemanticParityMayFallback,
+            expected_execution: ExpectedExecution::Ok,
+        },
+        DifferentialSqlCase {
+            seed: "known/duplicate-insert-target-columns".into(),
+            setup_sql: &[],
+            transaction_setup_sql: &[],
+            sql: "INSERT INTO lix_state (entity_pk, entity_pk, schema_key, file_id, snapshot_content) VALUES (lix_json('[\"dup\"]'), lix_json('[\"dup\"]'), 'lix_key_value', NULL, lix_json('{\"key\":\"dup\",\"value\":\"dup\"}'))".into(),
+            params: EMPTY_PARAMS,
+            probes: LIX_KEY_VALUE_PROBE,
+            expectation: DifferentialExpectation::SemanticParityMayFallback,
+            expected_execution: ExpectedExecution::Err {
+                code: "LIX_INVALID_PARAM",
+            },
+        },
+        DifferentialSqlCase {
+            seed: "known/duplicate-update-assignments".into(),
+            setup_sql: &[],
+            transaction_setup_sql: &[],
+            sql: "UPDATE lix_state SET metadata = NULL, metadata = NULL WHERE false".into(),
+            params: EMPTY_PARAMS,
+            probes: LIX_KEY_VALUE_PROBE,
+            expectation: DifferentialExpectation::SemanticParityMayFallback,
+            expected_execution: ExpectedExecution::Err {
+                code: "LIX_INVALID_PARAM",
+            },
+        },
+        DifferentialSqlCase {
+            seed: "known/qualified-target-table-name".into(),
+            setup_sql: &[],
+            transaction_setup_sql: &[],
+            sql: "UPDATE public.lix_state SET metadata = NULL WHERE false".into(),
+            params: EMPTY_PARAMS,
+            probes: LIX_KEY_VALUE_PROBE,
+            expectation: DifferentialExpectation::SemanticParityMayFallback,
+            expected_execution: ExpectedExecution::Err {
+                code: "LIX_UNSUPPORTED_SQL",
+            },
+        },
+        DifferentialSqlCase {
+            seed: "known/staged-overlay-global-row-read".into(),
+            setup_sql: &[],
+            transaction_setup_sql: &[],
+            sql: "INSERT INTO lix_state (entity_pk, schema_key, file_id, snapshot_content, global, untracked) VALUES (lix_json('[\"global-diff\"]'), 'lix_key_value', NULL, lix_json('{\"key\":\"global-diff\",\"value\":\"global\"}'), true, true)".into(),
+            params: EMPTY_PARAMS,
+            probes: LIX_KEY_VALUE_PROBE,
+            expectation: DifferentialExpectation::SemanticParityMayFallback,
+            expected_execution: ExpectedExecution::Ok,
+        },
+        DifferentialSqlCase {
+            seed: "known/empty-branch-filter-base-staged-dedupe".into(),
+            setup_sql: SETUP_SEED_LIX_STATE_ROW,
+            transaction_setup_sql: &[],
+            sql: "UPDATE lix_state SET snapshot_content = lix_json('{\"key\":\"diff-key\",\"value\":\"staged\"}') WHERE schema_key IN ('lix_key_value') AND entity_pk = lix_json('[\"diff-key\"]')".into(),
+            params: EMPTY_PARAMS,
+            probes: LIX_KEY_VALUE_PROBE,
+            expectation: DifferentialExpectation::SemanticParityMayFallback,
+            expected_execution: ExpectedExecution::Ok,
+        },
+        DifferentialSqlCase {
+            seed: "known/parameter-binding-after-contradiction".into(),
+            setup_sql: SETUP_SEED_LIX_STATE_ROW,
+            transaction_setup_sql: &[],
+            sql: "UPDATE lix_state SET metadata = $2 WHERE schema_key = 'lix_key_value' AND schema_key = 'other_schema' AND entity_pk = $1".into(),
+            params: PARAM_ENTITY_PK_AND_METADATA,
+            probes: LIX_KEY_VALUE_PROBE,
+            expectation: DifferentialExpectation::SemanticParityMayFallback,
+            expected_execution: ExpectedExecution::Ok,
+        },
+        DifferentialSqlCase {
+            seed: "known/staged-overlay-update-sees-prior-staged-row".into(),
+            setup_sql: &[],
+            transaction_setup_sql: TX_SETUP_STAGED_LIX_STATE_ROW,
+            sql: "UPDATE lix_state SET snapshot_content = lix_json('{\"key\":\"tx-diff\",\"value\":\"updated\"}') WHERE schema_key = 'lix_key_value' AND entity_pk = lix_json('[\"tx-diff\"]')".into(),
+            params: EMPTY_PARAMS,
+            probes: LIX_KEY_VALUE_PROBE,
+            expectation: DifferentialExpectation::SemanticParityMayFallback,
+            expected_execution: ExpectedExecution::Ok,
+        },
+    ]
+}
+
+#[cfg(test)]
+pub(crate) fn generated_dml_cases() -> Vec<DifferentialSqlCase> {
+    let mut cases = Vec::new();
+
+    for target in ["lix_state", "lix_state_by_branch"] {
+        cases.push(DifferentialSqlCase {
+            seed: format!("generated/{target}/delete-false").into(),
+            setup_sql: SETUP_SEED_LIX_STATE_ROW,
+            transaction_setup_sql: &[],
+            sql: format!("DELETE FROM {target} WHERE false").into(),
+            params: EMPTY_PARAMS,
+            probes: LIX_KEY_VALUE_BRANCHED_PROBE,
+            expectation: DifferentialExpectation::FastRequiredParity,
+            expected_execution: ExpectedExecution::Ok,
+        });
+        cases.push(DifferentialSqlCase {
+            seed: format!("generated/{target}/update-false").into(),
+            setup_sql: SETUP_SEED_LIX_STATE_ROW,
+            transaction_setup_sql: &[],
+            sql: format!("UPDATE {target} SET metadata = NULL WHERE false").into(),
+            params: EMPTY_PARAMS,
+            probes: LIX_KEY_VALUE_BRANCHED_PROBE,
+            expectation: DifferentialExpectation::FastRequiredParity,
+            expected_execution: ExpectedExecution::Ok,
+        });
+    }
+
+    cases.extend([
+        DifferentialSqlCase {
+            seed: "generated/lix-state-by-branch/update-explicit-miss".into(),
+            setup_sql: SETUP_SEED_LIX_STATE_ROW,
+            transaction_setup_sql: &[],
+            sql: "UPDATE lix_state_by_branch SET metadata = NULL WHERE branch_id = 'branch-b' AND schema_key = 'lix_key_value'".into(),
+            params: EMPTY_PARAMS,
+            probes: LIX_KEY_VALUE_BRANCHED_PROBE,
+            expectation: DifferentialExpectation::SemanticParityMayFallback,
+            expected_execution: ExpectedExecution::Err {
+                code: "LIX_ERROR_INVALID_STORAGE_SCOPE",
+            },
+        },
+        DifferentialSqlCase {
+            seed: "generated/entity-base/reject-hidden-branch".into(),
+            setup_sql: &[],
+            transaction_setup_sql: &[],
+            sql: "DELETE FROM lix_registered_schema WHERE lixcol_branch_id = 'branch-a'".into(),
+            params: EMPTY_PARAMS,
+            probes: REGISTERED_SCHEMA_PROBE,
+            expectation: DifferentialExpectation::SemanticParityMayFallback,
+            expected_execution: ExpectedExecution::Err {
+                code: "LIX_COLUMN_NOT_FOUND",
+            },
+        },
+        DifferentialSqlCase {
+            seed: "generated/lix-state/update-param-metadata".into(),
+            setup_sql: SETUP_SEED_LIX_STATE_ROW,
+            transaction_setup_sql: &[],
+            sql: "UPDATE lix_state SET metadata = $1 WHERE schema_key = 'lix_key_value' AND entity_pk = lix_json('[\"diff-key\"]')".into(),
+            params: PARAM_METADATA_JSON,
+            probes: LIX_KEY_VALUE_PROBE,
+            expectation: DifferentialExpectation::SemanticParityMayFallback,
+            expected_execution: ExpectedExecution::Ok,
+        },
+    ]);
+
+    cases
+}

package/dist-engine-src/src/sql2/test_support/mod.rs

@@ -0,0 +1,2 @@
+pub(crate) mod differential;
+pub(crate) mod generators;

package/dist-engine-src/src/sql2/udfs/{lix_active_version_commit_id.rs → lix_active_branch_commit_id.rs}

@@ -7,29 +7,29 @@ use datafusion::logical_expr::{
 };
 
 #[derive(Clone, PartialEq, Eq, Hash)]
-pub(super) struct LixActiveVersionCommitId {
+pub(super) struct LixActiveBranchCommitId {
     commit_id: Option<String>,
 }
 
-impl LixActiveVersionCommitId {
+impl LixActiveBranchCommitId {
     pub(super) fn new(commit_id: Option<String>) -> Self {
         Self { commit_id }
     }
 }
 
-impl std::fmt::Debug for LixActiveVersionCommitId {
+impl std::fmt::Debug for LixActiveBranchCommitId {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("LixActiveVersionCommitId").finish()
+        f.debug_struct("LixActiveBranchCommitId").finish()
     }
 }
 
-impl ScalarUDFImpl for LixActiveVersionCommitId {
+impl ScalarUDFImpl for LixActiveBranchCommitId {
     fn as_any(&self) -> &dyn Any {
         self
     }
 
     fn name(&self) -> &str {
-        "lix_active_version_commit_id"
+        "lix_active_branch_commit_id"
     }
 
     fn signature(&self) -> &Signature {
@@ -44,7 +44,7 @@ impl ScalarUDFImpl for LixActiveVersionCommitId {
 
     fn invoke_with_args(&self, args: ScalarFunctionArgs) -> Result<ColumnarValue> {
         if !args.args.is_empty() {
-            return plan_err!("lix_active_version_commit_id requires no arguments");
+            return plan_err!("lix_active_branch_commit_id requires no arguments");
         }
         Ok(ColumnarValue::Scalar(ScalarValue::Utf8(
             self.commit_id.clone(),

package/dist-engine-src/src/sql2/udfs/mod.rs

@@ -1,5 +1,5 @@
 mod common;
-mod lix_active_version_commit_id;
+mod lix_active_branch_commit_id;
 mod lix_empty_blob;
 mod lix_json;
 mod lix_json_get;
@@ -8,15 +8,12 @@ mod lix_text_decode;
 mod lix_text_encode;
 mod lix_timestamp;
 mod lix_uuid_v7;
-mod public_call;
 
 use datafusion::execution::context::SessionContext;
 use datafusion::logical_expr::ScalarUDF;
 
 use crate::functions::FunctionProviderHandle;
 
-pub(crate) use public_call::validate_public_udf_calls_in_datafusion_statement;
-
 #[cfg(test)]
 pub(crate) fn system_sql2_function_provider() -> FunctionProviderHandle {
     use crate::functions::{FunctionProvider, SharedFunctionProvider, SystemFunctionProvider};
@@ -27,10 +24,10 @@ pub(crate) fn system_sql2_function_provider() -> FunctionProviderHandle {
 pub(crate) fn register_sql2_functions(
     ctx: &SessionContext,
     functions: FunctionProviderHandle,
-    active_version_commit_id: Option<String>,
+    active_branch_commit_id: Option<String>,
 ) {
     ctx.register_udf(ScalarUDF::from(
-        lix_active_version_commit_id::LixActiveVersionCommitId::new(active_version_commit_id),
+        lix_active_branch_commit_id::LixActiveBranchCommitId::new(active_branch_commit_id),
     ));
     ctx.register_udf(ScalarUDF::from(lix_json_get::LixJsonGet::new()));
     ctx.register_udf(ScalarUDF::from(lix_json_get_text::LixJsonGetText::new()));

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

@@ -11,6 +11,7 @@ use datafusion::physical_expr::PhysicalExpr;
 use datafusion::physical_plan::projection::ProjectionExec;
 use datafusion::physical_plan::ExecutionPlan;
 
+use crate::sql2::exec::datafusion::LIX_INSERT_COLUMN_OMITTED_METADATA_KEY;
 use crate::LixError;
 
 #[derive(Debug, Clone)]
@@ -47,24 +48,32 @@ pub(crate) struct InsertColumnIntents {
 }
 
 impl InsertColumnIntents {
-    pub(crate) fn all_explicit() -> Self {
-        Self {
-            explicit_columns: None,
+    pub(crate) fn from_input(input: &Arc<dyn ExecutionPlan>) -> Self {
+        if let Some(explicit_columns) = Self::explicit_columns_from_schema(input) {
+            return Self {
+                explicit_columns: Some(explicit_columns),
+            };
         }
-    }
 
-    pub(crate) fn from_input(input: &Arc<dyn ExecutionPlan>) -> Self {
         let Some(projection) = input.as_any().downcast_ref::<ProjectionExec>() else {
             return Self {
                 explicit_columns: None,
             };
         };
 
+        let child_schema = projection.children().first().map(|child| child.schema());
         let explicit_columns = projection
             .expr()
             .iter()
-            .filter(|expr| !is_generated_null_default(expr.expr.as_ref()))
-            .map(|expr| expr.alias.clone())
+            .enumerate()
+            .filter(|(index, expr)| {
+                !is_generated_null_default(expr.expr.as_ref())
+                    && !child_schema
+                        .as_ref()
+                        .and_then(|schema| schema.fields().get(*index))
+                        .is_some_and(|field| field_is_omitted_insert_default(field.as_ref()))
+            })
+            .map(|(_, expr)| expr.alias.clone())
             .collect();
 
         Self {
@@ -72,27 +81,41 @@ impl InsertColumnIntents {
         }
     }
 
+    fn explicit_columns_from_schema(input: &Arc<dyn ExecutionPlan>) -> Option<BTreeSet<String>> {
+        let omitted_columns = input
+            .schema()
+            .fields()
+            .iter()
+            .filter(|field| field_is_omitted_insert_default(field.as_ref()))
+            .map(|field| field.name().clone())
+            .collect::<BTreeSet<_>>();
+        if omitted_columns.is_empty() {
+            return None;
+        }
+
+        Some(
+            input
+                .schema()
+                .fields()
+                .iter()
+                .filter(|field| !omitted_columns.contains(field.name().as_str()))
+                .map(|field| field.name().clone())
+                .collect(),
+        )
+    }
+
     pub(crate) fn includes_column(&self, column_name: &str) -> bool {
         self.explicit_columns
             .as_ref()
             .is_none_or(|columns| columns.contains(column_name))
     }
+}
 
-    pub(crate) fn cell(
-        &self,
-        batch: &RecordBatch,
-        row_index: usize,
-        column_name: &str,
-    ) -> Result<InsertCell> {
-        if !self.includes_column(column_name) {
-            return Ok(InsertCell::Omitted);
-        }
-
-        optional_scalar_value(batch, row_index, column_name).map(|value| match value {
-            None => InsertCell::Omitted,
-            Some(value) => InsertCell::Provided(SqlCell::from_scalar(value)),
-        })
-    }
+fn field_is_omitted_insert_default(field: &datafusion::arrow::datatypes::Field) -> bool {
+    field
+        .metadata()
+        .get(LIX_INSERT_COLUMN_OMITTED_METADATA_KEY)
+        .is_some_and(|value| value == "true")
 }
 
 pub(crate) fn reject_non_binary_casts_for_insert_column(