Struct Delete 

pub struct Delete { /* private fields */ }

Builder of Delete command.

Basic API

use sql_query_builder as sql;

let query = sql::Delete::new()
  .delete_from("users")
  .where_clause("id = $1")
  .as_string();

Output

DELETE FROM users WHERE id = $1

Implementations

impl Delete

pub fn as_string(&self) -> String

Gets the current state of the Delete and returns it as string

Example

let query = sql::Delete::new()
  .delete_from("users")
  .where_clause("id = $1")
  .as_string();

Output

DELETE FROM users WHERE id = $1

pub fn debug(self) -> Self

Prints the current state of the Delete to the standard output in a more ease to read version. This method is useful to debug complex queries or just print the generated SQL while you type

Example

let query = sql::Delete::new()
  .delete_from("users")
  .where_clause("login = 'foo'")
  .where_clause("name = 'Foo'")
  .debug()
  .as_string();

Prints to the standard output

-- ------------------------------------------------------------------------------
DELETE FROM users
WHERE
  login = 'foo'
  AND name = 'Foo'
-- ------------------------------------------------------------------------------

pub fn delete_from(self, table: &str) -> Self

The delete and from clauses. This method overrides the previous value

Example

let delete = sql::Delete::new()
  .delete_from("orders");

let delete = sql::Delete::new()
  .delete_from("addresses")
  .delete_from("orders");

Output

DELETE FROM orders

pub fn new() -> Self

Creates instance of the Delete command

pub fn print(self) -> Self

Prints the current state of the Delete to the standard output similar to debug method, the difference is that this method prints in one line.

pub fn raw(self, raw_sql: &str) -> Self

Adds at the beginning a raw SQL query.

Example

let raw_query = "delete from users";

let query = sql::Delete::new()
  .raw(raw_query)
  .where_clause("login = 'foo'")
  .as_string();

Output

delete from users WHERE login = 'foo'

pub fn raw_after(self, clause: DeleteClause, raw_sql: &str) -> Self

Adds a raw SQL query after a specified clause.

Example

let raw = "where name = 'Foo'";

let query = sql::Delete::new()
  .delete_from("users")
  .raw_after(sql::DeleteClause::DeleteFrom, raw)
  .as_string();

Output

DELETE FROM users where name = 'Foo'

pub fn raw_before(self, clause: DeleteClause, raw_sql: &str) -> Self

Adds a raw SQL query before a specified clause.

Example

let raw = "delete from users";

let query = sql::Delete::new()
  .raw_before(sql::DeleteClause::Where, raw)
  .where_clause("name = 'Bar'")
  .as_string();

Output

delete from users WHERE name = 'Bar'

pub fn where_and(self, condition: &str) -> Self

The method will concatenate multiples calls using the and operator. This method is un alias of where_clause.

Example

let query = sql::Delete::new()
  .where_clause("login = $1")
  .where_and("product_id = $2")
  .where_and("created_at >= current_date")
  .as_string();

Outputs

WHERE
  login = $1
  AND product_id = $2
  AND created_at >= current_date

pub fn where_clause(self, condition: &str) -> Self

The where clause, this method will concatenate multiples calls using the and operator. If you intended to use the or operator you should use the where_or method

Example

let query = sql::Delete::new()
  .where_clause("login = $1")
  .where_clause("status = 'deactivated'")
  .as_string();

Outputs

WHERE
  login = $1
  AND status = 'deactivated'

pub fn where_or(self, condition: &str) -> Self

The where clause that concatenate multiples calls using the OR operator. If you intended to use the and operator you should use the where_clause method

Example

let query = sql::Delete::new()
  .where_clause("login = 'foo'")
  .where_or("login = 'bar'")
  .as_string();

Output

WHERE
  login = 'foo'
  OR login = 'bar'

impl Delete

pub fn with( self, name: &str, query: impl WithQuery + 'static + Send + Sync, ) -> Self

Available on crate features postgresql and sqlite and mysql only.

The with clause

Example

let deactivated_users = sql::Select::new()
  .select("id")
  .from("users")
  .where_clause("ative = false");

let delete = sql::Delete::new()
  .with("deactivated_users", deactivated_users)
  .delete_from("users")
  .where_clause("id in (select * from deactivated_users)")
  .debug();

Output

WITH deactivated_users AS (
  SELECT id
  FROM users
  WHERE ative = false
)
DELETE FROM users
WHERE id in (select * from deactivated_users)

impl Delete

pub fn returning(self, output_name: &str) -> Self

Available on crate features postgresql and sqlite only.

The returning clause

Example

let delete = sql::Delete::new()
  .delete_from("users")
  .returning("id")
  .returning("login");

Output

DELETE FROM users RETURNING id, login

impl Delete

pub fn delete(self, table: &str) -> Self

Available on crate feature mysql only.

The delete clause. MySQL allow single and multi-table deletes

Single-table delete

let delete = sql::Delete::new()
  .delete("low_priority")
  .from("t1")
  .where_clause("t1.id = '123'");

Output

DELETE low_priority FROM t1 WHERE t1.id = '123'

If the delete clause has no argument you can use the delete_from method.

let delete = sql::Delete::new()
  .delete_from("t1")
  .where_clause("t1.id = '123'");

Output

DELETE FROM t1 WHERE t1.id = '123'

Multi-table deletes

let delete = sql::Delete::new()
  .delete("t1")
  .delete("t2")
  .from("t1")
  .inner_join("t2")
  .inner_join("t3")
  .where_clause("t1.id = t2.id")
  .where_and("t2.id = t3.id");

Output

DELETE t1, t2
FROM t1
INNER JOIN t2
INNER JOIN t3
WHERE
  t1.id = t2.id
  AND t2.id = t3.id

pub fn from(self, table: &str) -> Self

Available on crate feature mysql only.

The from clause

Example

let query = sql::Delete::new()
  .from("users")
  .as_string();

Output

FROM users

pub fn cross_join(self, table: &str) -> Self

Available on crate feature mysql only.

The cross join clause

Example

let query = sql::Delete::new()
  .cross_join("addresses")
  .as_string();

Output

CROSS JOIN addresses

pub fn inner_join(self, table: &str) -> Self

Available on crate feature mysql only.

The inner join clause

Example

let query = sql::Delete::new()
  .inner_join("addresses on addresses.user_login = users.login")
  .as_string();

Output

INNER JOIN addresses on addresses.user_login = users.login

pub fn left_join(self, table: &str) -> Self

Available on crate feature mysql only.

The left join clause

Example

let query = sql::Delete::new()
  .left_join("addresses on addresses.user_login = users.login")
  .as_string();

Output

LEFT JOIN addresses on addresses.user_login = users.login

pub fn right_join(self, table: &str) -> Self

Available on crate feature mysql only.

The right join clause

Example

let query = sql::Delete::new()
  .right_join("addresses on addresses.user_login = users.login")
  .as_string();

Output

RIGHT JOIN addresses on addresses.user_login = users.login

pub fn limit(self, num: &str) -> Self

Available on crate feature mysql only.

The limit clause, this method overrides the previous value

Example

let delete = sql::Delete::new()
  .limit("123");

let delete = sql::Delete::new()
  .limit("1000")
  .limit("123");

Output

LIMIT 123

pub fn order_by(self, column: &str) -> Self

Available on crate feature mysql only.

The order by clause

Example

let delete = sql::Delete::new()
  .order_by("created_at asc");

Output

ORDER BY created_at asc

pub fn partition(self, name: &str) -> Self

Available on crate feature mysql only.

The partition clause

Example

let query = sql::Delete::new()
  .delete_from("employees")
  .partition("p1")
  .to_string();

Output

DELETE FROM employees PARTITION (p1)

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 Default for Delete

fn default() -> Delete

Returns the “default value” for a type.

impl Display for Delete

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

Formats the value using the given formatter.