Struct diesel::query_builder::InsertStatement
source · [−]pub struct InsertStatement<T, U, Op = Insert, Ret = NoReturningClause> { /* private fields */ }
Expand description
A fully constructed insert statement.
The parameters of this struct represent:
T
: The table we are inserting intoU
: The data being insertedOp
: The operation being performed. The specific types used to represent this are private, but correspond to SQL such asINSERT
orREPLACE
. You can safely rely on the default type representingINSERT
Ret
: TheRETURNING
clause of the query. The specific types used to represent this are private. You can safely rely on the default type representing a query without aRETURNING
clause.
Implementations
sourceimpl<T, U, C, Op, Ret> InsertStatement<T, InsertFromSelect<U, C>, Op, Ret>
impl<T, 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<SqlType = U::SqlType>,
U: Query,
pub fn into_columns<C2>(
self,
columns: C2
) -> InsertStatement<T, InsertFromSelect<U, C2>, Op, Ret> where
C2: ColumnList<Table = T> + Expression<SqlType = U::SqlType>,
U: Query,
Set the column list when inserting from a select statement
See the documentation for insert_into
for usage examples.
sourceimpl<T, U, Op> InsertStatement<T, U, Op>
impl<T, 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);
sourceimpl<T, U, Op, Ret> InsertStatement<T, U, Op, Ret> where
U: UndecoratedInsertRecord<T>,
impl<T, U, Op, Ret> InsertStatement<T, U, Op, Ret> where
U: UndecoratedInsertRecord<T>,
sourcepub fn on_conflict_do_nothing(
self
) -> InsertStatement<T, OnConflictValues<U, NoConflictTarget, DoNothing>, Op, Ret>
pub fn on_conflict_do_nothing(
self
) -> InsertStatement<T, OnConflictValues<U, 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<Self, ConflictTarget<Target>> where
ConflictTarget<Target>: OnConflictTarget<T>,
pub fn on_conflict<Target>(
self,
target: Target
) -> IncompleteOnConflict<Self, 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
conn.execute("CREATE UNIQUE INDEX users_name ON users (name)").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::pg::upsert::*;
conn.execute("CREATE UNIQUE INDEX users_name_hair_color ON users (name, hair_color)").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
sourceimpl<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 Query = InsertStatement<T, U, Op, ReturningClause<T::AllColumns>>
type Query = InsertStatement<T, U, Op, ReturningClause<T::AllColumns>>
What kind of query does this type represent?
sourceimpl<T: Clone, U: Clone, Op: Clone, Ret: Clone> Clone for InsertStatement<T, U, Op, Ret>
impl<T: Clone, U: Clone, Op: Clone, Ret: Clone> Clone for InsertStatement<T, U, Op, Ret>
sourcefn 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 · sourcefn clone_from(&mut self, source: &Self)
fn clone_from(&mut self, source: &Self)
Performs copy-assignment from source
. Read more
sourceimpl<T, U, Op, Ret> Query for InsertStatement<T, U, Op, ReturningClause<Ret>> where
Ret: Expression + SelectableExpression<T> + NonAggregate,
impl<T, U, Op, Ret> Query for InsertStatement<T, U, Op, ReturningClause<Ret>> where
Ret: Expression + SelectableExpression<T> + NonAggregate,
sourceimpl<T, U, Op, Ret, DB> QueryFragment<DB> for InsertStatement<T, U, Op, Ret> where
DB: Backend,
T: Table,
T::FromClause: QueryFragment<DB>,
U: QueryFragment<DB> + CanInsertInSingleQuery<DB>,
Op: QueryFragment<DB>,
Ret: QueryFragment<DB>,
impl<T, U, Op, Ret, DB> QueryFragment<DB> for InsertStatement<T, U, Op, Ret> where
DB: Backend,
T: Table,
T::FromClause: QueryFragment<DB>,
U: QueryFragment<DB> + CanInsertInSingleQuery<DB>,
Op: QueryFragment<DB>,
Ret: QueryFragment<DB>,
sourcefn walk_ast(&self, out: AstPass<'_, DB>) -> QueryResult<()>
fn walk_ast(&self, out: AstPass<'_, DB>) -> QueryResult<()>
Walk over this QueryFragment
for all passes. Read more
sourcefn to_sql(&self, out: &mut DB::QueryBuilder) -> QueryResult<()>
fn to_sql(&self, out: &mut DB::QueryBuilder) -> QueryResult<()>
Converts this QueryFragment
to its SQL representation. Read more
sourcefn collect_binds(
&self,
out: &mut DB::BindCollector,
metadata_lookup: &DB::MetadataLookup
) -> QueryResult<()>
fn collect_binds(
&self,
out: &mut DB::BindCollector,
metadata_lookup: &DB::MetadataLookup
) -> QueryResult<()>
Serializes all bind parameters in this query. Read more
sourcefn is_safe_to_cache_prepared(&self) -> QueryResult<bool>
fn is_safe_to_cache_prepared(&self) -> QueryResult<bool>
Is this query safe to store in the prepared statement cache? Read more
sourceimpl<T, U, Op, Ret> QueryId for InsertStatement<T, U, Op, Ret>
impl<T, U, Op, Ret> QueryId for InsertStatement<T, U, Op, Ret>
sourceconst HAS_STATIC_QUERY_ID: bool
const HAS_STATIC_QUERY_ID: bool
Can the SQL generated by Self
be uniquely identified by its type? Read more
sourceimpl<T, U, Op, Ret, Conn> RunQueryDsl<Conn> for InsertStatement<T, U, Op, Ret>
impl<T, U, Op, Ret, Conn> RunQueryDsl<Conn> for InsertStatement<T, U, Op, Ret>
sourcefn execute(self, conn: &Conn) -> QueryResult<usize> where
Conn: Connection,
Self: ExecuteDsl<Conn>,
fn execute(self, conn: &Conn) -> QueryResult<usize> where
Conn: Connection,
Self: ExecuteDsl<Conn>,
Executes the given command, returning the number of rows affected. Read more
sourcefn load<U>(self, conn: &Conn) -> QueryResult<Vec<U>> where
Self: LoadQuery<Conn, U>,
fn load<U>(self, conn: &Conn) -> QueryResult<Vec<U>> where
Self: LoadQuery<Conn, U>,
Executes the given query, returning a Vec
with the returned rows. Read more
sourcefn get_result<U>(self, conn: &Conn) -> QueryResult<U> where
Self: LoadQuery<Conn, U>,
fn get_result<U>(self, conn: &Conn) -> QueryResult<U> where
Self: LoadQuery<Conn, U>,
Runs the command, and returns the affected row. Read more
sourcefn get_results<U>(self, conn: &Conn) -> QueryResult<Vec<U>> where
Self: LoadQuery<Conn, U>,
fn get_results<U>(self, conn: &Conn) -> QueryResult<Vec<U>> where
Self: LoadQuery<Conn, U>,
Runs the command, returning an Vec
with the affected rows. Read more
impl<T: Copy, U: Copy, Op: Copy, Ret: Copy> Copy for InsertStatement<T, U, Op, Ret>
Auto Trait Implementations
impl<T, U, Op, Ret> RefUnwindSafe for InsertStatement<T, U, Op, Ret> where
Op: RefUnwindSafe,
Ret: RefUnwindSafe,
T: RefUnwindSafe,
U: RefUnwindSafe,
impl<T, U, Op, Ret> Send for InsertStatement<T, U, Op, Ret> where
Op: Send,
Ret: Send,
T: Send,
U: Send,
impl<T, U, Op, Ret> Sync for InsertStatement<T, U, Op, Ret> where
Op: Sync,
Ret: Sync,
T: Sync,
U: Sync,
impl<T, U, Op, Ret> Unpin for InsertStatement<T, U, Op, Ret> where
Op: Unpin,
Ret: Unpin,
T: Unpin,
U: Unpin,
impl<T, U, Op, Ret> UnwindSafe for InsertStatement<T, U, Op, Ret> where
Op: UnwindSafe,
Ret: UnwindSafe,
T: UnwindSafe,
U: UnwindSafe,
Blanket Implementations
sourceimpl<T> AsQuery for T where
T: Query,
impl<T> AsQuery for T where
T: Query,
type Query = Self
type Query = Self
What kind of query does this type represent?
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcepub fn borrow_mut(&mut self) -> &mut T
pub fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
sourceimpl<Conn, DB, T> ExecuteDsl<Conn, DB> for T where
Conn: Connection<Backend = DB>,
DB: Backend,
T: QueryFragment<DB> + QueryId,
impl<Conn, DB, T> ExecuteDsl<Conn, DB> for T where
Conn: Connection<Backend = DB>,
DB: Backend,
T: QueryFragment<DB> + QueryId,
sourcefn execute(query: Self, conn: &Conn) -> QueryResult<usize>
fn execute(query: Self, conn: &Conn) -> QueryResult<usize>
Execute this command
sourceimpl<T> IntoSql for T
impl<T> IntoSql for T
sourceimpl<T> ToOwned for T where
T: Clone,
impl<T> ToOwned for T where
T: Clone,
type Owned = T
type Owned = T
The resulting type after obtaining ownership.
sourcepub fn to_owned(&self) -> T
pub fn to_owned(&self) -> T
Creates owned data from borrowed data, usually by cloning. Read more
sourcepub fn clone_into(&self, target: &mut T)
pub fn clone_into(&self, target: &mut T)
toowned_clone_into
)Uses borrowed data to replace owned data, usually by cloning. Read more