use super::*;
#[derive(Debug, Clone, PartialEq)]
pub enum InterpPart {
Text(String),
Interp(Box<Expr>),
}
#[derive(Debug, Clone, PartialEq)]
pub enum Expr {
Literal(LiteralValue),
List(Vec<Expr>),
Map(Vec<MapPair>),
StringInterp(Vec<InterpPart>),
Variable(SmallName),
Parameter(String),
Property(Box<PropertyAccess>),
FunctionCall(FunctionCallExpr),
Binary(Box<BinaryExpr>),
Unary(Box<UnaryExpr>),
Comparison(Box<ComparisonExpr>),
In(Box<InExpr>),
IsNull(Box<IsNullExpr>),
IsType(Box<IsTypeExpr>),
IsNormalized(Box<IsNormalizedExpr>),
ChronologicalCompare(Box<ChronologicalCompareExpr>),
StringMatch(Box<StringMatchExpr>),
CountStar,
Star,
Case(Box<CaseExpr>),
ExistsSubquery(Box<ExistsSubqueryExpr>),
CountSubquery(Box<CountSubqueryExpr>),
CollectSubquery(Box<CollectSubqueryExpr>),
ListComprehension(Box<ListComprehensionExpr>),
MapComprehension(Box<MapComprehensionExpr>),
PatternComprehension(Box<PatternComprehensionExpr>),
Reduce(Box<ReduceExpr>),
AllReduce(Box<AllReduceExpr>),
ShortestPath(Box<ShortestPathExpr>),
Subscript(Box<SubscriptExpr>),
Quantifier(Box<QuantifierExpr>),
HasLabel(Box<HasLabelExpr>),
Paren(Box<Expr>),
PatternPredicate(Box<PatternPredicateExpr>),
MapProjection(Box<MapProjectionExpr>),
OptionValuePlaceholder,
}
#[derive(Debug, Clone, PartialEq)]
pub enum LiteralValue {
Null,
Bool(bool),
Integer(i64),
Float(f64),
String(String),
}
#[derive(Debug, Clone, PartialEq)]
pub struct MapPair {
pub key: SmallName,
pub value: Expr,
}
#[derive(Debug, Clone, PartialEq)]
pub struct MapProjectionExpr {
pub expr: Expr,
pub items: Vec<MapProjectionItem>,
}
#[derive(Debug, Clone, PartialEq)]
pub enum MapProjectionItem {
AllProperties,
Property(SmallName),
Variable(SmallName),
KeyValue(SmallName, Expr),
}
#[derive(Debug, Clone, PartialEq)]
pub struct PropertyAccess {
pub expr: Expr,
pub property: SmallName,
pub key_expr: Option<Expr>,
}
#[derive(Debug, Clone, PartialEq)]
pub struct FunctionCallExpr {
pub name: SmallName,
pub args: Vec<Expr>,
pub distinct: bool,
}
#[derive(Debug, Clone, PartialEq)]
pub struct BinaryExpr {
pub left: Expr,
pub op: &'static str,
pub right: Expr,
}
#[derive(Debug, Clone, PartialEq)]
pub struct UnaryExpr {
pub op: &'static str,
pub expr: Expr,
}
#[derive(Debug, Clone, PartialEq)]
pub struct ComparisonExpr {
pub left: Expr,
pub op: &'static str,
pub right: Expr,
}
#[derive(Debug, Clone, PartialEq)]
pub struct InExpr {
pub expr: Expr,
pub list: Expr,
}
#[derive(Debug, Clone, PartialEq)]
pub struct IsNullExpr {
pub expr: Expr,
pub negated: bool,
}
#[derive(Debug, Clone, PartialEq)]
pub struct IsTypeExpr {
pub expr: Expr,
pub type_expr: TypeExpr,
pub negated: bool,
}
#[derive(Debug, Clone, PartialEq)]
pub enum TypeExpr {
Predefined {
kind: PredefinedKind,
not_null: bool,
},
List {
element: Box<TypeExpr>,
not_null: bool,
},
PropertyValue { not_null: bool },
Union(Vec<TypeExpr>),
Vector {
coord: Option<VectorCoordKind>,
dimension: Option<i64>,
not_null: bool,
},
}
impl TypeExpr {
pub fn direct_not_null(&self) -> bool {
match self {
TypeExpr::Predefined { not_null, .. } => *not_null,
TypeExpr::List { not_null, .. } => *not_null,
TypeExpr::PropertyValue { not_null } => *not_null,
TypeExpr::Vector { not_null, .. } => *not_null,
TypeExpr::Union(_) => false,
}
}
}
pub use relate_model::VectorCoordKind;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum PredefinedKind {
Nothing,
Null,
Any,
Boolean,
String,
Integer,
Float,
Date,
Duration,
Point,
LocalTime,
ZonedTime,
LocalDateTime,
ZonedDateTime,
Node,
Relationship,
Path,
Map,
Uuid,
}
#[derive(Debug, Clone, PartialEq)]
pub struct IsNormalizedExpr {
pub expr: Expr,
pub form: Option<String>,
pub negated: bool,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ChronologicalOp {
Before,
After,
SameInstant,
SameRepresentation,
}
#[derive(Debug, Clone, PartialEq)]
pub struct ChronologicalCompareExpr {
pub left: Expr,
pub op: ChronologicalOp,
pub right: Expr,
pub negated: bool,
}
#[derive(Debug, Clone, PartialEq)]
pub struct StringMatchExpr {
pub left: Expr,
pub op: &'static str,
pub right: Expr,
}
#[derive(Debug, Clone, PartialEq)]
pub struct CaseExpr {
pub whens: Vec<WhenClause>,
pub else_expr: Option<Expr>,
}
#[derive(Debug, Clone, PartialEq)]
pub struct WhenClause {
pub condition: Expr,
pub result: Expr,
}
#[derive(Debug, Clone, PartialEq)]
pub struct ExistsSubqueryExpr {
pub statement: Statement,
}
#[derive(Debug, Clone, PartialEq)]
pub struct CountSubqueryExpr {
pub statement: Statement,
}
#[derive(Debug, Clone, PartialEq)]
pub struct CollectSubqueryExpr {
pub statement: Statement,
}
#[derive(Debug, Clone, PartialEq)]
pub struct MapComprehensionExpr {
pub key_var: Option<SmallName>,
pub value_var: SmallName,
pub source_expr: Expr,
pub where_expr: Option<Expr>,
pub key_expr: Expr,
pub value_expr: Expr,
}
#[derive(Debug, Clone, PartialEq)]
pub struct ListComprehensionExpr {
pub variable: SmallName,
pub list_expr: Expr,
pub where_expr: Option<Expr>,
pub map_expr: Option<Expr>,
}
#[derive(Debug, Clone, PartialEq)]
pub struct PatternComprehensionExpr {
pub path_variable: Option<SmallName>,
pub pattern: PatternPath,
pub where_expr: Option<Expr>,
pub map_expr: Expr,
}
#[derive(Debug, Clone, PartialEq)]
pub struct ReduceExpr {
pub accumulator: SmallName,
pub init_expr: Expr,
pub variable: SmallName,
pub list_expr: Expr,
pub expression: Expr,
}
#[derive(Debug, Clone, PartialEq)]
pub struct AllReduceExpr {
pub accumulator: SmallName,
pub init_expr: Expr,
pub variable: SmallName,
pub list_expr: Expr,
pub expression: Expr,
pub predicate: Expr,
}
#[derive(Debug, Clone, PartialEq)]
pub struct ShortestPathExpr {
pub pattern: PatternPath,
pub all: bool,
}
#[derive(Debug, Clone, PartialEq)]
pub struct SubscriptExpr {
pub expr: Expr,
pub index: Option<Expr>,
pub from: Option<Expr>,
pub to: Option<Expr>,
pub slice: bool,
}
#[derive(Debug, Clone, PartialEq)]
pub struct QuantifierExpr {
pub quantifier: String,
pub variable: SmallName,
pub list: Expr,
pub predicate: Option<Expr>,
}
#[derive(Debug, Clone, PartialEq)]
pub struct HasLabelExpr {
pub expr: Expr,
pub label_expr: LabelExpr,
pub negated: bool,
pub strict: bool,
}
#[derive(Debug, Clone, PartialEq)]
pub struct PatternPredicateExpr {
pub pattern: PatternPath,
}