Struct Insert 

pub struct Insert<A>
where
    A: ActiveModelTrait,
{ /* private fields */ }

Performs INSERT operations on a ActiveModel

Implementations

impl<A> Insert<A>

where A: ActiveModelTrait,

pub fn exec<'a, C>(self, db: &'a C) -> Result<InsertResult<A>, DbErr>

where C: ConnectionTrait, A: 'a,

Execute an insert operation

pub fn exec_without_returning<'a, C>(self, db: &'a C) -> Result<u64, DbErr>

where C: ConnectionTrait, A: 'a,

Execute an insert operation without returning (don’t use RETURNING syntax) Number of rows affected is returned

pub fn exec_with_returning<'a, C>( self, db: &'a C, ) -> Result<<A::Entity as EntityTrait>::Model, DbErr>

where <A::Entity as EntityTrait>::Model: IntoActiveModel<A>, C: ConnectionTrait, A: 'a,

Execute an insert operation and return the inserted model (use RETURNING syntax if supported)

• To get back all inserted models, use [exec_with_returning_many].
• To get back all inserted primary keys, use [exec_with_returning_keys].

pub fn exec_with_returning_keys<'a, C>( self, db: &'a C, ) -> Result<Vec<<<<A as ActiveModelTrait>::Entity as EntityTrait>::PrimaryKey as PrimaryKeyTrait>::ValueType>, DbErr>

where <A::Entity as EntityTrait>::Model: IntoActiveModel<A>, C: ConnectionTrait, A: 'a,

Execute an insert operation and return primary keys of inserted models

pub fn exec_with_returning_many<'a, C>( self, db: &'a C, ) -> Result<Vec<<A::Entity as EntityTrait>::Model>, DbErr>

where <A::Entity as EntityTrait>::Model: IntoActiveModel<A>, C: ConnectionTrait, A: 'a,

Execute an insert operation and return all inserted models

impl<A> Insert<A>

where A: ActiveModelTrait,

pub fn one<M>(m: M) -> Self

where M: IntoActiveModel<A>,

Insert one Model or ActiveModel

Model

use sea_orm::{DbBackend, entity::*, query::*, tests_cfg::cake};

assert_eq!(
    Insert::one(cake::Model {
        id: 1,
        name: "Apple Pie".to_owned(),
    })
    .build(DbBackend::Postgres)
    .to_string(),
    r#"INSERT INTO "cake" ("id", "name") VALUES (1, 'Apple Pie')"#,
);

ActiveModel

use sea_orm::{DbBackend, entity::*, query::*, tests_cfg::cake};

assert_eq!(
    Insert::one(cake::ActiveModel {
        id: NotSet,
        name: Set("Apple Pie".to_owned()),
    })
    .build(DbBackend::Postgres)
    .to_string(),
    r#"INSERT INTO "cake" ("name") VALUES ('Apple Pie')"#,
);

pub fn many<M, I>(models: I) -> InsertMany<A>

where M: IntoActiveModel<A>, I: IntoIterator<Item = M>,

Insert many Model or ActiveModel. Alias to InsertMany::many.

use sea_orm::{DbBackend, entity::*, query::*, tests_cfg::cake};

assert_eq!(
    Insert::many([
        cake::Model {
            id: 1,
            name: "Apple Pie".to_owned(),
        },
        cake::Model {
            id: 2,
            name: "Orange Scone".to_owned(),
        }
    ])
    .build(DbBackend::Postgres)
    .to_string(),
    r#"INSERT INTO "cake" ("id", "name") VALUES (1, 'Apple Pie'), (2, 'Orange Scone')"#,
);

pub fn on_conflict(self, on_conflict: OnConflict) -> Self

Set ON CONFLICT logic

on conflict do nothing

use sea_orm::{DbBackend, entity::*, query::*, sea_query::OnConflict, tests_cfg::cake};

let orange = cake::ActiveModel {
    id: ActiveValue::set(2),
    name: ActiveValue::set("Orange".to_owned()),
};
assert_eq!(
    cake::Entity::insert(orange)
        .on_conflict(
            OnConflict::column(cake::Column::Name)
                .do_nothing()
                .to_owned()
        )
        .build(DbBackend::Postgres)
        .to_string(),
    r#"INSERT INTO "cake" ("id", "name") VALUES (2, 'Orange') ON CONFLICT ("name") DO NOTHING"#,
);

on conflict do update (upsert)

use sea_orm::{entity::*, query::*, sea_query::OnConflict, tests_cfg::cake, DbBackend};

let orange = cake::ActiveModel {
    id: ActiveValue::set(2),
    name: ActiveValue::set("Orange".to_owned()),
};
let query = cake::Entity::insert(orange)
    .on_conflict(
        OnConflict::column(cake::Column::Name)
            .update_column(cake::Column::Name)
            .to_owned()
    );
assert_eq!(
    query
        .build(DbBackend::MySql)
        .to_string(),
    "INSERT INTO `cake` (`id`, `name`) VALUES (2, 'Orange') ON DUPLICATE KEY UPDATE `name` = VALUES(`name`)"
);
assert_eq!(
    query
        .build(DbBackend::Postgres)
        .to_string(),
    r#"INSERT INTO "cake" ("id", "name") VALUES (2, 'Orange') ON CONFLICT ("name") DO UPDATE SET "name" = "excluded"."name""#,
);
assert_eq!(
    query
        .build(DbBackend::Sqlite)
        .to_string(),
    r#"INSERT INTO "cake" ("id", "name") VALUES (2, 'Orange') ON CONFLICT ("name") DO UPDATE SET "name" = "excluded"."name""#,
);

pub fn do_nothing(self) -> TryInsert<A>

where A: ActiveModelTrait,

Allow insert statement to return without error if nothing’s been inserted

pub fn on_empty_do_nothing(self) -> TryInsert<A>

where A: ActiveModelTrait,

Alias to do_nothing

pub fn on_conflict_do_nothing(self) -> TryInsert<A>

where A: ActiveModelTrait,

Set ON CONFLICT on primary key do nothing, but with MySQL specific polyfill.

use sea_orm::{entity::*, query::*, sea_query::OnConflict, tests_cfg::cake, DbBackend};

let orange = cake::ActiveModel {
    id: ActiveValue::set(2),
    name: ActiveValue::set("Orange".to_owned()),
};

assert_eq!(
    cake::Entity::insert(orange.clone())
        .on_conflict_do_nothing()
        .build(DbBackend::MySql)
        .to_string(),
    r#"INSERT INTO `cake` (`id`, `name`) VALUES (2, 'Orange') ON DUPLICATE KEY UPDATE `id` = `id`"#,
);
assert_eq!(
    cake::Entity::insert(orange.clone())
        .on_conflict_do_nothing()
        .build(DbBackend::Postgres)
        .to_string(),
    r#"INSERT INTO "cake" ("id", "name") VALUES (2, 'Orange') ON CONFLICT ("id") DO NOTHING"#,
);
assert_eq!(
    cake::Entity::insert(orange)
        .on_conflict_do_nothing()
        .build(DbBackend::Sqlite)
        .to_string(),
    r#"INSERT INTO "cake" ("id", "name") VALUES (2, 'Orange') ON CONFLICT ("id") DO NOTHING"#,
);

Trait Implementations

impl<A> Debug for Insert<A>

where A: ActiveModelTrait + Debug,

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

Formats the value using the given formatter.

impl<A> QueryTrait for Insert<A>

where A: ActiveModelTrait,

type QueryStatement = InsertStatement

Constrain the QueryStatement to StatementBuilder trait

fn query(&mut self) -> &mut InsertStatement

Get a mutable ref to the query builder

fn as_query(&self) -> &InsertStatement

Get an immutable ref to the query builder

fn into_query(self) -> InsertStatement

Take ownership of the query builder

fn build(&self, db_backend: DbBackend) -> Statement

Build the query as Statement

fn apply_if<T, F>(self, val: Option<T>, if_some: F) -> Self

where Self: Sized, F: FnOnce(Self, T) -> Self,

Apply an operation on the QueryTrait::QueryStatement if the given Option<T> is Some(_)