Trait diesel::prelude::Insertable

pub trait Insertable<T> {
    type Values;
    fn values(self) -> Self::Values;

    fn insert_into(self, table: T) -> InsertStatement<T, Self::Values>
    where
        Self: Sized,
    { ... }
}

Represents that a structure can be used to insert a new row into the database. This is automatically implemented for &[T] and &Vec<T> for inserting more than one record.

Deriving

This trait can be automatically derived by adding #[derive(Insertable)] to your struct. Structs which derive this trait must also be annotated with #[table_name = "some_table_name"]. If the field name of your struct differs from the name of the column, you can annotate the field with #[column_name = "some_column_name"].

Your struct can also contain fields which implement Insertable. This is useful when you want to have one field map to more than one column (for example, an enum that maps to a label and a value column). Add #[diesel(embed)] to any such fields.

Associated Types

type Values

The VALUES clause to insert these records

The types used here are generally internal to Diesel. Implementations of this trait should use the Values type of other Insertable types. For example <diesel::dsl::Eq<column, &str> as Insertable<table>>::Values.

Required Methods

fn values(self) -> Self::Values

Construct Self::Values

Implementations of this trait typically call .values on other Insertable types.

Provided Methods

fn insert_into(self, table: T) -> InsertStatement<T, Self::Values> where
    Self: Sized, 

Insert self into a given table.

foo.insert_into(table) is identical to insert_into(table).values(foo). However, when inserting from a select statement, this form is generally preferred.

Example

users::table
    .select((
        users::name.concat("'s First Post"),
        users::id,
    ))
    .insert_into(posts::table)
    .into_columns((posts::title, posts::user_id))
    .execute(&conn)?;

let inserted_posts = posts::table
    .select(posts::title)
    .load::<String>(&conn)?;
let expected = vec!["Sean's First Post", "Tess's First Post"];
assert_eq!(expected, inserted_posts);

Implementations on Foreign Types

impl<'a, T, Tab> Insertable<Tab> for &'a [T] where
    &'a T: UndecoratedInsertRecord<Tab>, 

type Values = BatchInsert<'a, T, Tab>

fn values(self) -> Self::Values

fn insert_into(self, table: T) -> InsertStatement<T, Self::Values> where
    Self: Sized, 

impl<'a, T, Tab> Insertable<Tab> for &'a Vec<T> where
    &'a [T]: Insertable<Tab>, 

type Values = <&'a [T] as Insertable<Tab>>::Values

fn values(self) -> Self::Values

fn insert_into(self, table: T) -> InsertStatement<T, Self::Values> where
    Self: Sized, 

impl<T, Tab> Insertable<Tab> for Option<T> where
    T: Insertable<Tab>,
    T::Values: Default, 

type Values = T::Values

fn values(self) -> Self::Values

fn insert_into(self, table: T) -> InsertStatement<T, Self::Values> where
    Self: Sized, 

impl<'a, T, Tab> Insertable<Tab> for &'a Option<T> where
    Option<&'a T>: Insertable<Tab>, 

type Values = <Option<&'a T> as Insertable<Tab>>::Values

fn values(self) -> Self::Values

fn insert_into(self, table: T) -> InsertStatement<T, Self::Values> where
    Self: Sized, 

impl<A, SA, Tab> Insertable<Tab> for (A,) where
    A: Insertable<Tab, Values = ValuesClause<SA, Tab>>, 

type Values = ValuesClause<(SA,), Tab>

fn values(self) -> Self::Values

fn insert_into(self, table: T) -> InsertStatement<T, Self::Values> where
    Self: Sized, 

impl<'a, A, Tab> Insertable<Tab> for &'a (A,) where
    (&'a A,): Insertable<Tab>, 

type Values = <(&'a A,) as Insertable<Tab>>::Values

fn values(self) -> Self::Values

fn insert_into(self, table: T) -> InsertStatement<T, Self::Values> where
    Self: Sized, 

impl<A, B, SA, SB, Tab> Insertable<Tab> for (A, B) where
    A: Insertable<Tab, Values = ValuesClause<SA, Tab>>,
    B: Insertable<Tab, Values = ValuesClause<SB, Tab>>, 

type Values = ValuesClause<(SA, SB), Tab>

fn values(self) -> Self::Values

fn insert_into(self, table: T) -> InsertStatement<T, Self::Values> where
    Self: Sized, 

impl<'a, A, B, Tab> Insertable<Tab> for &'a (A, B) where
    (&'a A, &'a B): Insertable<Tab>, 

type Values = <(&'a A, &'a B) as Insertable<Tab>>::Values

fn values(self) -> Self::Values

fn insert_into(self, table: T) -> InsertStatement<T, Self::Values> where
    Self: Sized, 

impl<A, B, C, SA, SB, SC, Tab> Insertable<Tab> for (A, B, C) where
    A: Insertable<Tab, Values = ValuesClause<SA, Tab>>,
    B: Insertable<Tab, Values = ValuesClause<SB, Tab>>,
    C: Insertable<Tab, Values = ValuesClause<SC, Tab>>, 

type Values = ValuesClause<(SA, SB, SC), Tab>

fn values(self) -> Self::Values

fn insert_into(self, table: T) -> InsertStatement<T, Self::Values> where
    Self: Sized, 

impl<'a, A, B, C, Tab> Insertable<Tab> for &'a (A, B, C) where
    (&'a A, &'a B, &'a C): Insertable<Tab>, 

type Values = <(&'a A, &'a B, &'a C) as Insertable<Tab>>::Values

fn values(self) -> Self::Values

fn insert_into(self, table: T) -> InsertStatement<T, Self::Values> where
    Self: Sized, 

impl<A, B, C, D, SA, SB, SC, SD, Tab> Insertable<Tab> for (A, B, C, D) where
    A: Insertable<Tab, Values = ValuesClause<SA, Tab>>,
    B: Insertable<Tab, Values = ValuesClause<SB, Tab>>,
    C: Insertable<Tab, Values = ValuesClause<SC, Tab>>,
    D: Insertable<Tab, Values = ValuesClause<SD, Tab>>, 

type Values = ValuesClause<(SA, SB, SC, SD), Tab>

fn values(self) -> Self::Values

fn insert_into(self, table: T) -> InsertStatement<T, Self::Values> where
    Self: Sized, 

impl<'a, A, B, C, D, Tab> Insertable<Tab> for &'a (A, B, C, D) where
    (&'a A, &'a B, &'a C, &'a D): Insertable<Tab>, 

type Values = <(&'a A, &'a B, &'a C, &'a D) as Insertable<Tab>>::Values

fn values(self) -> Self::Values

fn insert_into(self, table: T) -> InsertStatement<T, Self::Values> where
    Self: Sized, 

impl<A, B, C, D, E, SA, SB, SC, SD, SE, Tab> Insertable<Tab> for (A, B, C, D, E) where
    A: Insertable<Tab, Values = ValuesClause<SA, Tab>>,
    B: Insertable<Tab, Values = ValuesClause<SB, Tab>>,
    C: Insertable<Tab, Values = ValuesClause<SC, Tab>>,
    D: Insertable<Tab, Values = ValuesClause<SD, Tab>>,
    E: Insertable<Tab, Values = ValuesClause<SE, Tab>>, 

type Values = ValuesClause<(SA, SB, SC, SD, SE), Tab>

fn values(self) -> Self::Values

fn insert_into(self, table: T) -> InsertStatement<T, Self::Values> where
    Self: Sized, 

impl<'a, A, B, C, D, E, Tab> Insertable<Tab> for &'a (A, B, C, D, E) where
    (&'a A, &'a B, &'a C, &'a D, &'a E): Insertable<Tab>, 

type Values = <(&'a A, &'a B, &'a C, &'a D, &'a E) as Insertable<Tab>>::Values

fn values(self) -> Self::Values

fn insert_into(self, table: T) -> InsertStatement<T, Self::Values> where
    Self: Sized, 

impl<A, B, C, D, E, F, SA, SB, SC, SD, SE, SF, Tab> Insertable<Tab> for (A, B, C, D, E, F) where
    A: Insertable<Tab, Values = ValuesClause<SA, Tab>>,
    B: Insertable<Tab, Values = ValuesClause<SB, Tab>>,
    C: Insertable<Tab, Values = ValuesClause<SC, Tab>>,
    D: Insertable<Tab, Values = ValuesClause<SD, Tab>>,
    E: Insertable<Tab, Values = ValuesClause<SE, Tab>>,
    F: Insertable<Tab, Values = ValuesClause<SF, Tab>>, 

type Values = ValuesClause<(SA, SB, SC, SD, SE, SF), Tab>

fn values(self) -> Self::Values

fn insert_into(self, table: T) -> InsertStatement<T, Self::Values> where
    Self: Sized, 

impl<'a, A, B, C, D, E, F, Tab> Insertable<Tab> for &'a (A, B, C, D, E, F) where
    (&'a A, &'a B, &'a C, &'a D, &'a E, &'a F): Insertable<Tab>, 

type Values = <(&'a A, &'a B, &'a C, &'a D, &'a E, &'a F) as Insertable<Tab>>::Values

fn values(self) -> Self::Values

fn insert_into(self, table: T) -> InsertStatement<T, Self::Values> where
    Self: Sized, 

impl<A, B, C, D, E, F, G, SA, SB, SC, SD, SE, SF, SG, Tab> Insertable<Tab> for (A, B, C, D, E, F, G) where
    A: Insertable<Tab, Values = ValuesClause<SA, Tab>>,
    B: Insertable<Tab, Values = ValuesClause<SB, Tab>>,
    C: Insertable<Tab, Values = ValuesClause<SC, Tab>>,
    D: Insertable<Tab, Values = ValuesClause<SD, Tab>>,
    E: Insertable<Tab, Values = ValuesClause<SE, Tab>>,
    F: Insertable<Tab, Values = ValuesClause<SF, Tab>>,
    G: Insertable<Tab, Values = ValuesClause<SG, Tab>>, 

type Values = ValuesClause<(SA, SB, SC, SD, SE, SF, SG), Tab>

fn values(self) -> Self::Values

fn insert_into(self, table: T) -> InsertStatement<T, Self::Values> where
    Self: Sized, 

impl<'a, A, B, C, D, E, F, G, Tab> Insertable<Tab> for &'a (A, B, C, D, E, F, G) where
    (&'a A, &'a B, &'a C, &'a D, &'a E, &'a F, &'a G): Insertable<Tab>, 

type Values = <(&'a A, &'a B, &'a C, &'a D, &'a E, &'a F, &'a G) as Insertable<Tab>>::Values

fn values(self) -> Self::Values

fn insert_into(self, table: T) -> InsertStatement<T, Self::Values> where
    Self: Sized, 

impl<A, B, C, D, E, F, G, H, SA, SB, SC, SD, SE, SF, SG, SH, Tab> Insertable<Tab> for (A, B, C, D, E, F, G, H) where
    A: Insertable<Tab, Values = ValuesClause<SA, Tab>>,
    B: Insertable<Tab, Values = ValuesClause<SB, Tab>>,
    C: Insertable<Tab, Values = ValuesClause<SC, Tab>>,
    D: Insertable<Tab, Values = ValuesClause<SD, Tab>>,
    E: Insertable<Tab, Values = ValuesClause<SE, Tab>>,
    F: Insertable<Tab, Values = ValuesClause<SF, Tab>>,
    G: Insertable<Tab, Values = ValuesClause<SG, Tab>>,
    H: Insertable<Tab, Values = ValuesClause<SH, Tab>>, 

type Values = ValuesClause<(SA, SB, SC, SD, SE, SF, SG, SH), Tab>

fn values(self) -> Self::Values

fn insert_into(self, table: T) -> InsertStatement<T, Self::Values> where
    Self: Sized, 

impl<'a, A, B, C, D, E, F, G, H, Tab> Insertable<Tab> for &'a (A, B, C, D, E, F, G, H) where
    (&'a A, &'a B, &'a C, &'a D, &'a E, &'a F, &'a G, &'a H): Insertable<Tab>, 

type Values = <(&'a A, &'a B, &'a C, &'a D, &'a E, &'a F, &'a G, &'a H) as Insertable<Tab>>::Values

fn values(self) -> Self::Values

fn insert_into(self, table: T) -> InsertStatement<T, Self::Values> where
    Self: Sized, 

impl<A, B, C, D, E, F, G, H, I, SA, SB, SC, SD, SE, SF, SG, SH, SI, Tab> Insertable<Tab> for (A, B, C, D, E, F, G, H, I) where
    A: Insertable<Tab, Values = ValuesClause<SA, Tab>>,
    B: Insertable<Tab, Values = ValuesClause<SB, Tab>>,
    C: Insertable<Tab, Values = ValuesClause<SC, Tab>>,
    D: Insertable<Tab, Values = ValuesClause<SD, Tab>>,
    E: Insertable<Tab, Values = ValuesClause<SE, Tab>>,
    F: Insertable<Tab, Values = ValuesClause<SF, Tab>>,
    G: Insertable<Tab, Values = ValuesClause<SG, Tab>>,
    H: Insertable<Tab, Values = ValuesClause<SH, Tab>>,
    I: Insertable<Tab, Values = ValuesClause<SI, Tab>>, 

type Values = ValuesClause<(SA, SB, SC, SD, SE, SF, SG, SH, SI), Tab>

fn values(self) -> Self::Values

fn insert_into(self, table: T) -> InsertStatement<T, Self::Values> where
    Self: Sized, 

impl<'a, A, B, C, D, E, F, G, H, I, Tab> Insertable<Tab> for &'a (A, B, C, D, E, F, G, H, I) where
    (&'a A, &'a B, &'a C, &'a D, &'a E, &'a F, &'a G, &'a H, &'a I): Insertable<Tab>, 

type Values = <(&'a A, &'a B, &'a C, &'a D, &'a E, &'a F, &'a G, &'a H, &'a I) as Insertable<Tab>>::Values

fn values(self) -> Self::Values

fn insert_into(self, table: T) -> InsertStatement<T, Self::Values> where
    Self: Sized, 

impl<A, B, C, D, E, F, G, H, I, J, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, Tab> Insertable<Tab> for (A, B, C, D, E, F, G, H, I, J) where
    A: Insertable<Tab, Values = ValuesClause<SA, Tab>>,
    B: Insertable<Tab, Values = ValuesClause<SB, Tab>>,
    C: Insertable<Tab, Values = ValuesClause<SC, Tab>>,
    D: Insertable<Tab, Values = ValuesClause<SD, Tab>>,
    E: Insertable<Tab, Values = ValuesClause<SE, Tab>>,
    F: Insertable<Tab, Values = ValuesClause<SF, Tab>>,
    G: Insertable<Tab, Values = ValuesClause<SG, Tab>>,
    H: Insertable<Tab, Values = ValuesClause<SH, Tab>>,
    I: Insertable<Tab, Values = ValuesClause<SI, Tab>>,
    J: Insertable<Tab, Values = ValuesClause<SJ, Tab>>, 

type Values = ValuesClause<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ), Tab>

fn values(self) -> Self::Values

fn insert_into(self, table: T) -> InsertStatement<T, Self::Values> where
    Self: Sized, 

impl<'a, A, B, C, D, E, F, G, H, I, J, Tab> Insertable<Tab> for &'a (A, B, C, D, E, F, G, H, I, J) where
    (&'a A, &'a B, &'a C, &'a D, &'a E, &'a F, &'a G, &'a H, &'a I, &'a J): Insertable<Tab>, 

type Values = <(&'a A, &'a B, &'a C, &'a D, &'a E, &'a F, &'a G, &'a H, &'a I, &'a J) as Insertable<Tab>>::Values

fn values(self) -> Self::Values

fn insert_into(self, table: T) -> InsertStatement<T, Self::Values> where
    Self: Sized, 

impl<A, B, C, D, E, F, G, H, I, J, K, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, Tab> Insertable<Tab> for (A, B, C, D, E, F, G, H, I, J, K) where
    A: Insertable<Tab, Values = ValuesClause<SA, Tab>>,
    B: Insertable<Tab, Values = ValuesClause<SB, Tab>>,
    C: Insertable<Tab, Values = ValuesClause<SC, Tab>>,
    D: Insertable<Tab, Values = ValuesClause<SD, Tab>>,
    E: Insertable<Tab, Values = ValuesClause<SE, Tab>>,
    F: Insertable<Tab, Values = ValuesClause<SF, Tab>>,
    G: Insertable<Tab, Values = ValuesClause<SG, Tab>>,
    H: Insertable<Tab, Values = ValuesClause<SH, Tab>>,
    I: Insertable<Tab, Values = ValuesClause<SI, Tab>>,
    J: Insertable<Tab, Values = ValuesClause<SJ, Tab>>,
    K: Insertable<Tab, Values = ValuesClause<SK, Tab>>, 

type Values = ValuesClause<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK), Tab>

fn values(self) -> Self::Values

fn insert_into(self, table: T) -> InsertStatement<T, Self::Values> where
    Self: Sized, 

impl<'a, A, B, C, D, E, F, G, H, I, J, K, Tab> Insertable<Tab> for &'a (A, B, C, D, E, F, G, H, I, J, K) where
    (&'a A, &'a B, &'a C, &'a D, &'a E, &'a F, &'a G, &'a H, &'a I, &'a J, &'a K): Insertable<Tab>, 

type Values = <(&'a A, &'a B, &'a C, &'a D, &'a E, &'a F, &'a G, &'a H, &'a I, &'a J, &'a K) as Insertable<Tab>>::Values

fn values(self) -> Self::Values

fn insert_into(self, table: T) -> InsertStatement<T, Self::Values> where
    Self: Sized, 

impl<A, B, C, D, E, F, G, H, I, J, K, L, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, Tab> Insertable<Tab> for (A, B, C, D, E, F, G, H, I, J, K, L) where
    A: Insertable<Tab, Values = ValuesClause<SA, Tab>>,
    B: Insertable<Tab, Values = ValuesClause<SB, Tab>>,
    C: Insertable<Tab, Values = ValuesClause<SC, Tab>>,
    D: Insertable<Tab, Values = ValuesClause<SD, Tab>>,
    E: Insertable<Tab, Values = ValuesClause<SE, Tab>>,
    F: Insertable<Tab, Values = ValuesClause<SF, Tab>>,
    G: Insertable<Tab, Values = ValuesClause<SG, Tab>>,
    H: Insertable<Tab, Values = ValuesClause<SH, Tab>>,
    I: Insertable<Tab, Values = ValuesClause<SI, Tab>>,
    J: Insertable<Tab, Values = ValuesClause<SJ, Tab>>,
    K: Insertable<Tab, Values = ValuesClause<SK, Tab>>,
    L: Insertable<Tab, Values = ValuesClause<SL, Tab>>, 

type Values = ValuesClause<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL), Tab>

fn values(self) -> Self::Values

fn insert_into(self, table: T) -> InsertStatement<T, Self::Values> where
    Self: Sized, 

impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, Tab> Insertable<Tab> for &'a (A, B, C, D, E, F, G, H, I, J, K, L) where
    (&'a A, &'a B, &'a C, &'a D, &'a E, &'a F, &'a G, &'a H, &'a I, &'a J, &'a K, &'a L): Insertable<Tab>, 

type Values = <(&'a A, &'a B, &'a C, &'a D, &'a E, &'a F, &'a G, &'a H, &'a I, &'a J, &'a K, &'a L) as Insertable<Tab>>::Values

fn values(self) -> Self::Values

fn insert_into(self, table: T) -> InsertStatement<T, Self::Values> where
    Self: Sized, 

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, Tab> Insertable<Tab> for (A, B, C, D, E, F, G, H, I, J, K, L, M) where
    A: Insertable<Tab, Values = ValuesClause<SA, Tab>>,
    B: Insertable<Tab, Values = ValuesClause<SB, Tab>>,
    C: Insertable<Tab, Values = ValuesClause<SC, Tab>>,
    D: Insertable<Tab, Values = ValuesClause<SD, Tab>>,
    E: Insertable<Tab, Values = ValuesClause<SE, Tab>>,
    F: Insertable<Tab, Values = ValuesClause<SF, Tab>>,
    G: Insertable<Tab, Values = ValuesClause<SG, Tab>>,
    H: Insertable<Tab, Values = ValuesClause<SH, Tab>>,
    I: Insertable<Tab, Values = ValuesClause<SI, Tab>>,
    J: Insertable<Tab, Values = ValuesClause<SJ, Tab>>,
    K: Insertable<Tab, Values = ValuesClause<SK, Tab>>,
    L: Insertable<Tab, Values = ValuesClause<SL, Tab>>,
    M: Insertable<Tab, Values = ValuesClause<SM, Tab>>, 

type Values = ValuesClause<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM), Tab>

fn values(self) -> Self::Values

fn insert_into(self, table: T) -> InsertStatement<T, Self::Values> where
    Self: Sized, 

impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M, Tab> Insertable<Tab> for &'a (A, B, C, D, E, F, G, H, I, J, K, L, M) where
    (&'a A, &'a B, &'a C, &'a D, &'a E, &'a F, &'a G, &'a H, &'a I, &'a J, &'a K, &'a L, &'a M): Insertable<Tab>, 

type Values = <(&'a A, &'a B, &'a C, &'a D, &'a E, &'a F, &'a G, &'a H, &'a I, &'a J, &'a K, &'a L, &'a M) as Insertable<Tab>>::Values

fn values(self) -> Self::Values

fn insert_into(self, table: T) -> InsertStatement<T, Self::Values> where
    Self: Sized, 

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, Tab> Insertable<Tab> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N) where
    A: Insertable<Tab, Values = ValuesClause<SA, Tab>>,
    B: Insertable<Tab, Values = ValuesClause<SB, Tab>>,
    C: Insertable<Tab, Values = ValuesClause<SC, Tab>>,
    D: Insertable<Tab, Values = ValuesClause<SD, Tab>>,
    E: Insertable<Tab, Values = ValuesClause<SE, Tab>>,
    F: Insertable<Tab, Values = ValuesClause<SF, Tab>>,
    G: Insertable<Tab, Values = ValuesClause<SG, Tab>>,
    H: Insertable<Tab, Values = ValuesClause<SH, Tab>>,
    I: Insertable<Tab, Values = ValuesClause<SI, Tab>>,
    J: Insertable<Tab, Values = ValuesClause<SJ, Tab>>,
    K: Insertable<Tab, Values = ValuesClause<SK, Tab>>,
    L: Insertable<Tab, Values = ValuesClause<SL, Tab>>,
    M: Insertable<Tab, Values = ValuesClause<SM, Tab>>,
    N: Insertable<Tab, Values = ValuesClause<SN, Tab>>, 

type Values = ValuesClause<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN), Tab>

fn values(self) -> Self::Values

fn insert_into(self, table: T) -> InsertStatement<T, Self::Values> where
    Self: Sized, 

impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M, N, Tab> Insertable<Tab> for &'a (A, B, C, D, E, F, G, H, I, J, K, L, M, N) where
    (&'a A, &'a B, &'a C, &'a D, &'a E, &'a F, &'a G, &'a H, &'a I, &'a J, &'a K, &'a L, &'a M, &'a N): Insertable<Tab>, 

type Values = <(&'a A, &'a B, &'a C, &'a D, &'a E, &'a F, &'a G, &'a H, &'a I, &'a J, &'a K, &'a L, &'a M, &'a N) as Insertable<Tab>>::Values

fn values(self) -> Self::Values

fn insert_into(self, table: T) -> InsertStatement<T, Self::Values> where
    Self: Sized, 

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, Tab> Insertable<Tab> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) where
    A: Insertable<Tab, Values = ValuesClause<SA, Tab>>,
    B: Insertable<Tab, Values = ValuesClause<SB, Tab>>,
    C: Insertable<Tab, Values = ValuesClause<SC, Tab>>,
    D: Insertable<Tab, Values = ValuesClause<SD, Tab>>,
    E: Insertable<Tab, Values = ValuesClause<SE, Tab>>,
    F: Insertable<Tab, Values = ValuesClause<SF, Tab>>,
    G: Insertable<Tab, Values = ValuesClause<SG, Tab>>,
    H: Insertable<Tab, Values = ValuesClause<SH, Tab>>,
    I: Insertable<Tab, Values = ValuesClause<SI, Tab>>,
    J: Insertable<Tab, Values = ValuesClause<SJ, Tab>>,
    K: Insertable<Tab, Values = ValuesClause<SK, Tab>>,
    L: Insertable<Tab, Values = ValuesClause<SL, Tab>>,
    M: Insertable<Tab, Values = ValuesClause<SM, Tab>>,
    N: Insertable<Tab, Values = ValuesClause<SN, Tab>>,
    O: Insertable<Tab, Values = ValuesClause<SO, Tab>>, 

type Values = ValuesClause<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO), Tab>

fn values(self) -> Self::Values

fn insert_into(self, table: T) -> InsertStatement<T, Self::Values> where
    Self: Sized, 

impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, Tab> Insertable<Tab> for &'a (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) where
    (&'a A, &'a B, &'a C, &'a D, &'a E, &'a F, &'a G, &'a H, &'a I, &'a J, &'a K, &'a L, &'a M, &'a N, &'a O): Insertable<Tab>, 

type Values = <(&'a A, &'a B, &'a C, &'a D, &'a E, &'a F, &'a G, &'a H, &'a I, &'a J, &'a K, &'a L, &'a M, &'a N, &'a O) as Insertable<Tab>>::Values

fn values(self) -> Self::Values

fn insert_into(self, table: T) -> InsertStatement<T, Self::Values> where
    Self: Sized, 

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, Tab> Insertable<Tab> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) where
    A: Insertable<Tab, Values = ValuesClause<SA, Tab>>,
    B: Insertable<Tab, Values = ValuesClause<SB, Tab>>,
    C: Insertable<Tab, Values = ValuesClause<SC, Tab>>,
    D: Insertable<Tab, Values = ValuesClause<SD, Tab>>,
    E: Insertable<Tab, Values = ValuesClause<SE, Tab>>,
    F: Insertable<Tab, Values = ValuesClause<SF, Tab>>,
    G: Insertable<Tab, Values = ValuesClause<SG, Tab>>,
    H: Insertable<Tab, Values = ValuesClause<SH, Tab>>,
    I: Insertable<Tab, Values = ValuesClause<SI, Tab>>,
    J: Insertable<Tab, Values = ValuesClause<SJ, Tab>>,
    K: Insertable<Tab, Values = ValuesClause<SK, Tab>>,
    L: Insertable<Tab, Values = ValuesClause<SL, Tab>>,
    M: Insertable<Tab, Values = ValuesClause<SM, Tab>>,
    N: Insertable<Tab, Values = ValuesClause<SN, Tab>>,
    O: Insertable<Tab, Values = ValuesClause<SO, Tab>>,
    P: Insertable<Tab, Values = ValuesClause<SP, Tab>>, 

type Values = ValuesClause<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP), Tab>

fn values(self) -> Self::Values

fn insert_into(self, table: T) -> InsertStatement<T, Self::Values> where
    Self: Sized, 

impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Tab> Insertable<Tab> for &'a (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) where
    (&'a A, &'a B, &'a C, &'a D, &'a E, &'a F, &'a G, &'a H, &'a I, &'a J, &'a K, &'a L, &'a M, &'a N, &'a O, &'a P): Insertable<Tab>, 

type Values = <(&'a A, &'a B, &'a C, &'a D, &'a E, &'a F, &'a G, &'a H, &'a I, &'a J, &'a K, &'a L, &'a M, &'a N, &'a O, &'a P) as Insertable<Tab>>::Values

fn values(self) -> Self::Values

fn insert_into(self, table: T) -> InsertStatement<T, Self::Values> where
    Self: Sized, 

Implementors