자동 포멧팅 기능 개선

Author: letspurify-ux

src/sql_parser_engine/engine.rs

@@ -1390,14 +1390,99 @@ impl SqlParserEngine {
         let mut scratch_chars = std::mem::take(&mut self.scratch_chars);
         scratch_chars.clear();
         scratch_chars.extend(text.chars());
-        let mut on_symbol = |_: &[char], _: usize, _: char, _: Option<char>| {};
-        let mut on_statement_boundary = |_: &[char], _: usize| {};
-        self.process_chars_with_observer(
-            &scratch_chars,
-            &mut on_symbol,
-            &mut on_statement_boundary,
-            &mut on_lexical_span,
-        );
+        let mut line_start = 0usize;
+
+        while line_start < scratch_chars.len() {
+            let line_end = scratch_chars[line_start..]
+                .iter()
+                .position(|ch| *ch == '\n')
+                .map_or(scratch_chars.len(), |offset| line_start + offset);
+            let chunk_end = usize::from(line_end < scratch_chars.len())
+                .saturating_add(line_end)
+                .min(scratch_chars.len());
+            let line: String = scratch_chars[line_start..line_end].iter().collect();
+            let line_started_with_empty_current = self.current_is_empty();
+            let current_has_only_sql_comments =
+                next_meaningful_word(self.current.as_str(), 0).is_none();
+            let current_is_effectively_empty =
+                line_started_with_empty_current || current_has_only_sql_comments;
+            let line_started_in_with_waiting_main_query =
+                self.state.in_with_plsql_declaration()
+                    && self.state.with_clause_waiting_main_query()
+                    && self.state.block_depth() == 0
+                    && self.state.paren_depth() == 0;
+            self.state
+                .close_foreign_module_source_on_terminator_line(&line);
+            let line_boundary_action = self
+                .state
+                .line_boundary_action_for_line(&line, current_is_effectively_empty);
+            if self.apply_line_boundary_action(line_boundary_action) {
+                line_start = chunk_end;
+                continue;
+            }
+            let line_starts_at_statement_boundary = self.state.is_idle()
+                && self.state.block_depth() == 0
+                && self.state.paren_depth() == 0
+                && !self.state.in_with_plsql_declaration()
+                && current_is_effectively_empty;
+            let sqlplus_remark_line = sql_text::is_sqlplus_remark_comment_line(&line);
+            let auto_terminated_tool_command = sqlplus_remark_line
+                || (sql_text::is_auto_terminated_tool_command(&line)
+                    && !self.line_is_mysql_server_statement(&line));
+
+            if (line_starts_at_statement_boundary
+                || (line_started_in_with_waiting_main_query && self.state.is_idle()))
+                && auto_terminated_tool_command
+            {
+                let is_comment_like_tool_line = sql_text::first_meaningful_word(&line)
+                    .is_some_and(|word| word.eq_ignore_ascii_case("PROMPT"));
+                if is_comment_like_tool_line {
+                    on_lexical_span(
+                        &scratch_chars,
+                        line_start,
+                        line_end,
+                        LexicalKind::LineComment,
+                    );
+                }
+                self.append_current_str(&line);
+                if chunk_end > line_end {
+                    self.append_current_char('\n');
+                }
+                self.finish_current_statement();
+                line_start = chunk_end;
+                continue;
+            }
+
+            let mut on_symbol = |_: &[char], _: usize, _: char, _: Option<char>| {};
+            let mut on_statement_boundary = |_: &[char], _: usize| {};
+            let mut offset_lexical_span =
+                |_: &[char], start: usize, end: usize, kind: LexicalKind| {
+                    on_lexical_span(
+                        &scratch_chars,
+                        line_start.saturating_add(start),
+                        line_start.saturating_add(end),
+                        kind,
+                    );
+                };
+            self.process_chars_with_observer(
+                &scratch_chars[line_start..chunk_end],
+                &mut on_symbol,
+                &mut on_statement_boundary,
+                &mut offset_lexical_span,
+            );
+            self.state.clear_skip_next_end_label_token();
+
+            if (line_started_with_empty_current || line_started_in_with_waiting_main_query)
+                && self.state.is_idle()
+                && self.state.block_depth() == 0
+                && self.state.paren_depth() == 0
+                && auto_terminated_tool_command
+            {
+                self.finish_current_statement();
+            }
+
+            line_start = chunk_end;
+        }
         self.scratch_chars = scratch_chars;
     }
 

src/sql_parser_engine/tests.rs

@@ -68,6 +68,71 @@ fn lexical_spans_apply_mysql_escape_and_dash_comment_rules() {
     }));
 }
 
+#[test]
+fn lexical_spans_treat_sqlplus_prompt_payload_as_opaque_line_text() {
+    let sql = concat!(
+        "PROMPT [w10] don't stop; keep going -- not a SQL comment\n",
+        "SELECT 1 AS \"it's\", q'\"double quoted q\"' AS q_value FROM dual;\n",
+        "SELECT \"SELECT\" + \"order\" FROM quoted_words;"
+    );
+    let spans = lexical_spans(sql, false);
+
+    let prompt_start = sql.find("PROMPT").expect("PROMPT line");
+    let prompt_end = sql.find('\n').expect("PROMPT line end");
+    assert!(spans.iter().any(|span| {
+        span.kind == LexicalKind::LineComment
+            && span.start == prompt_start
+            && span.end == prompt_end
+    }));
+
+    for quoted in ["\"it's\"", "\"SELECT\"", "\"order\""] {
+        let start = sql.find(quoted).expect("quoted identifier");
+        assert!(spans.iter().any(|span| {
+            span.kind == LexicalKind::QuotedIdentifier
+                && span.start <= start
+                && start + quoted.len() <= span.end
+        }));
+    }
+
+    let q_quote = "q'\"double quoted q\"'";
+    let q_quote_start = sql.find(q_quote).expect("q-quote");
+    assert!(spans.iter().any(|span| {
+        span.kind == LexicalKind::String
+            && span.start <= q_quote_start
+            && q_quote_start + q_quote.len() <= span.end
+    }));
+}
+
+#[test]
+fn lexical_spans_keep_oracle_final_hardcore_wave10_quotes_bounded() {
+    let sql = include_str!("../../test/final_hardcore.sql");
+    let spans = lexical_spans(sql, false);
+
+    let prompt_apostrophe = sql.find("don't stop").expect("PROMPT apostrophe") + 3;
+    assert_eq!(
+        super::lexical_kind_at(&spans, prompt_apostrophe),
+        Some(LexicalKind::LineComment),
+        "PROMPT payload must not open a SQL string"
+    );
+
+    for quoted in ["\"it's\"", "\"trailing space \"", "\"SELECT\"", "\"order\""] {
+        let start = sql.find(quoted).expect("quoted identifier");
+        assert_eq!(
+            super::lexical_kind_at(&spans, start),
+            Some(LexicalKind::QuotedIdentifier),
+            "{quoted} must start its own quoted-identifier span"
+        );
+        assert!(
+            spans.iter().any(|span| {
+                span.kind == LexicalKind::QuotedIdentifier
+                    && span.start == start
+                    && span.end == start + quoted.len()
+            }),
+            "{quoted} must close without contaminating following SQL"
+        );
+    }
+}
+
 #[test]
 fn pending_subprogram_begin_counter_does_not_underflow_on_malformed_nested_end() {
     let mut state = SplitState {

src/sql_text.rs

@@ -49,7 +49,11 @@ pub const ORACLE_SQL_KEYWORDS: &[&str] = &[
     "BETWEEN",
     "BFILE",
     "BINARY_DOUBLE",
+    "BINARY_DOUBLE_INFINITY",
+    "BINARY_DOUBLE_NAN",
     "BINARY_FLOAT",
+    "BINARY_FLOAT_INFINITY",
+    "BINARY_FLOAT_NAN",
     "BINARY_INTEGER",
     "BITMAP",
     "BLOB",

src/ui/builtin_signatures.rs

@@ -7459,6 +7459,7 @@ pub const MARIADB_FUNCTIONS: &[&str] = &[
     "REVERSE",
     "RIGHT",
     "ROUND",
+    "ROWNUM",
     "ROW_COUNT",
     "ROW_NUMBER",
     "RPAD",
@@ -9773,6 +9774,13 @@ const MARIADB_SIGNATURES: &[BuiltinSignature] = &[
         ],
         argument_separator_keywords: &[],
     },
+    BuiltinSignature {
+        name: "ROWNUM",
+        syntaxes: &[
+            "ROWNUM()",
+        ],
+        argument_separator_keywords: &[],
+    },
     BuiltinSignature {
         name: "ROW_COUNT",
         syntaxes: &[

src/ui/builtin_signatures_live_tests.rs

@@ -32,7 +32,7 @@ fn assert_catalog(db_type: DatabaseType, names: &[&str], expected_len: usize) {
 fn builtin_signature_catalogs_match_official_manual_indices() {
     assert_catalog(DatabaseType::Oracle, ORACLE_FUNCTIONS, 474);
     assert_catalog(DatabaseType::MySQL, MYSQL_FUNCTIONS, 408);
-    assert_catalog(DatabaseType::MariaDB, MARIADB_FUNCTIONS, 477);
+    assert_catalog(DatabaseType::MariaDB, MARIADB_FUNCTIONS, 478);
 }
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]

src/ui/sql_editor/format_sweep_tests.rs

@@ -2078,10 +2078,10 @@ COMMIT AND NO CHAIN;"#;
 
 #[test]
 fn formatting_sweep_mysql_xa_and_show_server_statements_are_stable() {
-    let source = r#"XA START 'sq-final-xa';
-XA END 'sq-final-xa';
-XA PREPARE 'sq-final-xa';
-XA COMMIT 'sq-final-xa';
+    let source = r#"XA START 'sq-final-xa', 'branch-one', 1;
+XA END 'sq-final-xa', 'branch-one', 1;
+XA PREPARE 'sq-final-xa', 'branch-one', 1;
+XA COMMIT 'sq-final-xa', 'branch-one', 1;
 SHOW CREATE DATABASE sq_manual_final;
 SHOW CREATE TABLE sq_manual_table;"#;
 
@@ -2093,7 +2093,17 @@ SHOW CREATE TABLE sq_manual_table;"#;
             run.issues,
             run.formatted
         );
-        assert!(run.formatted.contains("XA START 'sq-final-xa';"));
+        assert!(
+            run.formatted.contains("XA START 'sq-final-xa',")
+                && run.formatted.contains("'branch-one',")
+                && run.formatted.contains("1;"),
+            "{db_type:?} XA three-part XID was not preserved:\n{}",
+            run.formatted
+        );
+        assert!(
+            run.managed_list_owner_kinds.contains(&ListOwnerKind::XaXid),
+            "{db_type:?} XA XID components must have a typed list owner"
+        );
         assert!(run
             .formatted
             .contains("SHOW CREATE DATABASE sq_manual_final;"));
@@ -3775,7 +3785,7 @@ fn formatting_sweep_list_owner_inventory_covers_every_typed_variant() {
         ),
         (
             DatabaseType::MySQL,
-            "UPDATE t1, t2 SET t1.v = 1, t2.v = 2; ALTER TABLE t1 ADD a INT, ADD b INT; DROP TABLE IF EXISTS old_a, old_b; RENAME TABLE old_c TO new_c, old_d TO new_d; LOCK TABLES new_c READ, new_d WRITE; ANALYZE TABLE new_c, new_d; CREATE USER user_a IDENTIFIED BY 'x', user_b IDENTIFIED BY 'y';",
+            "UPDATE t1, t2 SET t1.v = 1, t2.v = 2; ALTER TABLE t1 ADD a INT, ADD b INT; DROP TABLE IF EXISTS old_a, old_b; RENAME TABLE old_c TO new_c, old_d TO new_d; LOCK TABLES new_c READ, new_d WRITE; ANALYZE TABLE new_c, new_d; CREATE USER user_a IDENTIFIED BY 'x', user_b IDENTIFIED BY 'y'; XA START 'gtrid', 'branch', 1;",
         ),
     ];