pub enum Expr {
Show 55 variants
Identifier(Identifier),
Property {
base: Box<Expr>,
key: Identifier,
},
GraphReference {
property_graph: bool,
graph: GraphExpression,
},
BindingTableReference {
binding: bool,
table: BindingTableExpression,
},
Parameter(String),
Literal(Literal),
Unary {
op: UnaryOp,
expr: Box<Expr>,
},
Binary {
left: Box<Expr>,
op: BinaryOp,
right: Box<Expr>,
},
Function {
name: Identifier,
quantifier: Option<SetQuantifier>,
args: Vec<Expr>,
},
SubstringByLength {
side: SubstringSide,
value: Box<Expr>,
length: Box<Expr>,
},
Trim {
specification: Option<TrimSpec>,
trim_character: Option<Box<Expr>>,
value: Box<Expr>,
},
MultiTrim {
specification: TrimSpec,
value: Box<Expr>,
trim_characters: Option<Box<Expr>>,
},
TrimList {
value: Box<Expr>,
count: Box<Expr>,
},
Elements {
path: Box<Expr>,
},
StringLength {
unit: StringLengthUnit,
value: Box<Expr>,
},
Fold {
upper: bool,
value: Box<Expr>,
},
Normalize {
value: Box<Expr>,
normal_form: Option<Identifier>,
},
CurrentDate,
CurrentTime {
precision: Option<u64>,
},
CurrentTimestamp {
precision: Option<u64>,
},
CurrentUser,
DateTimeFunction {
function: DateTimeFunctionKind,
value: Option<Box<Expr>>,
},
LocalTime {
precision: Option<u64>,
},
LocalTimestamp {
precision: Option<u64>,
},
AbsoluteValue {
expr: Box<Expr>,
},
DurationFunction {
value: Box<Expr>,
},
DurationBetween {
left: Box<Expr>,
right: Box<Expr>,
},
NumericFunction {
function: NumericFunctionKind,
args: Vec<Expr>,
},
Cast {
expr: Box<Expr>,
value_type: ValueType,
},
ValueQuery {
query: Box<QueryStatement>,
},
Let {
items: Vec<LetItem>,
value: Box<Expr>,
},
IsTyped {
expr: Box<Expr>,
negated: bool,
value_type: ValueType,
},
IsNull {
expr: Box<Expr>,
negated: bool,
},
IsUnknown {
expr: Box<Expr>,
negated: bool,
},
IsTruth {
expr: Box<Expr>,
negated: bool,
value: bool,
},
PropertyExists {
variable: Identifier,
property: Identifier,
},
ElementId {
variable: Identifier,
},
Exists {
patterns: Vec<PathPattern>,
},
ExistsQuery {
query: Box<QueryStatement>,
},
ExistsMatch {
matches: Vec<MatchClause>,
},
Same {
variables: Vec<Identifier>,
},
AllDifferent {
variables: Vec<Identifier>,
},
SourceDestination {
node: Identifier,
negated: bool,
kind: SourceDestinationKind,
edge: Identifier,
},
IsNormalized {
expr: Box<Expr>,
negated: bool,
normal_form: Option<Identifier>,
},
IsDirected {
variable: Identifier,
negated: bool,
},
IsLabeled {
variable: Identifier,
negated: bool,
label_expression: LabelExpression,
},
Case {
operand: Option<Box<Expr>>,
when_clauses: Vec<CaseWhenClause>,
else_expr: Option<Box<Expr>>,
},
Coalesce(Vec<Expr>),
NullIf {
left: Box<Expr>,
right: Box<Expr>,
},
List(Vec<Expr>),
TypedList {
type_name: ListValueTypeName,
values: Vec<Expr>,
},
Path(Vec<Expr>),
Record {
explicit: bool,
fields: MapLiteral,
},
Map(MapLiteral),
Wildcard,
}Variants§
Identifier(Identifier)
Property
GraphReference
BindingTableReference
Parameter(String)
Literal(Literal)
Unary
Binary
Function
SubstringByLength
Trim
MultiTrim
TrimList
Elements
StringLength
Fold
Normalize
CurrentDate
CurrentTime
CurrentTimestamp
CurrentUser
DateTimeFunction
LocalTime
LocalTimestamp
AbsoluteValue
DurationFunction
DurationBetween
NumericFunction
Cast
ValueQuery
Fields
§
query: Box<QueryStatement>Let
IsTyped
IsNull
IsUnknown
IsTruth
PropertyExists
ElementId
Fields
§
variable: IdentifierExists
Fields
§
patterns: Vec<PathPattern>ExistsQuery
Fields
§
query: Box<QueryStatement>ExistsMatch
Fields
§
matches: Vec<MatchClause>Same
Fields
§
variables: Vec<Identifier>AllDifferent
Fields
§
variables: Vec<Identifier>SourceDestination
IsNormalized
IsDirected
IsLabeled
Case
Coalesce(Vec<Expr>)
NullIf
List(Vec<Expr>)
TypedList
Path(Vec<Expr>)
Record
Map(MapLiteral)
Wildcard
Trait Implementations§
impl StructuralPartialEq for Expr
Auto Trait Implementations§
impl Freeze for Expr
impl RefUnwindSafe for Expr
impl Send for Expr
impl Sync for Expr
impl Unpin for Expr
impl UnsafeUnpin for Expr
impl UnwindSafe for Expr
Blanket Implementations§
Source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
Source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more