pub enum Expr {
Show 55 variants
Identifier(Ident),
CompoundIdentifier(Vec<Ident>),
JsonAccess {
left: Box<Expr>,
operator: JsonOperator,
right: Box<Expr>,
},
CompositeAccess {
expr: Box<Expr>,
key: Ident,
},
IsFalse(Box<Expr>),
IsNotFalse(Box<Expr>),
IsTrue(Box<Expr>),
IsNotTrue(Box<Expr>),
IsNull(Box<Expr>),
IsNotNull(Box<Expr>),
IsUnknown(Box<Expr>),
IsNotUnknown(Box<Expr>),
IsDistinctFrom(Box<Expr>, Box<Expr>),
IsNotDistinctFrom(Box<Expr>, Box<Expr>),
InList {
expr: Box<Expr>,
list: Vec<Expr>,
negated: bool,
},
InSubquery {
expr: Box<Expr>,
subquery: Box<Query>,
negated: bool,
},
InUnnest {
expr: Box<Expr>,
array_expr: Box<Expr>,
negated: bool,
},
Between {
expr: Box<Expr>,
negated: bool,
low: Box<Expr>,
high: Box<Expr>,
},
BinaryOp {
left: Box<Expr>,
op: BinaryOperator,
right: Box<Expr>,
},
Like {
negated: bool,
expr: Box<Expr>,
pattern: Box<Expr>,
escape_char: Option<char>,
},
ILike {
negated: bool,
expr: Box<Expr>,
pattern: Box<Expr>,
escape_char: Option<char>,
},
SimilarTo {
negated: bool,
expr: Box<Expr>,
pattern: Box<Expr>,
escape_char: Option<char>,
},
AnyOp(Box<Expr>),
AllOp(Box<Expr>),
UnaryOp {
op: UnaryOperator,
expr: Box<Expr>,
},
Cast {
expr: Box<Expr>,
data_type: DataType,
},
TryCast {
expr: Box<Expr>,
data_type: DataType,
},
SafeCast {
expr: Box<Expr>,
data_type: DataType,
},
AtTimeZone {
timestamp: Box<Expr>,
time_zone: String,
},
Extract {
field: DateTimeField,
expr: Box<Expr>,
},
Ceil {
expr: Box<Expr>,
field: DateTimeField,
},
Floor {
expr: Box<Expr>,
field: DateTimeField,
},
Position {
expr: Box<Expr>,
in: Box<Expr>,
},
Substring {
expr: Box<Expr>,
substring_from: Option<Box<Expr>>,
substring_for: Option<Box<Expr>>,
},
Trim {
expr: Box<Expr>,
trim_where: Option<TrimWhereField>,
trim_what: Option<Box<Expr>>,
},
Overlay {
expr: Box<Expr>,
overlay_what: Box<Expr>,
overlay_from: Box<Expr>,
overlay_for: Option<Box<Expr>>,
},
Collate {
expr: Box<Expr>,
collation: ObjectName,
},
Nested(Box<Expr>),
Value(Value),
TypedString {
data_type: DataType,
value: String,
},
MapAccess {
column: Box<Expr>,
keys: Vec<Expr>,
},
Function(Function),
AggregateExpressionWithFilter {
expr: Box<Expr>,
filter: Box<Expr>,
},
Case {
operand: Option<Box<Expr>>,
conditions: Vec<Expr>,
results: Vec<Expr>,
else_result: Option<Box<Expr>>,
},
Exists {
subquery: Box<Query>,
negated: bool,
},
Subquery(Box<Query>),
ArraySubquery(Box<Query>),
ListAgg(ListAgg),
GroupingSets(Vec<Vec<Expr>>),
Cube(Vec<Vec<Expr>>),
Rollup(Vec<Vec<Expr>>),
Tuple(Vec<Expr>),
ArrayIndex {
obj: Box<Expr>,
indexes: Vec<Expr>,
},
Array(Array),
Interval {
value: Box<Expr>,
leading_field: Option<DateTimeField>,
leading_precision: Option<u64>,
last_field: Option<DateTimeField>,
fractional_seconds_precision: Option<u64>,
},
}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
CompoundIdentifier(Vec<Ident>)
Multi-part identifier, e.g. table_alias.column or schema.table.col
JsonAccess
JSON access (postgres) eg: data->‘tags’
CompositeAccess
CompositeAccess (postgres) eg: SELECT (information_schema._pg_expandarray(array[‘i’,‘i’])).n
IsFalse(Box<Expr>)
IS FALSE operator
IsNotFalse(Box<Expr>)
IS NOT FALSE operator
IsTrue(Box<Expr>)
IS TRUE operator
IsNotTrue(Box<Expr>)
IS NOT TRUE operator
IsNull(Box<Expr>)
IS NULL operator
IsNotNull(Box<Expr>)
IS NOT NULL operator
IsUnknown(Box<Expr>)
IS UNKNOWN operator
IsNotUnknown(Box<Expr>)
IS NOT UNKNOWN operator
IsDistinctFrom(Box<Expr>, Box<Expr>)
IS DISTINCT FROM operator
IsNotDistinctFrom(Box<Expr>, Box<Expr>)
IS NOT DISTINCT FROM operator
InList
[ NOT ] IN (val1, val2, ...)
InSubquery
[ NOT ] IN (SELECT ...)
InUnnest
[ NOT ] IN UNNEST(array_expression)
Between
<expr> [ NOT ] BETWEEN <low> AND <high>
BinaryOp
Binary operation e.g. 1 + 1 or foo > bar
Like
LIKE
ILike
ILIKE (case-insensitive LIKE)
SimilarTo
SIMILAR TO regex
AnyOp(Box<Expr>)
Any operation e.g. 1 ANY (1) or foo > ANY(bar), It will be wrapped in the right side of BinaryExpr
AllOp(Box<Expr>)
ALL operation e.g. 1 ALL (1) or foo > ALL(bar), It will be wrapped in the right side of BinaryExpr
UnaryOp
Unary operation e.g. NOT foo
Cast
CAST an expression to a different data type e.g. CAST(foo AS VARCHAR(123))
TryCast
TRY_CAST an expression to a different data type e.g. TRY_CAST(foo AS VARCHAR(123))
SafeCast
SAFE_CAST an expression to a different data type e.g. SAFE_CAST(foo AS FLOAT64)
AtTimeZone
AT a timestamp to a different timezone e.g. FROM_UNIXTIME(0) AT TIME ZONE 'UTC-06:00'
Extract
EXTRACT(DateTimeField FROM
Ceil
CEIL(
Floor
FLOOR(
Position
POSITION(
Substring
SUBSTRING(
Trim
TRIM([BOTH | LEADING | TRAILING] [
Or
TRIM(
Overlay
OVERLAY(
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
TypedString
A constant of form <data_type> 'value'.
This can represent ANSI SQL DATE, TIME, and TIMESTAMP literals (such as DATE '2020-01-01'),
as well as constants of other types (a non-standard PostgreSQL extension).
MapAccess
Access a map-like object by field (e.g. column['field'] or column[4]
Note that depending on the dialect, struct like accesses may be
parsed as [ArrayIndex] or [MapAccess]
https://clickhouse.com/docs/en/sql-reference/data-types/map/
Function(Function)
Scalar function call e.g. LEFT(foo, 5)
AggregateExpressionWithFilter
Aggregate function with filter
Case
Fields
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
Exists
An exists expression [ NOT ] EXISTS(SELECT ...), used in expressions like
WHERE [ NOT ] EXISTS (SELECT ...).
Subquery(Box<Query>)
A parenthesized subquery (SELECT ...), used in expression like
SELECT (subquery) AS x or WHERE (subquery) = x
ArraySubquery(Box<Query>)
An array subquery constructor, e.g. SELECT ARRAY(SELECT 1 UNION SELECT 2)
ListAgg(ListAgg)
The LISTAGG function SELECT LISTAGG(...) WITHIN GROUP (ORDER BY ...)
GroupingSets(Vec<Vec<Expr>>)
The GROUPING SETS expr.
Cube(Vec<Vec<Expr>>)
The CUBE expr.
Rollup(Vec<Vec<Expr>>)
The ROLLUP expr.
Tuple(Vec<Expr>)
ROW / TUPLE a single value, such as SELECT (1, 2)
ArrayIndex
An array index expression e.g. (ARRAY[1, 2])[1] or (current_schemas(FALSE))[1]
Array(Array)
An array expression e.g. ARRAY[1, 2]
Interval
INTERVAL literals, roughly in the following format:
INTERVAL '<value>' [ <leading_field> [ (<leading_precision>) ] ] [ TO <last_field> [ (<fractional_seconds_precision>) ] ],
e.g. INTERVAL '123:45.67' MINUTE(3) TO SECOND(2).
The parser does not validate the <value>, nor does it ensure
that the <leading_field> units >= the units in <last_field>,
so the user will have to reject intervals like HOUR TO YEAR.