Enum Stmt 

pub enum Stmt {
    AlterTable(Box<(QualifiedName, AlterTableBody)>),
    Analyze(Option<QualifiedName>),
    Attach {
        expr: Box<Expr>,
        db_name: Box<Expr>,
        key: Option<Box<Expr>>,
    },
    Begin(Option<TransactionType>, Option<Name>),
    Commit(Option<Name>),
    CreateIndex {
        unique: bool,
        if_not_exists: bool,
        idx_name: Box<QualifiedName>,
        tbl_name: Name,
        columns: Vec<SortedColumn>,
        where_clause: Option<Box<Expr>>,
    },
    CreateTable {
        temporary: bool,
        if_not_exists: bool,
        tbl_name: QualifiedName,
        body: Box<CreateTableBody>,
    },
    CreateTrigger(Box<CreateTrigger>),
    CreateView {
        temporary: bool,
        if_not_exists: bool,
        view_name: QualifiedName,
        columns: Option<Vec<IndexedColumn>>,
        select: Box<Select>,
    },
    CreateVirtualTable(Box<CreateVirtualTable>),
    Delete(Box<Delete>),
    Detach(Box<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(Box<Insert>),
    Pragma(Box<QualifiedName>, Option<Box<PragmaBody>>),
    Reindex {
        obj_name: Option<QualifiedName>,
    },
    Release(Name),
    Rollback {
        tx_name: Option<Name>,
        savepoint_name: Option<Name>,
    },
    Savepoint(Name),
    Select(Box<Select>),
    Update(Box<Update>),
    Vacuum(Option<Name>, Option<Box<Expr>>),
}

SQL statement

Variants

AlterTable(Box<(QualifiedName, AlterTableBody)>)

ALTER TABLE: table name, body

Analyze(Option<QualifiedName>)

ANALYSE: object name

Attach

ATTACH DATABASE

Fields

expr: Box<Expr>

filename

db_name: Box<Expr>

schema name

key: Option<Box<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: Box<QualifiedName>

index name

tbl_name: Name

table name

columns: Vec<SortedColumn>

indexed columns or expressions

where_clause: Option<Box<Expr>>

partial index

CreateTable

CREATE TABLE

Fields

temporary: bool

TEMPORARY

if_not_exists: bool

IF NOT EXISTS

tbl_name: QualifiedName

table name

body: Box<CreateTableBody>

table body

CreateTrigger(Box<CreateTrigger>)

CREATE TRIGGER

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(Box<CreateVirtualTable>)

CREATE VIRTUAL TABLE

Delete(Box<Delete>)

DELETE

Detach(Box<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(Box<Insert>)

INSERT

Pragma(Box<QualifiedName>, Option<Box<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(Box<Update>)

UPDATE

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

VACUUM: database name, into expr

Implementations

impl Stmt

pub fn column_count(&self) -> ColumnCount

Like sqlite3_column_count but more limited

pub fn readonly(&self) -> bool

Like sqlite3_stmt_readonly

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

check for extra rules

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

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

impl ToSqlString for Stmt

fn to_sql_string<C: ToSqlContext>(&self, context: &C) -> String

Convert the given value to String

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

fn format(&self) -> Result<String, Error>

Format AST node to string