Enum sqlparser::ast::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,
    },
    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>,
        ignore: bool,
        into: bool,
        table_name: ObjectName,
        table_alias: Option<Ident>,
        columns: Vec<Ident>,
        overwrite: bool,
        source: Option<Box<Query>>,
        partitioned: Option<Vec<Expr>>,
        after_columns: Vec<Ident>,
        table: bool,
        on: Option<OnInsert>,
        returning: Option<Vec<SelectItem>>,
        replace_into: bool,
        priority: Option<MysqlInsertPriority>,
    
},
    Install {
        extension_name: Ident,
    },
    Load {
        extension_name: Ident,
    },
    Directory {
        overwrite: bool,
        local: bool,
        path: String,
        file_format: Option<FileFormat>,
        source: Box<Query>,
    },
    Call(Function),
    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: FromTable,
        using: Option<Vec<TableWithJoins>>,
        selection: Option<Expr>,
        returning: Option<Vec<SelectItem>>,
        order_by: Vec<OrderByExpr>,
        limit: Option<Expr>,
    },
    CreateView {
        or_replace: bool,
        materialized: bool,
        name: ObjectName,
        columns: Vec<ViewColumnDef>,
        query: Box<Query>,
        options: CreateTableOptions,
        cluster_by: Vec<Ident>,
        with_no_schema_binding: bool,
        if_not_exists: bool,
        temporary: bool,
    },
    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>,
        comment: Option<String>,
        auto_increment_offset: Option<u32>,
        default_charset: Option<String>,
        collation: Option<String>,
        on_commit: Option<OnCommit>,
        on_cluster: Option<String>,
        order_by: Option<Vec<Ident>>,
        partition_by: Option<Box<Expr>>,
        cluster_by: Option<Vec<Ident>>,
        options: Option<Vec<SqlOption>>,
        strict: bool,
    
},
    CreateVirtualTable {
        name: ObjectName,
        if_not_exists: bool,
        module_name: Ident,
        module_args: Vec<Ident>,
    },
    CreateIndex {
        name: Option<ObjectName>,
        table_name: ObjectName,
        using: Option<Ident>,
        columns: Vec<OrderByExpr>,
        unique: bool,
        concurrently: bool,
        if_not_exists: bool,
        include: Vec<Ident>,
        nulls_distinct: Option<bool>,
        predicate: Option<Expr>,
    },
    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,
        if_exists: bool,
        only: bool,
        operations: Vec<AlterTableOperation>,
        location: Option<HiveSetLocation>,
    },
    AlterIndex {
        name: ObjectName,
        operation: AlterIndexOperation,
    },
    AlterView {
        name: ObjectName,
        columns: Vec<Ident>,
        query: Box<Query>,
        with_options: Vec<SqlOption>,
    },
    AlterRole {
        name: Ident,
        operation: AlterRoleOperation,
    },
    AttachDatabase {
        schema_name: Ident,
        database_file_name: Expr,
        database: bool,
    },
    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<DropFunctionDesc>,
        option: Option<ReferentialAction>,
    },
    Declare {
        stmts: Vec<Declare>,
    },
    CreateExtension {
        name: Ident,
        if_not_exists: bool,
        cascade: bool,
        schema: Option<Ident>,
        version: Option<Ident>,
    },
    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,
    },
    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>,
    },
    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,
        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>,
        begin: bool,
        modifier: Option<TransactionModifier>,
    },
    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,
        savepoint: Option<Ident>,
    },
    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,
    },
    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: 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>,
        using: Vec<Expr>,
    },
    Prepare {
        name: Ident,
        data_types: Vec<DataType>,
        statement: Box<Statement>,
    },
    Kill {
        modifier: Option<KillType>,
        id: u64,
    },
    ExplainTable {
        describe_alias: DescribeAlias,
        hive_format: Option<HiveDescribeFormat>,
        table_name: ObjectName,
    },
    Explain {
        describe_alias: DescribeAlias,
        analyze: bool,
        verbose: bool,
        statement: Box<Statement>,
        format: Option<AnalyzeFormat>,
    },
    Savepoint {
        name: Ident,
    },
    ReleaseSavepoint {
        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>,
    },
    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>,
    },
}

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

Variants

Analyze

Fields

table_name: ObjectName

partitions: Option<Vec<Expr>>

for_columns: bool

columns: Vec<Ident>

cache_metadata: bool

noscan: bool

compute_statistics: bool

ANALYZE

Analyze (Hive)

Truncate

Fields

table_name: ObjectName

partitions: Option<Vec<Expr>>

table: bool

TABLE - optional keyword;

TRUNCATE

Truncate (Hive)

Msck

Fields

table_name: ObjectName

repair: bool

partition_action: Option<AddDropSync>

MSCK

Msck (Hive)

Query(Box<Query>)

SELECT

Insert

Fields

or: Option<SqliteOnConflict>

Only for Sqlite

ignore: bool

Only for mysql

into: bool

INTO - optional keyword

table_name: ObjectName

TABLE

table_alias: Option<Ident>

table_name as foo (for PostgreSQL)

columns: Vec<Ident>

COLUMNS

overwrite: bool

Overwrite (Hive)

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

replace_into: bool

Only for mysql

priority: Option<MysqlInsertPriority>

Only for mysql

INSERT

Install

Fields

extension_name: Ident

Only for DuckDB

INSTALL

Load

Fields

extension_name: Ident

Only for DuckDB

LOAD

Directory

Fields

overwrite: bool

local: bool

path: String

file_format: Option<FileFormat>

source: Box<Query>

Call(Function)

CALL <function>

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

COPY [TO | FROM] ...

CopyIntoSnowflake

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>

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.

Close

Fields

cursor: CloseCursor

Cursor name

CLOSE

Closes the portal underlying an open cursor.

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

UPDATE

Delete

Fields

tables: Vec<ObjectName>

Multi tables delete are supported in mysql

from: FromTable

FROM

using: Option<Vec<TableWithJoins>>

USING (Snowflake, Postgres, MySQL)

selection: Option<Expr>

WHERE

returning: Option<Vec<SelectItem>>

RETURNING

order_by: Vec<OrderByExpr>

ORDER BY (MySQL)

limit: Option<Expr>

LIMIT (MySQL)

DELETE

CreateView

Fields

or_replace: bool

materialized: bool

name: ObjectName

View name

columns: Vec<ViewColumnDef>

query: Box<Query>

options: CreateTableOptions

cluster_by: Vec<Ident>

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

CREATE VIEW

CreateTable

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>

comment: Option<String>

auto_increment_offset: Option<u32>

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/

partition_by: Option<Box<Expr>>

BigQuery: A partition expression for the table. https://cloud.google.com/bigquery/docs/reference/standard-sql/data-definition-language#partition_expression

cluster_by: Option<Vec<Ident>>

BigQuery: Table clustering column list. https://cloud.google.com/bigquery/docs/reference/standard-sql/data-definition-language#table_option_list

options: Option<Vec<SqlOption>>

BigQuery: Table options list. https://cloud.google.com/bigquery/docs/reference/standard-sql/data-definition-language#table_option_list

strict: bool

SQLite “STRICT” clause. if the “STRICT” table-option keyword is added to the end, after the closing “)”, then strict typing rules apply to that table.

CREATE TABLE

CreateVirtualTable

Fields

name: ObjectName

if_not_exists: bool

module_name: Ident

module_args: Vec<Ident>

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

Sqlite specific statement

CreateIndex

Fields

name: Option<ObjectName>

index name

table_name: ObjectName

using: Option<Ident>

columns: Vec<OrderByExpr>

unique: bool

concurrently: bool

if_not_exists: bool

include: Vec<Ident>

nulls_distinct: Option<bool>

predicate: Option<Expr>

`CREATE INDEX`

CreateRole

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>

CREATE ROLE

See postgres

AlterTable

Fields

name: ObjectName

Table name

if_exists: bool

only: bool

operations: Vec<AlterTableOperation>

location: Option<HiveSetLocation>

ALTER TABLE

AlterIndex

Fields

name: ObjectName

operation: AlterIndexOperation

ALTER INDEX

AlterView

Fields

name: ObjectName

View name

columns: Vec<Ident>

query: Box<Query>

with_options: Vec<SqlOption>

ALTER VIEW

AlterRole

Fields

name: Ident

operation: AlterRoleOperation

ALTER ROLE

AttachDatabase

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’

ATTACH DATABASE 'path/to/file' AS alias

(SQLite-specific)

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

temporary: bool

MySQL-specific “TEMPORARY” keyword

DROP [TABLE, VIEW, ...]

DropFunction

Fields

if_exists: bool

func_desc: Vec<DropFunctionDesc>

One or more function to drop

option: Option<ReferentialAction>

CASCADE or RESTRICT

DROP FUNCTION

Declare

Fields

stmts: Vec<Declare>

DECLARE

Declare Cursor Variables

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

CreateExtension

Fields

name: Ident

if_not_exists: bool

cascade: bool

schema: Option<Ident>

version: Option<Ident>

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

Note: this is a PostgreSQL-specific statement,

Fetch

Fields

name: Ident

Cursor name

direction: FetchDirection

into: Option<ObjectName>

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

FETCH

Retrieve rows from a query using a cursor

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

Flush

Fields

object_type: FlushType

location: Option<FlushLocation>

channel: Option<String>

read_lock: bool

export: bool

tables: Vec<ObjectName>

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.

Discard

Fields

object_type: DiscardObject

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

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

SetRole

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.

SET [ SESSION | LOCAL ] ROLE role_name

Sets sesssion state. Examples: ANSI, Postgresql, MySQL, and Oracle

SetVariable

Fields

local: bool

hivevar: bool

variable: ObjectName

value: Vec<Expr>

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.

SetTimeZone

Fields

local: bool

value: Expr

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

SetNames

Fields

charset_name: String

collation_name: Option<String>

SET NAMES 'charset_name' [COLLATE 'collation_name']

Note: this is a MySQL-specific statement.

SetNamesDefault

SET NAMES DEFAULT

Note: this is a MySQL-specific statement.

ShowFunctions

Fields

filter: Option<ShowStatementFilter>

SHOW FUNCTIONS

Note: this is a Presto-specific statement.

ShowVariable

Fields

variable: Vec<Ident>

SHOW <variable>

Note: this is a PostgreSQL-specific statement.

ShowStatus

Fields

filter: Option<ShowStatementFilter>

global: bool

session: bool

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

Note: this is a MySQL-specific statement.

ShowVariables

Fields

filter: Option<ShowStatementFilter>

global: bool

session: bool

SHOW VARIABLES

Note: this is a MySQL-specific statement.

ShowCreate

Fields

obj_type: ShowCreateObject

obj_name: ObjectName

SHOW CREATE TABLE

Note: this is a MySQL-specific statement.

ShowColumns

Fields

extended: bool

full: bool

table_name: ObjectName

filter: Option<ShowStatementFilter>

SHOW COLUMNS

Note: this is a MySQL-specific statement.

ShowTables

Fields

extended: bool

full: bool

db_name: Option<Ident>

filter: Option<ShowStatementFilter>

SHOW TABLES

Note: this is a MySQL-specific statement.

ShowCollation

Fields

filter: Option<ShowStatementFilter>

SHOW COLLATION

Note: this is a MySQL-specific statement.

Use

Fields

db_name: Ident

USE

Note: This is a MySQL-specific statement.

StartTransaction

Fields

modes: Vec<TransactionMode>

begin: bool

modifier: Option<TransactionModifier>

Only for SQLite

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

If begin is false.

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

If begin is true

SetTransaction

Fields

modes: Vec<TransactionMode>

snapshot: Option<Value>

session: bool

SET TRANSACTION ...

Comment

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

COMMENT ON ...

Note: this is a PostgreSQL-specific statement.

Commit

Fields

chain: bool

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

Rollback

Fields

chain: bool

savepoint: Option<Ident>

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

CreateSchema

Fields

schema_name: SchemaName

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

if_not_exists: bool

CREATE SCHEMA

CreateDatabase

Fields

db_name: ObjectName

if_not_exists: bool

location: Option<String>

managed_location: Option<String>

CREATE DATABASE

CreateFunction

Fields

or_replace: bool

temporary: bool

name: ObjectName

args: Option<Vec<OperateFunctionArg>>

return_type: Option<DataType>

params: CreateFunctionBody

Optional parameters.

CREATE FUNCTION

Supported variants:

1. Hive
2. Postgres

CreateProcedure

Fields

or_alter: bool

name: ObjectName

params: Option<Vec<ProcedureParam>>

body: Vec<Statement>

CREATE PROCEDURE

CreateMacro

Fields

or_replace: bool

temporary: bool

name: ObjectName

args: Option<Vec<MacroArg>>

definition: MacroDefinition

CREATE MACRO

Supported variants:

1. DuckDB

CreateStage

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>

CREATE STAGE

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

Assert

Fields

condition: Expr

message: Option<Expr>

ASSERT <condition> [AS <message>]

Grant

Fields

privileges: Privileges

objects: GrantObjects

grantees: Vec<Ident>

with_grant_option: bool

granted_by: Option<Ident>

GRANT privileges ON objects TO grantees

Revoke

Fields

privileges: Privileges

objects: GrantObjects

grantees: Vec<Ident>

granted_by: Option<Ident>

cascade: bool

REVOKE privileges ON objects FROM grantees

Deallocate

Fields

name: Ident

prepare: bool

DEALLOCATE [ PREPARE ] { name | ALL }

Note: this is a PostgreSQL-specific statement.

Execute

Fields

name: Ident

parameters: Vec<Expr>

using: Vec<Expr>

EXECUTE name [ ( parameter [, ...] ) ] [USING <expr>]

Note: this is a PostgreSQL-specific statement.

Prepare

Fields

name: Ident

data_types: Vec<DataType>

statement: Box<Statement>

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

Note: this is a PostgreSQL-specific statement.

Kill

Fields

modifier: Option<KillType>

id: u64

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

ExplainTable

Fields

describe_alias: DescribeAlias

EXPLAIN | DESC | DESCRIBE

hive_format: Option<HiveDescribeFormat>

Hive style FORMATTED | EXTENDED

table_name: ObjectName

Table name

[EXPLAIN | DESC | DESCRIBE] TABLE

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

Explain

Fields

describe_alias: DescribeAlias

EXPLAIN | DESC | DESCRIBE

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

[EXPLAIN | DESC | DESCRIBE]  <statement>

Savepoint

Fields

name: Ident

SAVEPOINT

Define a new savepoint within the current transaction

ReleaseSavepoint

Fields

name: Ident

RELEASE [ SAVEPOINT ] savepoint_name

Merge

Fields

into: bool

table: TableFactor

source: TableFactor

on: Box<Expr>

clauses: Vec<MergeClause>

MERGE INTO <statement>

Based on Snowflake. See https://docs.snowflake.com/en/sql-reference/sql/merge.html

Cache

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

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

See Spark SQL docs for more details.

UNCache

Fields

table_name: ObjectName

Table name

if_exists: bool

UNCACHE TABLE [ IF EXISTS ]  <table_name>

CreateSequence

Fields

temporary: bool

if_not_exists: bool

name: ObjectName

data_type: Option<DataType>

sequence_options: Vec<SequenceOptions>

owned_by: Option<ObjectName>

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

Define a new sequence:

CreateType

Fields

name: ObjectName

representation: UserDefinedTypeRepresentation

CREATE TYPE <name>

Pragma

Fields

name: ObjectName

value: Option<Value>

is_eq: bool

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

LockTables

Fields

tables: Vec<LockTable>

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

UnlockTables

UNLOCK TABLES

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

Unload

Fields

query: Box<Query>

to: Ident

with: Vec<SqlOption>

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

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

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 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 + PartialOrd,

Restrict a value to a certain interval.

impl PartialEq for Statement

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

This method tests for self and other values to be equal, and is used by ==.

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

This method 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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method 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 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