pub enum Expr {
Show 62 variants
Identifier(Ident),
CompoundIdentifier(Vec<Ident>),
JsonAccess {
value: Box<Expr>,
path: JsonPath,
},
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<String>,
},
ILike {
negated: bool,
expr: Box<Expr>,
pattern: Box<Expr>,
escape_char: Option<String>,
},
SimilarTo {
negated: bool,
expr: Box<Expr>,
pattern: Box<Expr>,
escape_char: Option<String>,
},
RLike {
negated: bool,
expr: Box<Expr>,
pattern: Box<Expr>,
regexp: bool,
},
AnyOp {
left: Box<Expr>,
compare_op: BinaryOperator,
right: Box<Expr>,
},
AllOp {
left: Box<Expr>,
compare_op: BinaryOperator,
right: Box<Expr>,
},
UnaryOp {
op: UnaryOperator,
expr: Box<Expr>,
},
Convert {
expr: Box<Expr>,
data_type: Option<DataType>,
charset: Option<ObjectName>,
target_before_value: bool,
styles: Vec<Expr>,
},
Cast {
kind: CastKind,
expr: Box<Expr>,
data_type: DataType,
format: Option<CastFormat>,
},
AtTimeZone {
timestamp: Box<Expr>,
time_zone: Box<Expr>,
},
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>>,
special: bool,
},
Trim {
expr: Box<Expr>,
trim_where: Option<TrimWhereField>,
trim_what: Option<Box<Expr>>,
trim_characters: Option<Vec<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),
IntroducedString {
introducer: String,
value: Value,
},
TypedString {
data_type: DataType,
value: String,
},
MapAccess {
column: Box<Expr>,
keys: Vec<MapAccessKey>,
},
Function(Function),
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>),
GroupingSets(Vec<Vec<Expr>>),
Cube(Vec<Vec<Expr>>),
Rollup(Vec<Vec<Expr>>),
Tuple(Vec<Expr>),
Struct {
values: Vec<Expr>,
fields: Vec<StructField>,
},
Named {
expr: Box<Expr>,
name: Ident,
},
Dictionary(Vec<DictionaryField>),
Subscript {
expr: Box<Expr>,
subscript: Box<Subscript>,
},
Array(Array),
Interval(Interval),
MatchAgainst {
columns: Vec<Ident>,
match_value: Value,
opt_search_modifier: Option<SearchModifier>,
},
Wildcard,
QualifiedWildcard(ObjectName),
OuterJoin(Box<Expr>),
Prior(Box<Expr>),
Lambda(LambdaFunction),
}
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
Access data nested in a value containing semi-structured data, such as
the VARIANT
type on Snowflake. for example src:customer[0].name
.
See https://docs.snowflake.com/en/user-guide/querying-semistructured. See https://docs.databricks.com/en/sql/language-manual/functions/colonsign.html.
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
[NOT] LIKE <pattern> [ESCAPE <escape_character>]
ILike
ILIKE
(case-insensitive LIKE
)
SimilarTo
SIMILAR TO regex
RLike
MySQL: RLIKE regex or REGEXP regex
AnyOp
ANY
operation e.g. foo > ANY(bar)
, comparison operator is one of [=, >, <, =>, =<, !=]
AllOp
ALL
operation e.g. foo > ALL(bar)
, comparison operator is one of [=, >, <, =>, =<, !=]
UnaryOp
Unary operation e.g. NOT foo
Convert
CONVERT a value to a different data type or character encoding. e.g. CONVERT(foo USING utf8mb4)
Fields
charset: Option<ObjectName>
The target character encoding
Cast
CAST
an expression to a different data type e.g. CAST(foo AS VARCHAR(123))
AtTimeZone
AT a timestamp to a different timezone e.g. FROM_UNIXTIME(0) AT TIME ZONE 'UTC-06:00'
Extract
Extract a field from a timestamp e.g. EXTRACT(MONTH FROM foo)
Syntax:
EXTRACT(DateTimeField FROM <expr>)
Ceil
CEIL(<expr> [TO DateTimeField])
Floor
FLOOR(<expr> [TO DateTimeField])
Position
POSITION(<expr> in <expr>)
Substring
SUBSTRING(<expr> [FROM <expr>] [FOR <expr>])
or
SUBSTRING(<expr>, <expr>, <expr>)
Fields
Trim
TRIM([BOTH | LEADING | TRAILING] [<expr> FROM] <expr>)
TRIM(<expr>)
TRIM(<expr>, [, characters]) -- only Snowflake or Bigquery
Fields
trim_where: Option<TrimWhereField>
Overlay
OVERLAY(<expr> PLACING <expr> FROM <expr>[ FOR <expr> ]
Fields
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
IntroducedString
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 Subscript
or MapAccess
https://clickhouse.com/docs/en/sql-reference/data-types/map/
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
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
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)
Struct
BigQuery
specific Struct
literal expression 1
Syntax:
STRUCT<[field_name] field_type, ...>( expr1 [, ... ])
Named
Dictionary(Vec<DictionaryField>)
Subscript
An access of nested data using subscript syntax, for example array[2]
.
Array(Array)
An array expression e.g. ARRAY[1, 2]
Interval(Interval)
An interval expression e.g. INTERVAL '1' YEAR
MatchAgainst
MySQL
specific text search function (1).
Syntax:
MATCH (<col>, <col>, ...) AGAINST (<expr> [<search modifier>])
<col> = CompoundIdentifier
<expr> = String literal
Fields
opt_search_modifier: Option<SearchModifier>
<search modifier>
Wildcard
QualifiedWildcard(ObjectName)
Qualified wildcard, e.g. alias.*
or schema.table.*
.
(Same caveats apply to QualifiedWildcard
as to Wildcard
.)
OuterJoin(Box<Expr>)
Some dialects support an older syntax for outer joins where columns are
marked with the (+)
operator in the WHERE clause, for example:
SELECT t1.c1, t2.c2 FROM t1, t2 WHERE t1.c1 = t2.c2 (+)
which is equivalent to
SELECT t1.c1, t2.c2 FROM t1 LEFT OUTER JOIN t2 ON t1.c1 = t2.c2
See https://docs.snowflake.com/en/sql-reference/constructs/where#joins-in-the-where-clause.
Prior(Box<Expr>)
A reference to the prior level in a CONNECT BY clause.
Lambda(LambdaFunction)
A lambda function.
Syntax:
param -> expr | (param1, ...) -> expr
See https://docs.databricks.com/en/sql/language-manual/sql-ref-lambda-functions.html.
Trait Implementations§
source§impl From<Expr> for FunctionArgExpr
impl From<Expr> for FunctionArgExpr
source§fn from(wildcard_expr: Expr) -> FunctionArgExpr
fn from(wildcard_expr: Expr) -> FunctionArgExpr
source§impl Ord for Expr
impl Ord for Expr
source§impl PartialEq for Expr
impl PartialEq for Expr
source§impl PartialOrd for Expr
impl PartialOrd for Expr
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresource§impl VisitMut for Expr
impl VisitMut for Expr
fn visit<V>(&mut self, visitor: &mut V) -> ControlFlow<<V as VisitorMut>::Break>where
V: VisitorMut,
impl Eq for Expr
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 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
source§impl<Q, K> Comparable<K> for Q
impl<Q, K> Comparable<K> for Q
source§impl<Q, K> Equivalent<K> for Q
impl<Q, K> Equivalent<K> for Q
source§impl<Q, K> Equivalent<K> for Q
impl<Q, K> Equivalent<K> for Q
source§fn equivalent(&self, key: &K) -> bool
fn equivalent(&self, key: &K) -> bool
key
and return true
if they are equal.source§impl<T> IntoEither for T
impl<T> IntoEither for T
source§fn into_either(self, into_left: bool) -> Either<Self, Self>
fn into_either(self, into_left: bool) -> Either<Self, Self>
self
into a Left
variant of Either<Self, Self>
if into_left
is true
.
Converts self
into a Right
variant of Either<Self, Self>
otherwise. Read moresource§fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
self
into a Left
variant of Either<Self, Self>
if into_left(&self)
returns true
.
Converts self
into a Right
variant of Either<Self, Self>
otherwise. Read more