dsl_completion/
create_index.rs1use crate::phase::Phase;
12use text_size::TextSize;
13
14pub fn detect(source: &str, offset: TextSize) -> Option<Phase> {
15 let pos: usize = u32::from(offset) as usize;
16 let pos = pos.min(source.len());
17
18 let upper = source.to_ascii_uppercase();
20 let mut header: Option<usize> = None;
21 for needle in ["CREATE UNIQUE INDEX ", "CREATE INDEX "] {
22 let mut i = 0usize;
23 while let Some(rel) = upper[i..].find(needle) {
24 let p = i + rel;
25 if p > pos {
26 break;
27 }
28 header = Some(p);
29 i = p + needle.len();
30 }
31 if header.is_some() {
32 break;
33 }
34 }
35 let start = header?;
36 if source[start..pos].contains(';') {
38 return None;
39 }
40
41 let slice = &source[start..pos];
43 let su = slice.to_ascii_uppercase();
44 let on_rel = find_kw(&su, "ON")?;
45 let after_on = on_rel + 2;
46 let rest = &slice[after_on..];
47
48 let trim = rest.len() - rest.trim_start().len();
50 let table_start = trim;
51 let table: String =
52 rest[table_start..].chars().take_while(|c| c.is_alphanumeric() || *c == '_' || *c == '.').collect();
53 if table.is_empty() {
54 return Some(Phase::ExpectTable);
56 }
57 let after_table = table_start + table.len();
58
59 let mut after = rest[after_table..].trim_start();
63 let after_upper = after.to_ascii_uppercase();
64 if after_upper.starts_with("USING") {
65 let bytes = after.as_bytes();
66 let n = bytes.len();
67 let kw_ok = n == 5 || !(bytes[5].is_ascii_alphanumeric() || bytes[5] == b'_');
68 if kw_ok {
69 let rest_after_using = after[5..].trim_start();
70 let method_len: usize =
72 rest_after_using.chars().take_while(|c| c.is_alphanumeric() || *c == '_').map(|c| c.len_utf8()).sum();
73 after = rest_after_using[method_len..].trim_start();
74 }
75 }
76 if !after.starts_with('(') {
77 if rest[table_start..after_table].len() == rest[table_start..].trim_end().len() {
79 return Some(Phase::ExpectTable);
80 }
81 return None;
82 }
83 let body_bytes = after.as_bytes();
88 let mut depth: i32 = 0;
89 let mut k = 0usize;
90 while k < body_bytes.len() {
91 match body_bytes[k] {
92 b'(' => depth += 1,
93 b')' => {
94 depth -= 1;
95 if depth == 0 {
96 return None;
98 }
99 },
100 _ => {},
101 }
102 k += 1;
103 }
104 let name = table.rsplit('.').next().unwrap_or(&table).to_string();
106 Some(Phase::CtlExpectFkColumn { table: name })
107}
108
109fn find_kw(upper: &str, kw: &str) -> Option<usize> {
111 let bytes = upper.as_bytes();
112 let n = bytes.len();
113 let mut from = 0usize;
114 while let Some(rel) = upper[from..].find(kw) {
115 let i = from + rel;
116 let after = i + kw.len();
117 let prev_ok = i == 0 || !(bytes[i - 1].is_ascii_alphanumeric() || bytes[i - 1] == b'_');
118 let next_ok = after >= n || !(bytes[after].is_ascii_alphanumeric() || bytes[after] == b'_');
119 if prev_ok && next_ok {
120 return Some(i);
121 }
122 from = after;
123 }
124 None
125}