Struct sea_query::query::InsertStatement

pub struct InsertStatement { /* fields omitted */ }

Insert any new rows into an existing table

Examples

use sea_query::{tests_cfg::*, *};

let query = Query::insert()
    .into_table(Glyph::Table)
    .columns(vec![Glyph::Aspect, Glyph::Image])
    .values_panic(vec![5.15.into(), "12A".into()])
    .values_panic(vec![4.21.into(), "123".into()])
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"INSERT INTO `glyph` (`aspect`, `image`) VALUES (5.15, '12A'), (4.21, '123')"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"INSERT INTO "glyph" ("aspect", "image") VALUES (5.15, '12A'), (4.21, '123')"#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"INSERT INTO `glyph` (`aspect`, `image`) VALUES (5.15, '12A'), (4.21, '123')"#
);

Implementations

impl InsertStatement

pub fn new() -> Self

Construct a new InsertStatement

pub fn into_table<T>(&mut self, tbl_ref: T) -> &mut Self where
    T: IntoTableRef, 

Specify which table to insert into.

Examples

See InsertStatement::values

pub fn columns<C, I>(&mut self, columns: I) -> &mut Self where
    C: IntoIden,
    I: IntoIterator<Item = C>, 

Specify what columns to insert.

Examples

See InsertStatement::values

pub fn values<I>(&mut self, values: I) -> Result<&mut Self> where
    I: IntoIterator<Item = Value>, 

Specify a row of values to be inserted.

Examples

use sea_query::{tests_cfg::*, *};

let query = Query::insert()
    .into_table(Glyph::Table)
    .columns(vec![Glyph::Aspect, Glyph::Image])
    .values(vec![2.1345.into(), "24B".into()])
    .unwrap()
    .values_panic(vec![5.15.into(), "12A".into()])
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"INSERT INTO `glyph` (`aspect`, `image`) VALUES (2.1345, '24B'), (5.15, '12A')"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"INSERT INTO "glyph" ("aspect", "image") VALUES (2.1345, '24B'), (5.15, '12A')"#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"INSERT INTO `glyph` (`aspect`, `image`) VALUES (2.1345, '24B'), (5.15, '12A')"#
);

pub fn values_panic<I>(&mut self, values: I) -> &mut Self where
    I: IntoIterator<Item = Value>, 

Specify a row of values to be inserted, variation of InsertStatement::values.

pub fn returning(&mut self, select: SelectStatement) -> &mut Self

RETURNING expressions. Postgres only.

use sea_query::{tests_cfg::*, *};

let query = Query::insert()
    .into_table(Glyph::Table)
    .columns(vec![Glyph::Image])
    .values_panic(vec!["12A".into()])
    .returning(Query::select().column(Glyph::Id).take())
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    "INSERT INTO `glyph` (`image`) VALUES ('12A')"
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"INSERT INTO "glyph" ("image") VALUES ('12A') RETURNING "id""#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    "INSERT INTO `glyph` (`image`) VALUES ('12A')"
);

pub fn returning_col<C>(&mut self, col: C) -> &mut Self where
    C: IntoIden, 

RETURNING a column after insertion. Postgres only. This is equivalent to MySQL’s LAST_INSERT_ID. Wrapper over InsertStatement::returning().

use sea_query::{tests_cfg::*, *};

let query = Query::insert()
    .into_table(Glyph::Table)
    .columns(vec![Glyph::Image])
    .values_panic(vec!["12A".into()])
    .returning_col(Glyph::Id)
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    "INSERT INTO `glyph` (`image`) VALUES ('12A')"
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"INSERT INTO "glyph" ("image") VALUES ('12A') RETURNING "id""#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    "INSERT INTO `glyph` (`image`) VALUES ('12A')"
);

impl InsertStatement

pub fn to_string<T: QueryBuilder>(&self, query_builder: T) -> String

pub fn build<T: QueryBuilder>(&self, query_builder: T) -> (String, Values)

pub fn build_any(&self, query_builder: &dyn QueryBuilder) -> (String, Values)

Trait Implementations

impl Clone for InsertStatement

fn clone(&self) -> InsertStatement

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for InsertStatement

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

Formats the value using the given formatter.

impl Default for InsertStatement

fn default() -> InsertStatement

Returns the “default value” for a type.

impl QueryStatementBuilder for InsertStatement

fn build_collect<T: QueryBuilder>(
    &self,
    query_builder: T,
    collector: &mut dyn FnMut(Value)
) -> String

Build corresponding SQL statement for certain database backend and collect query parameters

Examples

use sea_query::{tests_cfg::*, *};

let query = Query::insert()
    .into_table(Glyph::Table)
    .columns(vec![Glyph::Aspect, Glyph::Image])
    .values_panic(vec![3.1415.into(), "041080".into()])
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"INSERT INTO `glyph` (`aspect`, `image`) VALUES (3.1415, '041080')"#
);

let mut params = Vec::new();
let mut collector = |v| params.push(v);

assert_eq!(
    query.build_collect(MysqlQueryBuilder, &mut collector),
    r#"INSERT INTO `glyph` (`aspect`, `image`) VALUES (?, ?)"#
);
assert_eq!(
    params,
    vec![
        Value::Double(Some(3.1415)),
        Value::String(Some(Box::new(String::from("041080")))),
    ]
);

fn build_collect_any(
    &self,
    query_builder: &dyn QueryBuilder,
    collector: &mut dyn FnMut(Value)
) -> String

Build corresponding SQL statement for certain database backend and collect query parameters

fn to_string<T: QueryBuilder>(&self, query_builder: T) -> String

Build corresponding SQL statement for certain database backend and return SQL string

fn build<T: QueryBuilder>(&self, query_builder: T) -> (String, Values)

Build corresponding SQL statement for certain database backend and collect query parameters into a vector

fn build_any(&self, query_builder: &dyn QueryBuilder) -> (String, Values)

Build corresponding SQL statement for certain database backend and collect query parameters into a vector