use std::fmt::{self, Display, Formatter};
use std::hash::{Hash, Hasher};
use std::ops::{Bound, ControlFlow};
use common::fmt::{EscapeIdent, EscapeKwFreeIdent, EscapeObjectKey, EscapeRidKey, Fmt, QuoteStr};
use rust_decimal::Decimal;
use surrealdb_strand::{Strand, TableName};
use surrealdb_types::{BigDecimal, SqlFormat, ToSql, write_sql};
use super::{EvalFrame, LogicalOp};
use crate::expr::binding_power::BindingPower;
use crate::expr::lookup::LookupKind;
use crate::expr::method::is_builtin_method;
use crate::expr::part::Recurse;
use crate::expr::record_id::RecordIdKeyGen;
use crate::expr::{BinaryOperator, Constant, Function, Kind, Literal, Mock, Param, PrefixOperator};
use crate::val::{
Bytes, Date, Datetime, Duration, File, Geometry, Interval, Regex, Time, Timestamp, Uuid,
};
#[derive(Clone, Debug)]
pub enum LogicalLiteral {
None,
Null,
UnboundedRange,
Bool(bool),
Float(f64),
Integer(i64),
Decimal(Decimal),
BigDecimal(Box<BigDecimal>),
String(Strand),
Bytes(Bytes),
Regex(Regex),
Duration(Duration),
Datetime(Datetime),
Uuid(Uuid),
Geometry(Geometry),
File(File),
I8(i8),
U8(u8),
I16(i16),
U16(u16),
I32(i32),
U32(u32),
U64(u64),
F16(half::f16),
F32(f32),
Date(Date),
Time(Time),
Timestamp(Timestamp),
Interval(Interval),
}
impl LogicalLiteral {
pub fn to_expr_literal(&self) -> Literal {
match self {
LogicalLiteral::None => Literal::None,
LogicalLiteral::Null => Literal::Null,
LogicalLiteral::UnboundedRange => Literal::UnboundedRange,
LogicalLiteral::Bool(x) => Literal::Bool(*x),
LogicalLiteral::Float(x) => Literal::Float(*x),
LogicalLiteral::Integer(x) => Literal::Integer(*x),
LogicalLiteral::Decimal(x) => Literal::Decimal(*x),
LogicalLiteral::BigDecimal(x) => Literal::BigDecimal(x.clone()),
LogicalLiteral::String(x) => Literal::String(x.clone()),
LogicalLiteral::Bytes(x) => Literal::Bytes(x.clone()),
LogicalLiteral::Regex(x) => Literal::Regex(x.clone()),
LogicalLiteral::Duration(x) => Literal::Duration(*x),
LogicalLiteral::Datetime(x) => Literal::Datetime(*x),
LogicalLiteral::Date(x) => Literal::Date(*x),
LogicalLiteral::Time(x) => Literal::Time(*x),
LogicalLiteral::Timestamp(x) => Literal::Timestamp(*x),
LogicalLiteral::Interval(x) => Literal::Interval(*x),
LogicalLiteral::Uuid(x) => Literal::Uuid(*x),
LogicalLiteral::Geometry(x) => Literal::Geometry(x.clone()),
LogicalLiteral::File(x) => Literal::File(x.clone()),
LogicalLiteral::I8(x) => Literal::I8(*x),
LogicalLiteral::U8(x) => Literal::U8(*x),
LogicalLiteral::I16(x) => Literal::I16(*x),
LogicalLiteral::U16(x) => Literal::U16(*x),
LogicalLiteral::I32(x) => Literal::I32(*x),
LogicalLiteral::U32(x) => Literal::U32(*x),
LogicalLiteral::U64(x) => Literal::U64(*x),
LogicalLiteral::F16(x) => Literal::F16(*x),
LogicalLiteral::F32(x) => Literal::F32(*x),
}
}
}
impl PartialEq for LogicalLiteral {
fn eq(&self, other: &Self) -> bool {
match (self, other) {
(LogicalLiteral::None, LogicalLiteral::None) => true,
(LogicalLiteral::Null, LogicalLiteral::Null) => true,
(LogicalLiteral::UnboundedRange, LogicalLiteral::UnboundedRange) => true,
(LogicalLiteral::Bool(a), LogicalLiteral::Bool(b)) => a == b,
(LogicalLiteral::Float(a), LogicalLiteral::Float(b)) => a.to_bits() == b.to_bits(),
(LogicalLiteral::Integer(a), LogicalLiteral::Integer(b)) => a == b,
(LogicalLiteral::Decimal(a), LogicalLiteral::Decimal(b)) => a == b,
(LogicalLiteral::BigDecimal(a), LogicalLiteral::BigDecimal(b)) => a == b,
(LogicalLiteral::String(a), LogicalLiteral::String(b)) => a == b,
(LogicalLiteral::Bytes(a), LogicalLiteral::Bytes(b)) => a == b,
(LogicalLiteral::Regex(a), LogicalLiteral::Regex(b)) => a == b,
(LogicalLiteral::Duration(a), LogicalLiteral::Duration(b)) => a == b,
(LogicalLiteral::Datetime(a), LogicalLiteral::Datetime(b)) => a == b,
(LogicalLiteral::Date(a), LogicalLiteral::Date(b)) => a == b,
(LogicalLiteral::Time(a), LogicalLiteral::Time(b)) => a == b,
(LogicalLiteral::Timestamp(a), LogicalLiteral::Timestamp(b)) => a == b,
(LogicalLiteral::Interval(a), LogicalLiteral::Interval(b)) => a.identical(b),
(LogicalLiteral::Uuid(a), LogicalLiteral::Uuid(b)) => a == b,
(LogicalLiteral::Geometry(a), LogicalLiteral::Geometry(b)) => a == b,
(LogicalLiteral::File(a), LogicalLiteral::File(b)) => a == b,
(LogicalLiteral::I8(a), LogicalLiteral::I8(b)) => a == b,
(LogicalLiteral::U8(a), LogicalLiteral::U8(b)) => a == b,
(LogicalLiteral::I16(a), LogicalLiteral::I16(b)) => a == b,
(LogicalLiteral::U16(a), LogicalLiteral::U16(b)) => a == b,
(LogicalLiteral::I32(a), LogicalLiteral::I32(b)) => a == b,
(LogicalLiteral::U32(a), LogicalLiteral::U32(b)) => a == b,
(LogicalLiteral::U64(a), LogicalLiteral::U64(b)) => a == b,
(LogicalLiteral::F16(a), LogicalLiteral::F16(b)) => a.to_bits() == b.to_bits(),
(LogicalLiteral::F32(a), LogicalLiteral::F32(b)) => a.to_bits() == b.to_bits(),
_ => false,
}
}
}
impl Eq for LogicalLiteral {}
impl Hash for LogicalLiteral {
fn hash<H: Hasher>(&self, state: &mut H) {
std::mem::discriminant(self).hash(state);
match self {
LogicalLiteral::None | LogicalLiteral::Null | LogicalLiteral::UnboundedRange => {}
LogicalLiteral::Bool(x) => x.hash(state),
LogicalLiteral::Float(x) => x.to_bits().hash(state),
LogicalLiteral::Integer(x) => x.hash(state),
LogicalLiteral::Decimal(x) => x.hash(state),
LogicalLiteral::BigDecimal(x) => x.hash(state),
LogicalLiteral::String(x) => x.hash(state),
LogicalLiteral::Bytes(x) => x.hash(state),
LogicalLiteral::Regex(x) => x.hash(state),
LogicalLiteral::Duration(x) => x.hash(state),
LogicalLiteral::Datetime(x) => x.hash(state),
LogicalLiteral::Date(x) => x.hash(state),
LogicalLiteral::Time(x) => x.hash(state),
LogicalLiteral::Timestamp(x) => x.hash(state),
LogicalLiteral::Interval(x) => x.hash(state),
LogicalLiteral::Uuid(x) => x.hash(state),
LogicalLiteral::Geometry(x) => x.hash(state),
LogicalLiteral::File(x) => x.hash(state),
LogicalLiteral::I8(x) => x.hash(state),
LogicalLiteral::U8(x) => x.hash(state),
LogicalLiteral::I16(x) => x.hash(state),
LogicalLiteral::U16(x) => x.hash(state),
LogicalLiteral::I32(x) => x.hash(state),
LogicalLiteral::U32(x) => x.hash(state),
LogicalLiteral::U64(x) => x.hash(state),
LogicalLiteral::F16(x) => x.to_bits().hash(state),
LogicalLiteral::F32(x) => x.to_bits().hash(state),
}
}
}
impl ToSql for LogicalLiteral {
fn fmt_sql(&self, f: &mut String, fmt: SqlFormat) {
self.to_expr_literal().fmt_sql(f, fmt);
}
}
#[derive(Debug, PartialEq, Eq, surrealdb_stored_derive::DynHash)]
pub enum LogicalExpr {
Literal(LogicalLiteral),
Array(Vec<LogicalExpr>),
Set(Vec<LogicalExpr>),
Object(Vec<(String, LogicalExpr)>),
RecordId(Box<LogicalRecordIdLit>),
Param(Param),
Table(TableName),
Mock(Mock),
Constant(Constant),
Field(Strand),
Doc,
Current,
Access {
base: Box<LogicalExpr>,
field: Strand,
},
Index {
base: Box<LogicalExpr>,
index: Box<LogicalExpr>,
},
First(Box<LogicalExpr>),
Last(Box<LogicalExpr>),
Each(Box<LogicalExpr>),
Flatten {
base: Box<LogicalExpr>,
explicit: bool,
},
Filter {
base: Box<LogicalExpr>,
predicate: Box<LogicalExpr>,
},
Method {
base: Box<LogicalExpr>,
name: Strand,
args: Vec<LogicalExpr>,
},
Destructure {
base: Box<LogicalExpr>,
fields: Vec<LogicalDestructureField>,
},
Optional {
base: Box<LogicalExpr>,
then: Box<LogicalExpr>,
},
Lookup {
base: Box<LogicalExpr>,
lookup: Box<LogicalLookup>,
},
Recurse(Box<LogicalRecurse>),
RepeatRecurse(Box<LogicalExpr>),
Broadcast {
base: Box<LogicalExpr>,
body: Box<LogicalExpr>,
flatten: bool,
},
SetField {
base: Box<LogicalExpr>,
field: Strand,
value: Box<LogicalExpr>,
},
Prefix {
op: PrefixOperator,
expr: Box<LogicalExpr>,
},
Postfix {
expr: Box<LogicalExpr>,
op: LogicalPostfixOperator,
},
Invoke {
target: Box<LogicalExpr>,
args: Vec<LogicalExpr>,
},
Binary {
left: Box<LogicalExpr>,
op: BinaryOperator,
right: Box<LogicalExpr>,
},
Call(Box<LogicalCall>),
Closure(Box<LogicalClosure>),
If(Box<LogicalIf>),
Throw(Box<LogicalExpr>),
Break,
Continue,
Subquery(Box<LogicalOp>),
}
impl Clone for LogicalExpr {
#[inline]
fn clone(&self) -> Self {
clone_expr(self)
}
}
#[inline(never)]
fn clone_expr(expr: &LogicalExpr) -> LogicalExpr {
use LogicalExpr as E;
match expr {
E::Literal(v) => E::Literal(v.clone()),
E::Array(v) => E::Array(v.clone()),
E::Set(v) => E::Set(v.clone()),
E::Object(v) => E::Object(v.clone()),
E::RecordId(v) => E::RecordId(v.clone()),
E::Param(v) => E::Param(v.clone()),
E::Table(v) => E::Table(v.clone()),
E::Mock(v) => E::Mock(v.clone()),
E::Constant(v) => E::Constant(v.clone()),
E::Field(v) => E::Field(v.clone()),
E::Doc => E::Doc,
E::Current => E::Current,
E::Access {
base,
field,
} => E::Access {
base: base.clone(),
field: field.clone(),
},
E::Index {
base,
index,
} => E::Index {
base: base.clone(),
index: index.clone(),
},
E::First(v) => E::First(v.clone()),
E::Last(v) => E::Last(v.clone()),
E::Each(v) => E::Each(v.clone()),
E::Flatten {
base,
explicit,
} => E::Flatten {
base: base.clone(),
explicit: *explicit,
},
E::Filter {
base,
predicate,
} => E::Filter {
base: base.clone(),
predicate: predicate.clone(),
},
E::Method {
base,
name,
args,
} => E::Method {
base: base.clone(),
name: name.clone(),
args: args.clone(),
},
E::Destructure {
base,
fields,
} => E::Destructure {
base: base.clone(),
fields: fields.clone(),
},
E::Optional {
base,
then,
} => E::Optional {
base: base.clone(),
then: then.clone(),
},
E::Lookup {
base,
lookup,
} => E::Lookup {
base: base.clone(),
lookup: lookup.clone(),
},
E::Recurse(v) => E::Recurse(v.clone()),
E::RepeatRecurse(v) => E::RepeatRecurse(v.clone()),
E::Broadcast {
base,
body,
flatten,
} => E::Broadcast {
base: base.clone(),
body: body.clone(),
flatten: *flatten,
},
E::SetField {
base,
field,
value,
} => E::SetField {
base: base.clone(),
field: field.clone(),
value: value.clone(),
},
E::Prefix {
op,
expr,
} => E::Prefix {
op: op.clone(),
expr: expr.clone(),
},
E::Postfix {
expr,
op,
} => E::Postfix {
expr: expr.clone(),
op: op.clone(),
},
E::Invoke {
target,
args,
} => E::Invoke {
target: target.clone(),
args: args.clone(),
},
E::Binary {
left,
op,
right,
} => E::Binary {
left: left.clone(),
op: op.clone(),
right: right.clone(),
},
E::Call(v) => E::Call(v.clone()),
E::Closure(v) => E::Closure(v.clone()),
E::If(v) => E::If(v.clone()),
E::Throw(v) => E::Throw(v.clone()),
E::Break => E::Break,
E::Continue => E::Continue,
E::Subquery(v) => E::Subquery(v.clone()),
}
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct LogicalRecordIdLit {
pub table: TableName,
pub key: LogicalRecordIdKey,
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub enum LogicalRecordIdKey {
Number(i64),
String(Strand),
Uuid(Uuid),
Array(Vec<LogicalExpr>),
Object(Vec<(String, LogicalExpr)>),
Generate(RecordIdKeyGen),
Range(Box<LogicalRecordIdKeyRange>),
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct LogicalRecordIdKeyRange {
pub start: Bound<LogicalRecordIdKey>,
pub end: Bound<LogicalRecordIdKey>,
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct LogicalRecurse {
pub base: LogicalExpr,
pub recurse: Recurse,
pub path: Option<LogicalRecursePath>,
pub instruction: Option<LogicalRecurseInstruction>,
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub enum LogicalRecursePath {
Nested(LogicalExpr),
Trailing(LogicalExpr),
}
impl LogicalRecursePath {
pub fn body(&self) -> &LogicalExpr {
match self {
LogicalRecursePath::Nested(body) | LogicalRecursePath::Trailing(body) => body,
}
}
pub fn body_mut(&mut self) -> &mut LogicalExpr {
match self {
LogicalRecursePath::Nested(body) | LogicalRecursePath::Trailing(body) => body,
}
}
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub enum LogicalDestructureField {
All(Strand),
Field(Strand),
Aliased(Strand, LogicalExpr),
Destructure(Strand, Vec<LogicalDestructureField>),
Rest,
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub enum LogicalRecurseInstruction {
Path {
inclusive: bool,
},
Collect {
inclusive: bool,
},
Shortest {
expects: LogicalExpr,
inclusive: bool,
},
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct LogicalLookup {
pub kind: LookupKind,
pub expr: Option<LogicalFields>,
pub only: bool,
pub what: Vec<LogicalLookupSubject>,
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 alias: Option<OutputPath>,
pub trace: super::LookupTrace,
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub enum LogicalLookupSubject {
Table {
table: TableName,
referencing_field: Option<String>,
},
Range {
table: TableName,
range: LogicalRecordIdKeyRange,
referencing_field: Option<String>,
},
}
impl LogicalLookupSubject {
fn referencing_field(&self) -> Option<&String> {
match self {
LogicalLookupSubject::Table {
referencing_field,
..
}
| LogicalLookupSubject::Range {
referencing_field,
..
} => referencing_field.as_ref(),
}
}
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub enum LogicalPostfixOperator {
Range,
RangeSkip,
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct LogicalCall {
pub receiver: Function,
pub args: Vec<LogicalExpr>,
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct LogicalClosure {
pub args: Vec<(Param, Kind)>,
pub returns: Option<Kind>,
pub body: LogicalExpr,
pub body_sql: std::sync::Arc<str>,
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct LogicalIf {
pub branches: Vec<(LogicalExpr, LogicalExpr)>,
pub otherwise: Option<LogicalExpr>,
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub enum LogicalFields {
Value {
expr: LogicalExpr,
alias: Option<OutputPath>,
},
Select(Vec<LogicalField>),
}
impl LogicalFields {
pub fn all() -> Self {
LogicalFields::Select(vec![LogicalField::All])
}
pub fn has_all_selection(&self) -> bool {
match self {
LogicalFields::Value {
..
} => false,
LogicalFields::Select(fields) => fields.iter().any(|f| matches!(f, LogicalField::All)),
}
}
}
#[cfg_attr(target_pointer_width = "64", expect(clippy::large_enum_variant))]
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub enum LogicalField {
All,
Single {
expr: LogicalExpr,
alias: Option<OutputPath>,
kind: Option<Kind>,
frame: EvalFrame,
},
}
impl LogicalField {
pub fn user(expr: LogicalExpr, alias: Option<OutputPath>) -> Self {
LogicalField::Single {
expr,
alias,
kind: None,
frame: EvalFrame::caller(),
}
}
pub fn column(
name: impl Into<String>,
expr: LogicalExpr,
kind: Option<Kind>,
frame: EvalFrame,
) -> Self {
LogicalField::Single {
expr,
alias: Some(OutputPath::field(name)),
kind,
frame,
}
}
pub fn output_path(&self) -> Option<OutputPath> {
match self {
LogicalField::All => None,
LogicalField::Single {
expr,
alias,
..
} => Some(alias.clone().unwrap_or_else(|| expr.output_path())),
}
}
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub enum LogicalOrdering {
Random,
Order(Vec<LogicalOrder>),
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct LogicalOrder {
pub value: LogicalExpr,
pub collate: bool,
pub numeric: bool,
pub direction: bool,
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub enum SourceRef {
Table(TableName),
RecordId(Box<LogicalRecordIdLit>),
Mock(Mock),
Param(Param),
Dynamic(LogicalExpr),
}
impl SourceRef {
pub fn classify(expr: LogicalExpr) -> Self {
match expr {
LogicalExpr::Table(table) => SourceRef::Table(table),
LogicalExpr::Mock(mock) => SourceRef::Mock(mock),
LogicalExpr::RecordId(rid) => SourceRef::RecordId(rid),
LogicalExpr::Param(param) => SourceRef::Param(param),
LogicalExpr::Literal(_)
| LogicalExpr::Array(_)
| LogicalExpr::Set(_)
| LogicalExpr::Object(_)
| 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(_) => SourceRef::Dynamic(expr),
}
}
pub fn for_each_expr<'a>(&'a self, out: &mut dyn FnMut(&'a LogicalExpr)) {
match self {
SourceRef::Table(_) | SourceRef::Mock(_) | SourceRef::Param(_) => {}
SourceRef::RecordId(rid) => rid.key.for_each_expr(out),
SourceRef::Dynamic(expr) => out(expr),
}
}
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 {
SourceRef::Table(_) | SourceRef::Mock(_) | SourceRef::Param(_) => {}
SourceRef::RecordId(rid) => rid.key.exprs_mut(out),
SourceRef::Dynamic(expr) => out.push(expr),
}
}
pub fn read_only(&self) -> bool {
match self {
SourceRef::Table(_) | SourceRef::Mock(_) | SourceRef::Param(_) => true,
SourceRef::RecordId(rid) => rid.read_only(),
SourceRef::Dynamic(expr) => expr.read_only(),
}
}
}
impl LogicalExpr {
pub fn is_path(&self) -> bool {
matches!(
self,
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 { .. }
)
}
pub fn step_base(&self) -> Option<&LogicalExpr> {
match self {
LogicalExpr::Access {
base,
..
}
| LogicalExpr::Index {
base,
..
}
| LogicalExpr::Flatten {
base,
..
}
| LogicalExpr::Filter {
base,
..
}
| LogicalExpr::Method {
base,
..
}
| LogicalExpr::Destructure {
base,
..
}
| LogicalExpr::Optional {
base,
..
}
| LogicalExpr::Lookup {
base,
..
}
| LogicalExpr::Broadcast {
base,
..
} => Some(base),
LogicalExpr::First(base)
| LogicalExpr::Last(base)
| LogicalExpr::Each(base)
| LogicalExpr::RepeatRecurse(base) => Some(base),
LogicalExpr::Recurse(recurse) => Some(&recurse.base),
LogicalExpr::Field(_)
| LogicalExpr::Doc
| LogicalExpr::Current
| 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(_) => None,
}
}
pub fn path_root(&self) -> &LogicalExpr {
let mut current = self;
while let Some(base) = current.step_base() {
current = base;
}
current
}
}
impl LogicalExpr {
pub fn for_each_child<'a>(&'a self, out: &mut dyn FnMut(&'a LogicalExpr)) {
match self {
LogicalExpr::Literal(_)
| LogicalExpr::Param(_)
| LogicalExpr::Table(_)
| LogicalExpr::Mock(_)
| LogicalExpr::Constant(_)
| LogicalExpr::Field(_)
| LogicalExpr::Doc
| LogicalExpr::Current
| LogicalExpr::Break
| LogicalExpr::Continue
| LogicalExpr::Subquery(_) => {}
LogicalExpr::Array(items) | LogicalExpr::Set(items) => {
for e in items {
out(e);
}
}
LogicalExpr::Object(entries) => {
for e in entries.iter().map(|(_, v)| v) {
out(e);
}
}
LogicalExpr::RecordId(rid) => rid.key.for_each_expr(out),
LogicalExpr::Access {
base,
..
}
| LogicalExpr::Flatten {
base,
..
} => out(base),
LogicalExpr::First(base)
| LogicalExpr::Last(base)
| LogicalExpr::Each(base)
| LogicalExpr::RepeatRecurse(base) => out(base),
LogicalExpr::Index {
base,
index,
} => {
out(base);
out(index);
}
LogicalExpr::Filter {
base,
predicate,
} => {
out(base);
out(predicate);
}
LogicalExpr::Method {
base,
args,
..
} => {
out(base);
for e in args {
out(e);
}
}
LogicalExpr::Destructure {
base,
fields,
} => {
out(base);
for field in fields {
field.for_each_expr(out);
}
}
LogicalExpr::Optional {
base,
then,
} => {
out(base);
out(then);
}
LogicalExpr::Lookup {
base,
lookup,
} => {
out(base);
lookup.for_each_expr(out);
}
LogicalExpr::Recurse(recurse) => {
out(&recurse.base);
if let Some(path) = &recurse.path {
out(path.body());
}
if let Some(LogicalRecurseInstruction::Shortest {
expects,
..
}) = &recurse.instruction
{
out(expects);
}
}
LogicalExpr::Broadcast {
base,
body,
..
} => {
out(base);
out(body);
}
LogicalExpr::SetField {
base,
value,
..
} => {
out(base);
out(value);
}
LogicalExpr::Prefix {
expr,
..
} => out(expr),
LogicalExpr::Postfix {
expr,
..
} => out(expr),
LogicalExpr::Invoke {
target,
args,
} => {
out(target);
for e in args {
out(e);
}
}
LogicalExpr::Binary {
left,
right,
..
} => {
out(left);
out(right);
}
LogicalExpr::Call(call) => {
for e in &call.args {
out(e);
}
}
LogicalExpr::Closure(closure) => out(&closure.body),
LogicalExpr::If(branches) => {
for (cond, then) in &branches.branches {
out(cond);
out(then);
}
if let Some(e) = &branches.otherwise {
out(e);
};
}
LogicalExpr::Throw(expr) => out(expr),
}
}
pub fn children(&self) -> Vec<&LogicalExpr> {
let mut out = Vec::new();
self.for_each_child(&mut |child| out.push(child));
out
}
pub fn children_mut(&mut self) -> Vec<&mut LogicalExpr> {
let mut out = Vec::new();
match self {
LogicalExpr::Literal(_)
| LogicalExpr::Param(_)
| LogicalExpr::Table(_)
| LogicalExpr::Mock(_)
| LogicalExpr::Constant(_)
| LogicalExpr::Field(_)
| LogicalExpr::Doc
| LogicalExpr::Current
| LogicalExpr::Break
| LogicalExpr::Continue
| LogicalExpr::Subquery(_) => {}
LogicalExpr::Array(items) | LogicalExpr::Set(items) => out.extend(items),
LogicalExpr::Object(entries) => out.extend(entries.iter_mut().map(|(_, v)| v)),
LogicalExpr::RecordId(rid) => rid.key.exprs_mut(&mut out),
LogicalExpr::Access {
base,
..
}
| LogicalExpr::Flatten {
base,
..
} => out.push(base),
LogicalExpr::First(base)
| LogicalExpr::Last(base)
| LogicalExpr::Each(base)
| LogicalExpr::RepeatRecurse(base) => out.push(base),
LogicalExpr::Index {
base,
index,
} => {
out.push(base);
out.push(index);
}
LogicalExpr::Filter {
base,
predicate,
} => {
out.push(base);
out.push(predicate);
}
LogicalExpr::Method {
base,
args,
..
} => {
out.push(base);
out.extend(args);
}
LogicalExpr::Destructure {
base,
fields,
} => {
out.push(base);
fields.iter_mut().for_each(|field| field.exprs_mut(&mut out));
}
LogicalExpr::Optional {
base,
then,
} => {
out.push(base);
out.push(then);
}
LogicalExpr::Lookup {
base,
lookup,
} => {
out.push(base);
lookup.exprs_mut(&mut out);
}
LogicalExpr::Recurse(recurse) => {
let LogicalRecurse {
base,
path,
instruction,
..
} = &mut **recurse;
out.push(base);
if let Some(path) = path {
out.push(path.body_mut());
}
if let Some(LogicalRecurseInstruction::Shortest {
expects,
..
}) = instruction
{
out.push(expects);
}
}
LogicalExpr::Broadcast {
base,
body,
..
} => {
out.push(base);
out.push(body);
}
LogicalExpr::SetField {
base,
value,
..
} => {
out.push(base);
out.push(value);
}
LogicalExpr::Prefix {
expr,
..
} => out.push(expr),
LogicalExpr::Postfix {
expr,
..
} => out.push(expr),
LogicalExpr::Invoke {
target,
args,
} => {
out.push(target);
out.extend(args);
}
LogicalExpr::Binary {
left,
right,
..
} => {
out.push(left);
out.push(right);
}
LogicalExpr::Call(call) => out.extend(&mut call.args),
LogicalExpr::Closure(closure) => out.push(&mut closure.body),
LogicalExpr::If(branches) => {
for (cond, then) in &mut branches.branches {
out.push(cond);
out.push(then);
}
out.extend(&mut branches.otherwise);
}
LogicalExpr::Throw(expr) => out.push(expr),
}
out
}
pub fn visit<B>(&self, f: &mut impl FnMut(&LogicalExpr) -> ControlFlow<B>) -> ControlFlow<B> {
fn walk<B>(
expr: &LogicalExpr,
f: &mut dyn FnMut(&LogicalExpr) -> ControlFlow<B>,
) -> ControlFlow<B> {
f(expr)?;
let mut flow = ControlFlow::Continue(());
expr.for_each_child(&mut |child| {
if flow.is_continue() {
flow = walk(child, &mut *f);
}
});
flow
}
walk(self, f)
}
pub fn visit_deep<B>(
&self,
f: &mut impl FnMut(&LogicalExpr) -> ControlFlow<B>,
) -> ControlFlow<B> {
fn walk<B>(
expr: &LogicalExpr,
f: &mut dyn FnMut(&LogicalExpr) -> ControlFlow<B>,
) -> ControlFlow<B> {
f(expr)?;
if let LogicalExpr::Subquery(op) = expr {
return match op.visit_scalars_deep(&mut |scalar| match walk(scalar, &mut *f) {
ControlFlow::Continue(()) => Ok(()),
ControlFlow::Break(b) => Err(b),
}) {
Ok(()) => ControlFlow::Continue(()),
Err(b) => ControlFlow::Break(b),
};
}
let mut flow = ControlFlow::Continue(());
expr.for_each_child(&mut |child| {
if flow.is_continue() {
flow = walk(child, &mut *f);
}
});
flow
}
walk(self, f)
}
pub fn visit_mut<E>(
&mut self,
f: &mut impl FnMut(&mut LogicalExpr) -> Result<(), E>,
) -> Result<(), E> {
self.visit_mut_dyn(f)
}
fn visit_mut_dyn<E>(
&mut self,
f: &mut dyn FnMut(&mut LogicalExpr) -> Result<(), E>,
) -> Result<(), E> {
for child in self.children_mut() {
child.visit_mut_dyn(&mut *f)?;
}
f(self)
}
pub fn transform<E>(
mut self,
f: &mut impl FnMut(LogicalExpr) -> Result<LogicalExpr, E>,
) -> Result<LogicalExpr, E> {
self.visit_mut(&mut |node| {
let taken = std::mem::replace(node, LogicalExpr::Break);
*node = f(taken)?;
Ok(())
})?;
Ok(self)
}
pub fn any(&self, mut pred: impl FnMut(&LogicalExpr) -> bool) -> bool {
self.visit(&mut |node| {
if pred(node) {
ControlFlow::Break(())
} else {
ControlFlow::Continue(())
}
})
.is_break()
}
}
impl LogicalDestructureField {
fn for_each_expr<'a>(&'a self, out: &mut dyn FnMut(&'a LogicalExpr)) {
match self {
LogicalDestructureField::All(_)
| LogicalDestructureField::Field(_)
| LogicalDestructureField::Rest => {}
LogicalDestructureField::Aliased(_, body) => out(body),
LogicalDestructureField::Destructure(_, fields) => {
for field in fields {
field.for_each_expr(out);
}
}
}
}
fn exprs_mut<'a>(&'a mut self, out: &mut Vec<&'a mut LogicalExpr>) {
match self {
LogicalDestructureField::All(_)
| LogicalDestructureField::Field(_)
| LogicalDestructureField::Rest => {}
LogicalDestructureField::Aliased(_, body) => out.push(body),
LogicalDestructureField::Destructure(_, fields) => {
fields.iter_mut().for_each(|field| field.exprs_mut(out))
}
}
}
}
impl LogicalLookup {
fn for_each_expr<'a>(&'a self, out: &mut dyn FnMut(&'a LogicalExpr)) {
if let Some(fields) = &self.expr {
fields.for_each_expr(out);
}
for subject in &self.what {
subject.for_each_expr(out);
}
if let Some(e) = &self.cond {
out(e);
};
for e in self.split.iter().flatten() {
out(e);
}
for e in self.group.iter().flatten() {
out(e);
}
if let Some(order) = &self.order {
order.for_each_expr(out);
}
if let Some(e) = &self.limit {
out(e);
};
if let Some(e) = &self.start {
out(e);
};
}
fn exprs_mut<'a>(&'a mut self, out: &mut Vec<&'a mut LogicalExpr>) {
if let Some(fields) = &mut self.expr {
fields.exprs_mut(out);
}
for subject in &mut self.what {
subject.exprs_mut(out);
}
out.extend(&mut self.cond);
out.extend(self.split.iter_mut().flatten());
out.extend(self.group.iter_mut().flatten());
if let Some(order) = &mut self.order {
order.exprs_mut(out);
}
out.extend(&mut self.limit);
out.extend(&mut self.start);
}
}
impl LogicalLookupSubject {
fn for_each_expr<'a>(&'a self, out: &mut dyn FnMut(&'a LogicalExpr)) {
match self {
LogicalLookupSubject::Table {
..
} => {}
LogicalLookupSubject::Range {
range,
..
} => range.for_each_expr(out),
}
}
fn exprs_mut<'a>(&'a mut self, out: &mut Vec<&'a mut LogicalExpr>) {
match self {
LogicalLookupSubject::Table {
..
} => {}
LogicalLookupSubject::Range {
range,
..
} => range.exprs_mut(out),
}
}
}
impl LogicalRecordIdKey {
fn for_each_expr<'a>(&'a self, out: &mut dyn FnMut(&'a LogicalExpr)) {
match self {
LogicalRecordIdKey::Number(_)
| LogicalRecordIdKey::String(_)
| LogicalRecordIdKey::Uuid(_)
| LogicalRecordIdKey::Generate(_) => {}
LogicalRecordIdKey::Array(items) => {
for e in items {
out(e);
}
}
LogicalRecordIdKey::Object(entries) => {
for e in entries.iter().map(|(_, v)| v) {
out(e);
}
}
LogicalRecordIdKey::Range(range) => range.for_each_expr(out),
}
}
fn exprs_mut<'a>(&'a mut self, out: &mut Vec<&'a mut LogicalExpr>) {
match self {
LogicalRecordIdKey::Number(_)
| LogicalRecordIdKey::String(_)
| LogicalRecordIdKey::Uuid(_)
| LogicalRecordIdKey::Generate(_) => {}
LogicalRecordIdKey::Array(items) => out.extend(items),
LogicalRecordIdKey::Object(entries) => out.extend(entries.iter_mut().map(|(_, v)| v)),
LogicalRecordIdKey::Range(range) => range.exprs_mut(out),
}
}
}
impl LogicalRecordIdKeyRange {
fn for_each_expr<'a>(&'a self, out: &mut dyn FnMut(&'a LogicalExpr)) {
for bound in [&self.start, &self.end] {
if let Bound::Included(key) | Bound::Excluded(key) = bound {
key.for_each_expr(out);
}
}
}
fn exprs_mut<'a>(&'a mut self, out: &mut Vec<&'a mut LogicalExpr>) {
for bound in [&mut self.start, &mut self.end] {
if let Bound::Included(key) | Bound::Excluded(key) = bound {
key.exprs_mut(out);
}
}
}
}
impl LogicalFields {
pub fn for_each_expr<'a>(&'a self, out: &mut dyn FnMut(&'a LogicalExpr)) {
match self {
LogicalFields::Value {
expr,
..
} => out(expr),
LogicalFields::Select(fields) => {
for field in fields {
if let LogicalField::Single {
expr,
..
} = field
{
out(expr);
}
}
}
}
}
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 {
LogicalFields::Value {
expr,
..
} => out.push(expr),
LogicalFields::Select(fields) => {
for field in fields {
if let LogicalField::Single {
expr,
..
} = field
{
out.push(expr);
}
}
}
}
}
}
impl LogicalOrdering {
pub fn for_each_expr<'a>(&'a self, out: &mut dyn FnMut(&'a LogicalExpr)) {
match self {
LogicalOrdering::Random => {}
LogicalOrdering::Order(orders) => {
for e in orders.iter().map(|o| &o.value) {
out(e);
}
}
}
}
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 {
LogicalOrdering::Random => {}
LogicalOrdering::Order(orders) => out.extend(orders.iter_mut().map(|o| &mut o.value)),
}
}
}
impl LogicalExpr {
pub fn shallow_eq(&self, other: &LogicalExpr) -> bool {
match self {
LogicalExpr::Literal(x) => matches!(other, LogicalExpr::Literal(y) if x == y),
LogicalExpr::Array(_) => matches!(other, LogicalExpr::Array(_)),
LogicalExpr::Set(_) => matches!(other, LogicalExpr::Set(_)),
LogicalExpr::Object(entries) => matches!(
other,
LogicalExpr::Object(others) if entries.len() == others.len()
&& entries.iter().zip(others).all(|((a, _), (b, _))| a == b)
),
LogicalExpr::RecordId(rid) => matches!(
other,
LogicalExpr::RecordId(o) if rid.table == o.table && key_shape_eq(&rid.key, &o.key)
),
LogicalExpr::Param(x) => matches!(other, LogicalExpr::Param(y) if x == y),
LogicalExpr::Table(x) => matches!(other, LogicalExpr::Table(y) if x == y),
LogicalExpr::Mock(x) => matches!(other, LogicalExpr::Mock(y) if x == y),
LogicalExpr::Constant(x) => matches!(other, LogicalExpr::Constant(y) if x == y),
LogicalExpr::Field(x) => matches!(other, LogicalExpr::Field(y) if x == y),
LogicalExpr::Doc => matches!(other, LogicalExpr::Doc),
LogicalExpr::Current => matches!(other, LogicalExpr::Current),
LogicalExpr::Access {
field,
..
} => matches!(
other,
LogicalExpr::Access { field: o, .. } if field == o
),
LogicalExpr::Index {
..
} => matches!(other, LogicalExpr::Index { .. }),
LogicalExpr::First(_) => matches!(other, LogicalExpr::First(_)),
LogicalExpr::Last(_) => matches!(other, LogicalExpr::Last(_)),
LogicalExpr::Each(_) => matches!(other, LogicalExpr::Each(_)),
LogicalExpr::Flatten {
explicit,
..
} => matches!(
other,
LogicalExpr::Flatten { explicit: o, .. } if explicit == o
),
LogicalExpr::Filter {
..
} => matches!(other, LogicalExpr::Filter { .. }),
LogicalExpr::Method {
name,
..
} => matches!(
other,
LogicalExpr::Method { name: o, .. } if name == o
),
LogicalExpr::Destructure {
fields,
..
} => matches!(
other,
LogicalExpr::Destructure { fields: o, .. } if destructure_shape_eq(fields, o)
),
LogicalExpr::Optional {
..
} => matches!(other, LogicalExpr::Optional { .. }),
LogicalExpr::Lookup {
lookup,
..
} => matches!(
other,
LogicalExpr::Lookup { lookup: o, .. } if lookup_shape_eq(lookup, o)
),
LogicalExpr::Recurse(recurse) => matches!(
other,
LogicalExpr::Recurse(o) if recurse.recurse == o.recurse
&& recurse_path_tag(&recurse.path) == recurse_path_tag(&o.path)
&& recurse_instruction_tag(&recurse.instruction)
== recurse_instruction_tag(&o.instruction)
),
LogicalExpr::RepeatRecurse(_) => matches!(other, LogicalExpr::RepeatRecurse(_)),
LogicalExpr::Broadcast {
flatten,
..
} => matches!(
other,
LogicalExpr::Broadcast { flatten: o, .. } if flatten == o
),
LogicalExpr::SetField {
field,
..
} => matches!(
other,
LogicalExpr::SetField { field: o, .. } if field == o
),
LogicalExpr::Prefix {
op,
..
} => matches!(other, LogicalExpr::Prefix { op: o, .. } if op == o),
LogicalExpr::Postfix {
op,
..
} => matches!(other, LogicalExpr::Postfix { op: o, .. } if op == o),
LogicalExpr::Invoke {
..
} => matches!(other, LogicalExpr::Invoke { .. }),
LogicalExpr::Binary {
op,
..
} => matches!(other, LogicalExpr::Binary { op: o, .. } if op == o),
LogicalExpr::Call(call) => {
matches!(other, LogicalExpr::Call(o) if call.receiver == o.receiver)
}
LogicalExpr::Closure(closure) => matches!(
other,
LogicalExpr::Closure(o) if closure.args == o.args
&& closure.returns == o.returns
&& closure.body_sql == o.body_sql
),
LogicalExpr::If(branches) => matches!(
other,
LogicalExpr::If(o) if branches.branches.len() == o.branches.len()
&& branches.otherwise.is_some() == o.otherwise.is_some()
),
LogicalExpr::Throw(_) => matches!(other, LogicalExpr::Throw(_)),
LogicalExpr::Break => matches!(other, LogicalExpr::Break),
LogicalExpr::Continue => matches!(other, LogicalExpr::Continue),
LogicalExpr::Subquery(_) => std::ptr::eq(self, other),
}
}
pub fn shallow_hash<H: Hasher>(&self, state: &mut H) {
std::mem::discriminant(self).hash(state);
match self {
LogicalExpr::Literal(x) => x.hash(state),
LogicalExpr::Array(_)
| LogicalExpr::Set(_)
| LogicalExpr::Doc
| LogicalExpr::Current
| LogicalExpr::Index {
..
}
| LogicalExpr::First(_)
| LogicalExpr::Last(_)
| LogicalExpr::Each(_)
| LogicalExpr::Filter {
..
}
| LogicalExpr::Optional {
..
}
| LogicalExpr::RepeatRecurse(_)
| LogicalExpr::Invoke {
..
}
| LogicalExpr::Throw(_)
| LogicalExpr::Break
| LogicalExpr::Continue => {}
LogicalExpr::Object(entries) => {
entries.len().hash(state);
entries.iter().for_each(|(key, _)| key.hash(state));
}
LogicalExpr::RecordId(rid) => {
rid.table.hash(state);
key_shape_hash(&rid.key, state);
}
LogicalExpr::Param(x) => x.hash(state),
LogicalExpr::Table(x) => x.hash(state),
LogicalExpr::Mock(x) => x.hash(state),
LogicalExpr::Constant(x) => x.hash(state),
LogicalExpr::Field(x) => x.hash(state),
LogicalExpr::Access {
field,
..
}
| LogicalExpr::SetField {
field,
..
} => field.hash(state),
LogicalExpr::Flatten {
explicit: flag,
..
}
| LogicalExpr::Broadcast {
flatten: flag,
..
} => flag.hash(state),
LogicalExpr::Method {
name,
..
} => name.hash(state),
LogicalExpr::Destructure {
fields,
..
} => destructure_shape_hash(fields, state),
LogicalExpr::Lookup {
lookup,
..
} => lookup_shape_hash(lookup, state),
LogicalExpr::Recurse(recurse) => {
recurse.recurse.hash(state);
recurse_path_tag(&recurse.path).hash(state);
recurse_instruction_tag(&recurse.instruction).hash(state);
}
LogicalExpr::Prefix {
op,
..
} => op.hash(state),
LogicalExpr::Postfix {
op,
..
} => op.hash(state),
LogicalExpr::Binary {
op,
..
} => op.hash(state),
LogicalExpr::Call(call) => call.receiver.hash(state),
LogicalExpr::Closure(closure) => {
closure.args.hash(state);
closure.returns.hash(state);
closure.body_sql.hash(state);
}
LogicalExpr::If(branches) => {
branches.branches.len().hash(state);
branches.otherwise.is_some().hash(state);
}
LogicalExpr::Subquery(_) => std::ptr::from_ref(self).hash(state),
}
}
}
fn recurse_instruction_tag(instruction: &Option<LogicalRecurseInstruction>) -> Option<(u8, bool)> {
match instruction {
None => None,
Some(LogicalRecurseInstruction::Path {
inclusive,
}) => Some((0, *inclusive)),
Some(LogicalRecurseInstruction::Collect {
inclusive,
}) => Some((1, *inclusive)),
Some(LogicalRecurseInstruction::Shortest {
inclusive,
..
}) => Some((2, *inclusive)),
}
}
fn recurse_path_tag(path: &Option<LogicalRecursePath>) -> Option<u8> {
match path {
None => None,
Some(LogicalRecursePath::Nested(_)) => Some(0),
Some(LogicalRecursePath::Trailing(_)) => Some(1),
}
}
fn key_shape_eq(a: &LogicalRecordIdKey, b: &LogicalRecordIdKey) -> bool {
match a {
LogicalRecordIdKey::Number(x) => matches!(b, LogicalRecordIdKey::Number(y) if x == y),
LogicalRecordIdKey::String(x) => matches!(b, LogicalRecordIdKey::String(y) if x == y),
LogicalRecordIdKey::Uuid(x) => matches!(b, LogicalRecordIdKey::Uuid(y) if x == y),
LogicalRecordIdKey::Generate(x) => matches!(b, LogicalRecordIdKey::Generate(y) if x == y),
LogicalRecordIdKey::Array(items) => {
matches!(b, LogicalRecordIdKey::Array(others) if items.len() == others.len())
}
LogicalRecordIdKey::Object(entries) => matches!(
b,
LogicalRecordIdKey::Object(others) if entries.len() == others.len()
&& entries.iter().zip(others).all(|((a, _), (b, _))| a == b)
),
LogicalRecordIdKey::Range(range) => {
matches!(b, LogicalRecordIdKey::Range(other) if range_shape_eq(range, other))
}
}
}
fn key_shape_hash<H: Hasher>(key: &LogicalRecordIdKey, state: &mut H) {
std::mem::discriminant(key).hash(state);
match key {
LogicalRecordIdKey::Number(x) => x.hash(state),
LogicalRecordIdKey::String(x) => x.hash(state),
LogicalRecordIdKey::Uuid(x) => x.hash(state),
LogicalRecordIdKey::Generate(x) => x.hash(state),
LogicalRecordIdKey::Array(items) => items.len().hash(state),
LogicalRecordIdKey::Object(entries) => {
entries.len().hash(state);
entries.iter().for_each(|(key, _)| key.hash(state));
}
LogicalRecordIdKey::Range(range) => range_shape_hash(range, state),
}
}
fn range_shape_eq(a: &LogicalRecordIdKeyRange, b: &LogicalRecordIdKeyRange) -> bool {
bound_shape_eq(&a.start, &b.start) && bound_shape_eq(&a.end, &b.end)
}
fn range_shape_hash<H: Hasher>(range: &LogicalRecordIdKeyRange, state: &mut H) {
bound_shape_hash(&range.start, state);
bound_shape_hash(&range.end, state);
}
fn bound_shape_eq(a: &Bound<LogicalRecordIdKey>, b: &Bound<LogicalRecordIdKey>) -> bool {
match (a, b) {
(Bound::Included(a), Bound::Included(b)) | (Bound::Excluded(a), Bound::Excluded(b)) => {
key_shape_eq(a, b)
}
(Bound::Unbounded, Bound::Unbounded) => true,
(Bound::Included(_) | Bound::Excluded(_) | Bound::Unbounded, _) => false,
}
}
fn bound_shape_hash<H: Hasher>(bound: &Bound<LogicalRecordIdKey>, state: &mut H) {
match bound {
Bound::Included(key) => {
0u8.hash(state);
key_shape_hash(key, state);
}
Bound::Excluded(key) => {
1u8.hash(state);
key_shape_hash(key, state);
}
Bound::Unbounded => 2u8.hash(state),
}
}
fn destructure_shape_eq(a: &[LogicalDestructureField], b: &[LogicalDestructureField]) -> bool {
a.len() == b.len()
&& a.iter().zip(b).all(|(a, b)| match a {
LogicalDestructureField::All(x) => {
matches!(b, LogicalDestructureField::All(y) if x == y)
}
LogicalDestructureField::Field(x) => {
matches!(b, LogicalDestructureField::Field(y) if x == y)
}
LogicalDestructureField::Aliased(x, _) => {
matches!(b, LogicalDestructureField::Aliased(y, _) if x == y)
}
LogicalDestructureField::Destructure(x, fields) => matches!(
b,
LogicalDestructureField::Destructure(y, others)
if x == y && destructure_shape_eq(fields, others)
),
LogicalDestructureField::Rest => matches!(b, LogicalDestructureField::Rest),
})
}
fn destructure_shape_hash<H: Hasher>(fields: &[LogicalDestructureField], state: &mut H) {
fields.len().hash(state);
for field in fields {
std::mem::discriminant(field).hash(state);
match field {
LogicalDestructureField::All(name)
| LogicalDestructureField::Field(name)
| LogicalDestructureField::Aliased(name, _) => name.hash(state),
LogicalDestructureField::Destructure(name, fields) => {
name.hash(state);
destructure_shape_hash(fields, state);
}
LogicalDestructureField::Rest => {}
}
}
}
fn lookup_shape_eq(a: &LogicalLookup, b: &LogicalLookup) -> bool {
a.kind == b.kind
&& a.only == b.only
&& a.alias == b.alias
&& match (&a.expr, &b.expr) {
(None, None) => true,
(Some(a), Some(b)) => fields_shape_eq(a, b),
(None, Some(_)) | (Some(_), None) => false,
} && a.what.len() == b.what.len()
&& a.what.iter().zip(&b.what).all(|(a, b)| subject_shape_eq(a, b))
&& a.cond.is_some() == b.cond.is_some()
&& a.split.as_ref().map(Vec::len) == b.split.as_ref().map(Vec::len)
&& a.group.as_ref().map(Vec::len) == b.group.as_ref().map(Vec::len)
&& match (&a.order, &b.order) {
(None, None) => true,
(Some(a), Some(b)) => ordering_shape_eq(a, b),
(None, Some(_)) | (Some(_), None) => false,
} && a.limit.is_some() == b.limit.is_some()
&& a.start.is_some() == b.start.is_some()
}
fn lookup_shape_hash<H: Hasher>(lookup: &LogicalLookup, state: &mut H) {
lookup.kind.hash(state);
lookup.only.hash(state);
lookup.alias.hash(state);
match &lookup.expr {
None => 0u8.hash(state),
Some(fields) => {
1u8.hash(state);
fields_shape_hash(fields, state);
}
}
lookup.what.len().hash(state);
lookup.what.iter().for_each(|subject| subject_shape_hash(subject, state));
lookup.cond.is_some().hash(state);
lookup.split.as_ref().map(Vec::len).hash(state);
lookup.group.as_ref().map(Vec::len).hash(state);
match &lookup.order {
None => 0u8.hash(state),
Some(order) => {
1u8.hash(state);
ordering_shape_hash(order, state);
}
}
lookup.limit.is_some().hash(state);
lookup.start.is_some().hash(state);
}
fn subject_shape_eq(a: &LogicalLookupSubject, b: &LogicalLookupSubject) -> bool {
match a {
LogicalLookupSubject::Table {
table,
referencing_field,
} => matches!(
b,
LogicalLookupSubject::Table { table: t, referencing_field: r }
if table == t && referencing_field == r
),
LogicalLookupSubject::Range {
table,
range,
referencing_field,
} => matches!(
b,
LogicalLookupSubject::Range { table: t, range: g, referencing_field: r }
if table == t && referencing_field == r && range_shape_eq(range, g)
),
}
}
fn subject_shape_hash<H: Hasher>(subject: &LogicalLookupSubject, state: &mut H) {
std::mem::discriminant(subject).hash(state);
match subject {
LogicalLookupSubject::Table {
table,
referencing_field,
} => {
table.hash(state);
referencing_field.hash(state);
}
LogicalLookupSubject::Range {
table,
range,
referencing_field,
} => {
table.hash(state);
referencing_field.hash(state);
range_shape_hash(range, state);
}
}
}
fn fields_shape_eq(a: &LogicalFields, b: &LogicalFields) -> bool {
match a {
LogicalFields::Value {
alias,
..
} => matches!(b, LogicalFields::Value { alias: o, .. } if alias == o),
LogicalFields::Select(fields) => matches!(
b,
LogicalFields::Select(others) if fields.len() == others.len()
&& fields.iter().zip(others).all(|(a, b)| match a {
LogicalField::All => matches!(b, LogicalField::All),
LogicalField::Single { alias, kind, frame, .. } => matches!(
b,
LogicalField::Single { alias: a2, kind: k2, frame: f2, .. }
if alias == a2 && kind == k2 && frame == f2
),
})
),
}
}
fn fields_shape_hash<H: Hasher>(fields: &LogicalFields, state: &mut H) {
std::mem::discriminant(fields).hash(state);
match fields {
LogicalFields::Value {
alias,
..
} => alias.hash(state),
LogicalFields::Select(fields) => {
fields.len().hash(state);
for field in fields {
std::mem::discriminant(field).hash(state);
if let LogicalField::Single {
alias,
kind,
frame,
..
} = field
{
alias.hash(state);
kind.hash(state);
frame.hash(state);
}
}
}
}
}
fn ordering_shape_eq(a: &LogicalOrdering, b: &LogicalOrdering) -> bool {
match a {
LogicalOrdering::Random => matches!(b, LogicalOrdering::Random),
LogicalOrdering::Order(orders) => matches!(
b,
LogicalOrdering::Order(others) if orders.len() == others.len()
&& orders.iter().zip(others).all(|(a, b)| {
a.collate == b.collate && a.numeric == b.numeric && a.direction == b.direction
})
),
}
}
fn ordering_shape_hash<H: Hasher>(ordering: &LogicalOrdering, state: &mut H) {
std::mem::discriminant(ordering).hash(state);
if let LogicalOrdering::Order(orders) = ordering {
orders.len().hash(state);
for order in orders {
order.collate.hash(state);
order.numeric.hash(state);
order.direction.hash(state);
}
}
}
impl LogicalExpr {
pub fn read_only(&self) -> bool {
match self {
LogicalExpr::Literal(_)
| LogicalExpr::Param(_)
| LogicalExpr::Table(_)
| LogicalExpr::Mock(_)
| LogicalExpr::Constant(_)
| LogicalExpr::Field(_)
| LogicalExpr::Doc
| LogicalExpr::Current
| LogicalExpr::Break
| LogicalExpr::Continue => true,
LogicalExpr::Array(items) | LogicalExpr::Set(items) => {
items.iter().all(LogicalExpr::read_only)
}
LogicalExpr::Object(entries) => entries.iter().all(|(_, v)| v.read_only()),
LogicalExpr::RecordId(rid) => rid.read_only(),
LogicalExpr::Method {
base,
name,
args,
} => {
is_builtin_method(name)
&& base.read_only()
&& args.iter().all(LogicalExpr::read_only)
}
LogicalExpr::Lookup {
base,
lookup,
} => base.read_only() && lookup.read_only(),
LogicalExpr::SetField {
base,
value,
..
} => base.read_only() && value.read_only(),
LogicalExpr::Access {
..
}
| LogicalExpr::Index {
..
}
| LogicalExpr::First(_)
| LogicalExpr::Last(_)
| LogicalExpr::Each(_)
| LogicalExpr::Flatten {
..
}
| LogicalExpr::Filter {
..
}
| LogicalExpr::Destructure {
..
}
| LogicalExpr::Optional {
..
}
| LogicalExpr::Recurse(_)
| LogicalExpr::RepeatRecurse(_)
| LogicalExpr::Broadcast {
..
} => {
let mut reads = true;
self.for_each_child(&mut |child| reads = reads && child.read_only());
reads
}
LogicalExpr::Prefix {
expr,
..
} => expr.read_only(),
LogicalExpr::Postfix {
expr,
..
} => expr.read_only(),
LogicalExpr::Invoke {
target,
args,
} => {
matches!(&**target, LogicalExpr::Closure(_))
&& target.read_only()
&& args.iter().all(LogicalExpr::read_only)
}
LogicalExpr::Binary {
left,
right,
..
} => left.read_only() && right.read_only(),
LogicalExpr::Call(call) => {
call.receiver.read_only() && call.args.iter().all(LogicalExpr::read_only)
}
LogicalExpr::Closure(closure) => closure.body.read_only(),
LogicalExpr::If(branches) => {
branches.branches.iter().all(|(c, t)| c.read_only() && t.read_only())
&& branches.otherwise.as_ref().is_none_or(LogicalExpr::read_only)
}
LogicalExpr::Throw(expr) => expr.read_only(),
LogicalExpr::Subquery(op) => op.read_only(),
}
}
}
impl LogicalRecordIdLit {
pub fn read_only(&self) -> bool {
self.key.read_only()
}
}
impl LogicalRecordIdKey {
fn read_only(&self) -> bool {
match self {
LogicalRecordIdKey::Number(_)
| LogicalRecordIdKey::String(_)
| LogicalRecordIdKey::Uuid(_)
| LogicalRecordIdKey::Generate(_) => true,
LogicalRecordIdKey::Array(items) => items.iter().all(LogicalExpr::read_only),
LogicalRecordIdKey::Object(entries) => entries.iter().all(|(_, v)| v.read_only()),
LogicalRecordIdKey::Range(range) => range.read_only(),
}
}
}
impl LogicalRecordIdKeyRange {
fn read_only(&self) -> bool {
[&self.start, &self.end].into_iter().all(|bound| match bound {
Bound::Included(key) | Bound::Excluded(key) => key.read_only(),
Bound::Unbounded => true,
})
}
}
impl LogicalLookup {
fn read_only(&self) -> bool {
self.what.iter().all(LogicalLookupSubject::read_only)
&& self.expr.as_ref().is_none_or(LogicalFields::read_only)
&& self.cond.as_ref().is_none_or(LogicalExpr::read_only)
&& self.split.iter().flatten().all(LogicalExpr::read_only)
&& self.group.iter().flatten().all(LogicalExpr::read_only)
&& self.order.as_ref().is_none_or(LogicalOrdering::read_only)
&& self.limit.as_ref().is_none_or(LogicalExpr::read_only)
&& self.start.as_ref().is_none_or(LogicalExpr::read_only)
}
}
impl LogicalLookupSubject {
fn read_only(&self) -> bool {
match self {
LogicalLookupSubject::Table {
..
} => true,
LogicalLookupSubject::Range {
range,
..
} => range.read_only(),
}
}
}
impl LogicalFields {
pub fn read_only(&self) -> bool {
match self {
LogicalFields::Value {
expr,
..
} => expr.read_only(),
LogicalFields::Select(fields) => fields.iter().all(|field| match field {
LogicalField::All => true,
LogicalField::Single {
expr,
..
} => expr.read_only(),
}),
}
}
}
impl LogicalOrdering {
pub fn read_only(&self) -> bool {
match self {
LogicalOrdering::Random => true,
LogicalOrdering::Order(orders) => orders.iter().all(|o| o.value.read_only()),
}
}
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct OutputPath {
pub parts: Vec<OutputPathPart>,
pub exact: bool,
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub enum OutputPathPart {
Field(String),
Lookup(String),
}
impl OutputPath {
pub fn field(name: impl Into<String>) -> Self {
OutputPath::keys(vec![OutputPathPart::Field(name.into())])
}
pub fn keys(parts: Vec<OutputPathPart>) -> Self {
OutputPath {
parts,
exact: true,
}
}
pub fn parts(&self) -> &[OutputPathPart] {
&self.parts
}
pub fn as_field(&self) -> Option<&str> {
match self.parts.as_slice() {
[OutputPathPart::Field(name)] => Some(name),
_ => None,
}
}
pub fn is_field(&self, name: &str) -> bool {
self.as_field() == Some(name)
}
pub fn name(&self) -> String {
match self.as_field() {
Some(name) => name.to_owned(),
None => self.to_sql(),
}
}
}
impl ToSql for OutputPath {
fn fmt_sql(&self, f: &mut String, fmt: SqlFormat) {
for (i, part) in self.parts.iter().enumerate() {
match part {
OutputPathPart::Field(name) if i == 0 => EscapeIdent(name).fmt_sql(f, fmt),
OutputPathPart::Field(name) => write_sql!(f, fmt, ".{}", EscapeKwFreeIdent(name)),
OutputPathPart::Lookup(lookup) => f.push_str(lookup),
}
}
}
}
enum Segment<'a> {
Field(&'a Strand),
Start(&'a LogicalExpr),
Lookup(&'a LogicalLookup),
Other,
}
impl LogicalExpr {
fn segments<'a>(&'a self, out: &mut Vec<Segment<'a>>) {
match self {
LogicalExpr::Current => {}
LogicalExpr::Field(name) => out.push(Segment::Field(name)),
LogicalExpr::Doc => out.push(Segment::Other),
LogicalExpr::Access {
base,
field,
} => {
base.segments(out);
out.push(Segment::Field(field));
}
LogicalExpr::Lookup {
base,
lookup,
} => {
base.segments(out);
out.push(Segment::Lookup(lookup));
}
LogicalExpr::Optional {
base,
then,
} => {
base.segments(out);
out.push(Segment::Other);
then.segments(out);
}
LogicalExpr::Recurse(recurse) => {
recurse.base.segments(out);
out.push(Segment::Other);
if let Some(LogicalRecursePath::Trailing(body)) = &recurse.path {
body.segments(out);
}
}
LogicalExpr::Broadcast {
base,
body,
..
} => {
base.segments(out);
body.segments(out);
}
LogicalExpr::Index {
base,
..
}
| LogicalExpr::Flatten {
base,
..
}
| LogicalExpr::Filter {
base,
..
}
| LogicalExpr::Method {
base,
..
}
| LogicalExpr::Destructure {
base,
..
} => {
base.segments(out);
out.push(Segment::Other);
}
LogicalExpr::First(base)
| LogicalExpr::Last(base)
| LogicalExpr::Each(base)
| LogicalExpr::RepeatRecurse(base) => {
base.segments(out);
out.push(Segment::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(_) => out.push(Segment::Start(self)),
}
}
pub fn named_after_gates(&self) -> std::borrow::Cow<'_, LogicalExpr> {
fn is_literal_gate(expr: &LogicalExpr) -> bool {
matches!(
expr,
LogicalExpr::Binary {
left,
op: BinaryOperator::And | BinaryOperator::Or,
..
} if matches!(left.as_ref(), LogicalExpr::Literal(LogicalLiteral::Bool(_)))
)
}
if !self.any(is_literal_gate) {
return std::borrow::Cow::Borrowed(self);
}
let folded = self.clone().transform::<std::convert::Infallible>(&mut |node| {
let LogicalExpr::Binary {
left,
op,
right,
} = node
else {
return Ok(node);
};
Ok(match (*left, op) {
(LogicalExpr::Literal(LogicalLiteral::Bool(true)), BinaryOperator::And)
| (LogicalExpr::Literal(LogicalLiteral::Bool(false)), BinaryOperator::Or) => *right,
(
literal @ LogicalExpr::Literal(LogicalLiteral::Bool(false)),
BinaryOperator::And,
)
| (
literal @ LogicalExpr::Literal(LogicalLiteral::Bool(true)),
BinaryOperator::Or,
) => literal,
(left, op) => LogicalExpr::Binary {
left: Box::new(left),
op,
right,
},
})
});
match folded {
Ok(folded) => std::borrow::Cow::Owned(folded),
Err(never) => match never {},
}
}
pub fn output_path(&self) -> OutputPath {
if self.is_path() {
let mut segments = Vec::new();
self.segments(&mut segments);
return path_output(&segments);
}
match self {
LogicalExpr::Param(param) => OutputPath::field(param.as_str()),
LogicalExpr::Call(call) => OutputPath::field(function_name(&call.receiver).as_str()),
LogicalExpr::Literal(LogicalLiteral::String(s)) => OutputPath::field(s.as_str()),
LogicalExpr::Literal(LogicalLiteral::Datetime(d)) => OutputPath::field(d.to_string()),
LogicalExpr::Literal(_)
| LogicalExpr::Array(_)
| LogicalExpr::Set(_)
| LogicalExpr::Object(_)
| LogicalExpr::RecordId(_)
| LogicalExpr::Table(_)
| LogicalExpr::Mock(_)
| LogicalExpr::Constant(_)
| LogicalExpr::Prefix {
..
}
| LogicalExpr::Postfix {
..
}
| LogicalExpr::Invoke {
..
}
| LogicalExpr::Binary {
..
}
| LogicalExpr::Closure(_)
| LogicalExpr::If(_)
| LogicalExpr::Throw(_)
| LogicalExpr::Break
| LogicalExpr::Continue
| LogicalExpr::Subquery(_)
| 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::SetField {
..
} => OutputPath::field(self.to_sql()),
}
}
pub fn output_name_renders_a_statement(&self) -> bool {
let is_statement =
|expr: &LogicalExpr| matches!(expr, LogicalExpr::Subquery(_) | LogicalExpr::If(_));
if self.is_path() {
let mut segments = Vec::new();
self.segments(&mut segments);
if segments
.iter()
.any(|segment| matches!(segment, Segment::Lookup(lookup) if lookup.alias.is_some()))
{
return false;
}
return segments.iter().any(|segment| match segment {
Segment::Start(start) => start.any(is_statement),
Segment::Lookup(lookup) => {
let mut found = false;
lookup.for_each_expr(&mut |expr| found = found || expr.any(is_statement));
found
}
Segment::Field(_) | Segment::Other => false,
});
}
match self {
LogicalExpr::Param(_)
| LogicalExpr::Call(_)
| LogicalExpr::Literal(
LogicalLiteral::String(_)
| LogicalLiteral::Datetime(_)
| LogicalLiteral::Date(_)
| LogicalLiteral::Time(_)
| LogicalLiteral::Timestamp(_)
| LogicalLiteral::Interval(_),
) => false,
LogicalExpr::Subquery(_) | LogicalExpr::If(_) => true,
LogicalExpr::Literal(_)
| LogicalExpr::Array(_)
| LogicalExpr::Set(_)
| LogicalExpr::Object(_)
| LogicalExpr::RecordId(_)
| LogicalExpr::Table(_)
| LogicalExpr::Mock(_)
| LogicalExpr::Constant(_)
| LogicalExpr::Prefix {
..
}
| LogicalExpr::Postfix {
..
}
| LogicalExpr::Invoke {
..
}
| LogicalExpr::Binary {
..
}
| LogicalExpr::Closure(_)
| LogicalExpr::Throw(_)
| LogicalExpr::Break
| LogicalExpr::Continue
| 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::SetField {
..
} => self.any(is_statement),
}
}
}
fn path_output(segments: &[Segment<'_>]) -> OutputPath {
let exact_when = |parts: Vec<OutputPathPart>| OutputPath {
exact: parts.len() == segments.len(),
parts,
};
for segment in segments {
if let Segment::Lookup(lookup) = segment
&& let Some(alias) = &lookup.alias
{
return exact_when(vec![OutputPathPart::Field(alias.name())]);
}
}
let naming: Vec<&Segment<'_>> =
segments.iter().filter(|s| !matches!(s, Segment::Other)).collect();
let name = match naming.as_slice() {
[Segment::Field(name)] => name.as_str().to_owned(),
_ => {
let mut out = String::new();
for (i, segment) in naming.iter().enumerate() {
match segment {
Segment::Field(name) if i == 0 => {
EscapeIdent(name.as_str()).fmt_sql(&mut out, SqlFormat::SingleLine)
}
Segment::Field(name) => {
out.push('.');
EscapeKwFreeIdent(name.as_str()).fmt_sql(&mut out, SqlFormat::SingleLine);
}
Segment::Start(start) => fmt_start(start, &mut out, SqlFormat::SingleLine),
Segment::Lookup(lookup) => lookup.fmt_sql(&mut out, SqlFormat::SingleLine),
Segment::Other => {}
}
}
out
}
};
if naming.is_empty() || naming.iter().any(|s| matches!(s, Segment::Start(_))) {
return exact_when(vec![OutputPathPart::Field(name)]);
}
exact_when(
naming
.iter()
.filter_map(|segment| match segment {
Segment::Field(name) => Some(OutputPathPart::Field(name.as_str().to_owned())),
Segment::Lookup(lookup) => Some(OutputPathPart::Lookup(lookup.to_sql())),
Segment::Start(_) | Segment::Other => None,
})
.collect(),
)
}
fn function_name(function: &Function) -> Strand {
let mut parts = function.to_idiom().0.into_iter();
if let Some(crate::expr::Part::Field(name)) = parts.next() {
name
} else {
Strand::new("function")
}
}
struct Cover<'a>(&'a LogicalExpr);
impl ToSql for Cover<'_> {
fn fmt_sql(&self, f: &mut String, fmt: SqlFormat) {
if let LogicalExpr::If(_) = self.0 {
f.push('(');
self.0.fmt_sql(f, fmt);
f.push(')');
} else {
self.0.fmt_sql(f, fmt);
}
}
}
impl LogicalExpr {
fn needs_parentheses(&self) -> bool {
match self {
LogicalExpr::Literal(LogicalLiteral::UnboundedRange)
| LogicalExpr::RecordId(_)
| LogicalExpr::Closure(_)
| LogicalExpr::Break
| LogicalExpr::Continue
| LogicalExpr::Throw(_)
| LogicalExpr::If(_)
| LogicalExpr::Postfix {
..
}
| LogicalExpr::Invoke {
..
} => true,
LogicalExpr::Literal(_)
| LogicalExpr::Array(_)
| LogicalExpr::Set(_)
| LogicalExpr::Object(_)
| 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::Binary {
..
}
| LogicalExpr::SetField {
..
}
| LogicalExpr::Call(_)
| LogicalExpr::Subquery(_) => false,
}
}
fn leading_step(&self) -> Option<&LogicalExpr> {
let mut current = self;
loop {
if let LogicalExpr::Broadcast {
base,
body,
..
} = current && matches!(**base, LogicalExpr::Current)
{
current = body;
continue;
}
match current.step_base() {
Some(LogicalExpr::Current) => return Some(current),
Some(base) => current = base,
None => return None,
}
}
}
fn has_left_minus(&self) -> bool {
match self {
LogicalExpr::Prefix {
op: PrefixOperator::Negate,
..
} => true,
LogicalExpr::Postfix {
expr,
..
}
| LogicalExpr::Binary {
left: expr,
..
}
| LogicalExpr::Invoke {
target: expr,
..
} => expr.has_left_minus(),
LogicalExpr::Literal(LogicalLiteral::Integer(x)) => x.is_negative(),
LogicalExpr::Literal(LogicalLiteral::Float(x)) => x.is_sign_negative(),
LogicalExpr::Literal(LogicalLiteral::Decimal(x)) => x.is_sign_negative(),
LogicalExpr::Literal(LogicalLiteral::I8(x)) => x.is_negative(),
LogicalExpr::Literal(LogicalLiteral::I16(x)) => x.is_negative(),
LogicalExpr::Literal(LogicalLiteral::I32(x)) => x.is_negative(),
LogicalExpr::Literal(LogicalLiteral::F16(x)) => x.is_finite() && x.is_sign_negative(),
LogicalExpr::Literal(LogicalLiteral::F32(x)) => x.is_finite() && x.is_sign_negative(),
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 {
..
} => matches!(
self.leading_step(),
Some(LogicalExpr::Lookup { lookup, .. })
if lookup.kind == LookupKind::Graph(crate::expr::Dir::Out)
),
LogicalExpr::Literal(_)
| LogicalExpr::Array(_)
| LogicalExpr::Set(_)
| LogicalExpr::Object(_)
| LogicalExpr::RecordId(_)
| LogicalExpr::Param(_)
| LogicalExpr::Table(_)
| LogicalExpr::Mock(_)
| LogicalExpr::Constant(_)
| LogicalExpr::SetField {
..
}
| LogicalExpr::Prefix {
..
}
| LogicalExpr::Call(_)
| LogicalExpr::Closure(_)
| LogicalExpr::If(_)
| LogicalExpr::Throw(_)
| LogicalExpr::Break
| LogicalExpr::Continue
| LogicalExpr::Subquery(_) => false,
}
}
fn has_left_idiom(&self) -> bool {
match self {
LogicalExpr::Postfix {
expr,
..
}
| LogicalExpr::Binary {
left: expr,
..
}
| LogicalExpr::Invoke {
target: expr,
..
} => expr.has_left_idiom(),
LogicalExpr::Literal(_)
| LogicalExpr::Array(_)
| LogicalExpr::Set(_)
| LogicalExpr::Object(_)
| LogicalExpr::RecordId(_)
| LogicalExpr::Param(_)
| LogicalExpr::Table(_)
| LogicalExpr::Mock(_)
| LogicalExpr::Constant(_)
| LogicalExpr::SetField {
..
}
| LogicalExpr::Prefix {
..
}
| LogicalExpr::Call(_)
| LogicalExpr::Closure(_)
| LogicalExpr::If(_)
| LogicalExpr::Throw(_)
| LogicalExpr::Break
| LogicalExpr::Continue
| LogicalExpr::Subquery(_) => false,
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 {
..
} => true,
}
}
fn binding_power(&self) -> BindingPower {
match self {
LogicalExpr::Prefix {
op,
..
} => {
if let PrefixOperator::Range | PrefixOperator::RangeInclusive = op {
BindingPower::Range
} else {
BindingPower::Prefix
}
}
LogicalExpr::Postfix {
op,
..
} => op.binding_power(),
LogicalExpr::Invoke {
..
} => BindingPower::Call,
LogicalExpr::Binary {
op,
..
} => BindingPower::for_binary_operator(op),
LogicalExpr::Literal(_)
| LogicalExpr::Array(_)
| 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::Call(_)
| LogicalExpr::Closure(_)
| LogicalExpr::If(_)
| LogicalExpr::Throw(_)
| LogicalExpr::Break
| LogicalExpr::Continue
| LogicalExpr::SetField {
..
}
| LogicalExpr::Subquery(_) => BindingPower::Prime,
}
}
}
impl LogicalPostfixOperator {
fn binding_power(&self) -> BindingPower {
match self {
LogicalPostfixOperator::Range | LogicalPostfixOperator::RangeSkip => {
BindingPower::Range
}
}
}
}
fn write_closing_indent(f: &mut String, fmt: SqlFormat) {
if let SqlFormat::Indented(level) = fmt
&& level > 0
{
for _ in 0..(level - 1) {
f.push('\t');
}
}
}
fn fmt_object_entries(entries: &[(String, LogicalExpr)], f: &mut String, fmt: SqlFormat) {
if fmt.is_pretty() {
f.push('{');
} else {
f.push_str("{ ");
}
if !entries.is_empty() {
let fmt = fmt.increment();
if fmt.is_pretty() {
f.push('\n');
fmt.write_indent(f);
}
for (i, (key, value)) in entries.iter().enumerate() {
if i > 0 {
fmt.write_separator(f);
}
write_sql!(f, fmt, "{}: {}", EscapeObjectKey(key), Cover(value));
}
if fmt.is_pretty() {
f.push('\n');
write_closing_indent(f, fmt);
}
}
if fmt.is_pretty() {
f.push('}');
} else {
f.push_str(" }");
}
}
#[derive(Clone, Copy, PartialEq, Eq)]
enum BodyRoot {
Step,
Bare,
}
fn fmt_start(start: &LogicalExpr, f: &mut String, fmt: SqlFormat) {
let negative_number = matches!(start, LogicalExpr::Literal(LogicalLiteral::Decimal(d)) if d.is_sign_negative())
|| matches!(start, LogicalExpr::Literal(LogicalLiteral::Integer(i)) if i.is_negative())
|| matches!(start, LogicalExpr::Literal(LogicalLiteral::Float(x)) if x.is_sign_negative())
|| matches!(start, LogicalExpr::Literal(LogicalLiteral::I8(i)) if i.is_negative())
|| matches!(start, LogicalExpr::Literal(LogicalLiteral::I16(i)) if i.is_negative())
|| matches!(start, LogicalExpr::Literal(LogicalLiteral::I32(i)) if i.is_negative())
|| matches!(start, LogicalExpr::Literal(LogicalLiteral::F16(x)) if x.is_finite() && x.is_sign_negative())
|| matches!(start, LogicalExpr::Literal(LogicalLiteral::F32(x)) if x.is_finite() && x.is_sign_negative());
if start.needs_parentheses()
|| matches!(
start,
LogicalExpr::Binary { .. }
| LogicalExpr::Prefix { .. }
| LogicalExpr::Postfix { .. }
| LogicalExpr::Invoke { .. }
) || negative_number
{
write_sql!(f, fmt, "({start})");
} else {
start.fmt_sql(f, fmt);
}
}
fn binds_onto_a_broadcast(step: &LogicalExpr) -> bool {
!matches!(step, LogicalExpr::Access { .. } | LogicalExpr::Each(_) | LogicalExpr::Flatten { .. })
}
fn fmt_path(expr: &LogicalExpr, f: &mut String, fmt: SqlFormat, root: BodyRoot) {
let start = f.len();
let mut steps = Vec::new();
let mut current = expr;
let mut grouped = false;
let root_expr = loop {
if let LogicalExpr::Broadcast {
base,
..
} = current
&& (matches!(
base.as_ref(),
LogicalExpr::Access { .. } | LogicalExpr::Destructure { .. }
) || matches!(
base.as_ref(),
LogicalExpr::Broadcast { body, .. } if body.step_base().is_some()
)) && !matches!(base.path_root(), LogicalExpr::Current)
{
steps.push(current);
grouped = true;
break base.as_ref();
}
match current.step_base() {
Some(base) => {
steps.push(current);
current = base;
}
None => break current,
}
};
if grouped {
write_sql!(f, fmt, "({root_expr})");
} else if let LogicalExpr::Field(name) = root_expr {
EscapeIdent(name.as_str()).fmt_sql(f, fmt);
} else if matches!(root_expr, LogicalExpr::Doc) {
f.push('@');
} else if !matches!(root_expr, LogicalExpr::Current) {
fmt_start(root_expr, f, fmt);
}
let mut root = root;
let on_current = matches!(root_expr, LogicalExpr::Current);
let groups = if on_current {
0
} else {
let mut after_access = false;
let mut groups = 0usize;
for step in steps.iter().rev() {
if after_access && binds_onto_a_broadcast(step) {
groups += 1;
}
after_access = matches!(step, LogicalExpr::Access { .. });
}
groups
};
if groups > 0 {
f.insert_str(start, &"(".repeat(groups));
}
let mut after_access = false;
for (i, step) in steps.iter().rev().enumerate() {
let innermost = i == 0 && on_current;
if after_access && !on_current && binds_onto_a_broadcast(step) {
f.push(')');
}
after_access = matches!(step, LogicalExpr::Access { .. });
match step {
LogicalExpr::Access {
field,
..
} => {
if innermost && root == BodyRoot::Bare {
EscapeIdent(field.as_str()).fmt_sql(f, fmt);
} else {
write_sql!(f, fmt, ".{}", EscapeKwFreeIdent(field.as_str()));
}
root = BodyRoot::Step;
}
LogicalExpr::Index {
index,
..
} => {
write_sql!(f, fmt, "[{index}]");
root = BodyRoot::Step;
}
LogicalExpr::First(_) => {
f.push_str("[0]");
root = BodyRoot::Step;
}
LogicalExpr::Last(_) => {
f.push_str("[$]");
root = BodyRoot::Step;
}
LogicalExpr::Each(_) => {
f.push_str(".*");
root = BodyRoot::Step;
}
LogicalExpr::Flatten {
explicit,
..
} => {
if *explicit {
f.push('…');
}
root = BodyRoot::Step;
}
LogicalExpr::Filter {
predicate,
..
} => {
write_sql!(f, fmt, "[WHERE {predicate}]");
root = BodyRoot::Step;
}
LogicalExpr::Method {
name,
args,
..
} => {
write_sql!(
f,
fmt,
".{}({})",
EscapeKwFreeIdent(name.as_str()),
Fmt::comma_separated(args.iter().map(Cover))
);
root = BodyRoot::Step;
}
LogicalExpr::Destructure {
fields,
..
} => {
fmt_destructure(fields, f, fmt);
root = BodyRoot::Step;
}
LogicalExpr::Lookup {
lookup,
..
} => {
lookup.fmt_sql(f, fmt);
root = BodyRoot::Step;
}
LogicalExpr::RepeatRecurse(_) => {
f.push_str(".@");
root = BodyRoot::Step;
}
LogicalExpr::Optional {
then,
..
} => {
f.push_str(".?");
fmt_path(then, f, fmt, BodyRoot::Step);
root = BodyRoot::Step;
}
LogicalExpr::Recurse(recurse) => {
write_sql!(f, fmt, ".{{{}", recurse.recurse);
if let Some(instruction) = &recurse.instruction {
write_sql!(f, fmt, "+{instruction}");
}
f.push('}');
match &recurse.path {
Some(LogicalRecursePath::Nested(body)) => {
f.push('(');
fmt_path(body, f, fmt, BodyRoot::Step);
f.push(')');
}
Some(LogicalRecursePath::Trailing(body)) => {
fmt_path(body, f, fmt, BodyRoot::Step)
}
None => {}
}
root = BodyRoot::Step;
}
LogicalExpr::Broadcast {
body,
..
} => {
let body_root = if innermost {
root
} else {
BodyRoot::Step
};
fmt_path(body, f, fmt, body_root);
root = BodyRoot::Step;
}
LogicalExpr::Field(_)
| LogicalExpr::Doc
| LogicalExpr::Current
| 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(_) => {}
}
}
}
fn fmt_destructure(fields: &[LogicalDestructureField], f: &mut String, fmt: SqlFormat) {
f.push_str(".{");
if !fmt.is_pretty() {
f.push(' ');
}
if !fields.is_empty() {
let fmt = fmt.increment();
write_sql!(f, fmt, "{}", Fmt::pretty_comma_separated(fields));
}
if fmt.is_pretty() {
f.push('}');
} else {
f.push_str(" }");
}
}
impl ToSql for LogicalExpr {
fn fmt_sql(&self, f: &mut String, fmt: SqlFormat) {
match self {
LogicalExpr::Literal(literal) => literal.fmt_sql(f, fmt),
LogicalExpr::Array(items) => {
f.push('[');
if !items.is_empty() {
let fmt = fmt.increment();
if fmt.is_pretty() {
f.push('\n');
fmt.write_indent(f);
}
for (i, item) in items.iter().enumerate() {
if i > 0 {
fmt.write_separator(f);
}
Cover(item).fmt_sql(f, fmt);
}
if fmt.is_pretty() {
f.push('\n');
write_closing_indent(f, fmt);
}
}
f.push(']');
}
LogicalExpr::Set(items) => {
f.push('{');
if !items.is_empty() {
let fmt = fmt.increment();
if fmt.is_pretty() {
f.push('\n');
fmt.write_indent(f);
}
for (i, item) in items.iter().enumerate() {
if i > 0 {
fmt.write_separator(f);
} else if let LogicalExpr::RecordId(_) = item {
f.push('(');
item.fmt_sql(f, fmt);
f.push(')');
continue;
}
Cover(item).fmt_sql(f, fmt);
}
if items.len() == 1 {
f.push(',');
}
if fmt.is_pretty() {
f.push('\n');
write_closing_indent(f, fmt);
}
} else {
f.push(',');
}
f.push('}');
}
LogicalExpr::Object(entries) => fmt_object_entries(entries, f, fmt),
LogicalExpr::RecordId(rid) => rid.fmt_sql(f, fmt),
LogicalExpr::Param(param) => param.fmt_sql(f, fmt),
LogicalExpr::Table(table) => EscapeIdent(table.as_str()).fmt_sql(f, fmt),
LogicalExpr::Mock(mock) => mock.fmt_sql(f, fmt),
LogicalExpr::Constant(constant) => constant.fmt_sql(f, fmt),
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 {
..
} => fmt_path(self, f, fmt, BodyRoot::Step),
LogicalExpr::SetField {
base,
field,
value,
} => write_sql!(
f,
fmt,
"set_field({}, {}, {})",
Cover(base),
QuoteStr(field.as_str()),
Cover(value)
),
LogicalExpr::Prefix {
op,
expr,
} => {
let expr: &LogicalExpr = expr;
let expr_bp = expr.binding_power();
let op_bp = if let PrefixOperator::Range | PrefixOperator::RangeInclusive = op {
BindingPower::Range
} else {
BindingPower::Prefix
};
if expr.needs_parentheses()
|| expr_bp < op_bp
|| expr_bp == op_bp && matches!(expr_bp, BindingPower::Range)
|| *op == PrefixOperator::Negate && expr.has_left_minus()
|| *op == PrefixOperator::Negate
&& matches!(
expr,
LogicalExpr::Literal(
LogicalLiteral::U8(_)
| LogicalLiteral::U16(_) | LogicalLiteral::U32(_)
| LogicalLiteral::U64(_)
)
) {
write_sql!(f, fmt, "{op}({expr})");
} else {
write_sql!(f, fmt, "{op}{expr}");
}
}
LogicalExpr::Postfix {
expr,
op,
} => {
let expr: &LogicalExpr = expr;
let expr_bp = expr.binding_power();
let op_bp = op.binding_power();
if expr.needs_parentheses()
|| expr_bp < op_bp
|| expr_bp == op_bp && matches!(expr_bp, BindingPower::Range)
{
write_sql!(f, fmt, "({expr}){op}");
} else {
write_sql!(f, fmt, "{expr}{op}");
}
}
LogicalExpr::Invoke {
target,
args,
} => {
let target: &LogicalExpr = target;
write_sql!(f, fmt, "({target})");
write_sql!(f, fmt, "({})", Fmt::comma_separated(args.iter().map(Cover)));
}
LogicalExpr::Binary {
left,
op,
right,
} => {
let left: &LogicalExpr = left;
let right: &LogicalExpr = right;
let op_bp = self.binding_power();
let left_bp = left.binding_power();
let right_bp = right.binding_power();
if left.needs_parentheses()
|| left_bp < op_bp
|| left_bp == op_bp
&& matches!(
left_bp,
BindingPower::Range
| BindingPower::Relation | BindingPower::Equality
| BindingPower::Power
) || matches!(op, BinaryOperator::Matches(_))
&& left_bp == BindingPower::Relation
{
write_sql!(f, fmt, "({left})");
} else {
write_sql!(f, fmt, "{left}");
}
if matches!(
op,
BinaryOperator::Range
| BinaryOperator::RangeSkip
| BinaryOperator::RangeInclusive
| BinaryOperator::RangeSkipInclusive
) {
op.fmt_sql(f, fmt);
} else {
f.push(' ');
op.fmt_sql(f, fmt);
f.push(' ');
}
if right.needs_parentheses()
|| right_bp < op_bp
|| right_bp == op_bp
&& matches!(
right_bp,
BindingPower::Nullish
| BindingPower::Range | BindingPower::Relation
| BindingPower::Equality | BindingPower::AddSub
| BindingPower::MulDiv
) || matches!(op, BinaryOperator::Matches(_))
&& right_bp == BindingPower::Relation
{
write_sql!(f, fmt, "({right})");
} else {
write_sql!(f, fmt, "{right}");
}
}
LogicalExpr::Call(call) => call.fmt_sql(f, fmt),
LogicalExpr::Closure(closure) => closure.fmt_sql(f, fmt),
LogicalExpr::If(branches) => branches.fmt_sql(f, fmt),
LogicalExpr::Throw(expr) => write_sql!(f, fmt, "THROW {}", Cover(expr)),
LogicalExpr::Break => f.push_str("BREAK"),
LogicalExpr::Continue => f.push_str("CONTINUE"),
LogicalExpr::Subquery(op) => {
f.push_str("(\n");
op.render(f, 1);
f.push(')');
}
}
}
}
impl Display for LogicalExpr {
fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
f.write_str(&self.to_sql())
}
}
impl ToSql for LogicalPostfixOperator {
fn fmt_sql(&self, f: &mut String, _fmt: SqlFormat) {
match self {
LogicalPostfixOperator::Range => f.push_str(".."),
LogicalPostfixOperator::RangeSkip => f.push_str(">.."),
}
}
}
impl ToSql for LogicalRecordIdLit {
fn fmt_sql(&self, f: &mut String, fmt: SqlFormat) {
write_sql!(f, fmt, "{}:{}", EscapeIdent(self.table.as_str()), self.key);
}
}
impl ToSql for LogicalRecordIdKey {
fn fmt_sql(&self, f: &mut String, fmt: SqlFormat) {
match self {
LogicalRecordIdKey::Number(v) => write_sql!(f, fmt, "{v}"),
LogicalRecordIdKey::String(v) => EscapeRidKey(v).fmt_sql(f, fmt),
LogicalRecordIdKey::Uuid(v) => write_sql!(f, fmt, "u{}", QuoteStr(&v.to_string())),
LogicalRecordIdKey::Array(items) => {
f.push('[');
if !items.is_empty() {
let fmt = fmt.increment();
write_sql!(f, fmt, "{}", Fmt::pretty_comma_separated(items.iter().map(Cover)));
}
f.push(']');
}
LogicalRecordIdKey::Object(entries) => {
if fmt.is_pretty() {
f.push('{');
} else {
f.push_str("{ ");
}
if !entries.is_empty() {
let fmt = fmt.increment();
write_sql!(
f,
fmt,
"{}",
Fmt::pretty_comma_separated(entries.iter().map(|(key, value)| Fmt::new(
(key, value),
|(key, value), f, fmt| write_sql!(
f,
fmt,
"{}: {}",
EscapeObjectKey(key),
Cover(value)
)
)))
);
}
if fmt.is_pretty() {
f.push('}');
} else {
f.push_str(" }");
}
}
LogicalRecordIdKey::Generate(generator) => match generator {
RecordIdKeyGen::Rand => f.push_str("rand()"),
RecordIdKeyGen::Ulid => f.push_str("ulid()"),
RecordIdKeyGen::Uuid => f.push_str("uuid()"),
},
LogicalRecordIdKey::Range(range) => range.fmt_sql(f, fmt),
}
}
}
impl ToSql for LogicalRecordIdKeyRange {
fn fmt_sql(&self, f: &mut String, fmt: SqlFormat) {
match &self.start {
Bound::Unbounded => {}
Bound::Included(v) => v.fmt_sql(f, fmt),
Bound::Excluded(v) => {
v.fmt_sql(f, fmt);
f.push('>');
}
}
match &self.end {
Bound::Unbounded => f.push_str(".."),
Bound::Excluded(v) => {
f.push_str("..");
v.fmt_sql(f, fmt);
}
Bound::Included(v) => {
f.push_str("..=");
v.fmt_sql(f, fmt);
}
}
}
}
impl ToSql for LogicalDestructureField {
fn fmt_sql(&self, f: &mut String, fmt: SqlFormat) {
match self {
LogicalDestructureField::All(name) => {
write_sql!(f, fmt, "{}.*", EscapeKwFreeIdent(name.as_str()))
}
LogicalDestructureField::Field(name) => {
write_sql!(f, fmt, "{}", EscapeKwFreeIdent(name.as_str()))
}
LogicalDestructureField::Aliased(name, body) => {
write_sql!(f, fmt, "{}: ", EscapeKwFreeIdent(name.as_str()));
fmt_path(body, f, fmt, BodyRoot::Bare);
}
LogicalDestructureField::Destructure(name, fields) => {
write_sql!(f, fmt, "{}", EscapeKwFreeIdent(name.as_str()));
fmt_destructure(fields, f, fmt);
}
LogicalDestructureField::Rest => f.push_str("..."),
}
}
}
impl ToSql for LogicalRecurseInstruction {
fn fmt_sql(&self, f: &mut String, fmt: SqlFormat) {
match self {
LogicalRecurseInstruction::Path {
inclusive,
} => {
f.push_str("path");
if *inclusive {
f.push_str("+inclusive");
}
}
LogicalRecurseInstruction::Collect {
inclusive,
} => {
f.push_str("collect");
if *inclusive {
f.push_str("+inclusive");
}
}
LogicalRecurseInstruction::Shortest {
expects,
inclusive,
} => {
write_sql!(f, fmt, "shortest={expects}");
if *inclusive {
f.push_str("+inclusive");
}
}
}
}
}
impl ToSql for LogicalLookup {
fn fmt_sql(&self, f: &mut String, fmt: SqlFormat) {
let short = self.what.len() <= 1
&& self.what.iter().all(|subject| {
subject.referencing_field().is_none()
&& !matches!(
subject,
LogicalLookupSubject::Range {
range: LogicalRecordIdKeyRange {
end: Bound::Unbounded,
..
},
..
}
)
}) && self.cond.is_none()
&& self.alias.is_none()
&& self.expr.is_none();
if short {
self.kind.fmt_sql(f, fmt);
if self.what.is_empty() {
f.push('?');
} else {
write_sql!(f, fmt, "{}", Fmt::comma_separated(self.what.iter()));
}
return;
}
write_sql!(f, fmt, "{}(", self.kind);
if let Some(fields) = &self.expr {
write_sql!(f, fmt, "SELECT {} FROM ", fields);
if self.only {
f.push_str("ONLY ");
}
}
if self.what.is_empty() {
f.push('?');
} else {
write_sql!(f, fmt, "{}", Fmt::comma_separated(&self.what));
}
if let Some(cond) = &self.cond {
write_sql!(f, fmt, " WHERE {}", Cover(cond));
}
if let Some(split) = &self.split {
write_sql!(f, fmt, " SPLIT ON {}", Fmt::comma_separated(split));
}
if let Some(group) = &self.group {
if group.is_empty() {
f.push_str(" GROUP ALL");
} else {
write_sql!(f, fmt, " GROUP BY {}", Fmt::comma_separated(group));
}
}
if let Some(order) = &self.order {
write_sql!(f, fmt, " {order}");
}
if let Some(limit) = &self.limit {
write_sql!(f, fmt, " LIMIT {}", Cover(limit));
}
if let Some(start) = &self.start {
write_sql!(f, fmt, " START {}", Cover(start));
}
if let Some(alias) = &self.alias {
write_sql!(f, fmt, " AS {alias}");
}
f.push(')');
}
}
impl ToSql for LogicalLookupSubject {
fn fmt_sql(&self, f: &mut String, fmt: SqlFormat) {
match self {
LogicalLookupSubject::Table {
table,
referencing_field,
} => {
write_sql!(f, fmt, "{}", EscapeKwFreeIdent(table.as_str()));
if let Some(field) = referencing_field {
write_sql!(f, fmt, " FIELD {}", EscapeKwFreeIdent(field));
}
}
LogicalLookupSubject::Range {
table,
range,
referencing_field,
} => {
write_sql!(f, fmt, "{}:{range}", EscapeKwFreeIdent(table.as_str()));
if let Some(field) = referencing_field {
write_sql!(f, fmt, " FIELD {}", EscapeKwFreeIdent(field));
}
}
}
}
}
impl ToSql for LogicalCall {
fn fmt_sql(&self, f: &mut String, fmt: SqlFormat) {
let args = || Fmt::comma_separated(self.args.iter().map(Cover));
match &self.receiver {
Function::Normal(name) => {
for (i, segment) in name.split("::").enumerate() {
if i == 0 {
write_sql!(f, fmt, "{}", EscapeIdent(segment));
} else {
f.push_str("::");
f.push_str(segment);
}
}
}
Function::Custom(name) => {
f.push_str("fn");
for segment in name.split("::") {
write_sql!(f, fmt, "::{}", EscapeKwFreeIdent(segment));
}
}
Function::Script(script) => {
write_sql!(f, fmt, "function({}) {{{}}}", args(), script);
return;
}
Function::Model(model) => write_sql!(f, fmt, "{model}"),
Function::Module(module, sub, prefix) => {
write_sql!(f, fmt, "{}::{}", prefix.as_str(), EscapeKwFreeIdent(module));
if let Some(sub) = sub {
for segment in sub.split("::") {
write_sql!(f, fmt, "::{}", EscapeKwFreeIdent(segment));
}
}
}
Function::Silo {
org,
pkg,
major,
minor,
patch,
sub,
} => {
write_sql!(
f,
fmt,
"silo::{}::{}<{major}.{minor}.{patch}>",
EscapeKwFreeIdent(org),
EscapeKwFreeIdent(pkg),
);
if let Some(sub) = sub {
for segment in sub.split("::") {
write_sql!(f, fmt, "::{}", EscapeKwFreeIdent(segment));
}
}
}
}
write_sql!(f, fmt, "({})", args());
}
}
impl ToSql for LogicalClosure {
fn fmt_sql(&self, f: &mut String, fmt: SqlFormat) {
f.push('|');
for (i, (name, kind)) in self.args.iter().enumerate() {
if i > 0 {
f.push_str(", ");
}
write_sql!(f, fmt, "{name}: ");
if let Kind::Either(_) = kind {
write_sql!(f, fmt, "<{kind}>");
} else {
write_sql!(f, fmt, "{kind}");
}
}
f.push('|');
if let Some(returns) = &self.returns {
write_sql!(f, fmt, " -> {returns}");
}
if self.body.has_left_idiom() {
write_sql!(f, fmt, " ({})", self.body);
} else {
write_sql!(f, fmt, " {}", Cover(&self.body));
}
}
}
impl ToSql for LogicalIf {
fn fmt_sql(&self, f: &mut String, fmt: SqlFormat) {
for (i, (cond, then)) in self.branches.iter().enumerate() {
if i > 0 {
f.push_str(" ELSE ");
}
write_sql!(f, fmt, "IF {} THEN {then}", Cover(cond));
}
if let Some(otherwise) = &self.otherwise {
write_sql!(f, fmt, " ELSE {}", Cover(otherwise));
}
f.push_str(" END");
}
}
impl ToSql for LogicalFields {
fn fmt_sql(&self, f: &mut String, fmt: SqlFormat) {
match self {
LogicalFields::Value {
expr,
alias,
} => {
write_sql!(f, fmt, "VALUE {}", Cover(expr));
if let Some(alias) = alias {
write_sql!(f, fmt, " AS {alias}");
}
}
LogicalFields::Select(fields) => {
write_sql!(f, fmt, "{}", Fmt::comma_separated(fields))
}
}
}
}
impl ToSql for LogicalField {
fn fmt_sql(&self, f: &mut String, fmt: SqlFormat) {
match self {
LogicalField::All => f.push('*'),
LogicalField::Single {
expr,
alias,
kind,
frame,
} => {
write_sql!(f, fmt, "{}", Cover(expr));
if let Some(alias) = alias {
write_sql!(f, fmt, " AS {alias}");
}
if let Some(kind) = kind {
write_sql!(f, fmt, " : {kind}");
}
if let Some(rendered) = super::render_frame(frame) {
f.push(' ');
f.push_str(&rendered);
}
}
}
}
}
impl ToSql for LogicalOrdering {
fn fmt_sql(&self, f: &mut String, fmt: SqlFormat) {
match self {
LogicalOrdering::Random => f.push_str("ORDER BY RAND()"),
LogicalOrdering::Order(orders) => {
write_sql!(f, fmt, "ORDER BY {}", Fmt::comma_separated(orders))
}
}
}
}
impl ToSql for LogicalOrder {
fn fmt_sql(&self, f: &mut String, fmt: SqlFormat) {
self.value.fmt_sql(f, fmt);
if self.collate {
f.push_str(" COLLATE");
}
if self.numeric {
f.push_str(" NUMERIC");
}
if !self.direction {
f.push_str(" DESC");
}
}
}
impl ToSql for SourceRef {
fn fmt_sql(&self, f: &mut String, fmt: SqlFormat) {
match self {
SourceRef::Table(table) => EscapeIdent(table.as_str()).fmt_sql(f, fmt),
SourceRef::RecordId(rid) => rid.fmt_sql(f, fmt),
SourceRef::Mock(mock) => mock.fmt_sql(f, fmt),
SourceRef::Param(param) => param.fmt_sql(f, fmt),
SourceRef::Dynamic(expr) => expr.fmt_sql(f, fmt),
}
}
}
#[cfg(test)]
mod tests {
use std::convert::Infallible;
use super::*;
fn expr(sql: &str) -> LogicalExpr {
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");
};
crate::expr::logical::lower_expr(out.what).expect("expression should lower")
}
fn count_p(e: &LogicalExpr) -> usize {
let mut n = 0;
let _ = e.visit(&mut |x| {
if matches!(x, LogicalExpr::Param(p) if p.as_str() == "p") {
n += 1;
}
ControlFlow::<()>::Continue(())
});
n
}
fn nested_positions() -> Vec<(&'static str, LogicalExpr, usize)> {
vec![
("array elements", expr("[$p, $p]"), 2),
("set elements", LogicalExpr::Set(vec![expr("$p"), expr("$p")]), 2),
("object values", expr("{ a: $p, b: $p }"), 2),
("record-id array key", expr("t:[$p, $p]"), 2),
("record-id object key", expr("t:{ a: $p }"), 1),
("record-id range key", expr("t:[$p]..=[$p]"), 2),
("filter predicate", expr("a[WHERE b = $p]"), 1),
("index", expr("a[$p]"), 1),
("path start", expr("$p.a"), 1),
("method arguments", expr("a.slice($p, $p)"), 2),
("broadcast body", expr("a.b[$p]"), 1),
("optional body", expr("a.?.b[$p]"), 1),
("destructure alias", expr("a.{ b: c[$p] }"), 1),
("nested destructure", expr("a.{ b.{ c: d[$p] } }"), 1),
("lookup condition", expr("->(likes WHERE x = $p)"), 1),
(
"lookup projection and clauses",
expr("->(SELECT a[$p] FROM likes WHERE x = $p LIMIT $p START $p)"),
4,
),
("recurse nest", expr("a.{2..}(.b[$p])"), 1),
("recurse trailing body", expr("a.{2..}.b[$p]"), 1),
("recurse shortest", expr("a.{1..3+shortest=$p}"), 1),
("prefix operand", expr("-$p"), 1),
("cast operand", expr("<int> $p"), 1),
("postfix operand", expr("$p.."), 1),
("postfix call arguments", expr("$f($p, $p)"), 2),
("binary operands", expr("$p + $p"), 2),
("call arguments", expr("count($p, $p)"), 2),
("closure body", expr("|$x: int| $x + $p"), 1),
("if branches", expr("IF $p THEN $p ELSE IF $p THEN $p ELSE $p END"), 5),
("throw", expr("THROW $p"), 1),
("set_field base and value", set_field(expr("$p"), "f", expr("$p")), 2),
("subquery, not entered", expr("[(SELECT * FROM t WHERE a = $p)]"), 0),
]
}
fn set_field(base: LogicalExpr, field: &str, value: LogicalExpr) -> LogicalExpr {
LogicalExpr::SetField {
base: Box::new(base),
field: Strand::new(field),
value: Box::new(value),
}
}
#[test]
fn set_field_is_a_value_not_a_path() {
let guard = set_field(expr("a"), "b", expr("IF p THEN a.b ELSE NONE END"));
assert!(!guard.is_path());
assert_eq!(guard.step_base(), None);
assert_eq!(guard.path_root(), &guard);
assert!(guard.read_only());
assert!(!set_field(expr("a"), "b", expr("fn::write()")).read_only());
assert_eq!(guard.to_sql(), "set_field(a, 'b', (IF p THEN a.b ELSE NONE END))");
assert_eq!(set_field(expr("a"), "b", expr("x + 1")).to_sql(), "set_field(a, 'b', x + 1)");
assert_eq!(set_field(expr("a"), "it's", expr("1")).to_sql(), r#"set_field(a, "it's", 1)"#);
assert_eq!(guard.output_path(), OutputPath::field(guard.to_sql()));
assert!(guard.output_name_renders_a_statement());
assert!(!set_field(expr("a"), "b", expr("x + 1")).output_name_renders_a_statement());
assert_eq!(guard.children().len(), 2);
}
#[test]
fn the_walk_reaches_every_nested_position_and_stops_at_a_subquery() {
for (position, e, want) in nested_positions() {
assert_eq!(count_p(&e), want, "{position}: {e}");
}
}
#[test]
fn visit_mut_rewrites_the_same_positions() {
for (position, mut e, want) in nested_positions() {
let mut rewritten = 0;
let Ok(()) = e.visit_mut(&mut |x| {
if matches!(x, LogicalExpr::Param(p) if p.as_str() == "p") {
*x = LogicalExpr::Literal(LogicalLiteral::Integer(1));
rewritten += 1;
}
Ok::<(), Infallible>(())
});
assert_eq!(rewritten, want, "{position}");
assert_eq!(count_p(&e), 0, "{position}: {e}");
}
}
#[test]
fn an_identity_transform_rebuilds_the_same_expression() {
for (position, e, _) in nested_positions() {
let Ok(rebuilt) = e.clone().transform(&mut Ok::<LogicalExpr, Infallible>);
assert_eq!(rebuilt, e, "{position}");
}
}
#[test]
fn a_path_names_its_output_by_its_naming_steps() {
let field = |name: &str| OutputPathPart::Field(name.into());
let lookup = |name: &str| OutputPathPart::Lookup(name.into());
let cases: Vec<(&str, Vec<OutputPathPart>, bool)> = vec![
("a", vec![field("a")], true),
("a.b", vec![field("a"), field("b")], true),
("tags[WHERE type = 'x'][0].value", vec![field("tags"), field("value")], false),
("a[0]", vec![field("a")], false),
("a[$]", vec![field("a")], false),
("a.*", vec![field("a")], false),
("a.?.b", vec![field("a"), field("b")], false),
("a.len()", vec![field("a")], false),
("a.{ b, c }", vec![field("a")], false),
("a.{..}.b", vec![field("a"), field("b")], false),
("a.{..}(.b)", vec![field("a")], false),
("->likes->person", vec![lookup("->likes"), lookup("->person")], true),
(
"->likes->person.name",
vec![lookup("->likes"), lookup("->person"), field("name")],
true,
),
("->(likes AS l)->person.name", vec![field("l")], false),
("->(likes AS l)", vec![field("l")], true),
("$p.a", vec![field("$p.a")], false),
("(1 + 2).b", vec![field("(1 + 2).b")], false),
("$p", vec![field("p")], true),
("count()", vec![field("count")], true),
("fn::f()", vec![field("fn::f")], true),
("'x'", vec![field("x")], true),
("1 + 2", vec![field("1 + 2")], true),
];
for (sql, parts, exact) in cases {
let got = expr(sql).output_path();
assert_eq!(got.parts(), parts.as_slice(), "output path of `{sql}`");
assert_eq!(got.exact, exact, "exactness of `{sql}`");
}
assert_ne!(expr("a[0]").output_path(), expr("a").output_path());
assert_eq!(expr("a.b").output_path().name(), "a.b");
assert_eq!(expr("a").output_path().name(), "a");
assert_eq!(expr("->likes->person").output_path().name(), "->likes->person");
assert_eq!(expr("`a.b`").output_path().name(), "a.b");
assert_eq!(expr("`a.b`").output_path(), OutputPath::field("a.b"));
assert!(expr("id").output_path().is_field("id"));
}
#[test]
fn a_chain_of_grouped_steps_opens_all_its_parentheses_at_the_start() {
let mut plan = LogicalExpr::Field(Strand::new("a"));
let mut expected = String::from("a");
for name in ["b", "c", "d", "e", "g", "h", "i", "j"] {
plan = LogicalExpr::Access {
base: Box::new(plan),
field: Strand::new(name),
};
plan = LogicalExpr::Index {
base: Box::new(plan),
index: Box::new(LogicalExpr::Literal(LogicalLiteral::Integer(0))),
};
expected = format!("({expected}.{name})[0]");
}
assert_eq!(plan.to_sql(), expected);
assert_eq!(expr(&expected), plan, "`{expected}` reads back as a different plan");
}
#[test]
fn a_path_root_is_the_expression_it_starts_from() {
assert_eq!(expr("a.b[0].c").path_root(), &LogicalExpr::Field(Strand::new("a")));
assert_eq!(expr("$p.a[0]").path_root(), &expr("$p"));
assert_eq!(expr("->likes->person").path_root(), &LogicalExpr::Current);
assert_eq!(expr("1 + 2").path_root(), &expr("1 + 2"));
assert!(expr("a[0]").is_path());
assert!(!expr("$p").is_path());
}
#[test]
fn every_literal_variant_equals_itself() {
fn _forces_this_list_to_be_updated(l: &LogicalLiteral) {
match l {
LogicalLiteral::None
| LogicalLiteral::Null
| LogicalLiteral::UnboundedRange
| LogicalLiteral::Bool(_)
| LogicalLiteral::Float(_)
| LogicalLiteral::Integer(_)
| LogicalLiteral::Decimal(_)
| LogicalLiteral::BigDecimal(_)
| LogicalLiteral::String(_)
| LogicalLiteral::Bytes(_)
| LogicalLiteral::Regex(_)
| LogicalLiteral::Duration(_)
| LogicalLiteral::Datetime(_)
| LogicalLiteral::Date(_)
| LogicalLiteral::Time(_)
| LogicalLiteral::Timestamp(_)
| LogicalLiteral::Interval(_)
| LogicalLiteral::Uuid(_)
| LogicalLiteral::Geometry(_)
| LogicalLiteral::File(_)
| LogicalLiteral::I8(_)
| LogicalLiteral::U8(_)
| LogicalLiteral::I16(_)
| LogicalLiteral::U16(_)
| LogicalLiteral::I32(_)
| LogicalLiteral::U32(_)
| LogicalLiteral::U64(_)
| LogicalLiteral::F16(_)
| LogicalLiteral::F32(_) => {}
}
}
let samples = [
LogicalLiteral::None,
LogicalLiteral::Null,
LogicalLiteral::UnboundedRange,
LogicalLiteral::Bool(true),
LogicalLiteral::Float(1.5),
LogicalLiteral::Float(f64::NAN),
LogicalLiteral::Integer(7),
LogicalLiteral::Decimal(Decimal::new(150, 2)),
LogicalLiteral::BigDecimal(Box::new(BigDecimal::from(7i64))),
LogicalLiteral::String(Strand::new("s")),
LogicalLiteral::Bytes(Bytes::from(vec![1u8])),
LogicalLiteral::Regex("a".parse::<Regex>().expect("regex")),
LogicalLiteral::Duration(Duration::from_secs(1)),
LogicalLiteral::Datetime(Datetime::MIN_UTC),
LogicalLiteral::Uuid(Uuid::nil()),
LogicalLiteral::Geometry(Geometry::Point(geo_types::Point::new(1.0, 2.0))),
LogicalLiteral::File(File::new("b".to_owned(), "p".to_owned())),
LogicalLiteral::I8(-5),
LogicalLiteral::U8(5),
LogicalLiteral::I16(-500),
LogicalLiteral::U16(500),
LogicalLiteral::I32(-50000),
LogicalLiteral::U32(50000),
LogicalLiteral::U64(500000),
LogicalLiteral::F16(half::f16::from_f32(1.5)),
LogicalLiteral::F16(half::f16::NAN),
LogicalLiteral::F32(1.5),
LogicalLiteral::F32(f32::NAN),
];
for sample in samples {
assert_eq!(sample, sample.clone(), "{sample:?} must equal itself");
}
assert_ne!(LogicalLiteral::Float(-0.0), LogicalLiteral::Float(0.0));
}
fn shallow_corpus() -> Vec<LogicalExpr> {
let mut corpus = Vec::new();
let texts = [
"1",
"2",
"'s'",
"[a, 1]",
"[a]",
"{ a: 1, b: c }",
"{ a: 1, d: c }",
"{ a: 1 }",
"t:1",
"t:2",
"u:1",
"t:[a, 1]",
"t:[a]",
"t:{ k: a }",
"t:{ j: a }",
"t:[1]..=[a]",
"t:[1]..[a]",
"t:rand()",
"t:ulid()",
"$p",
"$q",
"|t:3|",
"|t:4|",
"math::pi",
"math::e",
"a.b",
"a.c",
"a.b.c",
"a[0]",
"a[$]",
"a[a + 1]",
"a[WHERE x > 1]",
"a.*",
"a…",
"a.b.*",
"a.slice(1, 2)",
"a.slice(1)",
"a.other(1, 2)",
"a.{ x, y }",
"a.{ x, y: z }",
"a.{ x, w: z }",
"a.{ x.*, y }",
"a.{ x.{ y }, ... }",
"a.?.b",
"->likes->person",
"->likes",
"<-likes",
"->(likes WHERE x = 1)",
"->(SELECT * FROM likes WHERE x = 1 LIMIT 3)",
"->(SELECT * FROM likes LIMIT 3 START 1)",
"->(SELECT * FROM likes SPLIT a)",
"->(SELECT * FROM likes GROUP BY a)",
"->(SELECT * FROM likes ORDER BY a)",
"->(SELECT * FROM likes ORDER BY a DESC)",
"->(SELECT * FROM likes ORDER BY a NUMERIC)",
"->(SELECT * FROM likes ORDER BY RAND())",
"->(likes AS x)",
"->(likes:1..3)",
"->(likes:1..=3)",
"->(likes, knows)",
"->(SELECT a, b AS c FROM likes)",
"->(SELECT VALUE a FROM likes)",
"<~person",
"a.{2}",
"a.{2}(.b)",
"a.{2}.b.@",
"a.{3}.b.@",
"a.{1..3+collect}(.b)",
"a.{1..3+path}(.b)",
"a.{1..3+path+inclusive}(.b)",
"a.{1..3+shortest=t:1}(.b)",
"a.b[0].c",
"<int> a",
"<string> a",
"-a",
"!a",
"+a",
"a..",
"a>..",
"..a",
"a + 1",
"a - 1",
"a AND b",
"a ?? b",
"a ?: b",
"a = b",
"math::abs(1)",
"math::abs(a)",
"math::sqrt(a)",
"fn::f(1)",
"$f(1)",
"|$x: int| $x + 1",
"|$x: int| $x + 2",
"|$x: int| -> int { $x + 1 }",
"|$x: string| $x + 1",
"IF a THEN 1 ELSE 2 END",
"IF a THEN 1 END",
"IF a THEN 1 ELSE IF b THEN 2 ELSE 3 END",
"(SELECT * FROM t)",
"(SELECT a FROM t)",
];
for text in texts {
corpus.push(expr(text));
}
corpus.extend([
LogicalExpr::Set(vec![expr("1"), expr("2")]),
LogicalExpr::Set(vec![expr("1")]),
LogicalExpr::Table(TableName::from("t")),
LogicalExpr::Table(TableName::from("u")),
LogicalExpr::Doc,
LogicalExpr::Current,
LogicalExpr::First(Box::new(expr("a"))),
LogicalExpr::Break,
LogicalExpr::Continue,
LogicalExpr::Throw(Box::new(expr("1"))),
LogicalExpr::RepeatRecurse(Box::new(LogicalExpr::Current)),
LogicalExpr::SetField {
base: Box::new(expr("o")),
field: Strand::new("k"),
value: Box::new(expr("1")),
},
LogicalExpr::SetField {
base: Box::new(expr("o")),
field: Strand::new("j"),
value: Box::new(expr("1")),
},
LogicalExpr::Flatten {
base: Box::new(expr("a")),
explicit: false,
},
]);
let mut all = Vec::new();
for root in &corpus {
let _ = root.visit(&mut |node| {
all.push(node.clone());
ControlFlow::<()>::Continue(())
});
}
all
}
#[test]
fn shallow_identity_is_equality_modulo_children() {
use std::collections::hash_map::DefaultHasher;
let corpus = shallow_corpus();
let variants =
corpus.iter().map(std::mem::discriminant).collect::<std::collections::HashSet<_>>();
assert_eq!(variants.len(), 38, "the corpus must cover every variant");
let hash = |expr: &LogicalExpr| {
let mut state = DefaultHasher::new();
expr.shallow_hash(&mut state);
state.finish()
};
for a in &corpus {
for b in &corpus {
let children_equal = a.children() == b.children();
if matches!(a, LogicalExpr::Subquery(_)) {
assert_eq!(a.shallow_eq(b), std::ptr::eq(a, b));
} else {
assert_eq!(
a.shallow_eq(b) && children_equal,
a == b,
"shallow identity of {a:?} and {b:?}"
);
}
if a.shallow_eq(b) {
assert_eq!(hash(a), hash(b), "{a:?} and {b:?} are shallow-equal");
}
}
}
}
}