Enum Stmt

pub enum Stmt {
    AlterTable(QualifiedName, AlterTableBody),
    Analyze(Option<QualifiedName>),
    Attach {
        expr: Expr,
        db_name: Expr,
        key: Option<Expr>,
    },
    Begin(Option<TransactionType>, Option<Name>),
    Commit(Option<Name>),
    CreateIndex {
        unique: bool,
        if_not_exists: bool,
        idx_name: QualifiedName,
        tbl_name: Name,
        columns: Vec<SortedColumn>,
        where_clause: Option<Expr>,
    },
    CreateTable {
        temporary: bool,
        if_not_exists: bool,
        tbl_name: QualifiedName,
        body: CreateTableBody,
    },
    CreateTrigger {
        temporary: bool,
        if_not_exists: bool,
        trigger_name: QualifiedName,
        time: Option<TriggerTime>,
        event: TriggerEvent,
        tbl_name: QualifiedName,
        for_each_row: bool,
        when_clause: Option<Expr>,
        commands: Vec<TriggerCmd>,
    },
    CreateView {
        temporary: bool,
        if_not_exists: bool,
        view_name: QualifiedName,
        columns: Option<Vec<IndexedColumn>>,
        select: Box<Select>,
    },
    CreateVirtualTable {
        if_not_exists: bool,
        tbl_name: QualifiedName,
        module_name: Name,
        args: Option<Vec<Box<str>>>,
    },
    Delete {
        with: Option<With>,
        tbl_name: QualifiedName,
        indexed: Option<Indexed>,
        where_clause: Option<Expr>,
        returning: Option<Vec<ResultColumn>>,
        order_by: Option<Vec<SortedColumn>>,
        limit: Option<Limit>,
    },
    Detach(Expr),
    DropIndex {
        if_exists: bool,
        idx_name: QualifiedName,
    },
    DropTable {
        if_exists: bool,
        tbl_name: QualifiedName,
    },
    DropTrigger {
        if_exists: bool,
        trigger_name: QualifiedName,
    },
    DropView {
        if_exists: bool,
        view_name: QualifiedName,
    },
    Insert {
        with: Option<With>,
        or_conflict: Option<ResolveType>,
        tbl_name: QualifiedName,
        columns: Option<DistinctNames>,
        body: InsertBody,
        returning: Option<Vec<ResultColumn>>,
    },
    Pragma(QualifiedName, Option<PragmaBody>),
    Reindex {
        obj_name: Option<QualifiedName>,
    },
    Release(Name),
    Rollback {
        tx_name: Option<Name>,
        savepoint_name: Option<Name>,
    },
    Savepoint(Name),
    Select(Box<Select>),
    Update {
        with: Option<With>,
        or_conflict: Option<ResolveType>,
        tbl_name: QualifiedName,
        indexed: Option<Indexed>,
        sets: Vec<Set>,
        from: Option<FromClause>,
        where_clause: Option<Expr>,
        returning: Option<Vec<ResultColumn>>,
        order_by: Option<Vec<SortedColumn>>,
        limit: Option<Limit>,
    },
    Vacuum(Option<Name>, Option<Expr>),
}

SQL statement

Variants

AlterTable(QualifiedName, AlterTableBody)

ALTER TABLE: table name, body

Analyze(Option<QualifiedName>)

ANALYSE: object name

Attach

ATTACH DATABASE

Fields

expr: Expr

filename

db_name: Expr

schema name

key: Option<Expr>

password

Begin(Option<TransactionType>, Option<Name>)

BEGIN: tx type, tx name

Commit(Option<Name>)

COMMIT/END: tx name

CreateIndex

CREATE INDEX

Fields

unique: bool

UNIQUE

if_not_exists: bool

IF NOT EXISTS

idx_name: QualifiedName

index name

tbl_name: Name

table name

columns: Vec<SortedColumn>

indexed columns or expressions

where_clause: Option<Expr>

partial index

CreateTable

CREATE TABLE

Fields

temporary: bool

TEMPORARY

if_not_exists: bool

IF NOT EXISTS

tbl_name: QualifiedName

table name

body: CreateTableBody

table body

CreateTrigger

CREATE TRIGGER

Fields

temporary: bool

TEMPORARY

if_not_exists: bool

IF NOT EXISTS

trigger_name: QualifiedName

trigger name

time: Option<TriggerTime>

BEFORE/AFTER/INSTEAD OF

event: TriggerEvent

DELETE/INSERT/UPDATE

tbl_name: QualifiedName

table name

for_each_row: bool

FOR EACH ROW

when_clause: Option<Expr>

WHEN

commands: Vec<TriggerCmd>

statements

CreateView

CREATE VIEW

Fields

temporary: bool

TEMPORARY

if_not_exists: bool

IF NOT EXISTS

view_name: QualifiedName

view name

columns: Option<Vec<IndexedColumn>>

columns

select: Box<Select>

query

CreateVirtualTable

CREATE VIRTUAL TABLE

Fields

if_not_exists: bool

IF NOT EXISTS

tbl_name: QualifiedName

table name

module_name: Name

module

args: Option<Vec<Box<str>>>

args

Delete

DELETE

Fields

with: Option<With>

CTE

tbl_name: QualifiedName

FROM table name

indexed: Option<Indexed>

INDEXED

where_clause: Option<Expr>

WHERE clause

returning: Option<Vec<ResultColumn>>

RETURNING

order_by: Option<Vec<SortedColumn>>

ORDER BY

limit: Option<Limit>

LIMIT

Detach(Expr)

DETACH DATABASE: db name

DropIndex

DROP INDEX

Fields

if_exists: bool

IF EXISTS

idx_name: QualifiedName

index name

DropTable

DROP TABLE

Fields

if_exists: bool

IF EXISTS

tbl_name: QualifiedName

table name

DropTrigger

DROP TRIGGER

Fields

if_exists: bool

IF EXISTS

trigger_name: QualifiedName

trigger name

DropView

DROP VIEW

Fields

if_exists: bool

IF EXISTS

view_name: QualifiedName

view name

Insert

INSERT

Fields

with: Option<With>

CTE

or_conflict: Option<ResolveType>

OR

tbl_name: QualifiedName

table name

columns: Option<DistinctNames>

COLUMNS

body: InsertBody

VALUES or SELECT

returning: Option<Vec<ResultColumn>>

RETURNING

Pragma(QualifiedName, Option<PragmaBody>)

PRAGMA: pragma name, body

Reindex

REINDEX

Fields

obj_name: Option<QualifiedName>

collation or index or table name

Release(Name)

RELEASE: savepoint name

Rollback

ROLLBACK

Fields

tx_name: Option<Name>

transaction name

savepoint_name: Option<Name>

savepoint name

Savepoint(Name)

SAVEPOINT: savepoint name

Select(Box<Select>)

SELECT

Update

UPDATE

Fields

with: Option<With>

CTE

or_conflict: Option<ResolveType>

OR

tbl_name: QualifiedName

table name

indexed: Option<Indexed>

INDEXED

sets: Vec<Set>

SET assignments

from: Option<FromClause>

FROM

where_clause: Option<Expr>

WHERE clause

returning: Option<Vec<ResultColumn>>

RETURNING

order_by: Option<Vec<SortedColumn>>

ORDER BY

limit: Option<Limit>

LIMIT

Vacuum(Option<Name>, Option<Expr>)

VACUUM: database name, into expr

Implementations

impl Stmt

pub fn create_index( unique: bool, if_not_exists: bool, idx_name: QualifiedName, tbl_name: Name, columns: Vec<SortedColumn>, where_clause: Option<Expr>, ) -> Result<Self, ParserError>

CREATE INDEX constructor

pub fn update( with: Option<With>, or_conflict: Option<ResolveType>, tbl_name: QualifiedName, indexed: Option<Indexed>, sets: Vec<Set>, from: Option<FromClause>, where_clause: Option<Expr>, returning: Option<Vec<ResultColumn>>, order_by: Option<Vec<SortedColumn>>, limit: Option<Limit>, ) -> Result<Self, ParserError>

UPDATE constructor

Trait Implementations

impl Clone for Stmt

fn clone(&self) -> Stmt

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Stmt

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for Stmt

fn eq(&self, other: &Stmt) -> 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 ToTokens for Stmt

fn to_tokens<S: TokenStream>(&self, s: &mut S) -> Result<(), S::Error>

Send token(s) to the specified stream

fn to_fmt(&self, f: &mut Formatter<'_>) -> Result

Format AST node

impl Eq for Stmt

impl StructuralPartialEq for Stmt