perf: evaluate built-in rules over Polyglot query facts and drop sqlparser (#1143)

* feat(analysis): expose the mapped dialect normalization of analysis SQL

Rules need analysis's Snowflake variant normalization together with the
character map back to the authored SQL, so positions survive the rewrite.

* perf(rules): evaluate built-in model rules over Polyglot query facts

Built-in model and SQL-test rules re-parsed every model with sqlparser.
They now read compact facts from one Polyglot parse per stubbed query
shape: dependency calls are stubbed by occurrence, shapes are shared by
the rules workers when their stubbed SQL is byte-identical, and positions
map back to each model's own SQL.

Models sqlparser rejected but Polyglot parses are now evaluated;
SQBRDECLARATION101/102 quote the comparison's source text and follow its
source position. Unparseable SQL keeps the unevaluated result with
Polyglot's error.

* build: drop sqlparser from the workspace

The rules quote policy is a static dialect table, so no crate needs
sqlparser any more.

* fix(rules): honour dialect comment syntax when stubbing query shapes

The stub scanner only knew -- and /* */ comments, so a Snowflake // or a
Snowflake/BigQuery # comment could hold a phantom __ref call, or an
apostrophe in it could open a fake string that swallowed real calls.
Scan with the comment and quoting syntax the rules parser used per
dialect, and blank comments before normalization and parsing.

* fix(rules): match sqlparser literal, function-call, TOP and import-star facts

- SQBRDECLARATION101 compares each string literal's own source text with
  the authored SQL and covers double-quoted, triple-quoted, escape and
  Unicode strings again.
- SQBRTEST203 no longer treats a parameterized cast type such as
  DECIMAL(18, 2) as a function call.
- A T-SQL TOP (n), TOP n PERCENT or WITH TIES clause is not projection.
- Stars in dependency import CTEs are exempt from SQBRMODEL102 by CTE
  classification, not by having a recovered source position.

* fix(rules): anchor FROM-first stars on their FROM keyword

A DuckDB FROM-first query has an implicit star but no SELECT token, so
its star finding fell back to 1:1. Anchor that star on the FROM keyword.
A SELECT whose only located part is an unaliased subquery is now matched
to its own SELECT keyword through the subquery's opening parenthesis, so
its star keeps its source position too.

* fix(rules): treat CONVERT and TRY_CONVERT type arguments as types

SQBRTEST203 counted the leading parameterized type of a T-SQL
CONVERT(VARCHAR(10), x) or TRY_CONVERT(DECIMAL(18, 2), x) as a function
call, so an empty SQL Server mock or bare existence assertion was not
flagged. Skip that type argument, as sqlparser's conversion parse did;
function calls in the value argument still count.

* 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

Cargo.lock

@@ -110,7 +110,6 @@ sqlbuild-scopes = { path = "crates/sqlbuild-scopes" }
 sqlbuild-sqltext = { path = "crates/sqlbuild-sqltext" }
 sqlbuild-state = { path = "crates/sqlbuild-state" }
 stacker = "0.1"
-sqlparser = { version = "0.58", features = ["visitor"] }
 syn = { version = "2", features = ["full", "visit", "extra-traits"] }
 tempfile = "3"
 toml = "0.9"

Cargo.toml

@@ -175,6 +175,17 @@ pub(crate) fn normalize_analysis_sql(
     normalize(sql, dialect, &stubs, &placeholders).map(|mapped| mapped.sql)
 }
 
+pub(crate) fn normalize_dialect_sql_mapped(
+    sql: &str,
+    dialect: &str,
+) -> Result<(String, Vec<usize>), String> {
+    let input = MappedSql::new(sql);
+    if !dialect.eq_ignore_ascii_case("snowflake") {
+        return Ok((input.sql, input.offsets));
+    }
+    normalize_variant(input).map(|mapped| (mapped.sql, mapped.offsets))
+}
+
 pub(crate) fn normalize_dialect_sql(sql: &str, dialect: &str) -> Result<String, String> {
     if !dialect.eq_ignore_ascii_case("snowflake") {
         return Ok(sql.to_owned());

crates/sqlbuild-analysis/src/semantic_validation/_helpers/normalization.rs

@@ -6,6 +6,7 @@ pub mod new_analysis_pool;
 pub mod normalize;
 pub mod normalize_batch;
 pub mod normalize_dialect;
+pub mod normalize_mapped;
 use crate::semantic_validation::models::ProjectCatalog;
 
 use polyglot_sql::{

crates/sqlbuild-analysis/src/semantic_validation/main.rs

@@ -0,0 +1,7 @@
+use crate::semantic_validation::models::MappedNormalization;
+
+/// The dialect normalization analysis applies to `sql`, mapped back to its input characters.
+pub fn normalize_mapped(sql: &str, dialect: &str) -> Result<MappedNormalization, String> {
+    crate::semantic_validation::_helpers::normalization::normalize_dialect_sql_mapped(sql, dialect)
+        .map(|(sql, offsets)| MappedNormalization { sql, offsets })
+}

crates/sqlbuild-analysis/src/semantic_validation/main/normalize_mapped.rs

@@ -28,6 +28,13 @@ pub struct NormalizationInput {
     pub placeholders: HashMap<String, String>,
 }
 
+/// Normalized analysis SQL with, per normalized character, the input character it came from.
+#[derive(Debug)]
+pub struct MappedNormalization {
+    pub sql: String,
+    pub offsets: Vec<usize>,
+}
+
 #[derive(Debug)]
 pub struct PositionInput {
     pub authored: String,

crates/sqlbuild-analysis/src/semantic_validation/models.rs

@@ -24,7 +24,6 @@ sqlbuild-core.workspace = true
 sqlbuild-scopes.workspace = true
 sqlbuild-sqltext.workspace = true
 stacker.workspace = true
-sqlparser.workspace = true
 toml.workspace = true
 
 [build-dependencies]

crates/sqlbuild-rules/Cargo.toml

@@ -24,7 +24,6 @@ pub(crate) const ENFORCED_CONTRACT: &str = "enforced";
 pub(crate) const SELECT_STAR_MODEL_RULE_CODE: &str = "SQBRMODEL102";
 pub(crate) const BOOLEAN_TYPE: &str = "BOOLEAN";
 pub(crate) const DATE_TYPE: &str = "DATE";
-pub(crate) const NEGATION_OPERATOR: &str = "-";
 pub(crate) const DECLARATION_DOMAIN_COMPONENTS: usize = 3;
 pub(crate) const RULE_CODE_NUMBER_LENGTH: usize = 3;
 pub(crate) const EMPTY_FIXTURE_QUERY_TOKEN_COUNT: usize = 6;

crates/sqlbuild-rules/src/constants.rs

@@ -10,7 +10,7 @@ use crate::rules::main::{
     resolve_threshold_overrides, select, sql_test_coverage,
 };
 use crate::rules::models::{
-    ModelEvaluationRequest, ProjectEvaluationRequest, ResolvedThresholdOverride,
+    ModelEvaluationRequest, ProjectEvaluationRequest, QueryShapes, ResolvedThresholdOverride,
 };
 use fensu_policy::apply_suppressions;
 use fensu_policy::lifecycle::errors::LifecycleError;
@@ -188,6 +188,7 @@ fn evaluate_pending_models(
     pending_models: Vec<PendingModelRule<'_>>,
     context: ModelRuleBatchContext<'_>,
 ) -> Result<Vec<CompletedModelRule>, String> {
+    let shapes = QueryShapes::default();
     let evaluate_pending = |pending: PendingModelRule<'_>| CompletedModelRule {
         index: pending.index,
         identity: pending.identity,
@@ -203,6 +204,7 @@ fn evaluate_pending_models(
                 selected: context.selected,
                 request: context.request,
                 threshold_overrides: context.threshold_overrides,
+                shapes: &shapes,
             })
             .and_then(|faults| scoped_faults(context.selected, faults, RuleScope::evaluates_models))
         },

crates/sqlbuild-rules/src/engine/_helpers/evaluation.rs

@@ -8,6 +8,8 @@ mod evaluation;
 mod helpers;
 #[path = "tests/test_incremental_rules.rs"]
 mod incremental_rules;
+#[path = "tests/test_query_facts.rs"]
+mod query_facts;
 #[path = "tests/test_scope_facts.rs"]
 mod scope_facts;
 #[path = "tests/test_speculative_rows.rs"]