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

string::{String, ToString},

vec::Vec,

};

use core::fmt::{self, Display};

#[cfg(feature = "serde")]

use serde::{Deserialize, Serialize};

use sqlparser_derive::DFConvert;

#[cfg(feature = "visitor")]

use sqlparser_derive::{Visit, VisitMut};

pub use self::data_type::{

CharLengthUnits, CharacterLength, DataType, ExactNumberInfo, TimezoneInfo,

};

pub use self::ddl::{

AlterColumnOperation, AlterIndexOperation, AlterTableOperation, ColumnDef, ColumnOption,

ColumnOptionDef, GeneratedAs, IndexType, KeyOrIndexDisplay, ReferentialAction, TableConstraint,

UserDefinedTypeCompositeAttributeDef, UserDefinedTypeRepresentation,

};

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

pub use self::query::{

Cte, Distinct, ExceptSelectItem, ExcludeSelectItem, Fetch, IdentWithAlias, Join,

JoinConstraint, JoinOperator, LateralView, LockClause, LockType, NamedWindowDefinition,

NonBlock, Offset, OffsetRows, OrderByExpr, Query, RenameSelectItem, ReplaceSelectElement,

ReplaceSelectItem, Select, SelectInto, SelectItem, SetExpr, SetOperator, SetQuantifier, Table,

TableAlias, TableFactor, TableWithJoins, Top, Values, WildcardAdditionalOptions, With,

};

pub use self::value::{

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

pub mod helpers;

mod operator;

mod query;

mod value;

#[cfg(feature = "visitor")]

mod visitor;

pub trait Convert<T>

where

Self: Into<T>,

{

#[inline(always)]

fn convert(value: Self) -> T {

Self::into(value)

}

#[inline(always)]

#[allow(clippy::boxed_local)]

fn convert_box(value: Box<Self>) -> Box<T> {

Box::new(Self::convert(*value))

}

#[inline(always)]

fn convert_vec(value: Vec<Self>) -> Vec<T> {

value.into_iter().map(Self::convert).collect()

}

#[inline(always)]

fn convert_vec_box(value: Vec<Box<Self>>) -> Vec<Box<T>> {

value.into_iter().map(Self::convert_box).collect()

}

#[inline(always)]

fn convert_matrix(value: Vec<Vec<Self>>) -> Vec<Vec<T>> {

value.into_iter().map(Self::convert_vec).collect()

}

#[inline(always)]

fn convert_option(value: Option<Self>) -> Option<T> {

value.map(Self::convert)

}

#[inline(always)]

fn convert_option_box(value: Option<Box<Self>>) -> Option<Box<T>> {

value.map(Self::convert_box)

}

#[inline(always)]

fn convert_option_vec(value: Option<Vec<Self>>) -> Option<Vec<T>> {

value.map(Self::convert_vec)

}

}

impl<T, V> Convert<T> for V where V: Into<T> {}

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

#[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(q) if q == '[' => 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, DFConvert)]

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

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

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

}

}

}

}

/// JsonOperator

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

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

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

pub enum JsonOperator {

/// -> keeps the value as json

Arrow,

/// ->> keeps the value as text or int.

LongArrow,

/// #> Extracts JSON sub-object at the specified path

HashArrow,

/// #>> Extracts JSON sub-object at the specified path as text

HashLongArrow,

/// : Colon is used by Snowflake (Which is similar to LongArrow)

Colon,

/// jsonb @> jsonb -> boolean: Test whether left json contains the right json

AtArrow,

/// jsonb <@ jsonb -> boolean: Test whether right json contains the left json

ArrowAt,

/// jsonb #- text[] -> jsonb: Deletes the field or array element at the specified

/// path, where path elements can be either field keys or array indexes.

HashMinus,

/// jsonb @? jsonpath -> boolean: Does JSON path return any item for the specified

/// JSON value?

AtQuestion,

/// jsonb @@ jsonpath → boolean: Returns the result of a JSON path predicate check

/// for the specified JSON value. Only the first item of the result is taken into

/// account. If the result is not Boolean, then NULL is returned.

AtAt,

}

impl fmt::Display for JsonOperator {

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

match self {

JsonOperator::Arrow => {

write!(f, "->")

}

JsonOperator::LongArrow => {

write!(f, "->>")

}

JsonOperator::HashArrow => {

write!(f, "#>")

}

JsonOperator::HashLongArrow => {

write!(f, "#>>")

}

JsonOperator::Colon => {

write!(f, ":")

}

JsonOperator::AtArrow => {

write!(f, "@>")

}

JsonOperator::ArrowAt => write!(f, "<@"),

JsonOperator::HashMinus => write!(f, "#-"),

JsonOperator::AtQuestion => write!(f, "@?"),

JsonOperator::AtAt => write!(f, "@@"),

}

}

}

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

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

/// JSON access (postgres) eg: data->'tags'

JsonAccess {

left: Box<Expr>,

operator: JsonOperator,

right: Box<Expr>,

},

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

},

/// LIKE

Like {

negated: bool,

expr: Box<Expr>,

pattern: Box<Expr>,

escape_char: Option<char>,

},

/// ILIKE (case-insensitive LIKE)

ILike {

negated: bool,

expr: Box<Expr>,

pattern: Box<Expr>,

escape_char: Option<char>,

},

/// SIMILAR TO regex

SimilarTo {

negated: bool,

expr: Box<Expr>,

pattern: Box<Expr>,

escape_char: Option<char>,

},

/// Any operation e.g. `1 ANY (1)` or `foo > ANY(bar)`, It will be wrapped in the right side of BinaryExpr

AnyOp(Box<Expr>),

/// ALL operation e.g. `1 ALL (1)` or `foo > ALL(bar)`, It will be wrapped in the right side of BinaryExpr

AllOp(Box<Expr>),

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

UnaryOp { op: UnaryOperator, expr: Box<Expr> },

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

Cast {

expr: Box<Expr>,

data_type: DataType,

},

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

// this differs from CAST in the choice of how to implement invalid conversions

TryCast {

expr: Box<Expr>,

data_type: DataType,

},

/// SAFE_CAST an expression to a different data type e.g. `SAFE_CAST(foo AS FLOAT64)`

// only available for BigQuery: https://cloud.google.com/bigquery/docs/reference/standard-sql/functions-and-operators#safe_casting

// this works the same as `TRY_CAST`

SafeCast {

expr: Box<Expr>,

data_type: DataType,

},

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

},

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

/// ```

Substring {

expr: Box<Expr>,

substring_from: Option<Box<Expr>>,

substring_for: Option<Box<Expr>>,

},

/// ```sql

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

/// TRIM(<expr>)

/// ```

Trim {

expr: Box<Expr>,

// ([BOTH | LEADING | TRAILING]

trim_where: Option<TrimWhereField>,

trim_what: Option<Box<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<Expr> },

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

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

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

},

}

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}")?;

for k in keys {

match k {

k @ Expr::Value(Value::Number(_, _)) => write!(f, "[{k}]")?,

Expr::Value(Value::SingleQuotedString(s)) => write!(f, "[\"{s}\"]")?,

_ => write!(f, "[{k}]")?,

}

}

Ok(())

}

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::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(expr) => write!(f, "ANY({expr})"),

Expr::AllOp(expr) => write!(f, "ALL({expr})"),

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::Cast { expr, data_type } => write!(f, "CAST({expr} AS {data_type})"),

Expr::TryCast { expr, data_type } => write!(f, "TRY_CAST({expr} AS {data_type})"),

Expr::SafeCast { expr, data_type } => write!(f, "SAFE_CAST({expr} AS {data_type})"),

Expr::Extract { field, expr } => write!(f, "EXTRACT({field} FROM {expr})"),

Expr::Ceil { expr, field } => {

if field == &DateTimeField::NoDateTime {

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

} else {

write!(f, "CEIL({expr} TO {field})")

}

}

Expr::Floor { expr, field } => {

if field == &DateTimeField::NoDateTime {

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

} else {

write!(f, "FLOOR({expr} TO {field})")

}

}

Expr::Position { expr, r#in } => write!(f, "POSITION({expr} IN {in})"),

Expr::Collate { expr, collation } => write!(f, "{expr} COLLATE {collation}"),

Expr::Nested(ast) => write!(f, "({ast})"),

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

Expr::IntroducedString { introducer, value } => write!(f, "{introducer} {value}"),

Expr::TypedString { data_type, value } => {

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

write!(f, " '{}'", &value::escape_single_quote_string(value))

}

Expr::Function(fun) => write!(f, "{fun}"),

Expr::AggregateExpressionWithFilter { expr, filter } => {

write!(f, "{expr} FILTER (WHERE {filter})")

}

Expr::Case {

operand,

conditions,

results,

else_result,

} => {

write!(f, "CASE")?;

if let Some(operand) = operand {

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

}

for (c, r) in conditions.iter().zip(results) {

write!(f, " WHEN {c} THEN {r}")?;

}

if let Some(else_result) = else_result {

write!(f, " ELSE {else_result}")?;

}

write!(f, " END")

}

Expr::Exists { subquery, negated } => write!(

f,

"{}EXISTS ({})",

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

subquery

),

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

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

Expr::ListAgg(listagg) => write!(f, "{listagg}"),

Expr::ArrayAgg(arrayagg) => write!(f, "{arrayagg}"),

Expr::GroupingSets(sets) => {

write!(f, "GROUPING SETS (")?;

let mut sep = "";

for set in sets {

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

sep = ", ";

write!(f, "({})", display_comma_separated(set))?;

}

write!(f, ")")

}

Expr::Cube(sets) => {

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

let mut sep = "";

for set in sets {

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

sep = ", ";

if set.len() == 1 {

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

} else {

write!(f, "({})", display_comma_separated(set))?;

}

}

write!(f, ")")

}

Expr::Rollup(sets) => {

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

let mut sep = "";

for set in sets {

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

sep = ", ";

if set.len() == 1 {

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

} else {

write!(f, "({})", display_comma_separated(set))?;

}

}

write!(f, ")")

}

Expr::Substring {

expr,

substring_from,

substring_for,

} => {

write!(f, "SUBSTRING({expr}")?;

if let Some(from_part) = substring_from {

write!(f, " FROM {from_part}")?;

}

if let Some(for_part) = substring_for {

write!(f, " FOR {for_part}")?;

}

write!(f, ")")

}

Expr::Overlay {

expr,

overlay_what,

overlay_from,

overlay_for,

} => {

write!(

f,

"OVERLAY({expr} PLACING {overlay_what} FROM {overlay_from}"

)?;

if let Some(for_part) = overlay_for {

write!(f, " FOR {for_part}")?;

}

write!(f, ")")

}

Expr::IsDistinctFrom(a, b) => write!(f, "{a} IS DISTINCT FROM {b}"),

Expr::IsNotDistinctFrom(a, b) => write!(f, "{a} IS NOT DISTINCT FROM {b}"),

Expr::Trim {

expr,

trim_where,

trim_what,

} => {

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

if let Some(ident) = trim_where {

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

}

if let Some(trim_char) = trim_what {

write!(f, "{trim_char} FROM {expr}")?;

} else {

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

}

write!(f, ")")

}

Expr::Tuple(exprs) => {

write!(f, "({})", display_comma_separated(exprs))

}

Expr::ArrayIndex { obj, indexes } => {

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

for i in indexes {

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

}

Ok(())

}

Expr::Array(set) => {

write!(f, "{set}")

}

Expr::JsonAccess {

left,

operator,

right,

} => {

if operator == &JsonOperator::Colon {

write!(f, "{left}{operator}{right}")

} else {

write!(f, "{left} {operator} {right}")

}

}

Expr::CompositeAccess { expr, key } => {

write!(f, "{expr}.{key}")

}

Expr::AtTimeZone {

timestamp,

time_zone,

} => {

write!(f, "{timestamp} AT TIME ZONE '{time_zone}'")

}

Expr::Interval(interval) => {

write!(f, "{interval}")

}

Expr::MatchAgainst {

columns,

match_value: match_expr,

opt_search_modifier,

} => {

write!(f, "MATCH ({}) AGAINST ", display_comma_separated(columns),)?;

if let Some(search_modifier) = opt_search_modifier {

write!(f, "({match_expr} {search_modifier})")?;

} else {

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

}

Ok(())

}

}

}

}

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

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

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

pub enum WindowType {

WindowSpec(WindowSpec),

NamedWindow(Ident),

}

impl Display for WindowType {

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

match self {

WindowType::WindowSpec(spec) => write!(f, "({})", spec),

WindowType::NamedWindow(name) => write!(f, "{}", name),

}

}

}

/// A window specification (i.e. `OVER (PARTITION BY .. ORDER BY .. etc.)`)

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

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

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

pub struct WindowSpec {

pub partition_by: Vec<Expr>,

pub order_by: Vec<OrderByExpr>,

pub window_frame: Option<WindowFrame>,