Enum Statement

pub enum Statement {
    Analyze {
        table_name: ObjectName,
    },
    Truncate {
        table_name: ObjectName,
    },
    Query(Box<Query>),
    Insert {
        table_name: ObjectName,
        columns: Vec<Ident>,
        source: Box<Query>,
        returning: Vec<SelectItem>,
    },
    Copy {
        table_name: ObjectName,
        columns: Vec<Ident>,
        values: Vec<Option<String>>,
    },
    Update {
        table_name: ObjectName,
        assignments: Vec<Assignment>,
        selection: Option<Expr>,
        returning: Vec<SelectItem>,
    },
    Delete {
        table_name: ObjectName,
        selection: Option<Expr>,
        returning: Vec<SelectItem>,
    },
    Discard(DiscardType),
    CreateView {
        or_replace: bool,
        materialized: bool,
        if_not_exists: bool,
        name: ObjectName,
        columns: Vec<Ident>,
        query: Box<Query>,
        emit_mode: Option<EmitMode>,
        with_options: Vec<SqlOption>,
    },
    CreateTable {

        or_replace: bool,
        temporary: bool,
        if_not_exists: bool,
        name: ObjectName,
        columns: Vec<ColumnDef>,
        wildcard_idx: Option<usize>,
        constraints: Vec<TableConstraint>,
        with_options: Vec<SqlOption>,
        format_encode: Option<CompatibleFormatEncode>,
        source_watermarks: Vec<SourceWatermark>,
        append_only: bool,
        on_conflict: Option<OnConflict>,
        with_version_column: Option<String>,
        query: Option<Box<Query>>,
        cdc_table_info: Option<CdcTableInfo>,
        include_column_options: IncludeOption,
    
},
    CreateIndex {
        name: ObjectName,
        table_name: ObjectName,
        columns: Vec<OrderByExpr>,
        include: Vec<Ident>,
        distributed_by: Vec<Expr>,
        unique: bool,
        if_not_exists: bool,
    },
    CreateSource {
        stmt: CreateSourceStatement,
    },
    CreateSink {
        stmt: CreateSinkStatement,
    },
    CreateSubscription {
        stmt: CreateSubscriptionStatement,
    },
    CreateConnection {
        stmt: CreateConnectionStatement,
    },
    CreateSecret {
        stmt: CreateSecretStatement,
    },
    CreateFunction {
        or_replace: bool,
        temporary: bool,
        name: ObjectName,
        args: Option<Vec<OperateFunctionArg>>,
        returns: Option<CreateFunctionReturns>,
        params: CreateFunctionBody,
        with_options: CreateFunctionWithOptions,
    },
    CreateAggregate {
        or_replace: bool,
        name: ObjectName,
        args: Vec<OperateFunctionArg>,
        returns: DataType,
        append_only: bool,
        params: CreateFunctionBody,
    },
    DeclareCursor {
        stmt: DeclareCursorStatement,
    },
    FetchCursor {
        stmt: FetchCursorStatement,
    },
    CloseCursor {
        stmt: CloseCursorStatement,
    },
    AlterDatabase {
        name: ObjectName,
        operation: AlterDatabaseOperation,
    },
    AlterSchema {
        name: ObjectName,
        operation: AlterSchemaOperation,
    },
    AlterTable {
        name: ObjectName,
        operation: AlterTableOperation,
    },
    AlterIndex {
        name: ObjectName,
        operation: AlterIndexOperation,
    },
    AlterView {
        name: ObjectName,
        materialized: bool,
        operation: AlterViewOperation,
    },
    AlterSink {
        name: ObjectName,
        operation: AlterSinkOperation,
    },
    AlterSubscription {
        name: ObjectName,
        operation: AlterSubscriptionOperation,
    },
    AlterSource {
        name: ObjectName,
        operation: AlterSourceOperation,
    },
    AlterFunction {
        name: ObjectName,
        args: Option<Vec<OperateFunctionArg>>,
        operation: AlterFunctionOperation,
    },
    AlterConnection {
        name: ObjectName,
        operation: AlterConnectionOperation,
    },
    Describe {
        name: ObjectName,
    },
    ShowObjects {
        object: ShowObject,
        filter: Option<ShowStatementFilter>,
    },
    ShowCreateObject {
        create_type: ShowCreateType,
        name: ObjectName,
    },
    ShowTransactionIsolationLevel,
    CancelJobs(JobIdents),
    Kill(i32),
    Drop(DropStatement),
    DropFunction {
        if_exists: bool,
        func_desc: Vec<FunctionDesc>,
        option: Option<ReferentialAction>,
    },
    DropAggregate {
        if_exists: bool,
        func_desc: Vec<FunctionDesc>,
        option: Option<ReferentialAction>,
    },
    SetVariable {
        local: bool,
        variable: Ident,
        value: SetVariableValue,
    },
    ShowVariable {
        variable: Vec<Ident>,
    },
    StartTransaction {
        modes: Vec<TransactionMode>,
    },
    Begin {
        modes: Vec<TransactionMode>,
    },
    Abort,
    SetTransaction {
        modes: Vec<TransactionMode>,
        snapshot: Option<Value>,
        session: bool,
    },
    SetTimeZone {
        local: bool,
        value: SetTimeZoneValue,
    },
    Comment {
        object_type: CommentObject,
        object_name: ObjectName,
        comment: Option<String>,
    },
    Commit {
        chain: bool,
    },
    Rollback {
        chain: bool,
    },
    CreateSchema {
        schema_name: ObjectName,
        if_not_exists: bool,
        owner: Option<ObjectName>,
    },
    CreateDatabase {
        db_name: ObjectName,
        if_not_exists: bool,
        owner: Option<ObjectName>,
    },
    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>,
        revoke_grant_option: bool,
        cascade: bool,
    },
    Deallocate {
        name: Ident,
        prepare: bool,
    },
    Execute {
        name: Ident,
        parameters: Vec<Expr>,
    },
    Prepare {
        name: Ident,
        data_types: Vec<DataType>,
        statement: Box<Statement>,
    },
    Explain {
        analyze: bool,
        statement: Box<Statement>,
        options: ExplainOptions,
    },
    CreateUser(CreateUserStatement),
    AlterUser(AlterUserStatement),
    AlterSystem {
        param: Ident,
        value: SetVariableValue,
    },
    Flush,
    Wait,
    Recover,
}

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

Variants

Analyze

Analyze (Hive)

Fields

table_name: ObjectName

Truncate

Truncate (Hive)

Fields

table_name: ObjectName

Query(Box<Query>)

SELECT

Insert

INSERT

Fields

table_name: ObjectName

TABLE

columns: Vec<Ident>

COLUMNS

source: Box<Query>

A SQL query that specifies what to insert

returning: Vec<SelectItem>

Define output of this insert statement

Copy

Fields

table_name: ObjectName

TABLE

columns: Vec<Ident>

COLUMNS

values: Vec<Option<String>>

VALUES a vector of values to be copied

Update

UPDATE

Fields

table_name: ObjectName

TABLE

assignments: Vec<Assignment>

Column assignments

selection: Option<Expr>

WHERE

returning: Vec<SelectItem>

RETURNING

Delete

DELETE

Fields

table_name: ObjectName

FROM

selection: Option<Expr>

WHERE

returning: Vec<SelectItem>

RETURNING

Discard(DiscardType)

DISCARD

CreateView

CREATE VIEW

Fields

or_replace: bool

materialized: bool

if_not_exists: bool

name: ObjectName

View name

columns: Vec<Ident>

query: Box<Query>

emit_mode: Option<EmitMode>

with_options: Vec<SqlOption>

CreateTable

CREATE TABLE

Fields

or_replace: bool

temporary: bool

if_not_exists: bool

name: ObjectName

Table name

columns: Vec<ColumnDef>

Optional schema

wildcard_idx: Option<usize>

constraints: Vec<TableConstraint>

with_options: Vec<SqlOption>

format_encode: Option<CompatibleFormatEncode>

FORMAT ... ENCODE ... for table with connector

source_watermarks: Vec<SourceWatermark>

The watermark defined on source.

append_only: bool

Append only table.

on_conflict: Option<OnConflict>

On conflict behavior

with_version_column: Option<String>

with_version_column behind on conflict

query: Option<Box<Query>>

AS ( query )

cdc_table_info: Option<CdcTableInfo>

FROM cdc_source TABLE database_name.table_name

include_column_options: IncludeOption

INCLUDE a AS b INCLUDE c

CreateIndex

CREATE INDEX

Fields

name: ObjectName

index name

table_name: ObjectName

columns: Vec<OrderByExpr>

include: Vec<Ident>

distributed_by: Vec<Expr>

unique: bool

if_not_exists: bool

CreateSource

CREATE SOURCE

Fields

stmt: CreateSourceStatement

CreateSink

CREATE SINK

Fields

stmt: CreateSinkStatement

CreateSubscription

CREATE SUBSCRIPTION

Fields

stmt: CreateSubscriptionStatement

CreateConnection

CREATE CONNECTION

Fields

stmt: CreateConnectionStatement

CreateSecret

Fields

stmt: CreateSecretStatement

CreateFunction

CREATE FUNCTION

Postgres: https://www.postgresql.org/docs/15/sql-createfunction.html

Fields

or_replace: bool

temporary: bool

name: ObjectName

args: Option<Vec<OperateFunctionArg>>

returns: Option<CreateFunctionReturns>

params: CreateFunctionBody

Optional parameters.

with_options: CreateFunctionWithOptions

CreateAggregate

CREATE AGGREGATE

Postgres: https://www.postgresql.org/docs/15/sql-createaggregate.html

Fields

or_replace: bool

name: ObjectName

args: Vec<OperateFunctionArg>

returns: DataType

append_only: bool

Optional parameters.

params: CreateFunctionBody

DeclareCursor

DECLARE CURSOR

Fields

stmt: DeclareCursorStatement

FetchCursor

Fields

stmt: FetchCursorStatement

CloseCursor

Fields

stmt: CloseCursorStatement

AlterDatabase

ALTER DATABASE

Fields

name: ObjectName

operation: AlterDatabaseOperation

AlterSchema

ALTER SCHEMA

Fields

name: ObjectName

operation: AlterSchemaOperation

AlterTable

ALTER TABLE

Fields

name: ObjectName

Table name

operation: AlterTableOperation

AlterIndex

ALTER INDEX

Fields

name: ObjectName

Index name

operation: AlterIndexOperation

AlterView

ALTER VIEW

Fields

name: ObjectName

View name

materialized: bool

operation: AlterViewOperation

AlterSink

ALTER SINK

Fields

name: ObjectName

Sink name

operation: AlterSinkOperation

AlterSubscription

Fields

name: ObjectName

operation: AlterSubscriptionOperation

AlterSource

ALTER SOURCE

Fields

name: ObjectName

Source name

operation: AlterSourceOperation

AlterFunction

ALTER FUNCTION

Fields

name: ObjectName

Function name

args: Option<Vec<OperateFunctionArg>>

operation: AlterFunctionOperation

AlterConnection

ALTER CONNECTION

Fields

name: ObjectName

Connection name

operation: AlterConnectionOperation

Describe

DESCRIBE TABLE OR SOURCE

Fields

name: ObjectName

Table or Source name

ShowObjects

SHOW OBJECT COMMAND

Fields

object: ShowObject

filter: Option<ShowStatementFilter>

ShowCreateObject

SHOW CREATE COMMAND

Fields

create_type: ShowCreateType

Show create object type

name: ObjectName

Show create object name

ShowTransactionIsolationLevel

CancelJobs(JobIdents)

CANCEL JOBS COMMAND

Kill(i32)

KILL COMMAND Kill process in the show processlist.

Drop(DropStatement)

DROP

DropFunction

DROP FUNCTION

Fields

if_exists: bool

func_desc: Vec<FunctionDesc>

One or more function to drop

option: Option<ReferentialAction>

CASCADE or RESTRICT

DropAggregate

DROP AGGREGATE

Fields

if_exists: bool

func_desc: Vec<FunctionDesc>

One or more function to drop

option: Option<ReferentialAction>

CASCADE or RESTRICT

SetVariable

SET <variable>

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

Fields

local: bool

variable: Ident

value: SetVariableValue

ShowVariable

SHOW <variable>

Note: this is a PostgreSQL-specific statement.

Fields

variable: Vec<Ident>

StartTransaction

START TRANSACTION ...

Fields

modes: Vec<TransactionMode>

Begin

BEGIN [ TRANSACTION | WORK ]

Fields

modes: Vec<TransactionMode>

Abort

ABORT

SetTransaction

SET TRANSACTION ...

Fields

modes: Vec<TransactionMode>

snapshot: Option<Value>

session: bool

SetTimeZone

SET [ SESSION | LOCAL ] TIME ZONE { value | 'value' | LOCAL | DEFAULT }

Fields

local: bool

value: SetTimeZoneValue

Comment

COMMENT ON ...

Note: this is a PostgreSQL-specific statement.

Fields

object_type: CommentObject

object_name: ObjectName

comment: Option<String>

Commit

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

Fields

chain: bool

Rollback

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

Fields

chain: bool

CreateSchema

CREATE SCHEMA

Fields

schema_name: ObjectName

if_not_exists: bool

owner: Option<ObjectName>

CreateDatabase

CREATE DATABASE

Fields

db_name: ObjectName

if_not_exists: bool

owner: Option<ObjectName>

Grant

GRANT privileges ON objects TO grantees

Fields

privileges: Privileges

objects: GrantObjects

grantees: Vec<Ident>

with_grant_option: bool

granted_by: Option<Ident>

Revoke

REVOKE privileges ON objects FROM grantees

Fields

privileges: Privileges

objects: GrantObjects

grantees: Vec<Ident>

granted_by: Option<Ident>

revoke_grant_option: bool

cascade: bool

Deallocate

DEALLOCATE [ PREPARE ] { name | ALL }

Note: this is a PostgreSQL-specific statement.

Fields

name: Ident

prepare: bool

Execute

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

Note: this is a PostgreSQL-specific statement.

Fields

name: Ident

parameters: Vec<Expr>

Prepare

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

Note: this is a PostgreSQL-specific statement.

Fields

name: Ident

data_types: Vec<DataType>

statement: Box<Statement>

Explain

EXPLAIN / DESCRIBE for select_statement

Fields

analyze: bool

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

statement: Box<Statement>

A SQL query that specifies what to explain

options: ExplainOptions

options of the explain statement

CreateUser(CreateUserStatement)

CREATE USER

AlterUser(AlterUserStatement)

ALTER USER

AlterSystem

ALTER SYSTEM SET configuration_parameter { TO | = } { value | ‘value’ | DEFAULT }

Fields

param: Ident

value: SetVariableValue

Flush

FLUSH the current barrier.

Note: RisingWave specific statement.

Wait

WAIT for ALL running stream jobs to finish. It will block the current session the condition is met.

Recover

Trigger stream job recover

Implementations

impl Statement

pub fn to_redacted_string(&self, keywords: RedactSqlOptionKeywordsRef) -> String

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 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 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 Eq for Statement

impl StructuralPartialEq for Statement