databend_common_ast/ast/statements/

table.rs

// Copyright 2021 Datafuse Labs
//
// 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.

use std::collections::BTreeMap;
use std::fmt::Display;
use std::fmt::Formatter;
use std::time::Duration;

use derive_visitor::Drive;
use derive_visitor::DriveMut;

use crate::ast::CreateOption;
use crate::ast::Expr;
use crate::ast::Identifier;
use crate::ast::Query;
use crate::ast::TableIndexType;
use crate::ast::TableReference;
use crate::ast::TimeTravelPoint;
use crate::ast::TypeName;
use crate::ast::UriLocation;
use crate::ast::quote::QuotedString;
use crate::ast::statements::constraint::ConstraintType;
use crate::ast::statements::show::ShowLimit;
use crate::ast::write_comma_separated_list;
use crate::ast::write_comma_separated_string_map;
use crate::ast::write_dot_separated_list;
use crate::ast::write_space_separated_string_map;

#[derive(Debug, Clone, PartialEq, Drive, DriveMut)]
pub struct ShowTablesStmt {
    pub catalog: Option<Identifier>,
    pub database: Option<Identifier>,
    pub full: bool,
    pub limit: Option<ShowLimit>,
    pub with_history: bool,
}

impl Display for ShowTablesStmt {
    fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
        write!(f, "SHOW")?;
        if self.full {
            write!(f, " FULL")?;
        }
        write!(f, " TABLES")?;
        if self.with_history {
            write!(f, " HISTORY")?;
        }
        if let Some(database) = &self.database {
            write!(f, " FROM ")?;
            if let Some(catalog) = &self.catalog {
                write!(f, "{catalog}.",)?;
            }
            write!(f, "{database}")?;
        }
        if let Some(limit) = &self.limit {
            write!(f, " {limit}")?;
        }

        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Drive, DriveMut)]
pub struct ShowCreateTableStmt {
    pub catalog: Option<Identifier>,
    pub database: Option<Identifier>,
    pub table: Identifier,
    pub with_quoted_ident: bool,
}

impl Display for ShowCreateTableStmt {
    fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
        write!(f, "SHOW CREATE TABLE ")?;
        write_dot_separated_list(
            f,
            self.catalog
                .iter()
                .chain(&self.database)
                .chain(Some(&self.table)),
        )?;
        if self.with_quoted_ident {
            write!(f, " WITH QUOTED_IDENTIFIERS")?
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Drive, DriveMut)]
pub struct ShowTablesStatusStmt {
    pub database: Option<Identifier>,
    pub limit: Option<ShowLimit>,
}

impl Display for ShowTablesStatusStmt {
    fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
        write!(f, "SHOW TABLE STATUS")?;
        if let Some(database) = &self.database {
            write!(f, " FROM {database}")?;
        }
        if let Some(limit) = &self.limit {
            write!(f, " {limit}")?;
        }

        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Drive, DriveMut)]
pub struct ShowDropTablesStmt {
    pub database: Option<Identifier>,
    pub limit: Option<ShowLimit>,
}

impl Display for ShowDropTablesStmt {
    fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
        write!(f, "SHOW DROP TABLES")?;
        if let Some(database) = &self.database {
            write!(f, " FROM {database}")?;
        }
        if let Some(limit) = &self.limit {
            write!(f, " {limit}")?;
        }

        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Drive, DriveMut)]
pub enum ClusterType {
    Linear,
    Hilbert,
}

impl Display for ClusterType {
    fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
        match self {
            ClusterType::Linear => write!(f, "LINEAR"),
            ClusterType::Hilbert => write!(f, "HILBERT"),
        }
    }
}

impl std::str::FromStr for ClusterType {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s.to_lowercase().as_str() {
            "linear" => Ok(ClusterType::Linear),
            "hilbert" => Ok(ClusterType::Hilbert),
            _ => Err(()),
        }
    }
}

#[derive(Debug, Clone, PartialEq, Drive, DriveMut)]
pub struct ClusterOption {
    pub cluster_type: ClusterType,
    pub cluster_exprs: Vec<Expr>,
}

impl Display for ClusterOption {
    fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
        write!(f, "CLUSTER BY {}(", self.cluster_type)?;
        write_comma_separated_list(f, &self.cluster_exprs)?;
        write!(f, ")")
    }
}

#[derive(Debug, Clone, PartialEq, Drive, DriveMut)]
pub struct CreateTableStmt {
    pub create_option: CreateOption,
    pub catalog: Option<Identifier>,
    pub database: Option<Identifier>,
    pub table: Identifier,
    pub source: Option<CreateTableSource>,
    pub engine: Option<Engine>,
    pub uri_location: Option<UriLocation>,
    pub cluster_by: Option<ClusterOption>,
    pub table_options: BTreeMap<String, String>,
    pub iceberg_table_partition: Option<Vec<Identifier>>,
    pub table_properties: Option<BTreeMap<String, String>>,
    pub as_query: Option<Box<Query>>,
    pub table_type: TableType,
}

#[derive(Debug, Clone, PartialEq, Drive, DriveMut)]
pub enum TableType {
    Normal,
    Transient,
    Temporary,
}

impl Display for CreateTableStmt {
    fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
        write!(f, "CREATE")?;
        if let CreateOption::CreateOrReplace = self.create_option {
            write!(f, " OR REPLACE")?;
        }
        match self.table_type {
            TableType::Normal => {}
            TableType::Transient => write!(f, " TRANSIENT")?,
            TableType::Temporary => write!(f, " TEMPORARY")?,
        };
        write!(f, " TABLE")?;
        if let CreateOption::CreateIfNotExists = self.create_option {
            write!(f, " IF NOT EXISTS")?;
        }
        write!(f, " ")?;
        write_dot_separated_list(
            f,
            self.catalog
                .iter()
                .chain(&self.database)
                .chain(Some(&self.table)),
        )?;

        if let Some(source) = &self.source {
            write!(f, " {source}")?;
        }

        if let Some(engine) = &self.engine {
            write!(f, " ENGINE = {engine}")?;
        }

        if let Some(uri_location) = &self.uri_location {
            write!(f, " {uri_location}")?;
        }

        if let Some(cluster_by) = &self.cluster_by {
            write!(f, " {cluster_by}")?;
        }

        // Format table options
        if !self.table_options.is_empty() {
            write!(f, " ")?;
            write_space_separated_string_map(f, &self.table_options)?;
        }

        if let Some(iceberg_table_partition) = &self.iceberg_table_partition {
            write!(f, " PARTITION BY(")?;
            write_comma_separated_list(f, iceberg_table_partition)?;
            write!(f, ")")?;
        }

        if let Some(table_properties) = &self.table_properties {
            write!(f, " PROPERTIES(")?;
            write_space_separated_string_map(f, table_properties)?;
            write!(f, ")")?;
        }

        if let Some(as_query) = &self.as_query {
            write!(f, " AS {as_query}")?;
        }

        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Drive, DriveMut)]
pub struct AttachTableStmt {
    pub catalog: Option<Identifier>,
    pub database: Option<Identifier>,
    pub table: Identifier,
    pub columns_opt: Option<Vec<Identifier>>,
    pub uri_location: UriLocation,
}

impl Display for AttachTableStmt {
    fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
        write!(f, "ATTACH TABLE ")?;
        write_dot_separated_list(
            f,
            self.catalog
                .iter()
                .chain(&self.database)
                .chain(Some(&self.table)),
        )?;

        if let Some(cols) = &self.columns_opt {
            write!(f, " (")?;
            write_comma_separated_list(f, cols.iter())?;
            write!(f, ")")?;
        }

        write!(f, " {}", self.uri_location)?;

        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Drive, DriveMut)]
pub enum CreateTableSource {
    Columns {
        columns: Vec<ColumnDefinition>,
        opt_table_indexes: Option<Vec<TableIndexDefinition>>,
        opt_column_constraints: Option<Vec<ConstraintDefinition>>,
        opt_table_constraints: Option<Vec<ConstraintDefinition>>,
    },
    Like {
        catalog: Option<Identifier>,
        database: Option<Identifier>,
        table: Identifier,
    },
}

impl Display for CreateTableSource {
    fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
        match self {
            // `column_constraints` are not displayed, but are displayed by column
            CreateTableSource::Columns {
                columns,
                opt_table_indexes,
                opt_column_constraints: _column_constraints,
                opt_table_constraints: table_constraints,
            } => {
                write!(f, "(")?;
                write_comma_separated_list(f, columns)?;
                if let Some(table_indexes) = opt_table_indexes {
                    write!(f, ", ")?;
                    write_comma_separated_list(f, table_indexes)?;
                }
                if let Some(constraints) = table_constraints {
                    write!(f, ", ")?;
                    write_comma_separated_list(f, constraints)?;
                }
                write!(f, ")")
            }
            CreateTableSource::Like {
                catalog,
                database,
                table,
            } => {
                write!(f, "LIKE ")?;
                write_dot_separated_list(f, catalog.iter().chain(database).chain(Some(table)))
            }
        }
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Drive, DriveMut)]
pub struct DescribeTableStmt {
    pub catalog: Option<Identifier>,
    pub database: Option<Identifier>,
    pub table: Identifier,
}

impl Display for DescribeTableStmt {
    fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
        write!(f, "DESCRIBE ")?;
        write_dot_separated_list(
            f,
            self.catalog
                .iter()
                .chain(self.database.iter().chain(Some(&self.table))),
        )
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Drive, DriveMut)]
pub struct DropTableStmt {
    pub if_exists: bool,
    pub catalog: Option<Identifier>,
    pub database: Option<Identifier>,
    pub table: Identifier,
    pub all: bool,
}

impl Display for DropTableStmt {
    fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
        write!(f, "DROP TABLE ")?;
        if self.if_exists {
            write!(f, "IF EXISTS ")?;
        }
        write_dot_separated_list(
            f,
            self.catalog
                .iter()
                .chain(&self.database)
                .chain(Some(&self.table)),
        )?;
        if self.all {
            write!(f, " ALL")?;
        }

        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Drive, DriveMut)]
pub struct UndropTableStmt {
    pub catalog: Option<Identifier>,
    pub database: Option<Identifier>,
    pub table: Identifier,
}

impl Display for UndropTableStmt {
    fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
        write!(f, "UNDROP TABLE ")?;
        write_dot_separated_list(
            f,
            self.catalog
                .iter()
                .chain(&self.database)
                .chain(Some(&self.table)),
        )
    }
}

#[derive(Debug, Clone, PartialEq, Drive, DriveMut)]
pub struct AlterTableStmt {
    pub if_exists: bool,
    pub table_reference: TableReference,
    pub action: AlterTableAction,
}

impl Display for AlterTableStmt {
    fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
        write!(f, "ALTER TABLE")?;
        if self.if_exists {
            write!(f, " IF EXISTS")?;
        }
        write!(f, " {}", self.table_reference)?;
        write!(f, " {}", self.action)
    }
}

#[derive(Debug, Clone, PartialEq, Drive, DriveMut)]
pub enum SnapshotRefType {
    Branch,
    Tag,
}

impl Display for SnapshotRefType {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        match self {
            SnapshotRefType::Branch => write!(f, "BRANCH"),
            SnapshotRefType::Tag => write!(f, "TAG"),
        }
    }
}

#[derive(Debug, Clone, PartialEq, Drive, DriveMut)]
pub enum AlterTableAction {
    RenameTable {
        new_table: Identifier,
    },
    SwapWith {
        target_table: Identifier,
    },
    AddColumn {
        column: ColumnDefinition,
        option: AddColumnOption,
    },
    RenameColumn {
        old_column: Identifier,
        new_column: Identifier,
    },
    ModifyTableComment {
        new_comment: String,
    },
    ModifyColumn {
        action: ModifyColumnAction,
    },
    AddConstraint {
        constraint: ConstraintDefinition,
    },
    DropConstraint {
        constraint_name: Identifier,
    },
    // (column name id, policy name)
    AddRowAccessPolicy {
        columns: Vec<Identifier>,
        policy: Identifier,
    },
    // policy name
    DropRowAccessPolicy {
        policy: Identifier,
    },
    DropAllRowAccessPolicies,
    DropColumn {
        column: Identifier,
    },
    AlterTableClusterKey {
        cluster_by: ClusterOption,
    },
    DropTableClusterKey,
    ReclusterTable {
        is_final: bool,
        selection: Option<Expr>,
        limit: Option<u64>,
    },
    FlashbackTo {
        point: TimeTravelPoint,
    },
    SetOptions {
        set_options: BTreeMap<String, String>,
    },
    UnsetOptions {
        targets: Vec<Identifier>,
    },
    RefreshTableCache,
    ModifyConnection {
        new_connection: BTreeMap<String, String>,
    },
    CreateTableRef {
        ref_type: SnapshotRefType,
        ref_name: Identifier,
        travel_point: Option<TimeTravelPoint>,
        #[drive(skip)]
        retain: Option<Duration>,
    },
    DropTableRef {
        ref_type: SnapshotRefType,
        ref_name: Identifier,
    },
}

impl Display for AlterTableAction {
    fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
        match self {
            AlterTableAction::SetOptions { set_options } => {
                write!(f, "SET OPTIONS (")?;
                write_comma_separated_string_map(f, set_options)?;
                write!(f, ")")?;
            }
            AlterTableAction::RenameTable { new_table } => {
                write!(f, "RENAME TO {new_table}")?;
            }
            AlterTableAction::SwapWith { target_table } => {
                write!(f, "SWAP WITH {target_table}")?;
            }
            AlterTableAction::ModifyTableComment { new_comment } => {
                write!(f, "COMMENT={}", QuotedString(new_comment, '\''))?;
            }
            AlterTableAction::RenameColumn {
                old_column,
                new_column,
            } => {
                write!(f, "RENAME COLUMN {old_column} TO {new_column}")?;
            }
            AlterTableAction::AddColumn { column, option } => {
                write!(f, "ADD COLUMN {column}{option}")?;
            }
            AlterTableAction::AddConstraint { constraint } => {
                write!(f, "ADD {}", constraint)?;
            }
            AlterTableAction::DropConstraint { constraint_name } => {
                write!(f, "DROP CONSTRAINT {}", constraint_name)?;
            }
            AlterTableAction::ModifyColumn { action } => {
                write!(f, "MODIFY COLUMN {action}")?;
            }
            AlterTableAction::DropColumn { column } => {
                write!(f, "DROP COLUMN {column}")?;
            }
            AlterTableAction::AlterTableClusterKey { cluster_by } => {
                write!(f, "{cluster_by}")?;
            }
            AlterTableAction::DropTableClusterKey => {
                write!(f, "DROP CLUSTER KEY")?;
            }
            AlterTableAction::ReclusterTable {
                is_final,
                selection,
                limit,
            } => {
                write!(f, "RECLUSTER")?;
                if *is_final {
                    write!(f, " FINAL")?;
                }
                if let Some(conditions) = selection {
                    write!(f, " WHERE {conditions}")?;
                }
                if let Some(limit) = limit {
                    write!(f, " LIMIT {limit}")?;
                }
            }
            AlterTableAction::FlashbackTo { point } => {
                write!(f, "FLASHBACK TO {}", point)?;
            }
            AlterTableAction::UnsetOptions {
                targets: unset_targets,
            } => {
                write!(f, "UNSET OPTIONS ")?;
                if unset_targets.len() == 1 {
                    write!(f, "{}", unset_targets[0])?;
                } else {
                    write!(f, "(")?;
                    write_comma_separated_list(f, unset_targets)?;
                    write!(f, ")")?;
                }
            }
            AlterTableAction::RefreshTableCache => {
                write!(f, "REFRESH CACHE")?;
            }
            AlterTableAction::ModifyConnection { new_connection } => {
                write!(f, "CONNECTION=(")?;
                write_space_separated_string_map(f, new_connection)?;
                write!(f, ")")?;
            }
            AlterTableAction::AddRowAccessPolicy { columns, policy } => {
                write!(f, "ADD ROW ACCESS POLICY {} ON (", policy)?;
                write_comma_separated_list(f, columns)?;
                write!(f, ")")?
            }
            AlterTableAction::DropRowAccessPolicy { policy } => {
                write!(f, "DROP ROW ACCESS POLICY {}", policy)?
            }
            AlterTableAction::DropAllRowAccessPolicies => {
                write!(f, "DROP ALL ROW ACCESS POLICIES")?
            }
            AlterTableAction::CreateTableRef {
                ref_type,
                ref_name,
                travel_point,
                retain,
            } => {
                write!(f, "CREATE {ref_type} {ref_name}")?;
                if let Some(travel_point) = travel_point {
                    write!(f, " AT {travel_point}")?;
                }
                if let Some(retain) = retain {
                    let days = Duration::from_secs(60 * 60 * 24);
                    if retain >= &days {
                        let days = retain.as_secs() / (60 * 60 * 24);
                        write!(f, " RETAIN {days} DAYS ")?;
                    } else {
                        let seconds = retain.as_secs();
                        write!(f, " RETAIN {seconds} SECONDS ")?;
                    }
                }
            }
            AlterTableAction::DropTableRef { ref_type, ref_name } => {
                write!(f, "DROP {ref_type} {ref_name}")?;
            }
        };
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Drive, DriveMut)]
pub enum AddColumnOption {
    End,
    First,
    After(Identifier),
}

impl Display for AddColumnOption {
    fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
        match self {
            AddColumnOption::First => write!(f, " FIRST"),
            AddColumnOption::After(ident) => write!(f, " AFTER {ident}"),
            AddColumnOption::End => Ok(()),
        }
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Drive, DriveMut)]
pub struct RenameTableStmt {
    pub if_exists: bool,
    pub catalog: Option<Identifier>,
    pub database: Option<Identifier>,
    pub table: Identifier,
    pub new_catalog: Option<Identifier>,
    pub new_database: Option<Identifier>,
    pub new_table: Identifier,
}

impl Display for RenameTableStmt {
    fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
        write!(f, "RENAME TABLE ")?;
        if self.if_exists {
            write!(f, "IF EXISTS ")?;
        }
        write_dot_separated_list(
            f,
            self.catalog
                .iter()
                .chain(&self.database)
                .chain(Some(&self.table)),
        )?;
        write!(f, " TO ")?;
        write_dot_separated_list(
            f,
            self.new_catalog
                .iter()
                .chain(&self.new_database)
                .chain(Some(&self.new_table)),
        )
    }
}

#[derive(Debug, Clone, PartialEq, Drive, DriveMut)]
pub struct TruncateTableStmt {
    pub catalog: Option<Identifier>,
    pub database: Option<Identifier>,
    pub table: Identifier,
}

impl Display for TruncateTableStmt {
    fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
        write!(f, "TRUNCATE TABLE ")?;
        write_dot_separated_list(
            f,
            self.catalog
                .iter()
                .chain(&self.database)
                .chain(Some(&self.table)),
        )?;
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Drive, DriveMut)]
pub struct VacuumTableStmt {
    pub catalog: Option<Identifier>,
    pub database: Option<Identifier>,
    pub table: Identifier,
    pub option: VacuumTableOption,
}

impl Display for VacuumTableStmt {
    fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
        write!(f, "VACUUM TABLE ")?;
        write_dot_separated_list(
            f,
            self.catalog
                .iter()
                .chain(&self.database)
                .chain(Some(&self.table)),
        )?;
        write!(f, " {}", &self.option)?;

        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Drive, DriveMut)]
pub struct VacuumDropTableStmt {
    pub catalog: Option<Identifier>,
    pub database: Option<Identifier>,
    pub option: VacuumDropTableOption,
}

impl Display for VacuumDropTableStmt {
    fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
        write!(f, "VACUUM DROP TABLE ")?;
        if self.catalog.is_some() || self.database.is_some() {
            write!(f, "FROM ")?;
            write_dot_separated_list(f, self.catalog.iter().chain(&self.database))?;
            write!(f, " ")?;
        }
        write!(f, "{}", &self.option)?;

        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Drive, DriveMut)]
pub struct VacuumTemporaryFiles {
    pub limit: Option<u64>,
    #[drive(skip)]
    pub retain: Option<Duration>,
}

impl Display for crate::ast::VacuumTemporaryFiles {
    fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
        write!(f, "VACUUM TEMPORARY FILES")?;
        if let Some(retain) = &self.retain {
            let days = Duration::from_secs(60 * 60 * 24);
            if retain >= &days {
                let days = retain.as_secs() / (60 * 60 * 24);
                write!(f, " RETAIN {days} DAYS")?;
            } else {
                let seconds = retain.as_secs();
                write!(f, " RETAIN {seconds} SECONDS")?;
            }
        }

        if let Some(limit) = &self.limit {
            write!(f, " LIMIT {limit}")?;
        }

        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Drive, DriveMut)]
pub struct OptimizeTableStmt {
    pub catalog: Option<Identifier>,
    pub database: Option<Identifier>,
    pub table: Identifier,
    pub action: OptimizeTableAction,
    pub limit: Option<u64>,
}

impl Display for OptimizeTableStmt {
    fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
        write!(f, "OPTIMIZE TABLE ")?;
        write_dot_separated_list(
            f,
            self.catalog
                .iter()
                .chain(&self.database)
                .chain(Some(&self.table)),
        )?;
        write!(f, " {}", &self.action)?;
        if let Some(limit) = self.limit {
            write!(f, " LIMIT {limit}")?;
        }

        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Drive, DriveMut)]
pub struct AnalyzeTableStmt {
    pub catalog: Option<Identifier>,
    pub database: Option<Identifier>,
    pub table: Identifier,
    pub no_scan: bool,
}

impl Display for AnalyzeTableStmt {
    fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
        write!(f, "ANALYZE TABLE ")?;
        write_dot_separated_list(
            f,
            self.catalog
                .iter()
                .chain(&self.database)
                .chain(Some(&self.table)),
        )?;
        if self.no_scan {
            write!(f, " NOSCAN")?;
        }

        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Drive, DriveMut)]
pub struct ExistsTableStmt {
    pub catalog: Option<Identifier>,
    pub database: Option<Identifier>,
    pub table: Identifier,
}

impl Display for ExistsTableStmt {
    fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
        write!(f, "EXISTS TABLE ")?;
        write_dot_separated_list(
            f,
            self.catalog
                .iter()
                .chain(&self.database)
                .chain(Some(&self.table)),
        )
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Drive, DriveMut)]
pub enum Engine {
    Null,
    Memory,
    Fuse,
    View,
    Random,
    Iceberg,
    Delta,
}

impl Display for Engine {
    fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
        match self {
            Engine::Null => write!(f, "NULL"),
            Engine::Memory => write!(f, "MEMORY"),
            Engine::Fuse => write!(f, "FUSE"),
            Engine::View => write!(f, "VIEW"),
            Engine::Random => write!(f, "RANDOM"),
            Engine::Iceberg => write!(f, "ICEBERG"),
            Engine::Delta => write!(f, "DELTA"),
        }
    }
}

impl From<&str> for Engine {
    fn from(s: &str) -> Self {
        match s.to_lowercase().as_str() {
            "null" => Engine::Null,
            "memory" => Engine::Memory,
            "fuse" => Engine::Fuse,
            "view" => Engine::View,
            "random" => Engine::Random,
            "iceberg" => Engine::Iceberg,
            "delta" => Engine::Delta,
            _ => unreachable!("invalid engine: {}", s),
        }
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Drive, DriveMut)]
pub enum CompactTarget {
    Block,
    Segment,
}

#[derive(Debug, Clone, PartialEq, Drive, DriveMut)]
pub struct VacuumTableOption {
    // Some(true) means dry run with summary option
    pub dry_run: Option<bool>,
}

impl Display for VacuumTableOption {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        if let Some(summary) = self.dry_run {
            write!(f, "DRY RUN")?;
            if summary {
                write!(f, " SUMMARY")?;
            }
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Drive, DriveMut)]
pub struct VacuumDropTableOption {
    // Some(true) means dry run with summary option
    pub dry_run: Option<bool>,
    pub limit: Option<usize>,
}

impl Display for VacuumDropTableOption {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        if let Some(summary) = self.dry_run {
            write!(f, "DRY RUN")?;
            if summary {
                write!(f, " SUMMARY")?;
            }
        }
        if let Some(limit) = self.limit {
            write!(f, " LIMIT {}", limit)?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Drive, DriveMut)]
pub enum OptimizeTableAction {
    All,
    Purge { before: Option<TimeTravelPoint> },
    Compact { target: CompactTarget },
}

impl Display for OptimizeTableAction {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        match self {
            OptimizeTableAction::All => write!(f, "ALL"),
            OptimizeTableAction::Purge { before } => {
                write!(f, "PURGE")?;
                if let Some(point) = before {
                    write!(f, " BEFORE {}", point)?;
                }
                Ok(())
            }
            OptimizeTableAction::Compact { target } => {
                match target {
                    CompactTarget::Block => {
                        write!(f, "COMPACT")?;
                    }
                    CompactTarget::Segment => {
                        write!(f, "COMPACT SEGMENT")?;
                    }
                }
                Ok(())
            }
        }
    }
}

#[derive(Debug, Clone, PartialEq, Drive, DriveMut)]
pub enum ColumnExpr {
    Default(Box<Expr>),
    Virtual(Box<Expr>),
    Stored(Box<Expr>),
    AutoIncrement {
        start: u64,
        step: i64,
        is_ordered: bool,
    },
}

impl Display for ColumnExpr {
    fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
        match self {
            ColumnExpr::Default(expr) => {
                write!(f, " DEFAULT {expr}")?;
            }
            ColumnExpr::Virtual(expr) => {
                write!(f, " AS ({expr}) VIRTUAL")?;
            }
            ColumnExpr::Stored(expr) => {
                write!(f, " AS ({expr}) STORED")?;
            }
            ColumnExpr::AutoIncrement {
                start,
                step,
                is_ordered,
            } => {
                write!(f, " AUTOINCREMENT ({}, {}) ", start, step)?;
                if *is_ordered {
                    write!(f, "ORDER")?;
                } else {
                    write!(f, "NOORDER")?;
                }
            }
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Drive, DriveMut)]
pub enum NullableConstraint {
    Null,
    NotNull,
}

#[derive(Debug, Clone, PartialEq, Drive, DriveMut)]
pub struct ColumnDefinition {
    pub name: Identifier,
    pub data_type: TypeName,
    pub expr: Option<ColumnExpr>,
    pub check: Option<Expr>,
    pub comment: Option<String>,
}

impl Display for ColumnDefinition {
    fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
        write!(f, "{} {}", self.name, self.data_type)?;
        if let Some(expr) = &self.expr {
            write!(f, "{expr}")?;
        }
        if let Some(check_expr) = &self.check {
            write!(f, " CHECK ({check_expr})")?;
        }
        if let Some(comment) = &self.comment {
            write!(f, " COMMENT {}", QuotedString(comment, '\''))?;
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Drive, DriveMut)]
pub struct TableIndexDefinition {
    pub index_name: Identifier,
    pub index_type: TableIndexType,
    pub columns: Vec<Identifier>,
    pub sync_creation: bool,
    pub index_options: BTreeMap<String, String>,
}

impl Display for TableIndexDefinition {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        if !self.sync_creation {
            write!(f, "ASYNC ")?;
        }
        write!(f, "{} INDEX", self.index_type)?;
        write!(f, " {}", self.index_name)?;
        write!(f, " (")?;
        write_comma_separated_list(f, &self.columns)?;
        write!(f, ")")?;

        if !self.index_options.is_empty() {
            write!(f, " ")?;
            write_space_separated_string_map(f, &self.index_options)?;
        }

        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Drive, DriveMut)]
pub struct ConstraintDefinition {
    pub name: Option<Identifier>,
    pub constraint_type: ConstraintType,
}

impl Display for ConstraintDefinition {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        if let Some(constraint_name) = &self.name {
            write!(f, "CONSTRAINT {} ", constraint_name)?;
        }
        write!(f, "{}", self.constraint_type)
    }
}

#[derive(Debug, Clone, PartialEq, Drive, DriveMut)]
pub enum CreateDefinition {
    Column(ColumnDefinition),
    TableIndex(TableIndexDefinition),
    Constraint(ConstraintDefinition),
}

impl Display for CreateDefinition {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        match self {
            CreateDefinition::Column(column_def) => {
                write!(f, "{}", column_def)?;
            }
            CreateDefinition::TableIndex(table_index_def) => {
                write!(f, "{}", table_index_def)?;
            }
            CreateDefinition::Constraint(constraint_def) => {
                write!(f, "{}", constraint_def)?;
            }
        }
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Drive, DriveMut)]
pub struct ColumnComment {
    pub name: Identifier,
    pub comment: String,
}

impl Display for ColumnComment {
    fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
        write!(
            f,
            "{} COMMENT {}",
            self.name,
            QuotedString(&self.comment, '\'')
        )?;
        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Drive, DriveMut)]
pub enum ModifyColumnAction {
    // Set masking policy on a column with optional USING clause
    // Syntax: ALTER TABLE ... MODIFY COLUMN <column> SET MASKING POLICY <policy_name> [USING (<columns>)]
    //
    // Fields:
    // - Identifier: The column name to apply the masking policy to
    // - String: The masking policy name
    // - Option<Vec<Identifier>>: Optional USING clause columns
    //
    // USING clause behavior (follows Snowflake semantics):
    // - First column: The column to mask/tokenize (must match the target column)
    // - Additional columns: Condition columns to evaluate for conditional masking
    // - If USING is omitted: Treats as normal (non-conditional) masking policy
    SetMaskingPolicy(Identifier, String, Option<Vec<Identifier>>),
    // Unset masking policy from a column
    UnsetMaskingPolicy(Identifier),
    // vec<ColumnDefinition>
    SetDataType(Vec<ColumnDefinition>),
    // column name id
    ConvertStoredComputedColumn(Identifier),
    // (column name id, new comment)
    Comment(Vec<ColumnComment>),
}

impl Display for ModifyColumnAction {
    fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
        match &self {
            ModifyColumnAction::SetMaskingPolicy(column, name, using_columns) => {
                if let Some(using_columns) = using_columns {
                    write!(f, "{} SET MASKING POLICY {} USING (", column, name)?;
                    write_comma_separated_list(f, using_columns)?;
                    write!(f, ")")?
                } else {
                    write!(f, "{} SET MASKING POLICY {}", column, name)?
                }
            }
            ModifyColumnAction::UnsetMaskingPolicy(column) => {
                write!(f, "{} UNSET MASKING POLICY", column)?
            }
            ModifyColumnAction::SetDataType(column_defs) => {
                write_comma_separated_list(f, column_defs)?
            }
            ModifyColumnAction::ConvertStoredComputedColumn(column) => {
                write!(f, "{} DROP STORED", column)?
            }
            ModifyColumnAction::Comment(columns) => write_comma_separated_list(f, columns)?,
        }

        Ok(())
    }
}

#[derive(Debug, Clone, PartialEq, Drive, DriveMut, Default)]
pub struct ShowStatisticsStmt {
    pub catalog: Option<Identifier>,
    pub database: Option<Identifier>,
    pub target: ShowStatsTarget,
}

#[derive(Debug, Clone, PartialEq, Drive, DriveMut, Default)]
pub enum ShowStatsTarget {
    #[default]
    Database,
    Table(Identifier),
}

impl Display for ShowStatisticsStmt {
    fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
        write!(f, "SHOW STATISTICS")?;
        match &self.target {
            ShowStatsTarget::Database => {
                if let Some(database) = &self.database {
                    write!(f, " FROM DATABASE ")?;
                    if let Some(catalog) = &self.catalog {
                        write!(f, "{catalog}.",)?;
                    }
                    write!(f, "{database}")?;
                }
            }
            ShowStatsTarget::Table(table) => {
                write!(f, " FROM TABLE ")?;
                if let Some(database) = &self.database {
                    if let Some(catalog) = &self.catalog {
                        write!(f, "{catalog}.",)?;
                    }
                    write!(f, "{database}.")?;
                }
                write!(f, "{table}")?;
            }
        }
        Ok(())
    }
}