Enum Statement 

pub enum Statement {
    CreateTable(CreateTable),
    CreateTableIfNotExists(DeferredCreateTable),
    CreateIndex(CreateIndex),
    Insert(InsertStmt),
    Select(Box<SelectStmt>),
    Update(UpdateStmt),
    Delete(DeleteStmt),
    Drop(DropStmt),
    AlterTable(AlterTableStmt),
    AlterForeignTable(AlterForeignTableStmt),
    AlterView(AlterViewStmt),
    CreateView {
        name: String,
        column_names: Vec<String>,
        body: Box<SelectStmt>,
        or_replace: bool,
        persistence: RelationPersistence,
        options: Vec<(String, String)>,
    },
    CreateMaterializedView {
        name: String,
        column_names: Vec<String>,
        if_not_exists: bool,
        with_no_data: bool,
        options: Vec<(String, String)>,
        body: Box<SelectStmt>,
    },
    RefreshMaterializedView {
        name: String,
        concurrently: bool,
        with_no_data: bool,
    },
    CreateSchema {
        name: String,
        if_not_exists: bool,
    },
    Notify {
        channel: String,
        payload: String,
    },
    Listen {
        channel: String,
    },
    Unlisten {
        channel: Option<String>,
    },
    SetVariable {
        name: String,
        value: String,
    },
    ResetVariable {
        name: String,
    },
    ResetAllVariables,
    SetConstraints {
        constraints: Vec<SetConstraintName>,
        deferred: bool,
    },
    ShowVariable {
        name: String,
    },
    Discard {
        target: DiscardTarget,
    },
    Load {
        library: String,
    },
    Explain {
        analyze: bool,
        verbose: bool,
        format: Option<String>,
        body: Box<Statement>,
    },
    Analyze {
        table: Option<String>,
    },
    Vacuum(VacuumStmt),
    Truncate {
        tables: Vec<TruncateTarget>,
        cascade: bool,
        restart_identity: bool,
    },
    Transaction(TransactionStmt),
    DeclareCursor(DeclareCursorStmt),
    FetchCursor(FetchCursorStmt),
    CloseCursor {
        name: Option<String>,
    },
    CreateSequence(CreateSequence),
    AlterSequence(AlterSequence),
    CreateTableAs {
        name: String,
        if_not_exists: bool,
        column_names: Vec<String>,
        with_no_data: bool,
        persistence: RelationPersistence,
        on_commit: OnCommitAction,
        body: Box<SelectStmt>,
    },
    Prepare {
        name: String,
        body: Box<Statement>,
    },
    Execute {
        name: String,
        params: Vec<Expr>,
    },
    Deallocate {
        name: Option<String>,
    },
    Values {
        rows: Vec<Vec<Expr>>,
    },
    CreateForeignServer(CreateForeignServer),
    CreateForeignTable(CreateForeignTable),
    CreateForeignTableIfNotExists(DeferredCreateForeignTable),
    Merge(MergeStmt),
    CreateFunction(Box<CreateFunction>),
    DropFunction(DropFunctionStmt),
    AlterRoutine(AlterRoutineStmt),
    AlterRoutineOwner(AlterRoutineOwnerStmt),
    RenameRoutine(RenameRoutineStmt),
    GrantRoutine(GrantRoutineStmt),
    GrantTable(GrantTableStmt),
    GrantSequence(GrantSequenceStmt),
    GrantDatabase(GrantDatabaseStmt),
    GrantSchema(GrantSchemaStmt),
    GrantRole(GrantRoleStmt),
    CreateRole(CreateRoleStmt),
    AlterRole(AlterRoleStmt),
    DropRole(DropRoleStmt),
    CreateTrigger(CreateTrigger),
    DropTrigger(DropTrigger),
    CreateRule(CreateRule),
    DropRule(DropRule),
    DoBlock {
        language: String,
        body: String,
    },
    Call {
        name: String,
        args: Vec<Expr>,
    },
}

Variants

CreateTable(CreateTable)

CreateTableIfNotExists(DeferredCreateTable)

CreateIndex(CreateIndex)

Insert(InsertStmt)

Select(Box<SelectStmt>)

SelectStmt is the largest variant by far (CTEs + set-ops + n-ary expression trees), so we box it to keep the enum’s stack footprint proportional to the smaller variants.

Update(UpdateStmt)

Delete(DeleteStmt)

Drop(DropStmt)

AlterTable(AlterTableStmt)

AlterForeignTable(AlterForeignTableStmt)

AlterView(AlterViewStmt)

CreateView

CREATE [OR REPLACE] VIEW name [(column_name, ...)] AS SELECT .... The body is the underlying SelectStmt; views are materialised lazily on every reference (no row caching).

Fields

name: String

column_names: Vec<String>

body: Box<SelectStmt>

or_replace: bool

persistence: RelationPersistence

options: Vec<(String, String)>

Validated PostgreSQL view reloptions in declaration order.

CreateMaterializedView

CREATE MATERIALIZED VIEW ... AS SELECT ... [WITH [NO] DATA].

Fields

name: String

column_names: Vec<String>

if_not_exists: bool

with_no_data: bool

options: Vec<(String, String)>

body: Box<SelectStmt>

RefreshMaterializedView

REFRESH MATERIALIZED VIEW [CONCURRENTLY] name [WITH [NO] DATA].

Fields

name: String

concurrently: bool

with_no_data: bool

CreateSchema

CREATE SCHEMA [IF NOT EXISTS] name. This AST entry records the command for the engine’s durable schema catalog and namespace resolver.

Fields

name: String

if_not_exists: bool

Notify

NOTIFY channel [, 'payload'] queues one asynchronous notification for delivery when the outer transaction commits.

Fields

channel: String

payload: String

Listen

LISTEN channel transactionally subscribes the current SQL session.

Fields

channel: String

Unlisten

UNLISTEN channel | * transactionally removes one or every subscription. None represents *.

Fields

channel: Option<String>

SetVariable

SET <name> [TO|=] <value> - runtime parameter assignment. The engine gives search_path resolution semantics and stores other parameters in the logical session for subsequent SHOW statements.

Fields

name: String

value: String

ResetVariable

RESET <name> restores one runtime parameter to its session default.

Fields

name: String

ResetAllVariables

RESET ALL restores every resettable runtime parameter.

SetConstraints

SET CONSTRAINTS { ALL | name [, ...] } { DEFERRED | IMMEDIATE }. An empty constraint list represents ALL; qualified names retain their SQL spelling so execution can apply schema-search semantics.

Fields

constraints: Vec<SetConstraintName>

deferred: bool

ShowVariable

SHOW <variable> - return the runtime parameter as one (name -> value) row.

Fields

name: String

Discard

DISCARD [ALL|PLANS|SEQUENCES|TEMP|TEMPORARY] - clear session state. The engine resets session variables, prepared statements, sequence state, and the current session’s temporary relations as requested.

Fields

target: DiscardTarget

Load

LOAD 'library' - load a shared library into the session. The engine embeds its extension surface, so libraries it provides natively (Apache AGE) load as no-ops and unknown libraries fail like a missing $libdir file.

Fields

library: String

Explain

EXPLAIN .... Carries the inner statement so the engine can emit the planner output.

Fields

analyze: bool

verbose: bool

format: Option<String>

body: Box<Statement>

Analyze

ANALYZE [table]. The engine refreshes per-column statistics for cardinality estimation; the AST simply records the target.

Fields

table: Option<String>

Vacuum(VacuumStmt)

VACUUM [options] [relations]. Execution enforces PostgreSQL’s transaction-block restriction before validating options and dispatching storage maintenance.

Truncate

TRUNCATE TABLE t1, t2 .... Wipes the listed table hierarchies unless a target uses ONLY.

Fields

tables: Vec<TruncateTarget>

cascade: bool

restart_identity: bool

Transaction(TransactionStmt)

BEGIN / COMMIT / ROLLBACK / SAVEPOINT name.

DeclareCursor(DeclareCursorStmt)

DECLARE name [BINARY] [SCROLL] CURSOR [WITH HOLD] FOR query.

FetchCursor(FetchCursorStmt)

FETCH or MOVE over a named SQL cursor.

CloseCursor

CLOSE name or CLOSE ALL. None represents ALL.

Fields

name: Option<String>

CreateSequence(CreateSequence)

CREATE SEQUENCE name [START n] [INCREMENT n].

AlterSequence(AlterSequence)

ALTER SEQUENCE name [RESTART [WITH n]] [INCREMENT [BY] n] [START [WITH] n].

CreateTableAs

CREATE TABLE name AS SELECT ....

Fields

name: String

if_not_exists: bool

column_names: Vec<String>

with_no_data: bool

persistence: RelationPersistence

on_commit: OnCommitAction

body: Box<SelectStmt>

Prepare

PREPARE name AS <inner>.

Fields

name: String

body: Box<Statement>

Execute

EXECUTE name (param1, param2, ...).

Fields

name: String

params: Vec<Expr>

Deallocate

DEALLOCATE name | DEALLOCATE ALL. None means ALL.

Fields

name: Option<String>

Values

SELECT * FROM (VALUES ...) [AS alias] – a standalone VALUES statement (also reachable from a SET-OP body).

Fields

rows: Vec<Vec<Expr>>

CreateForeignServer(CreateForeignServer)

CREATE SERVER name FOREIGN DATA WRAPPER type OPTIONS (...).

CreateForeignTable(CreateForeignTable)

CREATE FOREIGN TABLE name (...) SERVER server OPTIONS (...).

CreateForeignTableIfNotExists(DeferredCreateForeignTable)

CREATE FOREIGN TABLE IF NOT EXISTS retains its raw-parser declaration until execution can check the shared relation namespace.

Merge(MergeStmt)

MERGE INTO target USING source ON cond WHEN MATCHED THEN ... WHEN NOT MATCHED THEN .... SQL:2003 conditional UPSERT.

CreateFunction(Box<CreateFunction>)

CREATE [OR REPLACE] FUNCTION | PROCEDURE .... Boxed: the definition (parameters + body source) dwarfs other variants.

DropFunction(DropFunctionStmt)

DROP FUNCTION | PROCEDURE [IF EXISTS] name[(args)] [, ...].

AlterRoutine(AlterRoutineStmt)

ALTER FUNCTION | PROCEDURE | ROUTINE name[(input_types)] volatility and null-input attributes.

AlterRoutineOwner(AlterRoutineOwnerStmt)

RenameRoutine(RenameRoutineStmt)

GrantRoutine(GrantRoutineStmt)

GrantTable(GrantTableStmt)

GrantSequence(GrantSequenceStmt)

GrantDatabase(GrantDatabaseStmt)

GrantSchema(GrantSchemaStmt)

GrantRole(GrantRoleStmt)

CreateRole(CreateRoleStmt)

AlterRole(AlterRoleStmt)

DropRole(DropRoleStmt)

CreateTrigger(CreateTrigger)

CREATE [OR REPLACE] TRIGGER ... ON relation.

DropTrigger(DropTrigger)

DROP TRIGGER [IF EXISTS] name ON relation.

CreateRule(CreateRule)

CREATE [OR REPLACE] RULE ... ON relation.

DropRule(DropRule)

DROP RULE [IF EXISTS] name ON relation.

DoBlock

DO [LANGUAGE lang] $$ ... $$ - anonymous code block.

Fields

language: String

body: String

Call

CALL proc(args) - procedure invocation. OUT / INOUT parameters shape the result row.

Fields

name: String

args: Vec<Expr>

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<'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 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.