Struct diesel::query_builder::InsertStatement

[+] Show declaration

pub struct InsertStatement<T, U, Op = Insert, Ret = NoReturningClause> { /* fields omitted */ }

[−] Expand description

A fully constructed insert statement.

The parameters of this struct represent:

• T: The table we are inserting into
• U: The data being inserted
• Op: The operation being performed. The specific types used to represent this are private, but correspond to SQL such as INSERT or REPLACE. You can safely rely on the default type representing INSERT
• Ret: The RETURNING 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 a RETURNING clause.

Methods

impl<T, U, C, Op, Ret> InsertStatement<T, InsertFromSelect<U, C>, Op, Ret>

[−]

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.

impl<T, U, Op> InsertStatement<T, U, Op>

[−]

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

impl<T, U, Op, Ret> InsertStatement<T, U, Op, Ret> where     U: UndecoratedInsertRecord<T>,

[−]

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

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_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_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

impl<T: Debug, U: Debug, Op: Debug, Ret: Debug> Debug for InsertStatement<T, U, Op, Ret>

[+]

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

[−]

Formats the value using the given formatter.

impl<T: Copy, U: Copy, Op: Copy, Ret: Copy> Copy for InsertStatement<T, U, Op, Ret>

impl<T: Clone, U: Clone, Op: Clone, Ret: Clone> Clone for InsertStatement<T, U, Op, Ret>

[+]

fn clone(&self) -> InsertStatement<T, U, Op, Ret>

[−]

Returns a copy of the value.

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

[−]

Performs copy-assignment from source.

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>,

[+]

fn walk_ast(&self, out: AstPass<DB>) -> QueryResult<()>

[−]

Walk over this QueryFragment for all passes.

fn to_sql(&self, out: &mut DB::QueryBuilder) -> QueryResult<()>

[−]

Converts this QueryFragment to its SQL representation.

fn collect_binds(     &self,     out: &mut DB::BindCollector,     metadata_lookup: &DB::MetadataLookup ) -> QueryResult<()>

[−]

Serializes all bind parameters in this query.

fn is_safe_to_cache_prepared(&self) -> QueryResult<bool>

[−]

Is this query safe to store in the prepared statement cache?

impl<'a, T, U, Op> ExecuteDsl<SqliteConnection> for InsertStatement<T, &'a [U], Op> where     &'a U: Insertable<T>,     InsertStatement<T, <&'a U as Insertable<T>>::Values, Op>: QueryFragment<Sqlite>,     T: Copy,     Op: Copy,

[+]

fn execute(query: Self, conn: &SqliteConnection) -> QueryResult<usize>

[−]

Execute this command

impl<'a, T, U, Op> ExecuteDsl<SqliteConnection> for InsertStatement<T, BatchInsert<'a, U, T>, Op> where     InsertStatement<T, &'a [U], Op>: ExecuteDsl<SqliteConnection>,

[+]

fn execute(query: Self, conn: &SqliteConnection) -> QueryResult<usize>

[−]

Execute this command

impl<T, U, Op> ExecuteDsl<SqliteConnection> for InsertStatement<T, OwnedBatchInsert<ValuesClause<U, T>>, Op> where     InsertStatement<T, ValuesClause<U, T>, Op>: QueryFragment<Sqlite>,     T: Copy,     Op: Copy,

[+]

fn execute(query: Self, conn: &SqliteConnection) -> QueryResult<usize>

[−]

Execute this command

impl<T, U, Op, Ret> QueryId for InsertStatement<T, U, Op, Ret>

[+]

type QueryId = ()

A type which uniquely represents Self in a SQL query.

const HAS_STATIC_QUERY_ID: bool

HAS_STATIC_QUERY_ID: bool = false

Can the SQL generated by Self be uniquely identified by its type?

fn query_id() -> Option<TypeId>

[−]

Returns the type id of Self::QueryId if Self::HAS_STATIC_QUERY_ID. Returns None otherwise.

impl<T, U, Op> AsQuery for InsertStatement<T, U, Op, NoReturningClause> where     T: Table,     InsertStatement<T, U, Op, ReturningClause<T::AllColumns>>: Query,

[+]

type SqlType = <Self::Query as Query>::SqlType

The SQL type of Self::Query

type Query = InsertStatement<T, U, Op, ReturningClause<T::AllColumns>>

What kind of query does this type represent?

fn as_query(self) -> Self::Query

[−]

Converts a type which semantically represents a SQL query into the actual query being executed. See the trait level docs for more.

impl<T, U, Op, Ret> Query for InsertStatement<T, U, Op, ReturningClause<Ret>> where     Ret: Expression + SelectableExpression<T> + NonAggregate,

type SqlType = Ret::SqlType

The SQL type that this query represents.

impl<T, U, Op, Ret, Conn> RunQueryDsl<Conn> for InsertStatement<T, U, Op, Ret>

[+]

fn execute(self, conn: &Conn) -> QueryResult<usize> where     Conn: Connection,     Self: ExecuteDsl<Conn>,

[−]

Executes the given command, returning the number of rows affected.

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.

fn get_result<U>(self, conn: &Conn) -> QueryResult<U> where     Self: LoadQuery<Conn, U>,

[−]

Runs the command, and returns the affected row.

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.

fn first<U>(self, conn: &Conn) -> QueryResult<U> where     Self: LimitDsl,     Limit<Self>: LoadQuery<Conn, U>,

[−]

Attempts to load a single record.