Struct Update

pub struct Update<'a> { /* private fields */ }

A builder for an UPDATE statement.

Implementations

impl<'a> Update<'a>

pub fn table<T>(table: T) -> Self

where T: Into<Table<'a>>,

Creates the basis for an UPDATE statement to the given table.

pub fn set<K, V>(&mut self, column: K, value: V)

where K: Into<Column<'a>>, V: Into<Expression<'a>>,

Add another column value assignment to the query

let mut query = Update::table("users");
query.set("foo", 10);
query.set("bar", false);

let (sql, params) = renderer::Postgres::build(query);
assert_eq!(r#"UPDATE "users" SET "foo" = $1, "bar" = $2"#, sql);

assert_eq!(
    vec![
        Value::from(10),
        Value::from(false),
    ],
    params,
);

pub fn so_that<T>(&mut self, conditions: T)

where T: Into<ConditionTree<'a>>,

Adds WHERE conditions to the query. See Comparable for more examples.

let mut query = Update::table("users");
query.set("foo", 1);
query.so_that("bar".equals(false));

let (sql, params) = renderer::Postgres::build(query);

assert_eq!(r#"UPDATE "users" SET "foo" = $1 WHERE "bar" = $2"#, sql);

assert_eq!(
    vec![
        Value::from(1),
        Value::from(false),
    ],
    params,
);

We can also use a nested SELECT in the conditions.

let mut select = Select::from_table("bars");
select.column("id");
select.so_that("uniq_val".equals(3));

let mut query = Update::table("users");
query.set("foo", 1);
query.so_that("bar".equals(select));

let (sql, params) = renderer::Postgres::build(query);

assert_eq!(
    r#"UPDATE "users" SET "foo" = $1 WHERE "bar" = (SELECT "id" FROM "bars" WHERE "uniq_val" = $2)"#,
    sql
);

assert_eq!(
    vec![
        Value::from(1),
        Value::from(3),
    ],
    params,
);

pub fn returning<K, I>(&mut self, columns: I)

where K: Into<Column<'a>>, I: IntoIterator<Item = K>,

Sets the returned columns.

let mut update = Update::table("users");
update.set("foo", 10);
update.returning(vec!["id"]);

let (sql, _) = renderer::Postgres::build(update);

assert_eq!(r#"UPDATE "users" SET "foo" = $1 RETURNING "id""#, sql);

Trait Implementations

impl<'a> Clone for Update<'a>

fn clone(&self) -> Update<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Update<'a>

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

Formats the value using the given formatter.

impl<'a> From<Update<'a>> for Query<'a>

fn from(update: Update<'a>) -> Self

Converts to this type from the input type.

impl<'a> PartialEq for Update<'a>

fn eq(&self, other: &Update<'a>) -> 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<'a> StructuralPartialEq for Update<'a>