use crate::engine::{current_statement_span, cursor_not_at_ws_boundary, push_keyword_kvs, stmt_slice_upper};
use crate::fallback;
use crate::item::Item;
use crate::sources;
use dsl_catalog::Catalog;
use dsl_parse::ParsedFile;
use dsl_resolve::Scope;
use text_size::TextSize;
pub(crate) fn update_set_at_column_slot(source: &str, offset: TextSize) -> bool {
let pos: usize = (u32::from(offset) as usize).min(source.len());
let bytes = source.as_bytes();
let mut anchor: Option<usize> = None;
let mut depth = 0i32;
let mut i = pos;
while i > 0 {
let b = bytes[i - 1];
if b >= 128 {
i -= 1;
continue;
}
let c = b as char;
if c == ')' {
depth += 1;
i -= 1;
continue;
}
if c == '(' {
if depth == 0 {
return false;
}
depth -= 1;
i -= 1;
continue;
}
if c == ';' {
return false;
}
if match_kw_at(bytes, i, b"SET") {
anchor = Some(i);
break;
}
i -= 1;
}
let Some(anchor) = anchor else {
return false;
};
if !(source.is_char_boundary(anchor) && source.is_char_boundary(pos)) {
return false;
}
let region = &source[anchor..pos];
let rbytes = region.as_bytes();
let n = rbytes.len();
let mut depth = 0i32;
let mut last_eq: Option<usize> = None;
let mut last_comma: Option<usize> = None;
let mut i = 0usize;
while i < n {
let c = rbytes[i] as char;
if c == '\'' {
i += 1;
while i < n && rbytes[i] != b'\'' {
i += 1;
}
i = (i + 1).min(n);
continue;
}
if c == '(' {
depth += 1;
} else if c == ')' {
depth -= 1;
} else if depth == 0 {
if c == ',' {
last_comma = Some(i);
} else if c == '=' {
last_eq = Some(i);
}
}
i += 1;
}
match (last_eq, last_comma) {
(None, _) => true,
(Some(_), None) => false,
(Some(eq), Some(co)) => co > eq,
}
}
pub(crate) fn on_conflict_expects_target_column(source: &str, offset: TextSize) -> bool {
let (_slice, upper) = stmt_slice_upper(source, offset);
let Some(oc_at) = upper.rfind("ON CONFLICT") else { return false };
let after = &upper[oc_at + "ON CONFLICT".len()..];
let mut depth = 0i32;
let mut in_target = false;
for c in after.chars() {
match c {
'(' => {
depth += 1;
in_target = true;
},
')' => depth -= 1,
_ => {},
}
}
if in_target && depth > 0 {
return true;
}
let trimmed = after.trim_end();
let after_set = trimmed.rsplit("SET").next().unwrap_or("");
if trimmed.contains("DO UPDATE SET") {
let cleaned = after_set.trim_start();
let no_assignment_yet = !cleaned.contains('=');
let after_comma_or_start = cleaned.is_empty()
|| cleaned.chars().all(|c| c.is_ascii_alphanumeric() || c == '_' || c == ',' || c.is_whitespace());
if no_assignment_yet && after_comma_or_start {
return true;
}
}
false
}
pub(crate) fn raise_expects_level_keyword(source: &str, offset: TextSize) -> bool {
let (slice, upper) = stmt_slice_upper(source, offset);
let stmt = slice.trim_start();
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if words.len() == 1 && words[0] == "RAISE" && stmt.ends_with(char::is_whitespace) {
return true;
}
false
}
pub(crate) fn reset_expects_subkeyword(source: &str, offset: TextSize) -> bool {
let (slice, upper) = stmt_slice_upper(source, offset);
let stmt = slice.trim_start();
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if words.len() == 1 && words[0] == "RESET" && stmt.ends_with(char::is_whitespace) {
return true;
}
false
}
pub(crate) fn window_clause_paren_expects_subclause(source: &str, offset: TextSize) -> bool {
let pos: usize = u32::from(offset) as usize;
let pos = pos.min(source.len());
let before = &source[..pos];
let upper = before.to_ascii_uppercase();
let Some(win_at) = upper.rfind("WINDOW ") else { return false };
let after = &before[win_at + "WINDOW ".len()..];
if !after.to_ascii_uppercase().contains(" AS ") {
return false;
}
let mut depth = 0i32;
let mut open_at: Option<usize> = None;
for (i, b) in after.bytes().enumerate() {
match b {
b'(' => {
if depth == 0 {
open_at = Some(i);
}
depth += 1;
},
b')' => {
depth -= 1;
if depth == 0 {
open_at = None;
}
},
_ => {},
}
}
let Some(open) = open_at else { return false };
let body_trim = after[open + 1..].trim();
body_trim.is_empty()
|| !["PARTITION", "ORDER", "ROWS", "RANGE", "GROUPS"]
.iter()
.any(|kw| body_trim.to_ascii_uppercase().starts_with(kw))
}
pub(crate) fn window_clause_partition_or_order_by_expects_column(source: &str, offset: TextSize) -> bool {
let pos: usize = u32::from(offset) as usize;
let pos = pos.min(source.len());
let before = &source[..pos];
if !before.ends_with(char::is_whitespace) {
return false;
}
let upper = before.to_ascii_uppercase();
let Some(win_at) = upper.rfind("WINDOW ") else { return false };
let after = &upper[win_at + "WINDOW ".len()..];
if !after.contains(" AS ") {
return false;
}
let mut depth = 0i32;
let mut open_at: Option<usize> = None;
for (i, b) in after.bytes().enumerate() {
match b {
b'(' => {
if depth == 0 {
open_at = Some(i);
}
depth += 1;
},
b')' => {
depth -= 1;
if depth == 0 {
open_at = None;
}
},
_ => {},
}
}
if open_at.is_none() {
return false;
}
let trimmed = upper.trim_end();
let ends_partition_by = trimmed.ends_with("PARTITION BY") && {
let n = trimmed.len() - "PARTITION BY".len();
n == 0 || !trimmed.as_bytes()[n - 1].is_ascii_alphanumeric()
};
let ends_order_by = trimmed.ends_with("ORDER BY") && {
let n = trimmed.len() - "ORDER BY".len();
n == 0 || !trimmed.as_bytes()[n - 1].is_ascii_alphanumeric()
};
ends_partition_by || ends_order_by || trimmed.ends_with(',')
}
pub(crate) const LATERAL_TARGETS: &[(&str, &str)] = &[
("generate_series", "generate_series(start, stop[, step]) -> setof <type>"),
("unnest", "unnest(<array>) -> setof <element-type>"),
("jsonb_array_elements", "jsonb_array_elements(<jsonb>) -> setof jsonb"),
("jsonb_array_elements_text", "jsonb_array_elements_text(<jsonb>) -> setof text"),
("jsonb_each", "jsonb_each(<jsonb>) -> setof (key text, value jsonb)"),
("jsonb_each_text", "jsonb_each_text(<jsonb>) -> setof (key text, value text)"),
("jsonb_object_keys", "jsonb_object_keys(<jsonb>) -> setof text"),
("jsonb_to_record", "jsonb_to_record(<jsonb>) AS x(...) -- requires column-def alias"),
("jsonb_to_recordset", "jsonb_to_recordset(<jsonb>) AS x(...) -- requires column-def alias"),
("json_array_elements", "json_array_elements(<json>) -> setof json"),
("json_array_elements_text", "json_array_elements_text(<json>) -> setof text"),
("json_each", "json_each(<json>) -> setof (key text, value json)"),
("json_each_text", "json_each_text(<json>) -> setof (key text, value text)"),
("json_object_keys", "json_object_keys(<json>) -> setof text"),
("regexp_split_to_table", "regexp_split_to_table(<str>, <pattern>) -> setof text"),
("string_to_table", "string_to_table(<str>, <delim>) -> setof text"),
("array_to_table", "(SELECT ...) -- a parenthesized subquery is also a valid LATERAL target"),
];
pub(crate) fn lateral_target_expected(source: &str, offset: TextSize) -> bool {
let pos: usize = u32::from(offset) as usize;
let pos = pos.min(source.len());
let before = &source[..pos];
let trimmed = before.trim_end_matches(|c: char| c.is_alphanumeric() || c == '_');
if !trimmed.ends_with(char::is_whitespace) {
return false;
}
let upper = trimmed.trim_end().to_ascii_uppercase();
if !upper.ends_with("LATERAL") {
return false;
}
let len = upper.len();
if len > 7 {
let prev = upper.as_bytes()[len - 8] as char;
if prev.is_alphanumeric() || prev == '_' {
return false;
}
}
true
}
pub(crate) fn tablesample_expects_method(source: &str, offset: TextSize) -> bool {
let pos: usize = u32::from(offset) as usize;
let pos = pos.min(source.len());
let before = &source[..pos];
if !before.ends_with(char::is_whitespace) {
return false;
}
let upper = before.trim_end().to_ascii_uppercase();
upper.ends_with(" TABLESAMPLE") || upper == "TABLESAMPLE"
}
pub(crate) fn select_for_locking_keywords(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
let pos: usize = u32::from(offset) as usize;
let pos = pos.min(source.len());
let before = &source[..pos];
if !before.ends_with(char::is_whitespace) {
return None;
}
let trimmed = before.trim_end();
let upper = trimmed.to_ascii_uppercase();
const STRENGTH: &[(&str, &str)] = &[
("UPDATE", "FOR UPDATE -- exclusive row lock"),
("NO KEY UPDATE", "FOR NO KEY UPDATE -- weaker than UPDATE"),
("SHARE", "FOR SHARE -- shared row lock"),
("KEY SHARE", "FOR KEY SHARE -- weakest row lock"),
];
const MODIFIERS: &[(&str, &str)] = &[
("OF", "OF <table>[, ...] -- restrict to specific tables"),
("NOWAIT", "NOWAIT -- error instead of waiting for the lock"),
("SKIP LOCKED", "SKIP LOCKED -- skip rows already locked"),
];
if upper.ends_with(" FOR") || upper == "FOR" {
return Some(STRENGTH);
}
for tail in &[" FOR UPDATE", " FOR NO KEY UPDATE", " FOR SHARE", " FOR KEY SHARE"] {
if upper.ends_with(tail) {
return Some(MODIFIERS);
}
}
None
}
pub(crate) fn is_predicate_continuation_keywords(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
let pos: usize = u32::from(offset) as usize;
let pos = pos.min(source.len());
let before = &source[..pos];
let trimmed = before.trim_end();
if !before.ends_with(char::is_whitespace) {
return None;
}
let upper_trim = trimmed.to_ascii_uppercase();
if upper_trim.ends_with(" IS DISTINCT") || upper_trim.ends_with(" IS NOT DISTINCT") {
return Some(&[("FROM", "IS [NOT] DISTINCT FROM <expr> -- NULL-aware compare")]);
}
if upper_trim.ends_with(" IS JSON") || upper_trim.ends_with(" IS NOT JSON") {
return Some(&[
("VALUE", "IS [NOT] JSON VALUE -- any JSON value (default)"),
("SCALAR", "IS [NOT] JSON SCALAR -- number/string/boolean/null"),
("ARRAY", "IS [NOT] JSON ARRAY"),
("OBJECT", "IS [NOT] JSON OBJECT [WITH|WITHOUT UNIQUE KEYS]"),
]);
}
if upper_trim.ends_with(" IS JSON OBJECT WITH") || upper_trim.ends_with(" IS NOT JSON OBJECT WITH") {
return Some(&[("UNIQUE KEYS", "WITH UNIQUE KEYS -- forbid duplicate keys at any level")]);
}
if upper_trim.ends_with(" IS JSON OBJECT WITHOUT") || upper_trim.ends_with(" IS NOT JSON OBJECT WITHOUT") {
return Some(&[("UNIQUE KEYS", "WITHOUT UNIQUE KEYS -- explicit default (duplicates allowed)")]);
}
let last_is_not = upper_trim.ends_with(" IS NOT") || upper_trim == "IS NOT";
if last_is_not {
const IS_NOT: &[(&str, &str)] = &[
("NULL", "IS NOT NULL"),
("TRUE", "IS NOT TRUE"),
("FALSE", "IS NOT FALSE"),
("UNKNOWN", "IS NOT UNKNOWN"),
("JSON", "IS NOT JSON [VALUE|SCALAR|ARRAY|OBJECT] (PG16+)"),
("DISTINCT FROM", "IS NOT DISTINCT FROM <expr> -- NULL-aware equality"),
];
return Some(IS_NOT);
}
let ends_with_is = trimmed.len() >= 2
&& trimmed.as_bytes()[trimmed.len() - 2..].eq_ignore_ascii_case(b"IS")
&& (trimmed.len() == 2 || trimmed.as_bytes()[trimmed.len() - 3].is_ascii_whitespace());
if ends_with_is {
const IS: &[(&str, &str)] = &[
("NULL", "IS NULL"),
("NOT NULL", "IS NOT NULL"),
("TRUE", "IS TRUE"),
("FALSE", "IS FALSE"),
("UNKNOWN", "IS UNKNOWN"),
("DISTINCT FROM", "IS DISTINCT FROM <expr> -- NULL-aware inequality"),
("NOT DISTINCT FROM", "IS NOT DISTINCT FROM <expr> -- NULL-aware equality"),
("JSON", "IS JSON [VALUE|SCALAR|ARRAY|OBJECT] (PG16+)"),
];
return Some(IS);
}
None
}
pub(crate) fn discard_expects_subkeyword(source: &str, offset: TextSize) -> bool {
let (slice, upper) = stmt_slice_upper(source, offset);
let stmt = slice.trim_start();
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if words.len() == 1 && words[0] == "DISCARD" && stmt.ends_with(char::is_whitespace) {
return true;
}
if words.len() == 2 && words[0] == "DISCARD" && !stmt.ends_with(char::is_whitespace) {
return true;
}
false
}
pub(crate) fn create_index_expects_on(source: &str, offset: TextSize) -> bool {
let (slice, upper) = stmt_slice_upper(source, offset);
let stmt = slice.trim_start();
if !upper.starts_with("CREATE INDEX") && !upper.starts_with("CREATE UNIQUE INDEX") {
return false;
}
let after = if let Some(s) = upper.strip_prefix("CREATE UNIQUE INDEX") {
s
} else if let Some(s) = upper.strip_prefix("CREATE INDEX") {
s
} else {
return false;
};
let words: Vec<&str> = after.split_ascii_whitespace().collect();
let mut i = 0;
if i < words.len() && words[i] == "CONCURRENTLY" {
i += 1;
}
if i + 3 <= words.len() && words[i] == "IF" && words[i + 1] == "NOT" && words[i + 2] == "EXISTS" {
i += 3;
}
if i + 1 == words.len() && stmt.ends_with(char::is_whitespace) && !after.contains(" ON ") {
return true;
}
false
}
pub(crate) fn create_policy_expects_on(source: &str, offset: TextSize) -> bool {
let (slice, upper) = stmt_slice_upper(source, offset);
let stmt = slice.trim_start();
if !upper.starts_with("CREATE POLICY") {
return false;
}
let after = &upper["CREATE POLICY".len()..];
let words: Vec<&str> = after.split_ascii_whitespace().collect();
words.len() == 1 && stmt.ends_with(char::is_whitespace) && !after.contains(" ON ")
}
pub(crate) fn create_policy_expects_table(source: &str, offset: TextSize) -> bool {
let (slice, upper) = stmt_slice_upper(source, offset);
let stmt = slice.trim_start();
if !upper.starts_with("CREATE POLICY") {
return false;
}
let after = &upper["CREATE POLICY".len()..];
let words: Vec<&str> = after.split_ascii_whitespace().collect();
if words.len() == 2 && words[1] == "ON" && stmt.ends_with(char::is_whitespace) {
return true;
}
if words.len() == 3 && words[1] == "ON" && !stmt.ends_with(char::is_whitespace) {
return true;
}
false
}
pub(crate) fn create_trigger_expects_timing(source: &str, offset: TextSize) -> bool {
let (slice, upper) = stmt_slice_upper(source, offset);
let stmt = slice.trim_start();
let starts = upper.starts_with("CREATE TRIGGER")
|| upper.starts_with("CREATE OR REPLACE TRIGGER")
|| upper.starts_with("CREATE CONSTRAINT TRIGGER");
if !starts {
return false;
}
let after = upper.split_once("TRIGGER").map(|x| x.1).unwrap_or("");
let words: Vec<&str> = after.split_ascii_whitespace().collect();
let mut i = 0;
if i + 3 <= words.len() && words[i] == "IF" && words[i + 1] == "NOT" && words[i + 2] == "EXISTS" {
i += 3;
}
if i + 1 == words.len() && stmt.ends_with(char::is_whitespace) {
return true;
}
false
}
pub(crate) fn command_expects_role_name(source: &str, offset: TextSize) -> bool {
let (slice, upper) = stmt_slice_upper(source, offset);
let stmt = slice.trim_start();
let kinds: &[(&[&str], &[&str])] = &[
(&["ALTER", "ROLE"], &["IF", "EXISTS"]),
(&["ALTER", "USER"], &["IF", "EXISTS"]),
(&["ALTER", "GROUP"], &["IF", "EXISTS"]),
(&["DROP", "ROLE"], &["IF", "EXISTS"]),
(&["DROP", "USER"], &["IF", "EXISTS"]),
(&["DROP", "GROUP"], &["IF", "EXISTS"]),
(&["REASSIGN", "OWNED", "BY"], &[]),
(&["DROP", "OWNED", "BY"], &[]),
(&["CREATE", "SCHEMA", "AUTHORIZATION"], &[]),
(&["GRANT", "ROLE"], &[]),
];
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
for (kw_seq, mods) in kinds {
if words.len() < kw_seq.len() {
continue;
}
if !kw_seq.iter().zip(words.iter()).all(|(k, w)| {
let cleaned = w.trim_end_matches(|c: char| !c.is_ascii_alphanumeric() && c != '_');
cleaned.eq_ignore_ascii_case(k)
}) {
continue;
}
let mut i = kw_seq.len();
while i < words.len() && mods.iter().any(|m| words[i].eq_ignore_ascii_case(m)) {
i += 1;
}
let ends_with_comma = stmt.trim_end().ends_with(',');
let last_word_is_partial = !stmt.ends_with(char::is_whitespace);
if i >= words.len() || ends_with_comma || last_word_is_partial {
return true;
}
}
false
}
pub(crate) fn set_statement_completion(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
let (slice, upper) = stmt_slice_upper(source, offset);
let stmt = slice.trim_start();
if upper.starts_with("SET ROLE")
|| upper.starts_with("SET SESSION AUTHORIZATION")
|| upper.starts_with("SET CONSTRAINTS")
|| upper.starts_with("SET TRANSACTION")
{
return None;
}
const SET_MODS: &[(&str, &str)] = &[
("LOCAL", "SET LOCAL <var> = <value> -- transaction-scoped"),
("SESSION", "SET SESSION <var> = <value> -- session-scoped (default)"),
];
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if words.len() == 1 && words[0] == "SET" && stmt.ends_with(char::is_whitespace) {
return Some(SET_MODS);
}
None
}
pub(crate) fn transaction_control_completion(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
let (_slice, upper) = stmt_slice_upper(source, offset);
const TXN_MODIFIERS: &[(&str, &str)] = &[
("ISOLATION LEVEL", "ISOLATION LEVEL SERIALIZABLE|REPEATABLE READ|READ COMMITTED|READ UNCOMMITTED"),
("READ ONLY", "READ ONLY"),
("READ WRITE", "READ WRITE"),
("DEFERRABLE", "DEFERRABLE"),
("NOT DEFERRABLE", "NOT DEFERRABLE"),
("ATOMIC", "ATOMIC -- standard-SQL CREATE FUNCTION body: BEGIN ATOMIC <stmts> END;"),
];
const EMPTY: &[(&str, &str)] = &[];
let starts_with =
|kw: &str| upper.starts_with(kw) && (upper.len() == kw.len() || upper.as_bytes()[kw.len()].is_ascii_whitespace());
if starts_with("BEGIN TRANSACTION") || starts_with("START TRANSACTION") || starts_with("BEGIN") {
return Some(TXN_MODIFIERS);
}
if starts_with("COMMIT")
|| starts_with("ROLLBACK")
|| starts_with("END")
|| starts_with("ABORT")
|| starts_with("SAVEPOINT")
|| starts_with("RELEASE")
{
return Some(EMPTY);
}
None
}
pub(crate) const COMMENT_ON_CLASSES: &[(&str, &str)] = &[
("TABLE", "COMMENT ON TABLE <name> IS '...'"),
("COLUMN", "COMMENT ON COLUMN <table>.<column> IS '...'"),
("SCHEMA", "COMMENT ON SCHEMA <name> IS '...'"),
("DATABASE", "COMMENT ON DATABASE <name> IS '...'"),
("FUNCTION", "COMMENT ON FUNCTION <name>(...) IS '...'"),
("PROCEDURE", "COMMENT ON PROCEDURE <name>(...) IS '...'"),
("ROUTINE", "COMMENT ON ROUTINE <name>(...) IS '...'"),
("INDEX", "COMMENT ON INDEX <name> IS '...'"),
("VIEW", "COMMENT ON VIEW <name> IS '...'"),
("MATERIALIZED VIEW", "COMMENT ON MATERIALIZED VIEW <name> IS '...'"),
("FOREIGN TABLE", "COMMENT ON FOREIGN TABLE <name> IS '...'"),
("FOREIGN DATA WRAPPER", "COMMENT ON FOREIGN DATA WRAPPER <name> IS '...'"),
("SERVER", "COMMENT ON SERVER <name> IS '...'"),
("SEQUENCE", "COMMENT ON SEQUENCE <name> IS '...'"),
("TYPE", "COMMENT ON TYPE <name> IS '...'"),
("DOMAIN", "COMMENT ON DOMAIN <name> IS '...'"),
("EXTENSION", "COMMENT ON EXTENSION <name> IS '...'"),
("ROLE", "COMMENT ON ROLE <name> IS '...'"),
("TRIGGER", "COMMENT ON TRIGGER <name> ON <table> IS '...'"),
("CONSTRAINT", "COMMENT ON CONSTRAINT <name> ON <table> IS '...'"),
("POLICY", "COMMENT ON POLICY <name> ON <table> IS '...'"),
("RULE", "COMMENT ON RULE <name> ON <table> IS '...'"),
("AGGREGATE", "COMMENT ON AGGREGATE <name>(args) IS '...'"),
("CAST", "COMMENT ON CAST (src AS dst) IS '...'"),
("COLLATION", "COMMENT ON COLLATION <name> IS '...'"),
("CONVERSION", "COMMENT ON CONVERSION <name> IS '...'"),
("OPERATOR", "COMMENT ON OPERATOR <op>(args) IS '...'"),
("OPERATOR CLASS", "COMMENT ON OPERATOR CLASS <name> USING <am> IS '...'"),
("OPERATOR FAMILY", "COMMENT ON OPERATOR FAMILY <name> USING <am> IS '...'"),
("STATISTICS", "COMMENT ON STATISTICS <name> IS '...'"),
("ACCESS METHOD", "COMMENT ON ACCESS METHOD <name> IS '...'"),
("LANGUAGE", "COMMENT ON LANGUAGE <name> IS '...'"),
("LARGE OBJECT", "COMMENT ON LARGE OBJECT <oid> IS '...'"),
("TABLESPACE", "COMMENT ON TABLESPACE <name> IS '...'"),
("PUBLICATION", "COMMENT ON PUBLICATION <name> IS '...'"),
("SUBSCRIPTION", "COMMENT ON SUBSCRIPTION <name> IS '...'"),
("EVENT TRIGGER", "COMMENT ON EVENT TRIGGER <name> IS '...'"),
("TEXT SEARCH CONFIGURATION", "COMMENT ON TEXT SEARCH CONFIGURATION <name> IS '...'"),
("TEXT SEARCH DICTIONARY", "COMMENT ON TEXT SEARCH DICTIONARY <name> IS '...'"),
("TEXT SEARCH PARSER", "COMMENT ON TEXT SEARCH PARSER <name> IS '...'"),
("TEXT SEARCH TEMPLATE", "COMMENT ON TEXT SEARCH TEMPLATE <name> IS '...'"),
("TRANSFORM", "COMMENT ON TRANSFORM FOR <type> LANGUAGE <lang> IS '...'"),
];
pub(crate) fn comment_on_is_value_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (_, upper) = stmt_slice_upper(source, offset);
if !upper.starts_with("COMMENT ON") {
return None;
}
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
let last = *words.last()?;
if last == "IS" {
return Some(&[("NULL", "IS NULL -- drop the comment"), ("''", "'' -- empty comment (equivalent to NULL)")]);
}
if words.contains(&"ON") && !words.contains(&"IS") && words.len() >= 4 {
return Some(&[("IS", "IS '<comment_text>' | IS NULL -- drop")]);
}
None
}
pub(crate) fn comment_on_expects_class_keyword(source: &str, offset: TextSize) -> bool {
let (slice, upper) = stmt_slice_upper(source, offset);
let stmt = slice.trim_start();
if !upper.starts_with("COMMENT ON") {
return false;
}
let after = &upper["COMMENT ON".len()..];
let after_trim = after.trim_start();
if after_trim.is_empty() && stmt.ends_with(char::is_whitespace) {
return true;
}
let words: Vec<&str> = after_trim.split_ascii_whitespace().collect();
if words.len() == 1 && !stmt.ends_with(char::is_whitespace) {
return true;
}
false
}
pub(crate) fn declare_cursor_for_expects_statement(source: &str, offset: TextSize) -> bool {
let (slice, upper) = stmt_slice_upper(source, offset);
let stmt = slice.trim_start();
if !upper.starts_with("DECLARE") {
return false;
}
let trimmed = upper.trim_end();
trimmed.ends_with("CURSOR FOR") && stmt.ends_with(char::is_whitespace)
}
pub(crate) fn with_cte_after_as_expects_materialized(source: &str, offset: TextSize) -> bool {
let (slice, upper) = stmt_slice_upper(source, offset);
let stmt = slice.trim_start();
if !upper.starts_with("WITH ") && !upper.starts_with("WITH\n") && !upper.starts_with("WITH\t") {
return false;
}
let trimmed = upper.trim_end();
trimmed.ends_with(" AS") && stmt.ends_with(char::is_whitespace)
}
pub(crate) fn do_expects_language_or_body(source: &str, offset: TextSize) -> bool {
let (slice, upper) = stmt_slice_upper(source, offset);
let stmt = slice.trim_start();
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
words.len() == 1 && words[0] == "DO" && stmt.ends_with(char::is_whitespace)
}
pub(crate) fn create_sequence_expects_option(source: &str, offset: TextSize) -> bool {
let (slice, upper) = stmt_slice_upper(source, offset);
let stmt = slice.trim_start();
if !upper.contains("SEQUENCE") || !upper.starts_with("CREATE") {
return false;
}
let after = if let Some(s) = upper.split_once("SEQUENCE").map(|x| x.1) { s } else { return false };
let words: Vec<&str> = after.split_ascii_whitespace().collect();
let mut i = 0;
if i + 3 <= words.len() && words[i] == "IF" && words[i + 1] == "NOT" && words[i + 2] == "EXISTS" {
i += 3;
}
if i + 1 == words.len() && stmt.ends_with(char::is_whitespace) {
return true;
}
false
}
pub(crate) fn create_type_enum_or_range_body(source: &str, offset: TextSize) -> bool {
let (_slice, upper) = stmt_slice_upper(source, offset);
if !upper.starts_with("CREATE TYPE") {
return false;
}
let Some(open_at) = upper.find(" AS ENUM (").map(|p| p + " AS ENUM (".len()) else {
return false;
};
let bytes = upper.as_bytes();
let mut depth: i32 = 1;
let mut i = open_at;
while i < bytes.len() {
match bytes[i] {
b'(' => depth += 1,
b')' => depth -= 1,
_ => {},
}
if depth == 0 {
return false;
}
i += 1;
}
depth > 0
}
pub(crate) fn create_type_as_expects_kind(source: &str, offset: TextSize) -> bool {
let (slice, upper) = stmt_slice_upper(source, offset);
let stmt = slice.trim_start();
if !upper.starts_with("CREATE TYPE") {
return false;
}
let after = &upper["CREATE TYPE".len()..];
let words: Vec<&str> = after.split_ascii_whitespace().collect();
if words.len() == 2 && words[1] == "AS" && stmt.ends_with(char::is_whitespace) {
return true;
}
if words.len() == 3 && words[1] == "AS" && !stmt.ends_with(char::is_whitespace) {
return true;
}
false
}
pub(crate) fn vacuum_paren_expects_option(source: &str, offset: TextSize) -> bool {
let (slice, upper) = stmt_slice_upper(source, offset);
let stmt = slice.trim_start();
if !upper.starts_with("VACUUM") {
return false;
}
let after = &stmt[upper.find("VACUUM").unwrap() + "VACUUM".len()..];
let mut depth = 0i32;
let mut saw_open = false;
for c in after.chars() {
match c {
'(' => {
depth += 1;
saw_open = true;
},
')' => depth -= 1,
_ => {},
}
}
if !saw_open || depth == 0 {
return false;
}
let trimmed = stmt.trim_end();
let last = trimmed.chars().last();
if matches!(last, Some('(') | Some(',')) {
return true;
}
if !stmt.ends_with(char::is_whitespace) {
let inner_start = after.rfind('(').unwrap_or(0);
let last_comma_or_open = after[inner_start..].rfind([',', '(']).unwrap_or(0);
let since = &after[inner_start + last_comma_or_open..];
if !since.contains('=') {
return true;
}
}
false
}
pub(crate) fn explain_paren_format_value(source: &str, offset: TextSize) -> bool {
explain_paren_value_after(source, offset, "FORMAT")
}
pub(crate) fn explain_paren_serialize_value(source: &str, offset: TextSize) -> bool {
explain_paren_value_after(source, offset, "SERIALIZE")
}
pub(crate) fn explain_paren_value_after(source: &str, offset: TextSize, kw: &str) -> bool {
let (slice, upper) = stmt_slice_upper(source, offset);
let stmt = slice.trim_start();
if !upper.starts_with("EXPLAIN") {
return false;
}
let after = &stmt[upper.find("EXPLAIN").unwrap() + "EXPLAIN".len()..];
let opens = after.matches('(').count();
let closes = after.matches(')').count();
if opens == 0 || opens <= closes {
return false;
}
let last_tok = stmt.split(|c: char| c.is_whitespace() || c == ',' || c == '(').rfind(|s| !s.is_empty()).unwrap_or("");
last_tok.eq_ignore_ascii_case(kw)
}
pub(crate) fn explain_paren_expects_option(source: &str, offset: TextSize) -> bool {
let (slice, upper) = stmt_slice_upper(source, offset);
let stmt = slice.trim_start();
if !upper.starts_with("EXPLAIN") {
return false;
}
let after = &stmt[upper.find("EXPLAIN").unwrap() + "EXPLAIN".len()..];
let mut depth = 0i32;
let mut saw_open = false;
for c in after.chars() {
match c {
'(' => {
depth += 1;
saw_open = true;
},
')' => depth -= 1,
_ => {},
}
}
if !saw_open || depth == 0 {
return false;
}
let trimmed = stmt.trim_end();
let last = trimmed.chars().last();
if matches!(last, Some('(') | Some(',')) {
return true;
}
if !stmt.ends_with(char::is_whitespace) {
let inner_start = after.rfind('(').unwrap_or(0);
let last_comma_or_open = after[inner_start..].rfind([',', '(']).unwrap_or(0);
let since = &after[inner_start + last_comma_or_open..];
if !since.contains('=') {
return true;
}
}
false
}
pub(crate) fn explain_expects_statement(source: &str, offset: TextSize) -> bool {
let (slice, upper) = stmt_slice_upper(source, offset);
let stmt = slice.trim_start();
if !upper.starts_with("EXPLAIN") {
return false;
}
let bytes = stmt.as_bytes();
let mut i = upper.find("EXPLAIN").unwrap_or(0) + "EXPLAIN".len();
let skip_ws = |b: &[u8], mut p: usize| {
while p < b.len() && b[p].is_ascii_whitespace() {
p += 1;
}
p
};
i = skip_ws(bytes, i);
if i < bytes.len() && bytes[i] == b'(' {
let mut depth = 1i32;
i += 1;
while i < bytes.len() && depth > 0 {
match bytes[i] {
b'(' => depth += 1,
b')' => depth -= 1,
_ => {},
}
if depth == 0 {
break;
}
i += 1;
}
if i >= bytes.len() {
return false; }
i += 1;
i = skip_ws(bytes, i);
}
loop {
let rest_upper = stmt[i..].trim_start().to_ascii_uppercase();
if let Some(stripped) = rest_upper.strip_prefix("ANALYZE") {
let consumed = "ANALYZE".len();
let lead = stmt[i..].len() - stmt[i..].trim_start().len();
let next = i + lead + consumed;
if next == bytes.len() || !bytes[next].is_ascii_alphanumeric() && bytes[next] != b'_' {
i = next;
i = skip_ws(bytes, i);
let _ = stripped;
continue;
}
}
if let Some(stripped) = rest_upper.strip_prefix("VERBOSE") {
let consumed = "VERBOSE".len();
let lead = stmt[i..].len() - stmt[i..].trim_start().len();
let next = i + lead + consumed;
if next == bytes.len() || !bytes[next].is_ascii_alphanumeric() && bytes[next] != b'_' {
i = next;
i = skip_ws(bytes, i);
let _ = stripped;
continue;
}
}
break;
}
i == bytes.len()
}
pub(crate) fn create_function_expects_return_type(source: &str, offset: TextSize) -> bool {
let (slice, upper) = stmt_slice_upper(source, offset);
let stmt = slice.as_str();
let has_create_fn = upper.contains("CREATE FUNCTION")
|| upper.contains("CREATE OR REPLACE FUNCTION")
|| upper.contains("CREATE PROCEDURE")
|| upper.contains("CREATE OR REPLACE PROCEDURE");
if !has_create_fn {
return false;
}
let Some(rets_at) = upper.rfind("RETURNS") else {
return false;
};
let bytes = stmt.as_bytes();
if rets_at > 0 && (bytes[rets_at - 1].is_ascii_alphanumeric() || bytes[rets_at - 1] == b'_') {
return false;
}
let after = &stmt[rets_at + "RETURNS".len()..];
let after_trim = after.trim_start();
if after_trim.is_empty() {
return true;
}
let after_setof = after_trim.strip_prefix("SETOF").or_else(|| after_trim.strip_prefix("setof"));
let rest = after_setof.unwrap_or(after_trim);
let words: Vec<&str> = rest.split_ascii_whitespace().collect();
match words.len() {
0 => true,
1 => !rest.ends_with(char::is_whitespace),
_ => false,
}
}
pub(crate) fn at_create_view_body_start(source: &str, offset: TextSize) -> bool {
let (slice, _) = stmt_slice_upper(source, offset);
let upper = slice.trim().to_ascii_uppercase();
if !upper.contains("VIEW") || !upper.ends_with("AS") {
return false;
}
upper.as_bytes().starts_with(b"CREATE")
}
pub(crate) fn drop_target_trailing_slot(source: &str, offset: TextSize) -> bool {
let (slice, _) = stmt_slice_upper(source, offset);
if !slice.ends_with(char::is_whitespace) {
return false;
}
let upper = slice.trim().to_ascii_uppercase();
if !upper.starts_with("DROP") {
return false;
}
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if words.len() < 3 {
return false; }
if words[0] != "DROP" {
return false;
}
let two_word_classes = [("MATERIALIZED", "VIEW"), ("FOREIGN", "TABLE")];
let one_word_classes: &[&str] = &[
"TABLE",
"VIEW",
"INDEX",
"SEQUENCE",
"SCHEMA",
"FUNCTION",
"PROCEDURE",
"TRIGGER",
"TYPE",
"ROLE",
"USER",
"DATABASE",
"EXTENSION",
"POLICY",
"DOMAIN",
"AGGREGATE",
"CAST",
"COLLATION",
"OPERATOR",
"RULE",
"TABLESPACE",
"SUBSCRIPTION",
"PUBLICATION",
"SERVER",
];
let mut idx = 1usize;
if idx + 1 < words.len() && two_word_classes.iter().any(|(a, b)| words[idx] == *a && words[idx + 1] == *b) {
idx += 2;
} else if one_word_classes.contains(&words[idx]) {
idx += 1;
} else {
return false;
}
if idx + 1 < words.len() && words[idx] == "IF" && words[idx + 1] == "EXISTS" {
idx += 2;
}
if idx >= words.len() {
return false;
}
let last = words[words.len() - 1];
if last == "CASCADE" || last == "RESTRICT" || last.ends_with(',') {
return false;
}
let trim_end = slice.trim_end();
if trim_end.ends_with(',') {
return false;
}
true
}
pub(crate) const DEFAULT_EXPRESSION_SUGGESTIONS: &[(&str, &str)] = &[
("NULL", "NULL default (column is nullable)"),
("CURRENT_TIMESTAMP", "transaction-start timestamp (timestamptz)"),
("CURRENT_DATE", "transaction-start date"),
("now()", "transaction-start timestamptz -- same as CURRENT_TIMESTAMP"),
("gen_random_uuid()", "random UUID v4 (requires pgcrypto; built-in since PG 13)"),
("FALSE", "literal false"),
("TRUE", "literal true"),
("0", "literal integer zero"),
("''", "empty string"),
];
pub(crate) fn ctl_column_constraint_after_default(source: &str, offset: TextSize) -> bool {
let pos: usize = (u32::from(offset) as usize).min(source.len());
let bytes = source.as_bytes();
if pos == 0 {
return false;
}
let mut end = pos;
while end > 0 && bytes[end - 1].is_ascii_whitespace() {
end -= 1;
}
if end == pos {
return false;
}
let mut start = end;
while start > 0 {
let b = bytes[start - 1];
if b.is_ascii_alphanumeric() || b == b'_' {
start -= 1;
} else {
break;
}
}
if start == end {
return false;
}
let word = source[start..end].to_ascii_uppercase();
word == "DEFAULT"
}
pub(crate) fn insert_after_values_tuple(source: &str, offset: TextSize) -> bool {
let (slice_owned, upper) = stmt_slice_upper(source, offset);
let slice = slice_owned.as_str();
if !upper.contains("VALUES") || !upper.trim_start().starts_with("INSERT") {
return false;
}
if upper.contains("RETURNING") || upper.contains("ON CONFLICT") {
return false;
}
let trimmed = slice.trim_end();
if !trimmed.ends_with(')') {
return false;
}
let bytes = slice.as_bytes();
let mut depth: i32 = 0;
let mut i = 0;
while i < bytes.len() {
let c = bytes[i];
if c == b'\'' {
i += 1;
while i < bytes.len() && bytes[i] != b'\'' {
i += 1;
}
i = (i + 1).min(bytes.len());
continue;
}
if c == b'(' {
depth += 1;
} else if c == b')' {
depth -= 1;
}
i += 1;
}
depth == 0
}
pub(crate) fn alter_table_add_column_after_default(source: &str, offset: TextSize) -> bool {
let (slice_owned, upper) = stmt_slice_upper(source, offset);
let slice = slice_owned.as_str();
if !upper.contains("ALTER TABLE") || !upper.contains("ADD COLUMN") {
return false;
}
let trimmed = slice.trim_end();
if trimmed.len() == slice.len() {
return false; }
let upper_trim = trimmed.to_ascii_uppercase();
if !upper_trim.ends_with("DEFAULT") {
return false;
}
let end = trimmed.len();
if end == 7 {
return true;
}
let prev = trimmed.as_bytes()[end - 8];
!(prev.is_ascii_alphanumeric() || prev == b'_')
}
pub(crate) fn after_top_level_create_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
let pos: usize = (u32::from(offset) as usize).min(source.len());
let bytes = source.as_bytes();
let (slice_owned, _) = stmt_slice_upper(source, offset);
let slice = slice_owned.trim();
let upper = slice.to_ascii_uppercase();
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if words.is_empty() || words[0] != "CREATE" {
return None;
}
let modifiers = ["OR", "REPLACE", "TEMP", "TEMPORARY", "UNLOGGED", "GLOBAL", "LOCAL", "UNIQUE", "MATERIALIZED"];
for w in &words[1..] {
if !modifiers.contains(w) {
return None;
}
}
if pos < bytes.len() && !bytes[pos].is_ascii_whitespace() {
return None;
}
let has_or = words.contains(&"OR");
let has_replace = words.contains(&"REPLACE");
let has_or_replace = has_or && has_replace;
let has_temp = words.contains(&"TEMP") || words.contains(&"TEMPORARY");
let has_unlogged = words.contains(&"UNLOGGED");
let has_unique = words.contains(&"UNIQUE");
let has_materialized = words.contains(&"MATERIALIZED");
if has_or && !has_replace {
return Some(&[("REPLACE", "CREATE OR REPLACE -- replace existing function/view/trigger/etc")]);
}
let suggest_modifiers = !has_or_replace && !has_temp && !has_unlogged && !has_unique && !has_materialized;
if !suggest_modifiers {
return Some(after_create_object_kinds_only());
}
Some(&[
("OR REPLACE", "CREATE OR REPLACE -- replace existing function/view/trigger/etc"),
("TEMP", "CREATE TEMP TABLE/VIEW/SEQUENCE -- session-scoped"),
("TEMPORARY", "CREATE TEMPORARY TABLE/VIEW/SEQUENCE -- session-scoped"),
("UNLOGGED", "CREATE UNLOGGED TABLE -- skipped from WAL"),
("GLOBAL", "CREATE GLOBAL TEMPORARY -- SQL standard alias"),
("LOCAL", "CREATE LOCAL TEMPORARY -- SQL standard alias"),
("UNIQUE", "CREATE UNIQUE INDEX -- enforce uniqueness"),
("MATERIALIZED", "CREATE MATERIALIZED VIEW <name> AS SELECT ..."),
("TABLE", "CREATE TABLE [IF NOT EXISTS] <name> (...)"),
("VIEW", "CREATE VIEW <name> AS SELECT ..."),
("MATERIALIZED VIEW", "CREATE MATERIALIZED VIEW <name> AS ..."),
("INDEX", "CREATE [UNIQUE] INDEX [CONCURRENTLY] [IF NOT EXISTS] <name> ON <table>(<cols>)"),
("UNIQUE INDEX", "CREATE UNIQUE INDEX ..."),
("SEQUENCE", "CREATE SEQUENCE [IF NOT EXISTS] <name>"),
("SCHEMA", "CREATE SCHEMA [IF NOT EXISTS] <name>"),
("FUNCTION", "CREATE [OR REPLACE] FUNCTION <name>(args) RETURNS ... AS $$ ... $$ LANGUAGE ..."),
("PROCEDURE", "CREATE [OR REPLACE] PROCEDURE <name>(args) ..."),
("TRIGGER", "CREATE [OR REPLACE] TRIGGER <name> {BEFORE|AFTER} <event> ON <table>"),
("TYPE", "CREATE TYPE <name> AS (...) | AS ENUM (...) | AS RANGE (...)"),
("ROLE", "CREATE ROLE <name> [WITH ...]"),
("USER", "CREATE USER <name> [WITH PASSWORD '...']"),
("DATABASE", "CREATE DATABASE <name> [OWNER <role>]"),
("EXTENSION", "CREATE EXTENSION [IF NOT EXISTS] <name>"),
("POLICY", "CREATE POLICY <name> ON <table> FOR ... TO ... USING (...)"),
("DOMAIN", "CREATE DOMAIN <name> AS <type> [CHECK (...)]"),
("AGGREGATE", "CREATE AGGREGATE <name>(arg_types) (SFUNC=..., STYPE=...)"),
("CAST", "CREATE CAST (src AS dst) WITH FUNCTION <fn> | WITHOUT FUNCTION"),
("COLLATION", "CREATE COLLATION <name> (...)"),
("OPERATOR", "CREATE OPERATOR <op> (...)"),
("RULE", "CREATE RULE <name> AS ON <event> TO <table> DO ..."),
("TABLESPACE", "CREATE TABLESPACE <name> LOCATION '<path>'"),
("SUBSCRIPTION", "CREATE SUBSCRIPTION <name> CONNECTION '<conn>' PUBLICATION <pub>"),
("PUBLICATION", "CREATE PUBLICATION <name> FOR TABLE ..."),
("FOREIGN TABLE", "CREATE FOREIGN TABLE <name> (...) SERVER <srv>"),
("SERVER", "CREATE SERVER <name> FOREIGN DATA WRAPPER <fdw>"),
("EVENT TRIGGER", "CREATE EVENT TRIGGER <name> ON <event> EXECUTE FUNCTION <fn>()"),
("TEXT SEARCH CONFIGURATION", "CREATE TEXT SEARCH CONFIGURATION <name> (PARSER=...)"),
("TEXT SEARCH DICTIONARY", "CREATE TEXT SEARCH DICTIONARY <name> (TEMPLATE=...)"),
("FOREIGN DATA WRAPPER", "CREATE FOREIGN DATA WRAPPER <name>"),
("CONVERSION", "CREATE [DEFAULT] CONVERSION <name> FOR '<src>' TO '<dst>' FROM <fn>"),
("TRANSFORM", "CREATE TRANSFORM FOR <type> LANGUAGE <lang> (...)"),
("USER MAPPING", "CREATE USER MAPPING FOR <role> SERVER <srv> OPTIONS (...)"),
("OPERATOR CLASS", "CREATE OPERATOR CLASS <name> FOR TYPE <type> USING <am> AS ..."),
("OPERATOR FAMILY", "CREATE OPERATOR FAMILY <name> USING <am>"),
("ACCESS METHOD", "CREATE ACCESS METHOD <name> TYPE {INDEX|TABLE} HANDLER <fn>"),
("STATISTICS", "CREATE STATISTICS [IF NOT EXISTS] <name> [(<kinds>)] ON <cols> FROM <tbl>"),
("LANGUAGE", "CREATE [OR REPLACE] [TRUSTED] [PROCEDURAL] LANGUAGE <name> HANDLER <fn>"),
("GROUP", "CREATE GROUP <name> [WITH <attr>...] -- SQL-standard alias for ROLE"),
("ROUTINE", "CREATE [OR REPLACE] ROUTINE <name>(args) ..."),
("TEXT SEARCH PARSER", "CREATE TEXT SEARCH PARSER <name> (START=..., GETTOKEN=..., END=..., LEXTYPES=...)"),
("TEXT SEARCH TEMPLATE", "CREATE TEXT SEARCH TEMPLATE <name> (INIT=..., LEXIZE=...)"),
])
}
pub(crate) fn after_create_object_kinds_only() -> &'static [(&'static str, &'static str)] {
&[
("TABLE", "CREATE TABLE [IF NOT EXISTS] <name> (...)"),
("VIEW", "CREATE VIEW <name> AS SELECT ..."),
("MATERIALIZED VIEW", "CREATE MATERIALIZED VIEW <name> AS ..."),
("INDEX", "CREATE [UNIQUE] INDEX [CONCURRENTLY] [IF NOT EXISTS] <name> ON <table>(<cols>)"),
("UNIQUE INDEX", "CREATE UNIQUE INDEX ..."),
("SEQUENCE", "CREATE SEQUENCE [IF NOT EXISTS] <name>"),
("SCHEMA", "CREATE SCHEMA [IF NOT EXISTS] <name>"),
("FUNCTION", "CREATE [OR REPLACE] FUNCTION <name>(args) RETURNS ... AS $$ ... $$ LANGUAGE ..."),
("PROCEDURE", "CREATE [OR REPLACE] PROCEDURE <name>(args) ..."),
("TRIGGER", "CREATE [OR REPLACE] TRIGGER <name> {BEFORE|AFTER} <event> ON <table>"),
("TYPE", "CREATE TYPE <name> AS (...) | AS ENUM (...) | AS RANGE (...)"),
("ROLE", "CREATE ROLE <name> [WITH ...]"),
("USER", "CREATE USER <name> [WITH PASSWORD '...']"),
("DATABASE", "CREATE DATABASE <name> [OWNER <role>]"),
("EXTENSION", "CREATE EXTENSION [IF NOT EXISTS] <name>"),
("POLICY", "CREATE POLICY <name> ON <table> FOR ... TO ... USING (...)"),
("DOMAIN", "CREATE DOMAIN <name> AS <type> [CHECK (...)]"),
("AGGREGATE", "CREATE AGGREGATE <name>(arg_types) (SFUNC=..., STYPE=...)"),
("CAST", "CREATE CAST (src AS dst) WITH FUNCTION <fn> | WITHOUT FUNCTION"),
("COLLATION", "CREATE COLLATION <name> (...)"),
("OPERATOR", "CREATE OPERATOR <op> (...)"),
("RULE", "CREATE RULE <name> AS ON <event> TO <table> DO ..."),
("TABLESPACE", "CREATE TABLESPACE <name> LOCATION '<path>'"),
("SUBSCRIPTION", "CREATE SUBSCRIPTION <name> CONNECTION '<conn>' PUBLICATION <pub>"),
("PUBLICATION", "CREATE PUBLICATION <name> FOR TABLE ..."),
("FOREIGN TABLE", "CREATE FOREIGN TABLE <name> (...) SERVER <srv>"),
("SERVER", "CREATE SERVER <name> FOREIGN DATA WRAPPER <fdw>"),
("EVENT TRIGGER", "CREATE EVENT TRIGGER <name> ON <event> EXECUTE FUNCTION <fn>()"),
("TEXT SEARCH CONFIGURATION", "CREATE TEXT SEARCH CONFIGURATION <name> (PARSER=...)"),
("TEXT SEARCH DICTIONARY", "CREATE TEXT SEARCH DICTIONARY <name> (TEMPLATE=...)"),
("FOREIGN DATA WRAPPER", "CREATE FOREIGN DATA WRAPPER <name>"),
("CONVERSION", "CREATE [DEFAULT] CONVERSION <name> FOR '<src>' TO '<dst>' FROM <fn>"),
("TRANSFORM", "CREATE TRANSFORM FOR <type> LANGUAGE <lang> (...)"),
("USER MAPPING", "CREATE USER MAPPING FOR <role> SERVER <srv> OPTIONS (...)"),
("OPERATOR CLASS", "CREATE OPERATOR CLASS <name> FOR TYPE <type> USING <am> AS ..."),
("OPERATOR FAMILY", "CREATE OPERATOR FAMILY <name> USING <am>"),
("ACCESS METHOD", "CREATE ACCESS METHOD <name> TYPE {INDEX|TABLE} HANDLER <fn>"),
("STATISTICS", "CREATE STATISTICS [IF NOT EXISTS] <name> [(<kinds>)] ON <cols> FROM <tbl>"),
("LANGUAGE", "CREATE [OR REPLACE] [TRUSTED] [PROCEDURAL] LANGUAGE <name> HANDLER <fn>"),
("GROUP", "CREATE GROUP <name> [WITH <attr>...] -- SQL-standard alias for ROLE"),
("ROUTINE", "CREATE [OR REPLACE] ROUTINE <name>(args) ..."),
("TEXT SEARCH PARSER", "CREATE TEXT SEARCH PARSER <name> (START=..., GETTOKEN=..., END=..., LEXTYPES=...)"),
("TEXT SEARCH TEMPLATE", "CREATE TEXT SEARCH TEMPLATE <name> (INIT=..., LEXIZE=...)"),
]
}
pub(crate) fn create_class_expects_if_not_exists(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (slice_owned, _) = stmt_slice_upper(source, offset);
let slice = slice_owned.trim();
let upper = slice.to_ascii_uppercase();
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if words.is_empty() || words[0] != "CREATE" {
return None;
}
let classes = [
"TABLE",
"VIEW",
"INDEX",
"SEQUENCE",
"SCHEMA",
"FUNCTION",
"PROCEDURE",
"TRIGGER",
"TYPE",
"ROLE",
"USER",
"DATABASE",
"EXTENSION",
"POLICY",
"DOMAIN",
"AGGREGATE",
"COLLATION",
"RULE",
"TABLESPACE",
"SUBSCRIPTION",
"PUBLICATION",
"SERVER",
];
if !classes.contains(words.last().unwrap_or(&"")) {
return None;
}
Some(&[("IF NOT EXISTS", "CREATE ... IF NOT EXISTS <name> -- skip silently if it already exists")])
}
pub(crate) fn after_top_level_alter_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
let pos: usize = (u32::from(offset) as usize).min(source.len());
let bytes = source.as_bytes();
let (slice_owned, _) = stmt_slice_upper(source, offset);
let slice = slice_owned.trim();
let upper = slice.to_ascii_uppercase();
if upper != "ALTER" {
return None;
}
if pos < bytes.len() && !bytes[pos].is_ascii_whitespace() {
return None;
}
Some(&[
("TABLE", "ALTER TABLE [IF EXISTS] [ONLY] <name> ..."),
("VIEW", "ALTER VIEW [IF EXISTS] <name> ..."),
("MATERIALIZED VIEW", "ALTER MATERIALIZED VIEW [IF EXISTS] <name> ..."),
("INDEX", "ALTER INDEX [IF EXISTS] <name> ..."),
("SEQUENCE", "ALTER SEQUENCE [IF EXISTS] <name> ..."),
("SCHEMA", "ALTER SCHEMA <name> RENAME TO ..."),
("FUNCTION", "ALTER FUNCTION <name>(args) ..."),
("PROCEDURE", "ALTER PROCEDURE <name>(args) ..."),
("ROUTINE", "ALTER ROUTINE <name>(args) ..."),
("TRIGGER", "ALTER TRIGGER <name> ON <table> ..."),
("TYPE", "ALTER TYPE <name> ADD VALUE ... | RENAME ..."),
("DOMAIN", "ALTER DOMAIN <name> SET DEFAULT ... | DROP DEFAULT ..."),
("ROLE", "ALTER ROLE <name> WITH ..."),
("USER", "ALTER USER <name> WITH ..."),
("GROUP", "ALTER GROUP <name> ..."),
("DATABASE", "ALTER DATABASE <name> ..."),
("EXTENSION", "ALTER EXTENSION <name> UPDATE [TO ...]"),
("POLICY", "ALTER POLICY <name> ON <table> ..."),
("AGGREGATE", "ALTER AGGREGATE <name>(args) ..."),
("CAST", "ALTER CAST (src AS dst) ..."),
("COLLATION", "ALTER COLLATION <name> ..."),
("OPERATOR", "ALTER OPERATOR <op>(args) ..."),
("OPERATOR CLASS", "ALTER OPERATOR CLASS <name> USING <am> ..."),
("OPERATOR FAMILY", "ALTER OPERATOR FAMILY <name> USING <am> ..."),
("RULE", "ALTER RULE <name> ON <table> RENAME TO ..."),
("TABLESPACE", "ALTER TABLESPACE <name> ..."),
("SUBSCRIPTION", "ALTER SUBSCRIPTION <name> ..."),
("PUBLICATION", "ALTER PUBLICATION <name> ..."),
("FOREIGN TABLE", "ALTER FOREIGN TABLE <name> ..."),
("FOREIGN DATA WRAPPER", "ALTER FOREIGN DATA WRAPPER <name> ..."),
("SERVER", "ALTER SERVER <name> ..."),
("LANGUAGE", "ALTER LANGUAGE <name> RENAME TO ..."),
("CONVERSION", "ALTER CONVERSION <name> RENAME TO ..."),
("EVENT TRIGGER", "ALTER EVENT TRIGGER <name> ..."),
("STATISTICS", "ALTER STATISTICS <name> ..."),
("TEXT SEARCH CONFIGURATION", "ALTER TEXT SEARCH CONFIGURATION <name> ..."),
("TEXT SEARCH DICTIONARY", "ALTER TEXT SEARCH DICTIONARY <name> ..."),
("TEXT SEARCH PARSER", "ALTER TEXT SEARCH PARSER <name> ..."),
("TEXT SEARCH TEMPLATE", "ALTER TEXT SEARCH TEMPLATE <name> ..."),
("SYSTEM", "ALTER SYSTEM SET <param> = ..."),
("DEFAULT PRIVILEGES", "ALTER DEFAULT PRIVILEGES [FOR ROLE <r>] [IN SCHEMA <s>] {GRANT|REVOKE} ..."),
("LARGE OBJECT", "ALTER LARGE OBJECT <oid> OWNER TO <role>"),
("USER MAPPING", "ALTER USER MAPPING FOR <role> SERVER <srv> OPTIONS (...)"),
])
}
pub(crate) fn show_or_set_guc_names(source: &str, offset: TextSize) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (slice_owned, _) = stmt_slice_upper(source, offset);
let slice = slice_owned.trim();
let upper = slice.to_ascii_uppercase();
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if words.is_empty() {
return None;
}
let want_guc = (words.len() == 1 && matches!(words[0], "SHOW" | "RESET"))
|| (words.len() == 2 && words[0] == "RESET" && words[1] != "ALL")
|| (words.len() == 2 && words[0] == "SET" && matches!(words[1], "LOCAL" | "SESSION"))
|| (words.len() == 2 && words[0] == "SET" && !matches!(words[1], "LOCAL" | "SESSION" | "TRANSACTION" | "ROLE" | "CONSTRAINTS" | "SESSION_AUTHORIZATION" | "TIME"))
|| (words.len() == 3 && words[0] == "SET" && matches!(words[1], "LOCAL" | "SESSION"))
|| (words.len() >= 4
&& words[0] == "ALTER"
&& matches!(words[1], "ROLE" | "USER" | "DATABASE")
&& words.last() == Some(&"SET"));
if !want_guc {
return None;
}
Some(&[
("ALL", "RESET ALL / SHOW ALL -- every GUC at once"),
("search_path", "search_path = 'public, schema2' -- schema resolution order"),
("timezone", "timezone = 'UTC'"),
("statement_timeout", "statement_timeout = '5s' -- abort long statements"),
("lock_timeout", "lock_timeout = '5s'"),
("idle_in_transaction_session_timeout", "idle_in_transaction_session_timeout = '60s'"),
("work_mem", "work_mem = '64MB' -- per-sort/hash memory"),
("maintenance_work_mem", "maintenance_work_mem = '256MB'"),
("shared_buffers", "shared_buffers = '2GB' (postgresql.conf only)"),
("effective_cache_size", "effective_cache_size = '8GB' -- planner hint"),
("default_transaction_isolation", "default_transaction_isolation = 'repeatable read'"),
("default_transaction_read_only", "default_transaction_read_only = on"),
("default_transaction_deferrable", "default_transaction_deferrable = on"),
("application_name", "application_name = 'myapp'"),
("log_statement", "log_statement = 'all' | 'mod' | 'ddl' | 'none'"),
("log_min_duration_statement", "log_min_duration_statement = '1s'"),
("client_encoding", "client_encoding = 'UTF8'"),
("DateStyle", "DateStyle = 'ISO, YMD'"),
("IntervalStyle", "IntervalStyle = 'iso_8601'"),
("synchronous_commit", "synchronous_commit = on | off | local | remote_write | remote_apply"),
("enable_seqscan", "enable_seqscan = off"),
("enable_hashjoin", "enable_hashjoin = off"),
("enable_mergejoin", "enable_mergejoin = off"),
("enable_nestloop", "enable_nestloop = off"),
("random_page_cost", "random_page_cost = 1.1 -- SSD-friendly"),
("seq_page_cost", "seq_page_cost = 1.0"),
("cpu_tuple_cost", "cpu_tuple_cost = 0.01"),
("jit", "jit = off"),
("max_parallel_workers_per_gather", "max_parallel_workers_per_gather = 4"),
("row_security", "row_security = on | off"),
("transaction_isolation", "transaction_isolation = 'serializable' | 'repeatable read' | 'read committed' (per-tx)"),
("transaction_read_only", "transaction_read_only = on | off (per-tx)"),
("transaction_deferrable", "transaction_deferrable = on (only with SERIALIZABLE + READ ONLY)"),
("vacuum_buffer_usage_limit", "vacuum_buffer_usage_limit = '<size>' (PG16+)"),
("temp_buffers", "temp_buffers = '8MB'"),
("temp_file_limit", "temp_file_limit = '-1' -- per-session temp disk cap"),
("max_parallel_maintenance_workers", "max_parallel_maintenance_workers = <n>"),
("max_parallel_workers", "max_parallel_workers = <n>"),
("min_parallel_index_scan_size", "min_parallel_index_scan_size = '512kB'"),
("min_parallel_table_scan_size", "min_parallel_table_scan_size = '8MB'"),
("parallel_setup_cost", "parallel_setup_cost = 1000"),
("parallel_tuple_cost", "parallel_tuple_cost = 0.1"),
("plan_cache_mode", "plan_cache_mode = 'auto' | 'force_custom_plan' | 'force_generic_plan'"),
("commit_delay", "commit_delay = <us>"),
("commit_siblings", "commit_siblings = <n>"),
("force_parallel_mode", "force_parallel_mode = off | on | regress (debug)"),
("session_replication_role", "session_replication_role = 'origin' | 'replica' | 'local'"),
("array_nulls", "array_nulls = on | off"),
("backslash_quote", "backslash_quote = 'safe_encoding' | 'on' | 'off'"),
("escape_string_warning", "escape_string_warning = on | off"),
("standard_conforming_strings", "standard_conforming_strings = on"),
("log_lock_waits", "log_lock_waits = on -- log waits longer than deadlock_timeout"),
("log_temp_files", "log_temp_files = '0' -- log every temp file (any size when 0)"),
("log_checkpoints", "log_checkpoints = on"),
("log_connections", "log_connections = on"),
("log_disconnections", "log_disconnections = on"),
("log_autovacuum_min_duration", "log_autovacuum_min_duration = '5s'"),
("log_replication_commands", "log_replication_commands = on"),
("debug_print_parse", "debug_print_parse = on (debug)"),
("debug_print_plan", "debug_print_plan = on (debug)"),
("debug_print_rewritten", "debug_print_rewritten = on (debug)"),
("tcp_keepalives_idle", "tcp_keepalives_idle = 60"),
("tcp_keepalives_interval", "tcp_keepalives_interval = 10"),
("tcp_keepalives_count", "tcp_keepalives_count = 3"),
("tcp_user_timeout", "tcp_user_timeout = 30000"),
("client_min_messages", "client_min_messages = notice | warning | error | log | debug1..5"),
("log_min_messages", "log_min_messages = warning | error | log | debug1..5"),
("log_min_error_statement", "log_min_error_statement = error"),
("log_error_verbosity", "log_error_verbosity = default | terse | verbose"),
("log_line_prefix", "log_line_prefix = '%m [%p] %u@%d '"),
("scram_iterations", "scram_iterations = 4096 (PG16+)"),
("password_encryption", "password_encryption = scram-sha-256"),
("ssl", "ssl = on"),
("hot_standby_feedback", "hot_standby_feedback = on"),
("max_standby_streaming_delay", "max_standby_streaming_delay = '30s'"),
("max_locks_per_transaction", "max_locks_per_transaction = 64 (postgresql.conf only)"),
("max_pred_locks_per_transaction", "max_pred_locks_per_transaction = 64"),
("max_connections", "max_connections = 100 (postgresql.conf only)"),
("max_prepared_transactions", "max_prepared_transactions = 0 (2PC; postgresql.conf only)"),
("max_replication_slots", "max_replication_slots = 10 (postgresql.conf only)"),
("max_wal_senders", "max_wal_senders = 10"),
("wal_compression", "wal_compression = on | off | pglz | lz4 | zstd"),
("wal_level", "wal_level = replica | logical (postgresql.conf only)"),
("archive_mode", "archive_mode = on | off | always"),
("checkpoint_timeout", "checkpoint_timeout = '5min'"),
("checkpoint_completion_target", "checkpoint_completion_target = 0.9"),
("default_toast_compression", "default_toast_compression = pglz | lz4"),
("default_table_access_method", "default_table_access_method = heap"),
("recovery_init_sync_method", "recovery_init_sync_method = fsync | syncfs (PG14+)"),
("restart_after_crash", "restart_after_crash = on"),
("xmlbinary", "xmlbinary = base64 | hex"),
("xmloption", "xmloption = content | document"),
])
}
pub(crate) fn security_label_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (_, upper) = stmt_slice_upper(source, offset);
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if words.len() < 2 || words[0] != "SECURITY" || words[1] != "LABEL" {
return None;
}
let last = *words.last()?;
if last == "LABEL" {
return Some(&[("FOR", "FOR <provider>"), ("ON", "ON <object_kind> <name>")]);
}
if last == "FOR" {
return None; }
if last == "ON" {
return Some(&[
("TABLE", "ON TABLE <name>"),
("COLUMN", "ON COLUMN <tbl>.<col>"),
("VIEW", "ON VIEW <name>"),
("MATERIALIZED VIEW", "ON MATERIALIZED VIEW <name>"),
("INDEX", "ON INDEX <name>"),
("SEQUENCE", "ON SEQUENCE <name>"),
("FUNCTION", "ON FUNCTION <name>(args)"),
("PROCEDURE", "ON PROCEDURE <name>(args)"),
("ROUTINE", "ON ROUTINE <name>(args)"),
("TYPE", "ON TYPE <name>"),
("DOMAIN", "ON DOMAIN <name>"),
("SCHEMA", "ON SCHEMA <name>"),
("ROLE", "ON ROLE <name>"),
("DATABASE", "ON DATABASE <name>"),
("TABLESPACE", "ON TABLESPACE <name>"),
("AGGREGATE", "ON AGGREGATE <name>(args)"),
("COLLATION", "ON COLLATION <name>"),
("EVENT TRIGGER", "ON EVENT TRIGGER <name>"),
("FOREIGN TABLE", "ON FOREIGN TABLE <name>"),
("LARGE OBJECT", "ON LARGE OBJECT <oid>"),
("LANGUAGE", "ON LANGUAGE <name>"),
("PUBLICATION", "ON PUBLICATION <name>"),
("SUBSCRIPTION", "ON SUBSCRIPTION <name>"),
]);
}
if words.contains(&"ON") && !words.contains(&"IS") && words.len() >= 5 {
return Some(&[("IS", "IS '<label_text>' | IS NULL -- clear label")]);
}
if last == "IS" {
return Some(&[
("NULL", "IS NULL -- clear the security label"),
("'unclassified'", "'unclassified'"),
("'confidential'", "'confidential'"),
("'secret'", "'secret'"),
("'top_secret'", "'top_secret'"),
]);
}
None
}
pub(crate) fn alter_table_attach_detach_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (_, upper) = stmt_slice_upper(source, offset);
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if words.first() != Some(&"ALTER") || words.get(1) != Some(&"TABLE") {
return None;
}
let last = *words.last()?;
if last == "ATTACH" || last == "DETACH" {
return Some(&[("PARTITION", "PARTITION <child>")]);
}
if words.contains(&"ATTACH")
&& words.contains(&"PARTITION")
&& words.len() >= 6
&& last != "PARTITION"
&& last != "FOR"
&& last != "VALUES"
&& !words.contains(&"VALUES")
{
return Some(&[
("FOR", "FOR VALUES { IN (...) | FROM (...) TO (...) | WITH (...) }"),
("DEFAULT", "DEFAULT -- catch-all partition"),
]);
}
if words.contains(&"DETACH")
&& words.contains(&"PARTITION")
&& words.len() >= 6
&& !words.contains(&"CONCURRENTLY")
&& !words.contains(&"FINALIZE")
{
return Some(&[
("CONCURRENTLY", "CONCURRENTLY -- detach without long lock"),
("FINALIZE", "FINALIZE -- complete a concurrent detach"),
]);
}
if last == "INHERIT" {
return None; }
if last == "NO" && words.contains(&"ALTER") {
return Some(&[("INHERIT", "NO INHERIT <parent> -- remove inheritance link")]);
}
if words.len() == 3 {
return Some(&[
("ATTACH PARTITION", "ATTACH PARTITION <child> FOR VALUES ..."),
("DETACH PARTITION", "DETACH PARTITION <child> [CONCURRENTLY|FINALIZE]"),
("INHERIT", "INHERIT <parent> -- add inheritance link"),
("NO INHERIT", "NO INHERIT <parent> -- remove inheritance link"),
]);
}
None
}
pub(crate) fn partition_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (_, upper) = stmt_slice_upper(source, offset);
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
let last = *words.last()?;
if last == "PARTITION" {
return Some(&[("OF", "PARTITION OF <parent> FOR VALUES ..."), ("BY", "PARTITION BY {RANGE|LIST|HASH} (<cols>)")]);
}
if last == "OF" && words.contains(&"PARTITION") {
return None; }
if last == "FOR" && words.contains(&"PARTITION") && words.contains(&"OF") {
return Some(&[
("VALUES", "FOR VALUES { IN (...) | FROM (...) TO (...) | WITH (MODULUS ..., REMAINDER ...) }"),
("DEFAULT", "FOR VALUES DEFAULT -- catch-all partition"),
]);
}
if last == "VALUES" && words.contains(&"PARTITION") {
return Some(&[
("IN", "IN (<v>[, ...]) -- list partition"),
("FROM", "FROM (<lo>) TO (<hi>) -- range partition"),
("WITH", "WITH (MODULUS <n>, REMAINDER <r>) -- hash partition"),
("DEFAULT", "DEFAULT -- catch-all"),
]);
}
if last == "BY" && words.contains(&"PARTITION") {
return Some(&[
("RANGE", "PARTITION BY RANGE (<cols>)"),
("LIST", "PARTITION BY LIST (<col>)"),
("HASH", "PARTITION BY HASH (<col>)"),
]);
}
if last == ")" && words.contains(&"FROM") && words.contains(&"VALUES") && !words.contains(&"TO") {
return Some(&[("TO", "TO (<hi>) -- upper bound of the range")]);
}
None
}
pub(crate) fn refresh_mv_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (_, upper) = stmt_slice_upper(source, offset);
let trimmed = upper.trim_start();
if !trimmed.starts_with("REFRESH MATERIALIZED VIEW") {
return None;
}
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
let last = *words.last()?;
if last == "WITH" {
return Some(&[
("DATA", "WITH DATA -- run the refresh query (default)"),
("NO DATA", "WITH NO DATA -- mark the MV invalid; useful before bulk reload"),
]);
}
if last == "NO" && words.contains(&"WITH") {
return Some(&[("DATA", "NO DATA")]);
}
if words.len() >= 4 && !matches!(last, "REFRESH" | "MATERIALIZED" | "VIEW" | "CONCURRENTLY") {
let mut menu: Vec<(&str, &str)> = Vec::with_capacity(2);
if !words.contains(&"CONCURRENTLY") {
menu.push(("WITH DATA", "WITH DATA -- populate (default)"));
menu.push(("WITH NO DATA", "WITH NO DATA -- mark invalid"));
} else {
menu.push(("WITH DATA", "WITH DATA"));
menu.push(("WITH NO DATA", "WITH NO DATA"));
}
return Some(&[
("WITH DATA", "WITH DATA -- populate (default)"),
("WITH NO DATA", "WITH NO DATA -- mark invalid; refresh later"),
]);
}
None
}
pub(crate) fn identity_paren_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset)
&& !source[..offset.into()].ends_with('(')
&& !source[..offset.into()].ends_with(',')
{
return None;
}
let (slice_owned, upper) = stmt_slice_upper(source, offset);
if !upper.contains("AS IDENTITY") && !upper.contains("AS IDENTITY") {
return None;
}
let at = upper.rfind("AS IDENTITY")?;
let after = &slice_owned[at + "AS IDENTITY".len()..];
let trimmed = after.trim_start();
if !trimmed.starts_with('(') {
return None;
}
let body = &trimmed[1..];
let opens = body.matches('(').count();
let closes = body.matches(')').count();
if closes > opens {
return None;
}
if body.ends_with(')') && opens == closes {
return None;
}
Some(&[
("START WITH", "START [WITH] <n> -- first generated value"),
("INCREMENT BY", "INCREMENT [BY] <n> -- step size"),
("MINVALUE", "MINVALUE <n> | NO MINVALUE"),
("MAXVALUE", "MAXVALUE <n> | NO MAXVALUE"),
("CACHE", "CACHE <n> -- preallocate per-backend"),
("CYCLE", "CYCLE -- wrap around at MAXVALUE/MINVALUE"),
("NO CYCLE", "NO CYCLE -- raise error on exhaust (default)"),
("OWNED BY", "OWNED BY <table>.<col> | NONE -- drop sequence when col goes"),
])
}
pub(crate) fn ctas_with_data_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (_, upper) = stmt_slice_upper(source, offset);
let is_ctas = upper.starts_with("CREATE TABLE") && upper.contains(" AS ");
let is_cmv = upper.starts_with("CREATE MATERIALIZED VIEW");
if !(is_ctas || is_cmv) {
return None;
}
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
let last = *words.last()?;
if last == "NO" && words.contains(&"WITH") {
return Some(&[("DATA", "NO DATA -- create the relation but skip the populate query")]);
}
if last == "WITH" {
return Some(&[
("DATA", "WITH DATA -- run the populate query immediately (default)"),
("NO DATA", "WITH NO DATA -- create empty; populate later with REFRESH/INSERT"),
]);
}
if (is_ctas || is_cmv) && !words.contains(&"WITH") {
if words.len() >= 5 {
return Some(&[("WITH DATA", "WITH DATA -- populate now"), ("WITH NO DATA", "WITH NO DATA -- create empty")]);
}
}
None
}
pub(crate) fn insert_into_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (slice_owned, upper) = stmt_slice_upper(source, offset);
let slice = slice_owned.as_str();
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if words.first() != Some(&"INSERT") {
return None;
}
if !words.contains(&"INTO") || words.len() < 3 {
return None;
}
let has_body =
words.contains(&"VALUES") || words.contains(&"SELECT") || words.contains(&"DEFAULT") || words.contains(&"CONFLICT");
if has_body {
return None;
}
if words.contains(&"OVERRIDING") && matches!(words.last(), Some(&"OVERRIDING") | Some(&"SYSTEM") | Some(&"USER")) {
return None;
}
let opens = slice.matches('(').count();
let closes = slice.matches(')').count();
if opens != closes {
return None;
}
Some(&[
("VALUES", "VALUES (<v>[, ...])[, ...]"),
("SELECT", "INSERT INTO ... SELECT <cols> FROM <src>"),
("DEFAULT VALUES", "DEFAULT VALUES -- all columns take their declared defaults"),
("OVERRIDING", "OVERRIDING {SYSTEM|USER} VALUE -- identity-column override"),
("ON CONFLICT", "ON CONFLICT [(target)] DO ... -- upsert"),
("RETURNING", "RETURNING <cols>"),
])
}
pub(crate) fn update_from_set_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (_, upper) = stmt_slice_upper(source, offset);
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if words.first() != Some(&"UPDATE") {
return None;
}
if words.contains(&"SET") || words.len() < 3 {
return None;
}
Some(&[
("SET", "SET <col> = <expr>[, ...]"),
("FROM", "FROM <other_tbl> -- multi-table UPDATE"),
("WHERE", "WHERE <predicate>"),
("RETURNING", "RETURNING <cols>"),
])
}
pub(crate) fn delete_using_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (_, upper) = stmt_slice_upper(source, offset);
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if words.first() != Some(&"DELETE") {
return None;
}
if !words.contains(&"FROM") || words.len() < 3 {
return None;
}
if words.contains(&"USING") || words.contains(&"WHERE") || words.contains(&"RETURNING") {
return None;
}
Some(&[
("USING", "USING <other_tbl> -- multi-table DELETE"),
("WHERE", "WHERE <predicate>"),
("RETURNING", "RETURNING <cols>"),
])
}
pub(crate) fn tablesample_after_paren_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (slice_owned, upper) = stmt_slice_upper(source, offset);
let slice = slice_owned.as_str();
if !upper.contains("TABLESAMPLE") {
return None;
}
let trimmed = slice.trim_end();
if !trimmed.ends_with(')') {
return None;
}
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if !words.iter().any(|w| *w == "BERNOULLI" || *w == "SYSTEM") {
return None;
}
if words.contains(&"REPEATABLE") {
return None;
}
Some(&[("REPEATABLE", "REPEATABLE (<seed>) -- reproducible sample")])
}
pub(crate) fn filter_clause_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (_, upper) = stmt_slice_upper(source, offset);
let trimmed = upper.trim_end();
if trimmed.ends_with("FILTER (") || trimmed.ends_with("FILTER(") {
return Some(&[("WHERE", "FILTER (WHERE <cond>) -- restrict which rows the aggregate sees")]);
}
None
}
pub(crate) fn table_function_with_ordinality_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (_, upper) = stmt_slice_upper(source, offset);
let trimmed = upper.trim_end();
if !trimmed.ends_with(") WITH") {
return None;
}
if upper.trim_start().starts_with("CREATE") {
return None;
}
if !(upper.contains("FROM ") || upper.contains("JOIN ")) {
return None;
}
Some(&[("ORDINALITY", "WITH ORDINALITY -- append a 1-based row-number column")])
}
pub(crate) fn window_clause_as_paren_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
let pos: usize = (u32::from(offset) as usize).min(source.len());
let bytes = source.as_bytes();
if pos < bytes.len() && !bytes[pos].is_ascii_whitespace() && bytes[pos] != b'(' {
return None;
}
let (slice_owned, upper) = stmt_slice_upper(source, offset);
let slice = slice_owned.as_str();
if !upper.contains("WINDOW") && !upper.contains("OVER") {
return None;
}
let opens = slice.matches('(').count();
let closes = slice.matches(')').count();
if opens == 0 || opens <= closes {
return None;
}
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
let last = *words.last()?;
if last == "PARTITION" {
return Some(&[("BY", "PARTITION BY <expr>[, ...]")]);
}
if last == "ORDER" {
return Some(&[("BY", "ORDER BY <expr>[, ...]")]);
}
if matches!(last, "RANGE" | "ROWS" | "GROUPS") {
return Some(&[
("BETWEEN", "BETWEEN <a> AND <b>"),
("UNBOUNDED PRECEDING", "frame starts at partition start"),
("CURRENT ROW", "frame starts at the current row"),
]);
}
if last == "BETWEEN" {
return Some(&[("UNBOUNDED PRECEDING", "frame starts at partition start"), ("CURRENT ROW", "current row")]);
}
if last == "AND" && words.contains(&"BETWEEN") {
return Some(&[("UNBOUNDED FOLLOWING", "frame ends at partition end"), ("CURRENT ROW", "current row")]);
}
if last == "UNBOUNDED" {
let mut after_and = false;
if let Some(b_idx) = words.iter().rposition(|w| *w == "BETWEEN")
&& words[b_idx + 1..].contains(&"AND")
{
after_and = true;
}
if after_and {
return Some(&[("FOLLOWING", "UNBOUNDED FOLLOWING -- frame ends at partition end")]);
}
return Some(&[("PRECEDING", "UNBOUNDED PRECEDING -- frame starts at partition start")]);
}
if last == "CURRENT" {
return Some(&[("ROW", "CURRENT ROW -- the current row only")]);
}
if last == "EXCLUDE" {
return Some(&[
("CURRENT ROW", "EXCLUDE CURRENT ROW -- skip the current row from the frame"),
("GROUP", "EXCLUDE GROUP -- skip the current row and all peers"),
("TIES", "EXCLUDE TIES -- skip the peers but keep the current row"),
("NO OTHERS", "EXCLUDE NO OTHERS -- default; no exclusion"),
]);
}
if matches!(last, "PRECEDING" | "FOLLOWING") {
let mut needs_and = false;
if let Some(b_idx) = words.iter().rposition(|w| *w == "BETWEEN")
&& !words[b_idx + 1..].contains(&"AND")
{
needs_and = true;
}
if needs_and {
return Some(&[("AND", "BETWEEN <a> AND <b>")]);
}
return Some(&[
("EXCLUDE CURRENT ROW", "EXCLUDE CURRENT ROW"),
("EXCLUDE GROUP", "EXCLUDE GROUP"),
("EXCLUDE TIES", "EXCLUDE TIES"),
("EXCLUDE NO OTHERS", "EXCLUDE NO OTHERS (default)"),
]);
}
let trimmed = slice.trim_end();
let last_char = trimmed.chars().last();
if matches!(last_char, Some('(') | Some(',')) || slice.ends_with(char::is_whitespace) {
return Some(&[
("PARTITION BY", "PARTITION BY <expr>[, ...]"),
("ORDER BY", "ORDER BY <expr>[, ...]"),
("RANGE", "RANGE BETWEEN <a> AND <b>"),
("ROWS", "ROWS BETWEEN <a> AND <b>"),
("GROUPS", "GROUPS BETWEEN <a> AND <b>"),
]);
}
None
}
pub(crate) fn set_op_followup_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (_, upper) = stmt_slice_upper(source, offset);
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
let last = *words.last()?;
if !matches!(last, "UNION" | "INTERSECT" | "EXCEPT") {
return None;
}
Some(&[
("ALL", "ALL -- keep duplicates (no implicit DISTINCT)"),
("DISTINCT", "DISTINCT -- explicit form of the default"),
("SELECT", "SELECT <next_query>"),
("VALUES", "VALUES (<row>) -- inline rows"),
])
}
pub(crate) fn grouping_sets_inner_paren_expects_column(source: &str, offset: TextSize) -> bool {
let (_, upper) = stmt_slice_upper(source, offset);
if !upper.contains("GROUPING SETS") {
return false;
}
let after = match upper.rfind("GROUPING SETS") {
Some(p) => &upper[p + "GROUPING SETS".len()..],
None => return false,
};
let mut depth = 0i32;
for b in after.bytes() {
match b {
b'(' => depth += 1,
b')' => depth -= 1,
_ => {},
}
}
depth >= 2
}
pub(crate) fn json_table_fresh_column_slot(source: &str, offset: TextSize) -> bool {
let (_, upper) = stmt_slice_upper(source, offset);
if !upper.contains("JSON_TABLE") {
return false;
}
let after = match upper.rfind("COLUMNS") {
Some(p) => &upper[p + "COLUMNS".len()..],
None => return false,
};
let mut depth = 0i32;
for b in after.bytes() {
match b {
b'(' => depth += 1,
b')' => depth -= 1,
_ => {},
}
}
if depth != 1 {
return false;
}
let trimmed = after.trim_end();
trimmed.ends_with('(') || trimmed.ends_with(',')
}
const JSON_TABLE_COLUMN_TYPES: &[(&str, &str)] = &[
("text", "arbitrary text -- the most common JSON_TABLE column type"),
("int", "32-bit integer"),
("bigint", "64-bit integer"),
("numeric", "exact decimal"),
("boolean", "true / false"),
("timestamp", "date + time, no time zone"),
("timestamptz", "date + time, with time zone"),
("date", "date only"),
("uuid", "UUID"),
("jsonb", "nested JSON -- usually paired with FORMAT JSON"),
];
pub(crate) fn json_table_column_slot_items(source: &str, offset: TextSize) -> Option<Vec<Item>> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let words = json_table_current_column_entry_words(source, offset)?;
let mut out = Vec::new();
match words.len() {
1 => {
for (ty, doc) in JSON_TABLE_COLUMN_TYPES {
out.push(Item {
label: (*ty).into(),
kind: crate::item::ItemKind::Type,
detail: Some((*doc).into()),
description: Some("JSON_TABLE column type".into()),
documentation_md: None,
insert_text: (*ty).into(),
is_snippet: false,
kb_entry: None,
sort_priority: 1,
});
}
push_keyword_kvs(&mut out, &[("FOR", "<name> FOR ORDINALITY -- 1-based row-number column")]);
},
2 if words[1] == "FOR" => {
push_keyword_kvs(&mut out, &[("ORDINALITY", "FOR ORDINALITY -- 1-based row-number column")]);
},
2 if !matches!(
words[1].as_str(),
"FOR"
| "PATH"
| "FORMAT"
| "EXISTS"
| "WRAPPER"
| "QUOTES"
| "KEEP"
| "OMIT"
| "DEFAULT"
| "NULL"
| "ON"
| "ERROR"
| "NESTED"
) =>
{
push_keyword_kvs(
&mut out,
&[
("PATH", "PATH '<json-path>' -- explicit path into the JSON document"),
("FORMAT", "FORMAT JSON -- treat the column value as a nested JSON document"),
("EXISTS", "EXISTS [PATH ...] -- boolean: does the path match anything"),
],
);
},
_ if words.last().map(String::as_str) == Some("FORMAT") => {
push_keyword_kvs(&mut out, &[("JSON", "FORMAT JSON -- the only valid FORMAT value")]);
},
_ if words.last().map(String::as_str) == Some("EXISTS") => {
push_keyword_kvs(&mut out, &[("PATH", "EXISTS PATH '<json-path>' -- optional, defaults to the column name")]);
},
_ => return None,
}
if out.is_empty() { None } else { Some(out) }
}
fn json_table_current_column_entry_words(source: &str, offset: TextSize) -> Option<Vec<String>> {
let (_, upper) = stmt_slice_upper(source, offset);
if !upper.contains("JSON_TABLE") {
return None;
}
let columns_at = upper.rfind("COLUMNS")?;
let after = &upper[columns_at + "COLUMNS".len()..];
let mut depth = 0i32;
let mut entry_start = 0usize;
for (i, b) in after.bytes().enumerate() {
match b {
b'(' => depth += 1,
b')' => depth -= 1,
b',' if depth == 1 => entry_start = i + 1,
_ => {},
}
}
if depth != 1 {
return None;
}
Some(after[entry_start..].split_whitespace().map(String::from).collect())
}
pub(crate) fn group_by_set_op_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (_, upper) = stmt_slice_upper(source, offset);
if !upper.contains("GROUP BY") {
return None;
}
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
let last = *words.last()?;
if last == "BY" && words.contains(&"GROUP") {
return Some(&[
("GROUPING SETS", "GROUPING SETS ((<a>), (<a>,<b>), ()) -- explicit sets"),
("CUBE", "CUBE (<a>, <b>) -- all subsets"),
("ROLLUP", "ROLLUP (<a>, <b>) -- nested hierarchy"),
]);
}
if last == "GROUPING" {
return Some(&[("SETS", "GROUPING SETS ((<cols>), ...)")]);
}
None
}
pub(crate) fn select_fetch_offset_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (_, upper) = stmt_slice_upper(source, offset);
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
let last = *words.last()?;
let starts_query = upper.starts_with("SELECT")
|| upper.starts_with("WITH")
|| upper.starts_with("VALUES")
|| upper.starts_with("TABLE");
if !starts_query {
return None;
}
if last == "FETCH" {
return Some(&[
("FIRST", "FETCH FIRST <n> {ROW|ROWS} {ONLY | WITH TIES}"),
("NEXT", "FETCH NEXT <n> {ROW|ROWS} {ONLY | WITH TIES}"),
]);
}
if matches!(last, "FIRST" | "NEXT") {
return Some(&[("ROW", "ROW {ONLY | WITH TIES}"), ("ROWS", "ROWS {ONLY | WITH TIES}")]);
}
if matches!(last, "ROW" | "ROWS") && words.contains(&"FETCH") {
return Some(&[
("ONLY", "ONLY -- standard"),
("WITH TIES", "WITH TIES -- include rows that tie on ORDER BY (PG 13+)"),
]);
}
if matches!(last, "ROW" | "ROWS") && words.contains(&"OFFSET") {
return Some(&[("FETCH", "FETCH {FIRST|NEXT} <n> {ROW|ROWS} {ONLY | WITH TIES}")]);
}
if last == "OFFSET" {
return None; }
if last == "WITH" {
return Some(&[("TIES", "WITH TIES -- include peers tied on ORDER BY")]);
}
None
}
pub(crate) fn insert_overriding_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (_, upper) = stmt_slice_upper(source, offset);
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if !upper.starts_with("INSERT") {
return None;
}
let last = *words.last()?;
if last == "OVERRIDING" {
return Some(&[
("SYSTEM VALUE", "OVERRIDING SYSTEM VALUE -- replace identity"),
("USER VALUE", "OVERRIDING USER VALUE -- accept user's value"),
]);
}
if (last == "SYSTEM" || last == "USER") && words.contains(&"OVERRIDING") {
return Some(&[("VALUE", "VALUE -- close the OVERRIDING clause")]);
}
None
}
pub(crate) fn with_cte_after_paren_close_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (slice_owned, upper) = stmt_slice_upper(source, offset);
let slice = slice_owned.as_str();
if !upper.trim_start().starts_with("WITH ")
&& !upper.trim_start().starts_with("WITH\t")
&& !upper.trim_start().starts_with("WITH\n")
{
return None;
}
let trimmed = slice.trim_end();
if !trimmed.ends_with(')') {
return None;
}
let opens = upper.matches('(').count();
let closes = upper.matches(')').count();
if opens == 0 || opens != closes {
return None;
}
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if words.iter().any(|w| matches!(*w, "SELECT" | "INSERT" | "UPDATE" | "DELETE" | "MERGE" | "VALUES" | "TABLE")) {
return None;
}
Some(&[
("SELECT", "SELECT <cols> FROM ... -- main query"),
("INSERT INTO", "INSERT INTO <tbl> ... -- main query"),
("UPDATE", "UPDATE <tbl> SET ... -- main query"),
("DELETE FROM", "DELETE FROM <tbl> ... -- main query"),
("MERGE INTO", "MERGE INTO <tbl> USING ... -- main query"),
("VALUES", "VALUES (<row>) -- inline-rows main query"),
("TABLE", "TABLE <name> -- shorthand for SELECT * FROM <name>"),
(",", "<cte_name> AS (<body>) -- continue CTE list"),
])
}
pub(crate) fn on_conflict_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (_, upper) = stmt_slice_upper(source, offset);
if !upper.contains("ON CONFLICT") {
return None;
}
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
let last = *words.last()?;
if last == "CONFLICT" {
return Some(&[
("ON CONSTRAINT", "ON CONFLICT ON CONSTRAINT <name>"),
("(", "ON CONFLICT (<col>[, ...]) -- expression target"),
("DO NOTHING", "ON CONFLICT DO NOTHING"),
("DO UPDATE", "ON CONFLICT DO UPDATE SET <col>=<val>[, ...]"),
]);
}
if last == "DO" {
return Some(&[
("NOTHING", "DO NOTHING -- skip the conflicting row"),
("UPDATE", "DO UPDATE SET <col>=<val>[, ...]"),
]);
}
if last == "UPDATE" && words.contains(&"CONFLICT") {
return Some(&[("SET", "SET <col> = <val>[, ...]")]);
}
None
}
pub(crate) fn vacuum_paren_value_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (slice_owned, upper) = stmt_slice_upper(source, offset);
let slice = slice_owned.as_str();
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if words.first() != Some(&"VACUUM") && words.first() != Some(&"ANALYZE") {
return None;
}
let opens = slice.matches('(').count();
let closes = slice.matches(')').count();
if opens == 0 || opens <= closes {
return None;
}
let last_raw = *words.last()?;
let last = last_raw.trim_start_matches(['(', ',']);
let boolean_opts = [
"FULL",
"FREEZE",
"VERBOSE",
"ANALYZE",
"DISABLE_PAGE_SKIPPING",
"SKIP_LOCKED",
"TRUNCATE",
"PROCESS_TOAST",
"PROCESS_MAIN",
"SKIP_DATABASE_STATS",
"ONLY_DATABASE_STATS",
];
if boolean_opts.contains(&last) {
return Some(&[("true", "true -- enable"), ("false", "false -- disable")]);
}
if last == "INDEX_CLEANUP" {
return Some(&[
("AUTO", "AUTO -- decide based on table state (default)"),
("ON", "ON -- always clean up indexes"),
("OFF", "OFF -- skip index cleanup"),
]);
}
None
}
pub(crate) fn prepare_next_keyword(source: &str, offset: TextSize) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (slice_owned, upper) = stmt_slice_upper(source, offset);
let slice = slice_owned.as_str();
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if words.first() != Some(&"PREPARE") {
return None;
}
let last = *words.last()?;
if last == "AS" {
return Some(&[
("SELECT", "AS SELECT ..."),
("INSERT", "AS INSERT INTO ..."),
("UPDATE", "AS UPDATE ..."),
("DELETE", "AS DELETE ..."),
("VALUES", "AS VALUES (...)"),
]);
}
let opens = slice.matches('(').count();
let closes = slice.matches(')').count();
if words.len() >= 2 && opens == closes && !words.contains(&"AS") {
return Some(&[("AS", "AS <statement>")]);
}
None
}
pub(crate) fn declare_cursor_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (_, upper) = stmt_slice_upper(source, offset);
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if words.first() != Some(&"DECLARE") {
return None;
}
let last = *words.last()?;
if last == "WITH" || last == "WITHOUT" {
return Some(&[("HOLD", "{WITH|WITHOUT} HOLD -- keep cursor open across commits")]);
}
if last == "NO" {
return Some(&[("SCROLL", "NO SCROLL -- forbid backward fetch")]);
}
if last == "CURSOR" {
return Some(&[
("WITH HOLD", "WITH HOLD -- survive COMMIT"),
("WITHOUT HOLD", "WITHOUT HOLD -- default"),
("FOR", "FOR <query>"),
]);
}
if last == "DECLARE" {
return None; }
if words.len() == 2 {
return Some(&[
("BINARY", "BINARY -- binary protocol"),
("INSENSITIVE", "INSENSITIVE -- materialise the result"),
("ASENSITIVE", "ASENSITIVE -- default"),
("SCROLL", "SCROLL -- allow PRIOR/BACKWARD fetch"),
("NO SCROLL", "NO SCROLL -- forbid backward fetch"),
("CURSOR", "CURSOR FOR <query>"),
]);
}
if !words.contains(&"CURSOR") && words.len() >= 3 {
return Some(&[
("BINARY", "BINARY"),
("INSENSITIVE", "INSENSITIVE"),
("ASENSITIVE", "ASENSITIVE"),
("SCROLL", "SCROLL"),
("NO SCROLL", "NO SCROLL"),
("CURSOR", "CURSOR [WITH HOLD] FOR <query>"),
]);
}
None
}
pub(crate) fn truncate_next_keyword(source: &str, offset: TextSize) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (_, upper) = stmt_slice_upper(source, offset);
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if words.first() != Some(&"TRUNCATE") {
return None;
}
let last = *words.last()?;
if matches!(last, "RESTART" | "CONTINUE") {
return Some(&[("IDENTITY", "IDENTITY -- act on sequence-backed columns")]);
}
if last == "IDENTITY" {
return Some(&[
("CASCADE", "CASCADE -- also truncate dependent FK tables"),
("RESTRICT", "RESTRICT -- refuse if dependents exist (default)"),
]);
}
if words.len() >= 2
&& !words.contains(&"CASCADE")
&& !words.contains(&"RESTRICT")
&& !words.contains(&"RESTART")
&& !words.contains(&"CONTINUE")
{
return Some(&[
("RESTART IDENTITY", "RESTART IDENTITY -- reset owned sequences"),
("CONTINUE IDENTITY", "CONTINUE IDENTITY -- keep current sequence values (default)"),
("CASCADE", "CASCADE -- also truncate FK-dependent tables"),
("RESTRICT", "RESTRICT -- refuse if dependents exist (default)"),
]);
}
None
}
pub(crate) fn set_role_auth_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (_, upper) = stmt_slice_upper(source, offset);
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if words.first() != Some(&"SET") {
return None;
}
if words.len() == 1 {
return None; }
if words == ["SET", "ROLE"] {
return Some(&[("NONE", "SET ROLE NONE -- revert to login role")]);
}
if words == ["SET", "SESSION"] {
return Some(&[
("AUTHORIZATION", "SET SESSION AUTHORIZATION <role>"),
("CHARACTERISTICS", "SET SESSION CHARACTERISTICS AS TRANSACTION ..."),
]);
}
if words == ["SET", "SESSION", "AUTHORIZATION"] {
return Some(&[("DEFAULT", "SET SESSION AUTHORIZATION DEFAULT -- restore login role")]);
}
if words == ["SET", "SESSION", "CHARACTERISTICS"] {
return Some(&[("AS TRANSACTION", "AS TRANSACTION ISOLATION LEVEL ...")]);
}
None
}
pub(crate) fn grant_revoke_followup_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (_, upper) = stmt_slice_upper(source, offset);
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
let first = *words.first()?;
if !matches!(first, "GRANT" | "REVOKE") {
return None;
}
let last = *words.last()?;
if last == "ON" {
return Some(&[
("TABLE", "ON TABLE <name>[, ...]"),
("SEQUENCE", "ON SEQUENCE <name>"),
("DATABASE", "ON DATABASE <name>"),
("DOMAIN", "ON DOMAIN <name>"),
("FOREIGN DATA WRAPPER", "ON FOREIGN DATA WRAPPER <name>"),
("FOREIGN SERVER", "ON FOREIGN SERVER <name>"),
("FUNCTION", "ON FUNCTION <name>(arg_types)"),
("PROCEDURE", "ON PROCEDURE <name>(arg_types)"),
("ROUTINE", "ON ROUTINE <name>(arg_types) -- fn or proc"),
("LANGUAGE", "ON LANGUAGE <name>"),
("LARGE OBJECT", "ON LARGE OBJECT <oid>"),
("PARAMETER", "ON PARAMETER <guc_name> -- PG15+"),
("SCHEMA", "ON SCHEMA <name>"),
("TABLESPACE", "ON TABLESPACE <name>"),
("TYPE", "ON TYPE <name>"),
("ALL TABLES IN SCHEMA", "ON ALL TABLES IN SCHEMA <s>"),
("ALL SEQUENCES IN SCHEMA", "ON ALL SEQUENCES IN SCHEMA <s>"),
("ALL FUNCTIONS IN SCHEMA", "ON ALL FUNCTIONS IN SCHEMA <s>"),
("ALL ROUTINES IN SCHEMA", "ON ALL ROUTINES IN SCHEMA <s>"),
("ALL PROCEDURES IN SCHEMA", "ON ALL PROCEDURES IN SCHEMA <s>"),
]);
}
if matches!(last, "TO" | "FROM") {
return None;
}
if last == "WITH" {
if first == "GRANT" {
return Some(&[
("GRANT OPTION", "WITH GRANT OPTION -- recipient may grant onward"),
("ADMIN OPTION", "WITH ADMIN OPTION -- recipient may manage role membership"),
]);
}
if first == "REVOKE" {
return Some(&[
("GRANT OPTION FOR", "REVOKE GRANT OPTION FOR -- drop forwarding right, keep priv"),
("ADMIN OPTION FOR", "REVOKE ADMIN OPTION FOR -- drop admin right, keep membership"),
]);
}
}
if last == "GRANTED" && first == "REVOKE" {
return Some(&[("BY", "GRANTED BY <role> -- target the grant from <role>")]);
}
let has_on = words.contains(&"ON");
let has_to_or_from = words.contains(&"TO") || words.contains(&"FROM");
if has_on && !has_to_or_from {
if first == "GRANT" {
return Some(&[("TO", "TO <role>[, ...]")]);
}
return Some(&[("FROM", "FROM <role>[, ...]")]);
}
if has_on && has_to_or_from && first == "GRANT" && !words.contains(&"WITH") {
return Some(&[("WITH GRANT OPTION", "WITH GRANT OPTION -- recipient may grant onward")]);
}
if has_on && has_to_or_from && first == "REVOKE" {
let mut tail: Vec<(&str, &str)> = Vec::new();
if !words.contains(&"CASCADE") && !words.contains(&"RESTRICT") {
tail.push(("CASCADE", "CASCADE -- also drop dependent grants"));
tail.push(("RESTRICT", "RESTRICT -- refuse if dependent grants exist (default)"));
}
if !words.contains(&"GRANTED") {
tail.push(("GRANTED BY", "GRANTED BY <role>"));
}
if !tail.is_empty() {
return Some(&[
("CASCADE", "CASCADE -- also drop dependent grants"),
("RESTRICT", "RESTRICT -- refuse if dependent grants exist (default)"),
("GRANTED BY", "GRANTED BY <role>"),
]);
}
}
None
}
pub(crate) fn fetch_move_direction_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (_, upper) = stmt_slice_upper(source, offset);
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if !matches!(words.first(), Some(&"FETCH") | Some(&"MOVE")) {
return None;
}
let last = *words.last()?;
if words.len() == 1 {
return Some(&[
("NEXT", "NEXT -- one row forward"),
("PRIOR", "PRIOR -- one row backward"),
("FIRST", "FIRST -- absolute 1"),
("LAST", "LAST -- absolute last"),
("ABSOLUTE", "ABSOLUTE <n>"),
("RELATIVE", "RELATIVE <n>"),
("FORWARD", "FORWARD [<n> | ALL]"),
("BACKWARD", "BACKWARD [<n> | ALL]"),
("ALL", "ALL -- every remaining row"),
("FROM", "FROM <cursor>"),
("IN", "IN <cursor>"),
]);
}
if matches!(last, "FORWARD" | "BACKWARD") {
return Some(&[("ALL", "ALL -- every remaining row"), ("FROM", "FROM <cursor>"), ("IN", "IN <cursor>")]);
}
if matches!(last, "NEXT" | "PRIOR" | "FIRST" | "LAST" | "ALL" | "ABSOLUTE" | "RELATIVE") {
return Some(&[("FROM", "FROM <cursor>"), ("IN", "IN <cursor>")]);
}
None
}
pub(crate) fn lock_mode_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (_, upper) = stmt_slice_upper(source, offset);
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if words.first() != Some(&"LOCK") {
return None;
}
let last = *words.last()?;
if last == "IN" {
return Some(&[
("ACCESS SHARE", "ACCESS SHARE MODE -- weakest; readers"),
("ROW SHARE", "ROW SHARE MODE -- SELECT FOR SHARE/UPDATE"),
("ROW EXCLUSIVE", "ROW EXCLUSIVE MODE -- INSERT/UPDATE/DELETE"),
("SHARE UPDATE EXCLUSIVE", "SHARE UPDATE EXCLUSIVE MODE -- VACUUM/ANALYZE"),
("SHARE", "SHARE MODE -- read-only after"),
("SHARE ROW EXCLUSIVE", "SHARE ROW EXCLUSIVE MODE"),
("EXCLUSIVE", "EXCLUSIVE MODE -- only ACCESS SHARE coexists"),
("ACCESS EXCLUSIVE", "ACCESS EXCLUSIVE MODE -- strongest; sole holder"),
]);
}
if matches!(last, "ACCESS" | "ROW" | "SHARE" | "EXCLUSIVE" | "UPDATE") {
return Some(&[
("MODE", "MODE -- close the IN <mode> MODE clause"),
("SHARE", "SHARE -- ACCESS SHARE / ROW SHARE / SHARE / SHARE ROW EXCLUSIVE / SHARE UPDATE EXCLUSIVE"),
("EXCLUSIVE", "EXCLUSIVE -- ACCESS EXCLUSIVE / ROW EXCLUSIVE / SHARE ROW EXCLUSIVE / SHARE UPDATE EXCLUSIVE"),
]);
}
if last == "MODE" {
return Some(&[("NOWAIT", "NOWAIT -- fail instead of waiting on contention")]);
}
if words.len() >= 2 && !words.contains(&"IN") && !words.contains(&"NOWAIT") {
return Some(&[("IN", "IN <mode> MODE [NOWAIT]"), ("NOWAIT", "NOWAIT -- fail rather than wait")]);
}
None
}
pub(crate) fn deallocate_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (_, upper) = stmt_slice_upper(source, offset);
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if words.first() != Some(&"DEALLOCATE") {
return None;
}
if words.len() == 1 {
return Some(&[
("ALL", "DEALLOCATE ALL -- forget every prepared statement"),
("PREPARE", "DEALLOCATE PREPARE <name>"),
]);
}
None
}
pub(crate) fn create_transform_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (slice_owned, upper) = stmt_slice_upper(source, offset);
let slice = slice_owned.as_str();
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
let t_idx = words.iter().position(|w| *w == "TRANSFORM")?;
if !words[..t_idx].iter().all(|w| matches!(*w, "CREATE" | "OR" | "REPLACE")) || words[0] != "CREATE" {
return None;
}
let tail = &words[t_idx + 1..];
let last = tail.last().copied();
if last == Some("TYPE") || last == Some("LANGUAGE") {
return None; }
if last == Some("FOR") {
return Some(&[("TYPE", "FOR TYPE <type>")]);
}
if last == Some("FROM") {
return Some(&[("SQL", "FROM SQL WITH FUNCTION <fn>(<types>)")]);
}
if last == Some("TO") {
return Some(&[("SQL", "TO SQL WITH FUNCTION <fn>(<types>)")]);
}
if last == Some("WITH") {
return Some(&[("FUNCTION", "WITH FUNCTION <fn>(<types>)")]);
}
if tail.is_empty() {
return Some(&[("FOR TYPE", "FOR TYPE <type> LANGUAGE <lang> (...)")]);
}
if tail.len() == 1 {
return Some(&[
("FOR TYPE", "FOR TYPE <type> LANGUAGE <lang> (...)"),
("LANGUAGE", "LANGUAGE <plpgsql|plperl|...>"),
]);
}
if tail.contains(&"TYPE") && !tail.contains(&"LANGUAGE") {
return Some(&[("LANGUAGE", "LANGUAGE <plpgsql|plperl|...>")]);
}
let opens = slice.matches('(').count();
let closes = slice.matches(')').count();
if opens > closes {
let trimmed = slice.trim_end();
let last_char = trimmed.chars().last();
if matches!(last_char, Some('(') | Some(',')) || slice.ends_with(char::is_whitespace) {
return Some(&[
("FROM SQL WITH FUNCTION", "FROM SQL WITH FUNCTION <fn>(<types>)"),
("TO SQL WITH FUNCTION", "TO SQL WITH FUNCTION <fn>(<types>)"),
]);
}
}
if tail.contains(&"LANGUAGE") && !tail.contains(&"(") && opens == closes {
return Some(&[("(", "( FROM SQL WITH FUNCTION ..., TO SQL WITH FUNCTION ... )")]);
}
None
}
pub(crate) fn create_operator_family_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (_, upper) = stmt_slice_upper(source, offset);
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if words.len() < 3 || words[0] != "CREATE" || words[1] != "OPERATOR" || words[2] != "FAMILY" {
return None;
}
let last = *words.last()?;
if last == "FAMILY" {
return None; }
if last == "USING" {
return Some(&[
("btree", "btree"),
("hash", "hash"),
("gist", "gist"),
("spgist", "spgist"),
("gin", "gin"),
("brin", "brin"),
]);
}
if words.len() >= 4 && !words.contains(&"USING") {
return Some(&[("USING", "USING <index_method>")]);
}
None
}
pub(crate) fn create_operator_class_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (_, upper) = stmt_slice_upper(source, offset);
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if words.len() < 3 || words[0] != "CREATE" || words[1] != "OPERATOR" || words[2] != "CLASS" {
return None;
}
let last = *words.last()?;
if last == "CLASS" {
return None; }
if last == "DEFAULT" {
return Some(&[("FOR TYPE", "FOR TYPE <type>")]);
}
if last == "FOR" {
return Some(&[("TYPE", "FOR TYPE <type>")]);
}
if last == "TYPE" {
return None; }
if last == "USING" {
return Some(&[
("btree", "btree"),
("hash", "hash"),
("gist", "gist"),
("spgist", "spgist"),
("gin", "gin"),
("brin", "brin"),
]);
}
if last == "FAMILY" {
return None; }
if last == "AS" {
return Some(&[
("OPERATOR", "OPERATOR <strategy_number> <op> [(<types>)] [FOR ORDER BY <opfamily>]"),
("FUNCTION", "FUNCTION <support_number> [(<types>)] <fn>(<types>)"),
("STORAGE", "STORAGE <storage_type>"),
]);
}
if words.contains(&"USING") && !words.contains(&"AS") {
let am_idx = words.iter().rposition(|w| *w == "USING")?;
if words.len() == am_idx + 2 && !matches!(last, "USING") {
return Some(&[("FAMILY", "FAMILY <existing_family>"), ("AS", "AS OPERATOR ... | FUNCTION ... | STORAGE ...")]);
}
if words.contains(&"FAMILY") && words.len() >= am_idx + 4 {
return Some(&[("AS", "AS OPERATOR ... | FUNCTION ... | STORAGE ...")]);
}
}
if words.contains(&"AS") && last == "," {
return Some(&[
("OPERATOR", "OPERATOR <strategy_number> <op>(<types>)"),
("FUNCTION", "FUNCTION <support_number> <fn>(<types>)"),
("STORAGE", "STORAGE <storage_type>"),
]);
}
if words.len() >= 4 && !words.contains(&"FOR") {
return Some(&[("DEFAULT", "DEFAULT -- mark as default opclass"), ("FOR TYPE", "FOR TYPE <type>")]);
}
None
}
pub(crate) fn alter_default_privileges_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (_, upper) = stmt_slice_upper(source, offset);
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if words.len() < 3 || words[0] != "ALTER" || words[1] != "DEFAULT" || words[2] != "PRIVILEGES" {
return None;
}
let last = *words.last()?;
if last == "PRIVILEGES" {
return Some(&[
("FOR ROLE", "FOR ROLE <r>[, ...]"),
("FOR USER", "FOR USER <r>[, ...]"),
("IN SCHEMA", "IN SCHEMA <s>[, ...]"),
("GRANT", "GRANT <privs> ON {TABLES|SEQUENCES|FUNCTIONS|TYPES|SCHEMAS} TO ..."),
("REVOKE", "REVOKE <privs> ON ... FROM ..."),
]);
}
if last == "FOR" {
return Some(&[("ROLE", "FOR ROLE <r>[, ...]"), ("USER", "FOR USER <r>[, ...]")]);
}
if last == "IN" {
return Some(&[("SCHEMA", "IN SCHEMA <s>[, ...]")]);
}
if last == "ON" {
return Some(&[
("TABLES", "ON TABLES"),
("SEQUENCES", "ON SEQUENCES"),
("FUNCTIONS", "ON FUNCTIONS"),
("ROUTINES", "ON ROUTINES"),
("TYPES", "ON TYPES"),
("SCHEMAS", "ON SCHEMAS"),
]);
}
if matches!(last, "TABLES" | "SEQUENCES" | "FUNCTIONS" | "ROUTINES" | "TYPES" | "SCHEMAS") {
if words.contains(&"GRANT") {
return Some(&[("TO", "TO <role>[, ...] | PUBLIC")]);
}
if words.contains(&"REVOKE") {
return Some(&[("FROM", "FROM <role>[, ...] | PUBLIC")]);
}
}
None
}
pub(crate) fn alter_extension_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (_, upper) = stmt_slice_upper(source, offset);
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if words.len() < 2 || words[0] != "ALTER" || words[1] != "EXTENSION" {
return None;
}
let last = *words.last()?;
if last == "UPDATE" {
return Some(&[("TO", "UPDATE TO '<version>'")]);
}
if last == "SET" {
return Some(&[("SCHEMA", "SET SCHEMA <schema>")]);
}
if last == "ADD" || last == "DROP" {
return Some(&[
("TABLE", "ADD/DROP TABLE <name>"),
("VIEW", "ADD/DROP VIEW <name>"),
("SEQUENCE", "ADD/DROP SEQUENCE <name>"),
("FUNCTION", "ADD/DROP FUNCTION <name>(args)"),
("PROCEDURE", "ADD/DROP PROCEDURE <name>(args)"),
("TYPE", "ADD/DROP TYPE <name>"),
("AGGREGATE", "ADD/DROP AGGREGATE <name>(args)"),
("OPERATOR", "ADD/DROP OPERATOR <op>(args)"),
("CAST", "ADD/DROP CAST (src AS dst)"),
("SCHEMA", "ADD/DROP SCHEMA <name>"),
("MATERIALIZED VIEW", "ADD/DROP MATERIALIZED VIEW <name>"),
("FOREIGN TABLE", "ADD/DROP FOREIGN TABLE <name>"),
("FOREIGN DATA WRAPPER", "ADD/DROP FOREIGN DATA WRAPPER <name>"),
("SERVER", "ADD/DROP SERVER <name>"),
("TEXT SEARCH CONFIGURATION", "ADD/DROP TEXT SEARCH CONFIGURATION <name>"),
("TEXT SEARCH DICTIONARY", "ADD/DROP TEXT SEARCH DICTIONARY <name>"),
("TEXT SEARCH PARSER", "ADD/DROP TEXT SEARCH PARSER <name>"),
("TEXT SEARCH TEMPLATE", "ADD/DROP TEXT SEARCH TEMPLATE <name>"),
]);
}
if words.len() >= 3 {
return Some(&[
("UPDATE", "UPDATE [TO '<version>']"),
("UPDATE TO", "UPDATE TO '<version>'"),
("SET SCHEMA", "SET SCHEMA <schema>"),
("ADD", "ADD <kind> <name>"),
("DROP", "DROP <kind> <name>"),
]);
}
None
}
pub(crate) fn alter_index_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
let pos: usize = (u32::from(offset) as usize).min(source.len());
let bytes = source.as_bytes();
let at_paren = pos > 0 && bytes[pos - 1] == b'(';
if !at_paren && cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (slice_owned, upper) = stmt_slice_upper(source, offset);
let slice = slice_owned.as_str();
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if words.len() < 2 || words[0] != "ALTER" || words[1] != "INDEX" {
return None;
}
let opens = slice.matches('(').count();
let closes = slice.matches(')').count();
if opens > closes && upper.contains(" SET (") {
let trimmed = slice.trim_end();
let last_char = trimmed.chars().last();
if matches!(last_char, Some('(') | Some(',')) || slice.ends_with(char::is_whitespace) {
return Some(&[
("fillfactor", "fillfactor = <int> -- index page fillfactor (10..100)"),
("deduplicate_items", "deduplicate_items = on|off -- btree dedup (PG13+)"),
("buffering", "buffering = on|off|auto -- gist build buffering"),
("fastupdate", "fastupdate = on|off -- gin pending-list updates"),
("gin_pending_list_limit", "gin_pending_list_limit = '<size>' -- pending-list size"),
("pages_per_range", "pages_per_range = <int> -- brin granularity"),
("autosummarize", "autosummarize = on|off -- brin auto summarize"),
]);
}
}
let last = *words.last()?;
if matches!(last, "RENAME" | "SET" | "RESET" | "ATTACH" | "DEPENDS" | "ALTER" | "NO" | "ALL" | "IN" | "OWNED") {
let menu: &[(&str, &str)] = match last {
"RENAME" => &[("TO", "RENAME TO <new>")],
"SET" => &[("TABLESPACE", "SET TABLESPACE <ts>"), ("(", "SET ( <param> = <val>[, ...] )")],
"RESET" => &[("(", "RESET ( <param>[, ...] )")],
"ATTACH" => &[("PARTITION", "ATTACH PARTITION <child_idx>")],
"DEPENDS" => &[("ON EXTENSION", "DEPENDS ON EXTENSION <ext>")],
"NO" => &[("DEPENDS ON EXTENSION", "NO DEPENDS ON EXTENSION <ext>")],
"ALTER" => &[("COLUMN", "ALTER COLUMN <col_num> SET STATISTICS <n>")],
"ALL" => &[("IN TABLESPACE", "ALL IN TABLESPACE <ts>")],
"IN" => &[("TABLESPACE", "IN TABLESPACE <ts>")],
"OWNED" => &[("BY", "OWNED BY <role>[, ...]")],
_ => &[],
};
if !menu.is_empty() {
return Some(menu);
}
}
if words.len() >= 3 {
return Some(&[
("RENAME TO", "RENAME TO <new>"),
("SET TABLESPACE", "SET TABLESPACE <ts>"),
("SET", "SET ( <param> = <val>[, ...] )"),
("RESET", "RESET ( <param>[, ...] )"),
("ATTACH PARTITION", "ATTACH PARTITION <child_idx>"),
("DEPENDS ON EXTENSION", "DEPENDS ON EXTENSION <ext>"),
("NO DEPENDS ON EXTENSION", "NO DEPENDS ON EXTENSION <ext>"),
("ALTER COLUMN", "ALTER COLUMN <col_num> SET STATISTICS <n>"),
]);
}
None
}
pub(crate) fn alter_sequence_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (_, upper) = stmt_slice_upper(source, offset);
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if words.len() < 2 || words[0] != "ALTER" || words[1] != "SEQUENCE" {
return None;
}
let last = *words.last()?;
if matches!(last, "RESTART" | "INCREMENT" | "START" | "MINVALUE" | "MAXVALUE" | "CACHE") {
let menu: &[(&str, &str)] = match last {
"RESTART" => &[("WITH", "RESTART WITH <n>")],
"INCREMENT" => &[("BY", "INCREMENT BY <n>")],
"START" => &[("WITH", "START WITH <n>")],
_ => &[],
};
if !menu.is_empty() {
return Some(menu);
}
return None; }
if last == "NO" {
return Some(&[("MINVALUE", "NO MINVALUE"), ("MAXVALUE", "NO MAXVALUE"), ("CYCLE", "NO CYCLE")]);
}
if last == "OWNED" {
return Some(&[("BY", "OWNED BY <table>.<col> | NONE")]);
}
if last == "OWNER" {
return Some(&[("TO", "OWNER TO <role>")]);
}
if last == "SET" {
return Some(&[("SCHEMA", "SET SCHEMA <schema>"), ("LOGGED", "SET LOGGED"), ("UNLOGGED", "SET UNLOGGED")]);
}
if last == "AS" {
return Some(&[("smallint", "AS smallint"), ("integer", "AS integer"), ("bigint", "AS bigint")]);
}
if words.len() >= 3 {
return Some(&[
("AS", "AS smallint | integer | bigint"),
("INCREMENT BY", "INCREMENT BY <n>"),
("MINVALUE", "MINVALUE <n>"),
("NO MINVALUE", "NO MINVALUE"),
("MAXVALUE", "MAXVALUE <n>"),
("NO MAXVALUE", "NO MAXVALUE"),
("START WITH", "START WITH <n>"),
("RESTART", "RESTART [WITH <n>]"),
("CACHE", "CACHE <n>"),
("CYCLE", "CYCLE"),
("NO CYCLE", "NO CYCLE"),
("OWNED BY", "OWNED BY <tbl>.<col> | NONE"),
("OWNER TO", "OWNER TO <role>"),
("RENAME TO", "RENAME TO <new_name>"),
("SET SCHEMA", "SET SCHEMA <schema>"),
]);
}
None
}
pub(crate) fn alter_text_search_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (_, upper) = stmt_slice_upper(source, offset);
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if words.len() < 3 || words[0] != "ALTER" || words[1] != "TEXT" || words[2] != "SEARCH" {
return None;
}
if words.len() < 4 {
return Some(&[
("CONFIGURATION", "CONFIGURATION <name> ..."),
("DICTIONARY", "DICTIONARY <name> ..."),
("PARSER", "PARSER <name> ..."),
("TEMPLATE", "TEMPLATE <name> ..."),
]);
}
let kind = words[3];
let last = *words.last()?;
if words.len() == 4 {
return None; }
if matches!(last, "RENAME" | "OWNER" | "SET" | "ADD" | "ALTER" | "DROP" | "MAPPING") {
let menu: &[(&str, &str)] = match (kind, last) {
(_, "RENAME") => &[("TO", "RENAME TO <new_name>")],
(_, "OWNER") => &[("TO", "OWNER TO <role>")],
(_, "SET") => &[("SCHEMA", "SET SCHEMA <schema>")],
("CONFIGURATION", "ADD") => &[("MAPPING FOR", "ADD MAPPING FOR <token_type>[, ...] WITH <dictionary>[, ...]")],
("CONFIGURATION", "ALTER") => &[
("MAPPING FOR", "ALTER MAPPING FOR <token_type> WITH <dictionary>"),
("MAPPING REPLACE", "ALTER MAPPING REPLACE <old_dict> WITH <new_dict>"),
],
("CONFIGURATION", "DROP") => &[("MAPPING FOR", "DROP MAPPING [IF EXISTS] FOR <token_type>[, ...]")],
("CONFIGURATION", "MAPPING") => {
&[("FOR", "MAPPING FOR <token_type>[, ...]"), ("REPLACE", "MAPPING REPLACE <old_dict> WITH <new_dict>")]
},
_ => &[],
};
if !menu.is_empty() {
return Some(menu);
}
}
if words.len() >= 5 && !matches!(last, "TO" | "FOR" | "WITH" | "MAPPING" | "REPLACE") {
let menu: &[(&str, &str)] = match kind {
"CONFIGURATION" => &[
("ADD MAPPING FOR", "ADD MAPPING FOR <token_type> WITH <dict>"),
("ALTER MAPPING FOR", "ALTER MAPPING FOR <token_type> WITH <dict>"),
("ALTER MAPPING REPLACE", "ALTER MAPPING REPLACE <old_dict> WITH <new_dict>"),
("DROP MAPPING FOR", "DROP MAPPING [IF EXISTS] FOR <token_type>"),
("RENAME TO", "RENAME TO <new>"),
("OWNER TO", "OWNER TO <role>"),
("SET SCHEMA", "SET SCHEMA <schema>"),
],
_ => &[("RENAME TO", "RENAME TO <new>"), ("OWNER TO", "OWNER TO <role>"), ("SET SCHEMA", "SET SCHEMA <schema>")],
};
return Some(menu);
}
None
}
pub(crate) fn alter_policy_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (_, upper) = stmt_slice_upper(source, offset);
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if words.len() < 2 || words[0] != "ALTER" || words[1] != "POLICY" {
return None;
}
let last = *words.last()?;
if last == "RENAME" {
return Some(&[("TO", "RENAME TO <new_name>")]);
}
if last == "WITH" {
return Some(&[("CHECK", "WITH CHECK (<predicate>) -- INSERT/UPDATE check")]);
}
if last == "TO" && !words.contains(&"RENAME") {
return Some(&[
("PUBLIC", "TO PUBLIC -- everyone"),
("CURRENT_USER", "TO CURRENT_USER"),
("SESSION_USER", "TO SESSION_USER"),
]);
}
if words.contains(&"ON") && words.len() >= 5 {
return Some(&[
("RENAME TO", "RENAME TO <new>"),
("TO", "TO <role>[, ...] | PUBLIC"),
("USING", "USING (<predicate>) -- visibility filter"),
("WITH CHECK", "WITH CHECK (<predicate>) -- write check"),
]);
}
if words.len() == 3 {
return Some(&[("ON", "ON <table>")]);
}
None
}
pub(crate) fn alter_domain_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (_, upper) = stmt_slice_upper(source, offset);
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if words.len() < 2 || words[0] != "ALTER" || words[1] != "DOMAIN" {
return None;
}
let last = *words.last()?;
if last == "SET" {
return Some(&[("DEFAULT", "SET DEFAULT <expr>"), ("NOT NULL", "SET NOT NULL"), ("SCHEMA", "SET SCHEMA <schema>")]);
}
if last == "DROP" {
return Some(&[
("DEFAULT", "DROP DEFAULT"),
("NOT NULL", "DROP NOT NULL"),
("CONSTRAINT", "DROP CONSTRAINT [IF EXISTS] <name>"),
]);
}
if last == "RENAME" {
return Some(&[("CONSTRAINT", "RENAME CONSTRAINT <old> TO <new>"), ("TO", "RENAME TO <new_name>")]);
}
if last == "OWNER" {
return Some(&[("TO", "OWNER TO <role>")]);
}
if last == "VALIDATE" {
return Some(&[("CONSTRAINT", "VALIDATE CONSTRAINT <name>")]);
}
if last == "ADD" {
return Some(&[("CONSTRAINT", "ADD CONSTRAINT <name> CHECK (...)"), ("CHECK", "ADD CHECK (VALUE > 0)")]);
}
if words.len() >= 3 {
return Some(&[
("SET DEFAULT", "SET DEFAULT <expr>"),
("DROP DEFAULT", "DROP DEFAULT"),
("SET NOT NULL", "SET NOT NULL"),
("DROP NOT NULL", "DROP NOT NULL"),
("ADD CONSTRAINT", "ADD CONSTRAINT <name> CHECK (...)"),
("DROP CONSTRAINT", "DROP CONSTRAINT [IF EXISTS] <name>"),
("RENAME CONSTRAINT", "RENAME CONSTRAINT <old> TO <new>"),
("RENAME TO", "RENAME TO <new_name>"),
("OWNER TO", "OWNER TO <role>"),
("SET SCHEMA", "SET SCHEMA <schema>"),
("VALIDATE CONSTRAINT", "VALIDATE CONSTRAINT <name>"),
]);
}
None
}
pub(crate) fn alter_materialized_view_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (_, upper) = stmt_slice_upper(source, offset);
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if words.len() < 3 || words[0] != "ALTER" || words[1] != "MATERIALIZED" || words[2] != "VIEW" {
return None;
}
let last = *words.last()?;
if matches!(last, "RENAME" | "OWNER" | "SET" | "RESET" | "CLUSTER" | "DEPENDS" | "ALTER") {
let menu: &[(&str, &str)] = match last {
"RENAME" => &[("TO", "RENAME TO <new>"), ("COLUMN", "RENAME COLUMN <old> TO <new>")],
"OWNER" => &[("TO", "OWNER TO <role>")],
"SET" => &[
("SCHEMA", "SET SCHEMA <schema>"),
("TABLESPACE", "SET TABLESPACE <ts> [NOWAIT]"),
("ACCESS METHOD", "SET ACCESS METHOD <am>"),
("(", "SET ( <param> = <value>[, ...] )"),
("WITHOUT CLUSTER", "SET WITHOUT CLUSTER"),
],
"RESET" => &[("(", "RESET ( <param>[, ...] )")],
"CLUSTER" => &[("ON", "CLUSTER ON <index_name>")],
"DEPENDS" => &[("ON EXTENSION", "DEPENDS ON EXTENSION <ext>")],
"ALTER" => &[
("COLUMN", "ALTER COLUMN <col> SET ..."),
("MATERIALIZED VIEW", "ALTER MATERIALIZED VIEW <name> ALL IN TABLESPACE ..."),
],
_ => &[],
};
if !menu.is_empty() {
return Some(menu);
}
}
if words.len() >= 4 {
return Some(&[
("RENAME TO", "RENAME TO <new>"),
("RENAME COLUMN", "RENAME COLUMN <old> TO <new>"),
("OWNER TO", "OWNER TO <role>"),
("SET SCHEMA", "SET SCHEMA <schema>"),
("SET TABLESPACE", "SET TABLESPACE <ts> [NOWAIT]"),
("SET ACCESS METHOD", "SET ACCESS METHOD <am>"),
("SET", "SET ( <param> = <val>[, ...] ) | SET WITHOUT CLUSTER"),
("RESET", "RESET ( <param>[, ...] )"),
("ALTER COLUMN", "ALTER COLUMN <col> SET STATISTICS|STORAGE|..."),
("CLUSTER ON", "CLUSTER ON <index_name>"),
("DEPENDS ON EXTENSION", "DEPENDS ON EXTENSION <ext>"),
]);
}
None
}
pub(crate) fn alter_event_trigger_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (_, upper) = stmt_slice_upper(source, offset);
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if words.len() < 3 || words[0] != "ALTER" || words[1] != "EVENT" || words[2] != "TRIGGER" {
return None;
}
let last = *words.last()?;
if matches!(last, "RENAME" | "OWNER" | "ENABLE" | "DEPENDS" | "NO") {
let menu: &[(&str, &str)] = match last {
"RENAME" => &[("TO", "RENAME TO <new>")],
"OWNER" => &[("TO", "OWNER TO <role>")],
"ENABLE" => &[
("REPLICA", "ENABLE REPLICA -- fire on the replica role only"),
("ALWAYS", "ENABLE ALWAYS -- fire regardless of session_replication_role"),
],
"DEPENDS" => &[("ON EXTENSION", "DEPENDS ON EXTENSION <ext>")],
"NO" => &[("DEPENDS ON EXTENSION", "NO DEPENDS ON EXTENSION <ext>")],
_ => &[],
};
if !menu.is_empty() {
return Some(menu);
}
}
if words.len() >= 4 {
return Some(&[
("ENABLE", "ENABLE [REPLICA | ALWAYS]"),
("DISABLE", "DISABLE"),
("RENAME TO", "RENAME TO <new>"),
("OWNER TO", "OWNER TO <role>"),
("DEPENDS ON EXTENSION", "DEPENDS ON EXTENSION <ext>"),
("NO DEPENDS ON EXTENSION", "NO DEPENDS ON EXTENSION <ext>"),
]);
}
None
}
pub(crate) fn alter_operator_class_family_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (_, upper) = stmt_slice_upper(source, offset);
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if words.len() < 3 || words[0] != "ALTER" || words[1] != "OPERATOR" {
return None;
}
let kind = words[2];
if !matches!(kind, "CLASS" | "FAMILY") {
return None;
}
let last = *words.last()?;
if matches!(last, "RENAME" | "OWNER" | "SET" | "USING" | "ADD" | "DROP") {
let menu: &[(&str, &str)] = match last {
"RENAME" => &[("TO", "RENAME TO <new>")],
"OWNER" => &[("TO", "OWNER TO <role>")],
"SET" => &[("SCHEMA", "SET SCHEMA <schema>")],
"USING" => &[
("btree", "btree"),
("hash", "hash"),
("gist", "gist"),
("spgist", "spgist"),
("gin", "gin"),
("brin", "brin"),
],
_ => &[],
};
if !menu.is_empty() {
return Some(menu);
}
}
if kind == "FAMILY" && words.contains(&"USING") && words.len() >= 6 {
let last = *words.last()?;
if last == "ADD" {
return Some(&[
("OPERATOR", "ADD OPERATOR <strategy_number> <op>(<types>) FOR ..."),
("FUNCTION", "ADD FUNCTION <support_number> [(<types>)] <fn>(<types>)"),
]);
}
if last == "DROP" {
return Some(&[
("OPERATOR", "DROP OPERATOR <strategy_number> (<types>)"),
("FUNCTION", "DROP FUNCTION <support_number> (<types>)"),
]);
}
return Some(&[
("ADD", "ADD OPERATOR | FUNCTION ..."),
("DROP", "DROP OPERATOR | FUNCTION ..."),
("RENAME TO", "RENAME TO <new>"),
("OWNER TO", "OWNER TO <role>"),
("SET SCHEMA", "SET SCHEMA <schema>"),
]);
}
if words.len() >= 4 {
return Some(&[
("USING", "USING <index_method>"),
("RENAME TO", "RENAME TO <new>"),
("OWNER TO", "OWNER TO <role>"),
("SET SCHEMA", "SET SCHEMA <schema>"),
]);
}
None
}
pub(crate) fn alter_collation_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (_, upper) = stmt_slice_upper(source, offset);
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if words.len() < 2 || words[0] != "ALTER" || words[1] != "COLLATION" {
return None;
}
let last = *words.last()?;
if last == "REFRESH" {
return Some(&[("VERSION", "REFRESH VERSION -- bump after libc/icu upgrade")]);
}
if words.len() >= 3 {
return Some(&[
("RENAME TO", "RENAME TO <new_name>"),
("OWNER TO", "OWNER TO <role>"),
("SET SCHEMA", "SET SCHEMA <schema>"),
("REFRESH VERSION", "REFRESH VERSION -- bump after libc/icu upgrade"),
]);
}
None
}
pub(crate) fn alter_rule_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (_, upper) = stmt_slice_upper(source, offset);
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if words.len() < 2 || words[0] != "ALTER" || words[1] != "RULE" {
return None;
}
let last = *words.last()?;
if last == "RULE" {
return None; }
if last == "ON" {
return None; }
if last == "RENAME" {
return Some(&[("TO", "RENAME TO <new>")]);
}
if words.contains(&"ON") && words.len() >= 5 && !words.contains(&"RENAME") {
return Some(&[("RENAME TO", "RENAME TO <new>")]);
}
if words.len() == 3 && !words.contains(&"ON") {
return Some(&[("ON", "ON <table>")]);
}
None
}
pub(crate) fn alter_trigger_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (_, upper) = stmt_slice_upper(source, offset);
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if words.len() < 2 || words[0] != "ALTER" || words[1] != "TRIGGER" {
return None;
}
let last = *words.last()?;
if last == "TRIGGER" {
return None; }
if last == "ON" {
return None; }
if last == "RENAME" {
return Some(&[("TO", "RENAME TO <new>")]);
}
if last == "DEPENDS" {
return Some(&[("ON EXTENSION", "DEPENDS ON EXTENSION <ext>")]);
}
if last == "NO" {
return Some(&[("DEPENDS ON EXTENSION", "NO DEPENDS ON EXTENSION <ext>")]);
}
if words.contains(&"ON") && words.len() >= 5 {
return Some(&[
("RENAME TO", "RENAME TO <new>"),
("DEPENDS ON EXTENSION", "DEPENDS ON EXTENSION <ext>"),
("NO DEPENDS ON EXTENSION", "NO DEPENDS ON EXTENSION <ext>"),
]);
}
if words.len() == 3 && !words.contains(&"ON") {
return Some(&[("ON", "ON <table>")]);
}
None
}
pub(crate) fn alter_access_method_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (_, upper) = stmt_slice_upper(source, offset);
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if words.len() < 3 || words[0] != "ALTER" || words[1] != "ACCESS" || words[2] != "METHOD" {
return None;
}
let last = *words.last()?;
if matches!(last, "RENAME" | "OWNER") {
return Some(match last {
"RENAME" => &[("TO", "RENAME TO <new>")],
"OWNER" => &[("TO", "OWNER TO <role>")],
_ => &[],
});
}
if words.len() >= 4 {
return Some(&[("RENAME TO", "RENAME TO <new>"), ("OWNER TO", "OWNER TO <role>")]);
}
None
}
pub(crate) fn create_conversion_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (_, upper) = stmt_slice_upper(source, offset);
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
let conv_idx = words.iter().position(|w| *w == "CONVERSION")?;
if !words[..conv_idx].iter().all(|w| matches!(*w, "CREATE" | "DEFAULT")) || words[0] != "CREATE" {
return None;
}
let tail = &words[conv_idx + 1..];
let last = tail.last().copied();
if tail.is_empty() {
return None; }
if last == Some("FOR") {
return None; }
if last == Some("TO") && tail.contains(&"FOR") {
return None; }
if last == Some("FROM") && tail.contains(&"FOR") {
return None; }
if tail.len() == 1 {
return Some(&[("FOR", "FOR '<src_encoding>' TO '<dst_encoding>' FROM <function>")]);
}
if tail.contains(&"FOR") && !tail.contains(&"TO") {
return Some(&[("TO", "TO '<dst_encoding>'")]);
}
if tail.contains(&"TO") && !tail.contains(&"FROM") {
return Some(&[("FROM", "FROM <conversion_function>")]);
}
None
}
pub(crate) fn alter_conversion_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (_, upper) = stmt_slice_upper(source, offset);
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if words.len() < 2 || words[0] != "ALTER" || words[1] != "CONVERSION" {
return None;
}
let last = *words.last()?;
if matches!(last, "RENAME" | "OWNER" | "SET") {
return Some(match last {
"RENAME" => &[("TO", "RENAME TO <new>")],
"OWNER" => &[("TO", "OWNER TO <role>")],
"SET" => &[("SCHEMA", "SET SCHEMA <schema>")],
_ => &[],
});
}
if words.len() >= 3 {
return Some(&[
("RENAME TO", "RENAME TO <new>"),
("OWNER TO", "OWNER TO <role>"),
("SET SCHEMA", "SET SCHEMA <schema>"),
]);
}
None
}
pub(crate) fn create_access_method_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (_, upper) = stmt_slice_upper(source, offset);
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if words.len() < 3 || words[0] != "CREATE" || words[1] != "ACCESS" || words[2] != "METHOD" {
return None;
}
let last = *words.last()?;
if last == "TYPE" {
return Some(&[
("INDEX", "TYPE INDEX -- index access method"),
("TABLE", "TYPE TABLE -- table access method (PG12+)"),
]);
}
if last == "HANDLER" {
return None; }
if words.len() >= 4 && !words.contains(&"TYPE") {
return Some(&[("TYPE", "TYPE {INDEX | TABLE}")]);
}
if words.contains(&"TYPE") && !words.contains(&"HANDLER") {
return Some(&[("HANDLER", "HANDLER <function> -- AM entrypoint")]);
}
None
}
pub(crate) fn create_view_post_name_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (slice_owned, upper) = stmt_slice_upper(source, offset);
let slice = slice_owned.as_str();
let trimmed = upper.trim_start();
let is_view = trimmed.starts_with("CREATE VIEW")
|| trimmed.starts_with("CREATE OR REPLACE VIEW")
|| trimmed.starts_with("CREATE TEMP VIEW")
|| trimmed.starts_with("CREATE TEMPORARY VIEW");
let is_mv = trimmed.starts_with("CREATE MATERIALIZED VIEW");
if !is_view && !is_mv {
return None;
}
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if words.contains(&"AS") {
let last = *words.last()?;
if last == "WITH" {
if is_view {
return Some(&[
("CHECK OPTION", "WITH CHECK OPTION -- enforce predicate on writes"),
("CASCADED CHECK OPTION", "WITH CASCADED CHECK OPTION -- + parent views"),
("LOCAL CHECK OPTION", "WITH LOCAL CHECK OPTION -- this view only"),
]);
}
if is_mv {
return Some(&[
("DATA", "WITH DATA -- populate now (default)"),
("NO DATA", "WITH NO DATA -- create empty; populate later with REFRESH"),
]);
}
}
if last == "NO" && words.contains(&"WITH") && is_mv {
return Some(&[("DATA", "NO DATA -- mark MV invalid")]);
}
if matches!(last, "CASCADED" | "LOCAL") && is_view {
return Some(&[("CHECK OPTION", "CHECK OPTION -- enforce predicate on writes")]);
}
return None;
}
let opens = slice.matches('(').count();
let closes = slice.matches(')').count();
let paren_balanced = opens == 0 || opens == closes;
let last = *words.last()?;
if last == "USING" && is_mv {
return Some(&[("heap", "USING heap -- default access method")]);
}
if last == "WITH" {
if is_mv {
return Some(&[("(", "WITH ( fillfactor = <n>, autovacuum_<param> = <v>, ... )")]);
}
return Some(&[(
"(",
"WITH ( security_barrier = true|false, security_invoker = true|false, check_option = local|cascaded )",
)]);
}
if last == "TABLESPACE" && is_mv {
return None; }
if paren_balanced && words.len() >= 3 {
let mut menu: Vec<(&str, &str)> = Vec::with_capacity(6);
if is_mv {
menu.push(("USING", "USING <access_method> -- PG12+"));
menu.push(("WITH", "WITH ( fillfactor = ..., autovacuum_<param> = ..., ... )"));
menu.push(("TABLESPACE", "TABLESPACE <name>"));
menu.push(("AS", "AS <select_statement>"));
} else {
menu.push(("WITH", "WITH ( security_barrier|security_invoker|check_option )"));
menu.push(("AS", "AS <select_statement>"));
}
if is_mv {
return Some(&[
("USING", "USING <access_method> -- PG12+"),
("WITH", "WITH ( fillfactor = ..., autovacuum_<param> = ..., ... )"),
("TABLESPACE", "TABLESPACE <name>"),
("AS", "AS <select_statement>"),
]);
}
return Some(&[
("WITH", "WITH ( security_barrier | security_invoker | check_option )"),
("AS", "AS <select_statement>"),
]);
}
None
}
pub(crate) fn alter_operator_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (slice_owned, upper) = stmt_slice_upper(source, offset);
let slice = slice_owned.as_str();
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if words.len() < 2 || words[0] != "ALTER" || words[1] != "OPERATOR" {
return None;
}
let last = *words.last()?;
if last == "OWNER" {
return Some(&[("TO", "OWNER TO <role>")]);
}
if last == "SET" {
return Some(&[("SCHEMA", "SET SCHEMA <schema>"), ("(", "SET ( RESTRICT = <fn>, JOIN = <fn> )")]);
}
let opens = slice.matches('(').count();
let closes = slice.matches(')').count();
if opens > 0 && opens == closes {
return Some(&[
("OWNER TO", "OWNER TO <role>"),
("SET SCHEMA", "SET SCHEMA <schema>"),
("SET", "SET ( RESTRICT = <fn>, JOIN = <fn> )"),
]);
}
None
}
pub(crate) fn alter_aggregate_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (slice_owned, upper) = stmt_slice_upper(source, offset);
let slice = slice_owned.as_str();
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if words.len() < 2 || words[0] != "ALTER" || words[1] != "AGGREGATE" {
return None;
}
let opens = slice.matches('(').count();
let closes = slice.matches(')').count();
if opens > 0 && opens == closes {
return Some(&[
("RENAME TO", "RENAME TO <new_name>"),
("OWNER TO", "OWNER TO <role>"),
("SET SCHEMA", "SET SCHEMA <schema>"),
]);
}
let last = *words.last()?;
if last == "RENAME" {
return Some(&[("TO", "RENAME TO <new_name>")]);
}
if last == "OWNER" {
return Some(&[("TO", "OWNER TO <role>")]);
}
if last == "SET" {
return Some(&[("SCHEMA", "SET SCHEMA <schema>")]);
}
None
}
pub(crate) fn alter_publication_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (_, upper) = stmt_slice_upper(source, offset);
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if words.len() < 2 || words[0] != "ALTER" || words[1] != "PUBLICATION" {
return None;
}
let last = *words.last()?;
if matches!(last, "ADD" | "SET" | "DROP") {
let menu: &[(&str, &str)] = match last {
"ADD" => &[("TABLE", "ADD TABLE <tbl>[, ...]"), ("TABLES IN SCHEMA", "ADD TABLES IN SCHEMA <schema>[, ...]")],
"SET" => &[
("TABLE", "SET TABLE <tbl>[, ...] -- replace the table list"),
("TABLES IN SCHEMA", "SET TABLES IN SCHEMA <schema>[, ...]"),
("(", "SET (publish = 'insert, ...')"),
],
"DROP" => &[("TABLE", "DROP TABLE <tbl>[, ...]"), ("TABLES IN SCHEMA", "DROP TABLES IN SCHEMA <schema>[, ...]")],
_ => &[],
};
if !menu.is_empty() {
return Some(menu);
}
}
if last == "RENAME" {
return Some(&[("TO", "RENAME TO <new_name>")]);
}
if last == "OWNER" {
return Some(&[("TO", "OWNER TO <role>")]);
}
if last == "IN" && words.contains(&"TABLES") {
return Some(&[("SCHEMA", "TABLES IN SCHEMA <schema>[, ...]")]);
}
if last == "TABLES" && (words.contains(&"ADD") || words.contains(&"SET") || words.contains(&"DROP")) {
return Some(&[("IN SCHEMA", "TABLES IN SCHEMA <schema>[, ...]")]);
}
if words.len() >= 3 {
return Some(&[
("ADD", "ADD TABLE / TABLES IN SCHEMA ..."),
("SET", "SET TABLE / TABLES IN SCHEMA / (...) ..."),
("DROP", "DROP TABLE / TABLES IN SCHEMA ..."),
("RENAME TO", "RENAME TO <new_name>"),
("OWNER TO", "OWNER TO <role>"),
]);
}
None
}
pub(crate) fn alter_subscription_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (_, upper) = stmt_slice_upper(source, offset);
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if words.len() < 2 || words[0] != "ALTER" || words[1] != "SUBSCRIPTION" {
return None;
}
let last = *words.last()?;
if matches!(last, "RENAME" | "OWNER") {
let menu: &[(&str, &str)] = match last {
"RENAME" => &[("TO", "RENAME TO <new_name>")],
"OWNER" => &[("TO", "OWNER TO <role>")],
_ => &[],
};
if !menu.is_empty() {
return Some(menu);
}
}
if last == "SET" {
return Some(&[
("PUBLICATION", "SET PUBLICATION <pub>[, ...]"),
("(", "( slot_name=..., synchronous_commit=..., binary=..., disable_on_error=... )"),
]);
}
if last == "ADD" {
return Some(&[("PUBLICATION", "ADD PUBLICATION <pub>[, ...]")]);
}
if last == "DROP" {
return Some(&[("PUBLICATION", "DROP PUBLICATION <pub>[, ...]")]);
}
if last == "REFRESH" {
return Some(&[("PUBLICATION", "REFRESH PUBLICATION [WITH (copy_data = true|false)]")]);
}
if last == "SKIP" {
return Some(&[("(", "SKIP ( lsn = '0/0' )")]);
}
if words.len() >= 3 {
return Some(&[
("CONNECTION", "CONNECTION '<conn_string>'"),
("SET PUBLICATION", "SET PUBLICATION <pub>[, ...]"),
("ADD PUBLICATION", "ADD PUBLICATION <pub>[, ...]"),
("DROP PUBLICATION", "DROP PUBLICATION <pub>[, ...]"),
("REFRESH PUBLICATION", "REFRESH PUBLICATION [WITH (copy_data = true|false)]"),
("ENABLE", "ENABLE"),
("DISABLE", "DISABLE"),
("SET", "SET (slot_name = ..., ...)"),
("RENAME TO", "RENAME TO <new_name>"),
("OWNER TO", "OWNER TO <role>"),
("SKIP", "SKIP ( lsn = '0/0' )"),
]);
}
None
}
pub(crate) fn alter_database_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (_, upper) = stmt_slice_upper(source, offset);
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if words.len() < 2 || words[0] != "ALTER" || words[1] != "DATABASE" {
return None;
}
let last = *words.last()?;
if matches!(last, "RENAME" | "OWNER" | "SET" | "RESET") {
let menu: &[(&str, &str)] = match last {
"RENAME" => &[("TO", "RENAME TO <new_name>")],
"OWNER" => &[("TO", "OWNER TO <role>")],
"SET" => {
&[("TABLESPACE", "SET TABLESPACE <tablespace>"), ("ALL", "RESET ALL -- restore every database GUC default")]
},
"RESET" => &[("ALL", "RESET ALL")],
_ => &[],
};
if !menu.is_empty() {
return Some(menu);
}
}
if last == "REFRESH" {
return Some(&[("COLLATION VERSION", "REFRESH COLLATION VERSION -- record current collversion (PG15+)")]);
}
if last == "WITH" {
return Some(&[
("ALLOW_CONNECTIONS", "ALLOW_CONNECTIONS true|false"),
("CONNECTION LIMIT", "CONNECTION LIMIT <n>"),
("IS_TEMPLATE", "IS_TEMPLATE true|false"),
]);
}
if last == "CONNECTION" {
return Some(&[("LIMIT", "CONNECTION LIMIT <n>")]);
}
if matches!(last, "ALLOW_CONNECTIONS" | "IS_TEMPLATE") {
return Some(&[("true", "true"), ("false", "false")]);
}
if words.len() >= 3 {
return Some(&[
("RENAME TO", "RENAME TO <new_name>"),
("OWNER TO", "OWNER TO <role>"),
("SET TABLESPACE", "SET TABLESPACE <tablespace>"),
("SET", "SET <param> = <val>"),
("RESET", "RESET <param> | RESET ALL"),
("WITH", "WITH ALLOW_CONNECTIONS|CONNECTION LIMIT|IS_TEMPLATE ..."),
("REFRESH COLLATION VERSION", "REFRESH COLLATION VERSION -- PG15+"),
("ALLOW_CONNECTIONS", "ALLOW_CONNECTIONS true|false (shorthand without WITH)"),
("CONNECTION LIMIT", "CONNECTION LIMIT <n>"),
("IS_TEMPLATE", "IS_TEMPLATE true|false"),
]);
}
None
}
pub(crate) fn alter_tablespace_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (_, upper) = stmt_slice_upper(source, offset);
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if words.len() < 2 || words[0] != "ALTER" || words[1] != "TABLESPACE" {
return None;
}
let last = *words.last()?;
if matches!(last, "RENAME" | "OWNER" | "SET" | "RESET") {
let menu: &[(&str, &str)] = match last {
"RENAME" => &[("TO", "RENAME TO <new_name>")],
"OWNER" => &[("TO", "OWNER TO <role>")],
"SET" => &[("(", "SET ( seq_page_cost = <n>, random_page_cost = <n>, effective_io_concurrency = <n> )")],
"RESET" => &[("(", "RESET ( <param>[, ...] )")],
_ => &[],
};
if !menu.is_empty() {
return Some(menu);
}
}
if words.len() >= 3 {
return Some(&[
("RENAME TO", "RENAME TO <new_name>"),
("OWNER TO", "OWNER TO <role>"),
("SET", "SET ( seq_page_cost = <n>, random_page_cost = <n>, effective_io_concurrency = <n> )"),
("RESET", "RESET ( <param>[, ...] )"),
]);
}
None
}
pub(crate) fn create_user_mapping_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (_, upper) = stmt_slice_upper(source, offset);
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if words.len() < 3 || words[0] != "CREATE" || words[1] != "USER" || words[2] != "MAPPING" {
return None;
}
let last = *words.last()?;
if last == "MAPPING" {
return Some(&[
("FOR", "FOR <role> SERVER <name> [OPTIONS (...)]"),
("IF NOT EXISTS", "IF NOT EXISTS -- skip silently when present"),
]);
}
if last == "FOR" {
return Some(&[
("CURRENT_USER", "FOR CURRENT_USER -- current session role"),
("CURRENT_ROLE", "FOR CURRENT_ROLE -- synonym"),
("PUBLIC", "FOR PUBLIC -- everyone (default fallback)"),
("USER", "FOR USER -- alias of CURRENT_USER"),
]);
}
if last == "SERVER" {
return None; }
if last == "OPTIONS" {
return Some(&[("(", "( <option_name> '<value>'[, ...] )")]);
}
if !words.contains(&"SERVER")
&& (words.contains(&"CURRENT_USER")
|| words.contains(&"CURRENT_ROLE")
|| words.contains(&"PUBLIC")
|| words.contains(&"USER")
|| words.len() >= 5)
{
return Some(&[("SERVER", "SERVER <name>")]);
}
if words.contains(&"SERVER") && !words.contains(&"OPTIONS") {
return Some(&[("OPTIONS", "OPTIONS (<key> '<val>'[, ...])")]);
}
None
}
pub(crate) fn alter_user_mapping_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (slice_owned, upper) = stmt_slice_upper(source, offset);
let slice = slice_owned.as_str();
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if words.len() < 3 || words[0] != "ALTER" || words[1] != "USER" || words[2] != "MAPPING" {
return None;
}
let last = *words.last()?;
if last == "MAPPING" {
return Some(&[("FOR", "FOR <role> SERVER <name> OPTIONS (...)")]);
}
if last == "FOR" {
return Some(&[
("CURRENT_USER", "FOR CURRENT_USER"),
("CURRENT_ROLE", "FOR CURRENT_ROLE"),
("PUBLIC", "FOR PUBLIC"),
("USER", "FOR USER"),
]);
}
if last == "SERVER" {
return None;
}
if last == "OPTIONS" {
return Some(&[("(", "( ADD|SET|DROP <k> '<v>'[, ...] )")]);
}
let opens = slice.matches('(').count();
let closes = slice.matches(')').count();
if opens > closes {
let trimmed = slice.trim_end();
let last_char = trimmed.chars().last();
if matches!(last_char, Some('(') | Some(',')) || slice.ends_with(char::is_whitespace) {
return Some(&[("ADD", "ADD <key> '<value>'"), ("SET", "SET <key> '<value>'"), ("DROP", "DROP <key>")]);
}
}
if words.contains(&"SERVER") && !words.contains(&"OPTIONS") {
return Some(&[("OPTIONS", "OPTIONS (<key> '<val>'[, ...])")]);
}
if !words.contains(&"SERVER")
&& (words.contains(&"CURRENT_USER")
|| words.contains(&"CURRENT_ROLE")
|| words.contains(&"PUBLIC")
|| words.contains(&"USER")
|| words.len() >= 5)
{
return Some(&[("SERVER", "SERVER <name>")]);
}
None
}
pub(crate) fn alter_schema_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (_, upper) = stmt_slice_upper(source, offset);
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if words.len() < 2 || words[0] != "ALTER" || words[1] != "SCHEMA" {
return None;
}
if words.len() >= 3 {
return Some(&[("RENAME TO", "RENAME TO <new_name>"), ("OWNER TO", "OWNER TO <role>")]);
}
None
}
pub(crate) fn create_text_search_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
let pos: usize = (u32::from(offset) as usize).min(source.len());
let bytes = source.as_bytes();
if pos < bytes.len() && !bytes[pos].is_ascii_whitespace() && bytes[pos] != b'(' && bytes[pos] != b',' {
return None;
}
let (slice_owned, upper) = stmt_slice_upper(source, offset);
let slice = slice_owned.as_str();
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if words.len() < 3 || words[0] != "CREATE" || words[1] != "TEXT" || words[2] != "SEARCH" {
return None;
}
if words.len() < 4 {
return Some(&[
("CONFIGURATION", "CREATE TEXT SEARCH CONFIGURATION <name> ( PARSER = ... )"),
("DICTIONARY", "CREATE TEXT SEARCH DICTIONARY <name> ( TEMPLATE = ... )"),
("PARSER", "CREATE TEXT SEARCH PARSER <name> ( START = ..., GETTOKEN = ..., END = ..., LEXTYPES = ... )"),
("TEMPLATE", "CREATE TEXT SEARCH TEMPLATE <name> ( INIT = ..., LEXIZE = ... )"),
]);
}
let kind = words[3];
let opens = slice.matches('(').count();
let closes = slice.matches(')').count();
if opens > closes {
let trimmed = slice.trim_end();
let last_char = trimmed.chars().last();
if !matches!(last_char, Some('(') | Some(',')) && !slice.ends_with(char::is_whitespace) {
return None;
}
return Some(match kind {
"CONFIGURATION" => &[("PARSER", "PARSER = <parser>"), ("COPY", "COPY = <existing_config>")],
"DICTIONARY" => &[("TEMPLATE", "TEMPLATE = <template>")],
"PARSER" => &[
("START", "START = <function>"),
("GETTOKEN", "GETTOKEN = <function>"),
("END", "END = <function>"),
("LEXTYPES", "LEXTYPES = <function>"),
("HEADLINE", "HEADLINE = <function>"),
],
"TEMPLATE" => &[("INIT", "INIT = <function>"), ("LEXIZE", "LEXIZE = <function>")],
_ => &[],
});
}
None
}
pub(crate) fn create_extension_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (_, upper) = stmt_slice_upper(source, offset);
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if words.len() < 2 || words[0] != "CREATE" || words[1] != "EXTENSION" {
return None;
}
let last = *words.last()?;
if matches!(last, "SCHEMA" | "VERSION") {
return None; }
if last == "WITH" {
return Some(&[
("SCHEMA", "WITH SCHEMA <schema>"),
("VERSION", "WITH VERSION '<ver>'"),
("CASCADE", "WITH CASCADE -- auto-install required extensions"),
]);
}
if words.len() >= 3 {
return Some(&[
("WITH", "WITH SCHEMA / VERSION / CASCADE clarifier"),
("SCHEMA", "SCHEMA <schema>"),
("VERSION", "VERSION '<ver>'"),
("CASCADE", "CASCADE -- auto-install required extensions"),
]);
}
None
}
pub(crate) fn create_function_attribute_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (_, upper) = stmt_slice_upper(source, offset);
let trimmed = upper.trim_start();
let is_fn = trimmed.starts_with("CREATE FUNCTION") || trimmed.starts_with("CREATE OR REPLACE FUNCTION");
let is_proc = trimmed.starts_with("CREATE PROCEDURE") || trimmed.starts_with("CREATE OR REPLACE PROCEDURE");
if !is_fn && !is_proc {
return None;
}
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
let last = *words.last()?;
let dq = upper.matches("$$").count();
if dq > 0 && dq % 2 == 1 {
return None;
}
if last == "LANGUAGE" {
return Some(&[
("plpgsql", "plpgsql -- procedural Postgres"),
("sql", "sql -- pure-SQL function body"),
("c", "c -- C extension"),
("plpython3u", "plpython3u -- Python 3 (untrusted)"),
("plperl", "plperl -- Perl"),
("pltcl", "pltcl -- Tcl"),
]);
}
if last == "SECURITY" {
return Some(&[
("DEFINER", "SECURITY DEFINER -- run with definer's privileges"),
("INVOKER", "SECURITY INVOKER -- run with caller's privileges (default)"),
]);
}
if last == "PARALLEL" {
return Some(&[
("SAFE", "PARALLEL SAFE -- safe for parallel workers"),
("RESTRICTED", "PARALLEL RESTRICTED -- leader only"),
("UNSAFE", "PARALLEL UNSAFE -- forbid parallel (default)"),
]);
}
if upper.rfind("RETURNS").map(|p| upper[p + "RETURNS".len()..].trim().is_empty()).unwrap_or(false) {
return None;
}
let opens = upper.matches('(').count();
let closes = upper.matches(')').count();
let paren_balanced = opens > 0 && opens == closes;
let has_returns = upper.contains("RETURNS");
if is_proc && !paren_balanced {
return None;
}
if is_fn && !has_returns {
return None;
}
if is_fn && let Some(p) = upper.rfind("RETURNS") {
let after = upper[p + "RETURNS".len()..].trim();
if after.is_empty() {
return None;
}
if after.split_ascii_whitespace().next().is_none_or(|t| t.is_empty()) {
return None;
}
}
if last == "AS" {
return None;
}
Some(&[
("LANGUAGE", "LANGUAGE plpgsql|sql|c|plpythonu|... -- pick body language"),
("AS", "AS $$ <body> $$ -- function body"),
("COST", "COST <n> -- per-row execution cost hint"),
("ROWS", "ROWS <n> -- estimated set-returning row count"),
("VOLATILE", "VOLATILE (default) -- result may change across calls"),
("STABLE", "STABLE -- same result within a single statement"),
("IMMUTABLE", "IMMUTABLE -- same args always yield the same result"),
("STRICT", "STRICT -- skip body when any arg is NULL (synonym of RETURNS NULL ON NULL INPUT)"),
("CALLED ON NULL INPUT", "CALLED ON NULL INPUT (default)"),
("RETURNS NULL ON NULL INPUT", "RETURNS NULL ON NULL INPUT (synonym of STRICT)"),
("LEAKPROOF", "LEAKPROOF -- doesn't leak side-info; required for some RLS views"),
("SECURITY DEFINER", "SECURITY DEFINER -- run as the role that defined the fn"),
("SECURITY INVOKER", "SECURITY INVOKER (default)"),
("PARALLEL", "PARALLEL SAFE | RESTRICTED | UNSAFE"),
("WINDOW", "WINDOW -- mark this fn as a window fn (C only)"),
("SET", "SET <param> [TO|=] <value> -- per-call GUC override"),
("SUPPORT", "SUPPORT <fn> -- planner-support function (C only)"),
("TRANSFORM", "TRANSFORM FOR TYPE <type> -- attach a TRANSFORM"),
("DEPENDS ON EXTENSION", "DEPENDS ON EXTENSION <ext>"),
])
}
pub(crate) fn alter_function_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (_, upper) = stmt_slice_upper(source, offset);
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if words.len() < 2 || words[0] != "ALTER" || !matches!(words[1], "FUNCTION" | "PROCEDURE" | "ROUTINE") {
return None;
}
let last = *words.last()?;
if matches!(last, "RENAME" | "OWNER" | "SET" | "RESET" | "DEPENDS" | "PARALLEL" | "SECURITY" | "LANGUAGE" | "SUPPORT")
{
let menu: &[(&str, &str)] = match last {
"RENAME" => &[("TO", "RENAME TO <new_name>")],
"OWNER" => &[("TO", "OWNER TO <role>")],
"SET" => {
&[("SCHEMA", "SET SCHEMA <schema>"), ("ROLE", "SET ROLE <role>"), ("SEARCH_PATH", "SET search_path = '...'")]
},
"RESET" => &[("ALL", "RESET ALL -- restore all session GUCs")],
"DEPENDS" => &[("ON EXTENSION", "DEPENDS ON EXTENSION <ext>")],
"PARALLEL" => &[
("SAFE", "PARALLEL SAFE -- usable inside parallel workers"),
("RESTRICTED", "PARALLEL RESTRICTED -- only the leader runs it"),
("UNSAFE", "PARALLEL UNSAFE -- forces a non-parallel plan"),
],
"SECURITY" => &[
("DEFINER", "SECURITY DEFINER -- runs with the function owner's rights"),
("INVOKER", "SECURITY INVOKER -- runs with the caller's rights (default)"),
],
"LANGUAGE" => &[
("sql", "LANGUAGE sql -- pure SQL function body"),
("plpgsql", "LANGUAGE plpgsql -- PL/pgSQL function body"),
("c", "LANGUAGE c -- C-language function (requires AS '<obj>')"),
("plpython3u", "LANGUAGE plpython3u -- PL/Python (untrusted)"),
("plperl", "LANGUAGE plperl -- PL/Perl (trusted)"),
("plperlu", "LANGUAGE plperlu -- PL/Perl (untrusted)"),
("pltcl", "LANGUAGE pltcl -- PL/Tcl"),
("internal", "LANGUAGE internal -- bound to a builtin symbol"),
],
"SUPPORT" => &[("support_fn", "SUPPORT <support_fn_name> -- planner support function (advanced)")],
_ => &[],
};
if !menu.is_empty() {
return Some(menu);
}
}
let opens = upper.matches('(').count();
let closes = upper.matches(')').count();
if opens > 0 && opens == closes {
return Some(&[
("RENAME TO", "RENAME TO <new_name>"),
("OWNER TO", "OWNER TO <role>"),
("SET SCHEMA", "SET SCHEMA <schema>"),
("COST", "COST <n>"),
("ROWS", "ROWS <n>"),
("VOLATILE", "VOLATILE / STABLE / IMMUTABLE"),
("STABLE", "STABLE"),
("IMMUTABLE", "IMMUTABLE"),
("STRICT", "STRICT / RETURNS NULL ON NULL INPUT"),
("LEAKPROOF", "LEAKPROOF"),
("SECURITY DEFINER", "SECURITY DEFINER"),
("SECURITY INVOKER", "SECURITY INVOKER"),
("PARALLEL", "PARALLEL SAFE | RESTRICTED | UNSAFE"),
("DEPENDS ON EXTENSION", "DEPENDS ON EXTENSION <ext>"),
]);
}
None
}
pub(crate) fn alter_statistics_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (_, upper) = stmt_slice_upper(source, offset);
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if words.len() < 2 || words[0] != "ALTER" || words[1] != "STATISTICS" {
return None;
}
let last = *words.last()?;
if matches!(last, "RENAME" | "OWNER" | "SET") {
let menu: &[(&str, &str)] = match last {
"RENAME" => &[("TO", "RENAME TO <new>")],
"OWNER" => &[("TO", "OWNER TO <role>")],
"SET" => {
&[("SCHEMA", "SET SCHEMA <schema>"), ("STATISTICS", "SET STATISTICS <n> -- per-extended-stats target (PG13+)")]
},
_ => &[],
};
if !menu.is_empty() {
return Some(menu);
}
}
if words.len() >= 3 {
return Some(&[
("RENAME TO", "RENAME TO <new>"),
("OWNER TO", "OWNER TO <role>"),
("SET SCHEMA", "SET SCHEMA <schema>"),
("SET STATISTICS", "SET STATISTICS <n> -- PG13+"),
]);
}
None
}
pub(crate) fn alter_view_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (_, upper) = stmt_slice_upper(source, offset);
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if words.len() < 2 || words[0] != "ALTER" || words[1] != "VIEW" {
return None;
}
let last = *words.last()?;
if matches!(last, "RENAME" | "OWNER" | "SET" | "RESET" | "ALTER") {
let menu: &[(&str, &str)] = match last {
"RENAME" => &[("TO", "RENAME TO <new_name>"), ("COLUMN", "RENAME COLUMN <old> TO <new>")],
"OWNER" => &[("TO", "OWNER TO <role>")],
"SET" => &[("SCHEMA", "SET SCHEMA <schema>"), ("(", "SET ( <storage_param> = <value> )")],
"RESET" => &[("(", "RESET ( <storage_param> )")],
"ALTER" => &[("COLUMN", "ALTER COLUMN <name> SET DEFAULT <expr>")],
_ => &[],
};
if !menu.is_empty() {
return Some(menu);
}
}
if words.len() >= 3 && !matches!(last, "RENAME" | "OWNER" | "SET" | "RESET" | "ALTER") {
return Some(&[
("RENAME TO", "RENAME TO <new_name>"),
("RENAME COLUMN", "RENAME COLUMN <old> TO <new>"),
("OWNER TO", "OWNER TO <role>"),
("SET SCHEMA", "SET SCHEMA <schema>"),
("SET (", "SET ( security_barrier = true, ... )"),
("RESET (", "RESET ( <param> )"),
("ALTER COLUMN", "ALTER COLUMN <name> SET DEFAULT <expr>"),
]);
}
None
}
pub(crate) fn create_database_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (_, upper) = stmt_slice_upper(source, offset);
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if words.len() < 2 || words[0] != "CREATE" || words[1] != "DATABASE" {
return None;
}
let last = *words.last()?;
if matches!(
last,
"OWNER"
| "TEMPLATE"
| "ENCODING"
| "LOCALE"
| "LC_COLLATE"
| "LC_CTYPE"
| "ICU_LOCALE"
| "ICU_RULES"
| "COLLATION_VERSION"
| "BUILTIN_LOCALE"
| "TABLESPACE"
| "OID"
) {
return None;
}
if last == "LIMIT" && words.contains(&"CONNECTION") {
return None; }
if last == "WITH" {
}
if last == "LOCALE_PROVIDER" {
return Some(&[
("libc", "LOCALE_PROVIDER libc -- default; OS-supplied collation"),
("icu", "LOCALE_PROVIDER icu -- ICU library collation"),
("builtin", "LOCALE_PROVIDER builtin -- PG16+ built-in basic locales"),
]);
}
if last == "ALLOW_CONNECTIONS" || last == "IS_TEMPLATE" {
return Some(&[("true", "true"), ("false", "false")]);
}
if last == "STRATEGY" {
return Some(&[
("wal_log", "wal_log -- default; copy via WAL records (safe for replicas)"),
("file_copy", "file_copy -- copy template files directly (faster, but bypasses WAL)"),
]);
}
if last == "CONNECTION" {
return Some(&[("LIMIT", "CONNECTION LIMIT <n> -- per-database parallel-session cap")]);
}
if words.len() >= 3 {
return Some(&[
("WITH", "WITH <options> -- noise word (optional)"),
("OWNER", "OWNER = <role>"),
("TEMPLATE", "TEMPLATE = <existing_db>"),
("ENCODING", "ENCODING = '<charset>'"),
("LOCALE", "LOCALE = '<locale>' -- shorthand for LC_COLLATE + LC_CTYPE"),
("LC_COLLATE", "LC_COLLATE = '<locale>'"),
("LC_CTYPE", "LC_CTYPE = '<locale>'"),
("LOCALE_PROVIDER", "LOCALE_PROVIDER libc | icu | builtin"),
("ICU_LOCALE", "ICU_LOCALE = '<icu_locale>'"),
("ICU_RULES", "ICU_RULES = '<icu_rule_string>' -- PG16+"),
("BUILTIN_LOCALE", "BUILTIN_LOCALE = 'C' | 'C.UTF-8' -- PG17+"),
("COLLATION_VERSION", "COLLATION_VERSION = '<v>' -- set the collation-version sentinel"),
("TABLESPACE", "TABLESPACE = <tablespace>"),
("ALLOW_CONNECTIONS", "ALLOW_CONNECTIONS true|false"),
("CONNECTION LIMIT", "CONNECTION LIMIT <n>"),
("IS_TEMPLATE", "IS_TEMPLATE true|false"),
("OID", "OID = <n> -- mostly internal; pg_upgrade uses it"),
("STRATEGY", "STRATEGY wal_log | file_copy"),
]);
}
None
}
pub(crate) fn create_tablespace_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (_, upper) = stmt_slice_upper(source, offset);
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if words.len() < 2 || words[0] != "CREATE" || words[1] != "TABLESPACE" {
return None;
}
let last = *words.last()?;
if last == "OWNER" {
return None; }
if last == "LOCATION" {
return None; }
if words.len() >= 3 && !words.contains(&"LOCATION") {
return Some(&[("OWNER", "OWNER <role>"), ("LOCATION", "LOCATION '<directory_path>' -- required")]);
}
if words.contains(&"LOCATION") && !words.contains(&"WITH") {
return Some(&[("WITH", "WITH ( <param> = <value>, ... )")]);
}
None
}
pub(crate) fn create_aggregate_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
let pos: usize = (u32::from(offset) as usize).min(source.len());
let bytes = source.as_bytes();
if pos < bytes.len() && !bytes[pos].is_ascii_whitespace() && bytes[pos] != b'(' && bytes[pos] != b',' {
return None;
}
let (slice_owned, upper) = stmt_slice_upper(source, offset);
let slice = slice_owned.as_str();
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if words.len() < 2 || words[0] != "CREATE" || words[1] != "AGGREGATE" {
return None;
}
let opens = slice.matches('(').count();
let closes = slice.matches(')').count();
if opens < 2 || opens - closes != 1 {
return None;
}
let trimmed = slice.trim_end();
let last_char = trimmed.chars().last();
if !matches!(last_char, Some('(') | Some(',')) && !slice.ends_with(char::is_whitespace) {
return None;
}
Some(&[
("SFUNC", "SFUNC = <transition_fn> -- required"),
("STYPE", "STYPE = <state_type> -- required"),
("SSPACE", "SSPACE = <avg_state_bytes>"),
("FINALFUNC", "FINALFUNC = <final_fn>"),
("FINALFUNC_EXTRA", "FINALFUNC_EXTRA -- pass extra args to FINALFUNC"),
("FINALFUNC_MODIFY", "FINALFUNC_MODIFY = READ_ONLY | SHAREABLE | READ_WRITE"),
("COMBINEFUNC", "COMBINEFUNC = <merge_fn> -- enables parallel aggregation"),
("SERIALFUNC", "SERIALFUNC = <serialize_fn>"),
("DESERIALFUNC", "DESERIALFUNC = <deserialize_fn>"),
("INITCOND", "INITCOND = '<state_initial>'"),
("MSFUNC", "MSFUNC = <moving_state_fn>"),
("MINVFUNC", "MINVFUNC = <inverse_state_fn>"),
("MSTYPE", "MSTYPE = <moving_state_type>"),
("MSSPACE", "MSSPACE = <avg_bytes>"),
("MFINALFUNC", "MFINALFUNC = <final_fn>"),
("MFINALFUNC_EXTRA", "MFINALFUNC_EXTRA"),
("MFINALFUNC_MODIFY", "MFINALFUNC_MODIFY = ..."),
("MINITCOND", "MINITCOND = '<state_initial>'"),
("SORTOP", "SORTOP = <operator>"),
("PARALLEL", "PARALLEL = SAFE | RESTRICTED | UNSAFE"),
("HYPOTHETICAL", "HYPOTHETICAL -- ordered-set hypothetical aggregate"),
])
}
pub(crate) fn create_cast_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (_, upper) = stmt_slice_upper(source, offset);
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if words.len() < 2 || words[0] != "CREATE" || words[1] != "CAST" {
return None;
}
let last = *words.last()?;
if last == "WITH" {
return Some(&[
("FUNCTION", "WITH FUNCTION <fn>(args) -- use this function"),
("INOUT", "WITH INOUT -- use IO conversion"),
]);
}
if last == "WITHOUT" {
return Some(&[("FUNCTION", "WITHOUT FUNCTION -- binary-compatible cast")]);
}
if last == "AS" {
return Some(&[
("ASSIGNMENT", "AS ASSIGNMENT -- automatic in assignments"),
("IMPLICIT", "AS IMPLICIT -- automatic everywhere"),
]);
}
let closes = upper.matches(')').count();
let opens = upper.matches('(').count();
if opens > 0 && closes == opens && !words.contains(&"WITH") && !words.contains(&"WITHOUT") {
return Some(&[
("WITH FUNCTION", "WITH FUNCTION <fn>(args)"),
("WITHOUT FUNCTION", "WITHOUT FUNCTION -- binary-compatible"),
("WITH INOUT", "WITH INOUT -- IO conversion"),
]);
}
if (words.contains(&"WITH") || words.contains(&"WITHOUT")) && !words.contains(&"AS") {
return Some(&[
("AS ASSIGNMENT", "AS ASSIGNMENT -- automatic in assignments"),
("AS IMPLICIT", "AS IMPLICIT -- automatic everywhere"),
]);
}
None
}
pub(crate) fn create_rule_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (_, upper) = stmt_slice_upper(source, offset);
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
let rule_idx = words.iter().position(|w| *w == "RULE")?;
if !words[..rule_idx].iter().all(|w| matches!(*w, "CREATE" | "OR" | "REPLACE")) || words[0] != "CREATE" {
return None;
}
let tail = &words[rule_idx + 1..];
if tail.is_empty() {
return None;
}
let last = *tail.last()?;
if last == "AS" {
return Some(&[("ON", "AS ON {SELECT | INSERT | UPDATE | DELETE}")]);
}
if last == "ON" {
return Some(&[("SELECT", "ON SELECT"), ("INSERT", "ON INSERT"), ("UPDATE", "ON UPDATE"), ("DELETE", "ON DELETE")]);
}
if matches!(last, "SELECT" | "INSERT" | "UPDATE" | "DELETE") {
return Some(&[("TO", "TO <table>")]);
}
if last == "DO" {
return Some(&[
("ALSO", "DO ALSO <command>"),
("INSTEAD", "DO INSTEAD {NOTHING | <command>}"),
("NOTHING", "DO NOTHING"),
]);
}
if last == "INSTEAD" {
return Some(&[
("NOTHING", "INSTEAD NOTHING"),
("SELECT", "INSTEAD SELECT ..."),
("INSERT", "INSTEAD INSERT ..."),
("UPDATE", "INSTEAD UPDATE ..."),
("DELETE", "INSTEAD DELETE ..."),
]);
}
if tail.contains(&"TO") && !tail.contains(&"DO") {
return Some(&[("WHERE", "WHERE <predicate>"), ("DO", "DO {ALSO|INSTEAD} {NOTHING | <command>}")]);
}
None
}
pub(crate) fn create_table_post_body_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (slice_owned, upper) = stmt_slice_upper(source, offset);
let slice = slice_owned.as_str();
let trimmed = upper.trim_start();
if !trimmed.starts_with("CREATE TABLE")
&& !trimmed.starts_with("CREATE TEMP TABLE")
&& !trimmed.starts_with("CREATE TEMPORARY TABLE")
&& !trimmed.starts_with("CREATE UNLOGGED TABLE")
&& !trimmed.starts_with("CREATE GLOBAL TABLE")
&& !trimmed.starts_with("CREATE LOCAL TABLE")
{
return None;
}
let opens = slice.matches('(').count();
let closes = slice.matches(')').count();
if opens == 0 || opens != closes {
return None;
}
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
let last = *words.last()?;
if last == "INHERITS" {
return Some(&[("(", "( <parent_table>[, ...] )")]);
}
if last == "PARTITION" {
return Some(&[("BY", "PARTITION BY { RANGE | LIST | HASH } (<cols>)")]);
}
if last == "WITHOUT" {
return Some(&[("OIDS", "WITHOUT OIDS -- legacy; no effect in PG12+")]);
}
if last == "WITH" {
return Some(&[
("OIDS", "WITH OIDS -- legacy; rejected in PG12+"),
("(", "( fillfactor=<n>, autovacuum_<param>=<v>, ... )"),
]);
}
if last == "ON" {
return Some(&[("COMMIT", "ON COMMIT { PRESERVE ROWS | DELETE ROWS | DROP }")]);
}
if last == "COMMIT" && words.contains(&"ON") {
return Some(&[
("PRESERVE ROWS", "ON COMMIT PRESERVE ROWS (default for TEMP)"),
("DELETE ROWS", "ON COMMIT DELETE ROWS -- empty rows at COMMIT"),
("DROP", "ON COMMIT DROP -- drop the temp table at COMMIT"),
]);
}
Some(&[
("INHERITS", "INHERITS ( <parent>[, ...] )"),
("PARTITION BY", "PARTITION BY { RANGE | LIST | HASH } (<cols>)"),
("USING", "USING <access_method>"),
("WITH", "WITH ( fillfactor=<n>, autovacuum_<param>=<v>, ... )"),
("WITHOUT OIDS", "WITHOUT OIDS -- legacy"),
("ON COMMIT", "ON COMMIT { PRESERVE ROWS | DELETE ROWS | DROP }"),
("TABLESPACE", "TABLESPACE <name>"),
])
}
pub(crate) fn exclude_constraint_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (_, upper) = stmt_slice_upper(source, offset);
if !upper.contains("EXCLUDE") {
return None;
}
if !upper.contains("CREATE TABLE") && !upper.contains("ALTER TABLE") {
return None;
}
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
let last = *words.last()?;
if last == "EXCLUDE" {
return Some(&[("USING", "USING <index_method>"), ("(", "( <col> WITH <op>, ... ) -- exclusion list")]);
}
if last == "USING" && words.contains(&"EXCLUDE") {
return Some(&[
("gist", "gist -- generalized search tree (recommended for ranges)"),
("spgist", "spgist -- space-partitioned GiST"),
("btree", "btree -- only for equality EXCLUDE"),
("brin", "brin -- block range index"),
]);
}
None
}
pub(crate) fn create_statistics_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
let pos: usize = (u32::from(offset) as usize).min(source.len());
let bytes = source.as_bytes();
if pos < bytes.len() && !bytes[pos].is_ascii_whitespace() && bytes[pos] != b'(' && bytes[pos] != b',' {
return None;
}
let (slice_owned, upper) = stmt_slice_upper(source, offset);
let slice = slice_owned.as_str();
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if words.len() < 2 || words[0] != "CREATE" || words[1] != "STATISTICS" {
return None;
}
let last = *words.last()?;
let opens = slice.matches('(').count();
let closes = slice.matches(')').count();
if opens > closes {
let trimmed = slice.trim_end();
let last_char = trimmed.chars().last();
if matches!(last_char, Some('(') | Some(',')) || slice.ends_with(char::is_whitespace) {
return Some(&[
("ndistinct", "ndistinct -- multi-column n-distinct estimate"),
("dependencies", "dependencies -- functional-dependency stats"),
("mcv", "mcv -- multi-column most-common-values list"),
]);
}
}
if last == "ON" {
return None; }
if last == "FROM" {
return None; }
if words.len() >= 3 && !words.contains(&"ON") && !words.contains(&"FROM") {
return Some(&[("(", "( ndistinct, dependencies, mcv )"), ("ON", "ON <col_or_expr>[, ...]")]);
}
if words.contains(&"ON") && !words.contains(&"FROM") {
return Some(&[("FROM", "FROM <table>")]);
}
None
}
pub(crate) fn create_type_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (slice_owned, upper) = stmt_slice_upper(source, offset);
let slice = slice_owned.as_str();
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if words.len() < 2 || words[0] != "CREATE" || words[1] != "TYPE" {
return None;
}
let n = words.len();
let last = words[n - 1];
if n == 3 {
return Some(&[
("AS", "AS ( <col> <type>, ... ) -- composite type"),
("AS ENUM", "AS ENUM ('a', 'b', ...) -- discrete labels"),
("AS RANGE", "AS RANGE ( SUBTYPE = <type>, ... )"),
("(", "( INPUT = ..., OUTPUT = ..., LIKE = ..., ... ) -- base type"),
]);
}
if last == "AS" {
return Some(&[
("ENUM", "AS ENUM ('a', 'b', ...)"),
("RANGE", "AS RANGE ( SUBTYPE = ... )"),
("(", "AS ( <col> <type>, ... ) -- composite"),
]);
}
if upper.contains("AS RANGE") && slice.matches('(').count() > slice.matches(')').count() {
let trimmed = slice.trim_end();
let last_char = trimmed.chars().last();
if matches!(last_char, Some('(') | Some(',')) || slice.ends_with(char::is_whitespace) {
return Some(&[
("SUBTYPE", "SUBTYPE = <type>"),
("SUBTYPE_OPCLASS", "SUBTYPE_OPCLASS = <opclass>"),
("COLLATION", "COLLATION = <collation>"),
("CANONICAL", "CANONICAL = <function>"),
("SUBTYPE_DIFF", "SUBTYPE_DIFF = <function>"),
("MULTIRANGE_TYPE_NAME", "MULTIRANGE_TYPE_NAME = <name>"),
]);
}
}
if !upper.contains(" AS ") && slice.matches('(').count() > slice.matches(')').count() {
let trimmed = slice.trim_end();
let last_char = trimmed.chars().last();
if matches!(last_char, Some('(') | Some(',')) || slice.ends_with(char::is_whitespace) {
return Some(&[
("INPUT", "INPUT = <function>"),
("OUTPUT", "OUTPUT = <function>"),
("RECEIVE", "RECEIVE = <function>"),
("SEND", "SEND = <function>"),
("TYPMOD_IN", "TYPMOD_IN = <function>"),
("TYPMOD_OUT", "TYPMOD_OUT = <function>"),
("INTERNALLENGTH", "INTERNALLENGTH = <n>"),
("PASSEDBYVALUE", "PASSEDBYVALUE"),
("ALIGNMENT", "ALIGNMENT = <type>"),
("STORAGE", "STORAGE = plain | external | extended | main"),
("LIKE", "LIKE = <existing_type>"),
("CATEGORY", "CATEGORY = '<char>'"),
("PREFERRED", "PREFERRED = true | false"),
("DEFAULT", "DEFAULT = <default_value>"),
("ELEMENT", "ELEMENT = <type> -- array element"),
("DELIMITER", "DELIMITER = '<char>'"),
("COLLATABLE", "COLLATABLE = true | false"),
]);
}
}
None
}
pub(crate) fn create_event_trigger_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (_, upper) = stmt_slice_upper(source, offset);
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if words.len() < 3 || words[0] != "CREATE" || words[1] != "EVENT" || words[2] != "TRIGGER" {
return None;
}
let last = *words.last()?;
if last == "ON" {
return Some(&[
("ddl_command_start", "ddl_command_start -- fires before a DDL"),
("ddl_command_end", "ddl_command_end -- fires after a DDL"),
("table_rewrite", "table_rewrite -- fires when a DDL rewrites a table"),
("sql_drop", "sql_drop -- fires after a DROP"),
("login", "login -- fires on session start (PG17+)"),
]);
}
if last == "EXECUTE" {
return Some(&[("FUNCTION", "EXECUTE FUNCTION <fn>()"), ("PROCEDURE", "EXECUTE PROCEDURE <fn>()")]);
}
if last == "WHEN" {
return Some(&[("tag", "tag IN ('CREATE TABLE', ...) -- filter by command tag")]);
}
if last == "TAG" && words.contains(&"WHEN") {
return Some(&[("IN", "IN ('<cmd_tag1>', '<cmd_tag2>', ...)")]);
}
if last == "IN" && words.contains(&"WHEN") {
return Some(&[("(", "( '<cmd_tag1>', '<cmd_tag2>', ... )")]);
}
if (last == "(" || last.starts_with("('")) && words.contains(&"IN") && words.contains(&"WHEN") {
return Some(&[
("'CREATE TABLE'", "'CREATE TABLE'"),
("'DROP TABLE'", "'DROP TABLE'"),
("'ALTER TABLE'", "'ALTER TABLE'"),
("'CREATE INDEX'", "'CREATE INDEX'"),
("'DROP INDEX'", "'DROP INDEX'"),
("'CREATE FUNCTION'", "'CREATE FUNCTION'"),
("'DROP FUNCTION'", "'DROP FUNCTION'"),
("'CREATE TRIGGER'", "'CREATE TRIGGER'"),
("'CREATE VIEW'", "'CREATE VIEW'"),
("'CREATE SCHEMA'", "'CREATE SCHEMA'"),
("'CREATE EXTENSION'", "'CREATE EXTENSION'"),
]);
}
if words.len() >= 5 && words.contains(&"ON") && !words.contains(&"EXECUTE") {
return Some(&[("WHEN", "WHEN tag IN ('CREATE TABLE', ...) -- filter"), ("EXECUTE", "EXECUTE FUNCTION <fn>()")]);
}
if words.len() == 4 {
return Some(&[("ON", "ON <event>")]);
}
None
}
pub(crate) fn create_language_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (_, upper) = stmt_slice_upper(source, offset);
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
let lang_idx = words.iter().position(|w| *w == "LANGUAGE")?;
if !words[..lang_idx].iter().all(|w| matches!(*w, "CREATE" | "OR" | "REPLACE" | "TRUSTED" | "PROCEDURAL"))
|| words[0] != "CREATE"
{
return None;
}
let tail = &words[lang_idx + 1..];
let last = tail.last().copied();
if tail.is_empty() {
return None;
}
if tail.len() == 1 {
return Some(&[
("HANDLER", "HANDLER <call_handler_fn>"),
("INLINE", "INLINE <inline_handler_fn>"),
("VALIDATOR", "VALIDATOR <validator_fn>"),
]);
}
if last == Some("HANDLER") || last == Some("INLINE") || last == Some("VALIDATOR") {
return None; }
let mut menu: Vec<(&str, &str)> = Vec::new();
if !tail.contains(&"INLINE") {
menu.push(("INLINE", "INLINE <inline_handler_fn>"));
}
if !tail.contains(&"VALIDATOR") {
menu.push(("VALIDATOR", "VALIDATOR <validator_fn>"));
}
if menu.is_empty() {
return None;
}
Some(&[("INLINE", "INLINE <inline_handler_fn>"), ("VALIDATOR", "VALIDATOR <validator_fn>")])
}
pub(crate) fn alter_language_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (_, upper) = stmt_slice_upper(source, offset);
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
let lang_idx = words.iter().position(|w| *w == "LANGUAGE")?;
if !words[..lang_idx].iter().all(|w| matches!(*w, "ALTER" | "PROCEDURAL")) || words[0] != "ALTER" {
return None;
}
let tail = &words[lang_idx + 1..];
if tail.is_empty() {
return None;
}
let last = *tail.last()?;
if matches!(last, "RENAME" | "OWNER") {
let menu: &[(&str, &str)] = match last {
"RENAME" => &[("TO", "RENAME TO <new_name>")],
"OWNER" => &[("TO", "OWNER TO <role>")],
_ => &[],
};
if !menu.is_empty() {
return Some(menu);
}
}
if !tail.is_empty() && last != "TO" {
return Some(&[("RENAME TO", "RENAME TO <new_name>"), ("OWNER TO", "OWNER TO <role>")]);
}
None
}
pub(crate) fn alter_server_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (slice_owned, upper) = stmt_slice_upper(source, offset);
let slice = slice_owned.as_str();
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if words.len() < 2 || words[0] != "ALTER" || words[1] != "SERVER" {
return None;
}
let last = *words.last()?;
if matches!(last, "RENAME" | "OWNER") {
return Some(match last {
"RENAME" => &[("TO", "RENAME TO <new_name>")],
"OWNER" => &[("TO", "OWNER TO <role>")],
_ => &[],
});
}
if last == "VERSION" {
return None; }
if last == "OPTIONS" {
return Some(&[("(", "( ADD|SET|DROP <key> '<val>'[, ...] )")]);
}
let opens = slice.matches('(').count();
let closes = slice.matches(')').count();
if opens > closes {
let trimmed = slice.trim_end();
let last_char = trimmed.chars().last();
if matches!(last_char, Some('(') | Some(',')) || slice.ends_with(char::is_whitespace) {
return Some(&[("ADD", "ADD <key> '<value>'"), ("SET", "SET <key> '<value>'"), ("DROP", "DROP <key>")]);
}
}
if words.len() >= 3 {
return Some(&[
("VERSION", "VERSION '<version>'"),
("OPTIONS", "OPTIONS ( ADD|SET|DROP <key> '<val>'[, ...] )"),
("RENAME TO", "RENAME TO <new_name>"),
("OWNER TO", "OWNER TO <role>"),
]);
}
None
}
pub(crate) fn alter_fdw_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (slice_owned, upper) = stmt_slice_upper(source, offset);
let slice = slice_owned.as_str();
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if words.len() < 5 || words[0] != "ALTER" || words[1] != "FOREIGN" || words[2] != "DATA" || words[3] != "WRAPPER" {
return None;
}
let last = *words.last()?;
if matches!(last, "RENAME" | "OWNER") {
return Some(match last {
"RENAME" => &[("TO", "RENAME TO <new_name>")],
"OWNER" => &[("TO", "OWNER TO <role>")],
_ => &[],
});
}
if matches!(last, "HANDLER" | "VALIDATOR") {
return None; }
if last == "NO" && (words.contains(&"WRAPPER") || words.contains(&"DATA")) {
return Some(&[("HANDLER", "NO HANDLER"), ("VALIDATOR", "NO VALIDATOR")]);
}
if last == "OPTIONS" {
return Some(&[("(", "( ADD|SET|DROP <key> '<val>'[, ...] )")]);
}
let opens = slice.matches('(').count();
let closes = slice.matches(')').count();
if opens > closes {
let trimmed = slice.trim_end();
let last_char = trimmed.chars().last();
if matches!(last_char, Some('(') | Some(',')) || slice.ends_with(char::is_whitespace) {
return Some(&[("ADD", "ADD <key> '<value>'"), ("SET", "SET <key> '<value>'"), ("DROP", "DROP <key>")]);
}
}
if words.len() >= 5 {
return Some(&[
("HANDLER", "HANDLER <function>"),
("NO HANDLER", "NO HANDLER"),
("VALIDATOR", "VALIDATOR <function>"),
("NO VALIDATOR", "NO VALIDATOR"),
("OPTIONS", "OPTIONS ( ADD|SET|DROP <key> '<val>'[, ...] )"),
("RENAME TO", "RENAME TO <new_name>"),
("OWNER TO", "OWNER TO <role>"),
]);
}
None
}
pub(crate) fn create_server_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (_, upper) = stmt_slice_upper(source, offset);
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
let is_server = words.len() >= 2 && words[0] == "CREATE" && words[1] == "SERVER";
let is_fdw =
words.len() >= 5 && words[0] == "CREATE" && words[1] == "FOREIGN" && words[2] == "DATA" && words[3] == "WRAPPER";
if !is_server && !is_fdw {
return None;
}
let last = *words.last()?;
if is_server {
if last == "TYPE" {
return None; }
if last == "VERSION" {
return None;
}
if last == "WRAPPER" && words.contains(&"FOREIGN") {
return None; }
return Some(&[
("TYPE", "TYPE '<type>'"),
("VERSION", "VERSION '<version>'"),
("FOREIGN DATA WRAPPER", "FOREIGN DATA WRAPPER <fdw_name>"),
("OPTIONS", "OPTIONS (key 'value', ...)"),
]);
}
if is_fdw {
return Some(&[
("HANDLER", "HANDLER <function>"),
("NO HANDLER", "NO HANDLER -- placeholder, can't be used"),
("VALIDATOR", "VALIDATOR <function>"),
("NO VALIDATOR", "NO VALIDATOR"),
("OPTIONS", "OPTIONS (key 'value', ...)"),
]);
}
None
}
pub(crate) fn create_operator_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
let pos: usize = (u32::from(offset) as usize).min(source.len());
let bytes = source.as_bytes();
if pos < bytes.len() && !bytes[pos].is_ascii_whitespace() && bytes[pos] != b',' && bytes[pos] != b'(' {
return None;
}
let (slice_owned, upper) = stmt_slice_upper(source, offset);
let slice = slice_owned.as_str();
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if words.len() < 2 || words[0] != "CREATE" || words[1] != "OPERATOR" {
return None;
}
let opens = slice.matches('(').count();
let closes = slice.matches(')').count();
if opens == 0 || opens <= closes {
return None;
}
let trimmed = slice.trim_end();
let last_char = trimmed.chars().last();
if matches!(last_char, Some('(') | Some(',')) || slice.ends_with(char::is_whitespace) {
return Some(&[
("FUNCTION", "FUNCTION = <fn_name>"),
("LEFTARG", "LEFTARG = <type>"),
("RIGHTARG", "RIGHTARG = <type>"),
("COMMUTATOR", "COMMUTATOR = OPERATOR(<schema>.<op>)"),
("NEGATOR", "NEGATOR = OPERATOR(<schema>.<op>)"),
("RESTRICT", "RESTRICT = <selectivity_fn>"),
("JOIN", "JOIN = <join_selectivity_fn>"),
("HASHES", "HASHES -- supports hash join"),
("MERGES", "MERGES -- supports merge join"),
]);
}
None
}
pub(crate) fn create_domain_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (_, upper) = stmt_slice_upper(source, offset);
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if words.len() < 2 || words[0] != "CREATE" || words[1] != "DOMAIN" {
return None;
}
let last = *words.last()?;
if words.len() == 3 {
return Some(&[
("AS", "AS <base_type>"),
("CHECK", "CHECK ( VALUE > 0 )"),
("DEFAULT", "DEFAULT <expr>"),
("NOT NULL", "NOT NULL"),
]);
}
if last == "AS" {
return None; }
if matches!(last, "NULL" | "DEFAULT" | "CHECK") {
return None; }
Some(&[
("CONSTRAINT", "CONSTRAINT <name> CHECK (...)"),
("CHECK", "CHECK ( VALUE > 0 )"),
("NOT NULL", "NOT NULL"),
("NULL", "NULL -- explicit nullable (default)"),
("DEFAULT", "DEFAULT <expr>"),
])
}
pub(crate) fn create_collation_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
let pos: usize = (u32::from(offset) as usize).min(source.len());
let bytes = source.as_bytes();
if pos < bytes.len() && !bytes[pos].is_ascii_whitespace() && bytes[pos] != b'(' && bytes[pos] != b',' {
return None;
}
let (slice_owned, upper) = stmt_slice_upper(source, offset);
let slice = slice_owned.as_str();
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if words.len() < 2 || words[0] != "CREATE" || words[1] != "COLLATION" {
return None;
}
let opens = slice.matches('(').count();
let closes = slice.matches(')').count();
if opens > 0 && opens > closes {
let trimmed = slice.trim_end();
let last_char = trimmed.chars().last();
if matches!(last_char, Some('(') | Some(',')) || slice.ends_with(char::is_whitespace) {
return Some(&[
("LOCALE", "LOCALE = '<locale_name>' -- e.g. 'en_US.UTF-8'"),
("LC_COLLATE", "LC_COLLATE = '<lc_collate>'"),
("LC_CTYPE", "LC_CTYPE = '<lc_ctype>'"),
("PROVIDER", "PROVIDER = libc | icu | builtin"),
("DETERMINISTIC", "DETERMINISTIC = true | false"),
("RULES", "RULES = '<ICU_rules>'"),
("VERSION", "VERSION = '<version_string>'"),
]);
}
}
let last = *words.last()?;
if last == "FROM" {
return None; }
if words.len() >= 3 && !words.contains(&"FROM") && opens == 0 {
return Some(&[
("FROM", "FROM <existing_collation> -- clone an existing collation"),
("(", "( LOCALE = '...', LC_COLLATE = '...' )"),
]);
}
None
}
pub(crate) fn column_generated_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (slice_owned, upper) = stmt_slice_upper(source, offset);
if !upper.contains("CREATE TABLE") && !upper.contains("ALTER TABLE") && !upper.contains("CREATE FOREIGN TABLE") {
return None;
}
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
let n = words.len();
let last = *words.last()?;
let second_last = if n >= 2 { Some(words[n - 2]) } else { None };
let third_last = if n >= 3 { Some(words[n - 3]) } else { None };
if last == "GENERATED" {
return Some(&[
("ALWAYS", "GENERATED ALWAYS AS IDENTITY | AS (<expr>) STORED"),
("BY DEFAULT", "GENERATED BY DEFAULT AS IDENTITY"),
]);
}
if last == "ALWAYS" && second_last == Some("GENERATED") {
return Some(&[("AS", "AS IDENTITY | AS (<expression>) STORED")]);
}
if last == "DEFAULT" && second_last == Some("BY") && third_last == Some("GENERATED") {
return Some(&[("AS IDENTITY", "AS IDENTITY -- sequence-backed column")]);
}
if last == "AS" && (second_last == Some("ALWAYS") || (second_last == Some("DEFAULT") && third_last == Some("BY"))) {
return Some(&[
("IDENTITY", "AS IDENTITY [(<seq_options>)]"),
("(", "AS ( <expression> ) STORED -- computed column"),
]);
}
let trimmed = slice_owned.trim_end();
if trimmed.ends_with(')') && upper.contains("GENERATED") && !upper.contains("STORED") && !upper.contains("VIRTUAL") {
return Some(&[
("STORED", "STORED -- materialised generated column"),
("VIRTUAL", "VIRTUAL -- on-the-fly generated column (PG18+ / reserved)"),
]);
}
None
}
pub(crate) fn create_index_trailing_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (_, upper) = stmt_slice_upper(source, offset);
let trimmed = upper.trim_start();
if !trimmed.starts_with("CREATE INDEX") && !trimmed.starts_with("CREATE UNIQUE INDEX") {
return None;
}
let opens = upper.matches('(').count();
let closes = upper.matches(')').count();
if opens == 0 || opens > closes {
return None;
}
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
let last = *words.last()?;
if matches!(last, "INCLUDE" | "WHERE" | "WITH" | "TABLESPACE" | "USING") {
return None;
}
Some(&[
("INCLUDE", "INCLUDE (<col>[, ...]) -- non-key payload columns"),
("WHERE", "WHERE <predicate> -- partial index"),
("WITH", "WITH (<option>=<value>, ...) -- storage params"),
("TABLESPACE", "TABLESPACE <name> -- place index in a specific tablespace"),
])
}
pub(crate) fn check_constraint_no_inherit_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (slice_owned, upper) = stmt_slice_upper(source, offset);
if !upper.contains("CHECK") {
return None;
}
if !upper.contains("CREATE TABLE") && !upper.contains("ALTER TABLE") && !upper.contains("CREATE DOMAIN") {
return None;
}
let after_check = {
let p = upper.rfind("CHECK")?;
&upper[p + "CHECK".len()..]
};
let opens = after_check.matches('(').count();
let closes = after_check.matches(')').count();
if opens == 0 || opens > closes {
return None;
}
if !slice_owned.ends_with(char::is_whitespace) {
return None;
}
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if matches!(words.last(), Some(&"NO") | Some(&"INHERIT")) {
return None;
}
Some(&[("NO INHERIT", "NO INHERIT -- child tables don't enforce this CHECK")])
}
pub(crate) fn column_constraint_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (_, upper) = stmt_slice_upper(source, offset);
if !upper.contains("CREATE TABLE") && !upper.contains("ALTER TABLE") && !upper.contains("CREATE FOREIGN TABLE") {
return None;
}
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
let n = words.len();
let last = *words.last()?;
let second_last = if n >= 2 { Some(words[n - 2]) } else { None };
let third_last = if n >= 3 { Some(words[n - 3]) } else { None };
if matches!(last, "DELETE" | "UPDATE") && second_last == Some("ON") {
return Some(&[
("CASCADE", "CASCADE -- propagate deletes/updates"),
("RESTRICT", "RESTRICT -- refuse if dependent rows exist (check immediate)"),
("NO ACTION", "NO ACTION -- default; check deferred if constraint is DEFERRABLE"),
("SET NULL", "SET NULL -- NULL out the FK columns"),
("SET DEFAULT", "SET DEFAULT -- reset FK columns to their DEFAULT"),
]);
}
if last == "SET" && matches!(second_last, Some("DELETE") | Some("UPDATE")) && third_last == Some("ON") {
return Some(&[("NULL", "SET NULL"), ("DEFAULT", "SET DEFAULT")]);
}
if last == "DEFERRABLE" {
return Some(&[("INITIALLY", "INITIALLY DEFERRED | IMMEDIATE")]);
}
if last == "INITIALLY" {
return Some(&[
("DEFERRED", "INITIALLY DEFERRED -- check at COMMIT"),
("IMMEDIATE", "INITIALLY IMMEDIATE -- check at statement end (default)"),
]);
}
None
}
pub(crate) fn cte_search_cycle_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (_, upper) = stmt_slice_upper(source, offset);
if !upper.contains("WITH RECURSIVE") {
return None;
}
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
let last = *words.last()?;
if last == "SEARCH" {
return Some(&[
("DEPTH FIRST BY", "DEPTH FIRST BY <cols> SET <out_col>"),
("BREADTH FIRST BY", "BREADTH FIRST BY <cols> SET <out_col>"),
]);
}
if matches!(last, "DEPTH" | "BREADTH") && words.contains(&"SEARCH") {
return Some(&[("FIRST BY", "FIRST BY <cols> SET <out_col>")]);
}
if last == "FIRST" && (words.contains(&"DEPTH") || words.contains(&"BREADTH")) {
return Some(&[("BY", "BY <cols> SET <out_col>")]);
}
if last == "CYCLE" {
return Some(&[("<cols>", "CYCLE <col1>, <col2>, ... SET <flag_col>")]);
}
if last == "SET" && words.contains(&"CYCLE") {
return Some(&[("<flag_col>", "SET <flag_col> [TO 't' DEFAULT 'f'] USING <path_col>")]);
}
if last == "USING" && words.contains(&"CYCLE") {
return Some(&[("<path_col>", "USING <path_col> -- array tracking visited rows")]);
}
None
}
pub(crate) fn alter_system_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (_, upper) = stmt_slice_upper(source, offset);
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if words.len() < 2 || words[0] != "ALTER" || words[1] != "SYSTEM" {
return None;
}
let n = words.len();
if n == 2 {
return Some(&[
("SET", "ALTER SYSTEM SET <param> = value -- write to postgresql.auto.conf"),
("RESET", "ALTER SYSTEM RESET <param> | ALL"),
]);
}
if n == 3 && words[2] == "SET" {
return Some(&[
("shared_buffers", "shared_buffers = '<size>'"),
("work_mem", "work_mem = '<size>'"),
("maintenance_work_mem", "maintenance_work_mem = '<size>'"),
("effective_cache_size", "effective_cache_size = '<size>'"),
("max_connections", "max_connections = <n> -- restart required"),
("max_wal_size", "max_wal_size = '<size>'"),
("checkpoint_timeout", "checkpoint_timeout = '<duration>'"),
("random_page_cost", "random_page_cost = <float>"),
("seq_page_cost", "seq_page_cost = <float>"),
("default_statistics_target", "default_statistics_target = <int>"),
("synchronous_commit", "synchronous_commit = 'on'|'off'|'remote_apply'|..."),
("log_statement", "log_statement = 'none'|'ddl'|'mod'|'all'"),
("log_min_duration_statement", "log_min_duration_statement = <ms>"),
("autovacuum_naptime", "autovacuum_naptime = '<duration>'"),
("autovacuum_vacuum_scale_factor", "autovacuum_vacuum_scale_factor = <float>"),
("wal_level", "wal_level = 'replica'|'logical' -- restart required"),
("max_replication_slots", "max_replication_slots = <n>"),
("max_wal_senders", "max_wal_senders = <n>"),
]);
}
if n == 4 && matches!(words[2], "SET") {
return Some(&[("TO", "TO <value>"), ("=", "= <value>")]);
}
if n == 3 && words[2] == "RESET" {
return Some(&[("ALL", "RESET ALL -- restore all GUCs to default")]);
}
None
}
pub(crate) fn alter_large_object_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (_, upper) = stmt_slice_upper(source, offset);
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if words.len() < 3 || words[0] != "ALTER" || words[1] != "LARGE" || words[2] != "OBJECT" {
return None;
}
let last = *words.last()?;
if last == "OBJECT" {
return None; }
if last == "OWNER" {
return Some(&[("TO", "OWNER TO <role>")]);
}
if words.len() >= 4 {
return Some(&[("OWNER TO", "OWNER TO <role>")]);
}
None
}
pub(crate) fn create_subscription_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (slice_owned, upper) = stmt_slice_upper(source, offset);
let slice = slice_owned.as_str();
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if words.len() < 2 || words[0] != "CREATE" || words[1] != "SUBSCRIPTION" {
return None;
}
let last = *words.last()?;
if last == "SUBSCRIPTION" {
return None; }
if last == "CONNECTION" {
return None; }
if last == "PUBLICATION" {
return None; }
if last == "WITH" {
return Some(&[("(", "WITH ( <param> = <value>[, ...] )")]);
}
let opens = slice.matches('(').count();
let closes = slice.matches(')').count();
if opens > closes {
let trimmed = slice.trim_end();
let last_char = trimmed.chars().last();
if matches!(last_char, Some('(') | Some(',')) || slice.ends_with(char::is_whitespace) {
return Some(&[
("connect", "connect = true|false -- default true; false = create slot but don't subscribe yet"),
("create_slot", "create_slot = true|false -- create the replication slot on the publisher"),
("enabled", "enabled = true|false -- whether the subscription starts active"),
("slot_name", "slot_name = '<name>' | NONE -- replication slot to attach to"),
("synchronous_commit", "synchronous_commit = 'on'|'off'|'remote_apply'|... -- apply-worker setting"),
("binary", "binary = true|false -- use binary protocol (PG14+)"),
("streaming", "streaming = 'off'|'on'|'parallel' -- streaming-in-progress xacts"),
("two_phase", "two_phase = true|false -- enable 2PC streaming (PG15+)"),
("disable_on_error", "disable_on_error = true|false -- auto-disable on apply error (PG15+)"),
("run_as_owner", "run_as_owner = true|false -- run the apply worker as the subscription owner (PG16+)"),
("password_required", "password_required = true|false -- require password in CONNECTION (PG16+)"),
("origin", "origin = 'none'|'any' -- which origin's data to apply (PG16+)"),
("failover", "failover = true|false -- allow synchronous failover (PG17+)"),
("copy_data", "copy_data = true|false -- initial table sync"),
]);
}
}
if !words.contains(&"CONNECTION") && words.len() >= 3 {
return Some(&[("CONNECTION", "CONNECTION '<conn_string>'")]);
}
if words.contains(&"CONNECTION") && !words.contains(&"PUBLICATION") {
return Some(&[("PUBLICATION", "PUBLICATION <pub>[, ...]")]);
}
if words.contains(&"PUBLICATION") && !words.contains(&"WITH") {
return Some(&[("WITH", "WITH ( <options> )")]);
}
None
}
pub(crate) fn create_publication_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (_, upper) = stmt_slice_upper(source, offset);
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if words.len() < 2 || words[0] != "CREATE" || words[1] != "PUBLICATION" {
return None;
}
let last = *words.last()?;
if last == "PUBLICATION" {
return None; }
if last == "FOR" {
return Some(&[
("ALL TABLES", "FOR ALL TABLES -- every existing + future table"),
("TABLE", "FOR TABLE <tbl>[, ...]"),
("TABLES IN SCHEMA", "FOR TABLES IN SCHEMA <schema>[, ...] (PG15+)"),
]);
}
if last == "ALL" && words.contains(&"FOR") {
return Some(&[("TABLES", "FOR ALL TABLES -- every existing + future table")]);
}
if last == "IN" && words.contains(&"TABLES") {
return Some(&[("SCHEMA", "TABLES IN SCHEMA <schema>[, ...] (PG15+)")]);
}
if last == "TABLES" && words.contains(&"FOR") && !words.contains(&"ALL") {
return Some(&[("IN SCHEMA", "TABLES IN SCHEMA <schema>[, ...] (PG15+)")]);
}
if last == "WITH" {
return Some(&[
("(publish", "WITH (publish = 'insert, update, delete, truncate')"),
("(publish_via_partition_root", "WITH (publish_via_partition_root = true)"),
]);
}
if !words.contains(&"FOR") && !words.contains(&"WITH") && words.len() >= 3 {
return Some(&[
("FOR", "FOR { ALL TABLES | TABLE ... | TABLES IN SCHEMA ... }"),
("WITH", "WITH (publish = '...')"),
]);
}
if words.contains(&"FOR") && !words.contains(&"WITH") {
return Some(&[("WITH", "WITH (publish = 'insert, update, delete, truncate')")]);
}
None
}
pub(crate) fn replica_identity_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (_, upper) = stmt_slice_upper(source, offset);
if !upper.contains("REPLICA IDENTITY") {
return None;
}
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
let last = *words.last()?;
if last == "IDENTITY" && words.contains(&"REPLICA") {
return Some(&[
("DEFAULT", "DEFAULT -- record PK columns (standard)"),
("FULL", "FULL -- record old image of every column (heavy WAL)"),
("NOTHING", "NOTHING -- record only TOAST columns"),
("USING INDEX", "USING INDEX <unique_index> -- use a specific UNIQUE index"),
]);
}
if last == "USING" && words.contains(&"REPLICA") {
return Some(&[("INDEX", "INDEX <unique_index_name>")]);
}
None
}
pub(crate) fn cluster_next_keyword(source: &str, offset: TextSize) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (_, upper) = stmt_slice_upper(source, offset);
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if words.first() != Some(&"CLUSTER") {
return None;
}
let n = words.len();
if n == 1 {
return Some(&[("VERBOSE", "CLUSTER VERBOSE -- per-table progress")]);
}
if n >= 3 && !words.contains(&"USING") {
return Some(&[("USING", "USING <index_name> -- pick a non-default cluster index")]);
}
None
}
pub(crate) fn import_foreign_schema_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (_, upper) = stmt_slice_upper(source, offset);
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if words.len() < 3 || words[0] != "IMPORT" || words[1] != "FOREIGN" || words[2] != "SCHEMA" {
return None;
}
let last = *words.last()?;
if last == "SCHEMA" && words.len() == 3 {
return None; }
if matches!(last, "LIMIT" | "TO" | "EXCEPT" | "FROM" | "SERVER" | "INTO") {
let menu: &[(&str, &str)] = match last {
"LIMIT" => &[("TO", "LIMIT TO (<rel>[, ...])")],
"TO" => &[("(", "( <rel>[, ...] )")],
"EXCEPT" => &[("(", "EXCEPT ( <rel>[, ...] )")],
"FROM" => &[("SERVER", "FROM SERVER <name>")],
"SERVER" => &[],
"INTO" => &[],
_ => &[],
};
if !menu.is_empty() {
return Some(menu);
}
return None;
}
Some(&[
("LIMIT TO", "LIMIT TO (<rel>[, ...]) -- import only these"),
("EXCEPT", "EXCEPT (<rel>[, ...]) -- import everything except"),
("FROM SERVER", "FROM SERVER <fdw_server> INTO <local_schema>"),
("INTO", "INTO <local_schema>"),
("OPTIONS", "OPTIONS (key 'value', ...)"),
])
}
pub(crate) fn create_schema_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (_, upper) = stmt_slice_upper(source, offset);
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if words.len() < 2 || words[0] != "CREATE" || words[1] != "SCHEMA" {
return None;
}
let last = *words.last()?;
if last == "AUTHORIZATION" {
return None; }
if words.len() == 2 {
return Some(&[
("IF NOT EXISTS", "IF NOT EXISTS <name> -- silently skip if present"),
("AUTHORIZATION", "AUTHORIZATION <role> -- omits <name>, uses role name"),
]);
}
if words.len() >= 3 && !words.contains(&"AUTHORIZATION") {
return Some(&[("AUTHORIZATION", "AUTHORIZATION <role> -- assign owner")]);
}
None
}
pub(crate) fn create_foreign_table_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (slice_owned, upper) = stmt_slice_upper(source, offset);
let slice = slice_owned.as_str();
let trimmed = upper.trim_start();
if !trimmed.starts_with("CREATE FOREIGN TABLE") {
return None;
}
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
let last = *words.last()?;
let opens = slice.matches('(').count();
let closes = slice.matches(')').count();
if last == "OPTIONS" {
return Some(&[("(", "( <option_name> '<value>', ... )")]);
}
if last == "SERVER" {
return None; }
if last == "INHERITS" {
return None; }
if let Some(srv_idx) = words.iter().rposition(|w| *w == "SERVER")
&& srv_idx == words.len() - 2
{
return Some(&[("OPTIONS", "OPTIONS (<key> '<value>', ...)")]);
}
if opens >= 1 && opens == closes && !words.contains(&"SERVER") {
return Some(&[("INHERITS", "INHERITS (<parent>[, ...])"), ("SERVER", "SERVER <fdw_server_name>")]);
}
None
}
pub(crate) fn reindex_next_keyword(source: &str, offset: TextSize) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (slice_owned, upper) = stmt_slice_upper(source, offset);
let slice = slice_owned.as_str();
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if words.first() != Some(&"REINDEX") {
return None;
}
let opens = slice.matches('(').count();
let closes = slice.matches(')').count();
if opens > closes {
let last_tok = slice.trim_end().chars().last();
if matches!(last_tok, Some('(') | Some(',')) || slice.ends_with(char::is_whitespace) {
let last_raw = *words.last()?;
let last = last_raw.trim_start_matches(['(', ',']);
if last == "CONCURRENTLY" || last == "VERBOSE" {
return Some(&[("true", "true -- enable"), ("false", "false -- disable")]);
}
if last == "TABLESPACE" {
return None; }
return Some(&[
("CONCURRENTLY", "CONCURRENTLY [true|false] -- avoid heavy locks"),
("TABLESPACE", "TABLESPACE <name> -- move rebuilt indexes into <name>"),
("VERBOSE", "VERBOSE [true|false] -- per-index progress"),
]);
}
}
if words.len() == 1 || (words.len() == 2 && words[1] == "CONCURRENTLY") {
return Some(&[
("INDEX", "REINDEX INDEX <name> -- single index"),
("TABLE", "REINDEX TABLE <name> -- all indexes on a table"),
("SCHEMA", "REINDEX SCHEMA <name> -- every index in the schema"),
("DATABASE", "REINDEX DATABASE <name> -- every index in the database"),
("SYSTEM", "REINDEX SYSTEM <name> -- only system catalog indexes"),
("CONCURRENTLY", "REINDEX CONCURRENTLY <kind> <name> (PG 12+)"),
("(", "( CONCURRENTLY|TABLESPACE|VERBOSE ... ) -- paren options (PG14+)"),
]);
}
None
}
pub(crate) fn call_expects_procedure(source: &str, offset: TextSize) -> bool {
if cursor_not_at_ws_boundary(source, offset) {
return false;
}
let (slice_owned, _) = stmt_slice_upper(source, offset);
slice_owned.trim().eq_ignore_ascii_case("CALL")
}
pub(crate) fn set_transaction_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (slice_owned, upper) = stmt_slice_upper(source, offset);
let _ = slice_owned;
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if words.is_empty() {
return None;
}
let is_set_tx = (words[0] == "SET" && words.contains(&"TRANSACTION"))
|| words[0] == "BEGIN"
|| (words[0] == "START" && words.contains(&"TRANSACTION"));
if !is_set_tx {
return None;
}
let last = *words.last()?;
if last == "ISOLATION" {
return Some(&[("LEVEL", "ISOLATION LEVEL <name>")]);
}
if last == "LEVEL" {
return Some(&[
("READ UNCOMMITTED", "READ UNCOMMITTED (treated as READ COMMITTED in PG)"),
("READ COMMITTED", "READ COMMITTED -- default"),
("REPEATABLE READ", "REPEATABLE READ -- snapshot isolation"),
("SERIALIZABLE", "SERIALIZABLE -- strictest"),
]);
}
if last == "READ" {
return Some(&[("ONLY", "READ ONLY -- block writes"), ("WRITE", "READ WRITE -- default")]);
}
if last == "NOT" {
return Some(&[("DEFERRABLE", "NOT DEFERRABLE -- default")]);
}
Some(&[
("ISOLATION LEVEL", "ISOLATION LEVEL READ COMMITTED | REPEATABLE READ | SERIALIZABLE"),
("READ ONLY", "READ ONLY"),
("READ WRITE", "READ WRITE (default)"),
("DEFERRABLE", "DEFERRABLE (REPEATABLE READ + READ ONLY only)"),
("NOT DEFERRABLE", "NOT DEFERRABLE (default)"),
("SNAPSHOT", "SNAPSHOT '<snapshot_id>' -- import a snapshot exported via pg_export_snapshot()"),
])
}
pub(crate) fn reassign_owned_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (_, upper) = stmt_slice_upper(source, offset);
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if words.first() != Some(&"REASSIGN") {
return None;
}
let last = *words.last()?;
if last == "REASSIGN" {
return Some(&[("OWNED", "OWNED BY <old_role>[, ...] TO <new_role>")]);
}
if last == "OWNED" {
return Some(&[("BY", "BY <old_role>[, ...]")]);
}
if last == "BY" {
return None; }
if !words.contains(&"TO") && words.len() >= 4 {
return Some(&[("TO", "TO <new_role>")]);
}
None
}
pub(crate) fn txn_followup_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (_, upper) = stmt_slice_upper(source, offset);
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
let last = *words.last()?;
let first = *words.first()?;
if !matches!(first, "COMMIT" | "ROLLBACK" | "ABORT" | "END" | "PREPARE") {
return None;
}
if first == "PREPARE" {
if words.len() == 1 {
return Some(&[("TRANSACTION", "PREPARE TRANSACTION '<gxid>'")]);
}
return None;
}
if words.len() == 1 {
let mut menu: &[(&str, &str)] = &[
("AND", "AND { CHAIN | NO CHAIN }"),
("TRANSACTION", "TRANSACTION -- SQL-standard noise"),
("WORK", "WORK -- SQL-standard noise"),
("PREPARED", "PREPARED '<gxid>' -- second phase of 2PC"),
];
if first == "ROLLBACK" {
menu = &[
("AND", "AND { CHAIN | NO CHAIN }"),
("TO", "TO [SAVEPOINT] <name>"),
("TRANSACTION", "TRANSACTION -- SQL-standard noise"),
("WORK", "WORK -- SQL-standard noise"),
("PREPARED", "PREPARED '<gxid>' -- second phase of 2PC"),
];
}
return Some(menu);
}
if last == "AND" {
return Some(&[("CHAIN", "CHAIN -- start a new xact with same options"), ("NO CHAIN", "NO CHAIN (default)")]);
}
if last == "NO" && words.contains(&"AND") {
return Some(&[("CHAIN", "NO CHAIN")]);
}
if last == "TO" && first == "ROLLBACK" {
return Some(&[("SAVEPOINT", "TO SAVEPOINT <name> -- optional kw")]);
}
if last == "PREPARED" {
return None;
}
None
}
pub(crate) fn release_savepoint_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (_, upper) = stmt_slice_upper(source, offset);
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if words.first() != Some(&"RELEASE") {
return None;
}
if words.len() == 1 {
return Some(&[("SAVEPOINT", "SAVEPOINT <name> -- optional keyword")]);
}
None
}
pub(crate) fn copy_paren_options_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
let pos: usize = (u32::from(offset) as usize).min(source.len());
let bytes = source.as_bytes();
if pos < bytes.len() && !bytes[pos].is_ascii_whitespace() && bytes[pos] != b'(' && bytes[pos] != b',' {
return None;
}
let (slice_owned, upper) = stmt_slice_upper(source, offset);
let slice = slice_owned.as_str();
if !upper.starts_with("COPY") {
return None;
}
let opens = slice.matches('(').count();
let closes = slice.matches(')').count();
if opens <= closes {
return None;
}
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
let last_tok =
upper.split(|c: char| c.is_whitespace() || c == ',' || c == '(').rfind(|s| !s.is_empty()).unwrap_or("");
if last_tok == "FORMAT" {
return Some(&[
("TEXT", "FORMAT TEXT -- default tab-separated"),
("CSV", "FORMAT CSV"),
("BINARY", "FORMAT BINARY"),
]);
}
if last_tok == "HEADER" {
return Some(&[
("TRUE", "HEADER TRUE -- emit/skip a header row"),
("FALSE", "HEADER FALSE -- default"),
("MATCH", "HEADER MATCH -- verify header columns match (PG16+)"),
]);
}
if matches!(last_tok, "FREEZE" | "OIDS" | "DEFAULT") {
return Some(&[("TRUE", "TRUE"), ("FALSE", "FALSE")]);
}
if !words.contains(&"WITH") && opens == 1 {
return None;
}
Some(&[
("FORMAT", "FORMAT { TEXT | CSV | BINARY }"),
("FREEZE", "FREEZE -- mark imported tuples as already-committed (load only)"),
("DELIMITER", "DELIMITER '<char>'"),
("NULL", "NULL '<text>' -- literal that means NULL"),
("HEADER", "HEADER { TRUE | FALSE | MATCH }"),
("QUOTE", "QUOTE '<char>'"),
("ESCAPE", "ESCAPE '<char>'"),
("FORCE_QUOTE", "FORCE_QUOTE { * | (col[, ...]) }"),
("FORCE_NOT_NULL", "FORCE_NOT_NULL (col[, ...])"),
("FORCE_NULL", "FORCE_NULL (col[, ...])"),
("ENCODING", "ENCODING '<name>'"),
("DEFAULT", "DEFAULT '<text>' -- string treated as column DEFAULT (PG16+)"),
("ON_ERROR", "ON_ERROR { STOP | IGNORE } -- per-row error handling (PG17+)"),
("LOG_VERBOSITY", "LOG_VERBOSITY { DEFAULT | VERBOSE } (PG17+)"),
])
}
pub(crate) fn copy_next_keyword(source: &str, offset: TextSize) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (slice_owned, upper) = stmt_slice_upper(source, offset);
let _ = slice_owned;
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if words.first() != Some(&"COPY") {
return None;
}
let n = words.len();
if n < 2 {
return None;
}
let last = words[n - 1];
if last == "FROM" {
return Some(&[
("STDIN", "FROM STDIN -- pipe data on the wire"),
("PROGRAM", "FROM PROGRAM '<cmd>' -- spawn cmd, read its stdout"),
]);
}
if last == "TO" {
return Some(&[
("STDOUT", "TO STDOUT -- stream data on the wire"),
("PROGRAM", "TO PROGRAM '<cmd>' -- spawn cmd, write to its stdin"),
]);
}
if last == "WITH" {
return Some(&[
("(FORMAT CSV", "WITH (FORMAT CSV, ...)"),
("(FORMAT TEXT", "WITH (FORMAT TEXT, ...) -- default"),
("(FORMAT BINARY", "WITH (FORMAT BINARY, ...)"),
]);
}
let has_from_or_to = words.contains(&"FROM") || words.contains(&"TO");
if !has_from_or_to {
return Some(&[("FROM", "FROM <source>"), ("TO", "TO <destination>")]);
}
if matches!(last, "STDIN" | "STDOUT") || last.ends_with('\'') {
return Some(&[
("WITH", "WITH (<options>) -- group all options in one paren list"),
("DELIMITER", "DELIMITER '<char>'"),
("HEADER", "HEADER -- skip first row on COPY FROM, write on COPY TO"),
("CSV", "CSV -- shorthand for FORMAT CSV"),
("BINARY", "BINARY -- shorthand for FORMAT BINARY"),
("FREEZE", "FREEZE -- mark imported tuples as already committed"),
("NULL", "NULL '<text>' -- literal that means NULL"),
("QUOTE", "QUOTE '<char>'"),
("ESCAPE", "ESCAPE '<char>'"),
("ENCODING", "ENCODING '<name>'"),
]);
}
None
}
pub(crate) fn do_block_next_keyword(source: &str, offset: TextSize) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (slice_owned, upper) = stmt_slice_upper(source, offset);
let _ = slice_owned;
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if words.first() != Some(&"DO") {
return None;
}
let n = words.len();
if n == 1 {
return Some(&[
("LANGUAGE", "LANGUAGE plpgsql/sql -- explicit (default is plpgsql)"),
("$$", "$$ BEGIN ... END; $$ -- anonymous code block"),
]);
}
if matches!(words.last(), Some(&"LANGUAGE")) {
return Some(&[
("plpgsql", "plpgsql -- procedural Postgres"),
("sql", "sql -- pure SQL function body"),
("plpython3u", "plpython3u -- Python 3 (untrusted)"),
("plperl", "plperl -- Perl"),
("pltcl", "pltcl -- Tcl"),
]);
}
None
}
pub(crate) fn role_next_keyword(source: &str, offset: TextSize) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (slice_owned, upper) = stmt_slice_upper(source, offset);
let _ = slice_owned;
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if words.len() < 2 || !matches!(words[0], "CREATE" | "ALTER") {
return None;
}
if !matches!(words[1], "ROLE" | "USER" | "GROUP") {
return None;
}
let last = *words.last()?;
if matches!(last, "PASSWORD" | "UNTIL" | "LIMIT" | "ROLE" | "GROUP" | "ADMIN") && words.len() >= 3 {
if last == "ROLE" && words[words.len() - 2] == "IN" {
return None;
}
if last == "GROUP" && words[words.len() - 2] == "IN" {
return None;
}
}
if words.len() < 3 {
return None;
}
Some(&[
("WITH", "WITH <attr_list> -- introduces role attributes"),
("LOGIN", "LOGIN -- can authenticate"),
("NOLOGIN", "NOLOGIN -- group-only role"),
("SUPERUSER", "SUPERUSER -- bypass every permission check"),
("NOSUPERUSER", "NOSUPERUSER -- not a superuser (default)"),
("CREATEDB", "CREATEDB -- can create databases"),
("NOCREATEDB", "NOCREATEDB -- cannot create databases (default)"),
("CREATEROLE", "CREATEROLE -- can create/manage other roles"),
("NOCREATEROLE", "NOCREATEROLE -- default"),
("INHERIT", "INHERIT -- auto-inherit privs from member-of roles (default)"),
("NOINHERIT", "NOINHERIT -- require explicit SET ROLE"),
("REPLICATION", "REPLICATION -- can initiate streaming replication"),
("NOREPLICATION", "NOREPLICATION -- default"),
("BYPASSRLS", "BYPASSRLS -- bypass row-level security"),
("NOBYPASSRLS", "NOBYPASSRLS -- default"),
("PASSWORD", "PASSWORD '<text>' -- role password"),
("ENCRYPTED PASSWORD", "ENCRYPTED PASSWORD '<text>' -- pre-hashed password"),
("VALID UNTIL", "VALID UNTIL '<timestamptz>' -- expiry"),
("CONNECTION LIMIT", "CONNECTION LIMIT <n> -- per-role parallel session cap"),
("IN ROLE", "IN ROLE <r>[, ...] -- inherit from these roles"),
("IN GROUP", "IN GROUP <r>[, ...] -- SQL-standard alias for IN ROLE"),
("ROLE", "ROLE <r>[, ...] -- members of THIS role"),
("ADMIN", "ADMIN <r>[, ...] -- members with WITH ADMIN OPTION"),
("USER", "USER <r>[, ...] -- alias for ROLE"),
("SYSID", "SYSID <oid> -- legacy; ignored"),
])
}
pub(crate) fn create_trigger_when_table(source: &str, offset: TextSize) -> Option<String> {
let (slice_owned, upper) = stmt_slice_upper(source, offset);
let slice = slice_owned.as_str();
if !upper.contains("CREATE") || !upper.contains("TRIGGER") {
return None;
}
let bytes = upper.as_bytes();
let mut from = 0usize;
let mut when_at: Option<usize> = None;
while let Some(rel) = upper[from..].find("WHEN") {
let at = from + rel;
let prev_ok = at == 0 || !(bytes[at - 1].is_ascii_alphanumeric() || bytes[at - 1] == b'_');
let next_ok = at + 4 >= bytes.len() || !(bytes[at + 4].is_ascii_alphanumeric() || bytes[at + 4] == b'_');
if prev_ok && next_ok {
when_at = Some(at);
}
from = at + 4;
}
let when_at = when_at?;
let after_when = &slice[when_at + 4..];
let paren_open = after_when.find('(')?;
let mut depth = 0i32;
for c in after_when[paren_open..].chars() {
match c {
'(' => depth += 1,
')' => depth -= 1,
_ => {},
}
}
if depth <= 0 {
return None;
}
let on_rel = upper[..when_at].rfind(" ON ")?;
let tbl_start = on_rel + 4;
let tbl_str: String =
upper[tbl_start..].chars().take_while(|c| c.is_alphanumeric() || *c == '_' || *c == '.').collect();
let tbl = tbl_str.rsplit('.').next().unwrap_or(&tbl_str).to_ascii_lowercase();
if tbl.is_empty() {
return None;
}
Some(tbl)
}
pub(crate) fn create_trigger_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (slice_owned, upper) = stmt_slice_upper(source, offset);
let slice = slice_owned.as_str();
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
let trigger_idx = words.iter().position(|w| *w == "TRIGGER")?;
if !words[..trigger_idx].iter().all(|w| matches!(*w, "CREATE" | "OR" | "REPLACE" | "CONSTRAINT"))
|| words[0] != "CREATE"
{
return None;
}
let after_kw = &words[trigger_idx + 1..];
if after_kw.is_empty() {
return None;
}
if after_kw.len() == 1 {
return None;
}
let tail = &after_kw[1..]; if tail.is_empty() || !slice.ends_with(char::is_whitespace) {
return Some(&[
("BEFORE", "BEFORE <event> ON <table>"),
("AFTER", "AFTER <event> ON <table>"),
("INSTEAD OF", "INSTEAD OF <event> ON <view>"),
]);
}
let last = *tail.last()?;
let upper_tail: Vec<&str> = tail.to_vec();
if last == "EXECUTE" {
return Some(&[
("FUNCTION", "EXECUTE FUNCTION <fn>(<args>)"),
("PROCEDURE", "EXECUTE PROCEDURE <fn>(<args>) -- pre-PG11"),
]);
}
if last == "FOR" {
return Some(&[("EACH", "FOR EACH ROW | STATEMENT")]);
}
if last == "EACH" {
return Some(&[
("ROW", "FOR EACH ROW -- per-row trigger"),
("STATEMENT", "FOR EACH STATEMENT -- one fire per statement"),
]);
}
if matches!(last, "ROW" | "STATEMENT") && upper_tail.contains(&"EACH") {
return Some(&[
("WHEN", "WHEN (<predicate>) -- conditional"),
("EXECUTE", "EXECUTE {FUNCTION|PROCEDURE} <fn>(<args>)"),
]);
}
if matches!(last, "BEFORE" | "AFTER") {
return Some(&[
("INSERT", "INSERT -- fire on INSERT"),
("UPDATE", "UPDATE -- fire on UPDATE"),
("DELETE", "DELETE -- fire on DELETE"),
("TRUNCATE", "TRUNCATE -- fire on TRUNCATE (statement-level only)"),
]);
}
if matches!(last, "OF") && upper_tail.contains(&"INSTEAD") {
return Some(&[("INSERT", "INSERT"), ("UPDATE", "UPDATE"), ("DELETE", "DELETE")]);
}
if matches!(last, "INSERT" | "UPDATE" | "DELETE" | "TRUNCATE") {
return Some(&[
("ON", "ON <table>"),
("OR", "OR <event> -- chain another event"),
("OF", "UPDATE OF <col>[, ...] -- column-list-scoped UPDATE event"),
]);
}
if last == "REFERENCING" {
return Some(&[
("OLD TABLE AS", "OLD TABLE AS <old_rows_alias>"),
("NEW TABLE AS", "NEW TABLE AS <new_rows_alias>"),
]);
}
if matches!(last, "OLD" | "NEW") && upper_tail.contains(&"REFERENCING") {
return Some(&[("TABLE AS", "TABLE AS <alias_name>")]);
}
if last == "TABLE" && upper_tail.contains(&"REFERENCING") {
return Some(&[("AS", "AS <alias_name>")]);
}
if upper_tail.contains(&"ON") && !upper_tail.contains(&"FOR") && !upper_tail.contains(&"EXECUTE") {
return Some(&[
("FROM", "FROM <referenced_table> -- only on CONSTRAINT triggers"),
("DEFERRABLE", "DEFERRABLE -- CONSTRAINT trigger only"),
("NOT DEFERRABLE", "NOT DEFERRABLE (default)"),
("INITIALLY DEFERRED", "INITIALLY DEFERRED"),
("INITIALLY IMMEDIATE", "INITIALLY IMMEDIATE (default)"),
("REFERENCING", "REFERENCING OLD/NEW TABLE AS <name>"),
("FOR", "FOR EACH {ROW|STATEMENT}"),
("WHEN", "WHEN (<predicate>) -- conditional"),
("EXECUTE", "EXECUTE {FUNCTION|PROCEDURE} <fn>()"),
]);
}
None
}
pub(crate) fn create_index_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (slice_owned, upper) = stmt_slice_upper(source, offset);
let slice = slice_owned.as_str();
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
let starts_index = words.starts_with(&["CREATE", "INDEX"])
|| words.starts_with(&["CREATE", "UNIQUE", "INDEX"])
|| (words.len() >= 3 && words[0] == "CREATE" && words[1] == "INDEX" && words[2] == "CONCURRENTLY")
|| (words.len() >= 4
&& words[0] == "CREATE"
&& words[1] == "UNIQUE"
&& words[2] == "INDEX"
&& words[3] == "CONCURRENTLY");
if !starts_index {
return None;
}
if matches!(words.last(), Some(&"USING")) {
return Some(&[
("btree", "B-tree (default) -- equality + range"),
("hash", "Hash -- equality only"),
("gist", "GiST -- geometric / range / fts / array"),
("gin", "GIN -- inverted index for arrays / jsonb / fts"),
("brin", "BRIN -- block-range, small index for sorted big tables"),
("spgist", "SP-GiST -- space-partitioned GiST"),
]);
}
let has_on = words.contains(&"ON");
let opens = slice.matches('(').count();
let closes = slice.matches(')').count();
if has_on && opens > 0 && closes >= opens && slice.trim_end().ends_with(')') {
return Some(&[
("INCLUDE", "INCLUDE (<cols>) -- non-key columns stored on leaf (PG11+)"),
("NULLS DISTINCT", "NULLS DISTINCT -- treat NULLs as different (default for non-unique)"),
("NULLS NOT DISTINCT", "NULLS NOT DISTINCT -- treat all NULLs as equal in UNIQUE (PG15+)"),
("WITH", "WITH (<storage_params>) -- e.g. fillfactor = 80"),
("TABLESPACE", "TABLESPACE <name> -- pin index storage"),
("WHERE", "WHERE <predicate> -- partial index"),
]);
}
None
}
pub(crate) fn alter_type_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (slice_owned, _) = stmt_slice_upper(source, offset);
let slice = slice_owned.trim();
let upper = slice.to_ascii_uppercase();
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if words.len() < 2 || words[0] != "ALTER" || words[1] != "TYPE" {
return None;
}
let n = words.len();
if n == 3 {
return Some(&[
("ADD VALUE", "ADD VALUE [IF NOT EXISTS] '<lit>' [BEFORE|AFTER '<existing>']"),
("RENAME VALUE", "RENAME VALUE '<old>' TO '<new>'"),
("RENAME TO", "RENAME TO <new_type_name>"),
("OWNER TO", "OWNER TO <role>"),
("SET SCHEMA", "SET SCHEMA <schema>"),
("ADD ATTRIBUTE", "ADD ATTRIBUTE <name> <type> [CASCADE|RESTRICT]"),
("DROP ATTRIBUTE", "DROP ATTRIBUTE [IF EXISTS] <name> [CASCADE|RESTRICT]"),
("ALTER ATTRIBUTE", "ALTER ATTRIBUTE <name> [SET DATA] TYPE <type>"),
]);
}
if n == 4 && words[3] == "ADD" {
return Some(&[("VALUE", "VALUE [IF NOT EXISTS] '<lit>'"), ("ATTRIBUTE", "ATTRIBUTE <name> <type>")]);
}
if n == 5 && words[3] == "ADD" && words[4] == "VALUE" {
return Some(&[("IF NOT EXISTS", "IF NOT EXISTS '<lit>' -- silently skip if value already present")]);
}
if n >= 6 && words[3] == "ADD" && words[4] == "VALUE" && !words.contains(&"BEFORE") && !words.contains(&"AFTER") {
let last = words.last()?;
if last.starts_with('\'') && last.ends_with('\'') {
return Some(&[
("BEFORE", "BEFORE '<existing>' -- insert before this value"),
("AFTER", "AFTER '<existing>' -- insert after this value"),
]);
}
}
if n == 4 && words[3] == "RENAME" {
return Some(&[
("VALUE", "VALUE '<old>' TO '<new>'"),
("TO", "TO <new_type_name>"),
("ATTRIBUTE", "ATTRIBUTE <old> TO <new>"),
]);
}
if n == 6 && words[3] == "RENAME" && words[4] == "VALUE" {
return Some(&[("TO", "TO '<new>' -- new value literal")]);
}
if n == 4 && words[3] == "SET" {
return Some(&[("SCHEMA", "SCHEMA <schema_name>")]);
}
if n == 4 && words[3] == "OWNER" {
return Some(&[("TO", "TO <role>")]);
}
None
}
pub(crate) fn drop_user_mapping_next_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (_, upper) = stmt_slice_upper(source, offset);
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if words.len() < 3 || words[0] != "DROP" || words[1] != "USER" || words[2] != "MAPPING" {
return None;
}
let last = *words.last()?;
if last == "MAPPING" {
return Some(&[("FOR", "FOR <role> SERVER <srv>"), ("IF EXISTS", "IF EXISTS FOR <role> SERVER <srv>")]);
}
if last == "EXISTS" && words.contains(&"IF") {
return Some(&[("FOR", "FOR <role> SERVER <srv>")]);
}
if last == "FOR" {
return Some(&[
("CURRENT_USER", "FOR CURRENT_USER"),
("CURRENT_ROLE", "FOR CURRENT_ROLE"),
("PUBLIC", "FOR PUBLIC"),
("USER", "FOR USER -- alias of CURRENT_USER"),
]);
}
if last == "SERVER" {
return None; }
if words.contains(&"FOR") && !words.contains(&"SERVER") {
return Some(&[("SERVER", "SERVER <name>")]);
}
None
}
pub(crate) fn after_top_level_drop_keyword(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
if cursor_not_at_ws_boundary(source, offset) {
return None;
}
let (slice_owned, _) = stmt_slice_upper(source, offset);
if !slice_owned.trim().eq_ignore_ascii_case("DROP") {
return None;
}
Some(&[
("TABLE", "DROP TABLE [IF EXISTS] <name> [CASCADE|RESTRICT]"),
("VIEW", "DROP VIEW [IF EXISTS] <name> [CASCADE|RESTRICT]"),
("MATERIALIZED VIEW", "DROP MATERIALIZED VIEW [IF EXISTS] <name>"),
("INDEX", "DROP INDEX [CONCURRENTLY] [IF EXISTS] <name>"),
("SEQUENCE", "DROP SEQUENCE [IF EXISTS] <name>"),
("SCHEMA", "DROP SCHEMA [IF EXISTS] <name> [CASCADE|RESTRICT]"),
("FUNCTION", "DROP FUNCTION [IF EXISTS] <name>(args)"),
("PROCEDURE", "DROP PROCEDURE [IF EXISTS] <name>(args)"),
("TRIGGER", "DROP TRIGGER [IF EXISTS] <name> ON <table>"),
("TYPE", "DROP TYPE [IF EXISTS] <name> [CASCADE|RESTRICT]"),
("ROLE", "DROP ROLE [IF EXISTS] <name>"),
("USER", "DROP USER [IF EXISTS] <name>"),
("DATABASE", "DROP DATABASE [IF EXISTS] <name>"),
("EXTENSION", "DROP EXTENSION [IF EXISTS] <name> [CASCADE]"),
("POLICY", "DROP POLICY [IF EXISTS] <name> ON <table>"),
("DOMAIN", "DROP DOMAIN [IF EXISTS] <name>"),
("AGGREGATE", "DROP AGGREGATE [IF EXISTS] <name>(args)"),
("CAST", "DROP CAST [IF EXISTS] (src AS dst)"),
("COLLATION", "DROP COLLATION [IF EXISTS] <name>"),
("OPERATOR", "DROP OPERATOR [IF EXISTS] <op>(args)"),
("RULE", "DROP RULE [IF EXISTS] <name> ON <table>"),
("TABLESPACE", "DROP TABLESPACE [IF EXISTS] <name>"),
("SUBSCRIPTION", "DROP SUBSCRIPTION [IF EXISTS] <name>"),
("PUBLICATION", "DROP PUBLICATION [IF EXISTS] <name>"),
("FOREIGN TABLE", "DROP FOREIGN TABLE [IF EXISTS] <name>"),
("FOREIGN DATA WRAPPER", "DROP FOREIGN DATA WRAPPER [IF EXISTS] <name>"),
("SERVER", "DROP SERVER [IF EXISTS] <name>"),
("ROUTINE", "DROP ROUTINE [IF EXISTS] <name>(args)"),
("OPERATOR CLASS", "DROP OPERATOR CLASS [IF EXISTS] <name> USING <am>"),
("OPERATOR FAMILY", "DROP OPERATOR FAMILY [IF EXISTS] <name> USING <am>"),
("STATISTICS", "DROP STATISTICS [IF EXISTS] <name>"),
("ACCESS METHOD", "DROP ACCESS METHOD [IF EXISTS] <name>"),
("LANGUAGE", "DROP LANGUAGE [IF EXISTS] <name>"),
("CONVERSION", "DROP CONVERSION [IF EXISTS] <name>"),
("EVENT TRIGGER", "DROP EVENT TRIGGER [IF EXISTS] <name>"),
("TRANSFORM", "DROP TRANSFORM FOR <type> LANGUAGE <lang>"),
("TEXT SEARCH CONFIGURATION", "DROP TEXT SEARCH CONFIGURATION [IF EXISTS] <name>"),
("TEXT SEARCH DICTIONARY", "DROP TEXT SEARCH DICTIONARY [IF EXISTS] <name>"),
("TEXT SEARCH PARSER", "DROP TEXT SEARCH PARSER [IF EXISTS] <name>"),
("TEXT SEARCH TEMPLATE", "DROP TEXT SEARCH TEMPLATE [IF EXISTS] <name>"),
("OWNED", "DROP OWNED BY <role>[, ...] [CASCADE|RESTRICT]"),
("MAPPING", "DROP USER MAPPING [IF EXISTS] FOR <role> SERVER <srv>"),
])
}
pub(crate) fn alter_table_subaction_at(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
let pos: usize = (u32::from(offset) as usize).min(source.len());
let bytes = source.as_bytes();
let mut end = pos;
while end > 0 && bytes[end - 1].is_ascii_whitespace() {
end -= 1;
}
let mut start = end;
while start > 0 {
let b = bytes[start - 1];
if !(b.is_ascii_alphanumeric() || b == b'_') {
break;
}
start -= 1;
}
if start == end {
return None;
}
let word = source[start..end].to_ascii_uppercase();
if end > pos || pos != end + (pos - end) {
}
let between = &source[end..pos];
if !between.chars().all(|c| c.is_ascii_whitespace()) {
return None;
}
let mut prev_end = start;
while prev_end > 0 && bytes[prev_end - 1].is_ascii_whitespace() {
prev_end -= 1;
}
let mut prev_start = prev_end;
while prev_start > 0 {
let b = bytes[prev_start - 1];
if !(b.is_ascii_alphanumeric() || b == b'_') {
break;
}
prev_start -= 1;
}
let prev_word = if prev_start < prev_end { source[prev_start..prev_end].to_ascii_uppercase() } else { String::new() };
if matches!(prev_word.as_str(), "ADD" | "DROP" | "RENAME" | "ALTER") {
return None;
}
match word.as_str() {
"ADD" => Some(&[
("COLUMN", "ADD COLUMN <name> <type>"),
("CONSTRAINT", "ADD CONSTRAINT <name> <kind>"),
("PRIMARY KEY", "ADD PRIMARY KEY (cols)"),
("UNIQUE", "ADD UNIQUE (cols)"),
("FOREIGN KEY", "ADD FOREIGN KEY (col) REFERENCES other(col)"),
("CHECK", "ADD CHECK (predicate)"),
("EXCLUDE", "ADD EXCLUDE USING gist (col WITH op)"),
]),
"DROP" => Some(&[
("COLUMN", "DROP COLUMN <name> [CASCADE|RESTRICT]"),
("CONSTRAINT", "DROP CONSTRAINT <name> [CASCADE|RESTRICT]"),
]),
"RENAME" => Some(&[
("COLUMN", "RENAME COLUMN <old> TO <new>"),
("CONSTRAINT", "RENAME CONSTRAINT <old> TO <new>"),
("TO", "RENAME TO <new_table>"),
]),
"ALTER" => {
Some(&[("COLUMN", "ALTER COLUMN <name> <action>"), ("CONSTRAINT", "ALTER CONSTRAINT <name> DEFERRABLE|...]")])
},
"OWNER" => Some(&[("TO", "OWNER TO <role>")]),
"NULLS" => Some(&[("NOT DISTINCT", "NULLS NOT DISTINCT -- treat NULLs as equal for uniqueness")]),
_ => None,
}
}
pub(crate) fn cast_as_expects_type(source: &str, offset: TextSize) -> bool {
let pos: usize = (u32::from(offset) as usize).min(source.len());
let bytes = source.as_bytes();
let mut depth = 0i32;
let mut i = pos;
while i > 0 {
i -= 1;
match bytes[i] {
b')' => depth += 1,
b'(' => {
if depth == 0 {
break;
}
depth -= 1;
},
_ => {},
}
}
if i == 0 && bytes.first() != Some(&b'(') {
return false;
}
let mut e = i;
while e > 0 && bytes[e - 1].is_ascii_whitespace() {
e -= 1;
}
let mut s = e;
while s > 0 && (bytes[s - 1].is_ascii_alphanumeric() || bytes[s - 1] == b'_') {
s -= 1;
}
if s == e {
return false;
}
let word = &source[s..e];
if !word.eq_ignore_ascii_case("CAST") {
return false;
}
let inside = &source[i + 1..pos];
let inside_upper = inside.to_ascii_uppercase();
inside_upper.contains(" AS ")
}
pub(crate) fn order_by_nulls_expects_first_last(source: &str, offset: TextSize) -> bool {
let pos: usize = (u32::from(offset) as usize).min(source.len());
let before = &source[..pos];
if !before.ends_with(char::is_whitespace) {
return false;
}
let upper = before.to_ascii_uppercase();
let trimmed = upper.trim_end();
if !trimmed.ends_with(" NULLS") && trimmed != "NULLS" {
return false;
}
upper.contains("ORDER BY")
}
pub(crate) fn alter_table_inherit_expects_parent(source: &str, offset: TextSize) -> bool {
let (slice, upper) = stmt_slice_upper(source, offset);
if !slice.ends_with(char::is_whitespace) {
return false;
}
let words: Vec<&str> = upper.split_ascii_whitespace().collect();
if words.first() != Some(&"ALTER") || words.get(1) != Some(&"TABLE") {
return false;
}
let last = words.last().copied();
let second = if words.len() >= 2 { Some(words[words.len() - 2]) } else { None };
matches!(last, Some("INHERIT")) && (second != Some("NO") && second != Some("CHECK") || second == Some("NO"))
}
pub(crate) fn alter_column_set_value_keywords(
source: &str,
offset: TextSize,
) -> Option<&'static [(&'static str, &'static str)]> {
let (slice, upper_full) = stmt_slice_upper(source, offset);
let upper = upper_full.trim_end();
if !upper.contains("ALTER COLUMN") || !slice.ends_with(char::is_whitespace) {
return None;
}
if upper.ends_with(" SET STORAGE") {
return Some(&[
("PLAIN", "PLAIN -- inline, never TOASTed"),
("EXTERNAL", "EXTERNAL -- TOAST, no compression"),
("EXTENDED", "EXTENDED -- TOAST + compression (default for varlena)"),
("MAIN", "MAIN -- prefer inline, compress before TOAST"),
("DEFAULT", "DEFAULT -- per-type default"),
]);
}
if upper.ends_with(" SET COMPRESSION") {
return Some(&[
("pglz", "pglz -- the original PG compressor (always available)"),
("lz4", "lz4 -- faster, needs build-time --with-lz4"),
("default", "default -- inherit per-column / cluster default"),
]);
}
None
}
pub(crate) fn alter_column_after_set_subkeyword_expects_silence(source: &str, offset: TextSize) -> bool {
let (slice, upper_full) = stmt_slice_upper(source, offset);
let upper = upper_full.trim_end().to_string();
if !upper.contains("ALTER COLUMN") {
return false;
}
for kw in &[" SET DEFAULT", " SET STATISTICS", " SET STORAGE", " SET COMPRESSION"] {
if upper.ends_with(kw) && slice.ends_with(char::is_whitespace) {
return true;
}
}
false
}
#[derive(Copy, Clone)]
pub enum AlterColumnAction {
Set,
Drop,
}
pub(crate) fn alter_column_action_kind(source: &str, offset: TextSize) -> Option<AlterColumnAction> {
let (slice, upper) = stmt_slice_upper(source, offset);
let stmt = slice.as_str();
if !upper.contains("ALTER COLUMN") {
return None;
}
let trimmed = upper.trim_end();
let after_alter_col = upper.rsplit("ALTER COLUMN").next()?;
let after_trim = after_alter_col.trim_end();
if after_trim.ends_with(" SET") && stmt.ends_with(char::is_whitespace) {
return Some(AlterColumnAction::Set);
}
if after_trim.ends_with(" DROP") && stmt.ends_with(char::is_whitespace) {
return Some(AlterColumnAction::Drop);
}
let _ = trimmed;
None
}
pub(crate) fn alter_table_expects_type(source: &str, offset: TextSize) -> bool {
let (slice, upper) = stmt_slice_upper(source, offset);
let stmt = slice.as_str();
if !upper.contains("ALTER TABLE") {
return false;
}
let Some(add_at) = upper.rfind("ADD COLUMN") else { return false };
let after = &stmt[add_at + "ADD COLUMN".len()..];
let mut tokens = after.split_ascii_whitespace().peekable();
if tokens.peek().is_some_and(|w| w.eq_ignore_ascii_case("IF")) {
tokens.next();
if tokens.peek().is_some_and(|w| w.eq_ignore_ascii_case("NOT")) {
tokens.next();
}
if tokens.peek().is_some_and(|w| w.eq_ignore_ascii_case("EXISTS")) {
tokens.next();
}
}
if tokens.next().is_none() {
return false;
}
let rest_after_name = stmt[add_at + "ADD COLUMN".len()..].trim_start().split_ascii_whitespace().collect::<Vec<_>>();
let mut effective = rest_after_name.iter().peekable();
if effective.peek().is_some_and(|w| w.eq_ignore_ascii_case("IF")) {
effective.next();
if effective.peek().is_some_and(|w| w.eq_ignore_ascii_case("NOT")) {
effective.next();
}
if effective.peek().is_some_and(|w| w.eq_ignore_ascii_case("EXISTS")) {
effective.next();
}
}
let rest: Vec<&&str> = effective.collect();
match rest.len() {
1 => stmt.ends_with(char::is_whitespace), 2 => !stmt.ends_with(char::is_whitespace), _ => false,
}
}
pub(crate) fn dml_drop_or_truncate_expects_table(source: &str, offset: TextSize) -> bool {
let (slice, upper) = stmt_slice_upper(source, offset);
let stmt = slice.as_str();
let trimmed_upper = upper.trim_start();
let kinds: &[(&[&str], &[&str])] = &[
(&["DROP", "TABLE"], &["IF", "EXISTS", "ONLY"]),
(&["DROP", "VIEW"], &["IF", "EXISTS"]),
(&["DROP", "MATERIALIZED", "VIEW"], &["IF", "EXISTS"]),
(&["DROP", "SEQUENCE"], &["IF", "EXISTS"]),
(&["DROP", "INDEX"], &["IF", "EXISTS", "CONCURRENTLY"]),
(&["TRUNCATE", "TABLE"], &["ONLY"]),
(&["TRUNCATE"], &["ONLY", "TABLE"]),
(&["VACUUM"], &["FULL", "FREEZE", "VERBOSE", "ANALYZE"]),
(&["VACUUM", "ANALYZE"], &["VERBOSE"]),
(&["VACUUM", "FULL"], &["VERBOSE", "ANALYZE"]),
(&["ANALYZE"], &["VERBOSE", "SKIP_LOCKED"]),
(&["COPY"], &[]),
(&["COMMENT", "ON", "TABLE"], &[]),
(&["COMMENT", "ON", "VIEW"], &[]),
(&["COMMENT", "ON", "MATERIALIZED", "VIEW"], &[]),
(&["COMMENT", "ON", "INDEX"], &[]),
(&["COMMENT", "ON", "SEQUENCE"], &[]),
(&["REFRESH", "MATERIALIZED", "VIEW"], &["CONCURRENTLY"]),
(&["LOCK"], &["TABLE"]),
(&["LOCK", "TABLE"], &["ONLY"]),
(&["REINDEX", "TABLE"], &["CONCURRENTLY"]),
(&["REINDEX", "INDEX"], &["CONCURRENTLY"]),
(&["MERGE", "INTO"], &["ONLY"]),
];
let words: Vec<&str> = trimmed_upper.split_ascii_whitespace().collect();
for (kw_seq, mods) in kinds {
if words.len() < kw_seq.len() {
continue;
}
if kw_seq.iter().zip(words.iter()).all(|(k, w)| {
let cleaned = w.trim_end_matches(|c: char| !c.is_ascii_alphanumeric() && c != '_');
cleaned.eq_ignore_ascii_case(k)
}) {
let mut i = kw_seq.len();
while i < words.len() && mods.iter().any(|m| words[i].eq_ignore_ascii_case(m)) {
i += 1;
}
let ends_with_comma = stmt.trim_end().ends_with(',');
let last_word_is_partial = !stmt.ends_with(char::is_whitespace);
if i >= words.len() || ends_with_comma || last_word_is_partial {
return true;
}
}
}
false
}
pub(crate) fn alter_table_existing_column_target(source: &str, offset: TextSize) -> Option<String> {
let (slice, upper) = stmt_slice_upper(source, offset);
let stmt = slice.as_str();
let alter_at = upper.find("ALTER TABLE")?;
let trimmed = upper.trim_end();
let preceded = |kw: &str| trimmed.ends_with(kw);
let in_column_slot = preceded(" DROP COLUMN")
|| preceded(" DROP COLUMN IF EXISTS")
|| preceded(" RENAME COLUMN")
|| preceded(" ALTER COLUMN");
if !in_column_slot {
return None;
}
let after = alter_at + "ALTER TABLE".len();
let rest = &stmt[after..];
let mut cursor = 0usize;
let mut tokens: Vec<&str> = Vec::new();
for tok in rest.split_ascii_whitespace() {
let tok_pos = rest[cursor..].find(tok).map(|p| cursor + p).unwrap_or(cursor);
cursor = tok_pos + tok.len();
tokens.push(tok);
if tokens.len() >= 4 {
break;
}
}
let mods: &[&str] = &["IF", "EXISTS", "ONLY"];
let table_tok = tokens.into_iter().find(|t| !mods.iter().any(|m| t.eq_ignore_ascii_case(m)))?;
let table = table_tok.rsplit('.').next().unwrap_or(table_tok).trim_matches('"').trim_end_matches(';').to_string();
if table.is_empty() {
return None;
}
Some(table)
}
pub(crate) fn dml_target_table(source: &str, offset: TextSize) -> Option<String> {
let (slice, upper) = stmt_slice_upper(source, offset);
let stmt = slice.as_str();
let (anchor, kw_len) = if let Some(a) = upper.rfind("INSERT INTO") {
(a, "INSERT INTO".len())
} else if let Some(a) = upper.rfind("DELETE FROM") {
(a, "DELETE FROM".len())
} else {
let a = upper.rfind("UPDATE ")?;
(a, "UPDATE".len())
};
let after = anchor + kw_len;
let rest = &stmt[after..];
let lead = rest.len() - rest.trim_start().len();
let raw = &rest[lead..];
let id_end = raw.find(|c: char| !c.is_ascii_alphanumeric() && c != '_' && c != '.' && c != '"').unwrap_or(raw.len());
let table = raw[..id_end].rsplit('.').next().unwrap_or(&raw[..id_end]).trim_matches('"').to_string();
if table.is_empty() {
return None;
}
Some(table)
}
pub(crate) fn insert_target_table_name_only(source: &str) -> Option<String> {
let upper = source.to_ascii_uppercase();
let at = upper.rfind("INSERT INTO")?;
let after = at + "INSERT INTO".len();
let rest = &source[after..];
let lead = rest.len() - rest.trim_start().len();
let raw = &rest[lead..];
let id_end = raw.find(|c: char| !c.is_ascii_alphanumeric() && c != '_' && c != '.' && c != '"').unwrap_or(raw.len());
let table = raw[..id_end].rsplit('.').next().unwrap_or(&raw[..id_end]).trim_matches('"').to_string();
if table.is_empty() {
return None;
}
Some(table)
}
pub(crate) fn insert_target_table(source: &str, offset: TextSize) -> Option<String> {
let (slice, upper) = stmt_slice_upper(source, offset);
let stmt = slice.as_str();
let at = upper.rfind("INSERT INTO")?;
let after = at + "INSERT INTO".len();
let rest = &stmt[after..];
let lead = rest.len() - rest.trim_start().len();
let raw = &rest[lead..];
let id_end = raw.find(|c: char| !c.is_ascii_alphanumeric() && c != '_' && c != '.' && c != '"').unwrap_or(raw.len());
let table = raw[..id_end].rsplit('.').next().unwrap_or(&raw[..id_end]).trim_matches('"').to_string();
if table.is_empty() {
return None;
}
let after_table = after + lead + id_end;
let trail = &stmt[after_table..];
let paren_at = trail.find('(')?;
let paren_body = &trail[paren_at + 1..];
if paren_body.contains(')') {
return None;
}
Some(table)
}
pub(crate) fn is_column_listed(it: &Item, used: &std::collections::HashSet<String>) -> bool {
if !matches!(it.kind, crate::item::ItemKind::Column) {
return false;
}
let tail = it.label.rsplit('.').next().unwrap_or(&it.label);
used.contains(&tail.to_ascii_lowercase())
}
pub(crate) fn used_columns_in_clause(source: &str, offset: TextSize) -> std::collections::HashSet<String> {
let pos: usize = u32::from(offset) as usize;
let mut pos = pos.min(source.len());
while pos > 0 && !source.is_char_boundary(pos) {
pos -= 1;
}
let bytes = source.as_bytes();
let mut anchor = 0usize;
let mut depth = 0i32;
let mut i = pos;
while i > 0 {
let b = bytes[i - 1];
if b >= 128 {
i -= 1;
continue;
}
let c = b as char;
if c == ')' {
depth += 1;
i -= 1;
continue;
}
if c == '(' {
if depth == 0 {
anchor = i;
break;
}
depth -= 1;
i -= 1;
continue;
}
if c == ';' {
anchor = i;
break;
}
let _ = c;
if match_kw_at(bytes, i, b"SELECT")
|| match_kw_at(bytes, i, b"RETURNING")
|| match_kw_at(bytes, i, b"VALUES")
|| match_kw_at(bytes, i, b"SET")
|| match_kw_at(bytes, i, b"BY")
{
anchor = i;
break;
}
i -= 1;
}
let region = if source.is_char_boundary(anchor) && source.is_char_boundary(pos) { &source[anchor..pos] } else { "" };
collect_idents_csv(region)
}
pub(crate) fn match_kw_at(bytes: &[u8], end: usize, kw: &[u8]) -> bool {
let len = kw.len();
if end < len {
return false;
}
let start = end - len;
for k in 0..len {
let a = bytes[start + k];
let b = kw[k];
if !a.is_ascii() {
return false;
}
if a.to_ascii_uppercase() != b {
return false;
}
}
let prev_ok = if start == 0 {
true
} else {
let prev = bytes[start - 1];
prev >= 128 || !is_word_char(prev as char)
};
let next_ok = if end >= bytes.len() {
true
} else {
let next = bytes[end];
next >= 128 || !is_word_char(next as char)
};
prev_ok && next_ok
}
pub(crate) fn is_word_char(c: char) -> bool {
c.is_ascii_alphanumeric() || c == '_'
}
pub(crate) fn collect_idents_csv(region: &str) -> std::collections::HashSet<String> {
let mut out = std::collections::HashSet::new();
let bytes = region.as_bytes();
let n = bytes.len();
let mut depth = 0i32;
let mut item_start = 0usize;
let mut i = 0usize;
while i < n {
let c = bytes[i] as char;
if c == '\'' {
i += 1;
while i < n && bytes[i] != b'\'' {
i += 1;
}
i = (i + 1).min(n);
continue;
}
if c == '(' {
depth += 1;
i += 1;
continue;
}
if c == ')' {
depth -= 1;
i += 1;
continue;
}
if c == ',' && depth == 0 {
push_first_ident(®ion[item_start..i], &mut out);
item_start = i + 1;
}
i += 1;
}
push_first_ident(®ion[item_start..], &mut out);
out
}
pub(crate) fn push_first_ident(item: &str, out: &mut std::collections::HashSet<String>) {
let item = item.trim();
if item.is_empty() {
return;
}
let head_end =
item.find(|c: char| !c.is_ascii_alphanumeric() && c != '_' && c != '.' && c != '"').unwrap_or(item.len());
let head = item[..head_end].trim_matches('"');
if head.is_empty() {
return;
}
let tail = head.rsplit('.').next().unwrap_or(head).trim_matches('"');
if !tail.is_empty() {
out.insert(tail.to_ascii_lowercase());
}
}
pub(crate) fn enclosing_fn_trigger_table(source: &str, pos: usize, cat: &Catalog) -> Option<String> {
let upper = source.to_ascii_uppercase();
let mut latest: Option<usize> = None;
for needle in ["CREATE OR REPLACE FUNCTION ", "CREATE FUNCTION ", "CREATE OR REPLACE PROCEDURE ", "CREATE PROCEDURE "]
{
let mut from = 0usize;
while let Some(rel) = upper[from..].find(needle) {
let p = from + rel;
if p > pos {
break;
}
latest = Some(p + needle.len());
from = p + needle.len();
}
}
let after = source[latest?..].trim_start();
let fn_name: String = after.chars().take_while(|c| c.is_alphanumeric() || *c == '_' || *c == '.').collect();
let fn_short = fn_name.rsplit('.').next().unwrap_or(&fn_name);
if fn_short.is_empty() {
return None;
}
if let Some(t) = scan_buffer_for_trigger_fn(source, fn_short) {
return Some(t);
}
for t in cat.tables() {
for tg in &t.triggers {
let fn_upper = tg.function.to_ascii_uppercase();
let needle = fn_short.to_ascii_uppercase();
if fn_upper.contains(&needle) {
return Some(t.name.clone());
}
}
}
None
}
pub(crate) fn scan_buffer_for_trigger_fn(source: &str, fn_name: &str) -> Option<String> {
let upper = source.to_ascii_uppercase();
let mut from = 0usize;
while let Some(rel) = upper[from..].find("CREATE TRIGGER") {
let p = from + rel;
let stmt_end = upper[p..].find(';').map(|e| p + e).unwrap_or(upper.len());
let stmt_upper = &upper[p..stmt_end];
let fn_upper = fn_name.to_ascii_uppercase();
let mentions = stmt_upper.contains(&format!("EXECUTE FUNCTION {}", fn_upper))
|| stmt_upper.contains(&format!("EXECUTE PROCEDURE {}", fn_upper))
|| stmt_upper.contains(&format!("EXECUTE FUNCTION PUBLIC.{}", fn_upper))
|| stmt_upper.contains(&format!("EXECUTE PROCEDURE PUBLIC.{}", fn_upper));
if mentions && let Some(on_pos) = stmt_upper.find(" ON ") {
let after = &source[p + on_pos + 4..stmt_end];
let tok: String =
after.trim_start().chars().take_while(|c| c.is_alphanumeric() || *c == '_' || *c == '.').collect();
if !tok.is_empty() {
return Some(tok.rsplit('.').next().unwrap_or(&tok).to_string());
}
}
from = stmt_end.max(p + 1);
}
None
}
pub(crate) fn trigger_target_table(source: &str) -> Option<String> {
let upper = source.to_uppercase();
let idx = ["CREATE OR REPLACE TRIGGER", "CREATE CONSTRAINT TRIGGER", "CREATE TRIGGER"]
.iter()
.filter_map(|kw| upper.rfind(kw))
.max()?;
let rest_upper = &upper[idx..];
let on_idx = rest_upper.find(" ON ")?;
let after = &source[idx + on_idx + 4..];
let tok = after
.trim_start()
.split(|c: char| c.is_whitespace() || c == '(' || c == ';' || c == ',')
.find(|s| !s.is_empty())?;
let tok = if tok.eq_ignore_ascii_case("ONLY") {
after.trim_start().split_ascii_whitespace().nth(1).unwrap_or(tok)
} else {
tok
};
Some(tok.split('.').next_back().unwrap_or(tok).trim_matches('"').to_string())
}
pub(crate) fn policy_target_table(source: &str) -> Option<String> {
let upper = source.to_uppercase();
let idx = upper.rfind("CREATE POLICY")?;
let rest_upper = &upper[idx..];
let on_idx = rest_upper.find(" ON ")?;
let after = &source[idx + on_idx + 4..];
let tok = after
.trim_start()
.split(|c: char| c.is_whitespace() || c == '(' || c == ';' || c == ',')
.find(|s| !s.is_empty())?;
Some(tok.split('.').next_back().unwrap_or(tok).trim_matches('"').to_string())
}
pub(crate) fn policy_expr_items(source: &str, offset: TextSize, cat: &Catalog) -> Option<Vec<Item>> {
let (_, upper) = stmt_slice_upper(source, offset);
if !upper.contains("POLICY") {
return None;
}
let mut open_at = None;
for kw in ["USING (", "WITH CHECK ("] {
if let Some(rel) = upper.rfind(kw) {
let candidate = rel + kw.len();
let mut depth = 1i32;
for b in upper[candidate..].bytes() {
match b {
b'(' => depth += 1,
b')' => depth -= 1,
_ => {},
}
}
if depth >= 1 && open_at.is_none_or(|o: usize| candidate > o) {
open_at = Some(candidate);
}
}
}
open_at?;
let mut out = Vec::new();
if let Some(t) = policy_target_table(source) {
sources::columns_of_table(cat, None, &t, &mut out);
if out.is_empty() {
for name in crate::source_tables::buffer_column_names(source, &t) {
out.push(crate::item::Item {
label: name.clone(),
kind: crate::item::ItemKind::Column,
detail: Some(format!("column of `{t}` (buffer)")),
description: None,
documentation_md: None,
insert_text: name,
is_snippet: false,
kb_entry: None,
sort_priority: 0,
});
}
}
}
push_all_functions(cat, &mut out);
sources::expression_keywords(&mut out);
Some(out)
}
fn plpgsql_inner_stmt_span(source: &str, pos: usize) -> &str {
let before = &source[..pos];
let upper = before.to_ascii_uppercase();
let mut boundary = upper.rfind(';').map(|p| p + 1).unwrap_or(0);
for kw in ["BEGIN", "THEN", "ELSE", "LOOP", "DECLARE"] {
if let Some(p) = upper.rfind(kw) {
let after = p + kw.len();
if after > boundary {
boundary = after;
}
}
}
&source[boundary..pos]
}
pub(crate) fn plpgsql_body_targeted_items(
source: &str,
offset: TextSize,
file: &ParsedFile,
scopes: &[Scope],
cat: &Catalog,
) -> Option<Vec<Item>> {
let pos: usize = u32::from(offset) as usize;
let pos = pos.min(source.len());
let span = plpgsql_inner_stmt_span(source, pos);
let upper = span.to_ascii_uppercase();
let has_dml_verb = ["SELECT", "UPDATE", "DELETE", "INSERT"].iter().any(|kw| upper.contains(kw));
if !has_dml_verb {
return None;
}
if upper.contains("RETURNING") {
let trimmed = upper.trim_end();
let words: Vec<&str> = trimmed.split_ascii_whitespace().collect();
if words.last().copied() == Some("AS") {
return Some(Vec::new());
}
let mut out = Vec::new();
if let Some(target) = dml_target_table(source, offset) {
sources::columns_of_table(cat, None, &target, &mut out);
} else {
push_scope_columns_or_all(file, scopes, source, cat, offset, &mut out);
}
push_aliases(file, scopes, source, offset, &mut out);
push_all_functions(cat, &mut out);
sources::expression_keywords(&mut out);
let used = used_columns_in_clause(source, offset);
if !used.is_empty() {
out.retain(|it| !is_column_listed(it, &used));
}
return Some(out);
}
if let Some(target) = insert_target_table(source, offset) {
let mut out = Vec::new();
sources::columns_of_table(cat, None, &target, &mut out);
let used = used_columns_in_clause(source, offset);
if !used.is_empty() {
out.retain(|it| !is_column_listed(it, &used));
}
return Some(out);
}
if update_set_at_column_slot(source, offset)
&& let Some(target) = dml_target_table(source, offset)
{
let mut out = Vec::new();
sources::columns_of_table(cat, None, &target, &mut out);
let used = used_columns_in_clause(source, offset);
if !used.is_empty() {
out.retain(|it| !is_column_listed(it, &used));
}
return Some(out);
}
let trimmed = upper.trim_end();
let mut words: Vec<&str> = trimmed.split_ascii_whitespace().collect();
if pos > 0 && source.as_bytes().get(pos - 1).is_some_and(|b| b.is_ascii_alphanumeric() || *b == b'_') {
words.pop();
}
let last = words.last().copied();
let prev = if words.len() >= 2 { words.get(words.len() - 2).copied() } else { None };
let mut out = Vec::new();
if matches!(last, Some("FROM") | Some("JOIN")) {
sources::tables(cat, &mut out);
return Some(out);
}
if matches!(last, Some("WHERE") | Some("AND") | Some("OR")) {
push_scope_columns_or_all(file, scopes, source, cat, offset, &mut out);
push_aliases(file, scopes, source, offset, &mut out);
push_all_functions(cat, &mut out);
sources::expression_keywords(&mut out);
return Some(out);
}
if last == Some("INTO") && prev == Some("INSERT") {
sources::tables(cat, &mut out);
return Some(out);
}
if last == Some("UPDATE") {
sources::tables(cat, &mut out);
return Some(out);
}
None
}
pub(crate) fn dot_alias(source: &str, offset: TextSize) -> Option<String> {
let pos: usize = offset.into();
let pos = floor_char_boundary(source, pos.min(source.len()));
let before = &source[..pos];
let dot_idx = before.rfind('.')?;
let after_dot = &before[dot_idx + 1..];
if !after_dot.chars().all(|c| c.is_alphanumeric() || c == '_') {
return None;
}
let pre_dot = &before[..dot_idx];
if pre_dot.ends_with('"') {
let body_end = pre_dot.len() - 1;
if let Some(open) = pre_dot[..body_end].rfind('"') {
let inner = &pre_dot[open + 1..body_end];
if !inner.is_empty() {
return Some(inner.to_string());
}
}
}
let alias: String =
pre_dot.chars().rev().take_while(|c| c.is_alphanumeric() || *c == '_').collect::<String>().chars().rev().collect();
if alias.is_empty() { None } else { Some(alias) }
}
pub(crate) fn floor_char_boundary(s: &str, byte: usize) -> usize {
let mut b = byte.min(s.len());
while b > 0 && !s.is_char_boundary(b) {
b -= 1;
}
b
}
pub(crate) fn cursor_in_inert_span(source: &str, offset: usize) -> bool {
let bytes = source.as_bytes();
let n = bytes.len();
let limit = offset.min(n);
let mut i = 0usize;
let mut state: u8 = 0;
while i < limit {
match state {
0 => {
if bytes[i] == b'$' {
let mut t = i + 1;
while t < n && (bytes[t].is_ascii_alphanumeric() || bytes[t] == b'_') {
t += 1;
}
if t < n && bytes[t] == b'$' {
let tag_end = t + 1;
let tag = &bytes[i..tag_end];
let mut k = tag_end;
let mut close = None;
while k + tag.len() <= n {
if &bytes[k..k + tag.len()] == tag {
close = Some(k);
break;
}
k += 1;
}
let body_close_end = close.map(|p| p + tag.len()).unwrap_or(n);
if offset > tag_end && offset <= close.unwrap_or(n) {
let body_off = offset - tag_end;
let body_src = &source[tag_end..close.unwrap_or(n)];
return cursor_in_inert_span(body_src, body_off);
}
i = body_close_end;
continue;
}
}
match bytes[i] {
b'\'' => {
state = 1;
i += 1;
continue;
},
b'-' if i + 1 < n && bytes[i + 1] == b'-' => {
state = 2;
i += 2;
continue;
},
b'/' if i + 1 < n && bytes[i + 1] == b'*' => {
state = 3;
i += 2;
continue;
},
_ => {
i += 1;
},
}
},
1 => {
if bytes[i] == b'\'' {
if i + 1 < n && bytes[i + 1] == b'\'' {
i += 2;
continue;
}
state = 0;
i += 1;
continue;
}
i += 1;
},
2 => {
if bytes[i] == b'\n' {
state = 0;
}
i += 1;
},
3 => {
if bytes[i] == b'*' && i + 1 < n && bytes[i + 1] == b'/' {
state = 0;
i += 2;
continue;
}
i += 1;
},
_ => break,
}
}
state != 0
}
pub(crate) struct ExecuteStringSpan {
pub content_start: usize,
pub content_end: usize,
pub dollar_quoted: bool,
}
fn preceded_by_word(source: &str, pos: usize, word: &str) -> bool {
let bytes = source.as_bytes();
let mut i = pos.min(bytes.len());
while i > 0 && bytes[i - 1].is_ascii_whitespace() {
i -= 1;
}
let word_end = i;
let mut word_start = i;
while word_start > 0 && (bytes[word_start - 1].is_ascii_alphanumeric() || bytes[word_start - 1] == b'_') {
word_start -= 1;
}
if word_start == word_end {
return false;
}
source[word_start..word_end].eq_ignore_ascii_case(word)
}
fn followed_by_concat(source: &str, pos: usize) -> bool {
let bytes = source.as_bytes();
let mut i = pos;
while i < bytes.len() && bytes[i].is_ascii_whitespace() {
i += 1;
}
bytes.get(i) == Some(&b'|') && bytes.get(i + 1) == Some(&b'|')
}
pub(crate) fn execute_dynamic_sql_span(source: &str, offset: usize) -> Option<ExecuteStringSpan> {
let bytes = source.as_bytes();
let n = bytes.len();
let limit = offset.min(n);
let mut i = 0usize;
let mut state: u8 = 0;
let mut string_start = 0usize;
while i < limit {
match state {
0 => {
if bytes[i] == b'$' {
let mut t = i + 1;
while t < n && (bytes[t].is_ascii_alphanumeric() || bytes[t] == b'_') {
t += 1;
}
if t < n && bytes[t] == b'$' {
let tag_end = t + 1;
let tag = &bytes[i..tag_end];
let mut k = tag_end;
let mut close = None;
while k + tag.len() <= n {
if &bytes[k..k + tag.len()] == tag {
close = Some(k);
break;
}
k += 1;
}
let body_end = close.unwrap_or(n);
let body_close_end = close.map(|p| p + tag.len()).unwrap_or(n);
if offset >= tag_end
&& offset <= body_end
&& preceded_by_word(source, i, "EXECUTE")
&& !followed_by_concat(source, body_close_end)
{
return Some(ExecuteStringSpan { content_start: tag_end, content_end: body_end, dollar_quoted: true });
}
if offset > tag_end && offset <= body_end {
let body_off = offset - tag_end;
let body_src = &source[tag_end..body_end];
return execute_dynamic_sql_span(body_src, body_off).map(|s| ExecuteStringSpan {
content_start: s.content_start + tag_end,
content_end: s.content_end + tag_end,
dollar_quoted: s.dollar_quoted,
});
}
i = body_close_end;
continue;
}
}
match bytes[i] {
b'\'' => {
state = 1;
string_start = i;
i += 1;
continue;
},
b'-' if i + 1 < n && bytes[i + 1] == b'-' => {
state = 2;
i += 2;
continue;
},
b'/' if i + 1 < n && bytes[i + 1] == b'*' => {
state = 3;
i += 2;
continue;
},
_ => {
i += 1;
},
}
},
1 => {
if bytes[i] == b'\'' {
if i + 1 < n && bytes[i + 1] == b'\'' {
i += 2;
continue;
}
state = 0;
i += 1;
continue;
}
i += 1;
},
2 => {
if bytes[i] == b'\n' {
state = 0;
}
i += 1;
},
3 => {
if bytes[i] == b'*' && i + 1 < n && bytes[i + 1] == b'/' {
state = 0;
i += 2;
continue;
}
i += 1;
},
_ => break,
}
}
if state != 1 {
return None;
}
let content_start = string_start + 1;
let mut k = limit;
let content_end = loop {
match bytes.get(k) {
None => break n,
Some(b'\'') => {
if bytes.get(k + 1) == Some(&b'\'') {
k += 2;
continue;
}
break k;
},
Some(_) => k += 1,
}
};
let close_end = (content_end + 1).min(n);
if !preceded_by_word(source, string_start, "EXECUTE") || followed_by_concat(source, close_end) {
return None;
}
Some(ExecuteStringSpan { content_start, content_end, dollar_quoted: false })
}
pub(crate) fn unescape_single_quoted(raw: &str, cursor_in_raw: usize) -> (String, usize) {
let bytes = raw.as_bytes();
let n = bytes.len();
let cursor_in_raw = cursor_in_raw.min(n);
let mut out = String::with_capacity(raw.len());
let mut mapped_cursor = cursor_in_raw;
let mut i = 0usize;
while i < n {
if bytes[i] == b'\'' && i + 1 < n && bytes[i + 1] == b'\'' {
if i + 1 < cursor_in_raw {
mapped_cursor -= 1;
}
out.push('\'');
i += 2;
continue;
}
let ch_len = raw[i..].chars().next().map(|c| c.len_utf8()).unwrap_or(1);
out.push_str(&raw[i..i + ch_len]);
i += ch_len;
}
(out, mapped_cursor)
}
pub(crate) fn fresh_name_slot_optional_keyword(source: &str, offset: TextSize) -> Option<&'static str> {
let (slice_owned, _) = stmt_slice_upper(source, offset);
let before = slice_owned.as_str();
let trimmed = before.trim_end_matches(|c: char| c.is_whitespace());
if before.len() == trimmed.len() {
return None; }
let upper = trimmed.to_ascii_uppercase();
let supports_index: &[&str] = &[
"CREATE TABLE",
"CREATE TEMP TABLE",
"CREATE TEMPORARY TABLE",
"CREATE UNLOGGED TABLE",
"CREATE GLOBAL TABLE",
"CREATE LOCAL TABLE",
"CREATE VIEW",
"CREATE MATERIALIZED VIEW",
"CREATE INDEX",
"CREATE UNIQUE INDEX",
"CREATE SCHEMA",
"CREATE SEQUENCE",
"CREATE TYPE",
"CREATE DOMAIN",
"CREATE TRIGGER",
"CREATE POLICY",
"CREATE EXTENSION",
"CREATE FOREIGN TABLE",
"CREATE PROCEDURE",
"CREATE FUNCTION",
"CREATE OR REPLACE TRIGGER",
"CREATE OR REPLACE FUNCTION",
"CREATE OR REPLACE PROCEDURE",
"CREATE OR REPLACE VIEW",
];
if supports_index.iter().any(|p| upper.ends_with(p)) {
return Some("IF NOT EXISTS");
}
None
}
pub(crate) fn at_fresh_name_slot(source: &str, offset: TextSize) -> bool {
let (slice_owned, upper) = stmt_slice_upper(source, offset);
let _before = slice_owned.as_str();
let bytes = upper.as_bytes();
let n = bytes.len();
let mut end = n;
while end > 0 && (bytes[end - 1].is_ascii_alphanumeric() || bytes[end - 1] == b'_') {
end -= 1;
}
let lead = &upper[..end].trim_end();
let lead = lead.strip_suffix("IF NOT EXISTS").unwrap_or(lead).trim_end();
const PATTERNS: &[&str] = &[
"CREATE TABLE",
"CREATE TEMP TABLE",
"CREATE TEMPORARY TABLE",
"CREATE UNLOGGED TABLE",
"CREATE GLOBAL TABLE",
"CREATE LOCAL TABLE",
"CREATE VIEW",
"CREATE OR REPLACE VIEW",
"CREATE MATERIALIZED VIEW",
"CREATE FUNCTION",
"CREATE OR REPLACE FUNCTION",
"CREATE PROCEDURE",
"CREATE OR REPLACE PROCEDURE",
"CREATE INDEX",
"CREATE UNIQUE INDEX",
"CREATE SCHEMA",
"CREATE SEQUENCE",
"CREATE TYPE",
"CREATE DOMAIN",
"CREATE TRIGGER",
"CREATE OR REPLACE TRIGGER",
"CREATE POLICY",
"CREATE EXTENSION",
"CREATE ROLE",
"CREATE USER",
"CREATE GROUP",
"CREATE DATABASE",
"CREATE TABLESPACE",
"CREATE LANGUAGE",
"CREATE AGGREGATE",
"CREATE CAST",
"CREATE COLLATION",
"CREATE CONVERSION",
"CREATE OPERATOR",
"CREATE RULE",
"CREATE PUBLICATION",
"CREATE SUBSCRIPTION",
"CREATE FOREIGN TABLE",
"CREATE FOREIGN DATA WRAPPER",
"CREATE SERVER",
"CREATE USER MAPPING",
"CREATE TEXT SEARCH CONFIGURATION",
"CREATE TEXT SEARCH DICTIONARY",
"CREATE TEXT SEARCH PARSER",
"CREATE TEXT SEARCH TEMPLATE",
"CONSTRAINT",
"ADD COLUMN",
"ADD CONSTRAINT",
"RENAME TO",
"RENAME CONSTRAINT",
"LISTEN",
"UNLISTEN",
"NOTIFY",
"PREPARE",
"DEALLOCATE",
"DECLARE",
"IMPORT FOREIGN SCHEMA",
"CHECKPOINT",
"FETCH",
"MOVE",
"CLOSE",
"OPEN",
"CREATE EVENT TRIGGER",
"CREATE INDEX CONCURRENTLY",
"CREATE UNIQUE INDEX CONCURRENTLY",
"WITH RECURSIVE",
"USE",
"VALUES",
];
if PATTERNS.iter().any(|p| lead.ends_with(p)) {
return true;
}
let tokens: Vec<&str> = lead.split_ascii_whitespace().collect();
let n = tokens.len();
if n >= 4 && tokens[n - 4] == "RENAME" && tokens[n - 3] == "COLUMN" && tokens[n - 1] == "TO" {
return true;
}
false
}
pub(crate) fn dedup_items(items: Vec<Item>) -> Vec<Item> {
use crate::item::ItemKind;
use std::collections::HashMap;
let mut idx: HashMap<(String, ItemKind), usize> = HashMap::new();
let mut out: Vec<Item> = Vec::with_capacity(items.len());
for it in items {
let key = (it.label.to_ascii_lowercase(), it.kind);
if let Some(&existing) = idx.get(&key) {
if let (Some(existing_detail), Some(new_detail)) = (out[existing].detail.as_ref(), it.detail.as_ref()) {
if existing_detail != new_detail && !existing_detail.contains(new_detail.as_str()) {
let merged = format!("{existing_detail}, {new_detail}");
out[existing].detail = Some(merged);
}
} else if out[existing].detail.is_none() && it.detail.is_some() {
out[existing].detail = it.detail;
}
if it.sort_priority < out[existing].sort_priority {
out[existing].sort_priority = it.sort_priority;
}
continue;
}
idx.insert(key, out.len());
out.push(it);
}
out
}
pub(crate) fn push_all_functions(cat: &Catalog, out: &mut Vec<Item>) {
let start = out.len();
sources::functions(out);
sources::db_functions(cat, out);
for it in &mut out[start..] {
it.sort_priority = 3;
}
}
pub(crate) fn push_cte_names(file: &ParsedFile, scopes: &[Scope], source: &str, offset: TextSize, out: &mut Vec<Item>) {
let mut names: Vec<String> = Vec::new();
if let Some(scope) = scope_for_offset(file, scopes, offset) {
for name in scope.cte_columns.keys() {
if !name.is_empty() {
names.push(name.clone());
}
}
}
if names.is_empty() {
names = fallback::cte_names_from_text(current_statement_span(source, offset));
}
for name in names {
if name.is_empty() {
continue;
}
out.push(crate::item::Item {
label: name.clone(),
kind: crate::item::ItemKind::Table,
detail: Some("CTE".into()),
description: None,
documentation_md: Some(format!("**CTE** `{name}` (defined by WITH in this statement)\n")),
insert_text: name.clone(),
is_snippet: false,
kb_entry: None,
sort_priority: 0,
});
}
}
pub(crate) fn push_aliases(file: &ParsedFile, scopes: &[Scope], source: &str, offset: TextSize, out: &mut Vec<Item>) {
let start = out.len();
if let Some(scope) = scope_for_offset(file, scopes, offset) {
sources::aliases_in_scope(scope, out);
}
if out.len() == start
&& let Some(scope) = fallback::scope_from_text(current_statement_span(source, offset))
{
sources::aliases_in_scope(&scope, out);
}
}
pub(crate) fn push_scope_columns_or_all(
file: &ParsedFile,
scopes: &[Scope],
source: &str,
cat: &Catalog,
offset: TextSize,
out: &mut Vec<Item>,
) {
let start = out.len();
let mut had_scope = false;
if let Some(scope) = scope_for_offset(file, scopes, offset) {
if scope_has_catalog_binding(scope, cat) {
had_scope = true;
}
push_scope_columns(scope, cat, out);
}
if !had_scope && let Some(fb) = fallback::scope_from_text(current_statement_span(source, offset)) {
had_scope = scope_has_catalog_binding(&fb, cat);
push_scope_columns(&fb, cat, out);
}
for it in &mut out[start..] {
it.sort_priority = 0;
}
if !had_scope {
let fb_start = out.len();
sources::columns_all(cat, out);
sources::tables(cat, out);
for it in &mut out[fb_start..] {
it.sort_priority = 4;
}
}
}
pub(crate) fn scope_has_catalog_binding(scope: &Scope, cat: &Catalog) -> bool {
scope.tables().any(|b| cat.find_table(b.table.schema.as_deref(), &b.table.name).is_some())
}
pub(crate) fn push_scope_columns(scope: &Scope, cat: &Catalog, out: &mut Vec<Item>) {
use std::collections::HashSet;
let mut seen: HashSet<String> = HashSet::new();
for b in scope.tables() {
if b.alias != b.table.name {
continue;
}
if !seen.insert(b.table.name.to_ascii_lowercase()) {
continue;
}
let Some(t) = cat.find_table(b.table.schema.as_deref(), &b.table.name) else {
continue;
};
for c in &t.columns {
out.push(sources::column_item(t, c));
}
}
}
pub(crate) fn scope_for_offset<'a>(file: &ParsedFile, scopes: &'a [Scope], offset: TextSize) -> Option<&'a Scope> {
let idx = file.statements.iter().position(|s| s.range.contains_inclusive(offset))?;
scopes.get(idx)
}