Statement in sqlparser::ast

Statement in sqlparser::ast - Rust

pub enum Statement {
Show 127 variants
    Analyze(Analyze),
    Set(Set),
    Truncate(Truncate),
    Msck(Msck),
    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),
    While(WhileStatement),
    Raise(RaiseStatement),
    Call(Function),
    Copy {
        source: CopySource,
        to: bool,
        target: CopyTarget,
        options: Vec<CopyOption>,
        legacy_options: Vec<CopyLegacyOption>,
        values: Vec<Option<String>>,
    },
    CopyIntoSnowflake {Show 14 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>>,
    },
    Open(OpenStatement),
    Close {
        cursor: CloseCursor,
    },
    Update(Update),
    Delete(Delete),
    CreateView(CreateView),
    CreateTable(CreateTable),
    CreateVirtualTable {
        name: ObjectName,
        if_not_exists: bool,
        module_name: Ident,
        module_args: Vec<Ident>,
    },
    CreateIndex(CreateIndex),
    CreateRole(CreateRole),
    CreateSecret {
        or_replace: bool,
        temporary: Option<bool>,
        if_not_exists: bool,
        name: Option<Ident>,
        storage_specifier: Option<Ident>,
        secret_type: Ident,
        options: Vec<SecretOption>,
    },
    CreateServer(CreateServerStatement),
    CreatePolicy(CreatePolicy),
    CreateConnector(CreateConnector),
    CreateOperator(CreateOperator),
    CreateOperatorFamily(CreateOperatorFamily),
    CreateOperatorClass(CreateOperatorClass),
    AlterTable(AlterTable),
    AlterSchema(AlterSchema),
    AlterIndex {
        name: ObjectName,
        operation: AlterIndexOperation,
    },
    AlterView {
        name: ObjectName,
        columns: Vec<Ident>,
        query: Box<Query>,
        with_options: Vec<SqlOption>,
    },
    AlterType(AlterType),
    AlterOperator(AlterOperator),
    AlterOperatorFamily(AlterOperatorFamily),
    AlterOperatorClass(AlterOperatorClass),
    AlterRole {
        name: Ident,
        operation: AlterRoleOperation,
    },
    AlterPolicy(AlterPolicy),
    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,
        table: Option<ObjectName>,
    },
    DropFunction(DropFunction),
    DropDomain(DropDomain),
    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(DropPolicy),
    DropConnector {
        if_exists: bool,
        name: Ident,
    },
    Declare {
        stmts: Vec<Declare>,
    },
    CreateExtension(CreateExtension),
    DropExtension(DropExtension),
    DropOperator(DropOperator),
    DropOperatorFamily(DropOperatorFamily),
    DropOperatorClass(DropOperatorClass),
    Fetch {
        name: Ident,
        direction: FetchDirection,
        position: FetchPosition,
        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,
    },
    ShowCharset(ShowCharset),
    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: Option<Vec<ExceptionWhen>>,
        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,
        with: Option<Vec<SqlOption>>,
        options: Option<Vec<SqlOption>>,
        default_collate_spec: Option<Expr>,
        clone: Option<ObjectName>,
    },
    CreateDatabase {Show 22 fields
        db_name: ObjectName,
        if_not_exists: bool,
        location: Option<String>,
        managed_location: Option<String>,
        or_replace: bool,
        transient: bool,
        clone: Option<ObjectName>,
        data_retention_time_in_days: Option<u64>,
        max_data_extension_time_in_days: Option<u64>,
        external_volume: Option<String>,
        catalog: Option<String>,
        replace_invalid_characters: Option<bool>,
        default_ddl_collation: Option<String>,
        storage_serialization_policy: Option<StorageSerializationPolicy>,
        comment: Option<String>,
        default_charset: Option<String>,
        default_collation: Option<String>,
        catalog_sync: Option<String>,
        catalog_sync_namespace_mode: Option<CatalogSyncNamespaceMode>,
        catalog_sync_namespace_flatten_delimiter: Option<String>,
        with_tags: Option<Vec<Tag>>,
        with_contacts: Option<Vec<ContactEntry>>,
    },
    CreateFunction(CreateFunction),
    CreateTrigger(CreateTrigger),
    DropTrigger(DropTrigger),
    CreateProcedure {
        or_alter: bool,
        name: ObjectName,
        params: Option<Vec<ProcedureParam>>,
        language: Option<Ident>,
        body: ConditionalStatements,
    },
    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(Grant),
    Deny(DenyStatement),
    Revoke(Revoke),
    Deallocate {
        name: Ident,
        prepare: bool,
    },
    Execute {
        name: Option<ObjectName>,
        parameters: Vec<Expr>,
        has_parentheses: bool,
        immediate: bool,
        into: Vec<Ident>,
        using: Vec<ExprWithAlias>,
        output: bool,
        default: bool,
    },
    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<AnalyzeFormatKind>,
        options: Option<Vec<UtilityOption>>,
    },
    Savepoint {
        name: Ident,
    },
    ReleaseSavepoint {
        name: Ident,
    },
    Merge(Merge),
    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>,
    },
    CreateDomain(CreateDomain),
    CreateType {
        name: ObjectName,
        representation: Option<UserDefinedTypeRepresentation>,
    },
    Pragma {
        name: ObjectName,
        value: Option<Value>,
        is_eq: bool,
    },
    LockTables {
        tables: Vec<LockTable>,
    },
    UnlockTables,
    Unload {
        query: Option<Box<Query>>,
        query_text: Option<String>,
        to: Ident,
        auth: Option<IamRoleKind>,
        with: Vec<SqlOption>,
        options: Vec<CopyLegacyOption>,
    },
    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),
    ExportData(ExportData),
    CreateUser(CreateUser),
    AlterUser(AlterUser),
    Vacuum(VacuumStatement),
    Reset(ResetStatement),
}

Expand description

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

SET statements (session, transaction, timezone, etc.).

Fields

LOAD DATA from a directory or query source.

Fields

Whether to overwrite existing files.

Whether the directory is local to the server.

Path to the directory or files.

Optional file format for the data.

Source query providing data to load.

A CASE statement.

An IF statement.

A WHILE statement.

A RAISE statement.

Fields

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

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

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

WITH options (from PostgreSQL version 9.0)

WITH options (before PostgreSQL version 9.0)

VALUES a vector of values to be copied

Fields

Kind of COPY INTO operation (table or location).

Target object for the COPY INTO operation.

Optional source object name (staged data).

Optional alias for the source object.

Stage-specific parameters (e.g., credentials, path).

Optional list of transformations applied when loading.

Optional source query instead of a staged object.

Optional list of specific file names to load.

Optional filename matching pattern.

Optional validation mode string.

Optional partition expression for loading.

Closes the portal underlying an open cursor.

Fields

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

Sqlite specific statement

Fields

Name of the virtual table module instance.

true when IF NOT EXISTS was specified.

Module name used by the virtual table.

Arguments passed to the module.

Fields

true when OR REPLACE was specified.

true when IF NOT EXISTS was present.

Optional storage specifier identifier.

The secret type identifier.

Additional secret options.

A CREATE SERVER statement.

Fields

Name of the index to alter.

The operation to perform on the index.

Fields

§columns: Vec<Ident>

Optional new column list for the view.

Replacement query for the view definition.

Additional WITH options for the view.

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

Fields

Operation to perform on the role.

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

(Postgresql-specific)

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 of the connector to alter.

Optional connector properties to set.

Optional new URL for the connector.

Optional new owner specification.

Fields

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

The session parameters to set or unset

ATTACH DATABASE 'path/to/file' AS alias

(SQLite-specific)

Fields

The name to bind to the newly attached database

An expression that indicates the path to the database file

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

Fields

true when IF NOT EXISTS was present.

true if the syntax used ATTACH DATABASE rather than ATTACH.

The path identifier to the database file being attached.

Optional alias assigned to the attached database.

Dialect-specific attach options (e.g., READ_ONLY).

Fields

true when IF EXISTS was present.

true if the syntax used DETACH DATABASE rather than DETACH.

Alias of the database to detach.

Fields

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

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

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

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

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

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

MySQL-specific “TEMPORARY” keyword

See PostgreSQL

DROP DOMAIN [ IF EXISTS ] name [, …] [ CASCADE | RESTRICT ]

Fields

true when IF EXISTS was present.

One or more functions/procedures to drop.

Optional drop behavior (CASCADE or RESTRICT).

Fields

true when IF EXISTS was present.

Optional TEMPORARY marker.

Name of the secret to drop.

Optional storage specifier identifier.

Fields

true when IF EXISTS was present.

Name of the connector to drop.

Declare Cursor Variables

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

Fields

Cursor declaration statements collected by DECLARE.

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

Note: this is a PostgreSQL-specific statement,

Retrieve rows from a query using a cursor

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

Fields

The fetch direction (e.g., FORWARD, BACKWARD).

The fetch position (e.g., ALL, NEXT, ABSOLUTE).

Optional target table to fetch rows into.

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

The specific flush option or object to flush.

Optional flush location (dialect-specific).

Optional channel name used for flush operations.

Whether a read lock was requested.

Whether this is an export flush operation.

Optional list of tables involved in the flush.

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

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

Fields

The kind of object(s) to discard (ALL, PLANS, etc.).

SHOW FUNCTIONS

Note: this is a Presto-specific statement.

Fields

Optional filter for which functions to display.

Note: this is a PostgreSQL-specific statement.

Fields

Variable name as one or more identifiers.

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

Note: this is a MySQL-specific statement.

Fields

Optional filter for which status entries to display.

true when GLOBAL scope was requested.

true when SESSION scope was requested.

Note: this is a MySQL-specific statement.

Fields

Optional filter for which variables to display.

true when GLOBAL scope was requested.

true when SESSION scope was requested.

Note: this is a MySQL-specific statement.

Fields

The kind of object being shown (TABLE, VIEW, etc.).

The name of the object to show create statement for.

Fields

§extended: bool

true when extended column information was requested.

§full: bool

true when full column details were requested.

Fields

true when terse output format was requested.

true when history information was requested.

Additional options for SHOW DATABASES.

Fields

true when terse (compact) output was requested.

true when history information was requested.

Additional options for SHOW SCHEMAS.

Show the available character sets (alias CHARSET).

Fields

true when terse output format was requested (compact listing).

true when history rows are requested.

true when extended information should be shown.

true when a full listing was requested.

true when external tables should be included.

Additional options for SHOW statements.

Fields

true when terse output format was requested.

true when materialized views should be included.

Additional options for SHOW statements.

Note: this is a MySQL-specific statement.

Fields

Optional filter for which collations to display.

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

If begin is false.

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

If begin is true

Fields

Transaction modes such as ISOLATION LEVEL or READ WRITE.

true when this was parsed as BEGIN instead of START.

Optional specific keyword used: TRANSACTION or WORK.

Optional transaction modifier (e.g., AND NO CHAIN).

List of statements belonging to the BEGIN block. Example:

BEGIN
    SELECT 1;
    SELECT 2;
END;

TRUE if the statement has an END keyword.

Note: this is a PostgreSQL-specific statement.

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

If end is false

If end is true

Fields

true when AND [ NO ] CHAIN was present.

true when this COMMIT was parsed as an END block terminator.

Optional transaction modifier for commit semantics.

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

Fields

true when AND [ NO ] CHAIN was present.

Optional savepoint name to roll back to.

Fields

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

true when IF NOT EXISTS was present.

Schema properties.

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

Trino

Schema options.

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

BigQuery

Default collation specification for the schema.

CREATE SCHEMA myschema DEFAULT COLLATE 'und:ci';

BigQuery

Clones a schema

CREATE SCHEMA myschema CLONE otherschema

Snowflake

Fields

Optional managed location.

Optional data retention time in days.

Optional maximum data extension time in days.

Optional external volume identifier.

Whether to replace invalid characters.

Default DDL collation string.

Storage serialization policy.

Optional default character set (MySQL).

Optional default collation (MySQL).

Optional catalog sync identifier.

Catalog sync namespace mode.

Optional flatten delimiter for namespace sync.

Optional tags for the database.

Optional contact entries for the database.

CREATE TRIGGER statement. See struct CreateTrigger for details.

DROP TRIGGER statement. See struct DropTrigger for details.

Fields

Optional procedure parameters.

Optional language identifier.

Fields

Whether macro is temporary.

Optional macro arguments.

Fields

OR REPLACE flag for stage.

Whether stage is temporary.

Directory table parameters.

ASSERT <condition> [AS <message>]

Fields

Assertion condition expression.

Optional message expression.

GRANT privileges ON objects TO grantees

DENY privileges ON object TO grantees

REVOKE privileges ON objects FROM grantees

DEALLOCATE [ PREPARE ] { name | ALL }

Note: this is a PostgreSQL-specific statement.

Fields

Name to deallocate (or ALL).

Whether PREPARE keyword was present.

Fields

Optional function/procedure name.

Parameter expressions passed to execute.

Whether parentheses were present.

Is this an EXECUTE IMMEDIATE.

Identifiers to capture results into.

USING expressions with optional aliases.

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

Note: this is a PostgreSQL-specific statement.

Fields

Name of the prepared statement.

Optional data types for parameters.

Statement being prepared.

Fields

Optional kill modifier (CONNECTION, QUERY, MUTATION).

The id of the process to kill.

Fields

EXPLAIN | DESC | DESCRIBE

Hive style FORMATTED | EXTENDED

[EXPLAIN | DESC | DESCRIBE]  <statement>

Fields

EXPLAIN | DESC | DESCRIBE

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

Display additional information regarding the plan.

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

SQLite

A SQL query that specifies what to explain

Optional output format of explain

Postgres style utility options, (analyze, verbose true)

Define a new savepoint within the current transaction

Fields

Name of the savepoint being defined.

RELEASE [ SAVEPOINT ] savepoint_name

Fields

Name of the savepoint to release.

A MERGE statement.

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

Snowflake BigQuery MSSQL

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

See Spark SQL docs for more details.

Fields

true if AS keyword was present before the query.

UNCACHE TABLE [ IF EXISTS ]  <table_name>

Fields

true when IF EXISTS was present.

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

Define a new sequence:

Fields

Whether the sequence is temporary.

Optional data type for the sequence.

Sequence options (INCREMENT, MINVALUE, etc.).

Optional OWNED BY target.

A CREATE DOMAIN statement.

Fields

Optional type representation details.

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

Fields

Pragma name (possibly qualified).

Whether the pragma used =.

Fields

List of tables to lock with modes.

Unloads the result of a query to file

Athena:

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

Redshift:

UNLOAD('statement') TO <destination> [ OPTIONS ]

Fields

Optional query AST to unload.

Optional original query text.

Optional IAM role/auth information.

Legacy copy-style options.

Fields

Optional cluster identifier.

Whether FINAL was specified.

Optional deduplication settings.

Fields

Notification channel identifier.

Fields

Notification channel identifier.

Fields

Notification channel identifier.

Fields

Whether LOCAL is present.

Input path for files to load.

Whether OVERWRITE was specified.

Target table name to load into.

Optional partition specification.

Optional table format information.

Fields

Error message expression or identifier.

Substitution arguments for the message.

Additional WITH options for RAISERROR.

Export data statement

Example:

EXPORT DATA OPTIONS(uri='gs://bucket/folder/*', format='PARQUET', overwrite=true) AS
SELECT field1, field2 FROM mydataset.table1 ORDER BY field1 LIMIT 10

BigQuery

CREATE [OR REPLACE] USER <user> [IF NOT EXISTS]

Snowflake

ALTER USER \[ IF EXISTS \] \[ <name> \]

Snowflake

Re-sorts rows and reclaims space in either a specified table or all tables in the current database

Redshift

Restore the value of a run-time parameter to the default value.

RESET configuration_parameter;
RESET ALL;

PostgreSQL

Source §

Formats a SQL statement with support for pretty printing.

When using the alternate flag ({:#}), the statement will be formatted with proper indentation and line breaks. For example:

let sql = "SELECT a, b FROM table_1";
let ast = Parser::parse_sql(&GenericDialect, sql).unwrap();

// Regular formatting
assert_eq!(format!("{}", ast[0]), "SELECT a, b FROM table_1");

// Pretty printing
assert_eq!(format!("{:#}", ast[0]),
r#"SELECT
  a,
  b
FROM
  table_1"#);

Source §