pub enum Expr {
Show 21 variants
Identifier(Ident),
Wildcard,
QualifiedWildcard(Vec<Ident>),
CompoundIdentifier(Vec<Ident>),
IsNull(Box<Expr>),
IsNotNull(Box<Expr>),
InList {
expr: Box<Expr>,
list: Vec<Expr>,
negated: bool,
},
ValueList(Vec<Expr>),
InSubquery {
expr: Box<Expr>,
subquery: Box<Query>,
negated: bool,
},
Between {
expr: Box<Expr>,
negated: bool,
low: Box<Expr>,
high: Box<Expr>,
},
BinaryOp {
left: Box<Expr>,
op: BinaryOperator,
right: Box<Expr>,
},
UnaryOp {
op: UnaryOperator,
expr: Box<Expr>,
},
Cast {
expr: Box<Expr>,
data_type: DataType,
},
Extract {
field: DateTimeField,
expr: Box<Expr>,
},
Collate {
expr: Box<Expr>,
collation: ObjectName,
},
Nested(Box<Expr>),
Value(Value),
Function(Function),
Case {
operand: Option<Box<Expr>>,
conditions: Vec<Expr>,
results: Vec<Expr>,
else_result: Option<Box<Expr>>,
},
Exists(Box<Query>),
Subquery(Box<Query>),
}
Expand description
An SQL expression of any type.
The parser does not distinguish between expressions of different types
(e.g. boolean vs string), so the caller must handle expressions of
inappropriate type, like WHERE 1
or SELECT 1=1
, as necessary.
Variants§
Identifier(Ident)
Identifier e.g. table name or column name
Wildcard
Unqualified wildcard (*
). SQL allows this in limited contexts, such as:
- right after
SELECT
(which is represented as a SelectItem::Wildcard instead) - or as part of an aggregate function, e.g.
COUNT(*)
,
…but we currently also accept it in contexts where it doesn’t make
sense, such as * + *
QualifiedWildcard(Vec<Ident>)
Qualified wildcard, e.g. alias.*
or schema.table.*
.
(Same caveats apply to QualifiedWildcard
as to Wildcard
.)
CompoundIdentifier(Vec<Ident>)
Multi-part identifier, e.g. table_alias.column
or schema.table.col
IsNull(Box<Expr>)
IS NULL
expression
IsNotNull(Box<Expr>)
IS NOT NULL
expression
InList
[ NOT ] IN (val1, val2, ...)
ValueList(Vec<Expr>)
InSubquery
[ NOT ] IN (SELECT ...)
Between
<expr> [ NOT ] BETWEEN <low> AND <high>
BinaryOp
Binary operation e.g. 1 + 1
or foo > bar
UnaryOp
Unary operation e.g. NOT foo
Cast
CAST an expression to a different data type e.g. CAST(foo AS VARCHAR(123))
Extract
Collate
expr COLLATE collation
Nested(Box<Expr>)
Nested expression e.g. (foo > bar)
or (1)
Value(Value)
A literal value, such as string, number, date or NULL
Function(Function)
Scalar function call e.g. LEFT(foo, 5)
Case
CASE [<operand>] WHEN <condition> THEN <result> ... [ELSE <result>] END
Note we only recognize a complete single expression as <condition>
,
not < 0
nor 1, 2, 3
as allowed in a <simple when clause>
per
https://jakewheat.github.io/sql-overview/sql-2011-foundation-grammar.html#simple-when-clause
Fields
Exists(Box<Query>)
An exists expression EXISTS(SELECT ...)
, used in expressions like
WHERE EXISTS (SELECT ...)
.
Subquery(Box<Query>)
A parenthesized subquery (SELECT ...)
, used in expression like
SELECT (subquery) AS x
or WHERE (subquery) = x