Struct Delete 

pub struct Delete {

    pub table: TableRef,
    pub on_cluster: Option<OnCluster>,
    pub alias: Option<Identifier>,
    pub alias_explicit_as: bool,
    pub using: Vec<TableRef>,
    pub where_clause: Option<Where>,
    pub output: Option<OutputClause>,
    pub leading_comments: Vec<String>,
    pub with: Option<With>,
    pub limit: Option<Expression>,
    pub order_by: Option<OrderBy>,
    pub returning: Vec<Expression>,
    pub tables: Vec<TableRef>,
    pub tables_from_using: bool,
    pub joins: Vec<Join>,
    pub force_index: Option<String>,
    pub no_from: bool,
}

DELETE statement

Fields

table: TableRef

on_cluster: Option<OnCluster>

ClickHouse: ON CLUSTER clause for distributed DDL

alias: Option<Identifier>

Optional alias for the table

alias_explicit_as: bool

Whether the alias was declared with explicit AS keyword

using: Vec<TableRef>

PostgreSQL/DuckDB USING clause - additional tables to join

where_clause: Option<Where>

output: Option<OutputClause>

OUTPUT clause (TSQL)

leading_comments: Vec<String>

Leading comments before the statement

with: Option<With>

WITH clause (CTEs)

limit: Option<Expression>

LIMIT clause (MySQL)

order_by: Option<OrderBy>

ORDER BY clause (MySQL)

returning: Vec<Expression>

RETURNING clause (PostgreSQL)

tables: Vec<TableRef>

MySQL multi-table DELETE: DELETE t1, t2 FROM … or DELETE FROM t1, t2 USING … These are the target tables to delete from

tables_from_using: bool

True if tables were after FROM keyword (DELETE FROM t1, t2 USING syntax) False if tables were before FROM keyword (DELETE t1, t2 FROM syntax)

joins: Vec<Join>

JOINs in MySQL multi-table DELETE: DELETE t1 FROM t1 LEFT JOIN t2 …

force_index: Option<String>

FORCE INDEX hint (MySQL): DELETE FROM t FORCE INDEX (idx)

no_from: bool

BigQuery-style DELETE without FROM keyword: DELETE table WHERE …

Trait Implementations

impl Clone for Delete

fn clone(&self) -> Delete

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Delete

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Delete

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Delete

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

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Delete