Struct Insert 

pub struct Insert {
    pub target: InsertTarget,
    pub source: Query,
    pub returning: Option<Returning>,
}

An INSERT statement that creates new records.

Combines an InsertTarget (where to insert), a Query source (the values to insert), and an optional Returning clause.

Examples

use toasty_core::stmt::{Insert, InsertTarget, Query, Values, Expr};
use toasty_core::schema::app::ModelId;

let insert = Insert {
    target: InsertTarget::Model(ModelId(0)),
    source: Query::values(Values::new(vec![Expr::null()])),
    returning: None,
};
assert!(insert.target.is_model());

Fields

target: InsertTarget

The target to insert into (model, table, or scoped query).

source: Query

The source query providing values to insert.

returning: Option<Returning>

Optional RETURNING clause to return data from the insertion.

Implementations

impl Insert

pub fn merge(&mut self, other: Insert)

Merges another Insert into this one by appending its value rows.

Both inserts must target the same model, and both sources must be VALUES expressions.

Trait Implementations

impl Clone for Insert

fn clone(&self) -> Insert

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Insert

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

Formats the value using the given formatter.

impl From<Insert> for Expr

fn from(value: Insert) -> Expr

Converts to this type from the input type.

impl From<Insert> for ExprSet

fn from(value: Insert) -> ExprSet

Converts to this type from the input type.

impl From<Insert> for ExprStmt

fn from(value: Insert) -> ExprStmt

Converts to this type from the input type.

impl<'a, T> IntoExprTarget<'a, T> for &'a Insert

where T: Resolve,

fn into_expr_target(self, schema: &'a T) -> ExprTarget<'a>

Converts self into an ExprTarget using the provided schema.

impl Node for Insert

fn visit<V>(&self, visit: V)

where V: Visit,

Traverses this node with an immutable visitor.

fn visit_mut<V>(&mut self, visit: V)

where V: VisitMut,

Traverses this node with a mutable visitor.

impl PartialEq for Insert

fn eq(&self, other: &Insert) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Insert