Type Alias DeleteBuilder 

pub type DeleteBuilder<'a, Schema, State, Table, Marker = (), Row = ()> = QueryBuilder<'a, Schema, State, Table, Marker, Row>;

A DELETE query being built for SQLite.

This is QueryBuilder in one of the Delete* states. Start it with QueryBuilder::delete.

Clause order

1. where (required): the rows to delete. r#where(true) deletes every row.
2. Optionally returning.

The WHERE condition and the RETURNING columns may only reference the table being deleted from; other tables do not compile.

Examples

use drizzle::sqlite::prelude::*;
use drizzle::core::expr::{eq, lt};
use drizzle::sqlite::builder::QueryBuilder;

#[SQLiteTable(name = "users")]
struct User {
    #[column(primary)]
    id: i32,
    name: String,
    email: Option<String>,
}

#[derive(SQLiteSchema)]
struct Schema {
    user: User,
}

let builder = QueryBuilder::new::<Schema>();
let Schema { user } = Schema::new();

// Delete specific row
let query = builder
    .delete(user)
    .r#where(eq(user.id, 1));
assert_eq!(query.to_sql().sql(), r#"DELETE FROM "users" WHERE "users"."id" = ?"#);

// Delete multiple rows
let query = builder
    .delete(user)
    .r#where(lt(user.id, 100));
assert_eq!(query.to_sql().sql(), r#"DELETE FROM "users" WHERE "users"."id" < ?"#);

With RETURNING:

let query = builder
    .delete(user)
    .r#where(eq(user.id, 1))
    .returning((user.id, user.name));
assert_eq!(
    query.to_sql().sql(),
    r#"DELETE FROM "users" WHERE "users"."id" = ? RETURNING "users"."id", "users"."name""#
);

r#where(true) deletes every row:

let query = builder.delete(log).r#where(true);
assert_eq!(query.to_sql().sql(), r#"DELETE FROM "logs" WHERE ?"#);

Aliased Type

pub struct DeleteBuilder<'a, Schema, State, Table, Marker = (), Row = ()> {
    pub sql: SQL<'a, SQLiteValue<'a>>,
    /* private fields */
}

Fields

sql: SQL<'a, SQLiteValue<'a>>

The SQL built so far.

Implementations

impl<'a, S, T> DeleteBuilder<'a, S, DeleteInitial, T>

pub fn where<E, ScopeProof>( self, condition: E, ) -> DeleteBuilder<'a, S, DeleteWhereSet, T>

where E: ExprSources + Expr<'a, SQLiteValue<'a>>, E::Sources: SourcesIn<Cons<T, Nil>, ScopeProof>, E::SQLType: BooleanLike,

Adds a WHERE clause that picks the rows to delete.

A DELETE runs only with a WHERE clause, so a forgotten condition does not empty the table; r#where(true) deletes every row. The condition must be a boolean expression over the target table’s columns.

Examples

// Delete specific row by ID
let query = builder
    .delete(user)
    .r#where(eq(user.id, 1));
assert_eq!(query.to_sql().sql(), r#"DELETE FROM "users" WHERE "users"."id" = ?"#);

// Delete with complex conditions
let query = builder
    .delete(user)
    .r#where(and(
        gt(user.id, 100),
        or(eq(user.name, "test"), eq(user.age, 0))
    ));
assert_eq!(
    query.to_sql().sql(),
    r#"DELETE FROM "users" WHERE ("users"."id" > ? AND ("users"."name" = ? OR "users"."age" = ?))"#
);

impl<'a, S, T> DeleteBuilder<'a, S, DeleteWhereSet, T>

pub fn returning<Columns, ScopeProof>( self, columns: Columns, ) -> DeleteBuilder<'a, S, DeleteReturningSet, T, Scoped<<Columns as IntoSelectTarget>::Marker, Cons<T, Nil>>, <<Columns as IntoSelectTarget>::Marker as ResolveRow<T>>::Row>

where Columns: ExprSources + ToSQL<'a, SQLiteValue<'a>> + IntoSelectTarget, Columns::Sources: SourcesIn<Cons<T, Nil>, ScopeProof>, Columns::Marker: ResolveRow<T>,

Adds a RETURNING clause after WHERE. See returning.