Struct starfish::migrator::prelude::InsertStatement

pub struct InsertStatement { /* private fields */ }

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() -> InsertStatement

Construct a new InsertStatement

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

Specify which table to insert into.

Examples

See InsertStatement::values

pub fn columns<C, I>(&mut self, columns: I) -> &mut InsertStatement 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 InsertStatement, Error> 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 select_from<S>(
    &mut self,
    select: S
) -> Result<&mut InsertStatement, Error> where
    S: Into<SelectStatement>, 

Specify a select query whose values to be inserted.

Examples

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

let query = Query::insert()
    .into_table(Glyph::Table)
    .columns(vec![Glyph::Aspect, Glyph::Image])
    .select_from(Query::select()
        .column(Glyph::Aspect)
        .column(Glyph::Image)
        .from(Glyph::Table)
        .and_where(Expr::col(Glyph::Image).like("0%"))
        .to_owned()
    )
    .unwrap()
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"INSERT INTO `glyph` (`aspect`, `image`) SELECT `aspect`, `image` FROM `glyph` WHERE `image` LIKE '0%'"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"INSERT INTO "glyph" ("aspect", "image") SELECT "aspect", "image" FROM "glyph" WHERE "image" LIKE '0%'"#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"INSERT INTO "glyph" ("aspect", "image") SELECT "aspect", "image" FROM "glyph" WHERE "image" LIKE '0%'"#
);

pub fn exprs<I>(&mut self, values: I) -> Result<&mut InsertStatement, Error> where
    I: IntoIterator<Item = SimpleExpr>, 

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])
    .exprs(vec![
        Expr::val(2).into(),
        Func::cast_as("2020-02-02 00:00:00", Alias::new("DATE")),
    ])
    .unwrap()
    .to_owned();

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"INSERT INTO `glyph` (`aspect`, `image`) VALUES (2, CAST('2020-02-02 00:00:00' AS DATE))"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"INSERT INTO "glyph" ("aspect", "image") VALUES (2, CAST('2020-02-02 00:00:00' AS DATE))"#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"INSERT INTO "glyph" ("aspect", "image") VALUES (2, CAST('2020-02-02 00:00:00' AS DATE))"#
);

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

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

pub fn exprs_panic<I>(&mut self, values: I) -> &mut InsertStatement where
    I: IntoIterator<Item = SimpleExpr>, 

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

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

RETURNING expressions.

Note:

Works on

• PostgreSQL
• SQLite
  • SQLite version >= 3.35.0
  • Note that sea-query won’t try to enforce either of these constraints

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),
    r#"INSERT INTO "glyph" ("image") VALUES ('12A') RETURNING "id""#
);

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

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

Note:

Works on

• PostgreSQL
• SQLite
  • SQLite version >= 3.35.0
  • Note that sea-query won’t try to enforce either of these constraints

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),
    r#"INSERT INTO "glyph" ("image") VALUES ('12A') RETURNING "id""#
);

pub fn with(self, clause: WithClause) -> WithQuery

Create a WithQuery by specifying a WithClause to execute this query with.

Examples

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

let select = SelectStatement::new()
        .columns([Glyph::Id, Glyph::Image, Glyph::Aspect])
        .from(Glyph::Table)
        .to_owned();
    let cte = CommonTableExpression::new()
        .query(select)
        .column(Glyph::Id)
        .column(Glyph::Image)
        .column(Glyph::Aspect)
        .table_name(Alias::new("cte"))
        .to_owned();
    let with_clause = WithClause::new().cte(cte).to_owned();
    let select = SelectStatement::new()
        .columns([Glyph::Id, Glyph::Image, Glyph::Aspect])
        .from(Alias::new("cte"))
        .to_owned();
    let mut insert = Query::insert();
    insert
        .into_table(Glyph::Table)
        .columns([Glyph::Id, Glyph::Image, Glyph::Aspect])
        .select_from(select)
        .unwrap();
    let query = insert.with(with_clause);

assert_eq!(
    query.to_string(MysqlQueryBuilder),
    r#"WITH `cte` (`id`, `image`, `aspect`) AS (SELECT `id`, `image`, `aspect` FROM `glyph`) INSERT INTO `glyph` (`id`, `image`, `aspect`) SELECT `id`, `image`, `aspect` FROM `cte`"#
);
assert_eq!(
    query.to_string(PostgresQueryBuilder),
    r#"WITH "cte" ("id", "image", "aspect") AS (SELECT "id", "image", "aspect" FROM "glyph") INSERT INTO "glyph" ("id", "image", "aspect") SELECT "id", "image", "aspect" FROM "cte""#
);
assert_eq!(
    query.to_string(SqliteQueryBuilder),
    r#"WITH "cte" ("id", "image", "aspect") AS (SELECT "id", "image", "aspect" FROM "glyph") INSERT INTO "glyph" ("id", "image", "aspect") SELECT "id", "image", "aspect" FROM "cte""#
);

impl InsertStatement

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

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

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<(), Error>

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_any_into(
    &self,
    query_builder: &dyn QueryBuilder,
    sql: &mut SqlWriter,
    collector: &mut dyn FnMut(Value)
)

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

fn into_sub_query_statement(self) -> SubQueryStatement

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

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

impl QueryStatementWriter for InsertStatement

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

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 to_string<T>(&self, query_builder: T) -> String where
    T: QueryBuilder, 

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

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

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

impl StatementBuilder for InsertStatement

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

Method to call in order to build a Statement