use common::keywords::could_be_reserved;
use common::{LeafError, internal_todo};
use parse_common::error::{MessageKind, RenderedError, SyntaxError};
use parse_common::span::Span;
#[derive(Debug, Clone, thiserror::Error)]
pub enum ParseError {
#[error("Size of query script exceeded maximum supported size of 4,294,967,295 bytes.")]
QueryTooLarge,
#[error("Parse error: {0}")]
InvalidQuery(RenderedError),
}
impl LeafError for ParseError {
fn map_kind(self, message: String) -> TypesError {
match self {
ParseError::QueryTooLarge => internal_todo(message),
ParseError::InvalidQuery(_) => TypesError::validation(message, None),
}
}
}
use surrealdb_parser_next::kw::Kw;
use surrealdb_parser_next::lex::{Lexer, T};
use surrealdb_strand::TableName;
use surrealdb_types::{
Datetime as PublicDatetime, Duration as PublicDuration, Error as TypesError,
RecordId as PublicRecordId, Value as PublicValue,
};
use tracing::instrument;
use super::query::Query as Ast;
use super::settings::{ParserConfig, ParserSettings};
use super::{entry, value as values};
use crate::expr::{Block, Expr, Fields, Function, Idiom, KeyNames, Kind};
pub fn could_be_reserved_keyword(s: &str) -> bool {
could_be_reserved(s)
}
pub fn render(input: &str, e: &entry::Error) -> RenderedError {
let span = |start: u32, end: u32| Span {
offset: start,
len: end.saturating_sub(start),
};
let err = match e {
entry::Error::Syntax(d) => {
let d = *d;
let mut err = SyntaxError::new(super::diagnostic::message(input, &d));
err = if d.label.is_empty() {
err.with_span(span(d.start, d.end), MessageKind::Error)
} else {
err.with_labeled_span(
span(d.start, d.end),
MessageKind::Error,
super::diagnostic::fill(d.label, input, d.start, d.end),
)
};
if let Some(x) = d.extra {
err = err.with_labeled_span(
span(x.start, x.end),
MessageKind::Error,
super::diagnostic::fill(x.label, input, x.start, x.end),
);
}
err
}
entry::Error::Lower(r) => {
let mut err = SyntaxError::new(&r.msg);
err = match (r.span, &r.label) {
(None, _) => err,
(Some((start, end)), None) => err.with_span(span(start, end), MessageKind::Error),
(Some((start, end)), Some(label)) => {
err.with_labeled_span(span(start, end), MessageKind::Error, label)
}
};
if let Some((start, end, label)) = &r.extra {
err = err.with_labeled_span(span(*start, *end), MessageKind::Error, label);
}
err
}
};
err.render_on(input)
}
fn run<T>(input: &str, parse: impl FnOnce() -> Result<T, entry::Error>) -> Result<T, ParseError> {
if input.len() > u32::MAX as usize {
return Err(ParseError::QueryTooLarge);
}
parse().map_err(|e| ParseError::InvalidQuery(render(input, &e)))
}
#[instrument(level = "trace", target = "surrealdb::core::syn", skip(input), fields(length = input.len()))]
pub fn parse(input: &str) -> Result<Ast, ParseError> {
query_with_settings(input, ParserSettings::all_features(&ParserConfig::default()))
}
#[instrument(level = "trace", target = "surrealdb::core::syn", skip(input), fields(length = input.len()))]
pub fn query_with_settings(input: &str, settings: ParserSettings) -> Result<Ast, ParseError> {
run(input, || entry::query(input, &settings.next()))
}
#[instrument(level = "trace", target = "surrealdb::core::syn", skip(input), fields(length = input.len()))]
pub fn execution_query_with_settings(
input: &str,
settings: ParserSettings,
) -> Result<Vec<super::ExecutionStatement>, ParseError> {
run(input, || entry::execution_query(input, settings))
}
#[instrument(level = "trace", target = "surrealdb::core::syn", skip(input), fields(length = input.len()))]
pub fn expr_with_settings(
input: &str,
settings: ParserSettings,
require_all: bool,
) -> Result<Expr, ParseError> {
run(input, || entry::expr(input, &settings.next(), require_all))
}
#[instrument(level = "trace", target = "surrealdb::core::syn", skip(input), fields(length = input.len()))]
pub fn logical_expr_with_settings(
input: &str,
settings: ParserSettings,
require_all: bool,
) -> Result<crate::expr::logical::LogicalExpr, ParseError> {
run(input, || entry::logical_expr(input, &settings.next(), require_all, false))
}
#[instrument(level = "trace", target = "surrealdb::core::syn", skip(input), fields(length = input.len()))]
pub fn idiom_with_settings(
input: &str,
settings: ParserSettings,
require_all: bool,
) -> Result<Idiom, ParseError> {
run(input, || entry::idiom(input, &settings.next(), require_all))
}
#[instrument(level = "trace", target = "surrealdb::core::syn", skip(input), fields(length = input.len()))]
pub fn kind_with_settings(
input: &str,
settings: ParserSettings,
require_all: bool,
) -> Result<Kind, ParseError> {
run(input, || entry::kind(input, &settings.next(), require_all))
}
#[instrument(level = "trace", target = "surrealdb::core::syn", skip(input), fields(length = input.len()))]
pub fn id_kind_with_settings(
input: &str,
settings: ParserSettings,
require_all: bool,
) -> Result<(Kind, Option<KeyNames>), ParseError> {
run(input, || entry::id_kind(input, &settings.next(), require_all, false))
}
#[instrument(level = "trace", target = "surrealdb::core::syn", skip(input), fields(length = input.len()))]
pub fn fields_with_settings(
input: &str,
settings: ParserSettings,
require_all: bool,
) -> Result<Fields, ParseError> {
run(input, || entry::fields(input, &settings.next(), require_all))
}
#[instrument(level = "trace", target = "surrealdb::core::syn", skip(input), fields(length = input.len()))]
pub fn expr(input: &str) -> Result<Expr, ParseError> {
expr_with_settings(input, ParserSettings::all_features(&ParserConfig::default()), false)
}
#[instrument(level = "trace", target = "surrealdb::core::syn", skip(input), fields(length = input.len()))]
pub fn expr_legacy_strand(input: &str) -> Result<Expr, ParseError> {
let settings = ParserSettings {
object_recursion_limit: usize::MAX,
query_recursion_limit: usize::MAX,
expr_recursion_limit: usize::MAX,
legacy_strands: true,
..Default::default()
};
expr_with_settings(input, settings, false)
}
#[instrument(level = "trace", target = "surrealdb::core::syn", skip(input), fields(length = input.len()))]
pub fn block(input: &str) -> Result<Block, ParseError> {
block_with_settings(input, ParserSettings::STORED_TEXT, true).map(|mut value| {
crate::expr::credentials::prepare(&mut value);
value
})
}
#[instrument(level = "trace", target = "surrealdb::core::syn", skip(input), fields(length = input.len()))]
pub fn block_with_settings(
input: &str,
settings: ParserSettings,
require_all_input: bool,
) -> Result<Block, ParseError> {
run(input, || entry::block(input, &settings.next(), require_all_input))
}
#[instrument(level = "trace", target = "surrealdb::core::syn", skip(input), fields(length = input.len()))]
pub fn idiom(input: &str) -> Result<Idiom, ParseError> {
idiom_with_settings(input, ParserSettings::default(), false)
}
#[instrument(level = "trace", target = "surrealdb::core::syn", skip(input), fields(length = input.len()))]
pub fn value(input: &str) -> Result<PublicValue, ParseError> {
value_with_settings(input, ParserSettings::default())
}
#[instrument(level = "trace", target = "surrealdb::core::syn", skip(input), fields(length = input.len()))]
pub fn value_with_settings(
input: &str,
settings: ParserSettings,
) -> Result<PublicValue, ParseError> {
run(input, || values::value(input, &settings.next()))
}
#[instrument(level = "trace", target = "surrealdb::core::syn", skip(input), fields(length = input.len()))]
pub fn json_with_settings(
input: &str,
settings: ParserSettings,
) -> Result<PublicValue, ParseError> {
run(input, || values::json(input, &settings.next()))
}
#[instrument(level = "trace", target = "surrealdb::core::syn", skip(input), fields(length = input.len()))]
pub fn record_id(input: &str) -> Result<PublicRecordId, ParseError> {
run(input, || values::record_id(input, &ParserSettings::default().next()))
}
#[instrument(level = "trace", target = "surrealdb::core::syn", skip(input), fields(length = input.len()))]
pub fn kind_for_definition(input: &str) -> Result<Kind, ParseError> {
let mut kind = match kind_with_settings(input, ParserSettings::STORED_TEXT, true) {
Ok(kind) => kind,
Err(err @ ParseError::InvalidQuery(_)) => union_with_an_any_member(input).ok_or(err)?,
Err(err) => return Err(err),
};
crate::expr::credentials::prepare(&mut kind);
Ok(kind)
}
fn union_with_an_any_member(input: &str) -> Option<Kind> {
let mut members = Vec::new();
let mut lexer = Lexer::new(input.as_bytes());
let mut depth = 0u32;
let mut start = 0;
loop {
let token = lexer.next_token();
if token.kind == T::Eof {
break;
} else if token.kind == T::Invalid {
return None;
} else if matches!(token.kind, T::Lt | T::LParen | T::LBracket | T::LBrace) {
depth += 1;
} else if matches!(token.kind, T::Gt | T::RParen | T::RBracket | T::RBrace) {
depth = depth.checked_sub(1)?;
} else if token.kind == T::Pipe && depth == 0 {
members.push(&input[start..token.start as usize]);
start = token.end as usize;
}
}
members.push(&input[start..]);
let is_any = |member: &str| {
let mut lexer = Lexer::new(member.as_bytes());
lexer.next_token().is_kw(Kw::Any) && lexer.next_token().kind == T::Eof
};
if members.len() < 2 || !members.iter().any(|member| is_any(member)) {
return None;
}
for member in members.into_iter().filter(|member| !is_any(member)) {
kind_with_settings(member, ParserSettings::STORED_TEXT, true).ok()?;
}
Some(Kind::Any)
}
#[instrument(level = "trace", target = "surrealdb::core::syn", skip(input), fields(length = input.len()))]
pub fn id_kind_for_definition(input: &str) -> Result<(Kind, Option<KeyNames>), ParseError> {
run(input, || entry::id_kind(input, &ParserSettings::STORED_TEXT.next(), true, true)).map(
|(mut kind, names)| {
crate::expr::credentials::prepare(&mut kind);
(kind, names)
},
)
}
#[instrument(level = "trace", target = "surrealdb::core::syn", skip(input), fields(length = input.len()))]
pub fn value_legacy_strand(input: &str, config: &ParserConfig) -> Result<PublicValue, ParseError> {
let settings = ParserSettings {
object_recursion_limit: config.max_object_parsing_depth as usize,
query_recursion_limit: config.max_query_parsing_depth as usize,
legacy_strands: true,
..Default::default()
};
value_with_settings(input, settings)
}
#[instrument(level = "trace", target = "surrealdb::core::syn", skip(input), fields(length = input.len()))]
pub fn expr_for_definition(input: &str) -> Result<Expr, ParseError> {
expr_with_settings(input, ParserSettings::STORED_TEXT, true).map(|mut value| {
crate::expr::credentials::prepare(&mut value);
value
})
}
#[instrument(level = "trace", target = "surrealdb::core::syn", skip(input), fields(length = input.len()))]
pub fn logical_expr_for_definition(
input: &str,
) -> Result<crate::expr::logical::LogicalExpr, ParseError> {
run(input, || entry::logical_expr(input, &ParserSettings::STORED_TEXT.next(), true, true))
}
#[instrument(level = "trace", target = "surrealdb::core::syn", skip(input), fields(length = input.len()))]
pub fn logical_block_for_definition(
input: &str,
) -> Result<crate::expr::logical::LogicalOp, ParseError> {
run(input, || entry::logical_block(input, &ParserSettings::STORED_TEXT.next()))
}
#[instrument(level = "trace", target = "surrealdb::core::syn", skip(input), fields(length = input.len()))]
pub fn duration(input: &str) -> Result<PublicDuration, ParseError> {
run(input, || entry::duration(input, &ParserSettings::default().next()))
.map(PublicDuration::from)
}
#[instrument(level = "trace", target = "surrealdb::core::syn", skip(input), fields(length = input.len()))]
pub fn datetime(input: &str) -> Result<PublicDatetime, ParseError> {
run(input, || entry::datetime(input))
}
#[instrument(level = "trace", target = "surrealdb::core::syn", skip(input), fields(length = input.len()))]
pub fn table(input: &str) -> Result<TableName, ParseError> {
run(input, || entry::table(input, &ParserSettings::default().next()))
}
#[instrument(level = "trace", target = "surrealdb::core::syn", skip(input), fields(length = input.len()))]
pub fn function_with_settings(
input: &str,
settings: ParserSettings,
) -> Result<Function, ParseError> {
run(input, || entry::function(input, &settings.next()))
}
#[instrument(level = "trace", target = "surrealdb::core::syn", skip(input), fields(length = input.len()))]
pub fn block_for_definition(input: &str) -> Result<Block, ParseError> {
block(input)
}
#[instrument(level = "trace", target = "surrealdb::core::syn", skip(input), fields(length = input.len()))]
pub fn idiom_for_definition(input: &str) -> Result<Idiom, ParseError> {
idiom_with_settings(input, ParserSettings::STORED_TEXT, true).map(|mut value| {
crate::expr::credentials::prepare(&mut value);
value
})
}
#[instrument(level = "trace", target = "surrealdb::core::syn", skip(input), fields(length = input.len()))]
pub fn fields_for_definition(input: &str) -> Result<Fields, ParseError> {
fields_with_settings(input, ParserSettings::STORED_TEXT, true).map(|mut value| {
crate::expr::credentials::prepare(&mut value);
value
})
}
#[instrument(level = "trace", target = "surrealdb::core::syn", skip(input), fields(length = input.len()))]
pub fn kind(input: &str) -> Result<Kind, ParseError> {
kind_with_settings(input, ParserSettings::default(), false)
}