1use text_size::TextSize;
12
13#[derive(Debug, Clone, PartialEq, Eq)]
14pub enum Phase {
15 Start,
17
18 SelectProjection,
21 InProjection,
24 NextProjection,
26 AfterStar,
29 ProjectionAlias,
31
32 ExpectTable,
34 AfterTable,
37 JoinModifier,
40 JoinComplete,
42 OnClause,
44 UsingClause,
46
47 WhereClause,
49 InPredicate,
51
52 AfterGroup,
54 GroupByList,
56 AfterOrder,
58 OrderByList,
60 HavingClause,
62 LimitClause,
64 OffsetClause,
66
67 AfterInsert,
69 AfterInsertTable,
70 InsertColumnList,
71 InsertExpectValues,
72 InsertValuesList,
73 AfterUpdate,
74 AfterUpdateTable,
75 UpdateAssignment,
76 AfterDelete,
77 ReturningClause,
81
82 AfterCreate,
84 AfterAlter,
85 AfterDrop,
86
87 AfterAlterTableExpectName,
90 AfterAlterTableName,
94
95 AfterGrantOrRevoke,
100 AfterGrantOn,
103 AfterGrantTo,
106
107 PlpgsqlBody,
110 PlpgsqlAssignRhs,
114
115 CtlExpectTableName,
119 CtlBodyStart,
123 CtlExpectType,
125 CtlExpectColumnConstraint,
128 CtlExpectConstraintName,
130 CtlExpectConstraintKind,
133 CtlExpectFkTable {},
135 CtlExpectFkColumn {
137 table: String,
138 },
139 CtlCheckExpr {
143 table: Option<String>,
144 },
145
146 CastType,
149
150 Unknown,
153}
154
155#[derive(Debug, Clone, PartialEq, Eq)]
156enum Tok<'a> {
157 Word(&'a str), Punct(char), StringLit,
160 NumberLit,
161}
162
163fn tokenise(src: &str, start: usize, end: usize) -> Vec<Tok<'_>> {
168 let bytes = src.as_bytes();
169 let mut out = Vec::new();
170 let mut i = start;
171 while i < end {
172 if !bytes[i].is_ascii() {
176 i += 1;
177 continue;
178 }
179 let c = bytes[i] as char;
180 if c.is_whitespace() {
181 i += 1;
182 continue;
183 }
184 if c == '-' && i + 1 < end && bytes[i + 1] == b'-' {
185 while i < end && bytes[i] != b'\n' {
187 i += 1;
188 }
189 continue;
190 }
191 if c == '/' && i + 1 < end && bytes[i + 1] == b'*' {
192 i += 2;
193 while i + 1 < end && !(bytes[i] == b'*' && bytes[i + 1] == b'/') {
194 i += 1;
195 }
196 i = (i + 2).min(end);
197 continue;
198 }
199 if c == '\'' {
200 i += 1;
201 while i < end {
202 let b = bytes[i];
203 if b == b'\'' && (i == 0 || bytes[i - 1] != b'\\') {
204 i += 1;
205 break;
206 }
207 i += 1;
208 }
209 out.push(Tok::StringLit);
210 continue;
211 }
212 if c == '"' {
213 let id_start = i + 1;
215 i += 1;
216 while i < end && bytes[i] != b'"' {
217 i += 1;
218 }
219 let id_end = i;
220 i = (i + 1).min(end);
221 if id_end > id_start {
222 out.push(Tok::Word(&src[id_start..id_end]));
223 }
224 continue;
225 }
226 if c == '$' {
227 if let Some(tag_end_rel) = src[i + 1..end].find('$') {
229 let tag = &src[i + 1..i + 1 + tag_end_rel];
230 if tag.chars().all(|ch| ch.is_alphanumeric() || ch == '_') {
231 let closer = format!("${tag}$");
232 let body_start = i + 1 + tag_end_rel + 1;
233 if let Some(rel) = src[body_start..end].find(&closer) {
234 i = body_start + rel + closer.len();
235 } else {
236 i = end;
237 }
238 out.push(Tok::StringLit);
239 continue;
240 }
241 }
242 }
243 if c.is_ascii_digit() {
244 let s = i;
245 while i < end && (bytes[i].is_ascii_digit() || bytes[i] == b'.') {
246 i += 1;
247 }
248 let _ = s;
249 out.push(Tok::NumberLit);
250 continue;
251 }
252 if is_word_start(c) {
253 let s = i;
254 while i < end {
255 if !bytes[i].is_ascii() {
258 break;
259 }
260 if !is_word_cont(bytes[i] as char) {
261 break;
262 }
263 i += 1;
264 }
265 out.push(Tok::Word(&src[s..i]));
266 continue;
267 }
268 out.push(Tok::Punct(c));
269 i += 1;
270 }
271 out
272}
273
274fn is_word_start(c: char) -> bool {
275 c.is_alphabetic() || c == '_'
276}
277fn is_word_cont(c: char) -> bool {
278 c.is_alphanumeric() || c == '_'
279}
280
281fn after_owner_to(src: &str, pos: usize) -> bool {
291 let bytes = src.as_bytes();
292 let mut i = pos.min(bytes.len());
293 while i > 0 && bytes[i - 1].is_ascii() && is_word_cont(bytes[i - 1] as char) {
294 i -= 1;
295 }
296 while i > 0 && bytes[i - 1].is_ascii() && bytes[i - 1].is_ascii_whitespace() {
297 i -= 1;
298 }
299 if i < 2 || !src.is_char_boundary(i) {
300 return false;
301 }
302 if !src[..i].to_ascii_uppercase().ends_with("TO") {
303 return false;
304 }
305 let pre_end = i - 2;
306 if !src.is_char_boundary(pre_end) {
307 return false;
308 }
309 let pre = src[..pre_end].trim_end();
310 pre.to_ascii_uppercase().ends_with("OWNER")
311}
312
313fn after_set_role(src: &str, pos: usize) -> bool {
315 let bytes = src.as_bytes();
316 let mut i = pos.min(bytes.len());
317 while i > 0 && bytes[i - 1].is_ascii() && is_word_cont(bytes[i - 1] as char) {
318 i -= 1;
319 }
320 while i > 0 && bytes[i - 1].is_ascii() && bytes[i - 1].is_ascii_whitespace() {
321 i -= 1;
322 }
323 if i < 4 || !src.is_char_boundary(i) {
324 return false;
325 }
326 if !src[..i].to_ascii_uppercase().ends_with("ROLE") {
327 return false;
328 }
329 let pre_end = i - 4;
330 if !src.is_char_boundary(pre_end) {
331 return false;
332 }
333 let pre = src[..pre_end].trim_end();
334 pre.to_ascii_uppercase().ends_with("SET")
335}
336
337fn after_double_colon(src: &str, pos: usize) -> bool {
338 let bytes = src.as_bytes();
339 let mut i = pos;
340 while i > 0 && is_word_cont(bytes[i - 1] as char) {
342 i -= 1;
343 }
344 while i > 0 && bytes[i - 1].is_ascii_whitespace() {
346 i -= 1;
347 }
348 i >= 2 && bytes[i - 1] == b':' && bytes[i - 2] == b':'
349}
350
351fn subquery_body_start(src: &str, start: usize, pos: usize) -> Option<usize> {
360 let bytes = src.as_bytes();
361 let upper = src.to_ascii_uppercase();
362 let upper_bytes = upper.as_bytes();
363 let end = pos.min(bytes.len());
364 let mut in_single = false;
365 let mut in_double = false;
366 let mut stack: Vec<usize> = Vec::new(); let mut depth: i32 = 0; let mut subq_depths: Vec<i32> = Vec::new(); let mut i = start;
370 while i < end {
371 let c = bytes[i] as char;
372 if !in_double && c == '\'' && (i == 0 || bytes[i - 1] != b'\\') {
373 in_single = !in_single;
374 i += 1;
375 continue;
376 }
377 if !in_single && c == '"' {
378 in_double = !in_double;
379 i += 1;
380 continue;
381 }
382 if in_single || in_double {
383 i += 1;
384 continue;
385 }
386 if c == '(' {
387 depth += 1;
388 let mut k = i + 1;
390 while k < end && bytes[k].is_ascii_whitespace() {
391 k += 1;
392 }
393 let starts_subquery = ["SELECT", "INSERT", "UPDATE", "DELETE", "WITH", "VALUES"].iter().any(|kw| {
394 k + kw.len() <= upper_bytes.len()
395 && &upper_bytes[k..k + kw.len()] == kw.as_bytes()
396 && (k + kw.len() == upper_bytes.len() || !is_word_cont(upper_bytes[k + kw.len()] as char))
397 });
398 if starts_subquery {
399 stack.push(i + 1);
400 subq_depths.push(depth);
401 }
402 } else if c == ')' {
403 if let Some(&d) = subq_depths.last()
404 && d == depth
405 {
406 stack.pop();
407 subq_depths.pop();
408 }
409 depth -= 1;
410 }
411 i += 1;
412 }
413 stack.last().copied()
414}
415
416fn create_view_body_start(src: &str, start: usize, pos: usize) -> Option<usize> {
422 let end = pos.min(src.len());
423 if start >= end {
424 return None;
425 }
426 let upper = src[start..end].to_ascii_uppercase();
427 if !upper.contains("CREATE") || !upper.contains("VIEW") {
429 return None;
430 }
431 let bytes = upper.as_bytes();
432 let n = bytes.len();
433 let mut i = 0usize;
435 while i < n && bytes[i].is_ascii_whitespace() {
436 i += 1;
437 }
438 if !match_word(bytes, i, b"CREATE") {
440 return None;
441 }
442 i += 6;
443 loop {
446 while i < n && bytes[i].is_ascii_whitespace() {
447 i += 1;
448 }
449 if match_word(bytes, i, b"OR") {
450 i += 2;
451 while i < n && bytes[i].is_ascii_whitespace() {
452 i += 1;
453 }
454 if !match_word(bytes, i, b"REPLACE") {
455 return None;
456 }
457 i += 7;
458 continue;
459 }
460 if match_word(bytes, i, b"TEMP") {
461 i += 4;
462 continue;
463 }
464 if match_word(bytes, i, b"TEMPORARY") {
465 i += 9;
466 continue;
467 }
468 if match_word(bytes, i, b"RECURSIVE") {
469 i += 9;
470 continue;
471 }
472 if match_word(bytes, i, b"MATERIALIZED") {
473 i += 12;
474 continue;
475 }
476 break;
477 }
478 while i < n && bytes[i].is_ascii_whitespace() {
479 i += 1;
480 }
481 if !match_word(bytes, i, b"VIEW") {
483 return None;
484 }
485 i += 4;
486 while i < n && bytes[i].is_ascii_whitespace() {
487 i += 1;
488 }
489 if match_word(bytes, i, b"IF") {
491 i += 2;
492 while i < n && bytes[i].is_ascii_whitespace() {
493 i += 1;
494 }
495 if !match_word(bytes, i, b"NOT") {
496 return None;
497 }
498 i += 3;
499 while i < n && bytes[i].is_ascii_whitespace() {
500 i += 1;
501 }
502 if !match_word(bytes, i, b"EXISTS") {
503 return None;
504 }
505 i += 6;
506 while i < n && bytes[i].is_ascii_whitespace() {
507 i += 1;
508 }
509 }
510 let name_start = i;
512 while i < n && !bytes[i].is_ascii_whitespace() && bytes[i] != b'(' {
513 i += 1;
514 }
515 if i == name_start {
516 return None;
517 }
518 while i < n && bytes[i].is_ascii_whitespace() {
519 i += 1;
520 }
521 if i < n && bytes[i] == b'(' {
523 let mut depth = 1i32;
524 i += 1;
525 while i < n && depth > 0 {
526 match bytes[i] {
527 b'(' => depth += 1,
528 b')' => depth -= 1,
529 _ => {},
530 }
531 i += 1;
532 }
533 while i < n && bytes[i].is_ascii_whitespace() {
534 i += 1;
535 }
536 }
537 if match_word(bytes, i, b"WITH") {
539 let after = i + 4;
540 let mut k = after;
541 while k < n && bytes[k].is_ascii_whitespace() {
542 k += 1;
543 }
544 if k < n && bytes[k] == b'(' {
545 let mut depth = 1i32;
546 i = k + 1;
547 while i < n && depth > 0 {
548 match bytes[i] {
549 b'(' => depth += 1,
550 b')' => depth -= 1,
551 _ => {},
552 }
553 i += 1;
554 }
555 while i < n && bytes[i].is_ascii_whitespace() {
556 i += 1;
557 }
558 }
559 }
560 if !match_word(bytes, i, b"AS") {
562 return None;
563 }
564 let after_as = i + 2;
565 if after_as > pos.saturating_sub(start) {
566 return None;
567 }
568 Some(start + after_as)
569}
570
571fn match_word(bytes: &[u8], i: usize, word: &[u8]) -> bool {
572 let n = bytes.len();
573 if i + word.len() > n {
574 return false;
575 }
576 if &bytes[i..i + word.len()] != word {
577 return false;
578 }
579 if i + word.len() < n && is_word_cont(bytes[i + word.len()] as char) {
580 return false;
581 }
582 if i > 0 && is_word_cont(bytes[i - 1] as char) {
583 return false;
584 }
585 true
586}
587
588fn statement_start(src: &str, pos: usize) -> usize {
589 let bytes = src.as_bytes();
590 let mut in_single = false;
591 let mut in_double = false;
592 let mut last_semi = 0;
593 let mut i = 0;
594 while i < pos.min(bytes.len()) {
595 let c = bytes[i] as char;
596 if !in_double && c == '\'' && (i == 0 || bytes[i - 1] != b'\\') {
597 in_single = !in_single;
598 } else if !in_single && c == '"' {
599 in_double = !in_double;
600 } else if !in_single && !in_double && c == ';' {
601 last_semi = i + 1;
602 }
603 i += 1;
604 }
605 last_semi
606}
607
608pub fn detect(src: &str, offset: TextSize) -> Phase {
610 let pos: usize = offset.into();
611 let pos = pos.min(src.len());
612
613 if after_double_colon(src, pos) {
617 return Phase::CastType;
618 }
619
620 if after_owner_to(src, pos) {
624 return Phase::AfterGrantTo;
625 }
626
627 if after_set_role(src, pos) {
631 return Phase::AfterGrantTo;
632 }
633
634 if inside_dollar_quoted(src, pos) {
637 if after_assignment(src, pos) {
640 return Phase::PlpgsqlAssignRhs;
641 }
642 return Phase::PlpgsqlBody;
643 }
644
645 let raw_start = statement_start(src, pos);
646 let start = subquery_body_start(src, raw_start, pos)
658 .or_else(|| create_view_body_start(src, raw_start, pos))
659 .unwrap_or(raw_start);
660 let toks = tokenise(src, start, pos);
661
662 let mut effective = toks;
669 if pos > 0 && is_word_cont(src.as_bytes()[pos - 1] as char) && matches!(effective.last(), Some(Tok::Word(_))) {
670 effective.pop();
671 }
672
673 let trimmed = strip_with_prefix(&effective);
680 walk(trimmed)
681}
682
683fn strip_with_prefix<'a, 'b>(toks: &'a [Tok<'b>]) -> &'a [Tok<'b>] {
689 let Some(Tok::Word(w)) = toks.first() else {
690 return toks;
691 };
692 if !w.eq_ignore_ascii_case("WITH") {
693 return toks;
694 }
695 let mut depth = 0i32;
696 for (i, t) in toks.iter().enumerate().skip(1) {
697 match t {
698 Tok::Punct('(') => depth += 1,
699 Tok::Punct(')') => depth -= 1,
700 Tok::Word(w) if depth == 0 => {
701 let up = w.to_ascii_uppercase();
702 if matches!(up.as_str(), "SELECT" | "INSERT" | "UPDATE" | "DELETE") {
703 return &toks[i..];
704 }
705 },
706 _ => {},
707 }
708 }
709 toks
710}
711
712fn upper(s: &str) -> String {
713 s.to_ascii_uppercase()
714}
715
716fn walk(toks: &[Tok<'_>]) -> Phase {
717 use Phase::*;
718 let mut phase = Start;
719 let mut i = 0;
720 while i < toks.len() {
721 let t = &toks[i];
722 phase = match (&phase, t) {
723 (Start, Tok::Word(w)) => match upper(w).as_str() {
725 "SELECT" => SelectProjection,
726 "INSERT" => AfterInsert,
727 "UPDATE" => AfterUpdate,
728 "DELETE" => AfterDelete,
729 "CREATE" => AfterCreate,
730 "ALTER" => AfterAlter,
731 "DROP" => AfterDrop,
732 "GRANT" => AfterGrantOrRevoke,
733 "REVOKE" => AfterGrantOrRevoke,
734 "WITH" => Start, _ => Unknown,
736 },
737
738 (SelectProjection, Tok::Word(w)) => match upper(w).as_str() {
740 "FROM" => ExpectTable,
741 "DISTINCT" | "ALL" => SelectProjection,
742 _ => InProjection,
743 },
744 (SelectProjection, Tok::Punct('*')) => AfterStar,
745 (SelectProjection, Tok::Punct(',')) => NextProjection,
746 (SelectProjection, Tok::Punct('(')) => InProjection,
747 (SelectProjection, _) => InProjection,
748
749 (NextProjection, Tok::Word(w)) => match upper(w).as_str() {
750 "FROM" => ExpectTable,
751 _ => InProjection,
752 },
753 (NextProjection, Tok::Punct('*')) => AfterStar,
754 (NextProjection, _) => InProjection,
755
756 (InProjection, Tok::Word(w)) => match upper(w).as_str() {
757 "FROM" => ExpectTable,
758 "AS" => ProjectionAlias,
759 _ => InProjection,
760 },
761 (InProjection, Tok::Punct(',')) => NextProjection,
762 (InProjection, Tok::Punct('.')) => InProjection,
763 (InProjection, Tok::Punct('(')) => InProjection,
764 (InProjection, _) => InProjection,
765
766 (ProjectionAlias, Tok::Word(_)) => InProjection,
767 (ProjectionAlias, _) => ProjectionAlias,
768
769 (AfterStar, Tok::Word(w)) => match upper(w).as_str() {
770 "FROM" => ExpectTable,
771 _ => InProjection,
772 },
773 (AfterStar, Tok::Punct(',')) => NextProjection,
774 (AfterStar, _) => AfterStar,
775
776 (ExpectTable, Tok::Word(_)) => AfterTable,
778 (ExpectTable, _) => ExpectTable,
779
780 (AfterTable, Tok::Word(w)) => match upper(w).as_str() {
781 "AS" => AfterTable,
782 "JOIN" => ExpectTable,
783 "INNER" | "LEFT" | "RIGHT" | "FULL" | "CROSS" => JoinModifier,
784 "WHERE" => WhereClause,
785 "GROUP" => AfterGroup,
786 "ORDER" => AfterOrder,
787 "HAVING" => HavingClause,
788 "LIMIT" => LimitClause,
789 "OFFSET" => OffsetClause,
790 "ON" => OnClause,
791 "USING" => UsingClause,
792 _ => AfterTable, },
794 (AfterTable, Tok::Punct(',')) => ExpectTable,
795 (AfterTable, Tok::Punct(';')) => Start,
796 (AfterTable, _) => AfterTable,
797
798 (JoinModifier, Tok::Word(w)) => match upper(w).as_str() {
799 "JOIN" => ExpectTable,
800 "OUTER" => JoinModifier,
801 _ => JoinModifier,
802 },
803 (JoinModifier, _) => JoinModifier,
804
805 (OnClause, Tok::Word(w)) => match upper(w).as_str() {
806 "AND" | "OR" => OnClause,
807 "JOIN" => ExpectTable,
808 "WHERE" => WhereClause,
809 "GROUP" => AfterGroup,
810 "ORDER" => AfterOrder,
811 "INNER" | "LEFT" | "RIGHT" | "FULL" | "CROSS" => JoinModifier,
812 _ => InPredicate,
813 },
814 (OnClause, Tok::Punct(';')) => Start,
815 (OnClause, _) => OnClause,
816
817 (WhereClause, Tok::Word(w)) => match upper(w).as_str() {
819 "GROUP" => AfterGroup,
820 "ORDER" => AfterOrder,
821 "HAVING" => HavingClause,
822 "LIMIT" => LimitClause,
823 "RETURNING" => ReturningClause,
824 _ => InPredicate,
825 },
826 (WhereClause, Tok::Punct(';')) => Start,
827 (WhereClause, _) => WhereClause,
828
829 (InPredicate, Tok::Word(w)) => match upper(w).as_str() {
830 "AND" | "OR" | "NOT" => WhereClause,
831 "GROUP" => AfterGroup,
832 "ORDER" => AfterOrder,
833 "HAVING" => HavingClause,
834 "LIMIT" => LimitClause,
835 "RETURNING" => ReturningClause,
836 _ => InPredicate,
837 },
838 (InPredicate, Tok::Punct(';')) => Start,
839 (InPredicate, _) => InPredicate,
840
841 (AfterGroup, Tok::Word(w)) if upper(w) == "BY" => GroupByList,
843 (AfterGroup, _) => AfterGroup,
844 (GroupByList, Tok::Word(w)) => match upper(w).as_str() {
845 "ORDER" => AfterOrder,
846 "HAVING" => HavingClause,
847 "LIMIT" => LimitClause,
848 _ => GroupByList,
849 },
850 (GroupByList, Tok::Punct(';')) => Start,
851 (GroupByList, _) => GroupByList,
852
853 (AfterOrder, Tok::Word(w)) if upper(w) == "BY" => OrderByList,
854 (AfterOrder, _) => AfterOrder,
855 (OrderByList, Tok::Word(w)) => match upper(w).as_str() {
856 "LIMIT" => LimitClause,
857 _ => OrderByList,
858 },
859 (OrderByList, Tok::Punct(';')) => Start,
860 (OrderByList, _) => OrderByList,
861
862 (HavingClause, Tok::Word(w)) => match upper(w).as_str() {
863 "ORDER" => AfterOrder,
864 "LIMIT" => LimitClause,
865 _ => HavingClause,
866 },
867 (HavingClause, Tok::Punct(';')) => Start,
868 (HavingClause, _) => HavingClause,
869
870 (LimitClause, Tok::Word(w)) if upper(w) == "OFFSET" => OffsetClause,
871 (LimitClause, Tok::Punct(';')) => Start,
872 (LimitClause, _) => LimitClause,
873 (OffsetClause, Tok::Punct(';')) => Start,
874 (OffsetClause, _) => OffsetClause,
875
876 (AfterInsert, Tok::Word(w)) if upper(w) == "INTO" => AfterInsertTable,
878 (AfterInsert, _) => AfterInsert,
879 (AfterInsertTable, Tok::Word(_)) => InsertColumnList,
880 (AfterInsertTable, _) => AfterInsertTable,
881 (InsertColumnList, Tok::Word(w)) if upper(w) == "VALUES" => InsertValuesList,
882 (InsertColumnList, Tok::Word(w)) if upper(w) == "SELECT" => SelectProjection,
883 (InsertColumnList, Tok::Punct(';')) => Start,
884 (InsertColumnList, _) => InsertColumnList,
885 (InsertExpectValues, _) => InsertValuesList,
886 (InsertValuesList, Tok::Word(w)) if upper(w) == "RETURNING" => ReturningClause,
887 (InsertValuesList, Tok::Punct(';')) => Start,
888 (InsertValuesList, _) => InsertValuesList,
889
890 (AfterUpdate, Tok::Word(_)) => AfterUpdateTable,
891 (AfterUpdate, _) => AfterUpdate,
892 (AfterUpdateTable, Tok::Word(w)) if upper(w) == "SET" => UpdateAssignment,
893 (AfterUpdateTable, _) => AfterUpdateTable,
894 (UpdateAssignment, Tok::Word(w)) => match upper(w).as_str() {
895 "WHERE" => WhereClause,
896 "RETURNING" => ReturningClause,
897 _ => UpdateAssignment,
898 },
899 (UpdateAssignment, Tok::Punct(';')) => Start,
900 (UpdateAssignment, _) => UpdateAssignment,
901
902 (AfterDelete, Tok::Word(w)) if upper(w) == "FROM" => ExpectTable,
903 (AfterDelete, _) => AfterDelete,
904
905 (ReturningClause, Tok::Punct(';')) => Start,
907 (ReturningClause, _) => ReturningClause,
908
909 (AfterAlter, Tok::Word(w)) if upper(w) == "TABLE" => AfterAlterTableExpectName,
911 (AfterAlter, _) => Unknown,
912 (AfterCreate, _) | (AfterDrop, _) => Unknown,
913
914 (AfterAlterTableExpectName, Tok::Word(w)) => match upper(w).as_str() {
916 "IF" | "EXISTS" | "ONLY" => AfterAlterTableExpectName,
917 _ => AfterAlterTableName,
918 },
919 (AfterAlterTableExpectName, Tok::Punct('.')) => AfterAlterTableExpectName, (AfterAlterTableExpectName, _) => AfterAlterTableExpectName,
921
922 (AfterAlterTableName, Tok::Punct(';')) => Start,
923 (AfterAlterTableName, _) => AfterAlterTableName,
924
925 (AfterGrantOrRevoke, Tok::Word(w)) => match upper(w).as_str() {
927 "ON" => AfterGrantOn,
928 "TO" | "FROM" => AfterGrantTo,
929 _ => AfterGrantOrRevoke, },
931 (AfterGrantOrRevoke, Tok::Punct(',')) => AfterGrantOrRevoke,
932 (AfterGrantOrRevoke, Tok::Punct(';')) => Start,
933 (AfterGrantOrRevoke, _) => AfterGrantOrRevoke,
934
935 (AfterGrantOn, Tok::Word(w)) => match upper(w).as_str() {
936 "TO" | "FROM" => AfterGrantTo,
937 _ => AfterGrantOn, },
939 (AfterGrantOn, Tok::Punct(';')) => Start,
940 (AfterGrantOn, _) => AfterGrantOn,
941
942 (AfterGrantTo, Tok::Punct(';')) => Start,
943 (AfterGrantTo, _) => AfterGrantTo,
944
945 (_, Tok::Punct(';')) => Start,
947 (_, _) => phase.clone(),
948 };
949 i += 1;
950 }
951 phase
952}
953
954fn inside_dollar_quoted(src: &str, pos: usize) -> bool {
958 let bytes = src.as_bytes();
959 let mut i = 0usize;
960 let mut current_tag: Option<String> = None;
961 while i < pos.min(bytes.len()) {
962 if let Some(tag) = ¤t_tag {
963 let closer = format!("${tag}$");
964 if src[i..].starts_with(&closer) {
965 i += closer.len();
966 current_tag = None;
967 continue;
968 }
969 i += 1;
970 continue;
971 }
972 if bytes[i] == b'$'
973 && let Some(end) = src[i + 1..].find('$')
974 {
975 let tag = &src[i + 1..i + 1 + end];
976 if tag.chars().all(|c| c.is_alphanumeric() || c == '_') {
977 current_tag = Some(tag.to_string());
978 i += 1 + end + 1;
979 continue;
980 }
981 }
982 i += 1;
983 }
984 current_tag.is_some()
985}
986
987fn after_assignment(src: &str, pos: usize) -> bool {
992 let bytes = src.as_bytes();
993 let upper_pos = pos.min(bytes.len());
994 let start = src[..upper_pos].rfind(';').map(|i| i + 1).unwrap_or(0);
996 let slice = &src[start..upper_pos];
997 let bs = slice.as_bytes();
998 let n = bs.len();
999 let mut depth = 0i32;
1000 let mut i = 0usize;
1001 let mut found = false;
1002 while i < n {
1003 match bs[i] {
1004 b'\'' => {
1005 i += 1;
1006 while i < n {
1007 if bs[i] == b'\'' {
1008 i += 1;
1009 break;
1010 }
1011 i += 1;
1012 }
1013 },
1014 b'(' => {
1015 depth += 1;
1016 i += 1;
1017 },
1018 b')' => {
1019 depth -= 1;
1020 i += 1;
1021 },
1022 b':' if depth == 0 && i + 1 < n && bs[i + 1] == b'=' => {
1023 found = true;
1024 i += 2;
1025 },
1026 _ => i += 1,
1027 }
1028 }
1029 found
1030}