sqlbuild 0.133.4__tar.gz → 0.133.5__tar.gz

{sqlbuild-0.133.4 → sqlbuild-0.133.5}/Cargo.lock

@@ -617,7 +617,7 @@ checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba"
 
 [[package]]
 name = "sqlbuild-rules-native"
-version = "0.133.4"
+version = "0.133.5"
 dependencies = [
  "fensu-policy",
  "globset",

{sqlbuild-0.133.4 → sqlbuild-0.133.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlbuild
-Version: 0.133.4
+Version: 0.133.5
 Requires-Dist: duckdb>=1.3.2
 Requires-Dist: filelock>=3.20.3
 Requires-Dist: orjson>=3.10.0

{sqlbuild-0.133.4 → sqlbuild-0.133.5}/crates/sqlbuild-rules-native/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sqlbuild-rules-native"
-version = "0.133.4"
+version = "0.133.5"
 edition.workspace = true
 license.workspace = true
 publish.workspace = true

{sqlbuild-0.133.4 → sqlbuild-0.133.5}/crates/sqlbuild-rules-native/src/compiler/_helpers/sql_tests/mod.rs

@@ -1,7 +1,6 @@
 pub(crate) mod cte_rename;
 pub(crate) mod cte_slices;
 pub(crate) mod cte_sql;
-pub(crate) mod errors;
 pub(crate) mod expected_columns;
 pub(crate) mod extraction;
 pub(crate) mod helper_scope;

{sqlbuild-0.133.4 → sqlbuild-0.133.5}/crates/sqlbuild-rules-native/src/compiler/_helpers/sql_tests/planning.rs

@@ -13,7 +13,6 @@ use crate::compiler::_helpers::sql_tests::cte_slices::SliceDialect;
 use crate::compiler::_helpers::sql_tests::cte_sql::{
     cte_definition_sql, leading_with_prefix_end, with_leading_ctes, with_unique_ctes,
 };
-use crate::compiler::_helpers::sql_tests::errors::RelationMarkerError;
 use crate::compiler::_helpers::sql_tests::expected_columns::expected_columns;
 use crate::compiler::_helpers::sql_tests::helper_scope::{
     ScopeGraph, helper_scope_ctes, merged_scoped_ctes,
@@ -1305,13 +1304,9 @@ fn analysis_template(
                 return None;
             }
             let expression = statements.remove(0);
-            let marker_calls = match relation_marker_calls(&expression) {
-                Ok(marker_calls) => marker_calls,
-                Err(RelationMarkerError) => return None,
-            };
             Some(AnalysisTemplate {
                 existing_cte_names: top_level_cte_names(&expression),
-                marker_calls,
+                marker_calls: relation_marker_calls(&expression),
             })
         })
     })

sqlbuild-0.133.5/crates/sqlbuild-rules-native/src/compiler/_helpers/sql_tests/relation_markers.rs

@@ -0,0 +1,73 @@
+//! Relation marker calls in a serialized pre-order walk of a parsed statement's relations.
+
+use polyglot_sql::expressions::{From, Join};
+use polyglot_sql::{Expression, ExpressionWalk};
+
+use crate::compiler::_helpers::sql_tests::planning::DBT_REF_FUNCTION;
+
+pub(crate) type MarkerCall = (String, String);
+
+/// Return marker calls in node order, where Polyglot children follow declared field order.
+pub(crate) fn relation_marker_calls(expression: &Expression) -> Vec<MarkerCall> {
+    expression.dfs().flat_map(node_marker_calls).collect()
+}
+
+/// FROM then JOIN marker calls of one node, plus the serialized `on` that traversal skips.
+fn node_marker_calls(node: &Expression) -> Vec<MarkerCall> {
+    match node {
+        Expression::Select(select) => select
+            .from
+            .iter()
+            .flat_map(from_markers)
+            .chain(join_markers(&select.joins))
+            .collect(),
+        Expression::From(from) => from_markers(from).collect(),
+        Expression::Delete(delete) => join_markers(&delete.joins).collect(),
+        Expression::JoinedTable(table) => join_markers(&table.joins).collect(),
+        Expression::DataDeletionProperty(property) => relation_marker_calls(&property.on),
+        _ => Vec::new(),
+    }
+}
+
+fn from_markers(from: &From) -> impl Iterator<Item = MarkerCall> + '_ {
+    from.expressions.iter().filter_map(marker)
+}
+
+fn join_markers(joins: &[Join]) -> impl Iterator<Item = MarkerCall> + '_ {
+    joins.iter().filter_map(|join| marker(&join.this))
+}
+
+fn marker(expression: &Expression) -> Option<MarkerCall> {
+    match expression {
+        Expression::Alias(alias) => marker(&alias.this),
+        Expression::Function(function) => {
+            let names: Vec<Option<&str>> = function
+                .args
+                .iter()
+                .map(|argument| match argument {
+                    Expression::Column(column) => Some(column.name.name.as_str()),
+                    _ => None,
+                })
+                .collect();
+            function_marker(&function.name, &names)
+        }
+        _ => None,
+    }
+}
+
+fn function_marker(name: &str, args: &[Option<&str>]) -> Option<MarkerCall> {
+    let function_name = name.to_ascii_lowercase();
+    let referenced_name = if function_name == DBT_REF_FUNCTION {
+        match args {
+            [Some(first)] => (*first).to_string(),
+            [Some(first), Some(second)] => format!("{first}__{second}"),
+            _ => return None,
+        }
+    } else {
+        let [Some(first)] = args else {
+            return None;
+        };
+        (*first).to_string()
+    };
+    Some((function_name, referenced_name))
+}

{sqlbuild-0.133.4 → sqlbuild-0.133.5}/crates/sqlbuild-rules-native/src/compiler/tests/helpers.rs

@@ -1662,7 +1662,7 @@ fn generic_lexical_syntax() -> Value {
 
 type MarkerCalls = Option<Vec<(String, String)>>;
 
-/// The previous JSON-tree walk, kept as the oracle the streaming collector must match.
+/// The original JSON-tree walk, kept as the oracle the direct relation walk must match.
 fn json_relation_marker_calls(value: &Value) -> Vec<(String, String)> {
     let from_markers = value
         .get("from")
@@ -1728,7 +1728,7 @@ pub(crate) fn owned_marker_calls(calls: &[(&str, &str)]) -> MarkerCalls {
     )
 }
 
-/// Parse one statement and return the streaming collector's and the JSON oracle's marker calls.
+/// Parse one statement and return the direct walk's and the JSON oracle's marker calls.
 pub(crate) fn relation_markers_and_json_oracle(
     dialect: &str,
     sql: &str,
@@ -1740,7 +1740,7 @@ pub(crate) fn relation_markers_and_json_oracle(
     assert_eq!(statements.len(), 1, "{sql}");
     let expression = statements.remove(0);
     (
-        relation_marker_calls(&expression).ok(),
+        Some(relation_marker_calls(&expression)),
         serde_json::to_value(&expression)
             .ok()
             .map(|value| json_relation_marker_calls(&value)),
@@ -1764,6 +1764,12 @@ pub(crate) fn relation_marker_oracle_mismatches(dialect: &str) -> Vec<String> {
         "SELECT * FROM {a} WHERE EXISTS (SELECT 1 FROM {b})",
         "SELECT * FROM {a} UNION SELECT * FROM {b}",
         "SELECT * FROM {a}, {b}",
+        "SELECT * FROM ({a} JOIN {b} ON TRUE)",
+        "SELECT * FROM {a} AS x LEFT JOIN LATERAL (SELECT * FROM {b}) AS y ON TRUE",
+        "SELECT * FROM (SELECT * FROM {a}) AS x CROSS JOIN {b} WHERE x.id IN (SELECT id FROM {a})",
+        "UPDATE orders SET amount = 1 FROM {a} JOIN {b} ON TRUE",
+        "DELETE FROM orders USING {a} JOIN {b} ON TRUE",
+        "INSERT INTO orders SELECT * FROM {a} JOIN {b} ON TRUE",
     ];
     let parser = Dialect::get_by_name(dialect).expect("test dialect must exist");
     wrappers
@@ -1781,7 +1787,7 @@ pub(crate) fn relation_marker_oracle_mismatches(dialect: &str) -> Vec<String> {
                 .unwrap_or_default()
                 .iter()
                 .any(|expression| {
-                    relation_marker_calls(expression).ok()
+                    Some(relation_marker_calls(expression))
                         != serde_json::to_value(expression)
                             .ok()
                             .map(|value| json_relation_marker_calls(&value))

{sqlbuild-0.133.4 → sqlbuild-0.133.5}/crates/sqlbuild-rules-native/src/compiler/tests/test_sql_test_relation_markers.rs

@@ -99,6 +99,16 @@ fn given_generated_relation_shapes_when_collecting_markers_then_json_oracle_matc
             dialect: "bigquery",
             expected_mismatches: &[],
         },
+        RelationMarkerOracleTestCase {
+            description: "tsql relation shapes",
+            dialect: "tsql",
+            expected_mismatches: &[],
+        },
+        RelationMarkerOracleTestCase {
+            description: "databricks relation shapes",
+            dialect: "databricks",
+            expected_mismatches: &[],
+        },
     ];
     for test_case in test_cases {
         assert_eq!(

{sqlbuild-0.133.4 → sqlbuild-0.133.5}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "maturin"
 
 [project]
 name = "sqlbuild"
-version = "0.133.4"
+version = "0.133.5"
 description = "Typed, test-first SQL pipelines with local E2E testing"
 readme = "README.md"
 requires-python = ">=3.12"

sqlbuild-0.133.4/crates/sqlbuild-rules-native/src/compiler/_helpers/sql_tests/errors.rs

@@ -1,23 +0,0 @@
-//! Error types owned by SQL-test planning helpers.
-
-use std::fmt::Display;
-
-use serde::ser;
-
-/// A parsed statement that `serde_json::to_value` could not represent.
-#[derive(Debug)]
-pub(crate) struct RelationMarkerError;
-
-impl Display for RelationMarkerError {
-    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        formatter.write_str("value cannot be represented as JSON")
-    }
-}
-
-impl std::error::Error for RelationMarkerError {}
-
-impl ser::Error for RelationMarkerError {
-    fn custom<M: Display>(_message: M) -> Self {
-        RelationMarkerError
-    }
-}