Struct IncompleteOnConflict 

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

A partially constructed ON CONFLICT clause.

Implementations

impl<T: QuerySource, U, Op, Ret, Target> IncompleteOnConflict<InsertStatement<T, U, Op, Ret>, Target>

pub fn do_nothing(self) -> DoNothing<Self>

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.

pub fn do_update(self) -> DoUpdate<Self>

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

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.

For some backends (PostgreSQL, SQLite) a WHERE clause can be used to limit the rows actually updated. For PostgreSQL and SQLite you can use the .filter() method to add conditions like that.

Examples

Set specific value on conflict

PostgreSQL/SQLite:

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);
assert_eq!(Ok(2), insert_count);

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

MySQL:

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)
);

diesel::insert_into(users)
    .values(&user2)
    .on_conflict(diesel::dsl::DuplicatedKeys)
    .do_update()
    .set(name.eq("I DONT KNOW ANYMORE"))
    .execute(conn)?;

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

PostgreSQL & SQLite:

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);

MySQL:

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)
);

diesel::insert_into(users)
    .values(&user2)
    .on_conflict(diesel::dsl::DuplicatedKeys)
    .do_update()
    .set(&user2)
    .execute(conn)?;

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::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)
);

#[cfg(feature = "postgres")]
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
);

Use .filter()method to limit the rows actually updated

use self::users::dsl::*;
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)
    .filter(id.ge(5))
    .execute(conn);
assert_eq!(Ok(0), insert_count);

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

Trait Implementations

impl<Stmt: Clone, Target: Clone> Clone for IncompleteOnConflict<Stmt, Target>

fn clone(&self) -> IncompleteOnConflict<Stmt, Target>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Stmt: Copy, Target: Copy> Copy for IncompleteOnConflict<Stmt, Target>

impl<Stmt: Debug, Target: Debug> Debug for IncompleteOnConflict<Stmt, Target>

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

Formats the value using the given formatter.

impl<Stmt, T, P> DecoratableTarget<P> for IncompleteOnConflict<Stmt, T>

where P: Expression, P::SqlType: BoolOrNullableBool, T: DecoratableTarget<P>,

fn filter_target(self, predicate: P) -> Self::FilterOutput

Adds a WHERE predicate to the ON CONFLICT target, telling PostgreSQL which unique index to check for conflicts.

This generates ON CONFLICT (target) WHERE predicate DO ... SQL. PostgreSQL selects unique indexes whose WHERE clause is implied by the predicate. The predicate does not need to exactly match the index’s WHERE clause; implication is sufficient.

Calling .filter_target() multiple times combines the predicates with AND. PostgreSQL only.

Example

diesel::sql_query(
    "CREATE UNIQUE INDEX users_name_active ON users (name) WHERE id > 5",
)
.execute(conn)?;

let user = User { id: 10, name: "Sean" };
diesel::insert_into(users).values(&user).execute(conn)?;

// id=11 satisfies the partial index predicate, so uniqueness is violated: does nothing.
let count = diesel::insert_into(users)
    .values(User { id: 11, name: "Sean" })
    .on_conflict(name)
    .filter_target(id.gt(5))
    .do_nothing()
    .execute(conn)?;
assert_eq!(count, 0);

// id=3 does not satisfy the partial index predicate, so it is not covered by the index:
// no uniqueness violation, inserts normally.
let count = diesel::insert_into(users)
    .values(User { id: 3, name: "Sean" })
    .on_conflict(name)
    .filter_target(id.gt(5))
    .do_nothing()
    .execute(conn)?;
assert_eq!(count, 1);

Do update

diesel::sql_query(
    "CREATE UNIQUE INDEX users_name_do_update ON users (name) WHERE id > 5",
)
.execute(conn)?;

diesel::insert_into(users)
    .values(User { id: 10, name: "Sean" })
    .execute(conn)?;

// id=11 satisfies the partial index predicate, so uniqueness is violated: name updated.
diesel::insert_into(users)
    .values(User { id: 11, name: "Sean" })
    .on_conflict(name)
    .filter_target(id.gt(5))
    .do_update()
    .set(name.eq("Updated"))
    .execute(conn)?;

let names = users.filter(id.gt(5)).select(name).load::<String>(conn)?;
assert_eq!(names, vec!["Updated"]);

Chaining filter_target

Calling .filter_target() multiple times combines the predicates with AND, which is useful when the unique index WHERE clause has multiple conditions.

diesel::sql_query(
    "CREATE UNIQUE INDEX users_name_range ON users (name) WHERE id > 5 AND id < 100",
)
.execute(conn)?;

diesel::insert_into(users)
    .values(User { id: 10, name: "Sean" })
    .execute(conn)?;

// Combined predicate matches the partial index, conflict detected: do nothing.
let count = diesel::insert_into(users)
    .values(User { id: 11, name: "Sean" })
    .on_conflict(name)
    .filter_target(id.gt(5))
    .filter_target(id.lt(100))
    .do_nothing()
    .execute(conn)?;
assert_eq!(count, 0);

type FilterOutput = IncompleteOnConflict<Stmt, <T as DecoratableTarget<P>>::FilterOutput>

The type returned by filter_target.