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

package/dist-engine-src/src/sql2/{udfs/public_call.rs → bind/public_udf.rs}

@@ -1,14 +1,18 @@
 use std::ops::ControlFlow;
 
+use datafusion::sql::parser::Statement as DataFusionStatement;
 use datafusion::sql::sqlparser::ast::{
     Expr, Function, FunctionArg, FunctionArgExpr, FunctionArguments, ObjectNamePart, Statement,
     Value, Visit, Visitor,
 };
+#[cfg(test)]
 use datafusion::sql::sqlparser::dialect::GenericDialect;
+#[cfg(test)]
 use datafusion::sql::sqlparser::parser::Parser;
 
 use crate::LixError;
 
+#[cfg(test)]
 pub(crate) fn validate_public_udf_calls(sql: &str) -> Result<(), LixError> {
     let statements = Parser::parse_sql(&GenericDialect {}, sql).map_err(|error| {
         LixError::new(
@@ -59,7 +63,7 @@ fn validate_public_function_call(function: &Function) -> Result<(), LixError> {
         "lix_empty_blob" => expect_exact_arity(name, arity, 0),
         "lix_timestamp" => expect_exact_arity(name, arity, 0),
         "lix_uuid_v7" => expect_exact_arity(name, arity, 0),
-        "lix_active_version_commit_id" => expect_exact_arity(name, arity, 0),
+        "lix_active_branch_commit_id" => expect_exact_arity(name, arity, 0),
         "lix_text_encode" | "lix_text_decode" => {
             expect_arity_range(name, arity, 1, 2)?;
             validate_literal_utf8_encoding(name, &function.args)
@@ -68,6 +72,77 @@ fn validate_public_function_call(function: &Function) -> Result<(), LixError> {
     }
 }
 
+pub(crate) fn validate_public_udf_calls_in_datafusion_statement(
+    statement: &DataFusionStatement,
+) -> Result<(), LixError> {
+    let mut visitor = PublicUdfCallVisitor;
+    visit_datafusion_statement(statement, &mut visitor)
+}
+
+pub(crate) fn statement_has_durable_runtime_function(statement: &DataFusionStatement) -> bool {
+    let mut visitor = DurableRuntimeFunctionVisitor { found: false };
+    visit_datafusion_statement_for_durable_runtime_function(statement, &mut visitor);
+    visitor.found
+}
+
+struct DurableRuntimeFunctionVisitor {
+    found: bool,
+}
+
+impl Visitor for DurableRuntimeFunctionVisitor {
+    type Break = ();
+
+    fn pre_visit_expr(&mut self, expr: &Expr) -> ControlFlow<Self::Break> {
+        let Expr::Function(function) = expr else {
+            return ControlFlow::Continue(());
+        };
+
+        if matches!(
+            public_lix_function_name(function),
+            Some("lix_timestamp" | "lix_uuid_v7")
+        ) {
+            self.found = true;
+            return ControlFlow::Break(());
+        }
+
+        ControlFlow::Continue(())
+    }
+}
+
+fn visit_datafusion_statement(
+    statement: &DataFusionStatement,
+    visitor: &mut PublicUdfCallVisitor,
+) -> Result<(), LixError> {
+    match statement {
+        DataFusionStatement::Statement(statement) => match statement.visit(visitor) {
+            ControlFlow::Continue(()) => Ok(()),
+            ControlFlow::Break(error) => Err(*error),
+        },
+        DataFusionStatement::Explain(explain) => {
+            visit_datafusion_statement(explain.statement.as_ref(), visitor)
+        }
+        _ => Ok(()),
+    }
+}
+
+fn visit_datafusion_statement_for_durable_runtime_function(
+    statement: &DataFusionStatement,
+    visitor: &mut DurableRuntimeFunctionVisitor,
+) {
+    match statement {
+        DataFusionStatement::Statement(statement) => {
+            let _ = statement.visit(visitor);
+        }
+        DataFusionStatement::Explain(explain) => {
+            visit_datafusion_statement_for_durable_runtime_function(
+                explain.statement.as_ref(),
+                visitor,
+            );
+        }
+        _ => {}
+    }
+}
+
 fn public_lix_function_name(function: &Function) -> Option<&'static str> {
     let part = function.name.0.last()?;
     let ident = match part {
@@ -79,7 +154,7 @@ fn public_lix_function_name(function: &Function) -> Option<&'static str> {
         "lix_empty_blob" => Some("lix_empty_blob"),
         "lix_timestamp" => Some("lix_timestamp"),
         "lix_uuid_v7" => Some("lix_uuid_v7"),
-        "lix_active_version_commit_id" => Some("lix_active_version_commit_id"),
+        "lix_active_branch_commit_id" => Some("lix_active_branch_commit_id"),
         "lix_text_encode" => Some("lix_text_encode"),
         "lix_text_decode" => Some("lix_text_decode"),
         _ => None,
@@ -181,7 +256,14 @@ fn invalid_param(message: impl Into<String>) -> LixError {
 
 #[cfg(test)]
 mod tests {
-    use super::validate_public_udf_calls;
+    use datafusion::sql::parser::Statement as DataFusionStatement;
+
+    use super::{statement_has_durable_runtime_function, validate_public_udf_calls};
+
+    fn parse_statement(sql: &str) -> DataFusionStatement {
+        crate::sql2::parse_statement(sql)
+            .unwrap_or_else(|error| panic!("failed to parse '{sql}': {error}"))
+    }
 
     #[test]
     fn rejects_lix_udf_wrong_arity_as_public_invalid_param() {
@@ -208,4 +290,17 @@ mod tests {
         )
         .expect("valid calls should pass public validation");
     }
+
+    #[test]
+    fn marks_durable_runtime_functions() {
+        assert!(statement_has_durable_runtime_function(&parse_statement(
+            "SELECT lix_uuid_v7()"
+        )));
+        assert!(statement_has_durable_runtime_function(&parse_statement(
+            "SELECT lix_timestamp()"
+        )));
+        assert!(!statement_has_durable_runtime_function(&parse_statement(
+            "SELECT lix_json('{\"x\":1}')"
+        )));
+    }
 }

package/dist-engine-src/src/sql2/bind/read.rs

@@ -0,0 +1,65 @@
+use datafusion::sql::parser::Statement as DataFusionStatement;
+use datafusion::sql::sqlparser::ast::Query;
+
+use crate::LixError;
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub(crate) struct BoundRead {
+    pub(crate) query: Box<Query>,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(crate) enum BoundStatementRoute {
+    Read,
+    Write,
+}
+
+pub(crate) fn bind_statement_route(
+    statement: &DataFusionStatement,
+) -> Result<BoundStatementRoute, LixError> {
+    match super::classify::classify_datafusion_statement(statement) {
+        super::classify::SqlStatementKind::Read => Ok(BoundStatementRoute::Read),
+        super::classify::SqlStatementKind::Write => Ok(BoundStatementRoute::Write),
+        super::classify::SqlStatementKind::Other => Err(LixError::new(
+            LixError::CODE_UNSUPPORTED_SQL,
+            "SQL statement is not supported by Lix SQL",
+        )),
+    }
+}
+
+pub(crate) fn bind_read_statement(
+    sql: &str,
+    statement: &DataFusionStatement,
+) -> Result<(), LixError> {
+    validate_public_read_sql_surface(sql)?;
+    if super::classify::classify_datafusion_statement(statement)
+        == super::classify::SqlStatementKind::Write
+    {
+        return Err(LixError::new(
+            LixError::CODE_UNSUPPORTED_SQL,
+            "SQL writes must use the bound write planning path",
+        ));
+    }
+    super::classify::validate_supported_datafusion_statement_ast(statement)?;
+    super::public_udf::validate_public_udf_calls_in_datafusion_statement(statement)?;
+    Ok(())
+}
+
+fn validate_public_read_sql_surface(sql: &str) -> Result<(), LixError> {
+    let normalized = sql.to_ascii_lowercase();
+    if normalized.contains("lower(path)") {
+        return Err(LixError::new(
+            LixError::CODE_UNSUPPORTED_SQL,
+            "public column 'path' must be compared directly to a literal or parameter",
+        ));
+    }
+    if normalized.contains("lixcol_branch_id")
+        && (normalized.contains("= lower(") || normalized.contains(" in (lower("))
+    {
+        return Err(LixError::new(
+            LixError::CODE_UNSUPPORTED_SQL,
+            "public column 'lixcol_branch_id' must be compared directly to a literal or parameter",
+        ));
+    }
+    Ok(())
+}