Enum quaint::ast::OnConflict

pub enum OnConflict<'a> {
    DoNothing,
    Update(Update<'a>, Vec<Column<'a>>),
}

INSERT conflict resolution strategies.

Variants

DoNothing

When a row already exists, do nothing. Works with PostgreSQL, MySQL or SQLite without schema information.

let query: Insert = Insert::single_into("users").into();
let (sql, _) = Sqlite::build(query.on_conflict(OnConflict::DoNothing))?;
assert_eq!("INSERT OR IGNORE INTO `users` DEFAULT VALUES", sql);

With Microsoft SQL server not supporting IGNORE in the INSERT statement, the INSERT is converted to a MERGE statement. For it to work in a correct way, the table should know all unique indices of the actual table.

In this example our users table holds one unique index for the id column.

let id = Column::from("id").table("users");
let table = Table::from("users").add_unique_index(id.clone());
let query: Insert = Insert::single_into(table).value(id, 1).into();
let (sql, _) = Mssql::build(query.on_conflict(OnConflict::DoNothing))?;

let expected_sql = indoc!(
    "
    MERGE INTO [users]
    USING (SELECT @P1 AS [id]) AS [dual] ([id])
    ON [dual].[id] = [users].[id]
    WHEN NOT MATCHED THEN
    INSERT ([id]) VALUES ([dual].[id]);
"
);

assert_eq!(expected_sql.replace('\n', " ").trim(), sql);

If the INSERT statement misses a value for a unique column that does not have default value set, the visitor will raise a panic. For compound unique indices, the add_unique_index takes a vector as a parameter.

If the column has a default value, it should be added to the Column definition to allow inserting missing unique values with the Insert statement. If default is set to DefaultValue::Generated, the value is considered to be always unique and not added to the join.

Update(Update<'a>, Vec<Column<'a>>)

ON CONFLICT UPDATE is supported for Sqlite and Postgres

Trait Implementations

impl<'a> Clone for OnConflict<'a>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for OnConflict<'a>

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

Formats the value using the given formatter.

impl<'a> PartialEq for OnConflict<'a>

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

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> StructuralPartialEq for OnConflict<'a>