surql_parser/upstream/syn/parser/
kind.rs

1use super::mac::unexpected;
2use super::{ParseResult, Parser};
3use crate::compat::types::PublicDuration;
4use crate::upstream::sql::Kind;
5use crate::upstream::sql::kind::{GeometryKind, KindLiteral};
6use crate::upstream::syn::lexer::compound;
7use crate::upstream::syn::parser::mac::expected;
8use crate::upstream::syn::token::{Keyword, Span, TokenKind, t};
9use reblessive::Stk;
10use std::collections::BTreeMap;
11impl Parser<'_> {
12	/// Parse a kind production.
13	///
14	/// # Parser State
15	/// expects the first `<` to already be eaten
16	pub async fn parse_kind(&mut self, stk: &mut Stk, delim: Span) -> ParseResult<Kind> {
17		let kind = self.parse_inner_kind(stk).await?;
18		self.expect_closing_delimiter(t!(">"), delim)?;
19		Ok(kind)
20	}
21	/// Parse an inner kind, a kind without enclosing `<` `>`.
22	pub async fn parse_inner_kind(&mut self, stk: &mut Stk) -> ParseResult<Kind> {
23		match self.parse_inner_single_kind(stk).await? {
24			Kind::Any => Ok(Kind::Any),
25			first => {
26				if self.peek_kind() == t!("|") {
27					let mut kind = vec![first];
28					while self.eat(t!("|")) {
29						kind.push(stk.run(|ctx| self.parse_concrete_kind(ctx)).await?);
30					}
31					let kind = Kind::either(kind);
32					Ok(kind)
33				} else {
34					Ok(first)
35				}
36			}
37		}
38	}
39	/// Parse a single inner kind, a kind without enclosing `<` `>`.
40	pub(super) async fn parse_inner_single_kind(&mut self, stk: &mut Stk) -> ParseResult<Kind> {
41		match self.peek_kind() {
42			t!("ANY") => {
43				self.pop_peek();
44				Ok(Kind::Any)
45			}
46			t!("OPTION") => {
47				self.pop_peek();
48				let delim = expected!(self, t!("<")).span;
49				let mut kinds = vec![
50					Kind::None,
51					stk.run(|ctx| self.parse_concrete_kind(ctx)).await?,
52				];
53				if self.peek_kind() == t!("|") {
54					while self.eat(t!("|")) {
55						kinds.push(stk.run(|ctx| self.parse_concrete_kind(ctx)).await?);
56					}
57				}
58				self.expect_closing_delimiter(t!(">"), delim)?;
59				Ok(Kind::either(kinds))
60			}
61			_ => stk.run(|ctx| self.parse_concrete_kind(ctx)).await,
62		}
63	}
64	/// Parse a single kind which is not any, option, or either.
65	async fn parse_concrete_kind(&mut self, stk: &mut Stk) -> ParseResult<Kind> {
66		let next = self.next();
67		match next.kind {
68			t!("true") => Ok(Kind::Literal(KindLiteral::Bool(true))),
69			t!("false") => Ok(Kind::Literal(KindLiteral::Bool(false))),
70			t!("'") | t!("\"") => {
71				let str = self.unescape_string_span(next.span)?;
72				Ok(Kind::Literal(KindLiteral::String(str.to_owned())))
73			}
74			TokenKind::NaN => Ok(Kind::Literal(KindLiteral::Float(f64::NAN))),
75			TokenKind::Infinity => Ok(Kind::Literal(KindLiteral::Float(f64::INFINITY))),
76			t!("+") | t!("-") => {
77				let compound = self.lex_compound(next, compound::number)?;
78				let kind = match compound.value {
79					compound::Numeric::Float(f) => KindLiteral::Float(f),
80					compound::Numeric::Integer(int) => {
81						KindLiteral::Integer(int.into_int(compound.span)?)
82					}
83					compound::Numeric::Decimal(decimal) => KindLiteral::Decimal(decimal),
84					compound::Numeric::Duration(_) => unreachable!(),
85				};
86				Ok(Kind::Literal(kind))
87			}
88			TokenKind::Digits => {
89				let compound = self.lex_compound(next, compound::numeric)?;
90				let v = match compound.value {
91					compound::Numeric::Integer(x) => {
92						KindLiteral::Integer(x.into_int(compound.span)?)
93					}
94					compound::Numeric::Float(x) => KindLiteral::Float(x),
95					compound::Numeric::Decimal(x) => KindLiteral::Decimal(x),
96					compound::Numeric::Duration(x) => {
97						KindLiteral::Duration(PublicDuration::from_std(x))
98					}
99				};
100				Ok(Kind::Literal(v))
101			}
102			t!("{") => {
103				let mut obj = BTreeMap::new();
104				while !self.eat(t!("}")) {
105					let key = self.parse_object_key()?;
106					expected!(self, t!(":"));
107					let kind = stk.run(|ctx| self.parse_inner_kind(ctx)).await?;
108					obj.insert(key, kind);
109					self.eat(t!(","));
110				}
111				Ok(Kind::Literal(KindLiteral::Object(obj)))
112			}
113			t!("[") => {
114				let mut arr = Vec::new();
115				while !self.eat(t!("]")) {
116					let kind = stk.run(|ctx| self.parse_inner_kind(ctx)).await?;
117					arr.push(kind);
118					self.eat(t!(","));
119				}
120				Ok(Kind::Literal(KindLiteral::Array(arr)))
121			}
122			t!("BOOL") => Ok(Kind::Bool),
123			t!("NONE") => Ok(Kind::None),
124			t!("NULL") => Ok(Kind::Null),
125			t!("BYTES") => Ok(Kind::Bytes),
126			t!("DATETIME") => Ok(Kind::Datetime),
127			t!("DECIMAL") => Ok(Kind::Decimal),
128			t!("DURATION") => Ok(Kind::Duration),
129			t!("FLOAT") => Ok(Kind::Float),
130			t!("INT") => Ok(Kind::Int),
131			t!("NUMBER") => Ok(Kind::Number),
132			t!("OBJECT") => Ok(Kind::Object),
133			t!("POINT") => Ok(Kind::Geometry(vec![GeometryKind::Point])),
134			t!("STRING") => Ok(Kind::String),
135			t!("UUID") => Ok(Kind::Uuid),
136			t!("RANGE") => Ok(Kind::Range),
137			t!("REGEX") => Ok(Kind::Regex),
138			t!("FUNCTION") => Ok(Kind::Function(Default::default(), Default::default())),
139			t!("RECORD") => {
140				let span = self.peek().span;
141				if self.eat(t!("<")) {
142					let mut tables = vec![self.parse_ident()?];
143					while self.eat(t!("|")) {
144						tables.push(self.parse_ident()?);
145					}
146					self.expect_closing_delimiter(t!(">"), span)?;
147					Ok(Kind::Record(tables))
148				} else {
149					Ok(Kind::Record(Vec::new()))
150				}
151			}
152			t!("TABLE") => {
153				let span = self.peek().span;
154				if self.eat(t!("<")) {
155					let mut tables = vec![self.parse_ident()?];
156					while self.eat(t!("|")) {
157						tables.push(self.parse_ident()?);
158					}
159					self.expect_closing_delimiter(t!(">"), span)?;
160					Ok(Kind::Table(tables))
161				} else {
162					Ok(Kind::Table(Vec::new()))
163				}
164			}
165			t!("GEOMETRY") => {
166				let span = self.peek().span;
167				if self.eat(t!("<")) {
168					let mut kind = vec![self.parse_geometry_kind()?];
169					while self.eat(t!("|")) {
170						kind.push(self.parse_geometry_kind()?);
171					}
172					self.expect_closing_delimiter(t!(">"), span)?;
173					Ok(Kind::Geometry(kind))
174				} else {
175					Ok(Kind::Geometry(Vec::new()))
176				}
177			}
178			t!("ARRAY") => {
179				let span = self.peek().span;
180				if self.eat(t!("<")) {
181					let kind = stk.run(|ctx| self.parse_inner_kind(ctx)).await?;
182					let size = self
183						.eat(t!(","))
184						.then(|| self.next_token_value())
185						.transpose()?;
186					self.expect_closing_delimiter(t!(">"), span)?;
187					Ok(Kind::Array(Box::new(kind), size))
188				} else {
189					Ok(Kind::Array(Box::new(Kind::Any), None))
190				}
191			}
192			t!("SET") => {
193				let span = self.peek().span;
194				if self.eat(t!("<")) {
195					let kind = stk.run(|ctx| self.parse_inner_kind(ctx)).await?;
196					let size = self
197						.eat(t!(","))
198						.then(|| self.next_token_value())
199						.transpose()?;
200					self.expect_closing_delimiter(t!(">"), span)?;
201					Ok(Kind::Set(Box::new(kind), size))
202				} else {
203					Ok(Kind::Set(Box::new(Kind::Any), None))
204				}
205			}
206			t!("FILE") => {
207				let span = self.peek().span;
208				if self.eat(t!("<")) {
209					let mut buckets = vec![self.parse_ident()?];
210					while self.eat(t!("|")) {
211						buckets.push(self.parse_ident()?);
212					}
213					self.expect_closing_delimiter(t!(">"), span)?;
214					Ok(Kind::File(buckets))
215				} else {
216					Ok(Kind::File(Vec::new()))
217				}
218			}
219			_ => unexpected!(self, next, "a kind name"),
220		}
221	}
222	/// Parse the kind of gemoetry
223	fn parse_geometry_kind(&mut self) -> ParseResult<GeometryKind> {
224		let next = self.next();
225		match next.kind {
226			TokenKind::Keyword(keyword) => match keyword {
227				Keyword::Point => Ok(GeometryKind::Point),
228				Keyword::Line => Ok(GeometryKind::Line),
229				Keyword::Polygon => Ok(GeometryKind::Polygon),
230				Keyword::MultiPoint => Ok(GeometryKind::MultiPoint),
231				Keyword::MultiLine => Ok(GeometryKind::MultiLine),
232				Keyword::MultiPolygon => Ok(GeometryKind::MultiPolygon),
233				Keyword::Collection => Ok(GeometryKind::Collection),
234				_ => unexpected!(self, next, "a geometry kind name"),
235			},
236			_ => unexpected!(self, next, "a geometry kind name"),
237		}
238	}
239}
surql_parser/upstream/syn/parser/kind.rs

surql_parser/upstream/syn/parser/
kind.rs
