Struct DeleteQuery 

pub struct DeleteQuery {
    pub with: With,
    pub hints: Hints,
    pub modifiers: Modifiers,
    pub tables: Vec<TableRef>,
    pub partitions: Vec<Cow<'static, str>>,
    pub using: TableRef,
    pub extra_using: Vec<TableRef>,
    pub where_: Where,
    pub order_by: OrderBy,
    pub limit: Limit,
}

A MySQL DELETE.

From https://dev.mysql.com/doc/refman/8.4/en/delete.html, taking the single-table form and the FROM … USING spelling of the multiple-table one:

[WITH [RECURSIVE] with_query [, ...]]
DELETE [hint_comment] [LOW_PRIORITY] [QUICK] [IGNORE]
    FROM tbl_name[.*] [[AS] tbl_alias] [, tbl_name[.*]] ...
    [PARTITION (partition_name [, partition_name] ...)]
    [USING table_references]
    [WHERE where_condition]
    [ORDER BY ...]
    [LIMIT row_count]

MySQL spells the multiple-table delete two ways — DELETE t1, t2 FROM refs and DELETE FROM t1, t2 USING refs. Only the second is built here, because it is also the single-table form with the USING left out, so one shape covers both and DELETE FROM t is what an empty USING gives.

PARTITION sits in an odd place

This is the one statement where MySQL writes PARTITION after the alias. TableRef puts it before, which is right everywhere else, so HasDeleteTables carries a partition slot of its own and the delete::from(..).partition(..) chain moves its list into it.

ORDER BY and LIMIT, like in UPDATE, are single-table only.

Fields

with: With

WITH ….

hints: Hints

/*+ … */.

modifiers: Modifiers

LOW_PRIORITY, QUICK and IGNORE.

tables: Vec<TableRef>

The tables rows are deleted from — the FROM list.

partitions: Vec<Cow<'static, str>>

PARTITION (…), written after the FROM list.

using: TableRef

The first USING item, with its joins.

extra_using: Vec<TableRef>

Further comma-separated USING items.

where_: Where

WHERE ….

order_by: OrderBy

ORDER BY …. Single-table form only.

limit: Limit

LIMIT row_count. Single-table form only, and there is no OFFSET.

Implementations

impl DeleteQuery

pub fn new() -> DeleteQuery

A DELETE with nothing set yet.

pub fn apply(&mut self, mods: impl Mod<DeleteQuery>)

Apply more mods to an existing query.

Trait Implementations

impl Clone for DeleteQuery

fn clone(&self) -> DeleteQuery

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DeleteQuery

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

Formats the value using the given formatter.

impl Default for DeleteQuery

fn default() -> DeleteQuery

Returns the “default value” for a type.

impl Expression for DeleteQuery

fn write_sql(&self, w: &mut SqlWriter<'_>)

Append this fragment to w.

impl HasDeleteTables for DeleteQuery

fn delete_tables_mut(&mut self) -> &mut Vec<TableRef>

The tables to delete from.

fn delete_partitions_mut(&mut self) -> &mut Vec<Cow<'static, str>>

The partitions to restrict the delete to.

impl HasExtraTables for DeleteQuery

fn extra_tables_mut(&mut self) -> &mut Vec<TableRef>

The additional table references to modify.

impl HasHints for DeleteQuery

fn hints_mut(&mut self) -> &mut Hints

The hints to add to.

impl HasJoins for DeleteQuery

fn joins_mut(&mut self) -> &mut Vec<Join>

The join list to modify.

impl HasLimit for DeleteQuery

fn limit_mut(&mut self) -> &mut Limit

The LIMIT clause to modify.

impl HasModifiers for DeleteQuery

fn modifiers_mut(&mut self) -> &mut Modifiers

The modifiers to add to.

impl HasOrderBy for DeleteQuery

fn order_by_mut(&mut self) -> &mut OrderBy

The ORDER BY clause to modify.

impl HasTableRef for DeleteQuery

fn table_ref_mut(&mut self) -> &mut TableRef

The table reference to modify.

impl HasWhere for DeleteQuery

fn where_mut(&mut self) -> &mut Where

The WHERE clause to modify.

impl HasWith for DeleteQuery

fn with_mut(&mut self) -> &mut With

The WITH clause to modify.

impl IntoExpr for DeleteQuery

fn into_expr(self) -> Expr

Perform the conversion.

impl IntoExprList for DeleteQuery

fn into_expr_list(self) -> Vec<Expr>

Perform the conversion.

impl Query for DeleteQuery

fn query_type(&self) -> QueryType

Which statement this renders.

fn dialect(&self) -> &dyn Dialect

The dialect this query renders itself in.

fn build(&self) -> Result<(String, Vec<Value>), Error>

Render to SQL and arguments, numbering placeholders from 1.

fn build_from(&self, start: usize) -> Result<(String, Vec<Value>), Error>

build with a different first placeholder position, for splicing into a statement that already has arguments — bob’s BuildN.

impl<H, L, M> QueryExtensions<H, L, M> for DeleteQuery

fn hooks(&self) -> &[Hook]

Hooks to run before this query executes.

fn loaders(&self) -> &[Loader]

Loaders to run after this query executes, for eagerly loaded relations.

fn mapper_mods(&self) -> &[MapperMod]

Adjustments to the row mapper, for relations loaded in the same query.