자동 포멧팅 기능 개선

Author: letspurify-ux

src/db/transaction.rs

@@ -69,6 +69,7 @@ pub struct SessionResidueState {
     may_have_prepared_statement: bool,
     may_have_user_variable: bool,
     may_have_session_setting: bool,
+    may_have_statement_diagnostics: bool,
     may_have_next_transaction_mode_override: bool,
     may_have_transaction_mode_override: bool,
     may_have_untracked_session_state: bool,
@@ -512,6 +513,7 @@ impl SessionResidueState {
             may_have_prepared_statement: effects.creates_prepared_statement,
             may_have_user_variable: effects.sets_user_variable,
             may_have_session_setting: effects.sets_session_setting,
+            may_have_statement_diagnostics: effects.sets_statement_diagnostics,
             may_have_next_transaction_mode_override: effects.sets_next_transaction_mode_override,
             may_have_transaction_mode_override: effects.sets_transaction_mode_override,
             may_have_untracked_session_state: effects.may_leave_unknown_state,
@@ -527,6 +529,8 @@ impl SessionResidueState {
             may_have_user_variable: self.may_have_user_variable || other.may_have_user_variable,
             may_have_session_setting: self.may_have_session_setting
                 || other.may_have_session_setting,
+            may_have_statement_diagnostics: self.may_have_statement_diagnostics
+                || other.may_have_statement_diagnostics,
             may_have_next_transaction_mode_override: self.may_have_next_transaction_mode_override
                 || other.may_have_next_transaction_mode_override,
             may_have_transaction_mode_override: self.may_have_transaction_mode_override
@@ -540,14 +544,22 @@ impl SessionResidueState {
         if effects.clears_all_session_residue {
             return Self::default();
         }
-        let state = if effects.consumes_next_transaction_mode_override {
+        let state = if effects.clears_statement_diagnostics {
             Self {
-                may_have_next_transaction_mode_override: false,
+                may_have_statement_diagnostics: false,
                 ..self
             }
         } else {
             self
         };
+        let state = if effects.consumes_next_transaction_mode_override {
+            Self {
+                may_have_next_transaction_mode_override: false,
+                ..state
+            }
+        } else {
+            state
+        };
         state.merged_with(Self::from_effects(effects))
     }
 
@@ -556,6 +568,7 @@ impl SessionResidueState {
             || self.may_have_prepared_statement
             || self.may_have_user_variable
             || self.may_have_session_setting
+            || self.may_have_statement_diagnostics
             || self.may_have_untracked_session_state
     }
 
@@ -616,6 +629,13 @@ impl SessionResidueState {
             ..self
         }
     }
+
+    fn with_statement_diagnostics_cleared(self) -> Self {
+        Self {
+            may_have_statement_diagnostics: false,
+            ..self
+        }
+    }
 }
 
 pub(crate) fn mysql_statement_can_cleanup_retained_session_for_preflight(
@@ -900,6 +920,8 @@ struct StatementSessionResidueEffects {
     creates_prepared_statement: bool,
     sets_user_variable: bool,
     sets_session_setting: bool,
+    sets_statement_diagnostics: bool,
+    clears_statement_diagnostics: bool,
     sets_next_transaction_mode_override: bool,
     sets_transaction_mode_override: bool,
     consumes_next_transaction_mode_override: bool,
@@ -913,10 +935,19 @@ impl StatementSessionResidueEffects {
             || self.creates_prepared_statement
             || self.sets_user_variable
             || self.sets_session_setting
+            || self.sets_statement_diagnostics
             || self.sets_next_transaction_mode_override
             || self.sets_transaction_mode_override
             || self.may_leave_unknown_state
     }
+
+    fn without_statement_diagnostics(self) -> Self {
+        Self {
+            sets_statement_diagnostics: false,
+            clears_statement_diagnostics: false,
+            ..self
+        }
+    }
 }
 
 #[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
@@ -983,6 +1014,10 @@ impl StatementSessionEffects {
         self.session_residue.may_leave_session_residue()
     }
 
+    pub(crate) fn preserves_statement_diagnostics(self) -> bool {
+        self.session_residue.sets_statement_diagnostics
+    }
+
     pub(crate) fn has_implicit_commit(self) -> bool {
         self.transaction.has_implicit_commit
     }
@@ -1425,7 +1460,10 @@ impl MySqlBatchSessionEffects {
         } else {
             self.session_residue_state = self
                 .session_residue_state
-                .merged_with(SessionResidueState::from_effects(effects.session_residue));
+                .with_statement_diagnostics_cleared()
+                .merged_with(SessionResidueState::from_effects(
+                    effects.session_residue.without_statement_diagnostics(),
+                ));
         }
 
         if cleanup_effects_confirmed && effects.releases_table_lock() {
@@ -1973,7 +2011,11 @@ pub(crate) fn retained_session_state_after_statement(
         } else {
             prior_state.session_residue_state()
         };
-        prior_residue.merged_with(SessionResidueState::from_effects(effects.session_residue))
+        prior_residue
+            .with_statement_diagnostics_cleared()
+            .merged_with(SessionResidueState::from_effects(
+                effects.session_residue.without_statement_diagnostics(),
+            ))
     } else if effects.releases_physical_session() {
         SessionResidueState::default()
     } else {
@@ -4256,6 +4298,14 @@ fn mysql_session_residue_effects_for_analysis(
 
     let leading_keyword = analysis.leading_keyword();
     let mut effects = StatementSessionResidueEffects::default();
+    let sets_found_rows = matches!(leading_keyword, Some("SELECT" | "WITH"))
+        && analysis
+            .words()
+            .iter()
+            .any(|word| word == "SQL_CALC_FOUND_ROWS");
+    effects.sets_statement_diagnostics =
+        sets_found_rows || analysis.classify_for_db_type(db_type) == SqlKind::Dml;
+    effects.clears_statement_diagnostics = !effects.sets_statement_diagnostics;
     if mysql_statement_assigns_user_variable(sql, analysis) {
         effects.sets_user_variable = true;
     }
@@ -5661,6 +5711,56 @@ mod tests {
         assert!(!plain_hint.may_leave_untracked_session_state);
     }
 
+    #[test]
+    fn mysql_statement_diagnostics_are_retained_until_the_next_select() {
+        for db_type in [DatabaseType::MySQL, DatabaseType::MariaDB] {
+            let post_processor = statement_session_post_processor_for(db_type);
+            for sql in [
+                "UPDATE t SET value = value + 1",
+                "SELECT SQL_CALC_FOUND_ROWS id FROM t LIMIT 1",
+            ] {
+                let effects = post_processor.effects_for_sql(sql);
+                assert!(
+                    effects.preserves_statement_diagnostics(),
+                    "{db_type} should preserve diagnostics after `{sql}`"
+                );
+                let retained = retained_session_state_after_statement(
+                    post_processor,
+                    RetainedSessionState::default(),
+                    effects,
+                    false,
+                    false,
+                    false,
+                    false,
+                );
+                assert!(
+                    retained.may_have_untracked_session_state(),
+                    "{db_type} should retain the physical session after `{sql}`"
+                );
+
+                let next_select = post_processor.effects_for_sql("SELECT ROW_COUNT()");
+                assert!(!next_select.preserves_statement_diagnostics());
+                let cleared = retained_session_state_after_statement(
+                    post_processor,
+                    retained,
+                    next_select,
+                    false,
+                    false,
+                    false,
+                    false,
+                );
+                assert!(
+                    !cleared.may_have_untracked_session_state(),
+                    "{db_type} should release consumed diagnostics after the next SELECT"
+                );
+            }
+
+            assert!(!post_processor
+                .effects_for_sql("SELECT 'SQL_CALC_FOUND_ROWS' AS note")
+                .preserves_statement_diagnostics());
+        }
+    }
+
     #[test]
     fn mysql_with_select_session_side_effects_are_tracked() {
         let assignment_hint = mysql_session_state_hint_for_sql(

src/ui/intellisense.rs

@@ -339,6 +339,10 @@ pub struct IntellisenseData {
     member_kinds_by_qualifier: HashMap<String, HashMap<String, HashSet<QualifiedMemberKind>>>,
     relation_member_entries_by_qualifier: HashMap<String, Vec<NameEntry>>,
     collection_element_type_by_type: HashMap<String, String>,
+    /// Declared object type of a column, keyed `TABLE.COLUMN`. Lets a
+    /// `alias.object_column.` chain resolve to the type's attributes/methods
+    /// even when nothing in the statement text spells the type out.
+    object_type_by_column: HashMap<String, String>,
     synonym_target_by_synonym: HashMap<String, String>,
     relations_upper: HashSet<String>,
     /// Names of virtual tables (CTEs, subquery aliases) whose columns were
@@ -427,6 +431,7 @@ impl IntellisenseData {
             member_kinds_by_qualifier: HashMap::new(),
             relation_member_entries_by_qualifier: HashMap::new(),
             collection_element_type_by_type: HashMap::new(),
+            object_type_by_column: HashMap::new(),
             synonym_target_by_synonym: HashMap::new(),
             relations_upper: HashSet::new(),
             virtual_table_keys: HashSet::new(),
@@ -1199,6 +1204,33 @@ impl IntellisenseData {
         self.collection_element_type_by_type.insert(key, element);
     }
 
+    pub fn set_object_type_for_column(&mut self, table: &str, column: &str, type_name: &str) {
+        let table_key = Self::normalize_qualifier_lookup_key(table);
+        let column_key = Self::normalize_qualifier_lookup_key(column);
+        let type_key = Self::normalize_qualifier_lookup_key(type_name);
+        if table_key.is_empty() || column_key.is_empty() || type_key.is_empty() {
+            return;
+        }
+        self.object_type_by_column
+            .insert(format!("{table_key}.{column_key}"), type_key);
+    }
+
+    pub fn object_type_for_column(&self, table: &str, column: &str) -> Option<&str> {
+        let column_key = Self::normalize_qualifier_lookup_key(column);
+        if column_key.is_empty() {
+            return None;
+        }
+        for table_key in Self::qualifier_lookup_keys(table) {
+            if let Some(type_name) = self
+                .object_type_by_column
+                .get(&format!("{table_key}.{column_key}"))
+            {
+                return Some(type_name.as_str());
+            }
+        }
+        None
+    }
+
     pub fn collection_element_type_for_type(&self, collection_type: &str) -> Option<&str> {
         for key in Self::qualifier_lookup_keys(collection_type) {
             if let Some(element_type) = self.collection_element_type_by_type.get(&key) {

src/ui/intellisense_context.rs

@@ -785,6 +785,14 @@ fn ddl_alter_table_add_action_is_new_name(
     action_words: &[String],
     action_ends_with_dot: bool,
 ) -> bool {
+    let action_words = match action_words {
+        [if_kw, not_kw, exists_kw, rest @ ..]
+            if if_kw == "IF" && not_kw == "NOT" && exists_kw == "EXISTS" =>
+        {
+            rest
+        }
+        _ => action_words,
+    };
     match action_words {
         [] => true,
         [word] if word == "CONSTRAINT" => true,
@@ -8087,13 +8095,18 @@ fn parse_top_level_pivot_clause(tokens: &[SqlToken]) -> Option<PivotClauseColumn
     let aggregate_columns = parse_pivot_aggregate_columns(&clause_tokens[..for_idx]);
     let aggregate_aliases = parse_pivot_aggregate_aliases(&clause_tokens[..for_idx]);
     let for_columns = parse_identifier_segment(&clause_tokens[for_idx + 1..in_idx]);
-    let generated_columns = if pivot_mode.should_skip_generated_columns() {
-        Vec::new()
-    } else {
-        parse_pivot_generated_columns_from_in_segment(
+    let generated_columns = match pivot_mode {
+        PivotMode::Regular => parse_pivot_generated_columns_from_in_segment(
             &clause_tokens[in_idx + 1..],
             &aggregate_aliases,
-        )
+        ),
+        PivotMode::Xml => {
+            let name = for_columns.join("_");
+            (!name.is_empty())
+                .then(|| format!("{name}_XML"))
+                .into_iter()
+                .collect()
+        }
     };
 
     let mut result = PivotClauseColumns {
@@ -12702,12 +12715,6 @@ enum PivotMode {
     Xml,
 }
 
-impl PivotMode {
-    fn should_skip_generated_columns(self) -> bool {
-        matches!(self, Self::Xml)
-    }
-}
-
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 enum IdentifierPathState {
     ExpectIdentifier,

src/ui/intellisense_context/tests.rs

@@ -7536,13 +7536,13 @@ fn extract_oracle_pivot_projection_columns_unescapes_string_literals_without_ali
 }
 
 #[test]
-fn extract_oracle_pivot_xml_projection_keeps_source_columns_without_generated_aliases() {
+fn extract_oracle_pivot_xml_projection_includes_the_generated_xml_column() {
     let tokens = tokenize(
         "SELECT * FROM (SELECT DEPTNO, job, SAL FROM oqt_t_emp) \
          PIVOT XML (SUM(SAL) FOR DEPTNO IN (ANY))",
     );
     let cols = extract_oracle_pivot_unpivot_projection_columns(&tokens);
-    assert_eq!(cols, vec!["job"]);
+    assert_eq!(cols, vec!["job", "DEPTNO_XML"]);
 }
 
 #[test]
@@ -10076,11 +10076,11 @@ fn full_join_table_position_is_table_context() {
 // ─── State machine regression tests ─────────────────────────────────────
 
 #[test]
-fn pivot_xml_skips_generated_columns() {
+fn pivot_xml_generates_one_xml_column() {
     let tokens =
         tokenize("SELECT * FROM sales PIVOT XML (SUM(amount) FOR quarter IN ('Q1' AS Q1))");
     let parsed = parse_top_level_pivot_clause(&tokens).expect("PIVOT XML clause should be parsed");
-    assert!(parsed.generated_columns.is_empty());
+    assert_eq!(parsed.generated_columns, vec!["quarter_XML".to_string()]);
     assert_eq!(parsed.for_columns, vec!["quarter".to_string()]);
     assert_eq!(parsed.aggregate_columns, vec!["amount".to_string()]);
 }