use std::collections::VecDeque;
use std::fmt::{self, Display, Formatter};
use std::ops::Bound;
use surrealdb_strand::Strand;
use surrealdb_types::ToSql;
use super::expr::{
LogicalCall, LogicalClosure, LogicalDestructureField, LogicalExpr, LogicalField, LogicalFields,
LogicalIf, LogicalLiteral, LogicalLookup, LogicalLookupSubject, LogicalOrder, LogicalOrdering,
LogicalPostfixOperator, LogicalRecordIdKey, LogicalRecordIdKeyRange, LogicalRecordIdLit,
LogicalRecurse, LogicalRecurseInstruction, LogicalRecursePath, OutputPath, SourceRef,
};
use super::{
LogicalAggregate, LogicalAssignment, LogicalBreak, LogicalContinue, LogicalData, LogicalDdl,
LogicalDdlStatement, LogicalEval, LogicalExplain, LogicalFetch, LogicalFilter, LogicalForeach,
LogicalIfOp, LogicalInfo, LogicalInsertRows, LogicalInserts, LogicalLet, LogicalLimit,
LogicalOnly, LogicalOp, LogicalProject, LogicalReturn, LogicalSequence, LogicalSleep,
LogicalSort, LogicalSource, LogicalSplit, LogicalSubquery, LogicalThrow, LogicalTimeout,
LogicalUnionAll, LogicalValues, LogicalVersionScope, LogicalWrite, LogicalWriteSource,
LogicalWriteStatement,
};
use crate::expr as surface;
use crate::expr::part::Recurse;
use crate::expr::statements::{IfelseStatement, InfoStatement, SelectStatement};
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum NoLogicalForm {
Unsupported(String),
}
impl Display for NoLogicalForm {
fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
match self {
NoLogicalForm::Unsupported(what) => write!(f, "{what} has no logical form"),
}
}
}
impl std::error::Error for NoLogicalForm {}
type Lowered<T> = Result<T, NoLogicalForm>;
pub fn lower(expr: impl Into<surface::Expr>) -> Lowered<LogicalOp> {
match expr.into() {
surface::Expr::IfElse(stmt) => lower_if_statement(*stmt),
surface::Expr::Throw(value) => Ok(LogicalOp::Throw(LogicalThrow {
value: lower_expr(*value)?,
})),
surface::Expr::Break => Ok(LogicalOp::Break(LogicalBreak)),
surface::Expr::Continue => Ok(LogicalOp::Continue(LogicalContinue)),
surface::Expr::Select(select) => lower_select(*select),
surface::Expr::Block(block) => lower_block(*block),
surface::Expr::Let(stmt) => Ok(LogicalOp::Let(LogicalLet {
name: stmt.name.into_string(),
kind: stmt.kind,
value: Box::new(lower(stmt.what)?),
synthetic: false,
})),
surface::Expr::Return(stmt) => Ok(LogicalOp::Return(LogicalReturn {
what: Box::new(lower_value_statement(stmt.what)?),
fetch: lower_fetchs(stmt.fetch)?,
})),
surface::Expr::Foreach(stmt) => Ok(LogicalOp::Foreach(LogicalForeach {
param: stmt.param,
range: lower_expr(stmt.range)?,
body: Box::new(lower_block(stmt.block)?),
})),
surface::Expr::Info(info) => Ok(LogicalOp::Info(Box::new(lower_info(*info)?))),
surface::Expr::Sleep(stmt) => Ok(LogicalOp::Sleep(LogicalSleep {
duration: LogicalExpr::Literal(LogicalLiteral::Duration(stmt.duration)),
})),
surface::Expr::Explain {
format,
analyze,
statement,
} => Ok(LogicalOp::Explain(LogicalExplain {
input: Box::new(lower_value_statement(*statement)?),
analyze,
format,
})),
surface::Expr::Create(stmt) => {
let targets = lower_exprs(stmt.what.clone())?;
let timeout = stmt.timeout.clone();
with_timeout(
LogicalOp::Write(LogicalWrite {
data: stmt.data.clone().map(lower_data).transpose()?.flatten(),
duplicate_update: None,
cond: None,
statement: LogicalWriteStatement::Create(stmt),
source: LogicalWriteSource::Targets(targets),
trace: crate::expr::logical::LookupTrace::None,
}),
timeout,
)
}
surface::Expr::Update(stmt) => {
let rows = lower_write_rows(stmt.what.clone(), stmt.with.as_ref())?;
let timeout = stmt.timeout.clone();
let explain = stmt.explain.as_ref().map(|surface::Explain(analyze)| *analyze);
let op = with_timeout(
LogicalOp::Write(LogicalWrite {
data: stmt.data.clone().map(lower_data).transpose()?.flatten(),
duplicate_update: None,
cond: stmt.cond.clone().map(|c| lower_expr(c.0)).transpose()?,
statement: LogicalWriteStatement::Update(stmt),
source: LogicalWriteSource::Rows(Box::new(rows)),
trace: crate::expr::logical::LookupTrace::None,
}),
timeout,
)?;
Ok(with_explain(op, explain))
}
surface::Expr::Upsert(stmt) => {
let targets = lower_exprs(stmt.what.clone())?;
let timeout = stmt.timeout.clone();
let explain = stmt.explain.as_ref().map(|surface::Explain(analyze)| *analyze);
let op = with_timeout(
LogicalOp::Write(LogicalWrite {
data: stmt.data.clone().map(lower_data).transpose()?.flatten(),
duplicate_update: None,
cond: stmt.cond.clone().map(|c| lower_expr(c.0)).transpose()?,
statement: LogicalWriteStatement::Upsert(stmt),
source: LogicalWriteSource::Targets(targets),
trace: crate::expr::logical::LookupTrace::None,
}),
timeout,
)?;
Ok(with_explain(op, explain))
}
surface::Expr::Delete(stmt) => {
let rows = lower_write_rows(stmt.what.clone(), stmt.with.as_ref())?;
let timeout = stmt.timeout.clone();
let explain = stmt.explain.as_ref().map(|surface::Explain(analyze)| *analyze);
let op = with_timeout(
LogicalOp::Write(LogicalWrite {
data: None,
duplicate_update: None,
cond: stmt.cond.clone().map(|c| lower_expr(c.0)).transpose()?,
statement: LogicalWriteStatement::Delete(stmt),
source: LogicalWriteSource::Rows(Box::new(rows)),
trace: crate::expr::logical::LookupTrace::None,
}),
timeout,
)?;
Ok(with_explain(op, explain))
}
surface::Expr::Insert(stmt) => {
let inserts = lower_inserts(stmt.into.clone(), stmt.data.clone())?;
let timeout = stmt.timeout.clone();
with_timeout(
LogicalOp::Write(LogicalWrite {
data: None,
duplicate_update: stmt.update.clone().map(lower_data).transpose()?.flatten(),
cond: None,
statement: LogicalWriteStatement::Insert(stmt),
source: LogicalWriteSource::Inserts(inserts),
trace: crate::expr::logical::LookupTrace::None,
}),
timeout,
)
}
surface::Expr::Relate(stmt) => {
let targets =
lower_exprs(vec![stmt.from.clone(), stmt.through.clone(), stmt.to.clone()])?;
let timeout = stmt.timeout.clone();
with_timeout(
LogicalOp::Write(LogicalWrite {
data: stmt.data.clone().map(lower_data).transpose()?.flatten(),
duplicate_update: None,
cond: None,
statement: LogicalWriteStatement::Relate(stmt),
source: LogicalWriteSource::Targets(targets),
trace: crate::expr::logical::LookupTrace::None,
}),
timeout,
)
}
surface::Expr::Define(stmt) => Ok(LogicalOp::Ddl(LogicalDdl {
statement: LogicalDdlStatement::Define(stmt),
})),
surface::Expr::Remove(stmt) => Ok(LogicalOp::Ddl(LogicalDdl {
statement: LogicalDdlStatement::Remove(stmt),
})),
surface::Expr::Rebuild(stmt) => Ok(LogicalOp::Ddl(LogicalDdl {
statement: LogicalDdlStatement::Rebuild(stmt),
})),
surface::Expr::Alter(stmt) => Ok(LogicalOp::Ddl(LogicalDdl {
statement: LogicalDdlStatement::Alter(stmt),
})),
scalar @ (surface::Expr::Literal(_)
| surface::Expr::Param(_)
| surface::Expr::Idiom(_)
| surface::Expr::Table(_)
| surface::Expr::Mock(_)
| surface::Expr::Constant(_)
| surface::Expr::Prefix {
..
}
| surface::Expr::Postfix {
..
}
| surface::Expr::Binary {
..
}
| surface::Expr::FunctionCall(_)
| surface::Expr::Closure(_)) => Ok(LogicalOp::Eval(LogicalEval {
expr: lower_expr(scalar)?,
})),
}
}
pub fn lower_value_statement(expr: impl Into<surface::Expr>) -> Lowered<LogicalOp> {
let expr = expr.into();
if matches!(
expr,
surface::Expr::IfElse(_)
| surface::Expr::Throw(_)
| surface::Expr::Break
| surface::Expr::Continue
) {
return Ok(LogicalOp::Eval(LogicalEval {
expr: lower_expr(expr)?,
}));
}
lower(expr)
}
fn lower_if_statement(stmt: IfelseStatement) -> Lowered<LogicalOp> {
if if_arm_is_a_let(&stmt) {
return Ok(LogicalOp::Eval(LogicalEval {
expr: lower_expr(surface::Expr::IfElse(Box::new(stmt)))?,
}));
}
let branches = stmt
.exprs
.into_iter()
.map(|(cond, then)| Ok((lower_expr(cond)?, lower(then)?)))
.collect::<Lowered<Vec<_>>>()?;
let otherwise = stmt.close.map(lower).transpose()?;
Ok(LogicalOp::If(LogicalIfOp::new(branches, otherwise)))
}
fn if_arm_is_a_let(stmt: &IfelseStatement) -> bool {
fn is_a_let(arm: &surface::Expr) -> bool {
if let surface::Expr::IfElse(nested) = arm {
if_arm_is_a_let(nested)
} else {
matches!(arm, surface::Expr::Let(_))
}
}
stmt.exprs.iter().any(|(_, then)| is_a_let(then)) || stmt.close.as_ref().is_some_and(is_a_let)
}
pub fn lower_expr(expr: impl Into<surface::Expr>) -> Lowered<LogicalExpr> {
Ok(match expr.into() {
surface::Expr::Literal(literal) => lower_literal(literal)?,
surface::Expr::Param(param) => LogicalExpr::Param(param),
surface::Expr::Idiom(idiom) => lower_idiom(idiom)?,
surface::Expr::Table(table) => LogicalExpr::Table(table),
surface::Expr::Mock(mock) => LogicalExpr::Mock(mock),
surface::Expr::Constant(constant) => LogicalExpr::Constant(constant),
surface::Expr::Prefix {
op,
expr,
} => LogicalExpr::Prefix {
op,
expr: Box::new(lower_expr(*expr)?),
},
surface::Expr::Postfix {
expr,
op,
} => lower_postfix(lower_expr(*expr)?, op)?,
surface::Expr::Binary {
left,
op,
right,
} => LogicalExpr::Binary {
left: Box::new(lower_expr(*left)?),
op,
right: Box::new(lower_expr(*right)?),
},
surface::Expr::FunctionCall(call) => LogicalExpr::Call(Box::new(LogicalCall {
receiver: call.receiver,
args: lower_exprs(call.arguments)?,
})),
surface::Expr::Closure(closure) => {
let body_sql = std::sync::Arc::from(closure.body.to_sql());
LogicalExpr::Closure(Box::new(LogicalClosure {
args: closure.args,
returns: closure.returns,
body: lower_expr(closure.body)?,
body_sql,
}))
}
surface::Expr::Break => LogicalExpr::Break,
surface::Expr::Continue => LogicalExpr::Continue,
surface::Expr::Throw(expr) => LogicalExpr::Throw(Box::new(lower_expr(*expr)?)),
surface::Expr::IfElse(stmt) => LogicalExpr::If(Box::new(lower_if(*stmt)?)),
statement @ (surface::Expr::Block(_)
| surface::Expr::Return(_)
| surface::Expr::Select(_)
| surface::Expr::Info(_)
| surface::Expr::Foreach(_)
| surface::Expr::Let(_)
| surface::Expr::Sleep(_)
| surface::Expr::Explain {
..
}
| surface::Expr::Create(_)
| surface::Expr::Update(_)
| surface::Expr::Upsert(_)
| surface::Expr::Delete(_)
| surface::Expr::Insert(_)
| surface::Expr::Relate(_)
| surface::Expr::Define(_)
| surface::Expr::Remove(_)
| surface::Expr::Rebuild(_)
| surface::Expr::Alter(_)) => LogicalExpr::Subquery(Box::new(lower(statement)?)),
})
}
pub fn lower_select(select: impl Into<SelectStatement>) -> Lowered<LogicalOp> {
let select = select.into();
let SelectStatement {
fields,
omit,
only,
what,
with,
cond,
split,
group,
order,
limit,
start,
fetch,
version,
timeout,
explain,
tempfiles,
for_update,
} = select;
let input = lower_sources(what, with.as_ref(), for_update)?;
let cond = cond.map(|c| lower_expr(c.0)).transpose()?;
let split = split
.map(|splits| splits.into_iter().map(|s| lower_idiom(s.0)).collect::<Lowered<_>>())
.transpose()?;
let fields = lower_fields(fields)?;
let group = group
.map(|groups| groups.0.into_iter().map(|g| lower_idiom(g.0)).collect::<Lowered<_>>())
.transpose()?;
let order = order.map(lower_ordering).transpose()?;
let limit = limit.map(|l| lower_expr(l.0)).transpose()?;
let start = start.map(|s| lower_expr(s.0)).transpose()?;
let omit = lower_exprs(omit)?;
let fetch = lower_fetchs(fetch)?;
let timeout = if is_absent(&timeout) {
None
} else {
Some(lower_expr(timeout)?)
};
let version = if is_absent(&version) {
None
} else {
Some(lower_expr(version)?)
};
Ok(select_pipeline(SelectClauses {
input,
fields,
omit,
only,
cond,
split,
group,
order,
limit,
start,
fetch,
version,
timeout,
explain: explain.map(|surface::Explain(analyze)| analyze),
tempfiles,
}))
}
pub(crate) struct SelectClauses {
pub input: LogicalOp,
pub fields: LogicalFields,
pub omit: Vec<LogicalExpr>,
pub only: bool,
pub cond: Option<LogicalExpr>,
pub split: Option<Vec<LogicalExpr>>,
pub group: Option<Vec<LogicalExpr>>,
pub order: Option<LogicalOrdering>,
pub limit: Option<LogicalExpr>,
pub start: Option<LogicalExpr>,
pub fetch: Vec<LogicalExpr>,
pub version: Option<LogicalExpr>,
pub timeout: Option<LogicalExpr>,
pub explain: Option<bool>,
pub tempfiles: bool,
}
pub(crate) fn select_pipeline(clauses: SelectClauses) -> LogicalOp {
let SelectClauses {
input,
fields,
omit,
only,
cond,
split,
group,
order,
limit,
start,
fetch,
version,
timeout,
explain,
tempfiles,
} = clauses;
let mut op = input;
if let Some(cond) = cond {
op = LogicalOp::Filter(LogicalFilter {
input: Box::new(op),
predicate: cond,
});
}
if let Some(splits) = split {
op = LogicalOp::Split(LogicalSplit {
input: Box::new(op),
exprs: splits,
});
}
let grouped = group.is_some();
if let Some(groups) = group {
op = LogicalOp::Aggregate(LogicalAggregate {
input: Box::new(op),
group: groups,
fields: fields.clone(),
});
}
if let Some(ordering) = order {
op = LogicalOp::Sort(LogicalSort {
input: Box::new(op),
ordering,
tempfiles,
});
}
if limit.is_some() || start.is_some() {
op = LogicalOp::Limit(LogicalLimit {
input: Box::new(op),
limit,
start,
});
}
if !grouped || !omit.is_empty() {
op = LogicalOp::Project(LogicalProject {
input: Box::new(op),
fields: if grouped {
LogicalFields::all()
} else {
fields
},
omit,
});
}
let fetches = fetch;
if !fetches.is_empty() {
op = LogicalOp::Fetch(LogicalFetch {
input: Box::new(op),
fetches,
});
}
if let Some(timeout) = timeout {
op = LogicalOp::Timeout(LogicalTimeout {
input: Box::new(op),
timeout,
});
}
if let Some(version) = version {
op = LogicalOp::VersionScope(LogicalVersionScope {
input: Box::new(op),
version,
});
}
if only {
op = LogicalOp::Only(LogicalOnly {
input: Box::new(op),
});
}
if let Some(analyze) = explain {
op = LogicalOp::Explain(LogicalExplain {
input: Box::new(op),
analyze,
format: crate::expr::ExplainFormat::Json,
});
}
op
}
fn lower_sources(
what: Vec<surface::Expr>,
with: Option<&surface::With>,
for_update: bool,
) -> Lowered<LogicalOp> {
let leaves = what
.into_iter()
.map(|source| lower_source(source, with, for_update))
.collect::<Lowered<Vec<_>>>()?;
Ok(match leaves.len() {
1 => leaves.into_iter().next().expect("length checked"),
_ => LogicalOp::UnionAll(LogicalUnionAll {
inputs: leaves,
}),
})
}
fn lower_write_rows(what: Vec<surface::Expr>, with: Option<&surface::With>) -> Lowered<LogicalOp> {
lower_sources(what, with, false)
}
fn lower_data(data: surface::Data) -> Lowered<Option<LogicalData>> {
Ok(Some(match data {
surface::Data::EmptyExpression => return Ok(None),
surface::Data::SetExpression(assignments)
| surface::Data::UpdateExpression(assignments) => LogicalData::Set(
assignments
.into_iter()
.map(|a| {
Ok(LogicalAssignment {
place: a.place,
operator: a.operator,
value: lower_expr(a.value)?,
})
})
.collect::<Lowered<Vec<_>>>()?,
),
surface::Data::UnsetExpression(paths) => LogicalData::Unset(paths),
surface::Data::PatchExpression(expr) => LogicalData::Patch(lower_expr(expr)?),
surface::Data::MergeExpression(expr) => LogicalData::Merge(lower_expr(expr)?),
surface::Data::ReplaceExpression(expr) => LogicalData::Replace(lower_expr(expr)?),
surface::Data::ContentExpression(expr) => LogicalData::Content(lower_expr(expr)?),
surface::Data::SingleExpression(expr) => LogicalData::Single(lower_expr(expr)?),
surface::Data::ValuesExpression(rows) => LogicalData::Values(
rows.into_iter()
.map(|row| {
row.into_iter()
.map(|(path, value)| Ok((path, lower_expr(value)?)))
.collect::<Lowered<Vec<_>>>()
})
.collect::<Lowered<Vec<_>>>()?,
),
}))
}
fn lower_inserts(into: Option<surface::Expr>, data: surface::Data) -> Lowered<LogicalInserts> {
let rows = match data {
surface::Data::ValuesExpression(tuples) => LogicalInsertRows::Tuples(
tuples
.into_iter()
.map(|tuple| {
tuple
.into_iter()
.map(|(path, value)| Ok((path, lower_expr(value)?)))
.collect::<Lowered<Vec<_>>>()
})
.collect::<Lowered<Vec<_>>>()?,
),
surface::Data::SingleExpression(expr) => LogicalInsertRows::Value(lower_expr(expr)?),
surface::Data::EmptyExpression
| surface::Data::SetExpression(_)
| surface::Data::UnsetExpression(_)
| surface::Data::PatchExpression(_)
| surface::Data::MergeExpression(_)
| surface::Data::ReplaceExpression(_)
| surface::Data::ContentExpression(_)
| surface::Data::UpdateExpression(_) => {
return Err(NoLogicalForm::Unsupported(
"an INSERT whose data clause names no rows".to_string(),
));
}
};
Ok(LogicalInserts {
into: into.map(lower_expr).transpose()?,
rows,
})
}
fn lower_source(
source: surface::Expr,
with: Option<&crate::expr::With>,
for_update: bool,
) -> Lowered<LogicalOp> {
if let surface::Expr::Select(inner) = source {
let inner = lower_select(*inner)?;
return Ok(if for_update {
LogicalOp::Source(LogicalSource {
source: SourceRef::classify(LogicalExpr::Subquery(Box::new(inner))),
schema: None,
with: with.cloned(),
for_update: true,
})
} else {
LogicalOp::Subquery(LogicalSubquery {
input: Box::new(inner),
})
});
}
let source = lower_expr(source)?;
Ok(if is_value_literal(&source) {
LogicalOp::Values(LogicalValues {
written: matches!(source, LogicalExpr::Array(_)),
expr: source,
for_update,
})
} else {
LogicalOp::Source(LogicalSource {
source: SourceRef::classify(source),
schema: None,
with: with.cloned(),
for_update,
})
})
}
pub fn is_value_literal(expr: &LogicalExpr) -> bool {
match expr {
LogicalExpr::Array(_) => true,
LogicalExpr::Literal(literal) => match literal {
LogicalLiteral::String(_)
| LogicalLiteral::Integer(_)
| LogicalLiteral::Float(_)
| LogicalLiteral::Decimal(_)
| LogicalLiteral::BigDecimal(_)
| LogicalLiteral::I8(_)
| LogicalLiteral::U8(_)
| LogicalLiteral::I16(_)
| LogicalLiteral::U16(_)
| LogicalLiteral::I32(_)
| LogicalLiteral::U32(_)
| LogicalLiteral::U64(_)
| LogicalLiteral::F16(_)
| LogicalLiteral::F32(_)
| LogicalLiteral::Bool(_)
| LogicalLiteral::None
| LogicalLiteral::Null => true,
LogicalLiteral::Bytes(_)
| LogicalLiteral::Regex(_)
| LogicalLiteral::Geometry(_)
| LogicalLiteral::File(_)
| LogicalLiteral::Uuid(_)
| LogicalLiteral::Datetime(_)
| LogicalLiteral::Date(_)
| LogicalLiteral::Time(_)
| LogicalLiteral::Timestamp(_)
| LogicalLiteral::Interval(_)
| LogicalLiteral::Duration(_)
| LogicalLiteral::UnboundedRange => false,
},
LogicalExpr::Set(_)
| LogicalExpr::Object(_)
| LogicalExpr::RecordId(_)
| LogicalExpr::Param(_)
| LogicalExpr::Table(_)
| LogicalExpr::Mock(_)
| LogicalExpr::Constant(_)
| LogicalExpr::Field(_)
| LogicalExpr::Doc
| LogicalExpr::Current
| LogicalExpr::Access {
..
}
| LogicalExpr::Index {
..
}
| LogicalExpr::First(_)
| LogicalExpr::Last(_)
| LogicalExpr::Each(_)
| LogicalExpr::Flatten {
..
}
| LogicalExpr::Filter {
..
}
| LogicalExpr::Method {
..
}
| LogicalExpr::Destructure {
..
}
| LogicalExpr::Optional {
..
}
| LogicalExpr::Lookup {
..
}
| LogicalExpr::Recurse(_)
| LogicalExpr::RepeatRecurse(_)
| LogicalExpr::Broadcast {
..
}
| LogicalExpr::Prefix {
..
}
| LogicalExpr::Postfix {
..
}
| LogicalExpr::Invoke {
..
}
| LogicalExpr::Binary {
..
}
| LogicalExpr::Call(_)
| LogicalExpr::Closure(_)
| LogicalExpr::If(_)
| LogicalExpr::Throw(_)
| LogicalExpr::Break
| LogicalExpr::Continue
| LogicalExpr::SetField {
..
}
| LogicalExpr::Subquery(_) => false,
}
}
fn with_explain(op: LogicalOp, analyze: Option<bool>) -> LogicalOp {
match analyze {
Some(analyze) => LogicalOp::Explain(LogicalExplain {
input: Box::new(op),
analyze,
format: crate::expr::ExplainFormat::Json,
}),
None => op,
}
}
fn with_timeout(op: LogicalOp, timeout: surface::Expr) -> Lowered<LogicalOp> {
if is_absent(&timeout) {
return Ok(op);
}
Ok(LogicalOp::Timeout(LogicalTimeout {
input: Box::new(op),
timeout: lower_expr(timeout)?,
}))
}
fn is_absent(expr: &surface::Expr) -> bool {
matches!(expr, surface::Expr::Literal(surface::Literal::None))
}
fn lower_block(block: surface::Block) -> Lowered<LogicalOp> {
Ok(LogicalOp::Sequence(LogicalSequence {
stmts: block.0.into_iter().map(lower).collect::<Lowered<_>>()?,
}))
}
fn lower_exprs(exprs: Vec<surface::Expr>) -> Lowered<Vec<LogicalExpr>> {
exprs.into_iter().map(lower_expr).collect()
}
fn lower_fetchs(fetch: Option<surface::Fetchs>) -> Lowered<Vec<LogicalExpr>> {
fetch.map_or(Ok(Vec::new()), |fetchs| fetchs.into_iter().map(|f| lower_expr(f.0)).collect())
}
fn lower_if(stmt: IfelseStatement) -> Lowered<LogicalIf> {
Ok(LogicalIf {
branches: stmt
.exprs
.into_iter()
.map(|(cond, then)| Ok((lower_expr(cond)?, lower_expr(then)?)))
.collect::<Lowered<_>>()?,
otherwise: stmt.close.map(lower_expr).transpose()?,
})
}
fn lower_info(info: InfoStatement) -> Lowered<LogicalInfo> {
let version = |v: Option<surface::Expr>| v.map(lower_expr).transpose();
Ok(match info {
InfoStatement::Root(structure, v) => LogicalInfo::Root {
structure,
version: version(v)?,
},
InfoStatement::Ns(structure, v) => LogicalInfo::Ns {
structure,
version: version(v)?,
},
InfoStatement::Db(structure, v) => LogicalInfo::Db {
structure,
version: version(v)?,
},
InfoStatement::Tb(table, structure, v) => LogicalInfo::Table {
table: lower_expr(table)?,
structure,
version: version(v)?,
},
InfoStatement::User(user, base, structure) => LogicalInfo::User {
user: lower_expr(user)?,
base,
structure,
},
InfoStatement::Index(index, table, structure) => LogicalInfo::Index {
index: lower_expr(index)?,
table: lower_expr(table)?,
structure,
},
})
}
fn lower_literal(literal: surface::Literal) -> Lowered<LogicalExpr> {
let leaf = |literal| Ok(LogicalExpr::Literal(literal));
match literal {
surface::Literal::None => leaf(LogicalLiteral::None),
surface::Literal::Null => leaf(LogicalLiteral::Null),
surface::Literal::UnboundedRange => leaf(LogicalLiteral::UnboundedRange),
surface::Literal::Bool(x) => leaf(LogicalLiteral::Bool(x)),
surface::Literal::Float(x) => leaf(LogicalLiteral::Float(x)),
surface::Literal::Integer(x) => leaf(LogicalLiteral::Integer(x)),
surface::Literal::Decimal(x) => leaf(LogicalLiteral::Decimal(x)),
surface::Literal::BigDecimal(x) => leaf(LogicalLiteral::BigDecimal(x)),
surface::Literal::I8(x) => leaf(LogicalLiteral::I8(x)),
surface::Literal::U8(x) => leaf(LogicalLiteral::U8(x)),
surface::Literal::I16(x) => leaf(LogicalLiteral::I16(x)),
surface::Literal::U16(x) => leaf(LogicalLiteral::U16(x)),
surface::Literal::I32(x) => leaf(LogicalLiteral::I32(x)),
surface::Literal::U32(x) => leaf(LogicalLiteral::U32(x)),
surface::Literal::U64(x) => leaf(LogicalLiteral::U64(x)),
surface::Literal::F16(x) => leaf(LogicalLiteral::F16(x)),
surface::Literal::F32(x) => leaf(LogicalLiteral::F32(x)),
surface::Literal::Duration(x) => leaf(LogicalLiteral::Duration(x)),
surface::Literal::String(x) => leaf(LogicalLiteral::String(x)),
surface::Literal::Datetime(x) => leaf(LogicalLiteral::Datetime(x)),
surface::Literal::Date(x) => leaf(LogicalLiteral::Date(x)),
surface::Literal::Time(x) => leaf(LogicalLiteral::Time(x)),
surface::Literal::Timestamp(x) => leaf(LogicalLiteral::Timestamp(x)),
surface::Literal::Interval(x) => leaf(LogicalLiteral::Interval(x)),
surface::Literal::Uuid(x) => leaf(LogicalLiteral::Uuid(x)),
surface::Literal::Regex(x) => leaf(LogicalLiteral::Regex(x)),
surface::Literal::Geometry(x) => leaf(LogicalLiteral::Geometry(x)),
surface::Literal::File(x) => leaf(LogicalLiteral::File(x)),
surface::Literal::Bytes(x) => leaf(LogicalLiteral::Bytes(x)),
surface::Literal::RecordId(rid) => {
Ok(LogicalExpr::RecordId(Box::new(lower_record_id(rid)?)))
}
surface::Literal::Array(items) => Ok(LogicalExpr::Array(lower_exprs(items)?)),
surface::Literal::Set(items) => Ok(LogicalExpr::Set(lower_exprs(items)?)),
surface::Literal::Object(entries) => {
if let Some(geometry) = crate::parser::geometry::collect_geometry(&entries) {
return leaf(LogicalLiteral::Geometry(geometry));
}
Ok(LogicalExpr::Object(lower_entries(entries)?))
}
}
}
fn lower_entries(
entries: Vec<surface::literal::ObjectEntry>,
) -> Lowered<Vec<(String, LogicalExpr)>> {
entries.into_iter().map(|e| Ok((e.key.into_string(), lower_expr(e.value)?))).collect()
}
fn lower_record_id(rid: surface::RecordIdLit) -> Lowered<LogicalRecordIdLit> {
Ok(LogicalRecordIdLit {
table: rid.table,
key: lower_record_id_key(rid.key)?,
})
}
fn lower_record_id_key(key: surface::RecordIdKeyLit) -> Lowered<LogicalRecordIdKey> {
Ok(match key {
surface::RecordIdKeyLit::Number(x) => LogicalRecordIdKey::Number(x),
surface::RecordIdKeyLit::String(x) => LogicalRecordIdKey::String(x),
surface::RecordIdKeyLit::Uuid(x) => LogicalRecordIdKey::Uuid(x),
surface::RecordIdKeyLit::Array(items) => LogicalRecordIdKey::Array(lower_exprs(items)?),
surface::RecordIdKeyLit::Object(entries) => {
LogicalRecordIdKey::Object(lower_entries(entries)?)
}
surface::RecordIdKeyLit::Generate(generator) => LogicalRecordIdKey::Generate(generator),
surface::RecordIdKeyLit::Range(range) => {
LogicalRecordIdKey::Range(Box::new(lower_record_id_range(*range)?))
}
})
}
fn lower_record_id_range(range: surface::RecordIdKeyRangeLit) -> Lowered<LogicalRecordIdKeyRange> {
let bound = |b: Bound<surface::RecordIdKeyLit>| {
Ok(match b {
Bound::Included(key) => Bound::Included(lower_record_id_key(key)?),
Bound::Excluded(key) => Bound::Excluded(lower_record_id_key(key)?),
Bound::Unbounded => Bound::Unbounded,
})
};
Ok(LogicalRecordIdKeyRange {
start: bound(range.start)?,
end: bound(range.end)?,
})
}
pub(crate) enum Step {
Access(Strand),
Index(LogicalExpr),
First,
Last,
Each,
Flatten,
Filter(LogicalExpr),
Method(Strand, Vec<LogicalExpr>),
Destructure(Vec<LogicalDestructureField>),
Optional,
Lookup(Box<LogicalLookup>),
Recurse(Recurse, Option<LogicalExpr>, Option<LogicalRecurseInstruction>),
RepeatRecurse,
}
impl Step {
fn is_mapping(&self) -> bool {
matches!(self, Step::Access(_) | Step::Each | Step::Destructure(_))
}
}
#[derive(Clone, Copy, PartialEq, Eq)]
pub(crate) enum PathMode {
Continuation,
Plain,
}
#[derive(Clone, Copy, PartialEq, Eq)]
enum Prev {
Lookup,
Flatten,
Filter,
Other,
}
fn lower_idiom(idiom: surface::Idiom) -> Lowered<LogicalExpr> {
let mut parts = restart_at_root(idiom.0).into_iter().peekable();
let base = match parts.peek() {
Some(surface::Part::Field(_)) => match parts.next() {
Some(surface::Part::Field(name)) => LogicalExpr::Field(name),
_ => unreachable!("peeked a field"),
},
Some(surface::Part::Start(_)) => match parts.next() {
Some(surface::Part::Start(start)) => lower_expr(start)?,
_ => unreachable!("peeked a start"),
},
Some(surface::Part::Doc) => {
parts.next();
LogicalExpr::Doc
}
Some(_) | None => LogicalExpr::Current,
};
let steps = lower_steps(parts)?;
Ok(fold_steps(base, steps, PathMode::Continuation))
}
fn lower_body(idiom: surface::Idiom) -> Lowered<LogicalExpr> {
let mut parts = restart_at_root(idiom.0).into_iter().peekable();
let base = match parts.peek() {
Some(surface::Part::Start(_)) => match parts.next() {
Some(surface::Part::Start(start)) => lower_expr(start)?,
_ => unreachable!("peeked a start"),
},
Some(surface::Part::Doc) => {
parts.next();
LogicalExpr::Doc
}
Some(_) | None => LogicalExpr::Current,
};
let steps = lower_steps(parts)?;
Ok(fold_steps(base, steps, PathMode::Plain))
}
fn restart_at_root(mut parts: Vec<surface::Part>) -> Vec<surface::Part> {
match parts
.iter()
.rposition(|part| matches!(part, surface::Part::Start(_) | surface::Part::Doc))
{
Some(at) if at > 0 => parts.split_off(at),
_ => parts,
}
}
fn lower_steps(parts: impl Iterator<Item = surface::Part>) -> Lowered<VecDeque<Step>> {
parts
.map(|part| {
Ok(match part {
surface::Part::All => Step::Each,
surface::Part::Flatten => Step::Flatten,
surface::Part::Last => Step::Last,
surface::Part::First => Step::First,
surface::Part::Field(name) => Step::Access(name),
surface::Part::Where(expr) => Step::Filter(lower_expr(expr)?),
surface::Part::Lookup(lookup) => Step::Lookup(Box::new(lower_lookup(*lookup)?)),
surface::Part::Value(expr) => Step::Index(lower_expr(expr)?),
surface::Part::Method(name, args) => Step::Method(name, lower_exprs(args)?),
surface::Part::Destructure(parts) => Step::Destructure(lower_destructure(parts)?),
surface::Part::Optional => Step::Optional,
surface::Part::Recurse(recurse, nested, instruction) => Step::Recurse(
recurse,
nested.map(lower_body).transpose()?,
instruction.map(lower_instruction).transpose()?,
),
surface::Part::RepeatRecurse => Step::RepeatRecurse,
surface::Part::Start(_) | surface::Part::Doc => {
return Err(NoLogicalForm::Unsupported(
"a root part that is not the first of its path".to_string(),
));
}
})
})
.collect()
}
pub(crate) fn fold_steps(base: LogicalExpr, steps: VecDeque<Step>, mode: PathMode) -> LogicalExpr {
fold_from(base, steps, mode, Prev::Other, false)
}
fn fold_from(
mut base: LogicalExpr,
mut steps: VecDeque<Step>,
mode: PathMode,
mut prev: Prev,
mut array_from_lookup: bool,
) -> LogicalExpr {
while let Some(step) = steps.pop_front() {
match step {
Step::Optional => {
let then = fold_steps(LogicalExpr::Current, steps, PathMode::Plain);
return LogicalExpr::Optional {
base: Box::new(base),
then: Box::new(then),
};
}
Step::Recurse(recurse, Some(nested), instruction) => {
base = LogicalExpr::Recurse(Box::new(LogicalRecurse {
base,
recurse,
path: Some(LogicalRecursePath::Nested(nested)),
instruction,
}));
prev = Prev::Other;
array_from_lookup = false;
}
Step::Recurse(recurse, None, instruction) => {
let suffix = match steps.iter().position(|s| matches!(s, Step::RepeatRecurse)) {
Some(pos) => steps.split_off(pos + 1),
None => VecDeque::new(),
};
let path = if steps.is_empty() {
None
} else {
Some(LogicalRecursePath::Trailing(fold_steps(
LogicalExpr::Current,
steps,
PathMode::Plain,
)))
};
base = LogicalExpr::Recurse(Box::new(LogicalRecurse {
base,
recurse,
path,
instruction,
}));
steps = suffix;
prev = Prev::Other;
array_from_lookup = false;
}
Step::Lookup(first) => {
let mut lookups = vec![*first];
while let Some(Step::Lookup(_)) = steps.front() {
if let Some(Step::Lookup(lookup)) = steps.pop_front() {
lookups.push(*lookup);
}
}
let fused = lookups.len() > 1;
let followed = !steps.is_empty();
let continues = mode == PathMode::Continuation
&& !matches!(prev, Prev::Lookup | Prev::Flatten)
&& (followed || fused);
if continues {
let inner = apply_lookups(LogicalExpr::Current, lookups, &steps);
let body = fold_from(inner, steps, mode, Prev::Lookup, true);
return LogicalExpr::Broadcast {
base: Box::new(base),
body: Box::new(body),
flatten: array_from_lookup,
};
}
base = apply_lookups(base, lookups, &steps);
prev = Prev::Lookup;
array_from_lookup = true;
}
step @ (Step::Access(_) | Step::Each | Step::Destructure(_)) => {
let broadcast = mode == PathMode::Continuation
&& !steps.is_empty()
&& !steps.iter().all(Step::is_mapping);
if broadcast {
let inner = apply_step(LogicalExpr::Current, step);
let body = fold_from(inner, steps, mode, Prev::Other, false);
return LogicalExpr::Broadcast {
base: Box::new(base),
body: Box::new(body),
flatten: false,
};
}
base = apply_step(base, step);
prev = Prev::Other;
array_from_lookup = false;
}
Step::Filter(predicate) => {
base = LogicalExpr::Filter {
base: Box::new(base),
predicate: Box::new(predicate),
};
prev = Prev::Filter;
}
Step::Flatten => {
base = LogicalExpr::Flatten {
base: Box::new(base),
explicit: true,
};
prev = Prev::Flatten;
array_from_lookup = true;
}
step @ (Step::Index(_)
| Step::First
| Step::Last
| Step::Method(..)
| Step::RepeatRecurse) => {
base = apply_step(base, step);
prev = Prev::Other;
array_from_lookup = false;
}
}
}
base
}
fn apply_lookups(
mut base: LogicalExpr,
lookups: Vec<LogicalLookup>,
rest: &VecDeque<Step>,
) -> LogicalExpr {
for lookup in lookups {
base = LogicalExpr::Lookup {
base: Box::new(base),
lookup: Box::new(lookup),
};
}
if let Some(Step::Filter(_)) = rest.front() {
base = LogicalExpr::Flatten {
base: Box::new(base),
explicit: false,
};
}
base
}
fn apply_step(base: LogicalExpr, step: Step) -> LogicalExpr {
let base = Box::new(base);
match step {
Step::Access(field) => LogicalExpr::Access {
base,
field,
},
Step::Index(index) => LogicalExpr::Index {
base,
index: Box::new(index),
},
Step::First => LogicalExpr::First(base),
Step::Last => LogicalExpr::Last(base),
Step::Each => LogicalExpr::Each(base),
Step::Flatten => LogicalExpr::Flatten {
base,
explicit: true,
},
Step::Filter(predicate) => LogicalExpr::Filter {
base,
predicate: Box::new(predicate),
},
Step::Method(name, args) => LogicalExpr::Method {
base,
name,
args,
},
Step::Destructure(fields) => LogicalExpr::Destructure {
base,
fields,
},
Step::RepeatRecurse => LogicalExpr::RepeatRecurse(base),
Step::Lookup(lookup) => LogicalExpr::Lookup {
base,
lookup,
},
Step::Recurse(recurse, nested, instruction) => {
LogicalExpr::Recurse(Box::new(LogicalRecurse {
base: *base,
recurse,
path: nested.map(LogicalRecursePath::Nested),
instruction,
}))
}
Step::Optional => LogicalExpr::Optional {
base,
then: Box::new(LogicalExpr::Current),
},
}
}
fn lower_output_path(idiom: surface::Idiom) -> Lowered<OutputPath> {
Ok(lower_idiom(idiom)?.output_path())
}
pub(crate) fn lower_destructure(
parts: Vec<surface::part::DestructurePart>,
) -> Lowered<Vec<LogicalDestructureField>> {
parts
.into_iter()
.map(|part| {
Ok(match part {
surface::part::DestructurePart::All(name) => LogicalDestructureField::All(name),
surface::part::DestructurePart::Field(name) => LogicalDestructureField::Field(name),
surface::part::DestructurePart::Aliased(name, idiom) => {
LogicalDestructureField::Aliased(name, lower_body(idiom)?)
}
surface::part::DestructurePart::Destructure(name, parts) => {
LogicalDestructureField::Destructure(name, lower_destructure(parts)?)
}
surface::part::DestructurePart::Rest => LogicalDestructureField::Rest,
})
})
.collect()
}
pub(crate) fn lower_instruction(
instruction: surface::part::RecurseInstruction,
) -> Lowered<LogicalRecurseInstruction> {
Ok(match instruction {
surface::part::RecurseInstruction::Path {
inclusive,
} => LogicalRecurseInstruction::Path {
inclusive,
},
surface::part::RecurseInstruction::Collect {
inclusive,
} => LogicalRecurseInstruction::Collect {
inclusive,
},
surface::part::RecurseInstruction::Shortest {
expects,
inclusive,
} => LogicalRecurseInstruction::Shortest {
expects: lower_expr(expects)?,
inclusive,
},
})
}
pub(crate) fn lower_lookup(lookup: surface::lookup::Lookup) -> Lowered<LogicalLookup> {
Ok(LogicalLookup {
kind: lookup.kind,
expr: lookup.expr.map(lower_fields).transpose()?,
only: lookup.only,
what: lookup.what.into_iter().map(lower_lookup_subject).collect::<Lowered<_>>()?,
cond: lookup.cond.map(|c| lower_expr(c.0)).transpose()?,
split: lookup
.split
.map(|s| s.0.into_iter().map(|x| lower_idiom(x.0)).collect::<Lowered<_>>())
.transpose()?,
group: lookup
.group
.map(|g| g.0.into_iter().map(|x| lower_idiom(x.0)).collect::<Lowered<_>>())
.transpose()?,
order: lookup.order.map(lower_ordering).transpose()?,
limit: lookup.limit.map(|l| lower_expr(l.0)).transpose()?,
start: lookup.start.map(|s| lower_expr(s.0)).transpose()?,
alias: lookup.alias.map(lower_output_path).transpose()?,
trace: crate::expr::logical::LookupTrace::None,
})
}
fn lower_lookup_subject(subject: surface::lookup::LookupSubject) -> Lowered<LogicalLookupSubject> {
Ok(match subject {
surface::lookup::LookupSubject::Table {
table,
referencing_field,
} => LogicalLookupSubject::Table {
table,
referencing_field,
},
surface::lookup::LookupSubject::Range {
table,
range,
referencing_field,
} => LogicalLookupSubject::Range {
table,
range: lower_record_id_range(range)?,
referencing_field,
},
})
}
pub fn lower_fields(fields: impl Into<surface::Fields>) -> Lowered<LogicalFields> {
Ok(match fields.into() {
surface::Fields::Value(selector) => LogicalFields::Value {
expr: lower_expr(selector.expr)?,
alias: selector.alias.map(lower_output_path).transpose()?,
},
surface::Fields::Select(fields) => LogicalFields::Select(
fields
.into_iter()
.map(|field| {
Ok(match field {
surface::Field::All => LogicalField::All,
surface::Field::Single(selector) => lower_field(selector)?,
})
})
.collect::<Lowered<_>>()?,
),
})
}
fn lower_field(selector: surface::field::Selector) -> Lowered<LogicalField> {
let written = match &selector.alias {
Some(_) => None,
None => Some(selector.expr.to_sql()),
};
let expr = lower_expr(selector.expr)?;
let alias = match selector.alias {
Some(alias) => Some(lower_output_path(alias)?),
None if expr.output_name_renders_a_statement() => written.map(OutputPath::field),
None => None,
};
Ok(LogicalField::user(expr, alias))
}
fn lower_ordering(ordering: surface::order::Ordering) -> Lowered<LogicalOrdering> {
Ok(match ordering {
surface::order::Ordering::Random => LogicalOrdering::Random,
surface::order::Ordering::Order(list) => LogicalOrdering::Order(
list.0
.into_iter()
.map(|order| {
Ok(LogicalOrder {
value: lower_idiom(order.value)?,
collate: order.collate,
numeric: order.numeric,
direction: order.direction,
})
})
.collect::<Lowered<_>>()?,
),
})
}
fn lower_postfix(expr: LogicalExpr, op: surface::PostfixOperator) -> Lowered<LogicalExpr> {
let expr = Box::new(expr);
Ok(match op {
surface::PostfixOperator::Range => LogicalExpr::Postfix {
expr,
op: LogicalPostfixOperator::Range,
},
surface::PostfixOperator::RangeSkip => LogicalExpr::Postfix {
expr,
op: LogicalPostfixOperator::RangeSkip,
},
surface::PostfixOperator::MethodCall(name, args) => LogicalExpr::Method {
base: expr,
name: name.into(),
args: lower_exprs(args)?,
},
surface::PostfixOperator::Call(args) => LogicalExpr::Invoke {
target: expr,
args: lower_exprs(args)?,
},
})
}
#[cfg(test)]
mod tests {
use std::collections::BTreeSet;
use surrealdb_types::ToSql;
use super::*;
use crate::expr as sql;
use crate::expr::logical::LogicalRecursePath;
use crate::parser::TopLevelExpr;
fn shape(op: &LogicalOp) -> Vec<&'static str> {
let mut out = vec![op.name()];
let mut current = op;
while let Some(child) = current.children().first() {
out.push(child.name());
current = child;
}
out
}
fn parse(sql: &str) -> sql::Expr {
let ast = crate::parser::parse(sql).expect("test statement should parse");
let top = ast.expressions.into_iter().next().expect("one statement");
let TopLevelExpr::Expr(expr) = top else {
panic!("expected a bare expression");
};
expr
}
fn lower_sql(sql: &str) -> LogicalOp {
lower(parse(sql)).expect("statement should lower")
}
#[test]
fn control_flow_in_statement_position_lowers_to_operators() {
assert_eq!(
lower_sql("IF $a { 1 } ELSE { 2 }").to_string(),
"If[$a ELSE]\n Sequence\n Eval[1]\n Sequence\n Eval[2]"
);
assert_eq!(lower_sql("THROW 'x'").to_string(), "Throw['x']");
assert_eq!(lower_sql("BREAK").to_string(), "Break");
assert_eq!(lower_sql("CONTINUE").to_string(), "Continue");
assert_eq!(
lower_sql("{ IF $a { BREAK }; CONTINUE; THROW 1 }").to_string(),
"Sequence\n If[$a]\n Sequence\n Break\n Continue\n Throw[1]"
);
assert_eq!(
lower_sql("FOR $x IN [1] { IF $x { CONTINUE } }").to_string(),
"Foreach[$x IN [1]]\n Sequence\n If[$x]\n Sequence\n Continue"
);
assert_eq!(
lower_sql("LET $v = IF $a THEN 1 END").to_string(),
"Let[$v]\n If[$a]\n Eval[1]"
);
assert_eq!(
lower_sql("IF $a THEN IF $b THEN 1 ELSE 2 END END").to_string(),
"If[$a]\n If[$b ELSE]\n Eval[1]\n Eval[2]"
);
}
#[test]
fn a_statement_if_with_a_let_arm_stays_an_expression() {
assert!(matches!(lower_sql("IF $c THEN (LET $x = 1) ELSE 3 END"), LogicalOp::Eval(_)));
assert!(matches!(lower_sql("IF $c THEN 1 ELSE (LET $x = 1) END"), LogicalOp::Eval(_)));
assert!(matches!(
lower_sql("IF $t THEN 1 ELSE IF $c THEN (LET $x = 1) ELSE 3 END"),
LogicalOp::Eval(_)
));
assert!(matches!(lower_sql("IF $t { LET $x = 1; } ELSE { 3 }"), LogicalOp::If(_)));
}
#[test]
fn control_flow_in_value_position_stays_an_expression() {
assert_eq!(
lower_sql("RETURN IF $a THEN 1 END").to_string(),
"Return\n Eval[IF $a THEN 1 END]"
);
assert_eq!(lower_sql("RETURN THROW 'x'").to_string(), "Return\n Eval[THROW 'x']");
assert!(matches!(lower_sql("[IF $a THEN 1 END]"), LogicalOp::Eval(_)));
}
#[test]
fn a_statement_if_has_its_value_position_form() {
let LogicalOp::If(ifs) = lower_sql("IF $a { 1 } ELSE IF $b { 2 }") else {
panic!("an IF operator");
};
let scalar = ifs.to_scalar();
assert_eq!(scalar.branches.len(), 2);
assert!(
scalar.branches.iter().all(
|(_, arm)| matches!(arm, LogicalExpr::Subquery(block) if block.name() == "Sequence")
),
"a block arm is the subquery of its block"
);
assert!(scalar.otherwise.is_none());
}
fn expr(sql: &str) -> LogicalExpr {
let sql::Expr::Return(out) = parse(&format!("RETURN {sql}")) else {
panic!("expected a RETURN");
};
lower_expr(out.what).expect("expression should lower")
}
#[test]
fn a_postfix_call_lowers_to_the_node_of_its_construct() {
let one = || {
let sql::Expr::Return(out) = parse("RETURN 1") else {
panic!("expected a RETURN");
};
out.what
};
let postfix = |op| {
lower_expr(sql::Expr::Postfix {
expr: Box::new(one()),
op,
})
.expect("expression should lower")
};
let method = postfix(sql::PostfixOperator::MethodCall("len".to_owned(), vec![]));
assert!(
matches!(
&method,
LogicalExpr::Method { name, args, .. } if name.as_str() == "len" && args.is_empty()
),
"{method:?}"
);
assert!(method.to_sql().ends_with(".len()"), "{}", method.to_sql());
let call = postfix(sql::PostfixOperator::Call(vec![one()]));
assert!(matches!(&call, LogicalExpr::Invoke { args, .. } if args.len() == 1), "{call:?}");
assert_eq!(call.to_sql(), "(1)(1)");
let range = postfix(sql::PostfixOperator::Range);
assert!(matches!(
&range,
LogicalExpr::Postfix {
op: LogicalPostfixOperator::Range,
..
}
));
assert_eq!(range.to_sql(), "1..");
}
#[test]
fn a_bare_select_is_a_projection_over_a_source() {
assert_eq!(shape(&lower_sql("SELECT * FROM t")), ["Project", "Source"]);
}
#[test]
fn a_where_clause_becomes_a_filter_under_the_projection() {
assert_eq!(
shape(&lower_sql("SELECT * FROM t WHERE a > 1")),
["Project", "Filter", "Source"]
);
}
#[test]
fn the_pipeline_order_matches_the_physical_planner() {
assert_eq!(
shape(&lower_sql(
"SELECT d FROM t WHERE b > 1 SPLIT d ORDER BY d LIMIT 1 FETCH f TIMEOUT 1s"
)),
["Timeout", "Fetch", "Project", "Limit", "Sort", "Split", "Filter", "Source"]
);
}
#[test]
fn a_grouped_pipeline_puts_the_aggregation_below_the_sort() {
assert_eq!(
shape(&lower_sql(
"SELECT d FROM t WHERE b > 1 GROUP BY d ORDER BY d LIMIT 1 FETCH f TIMEOUT 1s"
)),
["Timeout", "Fetch", "Limit", "Sort", "Aggregate", "Filter", "Source"]
);
}
#[test]
fn several_sources_concatenate() {
let op = lower_sql("SELECT * FROM a, b");
assert_eq!(shape(&op), ["Project", "UnionAll", "Source"]);
let LogicalOp::Project(LogicalProject {
input,
..
}) = &op
else {
panic!("expected a projection");
};
assert_eq!(input.children().len(), 2);
}
#[test]
fn a_literal_source_is_values_and_a_record_id_is_not() {
assert_eq!(shape(&lower_sql("SELECT * FROM [1, 2, 3]")), ["Project", "Values"]);
assert_eq!(shape(&lower_sql("SELECT * FROM 'x'")), ["Project", "Values"]);
assert_eq!(shape(&lower_sql("SELECT * FROM t:1")), ["Project", "Source"]);
let mixed = lower_sql("SELECT * FROM t, [1]");
let names: Vec<_> = mixed.children()[0].children().iter().map(LogicalOp::name).collect();
assert_eq!(names, ["Source", "Values"]);
}
#[test]
fn a_source_is_classified_by_its_syntax() {
fn source_of(sql: &str) -> SourceRef {
let op = lower_sql(sql);
let LogicalOp::Project(LogicalProject {
input,
..
}) = op
else {
panic!("expected a projection");
};
let LogicalOp::Source(LogicalSource {
source,
..
}) = *input
else {
panic!("expected a source");
};
source
}
assert!(matches!(source_of("SELECT * FROM t"), SourceRef::Table(_)));
assert!(matches!(source_of("SELECT * FROM t:1"), SourceRef::RecordId(_)));
assert!(matches!(source_of("SELECT * FROM t:1..5"), SourceRef::RecordId(_)));
assert!(matches!(source_of("SELECT * FROM |t:3|"), SourceRef::Mock(_)));
assert!(matches!(source_of("SELECT * FROM $p"), SourceRef::Param(_)));
assert!(matches!(source_of("SELECT * FROM a->likes->b"), SourceRef::Dynamic(_)));
assert!(matches!(source_of("SELECT * FROM { a: 1 }"), SourceRef::Dynamic(_)));
}
#[test]
fn a_subquery_source_is_lowered_eagerly() {
assert_eq!(
shape(&lower_sql("SELECT * FROM (SELECT * FROM t WHERE a) WHERE b")),
["Project", "Filter", "Subquery", "Project", "Filter", "Source"]
);
}
#[test]
fn a_subquery_source_under_for_update_is_a_locked_dynamic_source() {
let op = lower_sql("SELECT * FROM (SELECT * FROM t:1) FOR UPDATE");
assert_eq!(shape(&op), ["Project", "Source"]);
let LogicalOp::Project(LogicalProject {
input,
..
}) = op
else {
panic!("expected a projection");
};
let LogicalOp::Source(LogicalSource {
source,
for_update,
..
}) = *input
else {
panic!("expected a source");
};
assert!(for_update, "the clause is carried on the source");
let SourceRef::Dynamic(LogicalExpr::Subquery(nested)) = source else {
panic!("expected the nested plan as a dynamic scalar, got {source:?}");
};
assert_eq!(shape(&nested), ["Project", "Source"]);
}
#[test]
fn the_with_hint_is_attached_to_every_stored_source() {
let op = lower_sql("SELECT * FROM a, b, [1] WITH NOINDEX");
let leaves = op.children()[0].children();
let names: Vec<_> = leaves.iter().map(LogicalOp::name).collect();
assert_eq!(names, ["Source", "Source", "Values"]);
for leaf in leaves {
if let LogicalOp::Source(LogicalSource {
with,
..
}) = leaf
{
assert!(with.is_some(), "stored sources carry the hint");
}
}
}
#[test]
fn a_grouped_query_projects_in_the_aggregation_and_omits_the_projection() {
assert_eq!(shape(&lower_sql("SELECT count() FROM t GROUP ALL")), ["Aggregate", "Source"]);
assert_eq!(
shape(&lower_sql("SELECT count() OMIT x FROM t GROUP ALL")),
["Project", "Aggregate", "Source"]
);
}
#[test]
fn an_absent_version_or_timeout_contributes_no_operator() {
assert_eq!(shape(&lower_sql("SELECT * FROM t")), ["Project", "Source"]);
}
#[test]
fn only_wraps_the_whole_pipeline() {
assert_eq!(shape(&lower_sql("SELECT * FROM ONLY t:1")), ["Only", "Project", "Source"]);
}
#[test]
fn a_where_clause_is_a_user_filter_never_a_permission_filter() {
let op = lower_sql("SELECT * FROM t WHERE a > 1");
assert!(op.any(|n| matches!(n, LogicalOp::Filter(_))));
assert!(!op.any(|n| matches!(n, LogicalOp::PermissionFilter(_))));
}
#[test]
fn every_scalar_in_a_rendered_plan_is_surrealql() {
let rendered = lower_sql("SELECT a FROM t WHERE b > 1 LIMIT 2").to_string();
assert!(rendered.contains("b > 1"), "predicate should render as SurrealQL: {rendered}");
assert!(rendered.contains("LIMIT 2"), "limit should render: {rendered}");
assert!(rendered.contains("Source[t]"), "source should name its table: {rendered}");
}
const SCALAR_CORPUS: &[&str] = &[
"NONE",
"NULL",
"true",
"1",
"-1",
"1.5",
"1.5dec",
"'x'",
"d'2024-01-01T00:00:00Z'",
"1h30m",
"u'018e3b7a-0000-7000-8000-000000000000'",
"/a+/",
"..",
"[1, 2, 'x']",
"[]",
"{ a: 1, b: [2] }",
"{ }",
"{ type: 'Point', coordinates: [1.0, 2.0] }",
"t:1",
"t:['a', 1]",
"t:{ a: 1, b: 'x' }",
"t:1..5",
"t:1>..=5",
"t:..5",
"t:uuid()",
"t:⟨a b⟩",
"a.b[0].c[$]",
"a[WHERE b > 1].c",
"a.*",
"a[*]",
"a.{ b, c: d.e }",
"a.{ b.{ c } }",
"$p.name",
"(1 + 2).b",
"a.b.{2..}(.c)",
"a.{1..3+collect}",
"a.{..+path+inclusive}",
"a.?.b",
"->likes->person",
"->(likes WHERE x > 1 AS l)",
"<-knows<-person.name",
"<->knows",
"->likes:1..5",
"<~refs",
"->(likes, follows)",
"count(a, 'x')",
"fn::custom(1)",
"math::PI",
"a.map(|$v| $v + 1)",
"a.len()",
"$f(1)",
"|$x: int| $x + 1",
"|$x: int, $y: string| $x",
"|| 1",
"|$x: int| a + $x",
"IF a THEN 1 ELSE 2 END",
"IF a THEN 1 ELSE IF b THEN 2 ELSE 3 END",
"IF a THEN 1 END",
"[IF a THEN 1 END]",
"THROW 'x'",
"BREAK",
"CONTINUE",
"!a",
"-a",
"+a",
"-(1 + 2) * 3",
"-(-1)",
"<int> a",
"<string> (a + b)",
"..5",
"..=5",
"a..",
"a>..",
"a AND b",
"a OR 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 IN b",
"a NOT IN b",
"a ALLINSIDE b",
"a ANYINSIDE b",
"a NONEINSIDE b",
"a OUTSIDE b",
"a INTERSECTS b",
"a @@ 'x'",
"a @1@ 'x'",
"a <|3|> b",
"a <|3,COSINE|> b",
"a + b",
"a - b",
"a * b",
"a / b",
"a % b",
"a ** b",
"a..b",
"a..=b",
"a>..b",
"a>..=b",
"a + b * c",
"(a + b) * c",
"a - (b - c)",
"a ** (b ** c)",
"(a ** b) ** c",
"a AND (b OR c)",
"(a = b) = c",
];
#[test]
fn scalar_rendering_preserves_precedence_and_normalized_geometry() {
for sql in SCALAR_CORPUS {
let sql::Expr::Return(out) = parse(&format!("RETURN {sql}")) else {
panic!("expected a RETURN");
};
let expected = match out.what.as_static_value() {
Some(crate::val::Value::Geometry(geometry)) => {
surface::Literal::Geometry(geometry).to_sql()
}
_ => out.what.to_sql(),
};
let lowered = lower_expr(out.what).expect("expression should lower");
assert_eq!(
lowered.to_sql(),
expected,
"rendering of `{sql}` differs from the expression layer"
);
}
}
const IDIOM_CORPUS: &[&str] = &[
"a",
"a.b",
"a.b.c",
"a[0]",
"a[$]",
"a[1]",
"a[-1]",
"a[1..3]",
"a[b]",
"a[$i]",
"a.*",
"a[*]",
"a.*.b",
"a.b.*",
"a.*.*",
"a.*[0]",
"a…",
"a...",
"a.b…",
"a[WHERE b > 1]",
"a[WHERE b > 1].c",
"a[WHERE b > 1][0].c",
"a.b[0]",
"a.b[0].c",
"a.b[0].c[0]",
"a.b.c[0]",
"a.b.c.d[WHERE e][$]",
"a.len()",
"a.b.len()",
"a.slice(1, 2).c",
"a.map(|$v| $v.b)",
"a.{ b }",
"a.{ b, c }",
"a.{ b.* }",
"a.{ b: c }",
"a.{ b: c.d }",
"a.{ b: c[0].d }",
"a.{ b: $this.c }",
"a.{ b: c * 2 }",
"a.{ b: (c + 1).d }",
"a.{ b: [1, 2][0] }",
"a.{ b: ->likes->person }",
"a.{ b.{ c, d: e } }",
"a.{ b, c: d.e[0] }.f",
"a.{ b }[0]",
"a.?",
"a.?.b",
"a.?.b.c",
"a.?.b[0]",
"a.?.b.?.c",
"a.b.?.c[0]",
"a[0].?.b",
"->likes",
"->likes->person",
"->likes->person->follows",
"->likes->person.name",
"->likes->person.name[0]",
"->likes[WHERE x > 1]",
"->likes[WHERE x > 1]->person",
"->likes[WHERE x > 1]->person.name",
"->likes…->person",
"->likes...->person",
"->likes[0]",
"->likes.out",
"->likes.out->person",
"<-knows",
"<-knows<-person",
"<->knows",
"<->knows<->person",
"<~refs",
"<~refs<~more",
"<~(refs FIELD a)",
"->?",
"->(likes, follows)",
"->(likes WHERE x > 1)",
"->(likes WHERE x > 1 AS l)",
"->(likes AS l)->person",
"->(likes AS l).name",
"->likes:1..5",
"->likes:1..",
"->likes:..5",
"->(likes:1..)",
"->(SELECT * FROM likes)",
"->(SELECT VALUE out FROM likes WHERE x > 1 ORDER BY y LIMIT 1 START 1)",
"->(SELECT VALUE out FROM ONLY likes)",
"->(SELECT * FROM likes SPLIT ON a)",
"->(SELECT * FROM likes GROUP BY b)",
"->(SELECT * FROM likes GROUP ALL)",
"a->likes",
"a->likes->person",
"a->likes->person.name",
"a.b->likes",
"a.b->likes->person[0]",
"a.{..}",
"a.{2}",
"a.{1..3}",
"a.{..3}",
"a.{2..}",
"a.{..}(.b)",
"a.{..}(.b.c)",
"a.{..}(->knows->person)",
"a.{..}(->knows->person).name",
"a.{..}.b",
"a.{..}.b.c",
"a.{..}->knows->person",
"a.{..}->knows->person.name",
"a.{..}.b.@",
"a.{..}.b.@.c",
"a.{..}.{ name, friends: ->knows->person.@ }",
"a.{1..3}(.{ name, friends: ->knows->person.@ })",
"a.{..+path}(->knows->person)",
"a.{..+path+inclusive}(->knows->person)",
"a.{..+collect}(->knows->person)",
"a.{..+collect+inclusive}(->knows->person)",
"a.{..+shortest=person:1}(->knows->person)",
"a.{..+shortest=person:1+inclusive}(->knows->person)",
"a.{..+shortest=$target}(->knows->person)",
"@.a",
"@.a.b[0]",
"$p.a",
"$p.a.b",
"$p.a[0]",
"$p.a[0].b",
"$p->likes->person",
"$p[0]",
"$p[WHERE x]",
"$p.?.a",
"$p.{..}(.a)",
"(1 + 2).b",
"(-1).abs()",
"(-1.5).abs()",
"(-1.5dec).abs()",
"(!a).b",
"(a..).len()",
"(a.b).c[0]",
"(a.b[0]).c[0]",
"[1, 2][0]",
"[1, 2].len()",
"[{ a: [1, 2] }, { a: [3, 4] }].a[0]",
"{ a: 1 }.a",
"{ a: { b: 1 } }.a.b",
"person:1.name",
"person:1->likes->person",
"person:1.{ name, age }",
"'x'.len()",
"count().a",
"fn::f().a[0]",
"`a.b`",
"`a.b`.c",
"⟨a b⟩.⟨c d⟩",
"a.`b c`",
"a.function",
"a.b[WHERE c IN [1, 2]].d.e",
"a.b[WHERE c][0].d[WHERE e][$]",
"a[WHERE b].c[WHERE d]->e->f[WHERE g].h",
"(a.b)[0]",
"(a.b)[$]",
"(a.b)[WHERE c]",
"(a.b).len()",
"(a.b).*",
"(a.b).?.c",
"(a.b).{ x }",
"(a.b)->likes->person",
"(a.b.c)[0]",
"(a.b)[0].c",
"((a.b)[0].c)[1]",
"($p.a)[0]",
"((1 + 2).b)[0]",
"(person:1.name)[0]",
];
#[test]
fn a_path_renders_as_the_idiom_it_was_lowered_from() {
let lower_of = |sql: &str| {
let sql::Expr::Return(out) = parse(&format!("RETURN {sql}")) else {
panic!("expected a RETURN for `{sql}`");
};
lower_expr(out.what).expect("expression should lower")
};
for sql in IDIOM_CORPUS {
let lowered = lower_of(sql);
for (layout, rendered) in [("", lowered.to_sql()), (" pretty", lowered.to_sql_pretty())]
{
assert_eq!(
lower_of(&rendered),
lowered,
"the{layout} rendering of `{sql}` is `{rendered}`, which is a different \
expression"
);
}
}
}
#[test]
fn grouping_a_path_before_a_mapping_step_is_canonicalised_away() {
let grouped = lower_idiom("(a.b).c");
assert_eq!(shape_of(&grouped), shape_of(&lower_idiom("a.b.c")));
assert_eq!(grouped.to_sql(), "a.b.c");
}
#[test]
fn a_path_reads_back_as_the_plan_it_was_rendered_from() {
for sql in IDIOM_CORPUS {
let lowered = lower_idiom(sql);
let rendered = lowered.to_sql();
let reread = lower_idiom(&rendered);
assert_eq!(
shape_of(&reread),
shape_of(&lowered),
"`{sql}` rendered as `{rendered}`, which is a different plan"
);
assert_eq!(reread.to_sql(), rendered, "rendering `{sql}` is not idempotent");
}
}
#[test]
fn a_root_inside_a_path_restarts_it() {
let field = |name: &str| surface::Part::Field(name.into());
let doc_then_b =
super::lower_idiom(surface::Idiom(vec![field("a"), surface::Part::Doc, field("b")]))
.expect("lowers");
assert_eq!(shape_of(&doc_then_b), shape_of(&lower_idiom("@.b")));
let start = surface::Expr::Param(surface::Param::from("p".to_owned()));
let start_then_b = super::lower_idiom(surface::Idiom(vec![
field("a"),
surface::Part::Start(start),
field("b"),
]))
.expect("lowers");
assert_eq!(shape_of(&start_then_b), shape_of(&lower_idiom("$p.b")));
let twice = super::lower_idiom(surface::Idiom(vec![
surface::Part::Doc,
field("a"),
surface::Part::Doc,
field("b"),
]))
.expect("lowers");
assert_eq!(shape_of(&twice), shape_of(&lower_idiom("@.b")));
let body =
super::lower_body(surface::Idiom(vec![field("a"), surface::Part::Doc, field("b")]))
.expect("lowers");
assert_eq!(shape_of(&body), shape_of(&lower_idiom("@.b")));
}
fn lower_idiom(sql: &str) -> LogicalExpr {
let sql::Expr::Return(out) = parse(&format!("RETURN {sql}")) else {
panic!("expected a RETURN");
};
lower_expr(out.what).expect("expression should lower")
}
fn shape_of(e: &LogicalExpr) -> String {
match e {
LogicalExpr::Field(name) => name.to_string(),
LogicalExpr::Doc => "@".to_string(),
LogicalExpr::Current => "_".to_string(),
LogicalExpr::Access {
base,
field,
} => format!("{}.{field}", shape_of(base)),
LogicalExpr::Index {
base,
..
} => format!("{}[i]", shape_of(base)),
LogicalExpr::First(base) => format!("{}[first]", shape_of(base)),
LogicalExpr::Last(base) => format!("{}[$]", shape_of(base)),
LogicalExpr::Each(base) => format!("{}.*", shape_of(base)),
LogicalExpr::Flatten {
base,
explicit,
} => format!(
"{}{}",
shape_of(base),
if *explicit {
"…"
} else {
"~"
}
),
LogicalExpr::Filter {
base,
..
} => format!("{}[W]", shape_of(base)),
LogicalExpr::Method {
base,
name,
..
} => format!("{}.{name}()", shape_of(base)),
LogicalExpr::Destructure {
base,
..
} => format!("{}.{{}}", shape_of(base)),
LogicalExpr::Optional {
base,
then,
} => format!("?({}; {})", shape_of(base), shape_of(then)),
LogicalExpr::Lookup {
base,
lookup,
} => format!("{}{}", shape_of(base), lookup.to_sql()),
LogicalExpr::Recurse(r) => match &r.path {
None => format!("R({})", shape_of(&r.base)),
Some(LogicalRecursePath::Nested(body)) => {
format!("R({}; ({}))", shape_of(&r.base), shape_of(body))
}
Some(LogicalRecursePath::Trailing(body)) => {
format!("R({}; {})", shape_of(&r.base), shape_of(body))
}
},
LogicalExpr::RepeatRecurse(base) => format!("{}.@", shape_of(base)),
LogicalExpr::Broadcast {
base,
body,
flatten,
} => format!(
"B{}({}; {})",
if *flatten {
"*"
} else {
""
},
shape_of(base),
shape_of(body)
),
other @ (LogicalExpr::Literal(_)
| LogicalExpr::Array(_)
| LogicalExpr::Set(_)
| LogicalExpr::Object(_)
| LogicalExpr::RecordId(_)
| LogicalExpr::Param(_)
| LogicalExpr::Table(_)
| LogicalExpr::Mock(_)
| LogicalExpr::Constant(_)
| LogicalExpr::Prefix {
..
}
| LogicalExpr::Postfix {
..
}
| LogicalExpr::Invoke {
..
}
| LogicalExpr::Binary {
..
}
| LogicalExpr::Call(_)
| LogicalExpr::Closure(_)
| LogicalExpr::If(_)
| LogicalExpr::Throw(_)
| LogicalExpr::Break
| LogicalExpr::Continue
| LogicalExpr::SetField {
..
}
| LogicalExpr::Subquery(_)) => other.to_sql(),
}
}
#[test]
fn lowering_places_the_sequence_forms_by_the_continuation_rules() {
let cases = [
("a", "a"),
("a.b", "a.b"),
("a.b.c", "a.b.c"),
("a.*.b", "a.*.b"),
("a.{ b }.c", "a.{}.c"),
("a[0]", "a[i]"),
("a.b[0]", "B(a; _.b[i])"),
("a.b.c[0]", "B(a; B(_.b; _.c[i]))"),
("a.b[1].c[0]", "B(a; B(_.b[i]; _.c[i]))"),
("a.*[0]", "B(a; _.*[i])"),
("a.{ b }[0]", "B(a; _.{}[i])"),
("a.b.len()", "B(a; _.b.len())"),
("a[0].b", "a[i].b"),
("a[WHERE b].c", "a[W].c"),
("$p.a", "$p.a"),
("$p.a[0]", "B($p; _.a[i])"),
("(a.b).c[0]", "B(a.b; _.c[i])"),
("[1].a[0]", "B([1]; _.a[i])"),
("->likes", "_->likes"),
("->likes->person", "B(_; _->likes->person)"),
("->likes.out", "B(_; _->likes.out)"),
("a->likes", "a->likes"),
("a->likes->person", "B(a; _->likes->person)"),
("a->likes.out", "B(a; _->likes.out)"),
("a.b->likes", "B(a; _.b->likes)"),
("->likes[WHERE x]", "B(_; _->likes~[W])"),
("->likes[WHERE x]->person", "B(_; _->likes~[W]->person)"),
("->likes[WHERE x]->person.name", "B(_; B*(_->likes~[W]; _->person.name))"),
("a->likes[WHERE x]->person", "B(a; _->likes~[W]->person)"),
("->likes…->person", "B(_; _->likes…->person)"),
("a…->likes->person", "a…->likes->person"),
("a.b…->likes->person", "B(a; _.b…->likes->person)"),
("a…[WHERE x]->likes.out", "B*(a…[W]; _->likes.out)"),
("a.?", "?(a; _)"),
("a.?.b.c[0]", "?(a; _.b.c[i])"),
("a.b.?.c[0]", "B(a; ?(_.b; _.c[i]))"),
("a.{..}", "R(a)"),
("a.{..}(.b).c", "R(a; (_.b)).c"),
("a.{..}.b.c[0]", "R(a; _.b.c[i])"),
("a.{..}.b.@", "R(a; _.b.@)"),
("a.{..}.b.@.c[0]", "B(R(a; _.b.@); _.c[i])"),
("a.{..}->knows->person", "R(a; _->knows->person)"),
("a.b.{..}(->knows)", "B(a; R(_.b; (_->knows)))"),
("@.a", "@.a"),
];
for (sql, want) in cases {
assert_eq!(shape_of(&expr(sql)), want, "shape of `{sql}`");
}
}
#[test]
fn bodies_are_paths_over_the_current_value() {
let LogicalExpr::Destructure {
fields,
..
} = expr("a.{ b: c.d[1], e: $this.f, g: h * 2 }")
else {
panic!("expected a destructure");
};
let bodies: Vec<String> = fields
.iter()
.map(|field| match field {
LogicalDestructureField::Aliased(_, body) => shape_of(body),
other @ (LogicalDestructureField::All(_)
| LogicalDestructureField::Field(_)
| LogicalDestructureField::Destructure(..)
| LogicalDestructureField::Rest) => {
panic!("expected an alias, got {other:?}")
}
})
.collect();
assert_eq!(bodies, ["_.c.d[i]", "$this.f", "h * 2"]);
}
#[test]
fn a_block_is_a_sequence_as_a_statement_and_a_subquery_as_a_scalar() {
let statement = lower_sql("{ LET $a = 1; RETURN $a + 1; }");
assert_eq!(statement.name(), "Sequence");
assert_eq!(
statement.children().iter().map(LogicalOp::name).collect::<Vec<_>>(),
["Let", "Return"]
);
let scalar = expr("1 + { LET $a = 1; RETURN $a + 1; }");
let LogicalExpr::Binary {
right,
..
} = scalar
else {
panic!("expected a binary expression");
};
let LogicalExpr::Subquery(nested) = *right else {
panic!("expected a subquery");
};
assert_eq!(nested.name(), "Sequence");
}
#[test]
fn control_flow_and_if_have_one_encoding_per_position() {
assert!(matches!(lower_sql("IF true THEN 1 ELSE 2 END"), LogicalOp::If(_)));
assert!(
matches!(expr("[IF true THEN 1 END]"), LogicalExpr::Array(items) if matches!(items[0], LogicalExpr::If(_)))
);
assert!(matches!(lower_sql("BREAK"), LogicalOp::Break(_)));
assert!(matches!(lower_sql("THROW 'x'"), LogicalOp::Throw(_)));
}
#[test]
fn a_statement_in_scalar_position_is_a_subquery() {
for sql in ["SELECT * FROM t", "RETURN 1", "LET $x = 1", "INFO FOR DB", "SLEEP 1ms"] {
let lowered = expr(&format!("[{sql}]"));
let LogicalExpr::Array(items) = lowered else {
panic!("expected an array");
};
assert!(matches!(items[0], LogicalExpr::Subquery(_)), "`{sql}` should be a subquery");
}
}
fn expected(expr: &sql::Expr) -> &'static str {
match expr {
sql::Expr::Literal(_)
| sql::Expr::Param(_)
| sql::Expr::Idiom(_)
| sql::Expr::Table(_)
| sql::Expr::Constant(_)
| sql::Expr::Prefix {
..
}
| sql::Expr::Postfix {
..
}
| sql::Expr::Binary {
..
}
| sql::Expr::FunctionCall(_)
| sql::Expr::Closure(_)
| sql::Expr::Mock(_) => "Eval",
sql::Expr::Break => "Break",
sql::Expr::Continue => "Continue",
sql::Expr::Throw(_) => "Throw",
sql::Expr::IfElse(_) => "If",
sql::Expr::Block(_) => "Sequence",
sql::Expr::Return(_) => "Return",
sql::Expr::Select(_) => "Project",
sql::Expr::Info(_) => "Info",
sql::Expr::Foreach(_) => "Foreach",
sql::Expr::Let(_) => "Let",
sql::Expr::Sleep(_) => "Sleep",
sql::Expr::Explain {
..
} => "Explain",
sql::Expr::Create(_)
| sql::Expr::Update(_)
| sql::Expr::Delete(_)
| sql::Expr::Relate(_)
| sql::Expr::Insert(_)
| sql::Expr::Upsert(_) => "Write",
sql::Expr::Define(_)
| sql::Expr::Remove(_)
| sql::Expr::Rebuild(_)
| sql::Expr::Alter(_) => "Ddl",
}
}
fn variant_name(expr: &sql::Expr) -> &'static str {
match expr {
sql::Expr::Literal(_) => "Literal",
sql::Expr::Param(_) => "Param",
sql::Expr::Idiom(_) => "Idiom",
sql::Expr::Table(_) => "Table",
sql::Expr::Mock(_) => "Mock",
sql::Expr::Block(_) => "Block",
sql::Expr::Constant(_) => "Constant",
sql::Expr::Prefix {
..
} => "Prefix",
sql::Expr::Postfix {
..
} => "Postfix",
sql::Expr::Binary {
..
} => "Binary",
sql::Expr::FunctionCall(_) => "FunctionCall",
sql::Expr::Closure(_) => "Closure",
sql::Expr::Break => "Break",
sql::Expr::Continue => "Continue",
sql::Expr::Throw(_) => "Throw",
sql::Expr::Return(_) => "Return",
sql::Expr::IfElse(_) => "IfElse",
sql::Expr::Select(_) => "Select",
sql::Expr::Create(_) => "Create",
sql::Expr::Update(_) => "Update",
sql::Expr::Delete(_) => "Delete",
sql::Expr::Relate(_) => "Relate",
sql::Expr::Insert(_) => "Insert",
sql::Expr::Define(_) => "Define",
sql::Expr::Remove(_) => "Remove",
sql::Expr::Rebuild(_) => "Rebuild",
sql::Expr::Upsert(_) => "Upsert",
sql::Expr::Alter(_) => "Alter",
sql::Expr::Info(_) => "Info",
sql::Expr::Foreach(_) => "Foreach",
sql::Expr::Let(_) => "Let",
sql::Expr::Sleep(_) => "Sleep",
sql::Expr::Explain {
..
} => "Explain",
}
}
fn corpus() -> Vec<sql::Expr> {
let mut out: Vec<sql::Expr> = CORPUS.iter().map(|sql| parse(sql)).collect();
out.push(sql::Expr::Table("t".into()));
out
}
const CORPUS: &[&str] = &[
"1",
"$p",
"a.b",
"|t:3|",
"{ 1; 2 }",
"math::PI",
"!true",
"1..",
"1 + 2",
"count()",
"|| 1",
"BREAK",
"CONTINUE",
"THROW 'x'",
"RETURN 1",
"IF true THEN 1 ELSE 2 END",
"SELECT * FROM t",
"CREATE t",
"UPDATE t SET a = 1",
"DELETE t",
"RELATE a:1->r->b:1",
"INSERT INTO t { a: 1 }",
"DEFINE TABLE t",
"REMOVE TABLE t",
"REBUILD INDEX i ON t",
"UPSERT t",
"ALTER TABLE t SCHEMAFULL",
"INFO FOR DB",
"FOR $x IN [1] { }",
"LET $x = 1",
"SLEEP 1ms",
"EXPLAIN SELECT * FROM t",
];
#[test]
fn lowering_classifies_every_surface_variant() {
let mut seen = BTreeSet::new();
for statement in corpus() {
let sql = statement.to_sql();
seen.insert(variant_name(&statement));
let want = expected(&statement);
let got = lower(statement).expect("every surface variant lowers");
assert_eq!(got.name(), want, "`{sql}`");
}
let all: BTreeSet<_> = [
"Literal",
"Param",
"Idiom",
"Table",
"Mock",
"Block",
"Constant",
"Prefix",
"Postfix",
"Binary",
"FunctionCall",
"Closure",
"Break",
"Continue",
"Throw",
"Return",
"IfElse",
"Select",
"Create",
"Update",
"Delete",
"Relate",
"Insert",
"Define",
"Remove",
"Rebuild",
"Upsert",
"Alter",
"Info",
"Foreach",
"Let",
"Sleep",
"Explain",
]
.into_iter()
.collect();
assert_eq!(seen, all, "the corpus must cover every surface variant");
}
#[test]
fn a_ddl_nested_in_a_scalar_keeps_the_statements_logical_form() {
let statement = parse("RETURN { DEFINE TABLE x; 1 }");
let lowered = lower(statement).expect("a block holding a schema statement lowers");
assert!(
lowered.any(|node| matches!(node, LogicalOp::Ddl(_))),
"the block should carry the schema statement"
);
}
#[test]
fn a_mock_lowers_outside_from() {
for sql in [
"SELECT * FROM t WHERE a IN |u:3|",
"CREATE |u:3|",
"UPSERT |u:1..4|",
"LET $x = |u:3|",
"RETURN [|u:3|]",
] {
lower(parse(sql)).unwrap_or_else(|err| panic!("`{sql}` lowers: {err}"));
}
}
#[test]
fn a_ddl_plan_is_not_read_only() {
for sql in ["DEFINE TABLE x", "REMOVE TABLE x", "ALTER TABLE x", "REBUILD INDEX i ON x"] {
let lowered = lower(parse(sql)).expect("a schema statement lowers");
assert!(!lowered.read_only(), "`{sql}` writes the catalog");
}
let lowered = lower(parse("RETURN { DEFINE TABLE x; 1 }")).expect("the block lowers");
assert!(!lowered.read_only(), "a block holding a schema statement writes");
}
#[test]
fn a_ddl_node_owns_no_scalars_and_no_inputs() {
let lowered = lower(parse("DEFINE INDEX i ON t FIELDS a, b")).expect("lowers");
assert!(matches!(lowered, LogicalOp::Ddl(_)));
assert!(lowered.scalars().is_empty());
assert!(lowered.children().is_empty());
assert_eq!(lowered.name(), "Ddl");
}
#[test]
fn a_lowered_write_nested_in_a_scalar_keeps_the_statement_writing() {
let op = lower(parse("SELECT * FROM t WHERE a IN (CREATE u).id"))
.expect("a nested CREATE should lower with its statement");
assert!(!op.read_only(), "a statement containing a mutation must not claim read-only");
let control = lower(parse("SELECT * FROM t WHERE a IN u.id")).expect("should lower");
assert!(control.read_only(), "the control must be read-only for the pair to mean anything");
}
fn write_of(sql: &str) -> LogicalWrite {
let op = lower_sql(sql);
let name = op.name();
let LogicalOp::Write(write) = op else {
panic!("`{sql}` should lower to a write, got {name}");
};
write
}
fn targets_of(sql: &str) -> Vec<LogicalExpr> {
match write_of(sql).source {
LogicalWriteSource::Targets(targets) => targets,
other @ (LogicalWriteSource::Inserts(_) | LogicalWriteSource::Rows(_)) => panic!(
"`{sql}` writes subjects that need not exist, so it must not read them: {other:?}"
),
}
}
fn inserts_of(sql: &str) -> LogicalInserts {
match write_of(sql).source {
LogicalWriteSource::Inserts(inserts) => inserts,
other @ (LogicalWriteSource::Targets(_) | LogicalWriteSource::Rows(_)) => {
panic!("`{sql}` writes rows of its own: {other:?}")
}
}
}
fn rows_of(sql: &str) -> LogicalOp {
match write_of(sql).source {
LogicalWriteSource::Rows(rows) => *rows,
other @ (LogicalWriteSource::Targets(_) | LogicalWriteSource::Inserts(_)) => {
panic!("`{sql}` writes subjects that already exist, so it reads them: {other:?}")
}
}
}
#[test]
fn every_mutation_form_lowers_to_a_write() {
for (sql, kind) in [
("CREATE person SET a = 1", "CREATE"),
("UPDATE person SET a = 1", "UPDATE"),
("UPSERT person SET a = 1", "UPSERT"),
("DELETE person", "DELETE"),
("INSERT INTO person { a: 1 }", "INSERT"),
("RELATE person:a->likes->person:b", "RELATE"),
] {
assert_eq!(write_of(sql).statement.kind(), kind, "`{sql}`");
}
}
#[test]
fn a_creating_form_names_targets_and_an_updating_form_reads_rows() {
for sql in ["CREATE person", "UPSERT person", "RELATE person:a->likes->person:b"] {
let _ = targets_of(sql);
let op = lower_sql(sql);
assert!(op.children().is_empty(), "`{sql}` has no plan subtree to read");
}
let _ = inserts_of("INSERT INTO person { a: 1 }");
assert!(
lower_sql("INSERT INTO person { a: 1 }").children().is_empty(),
"an INSERT has no plan subtree to read"
);
for sql in ["UPDATE person SET a = 1", "DELETE person"] {
assert_eq!(shape(&rows_of(sql)), ["Source"], "`{sql}`");
}
}
#[test]
fn only_is_read_from_the_statement_and_insert_has_none() {
for sql in [
"CREATE ONLY person",
"UPDATE ONLY person:1 SET a = 1",
"UPSERT ONLY person:1",
"DELETE ONLY person:1",
"RELATE ONLY person:a->likes->person:b",
] {
assert!(write_of(sql).statement.only(), "`{sql}`");
}
assert!(!write_of("DELETE person:1").statement.only());
assert!(!write_of("INSERT INTO person { a: 1 }").statement.only());
}
#[test]
fn an_updating_forms_targets_lower_as_a_from_clause_does() {
let rows = rows_of("UPDATE a, b:1 WITH NOINDEX SET x = 1");
assert_eq!(rows.name(), "UnionAll");
let leaves: Vec<_> = rows.children().iter().map(LogicalOp::name).collect();
assert_eq!(leaves, ["Source", "Source"]);
for leaf in rows.children() {
let LogicalOp::Source(LogicalSource {
with,
for_update,
..
}) = leaf
else {
panic!("expected a source");
};
assert!(with.is_some(), "the hint reaches each stored source");
assert!(!for_update, "the mutation's own write takes the lock");
}
}
#[test]
fn an_updating_forms_condition_stays_out_of_its_row_subtree() {
for sql in ["UPDATE person SET a = 1 WHERE b > 1", "DELETE person WHERE b > 1"] {
let rows = rows_of(sql);
assert!(
!rows.any(|node| matches!(node, LogicalOp::Filter(_))),
"`{sql}` must not evaluate its condition below the write: {rows}"
);
assert!(
!rows.to_string().contains("b > 1"),
"`{sql}` must not push its condition into the scan: {rows}"
);
}
let LogicalWriteStatement::Update(stmt) =
write_of("UPDATE person SET a = 1 WHERE b > 1").statement
else {
panic!("expected an UPDATE");
};
assert!(stmt.cond.is_some());
let LogicalWriteStatement::Delete(stmt) = write_of("DELETE person WHERE b > 1").statement
else {
panic!("expected a DELETE");
};
assert!(stmt.cond.is_some());
assert_eq!(
shape(&lower_sql("SELECT * FROM person WHERE b > 1")),
["Project", "Filter", "Source"]
);
}
#[test]
fn upsert_names_targets_whether_or_not_it_has_a_condition() {
assert_eq!(targets_of("UPSERT person:1 SET a = 1").len(), 1);
assert_eq!(targets_of("UPSERT person:1 SET a = 1 WHERE b > 1").len(), 1);
assert_eq!(targets_of("UPSERT a, b:1").len(), 2, "one target per thing written");
}
#[test]
fn insert_carries_its_rows_and_its_into_table_as_its_source() {
let single = inserts_of("INSERT INTO person { a: 1 }");
assert!(single.into.is_some());
assert!(matches!(single.rows, LogicalInsertRows::Value(_)));
let bare = inserts_of("INSERT { id: person:1, a: 1 }");
assert!(
bare.into.is_none(),
"without INTO each record names its table through the id it carries"
);
let LogicalInsertRows::Tuples(tuples) =
inserts_of("INSERT INTO person (a, b) VALUES (1, 2), (3, 4)").rows
else {
panic!("a VALUES list must lower to tuples");
};
assert_eq!(tuples.len(), 2);
let rendered: Vec<_> =
tuples[0].iter().map(|(path, value)| (path.to_sql(), value.to_sql())).collect();
assert_eq!(rendered, [("a".to_string(), "1".to_string()), ("b".into(), "2".into())]);
}
#[test]
fn an_inserts_rows_are_the_nodes_own_scalars() {
let single = lower_sql("INSERT INTO person { a: $x }");
assert_eq!(single.scalars().len(), 2, "the INTO table and the one row expression");
assert!(single.children().is_empty(), "rows are not a plan subtree");
let tuples = lower_sql("INSERT INTO person (a, b) VALUES (1, 2), (3, 4)");
assert_eq!(tuples.scalars().len(), 5, "the INTO table and four values");
let bare = lower_sql("INSERT { id: person:1 }");
assert_eq!(bare.scalars().len(), 1, "no INTO table, one row expression");
}
#[test]
fn an_insert_whose_data_names_no_rows_has_no_logical_form() {
let stmt = sql::Expr::Insert(Box::new(sql::statements::InsertStatement {
into: Some(sql::Expr::Table("person".into())),
data: sql::Data::ContentExpression(sql::Expr::Literal(sql::Literal::Integer(1))),
ignore: false,
update: None,
output: None,
timeout: sql::Expr::Literal(sql::Literal::None),
relation: false,
}));
assert!(matches!(lower(stmt), Err(NoLogicalForm::Unsupported(_))));
}
#[test]
fn relate_names_its_endpoints_and_the_table_between_them() {
let rendered: Vec<_> =
targets_of("RELATE person:a->likes->person:b").iter().map(ToSql::to_sql).collect();
assert_eq!(rendered, ["person:a", "likes", "person:b"]);
let op = lower_sql("RELATE person:a->likes->person:b");
assert_eq!(op.scalars().len(), 3);
}
#[test]
fn an_explain_statement_carries_its_format() {
let LogicalOp::Explain(LogicalExplain {
analyze,
format,
input,
}) = lower_sql("EXPLAIN ANALYZE FORMAT JSON SELECT * FROM t")
else {
panic!("expected an Explain");
};
assert!(analyze);
assert_eq!(format, crate::expr::ExplainFormat::Json);
assert_eq!(input.name(), "Project");
let LogicalOp::Explain(LogicalExplain {
format,
analyze,
..
}) = lower_sql("SELECT * FROM t EXPLAIN FULL")
else {
panic!("expected an Explain");
};
assert!(analyze);
assert_eq!(format, crate::expr::ExplainFormat::Json);
}
#[test]
fn a_geojson_object_lowers_to_a_geometry() {
assert!(matches!(
expr("{ type: 'Point', coordinates: [1.0, 2.0] }"),
LogicalExpr::Literal(LogicalLiteral::Geometry(_))
));
assert!(matches!(expr("{ type: 'Point', other: 1 }"), LogicalExpr::Object(_)));
}
}