use std::fmt::{self, Display, Formatter};
use surrealdb_iam::AuthLimit;
use surrealdb_strand::Strand;
use surrealdb_types::{SqlFormat, ToSql};
use super::expr::{LogicalExpr, LogicalLiteral, OutputPath};
use crate::expr::constant::ConstantValue;
use crate::expr::{BinaryOperator, Idiom, Kind, Mock, Part, PrefixOperator};
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub enum FieldSegment {
Field(Strand),
All,
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct FieldPath(Vec<FieldSegment>);
impl FieldPath {
pub fn new(segments: Vec<FieldSegment>) -> Self {
FieldPath(segments)
}
pub fn field(name: impl Into<Strand>) -> Self {
FieldPath(vec![FieldSegment::Field(name.into())])
}
pub fn from_idiom(idiom: &Idiom) -> Option<Self> {
idiom
.0
.iter()
.map(|part| match part {
Part::Field(name) => Some(FieldSegment::Field(name.clone())),
Part::All => Some(FieldSegment::All),
Part::Flatten
| Part::First
| Part::Last
| Part::Value(_)
| Part::Where(_)
| Part::Lookup(_)
| Part::Start(_)
| Part::Method(..)
| Part::Destructure(_)
| Part::Optional
| Part::Recurse(..)
| Part::Doc
| Part::RepeatRecurse => None,
})
.collect::<Option<Vec<_>>>()
.map(FieldPath)
}
pub fn segments(&self) -> &[FieldSegment] {
&self.0
}
pub fn root(&self) -> Option<&Strand> {
match self.0.first() {
Some(FieldSegment::Field(name)) => Some(name),
Some(FieldSegment::All) | None => None,
}
}
pub fn as_field(&self) -> Option<&Strand> {
match self.0.as_slice() {
[FieldSegment::Field(name)] => Some(name),
_ => None,
}
}
pub fn child(mut self, segment: FieldSegment) -> Self {
self.0.push(segment);
self
}
}
impl TryFrom<&Idiom> for FieldPath {
type Error = ();
fn try_from(idiom: &Idiom) -> Result<Self, ()> {
FieldPath::from_idiom(idiom).ok_or(())
}
}
impl From<&OutputPath> for FieldPath {
fn from(path: &OutputPath) -> Self {
FieldPath(
path.parts()
.iter()
.map(|part| match part {
super::expr::OutputPathPart::Field(name)
| super::expr::OutputPathPart::Lookup(name) => FieldSegment::Field(Strand::new(name)),
})
.collect(),
)
}
}
impl ToSql for FieldPath {
fn fmt_sql(&self, f: &mut String, fmt: SqlFormat) {
for (i, segment) in self.0.iter().enumerate() {
match segment {
FieldSegment::Field(name) if i == 0 => {
common::fmt::EscapeIdent(name.as_str()).fmt_sql(f, fmt)
}
FieldSegment::Field(name) => {
f.push('.');
common::fmt::EscapeKwFreeIdent(name.as_str()).fmt_sql(f, fmt);
}
FieldSegment::All => f.push_str(".*"),
}
}
}
}
impl Display for FieldPath {
fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
f.write_str(&self.to_sql())
}
}
impl LogicalExpr {
pub fn field_path(&self) -> Option<FieldPath> {
match self {
LogicalExpr::Field(name) => Some(FieldPath::field(name.clone())),
LogicalExpr::Access {
base,
field,
} => Some(base.field_path()?.child(FieldSegment::Field(field.clone()))),
LogicalExpr::Each(base) => Some(base.field_path()?.child(FieldSegment::All)),
LogicalExpr::Doc
| LogicalExpr::Current
| LogicalExpr::Index {
..
}
| LogicalExpr::First(_)
| LogicalExpr::Last(_)
| LogicalExpr::Flatten {
..
}
| LogicalExpr::Filter {
..
}
| LogicalExpr::Method {
..
}
| LogicalExpr::Destructure {
..
}
| LogicalExpr::Optional {
..
}
| LogicalExpr::Lookup {
..
}
| LogicalExpr::Recurse(_)
| LogicalExpr::RepeatRecurse(_)
| LogicalExpr::Broadcast {
..
}
| 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,
}
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum Openness {
Closed,
Open,
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct Schema {
pub fields: Vec<FieldSchema>,
pub openness: Openness,
}
impl Schema {
pub fn open() -> Self {
Schema {
fields: Vec::new(),
openness: Openness::Open,
}
}
pub fn closed(fields: Vec<FieldSchema>) -> Self {
Schema {
fields,
openness: Openness::Closed,
}
}
pub fn is_open(&self) -> bool {
self.openness == Openness::Open
}
fn has_fields(&self) -> bool {
!self.fields.is_empty()
}
pub fn field(&self, path: &FieldPath) -> Option<&FieldSchema> {
self.fields.iter().find(|field| &field.path == path)
}
pub fn field_mut(&mut self, path: &FieldPath) -> Option<&mut FieldSchema> {
self.fields.iter_mut().find(|field| &field.path == path)
}
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct FieldSchema {
pub path: FieldPath,
pub kind: Kind,
pub checked: bool,
pub flexible: bool,
pub computed: Option<ComputedBody>,
pub select_permission: LogicalPermission,
}
impl FieldSchema {
pub fn new(path: FieldPath, kind: Kind) -> Self {
FieldSchema {
path,
kind,
checked: false,
flexible: false,
computed: None,
select_permission: LogicalPermission::Full,
}
}
pub fn checked(path: FieldPath, kind: Kind) -> Self {
FieldSchema {
checked: true,
..Self::new(path, kind)
}
}
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct ComputedBody {
pub expr: LogicalExpr,
pub kind: Option<Kind>,
pub auth: Option<AuthLimit>,
}
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub enum LogicalPermission {
None,
Full,
Specific(LogicalExpr),
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum LogicalPermissionRef<'a> {
None,
Full,
Specific(&'a LogicalExpr),
}
impl LogicalLiteral {
pub fn kind(&self) -> Kind {
match self {
LogicalLiteral::None => Kind::None,
LogicalLiteral::Null => Kind::Null,
LogicalLiteral::UnboundedRange => Kind::Range,
LogicalLiteral::Bool(_) => Kind::Bool,
LogicalLiteral::Float(_) => Kind::Float,
LogicalLiteral::Integer(_) => Kind::Int,
LogicalLiteral::Decimal(_) => Kind::Decimal,
LogicalLiteral::BigDecimal(_) => Kind::BigDecimal,
LogicalLiteral::I8(_) => Kind::I8,
LogicalLiteral::U8(_) => Kind::U8,
LogicalLiteral::I16(_) => Kind::I16,
LogicalLiteral::U16(_) => Kind::U16,
LogicalLiteral::I32(_) => Kind::I32,
LogicalLiteral::U32(_) => Kind::U32,
LogicalLiteral::U64(_) => Kind::U64,
LogicalLiteral::F16(_) => Kind::F16,
LogicalLiteral::F32(_) => Kind::F32,
LogicalLiteral::String(_) => Kind::String,
LogicalLiteral::Bytes(_) => Kind::Bytes,
LogicalLiteral::Regex(_) => Kind::Regex,
LogicalLiteral::Duration(_) => Kind::Duration,
LogicalLiteral::Datetime(_) => Kind::Datetime,
LogicalLiteral::Date(_) => Kind::Date,
LogicalLiteral::Time(_) => Kind::Time,
LogicalLiteral::Timestamp(_) => Kind::Timestamp,
LogicalLiteral::Interval(_) => Kind::Interval,
LogicalLiteral::Uuid(_) => Kind::Uuid,
LogicalLiteral::Geometry(_) => Kind::Geometry(Vec::new()),
LogicalLiteral::File(_) => Kind::File(Vec::new()),
}
}
}
pub fn is_numeric(kind: &Kind) -> bool {
kind.is_numeric()
}
pub fn kind_may_be_record(kind: &Kind) -> bool {
match kind {
Kind::Named(_) => true,
Kind::Any | Kind::Record(_) | Kind::Literal(_) => true,
Kind::Either(kinds) => kinds.iter().any(kind_may_be_record),
Kind::Array(element, _) | Kind::Set(element, _) => kind_may_be_record(element),
Kind::None
| Kind::Null
| Kind::Bool
| Kind::Bytes
| Kind::Datetime
| Kind::Date
| Kind::Time
| Kind::Timestamp
| Kind::Interval
| Kind::Decimal
| Kind::BigDecimal
| Kind::Duration
| Kind::Float
| Kind::Int
| Kind::I8
| Kind::U8
| Kind::I16
| Kind::U16
| Kind::I32
| Kind::U32
| Kind::U64
| Kind::F16
| Kind::F32
| Kind::Number
| Kind::Object
| Kind::String
| Kind::Uuid
| Kind::Regex
| Kind::Table(_)
| Kind::Geometry(_)
| Kind::Function(..)
| Kind::Range
| Kind::File(_)
| Kind::Enum(_) => false,
}
}
pub fn coercion_is_identity(declared: &Kind, actual: &Kind) -> bool {
match declared {
Kind::Named(_) => false,
Kind::Any => true,
Kind::Number => actual.is_numeric(),
Kind::Either(kinds) => match kinds.as_slice() {
[Kind::None, inner] => {
matches!(actual, Kind::None) || coercion_is_identity(inner, actual)
}
_ => declared == actual && !matches!(actual, Kind::Any),
},
Kind::Array(inner, None) => {
matches!(actual, Kind::Array(elements, None) if coercion_is_identity(inner, elements))
}
Kind::Set(inner, None) => {
matches!(actual, Kind::Set(elements, None) if coercion_is_identity(inner, elements))
}
Kind::Record(tables) => match actual {
Kind::Named(_) => false,
Kind::Record(of) => {
tables.is_empty() || (!of.is_empty() && of.iter().all(|t| tables.contains(t)))
}
Kind::Any
| Kind::None
| Kind::Null
| Kind::Bool
| Kind::Bytes
| Kind::Datetime
| Kind::Date
| Kind::Time
| Kind::Timestamp
| Kind::Interval
| Kind::Decimal
| Kind::BigDecimal
| Kind::Duration
| Kind::Float
| Kind::Int
| Kind::I8
| Kind::U8
| Kind::I16
| Kind::U16
| Kind::I32
| Kind::U32
| Kind::U64
| Kind::F16
| Kind::F32
| Kind::Number
| Kind::Object
| Kind::String
| Kind::Uuid
| Kind::Regex
| Kind::Table(_)
| Kind::Geometry(_)
| Kind::Function(..)
| Kind::Range
| Kind::File(_)
| Kind::Enum(_)
| Kind::Array(..)
| Kind::Set(..)
| Kind::Either(_)
| Kind::Literal(_) => false,
},
Kind::Geometry(shapes) => {
matches!(actual, Kind::Geometry(of) if shapes.is_empty() || (!of.is_empty() && of.iter().all(|s| shapes.contains(s))))
}
Kind::None
| Kind::Null
| Kind::Bool
| Kind::Bytes
| Kind::Datetime
| Kind::Date
| Kind::Time
| Kind::Timestamp
| Kind::Interval
| Kind::Decimal
| Kind::BigDecimal
| Kind::Duration
| Kind::Float
| Kind::Int
| Kind::I8
| Kind::U8
| Kind::I16
| Kind::U16
| Kind::I32
| Kind::U32
| Kind::U64
| Kind::F16
| Kind::F32
| Kind::Object
| Kind::String
| Kind::Uuid
| Kind::Regex
| Kind::Table(_)
| Kind::Function(..)
| Kind::Range
| Kind::File(_)
| Kind::Enum(_)
| Kind::Array(_, Some(_))
| Kind::Set(_, Some(_))
| Kind::Literal(_) => declared == actual,
}
}
fn each_keeps_element_kind(kind: &Kind) -> bool {
match kind {
Kind::Named(_) => false,
Kind::Any | Kind::Record(_) | Kind::Either(_) | Kind::Literal(_) => false,
Kind::None
| Kind::Null
| Kind::Bool
| Kind::Bytes
| Kind::Datetime
| Kind::Date
| Kind::Time
| Kind::Timestamp
| Kind::Interval
| Kind::Decimal
| Kind::BigDecimal
| Kind::Duration
| Kind::Float
| Kind::Int
| Kind::I8
| Kind::U8
| Kind::I16
| Kind::U16
| Kind::I32
| Kind::U32
| Kind::U64
| Kind::F16
| Kind::F32
| Kind::Number
| Kind::Object
| Kind::String
| Kind::Uuid
| Kind::Regex
| Kind::Table(_)
| Kind::Geometry(_)
| Kind::Function(..)
| Kind::Range
| Kind::File(_)
| Kind::Enum(_)
| Kind::Array(..)
| Kind::Set(..) => true,
}
}
fn mock_kind(mock: &Mock) -> Kind {
Kind::Array(Box::new(Kind::Record(vec![mock.table().clone()])), None)
}
pub fn common_kind(kinds: impl IntoIterator<Item = Kind>) -> Kind {
let mut kinds = kinds.into_iter();
let Some(first) = kinds.next() else {
return Kind::Any;
};
if kinds.all(|kind| kind == first) {
first
} else {
Kind::Any
}
}
impl LogicalExpr {
pub fn checked_kind(&self, schema: &Schema) -> Option<Kind> {
let mut kinds = Vec::new();
if matches!(
self,
LogicalExpr::Binary {
op: BinaryOperator::And | BinaryOperator::Or,
..
}
) {
self.for_each_child(&mut |child| kinds.push(child.checked_kind(schema)));
}
self.node_checked_kind(&kinds, schema)
}
pub fn node_checked_kind(&self, child_kinds: &[Option<Kind>], schema: &Schema) -> Option<Kind> {
match self {
LogicalExpr::Literal(literal) => Some(literal.kind()),
LogicalExpr::RecordId(rid) => Some(Kind::Record(vec![rid.table.clone()])),
LogicalExpr::Table(table) => Some(Kind::Table(vec![table.clone()])),
LogicalExpr::Mock(mock) => Some(mock_kind(mock)),
LogicalExpr::Constant(constant) => Some(match constant.value() {
ConstantValue::Float(_) => Kind::Float,
ConstantValue::Datetime(_) => Kind::Datetime,
ConstantValue::Duration(_) => Kind::Duration,
}),
LogicalExpr::Field(_)
| LogicalExpr::Access {
..
} => schema
.has_fields()
.then(|| self.field_path())
.flatten()
.and_then(|path| schema.field(&path))
.filter(|field| field.checked)
.map(|field| field.kind.clone()),
LogicalExpr::Prefix {
op,
..
} => match op {
PrefixOperator::Cast(kind) => Some(kind.clone()),
PrefixOperator::Not => Some(Kind::Bool),
PrefixOperator::Positive
| PrefixOperator::Negate
| PrefixOperator::Range
| PrefixOperator::RangeInclusive => None,
},
LogicalExpr::Binary {
op,
..
} => match op {
BinaryOperator::Equal
| BinaryOperator::ExactEqual
| BinaryOperator::NotEqual
| BinaryOperator::AllEqual
| BinaryOperator::AnyEqual
| BinaryOperator::LessThan
| BinaryOperator::LessThanEqual
| BinaryOperator::MoreThan
| BinaryOperator::MoreThanEqual
| BinaryOperator::Contain
| BinaryOperator::NotContain
| BinaryOperator::ContainAll
| BinaryOperator::ContainAny
| BinaryOperator::ContainNone
| BinaryOperator::Inside
| BinaryOperator::NotInside
| BinaryOperator::AllInside
| BinaryOperator::AnyInside
| BinaryOperator::NoneInside
| BinaryOperator::Outside
| BinaryOperator::Intersects
| BinaryOperator::Matches(_)
| BinaryOperator::NearestNeighbor(_) => Some(Kind::Bool),
BinaryOperator::And | BinaryOperator::Or => {
(child_kinds == [Some(Kind::Bool), Some(Kind::Bool)]).then_some(Kind::Bool)
}
BinaryOperator::NullCoalescing
| BinaryOperator::TenaryCondition
| BinaryOperator::Add
| BinaryOperator::Subtract
| BinaryOperator::Multiply
| BinaryOperator::Divide
| BinaryOperator::Remainder
| BinaryOperator::Power
| BinaryOperator::Range
| BinaryOperator::RangeInclusive
| BinaryOperator::RangeSkip
| BinaryOperator::RangeSkipInclusive => None,
},
LogicalExpr::Object(_) => Some(Kind::Object),
LogicalExpr::Array(_)
| LogicalExpr::Set(_)
| LogicalExpr::Param(_)
| LogicalExpr::Doc
| LogicalExpr::Current
| 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 {
..
}
| LogicalExpr::Postfix {
..
}
| LogicalExpr::Invoke {
..
}
| LogicalExpr::Call(_)
| LogicalExpr::Closure(_)
| LogicalExpr::If(_)
| LogicalExpr::Throw(_)
| LogicalExpr::Break
| LogicalExpr::Continue
| LogicalExpr::Subquery(_) => None,
}
}
pub fn kind(&self, schema: &Schema) -> Kind {
match self {
LogicalExpr::Literal(literal) => literal.kind(),
LogicalExpr::Array(items) => {
Kind::Array(Box::new(common_kind(items.iter().map(|e| e.kind(schema)))), None)
}
LogicalExpr::Set(items) => {
Kind::Set(Box::new(common_kind(items.iter().map(|e| e.kind(schema)))), None)
}
LogicalExpr::Object(_) => Kind::Object,
LogicalExpr::RecordId(rid) => Kind::Record(vec![rid.table.clone()]),
LogicalExpr::Table(table) => Kind::Table(vec![table.clone()]),
LogicalExpr::Mock(mock) => mock_kind(mock),
LogicalExpr::Constant(constant) => match constant.value() {
ConstantValue::Float(_) => Kind::Float,
ConstantValue::Datetime(_) => Kind::Datetime,
ConstantValue::Duration(_) => Kind::Duration,
},
LogicalExpr::Field(_)
| LogicalExpr::Access {
..
} => self
.field_path()
.and_then(|path| schema.field(&path))
.map(|field| field.kind.clone())
.unwrap_or(Kind::Any),
LogicalExpr::Each(base) => {
let element = self
.field_path()
.and_then(|path| schema.field(&path))
.map(|field| field.kind.clone());
match (base.kind(schema), element) {
(Kind::Array(_, len), Some(element)) if each_keeps_element_kind(&element) => {
Kind::Array(Box::new(element), len)
}
_ => Kind::Any,
}
}
LogicalExpr::Doc
| LogicalExpr::Current
| LogicalExpr::Index {
..
}
| LogicalExpr::First(_)
| LogicalExpr::Last(_)
| LogicalExpr::Flatten {
..
}
| LogicalExpr::Filter {
..
}
| LogicalExpr::Method {
..
}
| LogicalExpr::Destructure {
..
}
| LogicalExpr::Optional {
..
}
| LogicalExpr::Lookup {
..
}
| LogicalExpr::Recurse(_)
| LogicalExpr::RepeatRecurse(_)
| LogicalExpr::Broadcast {
..
} => Kind::Any,
LogicalExpr::Prefix {
op,
expr,
} => match op {
PrefixOperator::Not => Kind::Bool,
PrefixOperator::Positive | PrefixOperator::Negate => {
let kind = expr.kind(schema);
if is_numeric(&kind) {
kind
} else {
Kind::Any
}
}
PrefixOperator::Range | PrefixOperator::RangeInclusive => Kind::Range,
PrefixOperator::Cast(kind) => kind.clone(),
},
LogicalExpr::Postfix {
..
} => Kind::Range,
LogicalExpr::Invoke {
..
} => Kind::Any,
LogicalExpr::Binary {
left,
op,
right,
} => binary_kind(op, &left.kind(schema), &right.kind(schema)),
LogicalExpr::Closure(closure) => Kind::Function(
Some(closure.args.iter().map(|(_, kind)| kind.clone()).collect()),
closure.returns.clone().map(Box::new),
),
LogicalExpr::If(branches) => branch_kind(
branches.branches.iter().map(|(_, then)| then.kind(schema)).chain(std::iter::once(
branches.otherwise.as_ref().map_or(Kind::None, |e| e.kind(schema)),
)),
),
LogicalExpr::SetField {
base,
..
} => base.kind(schema),
LogicalExpr::Param(_)
| LogicalExpr::Call(_)
| LogicalExpr::Throw(_)
| LogicalExpr::Break
| LogicalExpr::Continue
| LogicalExpr::Subquery(_) => Kind::Any,
}
}
}
fn branch_kind(kinds: impl IntoIterator<Item = Kind>) -> Kind {
let flat: Vec<Kind> = kinds.into_iter().flat_map(Kind::flatten).collect();
if flat.contains(&Kind::Any) {
return Kind::Any;
}
let (none, rest): (Vec<Kind>, Vec<Kind>) = flat.into_iter().partition(|k| *k == Kind::None);
Kind::either(none.into_iter().chain(rest).collect())
}
fn binary_kind(op: &BinaryOperator, left: &Kind, right: &Kind) -> Kind {
match op {
BinaryOperator::Equal
| BinaryOperator::ExactEqual
| BinaryOperator::NotEqual
| BinaryOperator::AllEqual
| BinaryOperator::AnyEqual
| BinaryOperator::LessThan
| BinaryOperator::LessThanEqual
| BinaryOperator::MoreThan
| BinaryOperator::MoreThanEqual
| BinaryOperator::Contain
| BinaryOperator::NotContain
| BinaryOperator::ContainAll
| BinaryOperator::ContainAny
| BinaryOperator::ContainNone
| BinaryOperator::Inside
| BinaryOperator::NotInside
| BinaryOperator::AllInside
| BinaryOperator::AnyInside
| BinaryOperator::NoneInside
| BinaryOperator::Outside
| BinaryOperator::Intersects
| BinaryOperator::Matches(_)
| BinaryOperator::NearestNeighbor(_) => Kind::Bool,
BinaryOperator::And | BinaryOperator::Or => {
if *left == Kind::Bool && *right == Kind::Bool {
Kind::Bool
} else {
Kind::Any
}
}
BinaryOperator::NullCoalescing | BinaryOperator::TenaryCondition => Kind::Any,
BinaryOperator::Add
| BinaryOperator::Subtract
| BinaryOperator::Multiply
| BinaryOperator::Divide
| BinaryOperator::Remainder
| BinaryOperator::Power => {
if is_numeric(left) && is_numeric(right) {
Kind::Number
} else {
Kind::Any
}
}
BinaryOperator::Range
| BinaryOperator::RangeInclusive
| BinaryOperator::RangeSkip
| BinaryOperator::RangeSkipInclusive => Kind::Range,
}
}
#[cfg(test)]
mod tests {
use std::sync::Arc;
use surrealdb_strand::TableName;
use surrealdb_types::ToSql;
use super::*;
use crate::expr::logical::{
EvalFrame, GuardKind, JoinKind, LogicalBreak, LogicalContinue, LogicalDdl,
LogicalDdlStatement, LogicalDistinct, LogicalEval, LogicalExplain, LogicalFetch,
LogicalField, LogicalFields, LogicalFilter, LogicalForeach, LogicalIfOp, LogicalInfo,
LogicalJoin, LogicalLet, LogicalLimit, LogicalOnly, LogicalOp, LogicalOrdering,
LogicalPermissionFilter, LogicalProject, LogicalReturn, LogicalSequence, LogicalSleep,
LogicalSort, LogicalSource, LogicalSplit, LogicalSubquery, LogicalThrow, LogicalTimeout,
LogicalUnionAll, LogicalValues, LogicalVersionScope, RelationAlias, SourceRef, lower_expr,
};
use crate::expr::{ExplainFormat, Param};
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");
};
lower_expr(out.what).expect("expression should lower")
}
fn idiom(name: &str) -> FieldPath {
FieldPath::field(name)
}
fn table() -> TableName {
TableName::from("t")
}
fn closed() -> Schema {
let mut c = FieldSchema::new(idiom("c"), Kind::Object);
c.flexible = true;
Schema::closed(vec![
FieldSchema::new(idiom("id"), Kind::Record(vec![table()])),
FieldSchema::new(idiom("a"), Kind::Int),
FieldSchema::new(idiom("b"), Kind::option(Kind::String)),
c,
])
}
fn bound(schema: Schema) -> LogicalOp {
LogicalOp::Source(LogicalSource {
source: SourceRef::Table(table()),
schema: Some(Arc::new(schema)),
with: None,
for_update: false,
})
}
fn unbound() -> LogicalOp {
LogicalOp::Source(LogicalSource {
source: SourceRef::Table(table()),
schema: None,
with: None,
for_update: false,
})
}
fn kinds(schema: &Schema) -> Vec<(String, Kind)> {
schema.fields.iter().map(|f| (f.path.to_sql(), f.kind.clone())).collect()
}
fn paths(schema: &Schema) -> Vec<String> {
schema.fields.iter().map(|f| f.path.to_sql()).collect()
}
fn single(sql: &str, alias: Option<&str>) -> LogicalField {
LogicalField::user(expr(sql), alias.map(OutputPath::field))
}
fn kind_of(schema: &Schema, name: &str) -> Option<Kind> {
schema.field(&idiom(name)).map(|f| f.kind.clone())
}
#[test]
fn kind_answers_the_documented_cases() {
let schema = Schema::closed(vec![
FieldSchema::new(idiom("n"), Kind::Int),
FieldSchema::new(idiom("s"), Kind::String),
FieldSchema::new(idiom("b"), Kind::Bool),
FieldSchema::new(idiom("o"), Kind::Object),
]);
let cases = [
("1", Kind::Int),
("1.5", Kind::Float),
("'x'", Kind::String),
("true", Kind::Bool),
("NONE", Kind::None),
("n", Kind::Int),
("s", Kind::String),
("o.inner", Kind::Any),
("missing", Kind::Any),
("$p", Kind::Any),
("n > 1", Kind::Bool),
("s = 'x'", Kind::Bool),
("n IN [1]", Kind::Bool),
("!n", Kind::Bool),
("b AND b", Kind::Bool),
("n AND b", Kind::Any),
("b OR $p", Kind::Any),
("n + 1", Kind::Number),
("n * 1.5", Kind::Number),
("s + 'x'", Kind::Any),
("n + $p", Kind::Any),
("IF b THEN 1 ELSE 2 END", Kind::Int),
("IF b THEN 1 ELSE 'x' END", Kind::either(vec![Kind::Int, Kind::String])),
("IF b THEN 1 END", Kind::option(Kind::Int)),
("IF b THEN s ELSE NONE END", Kind::option(Kind::String)),
("IF b THEN NONE ELSE s END", Kind::option(Kind::String)),
("IF b THEN NONE END", Kind::None),
("IF b THEN $p ELSE 1 END", Kind::Any),
("IF b THEN o.inner ELSE NONE END", Kind::Any),
("count()", Kind::Any),
("(SELECT * FROM t)", Kind::Any),
("<string> n", Kind::String),
("t:1", Kind::Record(vec![table()])),
("[1, 2]", Kind::Array(Box::new(Kind::Int), None)),
("[1, 'x']", Kind::Array(Box::new(Kind::Any), None)),
(
"|$x: int| -> int { $x }",
Kind::Function(Some(vec![Kind::Int]), Some(Box::new(Kind::Int))),
),
];
for (sql, want) in cases {
assert_eq!(expr(sql).kind(&schema), want, "kind of `{sql}`");
}
}
#[test]
fn a_closed_schema_types_its_declared_fields_and_nothing_beneath_them() {
let schema = closed();
assert_eq!(expr("id").kind(&schema), Kind::Record(vec![table()]));
assert_eq!(expr("a").kind(&schema), Kind::Int);
assert_eq!(expr("b").kind(&schema), Kind::option(Kind::String));
assert_eq!(expr("c").kind(&schema), Kind::Object);
assert_eq!(expr("c.x").kind(&schema), Kind::Any);
assert_eq!(expr("missing").kind(&schema), Kind::Any);
assert_eq!(expr("a.b").kind(&schema), Kind::Any);
}
#[test]
fn every_undeclared_field_on_an_open_schema_is_any() {
let open = Schema::open();
for sql in ["id", "a", "b", "c", "c.x", "missing", "a.b[0]", "$p.a"] {
assert_eq!(expr(sql).kind(&open), Kind::Any, "kind of `{sql}` on an open schema");
}
assert_eq!(expr("1").kind(&open), Kind::Int);
assert_eq!(expr("a > 1").kind(&open), Kind::Bool);
assert_eq!(expr("a + 1").kind(&open), Kind::Any);
assert_eq!(unbound().schema(), Schema::open());
}
#[test]
fn declared_field_on_open_schema_retains_kind() {
let mut open = Schema::open();
open.fields.push(FieldSchema::new(FieldPath::field("age"), Kind::Int));
open.fields.push(FieldSchema::new(FieldPath::field("score"), Kind::Float));
assert_eq!(expr("age").kind(&open), Kind::Int);
assert_eq!(expr("score").kind(&open), Kind::Float);
assert_eq!(expr("missing").kind(&open), Kind::Any);
}
#[test]
fn a_projection_types_each_field_against_its_input() {
let project = |input: LogicalOp| {
LogicalOp::Project(LogicalProject {
input: Box::new(input),
fields: LogicalFields::Select(vec![
single("id", None),
single("a + 1", Some("sum")),
single("b", None),
single("c.x", Some("inner")),
single("a > 1", Some("big")),
single("<string> a", Some("text")),
]),
omit: vec![],
})
};
let schema = project(bound(closed())).schema();
assert_eq!(schema.openness, Openness::Closed);
assert_eq!(
kinds(&schema),
[
("id".to_string(), Kind::Record(vec![table()])),
("sum".to_string(), Kind::Number),
("b".to_string(), Kind::option(Kind::String)),
("inner".to_string(), Kind::Any),
("big".to_string(), Kind::Bool),
("text".to_string(), Kind::String),
]
);
let schema = project(unbound()).schema();
assert_eq!(schema.openness, Openness::Closed);
assert_eq!(
kinds(&schema),
[
("id".to_string(), Kind::Any),
("sum".to_string(), Kind::Any),
("b".to_string(), Kind::Any),
("inner".to_string(), Kind::Any),
("big".to_string(), Kind::Bool),
("text".to_string(), Kind::String),
]
);
let star = LogicalOp::Project(LogicalProject {
input: Box::new(bound(closed())),
fields: LogicalFields::all(),
omit: vec![expr("b")],
});
assert_eq!(star.schema().openness, Openness::Closed);
assert_eq!(paths(&star.schema()), ["id", "a", "c"]);
let star = LogicalOp::Project(LogicalProject {
input: Box::new(unbound()),
fields: LogicalFields::all(),
omit: vec![],
});
assert!(star.schema().is_open());
let value = LogicalOp::Project(LogicalProject {
input: Box::new(bound(closed())),
fields: LogicalFields::Value {
expr: expr("a"),
alias: None,
},
omit: vec![],
});
assert!(value.schema().is_open());
}
#[test]
fn a_union_merges_fields_by_path_and_is_open_when_any_input_is() {
let other = Schema::closed(vec![
FieldSchema::new(idiom("id"), Kind::Record(vec![TableName::from("u")])),
FieldSchema::new(idiom("a"), Kind::Int),
FieldSchema::new(idiom("d"), Kind::Bool),
]);
let union = LogicalOp::UnionAll(LogicalUnionAll {
inputs: vec![bound(closed()), bound(other)],
});
let schema = union.schema();
assert_eq!(schema.openness, Openness::Closed);
assert_eq!(paths(&schema), ["id", "a", "b", "c", "d"]);
assert_eq!(schema.field(&idiom("a")).map(|f| f.kind.clone()), Some(Kind::Int));
assert_eq!(schema.field(&idiom("id")).map(|f| f.kind.clone()), Some(Kind::Any));
assert_eq!(
schema.field(&idiom("d")).map(|f| f.kind.clone()),
Some(Kind::option(Kind::Bool))
);
assert_eq!(
schema.field(&idiom("b")).map(|f| f.kind.clone()),
Some(Kind::option(Kind::String))
);
let union = LogicalOp::UnionAll(LogicalUnionAll {
inputs: vec![bound(closed()), unbound()],
});
let schema = union.schema();
assert!(schema.is_open());
assert_eq!(paths(&schema), ["id", "a", "b", "c"]);
assert!(schema.fields.iter().all(|f| f.kind == Kind::Any), "{:?}", kinds(&schema));
}
#[test]
fn each_is_typed_as_the_array_it_yields() {
let all = |name: &str| idiom(name).child(FieldSegment::All);
let schema = Schema::closed(vec![
FieldSchema::new(idiom("tags"), Kind::Array(Box::new(Kind::String), None)),
FieldSchema::new(all("tags"), Kind::String),
FieldSchema::new(idiom("nums"), Kind::Array(Box::new(Kind::Int), Some(2))),
FieldSchema::new(all("nums"), Kind::Int),
FieldSchema::new(
idiom("refs"),
Kind::Array(Box::new(Kind::Record(vec![TableName::from("u")])), None),
),
FieldSchema::new(all("refs"), Kind::Record(vec![TableName::from("u")])),
FieldSchema::new(idiom("o"), Kind::Object),
FieldSchema::new(all("o"), Kind::String),
FieldSchema::new(idiom("loose"), Kind::Any),
FieldSchema::new(all("loose"), Kind::String),
]);
assert_eq!(expr("tags.*").kind(&schema), Kind::Array(Box::new(Kind::String), None));
assert_eq!(expr("nums.*").kind(&schema), Kind::Array(Box::new(Kind::Int), Some(2)));
assert_eq!(expr("<string> tags.*").kind(&schema), Kind::String);
assert_eq!(expr("refs.*").kind(&schema), Kind::Any);
assert_eq!(expr("o.*").kind(&schema), Kind::Any);
assert_eq!(expr("loose.*").kind(&schema), Kind::Any);
assert_eq!(expr("missing.*").kind(&schema), Kind::Any);
assert_eq!(expr("tags.*").field_path(), Some(all("tags")));
}
#[test]
fn a_split_replaces_a_collection_kind_with_its_element_kind() {
let schema = Schema::closed(vec![
FieldSchema::new(idiom("arr"), Kind::Array(Box::new(Kind::Int), None)),
FieldSchema::new(idiom("set"), Kind::Set(Box::new(Kind::String), None)),
FieldSchema::new(idiom("opt"), Kind::option(Kind::Array(Box::new(Kind::Bool), None))),
FieldSchema::new(idiom("a"), Kind::Int),
]);
let split = LogicalOp::Split(LogicalSplit {
input: Box::new(bound(schema)),
exprs: vec![expr("arr"), expr("set"), expr("opt"), expr("a"), expr("missing")],
});
let schema = split.schema();
assert_eq!(schema.openness, Openness::Closed);
assert_eq!(
kinds(&schema),
[
("arr".to_string(), Kind::Int),
("set".to_string(), Kind::String),
("opt".to_string(), Kind::option(Kind::Bool)),
("a".to_string(), Kind::Int),
]
);
assert!(
LogicalOp::Split(LogicalSplit {
input: Box::new(unbound()),
exprs: vec![expr("arr")],
})
.schema()
.is_open()
);
}
fn resolved_layer() -> LogicalOp {
LogicalOp::Project(LogicalProject {
input: Box::new(bound(closed())),
fields: LogicalFields::Select(vec![
LogicalField::All,
LogicalField::column(
"c",
expr("string::len(b)"),
Some(Kind::Int),
EvalFrame::computed(None),
),
LogicalField::column(
"b",
expr("IF p THEN b ELSE NONE END"),
None,
EvalFrame::permission(None),
),
]),
omit: vec![],
})
}
#[test]
fn a_layer_retypes_its_columns_over_its_input() {
let layer = resolved_layer();
assert!(layer.is_layer());
let schema = layer.schema();
assert_eq!(schema.openness, Openness::Closed);
assert_eq!(paths(&schema), ["id", "a", "b", "c"]);
assert_eq!(kind_of(&schema, "a"), Some(Kind::Int));
assert_eq!(kind_of(&schema, "c"), Some(Kind::Int));
assert_eq!(kind_of(&schema, "b"), Some(Kind::option(Kind::String)));
assert!(schema.field(&idiom("c")).is_some_and(|f| f.flexible));
}
#[test]
fn a_column_the_input_does_not_declare_is_typed_by_its_expression() {
let layer = LogicalOp::Project(LogicalProject {
input: Box::new(unbound()),
fields: LogicalFields::Select(vec![
LogicalField::All,
LogicalField::column(
"secret",
expr("IF p THEN secret ELSE NONE END"),
None,
EvalFrame::permission(None),
),
LogicalField::column(
"c",
expr("a + 1"),
Some(Kind::Int),
EvalFrame::computed(None),
),
LogicalField::column("d", expr("1 > 0"), None, EvalFrame::computed(None)),
]),
omit: vec![],
});
assert!(layer.is_layer());
let schema = layer.schema();
assert!(schema.is_open());
assert_eq!(
kinds(&schema),
[
("secret".to_string(), Kind::Any),
("c".to_string(), Kind::Int),
("d".to_string(), Kind::Bool),
]
);
let layer = LogicalOp::Project(LogicalProject {
input: Box::new(bound(Schema::closed(vec![FieldSchema::new(idiom("g"), Kind::Any)]))),
fields: LogicalFields::Select(vec![
LogicalField::All,
LogicalField::column(
"g",
expr("IF p THEN g ELSE NONE END"),
None,
EvalFrame::permission(None),
),
]),
omit: vec![],
});
assert_eq!(kind_of(&layer.schema(), "g"), Some(Kind::Any));
}
#[test]
fn a_read_above_a_layer_is_typed_as_the_column() {
let layer = resolved_layer();
let schema = layer.schema();
assert_eq!(expr("c").kind(&schema), Kind::Int);
assert_eq!(expr("b").kind(&schema), Kind::option(Kind::String));
assert_eq!(expr("c > 1").kind(&schema), Kind::Bool);
assert_eq!(expr("c + 1").kind(&schema), Kind::Number);
assert_eq!(expr("c").kind(&closed()), Kind::Object);
assert_eq!(expr("b").kind(&closed()), Kind::option(Kind::String));
assert_eq!(expr("$c").kind(&schema), Kind::Any);
assert_eq!(expr("$_c0").kind(&schema), Kind::Any);
let project = LogicalOp::Project(LogicalProject {
input: Box::new(layer),
fields: LogicalFields::Select(vec![
single("c", None),
single("b", Some("guarded")),
single("a", None),
]),
omit: vec![],
});
assert!(!project.is_layer());
assert_eq!(
kinds(&project.schema()),
[
("c".to_string(), Kind::Int),
("guarded".to_string(), Kind::option(Kind::String)),
("a".to_string(), Kind::Int),
]
);
}
#[test]
fn set_field_has_the_kind_of_its_base() {
let schema = closed();
let guard = LogicalExpr::SetField {
base: Box::new(expr("c")),
field: Strand::new("inner"),
value: Box::new(expr("IF p THEN c.inner ELSE NONE END")),
};
assert_eq!(guard.kind(&schema), Kind::Object);
assert_eq!(guard.field_path(), None);
}
#[test]
fn row_preserving_operators_pass_their_input_schema_through() {
let leaf = || Box::new(bound(closed()));
let ops = vec![
LogicalOp::Subquery(LogicalSubquery {
input: leaf(),
}),
LogicalOp::Filter(LogicalFilter {
input: leaf(),
predicate: expr("a > 1"),
}),
LogicalOp::PermissionFilter(LogicalPermissionFilter {
input: leaf(),
predicate: expr("true"),
auth: None,
guard: GuardKind::Read,
}),
LogicalOp::Distinct(LogicalDistinct {
input: leaf(),
}),
LogicalOp::Sort(LogicalSort {
input: leaf(),
ordering: LogicalOrdering::Random,
tempfiles: false,
}),
LogicalOp::Limit(LogicalLimit {
input: leaf(),
limit: Some(expr("1")),
start: None,
}),
LogicalOp::Timeout(LogicalTimeout {
input: leaf(),
timeout: expr("1s"),
}),
LogicalOp::VersionScope(LogicalVersionScope {
input: leaf(),
version: expr("d'2024-01-01T00:00:00Z'"),
}),
LogicalOp::Only(LogicalOnly {
input: leaf(),
}),
];
for op in ops {
assert_eq!(op.schema(), closed(), "{} should pass its input through", op.name());
}
}
#[test]
fn a_join_adds_the_alias_typed_as_the_right_tables_record() {
let join = |kind: JoinKind, right: LogicalOp| {
LogicalOp::Join(LogicalJoin::new(
bound(closed()),
right,
kind,
vec![(expr("a"), RelationAlias::new(0).access("id"))],
None,
RelationAlias::new(0),
EvalFrame::caller(),
))
};
let other = || {
LogicalOp::Filter(LogicalFilter {
input: Box::new(LogicalOp::Source(LogicalSource {
source: SourceRef::Table(TableName::from("u")),
schema: None,
with: None,
for_update: false,
})),
predicate: expr("true"),
})
};
let inner = join(JoinKind::Inner, other()).schema();
assert_eq!(inner.openness, Openness::Closed);
assert_eq!(kind_of(&inner, "_join0"), Some(Kind::Record(vec![TableName::from("u")])));
assert_eq!(kind_of(&inner, "a"), Some(Kind::Int));
let left = join(JoinKind::Left, other()).schema();
assert_eq!(
kind_of(&left, "_join0"),
Some(Kind::either(vec![Kind::Null, Kind::Record(vec![TableName::from("u")])]))
);
let values = join(
JoinKind::Inner,
LogicalOp::Values(LogicalValues {
expr: expr("[1]"),
for_update: false,
written: false,
}),
)
.schema();
assert_eq!(kind_of(&values, "_join0"), Some(Kind::Any));
assert_eq!(join(JoinKind::Semi, other()).schema(), closed());
assert_eq!(join(JoinKind::Anti, other()).schema(), closed());
}
#[test]
fn a_fetch_retypes_the_fields_its_targets_start_from() {
let fetch = |fetches: Vec<LogicalExpr>| {
LogicalOp::Fetch(LogicalFetch {
input: Box::new(bound(closed())),
fetches,
})
};
let schema = fetch(vec![expr("id")]).schema();
assert_eq!(schema.openness, Openness::Closed);
assert_eq!(
kinds(&schema),
[
("id".to_string(), Kind::Any),
("a".to_string(), Kind::Int),
("b".to_string(), Kind::option(Kind::String)),
("c".to_string(), Kind::Object),
]
);
let schema = fetch(vec![expr("c.link"), expr("b")]).schema();
assert_eq!(schema.field(&idiom("c")).map(|f| f.kind.clone()), Some(Kind::Any));
assert_eq!(schema.field(&idiom("b")).map(|f| f.kind.clone()), Some(Kind::Any));
assert_eq!(schema.field(&idiom("a")).map(|f| f.kind.clone()), Some(Kind::Int));
assert_eq!(fetch(vec![expr("missing")]).schema(), closed());
for target in ["$paths", "type::fields(['a'])", "$this.a"] {
assert!(fetch(vec![expr(target)]).schema().is_open(), "FETCH {target}");
}
assert!(
LogicalOp::Fetch(LogicalFetch {
input: Box::new(unbound()),
fetches: vec![expr("a")],
})
.schema()
.is_open()
);
}
#[test]
fn values_explain_and_every_statement_operator_are_open() {
let leaf = || Box::new(bound(closed()));
let ops = vec![
LogicalOp::Values(LogicalValues {
expr: expr("[1, 2]"),
for_update: false,
written: false,
}),
LogicalOp::Explain(LogicalExplain {
input: leaf(),
analyze: false,
format: ExplainFormat::Text,
}),
LogicalOp::Eval(LogicalEval {
expr: expr("1"),
}),
LogicalOp::Sequence(LogicalSequence {
stmts: vec![bound(closed())],
}),
LogicalOp::Let(LogicalLet {
name: "x".to_string(),
kind: Some(Kind::Int),
value: leaf(),
synthetic: false,
}),
LogicalOp::Return(LogicalReturn {
what: leaf(),
fetch: vec![],
}),
LogicalOp::Foreach(LogicalForeach {
param: Param::from("x".to_string()),
range: expr("[1]"),
body: leaf(),
}),
LogicalOp::Info(Box::new(LogicalInfo::Db {
structure: false,
version: None,
})),
LogicalOp::Sleep(LogicalSleep {
duration: expr("1ms"),
}),
LogicalOp::If(LogicalIfOp::new(vec![(expr("true"), bound(closed()))], None)),
LogicalOp::Throw(LogicalThrow {
value: expr("'x'"),
}),
LogicalOp::Break(LogicalBreak),
LogicalOp::Continue(LogicalContinue),
LogicalOp::Ddl(LogicalDdl {
statement: LogicalDdlStatement::Rebuild(Box::new(
crate::expr::statements::RebuildStatement::Index(
crate::expr::statements::rebuild::RebuildIndexStatement {
name: "i".into(),
table: TableName::from("t"),
if_exists: false,
concurrently: false,
},
),
)),
}),
];
for op in ops {
assert_eq!(op.schema(), Schema::open(), "{} should be open", op.name());
}
}
#[test]
fn coercion_identity_follows_the_declared_kind() {
assert!(coercion_is_identity(&Kind::Any, &Kind::Any));
assert!(coercion_is_identity(&Kind::Int, &Kind::Int));
assert!(!coercion_is_identity(&Kind::Int, &Kind::Any));
assert!(!coercion_is_identity(&Kind::Int, &Kind::Float));
assert!(coercion_is_identity(&Kind::Number, &Kind::Decimal));
assert!(coercion_is_identity(&Kind::option(Kind::Int), &Kind::Int));
assert!(coercion_is_identity(&Kind::option(Kind::Int), &Kind::None));
assert!(!coercion_is_identity(&Kind::option(Kind::Int), &Kind::option(Kind::String)));
assert!(coercion_is_identity(
&Kind::Array(Box::new(Kind::Int), None),
&Kind::Array(Box::new(Kind::Int), None)
));
assert!(!coercion_is_identity(
&Kind::Array(Box::new(Kind::Int), Some(2)),
&Kind::Array(Box::new(Kind::Int), None)
));
assert!(coercion_is_identity(
&Kind::Record(vec![]),
&Kind::Record(vec![TableName::from("t")])
));
assert!(!coercion_is_identity(
&Kind::Record(vec![TableName::from("u")]),
&Kind::Record(vec![])
));
assert!(!coercion_is_identity(
&Kind::Table(vec![]),
&Kind::Table(vec![TableName::from("a")])
));
assert!(coercion_is_identity(
&Kind::Geometry(vec![]),
&Kind::Geometry(vec![crate::expr::kind::GeometryKind::Point])
));
assert!(!coercion_is_identity(&Kind::option(Kind::Int), &Kind::option(Kind::Int)));
assert!(coercion_is_identity(
&Kind::Array(Box::new(Kind::Int), Some(3)),
&Kind::Array(Box::new(Kind::Int), Some(3))
));
}
}