sqlbuild 0.118.2__tar.gz → 0.119.0__tar.gz

{sqlbuild-0.118.2 → sqlbuild-0.119.0}/Cargo.lock

@@ -592,7 +592,7 @@ checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba"
 
 [[package]]
 name = "sqlbuild-rules-native"
-version = "0.118.2"
+version = "0.119.0"
 dependencies = [
  "fensu-policy",
  "globset",

{sqlbuild-0.118.2 → sqlbuild-0.119.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlbuild
-Version: 0.118.2
+Version: 0.119.0
 Requires-Dist: duckdb>=1.3.2
 Requires-Dist: filelock>=3.20.3
 Requires-Dist: orjson>=3.10.0
@@ -218,11 +218,11 @@ physical line width in `sqlbuild_project.toml` (the default is `100`):
 line_width = 100
 ```
 
-Select rules in `sqlbuild_project.toml` by exact code or derived family prefix:
+Prefer family selection in `sqlbuild_project.toml` over hand-maintained lists of exact codes:
 
 ```toml
 [rules]
-select = ["SQBRSQL", "XSQBRARCH"]
+select = ["SQBRSQL", "SQBRMODEL", "SQBRGRAPH", "XSQBRARCH"]
 ignore = ["SQBRSQL004"]
 ```
 
@@ -230,6 +230,27 @@ Built-in codes use `SQBR<FAMILY><three digits>`, such as `SQBRSQL001` and
 `SQBRGRAPH101`. Custom codes use `XSQBR<optional family><three digits>`, such as
 `XSQBRARCH001`. A family is always the code with its final three digits removed.
 
+Family selectors automatically include new built-in rules on upgrade. Exact-code lists retain
+their current membership and must be updated manually. In particular, selecting `SQBRSQL` enables
+`SQBRSQL040` (plain JOIN predicates) and `SQBRSQL041` (terminal CTE naming); existing projects may
+need to extract computed join keys into input CTEs and rename their last CTE to `final`.
+See the [SQL rule conventions](docs/native-lint-rule-matrix.md#join-keys-and-final-cte-names)
+for their exact scope and relationship to `SQBRSQL035`.
+
+`sqb format` reports a file-specific `format-unsafe` fault whenever a SQL body cannot be safely
+formatted, including parser, comment-attachment, interpolation-restoration, and idempotence
+failures. The entire original file is retained (including its headers and fixtures), the reason
+appears in human and JSON output, and both
+formatting and `sqb format --check` exit nonzero. A declined body is never counted as canonical.
+
+Formatting preserves authored cast types, postfix casts, quoted literals, variant paths, typed
+lambda parameters, and supported SQL function spellings while applying canonical layout. It uses
+the compiler's trusted-SQL function-depth budget and does not impose the separate browser-oriented
+UNION-chain limit from Polyglot's convenience formatting API. SQLBuild calls retain their authored
+spelling, including zero-argument cursor and empty-fixture intrinsics. CTE-producing macros remain
+authored calls rather than expanded project SQL, with each call on its own CTE-list line and
+leading comments attached to the node they describe.
+
 Custom rules are ordinary Python beneath `rules/**/*.py`. Only `@rule` functions register; helper
 functions, constants, dataclasses, classes, and nested packages remain ordinary Python. Typed,
 keyword-only parameters determine whether a rule runs once per model or once per project:

{sqlbuild-0.118.2 → sqlbuild-0.119.0}/README.md

@@ -182,11 +182,11 @@ physical line width in `sqlbuild_project.toml` (the default is `100`):
 line_width = 100
 ```
 
-Select rules in `sqlbuild_project.toml` by exact code or derived family prefix:
+Prefer family selection in `sqlbuild_project.toml` over hand-maintained lists of exact codes:
 
 ```toml
 [rules]
-select = ["SQBRSQL", "XSQBRARCH"]
+select = ["SQBRSQL", "SQBRMODEL", "SQBRGRAPH", "XSQBRARCH"]
 ignore = ["SQBRSQL004"]
 ```
 
@@ -194,6 +194,27 @@ Built-in codes use `SQBR<FAMILY><three digits>`, such as `SQBRSQL001` and
 `SQBRGRAPH101`. Custom codes use `XSQBR<optional family><three digits>`, such as
 `XSQBRARCH001`. A family is always the code with its final three digits removed.
 
+Family selectors automatically include new built-in rules on upgrade. Exact-code lists retain
+their current membership and must be updated manually. In particular, selecting `SQBRSQL` enables
+`SQBRSQL040` (plain JOIN predicates) and `SQBRSQL041` (terminal CTE naming); existing projects may
+need to extract computed join keys into input CTEs and rename their last CTE to `final`.
+See the [SQL rule conventions](docs/native-lint-rule-matrix.md#join-keys-and-final-cte-names)
+for their exact scope and relationship to `SQBRSQL035`.
+
+`sqb format` reports a file-specific `format-unsafe` fault whenever a SQL body cannot be safely
+formatted, including parser, comment-attachment, interpolation-restoration, and idempotence
+failures. The entire original file is retained (including its headers and fixtures), the reason
+appears in human and JSON output, and both
+formatting and `sqb format --check` exit nonzero. A declined body is never counted as canonical.
+
+Formatting preserves authored cast types, postfix casts, quoted literals, variant paths, typed
+lambda parameters, and supported SQL function spellings while applying canonical layout. It uses
+the compiler's trusted-SQL function-depth budget and does not impose the separate browser-oriented
+UNION-chain limit from Polyglot's convenience formatting API. SQLBuild calls retain their authored
+spelling, including zero-argument cursor and empty-fixture intrinsics. CTE-producing macros remain
+authored calls rather than expanded project SQL, with each call on its own CTE-list line and
+leading comments attached to the node they describe.
+
 Custom rules are ordinary Python beneath `rules/**/*.py`. Only `@rule` functions register; helper
 functions, constants, dataclasses, classes, and nested packages remain ordinary Python. Typed,
 keyword-only parameters determine whether a rule runs once per model or once per project:

{sqlbuild-0.118.2 → sqlbuild-0.119.0}/crates/sqlbuild-rules-native/Cargo.toml

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

{sqlbuild-0.118.2 → sqlbuild-0.119.0}/crates/sqlbuild-rules-native/src/sql_lint/_helpers/engine.rs

@@ -229,6 +229,16 @@ const INLINE_QUERY_RELATION: LintRuleMetadata = LintRuleMetadata {
     remediation: "Extract the derived relation into a named top-level CTE; use explicit LATERAL only when the relation must remain correlated.",
 };
 const TRIVIAL_EQUALITY_TOKEN_COUNT: usize = 3;
+const JOIN_EXPRESSION: LintRuleMetadata = LintRuleMetadata {
+    code: "SQBRSQL040",
+    message: "JOIN ON contains a computed expression",
+    remediation: "Compute keys, including variant path access, in input CTEs and join on plain columns. Literal-only predicates such as ON TRUE are allowed.",
+};
+const FINAL_CTE_NAME: LintRuleMetadata = LintRuleMetadata {
+    code: "SQBRSQL041",
+    message: "Only the last top-level CTE may be named final, and it must use that name",
+    remediation: "Name the last top-level CTE final and rename any other final CTE; SQBRSQL035 checks the terminal SELECT.",
+};
 
 const DEFAULT_RULES: [&str; 13] = [
     NULL_COMPARISON.code,
@@ -246,7 +256,7 @@ const DEFAULT_RULES: [&str; 13] = [
     INLINE_QUERY_RELATION.code,
 ];
 
-const ALL_RULE_METADATA: [&LintRuleMetadata; 39] = [
+const ALL_RULE_METADATA: [&LintRuleMetadata; 41] = [
     &NULL_COMPARISON,
     &IMPLICIT_CARTESIAN_JOIN,
     &JOIN_WITHOUT_CONDITION,
@@ -286,6 +296,8 @@ const ALL_RULE_METADATA: [&LintRuleMetadata; 39] = [
     &RECURSIVE_CTE,
     &CROSS_JOIN,
     &INLINE_QUERY_RELATION,
+    &JOIN_EXPRESSION,
+    &FINAL_CTE_NAME,
 ];
 
 fn is_ceremonial_cte_name(name: &str) -> bool {
@@ -395,6 +407,25 @@ pub(crate) fn lint(request: LintRequest) -> Result<LintResponse, String> {
         enabled: &enabled,
     };
     let mut diagnostics = diagnostics(&context);
+    let depths = token_depths(&tokens);
+    if enabled.contains(JOIN_EXPRESSION.code) {
+        diagnostics.extend(diagnostics_for_spans(
+            &JOIN_EXPRESSION,
+            &crate::sql_lint::_helpers::join_predicates::join_expression_spans(
+                &tokens,
+                &depths,
+                dialect_type,
+            ),
+            Some("computing a join key requires an authored CTE rewrite"),
+        ));
+    }
+    if enabled.contains(FINAL_CTE_NAME.code) && !request.allows_ceremonial_select {
+        diagnostics.extend(diagnostics_for_spans(
+            &FINAL_CTE_NAME,
+            &crate::sql_lint::_helpers::terminal_shape::final_cte_name_spans(&tokens, &depths),
+            Some("renaming a CTE requires updating its references"),
+        ));
+    }
     diagnostics.sort_by_key(|diagnostic| (diagnostic.start, diagnostic.end, diagnostic.code));
     Ok(LintResponse {
         version: LINT_API_VERSION,
@@ -508,6 +539,8 @@ fn collect_rule_migration_facts(
         .filter(|&index| !is_layout(&tokens[index]) && !is_comment(&tokens[index]))
         .collect();
 
+    let root_with = crate::sql_lint::_helpers::terminal_shape::root_with_indices(tokens, depths);
+
     for (position, &index) in significant.iter().enumerate() {
         let text = tokens[index].text.as_str();
         if text.eq_ignore_ascii_case("cross")
@@ -517,11 +550,11 @@ fn collect_rule_migration_facts(
         {
             facts.cross_joins.push(tokens[index].span);
         }
-        if text.eq_ignore_ascii_case("with") {
+        if tokens[index].token_type == TokenType::With {
             let starts_hierarchy = position.checked_sub(1).is_some_and(|previous| {
                 tokens[significant[previous]].token_type == TokenType::Start
             });
-            if depths[index] > 0 && !starts_hierarchy {
+            if !root_with.contains(&index) && !starts_hierarchy {
                 facts.nested_ctes.push(tokens[index].span);
             }
             if !starts_hierarchy

{sqlbuild-0.118.2 → sqlbuild-0.119.0}/crates/sqlbuild-rules-native/src/sql_lint/_helpers/formatter.rs

@@ -1,10 +1,11 @@
 use std::collections::BTreeMap;
 use std::str::FromStr;
 
-use polyglot_sql::tokens::Token;
-use polyglot_sql::{Dialect, DialectType, format_by_name};
+use polyglot_sql::tokens::{Token, TokenType};
+use polyglot_sql::{ComplexityGuardOptions, Dialect, DialectType, ParseOptions};
 use rayon::iter::{IntoParallelIterator, ParallelIterator};
 
+use crate::sql_lint::_helpers::formatter_syntax::{cte_macro_indices, protect_syntax};
 use crate::sql_lint::constants::{
     CAST_TYPE_SEPARATOR_KEYWORD, CLOSE_PARENTHESIS, LINT_API_VERSION, OPEN_PARENTHESIS,
     VALUES_RELATION_PREFIX_TOKEN_COUNT,
@@ -13,7 +14,8 @@ use crate::sql_lint::models::{FormatRequest, FormatResponse};
 
 const COMMENT_ATTACHMENT_FAILURE: &str =
     "native formatter could not preserve comment token attachments";
-const UNSUPPORTED_SQL_FAILURE: &str = "native formatter could not safely format unsupported SQL";
+const UNSUPPORTED_SQL_FAILURE: &str =
+    "native formatter could not safely restore literal or cast spelling";
 
 pub(crate) fn format_json_impl(request_json: &str) -> Result<String, String> {
     let request: FormatRequest =
@@ -31,6 +33,20 @@ pub(crate) fn format_batch_json_impl(request_json: &str) -> Result<String, Strin
 }
 
 fn format_sql(request: FormatRequest) -> Result<FormatResponse, String> {
+    let original = request.sql.clone();
+    match try_format_sql(request) {
+        Ok(value) => Ok(value),
+        Err(reason) => Ok(FormatResponse {
+            version: LINT_API_VERSION,
+            sql: original,
+            changed: false,
+            formatted: false,
+            reason: Some(reason),
+        }),
+    }
+}
+
+fn try_format_sql(request: FormatRequest) -> Result<FormatResponse, String> {
     if request.version != LINT_API_VERSION {
         return Err(format!(
             "unsupported native format request version {}; expected {LINT_API_VERSION}",
@@ -41,37 +57,38 @@ fn format_sql(request: FormatRequest) -> Result<FormatResponse, String> {
     let dialect_type =
         DialectType::from_str(&request.dialect).map_err(|error| error.to_string())?;
     let dialect = Dialect::get(dialect_type);
-    let tokens = match dialect.tokenize(&original) {
-        Ok(value) => value,
-        Err(_) => return response(original, false, false, Some(UNSUPPORTED_SQL_FAILURE)),
+    let parse_options = ParseOptions {
+        complexity_guard: Some(ComplexityGuardOptions {
+            max_function_call_depth: request.max_function_call_depth,
+            ..Default::default()
+        }),
     };
+    let tokens = dialect
+        .tokenize(&original)
+        .map_err(|error| format!("native formatter tokenization failed: {error}"))?;
     let comments = comments_in(&original, &tokens);
     let neutral = neutralize_comments(&original, &comments);
-    if dialect.parse(&neutral).is_err() {
-        return response(original, false, false, Some(UNSUPPORTED_SQL_FAILURE));
-    }
+    let validation_sql = protect_syntax(&neutral, &tokens, &[], false)?;
+    dialect
+        .parse_with_options(&validation_sql.sql, &parse_options)
+        .map_err(|error| format!("native formatter could not parse SQL: {error}"))?;
     let semantic_tokens = without_statement_terminators(&tokens);
     let formatted_context = FormatOnceContext {
-        dialect_name: &request.dialect,
+        parse_options: &parse_options,
         dialect: &dialect,
         original_sql: &neutral,
         original_tokens: &semantic_tokens,
         comments: &comments,
     };
-    let formatted = match format_once(&neutral, &formatted_context) {
-        Ok(value) => value,
-        Err(error) if error == COMMENT_ATTACHMENT_FAILURE => {
-            return response(original, false, false, Some(COMMENT_ATTACHMENT_FAILURE));
-        }
-        Err(_) => return response(original, false, false, Some(UNSUPPORTED_SQL_FAILURE)),
-    };
+    let formatted = format_once(&neutral, &formatted_context)?;
     let formatted_tokens = dialect
         .tokenize(&formatted)
         .map_err(|error| error.to_string())?;
     let formatted_neutral =
         neutralize_comments(&formatted, &comments_in(&formatted, &formatted_tokens));
+    let validation_sql = protect_syntax(&formatted_neutral, &formatted_tokens, &[], false)?;
     let _ = dialect
-        .parse(&formatted_neutral)
+        .parse_with_options(&validation_sql.sql, &parse_options)
         .map_err(|error| error.to_string())?;
     let second_tokens = dialect
         .tokenize(&formatted)
@@ -80,19 +97,13 @@ fn format_sql(request: FormatRequest) -> Result<FormatResponse, String> {
     let second_neutral = neutralize_comments(&formatted, &second_comments);
     let second_semantic_tokens = without_statement_terminators(&second_tokens);
     let second_context = FormatOnceContext {
-        dialect_name: &request.dialect,
+        parse_options: &parse_options,
         dialect: &dialect,
         original_sql: &second_neutral,
         original_tokens: &second_semantic_tokens,
         comments: &second_comments,
     };
-    let second_pass = match format_once(&second_neutral, &second_context) {
-        Ok(value) => value,
-        Err(error) if error == COMMENT_ATTACHMENT_FAILURE => {
-            return response(original, false, false, Some(COMMENT_ATTACHMENT_FAILURE));
-        }
-        Err(error) => return Err(error),
-    };
+    let second_pass = format_once(&second_neutral, &second_context)?;
     if second_pass != formatted {
         return Err("native formatter output is not idempotent".to_string());
     }
@@ -110,7 +121,7 @@ struct Comment {
 }
 
 struct FormatOnceContext<'a> {
-    dialect_name: &'a str,
+    parse_options: &'a ParseOptions,
     dialect: &'a Dialect,
     original_sql: &'a str,
     original_tokens: &'a [Token],
@@ -118,15 +129,33 @@ struct FormatOnceContext<'a> {
 }
 
 fn format_once(neutral_sql: &str, context: &FormatOnceContext<'_>) -> Result<String, String> {
-    let mut formatted = format_by_name(neutral_sql, context.dialect_name)
-        .map_err(|error| error.to_string())?
-        .join(";\n");
+    let protected = protect_syntax(
+        neutral_sql,
+        context.original_tokens,
+        &cast_type_token_ranges(context)?,
+        true,
+    )?;
+    let expressions = context
+        .dialect
+        .parse_with_options(&protected.sql, context.parse_options)
+        .map_err(|error| error.to_string())?;
+    let formatted_statements: Result<Vec<String>, String> = expressions
+        .iter()
+        .map(|expression| {
+            context
+                .dialect
+                .generate_pretty(expression)
+                .map_err(|error| error.to_string())
+        })
+        .collect();
+    let mut formatted = protected.restore(formatted_statements?.join(";\n"), context.dialect)?;
     formatted = restore_unparenthesized_from_values(formatted, context)?;
-    formatted = restore_string_literals(formatted, context)?;
-    formatted = restore_cast_type_spellings(formatted, context)?;
+    formatted = restore_null_treatment(formatted, context)?;
+    formatted = layout_cte_macros(formatted, context)?;
     if context.comments.is_empty() {
         return Ok(formatted);
     }
+    formatted = restore_implicit_aliases(formatted, context)?;
     let formatted_tokens = context
         .dialect
         .tokenize(&formatted)
@@ -170,6 +199,136 @@ fn format_once(neutral_sql: &str, context: &FormatOnceContext<'_>) -> Result<Str
     Ok(formatted)
 }
 
+fn restore_implicit_aliases(
+    mut formatted: String,
+    context: &FormatOnceContext<'_>,
+) -> Result<String, String> {
+    let tokens = context
+        .dialect
+        .tokenize(&formatted)
+        .map_err(|error| error.to_string())?;
+    let mut original = context.original_tokens.iter().peekable();
+    let mut removals: Vec<(usize, usize)> = Vec::new();
+    for token in &tokens {
+        if original
+            .peek()
+            .is_some_and(|before| before.token_type == token.token_type)
+        {
+            original.next();
+        } else if token.token_type == TokenType::As {
+            removals.push((token.span.start, token.span.end));
+        } else {
+            return Err(format!(
+                "{COMMENT_ATTACHMENT_FAILURE}: expected {:?}, generated {:?}",
+                original.peek().map(|token| token.token_type),
+                token.token_type
+            ));
+        }
+    }
+    if original.next().is_some() {
+        return Err(COMMENT_ATTACHMENT_FAILURE.to_string());
+    }
+    for (start, end) in removals.into_iter().rev() {
+        let start = char_to_byte(&formatted, start)?;
+        let end = char_to_byte(&formatted, end)?;
+        formatted.replace_range(
+            start..end + usize::from(formatted[end..].starts_with(' ')),
+            "",
+        );
+    }
+    Ok(formatted)
+}
+
+fn layout_cte_macros(
+    mut formatted: String,
+    context: &FormatOnceContext<'_>,
+) -> Result<String, String> {
+    let tokens = context
+        .dialect
+        .tokenize(&formatted)
+        .map_err(|error| error.to_string())?;
+    let macros = cte_macro_indices(&tokens);
+    if macros.is_empty() {
+        return Ok(formatted);
+    }
+    let depths = crate::sql_lint::_helpers::engine::token_depths(&tokens);
+    let chars: Vec<char> = formatted.chars().collect();
+    let mut gaps: BTreeMap<(usize, usize), String> = BTreeMap::new();
+    for index in macros {
+        let with = (0..index)
+            .rev()
+            .find(|&previous| {
+                tokens[previous].token_type == TokenType::With && depths[previous] == depths[index]
+            })
+            .ok_or_else(|| "native formatter lost a CTE macro scope".to_string())?;
+        let indentation = line_indentation(&chars, tokens[with].span.start);
+        let newline = format!("\n{}", " ".repeat(indentation));
+        gaps.insert(
+            (tokens[index - 1].span.end, tokens[index].span.start),
+            newline.clone(),
+        );
+        if tokens
+            .get(index + 1)
+            .is_some_and(|token| token.token_type == TokenType::Comma)
+            && let Some(next) = tokens.get(index + 2)
+        {
+            gaps.insert((tokens[index + 1].span.end, next.span.start), newline);
+        }
+    }
+    for ((start, end), replacement) in gaps.into_iter().rev() {
+        let start = char_to_byte(&formatted, start)?;
+        let end = char_to_byte(&formatted, end)?;
+        formatted.replace_range(start..end, &replacement);
+    }
+    Ok(formatted)
+}
+
+fn restore_null_treatment(
+    mut formatted: String,
+    context: &FormatOnceContext<'_>,
+) -> Result<String, String> {
+    let authored: Vec<bool> = context
+        .original_tokens
+        .windows(3)
+        .filter(|tokens| {
+            matches!(
+                tokens[0].text.to_ascii_uppercase().as_str(),
+                "IGNORE" | "RESPECT"
+            ) && tokens[1].text.eq_ignore_ascii_case("NULLS")
+        })
+        .map(|tokens| tokens[2].token_type == TokenType::RParen)
+        .collect();
+    if authored.is_empty() {
+        return Ok(formatted);
+    }
+    let tokens = context
+        .dialect
+        .tokenize(&formatted)
+        .map_err(|error| error.to_string())?;
+    let generated: Vec<usize> = (1..tokens.len().saturating_sub(1))
+        .filter(|&index| {
+            matches!(
+                tokens[index].text.to_ascii_uppercase().as_str(),
+                "IGNORE" | "RESPECT"
+            ) && tokens[index + 1].text.eq_ignore_ascii_case("NULLS")
+        })
+        .collect();
+    if authored.len() != generated.len() {
+        return Err("native formatter changed null-treatment clauses".to_string());
+    }
+    for (inside, index) in authored.into_iter().zip(generated).rev() {
+        if inside && tokens[index - 1].token_type == TokenType::RParen {
+            let start = char_to_byte(&formatted, tokens[index - 1].span.start)?;
+            let end = char_to_byte(&formatted, tokens[index + 1].span.end)?;
+            formatted.replace_range(
+                start..end,
+                &format!(" {} NULLS)", tokens[index].text.to_ascii_uppercase()),
+            );
+        }
+    }
+    Ok(formatted)
+}
+
 fn restore_unparenthesized_from_values(
     mut formatted: String,
     context: &FormatOnceContext<'_>,
@@ -200,7 +359,7 @@ fn restore_unparenthesized_from_values(
         })
         .collect();
     if authored_parenthesized.len() != formatted_values.len() {
-        return Ok(formatted);
+        return Err("native formatter could not preserve VALUES relation count".to_string());
     }
     let mut removals: Vec<(usize, usize)> = Vec::new();
     for (was_parenthesized, values_index) in
@@ -234,7 +393,7 @@ fn restore_unparenthesized_from_values(
             }
         }
         let Some(close_index) = close_index else {
-            return Ok(formatted);
+            return Err("native formatter could not locate the VALUES wrapper end".to_string());
         };
         let open = &formatted_tokens[wrapper_index];
         let close = &formatted_tokens[close_index];
@@ -347,73 +506,6 @@ fn trailing_comment_insertion(
     }
 }
 
-fn restore_string_literals(
-    mut formatted: String,
-    context: &FormatOnceContext<'_>,
-) -> Result<String, String> {
-    let originals: Vec<String> = context
-        .original_tokens
-        .iter()
-        .filter(|token| token.token_type == polyglot_sql::tokens::TokenType::String)
-        .map(|token| char_slice(context.original_sql, token.span.start, token.span.end))
-        .collect::<Option<Vec<String>>>()
-        .ok_or_else(|| UNSUPPORTED_SQL_FAILURE.to_string())?;
-    let formatted_tokens = context
-        .dialect
-        .tokenize(&formatted)
-        .map_err(|error| error.to_string())?;
-    let formatted_strings: Vec<&Token> = formatted_tokens
-        .iter()
-        .filter(|token| token.token_type == polyglot_sql::tokens::TokenType::String)
-        .collect();
-    if originals.len() != formatted_strings.len() {
-        return Err(UNSUPPORTED_SQL_FAILURE.to_string());
-    }
-    for (token, original) in formatted_strings.into_iter().zip(originals).rev() {
-        let start = char_to_byte(&formatted, token.span.start)?;
-        let end = char_to_byte(&formatted, token.span.end)?;
-        formatted.replace_range(start..end, &original);
-    }
-    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();
@@ -453,8 +545,15 @@ fn char_slice(value: &str, start: usize, end: usize) -> Option<String> {
 fn without_statement_terminators(tokens: &[Token]) -> Vec<Token> {
     tokens
         .iter()
-        .filter(|token| token.token_type != polyglot_sql::tokens::TokenType::Semicolon)
-        .cloned()
+        .enumerate()
+        .filter(|(index, token)| {
+            token.token_type != TokenType::Semicolon
+                && !(token.token_type == TokenType::Comma
+                    && tokens
+                        .get(index + 1)
+                        .is_some_and(|next| next.token_type == TokenType::From))
+        })
+        .map(|(_, token)| token.clone())
         .collect()
 }
 
@@ -544,6 +643,6 @@ fn response(
         changed,
         sql,
         formatted,
-        reason,
+        reason: reason.map(str::to_owned),
     })
 }