[][src]Struct diesel::pg::upsert::IncompleteOnConflict

pub struct IncompleteOnConflict<Stmt, Target> { /* fields omitted */ }

A partially constructed ON CONFLICT clause.

Methods

impl<T, U, Op, Ret, Target> IncompleteOnConflict<InsertStatement<T, U, Op, Ret>, Target>[src]

pub fn do_nothing(
    self
) -> InsertStatement<T, OnConflictValues<U, Target, DoNothing>, Op, Ret>
[src]

Creates a query with ON CONFLICT (target) DO NOTHING

If you want to do nothing when any constraint conflicts, use on_conflict_do_nothing instead. See on_conflict for usage examples.

impl<Stmt, Target> IncompleteOnConflict<Stmt, Target>[src]

pub fn do_update(self) -> IncompleteDoUpdate<Stmt, Target>[src]

Used to create a query in the form ON CONFLICT (...) DO UPDATE ...

Call .set on the result of this function with the changes you want to apply. The argument to set can be anything that implements AsChangeset (e.g. anything you could pass to set on a normal update statement).

Note: When inserting more than one row at a time, this query can still fail if the rows being inserted conflict with each other.

Examples

Set specific value on conflict

let user = User { id: 1, name: "Pascal" };
let user2 = User { id: 1, name: "Sean" };

assert_eq!(Ok(1), diesel::insert_into(users).values(&user).execute(&conn));

let insert_count = diesel::insert_into(users)
    .values(&user2)
    .on_conflict(id)
    .do_update()
    .set(name.eq("I DONT KNOW ANYMORE"))
    .execute(&conn);
assert_eq!(Ok(1), insert_count);

let users_in_db = users.load(&conn);
assert_eq!(Ok(vec![(1, "I DONT KNOW ANYMORE".to_string())]), users_in_db);

Set AsChangeset struct on conflict

let user = User { id: 1, name: "Pascal" };
let user2 = User { id: 1, name: "Sean" };

assert_eq!(Ok(1), diesel::insert_into(users).values(&user).execute(&conn));

let insert_count = diesel::insert_into(users)
    .values(&user2)
    .on_conflict(id)
    .do_update()
    .set(&user2)
    .execute(&conn);
assert_eq!(Ok(1), insert_count);

let users_in_db = users.load(&conn);
assert_eq!(Ok(vec![(1, "Sean".to_string())]), users_in_db);

Use excluded to get the rejected value

use diesel::pg::upsert::excluded;

let user = User { id: 1, name: "Pascal" };
let user2 = User { id: 1, name: "Sean" };
let user3 = User { id: 2, name: "Tess" };

assert_eq!(Ok(1), diesel::insert_into(users).values(&user).execute(&conn));

let insert_count = diesel::insert_into(users)
    .values(&vec![user2, user3])
    .on_conflict(id)
    .do_update()
    .set(name.eq(excluded(name)))
    .execute(&conn);
assert_eq!(Ok(2), insert_count);

let users_in_db = users.load(&conn);
assert_eq!(Ok(vec![(1, "Sean".to_string()), (2, "Tess".to_string())]), users_in_db);

Trait Implementations

impl<Stmt: Clone, Target: Clone> Clone for IncompleteOnConflict<Stmt, Target>[src]

fn clone_from(&mut self, source: &Self)1.0.0[src]

Performs copy-assignment from source. Read more

impl<Stmt: Copy, Target: Copy> Copy for IncompleteOnConflict<Stmt, Target>[src]

impl<Stmt: Debug, Target: Debug> Debug for IncompleteOnConflict<Stmt, Target>[src]

Auto Trait Implementations

impl<Stmt, Target> Unpin for IncompleteOnConflict<Stmt, Target> where
    Stmt: Unpin,
    Target: Unpin

impl<Stmt, Target> Sync for IncompleteOnConflict<Stmt, Target> where
    Stmt: Sync,
    Target: Sync

impl<Stmt, Target> Send for IncompleteOnConflict<Stmt, Target> where
    Stmt: Send,
    Target: Send

impl<Stmt, Target> UnwindSafe for IncompleteOnConflict<Stmt, Target> where
    Stmt: UnwindSafe,
    Target: UnwindSafe

impl<Stmt, Target> RefUnwindSafe for IncompleteOnConflict<Stmt, Target> where
    Stmt: RefUnwindSafe,
    Target: RefUnwindSafe

Blanket Implementations

impl<T> IntoSql for T[src]

fn into_sql<T>(self) -> AsExprOf<Self, T> where
    Self: AsExpression<T> + Sized
[src]

Convert self to an expression for Diesel's query builder. Read more

fn as_sql<'a, T>(&'a self) -> AsExprOf<&'a Self, T> where
    &'a Self: AsExpression<T>, 
[src]

Convert &self to an expression for Diesel's query builder. Read more

impl<T> From<T> for T[src]

impl<T> ToOwned for T where
    T: Clone
[src]

type Owned = T

The resulting type after obtaining ownership.

impl<T, U> Into<U> for T where
    U: From<T>, 
[src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 
[src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 
[src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

impl<T> BorrowMut<T> for T where
    T: ?Sized
[src]

impl<T> Borrow<T> for T where
    T: ?Sized
[src]

impl<T> Any for T where
    T: 'static + ?Sized
[src]