인텔리센스 기능 개선

Author: letspurify-ux

src/ui/intellisense_context.rs

@@ -2888,7 +2888,11 @@ impl RelationModifierState {
 fn is_row_limiting_fetch_clause(tokens: &[SqlToken], fetch_idx: usize) -> bool {
     matches!(
         next_word_upper(tokens, fetch_idx + 1),
-        Some((next_keyword, _)) if matches!(next_keyword.as_str(), "FIRST" | "NEXT")
+        Some((next_keyword, _))
+            if matches!(
+                next_keyword.as_str(),
+                "APPROXIMATE" | "EXACT" | "FIRST" | "NEXT"
+            )
     )
 }
 
@@ -3341,7 +3345,7 @@ fn scan_cursor_context(tokens: &[SqlToken], cursor_token_len: usize) -> CursorSc
                         if let Some((
                             alias,
                             next_idx,
-                            body_end,
+                            derived_body_end,
                             explicit_columns,
                             explicit_column_range,
                         )) = parse_subquery_alias(tokens, idx + 1)
@@ -3355,7 +3359,7 @@ fn scan_cursor_context(tokens: &[SqlToken], cursor_token_len: usize) -> CursorSc
                                     explicit_column_range,
                                     body_range: TokenRange {
                                         start: body_range.start,
-                                        end: body_end.max(body_range.end),
+                                        end: derived_body_end.unwrap_or(body_range.end),
                                     },
                                     depth: depth.saturating_sub(1),
                                 },
@@ -3786,6 +3790,26 @@ fn scan_cursor_context(tokens: &[SqlToken], cursor_token_len: usize) -> CursorSc
                     idx += 1;
                     continue;
                 }
+                if matches!(upper.as_str(), "TABLE" | "THE")
+                    && matches!(current_phase, SqlPhase::FromClause)
+                    && relation_state.is_expect_table()
+                {
+                    let open_idx = skip_comment_tokens(tokens, idx.saturating_add(1));
+                    if matches!(tokens.get(open_idx), Some(SqlToken::Symbol(sym)) if sym == "(")
+                        && is_query_expression_start(tokens, open_idx.saturating_add(1))
+                    {
+                        // Oracle collection-query wrappers (`TABLE (SELECT …)` and
+                        // legacy `THE (SELECT …)`) introduce a derived row source.
+                        // Keep the pending relation expectation until `(` so the
+                        // normal subquery tracker owns the body and its trailing
+                        // alias. Otherwise THE/TABLE is consumed as a relation
+                        // name and the first SELECT word is misparsed as its table.
+                        last_word = Some(upper);
+                        relation_state.expect_table();
+                        idx += 1;
+                        continue;
+                    }
+                }
                 if !(relation_modifier_state.blocks_outer_scope_cutoff()
                     && relation_state.is_expect_table())
                 {
@@ -7310,7 +7334,13 @@ fn matching_open_paren_before_close(tokens: &[SqlToken], close_idx: usize) -> Op
 fn parse_subquery_alias(
     tokens: &[SqlToken],
     start: usize,
-) -> Option<(String, usize, usize, Vec<String>, Option<TokenRange>)> {
+) -> Option<(
+    String,
+    usize,
+    Option<usize>,
+    Vec<String>,
+    Option<TokenRange>,
+)> {
     let mut idx = start;
     // An alias belongs to this derived relation only when it follows the closing
     // parenthesis in the same scope. Never step across another `)`: that token
@@ -7326,14 +7356,15 @@ fn parse_subquery_alias(
 
     idx = skip_relation_postfix_clauses(tokens, idx);
     let body_end = skip_derived_relation_postfix_clauses(tokens, idx);
+    let derived_body_end = (body_end > idx).then_some(body_end);
     let alias_start = skip_relation_postfix_clauses(tokens, body_end);
     let (alias, next_idx, explicit_columns, explicit_column_range) =
         parse_relation_alias_at_with_columns(tokens, alias_start, true);
     alias.map(|name| {
         (
             name,
             next_idx,
-            body_end,
+            derived_body_end,
             explicit_columns,
             explicit_column_range,
         )

src/ui/intellisense_context/tests.rs

@@ -10556,6 +10556,49 @@ fn extract_select_list_columns_supports_three_part_identifier_in_inline_view() {
     );
 }
 
+#[test]
+fn collection_query_wrappers_keep_inner_relation_scope() {
+    for wrapper in ["TABLE", "THE"] {
+        let sql = format!(
+            "SELECT legacy_owner.COLUMN_VALUE \
+             FROM {wrapper} (\
+               SELECT bag_owner.nums \
+               FROM sq_hard_bag bag_owner \
+               WHERE bag_owner.|\
+             ) legacy_owner"
+        );
+        let ctx = analyze(&sql);
+
+        assert_eq!(ctx.phase, SqlPhase::WhereClause, "wrapper={wrapper}");
+        assert_eq!(
+            resolve_qualifier_tables("bag_owner", &ctx.tables_in_scope),
+            vec!["sq_hard_bag".to_string()],
+            "wrapper={wrapper}, tables={:?}",
+            ctx.tables_in_scope
+        );
+    }
+}
+
+#[test]
+fn fromless_lateral_subquery_body_excludes_enclosing_close_parenthesis() {
+    let ctx = analyze(
+        "SELECT sample_owner.| \
+         FROM LATERAL (SELECT make_point(route_path) AS point_value) sample_owner",
+    );
+    let subquery = ctx
+        .subqueries
+        .iter()
+        .find(|subquery| subquery.alias.eq_ignore_ascii_case("sample_owner"))
+        .expect("LATERAL subquery alias");
+    let body = token_range_slice(ctx.statement_tokens.as_ref(), subquery.body_range);
+
+    assert_eq!(extract_select_list_columns(body), vec!["point_value"]);
+    assert!(
+        !matches!(body.last(), Some(SqlToken::Symbol(symbol)) if symbol == ")"),
+        "subquery body must not contain its enclosing close parenthesis: {body:?}"
+    );
+}
+
 // ─── DDL column-name context (CREATE INDEX / ALTER TABLE) ────────────────────
 
 #[test]

src/ui/sql_editor/formatter.rs

@@ -7879,25 +7879,7 @@ impl SqlEditorWidget {
         {
             return true;
         }
-        if format_stack.construct_flag_is_active(ConstructFlagKind::GrantRevokeActive)
-            && matches!(
-                keyword,
-                "SELECT"
-                    | "INSERT"
-                    | "UPDATE"
-                    | "DELETE"
-                    | "EXECUTE"
-                    | "ALTER"
-                    | "DROP"
-                    | "CREATE"
-                    | "INDEX"
-                    | "REFERENCES"
-                    | "ALL"
-                    | "PRIVILEGES"
-                    | "MERGE"
-                    | "ON"
-            )
-        {
+        if format_stack.construct_flag_is_active(ConstructFlagKind::GrantRevokeActive) {
             return true;
         }
         if format_stack.construct_flag_is_active(ConstructFlagKind::CreateSequenceActive)
@@ -31059,6 +31041,7 @@ ORDER BY v.amt DESC;"#;
 #[cfg(test)]
 mod format_indent_gap_tests {
     use super::FormatIndentedParenOwnerKind;
+    use crate::db::connection::DatabaseType;
     use crate::sql_delimiter::line_start_snapshot_before_token;
     use crate::ui::sql_editor::SqlEditorWidget;
     use crate::ui::SqlToken;
@@ -31712,6 +31695,29 @@ recursive_tree (node_id, parent_id, node_name, DEPTH, PATH) AS (
         );
     }
 
+    #[test]
+    fn format_sql_basic_keeps_grant_revoke_clause_keywords_inline() {
+        let source = "grant set user on *.* to 'actor'@'localhost'; revoke select on schema1.t1 from 'actor'@'localhost';";
+        let formatted =
+            SqlEditorWidget::format_sql_basic_for_db_type(source, DatabaseType::MariaDB);
+
+        assert!(
+            formatted.contains("GRANT SET USER ON *.* TO 'actor'@'localhost';"),
+            "a multi-word privilege must stay in the GRANT frame, got:\n{}",
+            formatted
+        );
+        assert!(
+            formatted.contains("REVOKE SELECT ON schema1.t1 FROM 'actor'@'localhost';"),
+            "FROM must stay in the REVOKE frame, got:\n{}",
+            formatted
+        );
+        assert_eq!(
+            SqlEditorWidget::format_sql_basic_for_db_type(&formatted, DatabaseType::MariaDB),
+            formatted,
+            "GRANT/REVOKE account statements must be idempotent"
+        );
+    }
+
     // ── MERGE WHEN MATCHED indent ──
 
     #[test]