Type Alias Statement 

pub type Statement = Statement;

Aliased Type

pub enum Statement {
    Analyze {
        table_name: ObjectName,
        partitions: Option<Vec<Expr>>,
        for_columns: bool,
        columns: Vec<Ident>,
        cache_metadata: bool,
        noscan: bool,
        compute_statistics: bool,
    },
    Truncate {
        table_name: ObjectName,
        partitions: Option<Vec<Expr>>,
        table: bool,
    },
    Msck {
        table_name: ObjectName,
        repair: bool,
        partition_action: Option<AddDropSync>,
    },
    Query(Box<Query>),
    Insert {
        or: Option<SqliteOnConflict>,
        into: bool,
        table_name: ObjectName,
        columns: Vec<Ident>,
        overwrite: bool,
        source: Box<Query>,
        partitioned: Option<Vec<Expr>>,
        after_columns: Vec<Ident>,
        table: bool,
        on: Option<OnInsert>,
        returning: Option<Vec<SelectItem>>,
    },
    Directory {
        overwrite: bool,
        local: bool,
        path: String,
        file_format: Option<FileFormat>,
        source: Box<Query>,
    },
    Copy {
        source: CopySource,
        to: bool,
        target: CopyTarget,
        options: Vec<CopyOption>,
        legacy_options: Vec<CopyLegacyOption>,
        values: Vec<Option<String>>,
    },
    CopyIntoSnowflake {
        into: ObjectName,
        from_stage: ObjectName,
        from_stage_alias: Option<Ident>,
        stage_params: StageParamsObject,
        from_transformations: Option<Vec<StageLoadSelectItem>>,
        files: Option<Vec<String>>,
        pattern: Option<String>,
        file_format: DataLoadingOptions,
        copy_options: DataLoadingOptions,
        validation_mode: Option<String>,
    },
    Close {
        cursor: CloseCursor,
    },
    Update {
        table: TableWithJoins,
        assignments: Vec<Assignment>,
        from: Option<TableWithJoins>,
        selection: Option<Expr>,
        returning: Option<Vec<SelectItem>>,
    },
    Delete {
        tables: Vec<ObjectName>,
        from: Vec<TableWithJoins>,
        using: Option<Vec<TableWithJoins>>,
        selection: Option<Expr>,
        returning: Option<Vec<SelectItem>>,
    },
    CreateView {
        or_replace: bool,
        materialized: bool,
        name: ObjectName,
        columns: Vec<Ident>,
        query: Box<Query>,
        with_options: Vec<SqlOption>,
        cluster_by: Vec<Ident>,
    },
    CreateTable {

        or_replace: bool,
        temporary: bool,
        external: bool,
        global: Option<bool>,
        if_not_exists: bool,
        transient: bool,
        name: ObjectName,
        columns: Vec<ColumnDef>,
        constraints: Vec<TableConstraint>,
        hive_distribution: HiveDistributionStyle,
        hive_formats: Option<HiveFormat>,
        table_properties: Vec<SqlOption>,
        with_options: Vec<SqlOption>,
        file_format: Option<FileFormat>,
        location: Option<String>,
        query: Option<Box<Query>>,
        without_rowid: bool,
        like: Option<ObjectName>,
        clone: Option<ObjectName>,
        engine: Option<String>,
        default_charset: Option<String>,
        collation: Option<String>,
        on_commit: Option<OnCommit>,
        on_cluster: Option<String>,
        order_by: Option<Vec<Ident>>,
    
},
    CreateVirtualTable {
        name: ObjectName,
        if_not_exists: bool,
        module_name: Ident,
        module_args: Vec<Ident>,
    },
    CreateIndex {
        name: ObjectName,
        table_name: ObjectName,
        using: Option<Ident>,
        columns: Vec<OrderByExpr>,
        unique: bool,
        if_not_exists: bool,
    },
    CreateRole {

        names: Vec<ObjectName>,
        if_not_exists: bool,
        login: Option<bool>,
        inherit: Option<bool>,
        bypassrls: Option<bool>,
        password: Option<Password>,
        superuser: Option<bool>,
        create_db: Option<bool>,
        create_role: Option<bool>,
        replication: Option<bool>,
        connection_limit: Option<Expr>,
        valid_until: Option<Expr>,
        in_role: Vec<Ident>,
        in_group: Vec<Ident>,
        role: Vec<Ident>,
        user: Vec<Ident>,
        admin: Vec<Ident>,
        authorization_owner: Option<ObjectName>,
    
},
    AlterTable {
        name: ObjectName,
        operation: AlterTableOperation,
    },
    AlterIndex {
        name: ObjectName,
        operation: AlterIndexOperation,
    },
    Drop {
        object_type: ObjectType,
        if_exists: bool,
        names: Vec<ObjectName>,
        cascade: bool,
        restrict: bool,
        purge: bool,
    },
    DropFunction {
        if_exists: bool,
        func_desc: Vec<DropFunctionDesc>,
        option: Option<ReferentialAction>,
    },
    Declare {
        name: Ident,
        binary: bool,
        sensitive: Option<bool>,
        scroll: Option<bool>,
        hold: Option<bool>,
        query: Box<Query>,
    },
    Fetch {
        name: Ident,
        direction: FetchDirection,
        into: Option<ObjectName>,
    },
    Discard {
        object_type: DiscardObject,
    },
    SetRole {
        context_modifier: ContextModifier,
        role_name: Option<Ident>,
    },
    SetVariable {
        local: bool,
        hivevar: bool,
        variable: ObjectName,
        value: Vec<Expr>,
    },
    SetTimeZone {
        local: bool,
        value: Expr,
    },
    SetNames {
        charset_name: String,
        collation_name: Option<String>,
    },
    SetNamesDefault {},
    ShowFunctions {
        filter: Option<ShowStatementFilter>,
    },
    ShowVariable {
        variable: Vec<Ident>,
    },
    ShowVariables {
        filter: Option<ShowStatementFilter>,
    },
    ShowCreate {
        obj_type: ShowCreateObject,
        obj_name: ObjectName,
    },
    ShowColumns {
        extended: bool,
        full: bool,
        table_name: ObjectName,
        filter: Option<ShowStatementFilter>,
    },
    ShowTables {
        extended: bool,
        full: bool,
        db_name: Option<Ident>,
        filter: Option<ShowStatementFilter>,
    },
    ShowCollation {
        filter: Option<ShowStatementFilter>,
    },
    Use {
        db_name: Ident,
    },
    StartTransaction {
        modes: Vec<TransactionMode>,
    },
    SetTransaction {
        modes: Vec<TransactionMode>,
        snapshot: Option<Value>,
        session: bool,
    },
    Comment {
        object_type: CommentObject,
        object_name: ObjectName,
        comment: Option<String>,
        if_exists: bool,
    },
    Commit {
        chain: bool,
    },
    Rollback {
        chain: bool,
    },
    CreateSchema {
        schema_name: SchemaName,
        if_not_exists: bool,
    },
    CreateDatabase {
        db_name: ObjectName,
        if_not_exists: bool,
        location: Option<String>,
        managed_location: Option<String>,
    },
    CreateFunction {
        or_replace: bool,
        temporary: bool,
        name: ObjectName,
        args: Option<Vec<OperateFunctionArg>>,
        return_type: Option<DataType>,
        params: CreateFunctionBody,
    },
    CreateStage {
        or_replace: bool,
        temporary: bool,
        if_not_exists: bool,
        name: ObjectName,
        stage_params: StageParamsObject,
        directory_table_params: DataLoadingOptions,
        file_format: DataLoadingOptions,
        copy_options: DataLoadingOptions,
        comment: Option<String>,
    },
    Assert {
        condition: Expr,
        message: Option<Expr>,
    },
    Grant {
        privileges: Privileges,
        objects: GrantObjects,
        grantees: Vec<Ident>,
        with_grant_option: bool,
        granted_by: Option<Ident>,
    },
    Revoke {
        privileges: Privileges,
        objects: GrantObjects,
        grantees: Vec<Ident>,
        granted_by: Option<Ident>,
        cascade: bool,
    },
    Deallocate {
        name: Ident,
        prepare: bool,
    },
    Execute {
        name: Ident,
        parameters: Vec<Expr>,
    },
    Prepare {
        name: Ident,
        data_types: Vec<DataType>,
        statement: Box<Statement>,
    },
    Kill {
        modifier: Option<KillType>,
        id: u64,
    },
    ExplainTable {
        describe_alias: bool,
        table_name: ObjectName,
    },
    Explain {
        describe_alias: bool,
        analyze: bool,
        verbose: bool,
        statement: Box<Statement>,
        format: Option<AnalyzeFormat>,
    },
    Savepoint {
        name: Ident,
    },
    Merge {
        into: bool,
        table: TableFactor,
        source: TableFactor,
        on: Box<Expr>,
        clauses: Vec<MergeClause>,
    },
    Cache {
        table_flag: Option<ObjectName>,
        table_name: ObjectName,
        has_as: bool,
        options: Vec<SqlOption>,
        query: Option<Query>,
    },
    UNCache {
        table_name: ObjectName,
        if_exists: bool,
    },
    CreateSequence {
        temporary: bool,
        if_not_exists: bool,
        name: ObjectName,
        data_type: Option<DataType>,
        sequence_options: Vec<SequenceOptions>,
        owned_by: Option<ObjectName>,
    },
}

Variants

Analyze

Analyze (Hive)

Fields

table_name: ObjectName

partitions: Option<Vec<Expr>>

for_columns: bool

columns: Vec<Ident>

cache_metadata: bool

noscan: bool

compute_statistics: bool

Truncate

Truncate (Hive)

Fields

table_name: ObjectName

partitions: Option<Vec<Expr>>

table: bool

TABLE - optional keyword;

Msck

Msck (Hive)

Fields

table_name: ObjectName

repair: bool

partition_action: Option<AddDropSync>

Query(Box<Query>)

SELECT

Insert

INSERT

Fields

or: Option<SqliteOnConflict>

Only for Sqlite

into: bool

INTO - optional keyword

table_name: ObjectName

TABLE

columns: Vec<Ident>

COLUMNS

overwrite: bool

Overwrite (Hive)

source: Box<Query>

A SQL query that specifies what to insert

partitioned: Option<Vec<Expr>>

partitioned insert (Hive)

after_columns: Vec<Ident>

Columns defined after PARTITION

table: bool

whether the insert has the table keyword (Hive)

on: Option<OnInsert>

returning: Option<Vec<SelectItem>>

RETURNING

Directory

Fields

overwrite: bool

local: bool

path: String

file_format: Option<FileFormat>

source: Box<Query>

Copy

Fields

source: CopySource

The source of ‘COPY TO’, or the target of ‘COPY FROM’

to: bool

If true, is a ‘COPY TO’ statement. If false is a ‘COPY FROM’

target: CopyTarget

The target of ‘COPY TO’, or the source of ‘COPY FROM’

options: Vec<CopyOption>

WITH options (from PostgreSQL version 9.0)

legacy_options: Vec<CopyLegacyOption>

WITH options (before PostgreSQL version 9.0)

values: Vec<Option<String>>

VALUES a vector of values to be copied

CopyIntoSnowflake

COPY INTO

See https://docs.snowflake.com/en/sql-reference/sql/copy-into-table Copy Into syntax available for Snowflake is different than the one implemented in Postgres. Although they share common prefix, it is reasonable to implement them in different enums. This can be refactored later once custom dialects are allowed to have custom Statements.

Fields

into: ObjectName

from_stage: ObjectName

from_stage_alias: Option<Ident>

stage_params: StageParamsObject

from_transformations: Option<Vec<StageLoadSelectItem>>

files: Option<Vec<String>>

pattern: Option<String>

file_format: DataLoadingOptions

copy_options: DataLoadingOptions

validation_mode: Option<String>

Close

Close - closes the portal underlying an open cursor.

Fields

cursor: CloseCursor

Cursor name

Update

UPDATE

Fields

table: TableWithJoins

TABLE

assignments: Vec<Assignment>

Column assignments

from: Option<TableWithJoins>

Table which provide value to be set

selection: Option<Expr>

WHERE

returning: Option<Vec<SelectItem>>

RETURNING

Delete

DELETE

Fields

tables: Vec<ObjectName>

Multi tables delete are supported in mysql

from: Vec<TableWithJoins>

FROM

using: Option<Vec<TableWithJoins>>

USING (Snowflake, Postgres, MySQL)

selection: Option<Expr>

WHERE

returning: Option<Vec<SelectItem>>

RETURNING

CreateView

CREATE VIEW

Fields

or_replace: bool

materialized: bool

name: ObjectName

View name

columns: Vec<Ident>

query: Box<Query>

with_options: Vec<SqlOption>

cluster_by: Vec<Ident>

CreateTable

CREATE TABLE

Fields

or_replace: bool

temporary: bool

external: bool

global: Option<bool>

if_not_exists: bool

transient: bool

name: ObjectName

Table name

columns: Vec<ColumnDef>

Optional schema

constraints: Vec<TableConstraint>

hive_distribution: HiveDistributionStyle

hive_formats: Option<HiveFormat>

table_properties: Vec<SqlOption>

with_options: Vec<SqlOption>

file_format: Option<FileFormat>

location: Option<String>

query: Option<Box<Query>>

without_rowid: bool

like: Option<ObjectName>

clone: Option<ObjectName>

engine: Option<String>

default_charset: Option<String>

collation: Option<String>

on_commit: Option<OnCommit>

on_cluster: Option<String>

ClickHouse “ON CLUSTER” clause: https://clickhouse.com/docs/en/sql-reference/distributed-ddl/

order_by: Option<Vec<Ident>>

ClickHouse “ORDER BY “ clause. Note that omitted ORDER BY is different than empty (represented as ()), the latter meaning “no sorting”. https://clickhouse.com/docs/en/sql-reference/statements/create/table/

CreateVirtualTable

SQLite’s CREATE VIRTUAL TABLE .. USING <module_name> (<module_args>)

Fields

name: ObjectName

if_not_exists: bool

module_name: Ident

module_args: Vec<Ident>

CreateIndex

CREATE INDEX

Fields

name: ObjectName

index name

table_name: ObjectName

using: Option<Ident>

columns: Vec<OrderByExpr>

unique: bool

if_not_exists: bool

CreateRole

CREATE ROLE See postgres

Fields

names: Vec<ObjectName>

if_not_exists: bool

login: Option<bool>

inherit: Option<bool>

bypassrls: Option<bool>

password: Option<Password>

superuser: Option<bool>

create_db: Option<bool>

create_role: Option<bool>

replication: Option<bool>

connection_limit: Option<Expr>

valid_until: Option<Expr>

in_role: Vec<Ident>

in_group: Vec<Ident>

role: Vec<Ident>

user: Vec<Ident>

admin: Vec<Ident>

authorization_owner: Option<ObjectName>

AlterTable

ALTER TABLE

Fields

name: ObjectName

Table name

operation: AlterTableOperation

AlterIndex

Fields

name: ObjectName

operation: AlterIndexOperation

Drop

DROP

Fields

object_type: ObjectType

The type of the object to drop: TABLE, VIEW, etc.

if_exists: bool

An optional IF EXISTS clause. (Non-standard.)

names: Vec<ObjectName>

One or more objects to drop. (ANSI SQL requires exactly one.)

cascade: bool

Whether CASCADE was specified. This will be false when RESTRICT or no drop behavior at all was specified.

restrict: bool

Whether RESTRICT was specified. This will be false when CASCADE or no drop behavior at all was specified.

purge: bool

Hive allows you specify whether the table’s stored data will be deleted along with the dropped table

DropFunction

DROP Function

Fields

if_exists: bool

func_desc: Vec<DropFunctionDesc>

One or more function to drop

option: Option<ReferentialAction>

CASCADE or RESTRICT

Declare

DECLARE - Declaring Cursor Variables

Note: this is a PostgreSQL-specific statement, but may also compatible with other SQL.

Fields

name: Ident

Cursor name

binary: bool

Causes the cursor to return data in binary rather than in text format.

sensitive: Option<bool>

None = Not specified Some(true) = INSENSITIVE Some(false) = ASENSITIVE

scroll: Option<bool>

None = Not specified Some(true) = SCROLL Some(false) = NO SCROLL

hold: Option<bool>

None = Not specified Some(true) = WITH HOLD, specifies that the cursor can continue to be used after the transaction that created it successfully commits Some(false) = WITHOUT HOLD, specifies that the cursor cannot be used outside of the transaction that created it

query: Box<Query>

Fetch

FETCH - retrieve rows from a query using a cursor

Note: this is a PostgreSQL-specific statement, but may also compatible with other SQL.

Fields

name: Ident

Cursor name

direction: FetchDirection

into: Option<ObjectName>

Optional, It’s possible to fetch rows form cursor to the table

Discard

DISCARD [ ALL | PLANS | SEQUENCES | TEMPORARY | TEMP ]

Note: this is a PostgreSQL-specific statement, but may also compatible with other SQL.

Fields

object_type: DiscardObject

SetRole

SET [ SESSION | LOCAL ] ROLE role_name. Examples: ANSI, Postgresql, MySQL, and Oracle.

Fields

context_modifier: ContextModifier

Non-ANSI optional identifier to inform if the role is defined inside the current session (SESSION) or transaction (LOCAL).

role_name: Option<Ident>

Role name. If NONE is specified, then the current role name is removed.

SetVariable

SET <variable>

Note: this is not a standard SQL statement, but it is supported by at least MySQL and PostgreSQL. Not all MySQL-specific syntatic forms are supported yet.

Fields

local: bool

hivevar: bool

variable: ObjectName

value: Vec<Expr>

SetTimeZone

SET TIME ZONE <value>

Note: this is a PostgreSQL-specific statements SET TIME ZONE <value> is an alias for SET timezone TO <value> in PostgreSQL

Fields

local: bool

value: Expr

SetNames

SET NAMES ‘charset_name’ [COLLATE ‘collation_name’]

Note: this is a MySQL-specific statement.

Fields

charset_name: String

collation_name: Option<String>

SetNamesDefault

SET NAMES DEFAULT

Note: this is a MySQL-specific statement.

ShowFunctions

SHOW FUNCTIONS

Note: this is a Presto-specific statement.

Fields

filter: Option<ShowStatementFilter>

ShowVariable

SHOW <variable>

Note: this is a PostgreSQL-specific statement.

Fields

variable: Vec<Ident>

ShowVariables

SHOW VARIABLES

Note: this is a MySQL-specific statement.

Fields

filter: Option<ShowStatementFilter>

ShowCreate

SHOW CREATE TABLE

Note: this is a MySQL-specific statement.

Fields

obj_type: ShowCreateObject

obj_name: ObjectName

ShowColumns

SHOW COLUMNS

Note: this is a MySQL-specific statement.

Fields

extended: bool

full: bool

table_name: ObjectName

filter: Option<ShowStatementFilter>

ShowTables

SHOW TABLES

Note: this is a MySQL-specific statement.

Fields

extended: bool

full: bool

db_name: Option<Ident>

filter: Option<ShowStatementFilter>

ShowCollation

SHOW COLLATION

Note: this is a MySQL-specific statement.

Fields

filter: Option<ShowStatementFilter>

Use

USE

Note: This is a MySQL-specific statement.

Fields

db_name: Ident

StartTransaction

{ BEGIN [ TRANSACTION | WORK ] | START TRANSACTION } ...

Fields

modes: Vec<TransactionMode>

SetTransaction

SET TRANSACTION ...

Fields

modes: Vec<TransactionMode>

snapshot: Option<Value>

session: bool

Comment

COMMENT ON ...

Note: this is a PostgreSQL-specific statement.

Fields

object_type: CommentObject

object_name: ObjectName

comment: Option<String>

if_exists: bool

An optional IF EXISTS clause. (Non-standard.) See https://docs.snowflake.com/en/sql-reference/sql/comment

Commit

COMMIT [ TRANSACTION | WORK ] [ AND [ NO ] CHAIN ]

Fields

chain: bool

Rollback

ROLLBACK [ TRANSACTION | WORK ] [ AND [ NO ] CHAIN ]

Fields

chain: bool

CreateSchema

CREATE SCHEMA

Fields

schema_name: SchemaName

<schema name> | AUTHORIZATION <schema authorization identifier> | <schema name> AUTHORIZATION <schema authorization identifier>

if_not_exists: bool

CreateDatabase

CREATE DATABASE

Fields

db_name: ObjectName

if_not_exists: bool

location: Option<String>

managed_location: Option<String>

CreateFunction

CREATE FUNCTION

Supported variants:

1. Hive
2. Postgres

Fields

or_replace: bool

temporary: bool

name: ObjectName

args: Option<Vec<OperateFunctionArg>>

return_type: Option<DataType>

params: CreateFunctionBody

Optional parameters.

CreateStage

CREATE STAGE

See https://docs.snowflake.com/en/sql-reference/sql/create-stage

Fields

or_replace: bool

temporary: bool

if_not_exists: bool

name: ObjectName

stage_params: StageParamsObject

directory_table_params: DataLoadingOptions

file_format: DataLoadingOptions

copy_options: DataLoadingOptions

comment: Option<String>

Assert

ASSERT <condition> [AS <message>]

Fields

condition: Expr

message: Option<Expr>

Grant

GRANT privileges ON objects TO grantees

Fields

privileges: Privileges

objects: GrantObjects

grantees: Vec<Ident>

with_grant_option: bool

granted_by: Option<Ident>

Revoke

REVOKE privileges ON objects FROM grantees

Fields

privileges: Privileges

objects: GrantObjects

grantees: Vec<Ident>

granted_by: Option<Ident>

cascade: bool

Deallocate

DEALLOCATE [ PREPARE ] { name | ALL }

Note: this is a PostgreSQL-specific statement.

Fields

name: Ident

prepare: bool

Execute

EXECUTE name [ ( parameter [, ...] ) ]

Note: this is a PostgreSQL-specific statement.

Fields

name: Ident

parameters: Vec<Expr>

Prepare

PREPARE name [ ( data_type [, ...] ) ] AS statement

Note: this is a PostgreSQL-specific statement.

Fields

name: Ident

data_types: Vec<DataType>

statement: Box<Statement>

Kill

KILL [CONNECTION | QUERY | MUTATION]

See https://clickhouse.com/docs/ru/sql-reference/statements/kill/ See https://dev.mysql.com/doc/refman/8.0/en/kill.html

Fields

modifier: Option<KillType>

id: u64

ExplainTable

EXPLAIN TABLE Note: this is a MySQL-specific statement. See https://dev.mysql.com/doc/refman/8.0/en/explain.html

Fields

describe_alias: bool

If true, query used the MySQL DESCRIBE alias for explain

table_name: ObjectName

Table name

Explain

EXPLAIN / DESCRIBE for select_statement

Fields

describe_alias: bool

analyze: bool

Carry out the command and show actual run times and other statistics.

verbose: bool

statement: Box<Statement>

A SQL query that specifies what to explain

format: Option<AnalyzeFormat>

Optional output format of explain

Savepoint

SAVEPOINT – define a new savepoint within the current transaction

Fields

name: Ident

Merge

Fields

into: bool

table: TableFactor

source: TableFactor

on: Box<Expr>

clauses: Vec<MergeClause>

Cache

CACHE [ FLAG ] TABLE <table_name> [ OPTIONS('K1' = 'V1', 'K2' = V2) ] [ AS ] [ <query> ].

See Spark SQL docs for more details.

Fields

table_flag: Option<ObjectName>

Table flag

table_name: ObjectName

Table name

has_as: bool

options: Vec<SqlOption>

Table confs

query: Option<Query>

Cache table as a Query

UNCache

UNCACHE TABLE [ IF EXISTS ] <table_name>

Fields

table_name: ObjectName

Table name

if_exists: bool

CreateSequence

CreateSequence – define a new sequence CREATE [ { TEMPORARY | TEMP } ] SEQUENCE [ IF NOT EXISTS ] <sequence_name>

Fields

temporary: bool

if_not_exists: bool

name: ObjectName

data_type: Option<DataType>

sequence_options: Vec<SequenceOptions>

owned_by: Option<ObjectName>