Skip to main content

dsl_completion/
detectors.rs

1//! Phase/context detector functions -- one function per SQL
2//! sub-construct (`CREATE X ... <cursor>`, `ALTER X ... <cursor>`,
3//! slot predicates, item-pushing helpers). Extracted from
4//! `engine.rs` in one large batch (was inline there) -- pure code
5//! motion, no behavior change. Deliberately not yet subdivided by
6//! statement family (CREATE vs ALTER vs ...); that's a lower-risk
7//! follow-up now that this code has no cross-file coupling left to
8//! worry about, only internal reorganization within one file.
9//!
10//! Depends on `engine::{stmt_slice_upper, cursor_not_at_ws_boundary,
11//! current_statement_span, push_keyword_kvs}` for statement-slice
12//! extraction and keyword-item building -- the low-level helpers
13//! shared across every detector.
14
15use crate::engine::{current_statement_span, cursor_not_at_ws_boundary, push_keyword_kvs, stmt_slice_upper};
16use crate::fallback;
17use crate::item::Item;
18use crate::sources;
19use dsl_catalog::Catalog;
20use dsl_parse::ParsedFile;
21use dsl_resolve::Scope;
22use text_size::TextSize;
23
24/// True for completion items that should be filtered when the column
25/// is already in the current clause's comma list. Matches both bare
26/// columns (`id`) and qualified ones (`u.id`) by checking the tail.
27/// True when the cursor sits at a column-LHS slot of an `ON CONFLICT`
28/// clause: either the conflict-target list `ON CONFLICT (<cursor>)` or
29/// the `DO UPDATE SET <cursor>` assignment target. Both expect a
30/// column of the INSERT target table -- not a free expression.
31/// True when the cursor in an `UPDATE ... SET ...` clause sits at a
32/// column-LHS slot (right after SET or after a top-level comma, with
33/// no `=` since). Returns false for value-expression positions so the
34/// caller can keep emitting functions/keywords there.
35pub(crate) fn update_set_at_column_slot(source: &str, offset: TextSize) -> bool {
36  let pos: usize = (u32::from(offset) as usize).min(source.len());
37  let bytes = source.as_bytes();
38  // Walk back to the SET keyword that anchors this assignment list.
39  let mut anchor: Option<usize> = None;
40  let mut depth = 0i32;
41  let mut i = pos;
42  while i > 0 {
43    let b = bytes[i - 1];
44    if b >= 128 {
45      i -= 1;
46      continue;
47    }
48    let c = b as char;
49    if c == ')' {
50      depth += 1;
51      i -= 1;
52      continue;
53    }
54    if c == '(' {
55      if depth == 0 {
56        return false;
57      }
58      depth -= 1;
59      i -= 1;
60      continue;
61    }
62    if c == ';' {
63      return false;
64    }
65    if match_kw_at(bytes, i, b"SET") {
66      anchor = Some(i);
67      break;
68    }
69    i -= 1;
70  }
71  let Some(anchor) = anchor else {
72    return false;
73  };
74  // Scan forward `[anchor..pos)` and locate the latest top-level
75  // `=` and `,`. The column slot rule: no `=` since the most recent
76  // `,` (or since SET, when no comma yet).
77  if !(source.is_char_boundary(anchor) && source.is_char_boundary(pos)) {
78    return false;
79  }
80  let region = &source[anchor..pos];
81  let rbytes = region.as_bytes();
82  let n = rbytes.len();
83  let mut depth = 0i32;
84  let mut last_eq: Option<usize> = None;
85  let mut last_comma: Option<usize> = None;
86  let mut i = 0usize;
87  while i < n {
88    let c = rbytes[i] as char;
89    if c == '\'' {
90      i += 1;
91      while i < n && rbytes[i] != b'\'' {
92        i += 1;
93      }
94      i = (i + 1).min(n);
95      continue;
96    }
97    if c == '(' {
98      depth += 1;
99    } else if c == ')' {
100      depth -= 1;
101    } else if depth == 0 {
102      if c == ',' {
103        last_comma = Some(i);
104      } else if c == '=' {
105        last_eq = Some(i);
106      }
107    }
108    i += 1;
109  }
110  match (last_eq, last_comma) {
111    (None, _) => true,
112    (Some(_), None) => false,
113    (Some(eq), Some(co)) => co > eq,
114  }
115}
116
117pub(crate) fn on_conflict_expects_target_column(source: &str, offset: TextSize) -> bool {
118  let (_slice, upper) = stmt_slice_upper(source, offset);
119  let Some(oc_at) = upper.rfind("ON CONFLICT") else { return false };
120  // Everything after ON CONFLICT until the cursor.
121  let after = &upper[oc_at + "ON CONFLICT".len()..];
122  // Case 1: `ON CONFLICT (<cursor>)` -- inside a paren list with no
123  // matching `)`. Track depth from the first `(` after ON CONFLICT.
124  let mut depth = 0i32;
125  let mut in_target = false;
126  for c in after.chars() {
127    match c {
128      '(' => {
129        depth += 1;
130        in_target = true;
131      },
132      ')' => depth -= 1,
133      _ => {},
134    }
135  }
136  if in_target && depth > 0 {
137    return true;
138  }
139  // Case 2: `DO UPDATE SET <cursor>` LHS slot -- cursor is right after
140  // the SET keyword and not yet inside an expression (no `=` since last
141  // top-level comma).
142  let trimmed = after.trim_end();
143  let after_set = trimmed.rsplit("SET").next().unwrap_or("");
144  if trimmed.contains("DO UPDATE SET") {
145    // If after_set has no `=` and we're either right after SET or after
146    // a comma, we're naming a column LHS.
147    let cleaned = after_set.trim_start();
148    let no_assignment_yet = !cleaned.contains('=');
149    let after_comma_or_start = cleaned.is_empty()
150      || cleaned.chars().all(|c| c.is_ascii_alphanumeric() || c == '_' || c == ',' || c.is_whitespace());
151    if no_assignment_yet && after_comma_or_start {
152      return true;
153    }
154  }
155  false
156}
157
158/// True when the cursor sits at `RAISE <cursor>` (PL/pgSQL) -- the
159/// next token is a level keyword (DEBUG / LOG / INFO / NOTICE /
160/// WARNING / EXCEPTION). Also fires for a partial level word.
161pub(crate) fn raise_expects_level_keyword(source: &str, offset: TextSize) -> bool {
162  let (slice, upper) = stmt_slice_upper(source, offset);
163  let stmt = slice.trim_start();
164  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
165  if words.len() == 1 && words[0] == "RAISE" && stmt.ends_with(char::is_whitespace) {
166    return true;
167  }
168  false
169}
170
171/// True when the cursor sits at `RESET <cursor>` -- the next token is
172/// ALL / ROLE / SESSION AUTHORIZATION / a GUC name. We surface only
173/// the keyword forms; GUC names are freeform.
174pub(crate) fn reset_expects_subkeyword(source: &str, offset: TextSize) -> bool {
175  let (slice, upper) = stmt_slice_upper(source, offset);
176  let stmt = slice.trim_start();
177  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
178  if words.len() == 1 && words[0] == "RESET" && stmt.ends_with(char::is_whitespace) {
179    return true;
180  }
181  false
182}
183
184/// True when the cursor sits at the start of a `WINDOW <name> AS (...)`
185/// body -- i.e. right after the opening `(`. Detects an unclosed
186/// window paren and rejects positions past a sub-clause keyword.
187pub(crate) fn window_clause_paren_expects_subclause(source: &str, offset: TextSize) -> bool {
188  let pos: usize = u32::from(offset) as usize;
189  let pos = pos.min(source.len());
190  let before = &source[..pos];
191  let upper = before.to_ascii_uppercase();
192  let Some(win_at) = upper.rfind("WINDOW ") else { return false };
193  // `WINDOW <name> AS (...)` is the only valid form.
194  let after = &before[win_at + "WINDOW ".len()..];
195  if !after.to_ascii_uppercase().contains(" AS ") {
196    return false;
197  }
198  // Track paren depth across every window def in this (possibly
199  // comma-separated `w1 AS (...), w2 AS (...)`) WINDOW clause up to
200  // the cursor, remembering where the innermost still-open paren
201  // started. A plain `after.find('(')` only finds the *first*
202  // definition's paren -- wrong once w1's body has already closed and
203  // a second `w2 AS (` follows. Nested calls inside a body (`PARTITION
204  // BY foo(x)`) don't confuse this: `open_at` only updates on the
205  // depth 0->1 transition, so it tracks the outer window-body paren,
206  // not `foo`'s.
207  let mut depth = 0i32;
208  let mut open_at: Option<usize> = None;
209  for (i, b) in after.bytes().enumerate() {
210    match b {
211      b'(' => {
212        if depth == 0 {
213          open_at = Some(i);
214        }
215        depth += 1;
216      },
217      b')' => {
218        depth -= 1;
219        if depth == 0 {
220          open_at = None;
221        }
222      },
223      _ => {},
224    }
225  }
226  let Some(open) = open_at else { return false };
227  // Cursor is inside the paren. Only fire when no sub-clause keyword
228  // has been typed yet -- so the FIRST thing in the body is the slot.
229  let body_trim = after[open + 1..].trim();
230  body_trim.is_empty()
231    || !["PARTITION", "ORDER", "ROWS", "RANGE", "GROUPS"]
232      .iter()
233      .any(|kw| body_trim.to_ascii_uppercase().starts_with(kw))
234}
235
236/// True when the cursor sits at `WINDOW w AS (PARTITION BY <cursor>` or
237/// `... (ORDER BY <cursor>` inside the window body -- expects a column
238/// from the FROM tables.
239pub(crate) fn window_clause_partition_or_order_by_expects_column(source: &str, offset: TextSize) -> bool {
240  let pos: usize = u32::from(offset) as usize;
241  let pos = pos.min(source.len());
242  let before = &source[..pos];
243  if !before.ends_with(char::is_whitespace) {
244    return false;
245  }
246  let upper = before.to_ascii_uppercase();
247  let Some(win_at) = upper.rfind("WINDOW ") else { return false };
248  let after = &upper[win_at + "WINDOW ".len()..];
249  if !after.contains(" AS ") {
250    return false;
251  }
252  // Find the innermost still-open paren (same reasoning as
253  // `window_clause_paren_expects_subclause` above -- a plain
254  // `after.find('(')` only finds the *first* window definition's
255  // paren, wrong once a second `w2 AS (` follows a closed `w1 AS
256  // (...)` body).
257  let mut depth = 0i32;
258  let mut open_at: Option<usize> = None;
259  for (i, b) in after.bytes().enumerate() {
260    match b {
261      b'(' => {
262        if depth == 0 {
263          open_at = Some(i);
264        }
265        depth += 1;
266      },
267      b')' => {
268        depth -= 1;
269        if depth == 0 {
270          open_at = None;
271        }
272      },
273      _ => {},
274    }
275  }
276  if open_at.is_none() {
277    return false;
278  }
279  // Trailing PARTITION BY / ORDER BY / comma after one of them.
280  // Use word-bounded match so `(PARTITION BY` (no leading space) also
281  // matches alongside ` PARTITION BY`.
282  let trimmed = upper.trim_end();
283  let ends_partition_by = trimmed.ends_with("PARTITION BY") && {
284    let n = trimmed.len() - "PARTITION BY".len();
285    n == 0 || !trimmed.as_bytes()[n - 1].is_ascii_alphanumeric()
286  };
287  let ends_order_by = trimmed.ends_with("ORDER BY") && {
288    let n = trimmed.len() - "ORDER BY".len();
289    n == 0 || !trimmed.as_bytes()[n - 1].is_ascii_alphanumeric()
290  };
291  ends_partition_by || ends_order_by || trimmed.ends_with(',')
292}
293
294/// True when the cursor sits at the sampling-method slot after
295/// `TABLESAMPLE` in a SELECT FROM clause.
296/// Curated set-returning function list used to narrow the slot right
297/// after `LATERAL`. Not exhaustive -- covers the SRFs that are
298/// genuinely common in LATERAL joins. The catalog's own function list
299/// is not used because it would re-introduce non-SRF noise.
300pub(crate) const LATERAL_TARGETS: &[(&str, &str)] = &[
301  ("generate_series", "generate_series(start, stop[, step]) -> setof <type>"),
302  ("unnest", "unnest(<array>) -> setof <element-type>"),
303  ("jsonb_array_elements", "jsonb_array_elements(<jsonb>) -> setof jsonb"),
304  ("jsonb_array_elements_text", "jsonb_array_elements_text(<jsonb>) -> setof text"),
305  ("jsonb_each", "jsonb_each(<jsonb>) -> setof (key text, value jsonb)"),
306  ("jsonb_each_text", "jsonb_each_text(<jsonb>) -> setof (key text, value text)"),
307  ("jsonb_object_keys", "jsonb_object_keys(<jsonb>) -> setof text"),
308  ("jsonb_to_record", "jsonb_to_record(<jsonb>) AS x(...) -- requires column-def alias"),
309  ("jsonb_to_recordset", "jsonb_to_recordset(<jsonb>) AS x(...) -- requires column-def alias"),
310  ("json_array_elements", "json_array_elements(<json>) -> setof json"),
311  ("json_array_elements_text", "json_array_elements_text(<json>) -> setof text"),
312  ("json_each", "json_each(<json>) -> setof (key text, value json)"),
313  ("json_each_text", "json_each_text(<json>) -> setof (key text, value text)"),
314  ("json_object_keys", "json_object_keys(<json>) -> setof text"),
315  ("regexp_split_to_table", "regexp_split_to_table(<str>, <pattern>) -> setof text"),
316  ("string_to_table", "string_to_table(<str>, <delim>) -> setof text"),
317  ("array_to_table", "(SELECT ...) -- a parenthesized subquery is also a valid LATERAL target"),
318];
319
320/// True when the cursor is positioned at a LATERAL-target slot:
321/// directly after a word-bounded `LATERAL` keyword, optionally with
322/// a partial identifier the user is starting to type.
323pub(crate) fn lateral_target_expected(source: &str, offset: TextSize) -> bool {
324  let pos: usize = u32::from(offset) as usize;
325  let pos = pos.min(source.len());
326  let before = &source[..pos];
327  // Trim a trailing partial word (the identifier under the cursor).
328  let trimmed = before.trim_end_matches(|c: char| c.is_alphanumeric() || c == '_');
329  if !trimmed.ends_with(char::is_whitespace) {
330    return false;
331  }
332  let upper = trimmed.trim_end().to_ascii_uppercase();
333  // The preceding token must be `LATERAL`. Use ends_with-with-boundary
334  // check so we don't match identifiers ending in LATERAL.
335  if !upper.ends_with("LATERAL") {
336    return false;
337  }
338  let len = upper.len();
339  if len > 7 {
340    let prev = upper.as_bytes()[len - 8] as char;
341    if prev.is_alphanumeric() || prev == '_' {
342      return false;
343    }
344  }
345  true
346}
347
348pub(crate) fn tablesample_expects_method(source: &str, offset: TextSize) -> bool {
349  let pos: usize = u32::from(offset) as usize;
350  let pos = pos.min(source.len());
351  let before = &source[..pos];
352  if !before.ends_with(char::is_whitespace) {
353    return false;
354  }
355  let upper = before.trim_end().to_ascii_uppercase();
356  upper.ends_with(" TABLESAMPLE") || upper == "TABLESAMPLE"
357}
358
359/// Detect a SELECT locking-clause slot:
360///   `... FOR <cursor>`            -> UPDATE / NO KEY UPDATE / SHARE / KEY SHARE
361///   `... FOR UPDATE <cursor>`     -> OF / NOWAIT / SKIP LOCKED
362///   `... FOR NO KEY UPDATE <cur>` -> OF / NOWAIT / SKIP LOCKED
363///   `... FOR SHARE <cursor>`      -> OF / NOWAIT / SKIP LOCKED
364///   `... FOR KEY SHARE <cursor>`  -> OF / NOWAIT / SKIP LOCKED
365/// Returns None when not in such a slot (so the regular AfterTable
366/// handler runs).
367pub(crate) fn select_for_locking_keywords(
368  source: &str,
369  offset: TextSize,
370) -> Option<&'static [(&'static str, &'static str)]> {
371  let pos: usize = u32::from(offset) as usize;
372  let pos = pos.min(source.len());
373  let before = &source[..pos];
374  if !before.ends_with(char::is_whitespace) {
375    return None;
376  }
377  let trimmed = before.trim_end();
378  let upper = trimmed.to_ascii_uppercase();
379  const STRENGTH: &[(&str, &str)] = &[
380    ("UPDATE", "FOR UPDATE -- exclusive row lock"),
381    ("NO KEY UPDATE", "FOR NO KEY UPDATE -- weaker than UPDATE"),
382    ("SHARE", "FOR SHARE -- shared row lock"),
383    ("KEY SHARE", "FOR KEY SHARE -- weakest row lock"),
384  ];
385  const MODIFIERS: &[(&str, &str)] = &[
386    ("OF", "OF <table>[, ...] -- restrict to specific tables"),
387    ("NOWAIT", "NOWAIT -- error instead of waiting for the lock"),
388    ("SKIP LOCKED", "SKIP LOCKED -- skip rows already locked"),
389  ];
390  if upper.ends_with(" FOR") || upper == "FOR" {
391    return Some(STRENGTH);
392  }
393  for tail in &[" FOR UPDATE", " FOR NO KEY UPDATE", " FOR SHARE", " FOR KEY SHARE"] {
394    if upper.ends_with(tail) {
395      return Some(MODIFIERS);
396    }
397  }
398  None
399}
400
401/// Return the IS-continuation keywords when the cursor sits right
402/// after `IS` or `IS NOT` in a predicate context. None otherwise.
403pub(crate) fn is_predicate_continuation_keywords(
404  source: &str,
405  offset: TextSize,
406) -> Option<&'static [(&'static str, &'static str)]> {
407  let pos: usize = u32::from(offset) as usize;
408  let pos = pos.min(source.len());
409  // Use the raw text up to the cursor; cheap and avoids parser sensitivity.
410  let before = &source[..pos];
411  let trimmed = before.trim_end();
412  if !before.ends_with(char::is_whitespace) {
413    return None;
414  }
415  // Detect a trailing `IS NOT` token (word-bounded: preceded by
416  // whitespace or at start of statement).
417  let upper_trim = trimmed.to_ascii_uppercase();
418  // `IS DISTINCT` / `IS NOT DISTINCT` -- next required token is FROM.
419  if upper_trim.ends_with(" IS DISTINCT") || upper_trim.ends_with(" IS NOT DISTINCT") {
420    return Some(&[("FROM", "IS [NOT] DISTINCT FROM <expr> -- NULL-aware compare")]);
421  }
422  // `IS JSON` / `IS NOT JSON` -- SQL/JSON predicate (PG16+); next is the
423  // optional shape token (VALUE/SCALAR/ARRAY/OBJECT). End-of-clause is
424  // also valid, but surfacing the four options helps discovery.
425  if upper_trim.ends_with(" IS JSON") || upper_trim.ends_with(" IS NOT JSON") {
426    return Some(&[
427      ("VALUE", "IS [NOT] JSON VALUE -- any JSON value (default)"),
428      ("SCALAR", "IS [NOT] JSON SCALAR -- number/string/boolean/null"),
429      ("ARRAY", "IS [NOT] JSON ARRAY"),
430      ("OBJECT", "IS [NOT] JSON OBJECT [WITH|WITHOUT UNIQUE KEYS]"),
431    ]);
432  }
433  // `... IS JSON OBJECT WITH` / `... WITHOUT` -- UNIQUE KEYS tail.
434  if upper_trim.ends_with(" IS JSON OBJECT WITH") || upper_trim.ends_with(" IS NOT JSON OBJECT WITH") {
435    return Some(&[("UNIQUE KEYS", "WITH UNIQUE KEYS -- forbid duplicate keys at any level")]);
436  }
437  if upper_trim.ends_with(" IS JSON OBJECT WITHOUT") || upper_trim.ends_with(" IS NOT JSON OBJECT WITHOUT") {
438    return Some(&[("UNIQUE KEYS", "WITHOUT UNIQUE KEYS -- explicit default (duplicates allowed)")]);
439  }
440  let last_is_not = upper_trim.ends_with(" IS NOT") || upper_trim == "IS NOT";
441  if last_is_not {
442    // After `IS NOT`: NULL / TRUE / FALSE / UNKNOWN / DISTINCT FROM.
443    const IS_NOT: &[(&str, &str)] = &[
444      ("NULL", "IS NOT NULL"),
445      ("TRUE", "IS NOT TRUE"),
446      ("FALSE", "IS NOT FALSE"),
447      ("UNKNOWN", "IS NOT UNKNOWN"),
448      ("JSON", "IS NOT JSON [VALUE|SCALAR|ARRAY|OBJECT] (PG16+)"),
449      ("DISTINCT FROM", "IS NOT DISTINCT FROM <expr> -- NULL-aware equality"),
450    ];
451    return Some(IS_NOT);
452  }
453  // Check ` IS` at end (word-bounded: preceded by whitespace).
454  let ends_with_is = trimmed.len() >= 2
455    && trimmed.as_bytes()[trimmed.len() - 2..].eq_ignore_ascii_case(b"IS")
456    && (trimmed.len() == 2 || trimmed.as_bytes()[trimmed.len() - 3].is_ascii_whitespace());
457  if ends_with_is {
458    const IS: &[(&str, &str)] = &[
459      ("NULL", "IS NULL"),
460      ("NOT NULL", "IS NOT NULL"),
461      ("TRUE", "IS TRUE"),
462      ("FALSE", "IS FALSE"),
463      ("UNKNOWN", "IS UNKNOWN"),
464      ("DISTINCT FROM", "IS DISTINCT FROM <expr> -- NULL-aware inequality"),
465      ("NOT DISTINCT FROM", "IS NOT DISTINCT FROM <expr> -- NULL-aware equality"),
466      ("JSON", "IS JSON [VALUE|SCALAR|ARRAY|OBJECT] (PG16+)"),
467    ];
468    return Some(IS);
469  }
470  None
471}
472
473/// True when the cursor sits at `DISCARD <cursor>` -- the next token
474/// is one of ALL / PLANS / SEQUENCES / TEMP / TEMPORARY.
475pub(crate) fn discard_expects_subkeyword(source: &str, offset: TextSize) -> bool {
476  let (slice, upper) = stmt_slice_upper(source, offset);
477  let stmt = slice.trim_start();
478  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
479  if words.len() == 1 && words[0] == "DISCARD" && stmt.ends_with(char::is_whitespace) {
480    return true;
481  }
482  // Partial sub-keyword being typed: `DISCARD AL` etc.
483  if words.len() == 2 && words[0] == "DISCARD" && !stmt.ends_with(char::is_whitespace) {
484    return true;
485  }
486  false
487}
488
489/// True when the cursor sits at the `ON` slot of `CREATE [UNIQUE]
490/// INDEX [CONCURRENTLY] [IF NOT EXISTS] <name> <cursor>` -- the next
491/// required token is `ON`.
492pub(crate) fn create_index_expects_on(source: &str, offset: TextSize) -> bool {
493  let (slice, upper) = stmt_slice_upper(source, offset);
494  let stmt = slice.trim_start();
495  if !upper.starts_with("CREATE INDEX") && !upper.starts_with("CREATE UNIQUE INDEX") {
496    return false;
497  }
498  // Walk past the keyword sequence and optional modifiers, then expect
499  // exactly one name token then whitespace at cursor.
500  let after = if let Some(s) = upper.strip_prefix("CREATE UNIQUE INDEX") {
501    s
502  } else if let Some(s) = upper.strip_prefix("CREATE INDEX") {
503    s
504  } else {
505    return false;
506  };
507  let words: Vec<&str> = after.split_ascii_whitespace().collect();
508  // Skip CONCURRENTLY / IF NOT EXISTS.
509  let mut i = 0;
510  if i < words.len() && words[i] == "CONCURRENTLY" {
511    i += 1;
512  }
513  if i + 3 <= words.len() && words[i] == "IF" && words[i + 1] == "NOT" && words[i + 2] == "EXISTS" {
514    i += 3;
515  }
516  // Expect single <name> then cursor whitespace, no ON yet.
517  if i + 1 == words.len() && stmt.ends_with(char::is_whitespace) && !after.contains(" ON ") {
518    return true;
519  }
520  false
521}
522
523/// True when the cursor sits at the `ON` slot of `CREATE POLICY <name>
524/// <cursor>` -- the next required token is `ON`.
525pub(crate) fn create_policy_expects_on(source: &str, offset: TextSize) -> bool {
526  let (slice, upper) = stmt_slice_upper(source, offset);
527  let stmt = slice.trim_start();
528  if !upper.starts_with("CREATE POLICY") {
529    return false;
530  }
531  let after = &upper["CREATE POLICY".len()..];
532  let words: Vec<&str> = after.split_ascii_whitespace().collect();
533  // Expect <name> (1 word) then cursor at whitespace, no ON yet.
534  words.len() == 1 && stmt.ends_with(char::is_whitespace) && !after.contains(" ON ")
535}
536
537/// True when the cursor sits at the table slot of `CREATE POLICY <name>
538/// ON <cursor>`.
539pub(crate) fn create_policy_expects_table(source: &str, offset: TextSize) -> bool {
540  let (slice, upper) = stmt_slice_upper(source, offset);
541  let stmt = slice.trim_start();
542  if !upper.starts_with("CREATE POLICY") {
543    return false;
544  }
545  let after = &upper["CREATE POLICY".len()..];
546  let words: Vec<&str> = after.split_ascii_whitespace().collect();
547  // `<name> ON <cursor>` -- 2 tokens then whitespace.
548  if words.len() == 2 && words[1] == "ON" && stmt.ends_with(char::is_whitespace) {
549    return true;
550  }
551  // Partial table name being typed: `<name> ON tab` -- 3 tokens, last
552  // partial.
553  if words.len() == 3 && words[1] == "ON" && !stmt.ends_with(char::is_whitespace) {
554    return true;
555  }
556  false
557}
558
559/// True when the cursor sits at the timing slot of a
560/// `CREATE [OR REPLACE] TRIGGER <name> <cursor>` statement -- the
561/// next token should be BEFORE / AFTER / INSTEAD OF.
562pub(crate) fn create_trigger_expects_timing(source: &str, offset: TextSize) -> bool {
563  let (slice, upper) = stmt_slice_upper(source, offset);
564  let stmt = slice.trim_start();
565  let starts = upper.starts_with("CREATE TRIGGER")
566    || upper.starts_with("CREATE OR REPLACE TRIGGER")
567    || upper.starts_with("CREATE CONSTRAINT TRIGGER");
568  if !starts {
569    return false;
570  }
571  // Tokens after the TRIGGER keyword: the next word is the trigger name,
572  // and the cursor sits at the slot right after it (whitespace).
573  let after = upper.split_once("TRIGGER").map(|x| x.1).unwrap_or("");
574  let words: Vec<&str> = after.split_ascii_whitespace().collect();
575  // Skip optional IF NOT EXISTS.
576  let mut i = 0;
577  if i + 3 <= words.len() && words[i] == "IF" && words[i + 1] == "NOT" && words[i + 2] == "EXISTS" {
578    i += 3;
579  }
580  // Expect <name> then cursor.
581  if i + 1 == words.len() && stmt.ends_with(char::is_whitespace) {
582    return true;
583  }
584  false
585}
586
587/// True when the cursor sits at a role-name slot of a command that
588/// takes an existing role from the catalog. Covers ALTER/DROP ROLE,
589/// DROP USER/GROUP, REASSIGN OWNED BY, DROP OWNED BY. The caller
590/// emits the catalog roles + PUBLIC pseudo-role.
591pub(crate) fn command_expects_role_name(source: &str, offset: TextSize) -> bool {
592  let (slice, upper) = stmt_slice_upper(source, offset);
593  let stmt = slice.trim_start();
594  let kinds: &[(&[&str], &[&str])] = &[
595    (&["ALTER", "ROLE"], &["IF", "EXISTS"]),
596    (&["ALTER", "USER"], &["IF", "EXISTS"]),
597    (&["ALTER", "GROUP"], &["IF", "EXISTS"]),
598    (&["DROP", "ROLE"], &["IF", "EXISTS"]),
599    (&["DROP", "USER"], &["IF", "EXISTS"]),
600    (&["DROP", "GROUP"], &["IF", "EXISTS"]),
601    (&["REASSIGN", "OWNED", "BY"], &[]),
602    (&["DROP", "OWNED", "BY"], &[]),
603    (&["CREATE", "SCHEMA", "AUTHORIZATION"], &[]),
604    (&["GRANT", "ROLE"], &[]),
605  ];
606  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
607  for (kw_seq, mods) in kinds {
608    if words.len() < kw_seq.len() {
609      continue;
610    }
611    if !kw_seq.iter().zip(words.iter()).all(|(k, w)| {
612      let cleaned = w.trim_end_matches(|c: char| !c.is_ascii_alphanumeric() && c != '_');
613      cleaned.eq_ignore_ascii_case(k)
614    }) {
615      continue;
616    }
617    let mut i = kw_seq.len();
618    while i < words.len() && mods.iter().any(|m| words[i].eq_ignore_ascii_case(m)) {
619      i += 1;
620    }
621    let ends_with_comma = stmt.trim_end().ends_with(',');
622    let last_word_is_partial = !stmt.ends_with(char::is_whitespace);
623    if i >= words.len() || ends_with_comma || last_word_is_partial {
624      return true;
625    }
626  }
627  false
628}
629
630/// Detect a `SET` / `SET LOCAL` / `SET SESSION` GUC-name slot.
631/// `SET <cursor>` -> suggest the scope modifiers (LOCAL, SESSION),
632/// since the actual GUC name comes next and isn't catalog-resolvable.
633/// `SET LOCAL <cursor>` / `SET SESSION <cursor>` -> empty (the GUC
634/// name is freeform). Returns None when not in a SET slot.
635pub(crate) fn set_statement_completion(
636  source: &str,
637  offset: TextSize,
638) -> Option<&'static [(&'static str, &'static str)]> {
639  let (slice, upper) = stmt_slice_upper(source, offset);
640  let stmt = slice.trim_start();
641  // Skip SET ROLE / SET CONSTRAINTS / SET TRANSACTION (those are
642  // their own slots; routing them as GUC would be confusing).
643  if upper.starts_with("SET ROLE")
644    || upper.starts_with("SET SESSION AUTHORIZATION")
645    || upper.starts_with("SET CONSTRAINTS")
646    || upper.starts_with("SET TRANSACTION")
647  {
648    return None;
649  }
650  const SET_MODS: &[(&str, &str)] = &[
651    ("LOCAL", "SET LOCAL <var> = <value>  -- transaction-scoped"),
652    ("SESSION", "SET SESSION <var> = <value>  -- session-scoped (default)"),
653  ];
654  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
655  // `SET <cursor>` -- emit LOCAL / SESSION modifiers. GUC name slot
656  // (`SET LOCAL <cursor>` etc) is filled by `show_or_set_guc_names`.
657  if words.len() == 1 && words[0] == "SET" && stmt.ends_with(char::is_whitespace) {
658    return Some(SET_MODS);
659  }
660  None
661}
662
663/// Detect a transaction-control statement slot. Returns the keyword
664/// list to emit (empty for COMMIT/ROLLBACK/END/ABORT/SAVEPOINT which
665/// take no further token or a fresh identifier). None when the cursor
666/// isn't in a recognised transaction-control slot.
667pub(crate) fn transaction_control_completion(
668  source: &str,
669  offset: TextSize,
670) -> Option<&'static [(&'static str, &'static str)]> {
671  let (_slice, upper) = stmt_slice_upper(source, offset);
672  // Slots that take transaction modifiers (ISOLATION LEVEL, READ ONLY,
673  // READ WRITE, DEFERRABLE, NOT DEFERRABLE). `ATOMIC` is the standard-SQL
674  // form for CREATE FUNCTION bodies (`BEGIN ATOMIC ... END;`).
675  const TXN_MODIFIERS: &[(&str, &str)] = &[
676    ("ISOLATION LEVEL", "ISOLATION LEVEL SERIALIZABLE|REPEATABLE READ|READ COMMITTED|READ UNCOMMITTED"),
677    ("READ ONLY", "READ ONLY"),
678    ("READ WRITE", "READ WRITE"),
679    ("DEFERRABLE", "DEFERRABLE"),
680    ("NOT DEFERRABLE", "NOT DEFERRABLE"),
681    ("ATOMIC", "ATOMIC -- standard-SQL CREATE FUNCTION body: BEGIN ATOMIC <stmts> END;"),
682  ];
683  // Slots that take nothing useful (fresh savepoint name / no args).
684  const EMPTY: &[(&str, &str)] = &[];
685  let starts_with =
686    |kw: &str| upper.starts_with(kw) && (upper.len() == kw.len() || upper.as_bytes()[kw.len()].is_ascii_whitespace());
687  if starts_with("BEGIN TRANSACTION") || starts_with("START TRANSACTION") || starts_with("BEGIN") {
688    return Some(TXN_MODIFIERS);
689  }
690  if starts_with("COMMIT")
691    || starts_with("ROLLBACK")
692    || starts_with("END")
693    || starts_with("ABORT")
694    || starts_with("SAVEPOINT")
695    || starts_with("RELEASE")
696  {
697    return Some(EMPTY);
698  }
699  None
700}
701
702/// Object classes that COMMENT ON accepts. Full PG kind list.
703pub(crate) const COMMENT_ON_CLASSES: &[(&str, &str)] = &[
704  ("TABLE", "COMMENT ON TABLE <name> IS '...'"),
705  ("COLUMN", "COMMENT ON COLUMN <table>.<column> IS '...'"),
706  ("SCHEMA", "COMMENT ON SCHEMA <name> IS '...'"),
707  ("DATABASE", "COMMENT ON DATABASE <name> IS '...'"),
708  ("FUNCTION", "COMMENT ON FUNCTION <name>(...) IS '...'"),
709  ("PROCEDURE", "COMMENT ON PROCEDURE <name>(...) IS '...'"),
710  ("ROUTINE", "COMMENT ON ROUTINE <name>(...) IS '...'"),
711  ("INDEX", "COMMENT ON INDEX <name> IS '...'"),
712  ("VIEW", "COMMENT ON VIEW <name> IS '...'"),
713  ("MATERIALIZED VIEW", "COMMENT ON MATERIALIZED VIEW <name> IS '...'"),
714  ("FOREIGN TABLE", "COMMENT ON FOREIGN TABLE <name> IS '...'"),
715  ("FOREIGN DATA WRAPPER", "COMMENT ON FOREIGN DATA WRAPPER <name> IS '...'"),
716  ("SERVER", "COMMENT ON SERVER <name> IS '...'"),
717  ("SEQUENCE", "COMMENT ON SEQUENCE <name> IS '...'"),
718  ("TYPE", "COMMENT ON TYPE <name> IS '...'"),
719  ("DOMAIN", "COMMENT ON DOMAIN <name> IS '...'"),
720  ("EXTENSION", "COMMENT ON EXTENSION <name> IS '...'"),
721  ("ROLE", "COMMENT ON ROLE <name> IS '...'"),
722  ("TRIGGER", "COMMENT ON TRIGGER <name> ON <table> IS '...'"),
723  ("CONSTRAINT", "COMMENT ON CONSTRAINT <name> ON <table> IS '...'"),
724  ("POLICY", "COMMENT ON POLICY <name> ON <table> IS '...'"),
725  ("RULE", "COMMENT ON RULE <name> ON <table> IS '...'"),
726  ("AGGREGATE", "COMMENT ON AGGREGATE <name>(args) IS '...'"),
727  ("CAST", "COMMENT ON CAST (src AS dst) IS '...'"),
728  ("COLLATION", "COMMENT ON COLLATION <name> IS '...'"),
729  ("CONVERSION", "COMMENT ON CONVERSION <name> IS '...'"),
730  ("OPERATOR", "COMMENT ON OPERATOR <op>(args) IS '...'"),
731  ("OPERATOR CLASS", "COMMENT ON OPERATOR CLASS <name> USING <am> IS '...'"),
732  ("OPERATOR FAMILY", "COMMENT ON OPERATOR FAMILY <name> USING <am> IS '...'"),
733  ("STATISTICS", "COMMENT ON STATISTICS <name> IS '...'"),
734  ("ACCESS METHOD", "COMMENT ON ACCESS METHOD <name> IS '...'"),
735  ("LANGUAGE", "COMMENT ON LANGUAGE <name> IS '...'"),
736  ("LARGE OBJECT", "COMMENT ON LARGE OBJECT <oid> IS '...'"),
737  ("TABLESPACE", "COMMENT ON TABLESPACE <name> IS '...'"),
738  ("PUBLICATION", "COMMENT ON PUBLICATION <name> IS '...'"),
739  ("SUBSCRIPTION", "COMMENT ON SUBSCRIPTION <name> IS '...'"),
740  ("EVENT TRIGGER", "COMMENT ON EVENT TRIGGER <name> IS '...'"),
741  ("TEXT SEARCH CONFIGURATION", "COMMENT ON TEXT SEARCH CONFIGURATION <name> IS '...'"),
742  ("TEXT SEARCH DICTIONARY", "COMMENT ON TEXT SEARCH DICTIONARY <name> IS '...'"),
743  ("TEXT SEARCH PARSER", "COMMENT ON TEXT SEARCH PARSER <name> IS '...'"),
744  ("TEXT SEARCH TEMPLATE", "COMMENT ON TEXT SEARCH TEMPLATE <name> IS '...'"),
745  ("TRANSFORM", "COMMENT ON TRANSFORM FOR <type> LANGUAGE <lang> IS '...'"),
746];
747
748/// True when the cursor sits right after `COMMENT ON` with no class
749/// keyword typed yet -- the user must pick a class before naming the
750/// target object.
751/// COMMENT ON ... IS <cursor> -> NULL or empty-string hints.
752pub(crate) fn comment_on_is_value_next_keyword(
753  source: &str,
754  offset: TextSize,
755) -> Option<&'static [(&'static str, &'static str)]> {
756  if cursor_not_at_ws_boundary(source, offset) {
757    return None;
758  }
759  let (_, upper) = stmt_slice_upper(source, offset);
760  if !upper.starts_with("COMMENT ON") {
761    return None;
762  }
763  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
764  let last = *words.last()?;
765  if last == "IS" {
766    return Some(&[("NULL", "IS NULL -- drop the comment"), ("''", "'' -- empty comment (equivalent to NULL)")]);
767  }
768  // After class + name, expect IS.
769  if words.contains(&"ON") && !words.contains(&"IS") && words.len() >= 4 {
770    return Some(&[("IS", "IS '<comment_text>' | IS NULL -- drop")]);
771  }
772  None
773}
774
775pub(crate) fn comment_on_expects_class_keyword(source: &str, offset: TextSize) -> bool {
776  let (slice, upper) = stmt_slice_upper(source, offset);
777  let stmt = slice.trim_start();
778  if !upper.starts_with("COMMENT ON") {
779    return false;
780  }
781  let after = &upper["COMMENT ON".len()..];
782  let after_trim = after.trim_start();
783  if after_trim.is_empty() && stmt.ends_with(char::is_whitespace) {
784    return true;
785  }
786  // A single partial class word being typed (no further tokens).
787  let words: Vec<&str> = after_trim.split_ascii_whitespace().collect();
788  if words.len() == 1 && !stmt.ends_with(char::is_whitespace) {
789    // Partial class keyword: still in the class slot.
790    return true;
791  }
792  false
793}
794
795/// True when the cursor sits at the body slot of `DECLARE <name>
796/// [...] CURSOR FOR <cursor>` -- expects a SELECT statement.
797pub(crate) fn declare_cursor_for_expects_statement(source: &str, offset: TextSize) -> bool {
798  let (slice, upper) = stmt_slice_upper(source, offset);
799  let stmt = slice.trim_start();
800  if !upper.starts_with("DECLARE") {
801    return false;
802  }
803  // The text ending in `CURSOR FOR ` (possibly with options between
804  // <name> and CURSOR) is the trigger.
805  let trimmed = upper.trim_end();
806  trimmed.ends_with("CURSOR FOR") && stmt.ends_with(char::is_whitespace)
807}
808
809/// True when the cursor sits at `WITH [RECURSIVE] <name> [(cols)] AS
810/// <cursor>` -- the next token is either MATERIALIZED, NOT
811/// MATERIALIZED, or `(` (the CTE body).
812pub(crate) fn with_cte_after_as_expects_materialized(source: &str, offset: TextSize) -> bool {
813  let (slice, upper) = stmt_slice_upper(source, offset);
814  let stmt = slice.trim_start();
815  if !upper.starts_with("WITH ") && !upper.starts_with("WITH\n") && !upper.starts_with("WITH\t") {
816    return false;
817  }
818  // Cursor must follow ` AS` token at top level.
819  let trimmed = upper.trim_end();
820  trimmed.ends_with(" AS") && stmt.ends_with(char::is_whitespace)
821}
822
823/// True when the cursor sits at `DO <cursor>` -- expects LANGUAGE or
824/// a dollar-quoted body.
825pub(crate) fn do_expects_language_or_body(source: &str, offset: TextSize) -> bool {
826  let (slice, upper) = stmt_slice_upper(source, offset);
827  let stmt = slice.trim_start();
828  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
829  words.len() == 1 && words[0] == "DO" && stmt.ends_with(char::is_whitespace)
830}
831
832/// True when the cursor sits at the option slot of
833/// `CREATE [TEMP|TEMPORARY|UNLOGGED] SEQUENCE [IF NOT EXISTS] <name>
834/// <cursor>` -- the next token is one of the sequence-option keywords.
835pub(crate) fn create_sequence_expects_option(source: &str, offset: TextSize) -> bool {
836  let (slice, upper) = stmt_slice_upper(source, offset);
837  let stmt = slice.trim_start();
838  if !upper.contains("SEQUENCE") || !upper.starts_with("CREATE") {
839    return false;
840  }
841  let after = if let Some(s) = upper.split_once("SEQUENCE").map(|x| x.1) { s } else { return false };
842  let words: Vec<&str> = after.split_ascii_whitespace().collect();
843  let mut i = 0;
844  // Optional IF NOT EXISTS.
845  if i + 3 <= words.len() && words[i] == "IF" && words[i + 1] == "NOT" && words[i + 2] == "EXISTS" {
846    i += 3;
847  }
848  // Expect <name> then cursor whitespace.
849  if i + 1 == words.len() && stmt.ends_with(char::is_whitespace) {
850    return true;
851  }
852  false
853}
854
855/// True when the cursor sits at `CREATE TYPE <name> AS <cursor>` --
856/// expects one of the type-kind keywords (ENUM / RANGE) or `(` for
857/// a composite type.
858/// True when the cursor sits inside the body of a `CREATE TYPE foo AS
859/// ENUM (` or `RANGE (` -- both expect literals or option pairs that
860/// have no useful catalog completion. Used to suppress the catch-all
861/// keyword dump.
862pub(crate) fn create_type_enum_or_range_body(source: &str, offset: TextSize) -> bool {
863  // Renamed semantically -- only ENUM body suppresses the menu (label literals).
864  // RANGE body wants option-name keywords (SUBTYPE / CANONICAL / ...), which
865  // `create_type_next_keyword` emits.
866  let (_slice, upper) = stmt_slice_upper(source, offset);
867  if !upper.starts_with("CREATE TYPE") {
868    return false;
869  }
870  let Some(open_at) = upper.find(" AS ENUM (").map(|p| p + " AS ENUM (".len()) else {
871    return false;
872  };
873  let bytes = upper.as_bytes();
874  let mut depth: i32 = 1;
875  let mut i = open_at;
876  while i < bytes.len() {
877    match bytes[i] {
878      b'(' => depth += 1,
879      b')' => depth -= 1,
880      _ => {},
881    }
882    if depth == 0 {
883      return false;
884    }
885    i += 1;
886  }
887  depth > 0
888}
889
890pub(crate) fn create_type_as_expects_kind(source: &str, offset: TextSize) -> bool {
891  let (slice, upper) = stmt_slice_upper(source, offset);
892  let stmt = slice.trim_start();
893  if !upper.starts_with("CREATE TYPE") {
894    return false;
895  }
896  let after = &upper["CREATE TYPE".len()..];
897  let words: Vec<&str> = after.split_ascii_whitespace().collect();
898  // `<name> AS <cursor>` -- 2 tokens with trailing whitespace, slot
899  // wants the kind keyword.
900  if words.len() == 2 && words[1] == "AS" && stmt.ends_with(char::is_whitespace) {
901    return true;
902  }
903  // `<name> AS <partial>` -- 3 tokens, no trailing whitespace, the
904  // user is mid-typing a kind keyword (e.g. `E` for ENUM). The LSP
905  // filters the emitted menu by prefix on the client side, so still
906  // emit the full kind list rather than fall through to the catch-all.
907  if words.len() == 3 && words[1] == "AS" && !stmt.ends_with(char::is_whitespace) {
908    return true;
909  }
910  false
911}
912
913/// True when the cursor sits inside the `VACUUM (...)` options paren
914/// at an option-name slot (start of paren or after comma).
915pub(crate) fn vacuum_paren_expects_option(source: &str, offset: TextSize) -> bool {
916  let (slice, upper) = stmt_slice_upper(source, offset);
917  let stmt = slice.trim_start();
918  if !upper.starts_with("VACUUM") {
919    return false;
920  }
921  let after = &stmt[upper.find("VACUUM").unwrap() + "VACUUM".len()..];
922  let mut depth = 0i32;
923  let mut saw_open = false;
924  for c in after.chars() {
925    match c {
926      '(' => {
927        depth += 1;
928        saw_open = true;
929      },
930      ')' => depth -= 1,
931      _ => {},
932    }
933  }
934  if !saw_open || depth == 0 {
935    return false;
936  }
937  let trimmed = stmt.trim_end();
938  let last = trimmed.chars().last();
939  if matches!(last, Some('(') | Some(',')) {
940    return true;
941  }
942  if !stmt.ends_with(char::is_whitespace) {
943    let inner_start = after.rfind('(').unwrap_or(0);
944    let last_comma_or_open = after[inner_start..].rfind([',', '(']).unwrap_or(0);
945    let since = &after[inner_start + last_comma_or_open..];
946    if !since.contains('=') {
947      return true;
948    }
949  }
950  false
951}
952
953/// True when the cursor sits at the FORMAT value slot inside the
954/// `EXPLAIN (...)` paren -- i.e. last meaningful token is `FORMAT`.
955pub(crate) fn explain_paren_format_value(source: &str, offset: TextSize) -> bool {
956  explain_paren_value_after(source, offset, "FORMAT")
957}
958
959/// True when the cursor sits at the SERIALIZE value slot inside the
960/// `EXPLAIN (...)` paren -- last meaningful token is `SERIALIZE`.
961pub(crate) fn explain_paren_serialize_value(source: &str, offset: TextSize) -> bool {
962  explain_paren_value_after(source, offset, "SERIALIZE")
963}
964
965pub(crate) fn explain_paren_value_after(source: &str, offset: TextSize, kw: &str) -> bool {
966  let (slice, upper) = stmt_slice_upper(source, offset);
967  let stmt = slice.trim_start();
968  if !upper.starts_with("EXPLAIN") {
969    return false;
970  }
971  let after = &stmt[upper.find("EXPLAIN").unwrap() + "EXPLAIN".len()..];
972  let opens = after.matches('(').count();
973  let closes = after.matches(')').count();
974  if opens == 0 || opens <= closes {
975    return false;
976  }
977  let last_tok = stmt.split(|c: char| c.is_whitespace() || c == ',' || c == '(').rfind(|s| !s.is_empty()).unwrap_or("");
978  last_tok.eq_ignore_ascii_case(kw)
979}
980
981/// True when the cursor sits inside the `EXPLAIN (...)` options paren
982/// at a fresh option-name slot (start of paren, or right after `,`).
983pub(crate) fn explain_paren_expects_option(source: &str, offset: TextSize) -> bool {
984  let (slice, upper) = stmt_slice_upper(source, offset);
985  let stmt = slice.trim_start();
986  if !upper.starts_with("EXPLAIN") {
987    return false;
988  }
989  // Find the `(` opening the options paren after EXPLAIN and verify
990  // it isn't closed before the cursor.
991  let after = &stmt[upper.find("EXPLAIN").unwrap() + "EXPLAIN".len()..];
992  let mut depth = 0i32;
993  let mut saw_open = false;
994  for c in after.chars() {
995    match c {
996      '(' => {
997        depth += 1;
998        saw_open = true;
999      },
1000      ')' => depth -= 1,
1001      _ => {},
1002    }
1003  }
1004  if !saw_open || depth == 0 {
1005    return false;
1006  }
1007  // Cursor is inside the paren. The slot expects an option name at
1008  // the start or right after a comma -- detect a freshly-empty option
1009  // (last non-whitespace in stmt is `(` or `,`), or a partial option
1010  // word being typed.
1011  let trimmed = stmt.trim_end();
1012  let last = trimmed.chars().last();
1013  if matches!(last, Some('(') | Some(',')) {
1014    return true;
1015  }
1016  // Partial word being typed at end -- only consider it an option
1017  // slot if no `=` has been typed since the last comma/( inside the
1018  // paren (otherwise we're in the value slot).
1019  if !stmt.ends_with(char::is_whitespace) {
1020    let inner_start = after.rfind('(').unwrap_or(0);
1021    let last_comma_or_open = after[inner_start..].rfind([',', '(']).unwrap_or(0);
1022    let since = &after[inner_start + last_comma_or_open..];
1023    if !since.contains('=') {
1024      return true;
1025    }
1026  }
1027  false
1028}
1029
1030/// True when the statement starts with `EXPLAIN` (optionally followed
1031/// by `(...)` options, `ANALYZE`, `VERBOSE`) and the cursor is at the
1032/// statement-start slot waiting for the inner SQL command.
1033pub(crate) fn explain_expects_statement(source: &str, offset: TextSize) -> bool {
1034  let (slice, upper) = stmt_slice_upper(source, offset);
1035  let stmt = slice.trim_start();
1036  if !upper.starts_with("EXPLAIN") {
1037    return false;
1038  }
1039  // Walk past EXPLAIN, the optional paren-options block, and the
1040  // ANALYZE / VERBOSE modifiers. After those, the cursor must be at
1041  // whitespace (no inner statement keyword typed yet) and on no
1042  // recognised statement starter (otherwise the SELECT-walk has
1043  // already moved us into a real phase).
1044  let bytes = stmt.as_bytes();
1045  let mut i = upper.find("EXPLAIN").unwrap_or(0) + "EXPLAIN".len();
1046  let skip_ws = |b: &[u8], mut p: usize| {
1047    while p < b.len() && b[p].is_ascii_whitespace() {
1048      p += 1;
1049    }
1050    p
1051  };
1052  i = skip_ws(bytes, i);
1053  // Optional paren-options.
1054  if i < bytes.len() && bytes[i] == b'(' {
1055    let mut depth = 1i32;
1056    i += 1;
1057    while i < bytes.len() && depth > 0 {
1058      match bytes[i] {
1059        b'(' => depth += 1,
1060        b')' => depth -= 1,
1061        _ => {},
1062      }
1063      if depth == 0 {
1064        break;
1065      }
1066      i += 1;
1067    }
1068    if i >= bytes.len() {
1069      return false; // still inside paren list
1070    }
1071    i += 1;
1072    i = skip_ws(bytes, i);
1073  }
1074  // Optional ANALYZE / VERBOSE modifiers (any order).
1075  loop {
1076    let rest_upper = stmt[i..].trim_start().to_ascii_uppercase();
1077    if let Some(stripped) = rest_upper.strip_prefix("ANALYZE") {
1078      // Make sure ANALYZE is a whole word.
1079      let consumed = "ANALYZE".len();
1080      let lead = stmt[i..].len() - stmt[i..].trim_start().len();
1081      let next = i + lead + consumed;
1082      if next == bytes.len() || !bytes[next].is_ascii_alphanumeric() && bytes[next] != b'_' {
1083        i = next;
1084        i = skip_ws(bytes, i);
1085        let _ = stripped;
1086        continue;
1087      }
1088    }
1089    if let Some(stripped) = rest_upper.strip_prefix("VERBOSE") {
1090      let consumed = "VERBOSE".len();
1091      let lead = stmt[i..].len() - stmt[i..].trim_start().len();
1092      let next = i + lead + consumed;
1093      if next == bytes.len() || !bytes[next].is_ascii_alphanumeric() && bytes[next] != b'_' {
1094        i = next;
1095        i = skip_ws(bytes, i);
1096        let _ = stripped;
1097        continue;
1098      }
1099    }
1100    break;
1101  }
1102  // At this point only the inner statement keyword could remain. If
1103  // the cursor sits before any keyword (i.e., i == end of stmt), we're
1104  // in the statement-starter slot.
1105  i == bytes.len()
1106}
1107
1108/// True when the cursor sits at the return-type slot of a
1109/// `CREATE [OR REPLACE] FUNCTION/PROCEDURE ... RETURNS <cursor>`
1110/// statement. Used to surface types-only instead of the broad menu.
1111pub(crate) fn create_function_expects_return_type(source: &str, offset: TextSize) -> bool {
1112  let (slice, upper) = stmt_slice_upper(source, offset);
1113  let stmt = slice.as_str();
1114  // Must be a CREATE [OR REPLACE] FUNCTION/PROCEDURE statement.
1115  let has_create_fn = upper.contains("CREATE FUNCTION")
1116    || upper.contains("CREATE OR REPLACE FUNCTION")
1117    || upper.contains("CREATE PROCEDURE")
1118    || upper.contains("CREATE OR REPLACE PROCEDURE");
1119  if !has_create_fn {
1120    return false;
1121  }
1122  let Some(rets_at) = upper.rfind("RETURNS") else {
1123    return false;
1124  };
1125  // Require word boundary before RETURNS.
1126  let bytes = stmt.as_bytes();
1127  if rets_at > 0 && (bytes[rets_at - 1].is_ascii_alphanumeric() || bytes[rets_at - 1] == b'_') {
1128    return false;
1129  }
1130  let after = &stmt[rets_at + "RETURNS".len()..];
1131  // After RETURNS, allow optional SETOF or TABLE keyword.
1132  let after_trim = after.trim_start();
1133  if after_trim.is_empty() {
1134    return true;
1135  }
1136  // Strip leading SETOF (single optional modifier).
1137  let after_setof = after_trim.strip_prefix("SETOF").or_else(|| after_trim.strip_prefix("setof"));
1138  let rest = after_setof.unwrap_or(after_trim);
1139  // After modifier whitespace, the only allowed token is the type
1140  // name -- accept either an empty trailing slot or a single partial
1141  // identifier being typed.
1142  let words: Vec<&str> = rest.split_ascii_whitespace().collect();
1143  match words.len() {
1144    0 => true,
1145    1 => !rest.ends_with(char::is_whitespace),
1146    _ => false,
1147  }
1148}
1149
1150/// True when the cursor sits right after one of the SET sub-keywords
1151/// inside an ALTER COLUMN clause: `SET DEFAULT|STATISTICS|STORAGE|
1152/// COMPRESSION <cursor>`. These slots take literals / specific tokens
1153/// (integers, storage names, compression methods, or freeform DEFAULT
1154/// expressions) -- the ALTER-table action menu is wrong here.
1155/// True when the cursor sits right after the `AS` of a CREATE VIEW
1156/// header (no body content typed yet). Used to narrow the Phase::Start
1157/// menu to just SELECT / WITH / VALUES / TABLE -- DDL keywords like
1158/// CREATE TABLE aren't legal as a view body.
1159pub(crate) fn at_create_view_body_start(source: &str, offset: TextSize) -> bool {
1160  let (slice, _) = stmt_slice_upper(source, offset);
1161  let upper = slice.trim().to_ascii_uppercase();
1162  if !upper.contains("VIEW") || !upper.ends_with("AS") {
1163    return false;
1164  }
1165  upper.as_bytes().starts_with(b"CREATE")
1166}
1167
1168/// True when the cursor in a `DROP <class> [IF EXISTS] <name> <cursor>`
1169/// statement sits right after a finished target name, so the next
1170/// legal tokens are CASCADE / RESTRICT (or `;`). Returns false when:
1171/// - the leading keyword isn't DROP
1172/// - we haven't seen a class keyword yet (TABLE / VIEW / ...)
1173/// - we haven't seen a name token after the class
1174/// - the cursor sits inside the name (no trailing whitespace)
1175/// - the user just typed a comma (continuing the target list)
1176pub(crate) fn drop_target_trailing_slot(source: &str, offset: TextSize) -> bool {
1177  let (slice, _) = stmt_slice_upper(source, offset);
1178  // Must end with whitespace -- otherwise the cursor is mid-name.
1179  if !slice.ends_with(char::is_whitespace) {
1180    return false;
1181  }
1182  let upper = slice.trim().to_ascii_uppercase();
1183  if !upper.starts_with("DROP") {
1184    return false;
1185  }
1186  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
1187  if words.len() < 3 {
1188    return false; // need at least DROP <CLASS> <NAME>
1189  }
1190  if words[0] != "DROP" {
1191    return false;
1192  }
1193  // Class keyword (allow 2-word classes like MATERIALIZED VIEW, FOREIGN TABLE).
1194  let two_word_classes = [("MATERIALIZED", "VIEW"), ("FOREIGN", "TABLE")];
1195  let one_word_classes: &[&str] = &[
1196    "TABLE",
1197    "VIEW",
1198    "INDEX",
1199    "SEQUENCE",
1200    "SCHEMA",
1201    "FUNCTION",
1202    "PROCEDURE",
1203    "TRIGGER",
1204    "TYPE",
1205    "ROLE",
1206    "USER",
1207    "DATABASE",
1208    "EXTENSION",
1209    "POLICY",
1210    "DOMAIN",
1211    "AGGREGATE",
1212    "CAST",
1213    "COLLATION",
1214    "OPERATOR",
1215    "RULE",
1216    "TABLESPACE",
1217    "SUBSCRIPTION",
1218    "PUBLICATION",
1219    "SERVER",
1220  ];
1221  let mut idx = 1usize;
1222  if idx + 1 < words.len() && two_word_classes.iter().any(|(a, b)| words[idx] == *a && words[idx + 1] == *b) {
1223    idx += 2;
1224  } else if one_word_classes.contains(&words[idx]) {
1225    idx += 1;
1226  } else {
1227    return false;
1228  }
1229  // Optional `IF EXISTS`.
1230  if idx + 1 < words.len() && words[idx] == "IF" && words[idx + 1] == "EXISTS" {
1231    idx += 2;
1232  }
1233  // Need at least one name word after that.
1234  if idx >= words.len() {
1235    return false;
1236  }
1237  // Last token must not be a continuation hint (comma) and must look
1238  // like an identifier (no leading `(`, no CASCADE/RESTRICT already).
1239  let last = words[words.len() - 1];
1240  if last == "CASCADE" || last == "RESTRICT" || last.ends_with(',') {
1241    return false;
1242  }
1243  // Check the raw character before trailing whitespace -- if it's a
1244  // `,`, the user is continuing the list, not done with the target.
1245  let trim_end = slice.trim_end();
1246  if trim_end.ends_with(',') {
1247    return false;
1248  }
1249  true
1250}
1251
1252/// Common DEFAULT-expression suggestions surfaced anywhere a column
1253/// default value is expected (CREATE TABLE column entry, ALTER TABLE
1254/// ADD COLUMN ... DEFAULT, ALTER COLUMN SET DEFAULT). Curated rather
1255/// than dumping the function set so the menu stays useful.
1256pub(crate) const DEFAULT_EXPRESSION_SUGGESTIONS: &[(&str, &str)] = &[
1257  ("NULL", "NULL default (column is nullable)"),
1258  ("CURRENT_TIMESTAMP", "transaction-start timestamp (timestamptz)"),
1259  ("CURRENT_DATE", "transaction-start date"),
1260  ("now()", "transaction-start timestamptz -- same as CURRENT_TIMESTAMP"),
1261  ("gen_random_uuid()", "random UUID v4 (requires pgcrypto; built-in since PG 13)"),
1262  ("FALSE", "literal false"),
1263  ("TRUE", "literal true"),
1264  ("0", "literal integer zero"),
1265  ("''", "empty string"),
1266];
1267
1268/// True when the cursor in a CREATE TABLE column entry sits in the
1269/// DEFAULT-expression slot (the most recently committed word in the
1270/// current column entry, after the column type, is DEFAULT).
1271pub(crate) fn ctl_column_constraint_after_default(source: &str, offset: TextSize) -> bool {
1272  let pos: usize = (u32::from(offset) as usize).min(source.len());
1273  let bytes = source.as_bytes();
1274  if pos == 0 {
1275    return false;
1276  }
1277  // Last word -- skip whitespace, read identifier letters back.
1278  let mut end = pos;
1279  while end > 0 && bytes[end - 1].is_ascii_whitespace() {
1280    end -= 1;
1281  }
1282  // Trailing whitespace required (otherwise user is mid-word).
1283  if end == pos {
1284    return false;
1285  }
1286  let mut start = end;
1287  while start > 0 {
1288    let b = bytes[start - 1];
1289    if b.is_ascii_alphanumeric() || b == b'_' {
1290      start -= 1;
1291    } else {
1292      break;
1293    }
1294  }
1295  if start == end {
1296    return false;
1297  }
1298  let word = source[start..end].to_ascii_uppercase();
1299  word == "DEFAULT"
1300}
1301
1302/// True when the cursor in an `INSERT INTO ... VALUES (...)` statement
1303/// sits AFTER a closed top-level tuple (paren depth 0, last
1304/// meaningful char is `)`, no RETURNING / ON CONFLICT typed yet).
1305/// The legal continuations here are `,` (another tuple), `RETURNING`,
1306/// `ON CONFLICT`, or `;` -- not arbitrary expressions, and not DEFAULT.
1307pub(crate) fn insert_after_values_tuple(source: &str, offset: TextSize) -> bool {
1308  let (slice_owned, upper) = stmt_slice_upper(source, offset);
1309  let slice = slice_owned.as_str();
1310  if !upper.contains("VALUES") || !upper.trim_start().starts_with("INSERT") {
1311    return false;
1312  }
1313  // After RETURNING or ON CONFLICT, the user is in those slots --
1314  // not the post-tuple slot.
1315  if upper.contains("RETURNING") || upper.contains("ON CONFLICT") {
1316    return false;
1317  }
1318  // Last non-whitespace char must be `)`.
1319  let trimmed = slice.trim_end();
1320  if !trimmed.ends_with(')') {
1321    return false;
1322  }
1323  // Paren-depth at end must be 0 (top-level).
1324  let bytes = slice.as_bytes();
1325  let mut depth: i32 = 0;
1326  let mut i = 0;
1327  while i < bytes.len() {
1328    let c = bytes[i];
1329    if c == b'\'' {
1330      i += 1;
1331      while i < bytes.len() && bytes[i] != b'\'' {
1332        i += 1;
1333      }
1334      i = (i + 1).min(bytes.len());
1335      continue;
1336    }
1337    if c == b'(' {
1338      depth += 1;
1339    } else if c == b')' {
1340      depth -= 1;
1341    }
1342    i += 1;
1343  }
1344  depth == 0
1345}
1346
1347/// True when the cursor in `ALTER TABLE <t> ADD COLUMN <name> <type>
1348/// DEFAULT <cursor>` sits in the DEFAULT-expression slot. Recognises
1349/// the cursor as right after the `DEFAULT` keyword (whitespace-only
1350/// between word and cursor).
1351pub(crate) fn alter_table_add_column_after_default(source: &str, offset: TextSize) -> bool {
1352  let (slice_owned, upper) = stmt_slice_upper(source, offset);
1353  let slice = slice_owned.as_str();
1354  if !upper.contains("ALTER TABLE") || !upper.contains("ADD COLUMN") {
1355    return false;
1356  }
1357  // Last word must be DEFAULT, followed by whitespace at the cursor.
1358  let trimmed = slice.trim_end();
1359  if trimmed.len() == slice.len() {
1360    return false; // no trailing whitespace -> mid-word
1361  }
1362  let upper_trim = trimmed.to_ascii_uppercase();
1363  if !upper_trim.ends_with("DEFAULT") {
1364    return false;
1365  }
1366  // Confirm DEFAULT is a whole word (not the tail of FOO_DEFAULT etc).
1367  let end = trimmed.len();
1368  if end == 7 {
1369    return true;
1370  }
1371  let prev = trimmed.as_bytes()[end - 8];
1372  !(prev.is_ascii_alphanumeric() || prev == b'_')
1373}
1374
1375/// True when the cursor sits right after a leading `CREATE` (optionally
1376/// `CREATE OR REPLACE` / `CREATE [TEMP|TEMPORARY|UNLOGGED|GLOBAL|LOCAL]`)
1377/// at the start of a statement. Returns the static list of object-type
1378/// keywords PG accepts after CREATE.
1379pub(crate) fn after_top_level_create_keyword(
1380  source: &str,
1381  offset: TextSize,
1382) -> Option<&'static [(&'static str, &'static str)]> {
1383  let pos: usize = (u32::from(offset) as usize).min(source.len());
1384  let bytes = source.as_bytes();
1385  let (slice_owned, _) = stmt_slice_upper(source, offset);
1386  let slice = slice_owned.trim();
1387  let upper = slice.to_ascii_uppercase();
1388  // Accept CREATE / CREATE OR REPLACE / CREATE TEMP / etc as the only
1389  // tokens so far. Reject if a class keyword has already been typed.
1390  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
1391  if words.is_empty() || words[0] != "CREATE" {
1392    return None;
1393  }
1394  let modifiers = ["OR", "REPLACE", "TEMP", "TEMPORARY", "UNLOGGED", "GLOBAL", "LOCAL", "UNIQUE", "MATERIALIZED"];
1395  for w in &words[1..] {
1396    if !modifiers.contains(w) {
1397      return None;
1398    }
1399  }
1400  if pos < bytes.len() && !bytes[pos].is_ascii_whitespace() {
1401    return None;
1402  }
1403  // Compute which modifiers have already been typed so we can prune
1404  // them from the suggestion list. Without this, after `CREATE OR `
1405  // the LSP would still suggest `OR REPLACE` (duplicating what the
1406  // user already typed); after `CREATE OR REPLACE ` it would still
1407  // offer TEMP/UNLOGGED (which can't legally follow OR REPLACE).
1408  let has_or = words.contains(&"OR");
1409  let has_replace = words.contains(&"REPLACE");
1410  let has_or_replace = has_or && has_replace;
1411  let has_temp = words.contains(&"TEMP") || words.contains(&"TEMPORARY");
1412  let has_unlogged = words.contains(&"UNLOGGED");
1413  let has_unique = words.contains(&"UNIQUE");
1414  let has_materialized = words.contains(&"MATERIALIZED");
1415  // When ONLY `OR` is typed (no REPLACE yet), the only legal next
1416  // word is REPLACE. Short-circuit to that single suggestion.
1417  if has_or && !has_replace {
1418    return Some(&[("REPLACE", "CREATE OR REPLACE -- replace existing function/view/trigger/etc")]);
1419  }
1420  // When `CREATE OR REPLACE` is fully typed, modifiers like TEMP /
1421  // UNLOGGED / etc can't follow -- only object-kind keywords are
1422  // legal. Same when TEMP/TEMPORARY/UNLOGGED already typed.
1423  let suggest_modifiers = !has_or_replace && !has_temp && !has_unlogged && !has_unique && !has_materialized;
1424  // Static slice + runtime filter doesn't compose; build a dynamic
1425  // Vec, leak its strings, and return a slice. But we need static
1426  // lifetime for the existing API. Instead we keep the static menu
1427  // and filter via a thread-local Vec elsewhere. For now, the easiest
1428  // path is to return a curated subset via match.
1429  // Subsets keyed on which modifiers are still legal:
1430  if !suggest_modifiers {
1431    // Only object-kind keywords legal after OR REPLACE / TEMP / etc.
1432    return Some(after_create_object_kinds_only());
1433  }
1434  Some(&[
1435    ("OR REPLACE", "CREATE OR REPLACE -- replace existing function/view/trigger/etc"),
1436    ("TEMP", "CREATE TEMP TABLE/VIEW/SEQUENCE -- session-scoped"),
1437    ("TEMPORARY", "CREATE TEMPORARY TABLE/VIEW/SEQUENCE -- session-scoped"),
1438    ("UNLOGGED", "CREATE UNLOGGED TABLE -- skipped from WAL"),
1439    ("GLOBAL", "CREATE GLOBAL TEMPORARY -- SQL standard alias"),
1440    ("LOCAL", "CREATE LOCAL TEMPORARY -- SQL standard alias"),
1441    ("UNIQUE", "CREATE UNIQUE INDEX -- enforce uniqueness"),
1442    ("MATERIALIZED", "CREATE MATERIALIZED VIEW <name> AS SELECT ..."),
1443    ("TABLE", "CREATE TABLE [IF NOT EXISTS] <name> (...)"),
1444    ("VIEW", "CREATE VIEW <name> AS SELECT ..."),
1445    ("MATERIALIZED VIEW", "CREATE MATERIALIZED VIEW <name> AS ..."),
1446    ("INDEX", "CREATE [UNIQUE] INDEX [CONCURRENTLY] [IF NOT EXISTS] <name> ON <table>(<cols>)"),
1447    ("UNIQUE INDEX", "CREATE UNIQUE INDEX ..."),
1448    ("SEQUENCE", "CREATE SEQUENCE [IF NOT EXISTS] <name>"),
1449    ("SCHEMA", "CREATE SCHEMA [IF NOT EXISTS] <name>"),
1450    ("FUNCTION", "CREATE [OR REPLACE] FUNCTION <name>(args) RETURNS ... AS $$ ... $$ LANGUAGE ..."),
1451    ("PROCEDURE", "CREATE [OR REPLACE] PROCEDURE <name>(args) ..."),
1452    ("TRIGGER", "CREATE [OR REPLACE] TRIGGER <name> {BEFORE|AFTER} <event> ON <table>"),
1453    ("TYPE", "CREATE TYPE <name> AS (...) | AS ENUM (...) | AS RANGE (...)"),
1454    ("ROLE", "CREATE ROLE <name> [WITH ...]"),
1455    ("USER", "CREATE USER <name> [WITH PASSWORD '...']"),
1456    ("DATABASE", "CREATE DATABASE <name> [OWNER <role>]"),
1457    ("EXTENSION", "CREATE EXTENSION [IF NOT EXISTS] <name>"),
1458    ("POLICY", "CREATE POLICY <name> ON <table> FOR ... TO ... USING (...)"),
1459    ("DOMAIN", "CREATE DOMAIN <name> AS <type> [CHECK (...)]"),
1460    ("AGGREGATE", "CREATE AGGREGATE <name>(arg_types) (SFUNC=..., STYPE=...)"),
1461    ("CAST", "CREATE CAST (src AS dst) WITH FUNCTION <fn> | WITHOUT FUNCTION"),
1462    ("COLLATION", "CREATE COLLATION <name> (...)"),
1463    ("OPERATOR", "CREATE OPERATOR <op> (...)"),
1464    ("RULE", "CREATE RULE <name> AS ON <event> TO <table> DO ..."),
1465    ("TABLESPACE", "CREATE TABLESPACE <name> LOCATION '<path>'"),
1466    ("SUBSCRIPTION", "CREATE SUBSCRIPTION <name> CONNECTION '<conn>' PUBLICATION <pub>"),
1467    ("PUBLICATION", "CREATE PUBLICATION <name> FOR TABLE ..."),
1468    ("FOREIGN TABLE", "CREATE FOREIGN TABLE <name> (...) SERVER <srv>"),
1469    ("SERVER", "CREATE SERVER <name> FOREIGN DATA WRAPPER <fdw>"),
1470    ("EVENT TRIGGER", "CREATE EVENT TRIGGER <name> ON <event> EXECUTE FUNCTION <fn>()"),
1471    ("TEXT SEARCH CONFIGURATION", "CREATE TEXT SEARCH CONFIGURATION <name> (PARSER=...)"),
1472    ("TEXT SEARCH DICTIONARY", "CREATE TEXT SEARCH DICTIONARY <name> (TEMPLATE=...)"),
1473    ("FOREIGN DATA WRAPPER", "CREATE FOREIGN DATA WRAPPER <name>"),
1474    ("CONVERSION", "CREATE [DEFAULT] CONVERSION <name> FOR '<src>' TO '<dst>' FROM <fn>"),
1475    ("TRANSFORM", "CREATE TRANSFORM FOR <type> LANGUAGE <lang> (...)"),
1476    ("USER MAPPING", "CREATE USER MAPPING FOR <role> SERVER <srv> OPTIONS (...)"),
1477    ("OPERATOR CLASS", "CREATE OPERATOR CLASS <name> FOR TYPE <type> USING <am> AS ..."),
1478    ("OPERATOR FAMILY", "CREATE OPERATOR FAMILY <name> USING <am>"),
1479    ("ACCESS METHOD", "CREATE ACCESS METHOD <name> TYPE {INDEX|TABLE} HANDLER <fn>"),
1480    ("STATISTICS", "CREATE STATISTICS [IF NOT EXISTS] <name> [(<kinds>)] ON <cols> FROM <tbl>"),
1481    ("LANGUAGE", "CREATE [OR REPLACE] [TRUSTED] [PROCEDURAL] LANGUAGE <name> HANDLER <fn>"),
1482    ("GROUP", "CREATE GROUP <name> [WITH <attr>...] -- SQL-standard alias for ROLE"),
1483    ("ROUTINE", "CREATE [OR REPLACE] ROUTINE <name>(args) ..."),
1484    ("TEXT SEARCH PARSER", "CREATE TEXT SEARCH PARSER <name> (START=..., GETTOKEN=..., END=..., LEXTYPES=...)"),
1485    ("TEXT SEARCH TEMPLATE", "CREATE TEXT SEARCH TEMPLATE <name> (INIT=..., LEXIZE=...)"),
1486  ])
1487}
1488
1489/// Object-kind keywords legal after `CREATE OR REPLACE`, `CREATE
1490/// TEMP`, `CREATE UNLOGGED`, etc. -- i.e. modifiers (OR REPLACE, TEMP,
1491/// UNIQUE, ...) are already consumed and the only legal next word is
1492/// the kind of object being created. Same static list as the full
1493/// menu minus the modifier rows.
1494pub(crate) fn after_create_object_kinds_only() -> &'static [(&'static str, &'static str)] {
1495  &[
1496    ("TABLE", "CREATE TABLE [IF NOT EXISTS] <name> (...)"),
1497    ("VIEW", "CREATE VIEW <name> AS SELECT ..."),
1498    ("MATERIALIZED VIEW", "CREATE MATERIALIZED VIEW <name> AS ..."),
1499    ("INDEX", "CREATE [UNIQUE] INDEX [CONCURRENTLY] [IF NOT EXISTS] <name> ON <table>(<cols>)"),
1500    ("UNIQUE INDEX", "CREATE UNIQUE INDEX ..."),
1501    ("SEQUENCE", "CREATE SEQUENCE [IF NOT EXISTS] <name>"),
1502    ("SCHEMA", "CREATE SCHEMA [IF NOT EXISTS] <name>"),
1503    ("FUNCTION", "CREATE [OR REPLACE] FUNCTION <name>(args) RETURNS ... AS $$ ... $$ LANGUAGE ..."),
1504    ("PROCEDURE", "CREATE [OR REPLACE] PROCEDURE <name>(args) ..."),
1505    ("TRIGGER", "CREATE [OR REPLACE] TRIGGER <name> {BEFORE|AFTER} <event> ON <table>"),
1506    ("TYPE", "CREATE TYPE <name> AS (...) | AS ENUM (...) | AS RANGE (...)"),
1507    ("ROLE", "CREATE ROLE <name> [WITH ...]"),
1508    ("USER", "CREATE USER <name> [WITH PASSWORD '...']"),
1509    ("DATABASE", "CREATE DATABASE <name> [OWNER <role>]"),
1510    ("EXTENSION", "CREATE EXTENSION [IF NOT EXISTS] <name>"),
1511    ("POLICY", "CREATE POLICY <name> ON <table> FOR ... TO ... USING (...)"),
1512    ("DOMAIN", "CREATE DOMAIN <name> AS <type> [CHECK (...)]"),
1513    ("AGGREGATE", "CREATE AGGREGATE <name>(arg_types) (SFUNC=..., STYPE=...)"),
1514    ("CAST", "CREATE CAST (src AS dst) WITH FUNCTION <fn> | WITHOUT FUNCTION"),
1515    ("COLLATION", "CREATE COLLATION <name> (...)"),
1516    ("OPERATOR", "CREATE OPERATOR <op> (...)"),
1517    ("RULE", "CREATE RULE <name> AS ON <event> TO <table> DO ..."),
1518    ("TABLESPACE", "CREATE TABLESPACE <name> LOCATION '<path>'"),
1519    ("SUBSCRIPTION", "CREATE SUBSCRIPTION <name> CONNECTION '<conn>' PUBLICATION <pub>"),
1520    ("PUBLICATION", "CREATE PUBLICATION <name> FOR TABLE ..."),
1521    ("FOREIGN TABLE", "CREATE FOREIGN TABLE <name> (...) SERVER <srv>"),
1522    ("SERVER", "CREATE SERVER <name> FOREIGN DATA WRAPPER <fdw>"),
1523    ("EVENT TRIGGER", "CREATE EVENT TRIGGER <name> ON <event> EXECUTE FUNCTION <fn>()"),
1524    ("TEXT SEARCH CONFIGURATION", "CREATE TEXT SEARCH CONFIGURATION <name> (PARSER=...)"),
1525    ("TEXT SEARCH DICTIONARY", "CREATE TEXT SEARCH DICTIONARY <name> (TEMPLATE=...)"),
1526    ("FOREIGN DATA WRAPPER", "CREATE FOREIGN DATA WRAPPER <name>"),
1527    ("CONVERSION", "CREATE [DEFAULT] CONVERSION <name> FOR '<src>' TO '<dst>' FROM <fn>"),
1528    ("TRANSFORM", "CREATE TRANSFORM FOR <type> LANGUAGE <lang> (...)"),
1529    ("USER MAPPING", "CREATE USER MAPPING FOR <role> SERVER <srv> OPTIONS (...)"),
1530    ("OPERATOR CLASS", "CREATE OPERATOR CLASS <name> FOR TYPE <type> USING <am> AS ..."),
1531    ("OPERATOR FAMILY", "CREATE OPERATOR FAMILY <name> USING <am>"),
1532    ("ACCESS METHOD", "CREATE ACCESS METHOD <name> TYPE {INDEX|TABLE} HANDLER <fn>"),
1533    ("STATISTICS", "CREATE STATISTICS [IF NOT EXISTS] <name> [(<kinds>)] ON <cols> FROM <tbl>"),
1534    ("LANGUAGE", "CREATE [OR REPLACE] [TRUSTED] [PROCEDURAL] LANGUAGE <name> HANDLER <fn>"),
1535    ("GROUP", "CREATE GROUP <name> [WITH <attr>...] -- SQL-standard alias for ROLE"),
1536    ("ROUTINE", "CREATE [OR REPLACE] ROUTINE <name>(args) ..."),
1537    ("TEXT SEARCH PARSER", "CREATE TEXT SEARCH PARSER <name> (START=..., GETTOKEN=..., END=..., LEXTYPES=...)"),
1538    ("TEXT SEARCH TEMPLATE", "CREATE TEXT SEARCH TEMPLATE <name> (INIT=..., LEXIZE=...)"),
1539  ]
1540}
1541
1542/// True when the cursor sits in the name slot right after a leading
1543/// `CREATE <CLASS>` (so the body's `(` hasn't appeared yet). Returns
1544/// the optional clarifier keywords PG accepts there -- IF NOT EXISTS,
1545/// CONCURRENTLY for indexes, ONLY for ALTER, etc.
1546pub(crate) fn create_class_expects_if_not_exists(
1547  source: &str,
1548  offset: TextSize,
1549) -> Option<&'static [(&'static str, &'static str)]> {
1550  if cursor_not_at_ws_boundary(source, offset) {
1551    return None;
1552  }
1553  let (slice_owned, _) = stmt_slice_upper(source, offset);
1554  let slice = slice_owned.trim();
1555  let upper = slice.to_ascii_uppercase();
1556  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
1557  if words.is_empty() || words[0] != "CREATE" {
1558    return None;
1559  }
1560  // Match: CREATE [OR REPLACE | TEMP | UNLOGGED | UNIQUE | MATERIALIZED ...] <CLASS> <cursor>
1561  // where <CLASS> is one of the recognised class keywords and nothing
1562  // follows it yet (i.e. the user is about to type the name).
1563  let classes = [
1564    "TABLE",
1565    "VIEW",
1566    "INDEX",
1567    "SEQUENCE",
1568    "SCHEMA",
1569    "FUNCTION",
1570    "PROCEDURE",
1571    "TRIGGER",
1572    "TYPE",
1573    "ROLE",
1574    "USER",
1575    "DATABASE",
1576    "EXTENSION",
1577    "POLICY",
1578    "DOMAIN",
1579    "AGGREGATE",
1580    "COLLATION",
1581    "RULE",
1582    "TABLESPACE",
1583    "SUBSCRIPTION",
1584    "PUBLICATION",
1585    "SERVER",
1586  ];
1587  if !classes.contains(words.last().unwrap_or(&"")) {
1588    return None;
1589  }
1590  Some(&[("IF NOT EXISTS", "CREATE ... IF NOT EXISTS <name> -- skip silently if it already exists")])
1591}
1592
1593/// True when the cursor sits directly after a leading `ALTER` keyword
1594/// with no class token typed yet -- emit the class menu PG accepts.
1595pub(crate) fn after_top_level_alter_keyword(
1596  source: &str,
1597  offset: TextSize,
1598) -> Option<&'static [(&'static str, &'static str)]> {
1599  let pos: usize = (u32::from(offset) as usize).min(source.len());
1600  let bytes = source.as_bytes();
1601  let (slice_owned, _) = stmt_slice_upper(source, offset);
1602  let slice = slice_owned.trim();
1603  let upper = slice.to_ascii_uppercase();
1604  if upper != "ALTER" {
1605    return None;
1606  }
1607  if pos < bytes.len() && !bytes[pos].is_ascii_whitespace() {
1608    return None;
1609  }
1610  Some(&[
1611    ("TABLE", "ALTER TABLE [IF EXISTS] [ONLY] <name> ..."),
1612    ("VIEW", "ALTER VIEW [IF EXISTS] <name> ..."),
1613    ("MATERIALIZED VIEW", "ALTER MATERIALIZED VIEW [IF EXISTS] <name> ..."),
1614    ("INDEX", "ALTER INDEX [IF EXISTS] <name> ..."),
1615    ("SEQUENCE", "ALTER SEQUENCE [IF EXISTS] <name> ..."),
1616    ("SCHEMA", "ALTER SCHEMA <name> RENAME TO ..."),
1617    ("FUNCTION", "ALTER FUNCTION <name>(args) ..."),
1618    ("PROCEDURE", "ALTER PROCEDURE <name>(args) ..."),
1619    ("ROUTINE", "ALTER ROUTINE <name>(args) ..."),
1620    ("TRIGGER", "ALTER TRIGGER <name> ON <table> ..."),
1621    ("TYPE", "ALTER TYPE <name> ADD VALUE ... | RENAME ..."),
1622    ("DOMAIN", "ALTER DOMAIN <name> SET DEFAULT ... | DROP DEFAULT ..."),
1623    ("ROLE", "ALTER ROLE <name> WITH ..."),
1624    ("USER", "ALTER USER <name> WITH ..."),
1625    ("GROUP", "ALTER GROUP <name> ..."),
1626    ("DATABASE", "ALTER DATABASE <name> ..."),
1627    ("EXTENSION", "ALTER EXTENSION <name> UPDATE [TO ...]"),
1628    ("POLICY", "ALTER POLICY <name> ON <table> ..."),
1629    ("AGGREGATE", "ALTER AGGREGATE <name>(args) ..."),
1630    ("CAST", "ALTER CAST (src AS dst) ..."),
1631    ("COLLATION", "ALTER COLLATION <name> ..."),
1632    ("OPERATOR", "ALTER OPERATOR <op>(args) ..."),
1633    ("OPERATOR CLASS", "ALTER OPERATOR CLASS <name> USING <am> ..."),
1634    ("OPERATOR FAMILY", "ALTER OPERATOR FAMILY <name> USING <am> ..."),
1635    ("RULE", "ALTER RULE <name> ON <table> RENAME TO ..."),
1636    ("TABLESPACE", "ALTER TABLESPACE <name> ..."),
1637    ("SUBSCRIPTION", "ALTER SUBSCRIPTION <name> ..."),
1638    ("PUBLICATION", "ALTER PUBLICATION <name> ..."),
1639    ("FOREIGN TABLE", "ALTER FOREIGN TABLE <name> ..."),
1640    ("FOREIGN DATA WRAPPER", "ALTER FOREIGN DATA WRAPPER <name> ..."),
1641    ("SERVER", "ALTER SERVER <name> ..."),
1642    ("LANGUAGE", "ALTER LANGUAGE <name> RENAME TO ..."),
1643    ("CONVERSION", "ALTER CONVERSION <name> RENAME TO ..."),
1644    ("EVENT TRIGGER", "ALTER EVENT TRIGGER <name> ..."),
1645    ("STATISTICS", "ALTER STATISTICS <name> ..."),
1646    ("TEXT SEARCH CONFIGURATION", "ALTER TEXT SEARCH CONFIGURATION <name> ..."),
1647    ("TEXT SEARCH DICTIONARY", "ALTER TEXT SEARCH DICTIONARY <name> ..."),
1648    ("TEXT SEARCH PARSER", "ALTER TEXT SEARCH PARSER <name> ..."),
1649    ("TEXT SEARCH TEMPLATE", "ALTER TEXT SEARCH TEMPLATE <name> ..."),
1650    ("SYSTEM", "ALTER SYSTEM SET <param> = ..."),
1651    ("DEFAULT PRIVILEGES", "ALTER DEFAULT PRIVILEGES [FOR ROLE <r>] [IN SCHEMA <s>] {GRANT|REVOKE} ..."),
1652    ("LARGE OBJECT", "ALTER LARGE OBJECT <oid> OWNER TO <role>"),
1653    ("USER MAPPING", "ALTER USER MAPPING FOR <role> SERVER <srv> OPTIONS (...)"),
1654  ])
1655}
1656
1657/// True when the cursor sits directly after a leading `DROP` keyword
1658/// at the start of a statement (no other meaningful tokens between
1659/// DROP and the cursor). Returns the static (keyword, doc) list of
1660/// object types the user can drop. None when DROP isn't the leading
1661/// keyword or another token has already been typed after it.
1662/// SHOW <guc> / SET <guc> / RESET <guc> -- emit common Postgres GUCs.
1663pub(crate) fn show_or_set_guc_names(source: &str, offset: TextSize) -> Option<&'static [(&'static str, &'static str)]> {
1664  if cursor_not_at_ws_boundary(source, offset) {
1665    return None;
1666  }
1667  let (slice_owned, _) = stmt_slice_upper(source, offset);
1668  let slice = slice_owned.trim();
1669  let upper = slice.to_ascii_uppercase();
1670  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
1671  if words.is_empty() {
1672    return None;
1673  }
1674  let want_guc = (words.len() == 1 && matches!(words[0], "SHOW" | "RESET"))
1675    || (words.len() == 2 && words[0] == "RESET" && words[1] != "ALL")
1676    || (words.len() == 2 && words[0] == "SET" && matches!(words[1], "LOCAL" | "SESSION"))
1677    || (words.len() == 2 && words[0] == "SET" && !matches!(words[1], "LOCAL" | "SESSION" | "TRANSACTION" | "ROLE" | "CONSTRAINTS" | "SESSION_AUTHORIZATION" | "TIME"))
1678    || (words.len() == 3 && words[0] == "SET" && matches!(words[1], "LOCAL" | "SESSION"))
1679    // ALTER {ROLE | USER | DATABASE} <name> SET <cursor>
1680    //   -> GUC name slot. The trailing SET-followup `TABLESPACE` /
1681    //   `SCHEMA` / etc. are accepted by the parser too, but the common
1682    //   case is per-role / per-db GUC override, so surface the GUC list.
1683    || (words.len() >= 4
1684        && words[0] == "ALTER"
1685        && matches!(words[1], "ROLE" | "USER" | "DATABASE")
1686        && words.last() == Some(&"SET"));
1687  if !want_guc {
1688    return None;
1689  }
1690  Some(&[
1691    ("ALL", "RESET ALL / SHOW ALL -- every GUC at once"),
1692    ("search_path", "search_path = 'public, schema2' -- schema resolution order"),
1693    ("timezone", "timezone = 'UTC'"),
1694    ("statement_timeout", "statement_timeout = '5s' -- abort long statements"),
1695    ("lock_timeout", "lock_timeout = '5s'"),
1696    ("idle_in_transaction_session_timeout", "idle_in_transaction_session_timeout = '60s'"),
1697    ("work_mem", "work_mem = '64MB' -- per-sort/hash memory"),
1698    ("maintenance_work_mem", "maintenance_work_mem = '256MB'"),
1699    ("shared_buffers", "shared_buffers = '2GB' (postgresql.conf only)"),
1700    ("effective_cache_size", "effective_cache_size = '8GB' -- planner hint"),
1701    ("default_transaction_isolation", "default_transaction_isolation = 'repeatable read'"),
1702    ("default_transaction_read_only", "default_transaction_read_only = on"),
1703    ("default_transaction_deferrable", "default_transaction_deferrable = on"),
1704    ("application_name", "application_name = 'myapp'"),
1705    ("log_statement", "log_statement = 'all' | 'mod' | 'ddl' | 'none'"),
1706    ("log_min_duration_statement", "log_min_duration_statement = '1s'"),
1707    ("client_encoding", "client_encoding = 'UTF8'"),
1708    ("DateStyle", "DateStyle = 'ISO, YMD'"),
1709    ("IntervalStyle", "IntervalStyle = 'iso_8601'"),
1710    ("synchronous_commit", "synchronous_commit = on | off | local | remote_write | remote_apply"),
1711    ("enable_seqscan", "enable_seqscan = off"),
1712    ("enable_hashjoin", "enable_hashjoin = off"),
1713    ("enable_mergejoin", "enable_mergejoin = off"),
1714    ("enable_nestloop", "enable_nestloop = off"),
1715    ("random_page_cost", "random_page_cost = 1.1 -- SSD-friendly"),
1716    ("seq_page_cost", "seq_page_cost = 1.0"),
1717    ("cpu_tuple_cost", "cpu_tuple_cost = 0.01"),
1718    ("jit", "jit = off"),
1719    ("max_parallel_workers_per_gather", "max_parallel_workers_per_gather = 4"),
1720    ("row_security", "row_security = on | off"),
1721    ("transaction_isolation", "transaction_isolation = 'serializable' | 'repeatable read' | 'read committed' (per-tx)"),
1722    ("transaction_read_only", "transaction_read_only = on | off (per-tx)"),
1723    ("transaction_deferrable", "transaction_deferrable = on (only with SERIALIZABLE + READ ONLY)"),
1724    ("vacuum_buffer_usage_limit", "vacuum_buffer_usage_limit = '<size>' (PG16+)"),
1725    ("temp_buffers", "temp_buffers = '8MB'"),
1726    ("temp_file_limit", "temp_file_limit = '-1' -- per-session temp disk cap"),
1727    ("max_parallel_maintenance_workers", "max_parallel_maintenance_workers = <n>"),
1728    ("max_parallel_workers", "max_parallel_workers = <n>"),
1729    ("min_parallel_index_scan_size", "min_parallel_index_scan_size = '512kB'"),
1730    ("min_parallel_table_scan_size", "min_parallel_table_scan_size = '8MB'"),
1731    ("parallel_setup_cost", "parallel_setup_cost = 1000"),
1732    ("parallel_tuple_cost", "parallel_tuple_cost = 0.1"),
1733    ("plan_cache_mode", "plan_cache_mode = 'auto' | 'force_custom_plan' | 'force_generic_plan'"),
1734    ("commit_delay", "commit_delay = <us>"),
1735    ("commit_siblings", "commit_siblings = <n>"),
1736    ("force_parallel_mode", "force_parallel_mode = off | on | regress (debug)"),
1737    ("session_replication_role", "session_replication_role = 'origin' | 'replica' | 'local'"),
1738    ("array_nulls", "array_nulls = on | off"),
1739    ("backslash_quote", "backslash_quote = 'safe_encoding' | 'on' | 'off'"),
1740    ("escape_string_warning", "escape_string_warning = on | off"),
1741    ("standard_conforming_strings", "standard_conforming_strings = on"),
1742    ("log_lock_waits", "log_lock_waits = on -- log waits longer than deadlock_timeout"),
1743    ("log_temp_files", "log_temp_files = '0' -- log every temp file (any size when 0)"),
1744    ("log_checkpoints", "log_checkpoints = on"),
1745    ("log_connections", "log_connections = on"),
1746    ("log_disconnections", "log_disconnections = on"),
1747    ("log_autovacuum_min_duration", "log_autovacuum_min_duration = '5s'"),
1748    ("log_replication_commands", "log_replication_commands = on"),
1749    ("debug_print_parse", "debug_print_parse = on (debug)"),
1750    ("debug_print_plan", "debug_print_plan = on (debug)"),
1751    ("debug_print_rewritten", "debug_print_rewritten = on (debug)"),
1752    ("tcp_keepalives_idle", "tcp_keepalives_idle = 60"),
1753    ("tcp_keepalives_interval", "tcp_keepalives_interval = 10"),
1754    ("tcp_keepalives_count", "tcp_keepalives_count = 3"),
1755    ("tcp_user_timeout", "tcp_user_timeout = 30000"),
1756    ("client_min_messages", "client_min_messages = notice | warning | error | log | debug1..5"),
1757    ("log_min_messages", "log_min_messages = warning | error | log | debug1..5"),
1758    ("log_min_error_statement", "log_min_error_statement = error"),
1759    ("log_error_verbosity", "log_error_verbosity = default | terse | verbose"),
1760    ("log_line_prefix", "log_line_prefix = '%m [%p] %u@%d '"),
1761    ("scram_iterations", "scram_iterations = 4096 (PG16+)"),
1762    ("password_encryption", "password_encryption = scram-sha-256"),
1763    ("ssl", "ssl = on"),
1764    ("hot_standby_feedback", "hot_standby_feedback = on"),
1765    ("max_standby_streaming_delay", "max_standby_streaming_delay = '30s'"),
1766    ("max_locks_per_transaction", "max_locks_per_transaction = 64 (postgresql.conf only)"),
1767    ("max_pred_locks_per_transaction", "max_pred_locks_per_transaction = 64"),
1768    ("max_connections", "max_connections = 100 (postgresql.conf only)"),
1769    ("max_prepared_transactions", "max_prepared_transactions = 0 (2PC; postgresql.conf only)"),
1770    ("max_replication_slots", "max_replication_slots = 10 (postgresql.conf only)"),
1771    ("max_wal_senders", "max_wal_senders = 10"),
1772    ("wal_compression", "wal_compression = on | off | pglz | lz4 | zstd"),
1773    ("wal_level", "wal_level = replica | logical (postgresql.conf only)"),
1774    ("archive_mode", "archive_mode = on | off | always"),
1775    ("checkpoint_timeout", "checkpoint_timeout = '5min'"),
1776    ("checkpoint_completion_target", "checkpoint_completion_target = 0.9"),
1777    ("default_toast_compression", "default_toast_compression = pglz | lz4"),
1778    ("default_table_access_method", "default_table_access_method = heap"),
1779    ("recovery_init_sync_method", "recovery_init_sync_method = fsync | syncfs (PG14+)"),
1780    ("restart_after_crash", "restart_after_crash = on"),
1781    ("xmlbinary", "xmlbinary = base64 | hex"),
1782    ("xmloption", "xmloption = content | document"),
1783  ])
1784}
1785
1786/// SECURITY LABEL chain.
1787///   SECURITY LABEL [FOR <provider>] ON <object_kind> <name> IS '<label>'
1788pub(crate) fn security_label_next_keyword(
1789  source: &str,
1790  offset: TextSize,
1791) -> Option<&'static [(&'static str, &'static str)]> {
1792  if cursor_not_at_ws_boundary(source, offset) {
1793    return None;
1794  }
1795  let (_, upper) = stmt_slice_upper(source, offset);
1796  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
1797  if words.len() < 2 || words[0] != "SECURITY" || words[1] != "LABEL" {
1798    return None;
1799  }
1800  let last = *words.last()?;
1801  if last == "LABEL" {
1802    return Some(&[("FOR", "FOR <provider>"), ("ON", "ON <object_kind> <name>")]);
1803  }
1804  if last == "FOR" {
1805    return None; // user types provider name
1806  }
1807  if last == "ON" {
1808    return Some(&[
1809      ("TABLE", "ON TABLE <name>"),
1810      ("COLUMN", "ON COLUMN <tbl>.<col>"),
1811      ("VIEW", "ON VIEW <name>"),
1812      ("MATERIALIZED VIEW", "ON MATERIALIZED VIEW <name>"),
1813      ("INDEX", "ON INDEX <name>"),
1814      ("SEQUENCE", "ON SEQUENCE <name>"),
1815      ("FUNCTION", "ON FUNCTION <name>(args)"),
1816      ("PROCEDURE", "ON PROCEDURE <name>(args)"),
1817      ("ROUTINE", "ON ROUTINE <name>(args)"),
1818      ("TYPE", "ON TYPE <name>"),
1819      ("DOMAIN", "ON DOMAIN <name>"),
1820      ("SCHEMA", "ON SCHEMA <name>"),
1821      ("ROLE", "ON ROLE <name>"),
1822      ("DATABASE", "ON DATABASE <name>"),
1823      ("TABLESPACE", "ON TABLESPACE <name>"),
1824      ("AGGREGATE", "ON AGGREGATE <name>(args)"),
1825      ("COLLATION", "ON COLLATION <name>"),
1826      ("EVENT TRIGGER", "ON EVENT TRIGGER <name>"),
1827      ("FOREIGN TABLE", "ON FOREIGN TABLE <name>"),
1828      ("LARGE OBJECT", "ON LARGE OBJECT <oid>"),
1829      ("LANGUAGE", "ON LANGUAGE <name>"),
1830      ("PUBLICATION", "ON PUBLICATION <name>"),
1831      ("SUBSCRIPTION", "ON SUBSCRIPTION <name>"),
1832    ]);
1833  }
1834  // After name -> IS.
1835  if words.contains(&"ON") && !words.contains(&"IS") && words.len() >= 5 {
1836    return Some(&[("IS", "IS '<label_text>' | IS NULL -- clear label")]);
1837  }
1838  // After IS -> common provider-specific label literal forms.
1839  if last == "IS" {
1840    return Some(&[
1841      ("NULL", "IS NULL -- clear the security label"),
1842      ("'unclassified'", "'unclassified'"),
1843      ("'confidential'", "'confidential'"),
1844      ("'secret'", "'secret'"),
1845      ("'top_secret'", "'top_secret'"),
1846    ]);
1847  }
1848  None
1849}
1850
1851/// ALTER TABLE ATTACH PARTITION / DETACH PARTITION / INHERIT chain.
1852pub(crate) fn alter_table_attach_detach_next_keyword(
1853  source: &str,
1854  offset: TextSize,
1855) -> Option<&'static [(&'static str, &'static str)]> {
1856  if cursor_not_at_ws_boundary(source, offset) {
1857    return None;
1858  }
1859  let (_, upper) = stmt_slice_upper(source, offset);
1860  // Word-boundary check: `ALTER TABLESPACE` must not satisfy this.
1861  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
1862  if words.first() != Some(&"ALTER") || words.get(1) != Some(&"TABLE") {
1863    return None;
1864  }
1865  let last = *words.last()?;
1866  if last == "ATTACH" || last == "DETACH" {
1867    return Some(&[("PARTITION", "PARTITION <child>")]);
1868  }
1869  // After ATTACH PARTITION <child> -> FOR VALUES menu.
1870  if words.contains(&"ATTACH")
1871    && words.contains(&"PARTITION")
1872    && words.len() >= 6
1873    && last != "PARTITION"
1874    && last != "FOR"
1875    && last != "VALUES"
1876    && !words.contains(&"VALUES")
1877  {
1878    return Some(&[
1879      ("FOR", "FOR VALUES { IN (...) | FROM (...) TO (...) | WITH (...) }"),
1880      ("DEFAULT", "DEFAULT -- catch-all partition"),
1881    ]);
1882  }
1883  // DETACH PARTITION <child> -> CONCURRENTLY / FINALIZE.
1884  if words.contains(&"DETACH")
1885    && words.contains(&"PARTITION")
1886    && words.len() >= 6
1887    && !words.contains(&"CONCURRENTLY")
1888    && !words.contains(&"FINALIZE")
1889  {
1890    return Some(&[
1891      ("CONCURRENTLY", "CONCURRENTLY -- detach without long lock"),
1892      ("FINALIZE", "FINALIZE -- complete a concurrent detach"),
1893    ]);
1894  }
1895  if last == "INHERIT" {
1896    return None; // user types parent table name
1897  }
1898  if last == "NO" && words.contains(&"ALTER") {
1899    return Some(&[("INHERIT", "NO INHERIT <parent> -- remove inheritance link")]);
1900  }
1901  // After ALTER TABLE <name> -> include INHERIT/NO INHERIT/ATTACH/DETACH in the action menu.
1902  if words.len() == 3 {
1903    return Some(&[
1904      ("ATTACH PARTITION", "ATTACH PARTITION <child> FOR VALUES ..."),
1905      ("DETACH PARTITION", "DETACH PARTITION <child> [CONCURRENTLY|FINALIZE]"),
1906      ("INHERIT", "INHERIT <parent> -- add inheritance link"),
1907      ("NO INHERIT", "NO INHERIT <parent> -- remove inheritance link"),
1908    ]);
1909  }
1910  None
1911}
1912
1913/// PARTITION chain. Covers `CREATE TABLE <child> PARTITION OF <parent>
1914/// FOR VALUES {IN | FROM ... TO ... | WITH (...)}` and `PARTITION BY
1915/// {RANGE | LIST | HASH} (<cols>)`.
1916pub(crate) fn partition_next_keyword(
1917  source: &str,
1918  offset: TextSize,
1919) -> Option<&'static [(&'static str, &'static str)]> {
1920  if cursor_not_at_ws_boundary(source, offset) {
1921    return None;
1922  }
1923  let (_, upper) = stmt_slice_upper(source, offset);
1924  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
1925  let last = *words.last()?;
1926  // `PARTITION OF <parent>` slot.
1927  if last == "PARTITION" {
1928    return Some(&[("OF", "PARTITION OF <parent> FOR VALUES ..."), ("BY", "PARTITION BY {RANGE|LIST|HASH} (<cols>)")]);
1929  }
1930  if last == "OF" && words.contains(&"PARTITION") {
1931    return None; // parent table name
1932  }
1933  // `FOR <cursor>` after PARTITION OF <parent>.
1934  if last == "FOR" && words.contains(&"PARTITION") && words.contains(&"OF") {
1935    return Some(&[
1936      ("VALUES", "FOR VALUES { IN (...) | FROM (...) TO (...) | WITH (MODULUS ..., REMAINDER ...) }"),
1937      ("DEFAULT", "FOR VALUES DEFAULT -- catch-all partition"),
1938    ]);
1939  }
1940  if last == "VALUES" && words.contains(&"PARTITION") {
1941    return Some(&[
1942      ("IN", "IN (<v>[, ...]) -- list partition"),
1943      ("FROM", "FROM (<lo>) TO (<hi>) -- range partition"),
1944      ("WITH", "WITH (MODULUS <n>, REMAINDER <r>) -- hash partition"),
1945      ("DEFAULT", "DEFAULT -- catch-all"),
1946    ]);
1947  }
1948  // `PARTITION BY <cursor>` -> RANGE / LIST / HASH.
1949  if last == "BY" && words.contains(&"PARTITION") {
1950    return Some(&[
1951      ("RANGE", "PARTITION BY RANGE (<cols>)"),
1952      ("LIST", "PARTITION BY LIST (<col>)"),
1953      ("HASH", "PARTITION BY HASH (<col>)"),
1954    ]);
1955  }
1956  // `FOR VALUES FROM (<lo>) <cursor>` -> TO
1957  if last == ")" && words.contains(&"FROM") && words.contains(&"VALUES") && !words.contains(&"TO") {
1958    return Some(&[("TO", "TO (<hi>) -- upper bound of the range")]);
1959  }
1960  None
1961}
1962
1963/// REFRESH MATERIALIZED VIEW <name> [WITH [NO] DATA] phase.
1964pub(crate) fn refresh_mv_next_keyword(
1965  source: &str,
1966  offset: TextSize,
1967) -> Option<&'static [(&'static str, &'static str)]> {
1968  if cursor_not_at_ws_boundary(source, offset) {
1969    return None;
1970  }
1971  let (_, upper) = stmt_slice_upper(source, offset);
1972  let trimmed = upper.trim_start();
1973  if !trimmed.starts_with("REFRESH MATERIALIZED VIEW") {
1974    return None;
1975  }
1976  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
1977  let last = *words.last()?;
1978  // After the view name, suggest CONCURRENTLY (if not present yet) + WITH ...
1979  // After `WITH` -> DATA | NO DATA
1980  if last == "WITH" {
1981    return Some(&[
1982      ("DATA", "WITH DATA -- run the refresh query (default)"),
1983      ("NO DATA", "WITH NO DATA -- mark the MV invalid; useful before bulk reload"),
1984    ]);
1985  }
1986  if last == "NO" && words.contains(&"WITH") {
1987    return Some(&[("DATA", "NO DATA")]);
1988  }
1989  // After the name -- need >= 4 words (REFRESH MATERIALIZED VIEW <name>)
1990  if words.len() >= 4 && !matches!(last, "REFRESH" | "MATERIALIZED" | "VIEW" | "CONCURRENTLY") {
1991    let mut menu: Vec<(&str, &str)> = Vec::with_capacity(2);
1992    if !words.contains(&"CONCURRENTLY") {
1993      menu.push(("WITH DATA", "WITH DATA -- populate (default)"));
1994      menu.push(("WITH NO DATA", "WITH NO DATA -- mark invalid"));
1995    } else {
1996      menu.push(("WITH DATA", "WITH DATA"));
1997      menu.push(("WITH NO DATA", "WITH NO DATA"));
1998    }
1999    // Static return type required -- pick a hardcoded set.
2000    return Some(&[
2001      ("WITH DATA", "WITH DATA -- populate (default)"),
2002      ("WITH NO DATA", "WITH NO DATA -- mark invalid; refresh later"),
2003    ]);
2004  }
2005  None
2006}
2007
2008/// `... AS IDENTITY ( <cursor>` -- sequence-option name slot in column
2009/// IDENTITY clause. Same option list as CREATE SEQUENCE.
2010pub(crate) fn identity_paren_next_keyword(
2011  source: &str,
2012  offset: TextSize,
2013) -> Option<&'static [(&'static str, &'static str)]> {
2014  if cursor_not_at_ws_boundary(source, offset)
2015    && !source[..offset.into()].ends_with('(')
2016    && !source[..offset.into()].ends_with(',')
2017  {
2018    return None;
2019  }
2020  let (slice_owned, upper) = stmt_slice_upper(source, offset);
2021  if !upper.contains("AS IDENTITY") && !upper.contains("AS  IDENTITY") {
2022    return None;
2023  }
2024  // Must be inside the paren immediately following `AS IDENTITY`.
2025  let at = upper.rfind("AS IDENTITY")?;
2026  let after = &slice_owned[at + "AS IDENTITY".len()..];
2027  let trimmed = after.trim_start();
2028  if !trimmed.starts_with('(') {
2029    return None;
2030  }
2031  let body = &trimmed[1..];
2032  let opens = body.matches('(').count();
2033  let closes = body.matches(')').count();
2034  if closes > opens {
2035    return None;
2036  }
2037  // Must NOT already be past the closing `)`.
2038  if body.ends_with(')') && opens == closes {
2039    return None;
2040  }
2041  Some(&[
2042    ("START WITH", "START [WITH] <n> -- first generated value"),
2043    ("INCREMENT BY", "INCREMENT [BY] <n> -- step size"),
2044    ("MINVALUE", "MINVALUE <n> | NO MINVALUE"),
2045    ("MAXVALUE", "MAXVALUE <n> | NO MAXVALUE"),
2046    ("CACHE", "CACHE <n> -- preallocate per-backend"),
2047    ("CYCLE", "CYCLE -- wrap around at MAXVALUE/MINVALUE"),
2048    ("NO CYCLE", "NO CYCLE -- raise error on exhaust (default)"),
2049    ("OWNED BY", "OWNED BY <table>.<col> | NONE -- drop sequence when col goes"),
2050  ])
2051}
2052
2053/// CREATE TABLE AS / CREATE MATERIALIZED VIEW chain:
2054///   `... AS SELECT ... <cursor>` -> WITH DATA | WITH NO DATA
2055///   `... WITH <cursor>` -> DATA | NO DATA
2056///   `... WITH NO <cursor>` -> DATA
2057pub(crate) fn ctas_with_data_next_keyword(
2058  source: &str,
2059  offset: TextSize,
2060) -> Option<&'static [(&'static str, &'static str)]> {
2061  if cursor_not_at_ws_boundary(source, offset) {
2062    return None;
2063  }
2064  let (_, upper) = stmt_slice_upper(source, offset);
2065  let is_ctas = upper.starts_with("CREATE TABLE") && upper.contains(" AS ");
2066  let is_cmv = upper.starts_with("CREATE MATERIALIZED VIEW");
2067  if !(is_ctas || is_cmv) {
2068    return None;
2069  }
2070  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
2071  let last = *words.last()?;
2072  if last == "NO" && words.contains(&"WITH") {
2073    return Some(&[("DATA", "NO DATA -- create the relation but skip the populate query")]);
2074  }
2075  if last == "WITH" {
2076    return Some(&[
2077      ("DATA", "WITH DATA -- run the populate query immediately (default)"),
2078      ("NO DATA", "WITH NO DATA -- create empty; populate later with REFRESH/INSERT"),
2079    ]);
2080  }
2081  // Only emit WITH options after `AS SELECT ...` or after the CMV body.
2082  if (is_ctas || is_cmv) && !words.contains(&"WITH") {
2083    // Heuristic: after a SELECT/VALUES body. Last token unlikely to be
2084    // a keyword we already chained. Skip if too few tokens.
2085    if words.len() >= 5 {
2086      return Some(&[("WITH DATA", "WITH DATA -- populate now"), ("WITH NO DATA", "WITH NO DATA -- create empty")]);
2087    }
2088  }
2089  None
2090}
2091
2092/// `INSERT INTO <tbl> [(cols)] <cursor>` -> body shape menu.
2093pub(crate) fn insert_into_next_keyword(
2094  source: &str,
2095  offset: TextSize,
2096) -> Option<&'static [(&'static str, &'static str)]> {
2097  if cursor_not_at_ws_boundary(source, offset) {
2098    return None;
2099  }
2100  let (slice_owned, upper) = stmt_slice_upper(source, offset);
2101  let slice = slice_owned.as_str();
2102  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
2103  if words.first() != Some(&"INSERT") {
2104    return None;
2105  }
2106  if !words.contains(&"INTO") || words.len() < 3 {
2107    return None;
2108  }
2109  // Only fire when body not yet typed (no VALUES/SELECT/DEFAULT).
2110  let has_body =
2111    words.contains(&"VALUES") || words.contains(&"SELECT") || words.contains(&"DEFAULT") || words.contains(&"CONFLICT");
2112  if has_body {
2113    return None;
2114  }
2115  // OVERRIDING SYSTEM/USER is a sub-clause that lives between the
2116  // (col-list) and VALUES; only defer to `insert_overriding_next_keyword`
2117  // while the sub-clause is mid-typing (last word OVERRIDING/SYSTEM/USER).
2118  // Once the user reaches VALUE, fall through so the body-shape menu fires.
2119  if words.contains(&"OVERRIDING") && matches!(words.last(), Some(&"OVERRIDING") | Some(&"SYSTEM") | Some(&"USER")) {
2120    return None;
2121  }
2122  // After (cols)? require balanced parens.
2123  let opens = slice.matches('(').count();
2124  let closes = slice.matches(')').count();
2125  if opens != closes {
2126    return None;
2127  }
2128  Some(&[
2129    ("VALUES", "VALUES (<v>[, ...])[, ...]"),
2130    ("SELECT", "INSERT INTO ... SELECT <cols> FROM <src>"),
2131    ("DEFAULT VALUES", "DEFAULT VALUES -- all columns take their declared defaults"),
2132    ("OVERRIDING", "OVERRIDING {SYSTEM|USER} VALUE -- identity-column override"),
2133    ("ON CONFLICT", "ON CONFLICT [(target)] DO ... -- upsert"),
2134    ("RETURNING", "RETURNING <cols>"),
2135  ])
2136}
2137
2138/// `UPDATE <tbl> <cursor>` -> SET / FROM / WHERE / RETURNING.
2139pub(crate) fn update_from_set_next_keyword(
2140  source: &str,
2141  offset: TextSize,
2142) -> Option<&'static [(&'static str, &'static str)]> {
2143  if cursor_not_at_ws_boundary(source, offset) {
2144    return None;
2145  }
2146  let (_, upper) = stmt_slice_upper(source, offset);
2147  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
2148  if words.first() != Some(&"UPDATE") {
2149    return None;
2150  }
2151  // Only fire when no SET typed yet AND at least one ident after UPDATE.
2152  if words.contains(&"SET") || words.len() < 3 {
2153    return None;
2154  }
2155  // Skip ONLY modifier or alias word.
2156  Some(&[
2157    ("SET", "SET <col> = <expr>[, ...]"),
2158    ("FROM", "FROM <other_tbl> -- multi-table UPDATE"),
2159    ("WHERE", "WHERE <predicate>"),
2160    ("RETURNING", "RETURNING <cols>"),
2161  ])
2162}
2163
2164/// `DELETE FROM <tbl> <cursor>` -> USING / WHERE / RETURNING.
2165pub(crate) fn delete_using_next_keyword(
2166  source: &str,
2167  offset: TextSize,
2168) -> Option<&'static [(&'static str, &'static str)]> {
2169  if cursor_not_at_ws_boundary(source, offset) {
2170    return None;
2171  }
2172  let (_, upper) = stmt_slice_upper(source, offset);
2173  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
2174  if words.first() != Some(&"DELETE") {
2175    return None;
2176  }
2177  if !words.contains(&"FROM") || words.len() < 3 {
2178    return None;
2179  }
2180  if words.contains(&"USING") || words.contains(&"WHERE") || words.contains(&"RETURNING") {
2181    return None;
2182  }
2183  Some(&[
2184    ("USING", "USING <other_tbl> -- multi-table DELETE"),
2185    ("WHERE", "WHERE <predicate>"),
2186    ("RETURNING", "RETURNING <cols>"),
2187  ])
2188}
2189
2190/// TABLESAMPLE <method> (<args>) <cursor> -> REPEATABLE (<seed>).
2191pub(crate) fn tablesample_after_paren_next_keyword(
2192  source: &str,
2193  offset: TextSize,
2194) -> Option<&'static [(&'static str, &'static str)]> {
2195  if cursor_not_at_ws_boundary(source, offset) {
2196    return None;
2197  }
2198  let (slice_owned, upper) = stmt_slice_upper(source, offset);
2199  let slice = slice_owned.as_str();
2200  if !upper.contains("TABLESAMPLE") {
2201    return None;
2202  }
2203  // Must be past a closing `)` and method was already typed.
2204  let trimmed = slice.trim_end();
2205  if !trimmed.ends_with(')') {
2206    return None;
2207  }
2208  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
2209  if !words.iter().any(|w| *w == "BERNOULLI" || *w == "SYSTEM") {
2210    return None;
2211  }
2212  if words.contains(&"REPEATABLE") {
2213    return None;
2214  }
2215  Some(&[("REPEATABLE", "REPEATABLE (<seed>) -- reproducible sample")])
2216}
2217
2218/// `<agg>(...) FILTER (<cursor>` -- FILTER's entire grammar is
2219/// `FILTER (WHERE <cond>)`, so WHERE is the only legal next token.
2220/// Narrow trigger: only fires immediately after the opening paren
2221/// (nothing typed yet), not once the user is already inside a WHERE
2222/// predicate -- that case wants the normal expression/column menu.
2223pub(crate) fn filter_clause_next_keyword(
2224  source: &str,
2225  offset: TextSize,
2226) -> Option<&'static [(&'static str, &'static str)]> {
2227  if cursor_not_at_ws_boundary(source, offset) {
2228    return None;
2229  }
2230  let (_, upper) = stmt_slice_upper(source, offset);
2231  let trimmed = upper.trim_end();
2232  if trimmed.ends_with("FILTER (") || trimmed.ends_with("FILTER(") {
2233    return Some(&[("WHERE", "FILTER (WHERE <cond>) -- restrict which rows the aggregate sees")]);
2234  }
2235  None
2236}
2237
2238/// `<set-returning-fn>(...) WITH <cursor>` in a FROM/JOIN item --
2239/// ORDINALITY is the only keyword that legally follows WITH directly
2240/// after a table-function call's closing paren (a leading statement
2241/// WITH is the CTE keyword, which can't appear there). Excludes
2242/// CREATE TABLE AS / CREATE MATERIALIZED VIEW statements, where a
2243/// trailing `... WITH` after the query means `WITH [NO] DATA`
2244/// instead -- that ambiguity is real (a table function can be the
2245/// last FROM item there too), so this intentionally defers to the
2246/// existing WITH DATA / NO DATA completion rather than guessing.
2247pub(crate) fn table_function_with_ordinality_next_keyword(
2248  source: &str,
2249  offset: TextSize,
2250) -> Option<&'static [(&'static str, &'static str)]> {
2251  if cursor_not_at_ws_boundary(source, offset) {
2252    return None;
2253  }
2254  let (_, upper) = stmt_slice_upper(source, offset);
2255  let trimmed = upper.trim_end();
2256  if !trimmed.ends_with(") WITH") {
2257    return None;
2258  }
2259  if upper.trim_start().starts_with("CREATE") {
2260    return None;
2261  }
2262  if !(upper.contains("FROM ") || upper.contains("JOIN ")) {
2263    return None;
2264  }
2265  Some(&[("ORDINALITY", "WITH ORDINALITY -- append a 1-based row-number column")])
2266}
2267
2268/// WINDOW <name> AS ( <cursor> ) -> emit PARTITION BY / ORDER BY / frame.
2269pub(crate) fn window_clause_as_paren_keyword(
2270  source: &str,
2271  offset: TextSize,
2272) -> Option<&'static [(&'static str, &'static str)]> {
2273  let pos: usize = (u32::from(offset) as usize).min(source.len());
2274  let bytes = source.as_bytes();
2275  if pos < bytes.len() && !bytes[pos].is_ascii_whitespace() && bytes[pos] != b'(' {
2276    return None;
2277  }
2278  let (slice_owned, upper) = stmt_slice_upper(source, offset);
2279  let slice = slice_owned.as_str();
2280  // Accept either a WINDOW clause (`WINDOW name AS (...)`) or an inline
2281  // OVER (...) window specification. Both share the same body grammar.
2282  if !upper.contains("WINDOW") && !upper.contains("OVER") {
2283    return None;
2284  }
2285  // Detect a still-open paren -- both forms put the cursor inside the
2286  // window spec body.
2287  let opens = slice.matches('(').count();
2288  let closes = slice.matches(')').count();
2289  if opens == 0 || opens <= closes {
2290    return None;
2291  }
2292  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
2293  let last = *words.last()?;
2294  if last == "PARTITION" {
2295    return Some(&[("BY", "PARTITION BY <expr>[, ...]")]);
2296  }
2297  if last == "ORDER" {
2298    return Some(&[("BY", "ORDER BY <expr>[, ...]")]);
2299  }
2300  // After RANGE/ROWS/GROUPS -> BETWEEN <bound> | <bound>
2301  if matches!(last, "RANGE" | "ROWS" | "GROUPS") {
2302    return Some(&[
2303      ("BETWEEN", "BETWEEN <a> AND <b>"),
2304      ("UNBOUNDED PRECEDING", "frame starts at partition start"),
2305      ("CURRENT ROW", "frame starts at the current row"),
2306    ]);
2307  }
2308  // After BETWEEN -> lower bound options
2309  if last == "BETWEEN" {
2310    return Some(&[("UNBOUNDED PRECEDING", "frame starts at partition start"), ("CURRENT ROW", "current row")]);
2311  }
2312  // After AND inside a BETWEEN -> upper bound options
2313  if last == "AND" && words.contains(&"BETWEEN") {
2314    return Some(&[("UNBOUNDED FOLLOWING", "frame ends at partition end"), ("CURRENT ROW", "current row")]);
2315  }
2316  // UNBOUNDED followups: PRECEDING (before AND) or FOLLOWING (after AND).
2317  if last == "UNBOUNDED" {
2318    let mut after_and = false;
2319    if let Some(b_idx) = words.iter().rposition(|w| *w == "BETWEEN")
2320      && words[b_idx + 1..].contains(&"AND")
2321    {
2322      after_and = true;
2323    }
2324    if after_and {
2325      return Some(&[("FOLLOWING", "UNBOUNDED FOLLOWING -- frame ends at partition end")]);
2326    }
2327    return Some(&[("PRECEDING", "UNBOUNDED PRECEDING -- frame starts at partition start")]);
2328  }
2329  // CURRENT followup: ROW.
2330  if last == "CURRENT" {
2331    return Some(&[("ROW", "CURRENT ROW -- the current row only")]);
2332  }
2333  // EXCLUDE bare: emit the four exclusion modes.
2334  if last == "EXCLUDE" {
2335    return Some(&[
2336      ("CURRENT ROW", "EXCLUDE CURRENT ROW -- skip the current row from the frame"),
2337      ("GROUP", "EXCLUDE GROUP -- skip the current row and all peers"),
2338      ("TIES", "EXCLUDE TIES -- skip the peers but keep the current row"),
2339      ("NO OTHERS", "EXCLUDE NO OTHERS -- default; no exclusion"),
2340    ]);
2341  }
2342  // After PRECEDING / FOLLOWING / CURRENT -- continue with AND or EXCLUDE.
2343  if matches!(last, "PRECEDING" | "FOLLOWING") {
2344    let mut needs_and = false;
2345    if let Some(b_idx) = words.iter().rposition(|w| *w == "BETWEEN")
2346      && !words[b_idx + 1..].contains(&"AND")
2347    {
2348      needs_and = true;
2349    }
2350    if needs_and {
2351      return Some(&[("AND", "BETWEEN <a> AND <b>")]);
2352    }
2353    return Some(&[
2354      ("EXCLUDE CURRENT ROW", "EXCLUDE CURRENT ROW"),
2355      ("EXCLUDE GROUP", "EXCLUDE GROUP"),
2356      ("EXCLUDE TIES", "EXCLUDE TIES"),
2357      ("EXCLUDE NO OTHERS", "EXCLUDE NO OTHERS (default)"),
2358    ]);
2359  }
2360  // Cursor at fresh slot inside the paren.
2361  let trimmed = slice.trim_end();
2362  let last_char = trimmed.chars().last();
2363  if matches!(last_char, Some('(') | Some(',')) || slice.ends_with(char::is_whitespace) {
2364    return Some(&[
2365      ("PARTITION BY", "PARTITION BY <expr>[, ...]"),
2366      ("ORDER BY", "ORDER BY <expr>[, ...]"),
2367      ("RANGE", "RANGE BETWEEN <a> AND <b>"),
2368      ("ROWS", "ROWS BETWEEN <a> AND <b>"),
2369      ("GROUPS", "GROUPS BETWEEN <a> AND <b>"),
2370    ]);
2371  }
2372  None
2373}
2374
2375/// `... UNION / INTERSECT / EXCEPT <cursor>` -> ALL | DISTINCT | new
2376/// SELECT (handled elsewhere).
2377pub(crate) fn set_op_followup_next_keyword(
2378  source: &str,
2379  offset: TextSize,
2380) -> Option<&'static [(&'static str, &'static str)]> {
2381  if cursor_not_at_ws_boundary(source, offset) {
2382    return None;
2383  }
2384  let (_, upper) = stmt_slice_upper(source, offset);
2385  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
2386  let last = *words.last()?;
2387  if !matches!(last, "UNION" | "INTERSECT" | "EXCEPT") {
2388    return None;
2389  }
2390  Some(&[
2391    ("ALL", "ALL -- keep duplicates (no implicit DISTINCT)"),
2392    ("DISTINCT", "DISTINCT -- explicit form of the default"),
2393    ("SELECT", "SELECT <next_query>"),
2394    ("VALUES", "VALUES (<row>) -- inline rows"),
2395  ])
2396}
2397
2398/// GROUP BY GROUPING SETS / CUBE / ROLLUP chain.
2399/// True when the cursor sits inside `GROUP BY GROUPING SETS ( ( <cursor>
2400/// ... ) )` -- the inner tuple is a column-list slot, not an expression
2401/// context. Same shape for nested ROLLUP / CUBE tuples within
2402/// GROUPING SETS. Phase machine misreads the double paren as a function
2403/// call argument list, so the completion engine has to detect this
2404/// explicitly to avoid dumping the full function library.
2405pub(crate) fn grouping_sets_inner_paren_expects_column(source: &str, offset: TextSize) -> bool {
2406  let (_, upper) = stmt_slice_upper(source, offset);
2407  if !upper.contains("GROUPING SETS") {
2408    return false;
2409  }
2410  // Find GROUPING SETS, then count open-parens after it. A 2+ open
2411  // depth from the cursor's perspective means we're inside the inner
2412  // tuple ( ( ... | ... ) ).
2413  let after = match upper.rfind("GROUPING SETS") {
2414    Some(p) => &upper[p + "GROUPING SETS".len()..],
2415    None => return false,
2416  };
2417  let mut depth = 0i32;
2418  for b in after.bytes() {
2419    match b {
2420      b'(' => depth += 1,
2421      b')' => depth -= 1,
2422      _ => {},
2423    }
2424  }
2425  depth >= 2
2426}
2427
2428/// `JSON_TABLE(... COLUMNS (<cursor>` at a fresh column-def slot
2429/// (right after the opening `(` or after a `,`, nothing typed yet).
2430/// There's no catalog entity to complete there -- the user is about
2431/// to type a brand-new column name -- so the generic phase's
2432/// catalog/table dump is wrong (it doesn't know this is a name
2433/// position, not an expression). Doesn't attempt to model the rest of
2434/// JSON_TABLE's column grammar (type / PATH / FORMAT / EXISTS /
2435/// NESTED); only suppresses the wrong suggestion and offers FOR (the
2436/// one non-name keyword that can start a column def, for
2437/// `<name> FOR ORDINALITY`).
2438pub(crate) fn json_table_fresh_column_slot(source: &str, offset: TextSize) -> bool {
2439  let (_, upper) = stmt_slice_upper(source, offset);
2440  if !upper.contains("JSON_TABLE") {
2441    return false;
2442  }
2443  let after = match upper.rfind("COLUMNS") {
2444    Some(p) => &upper[p + "COLUMNS".len()..],
2445    None => return false,
2446  };
2447  let mut depth = 0i32;
2448  for b in after.bytes() {
2449    match b {
2450      b'(' => depth += 1,
2451      b')' => depth -= 1,
2452      _ => {},
2453    }
2454  }
2455  // depth == 1: directly inside the column list, not nested deeper
2456  // (e.g. a NESTED COLUMNS sub-list) -- falling through to the
2457  // generic menu there is an acceptable miss rather than a wrong
2458  // guess.
2459  if depth != 1 {
2460    return false;
2461  }
2462  let trimmed = after.trim_end();
2463  trimmed.ends_with('(') || trimmed.ends_with(',')
2464}
2465
2466/// Curated data types offered at a JSON_TABLE column's type slot
2467/// (`<name> <cursor>`). Not exhaustive -- these are the types that
2468/// actually show up in JSON_TABLE column lists in practice; a fuller
2469/// list would just be noise. Multi-word types (`double precision`,
2470/// `character varying`) are intentionally omitted, same reasoning as
2471/// `json_table_column_slot_items`'s own doc comment.
2472const JSON_TABLE_COLUMN_TYPES: &[(&str, &str)] = &[
2473  ("text", "arbitrary text -- the most common JSON_TABLE column type"),
2474  ("int", "32-bit integer"),
2475  ("bigint", "64-bit integer"),
2476  ("numeric", "exact decimal"),
2477  ("boolean", "true / false"),
2478  ("timestamp", "date + time, no time zone"),
2479  ("timestamptz", "date + time, with time zone"),
2480  ("date", "date only"),
2481  ("uuid", "UUID"),
2482  ("jsonb", "nested JSON -- usually paired with FORMAT JSON"),
2483];
2484
2485/// JSON_TABLE column-def grammar completion beyond the fresh-slot
2486/// case (`json_table_fresh_column_slot` above, which fires when
2487/// nothing has been typed yet for this column). Handles the rest of
2488/// `column_name type [FORMAT JSON] [PATH ...] | column_name FOR
2489/// ORDINALITY | column_name type EXISTS [PATH ...]`:
2490///   - `<name> <cursor>` (1 word typed) -> data types + FOR
2491///   - `<name> FOR <cursor>` -> ORDINALITY
2492///   - `<name> <type> <cursor>` (2 words, 2nd isn't a grammar
2493///     keyword) -> PATH / FORMAT / EXISTS
2494///   - `... FORMAT <cursor>` -> JSON (the only valid value)
2495///   - `... EXISTS <cursor>` -> PATH (optional)
2496///
2497/// Doesn't attempt multi-word types (`double precision`, `character
2498/// varying`) -- past the 2-word mark this falls through to the
2499/// generic menu, an acceptable miss rather than a wrong guess, same
2500/// carve-out `json_table_fresh_column_slot` makes for nested COLUMNS
2501/// lists.
2502pub(crate) fn json_table_column_slot_items(source: &str, offset: TextSize) -> Option<Vec<Item>> {
2503  if cursor_not_at_ws_boundary(source, offset) {
2504    return None;
2505  }
2506  let words = json_table_current_column_entry_words(source, offset)?;
2507  let mut out = Vec::new();
2508  match words.len() {
2509    1 => {
2510      for (ty, doc) in JSON_TABLE_COLUMN_TYPES {
2511        out.push(Item {
2512          label: (*ty).into(),
2513          kind: crate::item::ItemKind::Type,
2514          detail: Some((*doc).into()),
2515          description: Some("JSON_TABLE column type".into()),
2516          documentation_md: None,
2517          insert_text: (*ty).into(),
2518          is_snippet: false,
2519          kb_entry: None,
2520          sort_priority: 1,
2521        });
2522      }
2523      push_keyword_kvs(&mut out, &[("FOR", "<name> FOR ORDINALITY -- 1-based row-number column")]);
2524    },
2525    2 if words[1] == "FOR" => {
2526      push_keyword_kvs(&mut out, &[("ORDINALITY", "FOR ORDINALITY -- 1-based row-number column")]);
2527    },
2528    2 if !matches!(
2529      words[1].as_str(),
2530      "FOR"
2531        | "PATH"
2532        | "FORMAT"
2533        | "EXISTS"
2534        | "WRAPPER"
2535        | "QUOTES"
2536        | "KEEP"
2537        | "OMIT"
2538        | "DEFAULT"
2539        | "NULL"
2540        | "ON"
2541        | "ERROR"
2542        | "NESTED"
2543    ) =>
2544    {
2545      push_keyword_kvs(
2546        &mut out,
2547        &[
2548          ("PATH", "PATH '<json-path>' -- explicit path into the JSON document"),
2549          ("FORMAT", "FORMAT JSON -- treat the column value as a nested JSON document"),
2550          ("EXISTS", "EXISTS [PATH ...] -- boolean: does the path match anything"),
2551        ],
2552      );
2553    },
2554    _ if words.last().map(String::as_str) == Some("FORMAT") => {
2555      push_keyword_kvs(&mut out, &[("JSON", "FORMAT JSON -- the only valid FORMAT value")]);
2556    },
2557    _ if words.last().map(String::as_str) == Some("EXISTS") => {
2558      push_keyword_kvs(&mut out, &[("PATH", "EXISTS PATH '<json-path>' -- optional, defaults to the column name")]);
2559    },
2560    _ => return None,
2561  }
2562  if out.is_empty() { None } else { Some(out) }
2563}
2564
2565/// Words (whitespace-split, uppercased) typed so far in the current
2566/// JSON_TABLE column-def entry -- from the last depth-1 comma or the
2567/// `COLUMNS (` itself, up to the cursor. `None` unless the cursor
2568/// sits directly inside a `COLUMNS (...)` list at depth 1 (same scope
2569/// `json_table_fresh_column_slot` checks -- see its own comment for
2570/// why depth 1, not nested `NESTED ... COLUMNS (...)` lists).
2571fn json_table_current_column_entry_words(source: &str, offset: TextSize) -> Option<Vec<String>> {
2572  let (_, upper) = stmt_slice_upper(source, offset);
2573  if !upper.contains("JSON_TABLE") {
2574    return None;
2575  }
2576  let columns_at = upper.rfind("COLUMNS")?;
2577  let after = &upper[columns_at + "COLUMNS".len()..];
2578  let mut depth = 0i32;
2579  let mut entry_start = 0usize;
2580  for (i, b) in after.bytes().enumerate() {
2581    match b {
2582      b'(' => depth += 1,
2583      b')' => depth -= 1,
2584      b',' if depth == 1 => entry_start = i + 1,
2585      _ => {},
2586    }
2587  }
2588  if depth != 1 {
2589    return None;
2590  }
2591  Some(after[entry_start..].split_whitespace().map(String::from).collect())
2592}
2593
2594pub(crate) fn group_by_set_op_next_keyword(
2595  source: &str,
2596  offset: TextSize,
2597) -> Option<&'static [(&'static str, &'static str)]> {
2598  if cursor_not_at_ws_boundary(source, offset) {
2599    return None;
2600  }
2601  let (_, upper) = stmt_slice_upper(source, offset);
2602  if !upper.contains("GROUP BY") {
2603    return None;
2604  }
2605  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
2606  let last = *words.last()?;
2607  if last == "BY" && words.contains(&"GROUP") {
2608    return Some(&[
2609      ("GROUPING SETS", "GROUPING SETS ((<a>), (<a>,<b>), ()) -- explicit sets"),
2610      ("CUBE", "CUBE (<a>, <b>) -- all subsets"),
2611      ("ROLLUP", "ROLLUP (<a>, <b>) -- nested hierarchy"),
2612    ]);
2613  }
2614  if last == "GROUPING" {
2615    return Some(&[("SETS", "GROUPING SETS ((<cols>), ...)")]);
2616  }
2617  None
2618}
2619
2620/// SELECT trailing FETCH/OFFSET chain.
2621///   ... FETCH {FIRST|NEXT} <n> {ROW|ROWS} {ONLY | WITH TIES}
2622///   ... OFFSET <n> {ROW|ROWS}
2623pub(crate) fn select_fetch_offset_next_keyword(
2624  source: &str,
2625  offset: TextSize,
2626) -> Option<&'static [(&'static str, &'static str)]> {
2627  if cursor_not_at_ws_boundary(source, offset) {
2628    return None;
2629  }
2630  let (_, upper) = stmt_slice_upper(source, offset);
2631  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
2632  let last = *words.last()?;
2633  // Only fire when statement begins with a query verb.
2634  let starts_query = upper.starts_with("SELECT")
2635    || upper.starts_with("WITH")
2636    || upper.starts_with("VALUES")
2637    || upper.starts_with("TABLE");
2638  if !starts_query {
2639    return None;
2640  }
2641  // FETCH <cursor> -> FIRST|NEXT
2642  if last == "FETCH" {
2643    return Some(&[
2644      ("FIRST", "FETCH FIRST <n> {ROW|ROWS} {ONLY | WITH TIES}"),
2645      ("NEXT", "FETCH NEXT <n> {ROW|ROWS} {ONLY | WITH TIES}"),
2646    ]);
2647  }
2648  if matches!(last, "FIRST" | "NEXT") {
2649    // After a count (we can't easily tell if a count was typed), emit ROW/ROWS as next-best.
2650    return Some(&[("ROW", "ROW {ONLY | WITH TIES}"), ("ROWS", "ROWS {ONLY | WITH TIES}")]);
2651  }
2652  if matches!(last, "ROW" | "ROWS") && words.contains(&"FETCH") {
2653    return Some(&[
2654      ("ONLY", "ONLY -- standard"),
2655      ("WITH TIES", "WITH TIES -- include rows that tie on ORDER BY (PG 13+)"),
2656    ]);
2657  }
2658  if matches!(last, "ROW" | "ROWS") && words.contains(&"OFFSET") {
2659    return Some(&[("FETCH", "FETCH {FIRST|NEXT} <n> {ROW|ROWS} {ONLY | WITH TIES}")]);
2660  }
2661  if last == "OFFSET" {
2662    return None; // user types the offset count
2663  }
2664  if last == "WITH" {
2665    return Some(&[("TIES", "WITH TIES -- include peers tied on ORDER BY")]);
2666  }
2667  None
2668}
2669
2670/// INSERT OVERRIDING chain.
2671///   INSERT INTO ... [OVERRIDING {SYSTEM|USER} VALUE] ...
2672pub(crate) fn insert_overriding_next_keyword(
2673  source: &str,
2674  offset: TextSize,
2675) -> Option<&'static [(&'static str, &'static str)]> {
2676  if cursor_not_at_ws_boundary(source, offset) {
2677    return None;
2678  }
2679  let (_, upper) = stmt_slice_upper(source, offset);
2680  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
2681  if !upper.starts_with("INSERT") {
2682    return None;
2683  }
2684  let last = *words.last()?;
2685  if last == "OVERRIDING" {
2686    return Some(&[
2687      ("SYSTEM VALUE", "OVERRIDING SYSTEM VALUE -- replace identity"),
2688      ("USER VALUE", "OVERRIDING USER VALUE -- accept user's value"),
2689    ]);
2690  }
2691  if (last == "SYSTEM" || last == "USER") && words.contains(&"OVERRIDING") {
2692    return Some(&[("VALUE", "VALUE -- close the OVERRIDING clause")]);
2693  }
2694  None
2695}
2696
2697/// ON CONFLICT chain.
2698///   ... ON CONFLICT [ <conflict_target> | ON CONSTRAINT <name> ] DO {NOTHING | UPDATE SET ... [WHERE ...]}
2699/// `WITH [RECURSIVE] <name> [(<col>, ...)] AS [MATERIALIZED|NOT MATERIALIZED] (<body>) <cursor>`
2700/// -- next legal token is the main query (SELECT/INSERT/UPDATE/DELETE/MERGE/VALUES)
2701/// or `,` to add another CTE.
2702pub(crate) fn with_cte_after_paren_close_next_keyword(
2703  source: &str,
2704  offset: TextSize,
2705) -> Option<&'static [(&'static str, &'static str)]> {
2706  if cursor_not_at_ws_boundary(source, offset) {
2707    return None;
2708  }
2709  let (slice_owned, upper) = stmt_slice_upper(source, offset);
2710  let slice = slice_owned.as_str();
2711  // Must be a WITH statement.
2712  if !upper.trim_start().starts_with("WITH ")
2713    && !upper.trim_start().starts_with("WITH\t")
2714    && !upper.trim_start().starts_with("WITH\n")
2715  {
2716    return None;
2717  }
2718  // Last non-whitespace char must be `)` and depth must be balanced.
2719  let trimmed = slice.trim_end();
2720  if !trimmed.ends_with(')') {
2721    return None;
2722  }
2723  let opens = upper.matches('(').count();
2724  let closes = upper.matches(')').count();
2725  if opens == 0 || opens != closes {
2726    return None;
2727  }
2728  // Suppress when a top-level main verb has already been typed.
2729  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
2730  if words.iter().any(|w| matches!(*w, "SELECT" | "INSERT" | "UPDATE" | "DELETE" | "MERGE" | "VALUES" | "TABLE")) {
2731    return None;
2732  }
2733  Some(&[
2734    ("SELECT", "SELECT <cols> FROM ... -- main query"),
2735    ("INSERT INTO", "INSERT INTO <tbl> ... -- main query"),
2736    ("UPDATE", "UPDATE <tbl> SET ... -- main query"),
2737    ("DELETE FROM", "DELETE FROM <tbl> ... -- main query"),
2738    ("MERGE INTO", "MERGE INTO <tbl> USING ... -- main query"),
2739    ("VALUES", "VALUES (<row>) -- inline-rows main query"),
2740    ("TABLE", "TABLE <name> -- shorthand for SELECT * FROM <name>"),
2741    (",", "<cte_name> AS (<body>) -- continue CTE list"),
2742  ])
2743}
2744
2745pub(crate) fn on_conflict_next_keyword(
2746  source: &str,
2747  offset: TextSize,
2748) -> Option<&'static [(&'static str, &'static str)]> {
2749  if cursor_not_at_ws_boundary(source, offset) {
2750    return None;
2751  }
2752  let (_, upper) = stmt_slice_upper(source, offset);
2753  if !upper.contains("ON CONFLICT") {
2754    return None;
2755  }
2756  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
2757  let last = *words.last()?;
2758  // `... ON CONFLICT <cursor>` -> target form options.
2759  if last == "CONFLICT" {
2760    return Some(&[
2761      ("ON CONSTRAINT", "ON CONFLICT ON CONSTRAINT <name>"),
2762      ("(", "ON CONFLICT (<col>[, ...]) -- expression target"),
2763      ("DO NOTHING", "ON CONFLICT DO NOTHING"),
2764      ("DO UPDATE", "ON CONFLICT DO UPDATE SET <col>=<val>[, ...]"),
2765    ]);
2766  }
2767  if last == "DO" {
2768    return Some(&[
2769      ("NOTHING", "DO NOTHING -- skip the conflicting row"),
2770      ("UPDATE", "DO UPDATE SET <col>=<val>[, ...]"),
2771    ]);
2772  }
2773  if last == "UPDATE" && words.contains(&"CONFLICT") {
2774    return Some(&[("SET", "SET <col> = <val>[, ...]")]);
2775  }
2776  None
2777}
2778
2779/// VACUUM ( <opt> <cursor> ) value slot -- when last word is an option
2780/// that takes a boolean / value, suggest the legal values.
2781pub(crate) fn vacuum_paren_value_keyword(
2782  source: &str,
2783  offset: TextSize,
2784) -> Option<&'static [(&'static str, &'static str)]> {
2785  if cursor_not_at_ws_boundary(source, offset) {
2786    return None;
2787  }
2788  let (slice_owned, upper) = stmt_slice_upper(source, offset);
2789  let slice = slice_owned.as_str();
2790  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
2791  if words.first() != Some(&"VACUUM") && words.first() != Some(&"ANALYZE") {
2792    return None;
2793  }
2794  // Cursor must sit inside the paren options list.
2795  let opens = slice.matches('(').count();
2796  let closes = slice.matches(')').count();
2797  if opens == 0 || opens <= closes {
2798    return None;
2799  }
2800  let last_raw = *words.last()?;
2801  let last = last_raw.trim_start_matches(['(', ',']);
2802  let boolean_opts = [
2803    "FULL",
2804    "FREEZE",
2805    "VERBOSE",
2806    "ANALYZE",
2807    "DISABLE_PAGE_SKIPPING",
2808    "SKIP_LOCKED",
2809    "TRUNCATE",
2810    "PROCESS_TOAST",
2811    "PROCESS_MAIN",
2812    "SKIP_DATABASE_STATS",
2813    "ONLY_DATABASE_STATS",
2814  ];
2815  if boolean_opts.contains(&last) {
2816    return Some(&[("true", "true -- enable"), ("false", "false -- disable")]);
2817  }
2818  if last == "INDEX_CLEANUP" {
2819    return Some(&[
2820      ("AUTO", "AUTO -- decide based on table state (default)"),
2821      ("ON", "ON -- always clean up indexes"),
2822      ("OFF", "OFF -- skip index cleanup"),
2823    ]);
2824  }
2825  // BUFFER_USAGE_LIMIT expects a size literal, not a boolean.
2826  // PARALLEL expects an integer, not a boolean.
2827  None
2828}
2829
2830/// PREPARE chain. `PREPARE <name> [(<arg_types>)] AS <statement>`.
2831pub(crate) fn prepare_next_keyword(source: &str, offset: TextSize) -> Option<&'static [(&'static str, &'static str)]> {
2832  if cursor_not_at_ws_boundary(source, offset) {
2833    return None;
2834  }
2835  let (slice_owned, upper) = stmt_slice_upper(source, offset);
2836  let slice = slice_owned.as_str();
2837  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
2838  if words.first() != Some(&"PREPARE") {
2839    return None;
2840  }
2841  let last = *words.last()?;
2842  if last == "AS" {
2843    return Some(&[
2844      ("SELECT", "AS SELECT ..."),
2845      ("INSERT", "AS INSERT INTO ..."),
2846      ("UPDATE", "AS UPDATE ..."),
2847      ("DELETE", "AS DELETE ..."),
2848      ("VALUES", "AS VALUES (...)"),
2849    ]);
2850  }
2851  // After the (args) paren or right after name -> AS slot.
2852  let opens = slice.matches('(').count();
2853  let closes = slice.matches(')').count();
2854  if words.len() >= 2 && opens == closes && !words.contains(&"AS") {
2855    return Some(&[("AS", "AS <statement>")]);
2856  }
2857  None
2858}
2859
2860/// DECLARE cursor phase chain (post-name).
2861///   DECLARE <name> [BINARY] [INSENSITIVE | ASENSITIVE] [[NO] SCROLL]
2862///                  CURSOR [{WITH | WITHOUT} HOLD] FOR <query>
2863pub(crate) fn declare_cursor_next_keyword(
2864  source: &str,
2865  offset: TextSize,
2866) -> Option<&'static [(&'static str, &'static str)]> {
2867  if cursor_not_at_ws_boundary(source, offset) {
2868    return None;
2869  }
2870  let (_, upper) = stmt_slice_upper(source, offset);
2871  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
2872  if words.first() != Some(&"DECLARE") {
2873    return None;
2874  }
2875  let last = *words.last()?;
2876  if last == "WITH" || last == "WITHOUT" {
2877    return Some(&[("HOLD", "{WITH|WITHOUT} HOLD -- keep cursor open across commits")]);
2878  }
2879  if last == "NO" {
2880    return Some(&[("SCROLL", "NO SCROLL -- forbid backward fetch")]);
2881  }
2882  if last == "CURSOR" {
2883    return Some(&[
2884      ("WITH HOLD", "WITH HOLD -- survive COMMIT"),
2885      ("WITHOUT HOLD", "WITHOUT HOLD -- default"),
2886      ("FOR", "FOR <query>"),
2887    ]);
2888  }
2889  if last == "DECLARE" {
2890    return None; // user types cursor name
2891  }
2892  // After name token -> modifiers.
2893  if words.len() == 2 {
2894    return Some(&[
2895      ("BINARY", "BINARY -- binary protocol"),
2896      ("INSENSITIVE", "INSENSITIVE -- materialise the result"),
2897      ("ASENSITIVE", "ASENSITIVE -- default"),
2898      ("SCROLL", "SCROLL -- allow PRIOR/BACKWARD fetch"),
2899      ("NO SCROLL", "NO SCROLL -- forbid backward fetch"),
2900      ("CURSOR", "CURSOR FOR <query>"),
2901    ]);
2902  }
2903  // After modifiers but before CURSOR -> chain more modifiers / CURSOR.
2904  if !words.contains(&"CURSOR") && words.len() >= 3 {
2905    return Some(&[
2906      ("BINARY", "BINARY"),
2907      ("INSENSITIVE", "INSENSITIVE"),
2908      ("ASENSITIVE", "ASENSITIVE"),
2909      ("SCROLL", "SCROLL"),
2910      ("NO SCROLL", "NO SCROLL"),
2911      ("CURSOR", "CURSOR [WITH HOLD] FOR <query>"),
2912    ]);
2913  }
2914  None
2915}
2916
2917/// TRUNCATE chain.
2918///   TRUNCATE [TABLE] [ONLY] <tbl>[, ...] [RESTART IDENTITY | CONTINUE IDENTITY] [CASCADE | RESTRICT]
2919pub(crate) fn truncate_next_keyword(source: &str, offset: TextSize) -> Option<&'static [(&'static str, &'static str)]> {
2920  if cursor_not_at_ws_boundary(source, offset) {
2921    return None;
2922  }
2923  let (_, upper) = stmt_slice_upper(source, offset);
2924  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
2925  if words.first() != Some(&"TRUNCATE") {
2926    return None;
2927  }
2928  let last = *words.last()?;
2929  if matches!(last, "RESTART" | "CONTINUE") {
2930    return Some(&[("IDENTITY", "IDENTITY -- act on sequence-backed columns")]);
2931  }
2932  if last == "IDENTITY" {
2933    return Some(&[
2934      ("CASCADE", "CASCADE -- also truncate dependent FK tables"),
2935      ("RESTRICT", "RESTRICT -- refuse if dependents exist (default)"),
2936    ]);
2937  }
2938  // After table list -> trailing-clause menu.
2939  if words.len() >= 2
2940    && !words.contains(&"CASCADE")
2941    && !words.contains(&"RESTRICT")
2942    && !words.contains(&"RESTART")
2943    && !words.contains(&"CONTINUE")
2944  {
2945    return Some(&[
2946      ("RESTART IDENTITY", "RESTART IDENTITY -- reset owned sequences"),
2947      ("CONTINUE IDENTITY", "CONTINUE IDENTITY -- keep current sequence values (default)"),
2948      ("CASCADE", "CASCADE -- also truncate FK-dependent tables"),
2949      ("RESTRICT", "RESTRICT -- refuse if dependents exist (default)"),
2950    ]);
2951  }
2952  None
2953}
2954
2955/// FETCH / MOVE cursor direction.
2956/// SET ROLE / SET SESSION AUTHORIZATION chain.
2957pub(crate) fn set_role_auth_next_keyword(
2958  source: &str,
2959  offset: TextSize,
2960) -> Option<&'static [(&'static str, &'static str)]> {
2961  if cursor_not_at_ws_boundary(source, offset) {
2962    return None;
2963  }
2964  let (_, upper) = stmt_slice_upper(source, offset);
2965  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
2966  if words.first() != Some(&"SET") {
2967    return None;
2968  }
2969  // `SET` alone -> common settable kinds.
2970  if words.len() == 1 {
2971    return None; // let other detectors / guc menu fire
2972  }
2973  // SET ROLE <cursor>
2974  if words == ["SET", "ROLE"] {
2975    return Some(&[("NONE", "SET ROLE NONE -- revert to login role")]);
2976  }
2977  // SET SESSION <cursor>
2978  if words == ["SET", "SESSION"] {
2979    return Some(&[
2980      ("AUTHORIZATION", "SET SESSION AUTHORIZATION <role>"),
2981      ("CHARACTERISTICS", "SET SESSION CHARACTERISTICS AS TRANSACTION ..."),
2982    ]);
2983  }
2984  if words == ["SET", "SESSION", "AUTHORIZATION"] {
2985    return Some(&[("DEFAULT", "SET SESSION AUTHORIZATION DEFAULT -- restore login role")]);
2986  }
2987  if words == ["SET", "SESSION", "CHARACTERISTICS"] {
2988    return Some(&[("AS TRANSACTION", "AS TRANSACTION ISOLATION LEVEL ...")]);
2989  }
2990  // `SET` <cursor> after target name -- after ROLE/AUTHORIZATION name typed.
2991  None
2992}
2993
2994/// GRANT / REVOKE follow-up keyword chain. After the privilege list,
2995/// suggest ON, then object class, then TO (GRANT) or FROM (REVOKE),
2996/// then WITH GRANT/ADMIN OPTION or CASCADE/RESTRICT.
2997pub(crate) fn grant_revoke_followup_next_keyword(
2998  source: &str,
2999  offset: TextSize,
3000) -> Option<&'static [(&'static str, &'static str)]> {
3001  if cursor_not_at_ws_boundary(source, offset) {
3002    return None;
3003  }
3004  let (_, upper) = stmt_slice_upper(source, offset);
3005  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
3006  let first = *words.first()?;
3007  if !matches!(first, "GRANT" | "REVOKE") {
3008    return None;
3009  }
3010  let last = *words.last()?;
3011  // ON <cursor> -- object class menu.
3012  if last == "ON" {
3013    return Some(&[
3014      ("TABLE", "ON TABLE <name>[, ...]"),
3015      ("SEQUENCE", "ON SEQUENCE <name>"),
3016      ("DATABASE", "ON DATABASE <name>"),
3017      ("DOMAIN", "ON DOMAIN <name>"),
3018      ("FOREIGN DATA WRAPPER", "ON FOREIGN DATA WRAPPER <name>"),
3019      ("FOREIGN SERVER", "ON FOREIGN SERVER <name>"),
3020      ("FUNCTION", "ON FUNCTION <name>(arg_types)"),
3021      ("PROCEDURE", "ON PROCEDURE <name>(arg_types)"),
3022      ("ROUTINE", "ON ROUTINE <name>(arg_types) -- fn or proc"),
3023      ("LANGUAGE", "ON LANGUAGE <name>"),
3024      ("LARGE OBJECT", "ON LARGE OBJECT <oid>"),
3025      ("PARAMETER", "ON PARAMETER <guc_name> -- PG15+"),
3026      ("SCHEMA", "ON SCHEMA <name>"),
3027      ("TABLESPACE", "ON TABLESPACE <name>"),
3028      ("TYPE", "ON TYPE <name>"),
3029      ("ALL TABLES IN SCHEMA", "ON ALL TABLES IN SCHEMA <s>"),
3030      ("ALL SEQUENCES IN SCHEMA", "ON ALL SEQUENCES IN SCHEMA <s>"),
3031      ("ALL FUNCTIONS IN SCHEMA", "ON ALL FUNCTIONS IN SCHEMA <s>"),
3032      ("ALL ROUTINES IN SCHEMA", "ON ALL ROUTINES IN SCHEMA <s>"),
3033      ("ALL PROCEDURES IN SCHEMA", "ON ALL PROCEDURES IN SCHEMA <s>"),
3034    ]);
3035  }
3036  // TO <cursor> | FROM <cursor> -- role name slot (no kw).
3037  if matches!(last, "TO" | "FROM") {
3038    return None;
3039  }
3040  // WITH <cursor> after a TO <role> in GRANT.
3041  if last == "WITH" {
3042    if first == "GRANT" {
3043      return Some(&[
3044        ("GRANT OPTION", "WITH GRANT OPTION -- recipient may grant onward"),
3045        ("ADMIN OPTION", "WITH ADMIN OPTION -- recipient may manage role membership"),
3046      ]);
3047    }
3048    if first == "REVOKE" {
3049      return Some(&[
3050        ("GRANT OPTION FOR", "REVOKE GRANT OPTION FOR -- drop forwarding right, keep priv"),
3051        ("ADMIN OPTION FOR", "REVOKE ADMIN OPTION FOR -- drop admin right, keep membership"),
3052      ]);
3053    }
3054  }
3055  // GRANTED <cursor> -- only on REVOKE.
3056  if last == "GRANTED" && first == "REVOKE" {
3057    return Some(&[("BY", "GRANTED BY <role> -- target the grant from <role>")]);
3058  }
3059  // After a name (typical heuristic: when TO/FROM not yet seen and ON
3060  // already), suggest the next link.
3061  let has_on = words.contains(&"ON");
3062  let has_to_or_from = words.contains(&"TO") || words.contains(&"FROM");
3063  if has_on && !has_to_or_from {
3064    if first == "GRANT" {
3065      return Some(&[("TO", "TO <role>[, ...]")]);
3066    }
3067    return Some(&[("FROM", "FROM <role>[, ...]")]);
3068  }
3069  if has_on && has_to_or_from && first == "GRANT" && !words.contains(&"WITH") {
3070    return Some(&[("WITH GRANT OPTION", "WITH GRANT OPTION -- recipient may grant onward")]);
3071  }
3072  if has_on && has_to_or_from && first == "REVOKE" {
3073    let mut tail: Vec<(&str, &str)> = Vec::new();
3074    if !words.contains(&"CASCADE") && !words.contains(&"RESTRICT") {
3075      tail.push(("CASCADE", "CASCADE -- also drop dependent grants"));
3076      tail.push(("RESTRICT", "RESTRICT -- refuse if dependent grants exist (default)"));
3077    }
3078    if !words.contains(&"GRANTED") {
3079      tail.push(("GRANTED BY", "GRANTED BY <role>"));
3080    }
3081    if !tail.is_empty() {
3082      // Static return; pick the common case.
3083      return Some(&[
3084        ("CASCADE", "CASCADE -- also drop dependent grants"),
3085        ("RESTRICT", "RESTRICT -- refuse if dependent grants exist (default)"),
3086        ("GRANTED BY", "GRANTED BY <role>"),
3087      ]);
3088    }
3089  }
3090  None
3091}
3092
3093pub(crate) fn fetch_move_direction_keyword(
3094  source: &str,
3095  offset: TextSize,
3096) -> Option<&'static [(&'static str, &'static str)]> {
3097  if cursor_not_at_ws_boundary(source, offset) {
3098    return None;
3099  }
3100  let (_, upper) = stmt_slice_upper(source, offset);
3101  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
3102  if !matches!(words.first(), Some(&"FETCH") | Some(&"MOVE")) {
3103    return None;
3104  }
3105  let last = *words.last()?;
3106  // First slot: direction keyword.
3107  if words.len() == 1 {
3108    return Some(&[
3109      ("NEXT", "NEXT -- one row forward"),
3110      ("PRIOR", "PRIOR -- one row backward"),
3111      ("FIRST", "FIRST -- absolute 1"),
3112      ("LAST", "LAST -- absolute last"),
3113      ("ABSOLUTE", "ABSOLUTE <n>"),
3114      ("RELATIVE", "RELATIVE <n>"),
3115      ("FORWARD", "FORWARD [<n> | ALL]"),
3116      ("BACKWARD", "BACKWARD [<n> | ALL]"),
3117      ("ALL", "ALL -- every remaining row"),
3118      ("FROM", "FROM <cursor>"),
3119      ("IN", "IN <cursor>"),
3120    ]);
3121  }
3122  // After FORWARD/BACKWARD/ABSOLUTE/RELATIVE -- optional count or ALL
3123  // -- then FROM | IN. After a direction kw with no count yet, also
3124  // suggest FROM/IN/ALL.
3125  if matches!(last, "FORWARD" | "BACKWARD") {
3126    return Some(&[("ALL", "ALL -- every remaining row"), ("FROM", "FROM <cursor>"), ("IN", "IN <cursor>")]);
3127  }
3128  if matches!(last, "NEXT" | "PRIOR" | "FIRST" | "LAST" | "ALL" | "ABSOLUTE" | "RELATIVE") {
3129    return Some(&[("FROM", "FROM <cursor>"), ("IN", "IN <cursor>")]);
3130  }
3131  // After FROM | IN -- user types cursor name; no kw.
3132  None
3133}
3134
3135/// LOCK TABLE chain.
3136///   LOCK [TABLE] [ONLY] <tbl>[, ...] [IN <mode> MODE] [NOWAIT]
3137pub(crate) fn lock_mode_next_keyword(
3138  source: &str,
3139  offset: TextSize,
3140) -> Option<&'static [(&'static str, &'static str)]> {
3141  if cursor_not_at_ws_boundary(source, offset) {
3142    return None;
3143  }
3144  let (_, upper) = stmt_slice_upper(source, offset);
3145  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
3146  if words.first() != Some(&"LOCK") {
3147    return None;
3148  }
3149  let last = *words.last()?;
3150  if last == "IN" {
3151    return Some(&[
3152      ("ACCESS SHARE", "ACCESS SHARE MODE -- weakest; readers"),
3153      ("ROW SHARE", "ROW SHARE MODE -- SELECT FOR SHARE/UPDATE"),
3154      ("ROW EXCLUSIVE", "ROW EXCLUSIVE MODE -- INSERT/UPDATE/DELETE"),
3155      ("SHARE UPDATE EXCLUSIVE", "SHARE UPDATE EXCLUSIVE MODE -- VACUUM/ANALYZE"),
3156      ("SHARE", "SHARE MODE -- read-only after"),
3157      ("SHARE ROW EXCLUSIVE", "SHARE ROW EXCLUSIVE MODE"),
3158      ("EXCLUSIVE", "EXCLUSIVE MODE -- only ACCESS SHARE coexists"),
3159      ("ACCESS EXCLUSIVE", "ACCESS EXCLUSIVE MODE -- strongest; sole holder"),
3160    ]);
3161  }
3162  // After a mode word (ACCESS / ROW / SHARE / EXCLUSIVE family) -> MODE.
3163  if matches!(last, "ACCESS" | "ROW" | "SHARE" | "EXCLUSIVE" | "UPDATE") {
3164    return Some(&[
3165      ("MODE", "MODE -- close the IN <mode> MODE clause"),
3166      ("SHARE", "SHARE -- ACCESS SHARE / ROW SHARE / SHARE / SHARE ROW EXCLUSIVE / SHARE UPDATE EXCLUSIVE"),
3167      ("EXCLUSIVE", "EXCLUSIVE -- ACCESS EXCLUSIVE / ROW EXCLUSIVE / SHARE ROW EXCLUSIVE / SHARE UPDATE EXCLUSIVE"),
3168    ]);
3169  }
3170  if last == "MODE" {
3171    return Some(&[("NOWAIT", "NOWAIT -- fail instead of waiting on contention")]);
3172  }
3173  // After LOCK <tbl>[, ...] -> IN/NOWAIT clarifier.
3174  if words.len() >= 2 && !words.contains(&"IN") && !words.contains(&"NOWAIT") {
3175    return Some(&[("IN", "IN <mode> MODE [NOWAIT]"), ("NOWAIT", "NOWAIT -- fail rather than wait")]);
3176  }
3177  None
3178}
3179
3180/// DEALLOCATE chain.
3181pub(crate) fn deallocate_next_keyword(
3182  source: &str,
3183  offset: TextSize,
3184) -> Option<&'static [(&'static str, &'static str)]> {
3185  if cursor_not_at_ws_boundary(source, offset) {
3186    return None;
3187  }
3188  let (_, upper) = stmt_slice_upper(source, offset);
3189  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
3190  if words.first() != Some(&"DEALLOCATE") {
3191    return None;
3192  }
3193  if words.len() == 1 {
3194    return Some(&[
3195      ("ALL", "DEALLOCATE ALL -- forget every prepared statement"),
3196      ("PREPARE", "DEALLOCATE PREPARE <name>"),
3197    ]);
3198  }
3199  None
3200}
3201
3202/// ALTER DEFAULT PRIVILEGES chain.
3203///   ALTER DEFAULT PRIVILEGES [FOR {ROLE|USER} <role>[, ...]]
3204///       [IN SCHEMA <schema>[, ...]]
3205///       {GRANT | REVOKE} ... ON {TABLES|SEQUENCES|FUNCTIONS|TYPES|SCHEMAS}
3206///       {TO | FROM} {<role>|PUBLIC} [WITH GRANT OPTION | CASCADE | RESTRICT]
3207/// CREATE TRANSFORM chain.
3208///   CREATE [OR REPLACE] TRANSFORM FOR <type> LANGUAGE <lang> (
3209///       FROM SQL WITH FUNCTION <fn>(...), TO SQL WITH FUNCTION <fn>(...) )
3210pub(crate) fn create_transform_next_keyword(
3211  source: &str,
3212  offset: TextSize,
3213) -> Option<&'static [(&'static str, &'static str)]> {
3214  if cursor_not_at_ws_boundary(source, offset) {
3215    return None;
3216  }
3217  let (slice_owned, upper) = stmt_slice_upper(source, offset);
3218  let slice = slice_owned.as_str();
3219  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
3220  let t_idx = words.iter().position(|w| *w == "TRANSFORM")?;
3221  if !words[..t_idx].iter().all(|w| matches!(*w, "CREATE" | "OR" | "REPLACE")) || words[0] != "CREATE" {
3222    return None;
3223  }
3224  let tail = &words[t_idx + 1..];
3225  let last = tail.last().copied();
3226  if last == Some("TYPE") || last == Some("LANGUAGE") {
3227    return None; // user types name
3228  }
3229  if last == Some("FOR") {
3230    return Some(&[("TYPE", "FOR TYPE <type>")]);
3231  }
3232  if last == Some("FROM") {
3233    return Some(&[("SQL", "FROM SQL WITH FUNCTION <fn>(<types>)")]);
3234  }
3235  if last == Some("TO") {
3236    return Some(&[("SQL", "TO SQL WITH FUNCTION <fn>(<types>)")]);
3237  }
3238  if last == Some("WITH") {
3239    return Some(&[("FUNCTION", "WITH FUNCTION <fn>(<types>)")]);
3240  }
3241  if tail.is_empty() {
3242    return Some(&[("FOR TYPE", "FOR TYPE <type> LANGUAGE <lang> (...)")]);
3243  }
3244  if tail.len() == 1 {
3245    return Some(&[
3246      ("FOR TYPE", "FOR TYPE <type> LANGUAGE <lang> (...)"),
3247      ("LANGUAGE", "LANGUAGE <plpgsql|plperl|...>"),
3248    ]);
3249  }
3250  if tail.contains(&"TYPE") && !tail.contains(&"LANGUAGE") {
3251    return Some(&[("LANGUAGE", "LANGUAGE <plpgsql|plperl|...>")]);
3252  }
3253  // Inside ( ... ) -- expect FROM SQL / TO SQL items.
3254  let opens = slice.matches('(').count();
3255  let closes = slice.matches(')').count();
3256  if opens > closes {
3257    let trimmed = slice.trim_end();
3258    let last_char = trimmed.chars().last();
3259    if matches!(last_char, Some('(') | Some(',')) || slice.ends_with(char::is_whitespace) {
3260      return Some(&[
3261        ("FROM SQL WITH FUNCTION", "FROM SQL WITH FUNCTION <fn>(<types>)"),
3262        ("TO SQL WITH FUNCTION", "TO SQL WITH FUNCTION <fn>(<types>)"),
3263      ]);
3264    }
3265  }
3266  // After LANGUAGE <name> -> need (.
3267  if tail.contains(&"LANGUAGE") && !tail.contains(&"(") && opens == closes {
3268    return Some(&[("(", "( FROM SQL WITH FUNCTION ..., TO SQL WITH FUNCTION ... )")]);
3269  }
3270  None
3271}
3272
3273/// CREATE OPERATOR FAMILY chain.
3274///   CREATE OPERATOR FAMILY <name> USING <index_method>
3275pub(crate) fn create_operator_family_next_keyword(
3276  source: &str,
3277  offset: TextSize,
3278) -> Option<&'static [(&'static str, &'static str)]> {
3279  if cursor_not_at_ws_boundary(source, offset) {
3280    return None;
3281  }
3282  let (_, upper) = stmt_slice_upper(source, offset);
3283  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
3284  if words.len() < 3 || words[0] != "CREATE" || words[1] != "OPERATOR" || words[2] != "FAMILY" {
3285    return None;
3286  }
3287  let last = *words.last()?;
3288  if last == "FAMILY" {
3289    return None; // user types name
3290  }
3291  if last == "USING" {
3292    return Some(&[
3293      ("btree", "btree"),
3294      ("hash", "hash"),
3295      ("gist", "gist"),
3296      ("spgist", "spgist"),
3297      ("gin", "gin"),
3298      ("brin", "brin"),
3299    ]);
3300  }
3301  if words.len() >= 4 && !words.contains(&"USING") {
3302    return Some(&[("USING", "USING <index_method>")]);
3303  }
3304  None
3305}
3306
3307/// CREATE OPERATOR CLASS chain.
3308///   CREATE OPERATOR CLASS <name> [DEFAULT] FOR TYPE <type>
3309///     USING <index_method> [FAMILY <family>] AS
3310///       { OPERATOR <strategy> <op> [(<types>)] [FOR ORDER BY <opfamily>]
3311///       | FUNCTION <support> [(<types>)] <fn>(<types>)
3312///       | STORAGE <storage_type> } [, ...]
3313pub(crate) fn create_operator_class_next_keyword(
3314  source: &str,
3315  offset: TextSize,
3316) -> Option<&'static [(&'static str, &'static str)]> {
3317  if cursor_not_at_ws_boundary(source, offset) {
3318    return None;
3319  }
3320  let (_, upper) = stmt_slice_upper(source, offset);
3321  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
3322  if words.len() < 3 || words[0] != "CREATE" || words[1] != "OPERATOR" || words[2] != "CLASS" {
3323    return None;
3324  }
3325  let last = *words.last()?;
3326  if last == "CLASS" {
3327    return None; // user types name
3328  }
3329  if last == "DEFAULT" {
3330    return Some(&[("FOR TYPE", "FOR TYPE <type>")]);
3331  }
3332  if last == "FOR" {
3333    return Some(&[("TYPE", "FOR TYPE <type>")]);
3334  }
3335  if last == "TYPE" {
3336    return None; // user types type name
3337  }
3338  if last == "USING" {
3339    return Some(&[
3340      ("btree", "btree"),
3341      ("hash", "hash"),
3342      ("gist", "gist"),
3343      ("spgist", "spgist"),
3344      ("gin", "gin"),
3345      ("brin", "brin"),
3346    ]);
3347  }
3348  if last == "FAMILY" {
3349    return None; // user types existing family name
3350  }
3351  if last == "AS" {
3352    return Some(&[
3353      ("OPERATOR", "OPERATOR <strategy_number> <op> [(<types>)] [FOR ORDER BY <opfamily>]"),
3354      ("FUNCTION", "FUNCTION <support_number> [(<types>)] <fn>(<types>)"),
3355      ("STORAGE", "STORAGE <storage_type>"),
3356    ]);
3357  }
3358  // After USING <am> -- next is FAMILY (optional) or AS.
3359  if words.contains(&"USING") && !words.contains(&"AS") {
3360    let am_idx = words.iter().rposition(|w| *w == "USING")?;
3361    if words.len() == am_idx + 2 && !matches!(last, "USING") {
3362      return Some(&[("FAMILY", "FAMILY <existing_family>"), ("AS", "AS OPERATOR ... | FUNCTION ... | STORAGE ...")]);
3363    }
3364    if words.contains(&"FAMILY") && words.len() >= am_idx + 4 {
3365      return Some(&[("AS", "AS OPERATOR ... | FUNCTION ... | STORAGE ...")]);
3366    }
3367  }
3368  // Inside AS body -- after a `,` -> repeat item kw.
3369  if words.contains(&"AS") && last == "," {
3370    return Some(&[
3371      ("OPERATOR", "OPERATOR <strategy_number> <op>(<types>)"),
3372      ("FUNCTION", "FUNCTION <support_number> <fn>(<types>)"),
3373      ("STORAGE", "STORAGE <storage_type>"),
3374    ]);
3375  }
3376  // Top-level after `<name>` -- need FOR TYPE / DEFAULT.
3377  if words.len() >= 4 && !words.contains(&"FOR") {
3378    return Some(&[("DEFAULT", "DEFAULT -- mark as default opclass"), ("FOR TYPE", "FOR TYPE <type>")]);
3379  }
3380  None
3381}
3382
3383pub(crate) fn alter_default_privileges_next_keyword(
3384  source: &str,
3385  offset: TextSize,
3386) -> Option<&'static [(&'static str, &'static str)]> {
3387  if cursor_not_at_ws_boundary(source, offset) {
3388    return None;
3389  }
3390  let (_, upper) = stmt_slice_upper(source, offset);
3391  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
3392  if words.len() < 3 || words[0] != "ALTER" || words[1] != "DEFAULT" || words[2] != "PRIVILEGES" {
3393    return None;
3394  }
3395  let last = *words.last()?;
3396  if last == "PRIVILEGES" {
3397    return Some(&[
3398      ("FOR ROLE", "FOR ROLE <r>[, ...]"),
3399      ("FOR USER", "FOR USER <r>[, ...]"),
3400      ("IN SCHEMA", "IN SCHEMA <s>[, ...]"),
3401      ("GRANT", "GRANT <privs> ON {TABLES|SEQUENCES|FUNCTIONS|TYPES|SCHEMAS} TO ..."),
3402      ("REVOKE", "REVOKE <privs> ON ... FROM ..."),
3403    ]);
3404  }
3405  if last == "FOR" {
3406    return Some(&[("ROLE", "FOR ROLE <r>[, ...]"), ("USER", "FOR USER <r>[, ...]")]);
3407  }
3408  if last == "IN" {
3409    return Some(&[("SCHEMA", "IN SCHEMA <s>[, ...]")]);
3410  }
3411  if last == "ON" {
3412    return Some(&[
3413      ("TABLES", "ON TABLES"),
3414      ("SEQUENCES", "ON SEQUENCES"),
3415      ("FUNCTIONS", "ON FUNCTIONS"),
3416      ("ROUTINES", "ON ROUTINES"),
3417      ("TYPES", "ON TYPES"),
3418      ("SCHEMAS", "ON SCHEMAS"),
3419    ]);
3420  }
3421  if matches!(last, "TABLES" | "SEQUENCES" | "FUNCTIONS" | "ROUTINES" | "TYPES" | "SCHEMAS") {
3422    if words.contains(&"GRANT") {
3423      return Some(&[("TO", "TO <role>[, ...] | PUBLIC")]);
3424    }
3425    if words.contains(&"REVOKE") {
3426      return Some(&[("FROM", "FROM <role>[, ...] | PUBLIC")]);
3427    }
3428  }
3429  None
3430}
3431
3432/// ALTER EXTENSION chain.
3433///   ALTER EXTENSION <name> { UPDATE [TO <version>] |
3434///                            SET SCHEMA <schema> |
3435///                            ADD <member_kind> <name> |
3436///                            DROP <member_kind> <name> }
3437pub(crate) fn alter_extension_next_keyword(
3438  source: &str,
3439  offset: TextSize,
3440) -> Option<&'static [(&'static str, &'static str)]> {
3441  if cursor_not_at_ws_boundary(source, offset) {
3442    return None;
3443  }
3444  let (_, upper) = stmt_slice_upper(source, offset);
3445  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
3446  if words.len() < 2 || words[0] != "ALTER" || words[1] != "EXTENSION" {
3447    return None;
3448  }
3449  let last = *words.last()?;
3450  if last == "UPDATE" {
3451    return Some(&[("TO", "UPDATE TO '<version>'")]);
3452  }
3453  if last == "SET" {
3454    return Some(&[("SCHEMA", "SET SCHEMA <schema>")]);
3455  }
3456  if last == "ADD" || last == "DROP" {
3457    return Some(&[
3458      ("TABLE", "ADD/DROP TABLE <name>"),
3459      ("VIEW", "ADD/DROP VIEW <name>"),
3460      ("SEQUENCE", "ADD/DROP SEQUENCE <name>"),
3461      ("FUNCTION", "ADD/DROP FUNCTION <name>(args)"),
3462      ("PROCEDURE", "ADD/DROP PROCEDURE <name>(args)"),
3463      ("TYPE", "ADD/DROP TYPE <name>"),
3464      ("AGGREGATE", "ADD/DROP AGGREGATE <name>(args)"),
3465      ("OPERATOR", "ADD/DROP OPERATOR <op>(args)"),
3466      ("CAST", "ADD/DROP CAST (src AS dst)"),
3467      ("SCHEMA", "ADD/DROP SCHEMA <name>"),
3468      ("MATERIALIZED VIEW", "ADD/DROP MATERIALIZED VIEW <name>"),
3469      ("FOREIGN TABLE", "ADD/DROP FOREIGN TABLE <name>"),
3470      ("FOREIGN DATA WRAPPER", "ADD/DROP FOREIGN DATA WRAPPER <name>"),
3471      ("SERVER", "ADD/DROP SERVER <name>"),
3472      ("TEXT SEARCH CONFIGURATION", "ADD/DROP TEXT SEARCH CONFIGURATION <name>"),
3473      ("TEXT SEARCH DICTIONARY", "ADD/DROP TEXT SEARCH DICTIONARY <name>"),
3474      ("TEXT SEARCH PARSER", "ADD/DROP TEXT SEARCH PARSER <name>"),
3475      ("TEXT SEARCH TEMPLATE", "ADD/DROP TEXT SEARCH TEMPLATE <name>"),
3476    ]);
3477  }
3478  if words.len() >= 3 {
3479    return Some(&[
3480      ("UPDATE", "UPDATE [TO '<version>']"),
3481      ("UPDATE TO", "UPDATE TO '<version>'"),
3482      ("SET SCHEMA", "SET SCHEMA <schema>"),
3483      ("ADD", "ADD <kind> <name>"),
3484      ("DROP", "DROP <kind> <name>"),
3485    ]);
3486  }
3487  None
3488}
3489
3490/// ALTER SEQUENCE chain.
3491/// ALTER INDEX chain.
3492///   ALTER INDEX [IF EXISTS] <name>
3493///       RENAME TO <new>
3494///     | SET TABLESPACE <ts>
3495///     | SET ( <param> = <val>[, ...] )
3496///     | RESET ( <param>[, ...] )
3497///     | ATTACH PARTITION <child_idx>
3498///     | DEPENDS ON EXTENSION <ext>
3499///     | NO DEPENDS ON EXTENSION <ext>
3500///     | ALTER COLUMN <col_num> SET STATISTICS <n>
3501///   ALTER INDEX ALL IN TABLESPACE <ts> [OWNED BY <role>[, ...]] SET TABLESPACE <new_ts> [NOWAIT]
3502pub(crate) fn alter_index_next_keyword(
3503  source: &str,
3504  offset: TextSize,
3505) -> Option<&'static [(&'static str, &'static str)]> {
3506  let pos: usize = (u32::from(offset) as usize).min(source.len());
3507  let bytes = source.as_bytes();
3508  // Allow cursor right after `(` for the storage-param menu below.
3509  let at_paren = pos > 0 && bytes[pos - 1] == b'(';
3510  if !at_paren && cursor_not_at_ws_boundary(source, offset) {
3511    return None;
3512  }
3513  let (slice_owned, upper) = stmt_slice_upper(source, offset);
3514  let slice = slice_owned.as_str();
3515  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
3516  if words.len() < 2 || words[0] != "ALTER" || words[1] != "INDEX" {
3517    return None;
3518  }
3519  // SET ( <param>[, ...] ) -- storage param name slot inside paren.
3520  let opens = slice.matches('(').count();
3521  let closes = slice.matches(')').count();
3522  if opens > closes && upper.contains(" SET (") {
3523    let trimmed = slice.trim_end();
3524    let last_char = trimmed.chars().last();
3525    if matches!(last_char, Some('(') | Some(',')) || slice.ends_with(char::is_whitespace) {
3526      return Some(&[
3527        ("fillfactor", "fillfactor = <int> -- index page fillfactor (10..100)"),
3528        ("deduplicate_items", "deduplicate_items = on|off -- btree dedup (PG13+)"),
3529        ("buffering", "buffering = on|off|auto -- gist build buffering"),
3530        ("fastupdate", "fastupdate = on|off -- gin pending-list updates"),
3531        ("gin_pending_list_limit", "gin_pending_list_limit = '<size>' -- pending-list size"),
3532        ("pages_per_range", "pages_per_range = <int> -- brin granularity"),
3533        ("autosummarize", "autosummarize = on|off -- brin auto summarize"),
3534      ]);
3535    }
3536  }
3537  let last = *words.last()?;
3538  if matches!(last, "RENAME" | "SET" | "RESET" | "ATTACH" | "DEPENDS" | "ALTER" | "NO" | "ALL" | "IN" | "OWNED") {
3539    let menu: &[(&str, &str)] = match last {
3540      "RENAME" => &[("TO", "RENAME TO <new>")],
3541      "SET" => &[("TABLESPACE", "SET TABLESPACE <ts>"), ("(", "SET ( <param> = <val>[, ...] )")],
3542      "RESET" => &[("(", "RESET ( <param>[, ...] )")],
3543      "ATTACH" => &[("PARTITION", "ATTACH PARTITION <child_idx>")],
3544      "DEPENDS" => &[("ON EXTENSION", "DEPENDS ON EXTENSION <ext>")],
3545      "NO" => &[("DEPENDS ON EXTENSION", "NO DEPENDS ON EXTENSION <ext>")],
3546      "ALTER" => &[("COLUMN", "ALTER COLUMN <col_num> SET STATISTICS <n>")],
3547      "ALL" => &[("IN TABLESPACE", "ALL IN TABLESPACE <ts>")],
3548      "IN" => &[("TABLESPACE", "IN TABLESPACE <ts>")],
3549      "OWNED" => &[("BY", "OWNED BY <role>[, ...]")],
3550      _ => &[],
3551    };
3552    if !menu.is_empty() {
3553      return Some(menu);
3554    }
3555  }
3556  if words.len() >= 3 {
3557    return Some(&[
3558      ("RENAME TO", "RENAME TO <new>"),
3559      ("SET TABLESPACE", "SET TABLESPACE <ts>"),
3560      ("SET", "SET ( <param> = <val>[, ...] )"),
3561      ("RESET", "RESET ( <param>[, ...] )"),
3562      ("ATTACH PARTITION", "ATTACH PARTITION <child_idx>"),
3563      ("DEPENDS ON EXTENSION", "DEPENDS ON EXTENSION <ext>"),
3564      ("NO DEPENDS ON EXTENSION", "NO DEPENDS ON EXTENSION <ext>"),
3565      ("ALTER COLUMN", "ALTER COLUMN <col_num> SET STATISTICS <n>"),
3566    ]);
3567  }
3568  None
3569}
3570
3571pub(crate) fn alter_sequence_next_keyword(
3572  source: &str,
3573  offset: TextSize,
3574) -> Option<&'static [(&'static str, &'static str)]> {
3575  if cursor_not_at_ws_boundary(source, offset) {
3576    return None;
3577  }
3578  let (_, upper) = stmt_slice_upper(source, offset);
3579  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
3580  if words.len() < 2 || words[0] != "ALTER" || words[1] != "SEQUENCE" {
3581    return None;
3582  }
3583  let last = *words.last()?;
3584  if matches!(last, "RESTART" | "INCREMENT" | "START" | "MINVALUE" | "MAXVALUE" | "CACHE") {
3585    let menu: &[(&str, &str)] = match last {
3586      "RESTART" => &[("WITH", "RESTART WITH <n>")],
3587      "INCREMENT" => &[("BY", "INCREMENT BY <n>")],
3588      "START" => &[("WITH", "START WITH <n>")],
3589      _ => &[],
3590    };
3591    if !menu.is_empty() {
3592      return Some(menu);
3593    }
3594    return None; // user types value
3595  }
3596  if last == "NO" {
3597    return Some(&[("MINVALUE", "NO MINVALUE"), ("MAXVALUE", "NO MAXVALUE"), ("CYCLE", "NO CYCLE")]);
3598  }
3599  if last == "OWNED" {
3600    return Some(&[("BY", "OWNED BY <table>.<col> | NONE")]);
3601  }
3602  if last == "OWNER" {
3603    return Some(&[("TO", "OWNER TO <role>")]);
3604  }
3605  if last == "SET" {
3606    return Some(&[("SCHEMA", "SET SCHEMA <schema>"), ("LOGGED", "SET LOGGED"), ("UNLOGGED", "SET UNLOGGED")]);
3607  }
3608  if last == "AS" {
3609    return Some(&[("smallint", "AS smallint"), ("integer", "AS integer"), ("bigint", "AS bigint")]);
3610  }
3611  if words.len() >= 3 {
3612    return Some(&[
3613      ("AS", "AS smallint | integer | bigint"),
3614      ("INCREMENT BY", "INCREMENT BY <n>"),
3615      ("MINVALUE", "MINVALUE <n>"),
3616      ("NO MINVALUE", "NO MINVALUE"),
3617      ("MAXVALUE", "MAXVALUE <n>"),
3618      ("NO MAXVALUE", "NO MAXVALUE"),
3619      ("START WITH", "START WITH <n>"),
3620      ("RESTART", "RESTART [WITH <n>]"),
3621      ("CACHE", "CACHE <n>"),
3622      ("CYCLE", "CYCLE"),
3623      ("NO CYCLE", "NO CYCLE"),
3624      ("OWNED BY", "OWNED BY <tbl>.<col> | NONE"),
3625      ("OWNER TO", "OWNER TO <role>"),
3626      ("RENAME TO", "RENAME TO <new_name>"),
3627      ("SET SCHEMA", "SET SCHEMA <schema>"),
3628    ]);
3629  }
3630  None
3631}
3632
3633/// ALTER POLICY chain.
3634///   ALTER POLICY <name> ON <table> [RENAME TO <new>]
3635///       [TO {role|PUBLIC|CURRENT_USER}[, ...]]
3636///       [USING (<expr>)] [WITH CHECK (<expr>)]
3637/// ALTER TEXT SEARCH {CONFIGURATION|DICTIONARY|PARSER|TEMPLATE} chain.
3638pub(crate) fn alter_text_search_next_keyword(
3639  source: &str,
3640  offset: TextSize,
3641) -> Option<&'static [(&'static str, &'static str)]> {
3642  if cursor_not_at_ws_boundary(source, offset) {
3643    return None;
3644  }
3645  let (_, upper) = stmt_slice_upper(source, offset);
3646  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
3647  if words.len() < 3 || words[0] != "ALTER" || words[1] != "TEXT" || words[2] != "SEARCH" {
3648    return None;
3649  }
3650  if words.len() < 4 {
3651    return Some(&[
3652      ("CONFIGURATION", "CONFIGURATION <name> ..."),
3653      ("DICTIONARY", "DICTIONARY <name> ..."),
3654      ("PARSER", "PARSER <name> ..."),
3655      ("TEMPLATE", "TEMPLATE <name> ..."),
3656    ]);
3657  }
3658  let kind = words[3];
3659  let last = *words.last()?;
3660  // After kind keyword -> name slot.
3661  if words.len() == 4 {
3662    return None; // user types name
3663  }
3664  if matches!(last, "RENAME" | "OWNER" | "SET" | "ADD" | "ALTER" | "DROP" | "MAPPING") {
3665    let menu: &[(&str, &str)] = match (kind, last) {
3666      (_, "RENAME") => &[("TO", "RENAME TO <new_name>")],
3667      (_, "OWNER") => &[("TO", "OWNER TO <role>")],
3668      (_, "SET") => &[("SCHEMA", "SET SCHEMA <schema>")],
3669      ("CONFIGURATION", "ADD") => &[("MAPPING FOR", "ADD MAPPING FOR <token_type>[, ...] WITH <dictionary>[, ...]")],
3670      ("CONFIGURATION", "ALTER") => &[
3671        ("MAPPING FOR", "ALTER MAPPING FOR <token_type> WITH <dictionary>"),
3672        ("MAPPING REPLACE", "ALTER MAPPING REPLACE <old_dict> WITH <new_dict>"),
3673      ],
3674      ("CONFIGURATION", "DROP") => &[("MAPPING FOR", "DROP MAPPING [IF EXISTS] FOR <token_type>[, ...]")],
3675      ("CONFIGURATION", "MAPPING") => {
3676        &[("FOR", "MAPPING FOR <token_type>[, ...]"), ("REPLACE", "MAPPING REPLACE <old_dict> WITH <new_dict>")]
3677      },
3678      _ => &[],
3679    };
3680    if !menu.is_empty() {
3681      return Some(menu);
3682    }
3683  }
3684  // After ALTER TEXT SEARCH <kind> <name> -> action menu.
3685  if words.len() >= 5 && !matches!(last, "TO" | "FOR" | "WITH" | "MAPPING" | "REPLACE") {
3686    let menu: &[(&str, &str)] = match kind {
3687      "CONFIGURATION" => &[
3688        ("ADD MAPPING FOR", "ADD MAPPING FOR <token_type> WITH <dict>"),
3689        ("ALTER MAPPING FOR", "ALTER MAPPING FOR <token_type> WITH <dict>"),
3690        ("ALTER MAPPING REPLACE", "ALTER MAPPING REPLACE <old_dict> WITH <new_dict>"),
3691        ("DROP MAPPING FOR", "DROP MAPPING [IF EXISTS] FOR <token_type>"),
3692        ("RENAME TO", "RENAME TO <new>"),
3693        ("OWNER TO", "OWNER TO <role>"),
3694        ("SET SCHEMA", "SET SCHEMA <schema>"),
3695      ],
3696      _ => &[("RENAME TO", "RENAME TO <new>"), ("OWNER TO", "OWNER TO <role>"), ("SET SCHEMA", "SET SCHEMA <schema>")],
3697    };
3698    return Some(menu);
3699  }
3700  None
3701}
3702
3703pub(crate) fn alter_policy_next_keyword(
3704  source: &str,
3705  offset: TextSize,
3706) -> Option<&'static [(&'static str, &'static str)]> {
3707  if cursor_not_at_ws_boundary(source, offset) {
3708    return None;
3709  }
3710  let (_, upper) = stmt_slice_upper(source, offset);
3711  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
3712  if words.len() < 2 || words[0] != "ALTER" || words[1] != "POLICY" {
3713    return None;
3714  }
3715  let last = *words.last()?;
3716  if last == "RENAME" {
3717    return Some(&[("TO", "RENAME TO <new_name>")]);
3718  }
3719  if last == "WITH" {
3720    return Some(&[("CHECK", "WITH CHECK (<predicate>) -- INSERT/UPDATE check")]);
3721  }
3722  if last == "TO" && !words.contains(&"RENAME") {
3723    return Some(&[
3724      ("PUBLIC", "TO PUBLIC -- everyone"),
3725      ("CURRENT_USER", "TO CURRENT_USER"),
3726      ("SESSION_USER", "TO SESSION_USER"),
3727    ]);
3728  }
3729  // After ON <tbl> -> action menu.
3730  if words.contains(&"ON") && words.len() >= 5 {
3731    return Some(&[
3732      ("RENAME TO", "RENAME TO <new>"),
3733      ("TO", "TO <role>[, ...] | PUBLIC"),
3734      ("USING", "USING (<predicate>) -- visibility filter"),
3735      ("WITH CHECK", "WITH CHECK (<predicate>) -- write check"),
3736    ]);
3737  }
3738  if words.len() == 3 {
3739    return Some(&[("ON", "ON <table>")]);
3740  }
3741  None
3742}
3743
3744/// ALTER DOMAIN chain.
3745///   ALTER DOMAIN <name> { SET DEFAULT <expr> | DROP DEFAULT |
3746///                         {SET|DROP} NOT NULL |
3747///                         ADD <constraint> | DROP CONSTRAINT <name> |
3748///                         RENAME [CONSTRAINT <old> TO <new> | TO <new_name>] |
3749///                         OWNER TO <role> | SET SCHEMA <schema> |
3750///                         VALIDATE CONSTRAINT <name> }
3751pub(crate) fn alter_domain_next_keyword(
3752  source: &str,
3753  offset: TextSize,
3754) -> Option<&'static [(&'static str, &'static str)]> {
3755  if cursor_not_at_ws_boundary(source, offset) {
3756    return None;
3757  }
3758  let (_, upper) = stmt_slice_upper(source, offset);
3759  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
3760  if words.len() < 2 || words[0] != "ALTER" || words[1] != "DOMAIN" {
3761    return None;
3762  }
3763  let last = *words.last()?;
3764  if last == "SET" {
3765    return Some(&[("DEFAULT", "SET DEFAULT <expr>"), ("NOT NULL", "SET NOT NULL"), ("SCHEMA", "SET SCHEMA <schema>")]);
3766  }
3767  if last == "DROP" {
3768    return Some(&[
3769      ("DEFAULT", "DROP DEFAULT"),
3770      ("NOT NULL", "DROP NOT NULL"),
3771      ("CONSTRAINT", "DROP CONSTRAINT [IF EXISTS] <name>"),
3772    ]);
3773  }
3774  if last == "RENAME" {
3775    return Some(&[("CONSTRAINT", "RENAME CONSTRAINT <old> TO <new>"), ("TO", "RENAME TO <new_name>")]);
3776  }
3777  if last == "OWNER" {
3778    return Some(&[("TO", "OWNER TO <role>")]);
3779  }
3780  if last == "VALIDATE" {
3781    return Some(&[("CONSTRAINT", "VALIDATE CONSTRAINT <name>")]);
3782  }
3783  if last == "ADD" {
3784    return Some(&[("CONSTRAINT", "ADD CONSTRAINT <name> CHECK (...)"), ("CHECK", "ADD CHECK (VALUE > 0)")]);
3785  }
3786  // After ALTER DOMAIN <name> -> action menu.
3787  if words.len() >= 3 {
3788    return Some(&[
3789      ("SET DEFAULT", "SET DEFAULT <expr>"),
3790      ("DROP DEFAULT", "DROP DEFAULT"),
3791      ("SET NOT NULL", "SET NOT NULL"),
3792      ("DROP NOT NULL", "DROP NOT NULL"),
3793      ("ADD CONSTRAINT", "ADD CONSTRAINT <name> CHECK (...)"),
3794      ("DROP CONSTRAINT", "DROP CONSTRAINT [IF EXISTS] <name>"),
3795      ("RENAME CONSTRAINT", "RENAME CONSTRAINT <old> TO <new>"),
3796      ("RENAME TO", "RENAME TO <new_name>"),
3797      ("OWNER TO", "OWNER TO <role>"),
3798      ("SET SCHEMA", "SET SCHEMA <schema>"),
3799      ("VALIDATE CONSTRAINT", "VALIDATE CONSTRAINT <name>"),
3800    ]);
3801  }
3802  None
3803}
3804
3805/// ALTER COLLATION chain.
3806/// ALTER MATERIALIZED VIEW chain.
3807///   ALTER MATERIALIZED VIEW [IF EXISTS] <name>
3808///       RENAME TO <new>
3809///     | RENAME COLUMN <old> TO <new>
3810///     | OWNER TO <role>
3811///     | SET SCHEMA <schema>
3812///     | SET TABLESPACE <ts> [NOWAIT]
3813///     | SET ACCESS METHOD <am>
3814///     | SET ( <param> = <val>[, ...] )
3815///     | RESET ( <param>[, ...] )
3816///     | ALTER COLUMN <col> SET STATISTICS <n>
3817///     | ALTER COLUMN <col> SET STORAGE { PLAIN | EXTERNAL | EXTENDED | MAIN }
3818///     | DEPENDS ON EXTENSION <ext>
3819///     | CLUSTER ON <index> | SET WITHOUT CLUSTER
3820pub(crate) fn alter_materialized_view_next_keyword(
3821  source: &str,
3822  offset: TextSize,
3823) -> Option<&'static [(&'static str, &'static str)]> {
3824  if cursor_not_at_ws_boundary(source, offset) {
3825    return None;
3826  }
3827  let (_, upper) = stmt_slice_upper(source, offset);
3828  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
3829  if words.len() < 3 || words[0] != "ALTER" || words[1] != "MATERIALIZED" || words[2] != "VIEW" {
3830    return None;
3831  }
3832  let last = *words.last()?;
3833  if matches!(last, "RENAME" | "OWNER" | "SET" | "RESET" | "CLUSTER" | "DEPENDS" | "ALTER") {
3834    let menu: &[(&str, &str)] = match last {
3835      "RENAME" => &[("TO", "RENAME TO <new>"), ("COLUMN", "RENAME COLUMN <old> TO <new>")],
3836      "OWNER" => &[("TO", "OWNER TO <role>")],
3837      "SET" => &[
3838        ("SCHEMA", "SET SCHEMA <schema>"),
3839        ("TABLESPACE", "SET TABLESPACE <ts> [NOWAIT]"),
3840        ("ACCESS METHOD", "SET ACCESS METHOD <am>"),
3841        ("(", "SET ( <param> = <value>[, ...] )"),
3842        ("WITHOUT CLUSTER", "SET WITHOUT CLUSTER"),
3843      ],
3844      "RESET" => &[("(", "RESET ( <param>[, ...] )")],
3845      "CLUSTER" => &[("ON", "CLUSTER ON <index_name>")],
3846      "DEPENDS" => &[("ON EXTENSION", "DEPENDS ON EXTENSION <ext>")],
3847      "ALTER" => &[
3848        ("COLUMN", "ALTER COLUMN <col> SET ..."),
3849        ("MATERIALIZED VIEW", "ALTER MATERIALIZED VIEW <name> ALL IN TABLESPACE ..."),
3850      ],
3851      _ => &[],
3852    };
3853    if !menu.is_empty() {
3854      return Some(menu);
3855    }
3856  }
3857  if words.len() >= 4 {
3858    return Some(&[
3859      ("RENAME TO", "RENAME TO <new>"),
3860      ("RENAME COLUMN", "RENAME COLUMN <old> TO <new>"),
3861      ("OWNER TO", "OWNER TO <role>"),
3862      ("SET SCHEMA", "SET SCHEMA <schema>"),
3863      ("SET TABLESPACE", "SET TABLESPACE <ts> [NOWAIT]"),
3864      ("SET ACCESS METHOD", "SET ACCESS METHOD <am>"),
3865      ("SET", "SET ( <param> = <val>[, ...] ) | SET WITHOUT CLUSTER"),
3866      ("RESET", "RESET ( <param>[, ...] )"),
3867      ("ALTER COLUMN", "ALTER COLUMN <col> SET STATISTICS|STORAGE|..."),
3868      ("CLUSTER ON", "CLUSTER ON <index_name>"),
3869      ("DEPENDS ON EXTENSION", "DEPENDS ON EXTENSION <ext>"),
3870    ]);
3871  }
3872  None
3873}
3874
3875/// ALTER EVENT TRIGGER chain.
3876///   ALTER EVENT TRIGGER <name>
3877///       { ENABLE [REPLICA | ALWAYS] | DISABLE
3878///       | RENAME TO <new>
3879///       | OWNER TO <role>
3880///       | DEPENDS ON EXTENSION <ext>
3881///       | NO DEPENDS ON EXTENSION <ext> }
3882pub(crate) fn alter_event_trigger_next_keyword(
3883  source: &str,
3884  offset: TextSize,
3885) -> Option<&'static [(&'static str, &'static str)]> {
3886  if cursor_not_at_ws_boundary(source, offset) {
3887    return None;
3888  }
3889  let (_, upper) = stmt_slice_upper(source, offset);
3890  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
3891  if words.len() < 3 || words[0] != "ALTER" || words[1] != "EVENT" || words[2] != "TRIGGER" {
3892    return None;
3893  }
3894  let last = *words.last()?;
3895  if matches!(last, "RENAME" | "OWNER" | "ENABLE" | "DEPENDS" | "NO") {
3896    let menu: &[(&str, &str)] = match last {
3897      "RENAME" => &[("TO", "RENAME TO <new>")],
3898      "OWNER" => &[("TO", "OWNER TO <role>")],
3899      "ENABLE" => &[
3900        ("REPLICA", "ENABLE REPLICA -- fire on the replica role only"),
3901        ("ALWAYS", "ENABLE ALWAYS -- fire regardless of session_replication_role"),
3902      ],
3903      "DEPENDS" => &[("ON EXTENSION", "DEPENDS ON EXTENSION <ext>")],
3904      "NO" => &[("DEPENDS ON EXTENSION", "NO DEPENDS ON EXTENSION <ext>")],
3905      _ => &[],
3906    };
3907    if !menu.is_empty() {
3908      return Some(menu);
3909    }
3910  }
3911  if words.len() >= 4 {
3912    return Some(&[
3913      ("ENABLE", "ENABLE [REPLICA | ALWAYS]"),
3914      ("DISABLE", "DISABLE"),
3915      ("RENAME TO", "RENAME TO <new>"),
3916      ("OWNER TO", "OWNER TO <role>"),
3917      ("DEPENDS ON EXTENSION", "DEPENDS ON EXTENSION <ext>"),
3918      ("NO DEPENDS ON EXTENSION", "NO DEPENDS ON EXTENSION <ext>"),
3919    ]);
3920  }
3921  None
3922}
3923
3924/// ALTER OPERATOR CLASS / ALTER OPERATOR FAMILY chain.
3925pub(crate) fn alter_operator_class_family_next_keyword(
3926  source: &str,
3927  offset: TextSize,
3928) -> Option<&'static [(&'static str, &'static str)]> {
3929  if cursor_not_at_ws_boundary(source, offset) {
3930    return None;
3931  }
3932  let (_, upper) = stmt_slice_upper(source, offset);
3933  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
3934  if words.len() < 3 || words[0] != "ALTER" || words[1] != "OPERATOR" {
3935    return None;
3936  }
3937  let kind = words[2];
3938  if !matches!(kind, "CLASS" | "FAMILY") {
3939    return None;
3940  }
3941  let last = *words.last()?;
3942  if matches!(last, "RENAME" | "OWNER" | "SET" | "USING" | "ADD" | "DROP") {
3943    let menu: &[(&str, &str)] = match last {
3944      "RENAME" => &[("TO", "RENAME TO <new>")],
3945      "OWNER" => &[("TO", "OWNER TO <role>")],
3946      "SET" => &[("SCHEMA", "SET SCHEMA <schema>")],
3947      "USING" => &[
3948        ("btree", "btree"),
3949        ("hash", "hash"),
3950        ("gist", "gist"),
3951        ("spgist", "spgist"),
3952        ("gin", "gin"),
3953        ("brin", "brin"),
3954      ],
3955      _ => &[],
3956    };
3957    if !menu.is_empty() {
3958      return Some(menu);
3959    }
3960  }
3961  // After name USING <am> <cursor> -- ADD/DROP/etc for OPERATOR FAMILY.
3962  if kind == "FAMILY" && words.contains(&"USING") && words.len() >= 6 {
3963    let last = *words.last()?;
3964    if last == "ADD" {
3965      return Some(&[
3966        ("OPERATOR", "ADD OPERATOR <strategy_number> <op>(<types>) FOR ..."),
3967        ("FUNCTION", "ADD FUNCTION <support_number> [(<types>)] <fn>(<types>)"),
3968      ]);
3969    }
3970    if last == "DROP" {
3971      return Some(&[
3972        ("OPERATOR", "DROP OPERATOR <strategy_number> (<types>)"),
3973        ("FUNCTION", "DROP FUNCTION <support_number> (<types>)"),
3974      ]);
3975    }
3976    return Some(&[
3977      ("ADD", "ADD OPERATOR | FUNCTION ..."),
3978      ("DROP", "DROP OPERATOR | FUNCTION ..."),
3979      ("RENAME TO", "RENAME TO <new>"),
3980      ("OWNER TO", "OWNER TO <role>"),
3981      ("SET SCHEMA", "SET SCHEMA <schema>"),
3982    ]);
3983  }
3984  if words.len() >= 4 {
3985    return Some(&[
3986      ("USING", "USING <index_method>"),
3987      ("RENAME TO", "RENAME TO <new>"),
3988      ("OWNER TO", "OWNER TO <role>"),
3989      ("SET SCHEMA", "SET SCHEMA <schema>"),
3990    ]);
3991  }
3992  None
3993}
3994
3995pub(crate) fn alter_collation_next_keyword(
3996  source: &str,
3997  offset: TextSize,
3998) -> Option<&'static [(&'static str, &'static str)]> {
3999  if cursor_not_at_ws_boundary(source, offset) {
4000    return None;
4001  }
4002  let (_, upper) = stmt_slice_upper(source, offset);
4003  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
4004  if words.len() < 2 || words[0] != "ALTER" || words[1] != "COLLATION" {
4005    return None;
4006  }
4007  let last = *words.last()?;
4008  if last == "REFRESH" {
4009    return Some(&[("VERSION", "REFRESH VERSION -- bump after libc/icu upgrade")]);
4010  }
4011  if words.len() >= 3 {
4012    return Some(&[
4013      ("RENAME TO", "RENAME TO <new_name>"),
4014      ("OWNER TO", "OWNER TO <role>"),
4015      ("SET SCHEMA", "SET SCHEMA <schema>"),
4016      ("REFRESH VERSION", "REFRESH VERSION -- bump after libc/icu upgrade"),
4017    ]);
4018  }
4019  None
4020}
4021
4022/// CREATE ACCESS METHOD chain.
4023/// `CREATE ACCESS METHOD <name> TYPE {INDEX|TABLE} HANDLER <fn>`
4024/// ALTER RULE chain.
4025///   ALTER RULE <name> ON <table> RENAME TO <new_name>
4026pub(crate) fn alter_rule_next_keyword(
4027  source: &str,
4028  offset: TextSize,
4029) -> Option<&'static [(&'static str, &'static str)]> {
4030  if cursor_not_at_ws_boundary(source, offset) {
4031    return None;
4032  }
4033  let (_, upper) = stmt_slice_upper(source, offset);
4034  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
4035  if words.len() < 2 || words[0] != "ALTER" || words[1] != "RULE" {
4036    return None;
4037  }
4038  let last = *words.last()?;
4039  if last == "RULE" {
4040    return None; // user types rule name
4041  }
4042  if last == "ON" {
4043    return None; // user types table
4044  }
4045  if last == "RENAME" {
4046    return Some(&[("TO", "RENAME TO <new>")]);
4047  }
4048  if words.contains(&"ON") && words.len() >= 5 && !words.contains(&"RENAME") {
4049    return Some(&[("RENAME TO", "RENAME TO <new>")]);
4050  }
4051  if words.len() == 3 && !words.contains(&"ON") {
4052    return Some(&[("ON", "ON <table>")]);
4053  }
4054  None
4055}
4056
4057/// ALTER TRIGGER chain.
4058///   ALTER TRIGGER <name> ON <table>
4059///       RENAME TO <new>
4060///     | DEPENDS ON EXTENSION <ext>
4061///     | NO DEPENDS ON EXTENSION <ext>
4062pub(crate) fn alter_trigger_next_keyword(
4063  source: &str,
4064  offset: TextSize,
4065) -> Option<&'static [(&'static str, &'static str)]> {
4066  if cursor_not_at_ws_boundary(source, offset) {
4067    return None;
4068  }
4069  let (_, upper) = stmt_slice_upper(source, offset);
4070  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
4071  if words.len() < 2 || words[0] != "ALTER" || words[1] != "TRIGGER" {
4072    return None;
4073  }
4074  let last = *words.last()?;
4075  if last == "TRIGGER" {
4076    return None; // user types name
4077  }
4078  if last == "ON" {
4079    return None; // user types table
4080  }
4081  if last == "RENAME" {
4082    return Some(&[("TO", "RENAME TO <new>")]);
4083  }
4084  if last == "DEPENDS" {
4085    return Some(&[("ON EXTENSION", "DEPENDS ON EXTENSION <ext>")]);
4086  }
4087  if last == "NO" {
4088    return Some(&[("DEPENDS ON EXTENSION", "NO DEPENDS ON EXTENSION <ext>")]);
4089  }
4090  if words.contains(&"ON") && words.len() >= 5 {
4091    return Some(&[
4092      ("RENAME TO", "RENAME TO <new>"),
4093      ("DEPENDS ON EXTENSION", "DEPENDS ON EXTENSION <ext>"),
4094      ("NO DEPENDS ON EXTENSION", "NO DEPENDS ON EXTENSION <ext>"),
4095    ]);
4096  }
4097  if words.len() == 3 && !words.contains(&"ON") {
4098    return Some(&[("ON", "ON <table>")]);
4099  }
4100  None
4101}
4102
4103/// ALTER ACCESS METHOD chain. PG only supports rename + owner changes.
4104///   ALTER ACCESS METHOD <name> { RENAME TO <new> | OWNER TO <role> }
4105pub(crate) fn alter_access_method_next_keyword(
4106  source: &str,
4107  offset: TextSize,
4108) -> Option<&'static [(&'static str, &'static str)]> {
4109  if cursor_not_at_ws_boundary(source, offset) {
4110    return None;
4111  }
4112  let (_, upper) = stmt_slice_upper(source, offset);
4113  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
4114  if words.len() < 3 || words[0] != "ALTER" || words[1] != "ACCESS" || words[2] != "METHOD" {
4115    return None;
4116  }
4117  let last = *words.last()?;
4118  if matches!(last, "RENAME" | "OWNER") {
4119    return Some(match last {
4120      "RENAME" => &[("TO", "RENAME TO <new>")],
4121      "OWNER" => &[("TO", "OWNER TO <role>")],
4122      _ => &[],
4123    });
4124  }
4125  if words.len() >= 4 {
4126    return Some(&[("RENAME TO", "RENAME TO <new>"), ("OWNER TO", "OWNER TO <role>")]);
4127  }
4128  None
4129}
4130
4131/// CREATE CONVERSION chain.
4132///   CREATE [DEFAULT] CONVERSION <name> FOR '<src_enc>' TO '<dst_enc>' FROM <fn>
4133pub(crate) fn create_conversion_next_keyword(
4134  source: &str,
4135  offset: TextSize,
4136) -> Option<&'static [(&'static str, &'static str)]> {
4137  if cursor_not_at_ws_boundary(source, offset) {
4138    return None;
4139  }
4140  let (_, upper) = stmt_slice_upper(source, offset);
4141  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
4142  let conv_idx = words.iter().position(|w| *w == "CONVERSION")?;
4143  if !words[..conv_idx].iter().all(|w| matches!(*w, "CREATE" | "DEFAULT")) || words[0] != "CREATE" {
4144    return None;
4145  }
4146  let tail = &words[conv_idx + 1..];
4147  let last = tail.last().copied();
4148  if tail.is_empty() {
4149    return None; // user types name
4150  }
4151  if last == Some("FOR") {
4152    return None; // user types '<src_enc>'
4153  }
4154  if last == Some("TO") && tail.contains(&"FOR") {
4155    return None; // user types '<dst_enc>'
4156  }
4157  if last == Some("FROM") && tail.contains(&"FOR") {
4158    return None; // user types function name
4159  }
4160  if tail.len() == 1 {
4161    return Some(&[("FOR", "FOR '<src_encoding>' TO '<dst_encoding>' FROM <function>")]);
4162  }
4163  if tail.contains(&"FOR") && !tail.contains(&"TO") {
4164    return Some(&[("TO", "TO '<dst_encoding>'")]);
4165  }
4166  if tail.contains(&"TO") && !tail.contains(&"FROM") {
4167    return Some(&[("FROM", "FROM <conversion_function>")]);
4168  }
4169  None
4170}
4171
4172/// ALTER CONVERSION chain.
4173pub(crate) fn alter_conversion_next_keyword(
4174  source: &str,
4175  offset: TextSize,
4176) -> Option<&'static [(&'static str, &'static str)]> {
4177  if cursor_not_at_ws_boundary(source, offset) {
4178    return None;
4179  }
4180  let (_, upper) = stmt_slice_upper(source, offset);
4181  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
4182  if words.len() < 2 || words[0] != "ALTER" || words[1] != "CONVERSION" {
4183    return None;
4184  }
4185  let last = *words.last()?;
4186  if matches!(last, "RENAME" | "OWNER" | "SET") {
4187    return Some(match last {
4188      "RENAME" => &[("TO", "RENAME TO <new>")],
4189      "OWNER" => &[("TO", "OWNER TO <role>")],
4190      "SET" => &[("SCHEMA", "SET SCHEMA <schema>")],
4191      _ => &[],
4192    });
4193  }
4194  if words.len() >= 3 {
4195    return Some(&[
4196      ("RENAME TO", "RENAME TO <new>"),
4197      ("OWNER TO", "OWNER TO <role>"),
4198      ("SET SCHEMA", "SET SCHEMA <schema>"),
4199    ]);
4200  }
4201  None
4202}
4203
4204pub(crate) fn create_access_method_next_keyword(
4205  source: &str,
4206  offset: TextSize,
4207) -> Option<&'static [(&'static str, &'static str)]> {
4208  if cursor_not_at_ws_boundary(source, offset) {
4209    return None;
4210  }
4211  let (_, upper) = stmt_slice_upper(source, offset);
4212  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
4213  if words.len() < 3 || words[0] != "CREATE" || words[1] != "ACCESS" || words[2] != "METHOD" {
4214    return None;
4215  }
4216  let last = *words.last()?;
4217  if last == "TYPE" {
4218    return Some(&[
4219      ("INDEX", "TYPE INDEX -- index access method"),
4220      ("TABLE", "TYPE TABLE -- table access method (PG12+)"),
4221    ]);
4222  }
4223  if last == "HANDLER" {
4224    return None; // user types function name
4225  }
4226  if words.len() >= 4 && !words.contains(&"TYPE") {
4227    return Some(&[("TYPE", "TYPE {INDEX | TABLE}")]);
4228  }
4229  if words.contains(&"TYPE") && !words.contains(&"HANDLER") {
4230    return Some(&[("HANDLER", "HANDLER <function> -- AM entrypoint")]);
4231  }
4232  None
4233}
4234
4235/// ALTER OPERATOR chain.
4236/// CREATE [OR REPLACE] VIEW / CREATE MATERIALIZED VIEW chain.
4237///   CREATE VIEW <name> [(cols)] [WITH (storage_params)] AS <select>
4238///                                [WITH [CASCADED|LOCAL] CHECK OPTION]
4239///   CREATE MATERIALIZED VIEW [IF NOT EXISTS] <name> [(cols)]
4240///                                [USING <am>] [WITH (storage_params)]
4241///                                [TABLESPACE <ts>] AS <select> [WITH [NO] DATA]
4242pub(crate) fn create_view_post_name_next_keyword(
4243  source: &str,
4244  offset: TextSize,
4245) -> Option<&'static [(&'static str, &'static str)]> {
4246  if cursor_not_at_ws_boundary(source, offset) {
4247    return None;
4248  }
4249  let (slice_owned, upper) = stmt_slice_upper(source, offset);
4250  let slice = slice_owned.as_str();
4251  let trimmed = upper.trim_start();
4252  let is_view = trimmed.starts_with("CREATE VIEW")
4253    || trimmed.starts_with("CREATE OR REPLACE VIEW")
4254    || trimmed.starts_with("CREATE TEMP VIEW")
4255    || trimmed.starts_with("CREATE TEMPORARY VIEW");
4256  let is_mv = trimmed.starts_with("CREATE MATERIALIZED VIEW");
4257  if !is_view && !is_mv {
4258    return None;
4259  }
4260  // Suppress when AS is already typed -- Phase machine handles the SELECT body.
4261  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
4262  if words.contains(&"AS") {
4263    // After AS handled by SELECT phase; but trailing WITH after the body
4264    // (WITH CHECK OPTION for views, WITH DATA for MVs) is still our slot.
4265    let last = *words.last()?;
4266    if last == "WITH" {
4267      if is_view {
4268        return Some(&[
4269          ("CHECK OPTION", "WITH CHECK OPTION -- enforce predicate on writes"),
4270          ("CASCADED CHECK OPTION", "WITH CASCADED CHECK OPTION -- + parent views"),
4271          ("LOCAL CHECK OPTION", "WITH LOCAL CHECK OPTION -- this view only"),
4272        ]);
4273      }
4274      if is_mv {
4275        return Some(&[
4276          ("DATA", "WITH DATA -- populate now (default)"),
4277          ("NO DATA", "WITH NO DATA -- create empty; populate later with REFRESH"),
4278        ]);
4279      }
4280    }
4281    if last == "NO" && words.contains(&"WITH") && is_mv {
4282      return Some(&[("DATA", "NO DATA -- mark MV invalid")]);
4283    }
4284    if matches!(last, "CASCADED" | "LOCAL") && is_view {
4285      return Some(&[("CHECK OPTION", "CHECK OPTION -- enforce predicate on writes")]);
4286    }
4287    return None;
4288  }
4289  // Body paren count.
4290  let opens = slice.matches('(').count();
4291  let closes = slice.matches(')').count();
4292  let paren_balanced = opens == 0 || opens == closes;
4293  let last = *words.last()?;
4294  if last == "USING" && is_mv {
4295    return Some(&[("heap", "USING heap -- default access method")]);
4296  }
4297  if last == "WITH" {
4298    if is_mv {
4299      return Some(&[("(", "WITH ( fillfactor = <n>, autovacuum_<param> = <v>, ... )")]);
4300    }
4301    return Some(&[(
4302      "(",
4303      "WITH ( security_barrier = true|false, security_invoker = true|false, check_option = local|cascaded )",
4304    )]);
4305  }
4306  if last == "TABLESPACE" && is_mv {
4307    return None; // user types tablespace name
4308  }
4309  if paren_balanced && words.len() >= 3 {
4310    // Fresh post-name slot.
4311    let mut menu: Vec<(&str, &str)> = Vec::with_capacity(6);
4312    if is_mv {
4313      menu.push(("USING", "USING <access_method> -- PG12+"));
4314      menu.push(("WITH", "WITH ( fillfactor = ..., autovacuum_<param> = ..., ... )"));
4315      menu.push(("TABLESPACE", "TABLESPACE <name>"));
4316      menu.push(("AS", "AS <select_statement>"));
4317    } else {
4318      menu.push(("WITH", "WITH ( security_barrier|security_invoker|check_option )"));
4319      menu.push(("AS", "AS <select_statement>"));
4320    }
4321    // Return the deterministic static menu.
4322    if is_mv {
4323      return Some(&[
4324        ("USING", "USING <access_method> -- PG12+"),
4325        ("WITH", "WITH ( fillfactor = ..., autovacuum_<param> = ..., ... )"),
4326        ("TABLESPACE", "TABLESPACE <name>"),
4327        ("AS", "AS <select_statement>"),
4328      ]);
4329    }
4330    return Some(&[
4331      ("WITH", "WITH ( security_barrier | security_invoker | check_option )"),
4332      ("AS", "AS <select_statement>"),
4333    ]);
4334  }
4335  None
4336}
4337
4338pub(crate) fn alter_operator_next_keyword(
4339  source: &str,
4340  offset: TextSize,
4341) -> Option<&'static [(&'static str, &'static str)]> {
4342  if cursor_not_at_ws_boundary(source, offset) {
4343    return None;
4344  }
4345  let (slice_owned, upper) = stmt_slice_upper(source, offset);
4346  let slice = slice_owned.as_str();
4347  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
4348  if words.len() < 2 || words[0] != "ALTER" || words[1] != "OPERATOR" {
4349    return None;
4350  }
4351  let last = *words.last()?;
4352  // Sub-keyword followups must beat the post-signature action menu so
4353  // `ALTER OPERATOR + (int,int) SET <cursor>` surfaces SCHEMA, not the
4354  // whole top-level menu again.
4355  if last == "OWNER" {
4356    return Some(&[("TO", "OWNER TO <role>")]);
4357  }
4358  if last == "SET" {
4359    return Some(&[("SCHEMA", "SET SCHEMA <schema>"), ("(", "SET ( RESTRICT = <fn>, JOIN = <fn> )")]);
4360  }
4361  // After the (left_type, right_type) signature -> action menu.
4362  let opens = slice.matches('(').count();
4363  let closes = slice.matches(')').count();
4364  if opens > 0 && opens == closes {
4365    return Some(&[
4366      ("OWNER TO", "OWNER TO <role>"),
4367      ("SET SCHEMA", "SET SCHEMA <schema>"),
4368      ("SET", "SET ( RESTRICT = <fn>, JOIN = <fn> )"),
4369    ]);
4370  }
4371  None
4372}
4373
4374/// ALTER AGGREGATE chain.
4375pub(crate) fn alter_aggregate_next_keyword(
4376  source: &str,
4377  offset: TextSize,
4378) -> Option<&'static [(&'static str, &'static str)]> {
4379  if cursor_not_at_ws_boundary(source, offset) {
4380    return None;
4381  }
4382  let (slice_owned, upper) = stmt_slice_upper(source, offset);
4383  let slice = slice_owned.as_str();
4384  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
4385  if words.len() < 2 || words[0] != "ALTER" || words[1] != "AGGREGATE" {
4386    return None;
4387  }
4388  let opens = slice.matches('(').count();
4389  let closes = slice.matches(')').count();
4390  if opens > 0 && opens == closes {
4391    return Some(&[
4392      ("RENAME TO", "RENAME TO <new_name>"),
4393      ("OWNER TO", "OWNER TO <role>"),
4394      ("SET SCHEMA", "SET SCHEMA <schema>"),
4395    ]);
4396  }
4397  let last = *words.last()?;
4398  if last == "RENAME" {
4399    return Some(&[("TO", "RENAME TO <new_name>")]);
4400  }
4401  if last == "OWNER" {
4402    return Some(&[("TO", "OWNER TO <role>")]);
4403  }
4404  if last == "SET" {
4405    return Some(&[("SCHEMA", "SET SCHEMA <schema>")]);
4406  }
4407  None
4408}
4409
4410/// ALTER PUBLICATION chain.
4411///   ALTER PUBLICATION <name> {ADD|SET|DROP} {TABLE|TABLES IN SCHEMA} ...
4412///   ALTER PUBLICATION <name> SET (publish = '...')
4413///   ALTER PUBLICATION <name> {RENAME TO | OWNER TO} ...
4414pub(crate) fn alter_publication_next_keyword(
4415  source: &str,
4416  offset: TextSize,
4417) -> Option<&'static [(&'static str, &'static str)]> {
4418  if cursor_not_at_ws_boundary(source, offset) {
4419    return None;
4420  }
4421  let (_, upper) = stmt_slice_upper(source, offset);
4422  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
4423  if words.len() < 2 || words[0] != "ALTER" || words[1] != "PUBLICATION" {
4424    return None;
4425  }
4426  let last = *words.last()?;
4427  if matches!(last, "ADD" | "SET" | "DROP") {
4428    let menu: &[(&str, &str)] = match last {
4429      "ADD" => &[("TABLE", "ADD TABLE <tbl>[, ...]"), ("TABLES IN SCHEMA", "ADD TABLES IN SCHEMA <schema>[, ...]")],
4430      "SET" => &[
4431        ("TABLE", "SET TABLE <tbl>[, ...] -- replace the table list"),
4432        ("TABLES IN SCHEMA", "SET TABLES IN SCHEMA <schema>[, ...]"),
4433        ("(", "SET (publish = 'insert, ...')"),
4434      ],
4435      "DROP" => &[("TABLE", "DROP TABLE <tbl>[, ...]"), ("TABLES IN SCHEMA", "DROP TABLES IN SCHEMA <schema>[, ...]")],
4436      _ => &[],
4437    };
4438    if !menu.is_empty() {
4439      return Some(menu);
4440    }
4441  }
4442  if last == "RENAME" {
4443    return Some(&[("TO", "RENAME TO <new_name>")]);
4444  }
4445  if last == "OWNER" {
4446    return Some(&[("TO", "OWNER TO <role>")]);
4447  }
4448  // `... ADD|SET|DROP TABLES IN <cursor>` -> SCHEMA.
4449  if last == "IN" && words.contains(&"TABLES") {
4450    return Some(&[("SCHEMA", "TABLES IN SCHEMA <schema>[, ...]")]);
4451  }
4452  // `... ADD|SET|DROP TABLES <cursor>` -> IN SCHEMA.
4453  if last == "TABLES" && (words.contains(&"ADD") || words.contains(&"SET") || words.contains(&"DROP")) {
4454    return Some(&[("IN SCHEMA", "TABLES IN SCHEMA <schema>[, ...]")]);
4455  }
4456  if words.len() >= 3 {
4457    return Some(&[
4458      ("ADD", "ADD TABLE / TABLES IN SCHEMA ..."),
4459      ("SET", "SET TABLE / TABLES IN SCHEMA / (...) ..."),
4460      ("DROP", "DROP TABLE / TABLES IN SCHEMA ..."),
4461      ("RENAME TO", "RENAME TO <new_name>"),
4462      ("OWNER TO", "OWNER TO <role>"),
4463    ]);
4464  }
4465  None
4466}
4467
4468/// ALTER SUBSCRIPTION chain.
4469pub(crate) fn alter_subscription_next_keyword(
4470  source: &str,
4471  offset: TextSize,
4472) -> Option<&'static [(&'static str, &'static str)]> {
4473  if cursor_not_at_ws_boundary(source, offset) {
4474    return None;
4475  }
4476  let (_, upper) = stmt_slice_upper(source, offset);
4477  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
4478  if words.len() < 2 || words[0] != "ALTER" || words[1] != "SUBSCRIPTION" {
4479    return None;
4480  }
4481  let last = *words.last()?;
4482  if matches!(last, "RENAME" | "OWNER") {
4483    let menu: &[(&str, &str)] = match last {
4484      "RENAME" => &[("TO", "RENAME TO <new_name>")],
4485      "OWNER" => &[("TO", "OWNER TO <role>")],
4486      _ => &[],
4487    };
4488    if !menu.is_empty() {
4489      return Some(menu);
4490    }
4491  }
4492  if last == "SET" {
4493    return Some(&[
4494      ("PUBLICATION", "SET PUBLICATION <pub>[, ...]"),
4495      ("(", "( slot_name=..., synchronous_commit=..., binary=..., disable_on_error=... )"),
4496    ]);
4497  }
4498  if last == "ADD" {
4499    return Some(&[("PUBLICATION", "ADD PUBLICATION <pub>[, ...]")]);
4500  }
4501  if last == "DROP" {
4502    return Some(&[("PUBLICATION", "DROP PUBLICATION <pub>[, ...]")]);
4503  }
4504  if last == "REFRESH" {
4505    return Some(&[("PUBLICATION", "REFRESH PUBLICATION [WITH (copy_data = true|false)]")]);
4506  }
4507  if last == "SKIP" {
4508    return Some(&[("(", "SKIP ( lsn = '0/0' )")]);
4509  }
4510  if words.len() >= 3 {
4511    return Some(&[
4512      ("CONNECTION", "CONNECTION '<conn_string>'"),
4513      ("SET PUBLICATION", "SET PUBLICATION <pub>[, ...]"),
4514      ("ADD PUBLICATION", "ADD PUBLICATION <pub>[, ...]"),
4515      ("DROP PUBLICATION", "DROP PUBLICATION <pub>[, ...]"),
4516      ("REFRESH PUBLICATION", "REFRESH PUBLICATION [WITH (copy_data = true|false)]"),
4517      ("ENABLE", "ENABLE"),
4518      ("DISABLE", "DISABLE"),
4519      ("SET", "SET (slot_name = ..., ...)"),
4520      ("RENAME TO", "RENAME TO <new_name>"),
4521      ("OWNER TO", "OWNER TO <role>"),
4522      ("SKIP", "SKIP ( lsn = '0/0' )"),
4523    ]);
4524  }
4525  None
4526}
4527
4528/// ALTER SCHEMA chain.
4529/// ALTER DATABASE chain. After name, emit the action menu:
4530///   RENAME TO / OWNER TO / SET TABLESPACE / REFRESH COLLATION VERSION /
4531///   WITH ALLOW_CONNECTIONS / CONNECTION LIMIT / IS_TEMPLATE / RESET ALL
4532///   / SET <param> = <val> / RESET <param>
4533pub(crate) fn alter_database_next_keyword(
4534  source: &str,
4535  offset: TextSize,
4536) -> Option<&'static [(&'static str, &'static str)]> {
4537  if cursor_not_at_ws_boundary(source, offset) {
4538    return None;
4539  }
4540  let (_, upper) = stmt_slice_upper(source, offset);
4541  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
4542  if words.len() < 2 || words[0] != "ALTER" || words[1] != "DATABASE" {
4543    return None;
4544  }
4545  let last = *words.last()?;
4546  if matches!(last, "RENAME" | "OWNER" | "SET" | "RESET") {
4547    let menu: &[(&str, &str)] = match last {
4548      "RENAME" => &[("TO", "RENAME TO <new_name>")],
4549      "OWNER" => &[("TO", "OWNER TO <role>")],
4550      "SET" => {
4551        &[("TABLESPACE", "SET TABLESPACE <tablespace>"), ("ALL", "RESET ALL -- restore every database GUC default")]
4552      },
4553      "RESET" => &[("ALL", "RESET ALL")],
4554      _ => &[],
4555    };
4556    if !menu.is_empty() {
4557      return Some(menu);
4558    }
4559  }
4560  if last == "REFRESH" {
4561    return Some(&[("COLLATION VERSION", "REFRESH COLLATION VERSION -- record current collversion (PG15+)")]);
4562  }
4563  if last == "WITH" {
4564    return Some(&[
4565      ("ALLOW_CONNECTIONS", "ALLOW_CONNECTIONS true|false"),
4566      ("CONNECTION LIMIT", "CONNECTION LIMIT <n>"),
4567      ("IS_TEMPLATE", "IS_TEMPLATE true|false"),
4568    ]);
4569  }
4570  if last == "CONNECTION" {
4571    return Some(&[("LIMIT", "CONNECTION LIMIT <n>")]);
4572  }
4573  if matches!(last, "ALLOW_CONNECTIONS" | "IS_TEMPLATE") {
4574    return Some(&[("true", "true"), ("false", "false")]);
4575  }
4576  // Top-level action menu (after `ALTER DATABASE <name>`).
4577  if words.len() >= 3 {
4578    return Some(&[
4579      ("RENAME TO", "RENAME TO <new_name>"),
4580      ("OWNER TO", "OWNER TO <role>"),
4581      ("SET TABLESPACE", "SET TABLESPACE <tablespace>"),
4582      ("SET", "SET <param> = <val>"),
4583      ("RESET", "RESET <param> | RESET ALL"),
4584      ("WITH", "WITH ALLOW_CONNECTIONS|CONNECTION LIMIT|IS_TEMPLATE ..."),
4585      ("REFRESH COLLATION VERSION", "REFRESH COLLATION VERSION -- PG15+"),
4586      ("ALLOW_CONNECTIONS", "ALLOW_CONNECTIONS true|false (shorthand without WITH)"),
4587      ("CONNECTION LIMIT", "CONNECTION LIMIT <n>"),
4588      ("IS_TEMPLATE", "IS_TEMPLATE true|false"),
4589    ]);
4590  }
4591  None
4592}
4593
4594/// ALTER TABLESPACE chain. After name:
4595///   RENAME TO / OWNER TO / SET ( <param> = <val> ) / RESET ( <param> )
4596pub(crate) fn alter_tablespace_next_keyword(
4597  source: &str,
4598  offset: TextSize,
4599) -> Option<&'static [(&'static str, &'static str)]> {
4600  if cursor_not_at_ws_boundary(source, offset) {
4601    return None;
4602  }
4603  let (_, upper) = stmt_slice_upper(source, offset);
4604  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
4605  if words.len() < 2 || words[0] != "ALTER" || words[1] != "TABLESPACE" {
4606    return None;
4607  }
4608  let last = *words.last()?;
4609  if matches!(last, "RENAME" | "OWNER" | "SET" | "RESET") {
4610    let menu: &[(&str, &str)] = match last {
4611      "RENAME" => &[("TO", "RENAME TO <new_name>")],
4612      "OWNER" => &[("TO", "OWNER TO <role>")],
4613      "SET" => &[("(", "SET ( seq_page_cost = <n>, random_page_cost = <n>, effective_io_concurrency = <n> )")],
4614      "RESET" => &[("(", "RESET ( <param>[, ...] )")],
4615      _ => &[],
4616    };
4617    if !menu.is_empty() {
4618      return Some(menu);
4619    }
4620  }
4621  if words.len() >= 3 {
4622    return Some(&[
4623      ("RENAME TO", "RENAME TO <new_name>"),
4624      ("OWNER TO", "OWNER TO <role>"),
4625      ("SET", "SET ( seq_page_cost = <n>, random_page_cost = <n>, effective_io_concurrency = <n> )"),
4626      ("RESET", "RESET ( <param>[, ...] )"),
4627    ]);
4628  }
4629  None
4630}
4631
4632/// CREATE USER MAPPING chain.
4633///   CREATE USER MAPPING [IF NOT EXISTS] FOR <role> SERVER <srv> OPTIONS (<k> '<v>', ...)
4634pub(crate) fn create_user_mapping_next_keyword(
4635  source: &str,
4636  offset: TextSize,
4637) -> Option<&'static [(&'static str, &'static str)]> {
4638  if cursor_not_at_ws_boundary(source, offset) {
4639    return None;
4640  }
4641  let (_, upper) = stmt_slice_upper(source, offset);
4642  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
4643  if words.len() < 3 || words[0] != "CREATE" || words[1] != "USER" || words[2] != "MAPPING" {
4644    return None;
4645  }
4646  let last = *words.last()?;
4647  if last == "MAPPING" {
4648    return Some(&[
4649      ("FOR", "FOR <role> SERVER <name> [OPTIONS (...)]"),
4650      ("IF NOT EXISTS", "IF NOT EXISTS -- skip silently when present"),
4651    ]);
4652  }
4653  if last == "FOR" {
4654    return Some(&[
4655      ("CURRENT_USER", "FOR CURRENT_USER -- current session role"),
4656      ("CURRENT_ROLE", "FOR CURRENT_ROLE -- synonym"),
4657      ("PUBLIC", "FOR PUBLIC -- everyone (default fallback)"),
4658      ("USER", "FOR USER -- alias of CURRENT_USER"),
4659    ]);
4660  }
4661  if last == "SERVER" {
4662    return None; // user types server name
4663  }
4664  if last == "OPTIONS" {
4665    return Some(&[("(", "( <option_name> '<value>'[, ...] )")]);
4666  }
4667  if !words.contains(&"SERVER")
4668    && (words.contains(&"CURRENT_USER")
4669      || words.contains(&"CURRENT_ROLE")
4670      || words.contains(&"PUBLIC")
4671      || words.contains(&"USER")
4672      || words.len() >= 5)
4673  {
4674    return Some(&[("SERVER", "SERVER <name>")]);
4675  }
4676  if words.contains(&"SERVER") && !words.contains(&"OPTIONS") {
4677    return Some(&[("OPTIONS", "OPTIONS (<key> '<val>'[, ...])")]);
4678  }
4679  None
4680}
4681
4682/// ALTER USER MAPPING chain.
4683///   ALTER USER MAPPING FOR <role> SERVER <srv> OPTIONS ( ADD|SET|DROP <k> ['<v>'] )
4684pub(crate) fn alter_user_mapping_next_keyword(
4685  source: &str,
4686  offset: TextSize,
4687) -> Option<&'static [(&'static str, &'static str)]> {
4688  if cursor_not_at_ws_boundary(source, offset) {
4689    return None;
4690  }
4691  let (slice_owned, upper) = stmt_slice_upper(source, offset);
4692  let slice = slice_owned.as_str();
4693  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
4694  if words.len() < 3 || words[0] != "ALTER" || words[1] != "USER" || words[2] != "MAPPING" {
4695    return None;
4696  }
4697  let last = *words.last()?;
4698  if last == "MAPPING" {
4699    return Some(&[("FOR", "FOR <role> SERVER <name> OPTIONS (...)")]);
4700  }
4701  if last == "FOR" {
4702    return Some(&[
4703      ("CURRENT_USER", "FOR CURRENT_USER"),
4704      ("CURRENT_ROLE", "FOR CURRENT_ROLE"),
4705      ("PUBLIC", "FOR PUBLIC"),
4706      ("USER", "FOR USER"),
4707    ]);
4708  }
4709  if last == "SERVER" {
4710    return None;
4711  }
4712  if last == "OPTIONS" {
4713    return Some(&[("(", "( ADD|SET|DROP <k> '<v>'[, ...] )")]);
4714  }
4715  // Inside OPTIONS paren -> ADD / SET / DROP at fresh slot.
4716  let opens = slice.matches('(').count();
4717  let closes = slice.matches(')').count();
4718  if opens > closes {
4719    let trimmed = slice.trim_end();
4720    let last_char = trimmed.chars().last();
4721    if matches!(last_char, Some('(') | Some(',')) || slice.ends_with(char::is_whitespace) {
4722      return Some(&[("ADD", "ADD <key> '<value>'"), ("SET", "SET <key> '<value>'"), ("DROP", "DROP <key>")]);
4723    }
4724  }
4725  if words.contains(&"SERVER") && !words.contains(&"OPTIONS") {
4726    return Some(&[("OPTIONS", "OPTIONS (<key> '<val>'[, ...])")]);
4727  }
4728  if !words.contains(&"SERVER")
4729    && (words.contains(&"CURRENT_USER")
4730      || words.contains(&"CURRENT_ROLE")
4731      || words.contains(&"PUBLIC")
4732      || words.contains(&"USER")
4733      || words.len() >= 5)
4734  {
4735    return Some(&[("SERVER", "SERVER <name>")]);
4736  }
4737  None
4738}
4739
4740pub(crate) fn alter_schema_next_keyword(
4741  source: &str,
4742  offset: TextSize,
4743) -> Option<&'static [(&'static str, &'static str)]> {
4744  if cursor_not_at_ws_boundary(source, offset) {
4745    return None;
4746  }
4747  let (_, upper) = stmt_slice_upper(source, offset);
4748  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
4749  if words.len() < 2 || words[0] != "ALTER" || words[1] != "SCHEMA" {
4750    return None;
4751  }
4752  if words.len() >= 3 {
4753    return Some(&[("RENAME TO", "RENAME TO <new_name>"), ("OWNER TO", "OWNER TO <role>")]);
4754  }
4755  None
4756}
4757
4758/// CREATE TEXT SEARCH {CONFIGURATION|DICTIONARY|PARSER|TEMPLATE} phase chain.
4759pub(crate) fn create_text_search_next_keyword(
4760  source: &str,
4761  offset: TextSize,
4762) -> Option<&'static [(&'static str, &'static str)]> {
4763  let pos: usize = (u32::from(offset) as usize).min(source.len());
4764  let bytes = source.as_bytes();
4765  if pos < bytes.len() && !bytes[pos].is_ascii_whitespace() && bytes[pos] != b'(' && bytes[pos] != b',' {
4766    return None;
4767  }
4768  let (slice_owned, upper) = stmt_slice_upper(source, offset);
4769  let slice = slice_owned.as_str();
4770  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
4771  if words.len() < 3 || words[0] != "CREATE" || words[1] != "TEXT" || words[2] != "SEARCH" {
4772    return None;
4773  }
4774  if words.len() < 4 {
4775    return Some(&[
4776      ("CONFIGURATION", "CREATE TEXT SEARCH CONFIGURATION <name> ( PARSER = ... )"),
4777      ("DICTIONARY", "CREATE TEXT SEARCH DICTIONARY <name> ( TEMPLATE = ... )"),
4778      ("PARSER", "CREATE TEXT SEARCH PARSER <name> ( START = ..., GETTOKEN = ..., END = ..., LEXTYPES = ... )"),
4779      ("TEMPLATE", "CREATE TEXT SEARCH TEMPLATE <name> ( INIT = ..., LEXIZE = ... )"),
4780    ]);
4781  }
4782  let kind = words[3];
4783  let opens = slice.matches('(').count();
4784  let closes = slice.matches(')').count();
4785  if opens > closes {
4786    let trimmed = slice.trim_end();
4787    let last_char = trimmed.chars().last();
4788    if !matches!(last_char, Some('(') | Some(',')) && !slice.ends_with(char::is_whitespace) {
4789      return None;
4790    }
4791    return Some(match kind {
4792      "CONFIGURATION" => &[("PARSER", "PARSER = <parser>"), ("COPY", "COPY = <existing_config>")],
4793      "DICTIONARY" => &[("TEMPLATE", "TEMPLATE = <template>")],
4794      "PARSER" => &[
4795        ("START", "START = <function>"),
4796        ("GETTOKEN", "GETTOKEN = <function>"),
4797        ("END", "END = <function>"),
4798        ("LEXTYPES", "LEXTYPES = <function>"),
4799        ("HEADLINE", "HEADLINE = <function>"),
4800      ],
4801      "TEMPLATE" => &[("INIT", "INIT = <function>"), ("LEXIZE", "LEXIZE = <function>")],
4802      _ => &[],
4803    });
4804  }
4805  None
4806}
4807
4808/// CREATE EXTENSION chain.
4809///   CREATE EXTENSION [IF NOT EXISTS] <name> [WITH] [SCHEMA <schema>]
4810///     [VERSION <ver>] [CASCADE]
4811pub(crate) fn create_extension_next_keyword(
4812  source: &str,
4813  offset: TextSize,
4814) -> Option<&'static [(&'static str, &'static str)]> {
4815  if cursor_not_at_ws_boundary(source, offset) {
4816    return None;
4817  }
4818  let (_, upper) = stmt_slice_upper(source, offset);
4819  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
4820  if words.len() < 2 || words[0] != "CREATE" || words[1] != "EXTENSION" {
4821    return None;
4822  }
4823  let last = *words.last()?;
4824  if matches!(last, "SCHEMA" | "VERSION") {
4825    return None; // user types the value
4826  }
4827  if last == "WITH" {
4828    return Some(&[
4829      ("SCHEMA", "WITH SCHEMA <schema>"),
4830      ("VERSION", "WITH VERSION '<ver>'"),
4831      ("CASCADE", "WITH CASCADE -- auto-install required extensions"),
4832    ]);
4833  }
4834  if words.len() >= 3 {
4835    return Some(&[
4836      ("WITH", "WITH SCHEMA / VERSION / CASCADE clarifier"),
4837      ("SCHEMA", "SCHEMA <schema>"),
4838      ("VERSION", "VERSION '<ver>'"),
4839      ("CASCADE", "CASCADE -- auto-install required extensions"),
4840    ]);
4841  }
4842  None
4843}
4844
4845/// ALTER FUNCTION / ALTER PROCEDURE chain after the function signature.
4846/// CREATE [OR REPLACE] FUNCTION/PROCEDURE attribute chain. Fires after
4847/// the return type (or after the `(args)` paren for PROCEDURE) and
4848/// before `AS $$ ... $$` / `RETURN <expr>`. Emits the attribute menu.
4849pub(crate) fn create_function_attribute_next_keyword(
4850  source: &str,
4851  offset: TextSize,
4852) -> Option<&'static [(&'static str, &'static str)]> {
4853  if cursor_not_at_ws_boundary(source, offset) {
4854    return None;
4855  }
4856  let (_, upper) = stmt_slice_upper(source, offset);
4857  let trimmed = upper.trim_start();
4858  let is_fn = trimmed.starts_with("CREATE FUNCTION") || trimmed.starts_with("CREATE OR REPLACE FUNCTION");
4859  let is_proc = trimmed.starts_with("CREATE PROCEDURE") || trimmed.starts_with("CREATE OR REPLACE PROCEDURE");
4860  if !is_fn && !is_proc {
4861    return None;
4862  }
4863  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
4864  let last = *words.last()?;
4865  // Inside or right after dollar-quoted body -- bail out (PL/pgSQL body
4866  // owns those slots). Heuristic: count `$$` markers.
4867  let dq = upper.matches("$$").count();
4868  if dq > 0 && dq % 2 == 1 {
4869    return None;
4870  }
4871  // After LANGUAGE -> language name slot (no kw).
4872  if last == "LANGUAGE" {
4873    return Some(&[
4874      ("plpgsql", "plpgsql -- procedural Postgres"),
4875      ("sql", "sql -- pure-SQL function body"),
4876      ("c", "c -- C extension"),
4877      ("plpython3u", "plpython3u -- Python 3 (untrusted)"),
4878      ("plperl", "plperl -- Perl"),
4879      ("pltcl", "pltcl -- Tcl"),
4880    ]);
4881  }
4882  // After SECURITY -> DEFINER / INVOKER.
4883  if last == "SECURITY" {
4884    return Some(&[
4885      ("DEFINER", "SECURITY DEFINER -- run with definer's privileges"),
4886      ("INVOKER", "SECURITY INVOKER -- run with caller's privileges (default)"),
4887    ]);
4888  }
4889  // After PARALLEL -> SAFE / RESTRICTED / UNSAFE.
4890  if last == "PARALLEL" {
4891    return Some(&[
4892      ("SAFE", "PARALLEL SAFE -- safe for parallel workers"),
4893      ("RESTRICTED", "PARALLEL RESTRICTED -- leader only"),
4894      ("UNSAFE", "PARALLEL UNSAFE -- forbid parallel (default)"),
4895    ]);
4896  }
4897  // After RETURNS -- delegate to existing detector (returns type slot
4898  // suppresses the keyword menu). Don't fire here.
4899  if upper.rfind("RETURNS").map(|p| upper[p + "RETURNS".len()..].trim().is_empty()).unwrap_or(false) {
4900    return None;
4901  }
4902  // Procedure form: after the closing `)` of the args paren -- need the
4903  // paren counts balanced AND no LANGUAGE yet.
4904  // Function form: after RETURNS <type>.
4905  let opens = upper.matches('(').count();
4906  let closes = upper.matches(')').count();
4907  let paren_balanced = opens > 0 && opens == closes;
4908  let has_returns = upper.contains("RETURNS");
4909  if is_proc && !paren_balanced {
4910    return None;
4911  }
4912  if is_fn && !has_returns {
4913    return None;
4914  }
4915  // After RETURNS, ensure the return type token is present.
4916  if is_fn && let Some(p) = upper.rfind("RETURNS") {
4917    let after = upper[p + "RETURNS".len()..].trim();
4918    if after.is_empty() {
4919      return None;
4920    }
4921    // First token after RETURNS = type or SETOF/TABLE. Be liberal --
4922    // if at least one identifier-like token sits there, treat the type
4923    // as committed.
4924    if after.split_ascii_whitespace().next().is_none_or(|t| t.is_empty()) {
4925      return None;
4926    }
4927  }
4928  // After AS -- body literal slot. The PL/pgSQL body handler owns it.
4929  if last == "AS" {
4930    return None;
4931  }
4932  Some(&[
4933    ("LANGUAGE", "LANGUAGE plpgsql|sql|c|plpythonu|... -- pick body language"),
4934    ("AS", "AS $$ <body> $$ -- function body"),
4935    ("COST", "COST <n> -- per-row execution cost hint"),
4936    ("ROWS", "ROWS <n> -- estimated set-returning row count"),
4937    ("VOLATILE", "VOLATILE (default) -- result may change across calls"),
4938    ("STABLE", "STABLE -- same result within a single statement"),
4939    ("IMMUTABLE", "IMMUTABLE -- same args always yield the same result"),
4940    ("STRICT", "STRICT -- skip body when any arg is NULL (synonym of RETURNS NULL ON NULL INPUT)"),
4941    ("CALLED ON NULL INPUT", "CALLED ON NULL INPUT (default)"),
4942    ("RETURNS NULL ON NULL INPUT", "RETURNS NULL ON NULL INPUT (synonym of STRICT)"),
4943    ("LEAKPROOF", "LEAKPROOF -- doesn't leak side-info; required for some RLS views"),
4944    ("SECURITY DEFINER", "SECURITY DEFINER -- run as the role that defined the fn"),
4945    ("SECURITY INVOKER", "SECURITY INVOKER (default)"),
4946    ("PARALLEL", "PARALLEL SAFE | RESTRICTED | UNSAFE"),
4947    ("WINDOW", "WINDOW -- mark this fn as a window fn (C only)"),
4948    ("SET", "SET <param> [TO|=] <value> -- per-call GUC override"),
4949    ("SUPPORT", "SUPPORT <fn> -- planner-support function (C only)"),
4950    ("TRANSFORM", "TRANSFORM FOR TYPE <type> -- attach a TRANSFORM"),
4951    ("DEPENDS ON EXTENSION", "DEPENDS ON EXTENSION <ext>"),
4952  ])
4953}
4954
4955pub(crate) fn alter_function_next_keyword(
4956  source: &str,
4957  offset: TextSize,
4958) -> Option<&'static [(&'static str, &'static str)]> {
4959  if cursor_not_at_ws_boundary(source, offset) {
4960    return None;
4961  }
4962  let (_, upper) = stmt_slice_upper(source, offset);
4963  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
4964  if words.len() < 2 || words[0] != "ALTER" || !matches!(words[1], "FUNCTION" | "PROCEDURE" | "ROUTINE") {
4965    return None;
4966  }
4967  let last = *words.last()?;
4968  if matches!(last, "RENAME" | "OWNER" | "SET" | "RESET" | "DEPENDS" | "PARALLEL" | "SECURITY" | "LANGUAGE" | "SUPPORT")
4969  {
4970    let menu: &[(&str, &str)] = match last {
4971      "RENAME" => &[("TO", "RENAME TO <new_name>")],
4972      "OWNER" => &[("TO", "OWNER TO <role>")],
4973      "SET" => {
4974        &[("SCHEMA", "SET SCHEMA <schema>"), ("ROLE", "SET ROLE <role>"), ("SEARCH_PATH", "SET search_path = '...'")]
4975      },
4976      "RESET" => &[("ALL", "RESET ALL -- restore all session GUCs")],
4977      "DEPENDS" => &[("ON EXTENSION", "DEPENDS ON EXTENSION <ext>")],
4978      "PARALLEL" => &[
4979        ("SAFE", "PARALLEL SAFE -- usable inside parallel workers"),
4980        ("RESTRICTED", "PARALLEL RESTRICTED -- only the leader runs it"),
4981        ("UNSAFE", "PARALLEL UNSAFE -- forces a non-parallel plan"),
4982      ],
4983      "SECURITY" => &[
4984        ("DEFINER", "SECURITY DEFINER -- runs with the function owner's rights"),
4985        ("INVOKER", "SECURITY INVOKER -- runs with the caller's rights (default)"),
4986      ],
4987      "LANGUAGE" => &[
4988        ("sql", "LANGUAGE sql -- pure SQL function body"),
4989        ("plpgsql", "LANGUAGE plpgsql -- PL/pgSQL function body"),
4990        ("c", "LANGUAGE c -- C-language function (requires AS '<obj>')"),
4991        ("plpython3u", "LANGUAGE plpython3u -- PL/Python (untrusted)"),
4992        ("plperl", "LANGUAGE plperl -- PL/Perl (trusted)"),
4993        ("plperlu", "LANGUAGE plperlu -- PL/Perl (untrusted)"),
4994        ("pltcl", "LANGUAGE pltcl -- PL/Tcl"),
4995        ("internal", "LANGUAGE internal -- bound to a builtin symbol"),
4996      ],
4997      "SUPPORT" => &[("support_fn", "SUPPORT <support_fn_name> -- planner support function (advanced)")],
4998      _ => &[],
4999    };
5000    if !menu.is_empty() {
5001      return Some(menu);
5002    }
5003  }
5004  // After the (args) signature -> action menu.
5005  let opens = upper.matches('(').count();
5006  let closes = upper.matches(')').count();
5007  if opens > 0 && opens == closes {
5008    return Some(&[
5009      ("RENAME TO", "RENAME TO <new_name>"),
5010      ("OWNER TO", "OWNER TO <role>"),
5011      ("SET SCHEMA", "SET SCHEMA <schema>"),
5012      ("COST", "COST <n>"),
5013      ("ROWS", "ROWS <n>"),
5014      ("VOLATILE", "VOLATILE / STABLE / IMMUTABLE"),
5015      ("STABLE", "STABLE"),
5016      ("IMMUTABLE", "IMMUTABLE"),
5017      ("STRICT", "STRICT / RETURNS NULL ON NULL INPUT"),
5018      ("LEAKPROOF", "LEAKPROOF"),
5019      ("SECURITY DEFINER", "SECURITY DEFINER"),
5020      ("SECURITY INVOKER", "SECURITY INVOKER"),
5021      ("PARALLEL", "PARALLEL SAFE | RESTRICTED | UNSAFE"),
5022      ("DEPENDS ON EXTENSION", "DEPENDS ON EXTENSION <ext>"),
5023    ]);
5024  }
5025  None
5026}
5027
5028/// ALTER VIEW chain.
5029/// ALTER STATISTICS chain.
5030///   ALTER STATISTICS <name> { RENAME TO <new>
5031///                            | SET SCHEMA <schema>
5032///                            | SET STATISTICS <n>
5033///                            | OWNER TO <role> }
5034pub(crate) fn alter_statistics_next_keyword(
5035  source: &str,
5036  offset: TextSize,
5037) -> Option<&'static [(&'static str, &'static str)]> {
5038  if cursor_not_at_ws_boundary(source, offset) {
5039    return None;
5040  }
5041  let (_, upper) = stmt_slice_upper(source, offset);
5042  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
5043  if words.len() < 2 || words[0] != "ALTER" || words[1] != "STATISTICS" {
5044    return None;
5045  }
5046  let last = *words.last()?;
5047  if matches!(last, "RENAME" | "OWNER" | "SET") {
5048    let menu: &[(&str, &str)] = match last {
5049      "RENAME" => &[("TO", "RENAME TO <new>")],
5050      "OWNER" => &[("TO", "OWNER TO <role>")],
5051      "SET" => {
5052        &[("SCHEMA", "SET SCHEMA <schema>"), ("STATISTICS", "SET STATISTICS <n> -- per-extended-stats target (PG13+)")]
5053      },
5054      _ => &[],
5055    };
5056    if !menu.is_empty() {
5057      return Some(menu);
5058    }
5059  }
5060  if words.len() >= 3 {
5061    return Some(&[
5062      ("RENAME TO", "RENAME TO <new>"),
5063      ("OWNER TO", "OWNER TO <role>"),
5064      ("SET SCHEMA", "SET SCHEMA <schema>"),
5065      ("SET STATISTICS", "SET STATISTICS <n> -- PG13+"),
5066    ]);
5067  }
5068  None
5069}
5070
5071pub(crate) fn alter_view_next_keyword(
5072  source: &str,
5073  offset: TextSize,
5074) -> Option<&'static [(&'static str, &'static str)]> {
5075  if cursor_not_at_ws_boundary(source, offset) {
5076    return None;
5077  }
5078  let (_, upper) = stmt_slice_upper(source, offset);
5079  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
5080  if words.len() < 2 || words[0] != "ALTER" || words[1] != "VIEW" {
5081    return None;
5082  }
5083  let last = *words.last()?;
5084  if matches!(last, "RENAME" | "OWNER" | "SET" | "RESET" | "ALTER") {
5085    let menu: &[(&str, &str)] = match last {
5086      "RENAME" => &[("TO", "RENAME TO <new_name>"), ("COLUMN", "RENAME COLUMN <old> TO <new>")],
5087      "OWNER" => &[("TO", "OWNER TO <role>")],
5088      "SET" => &[("SCHEMA", "SET SCHEMA <schema>"), ("(", "SET ( <storage_param> = <value> )")],
5089      "RESET" => &[("(", "RESET ( <storage_param> )")],
5090      "ALTER" => &[("COLUMN", "ALTER COLUMN <name> SET DEFAULT <expr>")],
5091      _ => &[],
5092    };
5093    if !menu.is_empty() {
5094      return Some(menu);
5095    }
5096  }
5097  if words.len() >= 3 && !matches!(last, "RENAME" | "OWNER" | "SET" | "RESET" | "ALTER") {
5098    return Some(&[
5099      ("RENAME TO", "RENAME TO <new_name>"),
5100      ("RENAME COLUMN", "RENAME COLUMN <old> TO <new>"),
5101      ("OWNER TO", "OWNER TO <role>"),
5102      ("SET SCHEMA", "SET SCHEMA <schema>"),
5103      ("SET (", "SET ( security_barrier = true, ... )"),
5104      ("RESET (", "RESET ( <param> )"),
5105      ("ALTER COLUMN", "ALTER COLUMN <name> SET DEFAULT <expr>"),
5106    ]);
5107  }
5108  None
5109}
5110
5111/// CREATE TABLESPACE chain.
5112///   CREATE TABLESPACE <name> [OWNER <role>] LOCATION '<dir>' [WITH (...)]
5113/// CREATE DATABASE chain. After name, emit the option keywords:
5114///   [WITH] OWNER = <role>
5115///         TEMPLATE = <db>
5116///         ENCODING = '<charset>'
5117///         LOCALE = '<locale>' / LC_COLLATE = ... / LC_CTYPE = ...
5118///         LOCALE_PROVIDER = libc | icu | builtin
5119///         ICU_LOCALE = '<icu>' / ICU_RULES = ...
5120///         COLLATION_VERSION = '<v>'
5121///         BUILTIN_LOCALE = '<l>'
5122///         TABLESPACE = <name>
5123///         ALLOW_CONNECTIONS = true|false
5124///         CONNECTION LIMIT = <n>
5125///         IS_TEMPLATE = true|false
5126///         OID = <n>
5127///         STRATEGY = wal_log | file_copy
5128pub(crate) fn create_database_next_keyword(
5129  source: &str,
5130  offset: TextSize,
5131) -> Option<&'static [(&'static str, &'static str)]> {
5132  if cursor_not_at_ws_boundary(source, offset) {
5133    return None;
5134  }
5135  let (_, upper) = stmt_slice_upper(source, offset);
5136  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
5137  if words.len() < 2 || words[0] != "CREATE" || words[1] != "DATABASE" {
5138    return None;
5139  }
5140  let last = *words.last()?;
5141  // Value slots -- silence.
5142  if matches!(
5143    last,
5144    "OWNER"
5145      | "TEMPLATE"
5146      | "ENCODING"
5147      | "LOCALE"
5148      | "LC_COLLATE"
5149      | "LC_CTYPE"
5150      | "ICU_LOCALE"
5151      | "ICU_RULES"
5152      | "COLLATION_VERSION"
5153      | "BUILTIN_LOCALE"
5154      | "TABLESPACE"
5155      | "OID"
5156  ) {
5157    return None;
5158  }
5159  if last == "LIMIT" && words.contains(&"CONNECTION") {
5160    return None; // user types <n>
5161  }
5162  if last == "WITH" {
5163    // After WITH, same option menu (the WITH keyword is optional in PG).
5164    // Fall through to the regular menu below.
5165  }
5166  if last == "LOCALE_PROVIDER" {
5167    return Some(&[
5168      ("libc", "LOCALE_PROVIDER libc -- default; OS-supplied collation"),
5169      ("icu", "LOCALE_PROVIDER icu -- ICU library collation"),
5170      ("builtin", "LOCALE_PROVIDER builtin -- PG16+ built-in basic locales"),
5171    ]);
5172  }
5173  if last == "ALLOW_CONNECTIONS" || last == "IS_TEMPLATE" {
5174    return Some(&[("true", "true"), ("false", "false")]);
5175  }
5176  if last == "STRATEGY" {
5177    return Some(&[
5178      ("wal_log", "wal_log -- default; copy via WAL records (safe for replicas)"),
5179      ("file_copy", "file_copy -- copy template files directly (faster, but bypasses WAL)"),
5180    ]);
5181  }
5182  if last == "CONNECTION" {
5183    return Some(&[("LIMIT", "CONNECTION LIMIT <n> -- per-database parallel-session cap")]);
5184  }
5185  // Fresh option slot.
5186  if words.len() >= 3 {
5187    return Some(&[
5188      ("WITH", "WITH <options> -- noise word (optional)"),
5189      ("OWNER", "OWNER = <role>"),
5190      ("TEMPLATE", "TEMPLATE = <existing_db>"),
5191      ("ENCODING", "ENCODING = '<charset>'"),
5192      ("LOCALE", "LOCALE = '<locale>' -- shorthand for LC_COLLATE + LC_CTYPE"),
5193      ("LC_COLLATE", "LC_COLLATE = '<locale>'"),
5194      ("LC_CTYPE", "LC_CTYPE = '<locale>'"),
5195      ("LOCALE_PROVIDER", "LOCALE_PROVIDER libc | icu | builtin"),
5196      ("ICU_LOCALE", "ICU_LOCALE = '<icu_locale>'"),
5197      ("ICU_RULES", "ICU_RULES = '<icu_rule_string>' -- PG16+"),
5198      ("BUILTIN_LOCALE", "BUILTIN_LOCALE = 'C' | 'C.UTF-8' -- PG17+"),
5199      ("COLLATION_VERSION", "COLLATION_VERSION = '<v>' -- set the collation-version sentinel"),
5200      ("TABLESPACE", "TABLESPACE = <tablespace>"),
5201      ("ALLOW_CONNECTIONS", "ALLOW_CONNECTIONS true|false"),
5202      ("CONNECTION LIMIT", "CONNECTION LIMIT <n>"),
5203      ("IS_TEMPLATE", "IS_TEMPLATE true|false"),
5204      ("OID", "OID = <n> -- mostly internal; pg_upgrade uses it"),
5205      ("STRATEGY", "STRATEGY wal_log | file_copy"),
5206    ]);
5207  }
5208  None
5209}
5210
5211pub(crate) fn create_tablespace_next_keyword(
5212  source: &str,
5213  offset: TextSize,
5214) -> Option<&'static [(&'static str, &'static str)]> {
5215  if cursor_not_at_ws_boundary(source, offset) {
5216    return None;
5217  }
5218  let (_, upper) = stmt_slice_upper(source, offset);
5219  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
5220  if words.len() < 2 || words[0] != "CREATE" || words[1] != "TABLESPACE" {
5221    return None;
5222  }
5223  let last = *words.last()?;
5224  if last == "OWNER" {
5225    return None; // user types role
5226  }
5227  if last == "LOCATION" {
5228    return None; // user types '<dir>'
5229  }
5230  if words.len() >= 3 && !words.contains(&"LOCATION") {
5231    return Some(&[("OWNER", "OWNER <role>"), ("LOCATION", "LOCATION '<directory_path>' -- required")]);
5232  }
5233  if words.contains(&"LOCATION") && !words.contains(&"WITH") {
5234    return Some(&[("WITH", "WITH ( <param> = <value>, ... )")]);
5235  }
5236  None
5237}
5238
5239/// CREATE AGGREGATE paren options.
5240pub(crate) fn create_aggregate_next_keyword(
5241  source: &str,
5242  offset: TextSize,
5243) -> Option<&'static [(&'static str, &'static str)]> {
5244  let pos: usize = (u32::from(offset) as usize).min(source.len());
5245  let bytes = source.as_bytes();
5246  if pos < bytes.len() && !bytes[pos].is_ascii_whitespace() && bytes[pos] != b'(' && bytes[pos] != b',' {
5247    return None;
5248  }
5249  let (slice_owned, upper) = stmt_slice_upper(source, offset);
5250  let slice = slice_owned.as_str();
5251  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
5252  if words.len() < 2 || words[0] != "CREATE" || words[1] != "AGGREGATE" {
5253    return None;
5254  }
5255  // Must be at fresh-option slot inside the SECOND paren (after arg-types paren).
5256  let opens = slice.matches('(').count();
5257  let closes = slice.matches(')').count();
5258  if opens < 2 || opens - closes != 1 {
5259    return None;
5260  }
5261  let trimmed = slice.trim_end();
5262  let last_char = trimmed.chars().last();
5263  if !matches!(last_char, Some('(') | Some(',')) && !slice.ends_with(char::is_whitespace) {
5264    return None;
5265  }
5266  Some(&[
5267    ("SFUNC", "SFUNC = <transition_fn> -- required"),
5268    ("STYPE", "STYPE = <state_type> -- required"),
5269    ("SSPACE", "SSPACE = <avg_state_bytes>"),
5270    ("FINALFUNC", "FINALFUNC = <final_fn>"),
5271    ("FINALFUNC_EXTRA", "FINALFUNC_EXTRA -- pass extra args to FINALFUNC"),
5272    ("FINALFUNC_MODIFY", "FINALFUNC_MODIFY = READ_ONLY | SHAREABLE | READ_WRITE"),
5273    ("COMBINEFUNC", "COMBINEFUNC = <merge_fn> -- enables parallel aggregation"),
5274    ("SERIALFUNC", "SERIALFUNC = <serialize_fn>"),
5275    ("DESERIALFUNC", "DESERIALFUNC = <deserialize_fn>"),
5276    ("INITCOND", "INITCOND = '<state_initial>'"),
5277    ("MSFUNC", "MSFUNC = <moving_state_fn>"),
5278    ("MINVFUNC", "MINVFUNC = <inverse_state_fn>"),
5279    ("MSTYPE", "MSTYPE = <moving_state_type>"),
5280    ("MSSPACE", "MSSPACE = <avg_bytes>"),
5281    ("MFINALFUNC", "MFINALFUNC = <final_fn>"),
5282    ("MFINALFUNC_EXTRA", "MFINALFUNC_EXTRA"),
5283    ("MFINALFUNC_MODIFY", "MFINALFUNC_MODIFY = ..."),
5284    ("MINITCOND", "MINITCOND = '<state_initial>'"),
5285    ("SORTOP", "SORTOP = <operator>"),
5286    ("PARALLEL", "PARALLEL = SAFE | RESTRICTED | UNSAFE"),
5287    ("HYPOTHETICAL", "HYPOTHETICAL -- ordered-set hypothetical aggregate"),
5288  ])
5289}
5290
5291/// CREATE CAST phase chain.
5292///   CREATE CAST (src AS dst) {WITH FUNCTION <fn>(args) | WITHOUT FUNCTION | WITH INOUT}
5293///     [AS ASSIGNMENT | AS IMPLICIT]
5294pub(crate) fn create_cast_next_keyword(
5295  source: &str,
5296  offset: TextSize,
5297) -> Option<&'static [(&'static str, &'static str)]> {
5298  if cursor_not_at_ws_boundary(source, offset) {
5299    return None;
5300  }
5301  let (_, upper) = stmt_slice_upper(source, offset);
5302  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
5303  if words.len() < 2 || words[0] != "CREATE" || words[1] != "CAST" {
5304    return None;
5305  }
5306  let last = *words.last()?;
5307  if last == "WITH" {
5308    return Some(&[
5309      ("FUNCTION", "WITH FUNCTION <fn>(args) -- use this function"),
5310      ("INOUT", "WITH INOUT -- use IO conversion"),
5311    ]);
5312  }
5313  if last == "WITHOUT" {
5314    return Some(&[("FUNCTION", "WITHOUT FUNCTION -- binary-compatible cast")]);
5315  }
5316  if last == "AS" {
5317    return Some(&[
5318      ("ASSIGNMENT", "AS ASSIGNMENT -- automatic in assignments"),
5319      ("IMPLICIT", "AS IMPLICIT -- automatic everywhere"),
5320    ]);
5321  }
5322  // After the (src AS dst) header -> WITH | WITHOUT.
5323  let closes = upper.matches(')').count();
5324  let opens = upper.matches('(').count();
5325  if opens > 0 && closes == opens && !words.contains(&"WITH") && !words.contains(&"WITHOUT") {
5326    return Some(&[
5327      ("WITH FUNCTION", "WITH FUNCTION <fn>(args)"),
5328      ("WITHOUT FUNCTION", "WITHOUT FUNCTION -- binary-compatible"),
5329      ("WITH INOUT", "WITH INOUT -- IO conversion"),
5330    ]);
5331  }
5332  // Trailing AS slot once WITH/WITHOUT chosen.
5333  if (words.contains(&"WITH") || words.contains(&"WITHOUT")) && !words.contains(&"AS") {
5334    return Some(&[
5335      ("AS ASSIGNMENT", "AS ASSIGNMENT -- automatic in assignments"),
5336      ("AS IMPLICIT", "AS IMPLICIT -- automatic everywhere"),
5337    ]);
5338  }
5339  None
5340}
5341
5342/// CREATE RULE phase chain.
5343///   CREATE [OR REPLACE] RULE <name> AS ON {SELECT|INSERT|UPDATE|DELETE}
5344///       TO <table> [WHERE <expr>] DO [ALSO|INSTEAD] {NOTHING | <command>}
5345pub(crate) fn create_rule_next_keyword(
5346  source: &str,
5347  offset: TextSize,
5348) -> Option<&'static [(&'static str, &'static str)]> {
5349  if cursor_not_at_ws_boundary(source, offset) {
5350    return None;
5351  }
5352  let (_, upper) = stmt_slice_upper(source, offset);
5353  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
5354  let rule_idx = words.iter().position(|w| *w == "RULE")?;
5355  if !words[..rule_idx].iter().all(|w| matches!(*w, "CREATE" | "OR" | "REPLACE")) || words[0] != "CREATE" {
5356    return None;
5357  }
5358  let tail = &words[rule_idx + 1..];
5359  if tail.is_empty() {
5360    return None;
5361  }
5362  let last = *tail.last()?;
5363  if last == "AS" {
5364    return Some(&[("ON", "AS ON {SELECT | INSERT | UPDATE | DELETE}")]);
5365  }
5366  if last == "ON" {
5367    return Some(&[("SELECT", "ON SELECT"), ("INSERT", "ON INSERT"), ("UPDATE", "ON UPDATE"), ("DELETE", "ON DELETE")]);
5368  }
5369  if matches!(last, "SELECT" | "INSERT" | "UPDATE" | "DELETE") {
5370    return Some(&[("TO", "TO <table>")]);
5371  }
5372  if last == "DO" {
5373    return Some(&[
5374      ("ALSO", "DO ALSO <command>"),
5375      ("INSTEAD", "DO INSTEAD {NOTHING | <command>}"),
5376      ("NOTHING", "DO NOTHING"),
5377    ]);
5378  }
5379  if last == "INSTEAD" {
5380    return Some(&[
5381      ("NOTHING", "INSTEAD NOTHING"),
5382      ("SELECT", "INSTEAD SELECT ..."),
5383      ("INSERT", "INSTEAD INSERT ..."),
5384      ("UPDATE", "INSTEAD UPDATE ..."),
5385      ("DELETE", "INSTEAD DELETE ..."),
5386    ]);
5387  }
5388  if tail.contains(&"TO") && !tail.contains(&"DO") {
5389    return Some(&[("WHERE", "WHERE <predicate>"), ("DO", "DO {ALSO|INSTEAD} {NOTHING | <command>}")]);
5390  }
5391  None
5392}
5393
5394/// CREATE STATISTICS phase chain.
5395///   CREATE STATISTICS [IF NOT EXISTS] <name> [(<kind>[, ...])] ON <col_list> FROM <table>
5396/// CREATE TABLE post-body trailing clauses:
5397///   CREATE TABLE t (...) <cursor>
5398///     -> INHERITS / PARTITION BY / USING / WITH / WITHOUT OIDS /
5399///        ON COMMIT / TABLESPACE
5400pub(crate) fn create_table_post_body_next_keyword(
5401  source: &str,
5402  offset: TextSize,
5403) -> Option<&'static [(&'static str, &'static str)]> {
5404  if cursor_not_at_ws_boundary(source, offset) {
5405    return None;
5406  }
5407  let (slice_owned, upper) = stmt_slice_upper(source, offset);
5408  let slice = slice_owned.as_str();
5409  let trimmed = upper.trim_start();
5410  if !trimmed.starts_with("CREATE TABLE")
5411    && !trimmed.starts_with("CREATE TEMP TABLE")
5412    && !trimmed.starts_with("CREATE TEMPORARY TABLE")
5413    && !trimmed.starts_with("CREATE UNLOGGED TABLE")
5414    && !trimmed.starts_with("CREATE GLOBAL TABLE")
5415    && !trimmed.starts_with("CREATE LOCAL TABLE")
5416  {
5417    return None;
5418  }
5419  // Body paren must have closed.
5420  let opens = slice.matches('(').count();
5421  let closes = slice.matches(')').count();
5422  if opens == 0 || opens != closes {
5423    return None;
5424  }
5425  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
5426  let last = *words.last()?;
5427  // After INHERITS / PARTITION / WITH / WITHOUT / USING / ON / TABLESPACE,
5428  // continue the sub-chain.
5429  if last == "INHERITS" {
5430    return Some(&[("(", "( <parent_table>[, ...] )")]);
5431  }
5432  if last == "PARTITION" {
5433    return Some(&[("BY", "PARTITION BY { RANGE | LIST | HASH } (<cols>)")]);
5434  }
5435  if last == "WITHOUT" {
5436    return Some(&[("OIDS", "WITHOUT OIDS -- legacy; no effect in PG12+")]);
5437  }
5438  if last == "WITH" {
5439    return Some(&[
5440      ("OIDS", "WITH OIDS -- legacy; rejected in PG12+"),
5441      ("(", "( fillfactor=<n>, autovacuum_<param>=<v>, ... )"),
5442    ]);
5443  }
5444  if last == "ON" {
5445    return Some(&[("COMMIT", "ON COMMIT { PRESERVE ROWS | DELETE ROWS | DROP }")]);
5446  }
5447  if last == "COMMIT" && words.contains(&"ON") {
5448    return Some(&[
5449      ("PRESERVE ROWS", "ON COMMIT PRESERVE ROWS (default for TEMP)"),
5450      ("DELETE ROWS", "ON COMMIT DELETE ROWS -- empty rows at COMMIT"),
5451      ("DROP", "ON COMMIT DROP -- drop the temp table at COMMIT"),
5452    ]);
5453  }
5454  // Fresh trailing slot menu.
5455  Some(&[
5456    ("INHERITS", "INHERITS ( <parent>[, ...] )"),
5457    ("PARTITION BY", "PARTITION BY { RANGE | LIST | HASH } (<cols>)"),
5458    ("USING", "USING <access_method>"),
5459    ("WITH", "WITH ( fillfactor=<n>, autovacuum_<param>=<v>, ... )"),
5460    ("WITHOUT OIDS", "WITHOUT OIDS -- legacy"),
5461    ("ON COMMIT", "ON COMMIT { PRESERVE ROWS | DELETE ROWS | DROP }"),
5462    ("TABLESPACE", "TABLESPACE <name>"),
5463  ])
5464}
5465
5466/// EXCLUDE constraint chain inside CREATE TABLE body:
5467///   EXCLUDE <cursor>                  -> USING / (
5468///   EXCLUDE USING <cursor>            -> btree / gist / spgist / brin (index methods)
5469///   EXCLUDE USING gist (<cursor>      -> column or expression (catalog)
5470///   EXCLUDE ... WITH <cursor>         -> operator placeholder (no kw)
5471pub(crate) fn exclude_constraint_next_keyword(
5472  source: &str,
5473  offset: TextSize,
5474) -> Option<&'static [(&'static str, &'static str)]> {
5475  if cursor_not_at_ws_boundary(source, offset) {
5476    return None;
5477  }
5478  let (_, upper) = stmt_slice_upper(source, offset);
5479  if !upper.contains("EXCLUDE") {
5480    return None;
5481  }
5482  if !upper.contains("CREATE TABLE") && !upper.contains("ALTER TABLE") {
5483    return None;
5484  }
5485  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
5486  let last = *words.last()?;
5487  if last == "EXCLUDE" {
5488    return Some(&[("USING", "USING <index_method>"), ("(", "( <col> WITH <op>, ... ) -- exclusion list")]);
5489  }
5490  if last == "USING" && words.contains(&"EXCLUDE") {
5491    return Some(&[
5492      ("gist", "gist -- generalized search tree (recommended for ranges)"),
5493      ("spgist", "spgist -- space-partitioned GiST"),
5494      ("btree", "btree -- only for equality EXCLUDE"),
5495      ("brin", "brin -- block range index"),
5496    ]);
5497  }
5498  None
5499}
5500
5501pub(crate) fn create_statistics_next_keyword(
5502  source: &str,
5503  offset: TextSize,
5504) -> Option<&'static [(&'static str, &'static str)]> {
5505  let pos: usize = (u32::from(offset) as usize).min(source.len());
5506  let bytes = source.as_bytes();
5507  if pos < bytes.len() && !bytes[pos].is_ascii_whitespace() && bytes[pos] != b'(' && bytes[pos] != b',' {
5508    return None;
5509  }
5510  let (slice_owned, upper) = stmt_slice_upper(source, offset);
5511  let slice = slice_owned.as_str();
5512  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
5513  if words.len() < 2 || words[0] != "CREATE" || words[1] != "STATISTICS" {
5514    return None;
5515  }
5516  let last = *words.last()?;
5517  let opens = slice.matches('(').count();
5518  let closes = slice.matches(')').count();
5519  if opens > closes {
5520    // Inside the kinds paren `(<kind>[, ...])`.
5521    let trimmed = slice.trim_end();
5522    let last_char = trimmed.chars().last();
5523    if matches!(last_char, Some('(') | Some(',')) || slice.ends_with(char::is_whitespace) {
5524      return Some(&[
5525        ("ndistinct", "ndistinct -- multi-column n-distinct estimate"),
5526        ("dependencies", "dependencies -- functional-dependency stats"),
5527        ("mcv", "mcv -- multi-column most-common-values list"),
5528      ]);
5529    }
5530  }
5531  if last == "ON" {
5532    return None; // column list slot
5533  }
5534  if last == "FROM" {
5535    return None; // table slot
5536  }
5537  if words.len() >= 3 && !words.contains(&"ON") && !words.contains(&"FROM") {
5538    return Some(&[("(", "( ndistinct, dependencies, mcv )"), ("ON", "ON <col_or_expr>[, ...]")]);
5539  }
5540  if words.contains(&"ON") && !words.contains(&"FROM") {
5541    return Some(&[("FROM", "FROM <table>")]);
5542  }
5543  None
5544}
5545
5546/// CREATE TYPE phase chain.
5547///   CREATE TYPE <name> AS (col type, ...)
5548///                     | AS ENUM ('a', 'b', ...)
5549///                     | AS RANGE (SUBTYPE = ..., ...)
5550///                     | (INPUT = ..., OUTPUT = ..., LIKE = ..., ...)
5551pub(crate) fn create_type_next_keyword(
5552  source: &str,
5553  offset: TextSize,
5554) -> Option<&'static [(&'static str, &'static str)]> {
5555  if cursor_not_at_ws_boundary(source, offset) {
5556    return None;
5557  }
5558  let (slice_owned, upper) = stmt_slice_upper(source, offset);
5559  let slice = slice_owned.as_str();
5560  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
5561  if words.len() < 2 || words[0] != "CREATE" || words[1] != "TYPE" {
5562    return None;
5563  }
5564  let n = words.len();
5565  let last = words[n - 1];
5566  // CREATE TYPE name <cursor> -> AS or `(` for base types.
5567  if n == 3 {
5568    return Some(&[
5569      ("AS", "AS ( <col> <type>, ... ) -- composite type"),
5570      ("AS ENUM", "AS ENUM ('a', 'b', ...) -- discrete labels"),
5571      ("AS RANGE", "AS RANGE ( SUBTYPE = <type>, ... )"),
5572      ("(", "( INPUT = ..., OUTPUT = ..., LIKE = ..., ... ) -- base type"),
5573    ]);
5574  }
5575  if last == "AS" {
5576    return Some(&[
5577      ("ENUM", "AS ENUM ('a', 'b', ...)"),
5578      ("RANGE", "AS RANGE ( SUBTYPE = ... )"),
5579      ("(", "AS ( <col> <type>, ... ) -- composite"),
5580    ]);
5581  }
5582  // Inside `AS RANGE ( <cursor>` -> option-name keywords.
5583  if upper.contains("AS RANGE") && slice.matches('(').count() > slice.matches(')').count() {
5584    let trimmed = slice.trim_end();
5585    let last_char = trimmed.chars().last();
5586    if matches!(last_char, Some('(') | Some(',')) || slice.ends_with(char::is_whitespace) {
5587      return Some(&[
5588        ("SUBTYPE", "SUBTYPE = <type>"),
5589        ("SUBTYPE_OPCLASS", "SUBTYPE_OPCLASS = <opclass>"),
5590        ("COLLATION", "COLLATION = <collation>"),
5591        ("CANONICAL", "CANONICAL = <function>"),
5592        ("SUBTYPE_DIFF", "SUBTYPE_DIFF = <function>"),
5593        ("MULTIRANGE_TYPE_NAME", "MULTIRANGE_TYPE_NAME = <name>"),
5594      ]);
5595    }
5596  }
5597  // Inside the base-type paren `CREATE TYPE name ( <cursor>`.
5598  if !upper.contains(" AS ") && slice.matches('(').count() > slice.matches(')').count() {
5599    let trimmed = slice.trim_end();
5600    let last_char = trimmed.chars().last();
5601    if matches!(last_char, Some('(') | Some(',')) || slice.ends_with(char::is_whitespace) {
5602      return Some(&[
5603        ("INPUT", "INPUT = <function>"),
5604        ("OUTPUT", "OUTPUT = <function>"),
5605        ("RECEIVE", "RECEIVE = <function>"),
5606        ("SEND", "SEND = <function>"),
5607        ("TYPMOD_IN", "TYPMOD_IN = <function>"),
5608        ("TYPMOD_OUT", "TYPMOD_OUT = <function>"),
5609        ("INTERNALLENGTH", "INTERNALLENGTH = <n>"),
5610        ("PASSEDBYVALUE", "PASSEDBYVALUE"),
5611        ("ALIGNMENT", "ALIGNMENT = <type>"),
5612        ("STORAGE", "STORAGE = plain | external | extended | main"),
5613        ("LIKE", "LIKE = <existing_type>"),
5614        ("CATEGORY", "CATEGORY = '<char>'"),
5615        ("PREFERRED", "PREFERRED = true | false"),
5616        ("DEFAULT", "DEFAULT = <default_value>"),
5617        ("ELEMENT", "ELEMENT = <type> -- array element"),
5618        ("DELIMITER", "DELIMITER = '<char>'"),
5619        ("COLLATABLE", "COLLATABLE = true | false"),
5620      ]);
5621    }
5622  }
5623  None
5624}
5625
5626/// CREATE EVENT TRIGGER phase chain.
5627///   CREATE EVENT TRIGGER <name> ON <event>
5628///     [WHEN <filter_var> IN ('tag', ...) AND ...]
5629///     EXECUTE FUNCTION <fn>()
5630pub(crate) fn create_event_trigger_next_keyword(
5631  source: &str,
5632  offset: TextSize,
5633) -> Option<&'static [(&'static str, &'static str)]> {
5634  if cursor_not_at_ws_boundary(source, offset) {
5635    return None;
5636  }
5637  let (_, upper) = stmt_slice_upper(source, offset);
5638  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
5639  if words.len() < 3 || words[0] != "CREATE" || words[1] != "EVENT" || words[2] != "TRIGGER" {
5640    return None;
5641  }
5642  let last = *words.last()?;
5643  if last == "ON" {
5644    return Some(&[
5645      ("ddl_command_start", "ddl_command_start -- fires before a DDL"),
5646      ("ddl_command_end", "ddl_command_end -- fires after a DDL"),
5647      ("table_rewrite", "table_rewrite -- fires when a DDL rewrites a table"),
5648      ("sql_drop", "sql_drop -- fires after a DROP"),
5649      ("login", "login -- fires on session start (PG17+)"),
5650    ]);
5651  }
5652  if last == "EXECUTE" {
5653    return Some(&[("FUNCTION", "EXECUTE FUNCTION <fn>()"), ("PROCEDURE", "EXECUTE PROCEDURE <fn>()")]);
5654  }
5655  if last == "WHEN" {
5656    return Some(&[("tag", "tag IN ('CREATE TABLE', ...) -- filter by command tag")]);
5657  }
5658  // WHEN tag <cursor> -> IN
5659  if last == "TAG" && words.contains(&"WHEN") {
5660    return Some(&[("IN", "IN ('<cmd_tag1>', '<cmd_tag2>', ...)")]);
5661  }
5662  // WHEN tag IN <cursor> -> (
5663  if last == "IN" && words.contains(&"WHEN") {
5664    return Some(&[("(", "( '<cmd_tag1>', '<cmd_tag2>', ... )")]);
5665  }
5666  // WHEN tag IN ( <cursor> ) -> common command-tag suggestions
5667  if (last == "(" || last.starts_with("('")) && words.contains(&"IN") && words.contains(&"WHEN") {
5668    return Some(&[
5669      ("'CREATE TABLE'", "'CREATE TABLE'"),
5670      ("'DROP TABLE'", "'DROP TABLE'"),
5671      ("'ALTER TABLE'", "'ALTER TABLE'"),
5672      ("'CREATE INDEX'", "'CREATE INDEX'"),
5673      ("'DROP INDEX'", "'DROP INDEX'"),
5674      ("'CREATE FUNCTION'", "'CREATE FUNCTION'"),
5675      ("'DROP FUNCTION'", "'DROP FUNCTION'"),
5676      ("'CREATE TRIGGER'", "'CREATE TRIGGER'"),
5677      ("'CREATE VIEW'", "'CREATE VIEW'"),
5678      ("'CREATE SCHEMA'", "'CREATE SCHEMA'"),
5679      ("'CREATE EXTENSION'", "'CREATE EXTENSION'"),
5680    ]);
5681  }
5682  if words.len() >= 5 && words.contains(&"ON") && !words.contains(&"EXECUTE") {
5683    return Some(&[("WHEN", "WHEN tag IN ('CREATE TABLE', ...) -- filter"), ("EXECUTE", "EXECUTE FUNCTION <fn>()")]);
5684  }
5685  if words.len() == 4 {
5686    return Some(&[("ON", "ON <event>")]);
5687  }
5688  None
5689}
5690
5691/// CREATE SERVER / CREATE FOREIGN DATA WRAPPER phase chain.
5692/// CREATE LANGUAGE chain.
5693///   CREATE [OR REPLACE] [TRUSTED] [PROCEDURAL] LANGUAGE <name>
5694///     [ HANDLER <call_handler> [ INLINE <inline_handler> ] [ VALIDATOR <fn> ] ]
5695pub(crate) fn create_language_next_keyword(
5696  source: &str,
5697  offset: TextSize,
5698) -> Option<&'static [(&'static str, &'static str)]> {
5699  if cursor_not_at_ws_boundary(source, offset) {
5700    return None;
5701  }
5702  let (_, upper) = stmt_slice_upper(source, offset);
5703  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
5704  let lang_idx = words.iter().position(|w| *w == "LANGUAGE")?;
5705  if !words[..lang_idx].iter().all(|w| matches!(*w, "CREATE" | "OR" | "REPLACE" | "TRUSTED" | "PROCEDURAL"))
5706    || words[0] != "CREATE"
5707  {
5708    return None;
5709  }
5710  let tail = &words[lang_idx + 1..];
5711  let last = tail.last().copied();
5712  // Right after LANGUAGE -> user types name; suggest TRUSTED/PROCEDURAL as
5713  // forward-looking modifiers won't help. Skip until name committed.
5714  if tail.is_empty() {
5715    return None;
5716  }
5717  if tail.len() == 1 {
5718    // After language name -> HANDLER / nothing.
5719    return Some(&[
5720      ("HANDLER", "HANDLER <call_handler_fn>"),
5721      ("INLINE", "INLINE <inline_handler_fn>"),
5722      ("VALIDATOR", "VALIDATOR <validator_fn>"),
5723    ]);
5724  }
5725  if last == Some("HANDLER") || last == Some("INLINE") || last == Some("VALIDATOR") {
5726    return None; // user types fn name
5727  }
5728  // After a fn name in the chain -> next optional clause.
5729  let mut menu: Vec<(&str, &str)> = Vec::new();
5730  if !tail.contains(&"INLINE") {
5731    menu.push(("INLINE", "INLINE <inline_handler_fn>"));
5732  }
5733  if !tail.contains(&"VALIDATOR") {
5734    menu.push(("VALIDATOR", "VALIDATOR <validator_fn>"));
5735  }
5736  if menu.is_empty() {
5737    return None;
5738  }
5739  // Return a static slice -- emit both (validator second) regardless.
5740  Some(&[("INLINE", "INLINE <inline_handler_fn>"), ("VALIDATOR", "VALIDATOR <validator_fn>")])
5741}
5742
5743/// ALTER LANGUAGE chain.
5744///   ALTER [PROCEDURAL] LANGUAGE <name> RENAME TO <new_name>
5745///   ALTER [PROCEDURAL] LANGUAGE <name> OWNER TO <role>
5746pub(crate) fn alter_language_next_keyword(
5747  source: &str,
5748  offset: TextSize,
5749) -> Option<&'static [(&'static str, &'static str)]> {
5750  if cursor_not_at_ws_boundary(source, offset) {
5751    return None;
5752  }
5753  let (_, upper) = stmt_slice_upper(source, offset);
5754  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
5755  let lang_idx = words.iter().position(|w| *w == "LANGUAGE")?;
5756  if !words[..lang_idx].iter().all(|w| matches!(*w, "ALTER" | "PROCEDURAL")) || words[0] != "ALTER" {
5757    return None;
5758  }
5759  let tail = &words[lang_idx + 1..];
5760  if tail.is_empty() {
5761    return None;
5762  }
5763  let last = *tail.last()?;
5764  if matches!(last, "RENAME" | "OWNER") {
5765    let menu: &[(&str, &str)] = match last {
5766      "RENAME" => &[("TO", "RENAME TO <new_name>")],
5767      "OWNER" => &[("TO", "OWNER TO <role>")],
5768      _ => &[],
5769    };
5770    if !menu.is_empty() {
5771      return Some(menu);
5772    }
5773  }
5774  if !tail.is_empty() && last != "TO" {
5775    return Some(&[("RENAME TO", "RENAME TO <new_name>"), ("OWNER TO", "OWNER TO <role>")]);
5776  }
5777  None
5778}
5779
5780/// ALTER SERVER chain.
5781///   ALTER SERVER <name> [VERSION '<v>'] [OPTIONS (ADD|SET|DROP <k> ['<v>'])]
5782///                       | RENAME TO <new_name>
5783///                       | OWNER TO <role>
5784pub(crate) fn alter_server_next_keyword(
5785  source: &str,
5786  offset: TextSize,
5787) -> Option<&'static [(&'static str, &'static str)]> {
5788  if cursor_not_at_ws_boundary(source, offset) {
5789    return None;
5790  }
5791  let (slice_owned, upper) = stmt_slice_upper(source, offset);
5792  let slice = slice_owned.as_str();
5793  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
5794  if words.len() < 2 || words[0] != "ALTER" || words[1] != "SERVER" {
5795    return None;
5796  }
5797  let last = *words.last()?;
5798  if matches!(last, "RENAME" | "OWNER") {
5799    return Some(match last {
5800      "RENAME" => &[("TO", "RENAME TO <new_name>")],
5801      "OWNER" => &[("TO", "OWNER TO <role>")],
5802      _ => &[],
5803    });
5804  }
5805  if last == "VERSION" {
5806    return None; // user types '<version>'
5807  }
5808  if last == "OPTIONS" {
5809    return Some(&[("(", "( ADD|SET|DROP <key> '<val>'[, ...] )")]);
5810  }
5811  let opens = slice.matches('(').count();
5812  let closes = slice.matches(')').count();
5813  if opens > closes {
5814    let trimmed = slice.trim_end();
5815    let last_char = trimmed.chars().last();
5816    if matches!(last_char, Some('(') | Some(',')) || slice.ends_with(char::is_whitespace) {
5817      return Some(&[("ADD", "ADD <key> '<value>'"), ("SET", "SET <key> '<value>'"), ("DROP", "DROP <key>")]);
5818    }
5819  }
5820  if words.len() >= 3 {
5821    return Some(&[
5822      ("VERSION", "VERSION '<version>'"),
5823      ("OPTIONS", "OPTIONS ( ADD|SET|DROP <key> '<val>'[, ...] )"),
5824      ("RENAME TO", "RENAME TO <new_name>"),
5825      ("OWNER TO", "OWNER TO <role>"),
5826    ]);
5827  }
5828  None
5829}
5830
5831/// ALTER FOREIGN DATA WRAPPER chain.
5832///   ALTER FOREIGN DATA WRAPPER <name>
5833///       [HANDLER <fn> | NO HANDLER]
5834///       [VALIDATOR <fn> | NO VALIDATOR]
5835///       [OPTIONS (ADD|SET|DROP <k> ['<v>']...)]
5836///       | RENAME TO <new_name>
5837///       | OWNER TO <role>
5838pub(crate) fn alter_fdw_next_keyword(
5839  source: &str,
5840  offset: TextSize,
5841) -> Option<&'static [(&'static str, &'static str)]> {
5842  if cursor_not_at_ws_boundary(source, offset) {
5843    return None;
5844  }
5845  let (slice_owned, upper) = stmt_slice_upper(source, offset);
5846  let slice = slice_owned.as_str();
5847  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
5848  if words.len() < 5 || words[0] != "ALTER" || words[1] != "FOREIGN" || words[2] != "DATA" || words[3] != "WRAPPER" {
5849    return None;
5850  }
5851  let last = *words.last()?;
5852  if matches!(last, "RENAME" | "OWNER") {
5853    return Some(match last {
5854      "RENAME" => &[("TO", "RENAME TO <new_name>")],
5855      "OWNER" => &[("TO", "OWNER TO <role>")],
5856      _ => &[],
5857    });
5858  }
5859  if matches!(last, "HANDLER" | "VALIDATOR") {
5860    return None; // user types fn name
5861  }
5862  if last == "NO" && (words.contains(&"WRAPPER") || words.contains(&"DATA")) {
5863    return Some(&[("HANDLER", "NO HANDLER"), ("VALIDATOR", "NO VALIDATOR")]);
5864  }
5865  if last == "OPTIONS" {
5866    return Some(&[("(", "( ADD|SET|DROP <key> '<val>'[, ...] )")]);
5867  }
5868  let opens = slice.matches('(').count();
5869  let closes = slice.matches(')').count();
5870  if opens > closes {
5871    let trimmed = slice.trim_end();
5872    let last_char = trimmed.chars().last();
5873    if matches!(last_char, Some('(') | Some(',')) || slice.ends_with(char::is_whitespace) {
5874      return Some(&[("ADD", "ADD <key> '<value>'"), ("SET", "SET <key> '<value>'"), ("DROP", "DROP <key>")]);
5875    }
5876  }
5877  if words.len() >= 5 {
5878    return Some(&[
5879      ("HANDLER", "HANDLER <function>"),
5880      ("NO HANDLER", "NO HANDLER"),
5881      ("VALIDATOR", "VALIDATOR <function>"),
5882      ("NO VALIDATOR", "NO VALIDATOR"),
5883      ("OPTIONS", "OPTIONS ( ADD|SET|DROP <key> '<val>'[, ...] )"),
5884      ("RENAME TO", "RENAME TO <new_name>"),
5885      ("OWNER TO", "OWNER TO <role>"),
5886    ]);
5887  }
5888  None
5889}
5890
5891pub(crate) fn create_server_next_keyword(
5892  source: &str,
5893  offset: TextSize,
5894) -> Option<&'static [(&'static str, &'static str)]> {
5895  if cursor_not_at_ws_boundary(source, offset) {
5896    return None;
5897  }
5898  let (_, upper) = stmt_slice_upper(source, offset);
5899  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
5900  let is_server = words.len() >= 2 && words[0] == "CREATE" && words[1] == "SERVER";
5901  let is_fdw =
5902    words.len() >= 5 && words[0] == "CREATE" && words[1] == "FOREIGN" && words[2] == "DATA" && words[3] == "WRAPPER";
5903  if !is_server && !is_fdw {
5904    return None;
5905  }
5906  let last = *words.last()?;
5907  if is_server {
5908    if last == "TYPE" {
5909      return None; // user types a type literal
5910    }
5911    if last == "VERSION" {
5912      return None;
5913    }
5914    if last == "WRAPPER" && words.contains(&"FOREIGN") {
5915      return None; // user types the FDW name
5916    }
5917    return Some(&[
5918      ("TYPE", "TYPE '<type>'"),
5919      ("VERSION", "VERSION '<version>'"),
5920      ("FOREIGN DATA WRAPPER", "FOREIGN DATA WRAPPER <fdw_name>"),
5921      ("OPTIONS", "OPTIONS (key 'value', ...)"),
5922    ]);
5923  }
5924  if is_fdw {
5925    return Some(&[
5926      ("HANDLER", "HANDLER <function>"),
5927      ("NO HANDLER", "NO HANDLER -- placeholder, can't be used"),
5928      ("VALIDATOR", "VALIDATOR <function>"),
5929      ("NO VALIDATOR", "NO VALIDATOR"),
5930      ("OPTIONS", "OPTIONS (key 'value', ...)"),
5931    ]);
5932  }
5933  None
5934}
5935
5936/// CREATE OPERATOR phase chain. PG syntax:
5937///   CREATE OPERATOR <op> ( FUNCTION = <fn>, LEFTARG = <type>,
5938///       RIGHTARG = <type>, [COMMUTATOR = OPERATOR(<schema>.<op>)],
5939///       [NEGATOR = ...], [RESTRICT = <selfn>], [JOIN = <joinfn>],
5940///       [HASHES], [MERGES] )
5941pub(crate) fn create_operator_next_keyword(
5942  source: &str,
5943  offset: TextSize,
5944) -> Option<&'static [(&'static str, &'static str)]> {
5945  let pos: usize = (u32::from(offset) as usize).min(source.len());
5946  let bytes = source.as_bytes();
5947  if pos < bytes.len() && !bytes[pos].is_ascii_whitespace() && bytes[pos] != b',' && bytes[pos] != b'(' {
5948    return None;
5949  }
5950  let (slice_owned, upper) = stmt_slice_upper(source, offset);
5951  let slice = slice_owned.as_str();
5952  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
5953  if words.len() < 2 || words[0] != "CREATE" || words[1] != "OPERATOR" {
5954    return None;
5955  }
5956  // Cursor must sit inside the paren options list.
5957  let opens = slice.matches('(').count();
5958  let closes = slice.matches(')').count();
5959  if opens == 0 || opens <= closes {
5960    return None;
5961  }
5962  // Either at a fresh option-name slot (right after `(` or `,`).
5963  let trimmed = slice.trim_end();
5964  let last_char = trimmed.chars().last();
5965  if matches!(last_char, Some('(') | Some(',')) || slice.ends_with(char::is_whitespace) {
5966    return Some(&[
5967      ("FUNCTION", "FUNCTION = <fn_name>"),
5968      ("LEFTARG", "LEFTARG = <type>"),
5969      ("RIGHTARG", "RIGHTARG = <type>"),
5970      ("COMMUTATOR", "COMMUTATOR = OPERATOR(<schema>.<op>)"),
5971      ("NEGATOR", "NEGATOR = OPERATOR(<schema>.<op>)"),
5972      ("RESTRICT", "RESTRICT = <selectivity_fn>"),
5973      ("JOIN", "JOIN = <join_selectivity_fn>"),
5974      ("HASHES", "HASHES -- supports hash join"),
5975      ("MERGES", "MERGES -- supports merge join"),
5976    ]);
5977  }
5978  None
5979}
5980
5981/// CREATE DOMAIN phase chain.
5982///   CREATE DOMAIN <name> [AS] <basetype> [DEFAULT <expr>] [<constraint>...]
5983///   where <constraint> = [CONSTRAINT <name>] {NOT NULL | NULL | CHECK (<expr>)}
5984pub(crate) fn create_domain_next_keyword(
5985  source: &str,
5986  offset: TextSize,
5987) -> Option<&'static [(&'static str, &'static str)]> {
5988  if cursor_not_at_ws_boundary(source, offset) {
5989    return None;
5990  }
5991  let (_, upper) = stmt_slice_upper(source, offset);
5992  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
5993  if words.len() < 2 || words[0] != "CREATE" || words[1] != "DOMAIN" {
5994    return None;
5995  }
5996  let last = *words.last()?;
5997  // `CREATE DOMAIN name <cursor>` -> AS or constraints.
5998  if words.len() == 3 {
5999    return Some(&[
6000      ("AS", "AS <base_type>"),
6001      ("CHECK", "CHECK ( VALUE > 0 )"),
6002      ("DEFAULT", "DEFAULT <expr>"),
6003      ("NOT NULL", "NOT NULL"),
6004    ]);
6005  }
6006  if last == "AS" {
6007    return None; // user types the base type
6008  }
6009  // After the base type or after a constraint, expect more constraints.
6010  if matches!(last, "NULL" | "DEFAULT" | "CHECK") {
6011    return None; // expression / value slot
6012  }
6013  Some(&[
6014    ("CONSTRAINT", "CONSTRAINT <name> CHECK (...)"),
6015    ("CHECK", "CHECK ( VALUE > 0 )"),
6016    ("NOT NULL", "NOT NULL"),
6017    ("NULL", "NULL -- explicit nullable (default)"),
6018    ("DEFAULT", "DEFAULT <expr>"),
6019  ])
6020}
6021
6022/// CREATE COLLATION phase chain.
6023///   CREATE COLLATION [IF NOT EXISTS] <name> ( LOCALE = '...' | LC_COLLATE = '...', ... )
6024///   CREATE COLLATION <name> FROM <existing>
6025pub(crate) fn create_collation_next_keyword(
6026  source: &str,
6027  offset: TextSize,
6028) -> Option<&'static [(&'static str, &'static str)]> {
6029  let pos: usize = (u32::from(offset) as usize).min(source.len());
6030  let bytes = source.as_bytes();
6031  if pos < bytes.len() && !bytes[pos].is_ascii_whitespace() && bytes[pos] != b'(' && bytes[pos] != b',' {
6032    return None;
6033  }
6034  let (slice_owned, upper) = stmt_slice_upper(source, offset);
6035  let slice = slice_owned.as_str();
6036  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
6037  if words.len() < 2 || words[0] != "CREATE" || words[1] != "COLLATION" {
6038    return None;
6039  }
6040  // Cursor inside the paren options list -> emit option-name keywords.
6041  let opens = slice.matches('(').count();
6042  let closes = slice.matches(')').count();
6043  if opens > 0 && opens > closes {
6044    let trimmed = slice.trim_end();
6045    let last_char = trimmed.chars().last();
6046    if matches!(last_char, Some('(') | Some(',')) || slice.ends_with(char::is_whitespace) {
6047      return Some(&[
6048        ("LOCALE", "LOCALE = '<locale_name>' -- e.g. 'en_US.UTF-8'"),
6049        ("LC_COLLATE", "LC_COLLATE = '<lc_collate>'"),
6050        ("LC_CTYPE", "LC_CTYPE = '<lc_ctype>'"),
6051        ("PROVIDER", "PROVIDER = libc | icu | builtin"),
6052        ("DETERMINISTIC", "DETERMINISTIC = true | false"),
6053        ("RULES", "RULES = '<ICU_rules>'"),
6054        ("VERSION", "VERSION = '<version_string>'"),
6055      ]);
6056    }
6057  }
6058  // After name -> FROM or `(`.
6059  let last = *words.last()?;
6060  if last == "FROM" {
6061    return None; // user types an existing collation
6062  }
6063  if words.len() >= 3 && !words.contains(&"FROM") && opens == 0 {
6064    return Some(&[
6065      ("FROM", "FROM <existing_collation> -- clone an existing collation"),
6066      ("(", "( LOCALE = '...', LC_COLLATE = '...' )"),
6067    ]);
6068  }
6069  None
6070}
6071
6072/// ALTER SYSTEM phase chain.
6073/// GENERATED column chain inside CREATE TABLE / ALTER TABLE / CREATE FOREIGN TABLE:
6074///   <col> <type> GENERATED <cursor>                 -> ALWAYS / BY DEFAULT
6075///   <col> <type> GENERATED ALWAYS <cursor>          -> AS IDENTITY / AS (...)
6076///   <col> <type> GENERATED BY DEFAULT <cursor>      -> AS IDENTITY
6077///   <col> <type> GENERATED ... AS <cursor>          -> IDENTITY / (
6078///   <col> ... AS IDENTITY <cursor>                  -> ( <seq_opts>
6079///   <col> ... AS (<expr>) <cursor>                  -> STORED / VIRTUAL
6080pub(crate) fn column_generated_next_keyword(
6081  source: &str,
6082  offset: TextSize,
6083) -> Option<&'static [(&'static str, &'static str)]> {
6084  if cursor_not_at_ws_boundary(source, offset) {
6085    return None;
6086  }
6087  let (slice_owned, upper) = stmt_slice_upper(source, offset);
6088  if !upper.contains("CREATE TABLE") && !upper.contains("ALTER TABLE") && !upper.contains("CREATE FOREIGN TABLE") {
6089    return None;
6090  }
6091  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
6092  let n = words.len();
6093  let last = *words.last()?;
6094  let second_last = if n >= 2 { Some(words[n - 2]) } else { None };
6095  let third_last = if n >= 3 { Some(words[n - 3]) } else { None };
6096
6097  // GENERATED <cursor> -> ALWAYS | BY DEFAULT
6098  if last == "GENERATED" {
6099    return Some(&[
6100      ("ALWAYS", "GENERATED ALWAYS AS IDENTITY | AS (<expr>) STORED"),
6101      ("BY DEFAULT", "GENERATED BY DEFAULT AS IDENTITY"),
6102    ]);
6103  }
6104  // GENERATED ALWAYS <cursor> -> AS
6105  if last == "ALWAYS" && second_last == Some("GENERATED") {
6106    return Some(&[("AS", "AS IDENTITY | AS (<expression>) STORED")]);
6107  }
6108  // GENERATED BY DEFAULT <cursor> -> AS IDENTITY
6109  if last == "DEFAULT" && second_last == Some("BY") && third_last == Some("GENERATED") {
6110    return Some(&[("AS IDENTITY", "AS IDENTITY -- sequence-backed column")]);
6111  }
6112  // GENERATED ALWAYS AS <cursor> -> IDENTITY | (
6113  if last == "AS" && (second_last == Some("ALWAYS") || (second_last == Some("DEFAULT") && third_last == Some("BY"))) {
6114    return Some(&[
6115      ("IDENTITY", "AS IDENTITY [(<seq_options>)]"),
6116      ("(", "AS ( <expression> ) STORED -- computed column"),
6117    ]);
6118  }
6119  // ... AS (<expr>) <cursor> -> STORED
6120  // Detect: last char of slice is `)`, and a `GENERATED` precedes it.
6121  let trimmed = slice_owned.trim_end();
6122  if trimmed.ends_with(')') && upper.contains("GENERATED") && !upper.contains("STORED") && !upper.contains("VIRTUAL") {
6123    // make sure last keyword before `(` was AS
6124    return Some(&[
6125      ("STORED", "STORED -- materialised generated column"),
6126      ("VIRTUAL", "VIRTUAL -- on-the-fly generated column (PG18+ / reserved)"),
6127    ]);
6128  }
6129  None
6130}
6131
6132/// CREATE INDEX trailing-clause slot: cursor sits past the closing
6133/// `)` of the expression list. Emit the trailing clauses PG allows.
6134pub(crate) fn create_index_trailing_next_keyword(
6135  source: &str,
6136  offset: TextSize,
6137) -> Option<&'static [(&'static str, &'static str)]> {
6138  if cursor_not_at_ws_boundary(source, offset) {
6139    return None;
6140  }
6141  let (_, upper) = stmt_slice_upper(source, offset);
6142  let trimmed = upper.trim_start();
6143  if !trimmed.starts_with("CREATE INDEX") && !trimmed.starts_with("CREATE UNIQUE INDEX") {
6144    return None;
6145  }
6146  // Must be past a `(` body that closed.
6147  let opens = upper.matches('(').count();
6148  let closes = upper.matches(')').count();
6149  if opens == 0 || opens > closes {
6150    return None;
6151  }
6152  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
6153  let last = *words.last()?;
6154  // Avoid re-emitting if the user has already started a trailing clause.
6155  if matches!(last, "INCLUDE" | "WHERE" | "WITH" | "TABLESPACE" | "USING") {
6156    return None;
6157  }
6158  Some(&[
6159    ("INCLUDE", "INCLUDE (<col>[, ...]) -- non-key payload columns"),
6160    ("WHERE", "WHERE <predicate> -- partial index"),
6161    ("WITH", "WITH (<option>=<value>, ...) -- storage params"),
6162    ("TABLESPACE", "TABLESPACE <name> -- place index in a specific tablespace"),
6163  ])
6164}
6165
6166/// CHECK constraint trailing slot:
6167///   ... CHECK (<expr>) <cursor>  -> NO INHERIT
6168pub(crate) fn check_constraint_no_inherit_next_keyword(
6169  source: &str,
6170  offset: TextSize,
6171) -> Option<&'static [(&'static str, &'static str)]> {
6172  if cursor_not_at_ws_boundary(source, offset) {
6173    return None;
6174  }
6175  let (slice_owned, upper) = stmt_slice_upper(source, offset);
6176  if !upper.contains("CHECK") {
6177    return None;
6178  }
6179  if !upper.contains("CREATE TABLE") && !upper.contains("ALTER TABLE") && !upper.contains("CREATE DOMAIN") {
6180    return None;
6181  }
6182  // The latest CHECK must have a matching closing `)`.
6183  let after_check = {
6184    let p = upper.rfind("CHECK")?;
6185    &upper[p + "CHECK".len()..]
6186  };
6187  let opens = after_check.matches('(').count();
6188  let closes = after_check.matches(')').count();
6189  if opens == 0 || opens > closes {
6190    return None;
6191  }
6192  // Must end with whitespace boundary.
6193  if !slice_owned.ends_with(char::is_whitespace) {
6194    return None;
6195  }
6196  // Don't re-emit when NO is already typed.
6197  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
6198  if matches!(words.last(), Some(&"NO") | Some(&"INHERIT")) {
6199    return None;
6200  }
6201  Some(&[("NO INHERIT", "NO INHERIT -- child tables don't enforce this CHECK")])
6202}
6203
6204/// Column / table constraint sub-keywords inside CREATE TABLE / ALTER TABLE:
6205///   REFERENCES <t>(<c>) ON DELETE <cursor>   -> CASCADE / RESTRICT / NO ACTION / SET NULL / SET DEFAULT
6206///   REFERENCES <t>(<c>) ON UPDATE <cursor>   -> same
6207///   ... ON DELETE SET <cursor>               -> NULL / DEFAULT
6208///   ... DEFERRABLE <cursor>                  -> INITIALLY
6209///   ... DEFERRABLE INITIALLY <cursor>        -> DEFERRED / IMMEDIATE
6210///   ... INITIALLY <cursor>                   -> DEFERRED / IMMEDIATE
6211pub(crate) fn column_constraint_next_keyword(
6212  source: &str,
6213  offset: TextSize,
6214) -> Option<&'static [(&'static str, &'static str)]> {
6215  if cursor_not_at_ws_boundary(source, offset) {
6216    return None;
6217  }
6218  let (_, upper) = stmt_slice_upper(source, offset);
6219  // Must be inside a TABLE/COLUMN DDL context.
6220  if !upper.contains("CREATE TABLE") && !upper.contains("ALTER TABLE") && !upper.contains("CREATE FOREIGN TABLE") {
6221    return None;
6222  }
6223  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
6224  let n = words.len();
6225  let last = *words.last()?;
6226  let second_last = if n >= 2 { Some(words[n - 2]) } else { None };
6227  let third_last = if n >= 3 { Some(words[n - 3]) } else { None };
6228
6229  // ON DELETE <cursor> | ON UPDATE <cursor>
6230  if matches!(last, "DELETE" | "UPDATE") && second_last == Some("ON") {
6231    return Some(&[
6232      ("CASCADE", "CASCADE -- propagate deletes/updates"),
6233      ("RESTRICT", "RESTRICT -- refuse if dependent rows exist (check immediate)"),
6234      ("NO ACTION", "NO ACTION -- default; check deferred if constraint is DEFERRABLE"),
6235      ("SET NULL", "SET NULL -- NULL out the FK columns"),
6236      ("SET DEFAULT", "SET DEFAULT -- reset FK columns to their DEFAULT"),
6237    ]);
6238  }
6239  // ON {DELETE|UPDATE} SET <cursor> -> NULL | DEFAULT
6240  if last == "SET" && matches!(second_last, Some("DELETE") | Some("UPDATE")) && third_last == Some("ON") {
6241    return Some(&[("NULL", "SET NULL"), ("DEFAULT", "SET DEFAULT")]);
6242  }
6243  // DEFERRABLE <cursor> | NOT DEFERRABLE <cursor>
6244  if last == "DEFERRABLE" {
6245    return Some(&[("INITIALLY", "INITIALLY DEFERRED | IMMEDIATE")]);
6246  }
6247  // INITIALLY <cursor>
6248  if last == "INITIALLY" {
6249    return Some(&[
6250      ("DEFERRED", "INITIALLY DEFERRED -- check at COMMIT"),
6251      ("IMMEDIATE", "INITIALLY IMMEDIATE -- check at statement end (default)"),
6252    ]);
6253  }
6254  None
6255}
6256
6257/// WITH RECURSIVE ... SEARCH / CYCLE clause chain (PG14+).
6258///   ... SEARCH { DEPTH | BREADTH } FIRST BY <cols> SET <out_col>
6259///   ... CYCLE <cols> SET <flag_col> [TO 't' DEFAULT 'f'] USING <path_col>
6260pub(crate) fn cte_search_cycle_next_keyword(
6261  source: &str,
6262  offset: TextSize,
6263) -> Option<&'static [(&'static str, &'static str)]> {
6264  if cursor_not_at_ws_boundary(source, offset) {
6265    return None;
6266  }
6267  let (_, upper) = stmt_slice_upper(source, offset);
6268  // Must follow a WITH RECURSIVE somewhere in the statement.
6269  if !upper.contains("WITH RECURSIVE") {
6270    return None;
6271  }
6272  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
6273  let last = *words.last()?;
6274  // Bare `... SEARCH <cursor>` -> DEPTH | BREADTH
6275  if last == "SEARCH" {
6276    return Some(&[
6277      ("DEPTH FIRST BY", "DEPTH FIRST BY <cols> SET <out_col>"),
6278      ("BREADTH FIRST BY", "BREADTH FIRST BY <cols> SET <out_col>"),
6279    ]);
6280  }
6281  // `... SEARCH DEPTH | BREADTH <cursor>` -> FIRST
6282  if matches!(last, "DEPTH" | "BREADTH") && words.contains(&"SEARCH") {
6283    return Some(&[("FIRST BY", "FIRST BY <cols> SET <out_col>")]);
6284  }
6285  // `... DEPTH FIRST <cursor>` -> BY
6286  if last == "FIRST" && (words.contains(&"DEPTH") || words.contains(&"BREADTH")) {
6287    return Some(&[("BY", "BY <cols> SET <out_col>")]);
6288  }
6289  // `... CYCLE <cursor>` -> after the cycle-column list typed by user;
6290  // common next slot is SET.
6291  if last == "CYCLE" {
6292    return Some(&[("<cols>", "CYCLE <col1>, <col2>, ... SET <flag_col>")]);
6293  }
6294  // Inside the CYCLE clause -- after SET <flag>, optional TO / DEFAULT / USING
6295  if last == "SET" && words.contains(&"CYCLE") {
6296    return Some(&[("<flag_col>", "SET <flag_col> [TO 't' DEFAULT 'f'] USING <path_col>")]);
6297  }
6298  if last == "USING" && words.contains(&"CYCLE") {
6299    return Some(&[("<path_col>", "USING <path_col> -- array tracking visited rows")]);
6300  }
6301  None
6302}
6303
6304/// `ALTER SYSTEM {SET|RESET} <param> [= value | TO value]`
6305pub(crate) fn alter_system_next_keyword(
6306  source: &str,
6307  offset: TextSize,
6308) -> Option<&'static [(&'static str, &'static str)]> {
6309  if cursor_not_at_ws_boundary(source, offset) {
6310    return None;
6311  }
6312  let (_, upper) = stmt_slice_upper(source, offset);
6313  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
6314  if words.len() < 2 || words[0] != "ALTER" || words[1] != "SYSTEM" {
6315    return None;
6316  }
6317  let n = words.len();
6318  if n == 2 {
6319    return Some(&[
6320      ("SET", "ALTER SYSTEM SET <param> = value -- write to postgresql.auto.conf"),
6321      ("RESET", "ALTER SYSTEM RESET <param> | ALL"),
6322    ]);
6323  }
6324  // After SET -> common GUC names that ALTER SYSTEM is typically used for.
6325  if n == 3 && words[2] == "SET" {
6326    return Some(&[
6327      ("shared_buffers", "shared_buffers = '<size>'"),
6328      ("work_mem", "work_mem = '<size>'"),
6329      ("maintenance_work_mem", "maintenance_work_mem = '<size>'"),
6330      ("effective_cache_size", "effective_cache_size = '<size>'"),
6331      ("max_connections", "max_connections = <n> -- restart required"),
6332      ("max_wal_size", "max_wal_size = '<size>'"),
6333      ("checkpoint_timeout", "checkpoint_timeout = '<duration>'"),
6334      ("random_page_cost", "random_page_cost = <float>"),
6335      ("seq_page_cost", "seq_page_cost = <float>"),
6336      ("default_statistics_target", "default_statistics_target = <int>"),
6337      ("synchronous_commit", "synchronous_commit = 'on'|'off'|'remote_apply'|..."),
6338      ("log_statement", "log_statement = 'none'|'ddl'|'mod'|'all'"),
6339      ("log_min_duration_statement", "log_min_duration_statement = <ms>"),
6340      ("autovacuum_naptime", "autovacuum_naptime = '<duration>'"),
6341      ("autovacuum_vacuum_scale_factor", "autovacuum_vacuum_scale_factor = <float>"),
6342      ("wal_level", "wal_level = 'replica'|'logical' -- restart required"),
6343      ("max_replication_slots", "max_replication_slots = <n>"),
6344      ("max_wal_senders", "max_wal_senders = <n>"),
6345    ]);
6346  }
6347  // After SET <param> -> TO | =
6348  if n == 4 && matches!(words[2], "SET") {
6349    return Some(&[("TO", "TO <value>"), ("=", "= <value>")]);
6350  }
6351  // After RESET -> ALL or stay silent (user types GUC name).
6352  if n == 3 && words[2] == "RESET" {
6353    return Some(&[("ALL", "RESET ALL -- restore all GUCs to default")]);
6354  }
6355  None
6356}
6357
6358/// ALTER LARGE OBJECT chain.
6359///   ALTER LARGE OBJECT <oid> OWNER TO <role>
6360pub(crate) fn alter_large_object_next_keyword(
6361  source: &str,
6362  offset: TextSize,
6363) -> Option<&'static [(&'static str, &'static str)]> {
6364  if cursor_not_at_ws_boundary(source, offset) {
6365    return None;
6366  }
6367  let (_, upper) = stmt_slice_upper(source, offset);
6368  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
6369  if words.len() < 3 || words[0] != "ALTER" || words[1] != "LARGE" || words[2] != "OBJECT" {
6370    return None;
6371  }
6372  let last = *words.last()?;
6373  if last == "OBJECT" {
6374    return None; // user types loid
6375  }
6376  if last == "OWNER" {
6377    return Some(&[("TO", "OWNER TO <role>")]);
6378  }
6379  if words.len() >= 4 {
6380    return Some(&[("OWNER TO", "OWNER TO <role>")]);
6381  }
6382  None
6383}
6384
6385/// CREATE PUBLICATION phase chain.
6386/// `CREATE PUBLICATION <name> [FOR ALL TABLES | FOR TABLE <tbl>[, ...] | FOR TABLES IN SCHEMA <s>] [WITH (...)]`
6387/// CREATE SUBSCRIPTION chain.
6388///   CREATE SUBSCRIPTION <name> CONNECTION '<conninfo>' PUBLICATION <pub>[, ...]
6389///     [WITH (<param> = <value>[, ...])]
6390pub(crate) fn create_subscription_next_keyword(
6391  source: &str,
6392  offset: TextSize,
6393) -> Option<&'static [(&'static str, &'static str)]> {
6394  if cursor_not_at_ws_boundary(source, offset) {
6395    return None;
6396  }
6397  let (slice_owned, upper) = stmt_slice_upper(source, offset);
6398  let slice = slice_owned.as_str();
6399  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
6400  if words.len() < 2 || words[0] != "CREATE" || words[1] != "SUBSCRIPTION" {
6401    return None;
6402  }
6403  let last = *words.last()?;
6404  if last == "SUBSCRIPTION" {
6405    return None; // user types the subscription name
6406  }
6407  if last == "CONNECTION" {
6408    return None; // user types '<conninfo>' literal
6409  }
6410  if last == "PUBLICATION" {
6411    return None; // user types publication name
6412  }
6413  if last == "WITH" {
6414    return Some(&[("(", "WITH ( <param> = <value>[, ...] )")]);
6415  }
6416  // Inside WITH ( ... ) paren -> option name slot.
6417  let opens = slice.matches('(').count();
6418  let closes = slice.matches(')').count();
6419  if opens > closes {
6420    let trimmed = slice.trim_end();
6421    let last_char = trimmed.chars().last();
6422    if matches!(last_char, Some('(') | Some(',')) || slice.ends_with(char::is_whitespace) {
6423      return Some(&[
6424        ("connect", "connect = true|false -- default true; false = create slot but don't subscribe yet"),
6425        ("create_slot", "create_slot = true|false -- create the replication slot on the publisher"),
6426        ("enabled", "enabled = true|false -- whether the subscription starts active"),
6427        ("slot_name", "slot_name = '<name>' | NONE -- replication slot to attach to"),
6428        ("synchronous_commit", "synchronous_commit = 'on'|'off'|'remote_apply'|... -- apply-worker setting"),
6429        ("binary", "binary = true|false -- use binary protocol (PG14+)"),
6430        ("streaming", "streaming = 'off'|'on'|'parallel' -- streaming-in-progress xacts"),
6431        ("two_phase", "two_phase = true|false -- enable 2PC streaming (PG15+)"),
6432        ("disable_on_error", "disable_on_error = true|false -- auto-disable on apply error (PG15+)"),
6433        ("run_as_owner", "run_as_owner = true|false -- run the apply worker as the subscription owner (PG16+)"),
6434        ("password_required", "password_required = true|false -- require password in CONNECTION (PG16+)"),
6435        ("origin", "origin = 'none'|'any' -- which origin's data to apply (PG16+)"),
6436        ("failover", "failover = true|false -- allow synchronous failover (PG17+)"),
6437        ("copy_data", "copy_data = true|false -- initial table sync"),
6438      ]);
6439    }
6440  }
6441  // After the name + extra tokens, suggest CONNECTION.
6442  if !words.contains(&"CONNECTION") && words.len() >= 3 {
6443    return Some(&[("CONNECTION", "CONNECTION '<conn_string>'")]);
6444  }
6445  if words.contains(&"CONNECTION") && !words.contains(&"PUBLICATION") {
6446    return Some(&[("PUBLICATION", "PUBLICATION <pub>[, ...]")]);
6447  }
6448  if words.contains(&"PUBLICATION") && !words.contains(&"WITH") {
6449    return Some(&[("WITH", "WITH ( <options> )")]);
6450  }
6451  None
6452}
6453
6454pub(crate) fn create_publication_next_keyword(
6455  source: &str,
6456  offset: TextSize,
6457) -> Option<&'static [(&'static str, &'static str)]> {
6458  if cursor_not_at_ws_boundary(source, offset) {
6459    return None;
6460  }
6461  let (_, upper) = stmt_slice_upper(source, offset);
6462  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
6463  if words.len() < 2 || words[0] != "CREATE" || words[1] != "PUBLICATION" {
6464    return None;
6465  }
6466  let last = *words.last()?;
6467  if last == "PUBLICATION" {
6468    return None; // user types the publication name
6469  }
6470  if last == "FOR" {
6471    return Some(&[
6472      ("ALL TABLES", "FOR ALL TABLES -- every existing + future table"),
6473      ("TABLE", "FOR TABLE <tbl>[, ...]"),
6474      ("TABLES IN SCHEMA", "FOR TABLES IN SCHEMA <schema>[, ...] (PG15+)"),
6475    ]);
6476  }
6477  // `... FOR ALL <cursor>` -> TABLES.
6478  if last == "ALL" && words.contains(&"FOR") {
6479    return Some(&[("TABLES", "FOR ALL TABLES -- every existing + future table")]);
6480  }
6481  // `... FOR ALL TABLES IN <cursor>` / `... FOR TABLES IN <cursor>` -> SCHEMA.
6482  if last == "IN" && words.contains(&"TABLES") {
6483    return Some(&[("SCHEMA", "TABLES IN SCHEMA <schema>[, ...] (PG15+)")]);
6484  }
6485  // `... FOR TABLES <cursor>` -> IN SCHEMA.
6486  if last == "TABLES" && words.contains(&"FOR") && !words.contains(&"ALL") {
6487    return Some(&[("IN SCHEMA", "TABLES IN SCHEMA <schema>[, ...] (PG15+)")]);
6488  }
6489  if last == "WITH" {
6490    return Some(&[
6491      ("(publish", "WITH (publish = 'insert, update, delete, truncate')"),
6492      ("(publish_via_partition_root", "WITH (publish_via_partition_root = true)"),
6493    ]);
6494  }
6495  // After name + extra tokens, suggest FOR | WITH.
6496  if !words.contains(&"FOR") && !words.contains(&"WITH") && words.len() >= 3 {
6497    return Some(&[
6498      ("FOR", "FOR { ALL TABLES | TABLE ... | TABLES IN SCHEMA ... }"),
6499      ("WITH", "WITH (publish = '...')"),
6500    ]);
6501  }
6502  if words.contains(&"FOR") && !words.contains(&"WITH") {
6503    return Some(&[("WITH", "WITH (publish = 'insert, update, delete, truncate')")]);
6504  }
6505  None
6506}
6507
6508/// CLUSTER phase chain.
6509/// `CLUSTER [VERBOSE] [<table_name> [USING <index_name>]]`
6510/// ALTER TABLE ... REPLICA IDENTITY <cursor> chain.
6511pub(crate) fn replica_identity_next_keyword(
6512  source: &str,
6513  offset: TextSize,
6514) -> Option<&'static [(&'static str, &'static str)]> {
6515  if cursor_not_at_ws_boundary(source, offset) {
6516    return None;
6517  }
6518  let (_, upper) = stmt_slice_upper(source, offset);
6519  if !upper.contains("REPLICA IDENTITY") {
6520    return None;
6521  }
6522  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
6523  let last = *words.last()?;
6524  // `... REPLICA IDENTITY <cursor>` -> DEFAULT / FULL / NOTHING / USING INDEX
6525  if last == "IDENTITY" && words.contains(&"REPLICA") {
6526    return Some(&[
6527      ("DEFAULT", "DEFAULT -- record PK columns (standard)"),
6528      ("FULL", "FULL -- record old image of every column (heavy WAL)"),
6529      ("NOTHING", "NOTHING -- record only TOAST columns"),
6530      ("USING INDEX", "USING INDEX <unique_index> -- use a specific UNIQUE index"),
6531    ]);
6532  }
6533  // `... REPLICA IDENTITY USING <cursor>` -> INDEX
6534  if last == "USING" && words.contains(&"REPLICA") {
6535    return Some(&[("INDEX", "INDEX <unique_index_name>")]);
6536  }
6537  None
6538}
6539
6540pub(crate) fn cluster_next_keyword(source: &str, offset: TextSize) -> Option<&'static [(&'static str, &'static str)]> {
6541  if cursor_not_at_ws_boundary(source, offset) {
6542    return None;
6543  }
6544  let (_, upper) = stmt_slice_upper(source, offset);
6545  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
6546  if words.first() != Some(&"CLUSTER") {
6547    return None;
6548  }
6549  let n = words.len();
6550  if n == 1 {
6551    return Some(&[("VERBOSE", "CLUSTER VERBOSE -- per-table progress")]);
6552  }
6553  // After a table name -> USING.
6554  if n >= 3 && !words.contains(&"USING") {
6555    return Some(&[("USING", "USING <index_name> -- pick a non-default cluster index")]);
6556  }
6557  None
6558}
6559
6560/// IMPORT FOREIGN SCHEMA phase chain.
6561/// `IMPORT FOREIGN SCHEMA <name> [LIMIT TO|EXCEPT (...)] FROM SERVER <srv> INTO <schema> [OPTIONS (...)]`
6562pub(crate) fn import_foreign_schema_next_keyword(
6563  source: &str,
6564  offset: TextSize,
6565) -> Option<&'static [(&'static str, &'static str)]> {
6566  if cursor_not_at_ws_boundary(source, offset) {
6567    return None;
6568  }
6569  let (_, upper) = stmt_slice_upper(source, offset);
6570  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
6571  if words.len() < 3 || words[0] != "IMPORT" || words[1] != "FOREIGN" || words[2] != "SCHEMA" {
6572    return None;
6573  }
6574  let last = *words.last()?;
6575  if last == "SCHEMA" && words.len() == 3 {
6576    return None; // user about to type the schema name
6577  }
6578  if matches!(last, "LIMIT" | "TO" | "EXCEPT" | "FROM" | "SERVER" | "INTO") {
6579    let menu: &[(&str, &str)] = match last {
6580      "LIMIT" => &[("TO", "LIMIT TO (<rel>[, ...])")],
6581      "TO" => &[("(", "( <rel>[, ...] )")],
6582      "EXCEPT" => &[("(", "EXCEPT ( <rel>[, ...] )")],
6583      "FROM" => &[("SERVER", "FROM SERVER <name>")],
6584      "SERVER" => &[],
6585      "INTO" => &[],
6586      _ => &[],
6587    };
6588    if !menu.is_empty() {
6589      return Some(menu);
6590    }
6591    return None;
6592  }
6593  // After the source-schema name -> LIMIT TO / EXCEPT / FROM SERVER.
6594  Some(&[
6595    ("LIMIT TO", "LIMIT TO (<rel>[, ...]) -- import only these"),
6596    ("EXCEPT", "EXCEPT (<rel>[, ...]) -- import everything except"),
6597    ("FROM SERVER", "FROM SERVER <fdw_server> INTO <local_schema>"),
6598    ("INTO", "INTO <local_schema>"),
6599    ("OPTIONS", "OPTIONS (key 'value', ...)"),
6600  ])
6601}
6602
6603/// CREATE SCHEMA phase chain.
6604/// `CREATE SCHEMA [IF NOT EXISTS] [<name>] [AUTHORIZATION <role>] [<schema_element>]`
6605pub(crate) fn create_schema_next_keyword(
6606  source: &str,
6607  offset: TextSize,
6608) -> Option<&'static [(&'static str, &'static str)]> {
6609  if cursor_not_at_ws_boundary(source, offset) {
6610    return None;
6611  }
6612  let (_, upper) = stmt_slice_upper(source, offset);
6613  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
6614  if words.len() < 2 || words[0] != "CREATE" || words[1] != "SCHEMA" {
6615    return None;
6616  }
6617  let last = *words.last()?;
6618  if last == "AUTHORIZATION" {
6619    return None; // user types the role name
6620  }
6621  if words.len() == 2 {
6622    return Some(&[
6623      ("IF NOT EXISTS", "IF NOT EXISTS <name> -- silently skip if present"),
6624      ("AUTHORIZATION", "AUTHORIZATION <role> -- omits <name>, uses role name"),
6625    ]);
6626  }
6627  if words.len() >= 3 && !words.contains(&"AUTHORIZATION") {
6628    return Some(&[("AUTHORIZATION", "AUTHORIZATION <role> -- assign owner")]);
6629  }
6630  None
6631}
6632
6633/// REINDEX phase chain.
6634/// `REINDEX [CONCURRENTLY] {INDEX|TABLE|SCHEMA|DATABASE|SYSTEM} <name>`
6635/// CREATE FOREIGN TABLE phase chain.
6636///   CREATE FOREIGN TABLE [IF NOT EXISTS] <name> (...) [INHERITS (...)]
6637///     SERVER <srv> [OPTIONS (<key> '<val>', ...)]
6638///   CREATE FOREIGN TABLE <name> PARTITION OF <parent>
6639///     FOR VALUES ... SERVER <srv> [OPTIONS ...]
6640pub(crate) fn create_foreign_table_next_keyword(
6641  source: &str,
6642  offset: TextSize,
6643) -> Option<&'static [(&'static str, &'static str)]> {
6644  if cursor_not_at_ws_boundary(source, offset) {
6645    return None;
6646  }
6647  let (slice_owned, upper) = stmt_slice_upper(source, offset);
6648  let slice = slice_owned.as_str();
6649  let trimmed = upper.trim_start();
6650  if !trimmed.starts_with("CREATE FOREIGN TABLE") {
6651    return None;
6652  }
6653  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
6654  let last = *words.last()?;
6655  // OPTIONS ( <cursor> -- inside paren -> no kw; user types option name
6656  // (free-form).
6657  let opens = slice.matches('(').count();
6658  let closes = slice.matches(')').count();
6659  if last == "OPTIONS" {
6660    return Some(&[("(", "( <option_name> '<value>', ... )")]);
6661  }
6662  if last == "SERVER" {
6663    return None; // server name slot
6664  }
6665  if last == "INHERITS" {
6666    return None; // parent table list
6667  }
6668  // After SERVER <name> -> OPTIONS or PARTITION-of trailing.
6669  if let Some(srv_idx) = words.iter().rposition(|w| *w == "SERVER")
6670    && srv_idx == words.len() - 2
6671  {
6672    return Some(&[("OPTIONS", "OPTIONS (<key> '<value>', ...)")]);
6673  }
6674  // After top-level closing `)` of the column body -> INHERITS | SERVER.
6675  // Heuristic: opens == closes and opens >= 1 means body paren closed.
6676  if opens >= 1 && opens == closes && !words.contains(&"SERVER") {
6677    return Some(&[("INHERITS", "INHERITS (<parent>[, ...])"), ("SERVER", "SERVER <fdw_server_name>")]);
6678  }
6679  None
6680}
6681
6682pub(crate) fn reindex_next_keyword(source: &str, offset: TextSize) -> Option<&'static [(&'static str, &'static str)]> {
6683  if cursor_not_at_ws_boundary(source, offset) {
6684    return None;
6685  }
6686  let (slice_owned, upper) = stmt_slice_upper(source, offset);
6687  let slice = slice_owned.as_str();
6688  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
6689  if words.first() != Some(&"REINDEX") {
6690    return None;
6691  }
6692  // REINDEX ( <cursor> ) -- paren options menu (PG14+).
6693  let opens = slice.matches('(').count();
6694  let closes = slice.matches(')').count();
6695  if opens > closes {
6696    let last_tok = slice.trim_end().chars().last();
6697    if matches!(last_tok, Some('(') | Some(',')) || slice.ends_with(char::is_whitespace) {
6698      // After CONCURRENTLY -> bool. After TABLESPACE -> name (no kw).
6699      let last_raw = *words.last()?;
6700      let last = last_raw.trim_start_matches(['(', ',']);
6701      if last == "CONCURRENTLY" || last == "VERBOSE" {
6702        return Some(&[("true", "true -- enable"), ("false", "false -- disable")]);
6703      }
6704      if last == "TABLESPACE" {
6705        return None; // tablespace name slot
6706      }
6707      return Some(&[
6708        ("CONCURRENTLY", "CONCURRENTLY [true|false] -- avoid heavy locks"),
6709        ("TABLESPACE", "TABLESPACE <name> -- move rebuilt indexes into <name>"),
6710        ("VERBOSE", "VERBOSE [true|false] -- per-index progress"),
6711      ]);
6712    }
6713  }
6714  // REINDEX <cursor>  or  REINDEX CONCURRENTLY <cursor>.
6715  if words.len() == 1 || (words.len() == 2 && words[1] == "CONCURRENTLY") {
6716    return Some(&[
6717      ("INDEX", "REINDEX INDEX <name> -- single index"),
6718      ("TABLE", "REINDEX TABLE <name> -- all indexes on a table"),
6719      ("SCHEMA", "REINDEX SCHEMA <name> -- every index in the schema"),
6720      ("DATABASE", "REINDEX DATABASE <name> -- every index in the database"),
6721      ("SYSTEM", "REINDEX SYSTEM <name> -- only system catalog indexes"),
6722      ("CONCURRENTLY", "REINDEX CONCURRENTLY <kind> <name> (PG 12+)"),
6723      ("(", "( CONCURRENTLY|TABLESPACE|VERBOSE ... ) -- paren options (PG14+)"),
6724    ]);
6725  }
6726  None
6727}
6728
6729/// True when the cursor sits right after `CALL` (the procedure-name slot).
6730pub(crate) fn call_expects_procedure(source: &str, offset: TextSize) -> bool {
6731  if cursor_not_at_ws_boundary(source, offset) {
6732    return false;
6733  }
6734  let (slice_owned, _) = stmt_slice_upper(source, offset);
6735  slice_owned.trim().eq_ignore_ascii_case("CALL")
6736}
6737
6738/// SET TRANSACTION / BEGIN ISOLATION ... phase chain.
6739pub(crate) fn set_transaction_next_keyword(
6740  source: &str,
6741  offset: TextSize,
6742) -> Option<&'static [(&'static str, &'static str)]> {
6743  if cursor_not_at_ws_boundary(source, offset) {
6744    return None;
6745  }
6746  let (slice_owned, upper) = stmt_slice_upper(source, offset);
6747  let _ = slice_owned;
6748  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
6749  if words.is_empty() {
6750    return None;
6751  }
6752  let is_set_tx = (words[0] == "SET" && words.contains(&"TRANSACTION"))
6753    || words[0] == "BEGIN"
6754    || (words[0] == "START" && words.contains(&"TRANSACTION"));
6755  if !is_set_tx {
6756    return None;
6757  }
6758  let last = *words.last()?;
6759  if last == "ISOLATION" {
6760    return Some(&[("LEVEL", "ISOLATION LEVEL <name>")]);
6761  }
6762  if last == "LEVEL" {
6763    return Some(&[
6764      ("READ UNCOMMITTED", "READ UNCOMMITTED (treated as READ COMMITTED in PG)"),
6765      ("READ COMMITTED", "READ COMMITTED -- default"),
6766      ("REPEATABLE READ", "REPEATABLE READ -- snapshot isolation"),
6767      ("SERIALIZABLE", "SERIALIZABLE -- strictest"),
6768    ]);
6769  }
6770  if last == "READ" {
6771    return Some(&[("ONLY", "READ ONLY -- block writes"), ("WRITE", "READ WRITE -- default")]);
6772  }
6773  if last == "NOT" {
6774    return Some(&[("DEFERRABLE", "NOT DEFERRABLE -- default")]);
6775  }
6776  Some(&[
6777    ("ISOLATION LEVEL", "ISOLATION LEVEL READ COMMITTED | REPEATABLE READ | SERIALIZABLE"),
6778    ("READ ONLY", "READ ONLY"),
6779    ("READ WRITE", "READ WRITE (default)"),
6780    ("DEFERRABLE", "DEFERRABLE (REPEATABLE READ + READ ONLY only)"),
6781    ("NOT DEFERRABLE", "NOT DEFERRABLE (default)"),
6782    ("SNAPSHOT", "SNAPSHOT '<snapshot_id>' -- import a snapshot exported via pg_export_snapshot()"),
6783  ])
6784}
6785
6786/// REASSIGN OWNED chain: `REASSIGN OWNED BY <old>[, ...] TO <new>`.
6787pub(crate) fn reassign_owned_next_keyword(
6788  source: &str,
6789  offset: TextSize,
6790) -> Option<&'static [(&'static str, &'static str)]> {
6791  if cursor_not_at_ws_boundary(source, offset) {
6792    return None;
6793  }
6794  let (_, upper) = stmt_slice_upper(source, offset);
6795  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
6796  if words.first() != Some(&"REASSIGN") {
6797    return None;
6798  }
6799  let last = *words.last()?;
6800  if last == "REASSIGN" {
6801    return Some(&[("OWNED", "OWNED BY <old_role>[, ...] TO <new_role>")]);
6802  }
6803  if last == "OWNED" {
6804    return Some(&[("BY", "BY <old_role>[, ...]")]);
6805  }
6806  if last == "BY" {
6807    return None; // role name
6808  }
6809  // After role list -> TO.
6810  if !words.contains(&"TO") && words.len() >= 4 {
6811    return Some(&[("TO", "TO <new_role>")]);
6812  }
6813  None
6814}
6815
6816/// Followup keywords for COMMIT / ROLLBACK / PREPARE TRANSACTION shapes.
6817///   COMMIT <cursor>                  -> AND / TRANSACTION / WORK / PREPARED
6818///   COMMIT AND <cursor>              -> CHAIN / NO CHAIN
6819///   COMMIT AND NO <cursor>           -> CHAIN
6820///   ROLLBACK <cursor>                -> AND / TO / TRANSACTION / WORK / PREPARED
6821///   ROLLBACK TO <cursor>             -> SAVEPOINT
6822///   ROLLBACK AND <cursor>            -> CHAIN / NO CHAIN
6823///   PREPARE TRANSACTION <cursor>     -> '<gxid_literal>' (no kw)
6824pub(crate) fn txn_followup_next_keyword(
6825  source: &str,
6826  offset: TextSize,
6827) -> Option<&'static [(&'static str, &'static str)]> {
6828  if cursor_not_at_ws_boundary(source, offset) {
6829    return None;
6830  }
6831  let (_, upper) = stmt_slice_upper(source, offset);
6832  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
6833  let last = *words.last()?;
6834  let first = *words.first()?;
6835  if !matches!(first, "COMMIT" | "ROLLBACK" | "ABORT" | "END" | "PREPARE") {
6836    return None;
6837  }
6838  // PREPARE TRANSACTION <cursor> -- user types '<gxid_literal>'; no kw.
6839  if first == "PREPARE" {
6840    if words.len() == 1 {
6841      return Some(&[("TRANSACTION", "PREPARE TRANSACTION '<gxid>'")]);
6842    }
6843    return None;
6844  }
6845  // COMMIT / ROLLBACK / ABORT / END alone.
6846  if words.len() == 1 {
6847    let mut menu: &[(&str, &str)] = &[
6848      ("AND", "AND { CHAIN | NO CHAIN }"),
6849      ("TRANSACTION", "TRANSACTION -- SQL-standard noise"),
6850      ("WORK", "WORK -- SQL-standard noise"),
6851      ("PREPARED", "PREPARED '<gxid>' -- second phase of 2PC"),
6852    ];
6853    if first == "ROLLBACK" {
6854      menu = &[
6855        ("AND", "AND { CHAIN | NO CHAIN }"),
6856        ("TO", "TO [SAVEPOINT] <name>"),
6857        ("TRANSACTION", "TRANSACTION -- SQL-standard noise"),
6858        ("WORK", "WORK -- SQL-standard noise"),
6859        ("PREPARED", "PREPARED '<gxid>' -- second phase of 2PC"),
6860      ];
6861    }
6862    return Some(menu);
6863  }
6864  // <verb> AND <cursor>
6865  if last == "AND" {
6866    return Some(&[("CHAIN", "CHAIN -- start a new xact with same options"), ("NO CHAIN", "NO CHAIN (default)")]);
6867  }
6868  if last == "NO" && words.contains(&"AND") {
6869    return Some(&[("CHAIN", "NO CHAIN")]);
6870  }
6871  // ROLLBACK TO <cursor>
6872  if last == "TO" && first == "ROLLBACK" {
6873    return Some(&[("SAVEPOINT", "TO SAVEPOINT <name> -- optional kw")]);
6874  }
6875  // COMMIT/ROLLBACK PREPARED <cursor> -- user types '<gxid>'; no kw.
6876  if last == "PREPARED" {
6877    return None;
6878  }
6879  None
6880}
6881
6882/// RELEASE SAVEPOINT chain. `RELEASE [SAVEPOINT] <name>`.
6883pub(crate) fn release_savepoint_next_keyword(
6884  source: &str,
6885  offset: TextSize,
6886) -> Option<&'static [(&'static str, &'static str)]> {
6887  if cursor_not_at_ws_boundary(source, offset) {
6888    return None;
6889  }
6890  let (_, upper) = stmt_slice_upper(source, offset);
6891  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
6892  if words.first() != Some(&"RELEASE") {
6893    return None;
6894  }
6895  if words.len() == 1 {
6896    return Some(&[("SAVEPOINT", "SAVEPOINT <name> -- optional keyword")]);
6897  }
6898  None
6899}
6900
6901/// COPY (...) paren options menu. Fires inside `COPY ... WITH ( <cursor> )`
6902/// or directly inside `COPY ... ( <cursor> )` (PG9.6+ accepts both).
6903/// Also handles the value slot for FORMAT.
6904pub(crate) fn copy_paren_options_keyword(
6905  source: &str,
6906  offset: TextSize,
6907) -> Option<&'static [(&'static str, &'static str)]> {
6908  let pos: usize = (u32::from(offset) as usize).min(source.len());
6909  let bytes = source.as_bytes();
6910  if pos < bytes.len() && !bytes[pos].is_ascii_whitespace() && bytes[pos] != b'(' && bytes[pos] != b',' {
6911    return None;
6912  }
6913  let (slice_owned, upper) = stmt_slice_upper(source, offset);
6914  let slice = slice_owned.as_str();
6915  if !upper.starts_with("COPY") {
6916    return None;
6917  }
6918  // Cursor must sit inside an open paren past `WITH` or directly after
6919  // the table list (the modern form).
6920  let opens = slice.matches('(').count();
6921  let closes = slice.matches(')').count();
6922  if opens <= closes {
6923    return None;
6924  }
6925  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
6926  let last_tok =
6927    upper.split(|c: char| c.is_whitespace() || c == ',' || c == '(').rfind(|s| !s.is_empty()).unwrap_or("");
6928  if last_tok == "FORMAT" {
6929    return Some(&[
6930      ("TEXT", "FORMAT TEXT -- default tab-separated"),
6931      ("CSV", "FORMAT CSV"),
6932      ("BINARY", "FORMAT BINARY"),
6933    ]);
6934  }
6935  if last_tok == "HEADER" {
6936    return Some(&[
6937      ("TRUE", "HEADER TRUE -- emit/skip a header row"),
6938      ("FALSE", "HEADER FALSE -- default"),
6939      ("MATCH", "HEADER MATCH -- verify header columns match (PG16+)"),
6940    ]);
6941  }
6942  if matches!(last_tok, "FREEZE" | "OIDS" | "DEFAULT") {
6943    return Some(&[("TRUE", "TRUE"), ("FALSE", "FALSE")]);
6944  }
6945  if !words.contains(&"WITH") && opens == 1 {
6946    // We're inside COPY <tbl> (cols) -- emit nothing; user is typing columns.
6947    return None;
6948  }
6949  // Fresh option slot inside WITH paren.
6950  Some(&[
6951    ("FORMAT", "FORMAT { TEXT | CSV | BINARY }"),
6952    ("FREEZE", "FREEZE -- mark imported tuples as already-committed (load only)"),
6953    ("DELIMITER", "DELIMITER '<char>'"),
6954    ("NULL", "NULL '<text>' -- literal that means NULL"),
6955    ("HEADER", "HEADER { TRUE | FALSE | MATCH }"),
6956    ("QUOTE", "QUOTE '<char>'"),
6957    ("ESCAPE", "ESCAPE '<char>'"),
6958    ("FORCE_QUOTE", "FORCE_QUOTE { * | (col[, ...]) }"),
6959    ("FORCE_NOT_NULL", "FORCE_NOT_NULL (col[, ...])"),
6960    ("FORCE_NULL", "FORCE_NULL (col[, ...])"),
6961    ("ENCODING", "ENCODING '<name>'"),
6962    ("DEFAULT", "DEFAULT '<text>' -- string treated as column DEFAULT (PG16+)"),
6963    ("ON_ERROR", "ON_ERROR { STOP | IGNORE } -- per-row error handling (PG17+)"),
6964    ("LOG_VERBOSITY", "LOG_VERBOSITY { DEFAULT | VERBOSE } (PG17+)"),
6965  ])
6966}
6967
6968/// COPY statement phase detector. Slot chain:
6969///   COPY <tbl> <cursor> -> FROM | TO | (<cols>)
6970///   COPY <tbl> FROM <cursor> -> STDIN | PROGRAM | '<file>'
6971///   COPY <tbl> TO <cursor>   -> STDOUT | PROGRAM | '<file>'
6972///   COPY ... WITH <cursor>   -> ( FORMAT / DELIMITER / HEADER / ... )
6973///   COPY ... <after target> <cursor> -> WITH | (options)
6974pub(crate) fn copy_next_keyword(source: &str, offset: TextSize) -> Option<&'static [(&'static str, &'static str)]> {
6975  if cursor_not_at_ws_boundary(source, offset) {
6976    return None;
6977  }
6978  let (slice_owned, upper) = stmt_slice_upper(source, offset);
6979  let _ = slice_owned;
6980  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
6981  if words.first() != Some(&"COPY") {
6982    return None;
6983  }
6984  let n = words.len();
6985  // COPY alone -> nothing useful; let catalog table list flow through.
6986  if n < 2 {
6987    return None;
6988  }
6989  let last = words[n - 1];
6990  if last == "FROM" {
6991    return Some(&[
6992      ("STDIN", "FROM STDIN -- pipe data on the wire"),
6993      ("PROGRAM", "FROM PROGRAM '<cmd>' -- spawn cmd, read its stdout"),
6994    ]);
6995  }
6996  if last == "TO" {
6997    return Some(&[
6998      ("STDOUT", "TO STDOUT -- stream data on the wire"),
6999      ("PROGRAM", "TO PROGRAM '<cmd>' -- spawn cmd, write to its stdin"),
7000    ]);
7001  }
7002  if last == "WITH" {
7003    return Some(&[
7004      ("(FORMAT CSV", "WITH (FORMAT CSV, ...)"),
7005      ("(FORMAT TEXT", "WITH (FORMAT TEXT, ...) -- default"),
7006      ("(FORMAT BINARY", "WITH (FORMAT BINARY, ...)"),
7007    ]);
7008  }
7009  // After COPY <tbl> (n == 2) or COPY <tbl> (<col_list>) -> FROM | TO
7010  let has_from_or_to = words.contains(&"FROM") || words.contains(&"TO");
7011  if !has_from_or_to {
7012    return Some(&[("FROM", "FROM <source>"), ("TO", "TO <destination>")]);
7013  }
7014  // After STDIN/STDOUT/<file>/PROGRAM body -> WITH | DELIMITER | etc.
7015  if matches!(last, "STDIN" | "STDOUT") || last.ends_with('\'') {
7016    return Some(&[
7017      ("WITH", "WITH (<options>) -- group all options in one paren list"),
7018      ("DELIMITER", "DELIMITER '<char>'"),
7019      ("HEADER", "HEADER -- skip first row on COPY FROM, write on COPY TO"),
7020      ("CSV", "CSV -- shorthand for FORMAT CSV"),
7021      ("BINARY", "BINARY -- shorthand for FORMAT BINARY"),
7022      ("FREEZE", "FREEZE -- mark imported tuples as already committed"),
7023      ("NULL", "NULL '<text>' -- literal that means NULL"),
7024      ("QUOTE", "QUOTE '<char>'"),
7025      ("ESCAPE", "ESCAPE '<char>'"),
7026      ("ENCODING", "ENCODING '<name>'"),
7027    ]);
7028  }
7029  None
7030}
7031
7032/// DO $$ ... $$ phase detector. Triggered when the cursor sits right
7033/// after `DO ` (the dollar-quoted code body is handled by the PL/pgSQL
7034/// in-body detector; this is the LANGUAGE / dollar-tag slot before the
7035/// body opens).
7036pub(crate) fn do_block_next_keyword(source: &str, offset: TextSize) -> Option<&'static [(&'static str, &'static str)]> {
7037  if cursor_not_at_ws_boundary(source, offset) {
7038    return None;
7039  }
7040  let (slice_owned, upper) = stmt_slice_upper(source, offset);
7041  let _ = slice_owned;
7042  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
7043  if words.first() != Some(&"DO") {
7044    return None;
7045  }
7046  let n = words.len();
7047  // `DO <cursor>` -> LANGUAGE / dollar-quoted code start hint.
7048  if n == 1 {
7049    return Some(&[
7050      ("LANGUAGE", "LANGUAGE plpgsql/sql -- explicit (default is plpgsql)"),
7051      ("$$", "$$ BEGIN ... END; $$ -- anonymous code block"),
7052    ]);
7053  }
7054  if matches!(words.last(), Some(&"LANGUAGE")) {
7055    return Some(&[
7056      ("plpgsql", "plpgsql -- procedural Postgres"),
7057      ("sql", "sql -- pure SQL function body"),
7058      ("plpython3u", "plpython3u -- Python 3 (untrusted)"),
7059      ("plperl", "plperl -- Perl"),
7060      ("pltcl", "pltcl -- Tcl"),
7061    ]);
7062  }
7063  None
7064}
7065
7066/// CREATE / ALTER ROLE | USER phase detector. After `<name>` or `WITH`,
7067/// emits role attribute keywords (LOGIN, NOLOGIN, SUPERUSER, PASSWORD,
7068/// VALID UNTIL, IN ROLE, IN GROUP, ADMIN, INHERIT, BYPASSRLS, REPLICATION,
7069/// CREATEDB, CREATEROLE, CONNECTION LIMIT, ENCRYPTED PASSWORD).
7070pub(crate) fn role_next_keyword(source: &str, offset: TextSize) -> Option<&'static [(&'static str, &'static str)]> {
7071  if cursor_not_at_ws_boundary(source, offset) {
7072    return None;
7073  }
7074  let (slice_owned, upper) = stmt_slice_upper(source, offset);
7075  let _ = slice_owned;
7076  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
7077  if words.len() < 2 || !matches!(words[0], "CREATE" | "ALTER") {
7078    return None;
7079  }
7080  if !matches!(words[1], "ROLE" | "USER" | "GROUP") {
7081    return None;
7082  }
7083  // CREATE ROLE alice <cursor>  or  ALTER ROLE alice WITH <cursor>  or
7084  // CREATE ROLE alice WITH PASSWORD <cursor> -> need value (skip emit).
7085  let last = *words.last()?;
7086  // After PASSWORD / ENCRYPTED PASSWORD / VALID UNTIL we expect a literal
7087  // value typed by the user. Stay silent there.
7088  if matches!(last, "PASSWORD" | "UNTIL" | "LIMIT" | "ROLE" | "GROUP" | "ADMIN") && words.len() >= 3 {
7089    if last == "ROLE" && words[words.len() - 2] == "IN" {
7090      return None;
7091    }
7092    if last == "GROUP" && words[words.len() - 2] == "IN" {
7093      return None;
7094    }
7095  }
7096  // Need at least 3 words: CREATE/ALTER + ROLE/USER + <name>
7097  if words.len() < 3 {
7098    return None;
7099  }
7100  // Allowed slots: directly after name (n==3) or after WITH (last=="WITH")
7101  // or after any previously-emitted attribute keyword. Always emit the
7102  // full attribute menu -- client filters by prefix.
7103  Some(&[
7104    ("WITH", "WITH <attr_list> -- introduces role attributes"),
7105    ("LOGIN", "LOGIN -- can authenticate"),
7106    ("NOLOGIN", "NOLOGIN -- group-only role"),
7107    ("SUPERUSER", "SUPERUSER -- bypass every permission check"),
7108    ("NOSUPERUSER", "NOSUPERUSER -- not a superuser (default)"),
7109    ("CREATEDB", "CREATEDB -- can create databases"),
7110    ("NOCREATEDB", "NOCREATEDB -- cannot create databases (default)"),
7111    ("CREATEROLE", "CREATEROLE -- can create/manage other roles"),
7112    ("NOCREATEROLE", "NOCREATEROLE -- default"),
7113    ("INHERIT", "INHERIT -- auto-inherit privs from member-of roles (default)"),
7114    ("NOINHERIT", "NOINHERIT -- require explicit SET ROLE"),
7115    ("REPLICATION", "REPLICATION -- can initiate streaming replication"),
7116    ("NOREPLICATION", "NOREPLICATION -- default"),
7117    ("BYPASSRLS", "BYPASSRLS -- bypass row-level security"),
7118    ("NOBYPASSRLS", "NOBYPASSRLS -- default"),
7119    ("PASSWORD", "PASSWORD '<text>' -- role password"),
7120    ("ENCRYPTED PASSWORD", "ENCRYPTED PASSWORD '<text>' -- pre-hashed password"),
7121    ("VALID UNTIL", "VALID UNTIL '<timestamptz>' -- expiry"),
7122    ("CONNECTION LIMIT", "CONNECTION LIMIT <n> -- per-role parallel session cap"),
7123    ("IN ROLE", "IN ROLE <r>[, ...] -- inherit from these roles"),
7124    ("IN GROUP", "IN GROUP <r>[, ...] -- SQL-standard alias for IN ROLE"),
7125    ("ROLE", "ROLE <r>[, ...] -- members of THIS role"),
7126    ("ADMIN", "ADMIN <r>[, ...] -- members with WITH ADMIN OPTION"),
7127    ("USER", "USER <r>[, ...] -- alias for ROLE"),
7128    ("SYSID", "SYSID <oid> -- legacy; ignored"),
7129  ])
7130}
7131
7132/// True when the cursor sits inside the `WHEN (...)` paren of a
7133/// CREATE TRIGGER statement. Returns the trigger's target table name
7134/// so the engine can pull column entries (and `OLD.<col>`/`NEW.<col>`
7135/// row-alias suggestions) for that table.
7136pub(crate) fn create_trigger_when_table(source: &str, offset: TextSize) -> Option<String> {
7137  let (slice_owned, upper) = stmt_slice_upper(source, offset);
7138  let slice = slice_owned.as_str();
7139  if !upper.contains("CREATE") || !upper.contains("TRIGGER") {
7140    return None;
7141  }
7142  // Find the WHEN keyword (whole-word, case-insensitive) before the cursor.
7143  let bytes = upper.as_bytes();
7144  let mut from = 0usize;
7145  let mut when_at: Option<usize> = None;
7146  while let Some(rel) = upper[from..].find("WHEN") {
7147    let at = from + rel;
7148    let prev_ok = at == 0 || !(bytes[at - 1].is_ascii_alphanumeric() || bytes[at - 1] == b'_');
7149    let next_ok = at + 4 >= bytes.len() || !(bytes[at + 4].is_ascii_alphanumeric() || bytes[at + 4] == b'_');
7150    if prev_ok && next_ok {
7151      when_at = Some(at);
7152    }
7153    from = at + 4;
7154  }
7155  let when_at = when_at?;
7156  // Cursor must sit inside the WHEN paren -- look for `(` after WHEN
7157  // and verify paren depth > 0 at the cursor.
7158  let after_when = &slice[when_at + 4..];
7159  let paren_open = after_when.find('(')?;
7160  let mut depth = 0i32;
7161  for c in after_when[paren_open..].chars() {
7162    match c {
7163      '(' => depth += 1,
7164      ')' => depth -= 1,
7165      _ => {},
7166    }
7167  }
7168  if depth <= 0 {
7169    return None;
7170  }
7171  // Pull the target table from `ON <tbl>` between TRIGGER and WHEN.
7172  let on_rel = upper[..when_at].rfind(" ON ")?;
7173  let tbl_start = on_rel + 4;
7174  let tbl_str: String =
7175    upper[tbl_start..].chars().take_while(|c| c.is_alphanumeric() || *c == '_' || *c == '.').collect();
7176  let tbl = tbl_str.rsplit('.').next().unwrap_or(&tbl_str).to_ascii_lowercase();
7177  if tbl.is_empty() {
7178    return None;
7179  }
7180  Some(tbl)
7181}
7182
7183/// CREATE [OR REPLACE] TRIGGER phase detector. Slot chain after the
7184/// trigger name + ON table is reached:
7185///   CREATE TRIGGER <name> <cursor> -> BEFORE / AFTER / INSTEAD OF
7186///   ... BEFORE <cursor> -> INSERT / UPDATE / DELETE / TRUNCATE
7187///   ... <event> <cursor> -> OR (chain another event) | ON
7188///   ... ON <tbl> <cursor> -> FROM | DEFERRABLE | NOT DEFERRABLE | FOR | WHEN | EXECUTE
7189///   ... FOR <cursor> -> EACH
7190///   ... FOR EACH <cursor> -> ROW | STATEMENT
7191///   ... FOR EACH ROW <cursor> -> WHEN | EXECUTE
7192///   ... WHEN <cursor>  -- expression context; stay silent
7193///   ... EXECUTE <cursor> -> FUNCTION | PROCEDURE
7194pub(crate) fn create_trigger_next_keyword(
7195  source: &str,
7196  offset: TextSize,
7197) -> Option<&'static [(&'static str, &'static str)]> {
7198  if cursor_not_at_ws_boundary(source, offset) {
7199    return None;
7200  }
7201  let (slice_owned, upper) = stmt_slice_upper(source, offset);
7202  let slice = slice_owned.as_str();
7203  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
7204  // CREATE [OR REPLACE] [CONSTRAINT] TRIGGER <name> ...
7205  let trigger_idx = words.iter().position(|w| *w == "TRIGGER")?;
7206  if !words[..trigger_idx].iter().all(|w| matches!(*w, "CREATE" | "OR" | "REPLACE" | "CONSTRAINT"))
7207    || words[0] != "CREATE"
7208  {
7209    return None;
7210  }
7211  let after_kw = &words[trigger_idx + 1..];
7212  if after_kw.is_empty() {
7213    return None;
7214  }
7215  // First word after TRIGGER is the trigger name. Slot chain starts at
7216  // position 1 of `after_kw`.
7217  if after_kw.len() == 1 {
7218    return None;
7219  }
7220  let tail = &after_kw[1..]; // drop the trigger name
7221  // tail empty here means cursor is right after <name>.
7222  if tail.is_empty() || !slice.ends_with(char::is_whitespace) {
7223    return Some(&[
7224      ("BEFORE", "BEFORE <event> ON <table>"),
7225      ("AFTER", "AFTER <event> ON <table>"),
7226      ("INSTEAD OF", "INSTEAD OF <event> ON <view>"),
7227    ]);
7228  }
7229  let last = *tail.last()?;
7230  let upper_tail: Vec<&str> = tail.to_vec();
7231  // EXECUTE <cursor>
7232  if last == "EXECUTE" {
7233    return Some(&[
7234      ("FUNCTION", "EXECUTE FUNCTION <fn>(<args>)"),
7235      ("PROCEDURE", "EXECUTE PROCEDURE <fn>(<args>) -- pre-PG11"),
7236    ]);
7237  }
7238  // FOR / FOR EACH
7239  if last == "FOR" {
7240    return Some(&[("EACH", "FOR EACH ROW | STATEMENT")]);
7241  }
7242  if last == "EACH" {
7243    return Some(&[
7244      ("ROW", "FOR EACH ROW -- per-row trigger"),
7245      ("STATEMENT", "FOR EACH STATEMENT -- one fire per statement"),
7246    ]);
7247  }
7248  if matches!(last, "ROW" | "STATEMENT") && upper_tail.contains(&"EACH") {
7249    return Some(&[
7250      ("WHEN", "WHEN (<predicate>) -- conditional"),
7251      ("EXECUTE", "EXECUTE {FUNCTION|PROCEDURE} <fn>(<args>)"),
7252    ]);
7253  }
7254  // After BEFORE/AFTER/INSTEAD OF, expect an event keyword.
7255  if matches!(last, "BEFORE" | "AFTER") {
7256    return Some(&[
7257      ("INSERT", "INSERT -- fire on INSERT"),
7258      ("UPDATE", "UPDATE -- fire on UPDATE"),
7259      ("DELETE", "DELETE -- fire on DELETE"),
7260      ("TRUNCATE", "TRUNCATE -- fire on TRUNCATE (statement-level only)"),
7261    ]);
7262  }
7263  if matches!(last, "OF") && upper_tail.contains(&"INSTEAD") {
7264    return Some(&[("INSERT", "INSERT"), ("UPDATE", "UPDATE"), ("DELETE", "DELETE")]);
7265  }
7266  // After an event word, chain via OR <event> or ON <table>.
7267  if matches!(last, "INSERT" | "UPDATE" | "DELETE" | "TRUNCATE") {
7268    return Some(&[
7269      ("ON", "ON <table>"),
7270      ("OR", "OR <event> -- chain another event"),
7271      ("OF", "UPDATE OF <col>[, ...] -- column-list-scoped UPDATE event"),
7272    ]);
7273  }
7274  // REFERENCING chain: REFERENCING { OLD | NEW } TABLE [AS] <alias> [...]
7275  if last == "REFERENCING" {
7276    return Some(&[
7277      ("OLD TABLE AS", "OLD TABLE AS <old_rows_alias>"),
7278      ("NEW TABLE AS", "NEW TABLE AS <new_rows_alias>"),
7279    ]);
7280  }
7281  if matches!(last, "OLD" | "NEW") && upper_tail.contains(&"REFERENCING") {
7282    return Some(&[("TABLE AS", "TABLE AS <alias_name>")]);
7283  }
7284  if last == "TABLE" && upper_tail.contains(&"REFERENCING") {
7285    return Some(&[("AS", "AS <alias_name>")]);
7286  }
7287  // After ON <tbl>, expect FROM / DEFERRABLE / FOR / WHEN / EXECUTE / REFERENCING.
7288  if upper_tail.contains(&"ON") && !upper_tail.contains(&"FOR") && !upper_tail.contains(&"EXECUTE") {
7289    return Some(&[
7290      ("FROM", "FROM <referenced_table> -- only on CONSTRAINT triggers"),
7291      ("DEFERRABLE", "DEFERRABLE -- CONSTRAINT trigger only"),
7292      ("NOT DEFERRABLE", "NOT DEFERRABLE (default)"),
7293      ("INITIALLY DEFERRED", "INITIALLY DEFERRED"),
7294      ("INITIALLY IMMEDIATE", "INITIALLY IMMEDIATE (default)"),
7295      ("REFERENCING", "REFERENCING OLD/NEW TABLE AS <name>"),
7296      ("FOR", "FOR EACH {ROW|STATEMENT}"),
7297      ("WHEN", "WHEN (<predicate>) -- conditional"),
7298      ("EXECUTE", "EXECUTE {FUNCTION|PROCEDURE} <fn>()"),
7299    ]);
7300  }
7301  None
7302}
7303
7304/// CREATE INDEX phase detector. Handles slots NOT covered by the
7305/// existing `create_index::detect` (which routes inside-paren / ON
7306/// slots). Adds: after-table-no-paren -> USING|(; after-USING -> method;
7307/// after-closing-paren -> INCLUDE | NULLS [NOT] DISTINCT | WITH |
7308/// TABLESPACE | WHERE.
7309pub(crate) fn create_index_next_keyword(
7310  source: &str,
7311  offset: TextSize,
7312) -> Option<&'static [(&'static str, &'static str)]> {
7313  if cursor_not_at_ws_boundary(source, offset) {
7314    return None;
7315  }
7316  let (slice_owned, upper) = stmt_slice_upper(source, offset);
7317  let slice = slice_owned.as_str();
7318  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
7319  let starts_index = words.starts_with(&["CREATE", "INDEX"])
7320    || words.starts_with(&["CREATE", "UNIQUE", "INDEX"])
7321    || (words.len() >= 3 && words[0] == "CREATE" && words[1] == "INDEX" && words[2] == "CONCURRENTLY")
7322    || (words.len() >= 4
7323      && words[0] == "CREATE"
7324      && words[1] == "UNIQUE"
7325      && words[2] == "INDEX"
7326      && words[3] == "CONCURRENTLY");
7327  if !starts_index {
7328    return None;
7329  }
7330  // After USING <cursor> -> emit method names.
7331  if matches!(words.last(), Some(&"USING")) {
7332    return Some(&[
7333      ("btree", "B-tree (default) -- equality + range"),
7334      ("hash", "Hash -- equality only"),
7335      ("gist", "GiST -- geometric / range / fts / array"),
7336      ("gin", "GIN -- inverted index for arrays / jsonb / fts"),
7337      ("brin", "BRIN -- block-range, small index for sorted big tables"),
7338      ("spgist", "SP-GiST -- space-partitioned GiST"),
7339    ]);
7340  }
7341  // After closing `)` of the column list -> trailing-clause keywords.
7342  // Heuristic: paren depth at cursor == 0 AND a USING-or-paren run has
7343  // appeared before the cursor.
7344  let has_on = words.contains(&"ON");
7345  let opens = slice.matches('(').count();
7346  let closes = slice.matches(')').count();
7347  if has_on && opens > 0 && closes >= opens && slice.trim_end().ends_with(')') {
7348    return Some(&[
7349      ("INCLUDE", "INCLUDE (<cols>) -- non-key columns stored on leaf (PG11+)"),
7350      ("NULLS DISTINCT", "NULLS DISTINCT -- treat NULLs as different (default for non-unique)"),
7351      ("NULLS NOT DISTINCT", "NULLS NOT DISTINCT -- treat all NULLs as equal in UNIQUE (PG15+)"),
7352      ("WITH", "WITH (<storage_params>) -- e.g. fillfactor = 80"),
7353      ("TABLESPACE", "TABLESPACE <name> -- pin index storage"),
7354      ("WHERE", "WHERE <predicate> -- partial index"),
7355    ]);
7356  }
7357  None
7358}
7359
7360/// ALTER TYPE phase detector. PG syntax:
7361///   ALTER TYPE <name> ADD VALUE [IF NOT EXISTS] 'newval' [BEFORE|AFTER 'existing']
7362///   ALTER TYPE <name> RENAME VALUE 'old' TO 'new'
7363///   ALTER TYPE <name> RENAME TO <new>
7364///   ALTER TYPE <name> OWNER TO <role>
7365///   ALTER TYPE <name> SET SCHEMA <schema>
7366///   ALTER TYPE <name> ADD ATTRIBUTE <name> <type> [CASCADE|RESTRICT]
7367pub(crate) fn alter_type_next_keyword(
7368  source: &str,
7369  offset: TextSize,
7370) -> Option<&'static [(&'static str, &'static str)]> {
7371  if cursor_not_at_ws_boundary(source, offset) {
7372    return None;
7373  }
7374  let (slice_owned, _) = stmt_slice_upper(source, offset);
7375  let slice = slice_owned.trim();
7376  let upper = slice.to_ascii_uppercase();
7377  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
7378  if words.len() < 2 || words[0] != "ALTER" || words[1] != "TYPE" {
7379    return None;
7380  }
7381  let n = words.len();
7382  // ALTER TYPE <name> <cursor>
7383  if n == 3 {
7384    return Some(&[
7385      ("ADD VALUE", "ADD VALUE [IF NOT EXISTS] '<lit>' [BEFORE|AFTER '<existing>']"),
7386      ("RENAME VALUE", "RENAME VALUE '<old>' TO '<new>'"),
7387      ("RENAME TO", "RENAME TO <new_type_name>"),
7388      ("OWNER TO", "OWNER TO <role>"),
7389      ("SET SCHEMA", "SET SCHEMA <schema>"),
7390      ("ADD ATTRIBUTE", "ADD ATTRIBUTE <name> <type> [CASCADE|RESTRICT]"),
7391      ("DROP ATTRIBUTE", "DROP ATTRIBUTE [IF EXISTS] <name> [CASCADE|RESTRICT]"),
7392      ("ALTER ATTRIBUTE", "ALTER ATTRIBUTE <name> [SET DATA] TYPE <type>"),
7393    ]);
7394  }
7395  // ALTER TYPE <name> ADD <cursor>
7396  if n == 4 && words[3] == "ADD" {
7397    return Some(&[("VALUE", "VALUE [IF NOT EXISTS] '<lit>'"), ("ATTRIBUTE", "ATTRIBUTE <name> <type>")]);
7398  }
7399  // ALTER TYPE <name> ADD VALUE <cursor> -> IF NOT EXISTS
7400  if n == 5 && words[3] == "ADD" && words[4] == "VALUE" {
7401    return Some(&[("IF NOT EXISTS", "IF NOT EXISTS '<lit>' -- silently skip if value already present")]);
7402  }
7403  // ALTER TYPE <name> ADD VALUE 'lit' <cursor> -> BEFORE|AFTER
7404  if n >= 6 && words[3] == "ADD" && words[4] == "VALUE" && !words.contains(&"BEFORE") && !words.contains(&"AFTER") {
7405    let last = words.last()?;
7406    if last.starts_with('\'') && last.ends_with('\'') {
7407      return Some(&[
7408        ("BEFORE", "BEFORE '<existing>' -- insert before this value"),
7409        ("AFTER", "AFTER '<existing>' -- insert after this value"),
7410      ]);
7411    }
7412  }
7413  // ALTER TYPE <name> RENAME <cursor>
7414  if n == 4 && words[3] == "RENAME" {
7415    return Some(&[
7416      ("VALUE", "VALUE '<old>' TO '<new>'"),
7417      ("TO", "TO <new_type_name>"),
7418      ("ATTRIBUTE", "ATTRIBUTE <old> TO <new>"),
7419    ]);
7420  }
7421  // ALTER TYPE <name> RENAME VALUE 'lit' <cursor>
7422  if n == 6 && words[3] == "RENAME" && words[4] == "VALUE" {
7423    return Some(&[("TO", "TO '<new>' -- new value literal")]);
7424  }
7425  // ALTER TYPE <name> SET <cursor>
7426  if n == 4 && words[3] == "SET" {
7427    return Some(&[("SCHEMA", "SCHEMA <schema_name>")]);
7428  }
7429  // ALTER TYPE <name> OWNER <cursor>
7430  if n == 4 && words[3] == "OWNER" {
7431    return Some(&[("TO", "TO <role>")]);
7432  }
7433  None
7434}
7435
7436/// MERGE statement phase detector. Walks the trailing tokens of the
7437/// statement at the cursor and returns the next legal keyword slot, if
7438/// the statement is a MERGE. Returns None on non-MERGE or when the
7439/// cursor sits in an expression / identifier slot the generic engine
7440/// handles already.
7441/// True when the cursor sits at `MERGE ... THEN UPDATE SET <col> =
7442/// <cursor>` -- the RHS expression slot. Detect by walking back: the
7443/// last `=` token (word-bounded) sits between SET and the cursor, and
7444/// the statement starts with MERGE.
7445/// True when the cursor sits at `MERGE ... THEN UPDATE SET <cursor>`
7446/// or `... SET col=v, <cursor>` — the LHS column slot. Distinguished
7447/// from RHS by: SET present, and either no `=` after SET yet, OR the
7448/// last word is a comma-trailing comma terminator (so a new assignment
7449/// is starting).
7450/// DROP USER MAPPING follow-up:
7451///   DROP USER MAPPING <cursor>             -> FOR / IF EXISTS
7452///   DROP USER MAPPING IF EXISTS <cursor>   -> FOR
7453///   DROP USER MAPPING FOR <cursor>         -> CURRENT_USER/CURRENT_ROLE/PUBLIC/USER
7454///   DROP USER MAPPING FOR <role> <cursor>  -> SERVER
7455pub(crate) fn drop_user_mapping_next_keyword(
7456  source: &str,
7457  offset: TextSize,
7458) -> Option<&'static [(&'static str, &'static str)]> {
7459  if cursor_not_at_ws_boundary(source, offset) {
7460    return None;
7461  }
7462  let (_, upper) = stmt_slice_upper(source, offset);
7463  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
7464  if words.len() < 3 || words[0] != "DROP" || words[1] != "USER" || words[2] != "MAPPING" {
7465    return None;
7466  }
7467  let last = *words.last()?;
7468  if last == "MAPPING" {
7469    return Some(&[("FOR", "FOR <role> SERVER <srv>"), ("IF EXISTS", "IF EXISTS FOR <role> SERVER <srv>")]);
7470  }
7471  if last == "EXISTS" && words.contains(&"IF") {
7472    return Some(&[("FOR", "FOR <role> SERVER <srv>")]);
7473  }
7474  if last == "FOR" {
7475    return Some(&[
7476      ("CURRENT_USER", "FOR CURRENT_USER"),
7477      ("CURRENT_ROLE", "FOR CURRENT_ROLE"),
7478      ("PUBLIC", "FOR PUBLIC"),
7479      ("USER", "FOR USER -- alias of CURRENT_USER"),
7480    ]);
7481  }
7482  if last == "SERVER" {
7483    return None; // user types server name
7484  }
7485  if words.contains(&"FOR") && !words.contains(&"SERVER") {
7486    return Some(&[("SERVER", "SERVER <name>")]);
7487  }
7488  None
7489}
7490
7491pub(crate) fn after_top_level_drop_keyword(
7492  source: &str,
7493  offset: TextSize,
7494) -> Option<&'static [(&'static str, &'static str)]> {
7495  if cursor_not_at_ws_boundary(source, offset) {
7496    return None;
7497  }
7498  let (slice_owned, _) = stmt_slice_upper(source, offset);
7499  if !slice_owned.trim().eq_ignore_ascii_case("DROP") {
7500    return None;
7501  }
7502  Some(&[
7503    ("TABLE", "DROP TABLE [IF EXISTS] <name> [CASCADE|RESTRICT]"),
7504    ("VIEW", "DROP VIEW [IF EXISTS] <name> [CASCADE|RESTRICT]"),
7505    ("MATERIALIZED VIEW", "DROP MATERIALIZED VIEW [IF EXISTS] <name>"),
7506    ("INDEX", "DROP INDEX [CONCURRENTLY] [IF EXISTS] <name>"),
7507    ("SEQUENCE", "DROP SEQUENCE [IF EXISTS] <name>"),
7508    ("SCHEMA", "DROP SCHEMA [IF EXISTS] <name> [CASCADE|RESTRICT]"),
7509    ("FUNCTION", "DROP FUNCTION [IF EXISTS] <name>(args)"),
7510    ("PROCEDURE", "DROP PROCEDURE [IF EXISTS] <name>(args)"),
7511    ("TRIGGER", "DROP TRIGGER [IF EXISTS] <name> ON <table>"),
7512    ("TYPE", "DROP TYPE [IF EXISTS] <name> [CASCADE|RESTRICT]"),
7513    ("ROLE", "DROP ROLE [IF EXISTS] <name>"),
7514    ("USER", "DROP USER [IF EXISTS] <name>"),
7515    ("DATABASE", "DROP DATABASE [IF EXISTS] <name>"),
7516    ("EXTENSION", "DROP EXTENSION [IF EXISTS] <name> [CASCADE]"),
7517    ("POLICY", "DROP POLICY [IF EXISTS] <name> ON <table>"),
7518    ("DOMAIN", "DROP DOMAIN [IF EXISTS] <name>"),
7519    ("AGGREGATE", "DROP AGGREGATE [IF EXISTS] <name>(args)"),
7520    ("CAST", "DROP CAST [IF EXISTS] (src AS dst)"),
7521    ("COLLATION", "DROP COLLATION [IF EXISTS] <name>"),
7522    ("OPERATOR", "DROP OPERATOR [IF EXISTS] <op>(args)"),
7523    ("RULE", "DROP RULE [IF EXISTS] <name> ON <table>"),
7524    ("TABLESPACE", "DROP TABLESPACE [IF EXISTS] <name>"),
7525    ("SUBSCRIPTION", "DROP SUBSCRIPTION [IF EXISTS] <name>"),
7526    ("PUBLICATION", "DROP PUBLICATION [IF EXISTS] <name>"),
7527    ("FOREIGN TABLE", "DROP FOREIGN TABLE [IF EXISTS] <name>"),
7528    ("FOREIGN DATA WRAPPER", "DROP FOREIGN DATA WRAPPER [IF EXISTS] <name>"),
7529    ("SERVER", "DROP SERVER [IF EXISTS] <name>"),
7530    ("ROUTINE", "DROP ROUTINE [IF EXISTS] <name>(args)"),
7531    ("OPERATOR CLASS", "DROP OPERATOR CLASS [IF EXISTS] <name> USING <am>"),
7532    ("OPERATOR FAMILY", "DROP OPERATOR FAMILY [IF EXISTS] <name> USING <am>"),
7533    ("STATISTICS", "DROP STATISTICS [IF EXISTS] <name>"),
7534    ("ACCESS METHOD", "DROP ACCESS METHOD [IF EXISTS] <name>"),
7535    ("LANGUAGE", "DROP LANGUAGE [IF EXISTS] <name>"),
7536    ("CONVERSION", "DROP CONVERSION [IF EXISTS] <name>"),
7537    ("EVENT TRIGGER", "DROP EVENT TRIGGER [IF EXISTS] <name>"),
7538    ("TRANSFORM", "DROP TRANSFORM FOR <type> LANGUAGE <lang>"),
7539    ("TEXT SEARCH CONFIGURATION", "DROP TEXT SEARCH CONFIGURATION [IF EXISTS] <name>"),
7540    ("TEXT SEARCH DICTIONARY", "DROP TEXT SEARCH DICTIONARY [IF EXISTS] <name>"),
7541    ("TEXT SEARCH PARSER", "DROP TEXT SEARCH PARSER [IF EXISTS] <name>"),
7542    ("TEXT SEARCH TEMPLATE", "DROP TEXT SEARCH TEMPLATE [IF EXISTS] <name>"),
7543    ("OWNED", "DROP OWNED BY <role>[, ...] [CASCADE|RESTRICT]"),
7544    ("MAPPING", "DROP USER MAPPING [IF EXISTS] FOR <role> SERVER <srv>"),
7545  ])
7546}
7547
7548/// True when the cursor in an `ALTER TABLE <t> <ACTION> <cursor>`
7549/// statement is right after a top-level action keyword (ADD / DROP /
7550/// RENAME / nested ALTER) and should narrow to that action's
7551/// sub-keywords (COLUMN / CONSTRAINT / TO / ...). Returns None when
7552/// the cursor is elsewhere (e.g. mid-name, after the sub-keyword,
7553/// inside a column declaration), letting other branches handle it.
7554pub(crate) fn alter_table_subaction_at(
7555  source: &str,
7556  offset: TextSize,
7557) -> Option<&'static [(&'static str, &'static str)]> {
7558  let pos: usize = (u32::from(offset) as usize).min(source.len());
7559  let bytes = source.as_bytes();
7560  // Walk back through trailing whitespace.
7561  let mut end = pos;
7562  while end > 0 && bytes[end - 1].is_ascii_whitespace() {
7563    end -= 1;
7564  }
7565  // Read the previous word.
7566  let mut start = end;
7567  while start > 0 {
7568    let b = bytes[start - 1];
7569    if !(b.is_ascii_alphanumeric() || b == b'_') {
7570      break;
7571    }
7572    start -= 1;
7573  }
7574  if start == end {
7575    return None;
7576  }
7577  let word = source[start..end].to_ascii_uppercase();
7578  // The cursor must sit after that word with only whitespace between
7579  // (no partial third token).
7580  if end > pos || pos != end + (pos - end) {
7581    // (sanity) end <= pos by construction; the cursor at `end` (zero ws)
7582    // also counts as "right after the word".
7583  }
7584  let between = &source[end..pos];
7585  if !between.chars().all(|c| c.is_ascii_whitespace()) {
7586    return None;
7587  }
7588  // Also: the word before should NOT itself be ADD/DROP/RENAME/ALTER
7589  // (which would mean we're past the sub-keyword slot already, e.g.
7590  // `ALTER TABLE users ADD COLUMN` -- cursor here is column-name slot,
7591  // not sub-keyword slot).
7592  let mut prev_end = start;
7593  while prev_end > 0 && bytes[prev_end - 1].is_ascii_whitespace() {
7594    prev_end -= 1;
7595  }
7596  let mut prev_start = prev_end;
7597  while prev_start > 0 {
7598    let b = bytes[prev_start - 1];
7599    if !(b.is_ascii_alphanumeric() || b == b'_') {
7600      break;
7601    }
7602    prev_start -= 1;
7603  }
7604  let prev_word = if prev_start < prev_end { source[prev_start..prev_end].to_ascii_uppercase() } else { String::new() };
7605  if matches!(prev_word.as_str(), "ADD" | "DROP" | "RENAME" | "ALTER") {
7606    return None;
7607  }
7608  match word.as_str() {
7609    "ADD" => Some(&[
7610      ("COLUMN", "ADD COLUMN <name> <type>"),
7611      ("CONSTRAINT", "ADD CONSTRAINT <name> <kind>"),
7612      ("PRIMARY KEY", "ADD PRIMARY KEY (cols)"),
7613      ("UNIQUE", "ADD UNIQUE (cols)"),
7614      ("FOREIGN KEY", "ADD FOREIGN KEY (col) REFERENCES other(col)"),
7615      ("CHECK", "ADD CHECK (predicate)"),
7616      ("EXCLUDE", "ADD EXCLUDE USING gist (col WITH op)"),
7617    ]),
7618    "DROP" => Some(&[
7619      ("COLUMN", "DROP COLUMN <name> [CASCADE|RESTRICT]"),
7620      ("CONSTRAINT", "DROP CONSTRAINT <name> [CASCADE|RESTRICT]"),
7621    ]),
7622    "RENAME" => Some(&[
7623      ("COLUMN", "RENAME COLUMN <old> TO <new>"),
7624      ("CONSTRAINT", "RENAME CONSTRAINT <old> TO <new>"),
7625      ("TO", "RENAME TO <new_table>"),
7626    ]),
7627    "ALTER" => {
7628      Some(&[("COLUMN", "ALTER COLUMN <name> <action>"), ("CONSTRAINT", "ALTER CONSTRAINT <name> DEFERRABLE|...]")])
7629    },
7630    // OWNER TO <role> -- top-level ALTER TABLE action.
7631    "OWNER" => Some(&[("TO", "OWNER TO <role>")]),
7632    // NULLS NOT DISTINCT inside a UNIQUE/PRIMARY KEY constraint.
7633    "NULLS" => Some(&[("NOT DISTINCT", "NULLS NOT DISTINCT -- treat NULLs as equal for uniqueness")]),
7634    _ => None,
7635  }
7636}
7637
7638/// True when the cursor sits at `CAST(<expr> AS <cursor>` -- the next
7639/// legal token is a type identifier. Walks back to the nearest
7640/// unmatched `(` and checks the preceding word.
7641pub(crate) fn cast_as_expects_type(source: &str, offset: TextSize) -> bool {
7642  let pos: usize = (u32::from(offset) as usize).min(source.len());
7643  let bytes = source.as_bytes();
7644  // Walk back to the unmatched open paren.
7645  let mut depth = 0i32;
7646  let mut i = pos;
7647  while i > 0 {
7648    i -= 1;
7649    match bytes[i] {
7650      b')' => depth += 1,
7651      b'(' => {
7652        if depth == 0 {
7653          break;
7654        }
7655        depth -= 1;
7656      },
7657      _ => {},
7658    }
7659  }
7660  if i == 0 && bytes.first() != Some(&b'(') {
7661    return false;
7662  }
7663  // i is the open paren. The preceding word should be CAST.
7664  let mut e = i;
7665  while e > 0 && bytes[e - 1].is_ascii_whitespace() {
7666    e -= 1;
7667  }
7668  let mut s = e;
7669  while s > 0 && (bytes[s - 1].is_ascii_alphanumeric() || bytes[s - 1] == b'_') {
7670    s -= 1;
7671  }
7672  if s == e {
7673    return false;
7674  }
7675  let word = &source[s..e];
7676  if !word.eq_ignore_ascii_case("CAST") {
7677    return false;
7678  }
7679  // Inside the paren, the substring between `(` and cursor must contain
7680  // a word-bounded ` AS ` (case-insensitive).
7681  let inside = &source[i + 1..pos];
7682  let inside_upper = inside.to_ascii_uppercase();
7683  inside_upper.contains(" AS ")
7684}
7685
7686/// True when the cursor sits at `ALTER TABLE <t> [NO] INHERIT
7687/// <cursor>` -- the parent-table slot. Without this branch the
7688/// generic action menu fires and re-offers `INHERIT` / `NO INHERIT`,
7689/// which makes no sense after the user has already picked one.
7690/// True when the cursor sits at `ORDER BY <col> [ASC|DESC] NULLS
7691/// <cursor>` -- the trailing keyword is `NULLS` so the next legal
7692/// token is FIRST or LAST.
7693pub(crate) fn order_by_nulls_expects_first_last(source: &str, offset: TextSize) -> bool {
7694  let pos: usize = (u32::from(offset) as usize).min(source.len());
7695  let before = &source[..pos];
7696  if !before.ends_with(char::is_whitespace) {
7697    return false;
7698  }
7699  let upper = before.to_ascii_uppercase();
7700  let trimmed = upper.trim_end();
7701  if !trimmed.ends_with(" NULLS") && trimmed != "NULLS" {
7702    return false;
7703  }
7704  upper.contains("ORDER BY")
7705}
7706
7707pub(crate) fn alter_table_inherit_expects_parent(source: &str, offset: TextSize) -> bool {
7708  let (slice, upper) = stmt_slice_upper(source, offset);
7709  if !slice.ends_with(char::is_whitespace) {
7710    return false;
7711  }
7712  let words: Vec<&str> = upper.split_ascii_whitespace().collect();
7713  if words.first() != Some(&"ALTER") || words.get(1) != Some(&"TABLE") {
7714    return false;
7715  }
7716  let last = words.last().copied();
7717  let second = if words.len() >= 2 { Some(words[words.len() - 2]) } else { None };
7718  matches!(last, Some("INHERIT")) && (second != Some("NO") && second != Some("CHECK") || second == Some("NO"))
7719}
7720
7721pub(crate) fn alter_column_set_value_keywords(
7722  source: &str,
7723  offset: TextSize,
7724) -> Option<&'static [(&'static str, &'static str)]> {
7725  let (slice, upper_full) = stmt_slice_upper(source, offset);
7726  let upper = upper_full.trim_end();
7727  if !upper.contains("ALTER COLUMN") || !slice.ends_with(char::is_whitespace) {
7728    return None;
7729  }
7730  if upper.ends_with(" SET STORAGE") {
7731    return Some(&[
7732      ("PLAIN", "PLAIN -- inline, never TOASTed"),
7733      ("EXTERNAL", "EXTERNAL -- TOAST, no compression"),
7734      ("EXTENDED", "EXTENDED -- TOAST + compression (default for varlena)"),
7735      ("MAIN", "MAIN -- prefer inline, compress before TOAST"),
7736      ("DEFAULT", "DEFAULT -- per-type default"),
7737    ]);
7738  }
7739  if upper.ends_with(" SET COMPRESSION") {
7740    return Some(&[
7741      ("pglz", "pglz -- the original PG compressor (always available)"),
7742      ("lz4", "lz4 -- faster, needs build-time --with-lz4"),
7743      ("default", "default -- inherit per-column / cluster default"),
7744    ]);
7745  }
7746  None
7747}
7748
7749pub(crate) fn alter_column_after_set_subkeyword_expects_silence(source: &str, offset: TextSize) -> bool {
7750  let (slice, upper_full) = stmt_slice_upper(source, offset);
7751  let upper = upper_full.trim_end().to_string();
7752  if !upper.contains("ALTER COLUMN") {
7753    return false;
7754  }
7755  for kw in &[" SET DEFAULT", " SET STATISTICS", " SET STORAGE", " SET COMPRESSION"] {
7756    if upper.ends_with(kw) && slice.ends_with(char::is_whitespace) {
7757      return true;
7758    }
7759  }
7760  false
7761}
7762
7763/// Discriminates SET vs DROP sub-keyword slots within an ALTER COLUMN
7764/// clause.
7765#[derive(Copy, Clone)]
7766pub enum AlterColumnAction {
7767  Set,
7768  Drop,
7769}
7770
7771/// True when the cursor sits at the `ALTER COLUMN <name> SET <cursor>`
7772/// or `... DROP <cursor>` sub-keyword slot. Returns the discriminating
7773/// kind so the caller can emit the appropriate keyword menu.
7774pub(crate) fn alter_column_action_kind(source: &str, offset: TextSize) -> Option<AlterColumnAction> {
7775  let (slice, upper) = stmt_slice_upper(source, offset);
7776  let stmt = slice.as_str();
7777  if !upper.contains("ALTER COLUMN") {
7778    return None;
7779  }
7780  // Trim trailing whitespace so we can match the final keyword exactly.
7781  let trimmed = upper.trim_end();
7782  // The cursor's most recent keyword must be SET or DROP, and that
7783  // keyword must follow an ALTER COLUMN <name> sequence (not just any
7784  // SET / DROP in the statement).
7785  let after_alter_col = upper.rsplit("ALTER COLUMN").next()?;
7786  let after_trim = after_alter_col.trim_end();
7787  // Has a partial type word already been typed after the kind? If so
7788  // we're past the kind slot and should fall through.
7789  if after_trim.ends_with(" SET") && stmt.ends_with(char::is_whitespace) {
7790    return Some(AlterColumnAction::Set);
7791  }
7792  if after_trim.ends_with(" DROP") && stmt.ends_with(char::is_whitespace) {
7793    return Some(AlterColumnAction::Drop);
7794  }
7795  let _ = trimmed;
7796  None
7797}
7798
7799/// True when the cursor sits at the type-expected slot right after a
7800/// freshly-typed column name in `ALTER TABLE <t> ADD COLUMN <name>`.
7801/// The user has finished naming the new column and is now picking its
7802/// type, so the menu should be types-only, not the ADD/DROP action set.
7803pub(crate) fn alter_table_expects_type(source: &str, offset: TextSize) -> bool {
7804  let (slice, upper) = stmt_slice_upper(source, offset);
7805  let stmt = slice.as_str();
7806  // Must be an ALTER TABLE statement with an ADD COLUMN clause.
7807  if !upper.contains("ALTER TABLE") {
7808    return false;
7809  }
7810  let Some(add_at) = upper.rfind("ADD COLUMN") else { return false };
7811  // Tokens following ADD COLUMN. Skip the IF NOT EXISTS modifier.
7812  let after = &stmt[add_at + "ADD COLUMN".len()..];
7813  let mut tokens = after.split_ascii_whitespace().peekable();
7814  // Optional IF NOT EXISTS.
7815  if tokens.peek().is_some_and(|w| w.eq_ignore_ascii_case("IF")) {
7816    tokens.next();
7817    if tokens.peek().is_some_and(|w| w.eq_ignore_ascii_case("NOT")) {
7818      tokens.next();
7819    }
7820    if tokens.peek().is_some_and(|w| w.eq_ignore_ascii_case("EXISTS")) {
7821      tokens.next();
7822    }
7823  }
7824  // The freshly-typed column name. Required.
7825  if tokens.next().is_none() {
7826    return false;
7827  }
7828  // After the name, the slot expects a type. The cursor is in the type
7829  // slot when:
7830  //   - There are no more whitespace-separated tokens (just trailing
7831  //     whitespace after the name), or
7832  //   - The last token is a single partial identifier (no further tokens).
7833  let rest_after_name = stmt[add_at + "ADD COLUMN".len()..].trim_start().split_ascii_whitespace().collect::<Vec<_>>();
7834  // rest_after_name[0] is the name (possibly with IF NOT EXISTS prefix
7835  // tokens already consumed conceptually). We accept the type-slot when
7836  // there's exactly the name and an optional partial type word, with
7837  // the cursor not having moved on to constraint keywords.
7838  // The slot is type-expected if total tokens after ADD COLUMN (minus
7839  // IF NOT EXISTS) is 1 (name) or 2 (name + partial type word).
7840  let mut effective = rest_after_name.iter().peekable();
7841  if effective.peek().is_some_and(|w| w.eq_ignore_ascii_case("IF")) {
7842    effective.next();
7843    if effective.peek().is_some_and(|w| w.eq_ignore_ascii_case("NOT")) {
7844      effective.next();
7845    }
7846    if effective.peek().is_some_and(|w| w.eq_ignore_ascii_case("EXISTS")) {
7847      effective.next();
7848    }
7849  }
7850  let rest: Vec<&&str> = effective.collect();
7851  match rest.len() {
7852    1 => stmt.ends_with(char::is_whitespace), // just the name typed, cursor in fresh type slot
7853    2 => !stmt.ends_with(char::is_whitespace), // name + partial type word being typed
7854    _ => false,
7855  }
7856}
7857
7858/// True when the cursor sits at a target-name slot of a `DROP TABLE`
7859/// / `DROP TABLE IF EXISTS` / `DROP VIEW` / `DROP MATERIALIZED VIEW` /
7860/// `TRUNCATE [TABLE] [ONLY]` statement. Used to bypass the generic
7861/// Unknown catch-all menu that otherwise dumps 600+ items.
7862pub(crate) fn dml_drop_or_truncate_expects_table(source: &str, offset: TextSize) -> bool {
7863  let (slice, upper) = stmt_slice_upper(source, offset);
7864  let stmt = slice.as_str();
7865  let trimmed_upper = upper.trim_start();
7866  // Walk through tokens up to the cursor, skip optional modifiers, and
7867  // confirm we're still in the target-name slot of a recognised kind.
7868  let kinds: &[(&[&str], &[&str])] = &[
7869    (&["DROP", "TABLE"], &["IF", "EXISTS", "ONLY"]),
7870    (&["DROP", "VIEW"], &["IF", "EXISTS"]),
7871    (&["DROP", "MATERIALIZED", "VIEW"], &["IF", "EXISTS"]),
7872    (&["DROP", "SEQUENCE"], &["IF", "EXISTS"]),
7873    (&["DROP", "INDEX"], &["IF", "EXISTS", "CONCURRENTLY"]),
7874    (&["TRUNCATE", "TABLE"], &["ONLY"]),
7875    (&["TRUNCATE"], &["ONLY", "TABLE"]),
7876    // Admin commands whose target is a table-class name.
7877    (&["VACUUM"], &["FULL", "FREEZE", "VERBOSE", "ANALYZE"]),
7878    (&["VACUUM", "ANALYZE"], &["VERBOSE"]),
7879    (&["VACUUM", "FULL"], &["VERBOSE", "ANALYZE"]),
7880    (&["ANALYZE"], &["VERBOSE", "SKIP_LOCKED"]),
7881    (&["COPY"], &[]),
7882    (&["COMMENT", "ON", "TABLE"], &[]),
7883    (&["COMMENT", "ON", "VIEW"], &[]),
7884    (&["COMMENT", "ON", "MATERIALIZED", "VIEW"], &[]),
7885    (&["COMMENT", "ON", "INDEX"], &[]),
7886    (&["COMMENT", "ON", "SEQUENCE"], &[]),
7887    (&["REFRESH", "MATERIALIZED", "VIEW"], &["CONCURRENTLY"]),
7888    (&["LOCK"], &["TABLE"]),
7889    (&["LOCK", "TABLE"], &["ONLY"]),
7890    // (CLUSTER handled by `cluster_next_keyword` -- emits VERBOSE first.)
7891    (&["REINDEX", "TABLE"], &["CONCURRENTLY"]),
7892    (&["REINDEX", "INDEX"], &["CONCURRENTLY"]),
7893    // MERGE INTO <table> -- target table.
7894    (&["MERGE", "INTO"], &["ONLY"]),
7895  ];
7896  let words: Vec<&str> = trimmed_upper.split_ascii_whitespace().collect();
7897  for (kw_seq, mods) in kinds {
7898    if words.len() < kw_seq.len() {
7899      continue;
7900    }
7901    if kw_seq.iter().zip(words.iter()).all(|(k, w)| {
7902      // Strip trailing punctuation/commas so e.g. `users,` still matches.
7903      let cleaned = w.trim_end_matches(|c: char| !c.is_ascii_alphanumeric() && c != '_');
7904      cleaned.eq_ignore_ascii_case(k)
7905    }) {
7906      // Skip optional modifier words; trailing position must still be
7907      // expecting a name (we don't try to be precise about how many
7908      // names have been typed -- the comma case below covers it).
7909      let mut i = kw_seq.len();
7910      while i < words.len() && mods.iter().any(|m| words[i].eq_ignore_ascii_case(m)) {
7911        i += 1;
7912      }
7913      // Cursor at the end of the slice means we're typing a name.
7914      // Allow a trailing partial identifier or a trailing `,` (next
7915      // name in a list).
7916      let ends_with_comma = stmt.trim_end().ends_with(',');
7917      let last_word_is_partial = !stmt.ends_with(char::is_whitespace);
7918      if i >= words.len() || ends_with_comma || last_word_is_partial {
7919        return true;
7920      }
7921    }
7922  }
7923  false
7924}
7925
7926/// Return the ALTER TABLE target table when the cursor sits right
7927/// after a `DROP COLUMN [IF EXISTS]` / `RENAME COLUMN` / `ALTER COLUMN`
7928/// keyword phrase -- the slot that expects an EXISTING column name.
7929/// None otherwise (so the action-keyword menu still fires).
7930pub(crate) fn alter_table_existing_column_target(source: &str, offset: TextSize) -> Option<String> {
7931  let (slice, upper) = stmt_slice_upper(source, offset);
7932  let stmt = slice.as_str();
7933  // Must be an ALTER TABLE statement.
7934  let alter_at = upper.find("ALTER TABLE")?;
7935  // The cursor's nearest preceding column-introducing phrase.
7936  let trimmed = upper.trim_end();
7937  let preceded = |kw: &str| trimmed.ends_with(kw);
7938  let in_column_slot = preceded(" DROP COLUMN")
7939    || preceded(" DROP COLUMN IF EXISTS")
7940    || preceded(" RENAME COLUMN")
7941    || preceded(" ALTER COLUMN");
7942  if !in_column_slot {
7943    return None;
7944  }
7945  // Pull the table name right after `ALTER TABLE [IF EXISTS] [ONLY]`.
7946  let after = alter_at + "ALTER TABLE".len();
7947  let rest = &stmt[after..];
7948  let mut cursor = 0usize;
7949  let mut tokens: Vec<&str> = Vec::new();
7950  for tok in rest.split_ascii_whitespace() {
7951    let tok_pos = rest[cursor..].find(tok).map(|p| cursor + p).unwrap_or(cursor);
7952    cursor = tok_pos + tok.len();
7953    tokens.push(tok);
7954    if tokens.len() >= 4 {
7955      break;
7956    }
7957  }
7958  // Skip optional modifiers, take the first non-modifier token.
7959  let mods: &[&str] = &["IF", "EXISTS", "ONLY"];
7960  let table_tok = tokens.into_iter().find(|t| !mods.iter().any(|m| t.eq_ignore_ascii_case(m)))?;
7961  let table = table_tok.rsplit('.').next().unwrap_or(table_tok).trim_matches('"').trim_end_matches(';').to_string();
7962  if table.is_empty() {
7963    return None;
7964  }
7965  Some(table)
7966}
7967
7968/// Return the DML target table of the statement enclosing `offset`:
7969///   - `INSERT INTO <table> ...` -> `<table>`
7970///   - `UPDATE <table> ...`      -> `<table>`
7971///   - `DELETE FROM <table> ...` -> `<table>`
7972///
7973/// `<table>` may be schema-qualified; the bare name is returned. None
7974/// when no DML target keyword is found in the current statement.
7975pub(crate) fn dml_target_table(source: &str, offset: TextSize) -> Option<String> {
7976  let (slice, upper) = stmt_slice_upper(source, offset);
7977  let stmt = slice.as_str();
7978  let (anchor, kw_len) = if let Some(a) = upper.rfind("INSERT INTO") {
7979    (a, "INSERT INTO".len())
7980  } else if let Some(a) = upper.rfind("DELETE FROM") {
7981    (a, "DELETE FROM".len())
7982  } else {
7983    let a = upper.rfind("UPDATE ")?;
7984    (a, "UPDATE".len())
7985  };
7986  let after = anchor + kw_len;
7987  let rest = &stmt[after..];
7988  let lead = rest.len() - rest.trim_start().len();
7989  let raw = &rest[lead..];
7990  let id_end = raw.find(|c: char| !c.is_ascii_alphanumeric() && c != '_' && c != '.' && c != '"').unwrap_or(raw.len());
7991  let table = raw[..id_end].rsplit('.').next().unwrap_or(&raw[..id_end]).trim_matches('"').to_string();
7992  if table.is_empty() {
7993    return None;
7994  }
7995  Some(table)
7996}
7997
7998/// Walk back from `offset` to find `INSERT INTO <table> (` and return
7999/// the bare table name. None when the cursor isn't inside an INSERT
8000/// column list.
8001/// Just the target table identifier of the buffer's `INSERT INTO`,
8002/// without the cursor-inside-paren-list constraint. Used by EXCLUDED
8003/// virtual-alias resolution (cursor sits past VALUES (...) close paren).
8004pub(crate) fn insert_target_table_name_only(source: &str) -> Option<String> {
8005  let upper = source.to_ascii_uppercase();
8006  let at = upper.rfind("INSERT INTO")?;
8007  let after = at + "INSERT INTO".len();
8008  let rest = &source[after..];
8009  let lead = rest.len() - rest.trim_start().len();
8010  let raw = &rest[lead..];
8011  let id_end = raw.find(|c: char| !c.is_ascii_alphanumeric() && c != '_' && c != '.' && c != '"').unwrap_or(raw.len());
8012  let table = raw[..id_end].rsplit('.').next().unwrap_or(&raw[..id_end]).trim_matches('"').to_string();
8013  if table.is_empty() {
8014    return None;
8015  }
8016  Some(table)
8017}
8018
8019pub(crate) fn insert_target_table(source: &str, offset: TextSize) -> Option<String> {
8020  let (slice, upper) = stmt_slice_upper(source, offset);
8021  let stmt = slice.as_str();
8022  let at = upper.rfind("INSERT INTO")?;
8023  let after = at + "INSERT INTO".len();
8024  let rest = &stmt[after..];
8025  let lead = rest.len() - rest.trim_start().len();
8026  let raw = &rest[lead..];
8027  let id_end = raw.find(|c: char| !c.is_ascii_alphanumeric() && c != '_' && c != '.' && c != '"').unwrap_or(raw.len());
8028  let table = raw[..id_end].rsplit('.').next().unwrap_or(&raw[..id_end]).trim_matches('"').to_string();
8029  if table.is_empty() {
8030    return None;
8031  }
8032  // Must be inside the paren list: the chars between `<table>` and
8033  // cursor must contain `(` and not a closing `)`.
8034  let after_table = after + lead + id_end;
8035  let trail = &stmt[after_table..];
8036  let paren_at = trail.find('(')?;
8037  let paren_body = &trail[paren_at + 1..];
8038  if paren_body.contains(')') {
8039    return None;
8040  }
8041  Some(table)
8042}
8043
8044pub(crate) fn is_column_listed(it: &Item, used: &std::collections::HashSet<String>) -> bool {
8045  if !matches!(it.kind, crate::item::ItemKind::Column) {
8046    return false;
8047  }
8048  let tail = it.label.rsplit('.').next().unwrap_or(&it.label);
8049  used.contains(&tail.to_ascii_lowercase())
8050}
8051
8052/// Walk back from `offset` to the nearest clause-start anchor
8053/// (`SELECT`, `SET`, `GROUP BY`, `ORDER BY`, `RETURNING`, `(`) and
8054/// collect every bare identifier (split by top-level `,`) seen
8055/// between the anchor and the cursor. Lowercased for case-insensitive
8056/// matching. Multi-byte safe: only treats bytes < 128 as ASCII.
8057pub(crate) fn used_columns_in_clause(source: &str, offset: TextSize) -> std::collections::HashSet<String> {
8058  let pos: usize = u32::from(offset) as usize;
8059  let mut pos = pos.min(source.len());
8060  while pos > 0 && !source.is_char_boundary(pos) {
8061    pos -= 1;
8062  }
8063  let bytes = source.as_bytes();
8064  let mut anchor = 0usize;
8065  let mut depth = 0i32;
8066  let mut i = pos;
8067  while i > 0 {
8068    let b = bytes[i - 1];
8069    // Non-ASCII: skip without inspecting (continuation byte / multi-
8070    // byte char). Word-boundary logic only cares about ASCII keywords.
8071    if b >= 128 {
8072      i -= 1;
8073      continue;
8074    }
8075    let c = b as char;
8076    if c == ')' {
8077      depth += 1;
8078      i -= 1;
8079      continue;
8080    }
8081    if c == '(' {
8082      if depth == 0 {
8083        anchor = i;
8084        break;
8085      }
8086      depth -= 1;
8087      i -= 1;
8088      continue;
8089    }
8090    if c == ';' {
8091      anchor = i;
8092      break;
8093    }
8094    let _ = c;
8095    if match_kw_at(bytes, i, b"SELECT")
8096      || match_kw_at(bytes, i, b"RETURNING")
8097      || match_kw_at(bytes, i, b"VALUES")
8098      || match_kw_at(bytes, i, b"SET")
8099      || match_kw_at(bytes, i, b"BY")
8100    {
8101      anchor = i;
8102      break;
8103    }
8104    i -= 1;
8105  }
8106  let region = if source.is_char_boundary(anchor) && source.is_char_boundary(pos) { &source[anchor..pos] } else { "" };
8107  collect_idents_csv(region)
8108}
8109
8110/// True when `bytes[end - kw.len()..end]` (case-insensitive) equals
8111/// `kw` AND the byte before AND after are non-word chars (word-
8112/// boundary on both sides). Skips bounds checks cleanly when
8113/// end < kw.len().
8114pub(crate) fn match_kw_at(bytes: &[u8], end: usize, kw: &[u8]) -> bool {
8115  let len = kw.len();
8116  if end < len {
8117    return false;
8118  }
8119  let start = end - len;
8120  for k in 0..len {
8121    let a = bytes[start + k];
8122    let b = kw[k];
8123    if !a.is_ascii() {
8124      return false;
8125    }
8126    if a.to_ascii_uppercase() != b {
8127      return false;
8128    }
8129  }
8130  let prev_ok = if start == 0 {
8131    true
8132  } else {
8133    let prev = bytes[start - 1];
8134    prev >= 128 || !is_word_char(prev as char)
8135  };
8136  let next_ok = if end >= bytes.len() {
8137    true
8138  } else {
8139    let next = bytes[end];
8140    next >= 128 || !is_word_char(next as char)
8141  };
8142  prev_ok && next_ok
8143}
8144
8145pub(crate) fn is_word_char(c: char) -> bool {
8146  c.is_ascii_alphanumeric() || c == '_'
8147}
8148
8149/// Split `region` on top-level `,` (paren-depth aware), pull the
8150/// first identifier off each item, lowercase + collect.
8151pub(crate) fn collect_idents_csv(region: &str) -> std::collections::HashSet<String> {
8152  let mut out = std::collections::HashSet::new();
8153  let bytes = region.as_bytes();
8154  let n = bytes.len();
8155  let mut depth = 0i32;
8156  let mut item_start = 0usize;
8157  let mut i = 0usize;
8158  while i < n {
8159    let c = bytes[i] as char;
8160    if c == '\'' {
8161      i += 1;
8162      while i < n && bytes[i] != b'\'' {
8163        i += 1;
8164      }
8165      i = (i + 1).min(n);
8166      continue;
8167    }
8168    if c == '(' {
8169      depth += 1;
8170      i += 1;
8171      continue;
8172    }
8173    if c == ')' {
8174      depth -= 1;
8175      i += 1;
8176      continue;
8177    }
8178    if c == ',' && depth == 0 {
8179      push_first_ident(&region[item_start..i], &mut out);
8180      item_start = i + 1;
8181    }
8182    i += 1;
8183  }
8184  push_first_ident(&region[item_start..], &mut out);
8185  out
8186}
8187
8188pub(crate) fn push_first_ident(item: &str, out: &mut std::collections::HashSet<String>) {
8189  let item = item.trim();
8190  if item.is_empty() {
8191    return;
8192  }
8193  // Take the trailing dotted segment (`u.email` -> `email`) so we
8194  // don't match aliases. Strip everything after the first
8195  // non-word/dot char (`u.email = ...` -> `u.email`).
8196  let head_end =
8197    item.find(|c: char| !c.is_ascii_alphanumeric() && c != '_' && c != '.' && c != '"').unwrap_or(item.len());
8198  let head = item[..head_end].trim_matches('"');
8199  if head.is_empty() {
8200    return;
8201  }
8202  let tail = head.rsplit('.').next().unwrap_or(head).trim_matches('"');
8203  if !tail.is_empty() {
8204    out.insert(tail.to_ascii_lowercase());
8205  }
8206}
8207
8208/// Walk back from `pos` to find the enclosing `CREATE [OR REPLACE]
8209/// FUNCTION <name>(...)` header. Then search the buffer + the live
8210/// catalog's triggers for a CREATE TRIGGER bound to `<name>` and
8211/// return its target table. None when the function is never used by a
8212/// trigger we can see -- the caller should suppress completion in
8213/// that case so the user doesn't get bogus suggestions.
8214pub(crate) fn enclosing_fn_trigger_table(source: &str, pos: usize, cat: &Catalog) -> Option<String> {
8215  let upper = source.to_ascii_uppercase();
8216  let mut latest: Option<usize> = None;
8217  for needle in ["CREATE OR REPLACE FUNCTION ", "CREATE FUNCTION ", "CREATE OR REPLACE PROCEDURE ", "CREATE PROCEDURE "]
8218  {
8219    let mut from = 0usize;
8220    while let Some(rel) = upper[from..].find(needle) {
8221      let p = from + rel;
8222      if p > pos {
8223        break;
8224      }
8225      latest = Some(p + needle.len());
8226      from = p + needle.len();
8227    }
8228  }
8229  let after = source[latest?..].trim_start();
8230  let fn_name: String = after.chars().take_while(|c| c.is_alphanumeric() || *c == '_' || *c == '.').collect();
8231  let fn_short = fn_name.rsplit('.').next().unwrap_or(&fn_name);
8232  if fn_short.is_empty() {
8233    return None;
8234  }
8235
8236  // (a) Search buffer for `CREATE TRIGGER ... ON <table> ... EXECUTE
8237  // [FUNCTION|PROCEDURE] <fn_short>`. Multiple triggers can target
8238  // the same function but typically all bind to the same table.
8239  if let Some(t) = scan_buffer_for_trigger_fn(source, fn_short) {
8240    return Some(t);
8241  }
8242  // (b) Live catalog. dsl-catalog tracks triggers per table; locate
8243  // the table whose triggers reference this function.
8244  for t in cat.tables() {
8245    for tg in &t.triggers {
8246      // `function` field stores the raw action_statement, which
8247      // usually reads "EXECUTE FUNCTION schema.fn_name()". We
8248      // tolerate either form.
8249      let fn_upper = tg.function.to_ascii_uppercase();
8250      let needle = fn_short.to_ascii_uppercase();
8251      if fn_upper.contains(&needle) {
8252        return Some(t.name.clone());
8253      }
8254    }
8255  }
8256  None
8257}
8258
8259/// Find the first `CREATE TRIGGER ... ON <table> ... EXECUTE [FUNCTION|
8260/// PROCEDURE] <fn>` referencing `fn_name` in the source. Returns the
8261/// table name (sans schema prefix).
8262pub(crate) fn scan_buffer_for_trigger_fn(source: &str, fn_name: &str) -> Option<String> {
8263  let upper = source.to_ascii_uppercase();
8264  let mut from = 0usize;
8265  while let Some(rel) = upper[from..].find("CREATE TRIGGER") {
8266    let p = from + rel;
8267    // Find the end of this statement (next `;` or buffer end).
8268    let stmt_end = upper[p..].find(';').map(|e| p + e).unwrap_or(upper.len());
8269    let stmt_upper = &upper[p..stmt_end];
8270    // Must reference our function.
8271    let fn_upper = fn_name.to_ascii_uppercase();
8272    let mentions = stmt_upper.contains(&format!("EXECUTE FUNCTION {}", fn_upper))
8273      || stmt_upper.contains(&format!("EXECUTE PROCEDURE {}", fn_upper))
8274      || stmt_upper.contains(&format!("EXECUTE FUNCTION PUBLIC.{}", fn_upper))
8275      || stmt_upper.contains(&format!("EXECUTE PROCEDURE PUBLIC.{}", fn_upper));
8276    if mentions && let Some(on_pos) = stmt_upper.find(" ON ") {
8277      let after = &source[p + on_pos + 4..stmt_end];
8278      let tok: String =
8279        after.trim_start().chars().take_while(|c| c.is_alphanumeric() || *c == '_' || *c == '.').collect();
8280      if !tok.is_empty() {
8281        return Some(tok.rsplit('.').next().unwrap_or(&tok).to_string());
8282      }
8283    }
8284    from = stmt_end.max(p + 1);
8285  }
8286  None
8287}
8288
8289/// Find the table name in a `CREATE TRIGGER ... ON <table>` clause in
8290/// the buffer. Used for NEW / OLD resolution.
8291pub(crate) fn trigger_target_table(source: &str) -> Option<String> {
8292  let upper = source.to_uppercase();
8293  // Accept every CREATE TRIGGER variant: bare, `CREATE OR REPLACE
8294  // TRIGGER`, and `CREATE CONSTRAINT TRIGGER`. We anchor on the
8295  // earliest match so a script with multiple triggers still picks the
8296  // one we're cursoring in (caller passes the slice up to cursor).
8297  let idx = ["CREATE OR REPLACE TRIGGER", "CREATE CONSTRAINT TRIGGER", "CREATE TRIGGER"]
8298    .iter()
8299    .filter_map(|kw| upper.rfind(kw))
8300    .max()?;
8301  let rest_upper = &upper[idx..];
8302  let on_idx = rest_upper.find(" ON ")?;
8303  let after = &source[idx + on_idx + 4..];
8304  let tok = after
8305    .trim_start()
8306    .split(|c: char| c.is_whitespace() || c == '(' || c == ';' || c == ',')
8307    .find(|s| !s.is_empty())?;
8308  // Strip optional `ONLY` keyword introducing the table name.
8309  let tok = if tok.eq_ignore_ascii_case("ONLY") {
8310    after.trim_start().split_ascii_whitespace().nth(1).unwrap_or(tok)
8311  } else {
8312    tok
8313  };
8314  // Strip schema prefix + surrounding quotes.
8315  Some(tok.split('.').next_back().unwrap_or(tok).trim_matches('"').to_string())
8316}
8317
8318/// Find the target table of the `CREATE POLICY <name> ON <table>`
8319/// statement enclosing the cursor -- mirrors `trigger_target_table`'s
8320/// approach for `CREATE TRIGGER ... ON <table>` above (no `ONLY`
8321/// handling needed here -- CREATE POLICY's grammar doesn't accept it,
8322/// unlike statements that operate over a table hierarchy).
8323pub(crate) fn policy_target_table(source: &str) -> Option<String> {
8324  let upper = source.to_uppercase();
8325  let idx = upper.rfind("CREATE POLICY")?;
8326  let rest_upper = &upper[idx..];
8327  let on_idx = rest_upper.find(" ON ")?;
8328  let after = &source[idx + on_idx + 4..];
8329  let tok = after
8330    .trim_start()
8331    .split(|c: char| c.is_whitespace() || c == '(' || c == ';' || c == ',')
8332    .find(|s| !s.is_empty())?;
8333  Some(tok.split('.').next_back().unwrap_or(tok).trim_matches('"').to_string())
8334}
8335
8336/// `CREATE POLICY ... USING (⏵` or `... WITH CHECK (⏵` -- the policy's
8337/// boolean expression is scoped to the target table's columns, same
8338/// completion need `Phase::CtlCheckExpr`'s handler already serves for
8339/// CHECK constraints (see `engine.rs`'s `route_phase`). CREATE POLICY
8340/// has no AST representation and isn't routed through
8341/// `create_table::detect`, so this is its own detector rather than
8342/// reusing either existing mechanism -- but it calls the exact same
8343/// column-lookup building blocks `CtlCheckExpr` does.
8344pub(crate) fn policy_expr_items(source: &str, offset: TextSize, cat: &Catalog) -> Option<Vec<Item>> {
8345  let (_, upper) = stmt_slice_upper(source, offset);
8346  if !upper.contains("POLICY") {
8347    return None;
8348  }
8349  let mut open_at = None;
8350  for kw in ["USING (", "WITH CHECK ("] {
8351    if let Some(rel) = upper.rfind(kw) {
8352      let candidate = rel + kw.len();
8353      let mut depth = 1i32;
8354      for b in upper[candidate..].bytes() {
8355        match b {
8356          b'(' => depth += 1,
8357          b')' => depth -= 1,
8358          _ => {},
8359        }
8360      }
8361      if depth >= 1 && open_at.is_none_or(|o: usize| candidate > o) {
8362        open_at = Some(candidate);
8363      }
8364    }
8365  }
8366  open_at?;
8367  let mut out = Vec::new();
8368  if let Some(t) = policy_target_table(source) {
8369    sources::columns_of_table(cat, None, &t, &mut out);
8370    if out.is_empty() {
8371      for name in crate::source_tables::buffer_column_names(source, &t) {
8372        out.push(crate::item::Item {
8373          label: name.clone(),
8374          kind: crate::item::ItemKind::Column,
8375          detail: Some(format!("column of `{t}` (buffer)")),
8376          description: None,
8377          documentation_md: None,
8378          insert_text: name,
8379          is_snippet: false,
8380          kb_entry: None,
8381          sort_priority: 0,
8382        });
8383      }
8384    }
8385  }
8386  push_all_functions(cat, &mut out);
8387  sources::expression_keywords(&mut out);
8388  Some(out)
8389}
8390
8391/// Text since the nearest PL/pgSQL statement/block boundary before
8392/// `pos` -- the last `;`, or the last occurrence of a block keyword
8393/// (BEGIN/THEN/ELSE/LOOP/DECLARE), whichever is closer to `pos`.
8394/// Scoped to `source[..pos]` only.
8395fn plpgsql_inner_stmt_span(source: &str, pos: usize) -> &str {
8396  let before = &source[..pos];
8397  let upper = before.to_ascii_uppercase();
8398  let mut boundary = upper.rfind(';').map(|p| p + 1).unwrap_or(0);
8399  for kw in ["BEGIN", "THEN", "ELSE", "LOOP", "DECLARE"] {
8400    if let Some(p) = upper.rfind(kw) {
8401      let after = p + kw.len();
8402      if after > boundary {
8403        boundary = after;
8404      }
8405    }
8406  }
8407  &source[boundary..pos]
8408}
8409
8410/// `Phase::PlpgsqlBody` sub-detection: the current inner PL/pgSQL
8411/// statement is itself a SELECT/INSERT/UPDATE/DELETE at one of its
8412/// targeted slots, so offer the same menu the top-level phase would --
8413/// instead of the kitchen-sink fallback. Returns `None` (falls through
8414/// to the kitchen sink) for every other position -- this only narrows
8415/// the clearest, highest-value slots, it doesn't attempt full
8416/// clause-by-clause parity with top-level SQL.
8417///
8418/// Slots covered: FROM/JOIN (tables), WHERE/AND/OR (columns +
8419/// expression keywords), `INSERT INTO <table>` (tables), `INSERT INTO
8420/// t (<cols>)` (that table's columns only), `UPDATE <table>` (tables),
8421/// `UPDATE t SET <col> = ...` (that table's columns only, at any
8422/// position in the assignment list), `... RETURNING <cols/expr>`.
8423/// `DELETE FROM` is covered by the generic FROM branch already.
8424/// `EXECUTE '...'` dynamic-SQL string bodies are NOT covered -- SQL
8425/// text inside a string literal is a different, larger problem
8426/// (completion inside a string, not a bare-expression clause) and out
8427/// of scope here.
8428///
8429/// The four lower-level helpers this reuses (`insert_target_table`,
8430/// `dml_target_table`, `update_set_at_column_slot`,
8431/// `used_columns_in_clause`) each self-bound at the nearest real `;`
8432/// (or, for `update_set_at_column_slot`, bail outright on crossing
8433/// one) -- which coincides with PL/pgSQL inner-statement boundaries in
8434/// the raw text, so a later inner statement's target-table resolution
8435/// won't leak an earlier inner statement's table (verified by
8436/// `plpgsql_body_second_statement_target_does_not_leak_first_statements_table`
8437/// in `tests/engine.rs`).
8438pub(crate) fn plpgsql_body_targeted_items(
8439  source: &str,
8440  offset: TextSize,
8441  file: &ParsedFile,
8442  scopes: &[Scope],
8443  cat: &Catalog,
8444) -> Option<Vec<Item>> {
8445  let pos: usize = u32::from(offset) as usize;
8446  let pos = pos.min(source.len());
8447  let span = plpgsql_inner_stmt_span(source, pos);
8448  let upper = span.to_ascii_uppercase();
8449  let has_dml_verb = ["SELECT", "UPDATE", "DELETE", "INSERT"].iter().any(|kw| upper.contains(kw));
8450  if !has_dml_verb {
8451    return None;
8452  }
8453
8454  // RETURNING is always the last clause in INSERT/UPDATE/DELETE, so
8455  // once it appears anywhere in the current inner statement's span,
8456  // every position after it -- the first column, or any later
8457  // comma-separated one -- is the RETURNING slot. Checked before
8458  // everything else: a bare last-word match (`last == "RETURNING"`)
8459  // only catches the *first* column, since a trailing comma glues
8460  // onto the previous column name with no space (`RETURNING id,` is
8461  // one whitespace-delimited token, "ID,"); worse, leaving the
8462  // SET-column-slot check below to run first for a 2nd+ RETURNING
8463  // column is actively wrong, not just incomplete -- its backward scan
8464  // for SET's last `=`/`,` doesn't know to stop at RETURNING (only at
8465  // `;` or an unbalanced paren), so `UPDATE t SET x=1 RETURNING a, `
8466  // was misread as if the `,` still belonged to the SET list.
8467  if upper.contains("RETURNING") {
8468    let trimmed = upper.trim_end();
8469    let words: Vec<&str> = trimmed.split_ascii_whitespace().collect();
8470    if words.last().copied() == Some("AS") {
8471      // `RETURNING <expr> AS <cursor>` -- free-form alias name, no
8472      // menu (matches Phase::ReturningClause's own AS handling).
8473      return Some(Vec::new());
8474    }
8475    let mut out = Vec::new();
8476    if let Some(target) = dml_target_table(source, offset) {
8477      sources::columns_of_table(cat, None, &target, &mut out);
8478    } else {
8479      push_scope_columns_or_all(file, scopes, source, cat, offset, &mut out);
8480    }
8481    push_aliases(file, scopes, source, offset, &mut out);
8482    push_all_functions(cat, &mut out);
8483    sources::expression_keywords(&mut out);
8484    let used = used_columns_in_clause(source, offset);
8485    if !used.is_empty() {
8486      out.retain(|it| !is_column_listed(it, &used));
8487    }
8488    return Some(out);
8489  }
8490
8491  // Paren-content slots -- checked next, since inside a paren list
8492  // the *last bare word* before the cursor is often part of an
8493  // expression, not a real clause keyword, so the bare-word matching
8494  // below would misfire.
8495  if let Some(target) = insert_target_table(source, offset) {
8496    let mut out = Vec::new();
8497    sources::columns_of_table(cat, None, &target, &mut out);
8498    let used = used_columns_in_clause(source, offset);
8499    if !used.is_empty() {
8500      out.retain(|it| !is_column_listed(it, &used));
8501    }
8502    return Some(out);
8503  }
8504  if update_set_at_column_slot(source, offset)
8505    && let Some(target) = dml_target_table(source, offset)
8506  {
8507    let mut out = Vec::new();
8508    sources::columns_of_table(cat, None, &target, &mut out);
8509    let used = used_columns_in_clause(source, offset);
8510    if !used.is_empty() {
8511      out.retain(|it| !is_column_listed(it, &used));
8512    }
8513    return Some(out);
8514  }
8515
8516  let trimmed = upper.trim_end();
8517  let mut words: Vec<&str> = trimmed.split_ascii_whitespace().collect();
8518  // Strip a trailing partial identifier the user is still typing.
8519  if pos > 0 && source.as_bytes().get(pos - 1).is_some_and(|b| b.is_ascii_alphanumeric() || *b == b'_') {
8520    words.pop();
8521  }
8522  let last = words.last().copied();
8523  let prev = if words.len() >= 2 { words.get(words.len() - 2).copied() } else { None };
8524  let mut out = Vec::new();
8525  if matches!(last, Some("FROM") | Some("JOIN")) {
8526    sources::tables(cat, &mut out);
8527    return Some(out);
8528  }
8529  if matches!(last, Some("WHERE") | Some("AND") | Some("OR")) {
8530    push_scope_columns_or_all(file, scopes, source, cat, offset, &mut out);
8531    push_aliases(file, scopes, source, offset, &mut out);
8532    push_all_functions(cat, &mut out);
8533    sources::expression_keywords(&mut out);
8534    return Some(out);
8535  }
8536  // `INSERT INTO <cursor>` -- table target. Guarded on the *previous*
8537  // word being INSERT specifically: PL/pgSQL's `SELECT ... INTO <var>`
8538  // (assign a query result to a local variable) uses the same INTO
8539  // keyword for a wholly different purpose -- that case must NOT offer
8540  // tables, so it falls through to the kitchen sink instead (which
8541  // already includes PL/pgSQL locals).
8542  if last == Some("INTO") && prev == Some("INSERT") {
8543    sources::tables(cat, &mut out);
8544    return Some(out);
8545  }
8546  if last == Some("UPDATE") {
8547    sources::tables(cat, &mut out);
8548    return Some(out);
8549  }
8550  None
8551}
8552
8553/// Quick dot detection: returns the alias before the cursor's `.`.
8554pub(crate) fn dot_alias(source: &str, offset: TextSize) -> Option<String> {
8555  let pos: usize = offset.into();
8556  let pos = floor_char_boundary(source, pos.min(source.len()));
8557  let before = &source[..pos];
8558  let dot_idx = before.rfind('.')?;
8559  let after_dot = &before[dot_idx + 1..];
8560  if !after_dot.chars().all(|c| c.is_alphanumeric() || c == '_') {
8561    return None;
8562  }
8563  let pre_dot = &before[..dot_idx];
8564  // Double-quoted identifier alias: `"Foo Bar".col` -- walk back to the
8565  // matching opening `"` and return the content (without quotes).
8566  // Bindings are stored unquoted by the resolver so this matches.
8567  if pre_dot.ends_with('"') {
8568    let body_end = pre_dot.len() - 1;
8569    if let Some(open) = pre_dot[..body_end].rfind('"') {
8570      let inner = &pre_dot[open + 1..body_end];
8571      if !inner.is_empty() {
8572        return Some(inner.to_string());
8573      }
8574    }
8575  }
8576  let alias: String =
8577    pre_dot.chars().rev().take_while(|c| c.is_alphanumeric() || *c == '_').collect::<String>().chars().rev().collect();
8578  if alias.is_empty() { None } else { Some(alias) }
8579}
8580
8581/// Return the largest valid UTF-8 char boundary at or before `byte`.
8582/// Mirrors the (unstable) `str::floor_char_boundary` API.
8583pub(crate) fn floor_char_boundary(s: &str, byte: usize) -> usize {
8584  let mut b = byte.min(s.len());
8585  while b > 0 && !s.is_char_boundary(b) {
8586    b -= 1;
8587  }
8588  b
8589}
8590
8591/// True when the cursor at `offset` sits inside a SQL string literal,
8592/// line comment (`-- ...`), or block comment (`/* ... */`). Dollar-quoted
8593/// bodies (`$tag$...$tag$`) are NOT treated as inert -- they hold
8594/// PL/pgSQL code and completion remains useful there. When the cursor
8595/// lands inside a dollar-quote body the scan recurses with the body as a
8596/// fresh source so an inner `'literal'` still suppresses completion.
8597pub(crate) fn cursor_in_inert_span(source: &str, offset: usize) -> bool {
8598  let bytes = source.as_bytes();
8599  let n = bytes.len();
8600  let limit = offset.min(n);
8601  let mut i = 0usize;
8602  // 0 = code, 1 = single-quoted string, 2 = line comment, 3 = block comment.
8603  let mut state: u8 = 0;
8604  while i < limit {
8605    match state {
8606      0 => {
8607        // Dollar-quoted string `$tag$ ... $tag$` (tag may be empty).
8608        if bytes[i] == b'$' {
8609          let mut t = i + 1;
8610          while t < n && (bytes[t].is_ascii_alphanumeric() || bytes[t] == b'_') {
8611            t += 1;
8612          }
8613          if t < n && bytes[t] == b'$' {
8614            let tag_end = t + 1;
8615            let tag = &bytes[i..tag_end];
8616            let mut k = tag_end;
8617            let mut close = None;
8618            while k + tag.len() <= n {
8619              if &bytes[k..k + tag.len()] == tag {
8620                close = Some(k);
8621                break;
8622              }
8623              k += 1;
8624            }
8625            let body_close_end = close.map(|p| p + tag.len()).unwrap_or(n);
8626            // Cursor inside the body? Treat body as fresh source.
8627            if offset > tag_end && offset <= close.unwrap_or(n) {
8628              let body_off = offset - tag_end;
8629              let body_src = &source[tag_end..close.unwrap_or(n)];
8630              return cursor_in_inert_span(body_src, body_off);
8631            }
8632            i = body_close_end;
8633            continue;
8634          }
8635        }
8636        match bytes[i] {
8637          b'\'' => {
8638            state = 1;
8639            i += 1;
8640            continue;
8641          },
8642          b'-' if i + 1 < n && bytes[i + 1] == b'-' => {
8643            state = 2;
8644            i += 2;
8645            continue;
8646          },
8647          b'/' if i + 1 < n && bytes[i + 1] == b'*' => {
8648            state = 3;
8649            i += 2;
8650            continue;
8651          },
8652          _ => {
8653            i += 1;
8654          },
8655        }
8656      },
8657      1 => {
8658        if bytes[i] == b'\'' {
8659          // Doubled '' is an escape.
8660          if i + 1 < n && bytes[i + 1] == b'\'' {
8661            i += 2;
8662            continue;
8663          }
8664          state = 0;
8665          i += 1;
8666          continue;
8667        }
8668        i += 1;
8669      },
8670      2 => {
8671        if bytes[i] == b'\n' {
8672          state = 0;
8673        }
8674        i += 1;
8675      },
8676      3 => {
8677        if bytes[i] == b'*' && i + 1 < n && bytes[i + 1] == b'/' {
8678          state = 0;
8679          i += 2;
8680          continue;
8681        }
8682        i += 1;
8683      },
8684      _ => break,
8685    }
8686  }
8687  state != 0
8688}
8689
8690pub(crate) struct ExecuteStringSpan {
8691  /// Byte range of the string's content, excluding delimiters.
8692  pub content_start: usize,
8693  pub content_end: usize,
8694  pub dollar_quoted: bool,
8695}
8696
8697/// Word-boundary check: does `source[..pos]`, skipping trailing
8698/// whitespace, end with `word` (case-insensitive)?
8699fn preceded_by_word(source: &str, pos: usize, word: &str) -> bool {
8700  let bytes = source.as_bytes();
8701  let mut i = pos.min(bytes.len());
8702  while i > 0 && bytes[i - 1].is_ascii_whitespace() {
8703    i -= 1;
8704  }
8705  let word_end = i;
8706  let mut word_start = i;
8707  while word_start > 0 && (bytes[word_start - 1].is_ascii_alphanumeric() || bytes[word_start - 1] == b'_') {
8708    word_start -= 1;
8709  }
8710  if word_start == word_end {
8711    return false;
8712  }
8713  source[word_start..word_end].eq_ignore_ascii_case(word)
8714}
8715
8716/// Does `source[pos..]`, skipping leading whitespace, start with `||`?
8717fn followed_by_concat(source: &str, pos: usize) -> bool {
8718  let bytes = source.as_bytes();
8719  let mut i = pos;
8720  while i < bytes.len() && bytes[i].is_ascii_whitespace() {
8721    i += 1;
8722  }
8723  bytes.get(i) == Some(&b'|') && bytes.get(i + 1) == Some(&b'|')
8724}
8725
8726/// Byte span of the string literal (single- or dollar-quoted) that
8727/// `offset` sits inside, when that string is the un-concatenated SQL
8728/// text argument of a PL/pgSQL `EXECUTE` statement -- e.g. `EXECUTE
8729/// 'SELECT * FROM <cursor>'` or `EXECUTE $sql$ SELECT * FROM <cursor>
8730/// $sql$`. Mirrors `cursor_in_inert_span`'s state-machine walk (same
8731/// string / comment / dollar-quote tracking, same recursion into a
8732/// dollar-quoted body to reach a string nested inside it -- necessary
8733/// because `EXECUTE` only appears inside such bodies) but returns the
8734/// matched string's own span instead of a bool, and only when it's
8735/// EXECUTE's target: the nearest word before its opening delimiter
8736/// must be `EXECUTE` (word-boundary checked, so `format('...'` and
8737/// other non-EXECUTE strings never match), and the nearest token
8738/// after its closing delimiter must not be `||` (ruling out a
8739/// concatenated segment).
8740pub(crate) fn execute_dynamic_sql_span(source: &str, offset: usize) -> Option<ExecuteStringSpan> {
8741  let bytes = source.as_bytes();
8742  let n = bytes.len();
8743  let limit = offset.min(n);
8744  let mut i = 0usize;
8745  // 0 = code, 1 = single-quoted string, 2 = line comment, 3 = block comment.
8746  let mut state: u8 = 0;
8747  let mut string_start = 0usize;
8748  while i < limit {
8749    match state {
8750      0 => {
8751        if bytes[i] == b'$' {
8752          let mut t = i + 1;
8753          while t < n && (bytes[t].is_ascii_alphanumeric() || bytes[t] == b'_') {
8754            t += 1;
8755          }
8756          if t < n && bytes[t] == b'$' {
8757            let tag_end = t + 1;
8758            let tag = &bytes[i..tag_end];
8759            let mut k = tag_end;
8760            let mut close = None;
8761            while k + tag.len() <= n {
8762              if &bytes[k..k + tag.len()] == tag {
8763                close = Some(k);
8764                break;
8765              }
8766              k += 1;
8767            }
8768            let body_end = close.unwrap_or(n);
8769            let body_close_end = close.map(|p| p + tag.len()).unwrap_or(n);
8770            // Is this dollar-quoted string itself EXECUTE's target?
8771            if offset >= tag_end
8772              && offset <= body_end
8773              && preceded_by_word(source, i, "EXECUTE")
8774              && !followed_by_concat(source, body_close_end)
8775            {
8776              return Some(ExecuteStringSpan { content_start: tag_end, content_end: body_end, dollar_quoted: true });
8777            }
8778            // Cursor inside the body but not (directly) EXECUTE's own
8779            // target -- recurse to look for a match nested deeper
8780            // (the common case: this is the outer PL/pgSQL function
8781            // body, and the real EXECUTE string is somewhere inside).
8782            if offset > tag_end && offset <= body_end {
8783              let body_off = offset - tag_end;
8784              let body_src = &source[tag_end..body_end];
8785              return execute_dynamic_sql_span(body_src, body_off).map(|s| ExecuteStringSpan {
8786                content_start: s.content_start + tag_end,
8787                content_end: s.content_end + tag_end,
8788                dollar_quoted: s.dollar_quoted,
8789              });
8790            }
8791            i = body_close_end;
8792            continue;
8793          }
8794        }
8795        match bytes[i] {
8796          b'\'' => {
8797            state = 1;
8798            string_start = i;
8799            i += 1;
8800            continue;
8801          },
8802          b'-' if i + 1 < n && bytes[i + 1] == b'-' => {
8803            state = 2;
8804            i += 2;
8805            continue;
8806          },
8807          b'/' if i + 1 < n && bytes[i + 1] == b'*' => {
8808            state = 3;
8809            i += 2;
8810            continue;
8811          },
8812          _ => {
8813            i += 1;
8814          },
8815        }
8816      },
8817      1 => {
8818        if bytes[i] == b'\'' {
8819          if i + 1 < n && bytes[i + 1] == b'\'' {
8820            i += 2;
8821            continue;
8822          }
8823          state = 0;
8824          i += 1;
8825          continue;
8826        }
8827        i += 1;
8828      },
8829      2 => {
8830        if bytes[i] == b'\n' {
8831          state = 0;
8832        }
8833        i += 1;
8834      },
8835      3 => {
8836        if bytes[i] == b'*' && i + 1 < n && bytes[i + 1] == b'/' {
8837          state = 0;
8838          i += 2;
8839          continue;
8840        }
8841        i += 1;
8842      },
8843      _ => break,
8844    }
8845  }
8846  if state != 1 {
8847    return None;
8848  }
8849  // Cursor is inside a single-quoted string that started at
8850  // `string_start`. Find its closing quote (handling `''` escapes) to
8851  // get the full span, then check it's EXECUTE's un-concatenated
8852  // target. An unterminated string (no closing `'` anywhere in
8853  // `source` -- the common live-completion case: the user hasn't
8854  // typed the closing quote yet) falls back to extending through the
8855  // end of `source`, mirroring the dollar-quote branch's own
8856  // `close.unwrap_or(n)` fallback above.
8857  let content_start = string_start + 1;
8858  let mut k = limit;
8859  let content_end = loop {
8860    match bytes.get(k) {
8861      None => break n,
8862      Some(b'\'') => {
8863        if bytes.get(k + 1) == Some(&b'\'') {
8864          k += 2;
8865          continue;
8866        }
8867        break k;
8868      },
8869      Some(_) => k += 1,
8870    }
8871  };
8872  let close_end = (content_end + 1).min(n);
8873  if !preceded_by_word(source, string_start, "EXECUTE") || followed_by_concat(source, close_end) {
8874    return None;
8875  }
8876  Some(ExecuteStringSpan { content_start, content_end, dollar_quoted: false })
8877}
8878
8879/// Un-escape a single-quoted EXECUTE string's raw content (`''` ->
8880/// `'`) and map `cursor_in_raw` (a byte offset into `raw`, as returned
8881/// by `execute_dynamic_sql_span`) to the corresponding offset in the
8882/// unescaped output. Dollar-quoted content needs no unescaping and
8883/// must not be passed through this -- callers check
8884/// `ExecuteStringSpan::dollar_quoted` first.
8885pub(crate) fn unescape_single_quoted(raw: &str, cursor_in_raw: usize) -> (String, usize) {
8886  let bytes = raw.as_bytes();
8887  let n = bytes.len();
8888  let cursor_in_raw = cursor_in_raw.min(n);
8889  let mut out = String::with_capacity(raw.len());
8890  let mut mapped_cursor = cursor_in_raw;
8891  let mut i = 0usize;
8892  while i < n {
8893    if bytes[i] == b'\'' && i + 1 < n && bytes[i + 1] == b'\'' {
8894      // Collapsing `''` -> `'` removes one byte. Every collapse that
8895      // finishes strictly before the raw cursor shifts the mapped
8896      // cursor left by one.
8897      if i + 1 < cursor_in_raw {
8898        mapped_cursor -= 1;
8899      }
8900      out.push('\'');
8901      i += 2;
8902      continue;
8903    }
8904    let ch_len = raw[i..].chars().next().map(|c| c.len_utf8()).unwrap_or(1);
8905    out.push_str(&raw[i..i + ch_len]);
8906    i += ch_len;
8907  }
8908  (out, mapped_cursor)
8909}
8910
8911/// True when the cursor is at a "fresh name" slot -- i.e. immediately
8912/// after a `CREATE [OR REPLACE] <KIND> [IF NOT EXISTS]` keyword (or
8913/// while typing the name itself). SQL DDL invents these names, so the
8914/// LSP should offer NO completion candidates -- existing catalog
8915/// names would be wrong (collision) and keyword suggestions would
8916/// also be wrong (the user is mid-identifier).
8917/// Return the single optional clarifier keyword that legally fits in
8918/// a fresh-name slot, when it does. Used by the early-return guard so
8919/// `CREATE TABLE <cursor>` still emits `IF NOT EXISTS` instead of an
8920/// empty menu. None for slots where no optional keyword applies.
8921pub(crate) fn fresh_name_slot_optional_keyword(source: &str, offset: TextSize) -> Option<&'static str> {
8922  let (slice_owned, _) = stmt_slice_upper(source, offset);
8923  let before = slice_owned.as_str();
8924  let trimmed = before.trim_end_matches(|c: char| c.is_whitespace());
8925  // Only fire when no name partial has been typed yet -- the trimmed
8926  // text ends right after the class keyword.
8927  if before.len() == trimmed.len() {
8928    return None; // no trailing whitespace -> user mid-typing the name
8929  }
8930  let upper = trimmed.to_ascii_uppercase();
8931  let supports_index: &[&str] = &[
8932    "CREATE TABLE",
8933    "CREATE TEMP TABLE",
8934    "CREATE TEMPORARY TABLE",
8935    "CREATE UNLOGGED TABLE",
8936    "CREATE GLOBAL TABLE",
8937    "CREATE LOCAL TABLE",
8938    "CREATE VIEW",
8939    "CREATE MATERIALIZED VIEW",
8940    "CREATE INDEX",
8941    "CREATE UNIQUE INDEX",
8942    "CREATE SCHEMA",
8943    "CREATE SEQUENCE",
8944    "CREATE TYPE",
8945    "CREATE DOMAIN",
8946    "CREATE TRIGGER",
8947    "CREATE POLICY",
8948    "CREATE EXTENSION",
8949    "CREATE FOREIGN TABLE",
8950    "CREATE PROCEDURE",
8951    "CREATE FUNCTION",
8952    "CREATE OR REPLACE TRIGGER",
8953    "CREATE OR REPLACE FUNCTION",
8954    "CREATE OR REPLACE PROCEDURE",
8955    "CREATE OR REPLACE VIEW",
8956  ];
8957  if supports_index.iter().any(|p| upper.ends_with(p)) {
8958    return Some("IF NOT EXISTS");
8959  }
8960  None
8961}
8962
8963pub(crate) fn at_fresh_name_slot(source: &str, offset: TextSize) -> bool {
8964  let (slice_owned, upper) = stmt_slice_upper(source, offset);
8965  let _before = slice_owned.as_str();
8966  // Trim leading whitespace + skip the partial identifier the user
8967  // is currently typing (the "fresh name" itself).
8968  let bytes = upper.as_bytes();
8969  let n = bytes.len();
8970  let mut end = n;
8971  // Skip the identifier being typed (alphanumeric + underscore).
8972  while end > 0 && (bytes[end - 1].is_ascii_alphanumeric() || bytes[end - 1] == b'_') {
8973    end -= 1;
8974  }
8975  let lead = &upper[..end].trim_end();
8976  // Allow optional `IF NOT EXISTS` before the name.
8977  let lead = lead.strip_suffix("IF NOT EXISTS").unwrap_or(lead).trim_end();
8978  // Patterns that announce a fresh DDL object name:
8979  const PATTERNS: &[&str] = &[
8980    "CREATE TABLE",
8981    "CREATE TEMP TABLE",
8982    "CREATE TEMPORARY TABLE",
8983    "CREATE UNLOGGED TABLE",
8984    "CREATE GLOBAL TABLE",
8985    "CREATE LOCAL TABLE",
8986    "CREATE VIEW",
8987    "CREATE OR REPLACE VIEW",
8988    "CREATE MATERIALIZED VIEW",
8989    "CREATE FUNCTION",
8990    "CREATE OR REPLACE FUNCTION",
8991    "CREATE PROCEDURE",
8992    "CREATE OR REPLACE PROCEDURE",
8993    "CREATE INDEX",
8994    "CREATE UNIQUE INDEX",
8995    "CREATE SCHEMA",
8996    "CREATE SEQUENCE",
8997    "CREATE TYPE",
8998    "CREATE DOMAIN",
8999    "CREATE TRIGGER",
9000    "CREATE OR REPLACE TRIGGER",
9001    "CREATE POLICY",
9002    "CREATE EXTENSION",
9003    "CREATE ROLE",
9004    "CREATE USER",
9005    "CREATE GROUP",
9006    "CREATE DATABASE",
9007    "CREATE TABLESPACE",
9008    "CREATE LANGUAGE",
9009    "CREATE AGGREGATE",
9010    "CREATE CAST",
9011    "CREATE COLLATION",
9012    "CREATE CONVERSION",
9013    "CREATE OPERATOR",
9014    "CREATE RULE",
9015    "CREATE PUBLICATION",
9016    "CREATE SUBSCRIPTION",
9017    "CREATE FOREIGN TABLE",
9018    "CREATE FOREIGN DATA WRAPPER",
9019    "CREATE SERVER",
9020    "CREATE USER MAPPING",
9021    "CREATE TEXT SEARCH CONFIGURATION",
9022    "CREATE TEXT SEARCH DICTIONARY",
9023    "CREATE TEXT SEARCH PARSER",
9024    "CREATE TEXT SEARCH TEMPLATE",
9025    "CONSTRAINT",
9026    // ALTER TABLE sub-actions that take a fresh name. The user is
9027    // inventing a brand-new identifier; no catalog name and no SQL
9028    // keyword is a useful suggestion in this slot.
9029    "ADD COLUMN",
9030    "ADD CONSTRAINT",
9031    "RENAME TO",
9032    "RENAME CONSTRAINT",
9033    // Single-token-followup commands that take a fresh identifier
9034    // (LISTEN/NOTIFY channel name, PREPARE/DEALLOCATE statement name,
9035    // DECLARE cursor name). No catalog completion makes sense.
9036    "LISTEN",
9037    "UNLISTEN",
9038    "NOTIFY",
9039    "PREPARE",
9040    "DEALLOCATE",
9041    "DECLARE",
9042    "IMPORT FOREIGN SCHEMA",
9043    "CHECKPOINT",
9044    // Cursor-management commands (PL/pgSQL OPEN/FETCH/MOVE/CLOSE):
9045    // cursor names are user-defined; no catalog target to suggest.
9046    "FETCH",
9047    "MOVE",
9048    "CLOSE",
9049    "OPEN",
9050    // CREATE EVENT TRIGGER <name> -- fresh trigger name.
9051    "CREATE EVENT TRIGGER",
9052    // CREATE INDEX [UNIQUE] [CONCURRENTLY] [IF NOT EXISTS] <name>
9053    "CREATE INDEX CONCURRENTLY",
9054    "CREATE UNIQUE INDEX CONCURRENTLY",
9055    // `WITH RECURSIVE <name>` -- fresh CTE name.
9056    "WITH RECURSIVE",
9057    // (SHOW <guc> is handled by `show_or_set_guc_names` which emits the
9058    // common GUC name set; no entry here so that path can fire.)
9059    // `USE <name>` -- not PG syntax but users type it; stay quiet.
9060    "USE",
9061    // Top-level `VALUES (...)` -- the next required char is `(`.
9062    // Stay quiet rather than dumping the 641-item catch-all.
9063    "VALUES",
9064    // RENAME COLUMN's *destination* name (`RENAME COLUMN old TO new`)
9065    // -- the existing-column slot is handled separately by
9066    // alter_table_existing_column_target().
9067  ];
9068  if PATTERNS.iter().any(|p| lead.ends_with(p)) {
9069    return true;
9070  }
9071  // ALTER TABLE ... RENAME COLUMN <name> TO <cursor> -- fresh name
9072  // slot. The column name is variable so we can't match a fixed
9073  // suffix; instead check that the last 4 word-tokens are
9074  // `RENAME COLUMN <name> TO`.
9075  let tokens: Vec<&str> = lead.split_ascii_whitespace().collect();
9076  let n = tokens.len();
9077  if n >= 4 && tokens[n - 4] == "RENAME" && tokens[n - 3] == "COLUMN" && tokens[n - 1] == "TO" {
9078    return true;
9079  }
9080  false
9081}
9082
9083/// Drop later items whose (label, kind) collide with an earlier item.
9084/// Keeps the first occurrence (which is also the highest-priority emit
9085/// per call ordering). Matched case-insensitively because PG keyword
9086/// completion may be cased differently across sources.
9087/// Merge entries with the same `(label, kind)`. The first occurrence
9088/// wins for `insert_text` / `documentation_md`, but later occurrences
9089/// can contribute origin info into the `detail` field so a column that
9090/// lives in multiple tables surfaces as `id (users, orders, ...)`
9091/// instead of silently hiding the second binding.
9092pub(crate) fn dedup_items(items: Vec<Item>) -> Vec<Item> {
9093  use crate::item::ItemKind;
9094  use std::collections::HashMap;
9095  let mut idx: HashMap<(String, ItemKind), usize> = HashMap::new();
9096  let mut out: Vec<Item> = Vec::with_capacity(items.len());
9097  for it in items {
9098    let key = (it.label.to_ascii_lowercase(), it.kind);
9099    if let Some(&existing) = idx.get(&key) {
9100      // Merge origin info into detail.
9101      if let (Some(existing_detail), Some(new_detail)) = (out[existing].detail.as_ref(), it.detail.as_ref()) {
9102        if existing_detail != new_detail && !existing_detail.contains(new_detail.as_str()) {
9103          let merged = format!("{existing_detail}, {new_detail}");
9104          out[existing].detail = Some(merged);
9105        }
9106      } else if out[existing].detail.is_none() && it.detail.is_some() {
9107        out[existing].detail = it.detail;
9108      }
9109      // Pick the lower (= higher-priority) sort, so a column that
9110      // is in-scope (priority 0) wins over a catalog-wide bare
9111      // version (priority 3) regardless of insertion order.
9112      if it.sort_priority < out[existing].sort_priority {
9113        out[existing].sort_priority = it.sort_priority;
9114      }
9115      continue;
9116    }
9117    idx.insert(key, out.len());
9118    out.push(it);
9119  }
9120  out
9121}
9122
9123/// Push every function the LSP knows about -- built-in PG functions
9124/// from the knowledge base plus user-defined functions from the live
9125/// catalog. Both stamped with `sort_priority = 3` so they sit below
9126/// in-scope columns (0) but above generic keywords.
9127pub(crate) fn push_all_functions(cat: &Catalog, out: &mut Vec<Item>) {
9128  let start = out.len();
9129  sources::functions(out);
9130  sources::db_functions(cat, out);
9131  for it in &mut out[start..] {
9132    it.sort_priority = 3;
9133  }
9134}
9135
9136/// Emit the FROM/JOIN aliases declared in the statement enclosing
9137/// `offset`. Priority 1 so they appear right under in-scope columns.
9138/// Falls back to a raw-text scan when the parser produced no useful
9139/// scope (common while the user is still typing the SELECT projection).
9140/// Emit the CTE names declared by the statement enclosing `offset` as
9141/// Table-kind candidates. Used in FROM / JOIN slots so a CTE name is
9142/// a first-class completion target alongside catalog tables. Falls
9143/// back to a text-level scan when the parser failed (the common case
9144/// while the user is still typing the outer FROM).
9145pub(crate) fn push_cte_names(file: &ParsedFile, scopes: &[Scope], source: &str, offset: TextSize, out: &mut Vec<Item>) {
9146  let mut names: Vec<String> = Vec::new();
9147  if let Some(scope) = scope_for_offset(file, scopes, offset) {
9148    for name in scope.cte_columns.keys() {
9149      if !name.is_empty() {
9150        names.push(name.clone());
9151      }
9152    }
9153  }
9154  if names.is_empty() {
9155    // `cte_names_from_text` only looks at its argument's own leading
9156    // prefix (see its doc comment) -- must be scoped to the current
9157    // statement, not the whole buffer, or it checks statement #1's
9158    // prefix instead of the one under the cursor.
9159    names = fallback::cte_names_from_text(current_statement_span(source, offset));
9160  }
9161  for name in names {
9162    if name.is_empty() {
9163      continue;
9164    }
9165    out.push(crate::item::Item {
9166      label: name.clone(),
9167      kind: crate::item::ItemKind::Table,
9168      detail: Some("CTE".into()),
9169      description: None,
9170      documentation_md: Some(format!("**CTE** `{name}` (defined by WITH in this statement)\n")),
9171      insert_text: name.clone(),
9172      is_snippet: false,
9173      kb_entry: None,
9174      sort_priority: 0,
9175    });
9176  }
9177}
9178
9179pub(crate) fn push_aliases(file: &ParsedFile, scopes: &[Scope], source: &str, offset: TextSize, out: &mut Vec<Item>) {
9180  let start = out.len();
9181  if let Some(scope) = scope_for_offset(file, scopes, offset) {
9182    sources::aliases_in_scope(scope, out);
9183  }
9184  if out.len() == start
9185    && let Some(scope) = fallback::scope_from_text(current_statement_span(source, offset))
9186  {
9187    sources::aliases_in_scope(&scope, out);
9188  }
9189}
9190
9191pub(crate) fn push_scope_columns_or_all(
9192  file: &ParsedFile,
9193  scopes: &[Scope],
9194  source: &str,
9195  cat: &Catalog,
9196  offset: TextSize,
9197  out: &mut Vec<Item>,
9198) {
9199  let start = out.len();
9200  // Whether ANY in-scope binding contributed real catalog columns.
9201  // Synthetic bindings (CTEs, subquery aliases, function-call FROM)
9202  // don't count -- when the only scope is `t AS (SELECT ...)`, the
9203  // resolver maps `t` to a name that's not in the catalog, so
9204  // push_scope_columns emits nothing and we still need the text
9205  // fallback to surface any real `FROM users` columns in the body.
9206  let mut had_scope = false;
9207  if let Some(scope) = scope_for_offset(file, scopes, offset) {
9208    if scope_has_catalog_binding(scope, cat) {
9209      had_scope = true;
9210    }
9211    push_scope_columns(scope, cat, out);
9212  }
9213  if !had_scope && let Some(fb) = fallback::scope_from_text(current_statement_span(source, offset)) {
9214    had_scope = scope_has_catalog_binding(&fb, cat);
9215    push_scope_columns(&fb, cat, out);
9216  }
9217  // Promote in-scope column items to the top of the menu. They beat
9218  // catalog-wide columns + functions + keywords on sort.
9219  for it in &mut out[start..] {
9220    it.sort_priority = 0;
9221  }
9222  if !had_scope {
9223    // No FROM resolved yet -- emit every (table, column) pair plus
9224    // the table names themselves so the user can browse the catalog
9225    // without first picking a table.
9226    let fb_start = out.len();
9227    sources::columns_all(cat, out);
9228    sources::tables(cat, out);
9229    for it in &mut out[fb_start..] {
9230      it.sort_priority = 4;
9231    }
9232  }
9233}
9234
9235/// True when at least one in-scope binding maps to a real catalog
9236/// table. CTE / subquery / function-call FROM bindings don't count;
9237/// they're useful for qualified column lookups but contribute zero
9238/// bare columns to the projection menu.
9239pub(crate) fn scope_has_catalog_binding(scope: &Scope, cat: &Catalog) -> bool {
9240  scope.tables().any(|b| cat.find_table(b.table.schema.as_deref(), &b.table.name).is_some())
9241}
9242
9243pub(crate) fn push_scope_columns(scope: &Scope, cat: &Catalog, out: &mut Vec<Item>) {
9244  // Dedup by table name + skip aliased tables: when the user wrote
9245  // `FROM users AS u`, hide the bare column completion so they're
9246  // forced to type `u.id` (which the dot-context resolver then
9247  // expands). This matches the DX users expect from JetBrains /
9248  // VSCode SQL tools and keeps the menu honest about which columns
9249  // are actually reachable without qualification.
9250  use std::collections::HashSet;
9251  let mut seen: HashSet<String> = HashSet::new();
9252  for b in scope.tables() {
9253    if b.alias != b.table.name {
9254      continue;
9255    }
9256    if !seen.insert(b.table.name.to_ascii_lowercase()) {
9257      continue;
9258    }
9259    let Some(t) = cat.find_table(b.table.schema.as_deref(), &b.table.name) else {
9260      continue;
9261    };
9262    for c in &t.columns {
9263      out.push(sources::column_item(t, c));
9264    }
9265  }
9266}
9267
9268pub(crate) fn scope_for_offset<'a>(file: &ParsedFile, scopes: &'a [Scope], offset: TextSize) -> Option<&'a Scope> {
9269  let idx = file.statements.iter().position(|s| s.range.contains_inclusive(offset))?;
9270  scopes.get(idx)
9271}