sqlbuild 0.133.6__tar.gz → 0.134.0__tar.gz

{sqlbuild-0.133.6 → sqlbuild-0.134.0}/Cargo.lock

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

{sqlbuild-0.133.6 → sqlbuild-0.134.0}/PKG-INFO

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

{sqlbuild-0.133.6 → sqlbuild-0.134.0}/crates/sqlbuild-rules-native/Cargo.toml

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

{sqlbuild-0.133.6 → sqlbuild-0.134.0}/crates/sqlbuild-rules-native/src/configuration/_helpers/loading.rs

@@ -51,6 +51,7 @@ fn validate_raw(value: &toml::Value) -> Result<(), String> {
         "rule_exceptions",
         "graph_edge_exceptions",
         "rule_ignores",
+        "allow_exceptions",
         "select_star_allow",
         "domains",
         "approved_source_tokens",

{sqlbuild-0.133.6 → sqlbuild-0.134.0}/crates/sqlbuild-rules-native/src/models.rs

@@ -145,6 +145,7 @@ pub(crate) struct RulesConfig {
     pub rule_exceptions: Vec<RuleException>,
     pub graph_edge_exceptions: Vec<GraphEdgeException>,
     pub rule_ignores: Vec<RuleIgnore>,
+    pub allow_exceptions: bool,
     pub select_star_allow: Vec<SelectStarAllow>,
     pub domains: Vec<String>,
     pub approved_source_tokens: Vec<String>,
@@ -165,6 +166,7 @@ impl Default for RulesConfig {
             rule_exceptions: vec![],
             graph_edge_exceptions: vec![],
             rule_ignores: vec![],
+            allow_exceptions: true,
             select_star_allow: vec![],
             domains: vec![],
             approved_source_tokens: vec![],

{sqlbuild-0.133.6 → sqlbuild-0.134.0}/crates/sqlbuild-rules-native/src/sql_lint/_helpers/engine.rs

@@ -257,7 +257,7 @@ const DEFAULT_RULES: [&str; 13] = [
     INLINE_QUERY_RELATION.code,
 ];
 
-const ALL_RULE_METADATA: [&LintRuleMetadata; 44] = [
+const ALL_RULE_METADATA: [&LintRuleMetadata; 45] = [
     &NULL_COMPARISON,
     &IMPLICIT_CARTESIAN_JOIN,
     &JOIN_WITHOUT_CONDITION,
@@ -302,6 +302,7 @@ const ALL_RULE_METADATA: [&LintRuleMetadata; 44] = [
     &crate::sql_quality::constants::UNUSED_CTE_OUTPUT,
     &crate::sql_quality::constants::RANKING_SORT_CAP,
     &crate::sql_quality::constants::LONG_LITERAL,
+    &crate::sql_quality::constants::REPEATED_JSON_PARSE,
 ];
 
 fn is_ceremonial_cte_name(name: &str) -> bool {
@@ -442,6 +443,7 @@ pub(crate) fn lint(request: LintRequest) -> Result<LintResponse, String> {
         &crate::sql_quality::models::QualityRequest {
             statements: &statements,
             tokens: &tokens,
+            dialect: dialect_type,
             enabled: &enabled,
             max_literal_length: request
                 .max_literal_length

sqlbuild-0.134.0/crates/sqlbuild-rules-native/src/sql_quality/_helpers/json_parses.rs

@@ -0,0 +1,201 @@
+//! SQBRSQL045: the same JSON payload column parsed more than once in one SELECT scope.
+
+use std::borrow::Cow;
+use std::collections::HashMap;
+
+use polyglot_sql::expressions::{Column, Identifier};
+use polyglot_sql::scope::walk_in_scope;
+use polyglot_sql::tokens::Token;
+use polyglot_sql::{DialectType, Expression, ExpressionWalk};
+
+use crate::sql_lint::models::LintDiagnostic;
+use crate::sql_quality::constants::REPEATED_JSON_PARSE;
+use crate::sql_quality::models::QualityRequest;
+use crate::sql_quality::syntax::{is_trivia, lower};
+
+/// Significant tokens searched backwards from the column for the function name.
+const MAX_FUNCTION_NAME_DISTANCE: usize = 32;
+const PARSE_ONCE_FIX_REFUSAL: &str =
+    "Parsing the payload once requires naming a column in the CTE that reads it";
+
+/// An identifier normalised the way the dialect resolves it.
+type IdentifierKey = String;
+
+/// One JSON parse call whose argument resolves to a plain column.
+struct ParseCall<'a> {
+    function: &'static str,
+    column: &'a Column,
+    column_start: usize,
+}
+
+pub(crate) fn diagnostics(request: &QualityRequest<'_>) -> Vec<LintDiagnostic> {
+    let functions: &[&'static str] = parse_functions(request.dialect);
+    if functions.is_empty() {
+        return Vec::new();
+    }
+    let mut found: Vec<LintDiagnostic> = Vec::new();
+    for statement in request.statements {
+        for node in statement.dfs() {
+            if matches!(node, Expression::Select(_)) {
+                found.extend(scope_diagnostics(
+                    request.tokens,
+                    node,
+                    functions,
+                    request.dialect,
+                ));
+            }
+        }
+    }
+    found
+}
+
+/// JSON parse functions that take one string argument, by dialect, in upper case.
+fn parse_functions(dialect: DialectType) -> &'static [&'static str] {
+    match dialect {
+        DialectType::Snowflake | DialectType::Databricks => &["PARSE_JSON", "TRY_PARSE_JSON"],
+        DialectType::BigQuery => &["PARSE_JSON", "SAFE.PARSE_JSON"],
+        DialectType::DuckDB => &["JSON"],
+        _ => &[],
+    }
+}
+
+fn scope_diagnostics(
+    tokens: &[Token],
+    select: &Expression,
+    functions: &[&'static str],
+    dialect: DialectType,
+) -> Vec<LintDiagnostic> {
+    let quote: char = identifier_quote(dialect);
+    let mut calls: Vec<ParseCall<'_>> = walk_in_scope(select, false)
+        .filter_map(|node| parse_call(node, functions))
+        .collect();
+    calls.sort_by_key(|call| call.column_start);
+    let mut groups: HashMap<
+        (&'static str, Option<IdentifierKey>, IdentifierKey),
+        Vec<&ParseCall<'_>>,
+    > = HashMap::new();
+    for call in &calls {
+        let qualifier: Option<IdentifierKey> = call
+            .column
+            .table
+            .as_ref()
+            .map(|table| identifier_key(table, dialect));
+        groups
+            .entry((
+                call.function,
+                qualifier,
+                identifier_key(&call.column.name, dialect),
+            ))
+            .or_default()
+            .push(call);
+    }
+    let mut found: Vec<LintDiagnostic> = Vec::new();
+    for group in groups.values().filter(|group| group.len() > 1) {
+        let second: &ParseCall<'_> = group[1];
+        let (start, end) = function_span(tokens, second);
+        found.push(LintDiagnostic {
+            code: REPEATED_JSON_PARSE.code,
+            message: REPEATED_JSON_PARSE.message,
+            remediation: Cow::Owned(remediation(second, group.len(), quote)),
+            start,
+            end,
+            fix: None,
+            fix_unavailable_reason: Some(PARSE_ONCE_FIX_REFUSAL),
+        });
+    }
+    found
+}
+
+/// Normalises a name the way the dialect resolves it (Snowflake folds unquoted names upward).
+fn identifier_key(identifier: &Identifier, dialect: DialectType) -> IdentifierKey {
+    match dialect {
+        DialectType::Snowflake if identifier.quoted => identifier.name.clone(),
+        DialectType::Snowflake => identifier.name.to_uppercase(),
+        _ => lower(&identifier.name),
+    }
+}
+
+fn parse_call<'a>(node: &'a Expression, functions: &[&'static str]) -> Option<ParseCall<'a>> {
+    let (name, argument): (&str, &Expression) = match node {
+        Expression::ParseJson(function) => ("PARSE_JSON", &function.this),
+        Expression::Function(function) if function.args.len() == 1 => {
+            (function.name.as_str(), &function.args[0])
+        }
+        _ => return None,
+    };
+    let function: &'static str = functions
+        .iter()
+        .copied()
+        .find(|candidate| candidate.eq_ignore_ascii_case(name))?;
+    let column: &Column = unwrap_column(argument)?;
+    let column_start: usize = column.span.or(column.name.span)?.start;
+    Some(ParseCall {
+        function,
+        column,
+        column_start,
+    })
+}
+
+/// The column under wrappers that keep the parsed value tied to that column.
+fn unwrap_column(expression: &Expression) -> Option<&Column> {
+    let mut current: &Expression = expression;
+    loop {
+        current = match current {
+            Expression::Column(column) => return Some(column),
+            Expression::Paren(paren) => &paren.this,
+            Expression::Lower(function) | Expression::Upper(function) => &function.this,
+            Expression::Trim(trim) if trim.characters.is_none() => &trim.this,
+            Expression::Cast(cast) | Expression::TryCast(cast) | Expression::SafeCast(cast) => {
+                &cast.this
+            }
+            Expression::Coalesce(coalesce) if coalesce.expressions.len() == 1 => {
+                &coalesce.expressions[0]
+            }
+            _ => return None,
+        };
+    }
+}
+
+/// Span of the function-name token that opens `call`, or of its column when not found.
+fn function_span(tokens: &[Token], call: &ParseCall<'_>) -> (usize, usize) {
+    let bare: &str = call.function.rsplit('.').next().unwrap_or(call.function);
+    let before: usize = tokens.partition_point(|token| token.span.start < call.column_start);
+    tokens[..before]
+        .iter()
+        .rev()
+        .filter(|token| !is_trivia(token))
+        .take(MAX_FUNCTION_NAME_DISTANCE)
+        .find(|token| token.text.eq_ignore_ascii_case(bare))
+        .map_or((call.column_start, call.column_start), |token| {
+            (token.span.start, token.span.end)
+        })
+}
+
+fn remediation(call: &ParseCall<'_>, count: usize, quote: char) -> String {
+    let name: String = written(&call.column.name, quote);
+    let column: String = call.column.table.as_ref().map_or_else(
+        || name.clone(),
+        |table| format!("{}.{name}", written(table, quote)),
+    );
+    let function: &str = call.function;
+    format!(
+        "{function}({column}) is parsed {count} times in one SELECT. Parse it once in the CTE that reads it, for example `{function}({name}) AS payload`, and read every field from that column in a later step."
+    )
+}
+
+/// The identifier as authored, re-quoted with the dialect's identifier quote when it was quoted.
+fn written(identifier: &Identifier, quote: char) -> String {
+    if identifier.quoted {
+        let escaped: String = identifier.name.replace(quote, &format!("{quote}{quote}"));
+        format!("{quote}{escaped}{quote}")
+    } else {
+        identifier.name.clone()
+    }
+}
+
+fn identifier_quote(dialect: DialectType) -> char {
+    match dialect {
+        DialectType::BigQuery | DialectType::Databricks => '`',
+        _ => '"',
+    }
+}

{sqlbuild-0.133.6 → sqlbuild-0.134.0}/crates/sqlbuild-rules-native/src/sql_quality/constants.rs

@@ -15,6 +15,11 @@ pub(crate) const LONG_LITERAL: LintRuleMetadata = LintRuleMetadata {
     message: "String literal is longer than max_literal_length",
     remediation: "Define the value once as a constant and reference it with `@const`, or shorten it.",
 };
+pub(crate) const REPEATED_JSON_PARSE: LintRuleMetadata = LintRuleMetadata {
+    code: "SQBRSQL045",
+    message: "JSON payload is parsed more than once in one SELECT",
+    remediation: "Parse the payload once in the CTE that reads it, for example `TRY_PARSE_JSON(value) AS payload`, and read every field from that column in a later step.",
+};
 pub(crate) const UNSTABLE_ROW_NUMBER_CODE: &str = "SQBRSQL018";
 pub(crate) const UNPROVEN_RANKING_MESSAGE: &str =
     "Ranking window order is not proven unique within its partition";

{sqlbuild-0.133.6 → sqlbuild-0.134.0}/crates/sqlbuild-rules-native/src/sql_quality/main/diagnostics.rs

@@ -1,10 +1,11 @@
 use crate::sql_lint::models::LintDiagnostic;
 use crate::sql_quality::constants::{
-    LONG_LITERAL, RANKING_SORT_CAP, UNSTABLE_ROW_NUMBER_CODE, UNUSED_CTE_OUTPUT,
+    LONG_LITERAL, RANKING_SORT_CAP, REPEATED_JSON_PARSE, UNSTABLE_ROW_NUMBER_CODE,
+    UNUSED_CTE_OUTPUT,
 };
 use crate::sql_quality::keys::{KeyEnvironment, key_environment};
 use crate::sql_quality::models::QualityRequest;
-use crate::sql_quality::{cte_columns, literals, ranking};
+use crate::sql_quality::{cte_columns, json_parses, literals, ranking};
 
 /// Run every enabled SQL quality Rule over one parsed body.
 pub(crate) fn diagnostics(request: &QualityRequest<'_>) -> Result<Vec<LintDiagnostic>, String> {
@@ -15,6 +16,9 @@ pub(crate) fn diagnostics(request: &QualityRequest<'_>) -> Result<Vec<LintDiagno
     if request.enabled.contains(LONG_LITERAL.code) {
         found.extend(literals::diagnostics(request));
     }
+    if request.enabled.contains(REPEATED_JSON_PARSE.code) {
+        found.extend(json_parses::diagnostics(request));
+    }
     if request.enabled.contains(UNUSED_CTE_OUTPUT.code) {
         found.extend(cte_columns::diagnostics(request));
     }

{sqlbuild-0.133.6 → sqlbuild-0.134.0}/crates/sqlbuild-rules-native/src/sql_quality/mod.rs

@@ -3,6 +3,8 @@
 pub(crate) mod constants;
 #[path = "_helpers/cte_columns.rs"]
 mod cte_columns;
+#[path = "_helpers/json_parses.rs"]
+mod json_parses;
 #[path = "_helpers/keys.rs"]
 mod keys;
 #[path = "_helpers/literals.rs"]

{sqlbuild-0.133.6 → sqlbuild-0.134.0}/crates/sqlbuild-rules-native/src/sql_quality/models.rs

@@ -1,13 +1,14 @@
 use std::collections::{HashMap, HashSet};
 
-use polyglot_sql::Expression;
 use polyglot_sql::tokens::Token;
+use polyglot_sql::{DialectType, Expression};
 
 /// Inputs for one body's quality Rules, borrowed from the native lint request.
 #[derive(Debug)]
 pub(crate) struct QualityRequest<'a> {
     pub(crate) statements: &'a [Expression],
     pub(crate) tokens: &'a [Token],
+    pub(crate) dialect: DialectType,
     pub(crate) enabled: &'a HashSet<String>,
     pub(crate) max_literal_length: usize,
     pub(crate) max_ranking_order_by: usize,

{sqlbuild-0.133.6 → sqlbuild-0.134.0}/crates/sqlbuild-rules-native/src/sql_quality/tests/helpers.rs

@@ -23,6 +23,30 @@ pub(crate) fn lint(test_case: &QualityRuleTestCase) -> Result<Vec<Value>, String
         .unwrap_or_default())
 }
 
+/// Lint `sql` in `dialect` with only `rule` enabled.
+pub(crate) fn lint_dialect(sql: &str, dialect: &str, rule: &str) -> Result<Vec<Value>, String> {
+    let request: Value = json!({
+        "version": 1,
+        "sql": sql,
+        "dialect": dialect,
+        "enabled_rules": [rule],
+    });
+    let response: Value = serde_json::from_str(&lint_json(&request.to_string())?)
+        .map_err(|error| error.to_string())?;
+    Ok(response["diagnostics"]
+        .as_array()
+        .cloned()
+        .unwrap_or_default())
+}
+
+/// One DuckDB SELECT that parses each of `column_count` payload columns twice.
+pub(crate) fn wide_json_select(column_count: usize) -> String {
+    let projections: Vec<String> = (0..column_count * 2)
+        .map(|index| format!("json(e.c{})->>'f{index}' AS f{index}", index % column_count))
+        .collect();
+    format!("SELECT {} FROM events AS e", projections.join(", "))
+}
+
 pub(crate) fn anchors(sql: &str, diagnostics: &[Value]) -> Vec<String> {
     diagnostics
         .iter()

sqlbuild-0.134.0/crates/sqlbuild-rules-native/src/sql_quality/tests/test_json_parses.rs

@@ -0,0 +1,282 @@
+use std::time::Instant;
+
+use serde_json::Value;
+
+use crate::sql_quality::tests::helpers::{anchors, lint_dialect, wide_json_select};
+use crate::sql_quality::tests::test_types::{JsonParseScaleTestCase, JsonParseTestCase};
+
+const RULE: &str = "SQBRSQL045";
+
+#[test]
+fn given_json_parse_calls_when_linting_then_repeats_in_one_select_are_reported()
+-> Result<(), String> {
+    let test_cases = [
+        JsonParseTestCase {
+            description: "same column parsed twice reports the second call",
+            dialect: "snowflake",
+            sql: "SELECT TRY_PARSE_JSON(e.value):order_id AS order_id, TRY_PARSE_JSON(e.value):status AS status FROM events AS e",
+            expected_anchors: &["TRY_PARSE_JSON"],
+            expected_details: &["TRY_PARSE_JSON(e.value) is parsed 2 times in one SELECT."],
+        },
+        JsonParseTestCase {
+            description: "the finding is located at the second call",
+            dialect: "snowflake",
+            sql: "SELECT try_parse_json(value):a AS a, TRY_PARSE_JSON(value):b AS b FROM events",
+            expected_anchors: &["TRY_PARSE_JSON"],
+            expected_details: &["TRY_PARSE_JSON(value) is parsed 2 times in one SELECT."],
+        },
+        JsonParseTestCase {
+            description: "three parses give one finding with the count",
+            dialect: "snowflake",
+            sql: "SELECT PARSE_JSON(value):a AS a, PARSE_JSON(value):b AS b FROM events WHERE PARSE_JSON(value):c IS NOT NULL",
+            expected_anchors: &["PARSE_JSON"],
+            expected_details: &["PARSE_JSON(value) is parsed 3 times in one SELECT."],
+        },
+        JsonParseTestCase {
+            description: "column casing and wrappers do not hide a repeat",
+            dialect: "snowflake",
+            sql: "SELECT TRY_PARSE_JSON(LOWER(E.Value)):a AS a, TRY_PARSE_JSON((CAST(TRIM(e.value) AS VARCHAR))):b AS b, TRY_PARSE_JSON(COALESCE(UPPER(e.VALUE))):c AS c FROM events AS e",
+            expected_anchors: &["TRY_PARSE_JSON"],
+            expected_details: &["TRY_PARSE_JSON(e.value) is parsed 3 times in one SELECT."],
+        },
+        JsonParseTestCase {
+            description: "multi-argument COALESCE is not a plain column",
+            dialect: "snowflake",
+            sql: "SELECT TRY_PARSE_JSON(COALESCE(e.value, e.backup)):a AS a, TRY_PARSE_JSON(COALESCE(e.value, e.fallback)):b AS b, TRY_PARSE_JSON(e.value):c AS c FROM events AS e",
+            expected_anchors: &[],
+            expected_details: &[],
+        },
+        JsonParseTestCase {
+            description: "TRIM with characters is not a plain column",
+            dialect: "snowflake",
+            sql: "SELECT TRY_PARSE_JSON(TRIM(e.value, ' ')):a AS a, TRY_PARSE_JSON(e.value):b AS b FROM events AS e",
+            expected_anchors: &[],
+            expected_details: &[],
+        },
+        JsonParseTestCase {
+            description: "quoted names differing in case are different columns",
+            dialect: "snowflake",
+            sql: "SELECT TRY_PARSE_JSON(e.\"Value\"):a AS a, TRY_PARSE_JSON(e.\"value\"):b AS b FROM events AS e",
+            expected_anchors: &[],
+            expected_details: &[],
+        },
+        JsonParseTestCase {
+            description: "quoted and unquoted names are not merged",
+            dialect: "snowflake",
+            sql: "SELECT TRY_PARSE_JSON(e.\"value\"):a AS a, TRY_PARSE_JSON(e.value):b AS b FROM events AS e",
+            expected_anchors: &[],
+            expected_details: &[],
+        },
+        JsonParseTestCase {
+            description: "quoted qualifiers differing in case are different relations",
+            dialect: "snowflake",
+            sql: "SELECT TRY_PARSE_JSON(\"E\".value):a AS a, TRY_PARSE_JSON(\"e\".value):b AS b FROM events AS \"E\" INNER JOIN events AS \"e\" ON \"E\".id = \"e\".id",
+            expected_anchors: &[],
+            expected_details: &[],
+        },
+        JsonParseTestCase {
+            description: "identical quoted names are reported as written",
+            dialect: "snowflake",
+            sql: "SELECT TRY_PARSE_JSON(\"E\".\"Value\"):a AS a, TRY_PARSE_JSON(\"E\".\"Value\"):b AS b FROM events AS \"E\"",
+            expected_anchors: &["TRY_PARSE_JSON"],
+            expected_details: &["TRY_PARSE_JSON(\"E\".\"Value\") is parsed 2 times in one SELECT."],
+        },
+        JsonParseTestCase {
+            description: "bigquery quoted names keep backticks",
+            dialect: "bigquery",
+            sql: "SELECT JSON_VALUE(PARSE_JSON(e.`Value`), '$.a') AS a, JSON_VALUE(PARSE_JSON(e.`Value`), '$.b') AS b FROM events AS e",
+            expected_anchors: &["PARSE_JSON"],
+            expected_details: &["PARSE_JSON(e.`Value`) is parsed 2 times in one SELECT."],
+        },
+        JsonParseTestCase {
+            description: "snowflake quoted upper case matches the folded unquoted name",
+            dialect: "snowflake",
+            sql: "SELECT TRY_PARSE_JSON(e.\"VALUE\"):a AS a, TRY_PARSE_JSON(e.value):b AS b FROM events AS e",
+            expected_anchors: &["TRY_PARSE_JSON"],
+            expected_details: &["TRY_PARSE_JSON(e.value) is parsed 2 times in one SELECT."],
+        },
+        JsonParseTestCase {
+            description: "duckdb quoted names are case-insensitive",
+            dialect: "duckdb",
+            sql: "SELECT json(e.\"Value\") -> 'a' AS a, json(e.value) -> 'b' AS b FROM events AS e",
+            expected_anchors: &["json"],
+            expected_details: &["JSON(e.value) is parsed 2 times in one SELECT."],
+        },
+        JsonParseTestCase {
+            description: "bigquery backticked names are case-insensitive",
+            dialect: "bigquery",
+            sql: "SELECT JSON_VALUE(PARSE_JSON(e.`Value`), '$.a') AS a, JSON_VALUE(PARSE_JSON(e.value), '$.b') AS b FROM events AS e",
+            expected_anchors: &["PARSE_JSON"],
+            expected_details: &["PARSE_JSON(e.value) is parsed 2 times in one SELECT."],
+        },
+        JsonParseTestCase {
+            description: "databricks backticked names are case-insensitive",
+            dialect: "databricks",
+            sql: "SELECT try_parse_json(e.`v`) AS a, try_parse_json(e.V) AS b FROM events AS e",
+            expected_anchors: &["try_parse_json"],
+            expected_details: &["TRY_PARSE_JSON(e.V) is parsed 2 times in one SELECT."],
+        },
+        JsonParseTestCase {
+            description: "references are grouped as written",
+            dialect: "snowflake",
+            sql: "SELECT TRY_PARSE_JSON(value):a AS a, TRY_PARSE_JSON(e.value):b AS b, TRY_PARSE_JSON(events.value):c AS c FROM events AS e",
+            expected_anchors: &[],
+            expected_details: &[],
+        },
+        JsonParseTestCase {
+            description: "different columns pass",
+            dialect: "snowflake",
+            sql: "SELECT TRY_PARSE_JSON(e.payload):a AS a, TRY_PARSE_JSON(e.metadata):b AS b FROM events AS e",
+            expected_anchors: &[],
+            expected_details: &[],
+        },
+        JsonParseTestCase {
+            description: "same column name on different tables passes",
+            dialect: "snowflake",
+            sql: "SELECT TRY_PARSE_JSON(o.payload):a AS a, TRY_PARSE_JSON(c.payload):b AS b FROM orders AS o INNER JOIN customers AS c ON o.customer_id = c.customer_id",
+            expected_anchors: &[],
+            expected_details: &[],
+        },
+        JsonParseTestCase {
+            description: "different parse functions are not merged",
+            dialect: "snowflake",
+            sql: "SELECT PARSE_JSON(value):a AS a, TRY_PARSE_JSON(value):b AS b FROM events",
+            expected_anchors: &[],
+            expected_details: &[],
+        },
+        JsonParseTestCase {
+            description: "one parse per CTE scope passes",
+            dialect: "snowflake",
+            sql: "WITH parsed AS (SELECT TRY_PARSE_JSON(value) AS payload FROM events), final AS (SELECT TRY_PARSE_JSON(value) AS payload FROM events) SELECT payload FROM final",
+            expected_anchors: &[],
+            expected_details: &[],
+        },
+        JsonParseTestCase {
+            description: "nested SELECT is its own scope",
+            dialect: "snowflake",
+            sql: "SELECT TRY_PARSE_JSON(e.value):a AS a, (SELECT MAX(TRY_PARSE_JSON(x.value):b) FROM events AS x) AS b FROM events AS e",
+            expected_anchors: &[],
+            expected_details: &[],
+        },
+        JsonParseTestCase {
+            description: "repeat inside a subquery is reported in that scope",
+            dialect: "snowflake",
+            sql: "SELECT e.order_id FROM events AS e WHERE e.order_id IN (SELECT TRY_PARSE_JSON(value):id FROM events WHERE TRY_PARSE_JSON(value):ok)",
+            expected_anchors: &["TRY_PARSE_JSON"],
+            expected_details: &["TRY_PARSE_JSON(value) is parsed 2 times in one SELECT."],
+        },
+        JsonParseTestCase {
+            description: "union branches are separate scopes",
+            dialect: "snowflake",
+            sql: "SELECT TRY_PARSE_JSON(value) AS payload FROM events UNION ALL SELECT TRY_PARSE_JSON(value) AS payload FROM events",
+            expected_anchors: &[],
+            expected_details: &[],
+        },
+        JsonParseTestCase {
+            description: "a repeat inside one CTE body is reported",
+            dialect: "snowflake",
+            sql: "WITH parsed AS (SELECT TRY_PARSE_JSON(value):a AS a, TRY_PARSE_JSON(value):b AS b FROM events) SELECT a, b FROM parsed",
+            expected_anchors: &["TRY_PARSE_JSON"],
+            expected_details: &["TRY_PARSE_JSON(value) is parsed 2 times in one SELECT."],
+        },
+        JsonParseTestCase {
+            description: "non-column arguments pass",
+            dialect: "snowflake",
+            sql: "SELECT TRY_PARSE_JSON(value || '') AS a, TRY_PARSE_JSON(value || '') AS b FROM events",
+            expected_anchors: &[],
+            expected_details: &[],
+        },
+        JsonParseTestCase {
+            description: "bigquery safe parse is matched",
+            dialect: "bigquery",
+            sql: "SELECT JSON_VALUE(SAFE.PARSE_JSON(e.value), '$.a') AS a, JSON_VALUE(SAFE.PARSE_JSON(e.value), '$.b') AS b FROM events AS e",
+            expected_anchors: &["PARSE_JSON"],
+            expected_details: &["SAFE.PARSE_JSON(e.value) is parsed 2 times in one SELECT."],
+        },
+        JsonParseTestCase {
+            description: "databricks try parse is matched",
+            dialect: "databricks",
+            sql: "SELECT try_parse_json(value) AS a, try_parse_json(value) AS b FROM events",
+            expected_anchors: &["try_parse_json"],
+            expected_details: &["TRY_PARSE_JSON(value) is parsed 2 times in one SELECT."],
+        },
+        JsonParseTestCase {
+            description: "duckdb json is matched",
+            dialect: "duckdb",
+            sql: "SELECT json(e.value)->>'a' AS a, json(e.value)->>'b' AS b FROM events AS e",
+            expected_anchors: &["json"],
+            expected_details: &["JSON(e.value) is parsed 2 times in one SELECT."],
+        },
+        JsonParseTestCase {
+            description: "dialects without an equivalent are not checked",
+            dialect: "postgres",
+            sql: "SELECT CAST(value AS JSONB) AS a, CAST(value AS JSONB) AS b FROM events",
+            expected_anchors: &[],
+            expected_details: &[],
+        },
+    ];
+    for test_case in &test_cases {
+        let diagnostics: Vec<Value> = lint_dialect(test_case.sql, test_case.dialect, RULE)?;
+        assert_eq!(
+            anchors(test_case.sql, &diagnostics),
+            test_case.expected_anchors,
+            "{}",
+            test_case.description
+        );
+        let details: Vec<String> = diagnostics
+            .iter()
+            .map(|diagnostic| {
+                diagnostic["remediation"]
+                    .as_str()
+                    .unwrap_or_default()
+                    .split_inclusive(". ")
+                    .next()
+                    .unwrap_or_default()
+                    .trim_end()
+                    .to_owned()
+            })
+            .collect();
+        assert_eq!(
+            details, test_case.expected_details,
+            "{}",
+            test_case.description
+        );
+        assert!(
+            diagnostics
+                .iter()
+                .all(|diagnostic| diagnostic["fix"].is_null()),
+            "{}",
+            test_case.description
+        );
+    }
+    Ok(())
+}
+
+#[test]
+fn given_wide_select_with_many_repeated_parses_when_linting_then_it_stays_linear()
+-> Result<(), String> {
+    let test_cases = [JsonParseScaleTestCase {
+        description: "3,000 projections parsing 1,500 payload columns twice each",
+        column_count: 1_500,
+        expected_findings: 1_500,
+        expected_max_seconds: 10.0,
+    }];
+    for test_case in &test_cases {
+        let started: Instant = Instant::now();
+        let diagnostics: Vec<Value> =
+            lint_dialect(&wide_json_select(test_case.column_count), "duckdb", RULE)?;
+        let elapsed: f64 = started.elapsed().as_secs_f64();
+        assert_eq!(
+            diagnostics.len(),
+            test_case.expected_findings,
+            "{}",
+            test_case.description
+        );
+        assert!(
+            elapsed <= test_case.expected_max_seconds,
+            "{}: {elapsed:.2}s",
+            test_case.description
+        );
+    }
+    Ok(())
+}