// Licensed 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 core::fmt::{self, Display};

#[cfg(feature = "serde")]

use serde::{Deserialize, Serialize};

#[cfg(feature = "visitor")]

use sqlparser_derive::{Visit, VisitMut};

pub use self::data_type::{

ArrayElemTypeDef, CharLengthUnits, CharacterLength, DataType, ExactNumberInfo, TimezoneInfo,

};

pub use self::dcl::{AlterRoleOperation, ResetConfig, RoleOption, SetConfigValue};

pub use self::ddl::{

AlterColumnOperation, AlterIndexOperation, AlterTableOperation, ColumnDef, ColumnOption,

ColumnOptionDef, ConstraintCharacteristics, DeferrableInitial, GeneratedAs,

GeneratedExpressionMode, IndexOption, IndexType, KeyOrIndexDisplay, Partition, ProcedureParam,

ReferentialAction, TableConstraint, UserDefinedTypeCompositeAttributeDef,

UserDefinedTypeRepresentation, ViewColumnDef,

};

pub use self::dml::{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,

GroupByExpr, IdentWithAlias, IlikeSelectItem, Join, JoinConstraint, JoinOperator,

JsonTableColumn, JsonTableColumnErrorHandling, LateralView, LockClause, LockType,

MatchRecognizePattern, MatchRecognizeSymbol, Measure, NamedWindowDefinition, NamedWindowExpr,

NonBlock, Offset, OffsetRows, OrderByExpr, Query, RenameSelectItem, RepetitionQuantifier,

ReplaceSelectElement, ReplaceSelectItem, RowsPerMatch, Select, SelectInto, SelectItem, SetExpr,

SetOperator, SetQuantifier, SymbolDefinition, Table, TableAlias, TableFactor, TableVersion,

TableWithJoins, Top, TopQuantity, ValueTableMode, Values, WildcardAdditionalOptions, With,

};

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 value;

#[cfg(feature = "visitor")]

mod visitor;

struct DisplaySeparated<'a, T>

where

T: fmt::Display,

{

slice: &'a [T],

sep: &'static str,

}

impl<'a, T> fmt::Display for DisplaySeparated<'a, 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(())

}

}

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

where

T: fmt::Display,

{

DisplaySeparated { slice, sep }

}

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, PartialEq, PartialOrd, Eq, Ord, Hash)]

#[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>,

}

impl Ident {

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

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

where

S: Into<String>,

{

Ident {

value: value.into(),

quote_style: None,

}

}

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

}

}

}

impl From<&str> for Ident {

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

Ident {

value: value.to_string(),

quote_style: None,

}

}

}

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

}

}

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

}

/// Represents the syntax/style used in a map access.

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

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

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

pub enum MapAccessSyntax {

/// Access using bracket notation. `mymap[mykey]`

Bracket,

/// Access using period notation. `mymap.mykey`

Period,

}

/// Expression used to access a value in a nested structure.

///

/// Example: `SAFE_OFFSET(0)` in

/// ```sql

/// SELECT mymap[SAFE_OFFSET(0)];

/// ```

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

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

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

pub struct MapAccessKey {

pub key: Expr,

pub syntax: MapAccessSyntax,

}

impl fmt::Display for MapAccessKey {

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

match self.syntax {

MapAccessSyntax::Bracket => write!(f, "[{}]", self.key),

MapAccessSyntax::Period => write!(f, ".{}", self.key),

}

}

}

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

}

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

#[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>),

/// 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 (postgres) eg: SELECT (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,

expr: Box<Expr>,

pattern: Box<Expr>,

escape_char: Option<String>,

},

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

ILike {

negated: 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 `[=, >, <, =>, =<, !=]`

AnyOp {

left: Box<Expr>,

compare_op: BinaryOperator,

right: Box<Expr>,

},

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

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 {

/// 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: String,

},

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

///

/// Syntax:

/// ```sql

/// EXTRACT(DateTimeField FROM <expr>)

/// ```

Extract {

field: DateTimeField,

expr: Box<Expr>,

},

/// ```sql

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

/// ```

Ceil {

expr: Box<Expr>,

field: DateTimeField,

},

/// ```sql

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

/// ```

Floor {

expr: Box<Expr>,

field: DateTimeField,

},

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

},

/// 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`](Self::ArrayIndex) or [`MapAccess`](Self::MapAccess)

/// <https://clickhouse.com/docs/en/sql-reference/data-types/map/>

MapAccess {

column: Box<Expr>,

keys: Vec<MapAccessKey>,

},

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

Function(Function),

/// Aggregate function with filter

AggregateExpressionWithFilter {

expr: Box<Expr>,

filter: Box<Expr>,

},

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

/// An array subquery constructor, e.g. `SELECT ARRAY(SELECT 1 UNION SELECT 2)`

ArraySubquery(Box<Query>),

/// The `LISTAGG` function `SELECT LISTAGG(...) WITHIN GROUP (ORDER BY ...)`

ListAgg(ListAgg),

/// The `ARRAY_AGG` function `SELECT ARRAY_AGG(... ORDER BY ...)`

ArrayAgg(ArrayAgg),

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

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

/// Syntax:

/// ```sql

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

/// ```

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

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>),

/// An array index expression e.g. `(ARRAY[1, 2])[1]` or `(current_schemas(FALSE))[1]`

ArrayIndex {

obj: Box<Expr>,

indexes: Vec<Expr>,

},

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

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

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

QualifiedWildcard(ObjectName),

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

OuterJoin(Box<Expr>),

/// A reference to the prior level in a CONNECT BY clause.

Prior(Box<Expr>),

}

impl fmt::Display for CastFormat {

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

match self {

CastFormat::Value(v) => write!(f, "{v}"),

CastFormat::ValueAtTimeZone(v, tz) => write!(f, "{v} AT TIME ZONE {tz}"),

}

}

}

impl fmt::Display for Expr {

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

match self {

Expr::Identifier(s) => write!(f, "{s}"),

Expr::MapAccess { column, keys } => {

write!(f, "{column}{}", display_separated(keys, ""))

}

Expr::Wildcard => f.write_str("*"),

Expr::QualifiedWildcard(prefix) => write!(f, "{}.*", prefix),

Expr::CompoundIdentifier(s) => write!(f, "{}", display_separated(s, ".")),

Expr::IsTrue(ast) => write!(f, "{ast} IS TRUE"),

Expr::IsNotTrue(ast) => write!(f, "{ast} IS NOT TRUE"),

Expr::IsFalse(ast) => write!(f, "{ast} IS FALSE"),

Expr::IsNotFalse(ast) => write!(f, "{ast} IS NOT FALSE"),

Expr::IsNull(ast) => write!(f, "{ast} IS NULL"),

Expr::IsNotNull(ast) => write!(f, "{ast} IS NOT NULL"),

Expr::IsUnknown(ast) => write!(f, "{ast} IS UNKNOWN"),

Expr::IsNotUnknown(ast) => write!(f, "{ast} IS NOT UNKNOWN"),

Expr::InList {

expr,

list,

negated,

} => write!(

f,

"{} {}IN ({})",

expr,

if *negated { "NOT " } else { "" },

display_comma_separated(list)

),

Expr::InSubquery {

expr,

subquery,

negated,

} => write!(

f,

"{} {}IN ({})",

expr,

if *negated { "NOT " } else { "" },

subquery

),

Expr::InUnnest {

expr,

array_expr,

negated,

} => write!(

f,

"{} {}IN UNNEST({})",

expr,

if *negated { "NOT " } else { "" },

array_expr

),

Expr::Between {

expr,

negated,

low,

high,

} => write!(

f,

"{} {}BETWEEN {} AND {}",

expr,

if *negated { "NOT " } else { "" },

low,

high

),

Expr::BinaryOp { left, op, right } => write!(f, "{left} {op} {right}"),

Expr::Like {

negated,

expr,

pattern,

escape_char,

} => match escape_char {

Some(ch) => write!(

f,

"{} {}LIKE {} ESCAPE '{}'",

expr,

if *negated { "NOT " } else { "" },

pattern,

ch

),

_ => write!(

f,

"{} {}LIKE {}",

expr,

if *negated { "NOT " } else { "" },

pattern

),

},

Expr::ILike {

negated,

expr,

pattern,

escape_char,

} => match escape_char {

Some(ch) => write!(

f,

"{} {}ILIKE {} ESCAPE '{}'",

expr,

if *negated { "NOT " } else { "" },

pattern,

ch

),

_ => write!(

f,

"{} {}ILIKE {}",

expr,

if *negated { "NOT " } else { "" },

pattern

),

},

Expr::RLike {

negated,

expr,

pattern,

regexp,

} => write!(

f,

"{} {}{} {}",

expr,

if *negated { "NOT " } else { "" },

if *regexp { "REGEXP" } else { "RLIKE" },

pattern

),

Expr::SimilarTo {

negated,

expr,

pattern,

escape_char,

} => match escape_char {

Some(ch) => write!(

f,

"{} {}SIMILAR TO {} ESCAPE '{}'",

expr,

if *negated { "NOT " } else { "" },

pattern,

ch

),

_ => write!(

f,

"{} {}SIMILAR TO {}",

expr,

if *negated { "NOT " } else { "" },

pattern

),

},

Expr::AnyOp {

left,

compare_op,

right,

} => write!(f, "{left} {compare_op} ANY({right})"),

Expr::AllOp {

left,

compare_op,

right,

} => write!(f, "{left} {compare_op} ALL({right})"),

Expr::UnaryOp { op, expr } => {

if op == &UnaryOperator::PGPostfixFactorial {

write!(f, "{expr}{op}")

} else if op == &UnaryOperator::Not {

write!(f, "{op} {expr}")

} else {

write!(f, "{op}{expr}")

}

}

Expr::Convert {

expr,

target_before_value,

data_type,

charset,

styles,

} => {

write!(f, "CONVERT(")?;

if let Some(data_type) = data_type {

if let Some(charset) = charset {

write!(f, "{expr}, {data_type} CHARACTER SET {charset}")

} else if *target_before_value {

write!(f, "{data_type}, {expr}")

} else {

write!(f, "{expr}, {data_type}")

}

} else if let Some(charset) = charset {

write!(f, "{expr} USING {charset}")

} else {

write!(f, "{expr}") // This should never happen

}?;