fix(rules): match unanchored set-operation branches to their SELECT tokens

A set-operation branch whose items carry no Polyglot span, such as
SELECT CAST(1 AS INTEGER), CAST('games' AS VARCHAR) after an aliased
first branch, found no SELECT token region. Its SQBRCONTRACT105 cast
types then fell back to Polyglot's spelling and its findings to 1:1,
producing false contract findings. Such a select now takes the next
unclaimed SELECT region after the previous branch, since branches and
CTEs are read in source order.

Author: kvlonge

crates/sqlbuild-rules/src/engine/tests/test_query_facts.rs

@@ -94,6 +94,61 @@ fn given_dialect_sql_when_reading_query_facts_then_findings_match_the_authored_s
             columns: json!([]),
             expected_faults: &[("SQBRDECLARATION102", 1, 35, "3 < 7")],
         },
+        QueryFactsTestCase {
+            description: "unaliased later union branches keep their cast types",
+            dialect: "duckdb",
+            query_sql: "SELECT CAST(1 AS INTEGER) AS customer_id, CAST('books' AS VARCHAR) AS category, CAST(10.25 AS DECIMAL(12,2)) AS amount\nUNION ALL\nSELECT CAST(1 AS INTEGER), CAST('games' AS VARCHAR), CAST(20.50 AS DECIMAL(12,2))\nUNION ALL\nSELECT CAST(2 AS INTEGER), CAST('books' AS VARCHAR), CAST(7.00 AS DECIMAL(12,2))",
+            select: OUTPUT_TYPE_RULE,
+            enum_columns: &[],
+            columns: json!([{"name": "customer_id", "type": "INTEGER", "type_proven": true}, {"name": "category", "type": "VARCHAR", "type_proven": true}, {"name": "amount", "type": "DECIMAL(12,2)", "type_proven": true}]),
+            expected_faults: &[],
+        },
+        QueryFactsTestCase {
+            description: "an unaliased later union branch reports its own position",
+            dialect: "duckdb",
+            query_sql: "SELECT CAST(1 AS INTEGER) AS amount\nUNION ALL\nSELECT CAST(2 AS BIGINT)",
+            select: OUTPUT_TYPE_RULE,
+            enum_columns: &[],
+            columns: json!([{"name": "amount", "type": "INTEGER", "type_proven": true}]),
+            expected_faults: &[("SQBRCONTRACT105", 3, 13, "outer cast that does not target")],
+        },
+        QueryFactsTestCase {
+            description: "nested parenthesized set operations keep each branch position",
+            dialect: "duckdb",
+            query_sql: "(SELECT CAST(1 AS INTEGER) AS amount)\nUNION ALL\n((SELECT 2) EXCEPT (SELECT CAST(3 AS INTEGER)))",
+            select: OUTPUT_TYPE_RULE,
+            enum_columns: &[],
+            columns: json!([{"name": "amount", "type": "INTEGER", "type_proven": true}]),
+            expected_faults: &[(
+                "SQBRCONTRACT105",
+                3,
+                10,
+                "calculated without an outer explicit cast",
+            )],
+        },
+        QueryFactsTestCase {
+            description: "an unaliased branch after a subquery-filtered branch keeps its position",
+            dialect: "duckdb",
+            query_sql: "SELECT CAST(order_id AS INTEGER) AS amount FROM orders WHERE order_id IN (SELECT order_id FROM returns)\nUNION ALL BY NAME\nSELECT CAST(4 AS SMALLINT) AS amount",
+            select: OUTPUT_TYPE_RULE,
+            enum_columns: &[],
+            columns: json!([{"name": "amount", "type": "INTEGER", "type_proven": true}]),
+            expected_faults: &[("SQBRCONTRACT105", 3, 13, "outer cast that does not target")],
+        },
+        QueryFactsTestCase {
+            description: "unaliased union branches inside a final CTE keep their positions",
+            dialect: "duckdb",
+            query_sql: "WITH final AS (\n  SELECT CAST(1 AS INTEGER) AS amount\n  UNION ALL\n  SELECT 5 + 1\n)\nSELECT * FROM final",
+            select: OUTPUT_TYPE_RULE,
+            enum_columns: &[],
+            columns: json!([{"name": "amount", "type": "INTEGER", "type_proven": true}]),
+            expected_faults: &[(
+                "SQBRCONTRACT105",
+                4,
+                10,
+                "calculated without an outer explicit cast",
+            )],
+        },
         QueryFactsTestCase {
             description: "a BigQuery double-quoted string compared with an enum column",
             dialect: "bigquery",

crates/sqlbuild-rules/src/query_facts/_helpers/facts.rs

@@ -11,8 +11,8 @@ use polyglot_sql::dialects::Dialect;
 use polyglot_sql::expressions::{Identifier, Literal, Select, TableRef, With};
 use polyglot_sql::{ComplexityGuardOptions, Expression, ExpressionWalk, ParseOptions};
 use sqlbuild_analysis::lineage::main::parser_dialect::parser_dialect;
-use std::cell::RefCell;
-use std::collections::HashMap;
+use std::cell::{Cell, RefCell};
+use std::collections::{HashMap, HashSet};
 use std::ops::Range;
 
 fn parse_query(sql: &str, dialect_name: &str) -> Result<(Expression, Dialect), String> {
@@ -82,6 +82,8 @@ pub(crate) fn query_facts(sql: &str, dialect_name: &str) -> Result<QueryFacts, S
         tokens,
         dialect,
         spans: RefCell::default(),
+        cursor: Cell::default(),
+        claimed: RefCell::default(),
     };
     Ok(builder.query(&statement))
 }
@@ -104,6 +106,8 @@ struct Builder<'a> {
     selects: Vec<SelectTokens>,
     dialect: Dialect,
     spans: RefCell<HashMap<*const Expression, Option<ComparisonSpan>>>,
+    cursor: Cell<usize>,
+    claimed: RefCell<HashSet<usize>>,
 }
 
 struct ComparisonParts<'a> {
@@ -254,12 +258,25 @@ impl Builder<'_> {
         }
     }
 
+    /// The SELECT region around the select's first located part, else the next unclaimed one.
     fn select_tokens(&self, select: &Select) -> Option<&SelectTokens> {
-        let anchor = select_anchor(select, &self.tokens)?;
-        self.selects
-            .iter()
-            .filter(|tokens| tokens.start < anchor && anchor < tokens.end)
-            .max_by_key(|tokens| tokens.start)
+        let found = match select_anchor(select, &self.tokens) {
+            Some(anchor) => self
+                .selects
+                .iter()
+                .filter(|tokens| tokens.start < anchor && anchor < tokens.end)
+                .max_by_key(|tokens| tokens.start),
+            None => {
+                let after = self.cursor.get();
+                let claimed = self.claimed.borrow();
+                self.selects
+                    .iter()
+                    .find(|tokens| tokens.start >= after && !claimed.contains(&tokens.start))
+            }
+        }?;
+        self.claimed.borrow_mut().insert(found.start);
+        self.cursor.set(self.cursor.get().max(found.end));
+        Some(found)
     }
 
     fn item(