Struct quaint::ast::Update

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

A builder for an UPDATE statement.

Methods

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>(self, column: K, value: V) -> Update<'a> where
    K: Into<Column<'a>>,
    V: Into<DatabaseValue<'a>>, 

Add another column value assignment to the query

let query = Update::table("users").set("foo", 10).set("bar", false);
let (sql, params) = Sqlite::build(query);

assert_eq!("UPDATE `users` SET `foo` = ?, `bar` = ?", sql);

assert_eq!(
    vec![
        ParameterizedValue::Integer(10),
        ParameterizedValue::Boolean(false),
    ],
    params,
);

pub fn so_that<T>(self, conditions: T) -> Self where
    T: Into<ConditionTree<'a>>, 

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

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

assert_eq!("UPDATE `users` SET `foo` = ? WHERE `bar` = ?", sql);

assert_eq!(
    vec![
        ParameterizedValue::Integer(1),
        ParameterizedValue::Boolean(false),
    ],
    params,
);

We can also use a nested SELECT in the conditions.

let select = Select::from_table("bars").column("id").so_that("uniq_val".equals(3));
let query = Update::table("users").set("foo", 1).so_that("bar".equals(select));
let (sql, params) = Sqlite::build(query);

assert_eq!(
    "UPDATE `users` SET `foo` = ? WHERE `bar` = (SELECT `id` FROM `bars` WHERE `uniq_val` = ?)",
    sql
);

assert_eq!(
    vec![
        ParameterizedValue::Integer(1),
        ParameterizedValue::Integer(3),
    ],
    params,
);

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

Performs the conversion.

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

fn eq(&self, other: &Update<'a>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Update<'a>) -> bool

This method tests for !=.

impl<'a> StructuralPartialEq for Update<'a>