// Licensed to the Apache Software Foundation (ASF) under one

// or more contributor license agreements. See the NOTICE file

// distributed with this work for additional information

// regarding copyright ownership. The ASF licenses this file

// to you under the Apache License, Version 2.0 (the

// "License"); you may not use this file except in compliance

// with the License. You may obtain a copy of the License at

//

// http://www.apache.org/licenses/LICENSE-2.0

//

// Unless required by applicable law or agreed to in writing,

// software distributed under the License is distributed on an

// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY

// KIND, either express or implied. See the License for the

// specific language governing permissions and limitations

// under the License.

//! SQL Abstract Syntax Tree (AST) types

#[cfg(not(feature = "std"))]

use alloc::{

boxed::Box,

format,

string::{String, ToString},

vec::Vec,

};

use helpers::{attached_token::AttachedToken, stmt_data_loading::FileStagingCommand};

use core::ops::Deref;

use core::{

fmt::{self, Display},

hash,

};

#[cfg(feature = "serde")]

use serde::{Deserialize, Serialize};

#[cfg(feature = "visitor")]

use sqlparser_derive::{Visit, VisitMut};

use crate::tokenizer::Span;

pub use self::data_type::{

ArrayElemTypeDef, CharLengthUnits, CharacterLength, DataType, EnumMember, ExactNumberInfo,

StructBracketKind, TimezoneInfo,

};

pub use self::dcl::{

AlterRoleOperation, ResetConfig, RoleOption, SecondaryRoles, SetConfigValue, Use,

};

pub use self::ddl::{

AlterColumnOperation, AlterIndexOperation, AlterPolicyOperation, AlterTableOperation,

ClusteredBy, ColumnDef, ColumnOption, ColumnOptionDef, ColumnPolicy, ColumnPolicyProperty,

ConstraintCharacteristics, CreateFunction, Deduplicate, DeferrableInitial, DropBehavior,

GeneratedAs, GeneratedExpressionMode, IdentityParameters, IdentityProperty,

IdentityPropertyFormatKind, IdentityPropertyKind, IdentityPropertyOrder, IndexOption,

IndexType, KeyOrIndexDisplay, NullsDistinctOption, Owner, Partition, ProcedureParam,

ReferentialAction, TableConstraint, TagsColumnOption, UserDefinedTypeCompositeAttributeDef,

UserDefinedTypeRepresentation, ViewColumnDef,

};

pub use self::dml::{CreateIndex, CreateTable, Delete, Insert};

pub use self::operator::{BinaryOperator, UnaryOperator};

pub use self::query::{

AfterMatchSkip, ConnectBy, Cte, CteAsMaterialized, Distinct, EmptyMatchesMode,

ExceptSelectItem, ExcludeSelectItem, ExprWithAlias, Fetch, ForClause, ForJson, ForXml,

FormatClause, GroupByExpr, GroupByWithModifier, IdentWithAlias, IlikeSelectItem,

InputFormatClause, Interpolate, InterpolateExpr, Join, JoinConstraint, JoinOperator,

JsonTableColumn, JsonTableColumnErrorHandling, JsonTableNamedColumn, JsonTableNestedColumn,

LateralView, LockClause, LockType, MatchRecognizePattern, MatchRecognizeSymbol, Measure,

NamedWindowDefinition, NamedWindowExpr, NonBlock, Offset, OffsetRows, OpenJsonTableColumn,

OrderBy, OrderByExpr, PivotValueSource, ProjectionSelect, Query, RenameSelectItem,

RepetitionQuantifier, ReplaceSelectElement, ReplaceSelectItem, RowsPerMatch, Select,

SelectInto, SelectItem, SetExpr, SetOperator, SetQuantifier, Setting, SymbolDefinition, Table,

TableAlias, TableAliasColumnDef, TableFactor, TableFunctionArgs, TableSample,

TableSampleBucket, TableSampleKind, TableSampleMethod, TableSampleModifier,

TableSampleQuantity, TableSampleSeed, TableSampleSeedModifier, TableSampleUnit, TableVersion,

TableWithJoins, Top, TopQuantity, UpdateTableFromKind, ValueTableMode, Values,

WildcardAdditionalOptions, With, WithFill,

};

pub use self::trigger::{

TriggerEvent, TriggerExecBody, TriggerExecBodyType, TriggerObject, TriggerPeriod,

TriggerReferencing, TriggerReferencingType,

};

pub use self::value::{

escape_double_quote_string, escape_quoted_string, DateTimeField, DollarQuotedString,

TrimWhereField, Value,

};

use crate::ast::helpers::stmt_data_loading::{

DataLoadingOptions, StageLoadSelectItem, StageParamsObject,

};

#[cfg(feature = "visitor")]

pub use visitor::*;

mod data_type;

mod dcl;

mod ddl;

mod dml;

pub mod helpers;

mod operator;

mod query;

mod spans;

pub use spans::Spanned;

mod trigger;

mod value;

#[cfg(feature = "visitor")]

mod visitor;

pub struct DisplaySeparated<'a, T>

where

T: fmt::Display,

{

slice: &'a [T],

sep: &'static str,

}

impl<T> fmt::Display for DisplaySeparated<'_, T>

where

T: fmt::Display,

{

fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {

let mut delim = "";

for t in self.slice {

write!(f, "{delim}")?;

delim = self.sep;

write!(f, "{t}")?;

}

Ok(())

}

}

pub fn display_separated<'a, T>(slice: &'a [T], sep: &'static str) -> DisplaySeparated<'a, T>

where

T: fmt::Display,

{

DisplaySeparated { slice, sep }

}

pub fn display_comma_separated<T>(slice: &[T]) -> DisplaySeparated<'_, T>

where

T: fmt::Display,

{

DisplaySeparated { slice, sep: ", " }

}

/// An identifier, decomposed into its value or character data and the quote style.

#[derive(Debug, Clone, PartialOrd, Ord)]

#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]

#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]

pub struct Ident {

/// The value of the identifier without quotes.

pub value: String,

/// The starting quote if any. Valid quote characters are the single quote,

/// double quote, backtick, and opening square bracket.

pub quote_style: Option<char>,

/// The span of the identifier in the original SQL string.

pub span: Span,

}

impl PartialEq for Ident {

fn eq(&self, other: &Self) -> bool {

let Ident {

value,

quote_style,

// exhaustiveness check; we ignore spans in comparisons

span: _,

} = self;

value == &other.value && quote_style == &other.quote_style

}

}

impl core::hash::Hash for Ident {

fn hash<H: hash::Hasher>(&self, state: &mut H) {

let Ident {

value,

quote_style,

// exhaustiveness check; we ignore spans in hashes

span: _,

} = self;

value.hash(state);

quote_style.hash(state);

}

}

impl Eq for Ident {}

impl Ident {

/// Create a new identifier with the given value and no quotes and an empty span.

pub fn new<S>(value: S) -> Self

where

S: Into<String>,

{

Ident {

value: value.into(),

quote_style: None,

span: Span::empty(),

}

}

/// Create a new quoted identifier with the given quote and value. This function

/// panics if the given quote is not a valid quote character.

pub fn with_quote<S>(quote: char, value: S) -> Self

where

S: Into<String>,

{

assert!(quote == '\'' || quote == '"' || quote == '`' || quote == '[');

Ident {

value: value.into(),

quote_style: Some(quote),

span: Span::empty(),

}

}

pub fn with_span<S>(span: Span, value: S) -> Self

where

S: Into<String>,

{

Ident {

value: value.into(),

quote_style: None,

span,

}

}

pub fn with_quote_and_span<S>(quote: char, span: Span, value: S) -> Self

where

S: Into<String>,

{

assert!(quote == '\'' || quote == '"' || quote == '`' || quote == '[');

Ident {

value: value.into(),

quote_style: Some(quote),

span,

}

}

}

impl From<&str> for Ident {

fn from(value: &str) -> Self {

Ident {

value: value.to_string(),

quote_style: None,

span: Span::empty(),

}

}

}

impl fmt::Display for Ident {

fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {

match self.quote_style {

Some(q) if q == '"' || q == '\'' || q == '`' => {

let escaped = value::escape_quoted_string(&self.value, q);

write!(f, "{q}{escaped}{q}")

}

Some('[') => write!(f, "[{}]", self.value),

None => f.write_str(&self.value),

_ => panic!("unexpected quote style"),

}

}

}

/// A name of a table, view, custom type, etc., possibly multi-part, i.e. db.schema.obj

#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]

#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]

#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]

pub struct ObjectName(pub Vec<Ident>);

impl fmt::Display for ObjectName {

fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {

write!(f, "{}", display_separated(&self.0, "."))

}

}

/// Represents an Array Expression, either

/// `ARRAY[..]`, or `[..]`

#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]

#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]

#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]

pub struct Array {

/// The list of expressions between brackets

pub elem: Vec<Expr>,

/// `true` for `ARRAY[..]`, `false` for `[..]`

pub named: bool,

}

impl fmt::Display for Array {

fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {

write!(

f,

"{}[{}]",

if self.named { "ARRAY" } else { "" },

display_comma_separated(&self.elem)

)

}

}

/// Represents an INTERVAL expression, 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`.

#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]

#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]

#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]

pub struct Interval {

pub value: Box<Expr>,

pub leading_field: Option<DateTimeField>,

pub leading_precision: Option<u64>,

pub last_field: Option<DateTimeField>,

/// The seconds precision can be specified in SQL source as

/// `INTERVAL '__' SECOND(_, x)` (in which case the `leading_field`

/// will be `Second` and the `last_field` will be `None`),

/// or as `__ TO SECOND(x)`.

pub fractional_seconds_precision: Option<u64>,

}

impl fmt::Display for Interval {

fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {

let value = self.value.as_ref();

match (

&self.leading_field,

self.leading_precision,

self.fractional_seconds_precision,

) {

(

Some(DateTimeField::Second),

Some(leading_precision),

Some(fractional_seconds_precision),

) => {

// When the leading field is SECOND, the parser guarantees that

// the last field is None.

assert!(self.last_field.is_none());

write!(

f,

"INTERVAL {value} SECOND ({leading_precision}, {fractional_seconds_precision})"

)

}

_ => {

write!(f, "INTERVAL {value}")?;

if let Some(leading_field) = &self.leading_field {

write!(f, " {leading_field}")?;

}

if let Some(leading_precision) = self.leading_precision {

write!(f, " ({leading_precision})")?;

}

if let Some(last_field) = &self.last_field {

write!(f, " TO {last_field}")?;

}

if let Some(fractional_seconds_precision) = self.fractional_seconds_precision {

write!(f, " ({fractional_seconds_precision})")?;

}

Ok(())

}

}

}

}

/// A field definition within a struct

///

/// [bigquery]: https://cloud.google.com/bigquery/docs/reference/standard-sql/data-types#struct_type

#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]

#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]

#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]

pub struct StructField {

pub field_name: Option<Ident>,

pub field_type: DataType,

}

impl fmt::Display for StructField {

fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

if let Some(name) = &self.field_name {

write!(f, "{name} {}", self.field_type)

} else {

write!(f, "{}", self.field_type)

}

}

}

/// A field definition within a union

///

/// [duckdb]: https://duckdb.org/docs/sql/data_types/union.html

#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]

#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]

#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]

pub struct UnionField {

pub field_name: Ident,

pub field_type: DataType,

}

impl fmt::Display for UnionField {

fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

write!(f, "{} {}", self.field_name, self.field_type)

}

}

/// A dictionary field within a dictionary.

///

/// [duckdb]: https://duckdb.org/docs/sql/data_types/struct#creating-structs

#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]

#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]

#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]

pub struct DictionaryField {

pub key: Ident,

pub value: Box<Expr>,

}

impl fmt::Display for DictionaryField {

fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

write!(f, "{}: {}", self.key, self.value)

}

}

/// Represents a Map expression.

#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]

#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]

#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]

pub struct Map {

pub entries: Vec<MapEntry>,

}

impl Display for Map {

fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {

write!(f, "MAP {{{}}}", display_comma_separated(&self.entries))

}

}

/// A map field within a map.

///

/// [duckdb]: https://duckdb.org/docs/sql/data_types/map.html#creating-maps

#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]

#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]

#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]

pub struct MapEntry {

pub key: Box<Expr>,

pub value: Box<Expr>,

}

impl fmt::Display for MapEntry {

fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

write!(f, "{}: {}", self.key, self.value)

}

}

/// Options for `CAST` / `TRY_CAST`

/// BigQuery: <https://cloud.google.com/bigquery/docs/reference/standard-sql/format-elements#formatting_syntax>

#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]

#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]

#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]

pub enum CastFormat {

Value(Value),

ValueAtTimeZone(Value, Value),

}

/// An element of a JSON path.

#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]

#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]

#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]

pub enum JsonPathElem {

/// Accesses an object field using dot notation, e.g. `obj:foo.bar.baz`.

///

/// See <https://docs.snowflake.com/en/user-guide/querying-semistructured#dot-notation>.

Dot { key: String, quoted: bool },

/// Accesses an object field or array element using bracket notation,

/// e.g. `obj['foo']`.

///

/// See <https://docs.snowflake.com/en/user-guide/querying-semistructured#bracket-notation>.

Bracket { key: Expr },

}

/// A JSON path.

///

/// See <https://docs.snowflake.com/en/user-guide/querying-semistructured>.

/// See <https://docs.databricks.com/en/sql/language-manual/sql-ref-json-path-expression.html>.

#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]

#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]

#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]

pub struct JsonPath {

pub path: Vec<JsonPathElem>,

}

impl fmt::Display for JsonPath {

fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

for (i, elem) in self.path.iter().enumerate() {

match elem {

JsonPathElem::Dot { key, quoted } => {

if i == 0 {

write!(f, ":")?;

} else {

write!(f, ".")?;

}

if *quoted {

write!(f, "\"{}\"", escape_double_quote_string(key))?;

} else {

write!(f, "{key}")?;

}

}

JsonPathElem::Bracket { key } => {

write!(f, "[{key}]")?;

}

}

}

Ok(())

}

}

/// The syntax used for in a cast expression.

#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]

#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]

#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]

pub enum CastKind {

/// The standard SQL cast syntax, e.g. `CAST(<expr> as <datatype>)`

Cast,

/// A cast that returns `NULL` on failure, e.g. `TRY_CAST(<expr> as <datatype>)`.

///

/// See <https://docs.snowflake.com/en/sql-reference/functions/try_cast>.

/// See <https://learn.microsoft.com/en-us/sql/t-sql/functions/try-cast-transact-sql>.

TryCast,

/// A cast that returns `NULL` on failure, bigQuery-specific , e.g. `SAFE_CAST(<expr> as <datatype>)`.

///

/// See <https://cloud.google.com/bigquery/docs/reference/standard-sql/functions-and-operators#safe_casting>.

SafeCast,

/// `<expr> :: <datatype>`

DoubleColon,

}

/// `EXTRACT` syntax variants.

///

/// In Snowflake dialect, the `EXTRACT` expression can support either the `from` syntax

/// or the comma syntax.

///

/// See <https://docs.snowflake.com/en/sql-reference/functions/extract>

#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]

#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]

#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]

pub enum ExtractSyntax {

/// `EXTRACT( <date_or_time_part> FROM <date_or_time_expr> )`

From,

/// `EXTRACT( <date_or_time_part> , <date_or_timestamp_expr> )`

Comma,

}

/// The syntax used in a CEIL or FLOOR expression.

///

/// The `CEIL/FLOOR(<datetime value expression> TO <time unit>)` is an Amazon Kinesis Data Analytics extension.

/// See <https://docs.aws.amazon.com/kinesisanalytics/latest/sqlref/sql-reference-ceil.html> for

/// details.

///

/// Other dialects either support `CEIL/FLOOR( <expr> [, <scale>])` format or just

/// `CEIL/FLOOR(<expr>)`.

#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]

#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]

#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]

pub enum CeilFloorKind {

/// `CEIL( <expr> TO <DateTimeField>)`

DateTimeField(DateTimeField),

/// `CEIL( <expr> [, <scale>])`

Scale(Value),

}

/// An SQL expression of any type.

///

/// # Semantics / Type Checking

///

/// The parser does not distinguish between expressions of different types

/// (e.g. boolean vs string). The caller is responsible for detecting and

/// validating types as necessary (for example `WHERE 1` vs `SELECT 1=1`)

/// See the [README.md] for more details.

///

/// [README.md]: https://github.com/apache/datafusion-sqlparser-rs/blob/main/README.md#syntax-vs-semantics

///

/// # Equality and Hashing Does not Include Source Locations

///

/// The `Expr` type implements `PartialEq` and `Eq` based on the semantic value

/// of the expression (not bitwise comparison). This means that `Expr` instances

/// that are semantically equivalent but have different spans (locations in the

/// source tree) will compare as equal.

#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]

#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]

#[cfg_attr(

feature = "visitor",

derive(Visit, VisitMut),

visit(with = "visit_expr")

)]

pub enum Expr {

/// Identifier e.g. table name or column name

Identifier(Ident),

/// Multi-part identifier, e.g. `table_alias.column` or `schema.table.col`

CompoundIdentifier(Vec<Ident>),

/// Multi-part expression access.

///

/// This structure represents an access chain in structured / nested types

/// such as maps, arrays, and lists:

/// - Array

/// - A 1-dim array `a[1]` will be represented like:

/// `CompoundFieldAccess(Ident('a'), vec![Subscript(1)]`

/// - A 2-dim array `a[1][2]` will be represented like:

/// `CompoundFieldAccess(Ident('a'), vec![Subscript(1), Subscript(2)]`

/// - Map or Struct (Bracket-style)

/// - A map `a['field1']` will be represented like:

/// `CompoundFieldAccess(Ident('a'), vec![Subscript('field')]`

/// - A 2-dim map `a['field1']['field2']` will be represented like:

/// `CompoundFieldAccess(Ident('a'), vec![Subscript('field1'), Subscript('field2')]`

/// - Struct (Dot-style) (only effect when the chain contains both subscript and expr)

/// - A struct access `a[field1].field2` will be represented like:

/// `CompoundFieldAccess(Ident('a'), vec![Subscript('field1'), Ident('field2')]`

/// - If a struct access likes `a.field1.field2`, it will be represented by CompoundIdentifier([a, field1, field2])

CompoundFieldAccess {

root: Box<Expr>,

access_chain: Vec<AccessExpr>,

},

/// 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>.

JsonAccess {

/// The value being queried.

value: Box<Expr>,

/// The path to the data to extract.

path: JsonPath,

},

/// CompositeAccess eg: SELECT foo(bar).z, (information_schema._pg_expandarray(array['i','i'])).n

CompositeAccess {

expr: Box<Expr>,

key: Ident,

},

/// `IS FALSE` operator

IsFalse(Box<Expr>),

/// `IS NOT FALSE` operator

IsNotFalse(Box<Expr>),

/// `IS TRUE` operator

IsTrue(Box<Expr>),

/// `IS NOT TRUE` operator

IsNotTrue(Box<Expr>),

/// `IS NULL` operator

IsNull(Box<Expr>),

/// `IS NOT NULL` operator

IsNotNull(Box<Expr>),

/// `IS UNKNOWN` operator

IsUnknown(Box<Expr>),

/// `IS NOT UNKNOWN` operator

IsNotUnknown(Box<Expr>),

/// `IS DISTINCT FROM` operator

IsDistinctFrom(Box<Expr>, Box<Expr>),

/// `IS NOT DISTINCT FROM` operator

IsNotDistinctFrom(Box<Expr>, Box<Expr>),

/// `[ NOT ] IN (val1, val2, ...)`

InList {

expr: Box<Expr>,

list: Vec<Expr>,

negated: bool,

},

/// `[ NOT ] IN (SELECT ...)`

InSubquery {

expr: Box<Expr>,

subquery: Box<Query>,

negated: bool,

},

/// `[ NOT ] IN UNNEST(array_expression)`

InUnnest {

expr: Box<Expr>,

array_expr: Box<Expr>,

negated: bool,

},

/// `<expr> [ NOT ] BETWEEN <low> AND <high>`

Between {

expr: Box<Expr>,

negated: bool,

low: Box<Expr>,

high: Box<Expr>,

},

/// Binary operation e.g. `1 + 1` or `foo > bar`

BinaryOp {

left: Box<Expr>,

op: BinaryOperator,

right: Box<Expr>,

},

/// `[NOT] LIKE <pattern> [ESCAPE <escape_character>]`

Like {

negated: bool,

// Snowflake supports the ANY keyword to match against a list of patterns

// https://docs.snowflake.com/en/sql-reference/functions/like_any

any: bool,

expr: Box<Expr>,

pattern: Box<Expr>,

escape_char: Option<String>,

},

/// `ILIKE` (case-insensitive `LIKE`)

ILike {

negated: bool,

// Snowflake supports the ANY keyword to match against a list of patterns

// https://docs.snowflake.com/en/sql-reference/functions/like_any

any: bool,

expr: Box<Expr>,

pattern: Box<Expr>,

escape_char: Option<String>,

},

/// SIMILAR TO regex

SimilarTo {

negated: bool,

expr: Box<Expr>,

pattern: Box<Expr>,

escape_char: Option<String>,

},

/// MySQL: RLIKE regex or REGEXP regex

RLike {

negated: bool,

expr: Box<Expr>,

pattern: Box<Expr>,

// true for REGEXP, false for RLIKE (no difference in semantics)

regexp: bool,

},

/// `ANY` operation e.g. `foo > ANY(bar)`, comparison operator is one of `[=, >, <, =>, =<, !=]`

/// <https://docs.snowflake.com/en/sql-reference/operators-subquery#all-any>

AnyOp {

left: Box<Expr>,

compare_op: BinaryOperator,

right: Box<Expr>,

// ANY and SOME are synonymous: https://docs.cloudera.com/cdw-runtime/cloud/using-hiveql/topics/hive_comparison_predicates.html

is_some: bool,

},

/// `ALL` operation e.g. `foo > ALL(bar)`, comparison operator is one of `[=, >, <, =>, =<, !=]`

/// <https://docs.snowflake.com/en/sql-reference/operators-subquery#all-any>

AllOp {

left: Box<Expr>,

compare_op: BinaryOperator,

right: Box<Expr>,

},

/// Unary operation e.g. `NOT foo`

UnaryOp {

op: UnaryOperator,

expr: Box<Expr>,

},

/// CONVERT a value to a different data type or character encoding. e.g. `CONVERT(foo USING utf8mb4)`

Convert {

/// CONVERT (false) or TRY_CONVERT (true)

/// <https://learn.microsoft.com/en-us/sql/t-sql/functions/try-convert-transact-sql?view=sql-server-ver16>

is_try: bool,

/// The expression to convert

expr: Box<Expr>,

/// The target data type

data_type: Option<DataType>,

/// The target character encoding

charset: Option<ObjectName>,

/// whether the target comes before the expr (MSSQL syntax)

target_before_value: bool,

/// How to translate the expression.

///

/// [MSSQL]: https://learn.microsoft.com/en-us/sql/t-sql/functions/cast-and-convert-transact-sql?view=sql-server-ver16#style

styles: Vec<Expr>,

},

/// `CAST` an expression to a different data type e.g. `CAST(foo AS VARCHAR(123))`

Cast {

kind: CastKind,

expr: Box<Expr>,

data_type: DataType,

// Optional CAST(string_expression AS type FORMAT format_string_expression) as used by BigQuery

// https://cloud.google.com/bigquery/docs/reference/standard-sql/format-elements#formatting_syntax

format: Option<CastFormat>,

},

/// AT a timestamp to a different timezone e.g. `FROM_UNIXTIME(0) AT TIME ZONE 'UTC-06:00'`

AtTimeZone {

timestamp: Box<Expr>,

time_zone: Box<Expr>,

},

/// Extract a field from a timestamp e.g. `EXTRACT(MONTH FROM foo)`

/// Or `EXTRACT(MONTH, foo)`

///

/// Syntax:

/// ```sql

/// EXTRACT(DateTimeField FROM <expr>) | EXTRACT(DateTimeField, <expr>)

/// ```

Extract {

field: DateTimeField,

syntax: ExtractSyntax,

expr: Box<Expr>,

},

/// ```sql

/// CEIL(<expr> [TO DateTimeField])

/// ```

/// ```sql

/// CEIL( <input_expr> [, <scale_expr> ] )

/// ```

Ceil {

expr: Box<Expr>,

field: CeilFloorKind,

},

/// ```sql

/// FLOOR(<expr> [TO DateTimeField])

/// ```

/// ```sql

/// FLOOR( <input_expr> [, <scale_expr> ] )

///

Floor {

expr: Box<Expr>,

field: CeilFloorKind,

},

/// ```sql

/// POSITION(<expr> in <expr>)

/// ```

Position {

expr: Box<Expr>,

r#in: Box<Expr>,

},

/// ```sql

/// SUBSTRING(<expr> [FROM <expr>] [FOR <expr>])

/// ```

/// or

/// ```sql

/// SUBSTRING(<expr>, <expr>, <expr>)

/// ```

Substring {

expr: Box<Expr>,

substring_from: Option<Box<Expr>>,

substring_for: Option<Box<Expr>>,

/// false if the expression is represented using the `SUBSTRING(expr [FROM start] [FOR len])` syntax

/// true if the expression is represented using the `SUBSTRING(expr, start, len)` syntax

/// This flag is used for formatting.

special: bool,

},

/// ```sql

/// TRIM([BOTH | LEADING | TRAILING] [<expr> FROM] <expr>)

/// TRIM(<expr>)

/// TRIM(<expr>, [, characters]) -- only Snowflake or Bigquery

/// ```

Trim {

expr: Box<Expr>,

// ([BOTH | LEADING | TRAILING]

trim_where: Option<TrimWhereField>,

trim_what: Option<Box<Expr>>,

trim_characters: Option<Vec<Expr>>,

},

/// ```sql

/// OVERLAY(<expr> PLACING <expr> FROM <expr>[ FOR <expr> ]

/// ```

Overlay {

expr: Box<Expr>,

overlay_what: Box<Expr>,

overlay_from: Box<Expr>,

overlay_for: Option<Box<Expr>>,

},

/// `expr COLLATE collation`

Collate {

expr: Box<Expr>,

collation: ObjectName,

},

/// Nested expression e.g. `(foo > bar)` or `(1)`

Nested(Box<Expr>),

/// A literal value, such as string, number, date or NULL

Value(Value),

/// <https://dev.mysql.com/doc/refman/8.0/en/charset-introducer.html>

IntroducedString {

introducer: String,

value: Value,

},

/// 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).

TypedString {

data_type: DataType,

value: String,

},

/// Scalar function call e.g. `LEFT(foo, 5)`

Function(Function),

/// Arbitrary expr method call

///

/// Syntax:

///

/// `<arbitrary-expr>.<function-call>.<function-call-expr>...`

///

/// > `arbitrary-expr` can be any expression including a function call.

///

/// Example:

///

/// ```sql

/// SELECT (SELECT ',' + name FROM sys.objects FOR XML PATH(''), TYPE).value('.','NVARCHAR(MAX)')

/// SELECT CONVERT(XML,'<Book>abc</Book>').value('.','NVARCHAR(MAX)').value('.','NVARCHAR(MAX)')

/// ```

///

/// (mssql): <https://learn.microsoft.com/en-us/sql/t-sql/xml/xml-data-type-methods?view=sql-server-ver16>

Method(Method),

/// `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>

Case {

operand: Option<Box<Expr>>,

conditions: Vec<Expr>,

results: Vec<Expr>,

else_result: Option<Box<Expr>>,

},

/// An exists expression `[ NOT ] EXISTS(SELECT ...)`, used in expressions like

/// `WHERE [ NOT ] EXISTS (SELECT ...)`.

Exists {

subquery: Box<Query>,

negated: bool,

},

/// A parenthesized subquery `(SELECT ...)`, used in expression like

/// `SELECT (subquery) AS x` or `WHERE (subquery) = x`

Subquery(Box<Query>),

/// The `GROUPING SETS` expr.

GroupingSets(Vec<Vec<Expr>>),

/// The `CUBE` expr.

Cube(Vec<Vec<Expr>>),

/// The `ROLLUP` expr.

Rollup(Vec<Vec<Expr>>),

/// ROW / TUPLE a single value, such as `SELECT (1, 2)`

Tuple(Vec<Expr>),

/// `Struct` literal expression

/// Syntax:

/// ```sql

/// STRUCT<[field_name] field_type, ...>( expr1 [, ... ])

///

/// [BigQuery](https://cloud.google.com/bigquery/docs/reference/standard-sql/data-types#struct_type)

/// [Databricks](https://docs.databricks.com/en/sql/language-manual/functions/struct.html)

/// ```

Struct {

/// Struct values.

values: Vec<Expr>,

/// Struct field definitions.

fields: Vec<StructField>,

},

/// `BigQuery` specific: An named expression in a typeless struct [1]

///

/// Syntax

/// ```sql

/// 1 AS A

/// ```

/// [1]: https://cloud.google.com/bigquery/docs/reference/standard-sql/data-types#struct_type

Named {

expr: Box<Expr>,

name: Ident,

},

/// `DuckDB` specific `Struct` literal expression [1]

///

/// Syntax:

/// ```sql

/// syntax: {'field_name': expr1[, ... ]}

/// ```

/// [1]: https://duckdb.org/docs/sql/data_types/struct#creating-structs

Dictionary(Vec<DictionaryField>),

/// `DuckDB` specific `Map` literal expression [1]

///

/// Syntax:

/// ```sql

/// syntax: Map {key1: value1[, ... ]}

/// ```

/// [1]: https://duckdb.org/docs/sql/data_types/map#creating-maps

Map(Map),

/// An array expression e.g. `ARRAY[1, 2]`

Array(Array),

/// An interval expression e.g. `INTERVAL '1' YEAR`

Interval(Interval),

/// `MySQL` specific text search function [(1)].

///

/// Syntax:

/// ```sql

/// MATCH (<col>, <col>, ...) AGAINST (<expr> [<search modifier>])

///

/// <col> = CompoundIdentifier

/// <expr> = String literal

/// ```

/// [(1)]: https://dev.mysql.com/doc/refman/8.0/en/fulltext-search.html#function_match

MatchAgainst {

/// `(<col>, <col>, ...)`.

columns: Vec<Ident>,

/// `<expr>`.

match_value: Value,

/// `<search modifier>`

opt_search_modifier: Option<SearchModifier>,

},

Wildcard(AttachedToken),

/// Qualified wildcard, e.g. `alias.*` or `schema.table.*`.

/// (Same caveats apply to `QualifiedWildcard` as to `Wildcard`.)

QualifiedWildcard(ObjectName, AttachedToken),

/// Some dialects support an older syntax for outer joins where columns are

/// marked with the `(+)` operator in the WHERE clause, for example:

///

/// ```sql

/// SELECT t1.c1, t2.c2 FROM t1, t2 WHERE t1.c1 = t2.c2 (+)

/// ```

///

/// which is equivalent to

///

/// ```sql

/// 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>.