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

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

@@ -1,76 +0,0 @@
-use std::any::Any;
-
-use datafusion::arrow::datatypes::DataType;
-use datafusion::common::{plan_err, Result, ScalarValue};
-use datafusion::logical_expr::{
-    ColumnarValue, ScalarFunctionArgs, ScalarUDFImpl, Signature, Volatility,
-};
-
-use crate::functions::FunctionProviderHandle;
-
-#[derive(Clone)]
-pub(super) struct LixUuidV7 {
-    pub(super) functions: FunctionProviderHandle,
-}
-
-impl PartialEq for LixUuidV7 {
-    fn eq(&self, _other: &Self) -> bool {
-        true
-    }
-}
-
-impl Eq for LixUuidV7 {}
-
-impl std::hash::Hash for LixUuidV7 {
-    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
-        self.name().hash(state);
-    }
-}
-
-impl std::fmt::Debug for LixUuidV7 {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("LixUuidV7").finish()
-    }
-}
-
-impl ScalarUDFImpl for LixUuidV7 {
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-
-    fn name(&self) -> &str {
-        "lix_uuid_v7"
-    }
-
-    fn signature(&self) -> &Signature {
-        static SIGNATURE: std::sync::LazyLock<Signature> =
-            std::sync::LazyLock::new(|| Signature::nullary(Volatility::Volatile));
-        &SIGNATURE
-    }
-
-    fn return_type(&self, _arg_types: &[DataType]) -> Result<DataType> {
-        Ok(DataType::Utf8)
-    }
-
-    fn invoke_with_args(&self, args: ScalarFunctionArgs) -> Result<ColumnarValue> {
-        if !args.args.is_empty() {
-            return plan_err!("lix_uuid_v7 requires no arguments");
-        }
-        Ok(ColumnarValue::Scalar(ScalarValue::Utf8(Some(
-            self.functions.call_uuid_v7(),
-        ))))
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::super::test_support::single_text;
-
-    #[tokio::test]
-    async fn returns_uuid_text() {
-        let value = single_text("SELECT lix_uuid_v7()")
-            .await
-            .expect("uuid should not be null");
-        assert!(!value.is_empty());
-    }
-}

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

@@ -1,86 +0,0 @@
-mod common;
-mod lix_active_branch_commit_id;
-mod lix_empty_blob;
-mod lix_json;
-mod lix_json_get;
-mod lix_json_get_text;
-mod lix_text_decode;
-mod lix_text_encode;
-mod lix_timestamp;
-mod lix_uuid_v7;
-
-use datafusion::execution::context::SessionContext;
-use datafusion::logical_expr::ScalarUDF;
-
-use crate::functions::FunctionProviderHandle;
-
-#[cfg(test)]
-pub(crate) fn system_sql2_function_provider() -> FunctionProviderHandle {
-    use crate::functions::{FunctionProvider, SharedFunctionProvider, SystemFunctionProvider};
-
-    SharedFunctionProvider::new(Box::new(SystemFunctionProvider) as Box<dyn FunctionProvider + Send>)
-}
-
-pub(crate) fn register_sql2_functions(
-    ctx: &SessionContext,
-    functions: FunctionProviderHandle,
-    active_branch_commit_id: Option<String>,
-) {
-    ctx.register_udf(ScalarUDF::from(
-        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()));
-    ctx.register_udf(ScalarUDF::from(lix_text_decode::LixTextDecode::new()));
-    ctx.register_udf(ScalarUDF::from(lix_text_encode::LixTextEncode::new()));
-    ctx.register_udf(ScalarUDF::from(lix_json::LixJson));
-    ctx.register_udf(ScalarUDF::from(lix_empty_blob::LixEmptyBlob));
-    ctx.register_udf(ScalarUDF::from(lix_uuid_v7::LixUuidV7 {
-        functions: functions.clone(),
-    }));
-    ctx.register_udf(ScalarUDF::from(lix_timestamp::LixTimestamp { functions }));
-}
-
-#[cfg(test)]
-pub(super) mod test_support {
-    use datafusion::arrow::array::{Array, BinaryArray, StringArray};
-    use datafusion::prelude::SessionContext;
-
-    use super::{register_sql2_functions, system_sql2_function_provider};
-
-    pub(super) async fn single_text(sql: &str) -> Option<String> {
-        let ctx = SessionContext::new();
-        register_sql2_functions(&ctx, system_sql2_function_provider(), None);
-        let batches = ctx
-            .sql(sql)
-            .await
-            .expect("query should plan")
-            .collect()
-            .await
-            .expect("query should execute");
-        let array = batches[0]
-            .column(0)
-            .as_any()
-            .downcast_ref::<StringArray>()
-            .expect("first column should be utf8");
-        (!array.is_null(0)).then(|| array.value(0).to_string())
-    }
-
-    pub(super) async fn single_binary(sql: &str) -> Option<Vec<u8>> {
-        let ctx = SessionContext::new();
-        register_sql2_functions(&ctx, system_sql2_function_provider(), None);
-        let batches = ctx
-            .sql(sql)
-            .await
-            .expect("query should plan")
-            .collect()
-            .await
-            .expect("query should execute");
-        let array = batches[0]
-            .column(0)
-            .as_any()
-            .downcast_ref::<BinaryArray>()
-            .expect("first column should be binary");
-        (!array.is_null(0)).then(|| array.value(0).to_vec())
-    }
-}

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

@@ -1,368 +0,0 @@
-use std::collections::{BTreeMap, BTreeSet};
-use std::sync::Arc;
-
-use datafusion::arrow::array::ArrayRef;
-use datafusion::arrow::datatypes::DataType;
-use datafusion::arrow::record_batch::RecordBatch;
-use datafusion::common::{DataFusionError, Result, ScalarValue};
-use datafusion::logical_expr::Expr;
-use datafusion::physical_expr::expressions::{CastExpr, Literal};
-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)]
-pub(crate) enum SqlCell {
-    Null,
-    Value(ScalarValue),
-}
-
-impl SqlCell {
-    pub(crate) fn from_scalar(value: ScalarValue) -> Self {
-        if value.is_null() {
-            Self::Null
-        } else {
-            Self::Value(value)
-        }
-    }
-}
-
-#[derive(Debug, Clone)]
-pub(crate) enum InsertCell {
-    Omitted,
-    Provided(SqlCell),
-}
-
-#[derive(Debug, Clone)]
-pub(crate) enum UpdateCell {
-    Unassigned,
-    Assigned(SqlCell),
-}
-
-#[derive(Debug, Clone)]
-pub(crate) struct InsertColumnIntents {
-    explicit_columns: Option<BTreeSet<String>>,
-}
-
-impl InsertColumnIntents {
-    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),
-            };
-        }
-
-        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()
-            .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 {
-            explicit_columns: Some(explicit_columns),
-        }
-    }
-
-    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))
-    }
-}
-
-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(
-    input: &Arc<dyn ExecutionPlan>,
-    column_name: &str,
-    context: &str,
-) -> Result<()> {
-    reject_non_binary_casts_for_insert_column_in_plan(input.as_ref(), column_name, context)
-}
-
-fn reject_non_binary_casts_for_insert_column_in_plan(
-    input: &dyn ExecutionPlan,
-    column_name: &str,
-    context: &str,
-) -> Result<()> {
-    let Some(projection) = input.as_any().downcast_ref::<ProjectionExec>() else {
-        for child in input.children() {
-            reject_non_binary_casts_for_insert_column_in_plan(
-                child.as_ref(),
-                column_name,
-                context,
-            )?;
-        }
-        return Ok(());
-    };
-
-    let Some(expr) = projection
-        .expr()
-        .iter()
-        .find(|expr| expr.alias == column_name)
-    else {
-        return Ok(());
-    };
-
-    if contains_non_binary_cast_to_binary(expr.expr.as_ref()) {
-        return Err(super::error::lix_error_to_datafusion_error(
-            LixError::new(
-                LixError::CODE_TYPE_MISMATCH,
-                format!("{context} expected binary column '{column_name}'"),
-            )
-            .with_hint("Use X'...' or a binary parameter for file contents."),
-        ));
-    }
-
-    Ok(())
-}
-
-fn contains_non_binary_cast_to_binary(expr: &dyn PhysicalExpr) -> bool {
-    let Some(cast) = expr.as_any().downcast_ref::<CastExpr>() else {
-        return false;
-    };
-
-    if is_binary_type(cast.cast_type()) && !physical_expr_is_binary_or_null(cast.expr().as_ref()) {
-        return true;
-    }
-
-    contains_non_binary_cast_to_binary(cast.expr().as_ref())
-}
-
-fn physical_expr_is_binary_or_null(expr: &dyn PhysicalExpr) -> bool {
-    if let Some(literal) = expr.as_any().downcast_ref::<Literal>() {
-        return scalar_is_binary_or_null(literal.value());
-    }
-
-    if let Some(cast) = expr.as_any().downcast_ref::<CastExpr>() {
-        return is_binary_type(cast.cast_type())
-            && physical_expr_is_binary_or_null(cast.expr().as_ref());
-    }
-
-    false
-}
-
-pub(crate) fn scalar_is_binary_or_null(value: &ScalarValue) -> bool {
-    value.is_null()
-        || matches!(
-            value,
-            ScalarValue::Binary(_)
-                | ScalarValue::LargeBinary(_)
-                | ScalarValue::FixedSizeBinary(_, _)
-        )
-}
-
-pub(crate) fn logical_expr_is_binary_or_null(expr: &Expr) -> bool {
-    match expr {
-        Expr::Literal(value, _) => scalar_is_binary_or_null(value),
-        Expr::Cast(cast) => {
-            is_binary_type(&cast.data_type) && logical_expr_is_binary_or_null(&cast.expr)
-        }
-        Expr::Alias(alias) => logical_expr_is_binary_or_null(&alias.expr),
-        _ => false,
-    }
-}
-
-pub(crate) fn is_binary_type(data_type: &DataType) -> bool {
-    matches!(
-        data_type,
-        DataType::Binary | DataType::LargeBinary | DataType::FixedSizeBinary(_)
-    )
-}
-
-pub(crate) fn lix_file_data_type_lix_error() -> LixError {
-    LixError::new(
-        LixError::CODE_TYPE_MISMATCH,
-        "lix_file.data expects binary data",
-    )
-    .with_hint("Use X'...' or a binary parameter for file contents.")
-}
-
-pub(crate) fn lix_file_data_type_error(
-    context: &str,
-    column_name: &str,
-    instruction: &str,
-) -> DataFusionError {
-    super::error::lix_error_to_datafusion_error(
-        LixError::new(
-            LixError::CODE_TYPE_MISMATCH,
-            format!("{context} expected binary column '{column_name}'"),
-        )
-        .with_hint(instruction),
-    )
-}
-
-pub(crate) fn lix_file_data_type_error_with_value(
-    context: &str,
-    column_name: &str,
-    value: &ScalarValue,
-    instruction: &str,
-) -> DataFusionError {
-    super::error::lix_error_to_datafusion_error(
-        LixError::new(
-            LixError::CODE_TYPE_MISMATCH,
-            format!("{context} expected binary column '{column_name}', got {value:?}"),
-        )
-        .with_hint(instruction),
-    )
-}
-
-pub(crate) struct UpdateAssignmentValues {
-    values: BTreeMap<String, ArrayRef>,
-}
-
-impl UpdateAssignmentValues {
-    pub(crate) fn evaluate(
-        batch: &RecordBatch,
-        assignments: &[(String, Arc<dyn PhysicalExpr>)],
-    ) -> Result<Self> {
-        let mut values = BTreeMap::new();
-        for (column_name, assignment) in assignments {
-            values.insert(
-                column_name.clone(),
-                assignment.evaluate(batch)?.into_array(batch.num_rows())?,
-            );
-        }
-        Ok(Self { values })
-    }
-
-    #[cfg(test)]
-    pub(crate) fn from_batch_columns(batch: &RecordBatch, columns: &[&str]) -> Self {
-        let values = columns
-            .iter()
-            .filter_map(|column_name| {
-                let column_index = batch.schema().index_of(column_name).ok()?;
-                Some((
-                    (*column_name).to_string(),
-                    Arc::clone(batch.column(column_index)),
-                ))
-            })
-            .collect();
-        Self { values }
-    }
-
-    /// Returns only the value explicitly assigned by SQL UPDATE.
-    ///
-    /// Use this for document-patch semantics where `Unassigned` must remain
-    /// distinct from `Assigned(NULL)`.
-    pub(crate) fn assigned_cell(&self, row_index: usize, column_name: &str) -> Result<UpdateCell> {
-        let Some(array) = self.values.get(column_name) else {
-            return Ok(UpdateCell::Unassigned);
-        };
-
-        ScalarValue::try_from_array(array.as_ref(), row_index)
-            .map(SqlCell::from_scalar)
-            .map(UpdateCell::Assigned)
-            .map_err(|error| {
-                DataFusionError::Execution(format!(
-                    "failed to decode SQL UPDATE assignment for column '{column_name}' at row {row_index}: {error}"
-                ))
-            })
-    }
-
-    /// Returns the assigned SQL UPDATE value, or falls back to the existing row
-    /// column value when the column was not assigned.
-    ///
-    /// Use this for scalar row-column semantics. Do not use it to reconstruct
-    /// JSON documents from projected property columns, because projection can
-    /// erase the difference between an absent property and an explicit null.
-    pub(crate) fn assigned_or_existing_cell(
-        &self,
-        batch: &RecordBatch,
-        row_index: usize,
-        column_name: &str,
-    ) -> Result<InsertCell> {
-        match self.assigned_cell(row_index, column_name)? {
-            UpdateCell::Assigned(value) => Ok(InsertCell::Provided(value)),
-            UpdateCell::Unassigned => {
-                optional_scalar_value(batch, row_index, column_name).map(|value| match value {
-                    None => InsertCell::Omitted,
-                    Some(value) => InsertCell::Provided(SqlCell::from_scalar(value)),
-                })
-            }
-        }
-    }
-}
-
-pub(crate) fn optional_scalar_value(
-    batch: &RecordBatch,
-    row_index: usize,
-    column_name: &str,
-) -> Result<Option<ScalarValue>> {
-    let schema = batch.schema();
-    let column_index = match schema.index_of(column_name) {
-        Ok(column_index) => column_index,
-        Err(_) => return Ok(None),
-    };
-    if row_index >= batch.num_rows() {
-        return Err(DataFusionError::Execution(format!(
-            "row index {row_index} out of bounds for SQL write batch with {} rows",
-            batch.num_rows()
-        )));
-    }
-    ScalarValue::try_from_array(batch.column(column_index).as_ref(), row_index)
-        .map(Some)
-        .map_err(|error| {
-            DataFusionError::Execution(format!(
-                "failed to decode SQL write column '{column_name}' at row {row_index}: {error}"
-            ))
-        })
-}
-
-fn is_generated_null_default(expr: &dyn PhysicalExpr) -> bool {
-    if let Some(literal) = expr.as_any().downcast_ref::<Literal>() {
-        return literal.value().is_null();
-    }
-
-    if let Some(cast) = expr.as_any().downcast_ref::<CastExpr>() {
-        return is_generated_null_default(cast.expr().as_ref());
-    }
-
-    false
-}