자동 포멧팅 기능 개선

Author: letspurify-ux

src/db/query/query_tests.rs

@@ -16068,6 +16068,34 @@ fn test_parse_tool_command_classifies_unhandled_sqlplus_set_options_as_unsupport
     }
 }
 
+#[test]
+fn test_parse_tool_command_accepts_sqlterminator_compatibility_directive() {
+    for set_command in ["SET SQLTERMINATOR OFF", "SET SQLTERMINATOR ON;"] {
+        let parsed = QueryExecutor::parse_tool_command(set_command);
+        assert!(
+            matches!(
+                &parsed,
+                Some(ToolCommand::SqlPlusReportLayout { raw })
+                    if raw == set_command.trim_end_matches(';')
+            ),
+            "{set_command} should be accepted as a validated compatibility directive: {parsed:?}"
+        );
+    }
+
+    let parsed = QueryExecutor::parse_tool_command("SET SQLTERMINATOR MAYBE");
+    assert!(
+        matches!(
+            &parsed,
+            Some(ToolCommand::Unsupported {
+                message,
+                is_error: true,
+                ..
+            }) if message.contains("ON or OFF")
+        ),
+        "invalid SQLTERMINATOR mode must remain an error: {parsed:?}"
+    );
+}
+
 #[test]
 fn test_split_script_items_oracle_with_function_recovers_to_sqlplus_set_options() {
     for set_command in [

src/db/query/script.rs

@@ -10185,6 +10185,20 @@ impl QueryExecutor {
             return Some(Self::parse_sqlblanklines_command(trimmed));
         }
 
+        if upper.starts_with("SET SQLTERMINATOR") {
+            // The script splitter already accepts both SQL terminators (`;` and a
+            // line containing `/`) without a mutable SQL*Plus mode. Treat this as
+            // a validated compatibility directive so SQL*Plus fixtures can run
+            // unchanged instead of failing before their first SQL statement.
+            return Some(Self::parse_set_on_off_command(
+                trimmed,
+                "SET SQLTERMINATOR",
+                |_| ToolCommand::SqlPlusReportLayout {
+                    raw: trimmed.to_string(),
+                },
+            ));
+        }
+
         if upper.starts_with("SET TAB") {
             return Some(Self::parse_tab_command(trimmed));
         }

src/ui/sql_editor/format_sweep_tests.rs

@@ -837,39 +837,55 @@ fn format_sweep_audit_ddl_query_body_depth(
     let line_starts = line_start_offsets(formatted);
     let document = FormatSweepDocument::new(formatted, db_type);
     let mut words_by_line = vec![Vec::<&str>::new(); lines.len()];
-    let mut first_word_paren_depth_by_line = vec![None; lines.len()];
+    let mut first_word_delimiter_depth_by_line = vec![None; lines.len()];
     let mut first_word_statement_index_by_line = vec![None; lines.len()];
-    let mut trailing_comma_paren_depth_by_line = vec![None; lines.len()];
+    let mut trailing_comma_delimiter_depth_by_line = vec![None; lines.len()];
     let mut trailing_semicolon_paren_depth_by_line = vec![None; lines.len()];
     let mut line_idx = 0usize;
     let mut paren_depth = 0usize;
+    let mut brace_depth = 0usize;
+    let mut bracket_depth = 0usize;
 
     for token in &document.tokens {
         while line_idx + 1 < line_starts.len() && line_starts[line_idx + 1] <= token.start {
             line_idx = line_idx.saturating_add(1);
         }
-        if matches!(&token.token, SqlToken::Symbol(symbol) if symbol == ")") {
-            paren_depth = paren_depth.saturating_sub(1);
+        if let SqlToken::Symbol(symbol) = &token.token {
+            match symbol.as_str() {
+                ")" => paren_depth = paren_depth.saturating_sub(1),
+                "}" => brace_depth = brace_depth.saturating_sub(1),
+                "]" => bracket_depth = bracket_depth.saturating_sub(1),
+                _ => {}
+            }
         }
         if let SqlToken::Word(word) = &token.token {
             if let Some(words) = words_by_line.get_mut(line_idx) {
                 if words.is_empty() {
-                    first_word_paren_depth_by_line[line_idx] = Some(paren_depth);
+                    first_word_delimiter_depth_by_line[line_idx] =
+                        Some((paren_depth, brace_depth, bracket_depth));
                     first_word_statement_index_by_line[line_idx] = Some(token.statement_index);
                 }
                 words.push(word);
             }
         }
         if !matches!(token.token, SqlToken::Comment(_)) {
-            trailing_comma_paren_depth_by_line[line_idx] =
-                matches!(&token.token, SqlToken::Symbol(symbol) if symbol == ",")
-                    .then_some(paren_depth);
+            trailing_comma_delimiter_depth_by_line[line_idx] =
+                matches!(&token.token, SqlToken::Symbol(symbol) if symbol == ",").then_some((
+                    paren_depth,
+                    brace_depth,
+                    bracket_depth,
+                ));
             trailing_semicolon_paren_depth_by_line[line_idx] =
                 matches!(&token.token, SqlToken::Symbol(symbol) if symbol == ";")
                     .then_some(paren_depth);
         }
-        if matches!(&token.token, SqlToken::Symbol(symbol) if symbol == "(") {
-            paren_depth = paren_depth.saturating_add(1);
+        if let SqlToken::Symbol(symbol) = &token.token {
+            match symbol.as_str() {
+                "(" => paren_depth = paren_depth.saturating_add(1),
+                "{" => brace_depth = brace_depth.saturating_add(1),
+                "[" => bracket_depth = bracket_depth.saturating_add(1),
+                _ => {}
+            }
         }
     }
 
@@ -962,7 +978,9 @@ fn format_sweep_audit_ddl_query_body_depth(
             ));
         }
 
-        let query_paren_depth = first_word_paren_depth_by_line[body_idx].unwrap_or(0);
+        let query_delimiter_depth =
+            first_word_delimiter_depth_by_line[body_idx].unwrap_or((0, 0, 0));
+        let query_paren_depth = query_delimiter_depth.0;
         let statement_span_end_idx = first_word_statement_index_by_line[body_idx]
             .and_then(|statement_index| document.statements.get(statement_index))
             .map(|statement| {
@@ -977,7 +995,7 @@ fn format_sweep_audit_ddl_query_body_depth(
             .unwrap_or(statement_span_end_idx);
 
         for clause_idx in body_idx.saturating_add(1)..=statement_end_idx {
-            if first_word_paren_depth_by_line[clause_idx] != Some(query_paren_depth)
+            if first_word_delimiter_depth_by_line[clause_idx] != Some(query_delimiter_depth)
                 || !is_direct_query_clause(&words_by_line[clause_idx])
             {
                 continue;
@@ -1001,17 +1019,17 @@ fn format_sweep_audit_ddl_query_body_depth(
             }
         }
 
-        for (comma_idx, trailing_comma_paren_depth) in trailing_comma_paren_depth_by_line
+        for (comma_idx, trailing_comma_delimiter_depth) in trailing_comma_delimiter_depth_by_line
             .iter()
             .enumerate()
             .take(statement_end_idx)
             .skip(body_idx)
         {
-            if *trailing_comma_paren_depth != Some(query_paren_depth) {
+            if *trailing_comma_delimiter_depth != Some(query_delimiter_depth) {
                 continue;
             }
             let Some(sibling_idx) = (comma_idx.saturating_add(1)..=statement_end_idx).find(|idx| {
-                first_word_paren_depth_by_line[*idx] == Some(query_paren_depth)
+                first_word_delimiter_depth_by_line[*idx] == Some(query_delimiter_depth)
                     && !words_by_line[*idx].is_empty()
             }) else {
                 continue;
@@ -2450,6 +2468,22 @@ fn formatting_sweep_ddl_query_body_depth_audit_flags_missing_owner_depth() {
     }
 }
 
+#[test]
+fn formatting_sweep_ddl_query_body_depth_ignores_json_duality_delimiters() {
+    let formatted = r#"CREATE JSON RELATIONAL DUALITY VIEW dv_demo AS
+    SELECT JSON { '_id' :parent_owner.id, 'children' : [
+    SELECT JSON { 'childId' :child_owner.id, 'amount' :child_owner.amount }
+    FROM child_table child_owner WITH INSERT UPDATE DELETE
+    WHERE child_owner.parent_id = parent_owner.id ] }
+    FROM parent_table parent_owner WITH UPDATE INSERT DELETE;"#;
+
+    let (_, issues) = format_sweep_audit_ddl_query_body_depth(formatted, DatabaseType::Oracle);
+    assert!(
+        issues.is_empty(),
+        "JSON object/array commas are not DDL query-list siblings: {issues:#?}"
+    );
+}
+
 #[test]
 fn formatting_sweep_mysql_fixed_phrases_ignore_source_line_breaks() {
     let source = r#"DELIMITER $$

src/ui/sql_editor/formatter.rs

@@ -20459,8 +20459,31 @@ impl SqlEditorWidget {
                             needs_space = true;
                         }
                         "." => {
-                            trim_trailing_space(&mut out);
+                            let mysql_leading_default_schema_qualifier = mysql_compatible
+                                && matches!(
+                                    prev_word_upper,
+                                    Some(
+                                        "FROM"
+                                            | "INTO"
+                                            | "JOIN"
+                                            | "TABLE"
+                                            | "TABLES"
+                                            | "UPDATE"
+                                            | "USING"
+                                    )
+                                );
+                            if !mysql_leading_default_schema_qualifier {
+                                trim_trailing_space(&mut out);
+                            }
                             ensure_indent(&mut out, &mut at_line_start, line_indent);
+                            if mysql_leading_default_schema_qualifier
+                                && !out
+                                    .as_bytes()
+                                    .last()
+                                    .is_some_and(|byte| byte.is_ascii_whitespace())
+                            {
+                                out.push(' ');
+                            }
                             out.push('.');
                             needs_space = false;
                         }
@@ -32220,6 +32243,73 @@ FROM demo t WITH UPDATE INSERT DELETE;"#;
         );
     }
 
+    #[test]
+    fn format_for_auto_formatting_keeps_nested_json_duality_view_query_owned() {
+        let source = r#"CREATE JSON RELATIONAL DUALITY VIEW dv_demo AS
+SELECT JSON {
+  '_id' : parent_owner.id,
+  'children' : [
+    SELECT JSON {
+      'childId' : child_owner.id,
+      'amount' : child_owner.amount
+    }
+    FROM child_table child_owner WITH INSERT UPDATE DELETE
+    WHERE child_owner.parent_id = parent_owner.id
+  ]
+}
+FROM parent_table parent_owner WITH UPDATE INSERT DELETE;"#;
+
+        let (formatted, audit) =
+            SqlEditorWidget::format_for_auto_formatting_with_frame_alignment_audit(
+                source,
+                Some(crate::db::connection::DatabaseType::Oracle),
+            );
+
+        assert!(audit.issues.is_empty(), "{:#?}\n{formatted}", audit.issues);
+        assert_eq!(
+            SqlEditorWidget::format_for_auto_formatting_with_frame_alignment_audit(
+                &formatted,
+                Some(crate::db::connection::DatabaseType::Oracle),
+            )
+            .0,
+            formatted,
+            "nested duality-view formatting must be idempotent"
+        );
+    }
+
+    #[test]
+    fn format_for_auto_formatting_preserves_mariadb_leading_dot_table_qualifier() {
+        let source = "INSERT INTO . demo_table (id) VALUES (1);\n\
+                      SELECT * FROM . demo_table;\n\
+                      UPDATE . demo_table SET id = 2;\n\
+                      DELETE FROM . demo_table WHERE id = 2;";
+        let formatted = SqlEditorWidget::format_for_auto_formatting_with_db_type(
+            source,
+            false,
+            Some(crate::db::connection::DatabaseType::MariaDB),
+        );
+
+        for target in [
+            "INSERT INTO .demo_table",
+            "FROM .demo_table",
+            "UPDATE .demo_table",
+        ] {
+            assert!(
+                formatted.contains(target),
+                "MariaDB leading-dot qualifier lost its keyword separator `{target}`:\n{formatted}"
+            );
+        }
+        assert_eq!(
+            SqlEditorWidget::format_for_auto_formatting_with_db_type(
+                &formatted,
+                false,
+                Some(crate::db::connection::DatabaseType::MariaDB),
+            ),
+            formatted,
+            "MariaDB leading-dot formatting must be idempotent"
+        );
+    }
+
     #[test]
     fn format_for_auto_formatting_keeps_parenthesized_sql_macro_body_attached() {
         let source = r#"CREATE OR REPLACE FUNCTION topn RETURN VARCHAR2 SQL_MACRO(TABLE)

src/ui/sql_editor/intellisense/completion.rs

@@ -65154,6 +65154,35 @@ impl SqlEditorWidget {
             last_word_index_before("CURSOR").is_some_and(|cursor_idx| {
                 last_word_index_before("SELECT").is_none_or(|select_idx| cursor_idx > select_idx)
             });
+        if mysql_compatible
+            && previous_is_symbol("{")
+            && next_idx.is_some_and(
+                |idx| matches!(tokens.get(idx), Some(SqlToken::String(_))),
+            )
+            && ["D", "T", "TS"]
+                .iter()
+                .any(|keyword| matches_prefix(keyword))
+        {
+            return Some(&["D", "T", "TS"]);
+        }
+        if matches_prefix("ON")
+            && previous_word.is_some_and(|word| {
+                matches!(
+                    word.to_ascii_uppercase().as_str(),
+                    "ERROR" | "FALSE" | "NULL" | "TRUE"
+                )
+            })
+            && next_word.is_some_and(|word| {
+                matches!(word.to_ascii_uppercase().as_str(), "EMPTY" | "ERROR")
+            })
+            && Self::cursor_is_inside_table_function_columns_clause_matching(
+                tokens,
+                structural_end,
+                |table_fn| table_fn.eq_ignore_ascii_case("JSON_TABLE"),
+            )
+        {
+            return Some(&["ON"]);
+        }
         if matches_prefix("JOIN")
             && matches!(
                 phase,
@@ -67394,11 +67423,35 @@ impl SqlEditorWidget {
                 return Some(&["DUALITY"]);
             }
             if matches_prefix("WITH")
-                && has("DUALITY")
+                && (has("DUALITY")
+                    || (matches!(phase, intellisense_context::SqlPhase::FromClause)
+                        && has("SELECT")
+                        && has("JSON")))
                 && next_word.is_some_and(|word| word.eq_ignore_ascii_case("UPDATE"))
             {
                 return Some(&["WITH"]);
             }
+            if matches_prefix("WITH")
+                && matches!(phase, intellisense_context::SqlPhase::FromClause)
+                && has("SELECT")
+                && has("JSON")
+                && next_word.is_some_and(|word| {
+                    matches!(
+                        word.to_ascii_uppercase().as_str(),
+                        "INSERT" | "UPDATE" | "DELETE"
+                    )
+                })
+            {
+                return Some(&["WITH"]);
+            }
+            if matches_prefix("FROM")
+                && previous_is_symbol("}")
+                && has("SELECT")
+                && has("JSON")
+                && next_is_identifier_or_string
+            {
+                return Some(&["FROM"]);
+            }
             if matches_prefix("UPDATE") && has("DUALITY") {
                 return Some(&["UPDATE"]);
             }