1use 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
24pub(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 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 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 let after = &upper[oc_at + "ON CONFLICT".len()..];
122 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 let trimmed = after.trim_end();
143 let after_set = trimmed.rsplit("SET").next().unwrap_or("");
144 if trimmed.contains("DO UPDATE SET") {
145 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
158pub(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
171pub(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
184pub(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 let after = &before[win_at + "WINDOW ".len()..];
195 if !after.to_ascii_uppercase().contains(" AS ") {
196 return false;
197 }
198 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 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
236pub(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 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 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
294pub(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
320pub(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 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 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
359pub(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
401pub(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 let before = &source[..pos];
411 let trimmed = before.trim_end();
412 if !before.ends_with(char::is_whitespace) {
413 return None;
414 }
415 let upper_trim = trimmed.to_ascii_uppercase();
418 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 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 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 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 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
473pub(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 if words.len() == 2 && words[0] == "DISCARD" && !stmt.ends_with(char::is_whitespace) {
484 return true;
485 }
486 false
487}
488
489pub(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 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 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 if i + 1 == words.len() && stmt.ends_with(char::is_whitespace) && !after.contains(" ON ") {
518 return true;
519 }
520 false
521}
522
523pub(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 words.len() == 1 && stmt.ends_with(char::is_whitespace) && !after.contains(" ON ")
535}
536
537pub(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 if words.len() == 2 && words[1] == "ON" && stmt.ends_with(char::is_whitespace) {
549 return true;
550 }
551 if words.len() == 3 && words[1] == "ON" && !stmt.ends_with(char::is_whitespace) {
554 return true;
555 }
556 false
557}
558
559pub(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 let after = upper.split_once("TRIGGER").map(|x| x.1).unwrap_or("");
574 let words: Vec<&str> = after.split_ascii_whitespace().collect();
575 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 if i + 1 == words.len() && stmt.ends_with(char::is_whitespace) {
582 return true;
583 }
584 false
585}
586
587pub(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
630pub(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 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 if words.len() == 1 && words[0] == "SET" && stmt.ends_with(char::is_whitespace) {
658 return Some(SET_MODS);
659 }
660 None
661}
662
663pub(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 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 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
702pub(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
748pub(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 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 let words: Vec<&str> = after_trim.split_ascii_whitespace().collect();
788 if words.len() == 1 && !stmt.ends_with(char::is_whitespace) {
789 return true;
791 }
792 false
793}
794
795pub(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 let trimmed = upper.trim_end();
806 trimmed.ends_with("CURSOR FOR") && stmt.ends_with(char::is_whitespace)
807}
808
809pub(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 let trimmed = upper.trim_end();
820 trimmed.ends_with(" AS") && stmt.ends_with(char::is_whitespace)
821}
822
823pub(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
832pub(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 if i + 3 <= words.len() && words[i] == "IF" && words[i + 1] == "NOT" && words[i + 2] == "EXISTS" {
846 i += 3;
847 }
848 if i + 1 == words.len() && stmt.ends_with(char::is_whitespace) {
850 return true;
851 }
852 false
853}
854
855pub(crate) fn create_type_enum_or_range_body(source: &str, offset: TextSize) -> bool {
863 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 if words.len() == 2 && words[1] == "AS" && stmt.ends_with(char::is_whitespace) {
901 return true;
902 }
903 if words.len() == 3 && words[1] == "AS" && !stmt.ends_with(char::is_whitespace) {
908 return true;
909 }
910 false
911}
912
913pub(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
953pub(crate) fn explain_paren_format_value(source: &str, offset: TextSize) -> bool {
956 explain_paren_value_after(source, offset, "FORMAT")
957}
958
959pub(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
981pub(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 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 let trimmed = stmt.trim_end();
1012 let last = trimmed.chars().last();
1013 if matches!(last, Some('(') | Some(',')) {
1014 return true;
1015 }
1016 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
1030pub(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 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 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; }
1071 i += 1;
1072 i = skip_ws(bytes, i);
1073 }
1074 loop {
1076 let rest_upper = stmt[i..].trim_start().to_ascii_uppercase();
1077 if let Some(stripped) = rest_upper.strip_prefix("ANALYZE") {
1078 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 i == bytes.len()
1106}
1107
1108pub(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 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 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 let after_trim = after.trim_start();
1133 if after_trim.is_empty() {
1134 return true;
1135 }
1136 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 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
1150pub(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
1168pub(crate) fn drop_target_trailing_slot(source: &str, offset: TextSize) -> bool {
1177 let (slice, _) = stmt_slice_upper(source, offset);
1178 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; }
1190 if words[0] != "DROP" {
1191 return false;
1192 }
1193 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 if idx + 1 < words.len() && words[idx] == "IF" && words[idx + 1] == "EXISTS" {
1231 idx += 2;
1232 }
1233 if idx >= words.len() {
1235 return false;
1236 }
1237 let last = words[words.len() - 1];
1240 if last == "CASCADE" || last == "RESTRICT" || last.ends_with(',') {
1241 return false;
1242 }
1243 let trim_end = slice.trim_end();
1246 if trim_end.ends_with(',') {
1247 return false;
1248 }
1249 true
1250}
1251
1252pub(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
1268pub(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 let mut end = pos;
1279 while end > 0 && bytes[end - 1].is_ascii_whitespace() {
1280 end -= 1;
1281 }
1282 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
1302pub(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 if upper.contains("RETURNING") || upper.contains("ON CONFLICT") {
1316 return false;
1317 }
1318 let trimmed = slice.trim_end();
1320 if !trimmed.ends_with(')') {
1321 return false;
1322 }
1323 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
1347pub(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 let trimmed = slice.trim_end();
1359 if trimmed.len() == slice.len() {
1360 return false; }
1362 let upper_trim = trimmed.to_ascii_uppercase();
1363 if !upper_trim.ends_with("DEFAULT") {
1364 return false;
1365 }
1366 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
1375pub(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 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 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 if has_or && !has_replace {
1418 return Some(&[("REPLACE", "CREATE OR REPLACE -- replace existing function/view/trigger/etc")]);
1419 }
1420 let suggest_modifiers = !has_or_replace && !has_temp && !has_unlogged && !has_unique && !has_materialized;
1424 if !suggest_modifiers {
1431 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
1489pub(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
1542pub(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 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
1593pub(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
1657pub(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 || (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
1786pub(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; }
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 if words.contains(&"ON") && !words.contains(&"IS") && words.len() >= 5 {
1836 return Some(&[("IS", "IS '<label_text>' | IS NULL -- clear label")]);
1837 }
1838 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
1851pub(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 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 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 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; }
1898 if last == "NO" && words.contains(&"ALTER") {
1899 return Some(&[("INHERIT", "NO INHERIT <parent> -- remove inheritance link")]);
1900 }
1901 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
1913pub(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 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; }
1933 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 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 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
1963pub(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 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 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 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
2008pub(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 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 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
2053pub(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 if (is_ctas || is_cmv) && !words.contains(&"WITH") {
2083 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
2092pub(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 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 if words.contains(&"OVERRIDING") && matches!(words.last(), Some(&"OVERRIDING") | Some(&"SYSTEM") | Some(&"USER")) {
2120 return None;
2121 }
2122 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
2138pub(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 if words.contains(&"SET") || words.len() < 3 {
2153 return None;
2154 }
2155 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
2164pub(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
2190pub(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 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
2218pub(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
2238pub(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
2268pub(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 if !upper.contains("WINDOW") && !upper.contains("OVER") {
2283 return None;
2284 }
2285 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 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 if last == "BETWEEN" {
2310 return Some(&[("UNBOUNDED PRECEDING", "frame starts at partition start"), ("CURRENT ROW", "current row")]);
2311 }
2312 if last == "AND" && words.contains(&"BETWEEN") {
2314 return Some(&[("UNBOUNDED FOLLOWING", "frame ends at partition end"), ("CURRENT ROW", "current row")]);
2315 }
2316 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 if last == "CURRENT" {
2331 return Some(&[("ROW", "CURRENT ROW -- the current row only")]);
2332 }
2333 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 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 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
2375pub(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
2398pub(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 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
2428pub(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 if depth != 1 {
2460 return false;
2461 }
2462 let trimmed = after.trim_end();
2463 trimmed.ends_with('(') || trimmed.ends_with(',')
2464}
2465
2466const 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
2485pub(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
2565fn 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
2620pub(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 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 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 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; }
2664 if last == "WITH" {
2665 return Some(&[("TIES", "WITH TIES -- include peers tied on ORDER BY")]);
2666 }
2667 None
2668}
2669
2670pub(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
2697pub(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 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 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 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 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
2779pub(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 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 None
2828}
2829
2830pub(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 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
2860pub(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; }
2892 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 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
2917pub(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 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
2955pub(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 if words.len() == 1 {
2971 return None; }
2973 if words == ["SET", "ROLE"] {
2975 return Some(&[("NONE", "SET ROLE NONE -- revert to login role")]);
2976 }
2977 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 None
2992}
2993
2994pub(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 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 if matches!(last, "TO" | "FROM") {
3038 return None;
3039 }
3040 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 if last == "GRANTED" && first == "REVOKE" {
3057 return Some(&[("BY", "GRANTED BY <role> -- target the grant from <role>")]);
3058 }
3059 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 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 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 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 None
3133}
3134
3135pub(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 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 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
3180pub(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
3202pub(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; }
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 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 if tail.contains(&"LANGUAGE") && !tail.contains(&"(") && opens == closes {
3268 return Some(&[("(", "( FROM SQL WITH FUNCTION ..., TO SQL WITH FUNCTION ... )")]);
3269 }
3270 None
3271}
3272
3273pub(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; }
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
3307pub(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; }
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; }
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; }
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 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 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 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
3432pub(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
3490pub(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 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 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; }
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
3633pub(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 if words.len() == 4 {
3662 return None; }
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 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 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
3744pub(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 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
3805pub(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
3875pub(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
3924pub(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 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
4022pub(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; }
4042 if last == "ON" {
4043 return None; }
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
4057pub(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; }
4078 if last == "ON" {
4079 return None; }
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
4103pub(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
4131pub(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; }
4151 if last == Some("FOR") {
4152 return None; }
4154 if last == Some("TO") && tail.contains(&"FOR") {
4155 return None; }
4157 if last == Some("FROM") && tail.contains(&"FOR") {
4158 return None; }
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
4172pub(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; }
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
4235pub(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 let words: Vec<&str> = upper.split_ascii_whitespace().collect();
4262 if words.contains(&"AS") {
4263 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 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; }
4309 if paren_balanced && words.len() >= 3 {
4310 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 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 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 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
4374pub(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
4410pub(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 if last == "IN" && words.contains(&"TABLES") {
4450 return Some(&[("SCHEMA", "TABLES IN SCHEMA <schema>[, ...]")]);
4451 }
4452 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
4468pub(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
4528pub(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 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
4594pub(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
4632pub(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; }
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
4682pub(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 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
4758pub(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
4808pub(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; }
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
4845pub(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 let dq = upper.matches("$$").count();
4868 if dq > 0 && dq % 2 == 1 {
4869 return None;
4870 }
4871 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 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 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 if upper.rfind("RETURNS").map(|p| upper[p + "RETURNS".len()..].trim().is_empty()).unwrap_or(false) {
4900 return None;
4901 }
4902 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 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 if after.split_ascii_whitespace().next().is_none_or(|t| t.is_empty()) {
4925 return None;
4926 }
4927 }
4928 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 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
5028pub(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
5111pub(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 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; }
5162 if last == "WITH" {
5163 }
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 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; }
5227 if last == "LOCATION" {
5228 return None; }
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
5239pub(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 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
5291pub(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 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 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
5342pub(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
5394pub(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 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 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 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
5466pub(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 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; }
5534 if last == "FROM" {
5535 return None; }
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
5546pub(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 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 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 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
5626pub(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 if last == "TAG" && words.contains(&"WHEN") {
5660 return Some(&[("IN", "IN ('<cmd_tag1>', '<cmd_tag2>', ...)")]);
5661 }
5662 if last == "IN" && words.contains(&"WHEN") {
5664 return Some(&[("(", "( '<cmd_tag1>', '<cmd_tag2>', ... )")]);
5665 }
5666 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
5691pub(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 if tail.is_empty() {
5715 return None;
5716 }
5717 if tail.len() == 1 {
5718 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; }
5728 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 Some(&[("INLINE", "INLINE <inline_handler_fn>"), ("VALIDATOR", "VALIDATOR <validator_fn>")])
5741}
5742
5743pub(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
5780pub(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; }
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
5831pub(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; }
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; }
5911 if last == "VERSION" {
5912 return None;
5913 }
5914 if last == "WRAPPER" && words.contains(&"FOREIGN") {
5915 return None; }
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
5936pub(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 let opens = slice.matches('(').count();
5958 let closes = slice.matches(')').count();
5959 if opens == 0 || opens <= closes {
5960 return None;
5961 }
5962 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
5981pub(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 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; }
6009 if matches!(last, "NULL" | "DEFAULT" | "CHECK") {
6011 return None; }
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
6022pub(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 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 let last = *words.last()?;
6060 if last == "FROM" {
6061 return None; }
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
6072pub(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 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 if last == "ALWAYS" && second_last == Some("GENERATED") {
6106 return Some(&[("AS", "AS IDENTITY | AS (<expression>) STORED")]);
6107 }
6108 if last == "DEFAULT" && second_last == Some("BY") && third_last == Some("GENERATED") {
6110 return Some(&[("AS IDENTITY", "AS IDENTITY -- sequence-backed column")]);
6111 }
6112 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 let trimmed = slice_owned.trim_end();
6122 if trimmed.ends_with(')') && upper.contains("GENERATED") && !upper.contains("STORED") && !upper.contains("VIRTUAL") {
6123 return Some(&[
6125 ("STORED", "STORED -- materialised generated column"),
6126 ("VIRTUAL", "VIRTUAL -- on-the-fly generated column (PG18+ / reserved)"),
6127 ]);
6128 }
6129 None
6130}
6131
6132pub(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 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 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
6166pub(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 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 if !slice_owned.ends_with(char::is_whitespace) {
6194 return None;
6195 }
6196 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
6204pub(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 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 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 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 if last == "DEFERRABLE" {
6245 return Some(&[("INITIALLY", "INITIALLY DEFERRED | IMMEDIATE")]);
6246 }
6247 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
6257pub(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 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 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 if matches!(last, "DEPTH" | "BREADTH") && words.contains(&"SEARCH") {
6283 return Some(&[("FIRST BY", "FIRST BY <cols> SET <out_col>")]);
6284 }
6285 if last == "FIRST" && (words.contains(&"DEPTH") || words.contains(&"BREADTH")) {
6287 return Some(&[("BY", "BY <cols> SET <out_col>")]);
6288 }
6289 if last == "CYCLE" {
6292 return Some(&[("<cols>", "CYCLE <col1>, <col2>, ... SET <flag_col>")]);
6293 }
6294 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
6304pub(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 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 if n == 4 && matches!(words[2], "SET") {
6349 return Some(&[("TO", "TO <value>"), ("=", "= <value>")]);
6350 }
6351 if n == 3 && words[2] == "RESET" {
6353 return Some(&[("ALL", "RESET ALL -- restore all GUCs to default")]);
6354 }
6355 None
6356}
6357
6358pub(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; }
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
6385pub(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; }
6407 if last == "CONNECTION" {
6408 return None; }
6410 if last == "PUBLICATION" {
6411 return None; }
6413 if last == "WITH" {
6414 return Some(&[("(", "WITH ( <param> = <value>[, ...] )")]);
6415 }
6416 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 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; }
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 if last == "ALL" && words.contains(&"FOR") {
6479 return Some(&[("TABLES", "FOR ALL TABLES -- every existing + future table")]);
6480 }
6481 if last == "IN" && words.contains(&"TABLES") {
6483 return Some(&[("SCHEMA", "TABLES IN SCHEMA <schema>[, ...] (PG15+)")]);
6484 }
6485 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 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
6508pub(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 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 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 if n >= 3 && !words.contains(&"USING") {
6555 return Some(&[("USING", "USING <index_name> -- pick a non-default cluster index")]);
6556 }
6557 None
6558}
6559
6560pub(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; }
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 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
6603pub(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; }
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
6633pub(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 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; }
6665 if last == "INHERITS" {
6666 return None; }
6668 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 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 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 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; }
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 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
6729pub(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
6738pub(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
6786pub(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; }
6809 if !words.contains(&"TO") && words.len() >= 4 {
6811 return Some(&[("TO", "TO <new_role>")]);
6812 }
6813 None
6814}
6815
6816pub(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 if first == "PREPARE" {
6840 if words.len() == 1 {
6841 return Some(&[("TRANSACTION", "PREPARE TRANSACTION '<gxid>'")]);
6842 }
6843 return None;
6844 }
6845 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 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 if last == "TO" && first == "ROLLBACK" {
6873 return Some(&[("SAVEPOINT", "TO SAVEPOINT <name> -- optional kw")]);
6874 }
6875 if last == "PREPARED" {
6877 return None;
6878 }
6879 None
6880}
6881
6882pub(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
6901pub(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 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 return None;
6948 }
6949 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
6968pub(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 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 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 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
7032pub(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 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
7066pub(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 let last = *words.last()?;
7086 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 if words.len() < 3 {
7098 return None;
7099 }
7100 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
7132pub(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 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 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 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
7183pub(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 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 if after_kw.len() == 1 {
7218 return None;
7219 }
7220 let tail = &after_kw[1..]; 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 if last == "EXECUTE" {
7233 return Some(&[
7234 ("FUNCTION", "EXECUTE FUNCTION <fn>(<args>)"),
7235 ("PROCEDURE", "EXECUTE PROCEDURE <fn>(<args>) -- pre-PG11"),
7236 ]);
7237 }
7238 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 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 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 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 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
7304pub(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 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 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
7360pub(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 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 if n == 4 && words[3] == "ADD" {
7397 return Some(&[("VALUE", "VALUE [IF NOT EXISTS] '<lit>'"), ("ATTRIBUTE", "ATTRIBUTE <name> <type>")]);
7398 }
7399 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 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 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 if n == 6 && words[3] == "RENAME" && words[4] == "VALUE" {
7423 return Some(&[("TO", "TO '<new>' -- new value literal")]);
7424 }
7425 if n == 4 && words[3] == "SET" {
7427 return Some(&[("SCHEMA", "SCHEMA <schema_name>")]);
7428 }
7429 if n == 4 && words[3] == "OWNER" {
7431 return Some(&[("TO", "TO <role>")]);
7432 }
7433 None
7434}
7435
7436pub(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; }
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
7548pub(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 let mut end = pos;
7562 while end > 0 && bytes[end - 1].is_ascii_whitespace() {
7563 end -= 1;
7564 }
7565 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 if end > pos || pos != end + (pos - end) {
7581 }
7584 let between = &source[end..pos];
7585 if !between.chars().all(|c| c.is_ascii_whitespace()) {
7586 return None;
7587 }
7588 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" => Some(&[("TO", "OWNER TO <role>")]),
7632 "NULLS" => Some(&[("NOT DISTINCT", "NULLS NOT DISTINCT -- treat NULLs as equal for uniqueness")]),
7634 _ => None,
7635 }
7636}
7637
7638pub(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 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 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 let inside = &source[i + 1..pos];
7682 let inside_upper = inside.to_ascii_uppercase();
7683 inside_upper.contains(" AS ")
7684}
7685
7686pub(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#[derive(Copy, Clone)]
7766pub enum AlterColumnAction {
7767 Set,
7768 Drop,
7769}
7770
7771pub(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 let trimmed = upper.trim_end();
7782 let after_alter_col = upper.rsplit("ALTER COLUMN").next()?;
7786 let after_trim = after_alter_col.trim_end();
7787 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
7799pub(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 if !upper.contains("ALTER TABLE") {
7808 return false;
7809 }
7810 let Some(add_at) = upper.rfind("ADD COLUMN") else { return false };
7811 let after = &stmt[add_at + "ADD COLUMN".len()..];
7813 let mut tokens = after.split_ascii_whitespace().peekable();
7814 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 if tokens.next().is_none() {
7826 return false;
7827 }
7828 let rest_after_name = stmt[add_at + "ADD COLUMN".len()..].trim_start().split_ascii_whitespace().collect::<Vec<_>>();
7834 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), 2 => !stmt.ends_with(char::is_whitespace), _ => false,
7855 }
7856}
7857
7858pub(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 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 (&["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 (&["REINDEX", "TABLE"], &["CONCURRENTLY"]),
7892 (&["REINDEX", "INDEX"], &["CONCURRENTLY"]),
7893 (&["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 let cleaned = w.trim_end_matches(|c: char| !c.is_ascii_alphanumeric() && c != '_');
7904 cleaned.eq_ignore_ascii_case(k)
7905 }) {
7906 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 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
7926pub(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 let alter_at = upper.find("ALTER TABLE")?;
7935 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 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 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
7968pub(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
7998pub(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 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
8052pub(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 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
8110pub(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
8149pub(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(®ion[item_start..i], &mut out);
8180 item_start = i + 1;
8181 }
8182 i += 1;
8183 }
8184 push_first_ident(®ion[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 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
8208pub(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 if let Some(t) = scan_buffer_for_trigger_fn(source, fn_short) {
8240 return Some(t);
8241 }
8242 for t in cat.tables() {
8245 for tg in &t.triggers {
8246 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
8259pub(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 let stmt_end = upper[p..].find(';').map(|e| p + e).unwrap_or(upper.len());
8269 let stmt_upper = &upper[p..stmt_end];
8270 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
8289pub(crate) fn trigger_target_table(source: &str) -> Option<String> {
8292 let upper = source.to_uppercase();
8293 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 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 Some(tok.split('.').next_back().unwrap_or(tok).trim_matches('"').to_string())
8316}
8317
8318pub(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
8336pub(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
8391fn 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
8410pub(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 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 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 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 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 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
8553pub(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 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
8581pub(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
8591pub(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 let mut state: u8 = 0;
8604 while i < limit {
8605 match state {
8606 0 => {
8607 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 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 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 pub content_start: usize,
8693 pub content_end: usize,
8694 pub dollar_quoted: bool,
8695}
8696
8697fn 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
8716fn 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
8726pub(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 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 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 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 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
8879pub(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 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
8911pub(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 if before.len() == trimmed.len() {
8928 return None; }
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 let bytes = upper.as_bytes();
8969 let n = bytes.len();
8970 let mut end = n;
8971 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 let lead = lead.strip_suffix("IF NOT EXISTS").unwrap_or(lead).trim_end();
8978 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 "ADD COLUMN",
9030 "ADD CONSTRAINT",
9031 "RENAME TO",
9032 "RENAME CONSTRAINT",
9033 "LISTEN",
9037 "UNLISTEN",
9038 "NOTIFY",
9039 "PREPARE",
9040 "DEALLOCATE",
9041 "DECLARE",
9042 "IMPORT FOREIGN SCHEMA",
9043 "CHECKPOINT",
9044 "FETCH",
9047 "MOVE",
9048 "CLOSE",
9049 "OPEN",
9050 "CREATE EVENT TRIGGER",
9052 "CREATE INDEX CONCURRENTLY",
9054 "CREATE UNIQUE INDEX CONCURRENTLY",
9055 "WITH RECURSIVE",
9057 "USE",
9061 "VALUES",
9064 ];
9068 if PATTERNS.iter().any(|p| lead.ends_with(p)) {
9069 return true;
9070 }
9071 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
9083pub(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 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 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
9123pub(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
9136pub(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 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 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 for it in &mut out[start..] {
9220 it.sort_priority = 0;
9221 }
9222 if !had_scope {
9223 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
9235pub(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 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}