surql_parser/upstream/syn/parser/stmt/
remove.rs

1use crate::upstream::sql::statements::remove::{
2	RemoveAnalyzerStatement, RemoveApiStatement, RemoveBucketStatement, RemoveModuleStatement,
3	RemoveSequenceStatement,
4};
5use crate::upstream::sql::statements::{
6	RemoveAccessStatement, RemoveDatabaseStatement, RemoveEventStatement, RemoveFieldStatement,
7	RemoveFunctionStatement, RemoveIndexStatement, RemoveNamespaceStatement, RemoveParamStatement,
8	RemoveStatement, RemoveUserStatement,
9};
10use crate::upstream::sql::{ModuleName, Param};
11use crate::upstream::syn::error::bail;
12use crate::upstream::syn::parser::mac::{expected, expected_whitespace, unexpected};
13use crate::upstream::syn::parser::{ParseResult, Parser};
14use crate::upstream::syn::token::t;
15use reblessive::Stk;
16impl Parser<'_> {
17	pub async fn parse_remove_stmt(&mut self, stk: &mut Stk) -> ParseResult<RemoveStatement> {
18		let next = self.next();
19		let res = match next.kind {
20			t!("NAMESPACE") => {
21				let expunge = if self.eat(t!("AND")) {
22					expected!(self, t!("EXPUNGE"));
23					true
24				} else {
25					false
26				};
27				let if_exists = if self.eat(t!("IF")) {
28					expected!(self, t!("EXISTS"));
29					true
30				} else {
31					false
32				};
33				let name = stk.run(|stk| self.parse_expr_field(stk)).await?;
34				RemoveStatement::Namespace(RemoveNamespaceStatement {
35					name,
36					if_exists,
37					expunge,
38				})
39			}
40			t!("DATABASE") => {
41				let expunge = if self.eat(t!("AND")) {
42					expected!(self, t!("EXPUNGE"));
43					true
44				} else {
45					false
46				};
47				let if_exists = if self.eat(t!("IF")) {
48					expected!(self, t!("EXISTS"));
49					true
50				} else {
51					false
52				};
53				let name = stk.run(|stk| self.parse_expr_field(stk)).await?;
54				RemoveStatement::Database(RemoveDatabaseStatement {
55					name,
56					if_exists,
57					expunge,
58				})
59			}
60			t!("FUNCTION") => {
61				let if_exists = if self.eat(t!("IF")) {
62					expected!(self, t!("EXISTS"));
63					true
64				} else {
65					false
66				};
67				let name = self.parse_custom_function_name()?;
68				let next = self.peek();
69				if self.eat(t!("(")) {
70					self.expect_closing_delimiter(t!(")"), next.span)?;
71				}
72				RemoveStatement::Function(RemoveFunctionStatement { name, if_exists })
73			}
74			t!("MODULE") => {
75				if !self.settings.surrealism_enabled {
76					bail!(
77						"Experimental capability `surrealism` is not enabled", @ self
78						.last_span() => "Use of `REMOVE MODULE` is still experimental"
79					)
80				}
81				let if_exists = if self.eat(t!("IF")) {
82					expected!(self, t!("EXISTS"));
83					true
84				} else {
85					false
86				};
87				let peek = self.peek();
88				let name = match peek.kind {
89					t!("mod") => {
90						self.pop_peek();
91						expected_whitespace!(self, t!("::"));
92						let name = self.parse_ident()?;
93						ModuleName::Module(name)
94					}
95					t!("silo") => {
96						self.pop_peek();
97						expected_whitespace!(self, t!("::"));
98						let organisation = self.parse_ident()?;
99						expected_whitespace!(self, t!("::"));
100						let package = self.parse_ident()?;
101						expected_whitespace!(self, t!("<"));
102						let major = self.parse_version_digits()?;
103						expected_whitespace!(self, t!("."));
104						let minor = self.parse_version_digits()?;
105						expected_whitespace!(self, t!("."));
106						let patch = self.parse_version_digits()?;
107						expected_whitespace!(self, t!(">"));
108						ModuleName::Silo(organisation, package, major, minor, patch)
109					}
110					_ => unexpected!(self, peek, "a module name"),
111				};
112				let next = self.peek();
113				if self.eat(t!("(")) {
114					self.expect_closing_delimiter(t!(")"), next.span)?;
115				}
116				RemoveStatement::Module(RemoveModuleStatement { name, if_exists })
117			}
118			t!("ACCESS") => {
119				let if_exists = if self.eat(t!("IF")) {
120					expected!(self, t!("EXISTS"));
121					true
122				} else {
123					false
124				};
125				let name = stk.run(|stk| self.parse_expr_field(stk)).await?;
126				expected!(self, t!("ON"));
127				let base = self.parse_base()?;
128				RemoveStatement::Access(RemoveAccessStatement {
129					name,
130					base,
131					if_exists,
132				})
133			}
134			t!("PARAM") => {
135				let if_exists = if self.eat(t!("IF")) {
136					expected!(self, t!("EXISTS"));
137					true
138				} else {
139					false
140				};
141				let name = self.next_token_value::<Param>()?;
142				RemoveStatement::Param(RemoveParamStatement {
143					name: name.to_string(),
144					if_exists,
145				})
146			}
147			t!("TABLE") => {
148				let expunge = if self.eat(t!("AND")) {
149					expected!(self, t!("EXPUNGE"));
150					true
151				} else {
152					false
153				};
154				let if_exists = if self.eat(t!("IF")) {
155					expected!(self, t!("EXISTS"));
156					true
157				} else {
158					false
159				};
160				let name = stk.run(|stk| self.parse_expr_field(stk)).await?;
161				RemoveStatement::Table(crate::upstream::sql::statements::RemoveTableStatement {
162					name,
163					if_exists,
164					expunge,
165				})
166			}
167			t!("EVENT") => {
168				let if_exists = if self.eat(t!("IF")) {
169					expected!(self, t!("EXISTS"));
170					true
171				} else {
172					false
173				};
174				let name = stk.run(|stk| self.parse_expr_field(stk)).await?;
175				expected!(self, t!("ON"));
176				self.eat(t!("TABLE"));
177				let table = stk.run(|stk| self.parse_expr_field(stk)).await?;
178				RemoveStatement::Event(RemoveEventStatement {
179					name,
180					what: table,
181					if_exists,
182				})
183			}
184			t!("FIELD") => {
185				let if_exists = if self.eat(t!("IF")) {
186					expected!(self, t!("EXISTS"));
187					true
188				} else {
189					false
190				};
191				let name = stk.run(|stk| self.parse_expr_field(stk)).await?;
192				expected!(self, t!("ON"));
193				self.eat(t!("TABLE"));
194				let what = stk.run(|stk| self.parse_expr_field(stk)).await?;
195				RemoveStatement::Field(RemoveFieldStatement {
196					name,
197					what,
198					if_exists,
199				})
200			}
201			t!("INDEX") => {
202				let if_exists = if self.eat(t!("IF")) {
203					expected!(self, t!("EXISTS"));
204					true
205				} else {
206					false
207				};
208				let name = stk.run(|stk| self.parse_expr_field(stk)).await?;
209				expected!(self, t!("ON"));
210				self.eat(t!("TABLE"));
211				let what = stk.run(|stk| self.parse_expr_field(stk)).await?;
212				RemoveStatement::Index(RemoveIndexStatement {
213					name,
214					what,
215					if_exists,
216				})
217			}
218			t!("ANALYZER") => {
219				let if_exists = if self.eat(t!("IF")) {
220					expected!(self, t!("EXISTS"));
221					true
222				} else {
223					false
224				};
225				let name = stk.run(|stk| self.parse_expr_field(stk)).await?;
226				RemoveStatement::Analyzer(RemoveAnalyzerStatement { name, if_exists })
227			}
228			t!("SEQUENCE") => {
229				let if_exists = if self.eat(t!("IF")) {
230					expected!(self, t!("EXISTS"));
231					true
232				} else {
233					false
234				};
235				let name = stk.run(|stk| self.parse_expr_field(stk)).await?;
236				RemoveStatement::Sequence(RemoveSequenceStatement { name, if_exists })
237			}
238			t!("USER") => {
239				let if_exists = if self.eat(t!("IF")) {
240					expected!(self, t!("EXISTS"));
241					true
242				} else {
243					false
244				};
245				let name = stk.run(|stk| self.parse_expr_field(stk)).await?;
246				expected!(self, t!("ON"));
247				let base = self.parse_base()?;
248				RemoveStatement::User(RemoveUserStatement {
249					name,
250					base,
251					if_exists,
252				})
253			}
254			t!("API") => {
255				let if_exists = if self.eat(t!("IF")) {
256					expected!(self, t!("EXISTS"));
257					true
258				} else {
259					false
260				};
261				let name = stk.run(|stk| self.parse_expr_field(stk)).await?;
262				RemoveStatement::Api(RemoveApiStatement { name, if_exists })
263			}
264			t!("BUCKET") => {
265				let if_exists = if self.eat(t!("IF")) {
266					expected!(self, t!("EXISTS"));
267					true
268				} else {
269					false
270				};
271				let name = stk.run(|stk| self.parse_expr_field(stk)).await?;
272				RemoveStatement::Bucket(RemoveBucketStatement { name, if_exists })
273			}
274			_ => unexpected!(self, next, "a remove statement keyword"),
275		};
276		Ok(res)
277	}
278}
surql_parser/upstream/syn/parser/stmt/remove.rs

surql_parser/upstream/syn/parser/stmt/
remove.rs
