인텔리센스 기능 개선

letspurify-ux · letspurify-ux · commit 2134c87131ee · 2026-07-30T17:05:07.000+09:00
diff --git a/src/ui/intellisense_context.rs b/src/ui/intellisense_context.rs
@@ -218,6 +218,10 @@ pub struct CursorContext {
     pub qualifier: Option<String>,
     /// Resolved table names for the qualifier
     pub qualifier_tables: Vec<String>,
+    /// Visible Oracle row sources that use a `VERSIONS ... BETWEEN` clause.
+    /// Kept separately from catalog tables so completion can expose the
+    /// `VERSIONS_*` pseudocolumns only through the owning row-source alias.
+    oracle_flashback_versions_sources: Vec<ScopedTableRef>,
     /// The cursor introduces a brand-new DDL name or expects a data type
     /// (`ALTER TABLE t ADD <col> …`, `RENAME … TO <newname>`), where existing
     /// relations/columns/keywords are all irrelevant. Drives completion
@@ -229,6 +233,26 @@ pub struct CursorContext {
     pub(crate) with_plsql_awaiting_main_query_before_cursor_token: bool,
 }
 
+impl CursorContext {
+    pub(crate) fn qualifier_has_oracle_flashback_versions(&self, qualifier: &str) -> bool {
+        resolve_qualifier_table_refs(qualifier, &self.tables_in_scope)
+            .into_iter()
+            .any(|resolved| {
+                self.oracle_flashback_versions_sources.iter().any(|source| {
+                    resolved.depth == source.depth
+                        && resolved.is_cte == source.is_cte
+                        && normalize_identifier_for_lookup(&resolved.name)
+                            == normalize_identifier_for_lookup(&source.name)
+                        && resolved
+                            .alias
+                            .as_deref()
+                            .map(normalize_identifier_for_lookup)
+                            == source.alias.as_deref().map(normalize_identifier_for_lookup)
+                })
+            })
+    }
+}
+
 /// CTE parsing state machine
 #[derive(Debug, Clone, Copy, PartialEq)]
 enum CteState {
@@ -367,6 +391,16 @@ pub(crate) fn analyze_cursor_context_arc(
 ) -> CursorContext {
     let clamped_cursor_token_len = cursor_token_len.min(statement_tokens.len());
     let parse_result = scan_cursor_context(statement_tokens.as_ref(), clamped_cursor_token_len);
+    let visible_scope_ids: HashSet<usize> =
+        parse_result.visible_scope_chain.iter().copied().collect();
+    let oracle_flashback_versions_sources = parse_result
+        .parsed_tables
+        .iter()
+        .filter(|entry| {
+            entry.has_oracle_flashback_versions && visible_scope_ids.contains(&entry.scope_id)
+        })
+        .map(|entry| entry.table.clone())
+        .collect();
     let (active_query_range, in_set_operation_query_branch) = find_active_query_range(
         statement_tokens.as_ref(),
         &parse_result.parsed_ctes,
@@ -489,6 +523,7 @@ pub(crate) fn analyze_cursor_context_arc(
         focused_tables,
         qualifier: None,
         qualifier_tables: Vec::new(),
+        oracle_flashback_versions_sources,
         ddl_new_name_position,
         with_plsql_awaiting_main_query_before_cursor_token: parse_result
             .with_plsql_awaiting_main_query_before_cursor_token,
@@ -2026,6 +2061,7 @@ struct ParsedTableEntry {
     scope_id: usize,
     token_start: usize,
     origin: ParsedTableEntryOrigin,
+    has_oracle_flashback_versions: bool,
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -3335,6 +3371,7 @@ fn scan_cursor_context(tokens: &[SqlToken], cursor_token_len: usize) -> CursorSc
                                 scope_id: parent_scope_id,
                                 token_start: start_idx,
                                 origin: ParsedTableEntryOrigin::DerivedAlias,
+                                has_oracle_flashback_versions: false,
                             });
                             idx = next_idx;
                             close_parenthesis_scope(
@@ -3383,6 +3420,7 @@ fn scan_cursor_context(tokens: &[SqlToken], cursor_token_len: usize) -> CursorSc
                             scope_id: parent_scope_id,
                             token_start: start_idx,
                             origin: ParsedTableEntryOrigin::DerivedAlias,
+                            has_oracle_flashback_versions: false,
                         });
                         if depth_frames
                             .get(depth.saturating_sub(1))
@@ -4979,10 +5017,11 @@ fn scan_cursor_context(tokens: &[SqlToken], cursor_token_len: usize) -> CursorSc
                                     direct_after_alias,
                                     direct_explicit_columns,
                                     direct_explicit_column_range,
+                                    has_oracle_flashback_versions,
                                 ) = if allow_relation_alias {
                                     parse_alias_deep_with_columns(tokens, relation_arg_end)
                                 } else {
-                                    (None, relation_arg_end, Vec::new(), None)
+                                    (None, relation_arg_end, Vec::new(), None, false)
                                 };
                                 let (direct_alias, direct_after_alias) = sanitize_lock_table_alias(
                                     tokens,
@@ -5078,6 +5117,7 @@ fn scan_cursor_context(tokens: &[SqlToken], cursor_token_len: usize) -> CursorSc
                                     scope_id,
                                     token_start: idx,
                                     origin: ParsedTableEntryOrigin::Relation,
+                                    has_oracle_flashback_versions,
                                 });
                                 if matches!(current_phase, SqlPhase::FromClause) {
                                     push_recent_relation_table(
@@ -6455,9 +6495,17 @@ fn push_bracket_identifier_part(inner: &mut String, part: &str, word_like: bool)
 fn parse_alias_deep_with_columns(
     tokens: &[SqlToken],
     start: usize,
-) -> (Option<String>, usize, Vec<String>, Option<TokenRange>) {
-    let start = skip_relation_postfix_clauses(tokens, start);
-    parse_relation_alias_at_with_columns(tokens, start, true)
+) -> (Option<String>, usize, Vec<String>, Option<TokenRange>, bool) {
+    let (start, has_oracle_flashback_versions) = scan_relation_postfix_clauses(tokens, start);
+    let (alias, next_idx, explicit_columns, explicit_column_range) =
+        parse_relation_alias_at_with_columns(tokens, start, true);
+    (
+        alias,
+        next_idx,
+        explicit_columns,
+        explicit_column_range,
+        has_oracle_flashback_versions,
+    )
 }
 
 fn parse_alias_after_derived_relation_clauses(
@@ -6484,7 +6532,12 @@ fn parse_alias_after_derived_relation_clauses(
 }
 
 fn skip_relation_postfix_clauses(tokens: &[SqlToken], start: usize) -> usize {
+    scan_relation_postfix_clauses(tokens, start).0
+}
+
+fn scan_relation_postfix_clauses(tokens: &[SqlToken], start: usize) -> (usize, bool) {
     let mut idx = skip_comment_tokens(tokens, start);
+    let mut has_oracle_flashback_versions = false;
 
     loop {
         let Some(SqlToken::Word(word)) = tokens.get(idx) else {
@@ -6645,6 +6698,7 @@ fn skip_relation_postfix_clauses(tokens: &[SqlToken], start: usize) -> usize {
 
                 idx = skip_flashback_bound_expression(tokens, and_idx + 1);
                 idx = skip_comment_tokens(tokens, idx);
+                has_oracle_flashback_versions = true;
                 continue;
             }
             "AS" => {
@@ -6678,7 +6732,7 @@ fn skip_relation_postfix_clauses(tokens: &[SqlToken], start: usize) -> usize {
         }
     }
 
-    idx
+    (idx, has_oracle_flashback_versions)
 }
 
 fn skip_mysql_index_hint_clause(tokens: &[SqlToken], start: usize) -> Option<usize> {
@@ -7448,23 +7502,22 @@ fn filter_visible_scope_entries_declared_before_cursor_with_pos(
         .collect()
 }
 
-/// Resolve a qualifier only against row sources visible in the current scope.
-pub fn resolve_qualifier_tables(
+fn resolve_qualifier_table_refs<'a>(
     qualifier: &str,
-    tables_in_scope: &[ScopedTableRef],
-) -> Vec<String> {
-    fn unique_deepest_match(candidates: &[(usize, String)]) -> Vec<String> {
-        let Some(max_depth) = candidates.iter().map(|(depth, _)| *depth).max() else {
+    tables_in_scope: &'a [ScopedTableRef],
+) -> Vec<&'a ScopedTableRef> {
+    fn unique_deepest_match(candidates: Vec<&ScopedTableRef>) -> Vec<&ScopedTableRef> {
+        let Some(max_depth) = candidates.iter().map(|table_ref| table_ref.depth).max() else {
             return Vec::new();
         };
         let mut deepest = candidates
-            .iter()
-            .filter(|(depth, _)| *depth == max_depth)
-            .map(|(_, name)| name.clone())
+            .into_iter()
+            .filter(|table_ref| table_ref.depth == max_depth)
             .collect::<Vec<_>>();
-        deepest.sort_by_key(|name| normalize_identifier_for_lookup(name));
+        deepest.sort_by_key(|table_ref| normalize_identifier_for_lookup(&table_ref.name));
         deepest.dedup_by(|left, right| {
-            normalize_identifier_for_lookup(left) == normalize_identifier_for_lookup(right)
+            normalize_identifier_for_lookup(&left.name)
+                == normalize_identifier_for_lookup(&right.name)
         });
         if deepest.len() == 1 {
             deepest
@@ -7486,37 +7539,48 @@ pub fn resolve_qualifier_tables(
             .map(|a| normalize_identifier_for_lookup(a));
 
         if alias_upper.as_deref() == Some(qualifier_upper.as_str()) {
-            alias_matches.push((table_ref.depth, table_ref.name.clone()));
+            alias_matches.push(table_ref);
             continue;
         }
 
         if name_upper == qualifier_upper {
-            name_matches.push((table_ref.depth, table_ref.name.clone()));
+            name_matches.push(table_ref);
             continue;
         }
 
         if last_identifier_part_for_lookup(&table_ref.name)
             .is_some_and(|short| short.eq_ignore_ascii_case(&qualifier_upper))
         {
-            short_name_matches.push((table_ref.depth, table_ref.name.clone()));
+            short_name_matches.push(table_ref);
         }
     }
 
     if !alias_matches.is_empty() {
-        return unique_deepest_match(&alias_matches);
+        return unique_deepest_match(alias_matches);
     }
 
     if !name_matches.is_empty() {
-        return unique_deepest_match(&name_matches);
+        return unique_deepest_match(name_matches);
     }
 
     if !short_name_matches.is_empty() {
-        return unique_deepest_match(&short_name_matches);
+        return unique_deepest_match(short_name_matches);
     }
 
     Vec::new()
 }
 
+/// Resolve a qualifier only against row sources visible in the current scope.
+pub fn resolve_qualifier_tables(
+    qualifier: &str,
+    tables_in_scope: &[ScopedTableRef],
+) -> Vec<String> {
+    resolve_qualifier_table_refs(qualifier, tables_in_scope)
+        .into_iter()
+        .map(|table_ref| table_ref.name.clone())
+        .collect()
+}
+
 /// Resolve all table names from scope (for unqualified column suggestions).
 pub fn resolve_all_scope_tables(tables_in_scope: &[ScopedTableRef]) -> Vec<String> {
     let mut ordered_tables: Vec<(usize, &ScopedTableRef)> =
diff --git a/src/ui/intellisense_context/tests.rs b/src/ui/intellisense_context/tests.rs
@@ -10483,6 +10483,7 @@ fn oracle_as_of_clause_preserves_alias_after_modifier() {
     let ctx = analyze("SELECT e.| FROM employees AS OF SCN 12345 e");
     let tables = resolve_qualifier_tables("e", &ctx.tables_in_scope);
     assert_eq!(tables, vec!["employees".to_string()]);
+    assert!(!ctx.qualifier_has_oracle_flashback_versions("e"));
 }
 
 #[test]
@@ -10497,6 +10498,23 @@ fn oracle_versions_clause_preserves_alias_after_modifier() {
     let ctx = analyze("SELECT e.| FROM employees VERSIONS BETWEEN SCN MINVALUE AND MAXVALUE e");
     let tables = resolve_qualifier_tables("e", &ctx.tables_in_scope);
     assert_eq!(tables, vec!["employees".to_string()]);
+    assert!(ctx.qualifier_has_oracle_flashback_versions("e"));
+}
+
+#[test]
+fn oracle_versions_metadata_follows_its_visible_alias_and_scope() {
+    let joined = analyze(
+        "SELECT d.| FROM employees VERSIONS BETWEEN SCN MINVALUE AND MAXVALUE e \
+         JOIN departments d ON e.department_id = d.department_id",
+    );
+    assert!(joined.qualifier_has_oracle_flashback_versions("e"));
+    assert!(!joined.qualifier_has_oracle_flashback_versions("d"));
+
+    let shadowed = analyze(
+        "SELECT * FROM employees VERSIONS BETWEEN SCN MINVALUE AND MAXVALUE e \
+         WHERE EXISTS (SELECT 1 FROM departments e WHERE e.|)",
+    );
+    assert!(!shadowed.qualifier_has_oracle_flashback_versions("e"));
 }
 
 #[test]
diff --git a/src/ui/sql_editor/intellisense/completion.rs b/src/ui/sql_editor/intellisense/completion.rs
@@ -5381,18 +5381,23 @@ impl SqlEditorWidget {
                     Some(snapshot.preferred_db_type),
                 )
             {
-                for pseudo in [
-                    "ROWID",
-                    "ORA_ROWSCN",
-                    // A `VERSIONS BETWEEN ...` row source also exposes the
-                    // flashback version pseudo-columns through its alias.
-                    "VERSIONS_STARTSCN",
-                    "VERSIONS_STARTTIME",
-                    "VERSIONS_ENDSCN",
-                    "VERSIONS_ENDTIME",
-                    "VERSIONS_XID",
-                    "VERSIONS_OPERATION",
-                ] {
+                let has_flashback_versions =
+                    deep_ctx.qualifier_has_oracle_flashback_versions(qualifier);
+                let pseudocolumns: &[&str] = if has_flashback_versions {
+                    &[
+                        "ROWID",
+                        "ORA_ROWSCN",
+                        "VERSIONS_STARTSCN",
+                        "VERSIONS_STARTTIME",
+                        "VERSIONS_ENDSCN",
+                        "VERSIONS_ENDTIME",
+                        "VERSIONS_XID",
+                        "VERSIONS_OPERATION",
+                    ]
+                } else {
+                    &["ROWID", "ORA_ROWSCN"]
+                };
+                for &pseudo in pseudocolumns {
                     if crate::ui::intellisense::suggestion_matches_completion_prefix(
                         pseudo,
                         &snapshot.prefix,
@@ -7542,7 +7547,7 @@ impl SqlEditorWidget {
             Self::merge_suggestions_with_context_aliases(
                 suggestions,
                 early_qualified_visible_relation_column_suggestions,
-                true,
+                false,
             )
         };
         let suggestions = if early_oracle_graph_table_property_suggestions.is_empty() {
diff --git a/src/ui/sql_editor/intellisense/tests.rs b/src/ui/sql_editor/intellisense/tests.rs
