Type Alias diesel::query_builder::InsertOrIgnoreStatement
source · pub type InsertOrIgnoreStatement<T, U, Ret = NoReturningClause> = InsertStatement<T, U, InsertOrIgnore, Ret>;
Expand description
Represents a complete INSERT OR IGNORE
statement.
Aliased Type§
struct InsertOrIgnoreStatement<T, U, Ret = NoReturningClause> {
pub operator: InsertOrIgnore,
pub target: T,
pub records: U,
pub returning: Ret,
/* private fields */
}
Fields§
§operator: InsertOrIgnore
The operator used by this InsertStatement
Corresponds to either Insert
or Replace
target: T
The table we are inserting into
records: U
The data which should be inserted
returning: Ret
An optional returning clause
Implementations§
source§impl<T: QuerySource, U, Op, Ret> InsertStatement<T, U, Op, Ret>
impl<T: QuerySource, U, Op, Ret> InsertStatement<T, U, Op, Ret>
source§impl<T: QuerySource, U, C, Op, Ret> InsertStatement<T, InsertFromSelect<U, C>, Op, Ret>
impl<T: QuerySource, U, C, Op, Ret> InsertStatement<T, InsertFromSelect<U, C>, Op, Ret>
sourcepub fn into_columns<C2>(
self,
columns: C2
) -> InsertStatement<T, InsertFromSelect<U, C2>, Op, Ret>where
C2: ColumnList<Table = T> + Expression,
U: Query<SqlType = C2::SqlType>,
pub fn into_columns<C2>( self, columns: C2 ) -> InsertStatement<T, InsertFromSelect<U, C2>, Op, Ret>where C2: ColumnList<Table = T> + Expression, U: Query<SqlType = C2::SqlType>,
Set the column list when inserting from a select statement
See the documentation for insert_into
for usage examples.
source§impl<T: QuerySource, U, Op> InsertStatement<T, U, Op>
impl<T: QuerySource, U, Op> InsertStatement<T, U, Op>
sourcepub fn returning<E>(
self,
returns: E
) -> InsertStatement<T, U, Op, ReturningClause<E>>where
InsertStatement<T, U, Op, ReturningClause<E>>: Query,
pub fn returning<E>( self, returns: E ) -> InsertStatement<T, U, Op, ReturningClause<E>>where InsertStatement<T, U, Op, ReturningClause<E>>: Query,
Specify what expression is returned after execution of the insert
.
Examples
Inserting records:
let inserted_names = diesel::insert_into(users)
.values(&vec![name.eq("Timmy"), name.eq("Jimmy")])
.returning(name)
.get_results(connection);
assert_eq!(Ok(vec!["Timmy".to_string(), "Jimmy".to_string()]), inserted_names);
source§impl<T, U, Op, Ret> InsertStatement<T, U, Op, Ret>where
T: QuerySource,
U: UndecoratedInsertRecord<T> + IntoConflictValueClause,
impl<T, U, Op, Ret> InsertStatement<T, U, Op, Ret>where T: QuerySource, U: UndecoratedInsertRecord<T> + IntoConflictValueClause,
sourcepub fn on_conflict_do_nothing(
self
) -> InsertStatement<T, OnConflictValues<U::ValueClause, NoConflictTarget, DoNothing>, Op, Ret>
pub fn on_conflict_do_nothing( self ) -> InsertStatement<T, OnConflictValues<U::ValueClause, NoConflictTarget, DoNothing>, Op, Ret>
Adds ON CONFLICT DO NOTHING
to the insert statement, without
specifying any columns or constraints to restrict the conflict to.
Examples
Single Record
let user = User { id: 1, name: "Sean" };
let inserted_row_count = diesel::insert_into(users)
.values(&user)
.on_conflict_do_nothing()
.execute(conn);
assert_eq!(Ok(1), inserted_row_count);
let inserted_row_count = diesel::insert_into(users)
.values(&user)
.on_conflict_do_nothing()
.execute(conn);
assert_eq!(Ok(0), inserted_row_count);
Vec of Records
let user = User { id: 1, name: "Sean" };
let inserted_row_count = diesel::insert_into(users)
.values(&vec![user, user])
.on_conflict_do_nothing()
.execute(conn);
assert_eq!(Ok(1), inserted_row_count);
sourcepub fn on_conflict<Target>(
self,
target: Target
) -> IncompleteOnConflict<InsertStatement<T, U::ValueClause, Op, Ret>, ConflictTarget<Target>>where
ConflictTarget<Target>: OnConflictTarget<T>,
pub fn on_conflict<Target>( self, target: Target ) -> IncompleteOnConflict<InsertStatement<T, U::ValueClause, Op, Ret>, ConflictTarget<Target>>where ConflictTarget<Target>: OnConflictTarget<T>,
Adds an ON CONFLICT
to the insert statement, if a conflict occurs
for the given unique constraint.
Target
can be one of:
- A column
- A tuple of columns
on_constraint("constraint_name")
Examples
Specifying a column as the target
diesel::sql_query("CREATE UNIQUE INDEX users_name ON users (name)").execute(conn).unwrap();
let user = User { id: 1, name: "Sean" };
let same_name_different_id = User { id: 2, name: "Sean" };
let same_id_different_name = User { id: 1, name: "Pascal" };
assert_eq!(Ok(1), diesel::insert_into(users).values(&user).execute(conn));
let inserted_row_count = diesel::insert_into(users)
.values(&same_name_different_id)
.on_conflict(name)
.do_nothing()
.execute(conn);
assert_eq!(Ok(0), inserted_row_count);
let pk_conflict_result = diesel::insert_into(users)
.values(&same_id_different_name)
.on_conflict(name)
.do_nothing()
.execute(conn);
assert!(pk_conflict_result.is_err());
Specifying multiple columns as the target
use diesel::upsert::*;
diesel::sql_query("CREATE UNIQUE INDEX users_name_hair_color ON users (name, hair_color)").execute(conn).unwrap();
let user = User { id: 1, name: "Sean", hair_color: "black" };
let same_name_different_hair_color = User { id: 2, name: "Sean", hair_color: "brown" };
let same_name_same_hair_color = User { id: 3, name: "Sean", hair_color: "black" };
assert_eq!(Ok(1), diesel::insert_into(users).values(&user).execute(conn));
let inserted_row_count = diesel::insert_into(users)
.values(&same_name_different_hair_color)
.on_conflict((name, hair_color))
.do_nothing()
.execute(conn);
assert_eq!(Ok(1), inserted_row_count);
let inserted_row_count = diesel::insert_into(users)
.values(&same_name_same_hair_color)
.on_conflict((name, hair_color))
.do_nothing()
.execute(conn);
assert_eq!(Ok(0), inserted_row_count);
See the documentation for on_constraint
and do_update
for
more examples.
Trait Implementations§
source§impl<T, U, Op> AsQuery for InsertStatement<T, U, Op, NoReturningClause>where
T: Table,
InsertStatement<T, U, Op, ReturningClause<T::AllColumns>>: Query,
impl<T, U, Op> AsQuery for InsertStatement<T, U, Op, NoReturningClause>where T: Table, InsertStatement<T, U, Op, ReturningClause<T::AllColumns>>: Query,
§type SqlType = <<InsertStatement<T, U, Op, NoReturningClause> as AsQuery>::Query as Query>::SqlType
type SqlType = <<InsertStatement<T, U, Op, NoReturningClause> as AsQuery>::Query as Query>::SqlType
The SQL type of
Self::Query
§type Query = InsertStatement<T, U, Op, ReturningClause<<T as Table>::AllColumns>>
type Query = InsertStatement<T, U, Op, ReturningClause<<T as Table>::AllColumns>>
What kind of query does this type represent?
source§impl<T: Clone + QuerySource, U: Clone, Op: Clone, Ret: Clone> Clone for InsertStatement<T, U, Op, Ret>where
T::FromClause: Clone,
impl<T: Clone + QuerySource, U: Clone, Op: Clone, Ret: Clone> Clone for InsertStatement<T, U, Op, Ret>where T::FromClause: Clone,
source§fn clone(&self) -> InsertStatement<T, U, Op, Ret>
fn clone(&self) -> InsertStatement<T, U, Op, Ret>
Returns a copy of the value. Read more
1.0.0 · source§fn clone_from(&mut self, source: &Self)
fn clone_from(&mut self, source: &Self)
Performs copy-assignment from
source
. Read moresource§impl<T: Debug + QuerySource, U: Debug, Op: Debug, Ret: Debug> Debug for InsertStatement<T, U, Op, Ret>where
T::FromClause: Debug,
impl<T: Debug + QuerySource, U: Debug, Op: Debug, Ret: Debug> Debug for InsertStatement<T, U, Op, Ret>where T::FromClause: Debug,
source§impl<T, U, Op, Ret> Query for InsertStatement<T, U, Op, ReturningClause<Ret>>where
T: QuerySource,
Ret: Expression + SelectableExpression<T> + NonAggregate,
impl<T, U, Op, Ret> Query for InsertStatement<T, U, Op, ReturningClause<Ret>>where T: QuerySource, Ret: Expression + SelectableExpression<T> + NonAggregate,
§type SqlType = <Ret as Expression>::SqlType
type SqlType = <Ret as Expression>::SqlType
The SQL type that this query represents. Read more
source§impl<T, U, Op, Ret> QueryId for InsertStatement<T, U, Op, Ret>where
T: QuerySource + QueryId + 'static,
U: QueryId,
Op: QueryId,
Ret: QueryId,
impl<T, U, Op, Ret> QueryId for InsertStatement<T, U, Op, Ret>where T: QuerySource + QueryId + 'static, U: QueryId, Op: QueryId, Ret: QueryId,
source§impl<T: QuerySource, U, Op, Ret, Conn> RunQueryDsl<Conn> for InsertStatement<T, U, Op, Ret>
impl<T: QuerySource, U, Op, Ret, Conn> RunQueryDsl<Conn> for InsertStatement<T, U, Op, Ret>
source§fn load<'query, U>(self, conn: &mut Conn) -> QueryResult<Vec<U>>where
Self: LoadQuery<'query, Conn, U>,
fn load<'query, U>(self, conn: &mut Conn) -> QueryResult<Vec<U>>where Self: LoadQuery<'query, Conn, U>,
source§fn load_iter<'conn, 'query: 'conn, U, B>(
self,
conn: &'conn mut Conn
) -> QueryResult<LoadIter<'conn, 'query, Self, Conn, U, B>>where
U: 'conn,
Self: LoadQuery<'query, Conn, U, B> + 'conn,
fn load_iter<'conn, 'query: 'conn, U, B>( self, conn: &'conn mut Conn ) -> QueryResult<LoadIter<'conn, 'query, Self, Conn, U, B>>where U: 'conn, Self: LoadQuery<'query, Conn, U, B> + 'conn,
source§fn get_result<'query, U>(self, conn: &mut Conn) -> QueryResult<U>where
Self: LoadQuery<'query, Conn, U>,
fn get_result<'query, U>(self, conn: &mut Conn) -> QueryResult<U>where Self: LoadQuery<'query, Conn, U>,
Runs the command, and returns the affected row. Read more
source§fn get_results<'query, U>(self, conn: &mut Conn) -> QueryResult<Vec<U>>where
Self: LoadQuery<'query, Conn, U>,
fn get_results<'query, U>(self, conn: &mut Conn) -> QueryResult<Vec<U>>where Self: LoadQuery<'query, Conn, U>,
Runs the command, returning an
Vec
with the affected rows. Read more