Skip to main content

dsl_completion/
create_index.rs

1//! CREATE INDEX sub-phase detector.
2//!
3//! Recognises `CREATE [UNIQUE] INDEX [CONCURRENTLY] [IF NOT EXISTS] <name>
4//! ON <table> (<expr>, ...)` and returns the right [`Phase`] depending on
5//! cursor position:
6//!
7//! - right after `ON ` -> `ExpectTable` (catalog table list)
8//! - inside the paren body -> `CtlExpectFkColumn { table }` so only columns
9//!   of THIS table appear
10
11use 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  // Find the most recent CREATE INDEX header before the cursor.
19  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  // Ensure the header isn't already terminated by `;` before the cursor.
37  if source[start..pos].contains(';') {
38    return None;
39  }
40
41  // Find the `ON` keyword between start and cursor.
42  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  // Read the table name token after ON.
49  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    // Cursor sits between `ON ` and any name -> suggest tables.
55    return Some(Phase::ExpectTable);
56  }
57  let after_table = table_start + table.len();
58
59  // Past the table -- skip an optional `USING <method>` clause so
60  // `CREATE INDEX ix ON users USING btree (` still routes the cursor
61  // inside the paren body to the table-column slot.
62  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      // Consume the method name (single word identifier).
71      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    // Still typing the table name -> tables.
78    if rest[table_start..after_table].len() == rest[table_start..].trim_end().len() {
79      return Some(Phase::ExpectTable);
80    }
81    return None;
82  }
83  // Walk the paren body. When it closes BEFORE the cursor the user is in
84  // the trailing-clause slot (INCLUDE / WHERE / WITH / ...), which is
85  // handled by the engine-level keyword fallback -- return None here so
86  // that path can fire.
87  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          // Cursor sits past the closing paren -> trailing-clause slot.
97          return None;
98        }
99      },
100      _ => {},
101    }
102    k += 1;
103  }
104  // Paren still open -> cursor sits inside the index expression list.
105  let name = table.rsplit('.').next().unwrap_or(&table).to_string();
106  Some(Phase::CtlExpectFkColumn { table: name })
107}
108
109/// Whole-word match of `kw` in `upper`. Returns its byte offset or None.
110fn 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}