Enum Statement 

pub enum Statement {
    Analyze {
        table_name: ObjectName,
    },
    Truncate {
        table_name: ObjectName,
    },
    Refresh {
        table_name: ObjectName,
    },
    Query(Box<Query>),
    Insert {
        table_name: ObjectName,
        columns: Vec<Ident>,
        source: Box<Query>,
        returning: Vec<SelectItem>,
    },
    Copy {
        entity: CopyEntity,
        target: CopyTarget,
    },
    Update {
        table_name: ObjectName,
        assignments: Vec<Assignment>,
        selection: Option<Expr>,
        returning: Vec<SelectItem>,
    },
    Delete {
        table_name: ObjectName,
        selection: Option<Expr>,
        returning: Vec<SelectItem>,
    },
    DeleteMetaSnapshots {
        snapshot_ids: Vec<u64>,
    },
    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_columns: Vec<Ident>,
        query: Option<Box<Query>>,
        cdc_table_info: Option<CdcTableInfo>,
        include_column_options: IncludeOption,
        webhook_info: Option<WebhookSourceInfo>,
        engine: Engine,
    
},
    CreateIndex {
        name: ObjectName,
        table_name: ObjectName,
        columns: Vec<OrderByExpr>,
        method: Option<Ident>,
        include: Vec<Ident>,
        distributed_by: Vec<Expr>,
        unique: bool,
        if_not_exists: bool,
        with_properties: WithProperties,
    },
    CreateSource {
        stmt: CreateSourceStatement,
    },
    CreateSink {
        stmt: CreateSinkStatement,
    },
    CreateSubscription {
        stmt: CreateSubscriptionStatement,
    },
    CreateConnection {
        stmt: CreateConnectionStatement,
    },
    CreateSecret {
        stmt: CreateSecretStatement,
    },
    CreateFunction {
        or_replace: bool,
        temporary: bool,
        if_not_exists: bool,
        name: ObjectName,
        args: Option<Vec<OperateFunctionArg>>,
        returns: Option<CreateFunctionReturns>,
        params: CreateFunctionBody,
        with_options: CreateFunctionWithOptions,
    },
    CreateAggregate {
        or_replace: bool,
        if_not_exists: 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,
    },
    AlterSecret {
        name: ObjectName,
        operation: AlterSecretOperation,
    },
    AlterFragment {
        fragment_ids: Vec<u32>,
        operation: AlterFragmentOperation,
    },
    AlterCompactionGroup {
        group_ids: Vec<u64>,
        operation: AlterCompactionGroupOperation,
    },
    AlterDefaultPrivileges {
        target_users: Option<Vec<Ident>>,
        schema_names: Option<Vec<ObjectName>>,
        operation: DefaultPrivilegeOperation,
    },
    Describe {
        name: ObjectName,
        kind: DescribeKind,
    },
    DescribeFragment {
        fragment_id: u32,
    },
    ShowObjects {
        object: ShowObject,
        filter: Option<ShowStatementFilter>,
    },
    ShowCreateObject {
        create_type: ShowCreateType,
        name: ObjectName,
    },
    ShowTransactionIsolationLevel,
    CancelJobs(JobIdents),
    Kill(String),
    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>,
        resource_group: Option<SetVariableValue>,
        barrier_interval_ms: Option<u32>,
        checkpoint_frequency: Option<u64>,
    },
    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: Option<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,
    },
    ExplainAnalyzeStreamJob {
        target: AnalyzeTarget,
        duration_secs: Option<u64>,
    },
    CreateUser(CreateUserStatement),
    AlterUser(AlterUserStatement),
    AlterSystem {
        param: Ident,
        value: SetVariableValue,
    },
    Flush,
    Wait(WaitTarget),
    Backup,
    Recover,
    Use {
        db_name: ObjectName,
    },
    Vacuum {
        object_name: ObjectName,
        full: bool,
    },
}

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

Variants

Analyze

Analyze (Hive)

Fields

table_name: ObjectName

Truncate

Truncate (Hive)

Fields

table_name: ObjectName

Refresh

Refresh table

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

entity: CopyEntity

target: CopyTarget

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

DeleteMetaSnapshots

DELETE META SNAPSHOT(S)

Fields

snapshot_ids: Vec<u64>

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_columns: Vec<Ident>

with_version_columns behind on conflict - supports multiple version columns

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

webhook_info: Option<WebhookSourceInfo>

VALIDATE SECRET secure_secret_name AS secure_compare ()

engine: Engine

Engine = [hummock | iceberg]

CreateIndex

CREATE INDEX

Fields

name: ObjectName

index name

table_name: ObjectName

columns: Vec<OrderByExpr>

method: Option<Ident>

include: Vec<Ident>

distributed_by: Vec<Expr>

unique: bool

if_not_exists: bool

with_properties: WithProperties

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

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

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

AlterSecret

ALTER SECRET

Fields

name: ObjectName

Secret name

operation: AlterSecretOperation

AlterFragment

ALTER FRAGMENT

Fields

fragment_ids: Vec<u32>

operation: AlterFragmentOperation

AlterCompactionGroup

ALTER COMPACTION GROUP

Fields

group_ids: Vec<u64>

operation: AlterCompactionGroupOperation

AlterDefaultPrivileges

DESCRIBE relation ALTER DEFAULT PRIVILEGES

Fields

target_users: Option<Vec<Ident>>

schema_names: Option<Vec<ObjectName>>

operation: DefaultPrivilegeOperation

Describe

DESCRIBE relation

Fields

name: ObjectName

relation name

kind: DescribeKind

DescribeFragment

DESCRIBE FRAGMENT <fragment_id>

Fields

fragment_id: u32

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(String)

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>

resource_group: Option<SetVariableValue>

barrier_interval_ms: Option<u32>

checkpoint_frequency: Option<u64>

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

ExplainAnalyzeStreamJob

EXPLAIN ANALYZE for stream job We introduce a new statement rather than reuse EXPLAIN because the body of the statement is not an SQL query. TODO(kwannoel): Make profiling duration configurable: EXPLAIN ANALYZE (DURATION 1s) …

Fields

target: AnalyzeTarget

duration_secs: Option<u64>

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(WaitTarget)

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

Backup

Trigger meta backup.

Recover

Trigger stream job recover

Use

USE <db_name>

Note: this is a RisingWave specific statement and used to switch the current database.

Fields

db_name: ObjectName

Vacuum

VACUUM [FULL] [database_name][schema_name][object_name]

Note: this is a RisingWave specific statement for iceberg table/sink compaction.

Fields

object_name: ObjectName

full: bool

Implementations

impl Statement

pub fn try_to_string(&self) -> Result<String, ParserError>

Converts(unparses) the statement to a SQL string.

If the resulting SQL is not valid, returns an error.

pub fn to_string_unchecked(&self) -> String

Converts(unparses) the statement to a SQL string.

The result may not be valid SQL if there’s an implementation bug in the Display trait of any AST node. To avoid this, always prefer Statement::try_to_string to get a Result, or to_string which panics if the SQL is invalid.

fn fmt_unchecked(&self, f: impl Write) -> Result

pub fn is_create(&self) -> bool

impl Statement

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

pub fn default_create_table(name: ObjectName) -> Self

Create a new CREATE TABLE statement with the given name and empty fields.

Trait Implementations

impl Clone for Statement

fn clone(&self) -> Statement

Returns a duplicate 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

Converts(unparses) the statement to a SQL string.

If the resulting SQL is not valid, this function will panic. Use Statement::try_to_string to get a Result instead.

impl Eq for Statement

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