Struct DeleteStatement

pub struct DeleteStatement {
    pub(crate) table: Option<Box<TableRef>>,
    pub(crate) where: ConditionHolder,
    pub(crate) orders: Vec<OrderExpr>,
    pub(crate) limit: Option<Value>,
    pub(crate) returning: Option<ReturningClause>,
    pub(crate) with: Option<WithClause>,
}

Delete existing rows from the table

Examples

use sea_query::{tests_cfg::*, *};

let query = Query::delete()
    .from_table(Glyph::Table)
    .cond_where(any![
        Expr::col(Glyph::Id).lt(1),
        Expr::col(Glyph::Id).gt(10),
    ])
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"DELETE FROM `glyph` WHERE `id` < 1 OR `id` > 10"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"DELETE FROM "glyph" WHERE "id" < 1 OR "id" > 10"#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"DELETE FROM "glyph" WHERE "id" < 1 OR "id" > 10"#
);

Fields

table: Option<Box<TableRef>>

where: ConditionHolder

orders: Vec<OrderExpr>

limit: Option<Value>

returning: Option<ReturningClause>

with: Option<WithClause>

Implementations

impl DeleteStatement

pub fn new() -> Self

Construct a new DeleteStatement

pub fn take(&mut self) -> Self

pub fn from_table<T>(&mut self, tbl_ref: T) -> &mut Self

where T: IntoTableRef,

Specify which table to delete from.

Examples

use sea_query::{audit::*, tests_cfg::*, *};

let query = Query::delete()
    .from_table(Glyph::Table)
    .and_where(Expr::col(Glyph::Id).eq(1))
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"DELETE FROM `glyph` WHERE `id` = 1"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"DELETE FROM "glyph" WHERE "id" = 1"#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"DELETE FROM "glyph" WHERE "id" = 1"#
);
assert_eq!(
    query.audit_unwrap().deleted_tables(),
    [Glyph::Table.into_iden()]
);
assert_eq!(query.audit_unwrap().selected_tables(), []);

pub fn limit(&mut self, limit: u64) -> &mut Self

Limit number of updated rows.

pub fn returning(&mut self, returning_cols: ReturningClause) -> &mut Self

RETURNING expressions.

Examples

use sea_query::{audit::*, tests_cfg::*, *};

let query = Query::delete()
    .from_table(Glyph::Table)
    .and_where(Expr::col(Glyph::Id).eq(1))
    .returning(Query::returning().columns([Glyph::Id]))
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"DELETE FROM `glyph` WHERE `id` = 1"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"DELETE FROM "glyph" WHERE "id" = 1 RETURNING "id""#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"DELETE FROM "glyph" WHERE "id" = 1 RETURNING "id""#
);
assert_eq!(
    query.audit_unwrap().deleted_tables(),
    [Glyph::Table.into_iden()]
);
assert_eq!(
    query.audit_unwrap().selected_tables(),
    [Glyph::Table.into_iden()]
);

pub fn returning_col<C>(&mut self, col: C) -> &mut Self

where C: IntoColumnRef,

RETURNING expressions for a column.

Examples

use sea_query::{tests_cfg::*, *};

let query = Query::delete()
    .from_table(Glyph::Table)
    .and_where(Expr::col(Glyph::Id).eq(1))
    .returning_col(Glyph::Id)
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"DELETE FROM `glyph` WHERE `id` = 1"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"DELETE FROM "glyph" WHERE "id" = 1 RETURNING "id""#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"DELETE FROM "glyph" WHERE "id" = 1 RETURNING "id""#
);

pub fn returning_all(&mut self) -> &mut Self

RETURNING expressions all columns.

Examples

use sea_query::{tests_cfg::*, *};

let query = Query::delete()
    .from_table(Glyph::Table)
    .and_where(Expr::col(Glyph::Id).eq(1))
    .returning_all()
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"DELETE FROM `glyph` WHERE `id` = 1"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"DELETE FROM "glyph" WHERE "id" = 1 RETURNING *"#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"DELETE FROM "glyph" WHERE "id" = 1 RETURNING *"#
);

pub fn with(self, clause: WithClause) -> WithQuery

Create a WithQuery by specifying a WithClause to execute this query with.

Examples

use sea_query::{IntoCondition, IntoIden, audit::*, tests_cfg::*, *};

let select = SelectStatement::new()
        .columns([Glyph::Id])
        .from(Glyph::Table)
        .and_where(Expr::col(Glyph::Image).like("0%"))
        .to_owned();
    let cte = CommonTableExpression::new()
        .query(select)
        .column(Glyph::Id)
        .table_name("cte")
        .to_owned();
    let with_clause = WithClause::new().cte(cte).to_owned();
    let update = DeleteStatement::new()
        .from_table(Glyph::Table)
        .and_where(Expr::col(Glyph::Id).in_subquery(SelectStatement::new().column(Glyph::Id).from("cte").to_owned()))
        .to_owned();
    let query = update.with(with_clause);

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"WITH `cte` (`id`) AS (SELECT `id` FROM `glyph` WHERE `image` LIKE '0%') DELETE FROM `glyph` WHERE `id` IN (SELECT `id` FROM `cte`)"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"WITH "cte" ("id") AS (SELECT "id" FROM "glyph" WHERE "image" LIKE '0%') DELETE FROM "glyph" WHERE "id" IN (SELECT "id" FROM "cte")"#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"WITH "cte" ("id") AS (SELECT "id" FROM "glyph" WHERE "image" LIKE '0%') DELETE FROM "glyph" WHERE "id" IN (SELECT "id" FROM "cte")"#
);
assert_eq!(
    query.audit_unwrap().deleted_tables(),
    [Glyph::Table.into_iden()]
);
assert_eq!(
    query.audit_unwrap().selected_tables(),
    [Glyph::Table.into_iden()]
);

pub fn with_cte<C: Into<WithClause>>(&mut self, clause: C) -> &mut Self

Create a Common Table Expression by specifying a [CommonTableExpression] or WithClause to execute this query with.

Examples

use sea_query::{IntoCondition, IntoIden, audit::*, tests_cfg::*, *};

let select = SelectStatement::new()
        .columns([Glyph::Id])
        .from(Glyph::Table)
        .and_where(Expr::col(Glyph::Image).like("0%"))
        .to_owned();
    let cte = CommonTableExpression::new()
        .query(select)
        .column(Glyph::Id)
        .table_name("cte")
        .to_owned();
    let with_clause = WithClause::new().cte(cte).to_owned();
    let query = DeleteStatement::new()
        .with_cte(with_clause)
        .from_table(Glyph::Table)
        .and_where(Expr::col(Glyph::Id).in_subquery(SelectStatement::new().column(Glyph::Id).from("cte").to_owned()))
        .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"WITH `cte` (`id`) AS (SELECT `id` FROM `glyph` WHERE `image` LIKE '0%') DELETE FROM `glyph` WHERE `id` IN (SELECT `id` FROM `cte`)"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"WITH "cte" ("id") AS (SELECT "id" FROM "glyph" WHERE "image" LIKE '0%') DELETE FROM "glyph" WHERE "id" IN (SELECT "id" FROM "cte")"#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"WITH "cte" ("id") AS (SELECT "id" FROM "glyph" WHERE "image" LIKE '0%') DELETE FROM "glyph" WHERE "id" IN (SELECT "id" FROM "cte")"#
);
assert_eq!(
    query.audit_unwrap().deleted_tables(),
    [Glyph::Table.into_iden()]
);
assert_eq!(
    query.audit_unwrap().selected_tables(),
    [Glyph::Table.into_iden()]
);

impl DeleteStatement

pub fn build_collect_any_into( &self, query_builder: &dyn QueryBuilder, sql: &mut dyn SqlWriter, )

See QueryStatementBuilder::build_collect_any_into

pub fn build_any(&self, query_builder: &dyn QueryBuilder) -> (String, Values)

See QueryStatementBuilder::build_any

pub fn build_collect_any( &self, query_builder: &dyn QueryBuilder, sql: &mut dyn SqlWriter, ) -> String

See QueryStatementBuilder::build_collect_any

impl DeleteStatement

pub fn build_collect_into<T: QueryBuilder>( &self, query_builder: T, sql: &mut dyn SqlWriter, )

See QueryStatementWriter::build_collect_into

pub fn build_collect<T: QueryBuilder>( &self, query_builder: T, sql: &mut dyn SqlWriter, ) -> String

See QueryStatementWriter::build_collect

pub fn build<T: QueryBuilder>(&self, query_builder: T) -> (String, Values)

See QueryStatementWriter::build

pub fn to_string<T: QueryBuilder>(&self, query_builder: T) -> String

See QueryStatementWriter::to_string

impl DeleteStatement

pub fn add_order_by(&mut self, order: OrderExpr) -> &mut Self

See OrderedStatement::add_order_by

pub fn clear_order_by(&mut self) -> &mut Self

See OrderedStatement::clear_order_by

pub fn order_by<T>(&mut self, col: T, order: Order) -> &mut Self

where T: IntoColumnRef,

See OrderedStatement::order_by

pub fn order_by_expr(&mut self, expr: Expr, order: Order) -> &mut Self

See OrderedStatement::order_by_expr

pub fn order_by_customs<I, T>(&mut self, cols: I) -> &mut Self

where T: ToString, I: IntoIterator<Item = (T, Order)>,

See OrderedStatement::order_by_customs

pub fn order_by_columns<I, T>(&mut self, cols: I) -> &mut Self

where T: IntoColumnRef, I: IntoIterator<Item = (T, Order)>,

See OrderedStatement::order_by_columns

pub fn order_by_with_nulls<T>( &mut self, col: T, order: Order, nulls: NullOrdering, ) -> &mut Self

where T: IntoColumnRef,

See OrderedStatement::order_by_with_nulls

pub fn order_by_expr_with_nulls( &mut self, expr: Expr, order: Order, nulls: NullOrdering, ) -> &mut Self

See OrderedStatement::order_by_expr_with_nulls

pub fn order_by_customs_with_nulls<I, T>(&mut self, cols: I) -> &mut Self

where T: ToString, I: IntoIterator<Item = (T, Order, NullOrdering)>,

See OrderedStatement::order_by_customs_with_nulls

pub fn order_by_columns_with_nulls<I, T>(&mut self, cols: I) -> &mut Self

where T: IntoColumnRef, I: IntoIterator<Item = (T, Order, NullOrdering)>,

See OrderedStatement::order_by_columns_with_nulls

impl DeleteStatement

pub fn and_or_where(&mut self, condition: LogicalChainOper) -> &mut Self

See ConditionalStatement::and_or_where

pub fn cond_where<C>(&mut self, condition: C) -> &mut Self

where C: IntoCondition,

See ConditionalStatement::cond_where

pub fn and_where_option(&mut self, other: Option<Expr>) -> &mut Self

See ConditionalStatement::and_where_option

pub fn and_where(&mut self, other: Expr) -> &mut Self

See ConditionalStatement::and_where

Trait Implementations

impl Clone for DeleteStatement

fn clone(&self) -> DeleteStatement

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl ConditionalStatement for DeleteStatement

fn cond_where<C>(&mut self, condition: C) -> &mut Self

where C: IntoCondition,

Where condition, expressed with any and all. Calling cond_where multiple times will conjoin them. Calling or_where after cond_where will panic.

fn and_where(&mut self, other: Expr) -> &mut Self

And where condition. Calling or_where after and_where will panic.

fn and_where_option(&mut self, other: Option<Expr>) -> &mut Self

Optional and where, short hand for if c.is_some() q.and_where(c).

impl Debug for DeleteStatement

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

Formats the value using the given formatter.

impl Default for DeleteStatement

fn default() -> DeleteStatement

Returns the “default value” for a type.

impl From<DeleteStatement> for QueryStatement

fn from(s: DeleteStatement) -> Self

Converts to this type from the input type.

impl From<DeleteStatement> for SubQueryStatement

fn from(s: DeleteStatement) -> Self

Converts to this type from the input type.

impl OrderedStatement for DeleteStatement

fn clear_order_by(&mut self) -> &mut Self

Clear order expressions

fn order_by<T>(&mut self, col: T, order: Order) -> &mut Self

where T: IntoColumnRef,

Order by column.

fn order_by_expr(&mut self, expr: Expr, order: Order) -> &mut Self

Order by Expr.

fn order_by_customs<I, T>(&mut self, cols: I) -> &mut Self

where T: ToString, I: IntoIterator<Item = (T, Order)>,

Order by custom string.

fn order_by_columns<I, T>(&mut self, cols: I) -> &mut Self

where T: IntoColumnRef, I: IntoIterator<Item = (T, Order)>,

Order by vector of columns.

fn order_by_with_nulls<T>( &mut self, col: T, order: Order, nulls: NullOrdering, ) -> &mut Self

where T: IntoColumnRef,

Order by column with nulls order option.

fn order_by_expr_with_nulls( &mut self, expr: Expr, order: Order, nulls: NullOrdering, ) -> &mut Self

Order by Expr with nulls order option.

fn order_by_customs_with_nulls<I, T>(&mut self, cols: I) -> &mut Self

where T: ToString, I: IntoIterator<Item = (T, Order, NullOrdering)>,

Order by custom string with nulls order option.

fn order_by_columns_with_nulls<I, T>(&mut self, cols: I) -> &mut Self

where T: IntoColumnRef, I: IntoIterator<Item = (T, Order, NullOrdering)>,

Order by vector of columns with nulls order option.

impl PartialEq for DeleteStatement

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

fn build_collect_any_into( &self, query_builder: &dyn QueryBuilder, sql: &mut dyn SqlWriter, )

Build corresponding SQL statement into the SqlWriter for certain database backend and collect query parameters

fn build_any(&self, query_builder: &dyn QueryBuilder) -> (String, Values)

Build corresponding SQL statement for certain database backend and collect query parameters into a vector

fn build_collect_any( &self, query_builder: &dyn QueryBuilder, sql: &mut dyn SqlWriter, ) -> String

Build corresponding SQL statement for certain database backend and collect query parameters

fn into_sub_query_statement(self) -> SubQueryStatement

impl QueryStatementWriter for DeleteStatement

fn build_collect_into<T: QueryBuilder>( &self, query_builder: T, sql: &mut dyn SqlWriter, )

fn to_string<T: QueryBuilder>(&self, query_builder: T) -> String

Build corresponding SQL statement for certain database backend and return SQL string

fn build<T: QueryBuilder>(&self, query_builder: T) -> (String, Values)

Build corresponding SQL statement for certain database backend and collect query parameters into a vector

fn build_collect<T: QueryBuilder>( &self, query_builder: T, sql: &mut dyn SqlWriter, ) -> String

Build corresponding SQL statement for certain database backend and collect query parameters

impl StructuralPartialEq for DeleteStatement