sqlbuild 0.102.2__tar.gz → 0.102.4__tar.gz

{sqlbuild-0.102.2 → sqlbuild-0.102.4}/Cargo.lock

@@ -529,7 +529,7 @@ checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba"
 
 [[package]]
 name = "sqlbuild-rules-native"
-version = "0.102.2"
+version = "0.102.4"
 dependencies = [
  "fensu-policy",
  "globset",

{sqlbuild-0.102.2 → sqlbuild-0.102.4}/PKG-INFO

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

{sqlbuild-0.102.2 → sqlbuild-0.102.4}/crates/sqlbuild-rules-native/Cargo.toml

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

{sqlbuild-0.102.2 → sqlbuild-0.102.4}/crates/sqlbuild-rules-native/src/engine/tests/test_evaluation.rs

@@ -359,6 +359,17 @@ fn given_enforced_contract_outputs_when_evaluating_explicit_type_rule_then_retur
             expected_fault_count: 0,
             expected_message_fragment: "",
         },
+        test_types::ExplicitOutputTypeTestCase {
+            description: "wildcard terminal maps explicit final CTE column aliases by name",
+            query_sql: "WITH final(order_id, amount) AS (SELECT CAST(raw_id AS INTEGER) AS raw_id, CAST(raw_amount AS DECIMAL(18, 2)) AS raw_amount FROM orders) SELECT * FROM final",
+            columns: json!([
+                {"name": "amount", "type": "DECIMAL(18, 2)", "type_proven": true},
+                {"name": "order_id", "type": "INTEGER", "type_proven": true}
+            ]),
+            contract: "enforced",
+            expected_fault_count: 0,
+            expected_message_fragment: "",
+        },
         test_types::ExplicitOutputTypeTestCase {
             description: "renamed and reordered terminal columns map through positional set branches",
             query_sql: "WITH final AS (SELECT CAST(amount AS DECIMAL(18, 2)) AS amount, CAST(order_id AS INTEGER) AS order_id FROM current_orders UNION ALL SELECT CAST(amount AS DECIMAL(18, 2)) AS amount, CAST(order_id AS INTEGER) AS order_id FROM archived_orders) SELECT order_id AS id, amount AS total FROM final",
@@ -370,6 +381,48 @@ fn given_enforced_contract_outputs_when_evaluating_explicit_type_rule_then_retur
             expected_fault_count: 0,
             expected_message_fragment: "",
         },
+        test_types::ExplicitOutputTypeTestCase {
+            description: "terminal subset ignores extra final CTE outputs",
+            query_sql: "WITH final AS (SELECT CAST(order_id AS INTEGER) AS order_id, ignored_count + 1, ignored_label, CAST(amount AS DECIMAL(18, 2)) AS amount FROM orders) SELECT order_id AS id, amount AS total FROM final",
+            columns: json!([
+                {"name": "id", "type": "INTEGER", "type_proven": true},
+                {"name": "total", "type": "DECIMAL(18, 2)", "type_proven": true}
+            ]),
+            contract: "enforced",
+            expected_fault_count: 0,
+            expected_message_fragment: "",
+        },
+        test_types::ExplicitOutputTypeTestCase {
+            description: "terminal subset reports the selected calculated final CTE output",
+            query_sql: "WITH final AS (SELECT CAST(order_id AS INTEGER) AS order_id, ignored_count, ignored_label, amount + 1 AS amount FROM orders) SELECT order_id AS id, amount AS total FROM final",
+            columns: json!([
+                {"name": "id", "type": "INTEGER", "type_proven": true},
+                {"name": "total", "type": "DECIMAL(18, 2)", "type_proven": true}
+            ]),
+            contract: "enforced",
+            expected_fault_count: 1,
+            expected_message_fragment: "output \"amount\" is calculated without an outer explicit cast",
+        },
+        test_types::ExplicitOutputTypeTestCase {
+            description: "terminal subset maps outputs introduced by right by-name branch",
+            query_sql: "WITH final AS (SELECT CAST(1 AS INTEGER) AS ignored UNION ALL BY NAME SELECT 2 + 1 AS amount) SELECT amount AS total FROM final",
+            columns: json!([
+                {"name": "total", "type": "INTEGER", "type_proven": true}
+            ]),
+            contract: "enforced",
+            expected_fault_count: 1,
+            expected_message_fragment: "output \"amount\" is calculated without an outer explicit cast",
+        },
+        test_types::ExplicitOutputTypeTestCase {
+            description: "terminal subset maps explicit final CTE column aliases",
+            query_sql: "WITH final(order_id, ignored) AS (SELECT 1 + 1 AS raw_id, 3 AS extra) SELECT order_id AS id FROM final",
+            columns: json!([
+                {"name": "id", "type": "INTEGER", "type_proven": true}
+            ]),
+            contract: "enforced",
+            expected_fault_count: 1,
+            expected_message_fragment: "output \"raw_id\" is calculated without an outer explicit cast",
+        },
     ];
     for test_case in test_cases {
         let project_dir = TempDir::new().map_err(|error| error.to_string())?;

{sqlbuild-0.102.2 → sqlbuild-0.102.4}/crates/sqlbuild-rules-native/src/rules/_helpers/explicit_output_types.rs

@@ -68,12 +68,7 @@ impl OutputRule<'_> {
                 right,
                 ..
             } => {
-                let operation_by_name = matches!(
-                    set_quantifier,
-                    SetQuantifier::ByName
-                        | SetQuantifier::AllByName
-                        | SetQuantifier::DistinctByName
-                );
+                let operation_by_name = set_quantifier_by_name(set_quantifier);
                 let branch_scope = OutputScope {
                     columns: scope.columns,
                     set_branch: true,
@@ -190,6 +185,12 @@ fn final_cte_output_boundary<'a>(
         return None;
     }
     let select = root_select(query)?;
+    let cte_column_aliases: Vec<String> = final_cte
+        .alias
+        .columns
+        .iter()
+        .map(|column| column.name.value.clone())
+        .collect();
     if select.projection.len() == 1
         && matches!(
             select.projection[0],
@@ -198,7 +199,11 @@ fn final_cte_output_boundary<'a>(
     {
         return Some((
             &final_cte.query,
-            columns_in_output_order(&final_cte.query.body, columns),
+            columns_in_output_order_with_missing(
+                &final_cte.query.body,
+                columns,
+                &cte_column_aliases,
+            ),
         ));
     }
     if select.projection.len() != columns.len() {
@@ -213,10 +218,42 @@ fn final_cte_output_boundary<'a>(
         boundary_column.name = source_name;
         boundary_columns.push(boundary_column);
     }
-    let ordered_columns = columns_in_output_order(&final_cte.query.body, &boundary_columns);
+    let ordered_columns = columns_in_output_order_with_missing(
+        &final_cte.query.body,
+        &boundary_columns,
+        &cte_column_aliases,
+    );
     Some((&final_cte.query, ordered_columns))
 }
 
+fn columns_in_output_order_with_missing(
+    set_expr: &SetExpr,
+    columns: &[Column],
+    cte_column_aliases: &[String],
+) -> Vec<Column> {
+    let Some(output_names) = set_expression_output_names_with_missing(set_expr) else {
+        return columns.to_vec();
+    };
+    output_names
+        .into_iter()
+        .enumerate()
+        .map(|(index, body_name)| {
+            let exposed_name = cte_column_aliases
+                .get(index)
+                .map(String::as_str)
+                .or(body_name.as_deref());
+            let mut column = exposed_name
+                .and_then(|name| column_named(columns, name))
+                .cloned()
+                .unwrap_or_default();
+            if let Some(body_name) = body_name {
+                column.name = body_name;
+            }
+            column
+        })
+        .collect()
+}
+
 fn columns_in_output_order(set_expr: &SetExpr, columns: &[Column]) -> Vec<Column> {
     let Some(output_names) = set_expression_output_names(set_expr) else {
         return columns.to_vec();
@@ -252,6 +289,49 @@ fn set_expression_output_names(set_expr: &SetExpr) -> Option<Vec<String>> {
     }
 }
 
+fn set_expression_output_names_with_missing(set_expr: &SetExpr) -> Option<Vec<Option<String>>> {
+    match set_expr {
+        SetExpr::Select(select) => Some(
+            select
+                .projection
+                .iter()
+                .map(projection_output_name)
+                .collect(),
+        ),
+        SetExpr::Query(query) => set_expression_output_names_with_missing(&query.body),
+        SetExpr::SetOperation {
+            left,
+            right,
+            set_quantifier,
+            ..
+        } => {
+            let mut names = set_expression_output_names_with_missing(left)?;
+            if set_quantifier_by_name(set_quantifier) {
+                for right_name in set_expression_output_names_with_missing(right)? {
+                    let already_present = right_name.as_ref().is_some_and(|right_name| {
+                        names
+                            .iter()
+                            .flatten()
+                            .any(|left_name| left_name.eq_ignore_ascii_case(right_name))
+                    });
+                    if !already_present {
+                        names.push(right_name);
+                    }
+                }
+            }
+            Some(names)
+        }
+        _ => None,
+    }
+}
+
+fn set_quantifier_by_name(set_quantifier: &SetQuantifier) -> bool {
+    matches!(
+        set_quantifier,
+        SetQuantifier::ByName | SetQuantifier::AllByName | SetQuantifier::DistinctByName
+    )
+}
+
 fn projection_output_name(item: &SelectItem) -> Option<String> {
     match item {
         SelectItem::ExprWithAlias { alias, .. } => Some(alias.value.clone()),

{sqlbuild-0.102.2 → sqlbuild-0.102.4}/crates/sqlbuild-rules-native/src/sql_lint/_helpers/formatter.rs

@@ -3,7 +3,9 @@ use std::str::FromStr;
 use polyglot_sql::tokens::Token;
 use polyglot_sql::{Dialect, DialectType, format_by_name};
 
-use crate::sql_lint::constants::LINT_API_VERSION;
+use crate::sql_lint::constants::{
+    CAST_TYPE_SEPARATOR_KEYWORD, CLOSE_PARENTHESIS, LINT_API_VERSION, OPEN_PARENTHESIS,
+};
 use crate::sql_lint::models::{FormatRequest, FormatResponse};
 
 const COMMENT_ATTACHMENT_FAILURE: &str =
@@ -109,6 +111,7 @@ fn format_once(neutral_sql: &str, context: &FormatOnceContext<'_>) -> Result<Str
         .map_err(|error| error.to_string())?
         .join(";\n");
     formatted = restore_string_literals(formatted, context)?;
+    formatted = restore_cast_type_spellings(formatted, context)?;
     if context.comments.is_empty() {
         return Ok(formatted);
     }
@@ -224,6 +227,75 @@ fn restore_string_literals(
     Ok(formatted)
 }
 
+fn restore_cast_type_spellings(
+    mut formatted: String,
+    context: &FormatOnceContext<'_>,
+) -> Result<String, String> {
+    let type_ranges = cast_type_token_ranges(context)?;
+    if type_ranges.is_empty() {
+        return Ok(formatted);
+    }
+    let formatted_tokens = context
+        .dialect
+        .tokenize(&formatted)
+        .map_err(|error| error.to_string())?;
+    if context.original_tokens.len() != formatted_tokens.len() {
+        return Err(UNSUPPORTED_SQL_FAILURE.to_string());
+    }
+    let mut type_indices: Vec<usize> = type_ranges
+        .into_iter()
+        .flat_map(|(start, end)| start..=end)
+        .collect();
+    type_indices.sort_unstable();
+    type_indices.dedup();
+    for index in type_indices.into_iter().rev() {
+        let original_token = &context.original_tokens[index];
+        let formatted_token = &formatted_tokens[index];
+        let original = char_slice(
+            context.original_sql,
+            original_token.span.start,
+            original_token.span.end,
+        )
+        .ok_or_else(|| UNSUPPORTED_SQL_FAILURE.to_string())?;
+        let start = char_to_byte(&formatted, formatted_token.span.start)?;
+        let end = char_to_byte(&formatted, formatted_token.span.end)?;
+        formatted.replace_range(start..end, &original);
+    }
+    Ok(formatted)
+}
+
+fn cast_type_token_ranges(context: &FormatOnceContext<'_>) -> Result<Vec<(usize, usize)>, String> {
+    let mut ranges: Vec<(usize, usize)> = Vec::new();
+    let mut cast_type_starts: Vec<Option<usize>> = Vec::new();
+    let mut previous: Option<String> = None;
+    for (index, token) in context.original_tokens.iter().enumerate() {
+        let text = char_slice(context.original_sql, token.span.start, token.span.end)
+            .ok_or_else(|| UNSUPPORTED_SQL_FAILURE.to_string())?;
+        let normalized = text.to_ascii_uppercase();
+        if normalized == OPEN_PARENTHESIS {
+            let opens_cast = previous
+                .as_deref()
+                .is_some_and(|value| matches!(value, "CAST" | "TRY_CAST"));
+            cast_type_starts.push(opens_cast.then_some(usize::MAX));
+        } else if normalized == CLOSE_PARENTHESIS {
+            if let Some(Some(type_start)) = cast_type_starts.pop()
+                && type_start != usize::MAX
+                && type_start < index
+            {
+                ranges.push((type_start, index - 1));
+            }
+        } else if normalized == CAST_TYPE_SEPARATOR_KEYWORD
+            && let Some(Some(type_start)) = cast_type_starts.last_mut()
+            && *type_start == usize::MAX
+        {
+            *type_start = index + 1;
+        }
+        previous = Some(normalized);
+    }
+    ranges.sort_unstable();
+    Ok(ranges)
+}
+
 fn char_slice(value: &str, start: usize, end: usize) -> Option<String> {
     (start <= end).then(|| value.chars().skip(start).take(end - start).collect())
 }

sqlbuild-0.102.4/crates/sqlbuild-rules-native/src/sql_lint/constants.rs

@@ -0,0 +1,4 @@
+pub(crate) const CAST_TYPE_SEPARATOR_KEYWORD: &str = "AS";
+pub(crate) const CLOSE_PARENTHESIS: &str = ")";
+pub(crate) const LINT_API_VERSION: u32 = 1;
+pub(crate) const OPEN_PARENTHESIS: &str = "(";

{sqlbuild-0.102.2 → sqlbuild-0.102.4}/crates/sqlbuild-rules-native/src/sql_lint/tests/test_sql_lint.rs

@@ -1807,6 +1807,36 @@ fn given_format_cases_when_formatting_then_output_matches() -> Result<(), String
             expected_sql: "SELECT\n  id\nFROM items\nORDER BY\n  category NULLS LAST,\n  created_at DESC NULLS FIRST",
             expected_changed: true,
         },
+        test_types::FormatTestCase {
+            description: "explicit cast type spellings remain authored",
+            sql: "select cast(label as TEXT) as label, cast(id as INTEGER) as id, cast(observed_at as TIMESTAMP_NTZ) as observed_at, cast(amount as NUMERIC(10, 2)) as amount from items",
+            expected_sql: "SELECT\n  CAST(label AS TEXT) AS label,\n  CAST(id AS INTEGER) AS id,\n  CAST(observed_at AS TIMESTAMP_NTZ) AS observed_at,\n  CAST(amount AS NUMERIC(10, 2)) AS amount\nFROM items",
+            expected_changed: true,
+        },
+        test_types::FormatTestCase {
+            description: "nested and try cast type spellings remain authored",
+            sql: "select cast(coalesce(try_cast(raw_id as INTEGER), 0) as NUMERIC(10, 2)) as amount, cast(tags as ARRAY<INTEGER>) as tags from items",
+            expected_sql: "SELECT\n  CAST(COALESCE(TRY_CAST(raw_id AS INTEGER), 0) AS NUMERIC(10, 2)) AS amount,\n  CAST(tags AS ARRAY<INTEGER>) AS tags\nFROM items",
+            expected_changed: true,
+        },
+        test_types::FormatTestCase {
+            description: "commented cast type remains idempotent",
+            sql: "select cast(amount as NUMERIC(/* precision */ 10, 2)) as amount from items",
+            expected_sql: "SELECT\n  CAST(amount AS NUMERIC( /* precision */10, 2)) AS amount\nFROM items",
+            expected_changed: true,
+        },
+        test_types::FormatTestCase {
+            description: "cast-free token expansion remains supported",
+            sql: "select id label from items",
+            expected_sql: "SELECT\n  id AS label\nFROM items",
+            expected_changed: true,
+        },
+        test_types::FormatTestCase {
+            description: "cast-free multiple statements remain supported",
+            sql: "select 1; select 2",
+            expected_sql: "SELECT\n  1;\nSELECT\n  2",
+            expected_changed: true,
+        },
         test_types::FormatTestCase {
             description: "trailing comment",
             sql: "select a from items; -- retained",

{sqlbuild-0.102.2 → sqlbuild-0.102.4}/pyproject.toml

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

sqlbuild-0.102.2/crates/sqlbuild-rules-native/src/sql_lint/constants.rs

@@ -1 +0,0 @@
-pub(crate) const LINT_API_VERSION: u32 = 1;