use text_size::TextSize;
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Phase {
Start,
SelectProjection,
InProjection,
NextProjection,
AfterStar,
ProjectionAlias,
ExpectTable,
AfterTable,
JoinModifier,
JoinComplete,
OnClause,
UsingClause,
WhereClause,
InPredicate,
AfterGroup,
GroupByList,
AfterOrder,
OrderByList,
HavingClause,
LimitClause,
OffsetClause,
AfterInsert,
AfterInsertTable,
InsertColumnList,
InsertExpectValues,
InsertValuesList,
AfterUpdate,
AfterUpdateTable,
UpdateAssignment,
AfterDelete,
ReturningClause,
AfterCreate,
AfterAlter,
AfterDrop,
AfterAlterTableExpectName,
AfterAlterTableName,
AfterGrantOrRevoke,
AfterGrantOn,
AfterGrantTo,
PlpgsqlBody,
PlpgsqlAssignRhs,
CtlExpectTableName,
CtlBodyStart,
CtlExpectType,
CtlExpectColumnConstraint,
CtlExpectConstraintName,
CtlExpectConstraintKind,
CtlExpectFkTable {},
CtlExpectFkColumn {
table: String,
},
CtlCheckExpr {
table: Option<String>,
},
CastType,
Unknown,
}
#[derive(Debug, Clone, PartialEq, Eq)]
enum Tok<'a> {
Word(&'a str), Punct(char), StringLit,
NumberLit,
}
fn tokenise(src: &str, start: usize, end: usize) -> Vec<Tok<'_>> {
let bytes = src.as_bytes();
let mut out = Vec::new();
let mut i = start;
while i < end {
if !bytes[i].is_ascii() {
i += 1;
continue;
}
let c = bytes[i] as char;
if c.is_whitespace() {
i += 1;
continue;
}
if c == '-' && i + 1 < end && bytes[i + 1] == b'-' {
while i < end && bytes[i] != b'\n' {
i += 1;
}
continue;
}
if c == '/' && i + 1 < end && bytes[i + 1] == b'*' {
i += 2;
while i + 1 < end && !(bytes[i] == b'*' && bytes[i + 1] == b'/') {
i += 1;
}
i = (i + 2).min(end);
continue;
}
if c == '\'' {
i += 1;
while i < end {
let b = bytes[i];
if b == b'\'' && (i == 0 || bytes[i - 1] != b'\\') {
i += 1;
break;
}
i += 1;
}
out.push(Tok::StringLit);
continue;
}
if c == '"' {
let id_start = i + 1;
i += 1;
while i < end && bytes[i] != b'"' {
i += 1;
}
let id_end = i;
i = (i + 1).min(end);
if id_end > id_start {
out.push(Tok::Word(&src[id_start..id_end]));
}
continue;
}
if c == '$' {
if let Some(tag_end_rel) = src[i + 1..end].find('$') {
let tag = &src[i + 1..i + 1 + tag_end_rel];
if tag.chars().all(|ch| ch.is_alphanumeric() || ch == '_') {
let closer = format!("${tag}$");
let body_start = i + 1 + tag_end_rel + 1;
if let Some(rel) = src[body_start..end].find(&closer) {
i = body_start + rel + closer.len();
} else {
i = end;
}
out.push(Tok::StringLit);
continue;
}
}
}
if c.is_ascii_digit() {
let s = i;
while i < end && (bytes[i].is_ascii_digit() || bytes[i] == b'.') {
i += 1;
}
let _ = s;
out.push(Tok::NumberLit);
continue;
}
if is_word_start(c) {
let s = i;
while i < end {
if !bytes[i].is_ascii() {
break;
}
if !is_word_cont(bytes[i] as char) {
break;
}
i += 1;
}
out.push(Tok::Word(&src[s..i]));
continue;
}
out.push(Tok::Punct(c));
i += 1;
}
out
}
fn is_word_start(c: char) -> bool {
c.is_alphabetic() || c == '_'
}
fn is_word_cont(c: char) -> bool {
c.is_alphanumeric() || c == '_'
}
fn after_owner_to(src: &str, pos: usize) -> bool {
let bytes = src.as_bytes();
let mut i = pos.min(bytes.len());
while i > 0 && bytes[i - 1].is_ascii() && is_word_cont(bytes[i - 1] as char) {
i -= 1;
}
while i > 0 && bytes[i - 1].is_ascii() && bytes[i - 1].is_ascii_whitespace() {
i -= 1;
}
if i < 2 || !src.is_char_boundary(i) {
return false;
}
if !src[..i].to_ascii_uppercase().ends_with("TO") {
return false;
}
let pre_end = i - 2;
if !src.is_char_boundary(pre_end) {
return false;
}
let pre = src[..pre_end].trim_end();
pre.to_ascii_uppercase().ends_with("OWNER")
}
fn after_set_role(src: &str, pos: usize) -> bool {
let bytes = src.as_bytes();
let mut i = pos.min(bytes.len());
while i > 0 && bytes[i - 1].is_ascii() && is_word_cont(bytes[i - 1] as char) {
i -= 1;
}
while i > 0 && bytes[i - 1].is_ascii() && bytes[i - 1].is_ascii_whitespace() {
i -= 1;
}
if i < 4 || !src.is_char_boundary(i) {
return false;
}
if !src[..i].to_ascii_uppercase().ends_with("ROLE") {
return false;
}
let pre_end = i - 4;
if !src.is_char_boundary(pre_end) {
return false;
}
let pre = src[..pre_end].trim_end();
pre.to_ascii_uppercase().ends_with("SET")
}
fn after_double_colon(src: &str, pos: usize) -> bool {
let bytes = src.as_bytes();
let mut i = pos;
while i > 0 && is_word_cont(bytes[i - 1] as char) {
i -= 1;
}
while i > 0 && bytes[i - 1].is_ascii_whitespace() {
i -= 1;
}
i >= 2 && bytes[i - 1] == b':' && bytes[i - 2] == b':'
}
fn subquery_body_start(src: &str, start: usize, pos: usize) -> Option<usize> {
let bytes = src.as_bytes();
let upper = src.to_ascii_uppercase();
let upper_bytes = upper.as_bytes();
let end = pos.min(bytes.len());
let mut in_single = false;
let mut in_double = false;
let mut stack: Vec<usize> = Vec::new(); let mut depth: i32 = 0; let mut subq_depths: Vec<i32> = Vec::new(); let mut i = start;
while i < end {
let c = bytes[i] as char;
if !in_double && c == '\'' && (i == 0 || bytes[i - 1] != b'\\') {
in_single = !in_single;
i += 1;
continue;
}
if !in_single && c == '"' {
in_double = !in_double;
i += 1;
continue;
}
if in_single || in_double {
i += 1;
continue;
}
if c == '(' {
depth += 1;
let mut k = i + 1;
while k < end && bytes[k].is_ascii_whitespace() {
k += 1;
}
let starts_subquery = ["SELECT", "INSERT", "UPDATE", "DELETE", "WITH", "VALUES"].iter().any(|kw| {
k + kw.len() <= upper_bytes.len()
&& &upper_bytes[k..k + kw.len()] == kw.as_bytes()
&& (k + kw.len() == upper_bytes.len() || !is_word_cont(upper_bytes[k + kw.len()] as char))
});
if starts_subquery {
stack.push(i + 1);
subq_depths.push(depth);
}
} else if c == ')' {
if let Some(&d) = subq_depths.last()
&& d == depth
{
stack.pop();
subq_depths.pop();
}
depth -= 1;
}
i += 1;
}
stack.last().copied()
}
fn create_view_body_start(src: &str, start: usize, pos: usize) -> Option<usize> {
let end = pos.min(src.len());
if start >= end {
return None;
}
let upper = src[start..end].to_ascii_uppercase();
if !upper.contains("CREATE") || !upper.contains("VIEW") {
return None;
}
let bytes = upper.as_bytes();
let n = bytes.len();
let mut i = 0usize;
while i < n && bytes[i].is_ascii_whitespace() {
i += 1;
}
if !match_word(bytes, i, b"CREATE") {
return None;
}
i += 6;
loop {
while i < n && bytes[i].is_ascii_whitespace() {
i += 1;
}
if match_word(bytes, i, b"OR") {
i += 2;
while i < n && bytes[i].is_ascii_whitespace() {
i += 1;
}
if !match_word(bytes, i, b"REPLACE") {
return None;
}
i += 7;
continue;
}
if match_word(bytes, i, b"TEMP") {
i += 4;
continue;
}
if match_word(bytes, i, b"TEMPORARY") {
i += 9;
continue;
}
if match_word(bytes, i, b"RECURSIVE") {
i += 9;
continue;
}
if match_word(bytes, i, b"MATERIALIZED") {
i += 12;
continue;
}
break;
}
while i < n && bytes[i].is_ascii_whitespace() {
i += 1;
}
if !match_word(bytes, i, b"VIEW") {
return None;
}
i += 4;
while i < n && bytes[i].is_ascii_whitespace() {
i += 1;
}
if match_word(bytes, i, b"IF") {
i += 2;
while i < n && bytes[i].is_ascii_whitespace() {
i += 1;
}
if !match_word(bytes, i, b"NOT") {
return None;
}
i += 3;
while i < n && bytes[i].is_ascii_whitespace() {
i += 1;
}
if !match_word(bytes, i, b"EXISTS") {
return None;
}
i += 6;
while i < n && bytes[i].is_ascii_whitespace() {
i += 1;
}
}
let name_start = i;
while i < n && !bytes[i].is_ascii_whitespace() && bytes[i] != b'(' {
i += 1;
}
if i == name_start {
return None;
}
while i < n && bytes[i].is_ascii_whitespace() {
i += 1;
}
if i < n && bytes[i] == b'(' {
let mut depth = 1i32;
i += 1;
while i < n && depth > 0 {
match bytes[i] {
b'(' => depth += 1,
b')' => depth -= 1,
_ => {},
}
i += 1;
}
while i < n && bytes[i].is_ascii_whitespace() {
i += 1;
}
}
if match_word(bytes, i, b"WITH") {
let after = i + 4;
let mut k = after;
while k < n && bytes[k].is_ascii_whitespace() {
k += 1;
}
if k < n && bytes[k] == b'(' {
let mut depth = 1i32;
i = k + 1;
while i < n && depth > 0 {
match bytes[i] {
b'(' => depth += 1,
b')' => depth -= 1,
_ => {},
}
i += 1;
}
while i < n && bytes[i].is_ascii_whitespace() {
i += 1;
}
}
}
if !match_word(bytes, i, b"AS") {
return None;
}
let after_as = i + 2;
if after_as > pos.saturating_sub(start) {
return None;
}
Some(start + after_as)
}
fn match_word(bytes: &[u8], i: usize, word: &[u8]) -> bool {
let n = bytes.len();
if i + word.len() > n {
return false;
}
if &bytes[i..i + word.len()] != word {
return false;
}
if i + word.len() < n && is_word_cont(bytes[i + word.len()] as char) {
return false;
}
if i > 0 && is_word_cont(bytes[i - 1] as char) {
return false;
}
true
}
fn statement_start(src: &str, pos: usize) -> usize {
let bytes = src.as_bytes();
let mut in_single = false;
let mut in_double = false;
let mut last_semi = 0;
let mut i = 0;
while i < pos.min(bytes.len()) {
let c = bytes[i] as char;
if !in_double && c == '\'' && (i == 0 || bytes[i - 1] != b'\\') {
in_single = !in_single;
} else if !in_single && c == '"' {
in_double = !in_double;
} else if !in_single && !in_double && c == ';' {
last_semi = i + 1;
}
i += 1;
}
last_semi
}
pub fn detect(src: &str, offset: TextSize) -> Phase {
let pos: usize = offset.into();
let pos = pos.min(src.len());
if after_double_colon(src, pos) {
return Phase::CastType;
}
if after_owner_to(src, pos) {
return Phase::AfterGrantTo;
}
if after_set_role(src, pos) {
return Phase::AfterGrantTo;
}
if inside_dollar_quoted(src, pos) {
if after_assignment(src, pos) {
return Phase::PlpgsqlAssignRhs;
}
return Phase::PlpgsqlBody;
}
let raw_start = statement_start(src, pos);
let start = subquery_body_start(src, raw_start, pos)
.or_else(|| create_view_body_start(src, raw_start, pos))
.unwrap_or(raw_start);
let toks = tokenise(src, start, pos);
let mut effective = toks;
if pos > 0 && is_word_cont(src.as_bytes()[pos - 1] as char) && matches!(effective.last(), Some(Tok::Word(_))) {
effective.pop();
}
let trimmed = strip_with_prefix(&effective);
walk(trimmed)
}
fn strip_with_prefix<'a, 'b>(toks: &'a [Tok<'b>]) -> &'a [Tok<'b>] {
let Some(Tok::Word(w)) = toks.first() else {
return toks;
};
if !w.eq_ignore_ascii_case("WITH") {
return toks;
}
let mut depth = 0i32;
for (i, t) in toks.iter().enumerate().skip(1) {
match t {
Tok::Punct('(') => depth += 1,
Tok::Punct(')') => depth -= 1,
Tok::Word(w) if depth == 0 => {
let up = w.to_ascii_uppercase();
if matches!(up.as_str(), "SELECT" | "INSERT" | "UPDATE" | "DELETE") {
return &toks[i..];
}
},
_ => {},
}
}
toks
}
fn upper(s: &str) -> String {
s.to_ascii_uppercase()
}
fn walk(toks: &[Tok<'_>]) -> Phase {
use Phase::*;
let mut phase = Start;
let mut i = 0;
while i < toks.len() {
let t = &toks[i];
phase = match (&phase, t) {
(Start, Tok::Word(w)) => match upper(w).as_str() {
"SELECT" => SelectProjection,
"INSERT" => AfterInsert,
"UPDATE" => AfterUpdate,
"DELETE" => AfterDelete,
"CREATE" => AfterCreate,
"ALTER" => AfterAlter,
"DROP" => AfterDrop,
"GRANT" => AfterGrantOrRevoke,
"REVOKE" => AfterGrantOrRevoke,
"WITH" => Start, _ => Unknown,
},
(SelectProjection, Tok::Word(w)) => match upper(w).as_str() {
"FROM" => ExpectTable,
"DISTINCT" | "ALL" => SelectProjection,
_ => InProjection,
},
(SelectProjection, Tok::Punct('*')) => AfterStar,
(SelectProjection, Tok::Punct(',')) => NextProjection,
(SelectProjection, Tok::Punct('(')) => InProjection,
(SelectProjection, _) => InProjection,
(NextProjection, Tok::Word(w)) => match upper(w).as_str() {
"FROM" => ExpectTable,
_ => InProjection,
},
(NextProjection, Tok::Punct('*')) => AfterStar,
(NextProjection, _) => InProjection,
(InProjection, Tok::Word(w)) => match upper(w).as_str() {
"FROM" => ExpectTable,
"AS" => ProjectionAlias,
_ => InProjection,
},
(InProjection, Tok::Punct(',')) => NextProjection,
(InProjection, Tok::Punct('.')) => InProjection,
(InProjection, Tok::Punct('(')) => InProjection,
(InProjection, _) => InProjection,
(ProjectionAlias, Tok::Word(_)) => InProjection,
(ProjectionAlias, _) => ProjectionAlias,
(AfterStar, Tok::Word(w)) => match upper(w).as_str() {
"FROM" => ExpectTable,
_ => InProjection,
},
(AfterStar, Tok::Punct(',')) => NextProjection,
(AfterStar, _) => AfterStar,
(ExpectTable, Tok::Word(_)) => AfterTable,
(ExpectTable, _) => ExpectTable,
(AfterTable, Tok::Word(w)) => match upper(w).as_str() {
"AS" => AfterTable,
"JOIN" => ExpectTable,
"INNER" | "LEFT" | "RIGHT" | "FULL" | "CROSS" => JoinModifier,
"WHERE" => WhereClause,
"GROUP" => AfterGroup,
"ORDER" => AfterOrder,
"HAVING" => HavingClause,
"LIMIT" => LimitClause,
"OFFSET" => OffsetClause,
"ON" => OnClause,
"USING" => UsingClause,
_ => AfterTable, },
(AfterTable, Tok::Punct(',')) => ExpectTable,
(AfterTable, Tok::Punct(';')) => Start,
(AfterTable, _) => AfterTable,
(JoinModifier, Tok::Word(w)) => match upper(w).as_str() {
"JOIN" => ExpectTable,
"OUTER" => JoinModifier,
_ => JoinModifier,
},
(JoinModifier, _) => JoinModifier,
(OnClause, Tok::Word(w)) => match upper(w).as_str() {
"AND" | "OR" => OnClause,
"JOIN" => ExpectTable,
"WHERE" => WhereClause,
"GROUP" => AfterGroup,
"ORDER" => AfterOrder,
"INNER" | "LEFT" | "RIGHT" | "FULL" | "CROSS" => JoinModifier,
_ => InPredicate,
},
(OnClause, Tok::Punct(';')) => Start,
(OnClause, _) => OnClause,
(WhereClause, Tok::Word(w)) => match upper(w).as_str() {
"GROUP" => AfterGroup,
"ORDER" => AfterOrder,
"HAVING" => HavingClause,
"LIMIT" => LimitClause,
"RETURNING" => ReturningClause,
_ => InPredicate,
},
(WhereClause, Tok::Punct(';')) => Start,
(WhereClause, _) => WhereClause,
(InPredicate, Tok::Word(w)) => match upper(w).as_str() {
"AND" | "OR" | "NOT" => WhereClause,
"GROUP" => AfterGroup,
"ORDER" => AfterOrder,
"HAVING" => HavingClause,
"LIMIT" => LimitClause,
"RETURNING" => ReturningClause,
_ => InPredicate,
},
(InPredicate, Tok::Punct(';')) => Start,
(InPredicate, _) => InPredicate,
(AfterGroup, Tok::Word(w)) if upper(w) == "BY" => GroupByList,
(AfterGroup, _) => AfterGroup,
(GroupByList, Tok::Word(w)) => match upper(w).as_str() {
"ORDER" => AfterOrder,
"HAVING" => HavingClause,
"LIMIT" => LimitClause,
_ => GroupByList,
},
(GroupByList, Tok::Punct(';')) => Start,
(GroupByList, _) => GroupByList,
(AfterOrder, Tok::Word(w)) if upper(w) == "BY" => OrderByList,
(AfterOrder, _) => AfterOrder,
(OrderByList, Tok::Word(w)) => match upper(w).as_str() {
"LIMIT" => LimitClause,
_ => OrderByList,
},
(OrderByList, Tok::Punct(';')) => Start,
(OrderByList, _) => OrderByList,
(HavingClause, Tok::Word(w)) => match upper(w).as_str() {
"ORDER" => AfterOrder,
"LIMIT" => LimitClause,
_ => HavingClause,
},
(HavingClause, Tok::Punct(';')) => Start,
(HavingClause, _) => HavingClause,
(LimitClause, Tok::Word(w)) if upper(w) == "OFFSET" => OffsetClause,
(LimitClause, Tok::Punct(';')) => Start,
(LimitClause, _) => LimitClause,
(OffsetClause, Tok::Punct(';')) => Start,
(OffsetClause, _) => OffsetClause,
(AfterInsert, Tok::Word(w)) if upper(w) == "INTO" => AfterInsertTable,
(AfterInsert, _) => AfterInsert,
(AfterInsertTable, Tok::Word(_)) => InsertColumnList,
(AfterInsertTable, _) => AfterInsertTable,
(InsertColumnList, Tok::Word(w)) if upper(w) == "VALUES" => InsertValuesList,
(InsertColumnList, Tok::Word(w)) if upper(w) == "SELECT" => SelectProjection,
(InsertColumnList, Tok::Punct(';')) => Start,
(InsertColumnList, _) => InsertColumnList,
(InsertExpectValues, _) => InsertValuesList,
(InsertValuesList, Tok::Word(w)) if upper(w) == "RETURNING" => ReturningClause,
(InsertValuesList, Tok::Punct(';')) => Start,
(InsertValuesList, _) => InsertValuesList,
(AfterUpdate, Tok::Word(_)) => AfterUpdateTable,
(AfterUpdate, _) => AfterUpdate,
(AfterUpdateTable, Tok::Word(w)) if upper(w) == "SET" => UpdateAssignment,
(AfterUpdateTable, _) => AfterUpdateTable,
(UpdateAssignment, Tok::Word(w)) => match upper(w).as_str() {
"WHERE" => WhereClause,
"RETURNING" => ReturningClause,
_ => UpdateAssignment,
},
(UpdateAssignment, Tok::Punct(';')) => Start,
(UpdateAssignment, _) => UpdateAssignment,
(AfterDelete, Tok::Word(w)) if upper(w) == "FROM" => ExpectTable,
(AfterDelete, _) => AfterDelete,
(ReturningClause, Tok::Punct(';')) => Start,
(ReturningClause, _) => ReturningClause,
(AfterAlter, Tok::Word(w)) if upper(w) == "TABLE" => AfterAlterTableExpectName,
(AfterAlter, _) => Unknown,
(AfterCreate, _) | (AfterDrop, _) => Unknown,
(AfterAlterTableExpectName, Tok::Word(w)) => match upper(w).as_str() {
"IF" | "EXISTS" | "ONLY" => AfterAlterTableExpectName,
_ => AfterAlterTableName,
},
(AfterAlterTableExpectName, Tok::Punct('.')) => AfterAlterTableExpectName, (AfterAlterTableExpectName, _) => AfterAlterTableExpectName,
(AfterAlterTableName, Tok::Punct(';')) => Start,
(AfterAlterTableName, _) => AfterAlterTableName,
(AfterGrantOrRevoke, Tok::Word(w)) => match upper(w).as_str() {
"ON" => AfterGrantOn,
"TO" | "FROM" => AfterGrantTo,
_ => AfterGrantOrRevoke, },
(AfterGrantOrRevoke, Tok::Punct(',')) => AfterGrantOrRevoke,
(AfterGrantOrRevoke, Tok::Punct(';')) => Start,
(AfterGrantOrRevoke, _) => AfterGrantOrRevoke,
(AfterGrantOn, Tok::Word(w)) => match upper(w).as_str() {
"TO" | "FROM" => AfterGrantTo,
_ => AfterGrantOn, },
(AfterGrantOn, Tok::Punct(';')) => Start,
(AfterGrantOn, _) => AfterGrantOn,
(AfterGrantTo, Tok::Punct(';')) => Start,
(AfterGrantTo, _) => AfterGrantTo,
(_, Tok::Punct(';')) => Start,
(_, _) => phase.clone(),
};
i += 1;
}
phase
}
fn inside_dollar_quoted(src: &str, pos: usize) -> bool {
let bytes = src.as_bytes();
let mut i = 0usize;
let mut current_tag: Option<String> = None;
while i < pos.min(bytes.len()) {
if let Some(tag) = ¤t_tag {
let closer = format!("${tag}$");
if src[i..].starts_with(&closer) {
i += closer.len();
current_tag = None;
continue;
}
i += 1;
continue;
}
if bytes[i] == b'$'
&& let Some(end) = src[i + 1..].find('$')
{
let tag = &src[i + 1..i + 1 + end];
if tag.chars().all(|c| c.is_alphanumeric() || c == '_') {
current_tag = Some(tag.to_string());
i += 1 + end + 1;
continue;
}
}
i += 1;
}
current_tag.is_some()
}
fn after_assignment(src: &str, pos: usize) -> bool {
let bytes = src.as_bytes();
let upper_pos = pos.min(bytes.len());
let start = src[..upper_pos].rfind(';').map(|i| i + 1).unwrap_or(0);
let slice = &src[start..upper_pos];
let bs = slice.as_bytes();
let n = bs.len();
let mut depth = 0i32;
let mut i = 0usize;
let mut found = false;
while i < n {
match bs[i] {
b'\'' => {
i += 1;
while i < n {
if bs[i] == b'\'' {
i += 1;
break;
}
i += 1;
}
},
b'(' => {
depth += 1;
i += 1;
},
b')' => {
depth -= 1;
i += 1;
},
b':' if depth == 0 && i + 1 < n && bs[i + 1] == b'=' => {
found = true;
i += 2;
},
_ => i += 1,
}
}
found
}