Enum Statement

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,
        has_table_keyword: bool,
    },
    Set(Set),
    Truncate {
        table_names: Vec<TruncateTableTarget>,
        partitions: Option<Vec<Expr>>,
        table: bool,
        only: bool,
        identity: Option<TruncateIdentityOption>,
        cascade: Option<CascadeOption>,
        on_cluster: Option<Ident>,
    },
    Msck {
        table_name: ObjectName,
        repair: bool,
        partition_action: Option<AddDropSync>,
    },
    Query(Box<Query>),
    Insert(Insert),
    Install {
        extension_name: Ident,
    },
    Load {
        extension_name: Ident,
    },
    Directory {
        overwrite: bool,
        local: bool,
        path: String,
        file_format: Option<FileFormat>,
        source: Box<Query>,
    },
    Case(CaseStatement),
    If(IfStatement),
    Raise(RaiseStatement),
    Call(Function),
    Copy {
        source: CopySource,
        to: bool,
        target: CopyTarget,
        options: Vec<CopyOption>,
        legacy_options: Vec<CopyLegacyOption>,
        values: Vec<Option<String>>,
    },
    CopyIntoSnowflake {

        kind: CopyIntoSnowflakeKind,
        into: ObjectName,
        into_columns: Option<Vec<Ident>>,
        from_obj: Option<ObjectName>,
        from_obj_alias: Option<Ident>,
        stage_params: StageParamsObject,
        from_transformations: Option<Vec<StageLoadSelectItemKind>>,
        from_query: Option<Box<Query>>,
        files: Option<Vec<String>>,
        pattern: Option<String>,
        file_format: KeyValueOptions,
        copy_options: KeyValueOptions,
        validation_mode: Option<String>,
        partition: Option<Box<Expr>>,
    
},
    Close {
        cursor: CloseCursor,
    },
    Update {
        table: TableWithJoins,
        assignments: Vec<Assignment>,
        from: Option<UpdateTableFromKind>,
        selection: Option<Expr>,
        returning: Option<Vec<SelectItem>>,
        or: Option<SqliteOnConflict>,
    },
    Delete(Delete),
    CreateView {

        or_alter: bool,
        or_replace: bool,
        materialized: bool,
        name: ObjectName,
        columns: Vec<ViewColumnDef>,
        query: Box<Query>,
        options: CreateTableOptions,
        cluster_by: Vec<Ident>,
        comment: Option<String>,
        with_no_schema_binding: bool,
        if_not_exists: bool,
        temporary: bool,
        to: Option<ObjectName>,
        params: Option<CreateViewParams>,
    
},
    CreateTable(CreateTable),
    CreateVirtualTable {
        name: ObjectName,
        if_not_exists: bool,
        module_name: Ident,
        module_args: Vec<Ident>,
    },
    CreateIndex(CreateIndex),
    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>,
    
},
    CreateSecret {
        or_replace: bool,
        temporary: Option<bool>,
        if_not_exists: bool,
        name: Option<Ident>,
        storage_specifier: Option<Ident>,
        secret_type: Ident,
        options: Vec<SecretOption>,
    },
    CreatePolicy {
        name: Ident,
        table_name: ObjectName,
        policy_type: Option<CreatePolicyType>,
        command: Option<CreatePolicyCommand>,
        to: Option<Vec<Owner>>,
        using: Option<Expr>,
        with_check: Option<Expr>,
    },
    CreateConnector(CreateConnector),
    AlterTable {
        name: ObjectName,
        if_exists: bool,
        only: bool,
        operations: Vec<AlterTableOperation>,
        location: Option<HiveSetLocation>,
        on_cluster: Option<Ident>,
    },
    AlterIndex {
        name: ObjectName,
        operation: AlterIndexOperation,
    },
    AlterView {
        name: ObjectName,
        columns: Vec<Ident>,
        query: Box<Query>,
        with_options: Vec<SqlOption>,
    },
    AlterType(AlterType),
    AlterRole {
        name: Ident,
        operation: AlterRoleOperation,
    },
    AlterPolicy {
        name: Ident,
        table_name: ObjectName,
        operation: AlterPolicyOperation,
    },
    AlterConnector {
        name: Ident,
        properties: Option<Vec<SqlOption>>,
        url: Option<String>,
        owner: Option<AlterConnectorOwner>,
    },
    AlterSession {
        set: bool,
        session_params: KeyValueOptions,
    },
    AttachDatabase {
        schema_name: Ident,
        database_file_name: Expr,
        database: bool,
    },
    AttachDuckDBDatabase {
        if_not_exists: bool,
        database: bool,
        database_path: Ident,
        database_alias: Option<Ident>,
        attach_options: Vec<AttachDuckDBDatabaseOption>,
    },
    DetachDuckDBDatabase {
        if_exists: bool,
        database: bool,
        database_alias: Ident,
    },
    Drop {
        object_type: ObjectType,
        if_exists: bool,
        names: Vec<ObjectName>,
        cascade: bool,
        restrict: bool,
        purge: bool,
        temporary: bool,
    },
    DropFunction {
        if_exists: bool,
        func_desc: Vec<FunctionDesc>,
        drop_behavior: Option<DropBehavior>,
    },
    DropProcedure {
        if_exists: bool,
        proc_desc: Vec<FunctionDesc>,
        drop_behavior: Option<DropBehavior>,
    },
    DropSecret {
        if_exists: bool,
        temporary: Option<bool>,
        name: Ident,
        storage_specifier: Option<Ident>,
    },
    DropPolicy {
        if_exists: bool,
        name: Ident,
        table_name: ObjectName,
        drop_behavior: Option<DropBehavior>,
    },
    DropConnector {
        if_exists: bool,
        name: Ident,
    },
    Declare {
        stmts: Vec<Declare>,
    },
    CreateExtension {
        name: Ident,
        if_not_exists: bool,
        cascade: bool,
        schema: Option<Ident>,
        version: Option<Ident>,
    },
    DropExtension {
        names: Vec<Ident>,
        if_exists: bool,
        cascade_or_restrict: Option<ReferentialAction>,
    },
    Fetch {
        name: Ident,
        direction: FetchDirection,
        into: Option<ObjectName>,
    },
    Flush {
        object_type: FlushType,
        location: Option<FlushLocation>,
        channel: Option<String>,
        read_lock: bool,
        export: bool,
        tables: Vec<ObjectName>,
    },
    Discard {
        object_type: DiscardObject,
    },
    ShowFunctions {
        filter: Option<ShowStatementFilter>,
    },
    ShowVariable {
        variable: Vec<Ident>,
    },
    ShowStatus {
        filter: Option<ShowStatementFilter>,
        global: bool,
        session: bool,
    },
    ShowVariables {
        filter: Option<ShowStatementFilter>,
        global: bool,
        session: bool,
    },
    ShowCreate {
        obj_type: ShowCreateObject,
        obj_name: ObjectName,
    },
    ShowColumns {
        extended: bool,
        full: bool,
        show_options: ShowStatementOptions,
    },
    ShowDatabases {
        terse: bool,
        history: bool,
        show_options: ShowStatementOptions,
    },
    ShowSchemas {
        terse: bool,
        history: bool,
        show_options: ShowStatementOptions,
    },
    ShowObjects(ShowObjects),
    ShowTables {
        terse: bool,
        history: bool,
        extended: bool,
        full: bool,
        external: bool,
        show_options: ShowStatementOptions,
    },
    ShowViews {
        terse: bool,
        materialized: bool,
        show_options: ShowStatementOptions,
    },
    ShowCollation {
        filter: Option<ShowStatementFilter>,
    },
    Use(Use),
    StartTransaction {
        modes: Vec<TransactionMode>,
        begin: bool,
        transaction: Option<BeginTransactionKind>,
        modifier: Option<TransactionModifier>,
        statements: Vec<Statement>,
        exception_statements: Option<Vec<Statement>>,
        has_end_keyword: bool,
    },
    Comment {
        object_type: CommentObject,
        object_name: ObjectName,
        comment: Option<String>,
        if_exists: bool,
    },
    Commit {
        chain: bool,
        end: bool,
        modifier: Option<TransactionModifier>,
    },
    Rollback {
        chain: bool,
        savepoint: Option<Ident>,
    },
    CreateSchema {
        schema_name: SchemaName,
        if_not_exists: bool,
        options: Option<Vec<SqlOption>>,
        default_collate_spec: Option<Expr>,
    },
    CreateDatabase {
        db_name: ObjectName,
        if_not_exists: bool,
        location: Option<String>,
        managed_location: Option<String>,
    },
    CreateFunction(CreateFunction),
    CreateTrigger {

        or_replace: bool,
        is_constraint: bool,
        name: ObjectName,
        period: TriggerPeriod,
        events: Vec<TriggerEvent>,
        table_name: ObjectName,
        referenced_table_name: Option<ObjectName>,
        referencing: Vec<TriggerReferencing>,
        trigger_object: TriggerObject,
        include_each: bool,
        condition: Option<Expr>,
        exec_body: TriggerExecBody,
        characteristics: Option<ConstraintCharacteristics>,
    
},
    DropTrigger {
        if_exists: bool,
        trigger_name: ObjectName,
        table_name: Option<ObjectName>,
        option: Option<ReferentialAction>,
    },
    CreateProcedure {
        or_alter: bool,
        name: ObjectName,
        params: Option<Vec<ProcedureParam>>,
        body: Vec<Statement>,
    },
    CreateMacro {
        or_replace: bool,
        temporary: bool,
        name: ObjectName,
        args: Option<Vec<MacroArg>>,
        definition: MacroDefinition,
    },
    CreateStage {
        or_replace: bool,
        temporary: bool,
        if_not_exists: bool,
        name: ObjectName,
        stage_params: StageParamsObject,
        directory_table_params: KeyValueOptions,
        file_format: KeyValueOptions,
        copy_options: KeyValueOptions,
        comment: Option<String>,
    },
    Assert {
        condition: Expr,
        message: Option<Expr>,
    },
    Grant {
        privileges: Privileges,
        objects: Option<GrantObjects>,
        grantees: Vec<Grantee>,
        with_grant_option: bool,
        granted_by: Option<Ident>,
    },
    Revoke {
        privileges: Privileges,
        objects: Option<GrantObjects>,
        grantees: Vec<Grantee>,
        granted_by: Option<Ident>,
        cascade: Option<CascadeOption>,
    },
    Deallocate {
        name: Ident,
        prepare: bool,
    },
    Execute {
        name: Option<ObjectName>,
        parameters: Vec<Expr>,
        has_parentheses: bool,
        immediate: bool,
        into: Vec<Ident>,
        using: Vec<ExprWithAlias>,
    },
    Prepare {
        name: Ident,
        data_types: Vec<DataType>,
        statement: Box<Statement>,
    },
    Kill {
        modifier: Option<KillType>,
        id: u64,
    },
    ExplainTable {
        describe_alias: DescribeAlias,
        hive_format: Option<HiveDescribeFormat>,
        has_table_keyword: bool,
        table_name: ObjectName,
    },
    Explain {
        describe_alias: DescribeAlias,
        analyze: bool,
        verbose: bool,
        query_plan: bool,
        estimate: bool,
        statement: Box<Statement>,
        format: Option<AnalyzeFormat>,
        options: Option<Vec<UtilityOption>>,
    },
    Savepoint {
        name: Ident,
    },
    ReleaseSavepoint {
        name: Ident,
    },
    Merge {
        into: bool,
        table: TableFactor,
        source: TableFactor,
        on: Box<Expr>,
        clauses: Vec<MergeClause>,
        output: Option<OutputClause>,
    },
    Cache {
        table_flag: Option<ObjectName>,
        table_name: ObjectName,
        has_as: bool,
        options: Vec<SqlOption>,
        query: Option<Box<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>,
    },
    CreateType {
        name: ObjectName,
        representation: UserDefinedTypeRepresentation,
    },
    Pragma {
        name: ObjectName,
        value: Option<Value>,
        is_eq: bool,
    },
    LockTables {
        tables: Vec<LockTable>,
    },
    UnlockTables,
    Unload {
        query: Box<Query>,
        to: Ident,
        with: Vec<SqlOption>,
    },
    OptimizeTable {
        name: ObjectName,
        on_cluster: Option<Ident>,
        partition: Option<Partition>,
        include_final: bool,
        deduplicate: Option<Deduplicate>,
    },
    LISTEN {
        channel: Ident,
    },
    UNLISTEN {
        channel: Ident,
    },
    NOTIFY {
        channel: Ident,
        payload: Option<String>,
    },
    LoadData {
        local: bool,
        inpath: String,
        overwrite: bool,
        table_name: ObjectName,
        partitioned: Option<Vec<Expr>>,
        table_format: Option<HiveLoadDataFormat>,
    },
    RenameTable(Vec<RenameTable>),
    List(FileStagingCommand),
    Remove(FileStagingCommand),
    RaisError {
        message: Box<Expr>,
        severity: Box<Expr>,
        state: Box<Expr>,
        arguments: Vec<Expr>,
        options: Vec<RaisErrorOption>,
    },
    Print(PrintStatement),
    Return(ReturnStatement),
}

A top-level statement (SELECT, INSERT, CREATE, etc.)

Variants

Analyze

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

has_table_keyword: bool

Set(Set)

Truncate

TRUNCATE

Truncate (Hive)

Fields

table_names: Vec<TruncateTableTarget>

partitions: Option<Vec<Expr>>

table: bool

TABLE - optional keyword;

only: bool

Postgres-specific option [ TRUNCATE TABLE ONLY ]

identity: Option<TruncateIdentityOption>

Postgres-specific option [ RESTART IDENTITY | CONTINUE IDENTITY ]

cascade: Option<CascadeOption>

Postgres-specific option [ CASCADE | RESTRICT ]

on_cluster: Option<Ident>

ClickHouse-specific option [ ON CLUSTER cluster_name ]

ClickHouse

Msck

MSCK

Msck (Hive)

Fields

table_name: ObjectName

repair: bool

partition_action: Option<AddDropSync>

Query(Box<Query>)

SELECT

Insert(Insert)

INSERT

Install

INSTALL

Fields

extension_name: Ident

Only for DuckDB

Load

LOAD

Fields

extension_name: Ident

Only for DuckDB

Directory

Fields

overwrite: bool

local: bool

path: String

file_format: Option<FileFormat>

source: Box<Query>

Case(CaseStatement)

A CASE statement.

If(IfStatement)

An IF statement.

Raise(RaiseStatement)

A RAISE statement.

Call(Function)

CALL <function>

Copy

COPY [TO | FROM] ...

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 <table> | <location>

See: https://docs.snowflake.com/en/sql-reference/sql/copy-into-table https://docs.snowflake.com/en/sql-reference/sql/copy-into-location

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

kind: CopyIntoSnowflakeKind

into: ObjectName

into_columns: Option<Vec<Ident>>

from_obj: Option<ObjectName>

from_obj_alias: Option<Ident>

stage_params: StageParamsObject

from_transformations: Option<Vec<StageLoadSelectItemKind>>

from_query: Option<Box<Query>>

files: Option<Vec<String>>

pattern: Option<String>

file_format: KeyValueOptions

copy_options: KeyValueOptions

validation_mode: Option<String>

partition: Option<Box<Expr>>

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

Table which provide value to be set

selection: Option<Expr>

WHERE

returning: Option<Vec<SelectItem>>

RETURNING

or: Option<SqliteOnConflict>

SQLite-specific conflict resolution clause

Delete(Delete)

DELETE

CreateView

CREATE VIEW

Fields

or_alter: bool

True if this is a CREATE OR ALTER VIEW statement

MsSql

or_replace: bool

materialized: bool

name: ObjectName

View name

columns: Vec<ViewColumnDef>

query: Box<Query>

options: CreateTableOptions

cluster_by: Vec<Ident>

comment: Option<String>

Snowflake: Views can have comments in Snowflake. https://docs.snowflake.com/en/sql-reference/sql/create-view#syntax

with_no_schema_binding: bool

if true, has RedShift [WITH NO SCHEMA BINDING] clause https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_VIEW.html

if_not_exists: bool

if true, has SQLite IF NOT EXISTS clause https://www.sqlite.org/lang_createview.html

temporary: bool

if true, has SQLite TEMP or TEMPORARY clause https://www.sqlite.org/lang_createview.html

to: Option<ObjectName>

if not None, has Clickhouse TO clause, specify the table into which to insert results https://clickhouse.com/docs/en/sql-reference/statements/create/view#materialized-view

params: Option<CreateViewParams>

MySQL: Optional parameters for the view algorithm, definer, and security context

CreateTable(CreateTable)

CREATE TABLE

CreateVirtualTable

CREATE VIRTUAL TABLE .. USING <module_name> (<module_args>)`

Sqlite specific statement

Fields

name: ObjectName

if_not_exists: bool

module_name: Ident

module_args: Vec<Ident>

CreateIndex(CreateIndex)

`CREATE INDEX`

CreateRole

CREATE ROLE

See PostgreSQL

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>

CreateSecret

CREATE SECRET

See DuckDB

Fields

or_replace: bool

temporary: Option<bool>

if_not_exists: bool

name: Option<Ident>

storage_specifier: Option<Ident>

secret_type: Ident

options: Vec<SecretOption>

CreatePolicy

CREATE POLICY

See PostgreSQL

Fields

name: Ident

table_name: ObjectName

policy_type: Option<CreatePolicyType>

command: Option<CreatePolicyCommand>

to: Option<Vec<Owner>>

using: Option<Expr>

with_check: Option<Expr>

CreateConnector(CreateConnector)

CREATE CONNECTOR

See Hive

AlterTable

ALTER TABLE

Fields

name: ObjectName

Table name

if_exists: bool

only: bool

operations: Vec<AlterTableOperation>

location: Option<HiveSetLocation>

on_cluster: Option<Ident>

ClickHouse dialect supports ON CLUSTER clause for ALTER TABLE For example: ALTER TABLE table_name ON CLUSTER cluster_name ADD COLUMN c UInt32 ClickHouse

AlterIndex

ALTER INDEX

Fields

name: ObjectName

operation: AlterIndexOperation

AlterView

ALTER VIEW

Fields

name: ObjectName

View name

columns: Vec<Ident>

query: Box<Query>

with_options: Vec<SqlOption>

AlterType(AlterType)

ALTER TYPE
See [PostgreSQL](https://www.postgresql.org/docs/current/sql-altertype.html)

AlterRole

ALTER ROLE

Fields

name: Ident

operation: AlterRoleOperation

AlterPolicy

ALTER POLICY <NAME> ON <TABLE NAME> [<OPERATION>]

(Postgresql-specific)

Fields

name: Ident

table_name: ObjectName

operation: AlterPolicyOperation

AlterConnector

ALTER CONNECTOR connector_name SET DCPROPERTIES(property_name=property_value, ...);
or
ALTER CONNECTOR connector_name SET URL new_url;
or
ALTER CONNECTOR connector_name SET OWNER [USER|ROLE] user_or_role;

(Hive-specific)

Fields

name: Ident

properties: Option<Vec<SqlOption>>

url: Option<String>

owner: Option<AlterConnectorOwner>

AlterSession

ALTER SESSION SET sessionParam
ALTER SESSION UNSET <param_name> [ , <param_name> , ... ]

See https://docs.snowflake.com/en/sql-reference/sql/alter-session

Fields

set: bool

true is to set for the session parameters, false is to unset

session_params: KeyValueOptions

The session parameters to set or unset

AttachDatabase

ATTACH DATABASE 'path/to/file' AS alias

(SQLite-specific)

Fields

schema_name: Ident

The name to bind to the newly attached database

database_file_name: Expr

An expression that indicates the path to the database file

database: bool

true if the syntax is ‘ATTACH DATABASE’, false if it’s just ‘ATTACH’

AttachDuckDBDatabase

(DuckDB-specific)

ATTACH 'sqlite_file.db' AS sqlite_db (READ_ONLY, TYPE SQLITE);

See https://duckdb.org/docs/sql/statements/attach.html

Fields

if_not_exists: bool

database: bool

true if the syntax is ‘ATTACH DATABASE’, false if it’s just ‘ATTACH’

database_path: Ident

An expression that indicates the path to the database file

database_alias: Option<Ident>

attach_options: Vec<AttachDuckDBDatabaseOption>

DetachDuckDBDatabase

(DuckDB-specific)

DETACH db_alias;

See https://duckdb.org/docs/sql/statements/attach.html

Fields

if_exists: bool

database: bool

true if the syntax is ‘DETACH DATABASE’, false if it’s just ‘DETACH’

database_alias: Ident

Drop

DROP [TABLE, VIEW, ...]

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

temporary: bool

MySQL-specific “TEMPORARY” keyword

DropFunction

DROP FUNCTION

Fields

if_exists: bool

func_desc: Vec<FunctionDesc>

One or more function to drop

drop_behavior: Option<DropBehavior>

CASCADE or RESTRICT

DropProcedure

DROP PROCEDURE

Fields

if_exists: bool

proc_desc: Vec<FunctionDesc>

One or more function to drop

drop_behavior: Option<DropBehavior>

CASCADE or RESTRICT

DropSecret

DROP SECRET

Fields

if_exists: bool

temporary: Option<bool>

name: Ident

storage_specifier: Option<Ident>

DropPolicy

 DROP POLICY

See PostgreSQL

Fields

if_exists: bool

name: Ident

table_name: ObjectName

drop_behavior: Option<DropBehavior>

DropConnector

DROP CONNECTOR

See Hive

Fields

if_exists: bool

name: Ident

Declare

DECLARE

Declare Cursor Variables

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

Fields

stmts: Vec<Declare>

CreateExtension

CREATE EXTENSION [ IF NOT EXISTS ] extension_name
    [ WITH ] [ SCHEMA schema_name ]
             [ VERSION version ]
             [ CASCADE ]

Note: this is a PostgreSQL-specific statement,

Fields

name: Ident

if_not_exists: bool

cascade: bool

schema: Option<Ident>

version: Option<Ident>

DropExtension

DROP EXTENSION [ IF EXISTS ] name [, ...] [ CASCADE | RESTRICT ]

Note: this is a PostgreSQL-specific statement.
https://www.postgresql.org/docs/current/sql-dropextension.html

Fields

names: Vec<Ident>

if_exists: bool

cascade_or_restrict: Option<ReferentialAction>

CASCADE or RESTRICT

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

Flush

FLUSH [NO_WRITE_TO_BINLOG | LOCAL] flush_option [, flush_option] ... | tables_option

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

Fields

object_type: FlushType

location: Option<FlushLocation>

channel: Option<String>

read_lock: bool

export: bool

tables: Vec<ObjectName>

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

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>

ShowStatus

SHOW [GLOBAL | SESSION] STATUS [LIKE 'pattern' | WHERE expr]

Note: this is a MySQL-specific statement.

Fields

filter: Option<ShowStatementFilter>

global: bool

session: bool

ShowVariables

SHOW VARIABLES

Note: this is a MySQL-specific statement.

Fields

filter: Option<ShowStatementFilter>

global: bool

session: bool

ShowCreate

SHOW CREATE TABLE

Note: this is a MySQL-specific statement.

Fields

obj_type: ShowCreateObject

obj_name: ObjectName

ShowColumns

SHOW COLUMNS

Fields

extended: bool

full: bool

show_options: ShowStatementOptions

ShowDatabases

SHOW DATABASES

Fields

terse: bool

history: bool

show_options: ShowStatementOptions

ShowSchemas

SHOW SCHEMAS

Fields

terse: bool

history: bool

show_options: ShowStatementOptions

ShowObjects(ShowObjects)

SHOW OBJECTS LIKE 'line%' IN mydb.public

Snowflake-specific statement https://docs.snowflake.com/en/sql-reference/sql/show-objects

ShowTables

SHOW TABLES

Fields

terse: bool

history: bool

extended: bool

full: bool

external: bool

show_options: ShowStatementOptions

ShowViews

SHOW VIEWS

Fields

terse: bool

materialized: bool

show_options: ShowStatementOptions

ShowCollation

SHOW COLLATION

Note: this is a MySQL-specific statement.

Fields

filter: Option<ShowStatementFilter>

Use(Use)

`USE ...`

StartTransaction

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

If begin is false.

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

If begin is true

Fields

modes: Vec<TransactionMode>

begin: bool

transaction: Option<BeginTransactionKind>

modifier: Option<TransactionModifier>

statements: Vec<Statement>

List of statements belonging to the BEGIN block. Example:

BEGIN
    SELECT 1;
    SELECT 2;
END;

exception_statements: Option<Vec<Statement>>

Statements of an exception clause. Example:

BEGIN
    SELECT 1;
EXCEPTION WHEN ERROR THEN
    SELECT 2;
    SELECT 3;
END;
<https://cloud.google.com/bigquery/docs/reference/standard-sql/procedural-language#beginexceptionend>

has_end_keyword: bool

TRUE if the statement has an END keyword.

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 ]

If end is false

END [ TRY | CATCH ]

If end is true

Fields

chain: bool

end: bool

modifier: Option<TransactionModifier>

Rollback

ROLLBACK [ TRANSACTION | WORK ] [ AND [ NO ] CHAIN ] [ TO [ SAVEPOINT ] savepoint_name ]

Fields

chain: bool

savepoint: Option<Ident>

CreateSchema

CREATE SCHEMA

Fields

schema_name: SchemaName

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

if_not_exists: bool

options: Option<Vec<SqlOption>>

Schema options.

CREATE SCHEMA myschema OPTIONS(key1='value1');

BigQuery

default_collate_spec: Option<Expr>

Default collation specification for the schema.

CREATE SCHEMA myschema DEFAULT COLLATE 'und:ci';

BigQuery

CreateDatabase

CREATE DATABASE

Fields

db_name: ObjectName

if_not_exists: bool

location: Option<String>

managed_location: Option<String>

CreateFunction(CreateFunction)

CREATE FUNCTION

Supported variants:

1. Hive
2. PostgreSQL
3. BigQuery
4. MsSql

CreateTrigger

CREATE TRIGGER

Examples:

CREATE TRIGGER trigger_name
BEFORE INSERT ON table_name
FOR EACH ROW
EXECUTE FUNCTION trigger_function();

Postgres: https://www.postgresql.org/docs/current/sql-createtrigger.html

Fields

or_replace: bool

The OR REPLACE clause is used to re-create the trigger if it already exists.

Example:

CREATE OR REPLACE TRIGGER trigger_name
AFTER INSERT ON table_name
FOR EACH ROW
EXECUTE FUNCTION trigger_function();

is_constraint: bool

The CONSTRAINT keyword is used to create a trigger as a constraint.

name: ObjectName

The name of the trigger to be created.

period: TriggerPeriod

Determines whether the function is called before, after, or instead of the event.

Example of BEFORE:

CREATE TRIGGER trigger_name
BEFORE INSERT ON table_name
FOR EACH ROW
EXECUTE FUNCTION trigger_function();

Example of AFTER:

CREATE TRIGGER trigger_name
AFTER INSERT ON table_name
FOR EACH ROW
EXECUTE FUNCTION trigger_function();

Example of INSTEAD OF:

CREATE TRIGGER trigger_name
INSTEAD OF INSERT ON table_name
FOR EACH ROW
EXECUTE FUNCTION trigger_function();

events: Vec<TriggerEvent>

Multiple events can be specified using OR, such as INSERT, UPDATE, DELETE, or TRUNCATE.

table_name: ObjectName

The table on which the trigger is to be created.

referenced_table_name: Option<ObjectName>

The optional referenced table name that can be referenced via the FROM keyword.

referencing: Vec<TriggerReferencing>

This keyword immediately precedes the declaration of one or two relation names that provide access to the transition relations of the triggering statement.

trigger_object: TriggerObject

This specifies whether the trigger function should be fired once for every row affected by the trigger event, or just once per SQL statement.

include_each: bool

Whether to include the EACH term of the FOR EACH, as it is optional syntax.

condition: Option<Expr>

Triggering conditions

exec_body: TriggerExecBody

Execute logic block

characteristics: Option<ConstraintCharacteristics>

The characteristic of the trigger, which include whether the trigger is DEFERRABLE, INITIALLY DEFERRED, or INITIALLY IMMEDIATE,

DropTrigger

DROP TRIGGER

DROP TRIGGER [ IF EXISTS ] name ON table_name [ CASCADE | RESTRICT ]

Fields

if_exists: bool

trigger_name: ObjectName

table_name: Option<ObjectName>

option: Option<ReferentialAction>

CASCADE or RESTRICT

CreateProcedure

CREATE PROCEDURE

Fields

or_alter: bool

name: ObjectName

params: Option<Vec<ProcedureParam>>

body: Vec<Statement>

CreateMacro

CREATE MACRO

Supported variants:

1. DuckDB

Fields

or_replace: bool

temporary: bool

name: ObjectName

args: Option<Vec<MacroArg>>

definition: MacroDefinition

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: KeyValueOptions

file_format: KeyValueOptions

copy_options: KeyValueOptions

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: Option<GrantObjects>

grantees: Vec<Grantee>

with_grant_option: bool

granted_by: Option<Ident>

Revoke

REVOKE privileges ON objects FROM grantees

Fields

privileges: Privileges

objects: Option<GrantObjects>

grantees: Vec<Grantee>

granted_by: Option<Ident>

cascade: Option<CascadeOption>

Deallocate

DEALLOCATE [ PREPARE ] { name | ALL }

Note: this is a PostgreSQL-specific statement.

Fields

name: Ident

prepare: bool

Execute

An `EXECUTE` statement

Postgres: https://www.postgresql.org/docs/current/sql-execute.html MSSQL: https://learn.microsoft.com/en-us/sql/relational-databases/stored-procedures/execute-a-stored-procedure BigQuery: https://cloud.google.com/bigquery/docs/reference/standard-sql/procedural-language#execute_immediate Snowflake: https://docs.snowflake.com/en/sql-reference/sql/execute-immediate

Fields

name: Option<ObjectName>

parameters: Vec<Expr>

has_parentheses: bool

immediate: bool

Is this an EXECUTE IMMEDIATE

into: Vec<Ident>

using: Vec<ExprWithAlias>

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/en/sql-reference/statements/kill/ See https://dev.mysql.com/doc/refman/8.0/en/kill.html

Fields

modifier: Option<KillType>

id: u64

ExplainTable

[EXPLAIN | DESC | DESCRIBE] TABLE

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

Fields

describe_alias: DescribeAlias

EXPLAIN | DESC | DESCRIBE

hive_format: Option<HiveDescribeFormat>

Hive style FORMATTED | EXTENDED

has_table_keyword: bool

Snowflake and ClickHouse support DESC|DESCRIBE TABLE <table_name> syntax

Snowflake ClickHouse

table_name: ObjectName

Table name

Explain

[EXPLAIN | DESC | DESCRIBE]  <statement>

Fields

describe_alias: DescribeAlias

EXPLAIN | DESC | DESCRIBE

analyze: bool

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

verbose: bool

query_plan: bool

EXPLAIN QUERY PLAN Display the query plan without running the query.

SQLite

estimate: bool

EXPLAIN ESTIMATE Clickhouse

statement: Box<Statement>

A SQL query that specifies what to explain

format: Option<AnalyzeFormat>

Optional output format of explain

options: Option<Vec<UtilityOption>>

Postgres style utility options, (analyze, verbose true)

Savepoint

SAVEPOINT

Define a new savepoint within the current transaction

Fields

name: Ident

ReleaseSavepoint

RELEASE [ SAVEPOINT ] savepoint_name

Fields

name: Ident

Merge

A MERGE statement.

MERGE INTO <target_table> USING <source> ON <join_expr> { matchedClause | notMatchedClause } [ ... ]

Snowflake BigQuery MSSQL

Fields

into: bool

optional INTO keyword

table: TableFactor

Specifies the table to merge

source: TableFactor

Specifies the table or subquery to join with the target table

on: Box<Expr>

Specifies the expression on which to join the target table and source

clauses: Vec<MergeClause>

Specifies the actions to perform when values match or do not match.

output: Option<OutputClause>

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<Box<Query>>

Cache table as a Query

UNCache

UNCACHE TABLE [ IF EXISTS ]  <table_name>

Fields

table_name: ObjectName

Table name

if_exists: bool

CreateSequence

CREATE [ { TEMPORARY | TEMP } ] SEQUENCE [ IF NOT EXISTS ] <sequence_name>

Define a new sequence:

Fields

temporary: bool

if_not_exists: bool

name: ObjectName

data_type: Option<DataType>

sequence_options: Vec<SequenceOptions>

owned_by: Option<ObjectName>

CreateType

CREATE TYPE <name>

Fields

name: ObjectName

representation: UserDefinedTypeRepresentation

Pragma

PRAGMA <schema-name>.<pragma-name> = <pragma-value>

Fields

name: ObjectName

value: Option<Value>

is_eq: bool

LockTables

LOCK TABLES <table_name> [READ [LOCAL] | [LOW_PRIORITY] WRITE]

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

Fields

tables: Vec<LockTable>

UnlockTables

UNLOCK TABLES

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

Unload

UNLOAD(statement) TO <destination> [ WITH options ]

See Redshift https://docs.aws.amazon.com/redshift/latest/dg/r_UNLOAD.html and

Fields

query: Box<Query>

to: Ident

with: Vec<SqlOption>

OptimizeTable

OPTIMIZE TABLE [db.]name [ON CLUSTER cluster] [PARTITION partition | PARTITION ID 'partition_id'] [FINAL] [DEDUPLICATE [BY expression]]

See ClickHouse https://clickhouse.com/docs/en/sql-reference/statements/optimize

Fields

name: ObjectName

on_cluster: Option<Ident>

partition: Option<Partition>

include_final: bool

deduplicate: Option<Deduplicate>

LISTEN

LISTEN

listen for a notification channel

See Postgres https://www.postgresql.org/docs/current/sql-listen.html

Fields

channel: Ident

UNLISTEN

UNLISTEN

stop listening for a notification

See Postgres https://www.postgresql.org/docs/current/sql-unlisten.html

Fields

channel: Ident

NOTIFY

NOTIFY channel [ , payload ]

send a notification event together with an optional “payload” string to channel

See Postgres https://www.postgresql.org/docs/current/sql-notify.html

Fields

channel: Ident

payload: Option<String>

LoadData

LOAD DATA [LOCAL] INPATH 'filepath' [OVERWRITE] INTO TABLE tablename
[PARTITION (partcol1=val1, partcol2=val2 ...)]
[INPUTFORMAT 'inputformat' SERDE 'serde']

Loading files into tables

See Hive https://cwiki.apache.org/confluence/pages/viewpage.action?pageId=27362036#LanguageManualDML-Loadingfilesintotables

Fields

local: bool

inpath: String

overwrite: bool

table_name: ObjectName

partitioned: Option<Vec<Expr>>

table_format: Option<HiveLoadDataFormat>

RenameTable(Vec<RenameTable>)

Rename TABLE tbl_name TO new_tbl_name[, tbl_name2 TO new_tbl_name2] ...

Renames one or more tables

See Mysql https://dev.mysql.com/doc/refman/9.1/en/rename-table.html

List(FileStagingCommand)

Snowflake LIST See: https://docs.snowflake.com/en/sql-reference/sql/list

Remove(FileStagingCommand)

Snowflake REMOVE See: https://docs.snowflake.com/en/sql-reference/sql/remove

RaisError

RaiseError (MSSQL) RAISERROR ( { msg_id | msg_str | @local_variable } { , severity , state } [ , argument [ , …n ] ] ) [ WITH option [ , …n ] ] See https://learn.microsoft.com/en-us/sql/t-sql/language-elements/raiserror-transact-sql?view=sql-server-ver16

Fields

message: Box<Expr>

severity: Box<Expr>

state: Box<Expr>

arguments: Vec<Expr>

options: Vec<RaisErrorOption>

Print(PrintStatement)

PRINT msg_str | @local_variable | string_expr

See: https://learn.microsoft.com/en-us/sql/t-sql/statements/print-transact-sql

Return(ReturnStatement)

RETURN [ expression ]

See ReturnStatement

Trait Implementations

impl Clone for Statement

fn clone(&self) -> Statement

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Statement

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Statement

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Statement

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

Formats the value using the given formatter.

impl From<Set> for Statement

Convert a Set into a Statement. Convenience function, instead of writing Statement::Set(Set::Set...{...})

fn from(set: Set) -> Self

Converts to this type from the input type.

impl Hash for Statement

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

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for Statement

fn cmp(&self, other: &Statement) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for Statement

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

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for Statement

fn partial_cmp(&self, other: &Statement) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for Statement

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Spanned for Statement

partial span

Missing spans:

• Statement::CopyIntoSnowflake
• Statement::CreateSecret
• Statement::CreateRole
• Statement::AlterType
• Statement::AlterRole
• Statement::AttachDatabase
• Statement::AttachDuckDBDatabase
• Statement::DetachDuckDBDatabase
• Statement::Drop
• Statement::DropFunction
• Statement::DropProcedure
• Statement::DropSecret
• Statement::Declare
• Statement::CreateExtension
• Statement::Fetch
• Statement::Flush
• Statement::Discard
• Statement::Set
• Statement::ShowFunctions
• Statement::ShowVariable
• Statement::ShowStatus
• Statement::ShowVariables
• Statement::ShowCreate
• Statement::ShowColumns
• Statement::ShowTables
• Statement::ShowCollation
• Statement::StartTransaction
• Statement::Comment
• Statement::Commit
• Statement::Rollback
• Statement::CreateSchema
• Statement::CreateDatabase
• Statement::CreateFunction
• Statement::CreateTrigger
• Statement::DropTrigger
• Statement::CreateProcedure
• Statement::CreateMacro
• Statement::CreateStage
• Statement::Assert
• Statement::Grant
• Statement::Revoke
• Statement::Deallocate
• Statement::Execute
• Statement::Prepare
• Statement::Kill
• Statement::ExplainTable
• Statement::Explain
• Statement::Savepoint
• Statement::ReleaseSavepoint
• Statement::Merge
• Statement::Cache
• Statement::UNCache
• Statement::CreateSequence
• Statement::CreateType
• Statement::Pragma
• Statement::LockTables
• Statement::UnlockTables
• Statement::Unload
• Statement::OptimizeTable

fn span(&self) -> Span

Return the Span (the minimum and maximum Location) for this AST node, by recursively combining the spans of its children.

impl TryFrom<Statement> for CreateTableBuilder

type Error = ParserError

The type returned in the event of a conversion error.

fn try_from(stmt: Statement) -> Result<Self, Self::Error>

Performs the conversion.

impl Visit for Statement

fn visit<V: Visitor>(&self, visitor: &mut V) -> ControlFlow<V::Break>

impl VisitMut for Statement

fn visit<V: VisitorMut>(&mut self, visitor: &mut V) -> ControlFlow<V::Break>

impl Eq for Statement

impl StructuralPartialEq for Statement