use common::fmt::{
EscapeIdent, EscapeKwFreeIdent, EscapeKwIdent, EscapeObjectKey, Float, QuoteStr, SqlDuration,
};
use surrealdb_parser_next::ast::{self, Ast, Binary, NONE, Node, NodeId, Prefix, Tag};
use surrealdb_parser_next::decode;
use surrealdb_parser_next::lex::decode_duration;
use surrealdb_types::{SqlFormat, ToSql};
use super::{CHECK_NAMES, Lower, R, Reject, binary, lit};
use crate::expr::operator::BindingPower;
use crate::expr::{BinaryOperator, Function, Literal};
fn put<T: ToSql + ?Sized>(out: &mut String, v: &T) {
v.fmt_sql(out, SqlFormat::SingleLine);
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum LitShape {
None,
Null,
Int {
neg: bool,
},
Float {
neg: bool,
},
Decimal {
neg: bool,
},
RecordId,
UnboundedRange,
Other,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum FirstPart {
Empty,
Field,
Doc,
Lookup {
out: bool,
},
Start(NodeId),
Other,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum PostfixKind {
Range,
Call,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum Shape {
Lit(LitShape),
Param,
Table,
Mock,
Block,
Constant,
Idiom(FirstPart),
Prefix {
bp: BindingPower,
neg: bool,
},
Postfix(PostfixKind),
Binary(BindingPower),
FunctionCall,
Closure,
Break,
Continue,
Throw,
Return {
fetch: bool,
},
Stmt,
}
impl Shape {
fn bp(self) -> BindingPower {
if let Shape::Prefix {
bp,
..
}
| Shape::Binary(bp) = self
{
bp
} else if let Shape::Postfix(kind) = self {
match kind {
PostfixKind::Range => BindingPower::Range,
PostfixKind::Call => BindingPower::Call,
}
} else {
BindingPower::Prime
}
}
fn needs_parentheses(self) -> bool {
matches!(
self,
Shape::Lit(LitShape::UnboundedRange | LitShape::RecordId)
| Shape::Closure
| Shape::Break
| Shape::Continue
| Shape::Throw
| Shape::Return { .. }
| Shape::Stmt
| Shape::Postfix(_)
)
}
fn covered(self) -> bool {
matches!(
self,
Shape::Stmt
| Shape::Return {
fetch: true
}
)
}
}
fn prefix_op(op: u8) -> (&'static str, BindingPower, bool) {
match op {
x if x == Prefix::Not as u8 => ("!", BindingPower::Prefix, false),
x if x == Prefix::Neg as u8 => ("-", BindingPower::Prefix, true),
x if x == Prefix::Pos as u8 => ("+", BindingPower::Prefix, false),
x if x == Prefix::Range as u8 => ("..", BindingPower::Range, false),
_ => ("..=", BindingPower::Range, false),
}
}
fn slots(ast: &Ast, at: u32, len: usize) -> &[u32] {
&ast.extra[at as usize..at as usize + len]
}
#[derive(Clone, Copy)]
enum PartRef {
Doc,
Name(NodeId),
Start(NodeId),
Listed(NodeId),
}
impl Lower<'_> {
pub fn render_expr(&self, id: NodeId, out: &mut String) -> R<()> {
let n = self.n(id);
if matches!(
n.tag,
Tag::Array
| Tag::Object
| Tag::Prefix
| Tag::Cast | Tag::Binary
| Tag::Block | Tag::Set
) {
self.render_nesting(n, out)
} else {
self.render_other(id, out)
}
}
pub fn render_idiom(&self, id: NodeId, out: &mut String) -> R<()> {
let parts = self.idiom_parts(id)?;
for (i, part) in parts.iter().enumerate() {
self.render_part_ref(*part, i == 0, out)?;
}
Ok(())
}
pub fn render_part(&self, id: NodeId, i: usize, out: &mut String) -> R<()> {
let parts = self.idiom_parts(id)?;
match parts.get(i) {
Some(part) => self.render_part_ref(*part, false, out),
None => Err(Reject::new("no such idiom part")),
}
}
pub fn render_top(&self, id: NodeId, out: &mut String) -> R<()> {
let tag = self.n(id).tag;
if matches!(
tag,
Tag::Begin
| Tag::Cancel
| Tag::Commit
| Tag::Use | Tag::OptionStmt
| Tag::Kill | Tag::Live
| Tag::Show | Tag::AccessStmt
) {
put(out, &self.top(id)?);
Ok(())
} else if self.is_param_equality(id) {
out.push('(');
self.render_expr(id, out)?;
out.push(')');
Ok(())
} else {
self.render_expr(id, out)
}
}
#[inline(never)]
fn render_nesting(&self, n: &Node, out: &mut String) -> R<()> {
if n.tag == Tag::Array {
out.push('[');
self.render_covered_list(self.list(n.a), out)?;
out.push(']');
} else if n.tag == Tag::Object {
self.render_object(n, out)?;
} else if n.tag == Tag::Prefix {
let (text, bp, neg) = prefix_op(n.op);
out.push_str(text);
self.render_operand(bp, neg, n.a, out)?;
} else if n.tag == Tag::Cast {
out.push('<');
put(out, &self.kind(n.a)?);
out.push_str("> ");
self.render_operand(BindingPower::Prefix, false, n.b, out)?;
} else if n.tag == Tag::Binary {
let op = binary(Binary::from_u8(n.op));
self.render_binary(&op, n.a, n.b, out)?;
} else if n.tag == Tag::Block {
self.render_block(self.list(n.a), out)?;
} else if n.tag == Tag::Set {
self.render_set(self.list(n.a), out)?;
} else {
return Err(Reject::new(format!("not a nesting expression: {:?}", n.tag)));
}
Ok(())
}
#[inline(never)]
fn render_other(&self, id: NodeId, out: &mut String) -> R<()> {
let n = self.n(id);
let tag = n.tag;
if tag == Tag::None {
out.push_str("NONE");
} else if tag == Tag::Null {
out.push_str("NULL");
} else if tag == Tag::True {
out.push_str("true");
} else if tag == Tag::False {
out.push_str("false");
} else if tag == Tag::Int {
out.push_str(&Ast::int(n).to_string());
} else if tag == Tag::Float {
put(out, &Float(Ast::float(n)));
} else if tag == Tag::NaN {
put(out, &Float(f64::NAN));
} else if tag == Tag::Infinity {
put(out, &Float(f64::INFINITY));
} else if tag == Tag::UnboundedRange {
out.push_str("..");
} else if tag == Tag::Decimal {
put(out, &lit::decimal_of(n.op, self.text(id))?);
} else if tag == Tag::Regex {
put(out, &lit::regex_at(self.text(id), n.start, n.end)?);
} else if tag == Tag::Path {
match lit::builtin(&self.path_name(id)?, n.start, n.end)? {
lit::Builtin::Constant(c) => put(out, &c),
lit::Builtin::Function(_) => return Err(self.unexpected_after(n.end, "(")),
}
} else if tag == Tag::Duration {
let (s, ns) = decode_duration(self.text(id).as_bytes())
.ok_or(Reject::new("duration overflow"))?;
put(out, &SqlDuration(std::time::Duration::new(s, ns)));
} else if tag == Tag::Str {
self.render_str(id, out)?;
} else if tag == Tag::Param {
out.push('$');
put(out, &EscapeKwFreeIdent(&self.param_name(id)?));
} else if tag == Tag::Field || tag == Tag::Table {
put(out, &EscapeIdent(self.name(id)?));
} else if tag == Tag::RecordId {
put(out, &EscapeIdent(self.name(n.a)?));
out.push(':');
self.render_key(n.b, out)?;
} else if tag == Tag::BinaryX {
let op = self.binary_extended(n)?;
let right = self.ast.extra[n.b as usize];
self.render_binary(&op, n.a, right, out)?;
} else if tag == Tag::PostfixRange {
let s = self.shape(n.a)?;
self.render_parenthesised(
s.needs_parentheses() || s.bp() <= BindingPower::Range,
n.a,
out,
)?;
out.push_str(if n.op == 0 {
".."
} else {
">.."
});
} else if tag == Tag::Call {
self.render_call(n, out)?;
} else if tag == Tag::Script {
out.push_str("function(");
self.render_covered_list(self.list(n.b), out)?;
out.push_str(") {");
out.push_str(self.text(n.a));
out.push('}');
} else if tag == Tag::Point {
out.push('(');
put(out, &Float(self.coordinate(n.a)));
out.push_str(", ");
put(out, &Float(self.coordinate(n.b)));
out.push(')');
} else if tag == Tag::CallExpr {
out.push('(');
self.render_expr(n.a, out)?;
out.push_str(")(");
self.render_covered_list(self.list(n.b), out)?;
out.push(')');
} else if tag == Tag::Idiom {
self.render_idiom(id, out)?;
} else if tag == Tag::Select {
self.render_select(n, out)?;
} else if tag == Tag::Create {
self.render_create(n, out)?;
} else if tag == Tag::Update {
self.render_update(n, "UPDATE", true, out)?;
} else if tag == Tag::Upsert {
self.render_update(n, "UPSERT", true, out)?;
} else if tag == Tag::Delete {
self.render_update(n, "DELETE", false, out)?;
} else if tag == Tag::Relate {
self.render_relate(n, out)?;
} else if tag == Tag::Insert {
self.render_insert(n, out)?;
} else if tag == Tag::Return {
out.push_str("RETURN ");
self.render_covered(n.a, out)?;
if n.b != NONE {
out.push_str(" FETCH ");
self.render_list(self.list(n.b), out)?;
}
} else if tag == Tag::Let {
let rec = slots(self.ast, n.a, 3);
out.push_str("LET $");
put(out, &EscapeKwFreeIdent(&self.param_name(rec[0])?));
if rec[1] != NONE {
out.push_str(": ");
put(out, &self.kind(rec[1])?);
}
out.push_str(" = ");
self.render_covered(rec[2], out)?;
} else if tag == Tag::If {
self.render_if(n, out)?;
} else if tag == Tag::For {
let rec = slots(self.ast, n.a, 3);
if self.n(rec[2]).tag != Tag::Block {
return Err(Reject::new("not a block"));
}
out.push_str("FOR $");
put(out, &EscapeKwFreeIdent(&self.param_name(rec[0])?));
out.push_str(" IN ");
self.render_covered(rec[1], out)?;
out.push(' ');
self.render_expr(rec[2], out)?;
} else if tag == Tag::Explain {
out.push_str("EXPLAIN");
if n.op & 1 != 0 {
out.push_str(" ANALYZE");
}
out.push_str(if n.op & 2 != 0 {
" FORMAT JSON "
} else {
" FORMAT TEXT "
});
self.render_expr(n.a, out)?;
} else if tag == Tag::Alter {
put(out, &self.alter(n)?);
} else if tag == Tag::Remove {
put(out, &self.remove(n)?);
} else if tag == Tag::Define {
put(out, &self.define(n)?);
} else if tag == Tag::Closure {
self.render_closure(n, out)?;
} else if tag == Tag::Mock {
self.render_mock(n, out)?;
} else if tag == Tag::Sleep {
let (s, ns) = decode_duration(self.text(n.a).as_bytes())
.ok_or(Reject::new("duration overflow"))?;
out.push_str("SLEEP ");
put(out, &SqlDuration(std::time::Duration::new(s, ns)));
} else if tag == Tag::Throw {
out.push_str("THROW ");
self.render_covered(n.a, out)?;
} else if tag == Tag::Break {
out.push_str("BREAK");
} else if tag == Tag::Continue {
out.push_str("CONTINUE");
} else if tag == Tag::Info {
self.render_info(n, out)?;
} else if tag == Tag::Rebuild {
let rec = slots(self.ast, n.a, 3);
out.push_str("REBUILD INDEX");
if rec[2] & 1 != 0 {
out.push_str(" IF EXISTS");
}
out.push(' ');
put(out, &EscapeKwIdent(&self.name(rec[0])?, &["IF"]));
out.push_str(" ON ");
put(out, &EscapeKwFreeIdent(&self.name(rec[1])?));
if rec[2] & 2 != 0 {
out.push_str(" CONCURRENTLY");
}
} else {
return Err(Reject::new(format!("not an expression: {tag:?}")));
}
Ok(())
}
fn shape(&self, id: NodeId) -> R<Shape> {
let n = self.n(id);
let tag = n.tag;
let sh =
if tag == Tag::None {
Shape::Lit(LitShape::None)
} else if tag == Tag::Null {
Shape::Lit(LitShape::Null)
} else if tag == Tag::Int {
Shape::Lit(LitShape::Int {
neg: Ast::int(n) < 0,
})
} else if tag == Tag::Float {
Shape::Lit(LitShape::Float {
neg: Ast::float(n).is_sign_negative(),
})
} else if tag == Tag::NaN || tag == Tag::Infinity {
Shape::Lit(LitShape::Float {
neg: false,
})
} else if tag == Tag::Decimal {
Shape::Lit({
if n.op == surrealdb_parser_next::ast::DECIMAL_BIG {
LitShape::Decimal {
neg: lit::bigdecimal_value(self.text(id))?.signum() < 0,
}
} else if let Literal::Decimal(d) = lit::decimal(self.text(id))? {
LitShape::Decimal {
neg: d.is_sign_negative(),
}
} else {
LitShape::Other
}
})
} else if tag == Tag::Str {
Shape::Lit(self.str_shape(id)?)
} else if tag == Tag::RecordId {
Shape::Lit(LitShape::RecordId)
} else if tag == Tag::UnboundedRange {
Shape::Lit(LitShape::UnboundedRange)
} else if matches!(
tag,
Tag::True
| Tag::False | Tag::Array
| Tag::Object | Tag::Set
| Tag::Point | Tag::Regex
| Tag::Duration
) {
Shape::Lit(LitShape::Other)
} else if tag == Tag::Path {
Shape::Constant
} else if tag == Tag::Call {
if self.is_constant_call(n)? {
Shape::Postfix(PostfixKind::Call)
} else {
Shape::FunctionCall
}
} else if tag == Tag::Script {
Shape::FunctionCall
} else if tag == Tag::CallExpr {
Shape::Postfix(PostfixKind::Call)
} else if tag == Tag::PostfixRange {
Shape::Postfix(PostfixKind::Range)
} else if tag == Tag::Cast {
Shape::Prefix {
bp: BindingPower::Prefix,
neg: false,
}
} else if tag == Tag::Prefix {
let (_, bp, neg) = prefix_op(n.op);
Shape::Prefix {
bp,
neg,
}
} else if tag == Tag::Binary {
Shape::Binary(BindingPower::for_binary_operator(&binary(Binary::from_u8(n.op))))
} else if tag == Tag::BinaryX {
Shape::Binary(if Binary::from_u8(n.op) == Binary::Matches {
BindingPower::Equality
} else {
BindingPower::Relation
})
} else if tag == Tag::Field {
Shape::Idiom(FirstPart::Field)
} else if tag == Tag::Idiom {
Shape::Idiom(self.first_part(id)?)
} else if tag == Tag::Param {
Shape::Param
} else if tag == Tag::Table {
Shape::Table
} else if tag == Tag::Mock {
Shape::Mock
} else if tag == Tag::Block {
Shape::Block
} else if tag == Tag::Closure {
Shape::Closure
} else if tag == Tag::Break {
Shape::Break
} else if tag == Tag::Continue {
Shape::Continue
} else if tag == Tag::Throw {
Shape::Throw
} else if tag == Tag::Return {
Shape::Return {
fetch: n.b != NONE,
}
} else if matches!(
tag,
Tag::If
| Tag::Select | Tag::Create
| Tag::Update | Tag::Upsert
| Tag::Delete | Tag::Relate
| Tag::Insert | Tag::Define
| Tag::Remove | Tag::Alter
| Tag::Rebuild | Tag::Info
| Tag::For | Tag::Let
| Tag::Sleep | Tag::Explain
) {
Shape::Stmt
} else {
return Err(Reject::new(format!("not an expression: {tag:?}")));
};
Ok(sh)
}
fn str_shape(&self, id: NodeId) -> R<LitShape> {
let n = self.n(id);
Ok(match n.op {
b'r' => LitShape::RecordId,
0 | b's' if self.opts.legacy_strands => {
let mut s = String::new();
if !decode::unescape(decode::strip_delims(self.text(id)), &mut s) {
return Err(Reject::new("invalid escape"));
}
if let Literal::RecordId(_) = lit::legacy_strand(s) {
LitShape::RecordId
} else {
LitShape::Other
}
}
_ => LitShape::Other,
})
}
fn is_constant_call(&self, n: &Node) -> R<bool> {
let callee = self.n(n.a);
if callee.op != 0 || !CHECK_NAMES.with(|c| c.get()) {
return Ok(false);
}
let path = self.path_name(n.a)?;
Ok(matches!(lit::builtin(&path, callee.start, callee.end)?, lit::Builtin::Constant(_)))
}
fn first_part(&self, id: NodeId) -> R<FirstPart> {
let n = self.n(id);
let head = self.n(n.a);
let uncovered = head.depth & ast::COVERED == 0;
let listed = || match self.list(n.b).first() {
None => FirstPart::Empty,
Some(&p) => {
let tag = self.n(p).tag;
if tag == Tag::PartField {
FirstPart::Field
} else if tag == Tag::PartGraph {
FirstPart::Lookup {
out: self.n(p).op == 0,
}
} else {
FirstPart::Other
}
}
};
let res = if head.tag == Tag::Field && head.op == 1 {
listed()
} else if head.tag == Tag::Doc {
FirstPart::Doc
} else if (head.tag == Tag::Field || head.tag == Tag::Table) && uncovered {
FirstPart::Field
} else if head.tag == Tag::Idiom && uncovered {
let first = self.first_part(n.a)?;
if first == FirstPart::Empty {
listed()
} else {
first
}
} else {
FirstPart::Start(n.a)
};
Ok(res)
}
fn left_operand(&self, id: NodeId) -> Option<NodeId> {
let n = self.n(id);
if matches!(n.tag, Tag::Binary | Tag::BinaryX | Tag::PostfixRange | Tag::CallExpr) {
Some(n.a)
} else {
None
}
}
fn has_left_none_null(&self, mut id: NodeId) -> R<bool> {
loop {
let shape = self.shape(id)?;
if matches!(shape, Shape::Lit(LitShape::None | LitShape::Null)) {
return Ok(true);
} else if matches!(shape, Shape::Binary(_) | Shape::Postfix(_)) {
match self.left_operand(id) {
Some(left) => id = left,
None => return Ok(false),
}
} else if let Shape::Idiom(FirstPart::Start(head)) = shape {
id = head;
} else {
return Ok(false);
}
}
}
fn has_left_minus(&self, mut id: NodeId) -> R<bool> {
loop {
let shape = self.shape(id)?;
if let Shape::Prefix {
neg,
..
} = shape
{
return Ok(neg);
} else if let Shape::Lit(
LitShape::Int {
neg,
}
| LitShape::Float {
neg,
}
| LitShape::Decimal {
neg,
},
) = shape
{
return Ok(neg);
} else if let Shape::Idiom(FirstPart::Lookup {
out,
}) = shape
{
return Ok(out);
} else if matches!(shape, Shape::Binary(_) | Shape::Postfix(_)) {
match self.left_operand(id) {
Some(left) => id = left,
None => return Ok(false),
}
} else {
return Ok(false);
}
}
}
fn has_left_idiom(&self, mut id: NodeId) -> R<bool> {
loop {
let shape = self.shape(id)?;
if matches!(shape, Shape::Idiom(_)) {
return Ok(true);
} else if matches!(shape, Shape::Binary(_) | Shape::Postfix(_)) {
match self.left_operand(id) {
Some(left) => id = left,
None => return Ok(false),
}
} else {
return Ok(false);
}
}
}
fn is_param_equality(&self, id: NodeId) -> bool {
let n = self.n(id);
n.tag == Tag::Binary && n.op == Binary::Eq as u8 && self.n(n.a).tag == Tag::Param
}
fn render_covered(&self, id: NodeId, out: &mut String) -> R<()> {
if self.shape(id)?.covered() {
out.push('(');
self.render_expr(id, out)?;
out.push(')');
Ok(())
} else {
self.render_expr(id, out)
}
}
fn render_covered_list(&self, ids: &[NodeId], out: &mut String) -> R<()> {
for (i, &id) in ids.iter().enumerate() {
if i > 0 {
out.push_str(", ");
}
self.render_covered(id, out)?;
}
Ok(())
}
fn render_list(&self, ids: &[NodeId], out: &mut String) -> R<()> {
for (i, &id) in ids.iter().enumerate() {
if i > 0 {
out.push_str(", ");
}
self.render_expr(id, out)?;
}
Ok(())
}
fn render_operand(
&self,
op_bp: BindingPower,
neg: bool,
id: NodeId,
out: &mut String,
) -> R<()> {
let s = self.shape(id)?;
let bp = s.bp();
let paren = s.needs_parentheses()
|| bp < op_bp
|| bp == op_bp && op_bp == BindingPower::Range
|| neg && self.has_left_minus(id)?;
self.render_parenthesised(paren, id, out)
}
fn render_parenthesised(&self, paren: bool, id: NodeId, out: &mut String) -> R<()> {
if paren {
out.push('(');
}
self.render_expr(id, out)?;
if paren {
out.push(')');
}
Ok(())
}
fn render_binary(
&self,
op: &BinaryOperator,
left: NodeId,
right: NodeId,
out: &mut String,
) -> R<()> {
let op_bp = BindingPower::for_binary_operator(op);
let ls = self.shape(left)?;
let rs = self.shape(right)?;
let (lbp, rbp) = (ls.bp(), rs.bp());
let left_paren = ls.needs_parentheses()
|| lbp < op_bp
|| lbp == op_bp
&& matches!(
lbp,
BindingPower::Range
| BindingPower::Relation
| BindingPower::Equality
| BindingPower::Power
) || matches!(op, BinaryOperator::Matches(_))
&& lbp == BindingPower::Relation;
self.render_parenthesised(left_paren, left, out)?;
if matches!(
op,
BinaryOperator::Range
| BinaryOperator::RangeSkip
| BinaryOperator::RangeInclusive
| BinaryOperator::RangeSkipInclusive
) {
put(out, op);
} else {
out.push(' ');
put(out, op);
out.push(' ');
}
let right_paren =
rs.needs_parentheses()
|| rbp < op_bp
|| rbp == op_bp
&& matches!(
rbp,
BindingPower::Nullish
| BindingPower::Range | BindingPower::Relation
| BindingPower::Equality
| BindingPower::AddSub
| BindingPower::MulDiv
) || matches!(op, BinaryOperator::Matches(_)) && rbp == BindingPower::Relation;
self.render_parenthesised(right_paren, right, out)
}
fn render_str(&self, id: NodeId, out: &mut String) -> R<()> {
let n = self.n(id);
match n.op {
0 | b's' => {
let mut s = String::new();
if !decode::unescape(decode::strip_delims(self.text(id)), &mut s) {
return Err(Reject::new("invalid escape"));
}
if self.opts.legacy_strands {
put(out, &lit::legacy_strand(s));
} else {
put(out, &QuoteStr(&s));
}
}
b'f' => {
let mut s = String::new();
if !decode::unescape(decode::strip_delims(self.text(id)), &mut s) {
return Err(Reject::new("invalid escape"));
}
let f = lit::file(&s).map_err(|r| lit::in_token(r, self.text(id), n.start))?;
put(out, &Literal::File(f.into()));
}
_ => put(out, &self.prefixed(id)?),
}
Ok(())
}
fn render_object(&self, n: &Node, out: &mut String) -> R<()> {
out.push_str("{ ");
for (i, kv) in self.list(n.a).chunks(2).enumerate() {
if i > 0 {
out.push_str(", ");
}
put(out, &EscapeObjectKey(&self.name(kv[0])?));
out.push_str(": ");
self.render_covered(kv[1], out)?;
}
out.push_str(" }");
Ok(())
}
fn render_set(&self, items: &[NodeId], out: &mut String) -> R<()> {
out.push('{');
if items.is_empty() {
out.push(',');
}
for (i, &item) in items.iter().enumerate() {
if i > 0 {
out.push_str(", ");
self.render_covered(item, out)?;
} else if self.shape(item)? == Shape::Lit(LitShape::RecordId) {
out.push('(');
self.render_expr(item, out)?;
out.push(')');
} else {
self.render_covered(item, out)?;
}
}
if items.len() == 1 {
out.push(',');
}
out.push('}');
Ok(())
}
fn render_block(&self, stmts: &[NodeId], out: &mut String) -> R<()> {
match stmts.len() {
0 => out.push_str("{;}"),
_ => {
out.push_str("{ ");
for (i, &s) in stmts.iter().enumerate() {
if i > 0 {
out.push(' ');
}
let paren = (i == 0 && self.shape(s)? == Shape::Lit(LitShape::RecordId))
|| self.is_param_equality(s);
self.render_parenthesised(paren, s, out)?;
if stmts.len() > 1 {
out.push(';');
}
}
out.push_str(" }");
}
}
Ok(())
}
fn render_key(&self, id: NodeId, out: &mut String) -> R<()> {
let n = self.n(id);
if matches!(n.tag, Tag::Array | Tag::Object) {
self.render_expr(id, out)
} else if n.tag == Tag::KeyRange {
if n.a != NONE {
self.render_key(n.a, out)?;
if n.op & 1 != 0 {
out.push('>');
}
}
if n.b == NONE {
out.push_str("..");
} else {
out.push_str(if n.op & 2 != 0 {
"..="
} else {
".."
});
self.render_key(n.b, out)?;
}
Ok(())
} else if matches!(n.tag, Tag::KeyInt | Tag::KeyStr | Tag::KeyUuid | Tag::KeyGen) {
put(out, &self.key(id)?);
Ok(())
} else {
Err(Reject::new(format!("not a key: {:?}", n.tag)))
}
}
fn render_call(&self, n: &Node, out: &mut String) -> R<()> {
let callee = self.n(n.a);
if callee.op == 0 {
let path = self.path_name(n.a)?;
let name = if !CHECK_NAMES.with(|c| c.get()) {
path.to_lowercase()
} else {
match lit::builtin(&path, callee.start, callee.end)? {
lit::Builtin::Function(f) => f,
lit::Builtin::Constant(c) => {
out.push('(');
put(out, &c);
out.push_str(")(");
self.render_covered_list(self.list(n.b), out)?;
out.push(')');
return Ok(());
}
}
};
Self::render_receiver(&Function::Normal(name), out);
} else {
Self::render_receiver(&self.function_ref(n.a)?, out);
}
out.push('(');
self.render_covered_list(self.list(n.b), out)?;
out.push(')');
Ok(())
}
fn render_receiver(f: &Function, out: &mut String) {
match f {
Function::Normal(s) => {
for (i, seg) in s.split("::").enumerate() {
if i == 0 {
put(out, &EscapeIdent(seg));
} else {
out.push_str("::");
out.push_str(seg);
}
}
}
Function::Custom(s) => {
out.push_str("fn");
for seg in s.split("::") {
out.push_str("::");
put(out, &EscapeKwFreeIdent(seg));
}
}
Function::Model(m) => put(out, m),
Function::Module(m, sub, prefix) => {
out.push_str(prefix.as_str());
out.push_str("::");
put(out, &EscapeKwFreeIdent(m));
if let Some(sub) = sub {
for seg in sub.split("::") {
out.push_str("::");
put(out, &EscapeKwFreeIdent(seg));
}
}
}
Function::Silo {
org,
pkg,
major,
minor,
patch,
sub,
} => {
out.push_str("silo::");
put(out, &EscapeKwFreeIdent(org));
out.push_str("::");
put(out, &EscapeKwFreeIdent(pkg));
out.push_str(&format!("<{major}.{minor}.{patch}>"));
if let Some(sub) = sub {
for seg in sub.split("::") {
out.push_str("::");
put(out, &EscapeKwFreeIdent(seg));
}
}
}
Function::Script(_) => {}
}
}
fn render_closure(&self, n: &Node, out: &mut String) -> R<()> {
let r = slots(self.ast, n.a, 3);
out.push('|');
for (i, pk) in self.list(r[0]).chunks(2).enumerate() {
if i > 0 {
out.push_str(", ");
}
out.push('$');
put(out, &EscapeKwFreeIdent(&self.param_name(pk[0])?));
out.push_str(": ");
if pk[1] == NONE {
out.push_str("any");
} else {
let kind = self.kind(pk[1])?;
if matches!(kind, crate::expr::Kind::Either(_)) {
out.push('<');
put(out, &kind);
out.push('>');
} else {
put(out, &kind);
}
}
}
out.push('|');
if r[1] != NONE {
out.push_str(" -> ");
put(out, &self.kind(r[1])?);
}
if self.has_left_idiom(r[2])? {
out.push_str(" (");
self.render_expr(r[2], out)?;
out.push(')');
} else {
out.push(' ');
self.render_covered(r[2], out)?;
}
Ok(())
}
fn render_mock(&self, n: &Node, out: &mut String) -> R<()> {
let r = slots(self.ast, n.b, 3);
let int = |id: u32| Ast::int(self.n(id));
out.push('|');
put(out, &EscapeKwFreeIdent(&self.name(n.a)?));
out.push(':');
if r[2] & 1 == 0 {
out.push_str(&int(r[0]).to_string());
} else {
if r[0] != NONE {
out.push_str(&int(r[0]).to_string());
out.push_str(if r[2] & 2 != 0 {
">.."
} else {
".."
});
} else {
out.push_str("..");
}
if r[1] != NONE {
if r[2] & 4 != 0 {
out.push('=');
}
out.push_str(&int(r[1]).to_string());
}
}
out.push('|');
Ok(())
}
fn idiom_parts(&self, id: NodeId) -> R<Vec<PartRef>> {
let mut parts = Vec::new();
self.collect_parts(id, &mut parts)?;
Ok(parts)
}
fn collect_parts(&self, id: NodeId, parts: &mut Vec<PartRef>) -> R<()> {
let n = self.n(id);
if n.tag == Tag::Field {
if n.op != 1 {
parts.push(PartRef::Name(id));
}
return Ok(());
} else if n.tag == Tag::Idiom {
} else {
return Err(Reject::new(format!("not an idiom: {:?}", n.tag)));
}
let head = self.n(n.a);
let uncovered = head.depth & ast::COVERED == 0;
if head.tag == Tag::Field && head.op == 1 {
} else if head.tag == Tag::Doc {
parts.push(PartRef::Doc);
} else if (head.tag == Tag::Field || head.tag == Tag::Table) && uncovered {
parts.push(PartRef::Name(n.a));
} else if head.tag == Tag::Idiom && uncovered {
self.collect_parts(n.a, parts)?;
} else {
parts.push(PartRef::Start(n.a));
}
parts.extend(self.list(n.b).iter().map(|&p| PartRef::Listed(p)));
Ok(())
}
fn render_part_ref(&self, part: PartRef, first: bool, out: &mut String) -> R<()> {
match part {
PartRef::Doc => out.push('@'),
PartRef::Name(id) => self.render_field_part(id, first, out)?,
PartRef::Start(id) => {
if first {
self.render_start(id, out)?;
} else {
self.render_expr(id, out)?;
}
}
PartRef::Listed(id) => self.render_listed_part(id, first, out)?,
}
Ok(())
}
fn render_field_part(&self, id: NodeId, first: bool, out: &mut String) -> R<()> {
let name = self.name(id)?;
if first {
put(out, &EscapeIdent(&name));
} else {
out.push('.');
put(out, &EscapeKwFreeIdent(&name));
}
Ok(())
}
fn render_start(&self, id: NodeId, out: &mut String) -> R<()> {
let s = self.shape(id)?;
let paren = s.needs_parentheses()
|| matches!(
s,
Shape::Binary(_) | Shape::Prefix { .. } | Shape::Postfix(_) | Shape::Idiom(_)
) || matches!(
s,
Shape::Lit(
LitShape::Decimal {
neg: true
} | LitShape::Int {
neg: true
} | LitShape::Float {
neg: true
}
)
);
self.render_parenthesised(paren, id, out)
}
fn render_listed_part(&self, id: NodeId, first: bool, out: &mut String) -> R<()> {
let pn = self.n(id);
if pn.tag == Tag::PartField {
self.render_field_part(id, first, out)?;
} else if pn.tag == Tag::PartAll {
out.push_str(".*");
} else if pn.tag == Tag::PartLast {
out.push_str("[$]");
} else if pn.tag == Tag::PartFlatten {
out.push('…');
} else if pn.tag == Tag::PartOptional {
out.push_str(".?");
} else if pn.tag == Tag::PartIndex {
out.push('[');
self.render_expr(pn.a, out)?;
out.push(']');
} else if pn.tag == Tag::PartWhere {
out.push_str("[WHERE ");
self.render_expr(pn.a, out)?;
out.push(']');
} else if pn.tag == Tag::PartMethod {
out.push('.');
put(out, &EscapeKwFreeIdent(&self.name(pn.a)?));
out.push('(');
self.render_covered_list(self.list(pn.b), out)?;
out.push(')');
} else if pn.tag == Tag::PartGraph {
self.render_lookup(pn, out)?;
} else if pn.tag == Tag::PartRepeat {
out.push_str(".@");
} else if pn.tag == Tag::PartRecurse {
self.render_recurse(pn, out)?;
} else if pn.tag == Tag::PartDestructure {
self.render_destructure(pn, out)?;
} else {
return Err(Reject::new(format!("not a part: {:?}", pn.tag)));
}
Ok(())
}
fn render_recurse(&self, pn: &Node, out: &mut String) -> R<()> {
let r = slots(self.ast, pn.a, 7);
let num = |id: u32| -> R<Option<u32>> {
if id == NONE {
return Ok(None);
}
u32::try_from(Ast::int(self.n(id))).map(Some).map_err(|_| Reject::new("u32"))
};
out.push_str(".{");
let (min, max) = (num(r[1])?, num(r[2])?);
if r[0] == 0 {
out.push_str(&min.ok_or(Reject::new("fixed recursion has a count"))?.to_string());
} else {
if let Some(min) = min {
out.push_str(&min.to_string());
}
out.push_str("..");
if let Some(max) = max {
out.push_str(&max.to_string());
}
}
let inclusive = r[5] == 1;
match r[3] {
0 => {}
1 => out.push_str("+path"),
2 => out.push_str("+collect"),
_ => {
out.push_str("+shortest=");
self.render_expr(r[4], out)?;
}
}
if r[3] != 0 && inclusive {
out.push_str("+inclusive");
}
out.push('}');
if r[6] != NONE {
out.push('(');
for part in self.idiom_parts(r[6])? {
self.render_part_ref(part, false, out)?;
}
out.push(')');
}
Ok(())
}
fn render_destructure(&self, n: &Node, out: &mut String) -> R<()> {
out.push_str(".{ ");
for (i, &e) in self.list(n.a).iter().enumerate() {
if i > 0 {
out.push_str(", ");
}
let en = self.n(e);
if en.op == 4 {
out.push_str("...");
continue;
}
put(out, &EscapeKwFreeIdent(&self.name(en.a)?));
match en.op {
0 => {}
1 => {
out.push_str(": ");
let tag = self.n(en.b).tag;
if tag == Tag::Idiom {
self.render_idiom(en.b, out)?;
} else if tag == Tag::Field {
put(out, &EscapeIdent(self.name(en.b)?));
} else {
self.render_start(en.b, out)?;
}
}
2 => out.push_str(".*"),
_ => self.render_destructure(self.n(en.b), out)?,
}
}
out.push_str(" }");
Ok(())
}
fn render_lookup(&self, pn: &Node, out: &mut String) -> R<()> {
use ast::select as s;
let rec = slots(self.ast, pn.a, s::LEN);
let flags = rec[s::FLAGS];
let has_expr = flags & 128 != 0;
let subjects = self.list(rec[s::WHAT]);
out.push_str(match pn.op {
0 => "->",
1 => "<-",
2 => "<->",
_ => "<~",
});
let plain = |&sj: &NodeId| {
let x = slots(self.ast, self.n(sj).b, 2);
x[1] == NONE && (x[0] == NONE || self.n(x[0]).b != NONE)
};
if subjects.len() <= 1
&& subjects.iter().all(plain)
&& rec[s::COND] == NONE
&& rec[s::FETCH] == NONE
&& !has_expr
{
match subjects.first() {
None => out.push('?'),
Some(&sj) => self.render_subject(sj, out)?,
}
return Ok(());
}
out.push('(');
if has_expr {
out.push_str("SELECT ");
self.render_projection(rec, out)?;
out.push_str(" FROM ");
if flags & 1 != 0 {
out.push_str("ONLY ");
}
}
if subjects.is_empty() {
out.push('?');
}
for (i, &sj) in subjects.iter().enumerate() {
if i > 0 {
out.push_str(", ");
}
self.render_subject(sj, out)?;
}
if rec[s::COND] != NONE {
out.push_str(" WHERE ");
self.render_covered(rec[s::COND], out)?;
}
if has_expr {
self.render_split_group(rec, out)?;
}
self.render_order_limit_start(rec, out)?;
if rec[s::FETCH] != NONE {
out.push_str(" AS ");
self.render_idiom(rec[s::FETCH], out)?;
}
out.push(')');
Ok(())
}
fn render_subject(&self, id: NodeId, out: &mut String) -> R<()> {
let sn = self.n(id);
let x = slots(self.ast, sn.b, 2);
put(out, &EscapeKwFreeIdent(&self.name(sn.a)?));
if x[0] != NONE {
if self.n(x[0]).tag != Tag::KeyRange {
return Err(Reject::new("not a range"));
}
out.push(':');
self.render_key(x[0], out)?;
}
if x[1] != NONE {
out.push_str(" FIELD ");
put(out, &EscapeKwFreeIdent(&self.name(x[1])?));
}
Ok(())
}
fn render_projection(&self, rec: &[u32], out: &mut String) -> R<()> {
use ast::select as s;
if rec[s::VALUE] != NONE {
out.push_str("VALUE ");
return self.render_selector(rec[s::VALUE], out);
}
for (i, &f) in self.list(rec[s::FIELDS]).iter().enumerate() {
if i > 0 {
out.push_str(", ");
}
self.render_field(f, out)?;
}
Ok(())
}
fn render_field(&self, id: NodeId, out: &mut String) -> R<()> {
if self.n(id).tag == Tag::FieldAll {
out.push('*');
Ok(())
} else {
self.render_selector(id, out)
}
}
fn render_selector(&self, id: NodeId, out: &mut String) -> R<()> {
let n = self.n(id);
self.render_covered(n.a, out)?;
if n.b != NONE {
out.push_str(" AS ");
self.render_idiom(n.b, out)?;
}
Ok(())
}
fn render_idiom_list(&self, ids: &[NodeId], out: &mut String) -> R<()> {
for (i, &id) in ids.iter().enumerate() {
if i > 0 {
out.push_str(", ");
}
self.render_idiom(id, out)?;
}
Ok(())
}
fn render_split_group(&self, rec: &[u32], out: &mut String) -> R<()> {
use ast::select as s;
if rec[s::SPLIT] != NONE {
out.push_str(" SPLIT ON ");
self.render_idiom_list(self.list(rec[s::SPLIT]), out)?;
}
if rec[s::FLAGS] & 2 != 0 {
out.push_str(" GROUP ALL");
} else if rec[s::GROUP] != NONE {
out.push_str(" GROUP BY ");
self.render_idiom_list(self.list(rec[s::GROUP]), out)?;
}
Ok(())
}
fn render_order_limit_start(&self, rec: &[u32], out: &mut String) -> R<()> {
use ast::select as s;
if rec[s::ORDER] != NONE {
let items = self.list(rec[s::ORDER]);
if items.len() == 1 && self.n(items[0]).tag == Tag::OrderRand {
out.push_str(" ORDER BY RAND()");
} else {
out.push_str(" ORDER BY ");
for (i, &o) in items.iter().enumerate() {
if i > 0 {
out.push_str(", ");
}
let on = self.n(o);
self.render_idiom(on.a, out)?;
if on.op & 2 != 0 {
out.push_str(" COLLATE");
}
if on.op & 4 != 0 {
out.push_str(" NUMERIC");
}
if on.op & 1 != 0 {
out.push_str(" DESC");
}
}
}
}
if rec[s::LIMIT] != NONE {
out.push_str(" LIMIT ");
self.render_covered(rec[s::LIMIT], out)?;
}
if rec[s::START] != NONE {
out.push_str(" START ");
self.render_covered(rec[s::START], out)?;
}
Ok(())
}
fn render_with(&self, id: NodeId, out: &mut String) -> R<()> {
if let Some(with) = self.with(id)? {
out.push(' ');
put(out, &with);
}
Ok(())
}
fn render_opt_clause(&self, keyword: &str, id: NodeId, out: &mut String) -> R<()> {
if id != NONE && self.n(id).tag != Tag::None {
out.push(' ');
out.push_str(keyword);
out.push(' ');
self.render_covered(id, out)?;
}
Ok(())
}
fn render_select(&self, n: &Node, out: &mut String) -> R<()> {
use ast::select as s;
let rec = slots(self.ast, n.a, s::LEN);
let flags = rec[s::FLAGS];
out.push_str("SELECT ");
self.render_projection(rec, out)?;
let omit = self.list(rec[s::OMIT]);
if !omit.is_empty() {
out.push_str(" OMIT ");
self.render_covered_list(omit, out)?;
}
out.push_str(" FROM");
if flags & 1 != 0 {
out.push_str(" ONLY");
}
out.push(' ');
self.render_covered_list(self.list(rec[s::WHAT]), out)?;
self.render_with(rec[s::WITH], out)?;
if rec[s::COND] != NONE {
out.push_str(" WHERE ");
self.render_covered(rec[s::COND], out)?;
}
self.render_split_group(rec, out)?;
self.render_order_limit_start(rec, out)?;
if rec[s::FETCH] != NONE {
out.push_str(" FETCH ");
self.render_list(self.list(rec[s::FETCH]), out)?;
}
self.render_opt_clause("VERSION", rec[s::VERSION], out)?;
self.render_opt_clause("TIMEOUT", rec[s::TIMEOUT], out)?;
if flags & 64 != 0 {
out.push_str(" FOR UPDATE");
}
if flags & 8 != 0 {
out.push_str(" TEMPFILES");
}
self.render_explain(flags, out);
Ok(())
}
fn render_explain(&self, flags: u32, out: &mut String) {
if flags & 16 != 0 {
out.push_str(" EXPLAIN");
if flags & 32 != 0 {
out.push_str(" FULL");
}
}
}
fn render_data(&self, rec: &[u32], out: &mut String) -> R<()> {
use ast::write as w;
let payload = rec[w::DATA];
let word = match rec[w::DATA_KIND] {
0 => return Ok(()),
1 => {
out.push_str(" SET ");
return self.render_assigns(payload, out);
}
2 => {
out.push_str(" UNSET ");
return self.render_idiom_list(self.list(payload), out);
}
3 => " CONTENT ",
4 => " MERGE ",
5 => " PATCH ",
_ => " REPLACE ",
};
out.push_str(word);
self.render_expr(payload, out)
}
fn render_assigns(&self, list: u32, out: &mut String) -> R<()> {
for (i, &a) in self.list(list).iter().enumerate() {
if i > 0 {
out.push_str(", ");
}
let an = self.n(a);
self.render_idiom(an.a, out)?;
out.push_str(match an.op {
0 => " = ",
1 => " += ",
2 => " -= ",
_ => " +?= ",
});
self.render_covered(an.b, out)?;
}
Ok(())
}
fn render_output(&self, rec: &[u32], out: &mut String) -> R<()> {
use ast::write as w;
let word = match rec[w::OUTPUT_KIND] {
0 => return Ok(()),
1 => " RETURN NONE",
2 => " RETURN NULL",
3 => " RETURN DIFF",
4 => " RETURN AFTER",
5 => " RETURN BEFORE",
7 => {
out.push_str(" RETURN VALUE ");
return self.render_selector(rec[w::OUTPUT], out);
}
_ => {
out.push_str(" RETURN ");
let fields = self.list(rec[w::OUTPUT]);
for (i, &f) in fields.iter().enumerate() {
if i > 0 {
out.push_str(", ");
self.render_field(f, out)?;
continue;
}
let fnode = self.n(f);
if fnode.tag == Tag::FieldAll {
out.push('*');
continue;
}
if self.has_left_none_null(fnode.a)? {
out.push('(');
self.render_expr(fnode.a, out)?;
out.push(')');
} else {
self.render_covered(fnode.a, out)?;
}
if fnode.b != NONE {
out.push_str(" AS ");
self.render_idiom(fnode.b, out)?;
}
}
return Ok(());
}
};
out.push_str(word);
Ok(())
}
fn render_create(&self, n: &Node, out: &mut String) -> R<()> {
use ast::write as w;
let rec = slots(self.ast, n.a, w::LEN);
out.push_str("CREATE");
if rec[w::FLAGS] & 1 != 0 {
out.push_str(" ONLY");
}
out.push(' ');
self.render_covered_list(self.list(rec[w::WHAT]), out)?;
self.render_data(rec, out)?;
self.render_output(rec, out)?;
self.render_opt_clause("TIMEOUT", rec[w::TIMEOUT], out)
}
fn render_update(&self, n: &Node, keyword: &str, with_data: bool, out: &mut String) -> R<()> {
use ast::write as w;
let rec = slots(self.ast, n.a, w::LEN);
out.push_str(keyword);
if rec[w::FLAGS] & 1 != 0 {
out.push_str(" ONLY");
}
out.push(' ');
self.render_covered_list(self.list(rec[w::WHAT]), out)?;
self.render_with(rec[w::WITH], out)?;
if with_data {
self.render_data(rec, out)?;
}
if rec[w::COND] != NONE {
out.push_str(" WHERE ");
self.render_covered(rec[w::COND], out)?;
}
self.render_output(rec, out)?;
self.render_opt_clause("TIMEOUT", rec[w::TIMEOUT], out)?;
self.render_explain(rec[w::FLAGS], out);
Ok(())
}
fn is_bare_endpoint(&self, id: NodeId) -> R<bool> {
let n = self.n(id);
let res = if matches!(n.tag, Tag::Array | Tag::Param) {
true
} else if n.tag == Tag::RecordId {
self.n(n.b).tag != Tag::KeyRange
} else if n.tag == Tag::Str {
matches!(
self.expr(id)?,
crate::expr::Expr::Literal(Literal::RecordId(r))
if !matches!(r.key, crate::expr::RecordIdKeyLit::Range(_))
)
} else {
false
};
Ok(res)
}
fn render_relate(&self, n: &Node, out: &mut String) -> R<()> {
use ast::{relate as r, write as w};
let rec = slots(self.ast, n.a, r::LEN);
out.push_str("RELATE");
if rec[w::FLAGS] & 1 != 0 {
out.push_str(" ONLY");
}
if rec[w::FLAGS] & 4 != 0 {
out.push_str(" OR UPDATE");
}
out.push(' ');
let from = rec[r::FROM];
self.render_parenthesised(!self.is_bare_endpoint(from)?, from, out)?;
out.push_str(" -> ");
let through = rec[r::THROUGH];
let bare = matches!(self.n(through).tag, Tag::Param | Tag::Table);
self.render_parenthesised(!bare, through, out)?;
out.push_str(" -> ");
let to = rec[r::TO];
self.render_parenthesised(!self.is_bare_endpoint(to)?, to, out)?;
self.render_data(rec, out)?;
self.render_output(rec, out)?;
self.render_opt_clause("TIMEOUT", rec[w::TIMEOUT], out)
}
fn render_insert(&self, n: &Node, out: &mut String) -> R<()> {
use ast::{insert as i, write as w};
let rec = slots(self.ast, n.a, i::LEN);
out.push_str("INSERT");
if rec[w::FLAGS] & 2 != 0 {
out.push_str(" RELATION");
}
if rec[w::FLAGS] & 4 != 0 {
out.push_str(" IGNORE");
}
if rec[i::INTO] != NONE {
out.push_str(" INTO ");
self.render_covered(rec[i::INTO], out)?;
}
out.push(' ');
if rec[w::DATA_KIND] == 1 {
let v = slots(self.ast, rec[w::DATA], 2);
let rows = self.list(v[1]);
out.push('(');
if !rows.is_empty() {
self.render_idiom_list(self.list(v[0]), out)?;
}
out.push_str(") VALUES ");
for (i, &row) in rows.iter().enumerate() {
if i > 0 {
out.push_str(", ");
}
out.push('(');
self.render_covered_list(self.list(row), out)?;
out.push(')');
}
} else {
self.render_covered(rec[w::DATA], out)?;
}
if rec[i::UPDATE] != NONE {
out.push_str(" ON DUPLICATE KEY UPDATE ");
self.render_assigns(rec[i::UPDATE], out)?;
}
self.render_output(rec, out)?;
self.render_opt_clause("TIMEOUT", rec[w::TIMEOUT], out)
}
fn if_is_bracketed(&self, n: &Node) -> bool {
self.list(n.a).chunks(2).all(|cb| cb.get(1).is_some_and(|&b| self.n(b).tag == Tag::Block))
&& (n.b == NONE || self.n(n.b).tag == Tag::Block)
}
fn render_if(&self, n: &Node, out: &mut String) -> R<()> {
let branches = self.list(n.a);
if self.if_is_bracketed(n) {
for (i, cb) in branches.chunks(2).enumerate() {
if i > 0 {
out.push_str(" ELSE ");
}
out.push_str("IF ");
self.render_covered(cb[0], out)?;
out.push(' ');
self.render_if_block(cb[1], out)?;
}
if n.b != NONE {
out.push_str(" ELSE ");
self.render_if_block(n.b, out)?;
}
return Ok(());
}
for (i, cb) in branches.chunks(2).enumerate() {
if i > 0 {
out.push_str(" ELSE ");
}
out.push_str("IF ");
self.render_covered(cb[0], out)?;
out.push_str(" THEN ");
let then = self.n(cb[1]);
let nested = then.tag == Tag::If && self.if_is_bracketed(then);
self.render_parenthesised(nested, cb[1], out)?;
}
if n.b != NONE {
out.push_str(" ELSE ");
self.render_covered(n.b, out)?;
}
out.push_str(" END");
Ok(())
}
fn render_if_block(&self, id: NodeId, out: &mut String) -> R<()> {
let stmts = self.list(self.n(id).a);
match stmts.len() {
0 => out.push_str("{;}"),
1 => {
out.push_str("{ ");
self.render_expr(stmts[0], out)?;
out.push_str(" }");
}
_ => {
let mut simple = true;
for &s in stmts {
simple &=
matches!(self.shape(s)?, Shape::Lit(_) | Shape::Param | Shape::Idiom(_));
}
out.push_str("{\n");
for (i, &s) in stmts.iter().enumerate() {
if i > 0 {
out.push('\n');
}
if simple {
out.push('\t');
}
self.render_expr(s, out)?;
out.push(';');
}
out.push_str("\n}");
}
}
Ok(())
}
fn render_info(&self, n: &Node, out: &mut String) -> R<()> {
use ast::{InfoTarget as I, info};
let rec = slots(self.ast, n.a, info::LEN);
let structure = rec[info::FLAGS] & 1 != 0;
let version = |out: &mut String| -> R<()> {
if rec[info::VERSION] != NONE {
out.push_str(" VERSION ");
self.render_covered(rec[info::VERSION], out)?;
}
Ok(())
};
match n.op {
x if x == I::Root as u8 => out.push_str("INFO FOR ROOT"),
x if x == I::Ns as u8 => out.push_str("INFO FOR NAMESPACE"),
x if x == I::Db as u8 => out.push_str("INFO FOR DATABASE"),
x if x == I::Table as u8 => {
out.push_str("INFO FOR TABLE ");
self.render_covered(rec[info::WHAT], out)?;
}
x if x == I::User as u8 => {
out.push_str("INFO FOR USER ");
self.render_covered(rec[info::WHAT], out)?;
let base = rec[info::FLAGS] >> 1;
if base != 0 {
out.push_str(" ON ");
put(out, &Self::base(base));
}
}
_ => {
out.push_str("INFO FOR INDEX ");
self.render_covered(rec[info::WHAT], out)?;
out.push_str(" ON ");
self.render_covered(rec[info::TABLE], out)?;
}
}
if n.op <= I::Table as u8 {
version(out)?;
}
if structure {
out.push_str(" STRUCTURE");
}
Ok(())
}
}
#[cfg(test)]
mod tests {
use surrealdb_parser_next::{Limits, Scratch, parse_script};
use super::*;
use crate::parser::Options;
const EXPR_TAGS: &[Tag] = &[
Tag::Array,
Tag::Object,
Tag::Prefix,
Tag::Cast,
Tag::Binary,
Tag::Block,
Tag::Set,
Tag::None,
Tag::Null,
Tag::True,
Tag::False,
Tag::Int,
Tag::Float,
Tag::NaN,
Tag::Infinity,
Tag::UnboundedRange,
Tag::Decimal,
Tag::Regex,
Tag::Path,
Tag::Duration,
Tag::Str,
Tag::Param,
Tag::Field,
Tag::Table,
Tag::RecordId,
Tag::BinaryX,
Tag::PostfixRange,
Tag::Call,
Tag::Script,
Tag::Point,
Tag::CallExpr,
Tag::Idiom,
Tag::Select,
Tag::Create,
Tag::Update,
Tag::Upsert,
Tag::Delete,
Tag::Return,
Tag::Let,
Tag::If,
Tag::For,
Tag::Relate,
Tag::Insert,
Tag::Explain,
Tag::Alter,
Tag::Remove,
Tag::Define,
Tag::Closure,
Tag::Mock,
Tag::Sleep,
Tag::Throw,
Tag::Break,
Tag::Continue,
Tag::Info,
Tag::Rebuild,
];
fn mask(sql: &str) -> String {
let mut out = String::new();
let mut rest = sql;
while let Some(i) = rest.find(['\'', '"']) {
let quote = rest.as_bytes()[i];
let after = &rest[i + 1..];
let key = after.len() > 128
&& after.as_bytes()[128] == quote
&& after.as_bytes()[..128].iter().all(|b| b.is_ascii_alphanumeric());
out.push_str(&rest[..=i]);
if key {
out.push_str("[KEY]");
out.push(quote as char);
rest = &after[129..];
} else {
rest = after;
}
}
out.push_str(rest);
out
}
fn rendered(f: impl FnOnce(&mut String) -> R<()>) -> Result<String, String> {
let mut out = String::new();
f(&mut out).map(|()| out).map_err(|e| e.msg.to_string())
}
fn check(src: &str) -> Result<(), String> {
let mut ast = Ast::new();
let mut scratch = Scratch::default();
parse_script(src, Limits::default(), &mut ast, &mut scratch);
if !scratch.diags.is_empty() || ast.stmts.is_empty() {
return Err(format!("fixture does not parse: {src}"));
}
let sets = [
Options::ALL,
Options {
legacy_strands: true,
..Options::ALL
},
Options {
surrealism: false,
legacy_strands: false,
},
];
let views: Vec<NodeId> = ast
.nodes
.iter()
.filter(|n| n.tag == Tag::Clause && n.op == ast::Cl::View as u8)
.map(|n| n.a)
.collect();
for (set, opts) in sets.into_iter().enumerate() {
let lower = Lower {
ast: &ast,
src,
opts,
};
let mut compared = 0;
let mut failures = Vec::new();
let mut same = |what: &str, id: NodeId, want: String, got: Result<String, String>| {
compared += 1;
if let Ok(ref got) = got
&& mask(got) == mask(&want)
{
} else {
failures.push(format!(
"{what} differs under option set {set}\n fixture: {src}\n node: {:?} {}\n want: {want}\n got: {got:?}",
ast.node(id).tag,
lower.text(id)
));
}
};
for &s in &ast.stmts {
if let Ok(top) = lower.top(s) {
same("statement", s, top.to_sql(), rendered(|o| lower.render_top(s, o)));
}
}
for id in 0..ast.nodes.len() as NodeId {
let tag = ast.node(id).tag;
if matches!(tag, Tag::Field | Tag::Idiom)
&& let Ok(idiom) = lower.idiom(id)
{
same("idiom", id, idiom.to_sql(), rendered(|o| lower.render_idiom(id, o)));
for (i, part) in idiom.0.iter().enumerate() {
same("part", id, part.to_sql(), rendered(|o| lower.render_part(id, i, o)));
}
}
if EXPR_TAGS.contains(&tag)
&& !views.contains(&id)
&& let Ok(expr) = lower.expr(id)
{
same("expression", id, expr.to_sql(), rendered(|o| lower.render_expr(id, o)));
}
}
if set == 0 && compared == 0 {
return Err(format!("fixture compared nothing: {src}"));
}
if let Some(first) = failures.into_iter().next() {
return Err(first);
}
}
Ok(())
}
#[test]
fn fixtures_render_as_lowered() {
let failures: Vec<String> = FIXTURES.iter().filter_map(|src| check(src).err()).collect();
assert!(
failures.is_empty(),
"{} fixtures failed:\n{}",
failures.len(),
failures.join("\n")
);
}
#[test]
fn fixtures_cover_every_tag() {
const TOP_ONLY: &[Tag] = &[
Tag::Begin,
Tag::Cancel,
Tag::Commit,
Tag::Use,
Tag::OptionStmt,
Tag::Kill,
Tag::Live,
Tag::Show,
Tag::AccessStmt,
];
let mut counts = std::collections::BTreeMap::<String, usize>::new();
let mut ast = Ast::new();
let mut scratch = Scratch::default();
for src in FIXTURES {
parse_script(src, Limits::default(), &mut ast, &mut scratch);
let lower = Lower::new(&ast, src);
for &s in &ast.stmts {
if TOP_ONLY.contains(&ast.node(s).tag) && lower.top(s).is_ok() {
*counts.entry(format!("{:?}", ast.node(s).tag)).or_default() += 1;
}
}
let views: Vec<NodeId> = ast
.nodes
.iter()
.filter(|n| n.tag == Tag::Clause && n.op == ast::Cl::View as u8)
.map(|n| n.a)
.collect();
for id in 0..ast.nodes.len() as NodeId {
let tag = ast.node(id).tag;
if EXPR_TAGS.contains(&tag) && !views.contains(&id) && lower.expr(id).is_ok() {
*counts.entry(format!("{tag:?}")).or_default() += 1;
}
}
}
let thin: Vec<String> = EXPR_TAGS
.iter()
.chain(TOP_ONLY)
.map(|tag| (tag, counts.get(&format!("{tag:?}")).copied().unwrap_or(0)))
.filter(|&(_, n)| n < 3)
.map(|(tag, n)| format!("{tag:?} has {n}"))
.collect();
assert!(thin.is_empty(), "fewer than 3 fixture nodes: {}", thin.join(", "));
}
const FIXTURES: &[&str] = &[
"NONE",
"NULL",
"true",
"false",
"[false, true, false]",
"!false",
"1",
"-1",
"- 1",
"1.5f",
"-1.5f",
"1.5",
"-0.0f",
"NaN",
"[NaN, NaN]",
"Infinity",
"-Infinity",
"..",
"1.5dec",
"-2.50dec",
"1e3dec",
"-2e-3dec",
"1_000dec",
"9223372036854775807",
"-9223372036854775808",
r#"/a\/b/"#,
"math::pi",
"math::PI",
"time::epoch",
"90s",
"1y2w3d",
"1h30m",
"1ms",
"1ns",
r#"'a'"#,
r#""a""#,
r#"'it\'s'"#,
r#""quo\"te""#,
r#"'a"b'"#,
r#"'tab\t nl\n nul\0 bs\b'"#,
"s'x'",
"d'2020-01-01T00:00:00Z'",
r#"d"2020-01-01T01:00:00+01:00""#,
"d'2020-01-01T00:00:00.123456789Z'",
"u'018a6180-0000-7000-8000-000000000000'",
"b'ff00ab'",
"b''",
"r'person:tobie'",
"r'person:[1, 2]'",
"r'person:1..5'",
"f'bucket:/some/key'",
"$a",
"$select",
"$`a b`",
"a",
"`select`",
"`value`",
"`a b`",
"⟨a b⟩",
r#"`a\`b`"#,
"(1, 2)",
"(1.5, -2.5)",
"(NaN, Infinity)",
"(1, -0.0)",
r#"{ 'a"b': 1 }"#,
r#"{ "a'b": 1 }"#,
"{ a: 1, b: 2 }",
r#"{ 'a\nb': 1, '': 2, '0a': 3, 'NaN': 4, 'Infinity': 5, `select`: 6 }"#,
"/^[a-z]+$/",
"[/a/, /b\\/c/]",
"{ `x y`: 1 }",
r#"a.`select`"#,
r#"a.`b c`"#,
r#"`value`:1"#,
r#"`a b`:`c d`"#,
r#"person:`1a`"#,
r#"person:⟨a b⟩"#,
r#"$`\``"#,
"person:1",
"person:tobie",
"person:u'018a6180-0000-7000-8000-000000000000'",
"person:rand()",
"person:ulid()",
"person:uuid()",
"person:[1, 2]",
"person:[]",
"person:{ a: 1 }",
"person:{}",
"person:[1, [2, (SELECT * FROM x)]]",
"person:1..5",
"person:1>..5",
"person:1..=5",
"person:1>..=5",
"person:..5",
"person:..=5",
"person:1..",
"person:1>..",
"person:..",
"person:[1]..[2]",
"person:{ a: 1 }..{ a: 2 }",
"person:-9223372036854775809",
"person:123abc",
"person:1_0",
"[]",
"[1, 2, 3]",
"[(SELECT * FROM x), (RETURN 1 FETCH a), (IF a { b })]",
"[[1], { a: [2] }]",
"{ a: (SELECT * FROM x), b: (RETURN 1 FETCH a), c: (LET $a = 1) }",
"{,}",
"{1,}",
"{1, 2}",
"{a:1,}",
"{(a:1), b:2}",
"{ (SELECT * FROM x), 2 }",
"{ 1, (SELECT * FROM y) }",
"{{ a: 1 },}",
"!a",
"-a",
"+a",
"..a",
"..=a",
"!!a",
"- -a",
"-(-a)",
"-(-1)",
"- -1",
"+(-1)",
"-(+1)",
"!(a && b)",
"!a && b",
"-(1 + 2)",
"-a + b",
"-(a + b)",
"..(1..2)",
"..(..2)",
"..=(1..2)",
"-(1..2)",
"-(..)",
"-(a:1)",
"!(a:1)",
"-(1..)",
"..(1..)",
"-(math::pi(1))",
"-(->a)",
"-(<-a)",
"-(<->a)",
"-(->a + 1)",
"-(->a.b)",
"-(<-a + 1)",
"-(-1 + 2)",
"-(-1.5 + 2)",
"-(-1.5dec + 2)",
"-(-a + 2)",
"-(a - -1)",
"-(a..)",
"<int> a",
"<int> -1",
"<int> (a + b)",
"<int> a + b",
"<array<int>> [1]",
"<array<int, 3>> [1]",
"<set<string>> {1,}",
"<option<int>> 1",
"<int | string> 1",
"<record<a | b>> a:1",
"<geometry<point>> (1, 2)",
"<int><float> 1",
"<int> (SELECT * FROM x)",
"<{ a: int }> { a: 1 }",
"<[int, string]> [1, 'a']",
"<'a' | 1 | true> 'a'",
"<function> a",
"<file<b>> a",
"a + b",
"a - b",
"a * b",
"a / b",
"a % b",
"a ** b",
"a = b",
"a == b",
"a != b",
"a *= b",
"a ?= b",
"a || b",
"a OR b",
"a && b",
"a AND b",
"a ?? b",
"a ?: b",
"a < b",
"a <= b",
"a > b",
"a >= b",
"a ∋ b",
"a ∌ b",
"a ⊇ b",
"a ⊃ b",
"a ⊅ b",
"a ∈ b",
"a ∉ b",
"a ⊆ b",
"a ⊂ b",
"a ⊄ b",
"a CONTAINS b",
"a CONTAINSNOT b",
"a CONTAINSALL b",
"a CONTAINSANY b",
"a CONTAINSNONE b",
"a INSIDE b",
"a NOTINSIDE b",
"a ALLINSIDE b",
"a ANYINSIDE b",
"a NONEINSIDE b",
"a OUTSIDE b",
"a INTERSECTS b",
"1..2",
"1..=2",
"1>..2",
"1>..=2",
"a @@ b",
"a @1@ b",
"a @AND@ b",
"a @OR@ b",
"a @1,OR@ b",
"a <|3|> b",
"a <|3,COSINE|> b",
"a <|3,EUCLIDEAN|> b",
"a <|3,MANHATTAN|> b",
"a <|3,40|> b",
"(a @@ b) @@ c",
"a @@ (b @@ c)",
"(a <|3|> b) <|3|> c",
"a + b + c",
"(a + b) + c",
"a + (b + c)",
"a - b + c",
"a - (b + c)",
"(a - b) - c",
"a - (b - c)",
"(a + b) * c",
"a * (b + c)",
"a * b + c",
"a / b * c",
"a / (b * c)",
"(a * b) / c",
"a * (b / c)",
"a ** b ** c",
"(a ** b) ** c",
"a ** (b ** c)",
"(a ** b) * c",
"(a = b) = c",
"a = (b = c)",
"a == b == c",
"(a == b) == c",
"a == (b == c)",
"(a < b) < c",
"a < (b < c)",
"(a < b) == c",
"a < b == c",
"a == (b < c)",
"a || b && c",
"(a || b) && c",
"a || (b && c)",
"a && (b || c)",
"(a ?? b) ?: c",
"a ?? (b ?: c)",
"a ?? b || c",
"(a ?? b) || c",
"(1..2)..3",
"1..(2..3)",
"(1..2) + 1",
"1 + (2..3)",
"1..2 + 3",
"(1 + 2)..3",
"a..b",
"(a:1) + 1",
"1 + (a:1)",
"(a:1) = (b:2)",
"(..) + 1",
"1 + (..)",
"(..) = (..)",
"(1 + 2) > 3",
"1 + (2 > 3)",
"1 > 2 + 3",
"-1 + 2",
"1 + -2",
"1 - -2",
"1 - (-2)",
"1 - - 2",
"-1 ** 2",
"-(1 ** 2)",
"(-1) ** 2",
"(-a) ** 2",
"!a = b",
"!(a = b)",
"(!a) = b",
"1 + (SELECT * FROM x)",
"(SELECT * FROM x) + 1",
"(CREATE a) + (UPDATE b)",
"1 + (RETURN 1)",
"1 + (RETURN 1 FETCH a)",
"1 + (IF a { b })",
"1 + (LET $a = 1)",
"(THROW 1) + 1",
"1 + (THROW 1)",
"1 + (|| 1)",
"(|| 1) + 1",
"(INFO FOR ROOT) + 1",
"(SLEEP 1s) + 1",
"(a:1..2) + 1",
"1 + (a:1..2)",
"1 + ($a = 1)",
"a..",
"a>..",
"1..",
"1>..",
"(a..)..",
"(a>..)>..",
"(a + b)..",
"a + b..",
"(a..) + b",
"a + (b..)",
"(-1)..",
"-1..",
"(..2)..",
"(a:1)..",
"(a.b)..",
"a.b..",
"(a..).b",
"(a)(1)",
"(a + b)(1)",
"(1 + 2)(3, 4)",
"(a)(1)(2)",
"(a.b)(1)",
"(f(1))(2)",
"(a..)(1)",
"math::pi(1)",
"math::pi(1) + 1",
"1 + math::pi(1)",
"math::pi(1)(2)",
"(math::pi(1))..",
"math::pi",
"(|$a| $a)(1)",
"($a)(1)",
"(a)((SELECT * FROM x), (RETURN 1 FETCH a))",
"math::abs(1)",
"math::ABS(1)",
"string::len('a')",
"type::is::array(a)",
"count()",
"COUNT()",
"time::now()",
"math::abs((SELECT * FROM x))",
"math::abs(RETURN 1)",
"math::abs((RETURN 1 FETCH a))",
"math::abs(-1)",
"math::abs(1 + 2)",
"string::concat('a', 'b', 'c')",
"fn::x(1, 2)",
"fn::x::y()",
"fn::`a b`()",
"fn::`select`()",
"ext::foo(1)",
"ext::foo::bar(1)",
"ext::`a b`::`c d`(1)",
"mod::foo(1)",
"silo::org::pkg<1.2.3>(1)",
"silo::org::pkg<1.2.3>::sub::x(1)",
"ml::model<1.0.0>(1)",
"ml::a::b<1.0.0>(1, 2)",
"function(1, 2) { return 1; }",
"function() {}",
"function() { return `x`; }",
"(function() { return 1; }).a",
"a.b",
"a.b.c",
"a.`select`.c",
"a[0]",
"a[1 + 2]",
"a[$]",
"a.*",
"a[*]",
"a[WHERE x > 1]",
"a[WHERE (SELECT * FROM x)]",
"a.b()",
"a.b(1, 2)",
"a.b.c(1).d",
"a.b((SELECT * FROM x))",
"a.`select`(1)",
"a.?",
"a.b.?.c",
"a...",
"a.@",
"a.@.b",
"a.b[0].c[1]",
"@.a",
"@.a.b",
"$a.b",
"$a[0]",
"$a.b.c",
"$a.*",
"(a.b).c",
"(a).b",
"(a.b)[0]",
"(a.b)[0].c",
"((a.b).c).d",
"(a)[0]",
"([1, 2])[0]",
"[1, 2][0]",
"{ a: 1 }.a",
"({ a: 1 }).a",
"({ a: [1] }.a)[0]",
"(1 + 2).a",
"(a + b).c",
"(-1).a",
"(-1.5).a",
"(-1.5dec).a",
"(-0.0).a",
"(1).a",
"(NONE).a",
"(NULL).a",
"(a:1).b",
"a:1.b",
"a:1.b.c",
"(!a).b",
"(<int> a).b",
"(a..).b",
"(a..2).b",
"(a(1)).b",
"f(1).b",
"f(1).b[0]",
"f(1)[0]",
"math::abs(1).b",
"math::pi.a",
"(math::pi).a",
"(math::pi(1)).a",
"(SELECT * FROM x).a",
"(SELECT * FROM x)[0].a",
"(RETURN 1).a",
"(IF a { b }).c",
"(|| 1).a",
"(|| 1)[0]",
"(1, 2).c",
"|a:3|.b",
"('x').a",
"(r'a:1').b",
"(u'018a6180-0000-7000-8000-000000000000').a",
"(..).a",
"($a = 1).b",
"->a",
"<-a",
"<->a",
"<~a",
"->?",
"<-?",
"<->?",
"<~?",
"->a->b",
"->a->b.c",
"<-a<-b",
"->a<-b",
"<->a<->b",
"a->b",
"a:1->b",
"a:1->b->c.d",
"a:1->b[WHERE x]->c.name",
"a:1<-b<-c",
"a:1<~b",
"$a->b->c",
"$a<-b",
"@->a",
"->(a, b)",
"<-(a, b)",
"<->(a, b, c)",
"->(a, b)->c",
"->`select`",
"->`a b`",
"->(`select`:1..2)",
"<~(`select` FIELD `value`)",
"->(`select`, `value`)",
"->(a WHERE x > 1)",
"->(a WHERE x AS y)",
"->(a AS y)",
"->(? WHERE x)",
"->(?)",
"->(a LIMIT 2)",
"->(a WHERE x LIMIT 3 START 1)",
"->(SELECT x FROM a ORDER BY y DESC, z COLLATE NUMERIC LIMIT 3 START 1)",
"->(SELECT x FROM a ORDER BY RAND())",
"|| (->a)",
"|| (->?)",
"|| (<-a.b)",
"a.{2}()",
"a.{ b: (->x) }.c",
"->(a START 2)",
"->(a, b WHERE x)",
"->(SELECT x FROM a)",
"->(SELECT x, y AS z FROM a)",
"->(SELECT * FROM a)",
"->(SELECT VALUE x FROM a)",
"->(SELECT VALUE x AS y FROM a)",
"->(SELECT x FROM ONLY a)",
"->(SELECT x FROM a, b)",
"->(SELECT x FROM a WHERE y)",
"->(SELECT x FROM a WHERE y ORDER BY z LIMIT 1 START 2 AS w)",
"->(SELECT x FROM a SPLIT x)",
"->(SELECT x, count() FROM a GROUP BY x)",
"->(SELECT count() FROM a GROUP ALL)",
"->(SELECT x FROM ? WHERE y)",
"->(SELECT x FROM a:1..5)",
"->a:1..5",
"->(a:1..5)",
"->(a:1..)",
"->(a:..5)",
"->(a:..=5)",
"->(a:1>..=5)",
"->(a:1>..)",
"->(a:..)",
"->(a:1..3, b)",
"->(a:[1]..[2])",
"->(a:1..5 WHERE x)",
"->(a:1..5 AS y)",
"<~(a FIELD f)",
"<~(a FIELD f, b)",
"<~(a FIELD f WHERE x)",
"<~a.b",
"<~(a).b",
"<-(a:1..).b",
"<~(a WHERE x)",
"<~(SELECT x FROM a)",
"->(a WHERE (SELECT * FROM x))",
"->(SELECT (SELECT * FROM x) FROM a)",
"->(a FIELD f)",
"-(->a)",
"(->a).b",
"(->a)->b",
"(->a)[0]",
"->a.{ b, c }",
"(->a)(1)",
"1 + ->a",
"->a + 1",
"1 - ->a",
"a.{3}",
"a.{1..5}",
"a.{..5}",
"a.{1..}",
"a.{..}",
"a.{3}.b",
"a.{1..3+path}",
"a.{1..3+collect}",
"a.{..+path+inclusive}",
"a.{..+collect+inclusive}",
"a.{3+path}",
"a.{3+shortest=b:1}",
"a.{..+shortest=b:1+inclusive}",
"a.{2}(->x)",
"a.{2}(->x->y)",
"a.{1..3}(.b.c)",
"a.{2}(.b)",
"a.{2}(->x.name)",
"a.{2}(->x).@",
"a.{ b }",
"a.{ b, c }",
"a.{ b: c }",
"a.{ b: c.d }",
"a.{ b: (c) }",
"a.{ b: ->x }",
"a.{ b: (->x) }",
"a.{ b: 1 }",
"a.{ b: -1 }",
"a.{ b: 1 + 2 }",
"a.{ b: (1 + 2) }",
"a.{ b: f(1) }",
"a.{ b: (SELECT * FROM x) }",
"a.{ b: 'x' }",
"a.{ b: 'a:1' }",
"a.{ b: $c }",
"a.{ b: $c.d }",
"a.{ b: [1] }",
"a.{ b: c:1 }",
"a.{ b: NONE }",
"a.{ b.* }",
"a.{ b.{ c } }",
"a.{ b.{ c, d: e }, f }",
"a.{ ... }",
"a.{ b, ... }",
"a.{ `select`, `a b`: c }",
"a.{}",
"a.{ b }.c",
"a.{ b }[0]",
"$a.{ b, c }",
"{;}",
"{ 1 }",
"{ 1; 2 }",
"{ 1; 2; 3 }",
"{ a }",
"{ a; b }",
"{ (a:1) }",
"{ (a:1); 2 }",
"{ 1; (a:1) }",
"{ (a:1); (b:2) }",
"{ ($a = 1) }",
"{ ($a = 1); 2 }",
"{ 1; ($a = 1) }",
"{ ($a = 1); ($b = 2) }",
"{ LET $a = 1; $a }",
"{ RETURN 1 }",
"{ RETURN 1 FETCH a }",
"{ SELECT * FROM x }",
"{ { 1 } }",
"{ { 1 }; { 2 } }",
"{ BREAK }",
"{ THROW 'x' }",
"{ (SELECT * FROM x); (SELECT * FROM y) }",
"{ 1; }",
"{ a:1 }.a",
"($a = 1)",
"(a:1)",
"(a:1); 1",
"|| 1",
"|$a| $a",
"|$a: int| $a",
"|$a: array<int>| $a",
"|$a, $b| $a + $b",
"|$a: int, $b: string| $a",
"|$a: int| -> int { $a }",
"|| -> int { 1 }",
"|$a| -> int | string { $a }",
"|$a: <int | string>| $a",
"|$a: <option<int>>| $a",
"|| a.b",
"|| a + 1",
"|| a",
"|| (a + 1)",
"|| (SELECT * FROM x)",
"|| (RETURN 1 FETCH a)",
"|| RETURN 1",
"|| (a:1)",
"|| { 1 }",
"|| |$a| $a",
"|| 1 + ->a",
"|| a..",
"|| (1..)",
"|$`a b`| $`a b`",
"|$select| $select",
"|| ((a)..)",
"|| (f(1))",
"|| f(1)",
"|| (THROW 1)",
"|| (IF a { b })",
"|a:3|",
"|a:1..3|",
"|a:1>..3|",
"|a:1..=3|",
"|a:1>..=3|",
"|a:..3|",
"|a:..=3|",
"|a:1..|",
"|a:1>..|",
"|a:..|",
"|`a b`:3|",
"|`select`:3|",
"|a:-3|",
"|a:0|",
"LET $a = 1",
"LET $a: int = 1",
"LET $a: int | string = 1",
"LET $a = (SELECT * FROM x)",
"LET $a = (RETURN 1 FETCH b)",
"LET $`a b` = 1",
"LET $select = a:1",
"LET $a = (LET $b = 1)",
"LET $a = $b = 1",
"IF a { b }",
"IF a { b } ELSE { c }",
"IF a { b } ELSE IF c { d }",
"IF a { b } ELSE IF c { d } ELSE { e }",
"IF a THEN b END",
"IF a THEN b ELSE c END",
"IF a THEN b ELSE IF c THEN d END",
"IF a THEN b ELSE IF c THEN d ELSE e END",
"IF a THEN (IF b { c }) END",
"IF a THEN (IF b { c } ELSE { d }) ELSE e END",
"IF a THEN (IF b THEN c END) END",
"IF a THEN b ELSE (SELECT * FROM x) END",
"IF (SELECT * FROM x) THEN (SELECT * FROM y) ELSE (SELECT * FROM z) END",
"IF (SELECT * FROM x) { 2 }",
"IF a { b; c }",
"IF a { b; c; d }",
"IF a { 1; 2 }",
"IF a { 'x'; $y }",
"IF a { 1; 2 } ELSE { 3; 4 }",
"IF a { SELECT * FROM x; 2 }",
"IF a { SELECT * FROM x }",
"IF a { LET $b = 1; $b }",
"IF a {;}",
"IF a {;} ELSE {;}",
"IF a { (b:1) }",
"IF a { ($b = 1) }",
"IF a { b } ELSE IF c { 1; 2 }",
"IF a { (b:1); c }",
"IF a THEN { b } END",
"IF a THEN { b } ELSE { c } END",
"IF a { IF b { c } }",
"IF a { b } ELSE { IF c { d } ELSE { e } }",
"FOR $a IN [1, 2] { a }",
"FOR $a IN 1..3 { 1; 2 }",
"FOR $a IN (SELECT * FROM x) {;}",
"FOR $a IN b { BREAK; CONTINUE }",
"FOR $a IN b { IF a { CONTINUE } }",
"FOR $`a b` IN b { $`a b` }",
"FOR $a IN (RETURN [1] FETCH b) { $a }",
"RETURN 1",
"RETURN (SELECT * FROM x)",
"RETURN a FETCH b, c",
"RETURN a FETCH b.c",
"RETURN (RETURN 1 FETCH a)",
"RETURN (a:1)",
"RETURN $a = 1",
"RETURN IF a { b }",
"RETURN { a: 1 }",
"THROW 'x'",
"THROW (SELECT * FROM x)",
"THROW (THROW 1)",
"THROW { a: 1 }",
"THROW (RETURN 1 FETCH a)",
"SLEEP 1s",
"SLEEP 90s",
"SLEEP 1h30m",
"BREAK",
"CONTINUE",
"SELECT * FROM a",
"SELECT a, b AS c FROM a, b",
"SELECT a.b AS c.d FROM a",
"SELECT *, a FROM a",
"SELECT VALUE a FROM a",
"SELECT VALUE a AS b FROM a",
"SELECT VALUE (SELECT * FROM x) FROM a",
"SELECT (SELECT * FROM x) AS x FROM a",
"SELECT * OMIT a, b FROM a",
"SELECT * OMIT (a) FROM a",
"SELECT * FROM ONLY a",
"SELECT * FROM ONLY a:1",
"SELECT * FROM a:1, b:2",
"SELECT * FROM a:1..5",
"SELECT * FROM (SELECT * FROM x)",
"SELECT * FROM (a:1)",
"SELECT * FROM $a",
"SELECT * FROM [1, 2]",
"SELECT * FROM a WITH NOINDEX",
"SELECT * FROM a WITH INDEX i, `j k`",
"SELECT * FROM a WHERE b",
"SELECT * FROM a WHERE (SELECT * FROM x)",
"SELECT * FROM a WHERE NONE",
"SELECT * FROM a WHERE b = 1 AND c > 2",
"SELECT a, b FROM c SPLIT a",
"SELECT a, b FROM c SPLIT a, b",
"SELECT a, b FROM c SPLIT ON a",
"SELECT a, count() FROM c GROUP BY a",
"SELECT a, b, count() FROM c GROUP BY a, b",
"SELECT count() FROM a GROUP ALL",
"SELECT * FROM a ORDER BY b",
"SELECT * FROM a ORDER BY b DESC",
"SELECT * FROM a ORDER BY b ASC, c DESC",
"SELECT * FROM a ORDER BY b COLLATE",
"SELECT * FROM a ORDER BY b NUMERIC",
"SELECT * FROM a ORDER BY b COLLATE NUMERIC DESC",
"SELECT * FROM a ORDER BY RAND()",
"SELECT * FROM a ORDER BY b.c[0]",
"SELECT * FROM a LIMIT 1",
"SELECT * FROM a LIMIT (SELECT * FROM x)",
"SELECT * FROM a LIMIT 1 START 2",
"SELECT * FROM a START 2",
"SELECT * FROM a FETCH b",
"SELECT * FROM a FETCH b, c.d",
"SELECT * FROM a VERSION d'2020-01-01T00:00:00Z'",
"SELECT * FROM a VERSION (SELECT * FROM x)",
"SELECT * FROM a VERSION NONE",
"SELECT * FROM a VERSION (NONE)",
"SELECT * FROM a TIMEOUT 1s",
"SELECT * FROM a TIMEOUT NONE",
"SELECT * FROM a TIMEOUT (NONE)",
"SELECT * FROM a TIMEOUT $t",
"SELECT * FROM a FOR UPDATE",
"SELECT * FROM a TEMPFILES",
"SELECT * FROM a EXPLAIN",
"SELECT * FROM a EXPLAIN FULL",
"SELECT a, b AS c FROM d:1..2 WITH INDEX i WHERE e SPLIT a ORDER BY b LIMIT 1 START 2 FETCH f",
"SELECT a FROM d FETCH f VERSION d'2020-01-01T00:00:00Z' TIMEOUT 1s EXPLAIN FULL",
"SELECT a FROM d TIMEOUT 1s FOR UPDATE TEMPFILES EXPLAIN",
"SELECT * FROM x",
"SELECT 1 + 2 AS x FROM a",
"SELECT -1 AS x FROM a",
"SELECT NONE FROM a",
"SELECT (NONE) FROM a",
"EXPLAIN SELECT * FROM x",
"EXPLAIN ANALYZE SELECT * FROM a",
"EXPLAIN FORMAT JSON SELECT * FROM a",
"EXPLAIN ANALYZE FORMAT JSON SELECT * FROM a",
"EXPLAIN FORMAT TEXT SELECT * FROM a",
"EXPLAIN CREATE a",
"(EXPLAIN SELECT * FROM x)",
"CREATE a",
"CREATE ONLY a:1",
"CREATE a, b",
"CREATE a:1, a:2",
"CREATE (a:1)",
"CREATE $a",
"CREATE a SET b = 1",
"CREATE a SET b = 1, c += 2, d -= 3, e +?= 4",
"CREATE a SET b.c = (SELECT * FROM x), d[0] = 2",
"CREATE a SET b = (RETURN 1 FETCH c)",
"CREATE a UNSET b, c.d",
"CREATE a CONTENT { b: 1 }",
"CREATE a CONTENT $b",
"CREATE a CONTENT (SELECT * FROM x)",
"CREATE a MERGE { b: 1 }",
"CREATE a RETURN NONE",
"CREATE a RETURN NULL",
"CREATE a RETURN DIFF",
"CREATE a RETURN AFTER",
"CREATE a RETURN BEFORE",
"CREATE a RETURN b, c",
"CREATE a RETURN b AS c, d",
"CREATE a RETURN *",
"CREATE a RETURN *, b",
"CREATE a RETURN b, *",
"CREATE a RETURN VALUE b",
"CREATE a RETURN VALUE b AS c",
"CREATE a RETURN VALUE (NONE)",
"CREATE a RETURN (NONE)",
"CREATE a RETURN (NULL)",
"CREATE a RETURN (NONE + 1)",
"CREATE a RETURN (NONE..)",
"CREATE a RETURN (NONE) AS b",
"CREATE a RETURN (NONE), (NONE)",
"CREATE a RETURN (NONE).b",
"CREATE a RETURN (NONE)(1)",
"CREATE a RETURN (NONE = 1) AS b, c",
"CREATE a RETURN (-1)",
"CREATE a RETURN (SELECT * FROM x)",
"CREATE a RETURN 1 + 2",
"CREATE a RETURN b..",
"CREATE a TIMEOUT 1s",
"CREATE a TIMEOUT NONE",
"CREATE a SET b = 1 RETURN AFTER TIMEOUT 1s",
"UPDATE a",
"UPDATE ONLY a:1",
"UPDATE a SET b = 1 WHERE c",
"UPDATE a SET b = 1 WHERE c RETURN AFTER",
"UPDATE a WITH NOINDEX SET b = 1",
"UPDATE a WITH INDEX i SET b = 1",
"UPDATE a CONTENT { b: 1 }",
"UPDATE a MERGE { b: 1 }",
"UPDATE a REPLACE { b: 1 }",
"UPDATE a PATCH [{ op: 'add', path: '/b', value: 1 }]",
"UPDATE a UNSET b",
"UPDATE a SET b = 1 TIMEOUT 1s",
"UPDATE a SET b = 1 EXPLAIN",
"UPDATE a SET b = 1 EXPLAIN FULL",
"UPDATE a WHERE (SELECT * FROM x)",
"UPDATE a, b WHERE c",
"UPSERT a",
"UPSERT ONLY a:1 SET b = 1",
"UPSERT a SET b = 1 WHERE c RETURN BEFORE",
"UPSERT a WITH NOINDEX CONTENT { b: 1 } EXPLAIN",
"UPSERT a MERGE $b TIMEOUT 1s",
"DELETE a",
"DELETE ONLY a:1",
"DELETE a WHERE b",
"DELETE a WITH NOINDEX WHERE b RETURN BEFORE",
"DELETE a WHERE b TIMEOUT 1s EXPLAIN",
"DELETE a:1..3",
"DELETE (SELECT * FROM x)",
"RELATE a:1->b->c:2",
"RELATE ONLY a:1->b->c:2",
"RELATE a:1->b->c:2 SET x = 1",
"RELATE a:1->b->c:2 CONTENT { x: 1 }",
"RELATE a:1->b->c:2 RETURN NONE",
"RELATE a:1->b->c:2 TIMEOUT 1s",
"RELATE [a:1]->b->[c:2]",
"RELATE $a->$b->$c",
"RELATE a:1->$b->c:2",
"RELATE (a:1..2)->b->c:3",
"RELATE a:1->b->(c:2..3)",
"RELATE a:1->(1 + 1)->c:2",
"RELATE (SELECT * FROM x)->b->(SELECT * FROM y)",
"RELATE a:rand()->b->c:ulid()",
"RELATE a:[1]->b->c:{ x: 1 }",
"RELATE a:u'018a6180-0000-7000-8000-000000000000'->b->c:2",
"RELATE (b)->c->(d)",
"RELATE (r'a:1')->b->(r'c:2')",
"RELATE (r'a:1..2')->b->(r'c:2..3')",
"RELATE ('a:1')->b->('c:2')",
"RELATE a:1->`b c`->c:2",
"RELATE a:1->b:1->c:2",
"INSERT INTO a { b: 1 }",
"INSERT INTO a [{ b: 1 }, { b: 2 }]",
"INSERT INTO a (b, c) VALUES (1, 2), (3, 4)",
"INSERT INTO a (b) VALUES ((SELECT * FROM x))",
"INSERT IGNORE INTO a { b: 1 }",
"INSERT RELATION INTO a { b: 1 }",
"INSERT RELATION IGNORE INTO a { b: 1 }",
"INSERT INTO $a { b: 1 }",
"INSERT INTO a (b) VALUES (1) ON DUPLICATE KEY UPDATE b += 1, c = 2",
"INSERT INTO a { b: 1 } ON DUPLICATE KEY UPDATE b = (SELECT * FROM x) RETURN AFTER TIMEOUT 1s",
"INSERT { id: 1 }",
"INSERT (b) VALUES (1)",
"INSERT $a",
"INSERT INTO a $b",
"INSERT INTO a { b: 1 } RETURN NONE",
"INFO FOR ROOT",
"INFO FOR NS",
"INFO FOR DB",
"INFO FOR TABLE a",
"INFO FOR TABLE `a b`",
"INFO FOR TABLE (a)",
"INFO FOR USER a",
"INFO FOR USER a ON ROOT",
"INFO FOR USER a ON NS",
"INFO FOR USER a ON DB",
"INFO FOR INDEX i ON a",
"INFO FOR ROOT STRUCTURE",
"INFO FOR NS STRUCTURE",
"INFO FOR DB STRUCTURE",
"INFO FOR TABLE a STRUCTURE",
"INFO FOR USER a ON ROOT STRUCTURE",
"INFO FOR USER a STRUCTURE",
"INFO FOR INDEX i ON a STRUCTURE",
"INFO FOR ROOT VERSION d'2020-01-01T00:00:00Z'",
"INFO FOR NS VERSION d'2020-01-01T00:00:00Z' STRUCTURE",
"INFO FOR DB VERSION d'2020-01-01T00:00:00Z'",
"INFO FOR TABLE a VERSION d'2020-01-01T00:00:00Z' STRUCTURE",
"INFO FOR DB VERSION (SELECT * FROM x)",
"REBUILD INDEX i ON a",
"REBUILD INDEX IF EXISTS i ON a",
"REBUILD INDEX i ON a CONCURRENTLY",
"REBUILD INDEX IF EXISTS `if` ON `a b` CONCURRENTLY",
"REBUILD INDEX `select` ON `select`",
"BEGIN",
"BEGIN TRANSACTION",
"BEGIN ISOLATION LEVEL SNAPSHOT",
"BEGIN ISOLATION LEVEL SERIALIZABLE",
"BEGIN READ ONLY",
"BEGIN READ ONLY MAX STALENESS 5s",
"BEGIN READ ONLY MAX STALENESS 5s STRICT",
"BEGIN READ ONLY MAX STALENESS $x",
"CANCEL",
"COMMIT",
"CANCEL TRANSACTION",
"COMMIT TRANSACTION",
"BEGIN; CANCEL; BEGIN; COMMIT",
"USE NS a",
"USE DB b",
"USE NS a DB b",
"USE DEFAULT",
"USE NS $a DB (SELECT * FROM x)",
"OPTION IMPORT",
"OPTION IMPORT = false",
"OPTION IMPORT = true",
"KILL u'018a6180-0000-7000-8000-000000000000'",
"KILL $x",
"KILL u'018a6180-0000-7000-8000-000000000001'",
"LIVE SELECT * FROM a",
"LIVE SELECT DIFF FROM a",
"LIVE SELECT VALUE x FROM a WHERE y FETCH z",
"LIVE SELECT a, b FROM $c WHERE d",
"SHOW CHANGES FOR TABLE a SINCE 1 LIMIT 10",
"SHOW CHANGES FOR DATABASE SINCE d'2020-01-01T00:00:00Z'",
"SHOW CHANGES FOR TABLE `a b` SINCE 0",
"ACCESS a GRANT FOR USER b",
"ACCESS a GRANT FOR RECORD c:1",
"ACCESS a ON DATABASE SHOW ALL",
"ACCESS a ON NAMESPACE SHOW GRANT x",
"ACCESS a SHOW WHERE b = 1",
"ACCESS a REVOKE ALL",
"ACCESS a REVOKE GRANT x",
"ACCESS a REVOKE WHERE b",
"ACCESS a PURGE EXPIRED FOR 1d",
"ACCESS a PURGE REVOKED",
"ACCESS a PURGE EXPIRED, REVOKED FOR 1h",
"DEFINE NAMESPACE a",
"DEFINE DATABASE a",
"DEFINE TABLE a",
"DEFINE TABLE IF NOT EXISTS a SCHEMAFULL",
"DEFINE TABLE OVERWRITE a TYPE RELATION IN b OUT c",
"DEFINE TABLE a AS SELECT x, count() FROM b GROUP BY x",
"DEFINE FIELD a ON b TYPE int",
"DEFINE FIELD a.* ON b TYPE option<string> DEFAULT 'x' ASSERT $value != NONE",
"DEFINE INDEX i ON a FIELDS b UNIQUE",
"DEFINE INDEX i ON a FIELDS b, c HNSW DIMENSION 3 DIST COSINE",
"DEFINE FUNCTION fn::f($a: int) -> int { RETURN $a; }",
"DEFINE PARAM $p VALUE 1",
"DEFINE EVENT e ON a WHEN true THEN (RETURN 1)",
"DEFINE USER u ON ROOT PASSWORD 'x' ROLES OWNER",
"DEFINE ACCESS a ON DATABASE TYPE JWT ALGORITHM HS256 KEY 'secret'",
"DEFINE ACCESS a ON DATABASE TYPE BEARER FOR USER",
"DEFINE ACCESS a ON DATABASE TYPE JWT URL 'https://example.com/jwks'",
"DEFINE ANALYZER a TOKENIZERS blank FILTERS lowercase",
"DEFINE SEQUENCE a BATCH 10 START 1",
"ALTER TABLE a SCHEMAFULL",
"ALTER TABLE a DROP COMMENT",
"ALTER FIELD a ON b TYPE string",
"REMOVE TABLE a",
"REMOVE FIELD a ON b",
"REMOVE INDEX i ON a",
"REMOVE FUNCTION fn::f",
"'018a6180-0000-7000-8000-000000000000'",
"'2020-01-01T00:00:00Z'",
"'person:tobie'",
"'a:1' + 1",
"1 + 'a:1'",
"'a:1'..2",
"{ 'a:1' }",
"{ 'a:1'; 2 }",
"{ 'a:1', 2 }",
"{ 2, 'a:1' }",
"'a:1'.b",
"-'a:1'",
"[ 'a:1', '2020-01-01T00:00:00Z' ]",
"CREATE 'a:1'",
"SELECT * FROM 'a:1'",
"'a:1..2'",
"'a:rand()'",
"'a:[1]'",
"'a b:1'",
"s'a:1' + 1",
"1; 2; SELECT * FROM z",
"(a = b) @@ c",
"a = (b @@ c)",
"(a < b) @@ c",
"a @@ (b < c)",
];
#[test]
fn nullish_and_matches_parentheses_round_trip() {
for src in [
"published ?? (archived ?: true)",
"(published ?? archived) ?: true",
"(a = b) @@ c",
"a = (b @@ c)",
"(a < b) @@ c",
"a @@ (b < c)",
"(a @@ b) < c",
"a < (b @@ c)",
] {
let first = crate::parser::expr(src).unwrap_or_else(|e| panic!("{src}: {e}"));
let rendered = first.to_sql();
let second =
crate::parser::expr(&rendered).unwrap_or_else(|e| panic!("{rendered}: {e}"));
assert_eq!(first, second, "round-trip AST mismatch for {src:?} -> {rendered:?}");
}
}
}