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

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

@@ -1,354 +0,0 @@
-//! 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

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

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

@@ -1,295 +0,0 @@
-use std::sync::Arc;
-
-use datafusion::arrow::array::{
-    Array, ArrayRef, BinaryArray, BooleanArray, Float32Array, Float64Array, Int16Array, Int32Array,
-    Int64Array, Int8Array, LargeBinaryArray, LargeStringArray, StringArray, UInt16Array,
-    UInt32Array, UInt64Array, UInt8Array,
-};
-use datafusion::common::{plan_err, DataFusionError, Result};
-use datafusion::logical_expr::ColumnarValue;
-use serde_json::Value as JsonValue;
-
-pub(super) fn scalar_inputs(args: &[ColumnarValue]) -> bool {
-    args.iter()
-        .all(|value| matches!(value, ColumnarValue::Scalar(_)))
-}
-
-pub(super) fn json_value_to_serde(array: &dyn Array, row: usize) -> Result<Option<JsonValue>> {
-    let Some(raw) = text_like_value(array, row)? else {
-        return Ok(None);
-    };
-    serde_json::from_str::<JsonValue>(&raw)
-        .map(Some)
-        .map_err(|error| {
-            DataFusionError::Execution(format!(
-                "JSON function expected valid JSON text in its first argument, got error: {error}"
-            ))
-        })
-}
-
-pub(super) fn text_like_value(array: &dyn Array, row: usize) -> Result<Option<String>> {
-    if let Some(array) = array.as_any().downcast_ref::<StringArray>() {
-        return Ok((!array.is_null(row)).then(|| array.value(row).to_string()));
-    }
-    if let Some(array) = array.as_any().downcast_ref::<LargeStringArray>() {
-        return Ok((!array.is_null(row)).then(|| array.value(row).to_string()));
-    }
-    if let Some(value) = numeric_value(array, row)? {
-        return Ok(Some(value));
-    }
-    if let Some(array) = array.as_any().downcast_ref::<BooleanArray>() {
-        return Ok((!array.is_null(row)).then(|| {
-            if array.value(row) {
-                "true".to_string()
-            } else {
-                "false".to_string()
-            }
-        }));
-    }
-    if let Some(array) = array.as_any().downcast_ref::<BinaryArray>() {
-        return Ok(
-            (!array.is_null(row)).then(|| String::from_utf8_lossy(array.value(row)).to_string())
-        );
-    }
-    if let Some(array) = array.as_any().downcast_ref::<LargeBinaryArray>() {
-        return Ok(
-            (!array.is_null(row)).then(|| String::from_utf8_lossy(array.value(row)).to_string())
-        );
-    }
-    Err(DataFusionError::Execution(format!(
-        "unsupported argument type for JSON/text function: {:?}",
-        array.data_type()
-    )))
-}
-
-pub(super) fn numeric_value(array: &dyn Array, row: usize) -> Result<Option<String>> {
-    macro_rules! numeric_array {
-        ($ty:ty) => {
-            if let Some(array) = array.as_any().downcast_ref::<$ty>() {
-                return Ok((!array.is_null(row)).then(|| array.value(row).to_string()));
-            }
-        };
-    }
-
-    numeric_array!(Int8Array);
-    numeric_array!(Int16Array);
-    numeric_array!(Int32Array);
-    numeric_array!(Int64Array);
-    numeric_array!(UInt8Array);
-    numeric_array!(UInt16Array);
-    numeric_array!(UInt32Array);
-    numeric_array!(UInt64Array);
-    numeric_array!(Float32Array);
-    numeric_array!(Float64Array);
-    Ok(None)
-}
-
-pub(super) fn decode_utf8_value(array: &dyn Array, row: usize) -> Result<Option<String>> {
-    if let Some(array) = array.as_any().downcast_ref::<BinaryArray>() {
-        return (!array.is_null(row))
-            .then(|| String::from_utf8(array.value(row).to_vec()))
-            .transpose()
-            .map_err(|error| {
-                DataFusionError::Execution(format!(
-                    "lix_text_decode() expected valid UTF8 bytes: {error}"
-                ))
-            });
-    }
-    if let Some(array) = array.as_any().downcast_ref::<LargeBinaryArray>() {
-        return (!array.is_null(row))
-            .then(|| String::from_utf8(array.value(row).to_vec()))
-            .transpose()
-            .map_err(|error| {
-                DataFusionError::Execution(format!(
-                    "lix_text_decode() expected valid UTF8 bytes: {error}"
-                ))
-            });
-    }
-    if let Some(array) = array.as_any().downcast_ref::<StringArray>() {
-        return Ok((!array.is_null(row)).then(|| array.value(row).to_string()));
-    }
-    if let Some(array) = array.as_any().downcast_ref::<LargeStringArray>() {
-        return Ok((!array.is_null(row)).then(|| array.value(row).to_string()));
-    }
-    Err(DataFusionError::Execution(format!(
-        "lix_text_decode() expected Binary or Utf8, got {:?}",
-        array.data_type()
-    )))
-}
-
-pub(super) fn encode_utf8_value(array: &dyn Array, row: usize) -> Result<Option<Vec<u8>>> {
-    if let Some(array) = array.as_any().downcast_ref::<StringArray>() {
-        return Ok((!array.is_null(row)).then(|| array.value(row).as_bytes().to_vec()));
-    }
-    if let Some(array) = array.as_any().downcast_ref::<LargeStringArray>() {
-        return Ok((!array.is_null(row)).then(|| array.value(row).as_bytes().to_vec()));
-    }
-    if let Some(array) = array.as_any().downcast_ref::<BinaryArray>() {
-        return Ok((!array.is_null(row)).then(|| array.value(row).to_vec()));
-    }
-    if let Some(array) = array.as_any().downcast_ref::<LargeBinaryArray>() {
-        return Ok((!array.is_null(row)).then(|| array.value(row).to_vec()));
-    }
-    Err(DataFusionError::Execution(format!(
-        "lix_text_encode() expected Utf8 or Binary, got {:?}",
-        array.data_type()
-    )))
-}
-
-pub(super) fn validate_utf8_encoding_arg(
-    fn_name: &str,
-    encoding: Option<&ColumnarValue>,
-) -> Result<()> {
-    let Some(encoding) = encoding else {
-        return Ok(());
-    };
-    let arrays = ColumnarValue::values_to_arrays(std::slice::from_ref(encoding))?;
-    let array = &arrays[0];
-    if array.len() == 0 {
-        return Ok(());
-    }
-    let Some(value) = text_like_value(array.as_ref(), 0)? else {
-        return Ok(());
-    };
-    let normalized = value.trim().to_ascii_uppercase().replace('-', "");
-    if normalized == "UTF8" {
-        Ok(())
-    } else {
-        plan_err!("{fn_name}() only supports UTF8 encoding, got '{value}'")
-    }
-}
-
-pub(super) fn extract_json_path(
-    fn_name: &str,
-    arrays: &[ArrayRef],
-    row: usize,
-) -> Result<Option<JsonValue>> {
-    let Some(mut current) = json_value_to_serde(arrays[0].as_ref(), row)? else {
-        return Ok(None);
-    };
-
-    for path in &arrays[1..] {
-        let Some(segment) = json_path_segment(fn_name, path.as_ref(), row)? else {
-            return Ok(None);
-        };
-        let next = match segment {
-            JsonPathSegment::Key(key) => current.get(&key).cloned(),
-            JsonPathSegment::Index(index) => current
-                .as_array()
-                .and_then(|values| values.get(index))
-                .cloned(),
-        };
-        let Some(value) = next else {
-            return Ok(None);
-        };
-        current = value;
-    }
-
-    Ok(Some(current))
-}
-
-pub(super) fn json_text_value(value: &JsonValue) -> Result<String> {
-    match value {
-        JsonValue::String(text) => Ok(text.clone()),
-        JsonValue::Number(number) => Ok(number.to_string()),
-        JsonValue::Bool(boolean) => Ok(if *boolean {
-            "true".to_string()
-        } else {
-            "false".to_string()
-        }),
-        JsonValue::Array(_) | JsonValue::Object(_) => {
-            serde_json::to_string(value).map_err(|error| {
-                DataFusionError::Execution(format!(
-                    "lix_json_get_text() could not render JSON value: {error}"
-                ))
-            })
-        }
-        JsonValue::Null => Ok("null".to_string()),
-    }
-}
-
-pub(super) fn json_json_value(value: &JsonValue) -> Result<String> {
-    serde_json::to_string(value).map_err(|error| {
-        DataFusionError::Execution(format!(
-            "lix_json_get() could not render JSON value: {error}"
-        ))
-    })
-}
-
-enum JsonPathSegment {
-    Key(String),
-    Index(usize),
-}
-
-fn json_path_segment(
-    fn_name: &str,
-    array: &dyn Array,
-    row: usize,
-) -> Result<Option<JsonPathSegment>> {
-    if let Some(array) = array.as_any().downcast_ref::<StringArray>() {
-        if array.is_null(row) {
-            return Ok(None);
-        }
-        let value = array.value(row).to_string();
-        validate_json_path_key_segment(fn_name, &value)?;
-        return Ok(Some(JsonPathSegment::Key(value)));
-    }
-    if let Some(array) = array.as_any().downcast_ref::<LargeStringArray>() {
-        if array.is_null(row) {
-            return Ok(None);
-        }
-        let value = array.value(row).to_string();
-        validate_json_path_key_segment(fn_name, &value)?;
-        return Ok(Some(JsonPathSegment::Key(value)));
-    }
-    macro_rules! index_array {
-        ($ty:ty) => {
-            if let Some(array) = array.as_any().downcast_ref::<$ty>() {
-                if array.is_null(row) {
-                    return Ok(None);
-                }
-                let value = array.value(row);
-                let index = usize::try_from(value).map_err(|_| {
-                    DataFusionError::Execution(format!(
-                        "{fn_name}() path indexes must be non-negative integers"
-                    ))
-                })?;
-                return Ok(Some(JsonPathSegment::Index(index)));
-            }
-        };
-    }
-    index_array!(UInt8Array);
-    index_array!(UInt16Array);
-    index_array!(UInt32Array);
-    index_array!(UInt64Array);
-    index_array!(Int8Array);
-    index_array!(Int16Array);
-    index_array!(Int32Array);
-    index_array!(Int64Array);
-    Err(DataFusionError::Execution(format!(
-        "{fn_name}() path arguments must be strings or non-negative integers, got {:?}",
-        array.data_type()
-    )))
-}
-
-fn validate_json_path_key_segment(fn_name: &str, value: &str) -> Result<()> {
-    if value == "$" || value.starts_with("$.") || value.starts_with("$[") || value.starts_with('/')
-    {
-        return Err(DataFusionError::Execution(format!(
-            "{fn_name}() uses variadic path segments, not JSONPath or JSON Pointer; got '{value}'"
-        )));
-    }
-    Ok(())
-}
-
-pub(super) fn binary_array_from_owned(values: &[Option<Vec<u8>>]) -> BinaryArray {
-    let refs = values
-        .iter()
-        .map(|value| value.as_deref())
-        .collect::<Vec<_>>();
-    BinaryArray::from(refs)
-}
-
-pub(super) fn array_ref<T: Array + 'static>(array: T) -> ArrayRef {
-    Arc::new(array)
-}