#![deny(clippy::wildcard_enum_match_arm)]
pub mod dag;
mod effects;
mod exits;
mod expr;
pub(crate) mod lower;
mod request;
pub mod schema;
pub mod trace;
use std::fmt::{self, Display, Formatter};
use std::ops::ControlFlow;
use std::sync::Arc;
use surrealdb_iam::AuthLimit;
use surrealdb_strand::{Strand, TableName};
use surrealdb_types::{SqlFormat, ToSql, write_sql};
pub use self::effects::{
ChildFacts, EffectOracle, EffectSet, Effects, ITERATION_PARAMS, ROW_PARAMS, effects_of,
facts_of, invokes_unseen_body, key_is_generated, may_carry_unseen_closure, may_dereference,
node_effects, node_may_dereference,
};
pub use self::exits::Exits;
pub use self::expr::{
LogicalCall, LogicalClosure, LogicalDestructureField, LogicalExpr, LogicalField, LogicalFields,
LogicalIf, LogicalLiteral, LogicalLookup, LogicalLookupSubject, LogicalOrder, LogicalOrdering,
LogicalPostfixOperator, LogicalRecordIdKey, LogicalRecordIdKeyRange, LogicalRecordIdLit,
LogicalRecurse, LogicalRecurseInstruction, LogicalRecursePath, OutputPath, OutputPathPart,
SourceRef,
};
pub use self::lower::{
NoLogicalForm, is_value_literal, lower, lower_expr, lower_fields, lower_select,
lower_value_statement,
};
pub use self::request::{
Emission, LogicalTransaction, MisplacedControl, RequestGrouper, RequestStatementKind,
StatementPlace, StatementRole, TxnEnd, TxnMode, lower_request, lower_request_with,
};
pub use self::schema::{
ComputedBody, FieldPath, FieldSchema, FieldSegment, LogicalPermission, LogicalPermissionRef,
Openness, Schema, coercion_is_identity, kind_may_be_record,
};
pub use self::trace::LookupTrace;
use crate::expr::match_plan::MatchPlan;
use crate::expr::with::With;
use crate::expr::{Base, ExplainFormat, Idiom, Kind, Param};
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub enum EvalMode {
#[default]
Caller,
Permission,
MutablePermission,
Computed,
}
impl EvalMode {
pub fn checks_permissions(self) -> bool {
matches!(self, EvalMode::Caller | EvalMode::Computed)
}
pub fn forbids_writes(self) -> bool {
matches!(self, EvalMode::Permission | EvalMode::Computed)
}
}
#[derive(Clone, Debug, Default, PartialEq, Eq, Hash)]
pub struct EvalFrame {
pub mode: EvalMode,
pub auth: Option<AuthLimit>,
pub key_part: bool,
}
impl EvalFrame {
pub fn caller() -> Self {
Self::default()
}
pub fn permission(auth: Option<AuthLimit>) -> Self {
Self {
mode: EvalMode::Permission,
auth,
key_part: false,
}
}
pub fn mutable_permission(auth: Option<AuthLimit>) -> Self {
Self {
mode: EvalMode::MutablePermission,
auth,
key_part: false,
}
}
pub fn computed(auth: Option<AuthLimit>) -> Self {
Self {
mode: EvalMode::Computed,
auth,
key_part: false,
}
}
pub fn key_part() -> Self {
Self {
mode: EvalMode::Computed,
auth: None,
key_part: true,
}
}
pub fn is_caller(&self) -> bool {
self.mode == EvalMode::Caller && self.auth.is_none() && !self.key_part
}
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub enum LogicalInfo {
Root {
structure: bool,
version: Option<LogicalExpr>,
},
Ns {
structure: bool,
version: Option<LogicalExpr>,
},
Db {
structure: bool,
version: Option<LogicalExpr>,
},
Table {
table: LogicalExpr,
structure: bool,
version: Option<LogicalExpr>,
},
User {
user: LogicalExpr,
base: Option<Base>,
structure: bool,
},
Index {
index: LogicalExpr,
table: LogicalExpr,
structure: bool,
},
}
impl LogicalInfo {
pub fn for_each_expr<'a>(&'a self, out: &mut dyn FnMut(&'a LogicalExpr)) {
match self {
LogicalInfo::Root {
version,
..
}
| LogicalInfo::Ns {
version,
..
}
| LogicalInfo::Db {
version,
..
} => {
if let Some(e) = version {
out(e);
}
}
LogicalInfo::Table {
table,
version,
..
} => {
out(table);
if let Some(e) = version {
out(e);
};
}
LogicalInfo::User {
user,
..
} => out(user),
LogicalInfo::Index {
index,
table,
..
} => {
out(index);
out(table);
}
}
}
pub fn exprs<'a>(&'a self, out: &mut Vec<&'a LogicalExpr>) {
self.for_each_expr(&mut |expr| out.push(expr));
}
pub fn exprs_mut<'a>(&'a mut self, out: &mut Vec<&'a mut LogicalExpr>) {
match self {
LogicalInfo::Root {
version,
..
}
| LogicalInfo::Ns {
version,
..
}
| LogicalInfo::Db {
version,
..
} => out.extend(version),
LogicalInfo::Table {
table,
version,
..
} => {
out.push(table);
out.extend(version);
}
LogicalInfo::User {
user,
..
} => out.push(user),
LogicalInfo::Index {
index,
table,
..
} => {
out.push(index);
out.push(table);
}
}
}
pub fn read_only(&self) -> bool {
let mut exprs = Vec::new();
self.exprs(&mut exprs);
exprs.into_iter().all(LogicalExpr::read_only)
}
}
impl ToSql for LogicalInfo {
fn fmt_sql(&self, f: &mut String, fmt: SqlFormat) {
let (structure, version) = match self {
LogicalInfo::Root {
structure,
version,
} => {
f.push_str("INFO FOR ROOT");
(*structure, version.as_ref())
}
LogicalInfo::Ns {
structure,
version,
} => {
f.push_str("INFO FOR NAMESPACE");
(*structure, version.as_ref())
}
LogicalInfo::Db {
structure,
version,
} => {
f.push_str("INFO FOR DATABASE");
(*structure, version.as_ref())
}
LogicalInfo::Table {
table,
structure,
version,
} => {
write_sql!(f, fmt, "INFO FOR TABLE {table}");
(*structure, version.as_ref())
}
LogicalInfo::User {
user,
base,
structure,
} => {
write_sql!(f, fmt, "INFO FOR USER {user}");
if let Some(base) = base {
write_sql!(f, fmt, " ON {base}");
}
(*structure, None)
}
LogicalInfo::Index {
index,
table,
structure,
} => {
write_sql!(f, fmt, "INFO FOR INDEX {index} ON {table}");
(*structure, None)
}
};
if let Some(version) = version {
write_sql!(f, fmt, " VERSION {version}");
}
if structure {
f.push_str(" STRUCTURE");
}
}
}
#[derive(Debug, PartialEq, Eq, surrealdb_stored_derive::DynHash)]
pub enum LogicalOp {
Source(LogicalSource),
Values(LogicalValues),
Match(LogicalMatch),
Subquery(LogicalSubquery),
Write(LogicalWrite),
Ddl(LogicalDdl),
UnionAll(LogicalUnionAll),
Join(LogicalJoin),
Filter(LogicalFilter),
PermissionFilter(LogicalPermissionFilter),
Split(LogicalSplit),
Aggregate(LogicalAggregate),
Distinct(LogicalDistinct),
Window(LogicalWindow),
Sort(LogicalSort),
Limit(LogicalLimit),
Project(LogicalProject),
Fetch(LogicalFetch),
Timeout(LogicalTimeout),
VersionScope(LogicalVersionScope),
Only(LogicalOnly),
Explain(LogicalExplain),
Eval(LogicalEval),
Sequence(LogicalSequence),
Let(LogicalLet),
Return(LogicalReturn),
Foreach(LogicalForeach),
If(LogicalIfOp),
Throw(LogicalThrow),
Break(LogicalBreak),
Continue(LogicalContinue),
Info(Box<LogicalInfo>),
Sleep(LogicalSleep),
}
impl Clone for LogicalOp {
#[inline]
fn clone(&self) -> Self {
clone_op(self)
}
}
#[inline(never)]
fn clone_op(op: &LogicalOp) -> LogicalOp {
match op {
LogicalOp::Source(op) => LogicalOp::Source(op.clone()),
LogicalOp::Values(op) => LogicalOp::Values(op.clone()),
LogicalOp::Match(op) => LogicalOp::Match(op.clone()),
LogicalOp::Subquery(op) => LogicalOp::Subquery(op.clone()),
LogicalOp::Write(op) => LogicalOp::Write(op.clone()),
LogicalOp::Ddl(op) => LogicalOp::Ddl(op.clone()),
LogicalOp::UnionAll(op) => LogicalOp::UnionAll(op.clone()),
LogicalOp::Join(op) => LogicalOp::Join(op.clone()),
LogicalOp::Filter(op) => LogicalOp::Filter(op.clone()),
LogicalOp::PermissionFilter(op) => LogicalOp::PermissionFilter(op.clone()),
LogicalOp::Split(op) => LogicalOp::Split(op.clone()),
LogicalOp::Aggregate(op) => LogicalOp::Aggregate(op.clone()),
LogicalOp::Distinct(op) => LogicalOp::Distinct(op.clone()),
LogicalOp::Window(op) => LogicalOp::Window(op.clone()),
LogicalOp::Sort(op) => LogicalOp::Sort(op.clone()),
LogicalOp::Limit(op) => LogicalOp::Limit(op.clone()),
LogicalOp::Project(op) => LogicalOp::Project(op.clone()),
LogicalOp::Fetch(op) => LogicalOp::Fetch(op.clone()),
LogicalOp::Timeout(op) => LogicalOp::Timeout(op.clone()),
LogicalOp::VersionScope(op) => LogicalOp::VersionScope(op.clone()),
LogicalOp::Only(op) => LogicalOp::Only(op.clone()),
LogicalOp::Explain(op) => LogicalOp::Explain(op.clone()),
LogicalOp::Eval(op) => LogicalOp::Eval(op.clone()),
LogicalOp::Sequence(op) => LogicalOp::Sequence(op.clone()),
LogicalOp::Let(op) => LogicalOp::Let(op.clone()),
LogicalOp::Return(op) => LogicalOp::Return(op.clone()),
LogicalOp::Foreach(op) => LogicalOp::Foreach(op.clone()),
LogicalOp::If(op) => LogicalOp::If(op.clone()),
LogicalOp::Throw(op) => LogicalOp::Throw(op.clone()),
LogicalOp::Break(op) => LogicalOp::Break(*op),
LogicalOp::Continue(op) => LogicalOp::Continue(*op),
LogicalOp::Info(op) => LogicalOp::Info(op.clone()),
LogicalOp::Sleep(op) => LogicalOp::Sleep(op.clone()),
}
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct LogicalSource {
pub source: SourceRef,
pub schema: Option<Arc<Schema>>,
pub with: Option<With>,
pub for_update: bool,
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct LogicalValues {
pub expr: LogicalExpr,
pub for_update: bool,
pub written: bool,
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct LogicalMatch {
pub plan: Box<MatchPlan>,
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct LogicalSubquery {
pub input: Box<LogicalOp>,
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct LogicalWrite {
pub statement: LogicalWriteStatement,
pub source: LogicalWriteSource,
pub data: Option<LogicalData>,
pub duplicate_update: Option<LogicalData>,
pub cond: Option<LogicalExpr>,
pub trace: LookupTrace,
}
impl LogicalWrite {
pub fn for_each_scalar<'a>(&'a self, out: &mut dyn FnMut(&'a LogicalExpr)) {
let LogicalWrite {
source,
data,
duplicate_update,
cond,
..
} = self;
match source {
LogicalWriteSource::Targets(targets) => {
for target in targets {
out(target);
}
}
LogicalWriteSource::Inserts(inserts) => {
if let Some(into) = &inserts.into {
out(into);
}
match &inserts.rows {
LogicalInsertRows::Tuples(tuples) => {
for tuple in tuples {
for (_, value) in tuple {
out(value);
}
}
}
LogicalInsertRows::Value(expr) => out(expr),
}
}
LogicalWriteSource::Rows(_) => {}
}
for clause in [data, duplicate_update] {
for value in clause.iter().flat_map(LogicalData::values) {
out(value);
}
}
if let Some(cond) = cond {
out(cond);
}
}
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub enum LogicalData {
Set(Vec<LogicalAssignment>),
Unset(Vec<crate::expr::Idiom>),
Patch(LogicalExpr),
Merge(LogicalExpr),
Replace(LogicalExpr),
Content(LogicalExpr),
Single(LogicalExpr),
Values(Vec<Vec<(crate::expr::Idiom, LogicalExpr)>>),
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct LogicalAssignment {
pub place: crate::expr::Idiom,
pub operator: crate::expr::AssignOperator,
pub value: LogicalExpr,
}
impl LogicalData {
pub fn values(&self) -> Vec<&LogicalExpr> {
match self {
LogicalData::Set(assignments) => assignments.iter().map(|a| &a.value).collect(),
LogicalData::Unset(_) => vec![],
LogicalData::Patch(expr)
| LogicalData::Merge(expr)
| LogicalData::Replace(expr)
| LogicalData::Content(expr)
| LogicalData::Single(expr) => vec![expr],
LogicalData::Values(rows) => {
rows.iter().flat_map(|row| row.iter().map(|(_, value)| value)).collect()
}
}
}
pub fn values_mut(&mut self) -> Vec<&mut LogicalExpr> {
match self {
LogicalData::Set(assignments) => assignments.iter_mut().map(|a| &mut a.value).collect(),
LogicalData::Unset(_) => vec![],
LogicalData::Patch(expr)
| LogicalData::Merge(expr)
| LogicalData::Replace(expr)
| LogicalData::Content(expr)
| LogicalData::Single(expr) => vec![expr],
LogicalData::Values(rows) => {
rows.iter_mut().flat_map(|row| row.iter_mut().map(|(_, value)| value)).collect()
}
}
}
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub enum LogicalWriteSource {
Targets(Vec<LogicalExpr>),
Inserts(LogicalInserts),
Rows(Box<LogicalOp>),
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct LogicalInserts {
pub into: Option<LogicalExpr>,
pub rows: LogicalInsertRows,
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub enum LogicalInsertRows {
Tuples(Vec<Vec<(Idiom, LogicalExpr)>>),
Value(LogicalExpr),
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub enum LogicalWriteStatement {
Create(Box<crate::expr::statements::CreateStatement>),
Update(Box<crate::expr::statements::UpdateStatement>),
Upsert(Box<crate::expr::statements::UpsertStatement>),
Delete(Box<crate::expr::statements::DeleteStatement>),
Insert(Box<crate::expr::statements::InsertStatement>),
Relate(Box<crate::expr::statements::RelateStatement>),
}
impl LogicalWriteStatement {
pub fn kind(&self) -> &'static str {
match self {
LogicalWriteStatement::Create(_) => "CREATE",
LogicalWriteStatement::Update(_) => "UPDATE",
LogicalWriteStatement::Upsert(_) => "UPSERT",
LogicalWriteStatement::Delete(_) => "DELETE",
LogicalWriteStatement::Insert(_) => "INSERT",
LogicalWriteStatement::Relate(_) => "RELATE",
}
}
pub fn output(&self) -> Option<&crate::expr::output::Output> {
match self {
LogicalWriteStatement::Create(stmt) => stmt.output.as_ref(),
LogicalWriteStatement::Update(stmt) => stmt.output.as_ref(),
LogicalWriteStatement::Upsert(stmt) => stmt.output.as_ref(),
LogicalWriteStatement::Delete(stmt) => stmt.output.as_ref(),
LogicalWriteStatement::Insert(stmt) => stmt.output.as_ref(),
LogicalWriteStatement::Relate(stmt) => stmt.output.as_ref(),
}
}
pub fn cond(&self) -> Option<&crate::expr::Expr> {
match self {
LogicalWriteStatement::Update(stmt) => stmt.cond.as_ref().map(|cond| &cond.0),
LogicalWriteStatement::Upsert(stmt) => stmt.cond.as_ref().map(|cond| &cond.0),
LogicalWriteStatement::Delete(stmt) => stmt.cond.as_ref().map(|cond| &cond.0),
LogicalWriteStatement::Create(_)
| LogicalWriteStatement::Insert(_)
| LogicalWriteStatement::Relate(_) => None,
}
}
pub fn data(&self) -> Option<&crate::expr::Data> {
match self {
LogicalWriteStatement::Create(stmt) => stmt.data.as_ref(),
LogicalWriteStatement::Update(stmt) => stmt.data.as_ref(),
LogicalWriteStatement::Upsert(stmt) => stmt.data.as_ref(),
LogicalWriteStatement::Relate(stmt) => stmt.data.as_ref(),
LogicalWriteStatement::Delete(_) | LogicalWriteStatement::Insert(_) => None,
}
}
pub fn duplicate_update(&self) -> Option<&crate::expr::Data> {
match self {
LogicalWriteStatement::Insert(stmt) => stmt.update.as_ref(),
LogicalWriteStatement::Create(_)
| LogicalWriteStatement::Update(_)
| LogicalWriteStatement::Upsert(_)
| LogicalWriteStatement::Delete(_)
| LogicalWriteStatement::Relate(_) => None,
}
}
pub fn only(&self) -> bool {
match self {
LogicalWriteStatement::Create(stmt) => stmt.only,
LogicalWriteStatement::Update(stmt) => stmt.only,
LogicalWriteStatement::Upsert(stmt) => stmt.only,
LogicalWriteStatement::Delete(stmt) => stmt.only,
LogicalWriteStatement::Relate(stmt) => stmt.only,
LogicalWriteStatement::Insert(_) => false,
}
}
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct LogicalDdl {
pub statement: LogicalDdlStatement,
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub enum LogicalDdlStatement {
Define(Box<crate::expr::statements::DefineStatement>),
Remove(Box<crate::expr::statements::RemoveStatement>),
Alter(Box<crate::expr::statements::AlterStatement>),
Rebuild(Box<crate::expr::statements::RebuildStatement>),
}
impl LogicalDdlStatement {
pub fn kind(&self) -> &'static str {
match self {
LogicalDdlStatement::Define(_) => "DEFINE",
LogicalDdlStatement::Remove(_) => "REMOVE",
LogicalDdlStatement::Alter(_) => "ALTER",
LogicalDdlStatement::Rebuild(_) => "REBUILD",
}
}
}
impl From<LogicalDdlStatement> for crate::expr::Expr {
fn from(statement: LogicalDdlStatement) -> Self {
match statement {
LogicalDdlStatement::Define(stmt) => crate::expr::Expr::Define(stmt),
LogicalDdlStatement::Remove(stmt) => crate::expr::Expr::Remove(stmt),
LogicalDdlStatement::Alter(stmt) => crate::expr::Expr::Alter(stmt),
LogicalDdlStatement::Rebuild(stmt) => crate::expr::Expr::Rebuild(stmt),
}
}
}
impl ToSql for LogicalDdlStatement {
fn fmt_sql(&self, f: &mut String, fmt: SqlFormat) {
crate::expr::Expr::from(self.clone()).fmt_sql(f, fmt);
}
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct LogicalUnionAll {
pub inputs: Vec<LogicalOp>,
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct LogicalJoin {
pub inputs: Box<[LogicalOp; 2]>,
pub kind: JoinKind,
pub on: Vec<(LogicalExpr, LogicalExpr)>,
pub filter: Option<LogicalExpr>,
pub alias: RelationAlias,
pub frame: EvalFrame,
}
impl LogicalJoin {
pub fn new(
left: LogicalOp,
right: LogicalOp,
kind: JoinKind,
on: Vec<(LogicalExpr, LogicalExpr)>,
filter: Option<LogicalExpr>,
alias: RelationAlias,
frame: EvalFrame,
) -> Self {
Self {
inputs: Box::new([left, right]),
kind,
on,
filter,
alias,
frame,
}
}
pub fn left(&self) -> &LogicalOp {
&self.inputs[0]
}
pub fn right(&self) -> &LogicalOp {
&self.inputs[1]
}
pub fn left_mut(&mut self) -> &mut LogicalOp {
&mut self.inputs[0]
}
pub fn right_mut(&mut self) -> &mut LogicalOp {
&mut self.inputs[1]
}
pub fn into_inputs(self) -> (LogicalOp, LogicalOp) {
let [left, right] = *self.inputs;
(left, right)
}
pub fn right_table(&self) -> Option<&TableName> {
leaf_table(self.right())
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum JoinKind {
Inner,
Left,
Semi,
Anti,
}
impl JoinKind {
pub fn as_str(self) -> &'static str {
match self {
JoinKind::Inner => "INNER",
JoinKind::Left => "LEFT",
JoinKind::Semi => "SEMI",
JoinKind::Anti => "ANTI",
}
}
pub fn adds_right_row(self) -> bool {
matches!(self, JoinKind::Inner | JoinKind::Left)
}
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct RelationAlias(Strand);
impl RelationAlias {
const PREFIX: &'static str = "_join";
pub fn new(index: usize) -> Self {
Self(Strand::new(format!("{}{index}", Self::PREFIX)))
}
pub fn index_of(name: &str) -> Option<usize> {
name.strip_prefix(Self::PREFIX)?.parse().ok()
}
pub fn name(&self) -> &Strand {
&self.0
}
pub fn index(&self) -> Option<usize> {
Self::index_of(self.0.as_str())
}
pub fn field(&self) -> LogicalExpr {
LogicalExpr::Field(self.0.clone())
}
pub fn access(&self, field: impl Into<Strand>) -> LogicalExpr {
LogicalExpr::Access {
base: Box::new(self.field()),
field: field.into(),
}
}
pub fn is_root_of(&self, expr: &LogicalExpr) -> bool {
matches!(expr.path_root(), LogicalExpr::Field(name) if name == &self.0)
}
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct LogicalFilter {
pub input: Box<LogicalOp>,
pub predicate: LogicalExpr,
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct LogicalPermissionFilter {
pub input: Box<LogicalOp>,
pub predicate: LogicalExpr,
pub auth: Option<AuthLimit>,
pub guard: GuardKind,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum GuardKind {
Read,
Write,
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct LogicalSplit {
pub input: Box<LogicalOp>,
pub exprs: Vec<LogicalExpr>,
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct LogicalAggregate {
pub input: Box<LogicalOp>,
pub group: Vec<LogicalExpr>,
pub fields: LogicalFields,
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct LogicalDistinct {
pub input: Box<LogicalOp>,
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct LogicalWindow {
pub input: Box<LogicalOp>,
pub partition: Vec<LogicalExpr>,
pub order: Vec<LogicalOrder>,
pub calls: Vec<LogicalWindowCall>,
}
impl LogicalWindow {
pub fn for_each_expr<'a>(&'a self, out: &mut dyn FnMut(&'a LogicalExpr)) {
for key in &self.partition {
out(key);
}
for key in &self.order {
out(&key.value);
}
for call in &self.calls {
for arg in &call.args {
out(arg);
}
}
}
pub fn exprs_mut<'a>(&'a mut self, out: &mut Vec<&'a mut LogicalExpr>) {
out.extend(self.partition.iter_mut());
out.extend(self.order.iter_mut().map(|key| &mut key.value));
for call in &mut self.calls {
out.extend(call.args.iter_mut());
}
}
pub fn read_only(&self) -> bool {
let mut read_only = true;
self.for_each_expr(&mut |expr| read_only &= expr.read_only());
read_only
}
pub fn schema(&self) -> Schema {
let mut out = self.input.schema();
for call in &self.calls {
let path = FieldPath::field(call.output.as_str());
let kind = match call.function {
WindowFunction::RowNumber
| WindowFunction::Rank
| WindowFunction::DenseRank
| WindowFunction::Ntile
| WindowFunction::Count => Kind::Int,
WindowFunction::PercentRank | WindowFunction::CumeDist => Kind::Float,
WindowFunction::Lag
| WindowFunction::Lead
| WindowFunction::FirstValue
| WindowFunction::LastValue
| WindowFunction::NthValue
| WindowFunction::Sum
| WindowFunction::Avg
| WindowFunction::Min
| WindowFunction::Max => Kind::Any,
};
out.fields.retain(|f| f.path != path);
out.fields.push(FieldSchema::new(path, kind));
}
out
}
fn attrs(&self) -> Vec<String> {
let mut out = Vec::new();
if !self.partition.is_empty() {
let keys: Vec<String> = self.partition.iter().map(ToSql::to_sql).collect();
out.push(format!("PARTITION BY {}", keys.join(", ")));
}
if !self.order.is_empty() {
out.push(LogicalOrdering::Order(self.order.clone()).to_sql());
}
for call in &self.calls {
let args: Vec<String> = call.args.iter().map(ToSql::to_sql).collect();
out.push(format!(
"{:?}({}) {:?} AS {}",
call.function,
args.join(", "),
call.frame,
call.output.as_str()
));
}
out
}
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct LogicalWindowCall {
pub output: Strand,
pub function: WindowFunction,
pub args: Vec<LogicalExpr>,
pub frame: WindowFrame,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum WindowFunction {
RowNumber,
Rank,
DenseRank,
PercentRank,
CumeDist,
Ntile,
Lag,
Lead,
FirstValue,
LastValue,
NthValue,
Sum,
Avg,
Count,
Min,
Max,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub struct WindowFrame {
pub units: WindowFrameUnits,
pub start: WindowFrameBound,
pub end: WindowFrameBound,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum WindowFrameUnits {
Rows,
Range,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum WindowFrameBound {
UnboundedPreceding,
Preceding(u64),
CurrentRow,
Following(u64),
UnboundedFollowing,
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct LogicalSort {
pub input: Box<LogicalOp>,
pub ordering: LogicalOrdering,
pub tempfiles: bool,
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct LogicalLimit {
pub input: Box<LogicalOp>,
pub limit: Option<LogicalExpr>,
pub start: Option<LogicalExpr>,
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct LogicalProject {
pub input: Box<LogicalOp>,
pub fields: LogicalFields,
pub omit: Vec<LogicalExpr>,
}
impl LogicalProject {
pub fn is_layer(&self) -> bool {
let LogicalFields::Select(fields) = &self.fields else {
return false;
};
if !self.omit.is_empty() {
return false;
}
let [LogicalField::All, columns @ ..] = fields.as_slice() else {
return false;
};
!columns.is_empty()
&& columns.iter().all(|column| {
matches!(
column,
LogicalField::Single {
frame,
..
} if frame.mode != EvalMode::Caller
)
})
}
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct LogicalFetch {
pub input: Box<LogicalOp>,
pub fetches: Vec<LogicalExpr>,
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct LogicalTimeout {
pub input: Box<LogicalOp>,
pub timeout: LogicalExpr,
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct LogicalVersionScope {
pub input: Box<LogicalOp>,
pub version: LogicalExpr,
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct LogicalOnly {
pub input: Box<LogicalOp>,
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct LogicalExplain {
pub input: Box<LogicalOp>,
pub analyze: bool,
pub format: ExplainFormat,
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct LogicalEval {
pub expr: LogicalExpr,
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct LogicalSequence {
pub stmts: Vec<LogicalOp>,
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct LogicalLet {
pub name: String,
pub kind: Option<Kind>,
pub value: Box<LogicalOp>,
pub synthetic: bool,
}
impl LogicalLet {
pub fn is_refused(&self, session: bool) -> bool {
let name = self.name.as_str();
if session {
return surrealdb_cnf::PROTECTED_PARAM_NAMES.contains(&name);
}
surrealdb_cnf::is_refused_local_let_name(name)
&& !(self.synthetic && surrealdb_cnf::SYSTEM_BOUND_PARAM_NAMES.contains(&name))
}
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct LogicalReturn {
pub what: Box<LogicalOp>,
pub fetch: Vec<LogicalExpr>,
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct LogicalForeach {
pub param: Param,
pub range: LogicalExpr,
pub body: Box<LogicalOp>,
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct LogicalIfOp {
pub conditions: Vec<LogicalExpr>,
pub arms: Vec<LogicalOp>,
}
impl LogicalIfOp {
pub fn new(branches: Vec<(LogicalExpr, LogicalOp)>, otherwise: Option<LogicalOp>) -> Self {
let (conditions, mut arms): (Vec<_>, Vec<_>) = branches.into_iter().unzip();
arms.extend(otherwise);
Self {
conditions,
arms,
}
}
pub fn branches(&self) -> impl Iterator<Item = (&LogicalExpr, &LogicalOp)> {
self.conditions.iter().zip(&self.arms)
}
pub fn otherwise(&self) -> Option<&LogicalOp> {
self.arms.get(self.conditions.len())
}
pub fn into_parts(self) -> (Vec<(LogicalExpr, LogicalOp)>, Option<LogicalOp>) {
let mut arms = self.arms;
let otherwise = (arms.len() > self.conditions.len()).then(|| arms.pop()).flatten();
(self.conditions.into_iter().zip(arms).collect(), otherwise)
}
pub fn to_scalar(&self) -> LogicalIf {
let (branches, otherwise) = self.clone().into_parts();
LogicalIf {
branches: branches
.into_iter()
.map(|(condition, arm)| (condition, arm.into_scalar()))
.collect(),
otherwise: otherwise.map(LogicalOp::into_scalar),
}
}
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct LogicalThrow {
pub value: LogicalExpr,
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct LogicalBreak;
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub struct LogicalContinue;
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct LogicalSleep {
pub duration: LogicalExpr,
}
macro_rules! op_kinds {
($($variant:ident),* $(,)?) => {
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum OpKind {
$($variant,)*
}
impl OpKind {
pub const ALL: &'static [OpKind] = &[$(OpKind::$variant,)*];
}
impl LogicalOp {
pub fn kind(&self) -> OpKind {
match self {
$(LogicalOp::$variant(_) => OpKind::$variant,)*
}
}
}
};
}
op_kinds!(
Source,
Values,
Match,
Subquery,
Write,
Ddl,
UnionAll,
Join,
Filter,
PermissionFilter,
Split,
Aggregate,
Distinct,
Window,
Sort,
Limit,
Project,
Fetch,
Timeout,
VersionScope,
Only,
Explain,
Eval,
Sequence,
Let,
Return,
Foreach,
If,
Throw,
Break,
Continue,
Info,
Sleep,
);
impl LogicalOp {
pub fn name(&self) -> &'static str {
match self {
LogicalOp::Source(_) => "Source",
LogicalOp::Values(_) => "Values",
LogicalOp::Match(_) => "Match",
LogicalOp::Subquery(_) => "Subquery",
LogicalOp::Write(_) => "Write",
LogicalOp::Ddl(_) => "Ddl",
LogicalOp::UnionAll(_) => "UnionAll",
LogicalOp::Join(_) => "Join",
LogicalOp::Filter(_) => "Filter",
LogicalOp::PermissionFilter(_) => "PermissionFilter",
LogicalOp::Split(_) => "Split",
LogicalOp::Aggregate(_) => "Aggregate",
LogicalOp::Distinct(_) => "Distinct",
LogicalOp::Window(_) => "Window",
LogicalOp::Sort(_) => "Sort",
LogicalOp::Limit(_) => "Limit",
LogicalOp::Project(_) => "Project",
LogicalOp::Fetch(_) => "Fetch",
LogicalOp::Timeout(_) => "Timeout",
LogicalOp::VersionScope(_) => "VersionScope",
LogicalOp::Only(_) => "Only",
LogicalOp::Explain(_) => "Explain",
LogicalOp::Eval(_) => "Eval",
LogicalOp::Sequence(_) => "Sequence",
LogicalOp::Let(_) => "Let",
LogicalOp::Return(_) => "Return",
LogicalOp::Foreach(_) => "Foreach",
LogicalOp::If(_) => "If",
LogicalOp::Throw(_) => "Throw",
LogicalOp::Break(_) => "Break",
LogicalOp::Continue(_) => "Continue",
LogicalOp::Info(_) => "Info",
LogicalOp::Sleep(_) => "Sleep",
}
}
pub fn children(&self) -> &[LogicalOp] {
match self {
LogicalOp::Source(_)
| LogicalOp::Values(_)
| LogicalOp::Match(_)
| LogicalOp::Eval(_)
| LogicalOp::Throw(_)
| LogicalOp::Break(_)
| LogicalOp::Continue(_)
| LogicalOp::Info(_)
| LogicalOp::Ddl(_)
| LogicalOp::Sleep(_) => &[],
LogicalOp::Write(LogicalWrite {
source: LogicalWriteSource::Rows(input),
..
}) => std::slice::from_ref(input),
LogicalOp::Write(LogicalWrite {
source: LogicalWriteSource::Targets(_) | LogicalWriteSource::Inserts(_),
..
}) => &[],
LogicalOp::UnionAll(LogicalUnionAll {
inputs,
}) => inputs,
LogicalOp::Sequence(LogicalSequence {
stmts,
}) => stmts,
LogicalOp::If(LogicalIfOp {
arms,
..
}) => arms,
LogicalOp::Join(LogicalJoin {
inputs,
..
}) => inputs.as_slice(),
LogicalOp::Subquery(LogicalSubquery {
input,
})
| LogicalOp::Filter(LogicalFilter {
input,
..
})
| LogicalOp::PermissionFilter(LogicalPermissionFilter {
input,
..
})
| LogicalOp::Split(LogicalSplit {
input,
..
})
| LogicalOp::Aggregate(LogicalAggregate {
input,
..
})
| LogicalOp::Distinct(LogicalDistinct {
input,
})
| LogicalOp::Window(LogicalWindow {
input,
..
})
| LogicalOp::Sort(LogicalSort {
input,
..
})
| LogicalOp::Limit(LogicalLimit {
input,
..
})
| LogicalOp::Project(LogicalProject {
input,
..
})
| LogicalOp::Fetch(LogicalFetch {
input,
..
})
| LogicalOp::Timeout(LogicalTimeout {
input,
..
})
| LogicalOp::VersionScope(LogicalVersionScope {
input,
..
})
| LogicalOp::Only(LogicalOnly {
input,
})
| LogicalOp::Explain(LogicalExplain {
input,
..
})
| LogicalOp::Let(LogicalLet {
value: input,
..
})
| LogicalOp::Return(LogicalReturn {
what: input,
..
})
| LogicalOp::Foreach(LogicalForeach {
body: input,
..
}) => std::slice::from_ref(input),
}
}
pub fn children_mut(&mut self) -> &mut [LogicalOp] {
match self {
LogicalOp::Source(_)
| LogicalOp::Values(_)
| LogicalOp::Match(_)
| LogicalOp::Eval(_)
| LogicalOp::Throw(_)
| LogicalOp::Break(_)
| LogicalOp::Continue(_)
| LogicalOp::Info(_)
| LogicalOp::Ddl(_)
| LogicalOp::Sleep(_) => &mut [],
LogicalOp::Write(LogicalWrite {
source: LogicalWriteSource::Rows(input),
..
}) => std::slice::from_mut(input),
LogicalOp::Write(LogicalWrite {
source: LogicalWriteSource::Targets(_) | LogicalWriteSource::Inserts(_),
..
}) => &mut [],
LogicalOp::UnionAll(LogicalUnionAll {
inputs,
}) => inputs,
LogicalOp::Sequence(LogicalSequence {
stmts,
}) => stmts,
LogicalOp::If(LogicalIfOp {
arms,
..
}) => arms,
LogicalOp::Join(LogicalJoin {
inputs,
..
}) => inputs.as_mut_slice(),
LogicalOp::Subquery(LogicalSubquery {
input,
})
| LogicalOp::Filter(LogicalFilter {
input,
..
})
| LogicalOp::PermissionFilter(LogicalPermissionFilter {
input,
..
})
| LogicalOp::Split(LogicalSplit {
input,
..
})
| LogicalOp::Aggregate(LogicalAggregate {
input,
..
})
| LogicalOp::Distinct(LogicalDistinct {
input,
})
| LogicalOp::Window(LogicalWindow {
input,
..
})
| LogicalOp::Sort(LogicalSort {
input,
..
})
| LogicalOp::Limit(LogicalLimit {
input,
..
})
| LogicalOp::Project(LogicalProject {
input,
..
})
| LogicalOp::Fetch(LogicalFetch {
input,
..
})
| LogicalOp::Timeout(LogicalTimeout {
input,
..
})
| LogicalOp::VersionScope(LogicalVersionScope {
input,
..
})
| LogicalOp::Only(LogicalOnly {
input,
})
| LogicalOp::Explain(LogicalExplain {
input,
..
})
| LogicalOp::Let(LogicalLet {
value: input,
..
})
| LogicalOp::Return(LogicalReturn {
what: input,
..
})
| LogicalOp::Foreach(LogicalForeach {
body: input,
..
}) => std::slice::from_mut(input),
}
}
pub fn map_children<E>(
self,
mut f: impl FnMut(LogicalOp) -> Result<LogicalOp, E>,
) -> Result<Self, E> {
let boxed = |input: Box<LogicalOp>,
f: &mut dyn FnMut(LogicalOp) -> Result<LogicalOp, E>| {
f(*input).map(Box::new)
};
Ok(match self {
leaf @ (LogicalOp::Source(_)
| LogicalOp::Values(_)
| LogicalOp::Match(_)
| LogicalOp::Eval(_)
| LogicalOp::Throw(_)
| LogicalOp::Break(_)
| LogicalOp::Continue(_)
| LogicalOp::Info(_)
| LogicalOp::Ddl(_)
| LogicalOp::Sleep(_)) => leaf,
LogicalOp::Write(LogicalWrite {
statement,
source,
data,
duplicate_update,
cond,
trace,
}) => LogicalOp::Write(LogicalWrite {
statement,
data,
duplicate_update,
cond,
source: match source {
LogicalWriteSource::Rows(input) => {
LogicalWriteSource::Rows(Box::new(f(*input)?))
}
leaf @ (LogicalWriteSource::Targets(_) | LogicalWriteSource::Inserts(_)) => {
leaf
}
},
trace,
}),
LogicalOp::UnionAll(LogicalUnionAll {
inputs,
}) => LogicalOp::UnionAll(LogicalUnionAll {
inputs: inputs.into_iter().map(f).collect::<Result<_, E>>()?,
}),
LogicalOp::Sequence(LogicalSequence {
stmts,
}) => LogicalOp::Sequence(LogicalSequence {
stmts: stmts.into_iter().map(f).collect::<Result<_, E>>()?,
}),
LogicalOp::If(LogicalIfOp {
conditions,
arms,
}) => LogicalOp::If(LogicalIfOp {
conditions,
arms: arms.into_iter().map(f).collect::<Result<_, E>>()?,
}),
LogicalOp::Join(mut op) => {
let [left, right] = *op.inputs;
op.inputs = Box::new([f(left)?, f(right)?]);
LogicalOp::Join(op)
}
LogicalOp::Subquery(mut op) => {
op.input = boxed(op.input, &mut f)?;
LogicalOp::Subquery(op)
}
LogicalOp::Filter(mut op) => {
op.input = boxed(op.input, &mut f)?;
LogicalOp::Filter(op)
}
LogicalOp::PermissionFilter(mut op) => {
op.input = boxed(op.input, &mut f)?;
LogicalOp::PermissionFilter(op)
}
LogicalOp::Split(mut op) => {
op.input = boxed(op.input, &mut f)?;
LogicalOp::Split(op)
}
LogicalOp::Aggregate(mut op) => {
op.input = boxed(op.input, &mut f)?;
LogicalOp::Aggregate(op)
}
LogicalOp::Distinct(mut op) => {
op.input = boxed(op.input, &mut f)?;
LogicalOp::Distinct(op)
}
LogicalOp::Window(mut op) => {
op.input = boxed(op.input, &mut f)?;
LogicalOp::Window(op)
}
LogicalOp::Sort(mut op) => {
op.input = boxed(op.input, &mut f)?;
LogicalOp::Sort(op)
}
LogicalOp::Limit(mut op) => {
op.input = boxed(op.input, &mut f)?;
LogicalOp::Limit(op)
}
LogicalOp::Project(mut op) => {
op.input = boxed(op.input, &mut f)?;
LogicalOp::Project(op)
}
LogicalOp::Fetch(mut op) => {
op.input = boxed(op.input, &mut f)?;
LogicalOp::Fetch(op)
}
LogicalOp::Timeout(mut op) => {
op.input = boxed(op.input, &mut f)?;
LogicalOp::Timeout(op)
}
LogicalOp::VersionScope(mut op) => {
op.input = boxed(op.input, &mut f)?;
LogicalOp::VersionScope(op)
}
LogicalOp::Only(mut op) => {
op.input = boxed(op.input, &mut f)?;
LogicalOp::Only(op)
}
LogicalOp::Explain(mut op) => {
op.input = boxed(op.input, &mut f)?;
LogicalOp::Explain(op)
}
LogicalOp::Let(mut op) => {
op.value = boxed(op.value, &mut f)?;
LogicalOp::Let(op)
}
LogicalOp::Return(mut op) => {
op.what = boxed(op.what, &mut f)?;
LogicalOp::Return(op)
}
LogicalOp::Foreach(mut op) => {
op.body = boxed(op.body, &mut f)?;
LogicalOp::Foreach(op)
}
})
}
pub fn transform_up<E>(
self,
f: &mut impl FnMut(LogicalOp) -> Result<LogicalOp, E>,
) -> Result<Self, E> {
self.transform_up_dyn(f)
}
fn transform_up_dyn<E>(
self,
f: &mut dyn FnMut(LogicalOp) -> Result<LogicalOp, E>,
) -> Result<Self, E> {
let node = self.map_children(|child| child.transform_up_dyn(&mut *f))?;
f(node)
}
pub fn transform_down<E>(
self,
f: &mut impl FnMut(LogicalOp) -> Result<LogicalOp, E>,
) -> Result<Self, E> {
self.transform_down_dyn(f)
}
fn transform_down_dyn<E>(
self,
f: &mut dyn FnMut(LogicalOp) -> Result<LogicalOp, E>,
) -> Result<Self, E> {
f(self)?.map_children(|child| child.transform_down_dyn(&mut *f))
}
pub fn visit<'a, B>(
&'a self,
f: &mut impl FnMut(&'a LogicalOp) -> ControlFlow<B>,
) -> ControlFlow<B> {
self.visit_dyn(f)
}
fn visit_dyn<'a, B>(
&'a self,
f: &mut dyn FnMut(&'a LogicalOp) -> ControlFlow<B>,
) -> ControlFlow<B> {
f(self)?;
for child in self.children() {
child.visit_dyn(&mut *f)?;
}
ControlFlow::Continue(())
}
pub fn for_each_scalar<'a>(&'a self, out: &mut dyn FnMut(&'a LogicalExpr)) {
match self {
LogicalOp::Write(write) => write.for_each_scalar(out),
LogicalOp::Ddl(_) => {}
LogicalOp::Source(LogicalSource {
source,
..
}) => source.for_each_expr(out),
LogicalOp::Values(LogicalValues {
expr,
..
})
| LogicalOp::Eval(LogicalEval {
expr,
})
| LogicalOp::Timeout(LogicalTimeout {
timeout: expr,
..
})
| LogicalOp::VersionScope(LogicalVersionScope {
version: expr,
..
})
| LogicalOp::Foreach(LogicalForeach {
range: expr,
..
})
| LogicalOp::Sleep(LogicalSleep {
duration: expr,
})
| LogicalOp::Throw(LogicalThrow {
value: expr,
}) => out(expr),
LogicalOp::If(LogicalIfOp {
conditions,
..
}) => {
for condition in conditions {
out(condition);
}
}
LogicalOp::Match(LogicalMatch {
plan,
}) => {
for e in plan.scalars() {
out(e);
}
}
LogicalOp::Subquery(_)
| LogicalOp::UnionAll(_)
| LogicalOp::Distinct(_)
| LogicalOp::Only(_)
| LogicalOp::Explain(_)
| LogicalOp::Sequence(_)
| LogicalOp::Let(_)
| LogicalOp::Break(_)
| LogicalOp::Continue(_) => {}
LogicalOp::Filter(LogicalFilter {
predicate,
..
})
| LogicalOp::PermissionFilter(LogicalPermissionFilter {
predicate,
..
}) => out(predicate),
LogicalOp::Join(LogicalJoin {
on,
filter,
..
}) => {
for (left, right) in on {
out(left);
out(right);
}
if let Some(e) = filter {
out(e);
}
}
LogicalOp::Split(LogicalSplit {
exprs,
..
}) => {
for e in exprs {
out(e);
}
}
LogicalOp::Aggregate(LogicalAggregate {
group,
fields,
..
}) => {
for e in group {
out(e);
}
fields.for_each_expr(out);
}
LogicalOp::Window(window) => window.for_each_expr(out),
LogicalOp::Sort(LogicalSort {
ordering,
..
}) => ordering.for_each_expr(out),
LogicalOp::Limit(LogicalLimit {
limit,
start,
..
}) => {
if let Some(e) = limit {
out(e);
}
if let Some(e) = start {
out(e);
}
}
LogicalOp::Project(LogicalProject {
fields,
omit,
..
}) => {
fields.for_each_expr(out);
for e in omit {
out(e);
}
}
LogicalOp::Fetch(LogicalFetch {
fetches,
..
})
| LogicalOp::Return(LogicalReturn {
fetch: fetches,
..
}) => {
for e in fetches {
out(e);
}
}
LogicalOp::Info(info) => info.for_each_expr(out),
}
}
pub fn scalars(&self) -> Vec<&LogicalExpr> {
let mut out = Vec::new();
self.for_each_scalar(&mut |scalar| out.push(scalar));
out
}
pub fn scalars_mut(&mut self) -> Vec<&mut LogicalExpr> {
let mut out = Vec::new();
match self {
LogicalOp::Write(LogicalWrite {
source,
data,
duplicate_update,
cond,
..
}) => {
match source {
LogicalWriteSource::Targets(targets) => out.extend(targets.iter_mut()),
LogicalWriteSource::Inserts(inserts) => {
out.extend(inserts.into.iter_mut());
match &mut inserts.rows {
LogicalInsertRows::Tuples(tuples) => out.extend(
tuples
.iter_mut()
.flat_map(|tuple| tuple.iter_mut().map(|(_, v)| v)),
),
LogicalInsertRows::Value(expr) => out.push(expr),
}
}
LogicalWriteSource::Rows(_) => {}
}
for clause in [data, duplicate_update] {
out.extend(clause.iter_mut().flat_map(LogicalData::values_mut));
}
out.extend(cond.iter_mut());
}
LogicalOp::Ddl(_) => {}
LogicalOp::Source(LogicalSource {
source,
..
}) => source.exprs_mut(&mut out),
LogicalOp::Values(LogicalValues {
expr,
..
})
| LogicalOp::Eval(LogicalEval {
expr,
})
| LogicalOp::Timeout(LogicalTimeout {
timeout: expr,
..
})
| LogicalOp::VersionScope(LogicalVersionScope {
version: expr,
..
})
| LogicalOp::Foreach(LogicalForeach {
range: expr,
..
})
| LogicalOp::Sleep(LogicalSleep {
duration: expr,
})
| LogicalOp::Throw(LogicalThrow {
value: expr,
}) => out.push(expr),
LogicalOp::If(LogicalIfOp {
conditions,
..
}) => out.extend(conditions),
LogicalOp::Match(LogicalMatch {
plan,
}) => out.extend(plan.scalars_mut()),
LogicalOp::Subquery(_)
| LogicalOp::UnionAll(_)
| LogicalOp::Distinct(_)
| LogicalOp::Only(_)
| LogicalOp::Explain(_)
| LogicalOp::Sequence(_)
| LogicalOp::Let(_)
| LogicalOp::Break(_)
| LogicalOp::Continue(_) => {}
LogicalOp::Filter(LogicalFilter {
predicate,
..
})
| LogicalOp::PermissionFilter(LogicalPermissionFilter {
predicate,
..
}) => out.push(predicate),
LogicalOp::Join(LogicalJoin {
on,
filter,
..
}) => {
for (left, right) in on {
out.push(left);
out.push(right);
}
out.extend(filter);
}
LogicalOp::Split(LogicalSplit {
exprs,
..
}) => out.extend(exprs),
LogicalOp::Aggregate(LogicalAggregate {
group,
fields,
..
}) => {
out.extend(group);
fields.exprs_mut(&mut out);
}
LogicalOp::Window(window) => window.exprs_mut(&mut out),
LogicalOp::Sort(LogicalSort {
ordering,
..
}) => ordering.exprs_mut(&mut out),
LogicalOp::Limit(LogicalLimit {
limit,
start,
..
}) => {
out.extend(limit);
out.extend(start);
}
LogicalOp::Project(LogicalProject {
fields,
omit,
..
}) => {
fields.exprs_mut(&mut out);
out.extend(omit);
}
LogicalOp::Fetch(LogicalFetch {
fetches,
..
})
| LogicalOp::Return(LogicalReturn {
fetch: fetches,
..
}) => out.extend(fetches),
LogicalOp::Info(info) => info.exprs_mut(&mut out),
}
out
}
pub fn visit_scalars<E>(
&self,
f: &mut impl FnMut(&LogicalExpr) -> Result<(), E>,
) -> Result<(), E> {
let mut result = Ok(());
self.for_each_scalar(&mut |scalar| {
if result.is_ok() {
result = f(scalar);
}
});
result
}
pub fn visit_scalars_mut<E>(
&mut self,
f: &mut impl FnMut(&mut LogicalExpr) -> Result<(), E>,
) -> Result<(), E> {
self.scalars_mut().into_iter().try_for_each(f)
}
pub fn visit_scalars_deep<E>(
&self,
f: &mut impl FnMut(&LogicalExpr) -> Result<(), E>,
) -> Result<(), E> {
self.visit_scalars_deep_dyn(f)
}
fn visit_scalars_deep_dyn<E>(
&self,
mut f: &mut dyn FnMut(&LogicalExpr) -> Result<(), E>,
) -> Result<(), E> {
self.visit_scalars(&mut f)?;
self.children().iter().try_for_each(|child| child.visit_scalars_deep_dyn(&mut *f))
}
pub fn visit_scalars_deep_mut<E>(
&mut self,
f: &mut impl FnMut(&mut LogicalExpr) -> Result<(), E>,
) -> Result<(), E> {
self.visit_scalars_deep_mut_dyn(f)
}
fn visit_scalars_deep_mut_dyn<E>(
&mut self,
mut f: &mut dyn FnMut(&mut LogicalExpr) -> Result<(), E>,
) -> Result<(), E> {
self.visit_scalars_mut(&mut f)?;
self.children_mut()
.iter_mut()
.try_for_each(|child| child.visit_scalars_deep_mut_dyn(&mut *f))
}
pub fn visit_ops_deep<'a, B>(
&'a self,
f: &mut impl FnMut(&'a LogicalOp) -> ControlFlow<B>,
) -> ControlFlow<B> {
fn walk_op<'a, B>(
op: &'a LogicalOp,
f: &mut dyn FnMut(&'a LogicalOp) -> ControlFlow<B>,
) -> ControlFlow<B> {
f(op)?;
let mut flow = ControlFlow::Continue(());
op.for_each_scalar(&mut |scalar| {
if flow.is_continue() {
flow = walk_scalar(scalar, &mut *f);
}
});
flow?;
for child in op.children() {
walk_op(child, &mut *f)?;
}
ControlFlow::Continue(())
}
fn walk_scalar<'a, B>(
expr: &'a LogicalExpr,
f: &mut dyn FnMut(&'a LogicalOp) -> ControlFlow<B>,
) -> ControlFlow<B> {
if let LogicalExpr::Subquery(plan) = expr {
return walk_op(plan, f);
}
if matches!(expr, LogicalExpr::Closure(_)) {
return ControlFlow::Continue(());
}
let mut flow = ControlFlow::Continue(());
expr.for_each_child(&mut |child| {
if flow.is_continue() {
flow = walk_scalar(child, &mut *f);
}
});
flow
}
walk_op(self, f)
}
pub fn any(&self, mut pred: impl FnMut(&LogicalOp) -> bool) -> bool {
self.visit(&mut |node| {
if pred(node) {
ControlFlow::Break(())
} else {
ControlFlow::Continue(())
}
})
.is_break()
}
pub fn into_scalar(self) -> LogicalExpr {
match self {
LogicalOp::Eval(LogicalEval {
expr,
}) => expr,
LogicalOp::If(op) => LogicalExpr::If(Box::new(op.to_scalar())),
LogicalOp::Throw(LogicalThrow {
value,
}) => LogicalExpr::Throw(Box::new(value)),
LogicalOp::Break(_) => LogicalExpr::Break,
LogicalOp::Continue(_) => LogicalExpr::Continue,
other @ (LogicalOp::Source(_)
| LogicalOp::Values(_)
| LogicalOp::Match(_)
| LogicalOp::Subquery(_)
| LogicalOp::Write(_)
| LogicalOp::Ddl(_)
| LogicalOp::UnionAll(_)
| LogicalOp::Join(_)
| LogicalOp::Filter(_)
| LogicalOp::PermissionFilter(_)
| LogicalOp::Split(_)
| LogicalOp::Aggregate(_)
| LogicalOp::Distinct(_)
| LogicalOp::Window(_)
| LogicalOp::Sort(_)
| LogicalOp::Limit(_)
| LogicalOp::Project(_)
| LogicalOp::Fetch(_)
| LogicalOp::Timeout(_)
| LogicalOp::VersionScope(_)
| LogicalOp::Only(_)
| LogicalOp::Explain(_)
| LogicalOp::Sequence(_)
| LogicalOp::Let(_)
| LogicalOp::Return(_)
| LogicalOp::Foreach(_)
| LogicalOp::Info(_)
| LogicalOp::Sleep(_)) => LogicalExpr::Subquery(Box::new(other)),
}
}
pub fn read_only(&self) -> bool {
!self.any(|node| !node.node_read_only())
}
fn node_read_only(&self) -> bool {
match self {
LogicalOp::Write(_) | LogicalOp::Ddl(_) => false,
LogicalOp::Source(LogicalSource {
source,
for_update,
..
}) => !*for_update && source.read_only(),
LogicalOp::Values(LogicalValues {
expr,
for_update,
..
}) => !*for_update && expr.read_only(),
LogicalOp::Match(LogicalMatch {
plan,
}) => !plan.has_mutations() && plan.scalars().into_iter().all(LogicalExpr::read_only),
LogicalOp::Split(LogicalSplit {
exprs,
..
}) => exprs.iter().all(LogicalExpr::read_only),
LogicalOp::Aggregate(LogicalAggregate {
group,
fields,
..
}) => group.iter().all(LogicalExpr::read_only) && fields.read_only(),
LogicalOp::Window(window) => window.read_only(),
LogicalOp::Sort(LogicalSort {
ordering,
..
}) => ordering.read_only(),
LogicalOp::Project(LogicalProject {
fields,
omit,
..
}) => fields.read_only() && omit.iter().all(LogicalExpr::read_only),
LogicalOp::Subquery(_)
| LogicalOp::UnionAll(_)
| LogicalOp::Join(_)
| LogicalOp::Filter(_)
| LogicalOp::PermissionFilter(_)
| LogicalOp::Distinct(_)
| LogicalOp::Limit(_)
| LogicalOp::Fetch(_)
| LogicalOp::Timeout(_)
| LogicalOp::VersionScope(_)
| LogicalOp::Only(_)
| LogicalOp::Explain(_)
| LogicalOp::Eval(_)
| LogicalOp::Sequence(_)
| LogicalOp::Let(_)
| LogicalOp::Return(_)
| LogicalOp::Foreach(_)
| LogicalOp::If(_)
| LogicalOp::Throw(_)
| LogicalOp::Break(_)
| LogicalOp::Continue(_)
| LogicalOp::Info(_)
| LogicalOp::Sleep(_) => self.scalars().into_iter().all(LogicalExpr::read_only),
}
}
pub fn schema(&self) -> Schema {
match self {
LogicalOp::Write(_) => Schema::open(),
LogicalOp::Source(LogicalSource {
schema,
..
}) => schema.as_deref().cloned().unwrap_or_else(Schema::open),
LogicalOp::Fetch(LogicalFetch {
input,
fetches,
}) => {
let mut schema = input.schema();
for fetch in fetches {
let Some(root) = fetch_root(fetch) else {
return Schema::open();
};
for field in &mut schema.fields {
if field.path.root() == Some(root) {
field.kind = Kind::Any;
}
}
}
schema
}
LogicalOp::Values(_)
| LogicalOp::Match(_)
| LogicalOp::Explain(_)
| LogicalOp::Eval(_)
| LogicalOp::Sequence(_)
| LogicalOp::Let(_)
| LogicalOp::Return(_)
| LogicalOp::Foreach(_)
| LogicalOp::If(_)
| LogicalOp::Throw(_)
| LogicalOp::Break(_)
| LogicalOp::Continue(_)
| LogicalOp::Info(_)
| LogicalOp::Ddl(_)
| LogicalOp::Sleep(_) => Schema::open(),
LogicalOp::Window(window) => window.schema(),
LogicalOp::Subquery(LogicalSubquery {
input,
})
| LogicalOp::Filter(LogicalFilter {
input,
..
})
| LogicalOp::PermissionFilter(LogicalPermissionFilter {
input,
..
})
| LogicalOp::Distinct(LogicalDistinct {
input,
})
| LogicalOp::Sort(LogicalSort {
input,
..
})
| LogicalOp::Limit(LogicalLimit {
input,
..
})
| LogicalOp::Timeout(LogicalTimeout {
input,
..
})
| LogicalOp::VersionScope(LogicalVersionScope {
input,
..
})
| LogicalOp::Only(LogicalOnly {
input,
}) => input.schema(),
LogicalOp::Join(join) => {
let mut schema = join.left().schema();
if !join.kind.adds_right_row() {
return schema;
}
let matched = match join.right_table() {
Some(table) => Kind::Record(vec![table.clone()]),
None => Kind::Any,
};
let kind = match join.kind {
JoinKind::Left if matched != Kind::Any => {
Kind::either(vec![Kind::Null, matched])
}
JoinKind::Inner | JoinKind::Left | JoinKind::Semi | JoinKind::Anti => matched,
};
let path = FieldPath::field(join.alias.name().clone());
schema.fields.retain(|field| field.path != path);
schema.fields.push(FieldSchema::new(path, kind));
schema
}
LogicalOp::UnionAll(LogicalUnionAll {
inputs,
}) => {
let schemas: Vec<Schema> = inputs.iter().map(LogicalOp::schema).collect();
let mut out = Schema::closed(Vec::new());
for schema in &schemas {
if schema.is_open() {
out.openness = Openness::Open;
}
for field in &schema.fields {
if out.field(&field.path).is_none() {
let mut merged = field.clone();
merged.kind = union_kind(&schemas, &field.path);
merged.checked = schemas.iter().all(|schema| {
schema
.field(&field.path)
.is_some_and(|f| f.checked && f.kind == merged.kind)
});
out.fields.push(merged);
}
}
}
out
}
LogicalOp::Split(LogicalSplit {
input,
exprs,
}) => {
let mut schema = input.schema();
for path in exprs.iter().filter_map(LogicalExpr::field_path) {
if let Some(field) = schema.fields.iter_mut().find(|f| f.path == path) {
field.kind = element_kind(&field.kind);
}
}
schema
}
LogicalOp::Aggregate(LogicalAggregate {
input,
fields,
..
}) => project_schema(fields, &input.schema()),
LogicalOp::Project(LogicalProject {
input,
fields,
omit,
}) => {
let input = input.schema();
if self.is_layer() {
return layer_schema(fields, input);
}
let mut schema = project_schema(fields, &input);
schema.fields.retain(|field| {
!omit.iter().any(|o| o.field_path().as_ref() == Some(&field.path))
});
schema
}
}
}
pub fn inherits_row(&self) -> bool {
match self {
LogicalOp::Eval(_)
| LogicalOp::Sequence(_)
| LogicalOp::Let(_)
| LogicalOp::Return(_)
| LogicalOp::Foreach(_)
| LogicalOp::If(_)
| LogicalOp::Throw(_)
| LogicalOp::Break(_)
| LogicalOp::Continue(_)
| LogicalOp::Info(_)
| LogicalOp::Ddl(_)
| LogicalOp::Sleep(_)
| LogicalOp::Explain(_) => true,
LogicalOp::Source(_)
| LogicalOp::Values(_)
| LogicalOp::Match(_)
| LogicalOp::Subquery(_)
| LogicalOp::Write(_)
| LogicalOp::UnionAll(_)
| LogicalOp::Join(_)
| LogicalOp::Filter(_)
| LogicalOp::PermissionFilter(_)
| LogicalOp::Split(_)
| LogicalOp::Aggregate(_)
| LogicalOp::Distinct(_)
| LogicalOp::Window(_)
| LogicalOp::Sort(_)
| LogicalOp::Limit(_)
| LogicalOp::Project(_)
| LogicalOp::Fetch(_)
| LogicalOp::Timeout(_)
| LogicalOp::VersionScope(_)
| LogicalOp::Only(_) => false,
}
}
pub fn is_layer(&self) -> bool {
match self {
LogicalOp::Project(project) => project.is_layer(),
LogicalOp::Source(_)
| LogicalOp::Values(_)
| LogicalOp::Match(_)
| LogicalOp::Subquery(_)
| LogicalOp::Write(_)
| LogicalOp::UnionAll(_)
| LogicalOp::Join(_)
| LogicalOp::Filter(_)
| LogicalOp::PermissionFilter(_)
| LogicalOp::Split(_)
| LogicalOp::Aggregate(_)
| LogicalOp::Distinct(_)
| LogicalOp::Window(_)
| LogicalOp::Sort(_)
| LogicalOp::Limit(_)
| LogicalOp::Fetch(_)
| LogicalOp::Timeout(_)
| LogicalOp::VersionScope(_)
| LogicalOp::Only(_)
| LogicalOp::Explain(_)
| LogicalOp::Eval(_)
| LogicalOp::Sequence(_)
| LogicalOp::Let(_)
| LogicalOp::Return(_)
| LogicalOp::Foreach(_)
| LogicalOp::If(_)
| LogicalOp::Throw(_)
| LogicalOp::Break(_)
| LogicalOp::Continue(_)
| LogicalOp::Info(_)
| LogicalOp::Ddl(_)
| LogicalOp::Sleep(_) => false,
}
}
fn attrs(&self) -> Vec<String> {
match self {
LogicalOp::Write(LogicalWrite {
statement,
..
}) => {
let mut out = vec![statement.kind().to_string()];
if statement.only() {
out.push("ONLY".to_string());
}
out
}
LogicalOp::Source(LogicalSource {
source,
with,
for_update,
..
}) => {
let mut out = vec![source.to_sql()];
if let Some(w) = with {
out.push(w.to_sql());
}
if *for_update {
out.push("FOR UPDATE".to_string());
}
out
}
LogicalOp::Values(LogicalValues {
expr,
for_update,
..
}) => {
let mut out = vec![expr.to_sql()];
if *for_update {
out.push("FOR UPDATE".to_string());
}
out
}
LogicalOp::Eval(LogicalEval {
expr,
}) => vec![expr.to_sql()],
LogicalOp::Match(LogicalMatch {
plan,
}) => vec![plan.to_sql()],
LogicalOp::Subquery(_)
| LogicalOp::UnionAll(_)
| LogicalOp::Distinct(_)
| LogicalOp::Only(_)
| LogicalOp::Sequence(_) => vec![],
LogicalOp::Explain(LogicalExplain {
analyze,
format,
..
}) => {
let mut out = Vec::new();
if *analyze {
out.push("ANALYZE".to_string());
}
match format {
ExplainFormat::Text => {}
ExplainFormat::Json => out.push("FORMAT JSON".to_string()),
}
out
}
LogicalOp::Filter(LogicalFilter {
predicate,
..
}) => vec![predicate.to_sql()],
LogicalOp::PermissionFilter(LogicalPermissionFilter {
predicate,
auth,
..
}) => {
let mut out = vec![predicate.to_sql()];
if let Some(auth) = auth {
out.push(render_auth(auth));
}
out
}
LogicalOp::Join(LogicalJoin {
kind,
on,
filter,
alias,
frame,
..
}) => {
let mut out = vec![format!("{} AS {}", kind.as_str(), alias.name())];
if !on.is_empty() {
let keys = on
.iter()
.map(|(left, right)| format!("{} = {}", left.to_sql(), right.to_sql()))
.collect::<Vec<_>>()
.join(" AND ");
out.push(format!("ON {keys}"));
}
if let Some(filter) = filter {
out.push(format!("WHERE {}", filter.to_sql()));
}
out.extend(render_frame(frame));
out
}
LogicalOp::Split(LogicalSplit {
exprs,
..
}) => exprs.iter().map(ToSql::to_sql).collect(),
LogicalOp::Aggregate(LogicalAggregate {
group,
fields,
..
}) => {
let by = if group.is_empty() {
"ALL".to_string()
} else {
group.iter().map(ToSql::to_sql).collect::<Vec<_>>().join(", ")
};
vec![format!("BY {by}"), fields.to_sql()]
}
LogicalOp::Window(window) => window.attrs(),
LogicalOp::Sort(LogicalSort {
ordering,
tempfiles,
..
}) => {
let mut out = vec![ordering.to_sql()];
if *tempfiles {
out.push("TEMPFILES".to_string());
}
out
}
LogicalOp::Limit(LogicalLimit {
limit,
start,
..
}) => {
let mut out = Vec::new();
if let Some(l) = limit {
out.push(format!("LIMIT {}", l.to_sql()));
}
if let Some(s) = start {
out.push(format!("START {}", s.to_sql()));
}
out
}
LogicalOp::Project(LogicalProject {
fields,
omit,
..
}) => {
let mut out = vec![fields.to_sql()];
if !omit.is_empty() {
out.push(format!(
"OMIT {}",
omit.iter().map(ToSql::to_sql).collect::<Vec<_>>().join(", ")
));
}
out
}
LogicalOp::Fetch(LogicalFetch {
fetches,
..
}) => fetches.iter().map(ToSql::to_sql).collect(),
LogicalOp::Timeout(LogicalTimeout {
timeout,
..
}) => vec![timeout.to_sql()],
LogicalOp::VersionScope(LogicalVersionScope {
version,
..
}) => vec![version.to_sql()],
LogicalOp::Let(LogicalLet {
name,
kind,
..
}) => {
let mut out = format!("${name}");
if let Some(kind) = kind {
out.push_str(&format!(" : {}", kind.to_sql()));
}
vec![out]
}
LogicalOp::Return(LogicalReturn {
fetch,
..
}) => {
if fetch.is_empty() {
vec![]
} else {
vec![format!(
"FETCH {}",
fetch.iter().map(ToSql::to_sql).collect::<Vec<_>>().join(", ")
)]
}
}
LogicalOp::Foreach(LogicalForeach {
param,
range,
..
}) => vec![format!("{} IN {}", param.to_sql(), range.to_sql())],
LogicalOp::If(op) => {
let mut out: Vec<String> = op.conditions.iter().map(ToSql::to_sql).collect();
if op.otherwise().is_some() {
out.push("ELSE".to_string());
}
out
}
LogicalOp::Throw(LogicalThrow {
value,
}) => vec![value.to_sql()],
LogicalOp::Break(_) | LogicalOp::Continue(_) => vec![],
LogicalOp::Info(info) => vec![info.to_sql()],
LogicalOp::Ddl(ddl) => vec![ddl.statement.kind().to_string()],
LogicalOp::Sleep(LogicalSleep {
duration,
}) => vec![duration.to_sql()],
}
}
fn render(&self, f: &mut String, depth: usize) {
let indent = " ".repeat(depth);
f.push_str(&indent);
f.push_str(self.name());
let attrs = self.attrs();
if !attrs.is_empty() {
f.push('[');
for (i, line) in attrs.join(" ").split('\n').enumerate() {
if i > 0 {
f.push('\n');
f.push_str(&indent);
}
f.push_str(line);
}
f.push(']');
}
f.push('\n');
for child in self.children() {
child.render(f, depth + 1);
}
}
}
fn fetch_root(fetch: &LogicalExpr) -> Option<&surrealdb_strand::Strand> {
if let LogicalExpr::Field(name) = fetch.path_root() {
Some(name)
} else {
None
}
}
fn leaf_table(mut op: &LogicalOp) -> Option<&TableName> {
loop {
match op.children() {
[] => {
return match op {
LogicalOp::Source(LogicalSource {
source: SourceRef::Table(table),
..
}) => Some(table),
LogicalOp::Source(_)
| LogicalOp::Values(_)
| LogicalOp::Match(_)
| LogicalOp::Subquery(_)
| LogicalOp::Write(_)
| LogicalOp::UnionAll(_)
| LogicalOp::Join(_)
| LogicalOp::Filter(_)
| LogicalOp::PermissionFilter(_)
| LogicalOp::Split(_)
| LogicalOp::Aggregate(_)
| LogicalOp::Distinct(_)
| LogicalOp::Window(_)
| LogicalOp::Sort(_)
| LogicalOp::Limit(_)
| LogicalOp::Project(_)
| LogicalOp::Fetch(_)
| LogicalOp::Timeout(_)
| LogicalOp::VersionScope(_)
| LogicalOp::Only(_)
| LogicalOp::Explain(_)
| LogicalOp::Eval(_)
| LogicalOp::Sequence(_)
| LogicalOp::Let(_)
| LogicalOp::Return(_)
| LogicalOp::Foreach(_)
| LogicalOp::If(_)
| LogicalOp::Throw(_)
| LogicalOp::Break(_)
| LogicalOp::Continue(_)
| LogicalOp::Info(_)
| LogicalOp::Ddl(_)
| LogicalOp::Sleep(_) => None,
};
}
[input] => op = input,
_ => return None,
}
}
}
fn element_kind(kind: &Kind) -> Kind {
match kind {
Kind::Named(_) => Kind::Any,
Kind::Array(inner, _) | Kind::Set(inner, _) => (**inner).clone(),
Kind::Either(kinds) => Kind::either(kinds.iter().map(element_kind).collect()),
Kind::Any | Kind::Literal(_) => Kind::Any,
Kind::None
| Kind::Null
| Kind::Bool
| Kind::Bytes
| Kind::Datetime
| Kind::Date
| Kind::Time
| Kind::Timestamp
| Kind::Interval
| Kind::Decimal
| Kind::BigDecimal
| Kind::Duration
| Kind::Float
| Kind::Int
| Kind::I8
| Kind::U8
| Kind::I16
| Kind::U16
| Kind::I32
| Kind::U32
| Kind::U64
| Kind::F16
| Kind::F32
| Kind::Number
| Kind::Object
| Kind::String
| Kind::Uuid
| Kind::Regex
| Kind::Table(_)
| Kind::Record(_)
| Kind::Geometry(_)
| Kind::Function(..)
| Kind::Range
| Kind::File(_)
| Kind::Enum(_) => kind.clone(),
}
}
fn union_kind(inputs: &[Schema], path: &FieldPath) -> Kind {
let mut kind: Option<Kind> = None;
let mut absent = false;
for input in inputs {
match input.field(path) {
Some(field) => match &kind {
None => kind = Some(field.kind.clone()),
Some(seen) if *seen == field.kind => {}
Some(_) => return Kind::Any,
},
None if input.is_open() => return Kind::Any,
None => absent = true,
}
}
match kind {
Some(kind) if absent && kind != Kind::Any => Kind::option(kind),
Some(kind) => kind,
None => Kind::Any,
}
}
fn layer_schema(fields: &LogicalFields, mut input: Schema) -> Schema {
let LogicalFields::Select(fields) = fields else {
return input;
};
for field in fields {
let LogicalField::Single {
expr,
alias,
kind,
frame,
} = field
else {
continue;
};
let path = match alias {
Some(alias) => FieldPath::from(alias),
None => FieldPath::from(&expr.output_path()),
};
let (kind, checked) = match kind {
Some(kind) if frame.mode == EvalMode::Permission => (Kind::option(kind.clone()), false),
Some(kind) => (kind.clone(), true),
None => match input.field(&path).map(|declared| &declared.kind) {
Some(declared) if frame.mode == EvalMode::Permission && *declared != Kind::Any => {
(Kind::option(declared.clone()), false)
}
Some(_) | None if frame.mode == EvalMode::Permission => (expr.kind(&input), false),
Some(_) | None => (expr.kind(&input), expr.checked_kind(&input).is_some()),
},
};
match input.field_mut(&path) {
Some(declared) => {
declared.kind = kind;
declared.checked = checked;
}
None => {
let mut field = FieldSchema::new(path, kind);
field.checked = checked;
input.fields.push(field);
}
}
}
input
}
fn project_schema(fields: &LogicalFields, input: &Schema) -> Schema {
let selected = match fields {
LogicalFields::Value {
..
} => return Schema::open(),
LogicalFields::Select(selected) => selected,
};
let mut out = Schema::closed(Vec::new());
for field in selected {
match field {
LogicalField::All => {
out.openness = input.openness;
for field in &input.fields {
if out.field(&field.path).is_none() {
out.fields.push(field.clone());
}
}
}
LogicalField::Single {
expr,
alias,
kind,
..
} => {
let path = match alias {
Some(alias) => FieldPath::from(alias),
None => FieldPath::from(&expr.output_path()),
};
let (kind, checked) = match kind {
Some(kind) => (kind.clone(), false),
None => (expr.kind(input), expr.checked_kind(input).is_some()),
};
out.fields.retain(|f| f.path != path);
let mut field = FieldSchema::new(path, kind);
field.checked = checked;
out.fields.push(field);
}
}
}
out
}
fn render_auth(auth: &AuthLimit) -> String {
format!("@auth = {:?}", auth.level)
}
fn render_frame(frame: &EvalFrame) -> Option<String> {
let mut parts = Vec::new();
match frame.mode {
EvalMode::Caller => {}
EvalMode::Permission => parts.push("@permission".to_string()),
EvalMode::MutablePermission => parts.push("@mutable-permission".to_string()),
EvalMode::Computed => parts.push("@computed".to_string()),
}
if let Some(auth) = &frame.auth {
parts.push(render_auth(auth));
}
if frame.key_part {
parts.push("@key".to_string());
}
if parts.is_empty() {
None
} else {
Some(parts.join(" "))
}
}
impl ToSql for LogicalOp {
fn fmt_sql(&self, f: &mut String, _fmt: SqlFormat) {
self.render(f, 0);
}
}
impl Display for LogicalOp {
fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
let mut out = String::new();
self.render(&mut out, 0);
f.write_str(out.trim_end())
}
}
#[cfg(test)]
mod tests {
use std::convert::Infallible;
use surrealdb_strand::TableName;
use super::*;
use crate::expr::match_plan::{
BindingDef, BindingKind, DetachMode, MatchClausePlan, MatchColumn, MatchOutput,
MatchPredicate, MatchStage, MutationStage, NodeStep, PatternPlan,
};
use crate::expr::operator::BinaryOperator;
fn parse_expr(sql: &str) -> crate::expr::Expr {
let ast = crate::parser::parse(&format!("RETURN {sql}")).expect("expression should parse");
let crate::parser::TopLevelExpr::Expr(crate::expr::Expr::Return(out)) =
ast.expressions.into_iter().next().expect("one statement")
else {
panic!("expected a RETURN");
};
out.what
}
fn expr(sql: &str) -> LogicalExpr {
lower_expr(parse_expr(sql)).expect("expression should lower")
}
fn lower_sql(sql: &str) -> LogicalOp {
let ast = crate::parser::parse(sql).expect("statement should parse");
let crate::parser::TopLevelExpr::Expr(top) =
ast.expressions.into_iter().next().expect("one statement")
else {
panic!("expected a bare expression");
};
lower(top).expect("statement should lower")
}
fn tables_until_first(plan: &LogicalOp) -> (ControlFlow<&str>, Vec<&str>) {
let mut seen = Vec::new();
let stopped = plan.visit_ops_deep(&mut |node| {
if let LogicalOp::Source(LogicalSource {
source: SourceRef::Table(name),
..
}) = node
{
seen.push(name.as_str());
return ControlFlow::Break(name.as_str());
}
ControlFlow::Continue(())
});
(stopped, seen)
}
fn tables_reached(plan: &LogicalOp) -> Vec<&str> {
let mut reached = Vec::new();
let _ = plan.visit_ops_deep(&mut |node| {
if let LogicalOp::Source(LogicalSource {
source: SourceRef::Table(name),
..
}) = node
{
reached.push(name.as_str());
}
ControlFlow::<()>::Continue(())
});
reached
}
fn source(table: &str) -> LogicalOp {
LogicalOp::Source(LogicalSource {
source: SourceRef::Table(TableName::from(table)),
schema: None,
with: None,
for_update: false,
})
}
fn root_limit() -> AuthLimit {
AuthLimit::new(surrealdb_iam::Level::Root, None)
}
fn single(expr: LogicalExpr, alias: Option<&str>) -> LogicalField {
LogicalField::user(expr, alias.map(OutputPath::field))
}
fn layer(input: LogicalOp, columns: Vec<LogicalField>) -> LogicalOp {
let mut fields = vec![LogicalField::All];
fields.extend(columns);
LogicalOp::Project(LogicalProject {
input: Box::new(input),
fields: LogicalFields::Select(fields),
omit: vec![],
})
}
fn resolved_table_view() -> LogicalOp {
let table_permission = LogicalOp::PermissionFilter(LogicalPermissionFilter {
input: Box::new(source("t")),
predicate: expr("published = true"),
auth: None,
guard: GuardKind::Read,
});
let computed = layer(
table_permission,
vec![LogicalField::column(
"c",
expr("a + b"),
Some(Kind::Int),
EvalFrame::computed(None),
)],
);
let guarded = layer(
computed,
vec![LogicalField::column(
"secret",
expr("IF $auth.id = owner THEN secret ELSE NONE END"),
None,
EvalFrame::permission(None),
)],
);
let user_filter = LogicalOp::Filter(LogicalFilter {
input: Box::new(guarded),
predicate: expr("c > 10 AND secret = 'x'"),
});
LogicalOp::Project(LogicalProject {
input: Box::new(user_filter),
fields: LogicalFields::Select(vec![
single(expr("a"), None),
single(expr("c"), None),
single(expr("secret"), None),
]),
omit: vec![],
})
}
fn ddl_op() -> LogicalOp {
LogicalOp::Ddl(LogicalDdl {
statement: LogicalDdlStatement::Rebuild(Box::new(
crate::expr::statements::RebuildStatement::Index(
crate::expr::statements::rebuild::RebuildIndexStatement {
name: "i".into(),
table: TableName::from("t"),
if_exists: false,
concurrently: false,
},
),
)),
})
}
fn one_of_each() -> Vec<LogicalOp> {
let leaf = || Box::new(source("t"));
vec![
source("t"),
LogicalOp::Values(LogicalValues {
expr: expr("[1, 2]"),
for_update: false,
written: false,
}),
LogicalOp::Subquery(LogicalSubquery {
input: leaf(),
}),
LogicalOp::Write(LogicalWrite {
statement: LogicalWriteStatement::Create(Box::default()),
source: LogicalWriteSource::Targets(vec![expr("person")]),
data: None,
duplicate_update: None,
cond: None,
trace: crate::expr::logical::LookupTrace::None,
}),
LogicalOp::UnionAll(LogicalUnionAll {
inputs: vec![source("a"), source("b")],
}),
LogicalOp::Join(LogicalJoin::new(
source("a"),
source("b"),
JoinKind::Semi,
vec![(expr("x"), RelationAlias::new(0).access("k"))],
None,
RelationAlias::new(0),
EvalFrame::caller(),
)),
LogicalOp::Filter(LogicalFilter {
input: leaf(),
predicate: expr("a > 1"),
}),
LogicalOp::PermissionFilter(LogicalPermissionFilter {
input: leaf(),
predicate: expr("published = true"),
auth: Some(root_limit()),
guard: GuardKind::Read,
}),
LogicalOp::Split(LogicalSplit {
input: leaf(),
exprs: vec![expr("a")],
}),
LogicalOp::Aggregate(LogicalAggregate {
input: leaf(),
group: vec![],
fields: LogicalFields::all(),
}),
LogicalOp::Distinct(LogicalDistinct {
input: leaf(),
}),
LogicalOp::Sort(LogicalSort {
input: leaf(),
ordering: LogicalOrdering::Random,
tempfiles: false,
}),
LogicalOp::Limit(LogicalLimit {
input: leaf(),
limit: Some(expr("1")),
start: None,
}),
LogicalOp::Project(LogicalProject {
input: leaf(),
fields: LogicalFields::all(),
omit: vec![],
}),
LogicalOp::Fetch(LogicalFetch {
input: leaf(),
fetches: vec![expr("f")],
}),
LogicalOp::Timeout(LogicalTimeout {
input: leaf(),
timeout: expr("1s"),
}),
LogicalOp::VersionScope(LogicalVersionScope {
input: leaf(),
version: expr("d'2024-01-01T00:00:00Z'"),
}),
LogicalOp::Only(LogicalOnly {
input: leaf(),
}),
LogicalOp::Explain(LogicalExplain {
input: leaf(),
analyze: false,
format: ExplainFormat::Text,
}),
LogicalOp::Eval(LogicalEval {
expr: expr("1 + 1"),
}),
LogicalOp::Sequence(LogicalSequence {
stmts: vec![source("a"), source("b")],
}),
LogicalOp::Let(LogicalLet {
name: "x".to_string(),
kind: Some(Kind::Int),
value: leaf(),
synthetic: false,
}),
LogicalOp::Return(LogicalReturn {
what: leaf(),
fetch: vec![expr("f")],
}),
LogicalOp::Foreach(LogicalForeach {
param: Param::from("x".to_string()),
range: expr("[1, 2]"),
body: leaf(),
}),
LogicalOp::Info(Box::new(LogicalInfo::Db {
structure: false,
version: None,
})),
LogicalOp::Sleep(LogicalSleep {
duration: expr("1ms"),
}),
ddl_op(),
]
}
#[test]
fn read_only_covers_the_scalar_kinds_and_the_lock() {
assert!(
LogicalOp::Filter(LogicalFilter {
input: Box::new(source("t")),
predicate: expr("a > 1"),
})
.read_only()
);
assert!(
!LogicalOp::Filter(LogicalFilter {
input: Box::new(source("t")),
predicate: expr("fn::write() != NONE"),
})
.read_only()
);
assert!(
!LogicalOp::Split(LogicalSplit {
input: Box::new(source("t")),
exprs: vec![expr("a.some_method()")],
})
.read_only()
);
assert!(
!LogicalOp::Source(LogicalSource {
source: SourceRef::Table(TableName::from("t")),
schema: None,
with: None,
for_update: true,
})
.read_only()
);
assert!(
LogicalOp::Values(LogicalValues {
expr: expr("[1, 2]"),
for_update: false,
written: false,
})
.read_only()
);
assert!(
!LogicalOp::Values(LogicalValues {
expr: expr("fn::write()"),
for_update: false,
written: false,
})
.read_only()
);
assert!(
!LogicalOp::Sequence(LogicalSequence {
stmts: vec![LogicalOp::Eval(LogicalEval {
expr: expr("fn::write()"),
})],
})
.read_only()
);
}
fn match_op(predicate: LogicalExpr, extra: Vec<MatchStage>) -> LogicalOp {
let mut stages = vec![MatchStage::Read(MatchClausePlan {
optional_group: None,
patterns: vec![PatternPlan {
path_var: None,
search: None,
start: NodeStep {
binding: 0,
label: Some(TableName::from("t")),
},
steps: Vec::new(),
}],
predicates: vec![MatchPredicate {
expr: predicate,
deps: vec![0],
}],
})];
stages.extend(extra);
LogicalOp::Match(LogicalMatch {
plan: Box::new(MatchPlan {
bindings: vec![BindingDef {
name: "a".to_string(),
kind: BindingKind::Node,
user_named: true,
}],
stages,
output: Some(MatchOutput {
columns: vec![MatchColumn {
name: "x".to_string(),
expr: expr("a.x"),
hidden: false,
}],
distinct: false,
group_by: None,
order: Vec::new(),
skip: None,
limit: None,
}),
}),
})
}
#[test]
fn a_match_plan_declares_what_it_does_not_expose() {
let read = match_op(expr("a.n > 1"), Vec::new());
assert!(read.children().is_empty());
assert!(!read.inherits_row());
assert!(read.schema().is_open());
assert!(!read.is_layer());
let scalars: Vec<String> =
read.scalars().into_iter().map(|scalar| scalar.to_sql()).collect();
assert_eq!(scalars, vec!["a.n > 1".to_string(), "a.x".to_string()]);
let mut rewritten = read.clone();
let Ok(()) = rewritten.visit_scalars_mut(&mut |scalar: &mut LogicalExpr| {
*scalar = LogicalExpr::Literal(LogicalLiteral::Integer(0));
Ok::<_, Infallible>(())
});
let rewritten: Vec<String> =
rewritten.scalars().into_iter().map(|scalar| scalar.to_sql()).collect();
assert_eq!(rewritten, vec!["0".to_string(), "0".to_string()]);
assert!(read.read_only());
assert!(!match_op(expr("fn::write() != NONE"), Vec::new()).read_only());
let deleting = match_op(
expr("a.n > 1"),
vec![MatchStage::Mutate(MutationStage::Delete {
target: 0,
detach: DetachMode::NoDetach,
})],
);
assert!(deleting.scalars().into_iter().all(LogicalExpr::read_only));
assert!(!deleting.read_only());
}
#[test]
fn the_vocabulary_expresses_a_resolved_table_view() {
let rendered = resolved_table_view().to_string();
let expected = "\
Project[a, c, secret]
Filter[c > 10 AND secret = 'x']
Project[*, (IF $auth.id = owner THEN secret ELSE NONE END) AS secret @permission]
Project[*, a + b AS c : int @computed]
PermissionFilter[published = true]
Source[t]";
assert_eq!(rendered, expected, "\nrendered:\n{rendered}\n");
}
#[test]
fn a_layer_is_a_project_whose_columns_are_not_the_callers() {
let guard = || {
LogicalField::column(
"secret",
expr("IF p THEN secret ELSE NONE END"),
None,
EvalFrame::permission(None),
)
};
let computed =
|| LogicalField::column("c", expr("a + b"), Some(Kind::Int), EvalFrame::computed(None));
let project = |fields: Vec<LogicalField>, omit: Vec<LogicalExpr>| {
LogicalOp::Project(LogicalProject {
input: Box::new(source("t")),
fields: LogicalFields::Select(fields),
omit,
})
};
assert!(project(vec![LogicalField::All, guard()], vec![]).is_layer());
assert!(project(vec![LogicalField::All, computed(), guard()], vec![]).is_layer());
let narrowed = LogicalField::Single {
expr: expr("a + b"),
alias: Some(OutputPath::field("c")),
kind: None,
frame: EvalFrame {
mode: EvalMode::Caller,
auth: Some(root_limit()),
key_part: false,
},
};
assert!(!project(vec![LogicalField::All, narrowed], vec![]).is_layer());
assert!(!project(vec![single(expr("a"), None)], vec![]).is_layer());
assert!(!project(vec![LogicalField::All], vec![]).is_layer());
assert!(!project(vec![guard(), LogicalField::All], vec![]).is_layer());
assert!(
!project(vec![LogicalField::All, single(expr("a + b"), Some("c"))], vec![]).is_layer()
);
assert!(!project(vec![LogicalField::All, guard(), LogicalField::All], vec![]).is_layer());
assert!(!project(vec![LogicalField::All, guard()], vec![expr("secret")]).is_layer());
assert!(
!LogicalOp::Project(LogicalProject {
input: Box::new(source("t")),
fields: LogicalFields::Value {
expr: expr("a"),
alias: None,
},
omit: vec![],
})
.is_layer()
);
for op in one_of_each() {
if !matches!(op, LogicalOp::Project(_)) {
assert!(!op.is_layer(), "{} is not a layer", op.name());
}
}
}
#[test]
fn a_create_lowers_to_a_write() {
let op = super::lower(parse_expr("CREATE person SET name = 'x'")).expect("should lower");
let LogicalOp::Write(write) = &op else {
panic!("expected a Write, got {}", op.name());
};
assert_eq!(write.statement.kind(), "CREATE");
assert!(!write.statement.only());
let LogicalWriteSource::Targets(targets) = &write.source else {
panic!("a creating statement must not take a reading source")
};
assert_eq!(targets.len(), 1);
}
#[test]
fn create_keeps_one_target_per_thing_written() {
let many = super::lower(parse_expr("CREATE person:a, person:b")).expect("should lower");
let LogicalOp::Write(write) = &many else {
panic!("expected a Write")
};
let LogicalWriteSource::Targets(targets) = &write.source else {
panic!("expected targets")
};
assert_eq!(targets.len(), 2);
assert_eq!(many.scalars().len(), 2, "the targets are the node's own scalars");
assert!(many.children().is_empty(), "targets are not a plan subtree");
}
#[test]
fn a_write_is_never_read_only() {
let op = super::lower(parse_expr("CREATE person")).expect("should lower");
assert!(!op.read_only());
assert!(op.children().is_empty());
assert!(op.scalars().iter().all(|target| target.read_only()));
}
#[test]
fn a_write_declares_no_columns() {
let op = super::lower(parse_expr("CREATE person")).expect("should lower");
assert!(op.schema().is_open());
}
#[test]
fn a_scalar_subquery_renders_as_a_nested_plan() {
let plan = LogicalOp::Filter(LogicalFilter {
input: Box::new(source("t")),
predicate: expr("a IN (SELECT VALUE b FROM u)"),
});
let expected = "\
Filter[a INSIDE (
Project[VALUE b]
Source[u]
)]
Source[t]";
assert_eq!(plan.to_string(), expected, "\nrendered:\n{plan}\n");
}
#[test]
fn a_join_renders_its_kind_alias_keys_filter_and_frame() {
let alias = RelationAlias::new(0);
let plan = LogicalOp::Join(LogicalJoin::new(
source("t"),
source("u"),
JoinKind::Semi,
vec![(expr("a"), alias.access("b"))],
Some(LogicalExpr::Binary {
left: Box::new(alias.access("n")),
op: BinaryOperator::MoreThan,
right: Box::new(expr("m")),
}),
alias,
EvalFrame::permission(None),
));
let expected = "\
Join[SEMI AS _join0 ON a = _join0.b WHERE _join0.n > m @permission]
Source[t]
Source[u]";
assert_eq!(plan.to_string(), expected, "\nrendered:\n{plan}\n");
let plain = LogicalOp::Join(LogicalJoin::new(
source("t"),
source("u"),
JoinKind::Left,
vec![],
None,
RelationAlias::new(3),
EvalFrame::caller(),
));
assert_eq!(plain.to_string(), "Join[LEFT AS _join3]\n Source[t]\n Source[u]");
assert_eq!(RelationAlias::new(3).index(), Some(3));
}
#[test]
fn the_evaluation_modes_cover_every_executor_frame() {
let table = [
(EvalMode::Caller, true, false),
(EvalMode::Permission, false, true),
(EvalMode::MutablePermission, false, false),
(EvalMode::Computed, true, true),
];
for (mode, checks, forbids) in table {
assert_eq!(mode.checks_permissions(), checks, "{mode:?} checks_permissions");
assert_eq!(mode.forbids_writes(), forbids, "{mode:?} forbids_writes");
}
}
#[test]
fn authority_is_independent_of_mode() {
let frame = EvalFrame {
mode: EvalMode::Caller,
auth: Some(root_limit()),
key_part: false,
};
assert!(!frame.is_caller());
assert!(EvalFrame::caller().is_caller());
}
#[test]
fn a_layer_column_renders_its_kind_and_frame() {
let column = LogicalField::column(
"c",
expr("a + b"),
Some(Kind::Int),
EvalFrame::computed(Some(root_limit())),
);
assert_eq!(column.to_sql(), "a + b AS c : int @computed @auth = Root");
let guard = LogicalField::column(
"secret",
expr("IF p THEN secret ELSE NONE END"),
None,
EvalFrame::permission(None),
);
assert_eq!(guard.to_sql(), "(IF p THEN secret ELSE NONE END) AS secret @permission");
assert_eq!(single(expr("a + b"), Some("c")).to_sql(), "a + b AS c");
assert_eq!(single(expr("a"), None).to_sql(), "a");
}
#[test]
fn map_children_preserves_arity_for_every_variant() {
for op in one_of_each() {
let arity = op.children().len();
let Ok(rebuilt) = op.clone().map_children(Ok::<_, Infallible>);
assert_eq!(rebuilt, op, "identity rebuild should be a no-op for {}", op.name());
assert_eq!(rebuilt.children().len(), arity, "{} lost or gained an input", op.name());
}
}
#[test]
fn map_children_replaces_each_input_in_order() {
let op = LogicalOp::UnionAll(LogicalUnionAll {
inputs: vec![source("a"), source("b")],
});
let mut seen = Vec::new();
let Ok(rebuilt) = op.map_children(|child| {
seen.push(child.to_string());
Ok::<_, Infallible>(LogicalOp::Values(LogicalValues {
expr: expr("[]"),
for_update: false,
written: false,
}))
});
assert_eq!(seen, ["Source[a]", "Source[b]"]);
assert_eq!(rebuilt.children().len(), 2);
assert!(rebuilt.children().iter().all(|c| c.name() == "Values"));
}
#[test]
fn map_children_stops_at_the_first_error() {
let op = LogicalOp::UnionAll(LogicalUnionAll {
inputs: vec![source("a"), source("b"), source("c")],
});
let mut calls = 0;
let result = op.map_children(|child| {
calls += 1;
if child.to_string() == "Source[b]" {
Err("b")
} else {
Ok(child)
}
});
assert_eq!(result, Err("b"));
assert_eq!(calls, 2);
}
#[test]
fn transform_up_sees_children_before_parents() {
let mut order = Vec::new();
let Ok(_) = resolved_table_view().transform_up(&mut |node| {
order.push(node.name());
Ok::<_, Infallible>(node)
});
assert_eq!(
order,
["Source", "PermissionFilter", "Project", "Project", "Filter", "Project"]
);
}
#[test]
fn transform_down_sees_parents_before_children() {
let mut order = Vec::new();
let Ok(_) = resolved_table_view().transform_down(&mut |node| {
order.push(node.name());
Ok::<_, Infallible>(node)
});
assert_eq!(
order,
["Project", "Filter", "Project", "Project", "PermissionFilter", "Source"]
);
}
#[test]
fn transform_down_descends_into_the_rewritten_node() {
let op = LogicalOp::Only(LogicalOnly {
input: Box::new(source("t")),
});
let mut visited = Vec::new();
let Ok(out) = op.transform_down(&mut |node| {
visited.push(node.name());
Ok::<_, Infallible>(
if let LogicalOp::Only(LogicalOnly {
input,
}) = node
{
LogicalOp::Distinct(LogicalDistinct {
input: Box::new(LogicalOp::Filter(LogicalFilter {
input,
predicate: expr("true"),
})),
})
} else {
node
},
)
});
assert_eq!(visited, ["Only", "Filter", "Source"]);
assert_eq!(out.name(), "Distinct");
}
#[test]
fn visit_short_circuits_and_any_reports_it() {
let view = resolved_table_view();
let mut visited = 0;
let found = view.visit(&mut |node| {
visited += 1;
if matches!(node, LogicalOp::PermissionFilter(_)) {
ControlFlow::Break(node.name())
} else {
ControlFlow::Continue(())
}
});
assert_eq!(found, ControlFlow::Break("PermissionFilter"));
assert_eq!(visited, 5, "should stop at the permission filter");
assert!(view.any(LogicalOp::is_layer));
assert!(view.any(|n| matches!(n, LogicalOp::Project(_)) && !n.is_layer()));
}
fn count_params(op: &LogicalOp) -> usize {
let mut count = 0;
let Ok(()) = op.visit_scalars(&mut |scalar| {
let _ = scalar.visit(&mut |e| {
if matches!(e, LogicalExpr::Param(_)) {
count += 1;
}
ControlFlow::<()>::Continue(())
});
Ok::<(), Infallible>(())
});
count
}
fn fold_params(op: &mut LogicalOp) {
let Ok(()) = op.visit_scalars_mut(&mut |scalar| {
scalar.visit_mut(&mut |e| {
if matches!(e, LogicalExpr::Param(p) if p.as_str() == "p") {
*e = LogicalExpr::Literal(LogicalLiteral::Integer(1));
}
Ok::<(), Infallible>(())
})
});
}
fn one_of_each_with_params() -> Vec<(LogicalOp, usize)> {
let leaf = || Box::new(source("t"));
let p = || expr("$p");
let fields_with_param =
|| LogicalFields::Select(vec![single(p(), Some("a")), LogicalField::All]);
let idiom_with_param = || expr("a[$p]");
let ordering_with_param = || {
LogicalOrdering::Order(vec![LogicalOrder {
value: idiom_with_param(),
collate: false,
numeric: false,
direction: true,
}])
};
vec![
(
LogicalOp::Source(LogicalSource {
source: SourceRef::Dynamic(expr("$p + 1")),
schema: None,
with: None,
for_update: false,
}),
1,
),
(
LogicalOp::Source(LogicalSource {
source: SourceRef::classify(expr("t:[$p]")),
schema: None,
with: None,
for_update: false,
}),
1,
),
(
LogicalOp::Values(LogicalValues {
expr: expr("[$p, $p]"),
for_update: false,
written: false,
}),
2,
),
(
LogicalOp::Filter(LogicalFilter {
input: leaf(),
predicate: expr("a > $p"),
}),
1,
),
(
LogicalOp::PermissionFilter(LogicalPermissionFilter {
input: leaf(),
predicate: expr("owner = $p"),
auth: None,
guard: GuardKind::Read,
}),
1,
),
(
LogicalOp::Join(LogicalJoin::new(
source("a"),
source("b"),
JoinKind::Left,
vec![(p(), p())],
Some(p()),
RelationAlias::new(0),
EvalFrame::caller(),
)),
3,
),
(
LogicalOp::Project(LogicalProject {
input: leaf(),
fields: LogicalFields::Select(vec![
LogicalField::All,
LogicalField::column("c", p(), Some(Kind::Int), EvalFrame::computed(None)),
]),
omit: vec![],
}),
1,
),
(
LogicalOp::Split(LogicalSplit {
input: leaf(),
exprs: vec![idiom_with_param()],
}),
1,
),
(
LogicalOp::Aggregate(LogicalAggregate {
input: leaf(),
group: vec![idiom_with_param()],
fields: fields_with_param(),
}),
2,
),
(
LogicalOp::Sort(LogicalSort {
input: leaf(),
ordering: ordering_with_param(),
tempfiles: false,
}),
1,
),
(
LogicalOp::Limit(LogicalLimit {
input: leaf(),
limit: Some(p()),
start: Some(p()),
}),
2,
),
(
LogicalOp::Project(LogicalProject {
input: leaf(),
fields: fields_with_param(),
omit: vec![p()],
}),
2,
),
(
LogicalOp::Fetch(LogicalFetch {
input: leaf(),
fetches: vec![p()],
}),
1,
),
(
LogicalOp::Timeout(LogicalTimeout {
input: leaf(),
timeout: p(),
}),
1,
),
(
LogicalOp::VersionScope(LogicalVersionScope {
input: leaf(),
version: p(),
}),
1,
),
(
LogicalOp::Eval(LogicalEval {
expr: expr("$p + $p"),
}),
2,
),
(
LogicalOp::Return(LogicalReturn {
what: leaf(),
fetch: vec![p()],
}),
1,
),
(
LogicalOp::Foreach(LogicalForeach {
param: Param::from("x".to_string()),
range: p(),
body: leaf(),
}),
1,
),
(
LogicalOp::Info(Box::new(LogicalInfo::Index {
index: p(),
table: p(),
structure: false,
})),
2,
),
(
LogicalOp::Sleep(LogicalSleep {
duration: p(),
}),
1,
),
]
}
#[test]
fn visit_scalars_reaches_every_expression_slot() {
for (op, expected) in one_of_each_with_params() {
assert_eq!(
count_params(&op),
expected,
"{} should expose {expected} params",
op.name()
);
}
}
#[test]
fn visit_scalars_mut_rewrites_the_same_slots() {
for (mut op, _) in one_of_each_with_params() {
fold_params(&mut op);
assert_eq!(count_params(&op), 0, "{} should have no params left: {op}", op.name());
}
}
#[test]
fn visit_scalars_does_not_descend_into_inputs() {
let op = LogicalOp::Only(LogicalOnly {
input: Box::new(LogicalOp::Filter(LogicalFilter {
input: Box::new(source("t")),
predicate: expr("a > $p"),
})),
});
assert_eq!(count_params(&op), 0);
}
#[test]
fn a_scalar_subquery_is_walked_by_the_plan_not_the_scalar() {
let predicate = expr("a IN (SELECT VALUE b FROM u WHERE c = $p)");
assert!(!predicate.any(|e| matches!(e, LogicalExpr::Param(_))));
let mut nested = 0;
let _ = predicate.visit(&mut |e| {
if let LogicalExpr::Subquery(op) = e {
let Ok(()) = op.visit_scalars_deep(&mut |s| {
let _ = s.visit(&mut |x| {
if matches!(x, LogicalExpr::Param(_)) {
nested += 1;
}
ControlFlow::<()>::Continue(())
});
Ok::<(), Infallible>(())
});
}
ControlFlow::<()>::Continue(())
});
assert_eq!(nested, 1);
}
#[test]
fn visit_ops_deep_reaches_every_plan_of_the_statement() {
let plan = lower_sql(
"SELECT
(SELECT * FROM in_projection) AS p,
|$x| (SELECT * FROM in_closure_body) AS f
FROM at_root
WHERE k IN (
SELECT VALUE id FROM in_predicate
WHERE j IN (SELECT VALUE id FROM two_deep)
)",
);
assert_eq!(tables_reached(&plan), ["in_projection", "two_deep", "in_predicate", "at_root"]);
assert_eq!(
tables_until_first(&plan),
(ControlFlow::Break("in_projection"), vec!["in_projection"])
);
let siblings = lower_sql(
"SELECT (SELECT * FROM sib_first) AS a, (SELECT * FROM sib_second) AS b FROM at_root",
);
assert_eq!(tables_reached(&siblings), ["sib_first", "sib_second", "at_root"]);
assert_eq!(
tables_until_first(&siblings),
(ControlFlow::Break("sib_first"), vec!["sib_first"])
);
let matched =
match_op(LogicalExpr::Subquery(Box::new(source("in_match_scalar"))), Vec::new());
assert!(matched.children().is_empty());
assert_eq!(tables_reached(&matched), ["in_match_scalar"]);
}
#[test]
fn a_user_filter_and_a_permission_filter_are_distinct_variants() {
let view = resolved_table_view();
let mut user = 0;
let mut permission = 0;
let _ = view.visit(&mut |node| {
if matches!(node, LogicalOp::Filter(_)) {
user += 1;
}
if matches!(node, LogicalOp::PermissionFilter(_)) {
permission += 1;
}
ControlFlow::<()>::Continue(())
});
assert_eq!((user, permission), (1, 1));
}
#[test]
fn every_statement_operator_renders_in_the_tree_style() {
let plan = LogicalOp::Sequence(LogicalSequence {
stmts: vec![
LogicalOp::Let(LogicalLet {
name: "x".to_string(),
kind: Some(Kind::Int),
value: Box::new(LogicalOp::Eval(LogicalEval {
expr: expr("1 + 1"),
})),
synthetic: false,
}),
LogicalOp::Foreach(LogicalForeach {
param: Param::from("i".to_string()),
range: expr("[1, 2]"),
body: Box::new(LogicalOp::Sequence(LogicalSequence {
stmts: vec![
LogicalOp::Sleep(LogicalSleep {
duration: expr("1ms"),
}),
LogicalOp::Eval(LogicalEval {
expr: expr("IF $i > 1 THEN BREAK END"),
}),
],
})),
}),
LogicalOp::Info(Box::new(LogicalInfo::Table {
table: expr("t"),
structure: true,
version: Some(expr("d'2024-01-01T00:00:00Z'")),
})),
LogicalOp::Info(Box::new(LogicalInfo::Index {
index: expr("i"),
table: expr("t"),
structure: false,
})),
ddl_op(),
LogicalOp::Return(LogicalReturn {
what: Box::new(LogicalOp::Eval(LogicalEval {
expr: expr("$x"),
})),
fetch: vec![expr("f")],
}),
],
});
let expected = "\
Sequence
Let[$x : int]
Eval[1 + 1]
Foreach[$i IN [1, 2]]
Sequence
Sleep[1ms]
Eval[IF $i > 1 THEN BREAK END]
Info[INFO FOR TABLE t VERSION d'2024-01-01T00:00:00Z' STRUCTURE]
Info[INFO FOR INDEX i ON t]
Ddl[REBUILD]
Return[FETCH f]
Eval[$x]";
assert_eq!(plan.to_string(), expected, "\nrendered:\n{plan}\n");
}
#[test]
fn a_scalar_subquery_deep_in_the_tree_is_indented_beneath_its_operator() {
let plan = LogicalOp::Project(LogicalProject {
input: Box::new(LogicalOp::Filter(LogicalFilter {
input: Box::new(source("t")),
predicate: expr("a IN (SELECT VALUE b FROM u WHERE c > 1)"),
})),
fields: LogicalFields::Select(vec![single(expr("a"), None)]),
omit: vec![],
});
let expected = "\
Project[a]
Filter[a INSIDE (
Project[VALUE b]
Filter[c > 1]
Source[u]
)]
Source[t]";
assert_eq!(plan.to_string(), expected, "\nrendered:\n{plan}\n");
let plan = LogicalOp::Let(LogicalLet {
name: "x".to_string(),
kind: None,
value: Box::new(LogicalOp::Eval(LogicalEval {
expr: expr("[1, (SELECT * FROM t), { RETURN 2; }]"),
})),
synthetic: false,
});
let expected = "\
Let[$x]
Eval[[1, (
Project[*]
Source[t]
), (
Sequence
Return
Eval[2]
)]]";
assert_eq!(plan.to_string(), expected, "\nrendered:\n{plan}\n");
}
}