Merge wip/engine-free-functions: convert SQL function bodies without DuckDB's engine

Author: kvlonge

crates/sqlquack-convert/Cargo.toml

@@ -17,10 +17,8 @@ sqlquack-duckdb.workspace = true
 sqlquack-policy.workspace = true
 sqlquack-rules.workspace = true
 sqlquack-semantics.workspace = true
-sqlquack-syntax.workspace = true
-
-[dev-dependencies]
 sqlquack-snowflake.workspace = true
+sqlquack-syntax.workspace = true
 
 [lints]
 workspace = true

…t/src/analysis/main/declared_refusals.rs …c/analysis/_helpers/declared_refusals.rscrates/sqlquack-convert/src/analysis/main/declared_refusals.rs renamed to crates/sqlquack-convert/src/analysis/_helpers/declared_refusals.rs crates/sqlquack-convert/src/analysis/main/declared_refusals.rs renamed to crates/sqlquack-convert/src/analysis/_helpers/declared_refusals.rs

@@ -9,7 +9,7 @@ use sqlquack_core::refusals::types::ConstructPolicy;
 use sqlquack_syntax::Expression;
 
 /// The constructs the policy declares inexpressible, then the nodes of `source` Snowflake rejects.
-pub fn declared_refusals(
+pub(crate) fn declared_refusals(
     statement: &Expression,
     occurrences: &[Occurrence],
     policy: &dyn ConstructPolicy,

crates/sqlquack-convert/src/analysis/_helpers/mod.rs

@@ -1,4 +1,5 @@
 //! Helpers for the conversion pipeline.
 
+pub(crate) mod declared_refusals;
 pub(crate) mod override_calls;
 pub(crate) mod volatile_calls;

crates/sqlquack-convert/src/analysis/constants.rs

@@ -2,3 +2,6 @@
 
 /// The parsed tree's keys for a named call, scalar or aggregate.
 pub const CALL_NODE_KINDS: &[&str] = &["function", "aggregate_function"];
+
+/// The column a scalar SQL function body is converted as.
+pub const SCALAR_RESULT_COLUMN: &str = "RESULT";

crates/sqlquack-convert/src/analysis/main/analyze.rs

@@ -17,9 +17,9 @@ use sqlquack_rules::conversion::main::within_budget::within_budget;
 use sqlquack_rules::conversion::models::{ConversionOptions, Converted};
 use sqlquack_semantics::types::models::Schema;
 
+use crate::analysis::_helpers::declared_refusals::declared_refusals;
 use crate::analysis::_helpers::override_calls::overrides_applied;
 use crate::analysis::_helpers::volatile_calls::volatile_calls_kept;
-use crate::analysis::main::declared_refusals::declared_refusals;
 use crate::analysis::main::placed::placed;
 use crate::analysis::models::Analysis;
 

…ck/src/analysis/main/analyze_function.rs …rt/src/analysis/main/analyze_function.rscrates/sqlquack/src/analysis/main/analyze_function.rs renamed to crates/sqlquack-convert/src/analysis/main/analyze_function.rs crates/sqlquack/src/analysis/main/analyze_function.rs renamed to crates/sqlquack-convert/src/analysis/main/analyze_function.rs

@@ -13,9 +13,9 @@ use sqlquack_rules::conversion::models::{ConversionOptions, ConvertedFunction};
 use sqlquack_semantics::types::models::{FunctionReturns, FunctionSpec, Schema};
 use sqlquack_snowflake::typing::models::SnowflakeType;
 
+use crate::analysis::_helpers::declared_refusals::declared_refusals;
 use crate::analysis::constants::SCALAR_RESULT_COLUMN;
-use sqlquack_convert::analysis::main::declared_refusals::declared_refusals;
-use sqlquack_convert::analysis::main::placed::placed;
+use crate::analysis::main::placed::placed;
 
 /// Converts `body` as `spec` declares it; a NUMBER scalar's body must be of the declared type.
 pub fn analyze_function(

crates/sqlquack-convert/src/analysis/main/mod.rs

@@ -1,3 +1,3 @@
 pub mod analyze;
-pub mod declared_refusals;
+pub mod analyze_function;
 pub mod placed;

crates/sqlquack-convert/src/analysis/tests.rs

@@ -1,3 +1,5 @@
+#[path = "tests/test_analyze_function.rs"]
+mod test_analyze_function;
 #[path = "tests/test_override_calls.rs"]
 mod test_override_calls;
 #[path = "tests/test_types.rs"]

crates/sqlquack-convert/src/analysis/tests/test_analyze_function.rs

@@ -0,0 +1,79 @@
+use sqlquack_core::parsing::models::SourceDialect;
+use sqlquack_core::refusals::models::RefusalCategory;
+use sqlquack_rules::catalogue::main::builtin_catalogue::builtin_catalogue;
+use sqlquack_rules::conversion::models::ConversionOptions;
+use sqlquack_semantics::types::models::{
+    ColumnSpec, FunctionLanguage, FunctionReturns, FunctionSpec, FunctionTraits, Schema,
+};
+use sqlquack_snowflake::typing::models::SnowflakeType;
+
+use crate::analysis::main::analyze_function::analyze_function;
+use crate::analysis::tests::test_types::AnalyzeFunctionTestCase;
+
+#[test]
+fn given_a_sql_function_body_when_converted_without_the_engine_then_it_is_a_macro_body_or_refused()
+{
+    let amount = SnowflakeType::Number {
+        precision: 10,
+        scale: 2,
+    };
+    let spec = FunctionSpec {
+        language: FunctionLanguage::Sql,
+        arguments: vec![ColumnSpec::new("AMOUNT", amount)],
+        returns: FunctionReturns::Scalar(amount),
+        traits: FunctionTraits::default(),
+    };
+    let test_cases = [
+        AnalyzeFunctionTestCase {
+            description: "a NUMBER scalar body converts, its parameter cast to the declared type",
+            body: "CAST(amount * 2 AS NUMBER(10,2))",
+            expected_parameters: &["p1"],
+            expected_body_has: Some("SELECT CAST(p1 AS DECIMAL(10,2)) AS \"AMOUNT\""),
+            expected_refusals: &[],
+        },
+        AnalyzeFunctionTestCase {
+            description: "a body naming no parameter or column is refused as unresolved",
+            body: "missing + 1",
+            expected_parameters: &[],
+            expected_body_has: None,
+            expected_refusals: &[RefusalCategory::UnresolvedName],
+        },
+    ];
+    for test_case in test_cases {
+        let outcome = analyze_function(
+            (test_case.body, &spec),
+            SourceDialect::Snowflake,
+            &builtin_catalogue(),
+            (&Schema::default(), &ConversionOptions::default()),
+        );
+        let parameters = outcome
+            .as_ref()
+            .map(|converted| converted.parameters.clone())
+            .unwrap_or_default();
+        let body_has = test_case.expected_body_has.filter(|fragment| {
+            outcome
+                .as_ref()
+                .is_ok_and(|converted| converted.body.contains(fragment))
+        });
+        let refusals: Vec<RefusalCategory> = outcome
+            .err()
+            .unwrap_or_default()
+            .iter()
+            .map(|refusal| refusal.category)
+            .collect();
+        assert_eq!(
+            (parameters, body_has, refusals.as_slice()),
+            (
+                test_case
+                    .expected_parameters
+                    .iter()
+                    .map(|name| (*name).to_owned())
+                    .collect(),
+                test_case.expected_body_has,
+                test_case.expected_refusals
+            ),
+            "{}",
+            test_case.description
+        );
+    }
+}

crates/sqlquack-convert/src/analysis/tests/test_types.rs

@@ -4,3 +4,11 @@ pub(crate) struct OverrideCallsTestCase {
     pub(crate) emitted: &'static str,
     pub(crate) expected_refused: bool,
 }
+
+pub(crate) struct AnalyzeFunctionTestCase {
+    pub(crate) description: &'static str,
+    pub(crate) body: &'static str,
+    pub(crate) expected_parameters: &'static [&'static str],
+    pub(crate) expected_body_has: Option<&'static str>,
+    pub(crate) expected_refusals: &'static [sqlquack_core::refusals::models::RefusalCategory],
+}