sqlbuild 0.100.6__tar.gz → 0.100.7__tar.gz

{sqlbuild-0.100.6 → sqlbuild-0.100.7}/Cargo.lock

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

{sqlbuild-0.100.6 → sqlbuild-0.100.7}/PKG-INFO

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

{sqlbuild-0.100.6 → sqlbuild-0.100.7}/crates/sqlbuild-rules-native/Cargo.toml

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

{sqlbuild-0.100.6 → sqlbuild-0.100.7}/crates/sqlbuild-rules-native/src/constants.rs

@@ -10,6 +10,7 @@ pub(crate) const GENERIC_CASE_NAME: &str = "case";
 pub(crate) const CUSTOM_RULE_NAMESPACE: &str = "XSQBR";
 pub(crate) const TARGET_DIRECTORY: &str = "target";
 pub(crate) const REFERENCE_KIND: &str = "ref";
+pub(crate) const SOURCE_REFERENCE_KIND: &str = "source";
 pub(crate) const VIEW_MATERIALIZATION: &str = "view";
 pub(crate) const ENFORCED_CONTRACT: &str = "enforced";
 pub(crate) const BOOLEAN_TYPE: &str = "BOOLEAN";

{sqlbuild-0.100.6 → sqlbuild-0.100.7}/crates/sqlbuild-rules-native/src/engine/_helpers/evaluation.rs

@@ -140,7 +140,6 @@ pub(crate) fn evaluate_json(request_json: &str) -> Result<String, String> {
                 config: &request.config,
                 selected: &selected_by_code,
                 request: &request,
-                is_anchor: model_index == 0,
                 threshold_overrides: &threshold_overrides,
             })?;
             if let Some(identity) = fingerprint {

{sqlbuild-0.100.6 → sqlbuild-0.100.7}/crates/sqlbuild-rules-native/src/engine/tests/test_domain_layout.rs

@@ -9,6 +9,9 @@ fn given_owner_and_declaration_layouts_when_evaluating_then_returns_expected_fau
     let oversized_paths: Vec<String> = (0..11)
         .map(|index| format!("models/commerce/_macros/item_{index}.py"))
         .collect();
+    let repeated_paths: Vec<String> = (0..11)
+        .map(|_| "models/commerce/_macros/orders.py".to_owned())
+        .collect();
     let test_cases = [
         test_types::DomainLayoutTestCase {
             description: "leaf and branch models fault",
@@ -117,6 +120,17 @@ fn given_owner_and_declaration_layouts_when_evaluating_then_returns_expected_fau
             expected_message_fragments: &[],
             expected_absent_fragments: &[],
         },
+        test_types::DomainLayoutTestCase {
+            description: "multiple exports in one declaration file count once",
+            code: "SQBRDECLARATION304",
+            models: json!([]),
+            thresholds: json!({}),
+            layout: json!({}),
+            scope_index: helpers::scope_with_macros(&repeated_paths),
+            expected_codes: &[],
+            expected_message_fragments: &[],
+            expected_absent_fragments: &[],
+        },
         test_types::DomainLayoutTestCase {
             description: "generic declaration bucket faults",
             code: "SQBRDECLARATION305",

{sqlbuild-0.100.6 → sqlbuild-0.100.7}/crates/sqlbuild-rules-native/src/engine/tests/test_evaluation.rs

@@ -79,6 +79,96 @@ fn given_scoped_suppression_when_evaluating_native_fault_then_returns_no_faults(
     Ok(())
 }
 
+#[test]
+fn given_declaration_only_project_when_evaluating_project_rule_then_rule_still_runs()
+-> Result<(), String> {
+    let test_cases = [test_types::NativeEvaluationTestCase {
+        description: "duplicate enum rule runs without a model anchor",
+        config: json!({
+            "select": ["SQBRDECLARATION201"],
+            "cache": {"enabled": false}
+        }),
+        expected_faults: json!(["SQBRDECLARATION201"]),
+    }];
+    for test_case in test_cases {
+        let project_dir = TempDir::new().map_err(|error| error.to_string())?;
+        let mut request: Value =
+            serde_json::from_str(&helpers::request(&project_dir, &test_case.config))
+                .map_err(|error| error.to_string())?;
+        request["models"] = json!([]);
+        request["public_enums"] = json!([
+            {
+                "name": "order_status",
+                "relative_path": "enums/orders/order_status.sql",
+                "members": [{"name": "OPEN", "value": "open"}]
+            },
+            {
+                "name": "support_status",
+                "relative_path": "enums/support/support_status.sql",
+                "members": [{"name": "OPEN", "value": "open"}]
+            }
+        ]);
+        let result: Value = serde_json::from_str(&evaluate_json(&request.to_string())?)
+            .map_err(|error| error.to_string())?;
+        let actual_codes = Value::Array(
+            result["faults"]
+                .as_array()
+                .into_iter()
+                .flatten()
+                .map(|fault| fault["code"].clone())
+                .collect(),
+        );
+        assert_eq!(
+            actual_codes, test_case.expected_faults,
+            "{}",
+            test_case.description
+        );
+    }
+    Ok(())
+}
+
+#[test]
+fn given_scoped_and_global_declarations_when_evaluating_domain_rule_then_only_global_is_checked()
+-> Result<(), String> {
+    let test_cases = [
+        test_types::DeclarationScopeTestCase {
+            description: "local test declaration is outside global domain policy",
+            scope: "local",
+            path: "tests/unit/orders/_sqlbuild/enums/status.sql",
+            expected_fault_count: 0,
+        },
+        test_types::DeclarationScopeTestCase {
+            description: "global declaration without domain remains in policy",
+            scope: "global",
+            path: "enums/status.sql",
+            expected_fault_count: 1,
+        },
+    ];
+    for test_case in test_cases {
+        let project_dir = TempDir::new().map_err(|error| error.to_string())?;
+        let config = json!({
+            "select": ["SQBRDECLARATION301"],
+            "domains": ["orders"],
+            "cache": {"enabled": false}
+        });
+        let mut request: Value = serde_json::from_str(&helpers::request(&project_dir, &config))
+            .map_err(|error| error.to_string())?;
+        request["models"] = json!([]);
+        request["scope_index"] = helpers::scope_index();
+        request["scope_index"]["declarations"][0]["scope"] = json!(test_case.scope);
+        request["scope_index"]["declarations"][0]["path"] = json!(test_case.path);
+        let result: Value = serde_json::from_str(&evaluate_json(&request.to_string())?)
+            .map_err(|error| error.to_string())?;
+        assert_eq!(
+            result["faults"].as_array().map_or(0, Vec::len),
+            test_case.expected_fault_count,
+            "{}",
+            test_case.description
+        );
+    }
+    Ok(())
+}
+
 #[test]
 fn given_snowflake_expression_when_evaluating_rules_then_uses_project_dialect() -> Result<(), String>
 {

{sqlbuild-0.100.6 → sqlbuild-0.100.7}/crates/sqlbuild-rules-native/src/engine/tests/test_types.rs

@@ -6,6 +6,13 @@ pub(crate) struct NativeEvaluationTestCase {
     pub(crate) expected_faults: Value,
 }
 
+pub(crate) struct DeclarationScopeTestCase {
+    pub(crate) description: &'static str,
+    pub(crate) scope: &'static str,
+    pub(crate) path: &'static str,
+    pub(crate) expected_fault_count: usize,
+}
+
 pub(crate) struct DialectEvaluationTestCase {
     pub(crate) description: &'static str,
     pub(crate) dialect: &'static str,

{sqlbuild-0.100.6 → sqlbuild-0.100.7}/crates/sqlbuild-rules-native/src/rules/_helpers/domain_layout.rs

@@ -428,12 +428,19 @@ fn inspect_container(
     entries: &[ContainerEntry],
 ) -> Vec<Fault> {
     let mut faults: Vec<Fault> = Vec::new();
-    let direct: Vec<&ContainerEntry> = entries
+    let mut seen_paths: BTreeSet<&str> = BTreeSet::new();
+    let files: Vec<&ContainerEntry> = entries
         .iter()
+        .filter(|entry| seen_paths.insert(entry.path.as_str()))
+        .collect();
+    let direct: Vec<&ContainerEntry> = files
+        .iter()
+        .copied()
         .filter(|entry| entry.buckets.is_empty())
         .collect();
-    let grouped: Vec<&ContainerEntry> = entries
+    let grouped: Vec<&ContainerEntry> = files
         .iter()
+        .copied()
         .filter(|entry| !entry.buckets.is_empty())
         .collect();
     if let Some(rule) = inspection.evaluation.selected.get("SQBRDECLARATION302")
@@ -452,8 +459,9 @@ fn inspect_container(
         ));
     }
     if let Some(rule) = inspection.evaluation.selected.get("SQBRDECLARATION303") {
-        for entry in entries
+        for entry in files
             .iter()
+            .copied()
             .filter(|entry| entry.buckets.len() as u32 > inspection.max_depth)
         {
             faults.push(path_fault(
@@ -474,7 +482,7 @@ fn inspect_container(
     }
     if let Some(rule) = inspection.evaluation.selected.get("SQBRDECLARATION305") {
         let mut reported: BTreeSet<(String, String)> = BTreeSet::new();
-        for entry in entries {
+        for entry in files.iter().copied() {
             for bucket in &entry.buckets {
                 if (GENERIC_BUCKET_NAMES.contains(&bucket.as_str())
                     || RESERVED_BUCKET_NAMES.contains(&bucket.as_str()))
@@ -492,7 +500,7 @@ fn inspect_container(
     }
     if let Some(rule) = inspection.evaluation.selected.get("SQBRDECLARATION304") {
         let mut buckets: BTreeMap<String, Vec<&ContainerEntry>> = BTreeMap::new();
-        for entry in entries {
+        for entry in files.iter().copied() {
             let key = entry.buckets.first().cloned().unwrap_or_default();
             buckets.entry(key).or_default().push(entry);
         }
@@ -520,7 +528,7 @@ fn inspect_container(
         && let Some(rule) = inspection.evaluation.selected.get("SQBRDECLARATION306")
     {
         let mut locations: BTreeMap<String, Vec<(String, String)>> = BTreeMap::new();
-        for entry in entries {
+        for entry in files.iter().copied() {
             let location = entry.buckets.join("/");
             locations
                 .entry(location)

{sqlbuild-0.100.6 → sqlbuild-0.100.7}/crates/sqlbuild-rules-native/src/rules/_helpers/evaluation.rs

@@ -1,9 +1,11 @@
 use crate::constants::{
     BOOLEAN_TYPE, DATE_TYPE, DECLARATION_DOMAIN_COMPONENTS, ENFORCED_CONTRACT, NEGATION_OPERATOR,
-    REFERENCE_KIND, TIMESTAMP_TYPE, VIEW_MATERIALIZATION,
+    REFERENCE_KIND, SOURCE_REFERENCE_KIND, TIMESTAMP_TYPE, VIEW_MATERIALIZATION,
 };
 use crate::models::{Declaration, EvaluateRequest, Fault, Model, RuleMetadata, RulesConfig};
-use crate::rules::models::{FaultCollector, ModelEvaluationRequest, ResolvedThresholdOverride};
+use crate::rules::models::{
+    FaultCollector, ModelEvaluationRequest, ProjectEvaluationRequest, ResolvedThresholdOverride,
+};
 use globset::{Glob, GlobSetBuilder};
 use sqlparser::ast::{
     BinaryOperator, Expr, GroupByExpr, JoinConstraint, JoinOperator, Query, Select, SelectItem,
@@ -105,22 +107,10 @@ fn evaluate_model_inner(request: ModelEvaluationRequest<'_>) -> Result<Vec<Fault
         config,
         selected,
         request,
-        is_anchor,
         threshold_overrides,
     } = request;
     let metadata = |code: &str| selected.get(code).copied();
     let faults = FaultCollector::default();
-    if is_anchor {
-        if let Some(rule) = metadata("SQBRDECLARATION201") {
-            duplicate_enums(request, rule, &faults);
-        }
-        if let Some(rule) = metadata("SQBRDECLARATION301") {
-            declaration_domain_placement(request, config, rule, &faults);
-        }
-        if let Some(rule) = metadata("SQBRTEST301") {
-            custom_rule_test_coverage(request, config, (selected, rule), &faults);
-        }
-    }
     if !requires_parsed_model(selected) {
         return Ok(faults.into_inner());
     }
@@ -190,6 +180,25 @@ fn evaluate_model_inner(request: ModelEvaluationRequest<'_>) -> Result<Vec<Fault
     Ok(faults.into_inner())
 }
 
+pub(crate) fn evaluate_project_rules(request: &ProjectEvaluationRequest<'_>) -> Vec<Fault> {
+    let faults = FaultCollector::default();
+    if let Some(rule) = request.selected.get("SQBRDECLARATION201") {
+        duplicate_enums(request.request, rule, &faults);
+    }
+    if let Some(rule) = request.selected.get("SQBRDECLARATION301") {
+        declaration_domain_placement(request.request, &request.request.config, rule, &faults);
+    }
+    if let Some(rule) = request.selected.get("SQBRTEST301") {
+        custom_rule_test_coverage(
+            request.request,
+            &request.request.config,
+            (request.selected, rule),
+            &faults,
+        );
+    }
+    faults.into_inner()
+}
+
 fn requires_parsed_model(selected: &BTreeMap<String, &RuleMetadata>) -> bool {
     selected.values().any(|rule| {
         !rule.custom
@@ -1164,7 +1173,7 @@ fn source_token_rule(
             .model
             .references
             .iter()
-            .filter(|reference| reference.ref_kind != REFERENCE_KIND)
+            .filter(|reference| reference.ref_kind == SOURCE_REFERENCE_KIND)
             .map(|reference| reference.ref_name.clone()),
     );
     let mut retired_token: Option<(&String, &String)> = None;
@@ -1439,12 +1448,36 @@ fn declaration_domain_placement(
     rule: &RuleMetadata,
     faults: &FaultCollector,
 ) {
-    for declaration in request
-        .public_enums
-        .iter()
-        .chain(request.public_constants.iter())
-    {
-        let parts: Vec<_> = declaration.relative_path.split('/').collect();
+    let declarations: Vec<(&str, &str)> = if request.scope_index.completeness.placement {
+        request
+            .scope_index
+            .declarations
+            .iter()
+            .filter(|declaration| {
+                matches!(declaration.scope, crate::models::ScopeKind::Global)
+                    && matches!(
+                        declaration.kind,
+                        crate::models::DeclarationKind::Enum
+                            | crate::models::DeclarationKind::Constant
+                    )
+            })
+            .map(|declaration| (declaration.name.as_str(), declaration.path.as_str()))
+            .collect()
+    } else {
+        request
+            .public_enums
+            .iter()
+            .chain(request.public_constants.iter())
+            .map(|declaration| {
+                (
+                    declaration.name.as_str(),
+                    declaration.relative_path.as_str(),
+                )
+            })
+            .collect()
+    };
+    for (name, path) in declarations {
+        let parts: Vec<_> = path.split('/').collect();
         let domain = (parts.len() >= DECLARATION_DOMAIN_COMPONENTS).then(|| parts[1]);
         if domain.is_some_and(|value| {
             config.domains.is_empty() || config.domains.contains(&value.into())
@@ -1458,11 +1491,11 @@ fn declaration_domain_placement(
         };
         let root = parts.first().copied().unwrap_or("declarations");
         faults.push(path_fault(
-            &declaration.relative_path,
+            path,
             rule,
             format!(
                 "public declaration {:?} has no configured domain folder",
-                declaration.name
+                name
             ),
             format!("Move this declaration under {root}/{expected}/ at this file path."),
         ));

{sqlbuild-0.100.6 → sqlbuild-0.100.7}/crates/sqlbuild-rules-native/src/rules/main/evaluate_project.rs

@@ -5,6 +5,9 @@ pub(crate) fn evaluate_project(
     request: ProjectEvaluationRequest<'_>,
 ) -> Result<Vec<Fault>, String> {
     let mut faults = crate::rules::_helpers::domain_layout::evaluate_project(&request);
+    faults.extend(crate::rules::_helpers::evaluation::evaluate_project_rules(
+        &request,
+    ));
     faults.extend(crate::rules::_helpers::sql_test_rules::evaluate_project(
         request,
     )?);

{sqlbuild-0.100.6 → sqlbuild-0.100.7}/crates/sqlbuild-rules-native/src/rules/models.rs

@@ -15,7 +15,6 @@ pub(crate) struct ModelEvaluationRequest<'a> {
     pub(crate) config: &'a RulesConfig,
     pub(crate) selected: &'a BTreeMap<String, &'a RuleMetadata>,
     pub(crate) request: &'a EvaluateRequest,
-    pub(crate) is_anchor: bool,
     pub(crate) threshold_overrides: &'a [ResolvedThresholdOverride],
 }
 

{sqlbuild-0.100.6 → sqlbuild-0.100.7}/crates/sqlbuild-rules-native/src/sql_lint/_helpers/additional.rs

@@ -242,6 +242,7 @@ fn collect_select_additional_facts(
         if !is_exists_subquery(tokens, select_index)
             && !is_set_continuation_select(tokens, select_index)
             && !is_scalar_subquery(tokens, depths, select_index)
+            && !has_enclosing_cte_column_list(tokens, depths, select_index)
             && !is_ceremonial_select(tokens, &direct[..from_position], allows_ceremonial_select)
         {
             facts
@@ -321,6 +322,24 @@ fn collect_select_additional_facts(
     facts
 }
 
+fn has_enclosing_cte_column_list(tokens: &[Token], depths: &[usize], select_index: usize) -> bool {
+    let select_depth = depths[select_index];
+    let Some(body_open) = (0..select_index).rev().find(|&index| {
+        tokens[index].token_type == TokenType::LParen
+            && depths[index].saturating_add(1) == select_depth
+    }) else {
+        return false;
+    };
+    let Some(as_index) = significant_before(tokens, body_open) else {
+        return false;
+    };
+    if tokens[as_index].token_type != TokenType::As {
+        return false;
+    }
+    significant_before(tokens, as_index)
+        .is_some_and(|index| tokens[index].token_type == TokenType::RParen)
+}
+
 fn collect_reference_facts(context: &ReferenceFactContext<'_>) -> AdditionalQueryFacts {
     let query = context.query;
     let QuerySlice {
@@ -383,11 +402,14 @@ fn collect_reference_facts(context: &ReferenceFactContext<'_>) -> AdditionalQuer
             .filter(|&&index| !known.contains(&tokens[index].text.to_ascii_lowercase()))
             .map(|&index| tokens[index].span),
     );
-    facts.unused_joined_relations.extend(unused_join_spans(
-        query,
-        context.query_start,
-        context.query_end,
-    ));
+    let projects_bare_star = has_bare_projected_star(tokens, &direct[..from_position]);
+    if !projects_bare_star {
+        facts.unused_joined_relations.extend(unused_join_spans(
+            query,
+            context.query_start,
+            context.query_end,
+        ));
+    }
     facts
 }
 
@@ -563,6 +585,22 @@ fn projected_star_spans(tokens: &[Token], projection: &[usize]) -> Vec<Span> {
     spans
 }
 
+fn has_bare_projected_star(tokens: &[Token], projection: &[usize]) -> bool {
+    projection.iter().enumerate().any(|(position, &index)| {
+        if tokens[index].token_type != TokenType::Star {
+            return false;
+        }
+        let mut item_start = 0_usize;
+        for prior_position in (0..position).rev() {
+            if tokens[projection[prior_position]].token_type == TokenType::Comma {
+                item_start = prior_position + 1;
+                break;
+            }
+        }
+        is_bare_star_prefix(tokens, &projection[item_start..position])
+    })
+}
+
 fn is_exists_subquery(tokens: &[Token], select_index: usize) -> bool {
     let Some(open_index) = significant_before(tokens, select_index) else {
         return false;
@@ -739,6 +777,9 @@ fn unused_join_spans(query: &QuerySlice<'_>, query_start: usize, query_end: usiz
         .chain(relation_end_index..query_end)
         .filter(|&index| !is_layout(&tokens[index]) && !is_comment(&tokens[index]))
         .collect();
+    if contains_possible_unqualified_reference(tokens, &references) {
+        return Vec::new();
+    }
     let mut spans: Vec<Span> = Vec::new();
     for position in from_position + 1..relation_end {
         let index = direct[position];
@@ -777,6 +818,31 @@ fn unused_join_spans(query: &QuerySlice<'_>, query_start: usize, query_end: usiz
     spans
 }
 
+fn contains_possible_unqualified_reference(tokens: &[Token], references: &[usize]) -> bool {
+    references.iter().enumerate().any(|(position, &index)| {
+        if !is_identifier(&tokens[index])
+            || is_generated_identifier(&tokens[index])
+            || is_context_value(&tokens[index])
+        {
+            return false;
+        }
+        let previous = if position == 0 {
+            None
+        } else {
+            Some(references[position - 1])
+        };
+        let next = references.get(position + 1).copied();
+        previous.is_none_or(|candidate| {
+            !matches!(tokens[candidate].token_type, TokenType::Dot | TokenType::As)
+        }) && next.is_none_or(|candidate| {
+            !matches!(
+                tokens[candidate].token_type,
+                TokenType::Dot | TokenType::LParen
+            )
+        })
+    })
+}
+
 fn contains_qualified_reference(tokens: &[Token], references: &[usize], alias: &str) -> bool {
     references.windows(2).any(|window| {
         tokens[window[0]].text.eq_ignore_ascii_case(alias)

{sqlbuild-0.100.6 → sqlbuild-0.100.7}/crates/sqlbuild-rules-native/src/sql_lint/_helpers/engine.rs

@@ -14,6 +14,7 @@ use crate::sql_lint::models::{
 };
 
 use crate::sql_lint::_helpers::additional::collect_additional_facts;
+use crate::sql_lint::_helpers::terminal_shape::collect_terminal_shape_facts;
 
 const NULL_COMPARISON: LintRuleMetadata = LintRuleMetadata {
     code: "SQBRSQL001",
@@ -416,7 +417,8 @@ fn build_facts(
     sql: &str,
     options: &FactBuildOptions<'_>,
 ) -> QueryFacts {
-    let mut facts: QueryFacts = collect_token_query_facts(tokens, sql);
+    let mut facts: QueryFacts =
+        collect_token_query_facts(tokens, sql, options.allows_ceremonial_select);
     facts.null_comparisons = null_comparison_spans(tokens);
     facts.additional = collect_additional_facts(
         tokens,
@@ -431,10 +433,13 @@ fn build_facts(
     facts
 }
 
-fn collect_token_query_facts(tokens: &[Token], sql: &str) -> QueryFacts {
-    let mut facts = QueryFacts::default();
+fn collect_token_query_facts(
+    tokens: &[Token],
+    sql: &str,
+    allows_ceremonial_select: bool,
+) -> QueryFacts {
     let depths = token_depths(tokens);
-    facts = collect_rule_migration_facts(tokens, &depths, sql, facts);
+    let mut facts = collect_rule_migration_facts(tokens, &depths, sql, allows_ceremonial_select);
     for (select_index, token) in tokens.iter().enumerate() {
         if token.token_type != TokenType::Select {
             continue;
@@ -471,8 +476,9 @@ fn collect_rule_migration_facts(
     tokens: &[Token],
     depths: &[usize],
     sql: &str,
-    mut facts: QueryFacts,
+    allows_ceremonial_select: bool,
 ) -> QueryFacts {
+    let mut facts = QueryFacts::default();
     let significant: Vec<usize> = (0..tokens.len())
         .filter(|&index| !is_layout(&tokens[index]) && !is_comment(&tokens[index]))
         .collect();
@@ -500,7 +506,7 @@ fn collect_rule_migration_facts(
     }
 
     let (cte_only_bodies, terminal_selects) =
-        collect_terminal_shape_facts(tokens, depths, &significant);
+        collect_terminal_shape_facts(tokens, depths, &significant, allows_ceremonial_select);
     facts.cte_only_bodies.extend(cte_only_bodies);
     facts.terminal_selects.extend(terminal_selects);
     facts
@@ -509,99 +515,6 @@ fn collect_rule_migration_facts(
     facts
 }
 
-fn collect_terminal_shape_facts(
-    tokens: &[Token],
-    depths: &[usize],
-    significant: &[usize],
-) -> (Vec<Span>, Vec<Span>) {
-    let mut cte_only_bodies: Vec<Span> = Vec::new();
-    let mut terminal_selects: Vec<Span> = Vec::new();
-    let Some(root_select_position) = significant
-        .iter()
-        .rposition(|&index| depths[index] == 0 && tokens[index].token_type == TokenType::Select)
-    else {
-        return (cte_only_bodies, terminal_selects);
-    };
-    let root_select = significant[root_select_position];
-    let has_top_level_with = significant[..root_select_position]
-        .iter()
-        .any(|&index| depths[index] == 0 && tokens[index].text.eq_ignore_ascii_case("with"));
-    let tail: Vec<usize> = significant[root_select_position + 1..]
-        .iter()
-        .copied()
-        .take_while(|&index| tokens[index].token_type != TokenType::Semicolon)
-        .filter(|&index| depths[index] == 0)
-        .collect();
-    let has_terminal_logic = tail.iter().any(|&index| {
-        matches!(
-            tokens[index].token_type,
-            TokenType::Join
-                | TokenType::Where
-                | TokenType::Group
-                | TokenType::Having
-                | TokenType::Qualify
-                | TokenType::Order
-                | TokenType::Limit
-                | TokenType::Offset
-                | TokenType::Union
-                | TokenType::Intersect
-                | TokenType::Except
-        )
-    });
-    if !has_top_level_with || has_terminal_logic {
-        cte_only_bodies.push(tokens[root_select].span);
-    }
-    if !has_top_level_with {
-        return (cte_only_bodies, terminal_selects);
-    }
-
-    let final_cte = significant[..root_select_position]
-        .windows(3)
-        .filter(|window| {
-            depths[window[0]] == 0
-                && is_lint_identifier(&tokens[window[0]])
-                && tokens[window[1]].token_type == TokenType::As
-                && tokens[window[2]].token_type == TokenType::LParen
-        })
-        .map(|window| tokens[window[0]].text.to_ascii_lowercase())
-        .next_back();
-    let from_position = tail.iter().position(|&index| is_query_from(tokens, index));
-    let terminal_is_plain = from_position.is_some_and(|position| {
-        let projection = &tail[..position];
-        let relation = tail.get(position + 1);
-        let remainder = &tail[position.saturating_add(2)..];
-        !projection.is_empty()
-            && plain_terminal_projection(tokens, projection)
-            && relation.is_some_and(|&index| {
-                final_cte
-                    .as_ref()
-                    .is_some_and(|name| tokens[index].text.eq_ignore_ascii_case(name))
-            })
-            && remainder.is_empty()
-    });
-    if !terminal_is_plain {
-        terminal_selects.push(tokens[root_select].span);
-    }
-    (cte_only_bodies, terminal_selects)
-}
-
-fn plain_terminal_projection(tokens: &[Token], projection: &[usize]) -> bool {
-    projection.iter().all(|&index| {
-        is_lint_identifier(&tokens[index])
-            || matches!(
-                tokens[index].token_type,
-                TokenType::Star | TokenType::Dot | TokenType::Comma | TokenType::As
-            )
-    })
-}
-
-fn is_lint_identifier(token: &Token) -> bool {
-    matches!(
-        token.token_type,
-        TokenType::Identifier | TokenType::QuotedIdentifier | TokenType::Var
-    )
-}
-
 fn collect_comment_attachment_facts(tokens: &[Token], sql: &str) -> Vec<Span> {
     let mut invalid: Vec<Span> = Vec::new();
     for (index, token) in tokens.iter().enumerate() {

{sqlbuild-0.100.6 → sqlbuild-0.100.7}/crates/sqlbuild-rules-native/src/sql_lint/_helpers/mod.rs

@@ -1,3 +1,4 @@
 pub(crate) mod additional;
 pub(crate) mod engine;
 pub(crate) mod formatter;
+pub(crate) mod terminal_shape;