Type Alias diesel::query_builder::BoxedDeleteStatement
source · pub type BoxedDeleteStatement<'a, DB, T, Ret = NoReturningClause> = DeleteStatement<T, BoxedWhereClause<'a, DB>, Ret>;
Expand description
A DELETE
statement with a boxed WHERE
clause
Aliased Type§
struct BoxedDeleteStatement<'a, DB, T, Ret = NoReturningClause> { /* private fields */ }
Implementations§
source§impl<T: QuerySource, U> DeleteStatement<T, U, NoReturningClause>
impl<T: QuerySource, U> DeleteStatement<T, U, NoReturningClause>
sourcepub fn filter<Predicate>(self, predicate: Predicate) -> Filter<Self, Predicate>where
Self: FilterDsl<Predicate>,
pub fn filter<Predicate>(self, predicate: Predicate) -> Filter<Self, Predicate>where Self: FilterDsl<Predicate>,
Adds the given predicate to the WHERE
clause of the statement being
constructed.
If there is already a WHERE
clause, the predicate will be appended
with AND
. There is no difference in behavior between
delete(table.filter(x))
and delete(table).filter(x)
.
Example
let deleted_rows = diesel::delete(users)
.filter(name.eq("Sean"))
.execute(connection);
assert_eq!(Ok(1), deleted_rows);
let expected_names = vec!["Tess".to_string()];
let names = users.select(name).load(connection);
assert_eq!(Ok(expected_names), names);
sourcepub fn or_filter<Predicate>(
self,
predicate: Predicate
) -> OrFilter<Self, Predicate>where
Self: OrFilterDsl<Predicate>,
pub fn or_filter<Predicate>( self, predicate: Predicate ) -> OrFilter<Self, Predicate>where Self: OrFilterDsl<Predicate>,
Adds to the WHERE
clause of a query using OR
If there is already a WHERE
clause, the result will be (old OR new)
.
Calling foo.filter(bar).or_filter(baz)
is identical to foo.filter(bar.or(baz))
.
However, the second form is much harder to do dynamically.
Example
let deleted_rows = diesel::delete(users)
.filter(name.eq("Sean"))
.or_filter(name.eq("Tess"))
.execute(connection);
assert_eq!(Ok(2), deleted_rows);
let num_users = users.count().first(connection);
assert_eq!(Ok(0), num_users);
sourcepub fn into_boxed<'a, DB>(self) -> IntoBoxed<'a, Self, DB>where
DB: Backend,
Self: BoxedDsl<'a, DB>,
pub fn into_boxed<'a, DB>(self) -> IntoBoxed<'a, Self, DB>where DB: Backend, Self: BoxedDsl<'a, DB>,
Boxes the WHERE
clause of this delete statement.
This is useful for cases where you want to conditionally modify a query, but need the type to remain the same. The backend must be specified as part of this. It is not possible to box a query and have it be useable on multiple backends.
A boxed query will incur a minor performance penalty, as the query builder can no longer be inlined by the compiler. For most applications this cost will be minimal.
Example
let mut query = diesel::delete(users)
.into_boxed();
if params["sean_has_been_a_jerk"] {
query = query.filter(name.eq("Sean"));
}
let deleted_rows = query.execute(connection)?;
assert_eq!(1, deleted_rows);
let expected_names = vec!["Tess"];
let names = users.select(name).load::<String>(connection)?;
assert_eq!(expected_names, names);
source§impl<T: QuerySource, U> DeleteStatement<T, U, NoReturningClause>
impl<T: QuerySource, U> DeleteStatement<T, U, NoReturningClause>
sourcepub fn returning<E>(
self,
returns: E
) -> DeleteStatement<T, U, ReturningClause<E>>where
E: SelectableExpression<T>,
DeleteStatement<T, U, ReturningClause<E>>: Query,
pub fn returning<E>( self, returns: E ) -> DeleteStatement<T, U, ReturningClause<E>>where E: SelectableExpression<T>, DeleteStatement<T, U, ReturningClause<E>>: Query,
Specify what expression is returned after execution of the delete
.
Examples
Deleting a record:
let deleted_name = diesel::delete(users.filter(name.eq("Sean")))
.returning(name)
.get_result(connection);
assert_eq!(Ok("Sean".to_string()), deleted_name);
Trait Implementations§
source§impl<T, U> AsQuery for DeleteStatement<T, U, NoReturningClause>where
T: Table,
T::AllColumns: SelectableExpression<T>,
DeleteStatement<T, U, ReturningClause<T::AllColumns>>: Query,
impl<T, U> AsQuery for DeleteStatement<T, U, NoReturningClause>where T: Table, T::AllColumns: SelectableExpression<T>, DeleteStatement<T, U, ReturningClause<T::AllColumns>>: Query,
§type SqlType = <<DeleteStatement<T, U, NoReturningClause> as AsQuery>::Query as Query>::SqlType
type SqlType = <<DeleteStatement<T, U, NoReturningClause> as AsQuery>::Query as Query>::SqlType
Self::Query
§type Query = DeleteStatement<T, U, ReturningClause<<T as Table>::AllColumns>>
type Query = DeleteStatement<T, U, ReturningClause<<T as Table>::AllColumns>>
source§impl<'a, T, U, Ret, DB> BoxedDsl<'a, DB> for DeleteStatement<T, U, Ret>where
U: Into<BoxedWhereClause<'a, DB>>,
T: QuerySource,
impl<'a, T, U, Ret, DB> BoxedDsl<'a, DB> for DeleteStatement<T, U, Ret>where U: Into<BoxedWhereClause<'a, DB>>, T: QuerySource,
§type Output = DeleteStatement<T, BoxedWhereClause<'a, DB>, Ret>
type Output = DeleteStatement<T, BoxedWhereClause<'a, DB>, Ret>
internal_into_boxed
source§fn internal_into_boxed(self) -> Self::Output
fn internal_into_boxed(self) -> Self::Output
source§impl<T, U, Ret> Clone for DeleteStatement<T, U, Ret>where
T: QuerySource,
FromClause<T>: Clone,
U: Clone,
Ret: Clone,
impl<T, U, Ret> Clone for DeleteStatement<T, U, Ret>where T: QuerySource, FromClause<T>: Clone, U: Clone, Ret: Clone,
source§impl<T, U, Ret> Debug for DeleteStatement<T, U, Ret>where
T: QuerySource,
FromClause<T>: Debug,
U: Debug,
Ret: Debug,
impl<T, U, Ret> Debug for DeleteStatement<T, U, Ret>where T: QuerySource, FromClause<T>: Debug, U: Debug, Ret: Debug,
source§impl<T, U, Ret, Predicate> FilterDsl<Predicate> for DeleteStatement<T, U, Ret>where
U: WhereAnd<Predicate>,
Predicate: AppearsOnTable<T>,
T: QuerySource,
impl<T, U, Ret, Predicate> FilterDsl<Predicate> for DeleteStatement<T, U, Ret>where U: WhereAnd<Predicate>, Predicate: AppearsOnTable<T>, T: QuerySource,
source§impl<T, U, Ret, Predicate> OrFilterDsl<Predicate> for DeleteStatement<T, U, Ret>where
T: QuerySource,
U: WhereOr<Predicate>,
Predicate: AppearsOnTable<T>,
impl<T, U, Ret, Predicate> OrFilterDsl<Predicate> for DeleteStatement<T, U, Ret>where T: QuerySource, U: WhereOr<Predicate>, Predicate: AppearsOnTable<T>,
source§impl<T, U, Ret> Query for DeleteStatement<T, U, ReturningClause<Ret>>where
T: Table,
Ret: SelectableExpression<T>,
impl<T, U, Ret> Query for DeleteStatement<T, U, ReturningClause<Ret>>where T: Table, Ret: SelectableExpression<T>,
§type SqlType = <Ret as Expression>::SqlType
type SqlType = <Ret as Expression>::SqlType
source§impl<T, U, Ret> QueryId for DeleteStatement<T, U, Ret>where
T: QuerySource + QueryId + 'static,
U: QueryId,
Ret: QueryId,
impl<T, U, Ret> QueryId for DeleteStatement<T, U, Ret>where T: QuerySource + QueryId + 'static, U: QueryId, Ret: QueryId,
source§impl<T, U, Ret, Conn> RunQueryDsl<Conn> for DeleteStatement<T, U, Ret>where
T: QuerySource,
impl<T, U, Ret, Conn> RunQueryDsl<Conn> for DeleteStatement<T, U, Ret>where T: QuerySource,
source§fn load<'query, U>(self, conn: &mut Conn) -> QueryResult<Vec<U>>where
Self: LoadQuery<'query, Conn, U>,
fn load<'query, U>(self, conn: &mut Conn) -> QueryResult<Vec<U>>where Self: LoadQuery<'query, Conn, U>,
source§fn load_iter<'conn, 'query: 'conn, U, B>(
self,
conn: &'conn mut Conn
) -> QueryResult<LoadIter<'conn, 'query, Self, Conn, U, B>>where
U: 'conn,
Self: LoadQuery<'query, Conn, U, B> + 'conn,
fn load_iter<'conn, 'query: 'conn, U, B>( self, conn: &'conn mut Conn ) -> QueryResult<LoadIter<'conn, 'query, Self, Conn, U, B>>where U: 'conn, Self: LoadQuery<'query, Conn, U, B> + 'conn,
source§fn get_result<'query, U>(self, conn: &mut Conn) -> QueryResult<U>where
Self: LoadQuery<'query, Conn, U>,
fn get_result<'query, U>(self, conn: &mut Conn) -> QueryResult<U>where Self: LoadQuery<'query, Conn, U>,
source§fn get_results<'query, U>(self, conn: &mut Conn) -> QueryResult<Vec<U>>where
Self: LoadQuery<'query, Conn, U>,
fn get_results<'query, U>(self, conn: &mut Conn) -> QueryResult<Vec<U>>where Self: LoadQuery<'query, Conn, U>,
Vec
with the affected rows. Read more