Trait block_tools::db::use_diesel::prelude::Insertable[−][src]

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

    pub fn insert_into(
        self, 
        table: T
    ) -> InsertStatement<T, Self::Values, Insert, NoReturningClause> { ... }
}

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`[src]

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.

Loading content...

Required methods

`pub fn values(self) -> Self::Values`[src]

Construct Self::Values

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

Loading content...

Provided methods

`pub fn insert_into( self, table: T ) -> InsertStatement<T, Self::Values, Insert, NoReturningClause>`[src]

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);

Loading content...

Implementations on Foreign Types

`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>,` [src]

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

`pub fn values( self ) -> <&'a (A, B, C, D, E, F, G, H, I) as Insertable<Tab>>::Values`[src]

`impl<T, Tab> Insertable<Tab> for Vec<T, Global> where T: Insertable<Tab> + UndecoratedInsertRecord<Tab>,` [src]

`type Values = OwnedBatchInsert<<T as Insertable<Tab>>::Values, Tab>`

`pub fn values(self) -> <Vec<T, Global> as Insertable<Tab>>::Values`[src]

`impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Tab> Insertable<Tab> for &'a (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X) 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, &'a Q, &'a R, &'a S, &'a T, &'a U, &'a V, &'a W, &'a X): Insertable<Tab>,` [src]

`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, &'a Q, &'a R, &'a S, &'a T, &'a U, &'a V, &'a W, &'a X) as Insertable<Tab>>::Values`

`pub fn values( self ) -> <&'a (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X) as Insertable<Tab>>::Values`[src]

`impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, Tab> Insertable<Tab> for &'a (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC) 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, &'a Q, &'a R, &'a S, &'a T, &'a U, &'a V, &'a W, &'a X, &'a Y, &'a Z, &'a AA, &'a AB, &'a AC): Insertable<Tab>,` [src]

`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, &'a Q, &'a R, &'a S, &'a T, &'a U, &'a V, &'a W, &'a X, &'a Y, &'a Z, &'a AA, &'a AB, &'a AC) as Insertable<Tab>>::Values`

`pub fn values( self ) -> <&'a (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC) as Insertable<Tab>>::Values`[src]

`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>,` [src]

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

`pub fn values(self) -> <&'a (A, B, C, D, E, F) as Insertable<Tab>>::Values`[src]

`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>,` [src]

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

`pub fn values(self) -> <&'a (A, B, C, D, E) as Insertable<Tab>>::Values`[src]

`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>,` [src]

`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`

`pub fn values( self ) -> <&'a (A, B, C, D, E, F, G, H, I, J, K, L) as Insertable<Tab>>::Values`[src]

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

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

`pub fn values( self ) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) as Insertable<Tab>>::Values`[src]

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 C: Insertable<Tab, Values = ValuesClause<SC, Tab>>, F: Insertable<Tab, Values = ValuesClause<SF, Tab>>, D: Insertable<Tab, Values = ValuesClause<SD, Tab>>, L: Insertable<Tab, Values = ValuesClause<SL, Tab>>, G: Insertable<Tab, Values = ValuesClause<SG, Tab>>, M: Insertable<Tab, Values = ValuesClause<SM, Tab>>, E: Insertable<Tab, Values = ValuesClause<SE, Tab>>, A: Insertable<Tab, Values = ValuesClause<SA, Tab>>, K: Insertable<Tab, Values = ValuesClause<SK, Tab>>, I: Insertable<Tab, Values = ValuesClause<SI, Tab>>, B: Insertable<Tab, Values = ValuesClause<SB, Tab>>, H: Insertable<Tab, Values = ValuesClause<SH, Tab>>, J: Insertable<Tab, Values = ValuesClause<SJ, Tab>>, [src]

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

`pub fn values( self ) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M) as Insertable<Tab>>::Values`[src]

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, Tab> Insertable<Tab> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y) where C: Insertable<Tab, Values = ValuesClause<SC, Tab>>, S: Insertable<Tab, Values = ValuesClause<SS, Tab>>, F: Insertable<Tab, Values = ValuesClause<SF, Tab>>, D: Insertable<Tab, Values = ValuesClause<SD, Tab>>, W: Insertable<Tab, Values = ValuesClause<SW, Tab>>, O: Insertable<Tab, Values = ValuesClause<SO, Tab>>, L: Insertable<Tab, Values = ValuesClause<SL, Tab>>, G: Insertable<Tab, Values = ValuesClause<SG, Tab>>, T: Insertable<Tab, Values = ValuesClause<ST, Tab>>, M: Insertable<Tab, Values = ValuesClause<SM, Tab>>, E: Insertable<Tab, Values = ValuesClause<SE, Tab>>, U: Insertable<Tab, Values = ValuesClause<SU, Tab>>, P: Insertable<Tab, Values = ValuesClause<SP, Tab>>, A: Insertable<Tab, Values = ValuesClause<SA, Tab>>, R: Insertable<Tab, Values = ValuesClause<SR, Tab>>, K: Insertable<Tab, Values = ValuesClause<SK, Tab>>, V: Insertable<Tab, Values = ValuesClause<SV, Tab>>, I: Insertable<Tab, Values = ValuesClause<SI, Tab>>, N: Insertable<Tab, Values = ValuesClause<SN, Tab>>, B: Insertable<Tab, Values = ValuesClause<SB, Tab>>, H: Insertable<Tab, Values = ValuesClause<SH, Tab>>, J: Insertable<Tab, Values = ValuesClause<SJ, Tab>>, Q: Insertable<Tab, Values = ValuesClause<SQ, Tab>>, X: Insertable<Tab, Values = ValuesClause<SX, Tab>>, Y: Insertable<Tab, Values = ValuesClause<SY, Tab>>, [src]

`type Values = ValuesClause<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY), Tab>`

`pub fn values( self ) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y) as Insertable<Tab>>::Values`[src]

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, Tab> Insertable<Tab> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD) where C: Insertable<Tab, Values = ValuesClause<SC, Tab>>, S: Insertable<Tab, Values = ValuesClause<SS, Tab>>, F: Insertable<Tab, Values = ValuesClause<SF, Tab>>, D: Insertable<Tab, Values = ValuesClause<SD, Tab>>, W: Insertable<Tab, Values = ValuesClause<SW, Tab>>, O: Insertable<Tab, Values = ValuesClause<SO, Tab>>, L: Insertable<Tab, Values = ValuesClause<SL, Tab>>, G: Insertable<Tab, Values = ValuesClause<SG, Tab>>, T: Insertable<Tab, Values = ValuesClause<ST, Tab>>, M: Insertable<Tab, Values = ValuesClause<SM, Tab>>, E: Insertable<Tab, Values = ValuesClause<SE, Tab>>, U: Insertable<Tab, Values = ValuesClause<SU, Tab>>, P: Insertable<Tab, Values = ValuesClause<SP, Tab>>, A: Insertable<Tab, Values = ValuesClause<SA, Tab>>, R: Insertable<Tab, Values = ValuesClause<SR, Tab>>, K: Insertable<Tab, Values = ValuesClause<SK, Tab>>, V: Insertable<Tab, Values = ValuesClause<SV, Tab>>, I: Insertable<Tab, Values = ValuesClause<SI, Tab>>, N: Insertable<Tab, Values = ValuesClause<SN, Tab>>, B: Insertable<Tab, Values = ValuesClause<SB, Tab>>, H: Insertable<Tab, Values = ValuesClause<SH, Tab>>, J: Insertable<Tab, Values = ValuesClause<SJ, Tab>>, Q: Insertable<Tab, Values = ValuesClause<SQ, Tab>>, X: Insertable<Tab, Values = ValuesClause<SX, Tab>>, Y: Insertable<Tab, Values = ValuesClause<SY, Tab>>, Z: Insertable<Tab, Values = ValuesClause<SZ, Tab>>, AA: Insertable<Tab, Values = ValuesClause<SAA, Tab>>, AB: Insertable<Tab, Values = ValuesClause<SAB, Tab>>, AC: Insertable<Tab, Values = ValuesClause<SAC, Tab>>, AD: Insertable<Tab, Values = ValuesClause<SAD, Tab>>, [src]

`type Values = ValuesClause<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD), Tab>`

`pub fn values( self ) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD) as Insertable<Tab>>::Values`[src]

`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>,` [src]

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

`pub fn values(self) -> <&'a (A, B, C, D) as Insertable<Tab>>::Values`[src]

`impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, Tab> Insertable<Tab> for &'a (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD) 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, &'a Q, &'a R, &'a S, &'a T, &'a U, &'a V, &'a W, &'a X, &'a Y, &'a Z, &'a AA, &'a AB, &'a AC, &'a AD): Insertable<Tab>,` [src]

`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, &'a Q, &'a R, &'a S, &'a T, &'a U, &'a V, &'a W, &'a X, &'a Y, &'a Z, &'a AA, &'a AB, &'a AC, &'a AD) as Insertable<Tab>>::Values`

`pub fn values( self ) -> <&'a (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD) as Insertable<Tab>>::Values`[src]

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, Tab> Insertable<Tab> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA) where C: Insertable<Tab, Values = ValuesClause<SC, Tab>>, S: Insertable<Tab, Values = ValuesClause<SS, Tab>>, F: Insertable<Tab, Values = ValuesClause<SF, Tab>>, D: Insertable<Tab, Values = ValuesClause<SD, Tab>>, W: Insertable<Tab, Values = ValuesClause<SW, Tab>>, O: Insertable<Tab, Values = ValuesClause<SO, Tab>>, L: Insertable<Tab, Values = ValuesClause<SL, Tab>>, G: Insertable<Tab, Values = ValuesClause<SG, Tab>>, T: Insertable<Tab, Values = ValuesClause<ST, Tab>>, M: Insertable<Tab, Values = ValuesClause<SM, Tab>>, E: Insertable<Tab, Values = ValuesClause<SE, Tab>>, U: Insertable<Tab, Values = ValuesClause<SU, Tab>>, P: Insertable<Tab, Values = ValuesClause<SP, Tab>>, A: Insertable<Tab, Values = ValuesClause<SA, Tab>>, R: Insertable<Tab, Values = ValuesClause<SR, Tab>>, K: Insertable<Tab, Values = ValuesClause<SK, Tab>>, V: Insertable<Tab, Values = ValuesClause<SV, Tab>>, I: Insertable<Tab, Values = ValuesClause<SI, Tab>>, N: Insertable<Tab, Values = ValuesClause<SN, Tab>>, B: Insertable<Tab, Values = ValuesClause<SB, Tab>>, H: Insertable<Tab, Values = ValuesClause<SH, Tab>>, J: Insertable<Tab, Values = ValuesClause<SJ, Tab>>, Q: Insertable<Tab, Values = ValuesClause<SQ, Tab>>, X: Insertable<Tab, Values = ValuesClause<SX, Tab>>, Y: Insertable<Tab, Values = ValuesClause<SY, Tab>>, Z: Insertable<Tab, Values = ValuesClause<SZ, Tab>>, AA: Insertable<Tab, Values = ValuesClause<SAA, Tab>>, [src]

`type Values = ValuesClause<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA), Tab>`

`pub fn values( self ) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA) as Insertable<Tab>>::Values`[src]

`impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Tab> Insertable<Tab> for &'a (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y) 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, &'a Q, &'a R, &'a S, &'a T, &'a U, &'a V, &'a W, &'a X, &'a Y): Insertable<Tab>,` [src]

`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, &'a Q, &'a R, &'a S, &'a T, &'a U, &'a V, &'a W, &'a X, &'a Y) as Insertable<Tab>>::Values`

`pub fn values( self ) -> <&'a (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y) as Insertable<Tab>>::Values`[src]

`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>>,` [src]

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

`pub fn values(self) -> <(A, B) as Insertable<Tab>>::Values`[src]

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

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

`pub fn values(self) -> <&'a [T] as Insertable<Tab>>::Values`[src]

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 C: Insertable<Tab, Values = ValuesClause<SC, Tab>>, F: Insertable<Tab, Values = ValuesClause<SF, Tab>>, D: Insertable<Tab, Values = ValuesClause<SD, Tab>>, G: Insertable<Tab, Values = ValuesClause<SG, Tab>>, E: Insertable<Tab, Values = ValuesClause<SE, Tab>>, A: Insertable<Tab, Values = ValuesClause<SA, Tab>>, I: Insertable<Tab, Values = ValuesClause<SI, Tab>>, B: Insertable<Tab, Values = ValuesClause<SB, Tab>>, H: Insertable<Tab, Values = ValuesClause<SH, Tab>>, J: Insertable<Tab, Values = ValuesClause<SJ, Tab>>, [src]

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

`pub fn values( self ) -> <(A, B, C, D, E, F, G, H, I, J) as Insertable<Tab>>::Values`[src]

`impl<T, Tab> Insertable<Tab> for Option<T> where T: Insertable<Tab>, <T as Insertable<Tab>>::Values: Default,` [src]

`type Values = <T as Insertable<Tab>>::Values`

`pub fn values(self) -> <Option<T> as Insertable<Tab>>::Values`[src]

`impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, Tab> Insertable<Tab> for &'a (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) 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, &'a Q, &'a R, &'a S): Insertable<Tab>,` [src]

`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, &'a Q, &'a R, &'a S) as Insertable<Tab>>::Values`

`pub fn values( self ) -> <&'a (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) as Insertable<Tab>>::Values`[src]

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 C: Insertable<Tab, Values = ValuesClause<SC, Tab>>, F: Insertable<Tab, Values = ValuesClause<SF, Tab>>, D: Insertable<Tab, Values = ValuesClause<SD, Tab>>, L: Insertable<Tab, Values = ValuesClause<SL, Tab>>, G: Insertable<Tab, Values = ValuesClause<SG, Tab>>, E: Insertable<Tab, Values = ValuesClause<SE, Tab>>, A: Insertable<Tab, Values = ValuesClause<SA, Tab>>, K: Insertable<Tab, Values = ValuesClause<SK, Tab>>, I: Insertable<Tab, Values = ValuesClause<SI, Tab>>, B: Insertable<Tab, Values = ValuesClause<SB, Tab>>, H: Insertable<Tab, Values = ValuesClause<SH, Tab>>, J: Insertable<Tab, Values = ValuesClause<SJ, Tab>>, [src]

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

`pub fn values( self ) -> <(A, B, C, D, E, F, G, H, I, J, K, L) as Insertable<Tab>>::Values`[src]

`impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, Tab> Insertable<Tab> for &'a (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z) 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, &'a Q, &'a R, &'a S, &'a T, &'a U, &'a V, &'a W, &'a X, &'a Y, &'a Z): Insertable<Tab>,` [src]

`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, &'a Q, &'a R, &'a S, &'a T, &'a U, &'a V, &'a W, &'a X, &'a Y, &'a Z) as Insertable<Tab>>::Values`

`pub fn values( self ) -> <&'a (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z) as Insertable<Tab>>::Values`[src]

`impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, Tab> Insertable<Tab> for &'a (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) 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, &'a Q): Insertable<Tab>,` [src]

`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, &'a Q) as Insertable<Tab>>::Values`

`pub fn values( self ) -> <&'a (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) as Insertable<Tab>>::Values`[src]

`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>,` [src]

`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`

`pub fn values( self ) -> <&'a (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) as Insertable<Tab>>::Values`[src]

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

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

`pub fn values(self) -> <(A, B, C, D, E) as Insertable<Tab>>::Values`[src]

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

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

`pub fn values( self ) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) as Insertable<Tab>>::Values`[src]

`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>,` [src]

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

`pub fn values(self) -> <&'a (A, B, C, D, E, F, G) as Insertable<Tab>>::Values`[src]

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

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

`pub fn values(self) -> <(A, B, C, D) as Insertable<Tab>>::Values`[src]

`impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, Tab> Insertable<Tab> for &'a (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) 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, &'a Q, &'a R, &'a S, &'a T, &'a U): Insertable<Tab>,` [src]

`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, &'a Q, &'a R, &'a S, &'a T, &'a U) as Insertable<Tab>>::Values`

`pub fn values( self ) -> <&'a (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) as Insertable<Tab>>::Values`[src]

`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>,` [src]

`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`

`pub fn values( self ) -> <&'a (A, B, C, D, E, F, G, H, I, J) as Insertable<Tab>>::Values`[src]

`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>,` [src]

`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`

`pub fn values( self ) -> <&'a (A, B, C, D, E, F, G, H, I, J, K) as Insertable<Tab>>::Values`[src]

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

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

`pub fn values(self) -> <&'a (A, B, C) as Insertable<Tab>>::Values`[src]

`impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, Tab> Insertable<Tab> for &'a (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA) 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, &'a Q, &'a R, &'a S, &'a T, &'a U, &'a V, &'a W, &'a X, &'a Y, &'a Z, &'a AA): Insertable<Tab>,` [src]

`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, &'a Q, &'a R, &'a S, &'a T, &'a U, &'a V, &'a W, &'a X, &'a Y, &'a Z, &'a AA) as Insertable<Tab>>::Values`

`pub fn values( self ) -> <&'a (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA) as Insertable<Tab>>::Values`[src]

`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>,` [src]

`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`

`pub fn values( self ) -> <&'a (A, B, C, D, E, F, G, H, I, J, K, L, M, N) as Insertable<Tab>>::Values`[src]

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, Tab> Insertable<Tab> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC) where C: Insertable<Tab, Values = ValuesClause<SC, Tab>>, S: Insertable<Tab, Values = ValuesClause<SS, Tab>>, F: Insertable<Tab, Values = ValuesClause<SF, Tab>>, D: Insertable<Tab, Values = ValuesClause<SD, Tab>>, W: Insertable<Tab, Values = ValuesClause<SW, Tab>>, O: Insertable<Tab, Values = ValuesClause<SO, Tab>>, L: Insertable<Tab, Values = ValuesClause<SL, Tab>>, G: Insertable<Tab, Values = ValuesClause<SG, Tab>>, T: Insertable<Tab, Values = ValuesClause<ST, Tab>>, M: Insertable<Tab, Values = ValuesClause<SM, Tab>>, E: Insertable<Tab, Values = ValuesClause<SE, Tab>>, U: Insertable<Tab, Values = ValuesClause<SU, Tab>>, P: Insertable<Tab, Values = ValuesClause<SP, Tab>>, A: Insertable<Tab, Values = ValuesClause<SA, Tab>>, R: Insertable<Tab, Values = ValuesClause<SR, Tab>>, K: Insertable<Tab, Values = ValuesClause<SK, Tab>>, V: Insertable<Tab, Values = ValuesClause<SV, Tab>>, I: Insertable<Tab, Values = ValuesClause<SI, Tab>>, N: Insertable<Tab, Values = ValuesClause<SN, Tab>>, B: Insertable<Tab, Values = ValuesClause<SB, Tab>>, H: Insertable<Tab, Values = ValuesClause<SH, Tab>>, J: Insertable<Tab, Values = ValuesClause<SJ, Tab>>, Q: Insertable<Tab, Values = ValuesClause<SQ, Tab>>, X: Insertable<Tab, Values = ValuesClause<SX, Tab>>, Y: Insertable<Tab, Values = ValuesClause<SY, Tab>>, Z: Insertable<Tab, Values = ValuesClause<SZ, Tab>>, AA: Insertable<Tab, Values = ValuesClause<SAA, Tab>>, AB: Insertable<Tab, Values = ValuesClause<SAB, Tab>>, AC: Insertable<Tab, Values = ValuesClause<SAC, Tab>>, [src]

`type Values = ValuesClause<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC), Tab>`

`pub fn values( self ) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC) as Insertable<Tab>>::Values`[src]

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 C: Insertable<Tab, Values = ValuesClause<SC, Tab>>, F: Insertable<Tab, Values = ValuesClause<SF, Tab>>, D: Insertable<Tab, Values = ValuesClause<SD, Tab>>, G: Insertable<Tab, Values = ValuesClause<SG, Tab>>, E: Insertable<Tab, Values = ValuesClause<SE, Tab>>, A: Insertable<Tab, Values = ValuesClause<SA, Tab>>, B: Insertable<Tab, Values = ValuesClause<SB, Tab>>, [src]

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

`pub fn values(self) -> <(A, B, C, D, E, F, G) as Insertable<Tab>>::Values`[src]

`impl<'a, A, Tab> Insertable<Tab> for &'a (A,) where (&'a A,): Insertable<Tab>,` [src]

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

`pub fn values(self) -> <&'a (A,) as Insertable<Tab>>::Values`[src]

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 C: Insertable<Tab, Values = ValuesClause<SC, Tab>>, F: Insertable<Tab, Values = ValuesClause<SF, Tab>>, D: Insertable<Tab, Values = ValuesClause<SD, Tab>>, O: Insertable<Tab, Values = ValuesClause<SO, Tab>>, L: Insertable<Tab, Values = ValuesClause<SL, Tab>>, G: Insertable<Tab, Values = ValuesClause<SG, Tab>>, M: Insertable<Tab, Values = ValuesClause<SM, Tab>>, E: Insertable<Tab, Values = ValuesClause<SE, Tab>>, A: Insertable<Tab, Values = ValuesClause<SA, Tab>>, K: Insertable<Tab, Values = ValuesClause<SK, Tab>>, I: Insertable<Tab, Values = ValuesClause<SI, Tab>>, N: Insertable<Tab, Values = ValuesClause<SN, Tab>>, B: Insertable<Tab, Values = ValuesClause<SB, Tab>>, H: Insertable<Tab, Values = ValuesClause<SH, Tab>>, J: Insertable<Tab, Values = ValuesClause<SJ, Tab>>, [src]

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

`pub fn values( self ) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) as Insertable<Tab>>::Values`[src]

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 C: Insertable<Tab, Values = ValuesClause<SC, Tab>>, F: Insertable<Tab, Values = ValuesClause<SF, Tab>>, D: Insertable<Tab, Values = ValuesClause<SD, Tab>>, G: Insertable<Tab, Values = ValuesClause<SG, Tab>>, E: Insertable<Tab, Values = ValuesClause<SE, Tab>>, A: Insertable<Tab, Values = ValuesClause<SA, Tab>>, B: Insertable<Tab, Values = ValuesClause<SB, Tab>>, H: Insertable<Tab, Values = ValuesClause<SH, Tab>>, [src]

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

`pub fn values(self) -> <(A, B, C, D, E, F, G, H) as Insertable<Tab>>::Values`[src]

`impl<'a, T, Tab> Insertable<Tab> for &'a Option<T> where Option<&'a T>: Insertable<Tab>,` [src]

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

`pub fn values(self) -> <&'a Option<T> as Insertable<Tab>>::Values`[src]

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

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

`pub fn values( self ) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) as Insertable<Tab>>::Values`[src]

`impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, Tab> Insertable<Tab> for &'a (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W) 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, &'a Q, &'a R, &'a S, &'a T, &'a U, &'a V, &'a W): Insertable<Tab>,` [src]

`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, &'a Q, &'a R, &'a S, &'a T, &'a U, &'a V, &'a W) as Insertable<Tab>>::Values`

`pub fn values( self ) -> <&'a (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W) as Insertable<Tab>>::Values`[src]

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 C: Insertable<Tab, Values = ValuesClause<SC, Tab>>, F: Insertable<Tab, Values = ValuesClause<SF, Tab>>, D: Insertable<Tab, Values = ValuesClause<SD, Tab>>, L: Insertable<Tab, Values = ValuesClause<SL, Tab>>, G: Insertable<Tab, Values = ValuesClause<SG, Tab>>, M: Insertable<Tab, Values = ValuesClause<SM, Tab>>, E: Insertable<Tab, Values = ValuesClause<SE, Tab>>, A: Insertable<Tab, Values = ValuesClause<SA, Tab>>, K: Insertable<Tab, Values = ValuesClause<SK, Tab>>, I: Insertable<Tab, Values = ValuesClause<SI, Tab>>, N: Insertable<Tab, Values = ValuesClause<SN, Tab>>, B: Insertable<Tab, Values = ValuesClause<SB, Tab>>, H: Insertable<Tab, Values = ValuesClause<SH, Tab>>, J: Insertable<Tab, Values = ValuesClause<SJ, Tab>>, [src]

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

`pub fn values( self ) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N) as Insertable<Tab>>::Values`[src]

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, Tab> Insertable<Tab> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z) where C: Insertable<Tab, Values = ValuesClause<SC, Tab>>, S: Insertable<Tab, Values = ValuesClause<SS, Tab>>, F: Insertable<Tab, Values = ValuesClause<SF, Tab>>, D: Insertable<Tab, Values = ValuesClause<SD, Tab>>, W: Insertable<Tab, Values = ValuesClause<SW, Tab>>, O: Insertable<Tab, Values = ValuesClause<SO, Tab>>, L: Insertable<Tab, Values = ValuesClause<SL, Tab>>, G: Insertable<Tab, Values = ValuesClause<SG, Tab>>, T: Insertable<Tab, Values = ValuesClause<ST, Tab>>, M: Insertable<Tab, Values = ValuesClause<SM, Tab>>, E: Insertable<Tab, Values = ValuesClause<SE, Tab>>, U: Insertable<Tab, Values = ValuesClause<SU, Tab>>, P: Insertable<Tab, Values = ValuesClause<SP, Tab>>, A: Insertable<Tab, Values = ValuesClause<SA, Tab>>, R: Insertable<Tab, Values = ValuesClause<SR, Tab>>, K: Insertable<Tab, Values = ValuesClause<SK, Tab>>, V: Insertable<Tab, Values = ValuesClause<SV, Tab>>, I: Insertable<Tab, Values = ValuesClause<SI, Tab>>, N: Insertable<Tab, Values = ValuesClause<SN, Tab>>, B: Insertable<Tab, Values = ValuesClause<SB, Tab>>, H: Insertable<Tab, Values = ValuesClause<SH, Tab>>, J: Insertable<Tab, Values = ValuesClause<SJ, Tab>>, Q: Insertable<Tab, Values = ValuesClause<SQ, Tab>>, X: Insertable<Tab, Values = ValuesClause<SX, Tab>>, Y: Insertable<Tab, Values = ValuesClause<SY, Tab>>, Z: Insertable<Tab, Values = ValuesClause<SZ, Tab>>, [src]

`type Values = ValuesClause<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ), Tab>`

`pub fn values( self ) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z) as Insertable<Tab>>::Values`[src]

`impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, Tab> Insertable<Tab> for &'a (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB) 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, &'a Q, &'a R, &'a S, &'a T, &'a U, &'a V, &'a W, &'a X, &'a Y, &'a Z, &'a AA, &'a AB): Insertable<Tab>,` [src]

`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, &'a Q, &'a R, &'a S, &'a T, &'a U, &'a V, &'a W, &'a X, &'a Y, &'a Z, &'a AA, &'a AB) as Insertable<Tab>>::Values`

`pub fn values( self ) -> <&'a (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB) as Insertable<Tab>>::Values`[src]

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

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

`pub fn values(self) -> <(A, B, C, D, E, F) as Insertable<Tab>>::Values`[src]

`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>,` [src]

`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`

`pub fn values( self ) -> <&'a (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) as Insertable<Tab>>::Values`[src]

`impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, Tab> Insertable<Tab> for &'a (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) 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, &'a Q, &'a R, &'a S, &'a T): Insertable<Tab>,` [src]

`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, &'a Q, &'a R, &'a S, &'a T) as Insertable<Tab>>::Values`

`pub fn values( self ) -> <&'a (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) as Insertable<Tab>>::Values`[src]

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 C: Insertable<Tab, Values = ValuesClause<SC, Tab>>, F: Insertable<Tab, Values = ValuesClause<SF, Tab>>, D: Insertable<Tab, Values = ValuesClause<SD, Tab>>, G: Insertable<Tab, Values = ValuesClause<SG, Tab>>, E: Insertable<Tab, Values = ValuesClause<SE, Tab>>, A: Insertable<Tab, Values = ValuesClause<SA, Tab>>, K: Insertable<Tab, Values = ValuesClause<SK, Tab>>, I: Insertable<Tab, Values = ValuesClause<SI, Tab>>, B: Insertable<Tab, Values = ValuesClause<SB, Tab>>, H: Insertable<Tab, Values = ValuesClause<SH, Tab>>, J: Insertable<Tab, Values = ValuesClause<SJ, Tab>>, [src]

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

`pub fn values( self ) -> <(A, B, C, D, E, F, G, H, I, J, K) as Insertable<Tab>>::Values`[src]

`impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE, Tab> Insertable<Tab> for &'a (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE) 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, &'a Q, &'a R, &'a S, &'a T, &'a U, &'a V, &'a W, &'a X, &'a Y, &'a Z, &'a AA, &'a AB, &'a AC, &'a AD, &'a AE): Insertable<Tab>,` [src]

`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, &'a Q, &'a R, &'a S, &'a T, &'a U, &'a V, &'a W, &'a X, &'a Y, &'a Z, &'a AA, &'a AB, &'a AC, &'a AD, &'a AE) as Insertable<Tab>>::Values`

`pub fn values( self ) -> <&'a (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE) as Insertable<Tab>>::Values`[src]

`impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, Tab> Insertable<Tab> for &'a (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) 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, &'a Q, &'a R, &'a S, &'a T, &'a U, &'a V): Insertable<Tab>,` [src]

`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, &'a Q, &'a R, &'a S, &'a T, &'a U, &'a V) as Insertable<Tab>>::Values`

`pub fn values( self ) -> <&'a (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) as Insertable<Tab>>::Values`[src]

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

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

`pub fn values(self) -> <&'a Vec<T, Global> as Insertable<Tab>>::Values`[src]

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE, AF, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF, Tab> Insertable<Tab> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE, AF) where C: Insertable<Tab, Values = ValuesClause<SC, Tab>>, S: Insertable<Tab, Values = ValuesClause<SS, Tab>>, F: Insertable<Tab, Values = ValuesClause<SF, Tab>>, D: Insertable<Tab, Values = ValuesClause<SD, Tab>>, W: Insertable<Tab, Values = ValuesClause<SW, Tab>>, O: Insertable<Tab, Values = ValuesClause<SO, Tab>>, L: Insertable<Tab, Values = ValuesClause<SL, Tab>>, G: Insertable<Tab, Values = ValuesClause<SG, Tab>>, T: Insertable<Tab, Values = ValuesClause<ST, Tab>>, M: Insertable<Tab, Values = ValuesClause<SM, Tab>>, E: Insertable<Tab, Values = ValuesClause<SE, Tab>>, U: Insertable<Tab, Values = ValuesClause<SU, Tab>>, P: Insertable<Tab, Values = ValuesClause<SP, Tab>>, A: Insertable<Tab, Values = ValuesClause<SA, Tab>>, R: Insertable<Tab, Values = ValuesClause<SR, Tab>>, K: Insertable<Tab, Values = ValuesClause<SK, Tab>>, V: Insertable<Tab, Values = ValuesClause<SV, Tab>>, I: Insertable<Tab, Values = ValuesClause<SI, Tab>>, N: Insertable<Tab, Values = ValuesClause<SN, Tab>>, B: Insertable<Tab, Values = ValuesClause<SB, Tab>>, H: Insertable<Tab, Values = ValuesClause<SH, Tab>>, J: Insertable<Tab, Values = ValuesClause<SJ, Tab>>, Q: Insertable<Tab, Values = ValuesClause<SQ, Tab>>, X: Insertable<Tab, Values = ValuesClause<SX, Tab>>, Y: Insertable<Tab, Values = ValuesClause<SY, Tab>>, Z: Insertable<Tab, Values = ValuesClause<SZ, Tab>>, AA: Insertable<Tab, Values = ValuesClause<SAA, Tab>>, AB: Insertable<Tab, Values = ValuesClause<SAB, Tab>>, AC: Insertable<Tab, Values = ValuesClause<SAC, Tab>>, AD: Insertable<Tab, Values = ValuesClause<SAD, Tab>>, AE: Insertable<Tab, Values = ValuesClause<SAE, Tab>>, AF: Insertable<Tab, Values = ValuesClause<SAF, Tab>>, [src]

`type Values = ValuesClause<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, SAF), Tab>`

`pub fn values( self ) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE, AF) as Insertable<Tab>>::Values`[src]

`impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, Tab> Insertable<Tab> for &'a (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) 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, &'a Q, &'a R): Insertable<Tab>,` [src]

`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, &'a Q, &'a R) as Insertable<Tab>>::Values`

`pub fn values( self ) -> <&'a (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) as Insertable<Tab>>::Values`[src]

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

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

`pub fn values(self) -> <(A,) as Insertable<Tab>>::Values`[src]

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, Tab> Insertable<Tab> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X) where C: Insertable<Tab, Values = ValuesClause<SC, Tab>>, S: Insertable<Tab, Values = ValuesClause<SS, Tab>>, F: Insertable<Tab, Values = ValuesClause<SF, Tab>>, D: Insertable<Tab, Values = ValuesClause<SD, Tab>>, W: Insertable<Tab, Values = ValuesClause<SW, Tab>>, O: Insertable<Tab, Values = ValuesClause<SO, Tab>>, L: Insertable<Tab, Values = ValuesClause<SL, Tab>>, G: Insertable<Tab, Values = ValuesClause<SG, Tab>>, T: Insertable<Tab, Values = ValuesClause<ST, Tab>>, M: Insertable<Tab, Values = ValuesClause<SM, Tab>>, E: Insertable<Tab, Values = ValuesClause<SE, Tab>>, U: Insertable<Tab, Values = ValuesClause<SU, Tab>>, P: Insertable<Tab, Values = ValuesClause<SP, Tab>>, A: Insertable<Tab, Values = ValuesClause<SA, Tab>>, R: Insertable<Tab, Values = ValuesClause<SR, Tab>>, K: Insertable<Tab, Values = ValuesClause<SK, Tab>>, V: Insertable<Tab, Values = ValuesClause<SV, Tab>>, I: Insertable<Tab, Values = ValuesClause<SI, Tab>>, N: Insertable<Tab, Values = ValuesClause<SN, Tab>>, B: Insertable<Tab, Values = ValuesClause<SB, Tab>>, H: Insertable<Tab, Values = ValuesClause<SH, Tab>>, J: Insertable<Tab, Values = ValuesClause<SJ, Tab>>, Q: Insertable<Tab, Values = ValuesClause<SQ, Tab>>, X: Insertable<Tab, Values = ValuesClause<SX, Tab>>, [src]

`type Values = ValuesClause<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX), Tab>`

`pub fn values( self ) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X) as Insertable<Tab>>::Values`[src]

`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>,` [src]

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

`pub fn values(self) -> <&'a (A, B, C, D, E, F, G, H) as Insertable<Tab>>::Values`[src]

impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE, AF, Tab> Insertable<Tab> for &'a (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE, AF) 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, &'a Q, &'a R, &'a S, &'a T, &'a U, &'a V, &'a W, &'a X, &'a Y, &'a Z, &'a AA, &'a AB, &'a AC, &'a AD, &'a AE, &'a AF): Insertable<Tab>, [src]

`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, &'a Q, &'a R, &'a S, &'a T, &'a U, &'a V, &'a W, &'a X, &'a Y, &'a Z, &'a AA, &'a AB, &'a AC, &'a AD, &'a AE, &'a AF) as Insertable<Tab>>::Values`

`pub fn values( self ) -> <&'a (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE, AF) as Insertable<Tab>>::Values`[src]

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, Tab> Insertable<Tab> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W) where C: Insertable<Tab, Values = ValuesClause<SC, Tab>>, S: Insertable<Tab, Values = ValuesClause<SS, Tab>>, F: Insertable<Tab, Values = ValuesClause<SF, Tab>>, D: Insertable<Tab, Values = ValuesClause<SD, Tab>>, W: Insertable<Tab, Values = ValuesClause<SW, Tab>>, O: Insertable<Tab, Values = ValuesClause<SO, Tab>>, L: Insertable<Tab, Values = ValuesClause<SL, Tab>>, G: Insertable<Tab, Values = ValuesClause<SG, Tab>>, T: Insertable<Tab, Values = ValuesClause<ST, Tab>>, M: Insertable<Tab, Values = ValuesClause<SM, Tab>>, E: Insertable<Tab, Values = ValuesClause<SE, Tab>>, U: Insertable<Tab, Values = ValuesClause<SU, Tab>>, P: Insertable<Tab, Values = ValuesClause<SP, Tab>>, A: Insertable<Tab, Values = ValuesClause<SA, Tab>>, R: Insertable<Tab, Values = ValuesClause<SR, Tab>>, K: Insertable<Tab, Values = ValuesClause<SK, Tab>>, V: Insertable<Tab, Values = ValuesClause<SV, Tab>>, I: Insertable<Tab, Values = ValuesClause<SI, Tab>>, N: Insertable<Tab, Values = ValuesClause<SN, Tab>>, B: Insertable<Tab, Values = ValuesClause<SB, Tab>>, H: Insertable<Tab, Values = ValuesClause<SH, Tab>>, J: Insertable<Tab, Values = ValuesClause<SJ, Tab>>, Q: Insertable<Tab, Values = ValuesClause<SQ, Tab>>, [src]

`type Values = ValuesClause<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW), Tab>`

`pub fn values( self ) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W) as Insertable<Tab>>::Values`[src]

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 C: Insertable<Tab, Values = ValuesClause<SC, Tab>>, F: Insertable<Tab, Values = ValuesClause<SF, Tab>>, D: Insertable<Tab, Values = ValuesClause<SD, Tab>>, G: Insertable<Tab, Values = ValuesClause<SG, Tab>>, E: Insertable<Tab, Values = ValuesClause<SE, Tab>>, A: Insertable<Tab, Values = ValuesClause<SA, Tab>>, I: Insertable<Tab, Values = ValuesClause<SI, Tab>>, B: Insertable<Tab, Values = ValuesClause<SB, Tab>>, H: Insertable<Tab, Values = ValuesClause<SH, Tab>>, [src]

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

`pub fn values(self) -> <(A, B, C, D, E, F, G, H, I) as Insertable<Tab>>::Values`[src]

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

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

`pub fn values(self) -> <(A, B, C) as Insertable<Tab>>::Values`[src]

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

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

`pub fn values( self ) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) as Insertable<Tab>>::Values`[src]

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, Tab> Insertable<Tab> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) where C: Insertable<Tab, Values = ValuesClause<SC, Tab>>, S: Insertable<Tab, Values = ValuesClause<SS, Tab>>, F: Insertable<Tab, Values = ValuesClause<SF, Tab>>, D: Insertable<Tab, Values = ValuesClause<SD, Tab>>, O: Insertable<Tab, Values = ValuesClause<SO, Tab>>, L: Insertable<Tab, Values = ValuesClause<SL, Tab>>, G: Insertable<Tab, Values = ValuesClause<SG, Tab>>, T: Insertable<Tab, Values = ValuesClause<ST, Tab>>, M: Insertable<Tab, Values = ValuesClause<SM, Tab>>, E: Insertable<Tab, Values = ValuesClause<SE, Tab>>, U: Insertable<Tab, Values = ValuesClause<SU, Tab>>, P: Insertable<Tab, Values = ValuesClause<SP, Tab>>, A: Insertable<Tab, Values = ValuesClause<SA, Tab>>, R: Insertable<Tab, Values = ValuesClause<SR, Tab>>, K: Insertable<Tab, Values = ValuesClause<SK, Tab>>, V: Insertable<Tab, Values = ValuesClause<SV, Tab>>, I: Insertable<Tab, Values = ValuesClause<SI, Tab>>, N: Insertable<Tab, Values = ValuesClause<SN, Tab>>, B: Insertable<Tab, Values = ValuesClause<SB, Tab>>, H: Insertable<Tab, Values = ValuesClause<SH, Tab>>, J: Insertable<Tab, Values = ValuesClause<SJ, Tab>>, Q: Insertable<Tab, Values = ValuesClause<SQ, Tab>>, [src]

`type Values = ValuesClause<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV), Tab>`

`pub fn values( self ) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) as Insertable<Tab>>::Values`[src]

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE, Tab> Insertable<Tab> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE) where C: Insertable<Tab, Values = ValuesClause<SC, Tab>>, S: Insertable<Tab, Values = ValuesClause<SS, Tab>>, F: Insertable<Tab, Values = ValuesClause<SF, Tab>>, D: Insertable<Tab, Values = ValuesClause<SD, Tab>>, W: Insertable<Tab, Values = ValuesClause<SW, Tab>>, O: Insertable<Tab, Values = ValuesClause<SO, Tab>>, L: Insertable<Tab, Values = ValuesClause<SL, Tab>>, G: Insertable<Tab, Values = ValuesClause<SG, Tab>>, T: Insertable<Tab, Values = ValuesClause<ST, Tab>>, M: Insertable<Tab, Values = ValuesClause<SM, Tab>>, E: Insertable<Tab, Values = ValuesClause<SE, Tab>>, U: Insertable<Tab, Values = ValuesClause<SU, Tab>>, P: Insertable<Tab, Values = ValuesClause<SP, Tab>>, A: Insertable<Tab, Values = ValuesClause<SA, Tab>>, R: Insertable<Tab, Values = ValuesClause<SR, Tab>>, K: Insertable<Tab, Values = ValuesClause<SK, Tab>>, V: Insertable<Tab, Values = ValuesClause<SV, Tab>>, I: Insertable<Tab, Values = ValuesClause<SI, Tab>>, N: Insertable<Tab, Values = ValuesClause<SN, Tab>>, B: Insertable<Tab, Values = ValuesClause<SB, Tab>>, H: Insertable<Tab, Values = ValuesClause<SH, Tab>>, J: Insertable<Tab, Values = ValuesClause<SJ, Tab>>, Q: Insertable<Tab, Values = ValuesClause<SQ, Tab>>, X: Insertable<Tab, Values = ValuesClause<SX, Tab>>, Y: Insertable<Tab, Values = ValuesClause<SY, Tab>>, Z: Insertable<Tab, Values = ValuesClause<SZ, Tab>>, AA: Insertable<Tab, Values = ValuesClause<SAA, Tab>>, AB: Insertable<Tab, Values = ValuesClause<SAB, Tab>>, AC: Insertable<Tab, Values = ValuesClause<SAC, Tab>>, AD: Insertable<Tab, Values = ValuesClause<SAD, Tab>>, AE: Insertable<Tab, Values = ValuesClause<SAE, Tab>>, [src]

`type Values = ValuesClause<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD, SAE), Tab>`

`pub fn values( self ) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE) as Insertable<Tab>>::Values`[src]

`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>,` [src]

`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`

`pub fn values( self ) -> <&'a (A, B, C, D, E, F, G, H, I, J, K, L, M) as Insertable<Tab>>::Values`[src]

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

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

`pub fn values(self) -> <&'a (A, B) as Insertable<Tab>>::Values`[src]

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 C: Insertable<Tab, Values = ValuesClause<SC, Tab>>, F: Insertable<Tab, Values = ValuesClause<SF, Tab>>, D: Insertable<Tab, Values = ValuesClause<SD, Tab>>, O: Insertable<Tab, Values = ValuesClause<SO, Tab>>, L: Insertable<Tab, Values = ValuesClause<SL, Tab>>, G: Insertable<Tab, Values = ValuesClause<SG, Tab>>, M: Insertable<Tab, Values = ValuesClause<SM, Tab>>, E: Insertable<Tab, Values = ValuesClause<SE, Tab>>, P: Insertable<Tab, Values = ValuesClause<SP, Tab>>, A: Insertable<Tab, Values = ValuesClause<SA, Tab>>, K: Insertable<Tab, Values = ValuesClause<SK, Tab>>, I: Insertable<Tab, Values = ValuesClause<SI, Tab>>, N: Insertable<Tab, Values = ValuesClause<SN, Tab>>, B: Insertable<Tab, Values = ValuesClause<SB, Tab>>, H: Insertable<Tab, Values = ValuesClause<SH, Tab>>, J: Insertable<Tab, Values = ValuesClause<SJ, Tab>>, [src]

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

`pub fn values( self ) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) as Insertable<Tab>>::Values`[src]

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, Tab> Insertable<Tab> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) where C: Insertable<Tab, Values = ValuesClause<SC, Tab>>, S: Insertable<Tab, Values = ValuesClause<SS, Tab>>, F: Insertable<Tab, Values = ValuesClause<SF, Tab>>, D: Insertable<Tab, Values = ValuesClause<SD, Tab>>, O: Insertable<Tab, Values = ValuesClause<SO, Tab>>, L: Insertable<Tab, Values = ValuesClause<SL, Tab>>, G: Insertable<Tab, Values = ValuesClause<SG, Tab>>, T: Insertable<Tab, Values = ValuesClause<ST, Tab>>, M: Insertable<Tab, Values = ValuesClause<SM, Tab>>, E: Insertable<Tab, Values = ValuesClause<SE, Tab>>, U: Insertable<Tab, Values = ValuesClause<SU, Tab>>, P: Insertable<Tab, Values = ValuesClause<SP, Tab>>, A: Insertable<Tab, Values = ValuesClause<SA, Tab>>, R: Insertable<Tab, Values = ValuesClause<SR, Tab>>, K: Insertable<Tab, Values = ValuesClause<SK, Tab>>, I: Insertable<Tab, Values = ValuesClause<SI, Tab>>, N: Insertable<Tab, Values = ValuesClause<SN, Tab>>, B: Insertable<Tab, Values = ValuesClause<SB, Tab>>, H: Insertable<Tab, Values = ValuesClause<SH, Tab>>, J: Insertable<Tab, Values = ValuesClause<SJ, Tab>>, Q: Insertable<Tab, Values = ValuesClause<SQ, Tab>>, [src]

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

`pub fn values( self ) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) as Insertable<Tab>>::Values`[src]

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, Tab> Insertable<Tab> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB) where C: Insertable<Tab, Values = ValuesClause<SC, Tab>>, S: Insertable<Tab, Values = ValuesClause<SS, Tab>>, F: Insertable<Tab, Values = ValuesClause<SF, Tab>>, D: Insertable<Tab, Values = ValuesClause<SD, Tab>>, W: Insertable<Tab, Values = ValuesClause<SW, Tab>>, O: Insertable<Tab, Values = ValuesClause<SO, Tab>>, L: Insertable<Tab, Values = ValuesClause<SL, Tab>>, G: Insertable<Tab, Values = ValuesClause<SG, Tab>>, T: Insertable<Tab, Values = ValuesClause<ST, Tab>>, M: Insertable<Tab, Values = ValuesClause<SM, Tab>>, E: Insertable<Tab, Values = ValuesClause<SE, Tab>>, U: Insertable<Tab, Values = ValuesClause<SU, Tab>>, P: Insertable<Tab, Values = ValuesClause<SP, Tab>>, A: Insertable<Tab, Values = ValuesClause<SA, Tab>>, R: Insertable<Tab, Values = ValuesClause<SR, Tab>>, K: Insertable<Tab, Values = ValuesClause<SK, Tab>>, V: Insertable<Tab, Values = ValuesClause<SV, Tab>>, I: Insertable<Tab, Values = ValuesClause<SI, Tab>>, N: Insertable<Tab, Values = ValuesClause<SN, Tab>>, B: Insertable<Tab, Values = ValuesClause<SB, Tab>>, H: Insertable<Tab, Values = ValuesClause<SH, Tab>>, J: Insertable<Tab, Values = ValuesClause<SJ, Tab>>, Q: Insertable<Tab, Values = ValuesClause<SQ, Tab>>, X: Insertable<Tab, Values = ValuesClause<SX, Tab>>, Y: Insertable<Tab, Values = ValuesClause<SY, Tab>>, Z: Insertable<Tab, Values = ValuesClause<SZ, Tab>>, AA: Insertable<Tab, Values = ValuesClause<SAA, Tab>>, AB: Insertable<Tab, Values = ValuesClause<SAB, Tab>>, [src]

`type Values = ValuesClause<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB), Tab>`

`pub fn values( self ) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB) as Insertable<Tab>>::Values`[src]

Loading content...

Implementors

`impl<'a, 'b, ST, QS, DB, T> Insertable<T> for &'b BoxedSelectStatement<'a, ST, QS, DB> where T: Table, &'b BoxedSelectStatement<'a, ST, QS, DB>: Query,` [src]

`type Values = InsertFromSelect<&'b BoxedSelectStatement<'a, ST, QS, DB>, <T as Table>::AllColumns>`

`pub fn values( self ) -> <&'b BoxedSelectStatement<'a, ST, QS, DB> as Insertable<T>>::Values`[src]

`impl<'a, 'insert> Insertable<table> for &'insert NewPotentialUser<'a>`[src]

`type Values = <(Option<Eq<email, &'insert &'a str>>, Option<Eq<session_code, &'insert &'a str>>, Option<Eq<verification_code, &'insert &'a str>>, Option<Eq<username, &'insert &'a str>>, Option<Eq<password, &'insert &'a str>>, Option<Eq<created_at, &'insert SystemTime>>) as Insertable<table>>::Values`

`fn values(self) -> Self::Values`[src]

`impl<'a, 'insert> Insertable<table> for NewPotentialUser<'a>`[src]

`type Values = <(Option<Eq<email, &'a str>>, Option<Eq<session_code, &'a str>>, Option<Eq<verification_code, &'a str>>, Option<Eq<username, &'a str>>, Option<Eq<password, &'a str>>, Option<Eq<created_at, SystemTime>>) as Insertable<table>>::Values`

`fn values(self) -> Self::Values`[src]

`impl<'a, ST, QS, DB, T> Insertable<T> for BoxedSelectStatement<'a, ST, QS, DB> where T: Table, BoxedSelectStatement<'a, ST, QS, DB>: Query,` [src]

`type Values = InsertFromSelect<BoxedSelectStatement<'a, ST, QS, DB>, <T as Table>::AllColumns>`

`pub fn values( self ) -> <BoxedSelectStatement<'a, ST, QS, DB> as Insertable<T>>::Values`[src]

`impl<'a, T> Insertable<T> for &'a block_tools::db::schema::blocks::table where table: Insertable<T>,` [src]

`type Values = <table as Insertable<T>>::Values`

`fn values(self) -> Self::Values`[src]

`impl<'a, T> Insertable<T> for &'a block_tools::db::schema::potential_users::table where table: Insertable<T>,` [src]

`type Values = <table as Insertable<T>>::Values`

`fn values(self) -> Self::Values`[src]

`impl<'a, T> Insertable<T> for &'a block_tools::db::schema::properties::table where table: Insertable<T>,` [src]

`type Values = <table as Insertable<T>>::Values`

`fn values(self) -> Self::Values`[src]

`impl<'a, T> Insertable<T> for &'a block_tools::db::schema::users::table where table: Insertable<T>,` [src]

`type Values = <table as Insertable<T>>::Values`

`fn values(self) -> Self::Values`[src]

`impl<'insert> Insertable<table> for &'insert NewBlock`[src]

`type Values = <(Option<Eq<block_type, &'insert String>>, Option<Eq<created_at, &'insert SystemTime>>, Option<Eq<updated_at, &'insert SystemTime>>, Option<Eq<block_data, &'insert String>>, Option<Eq<owner_id, &'insert i32>>) as Insertable<table>>::Values`

`fn values(self) -> Self::Values`[src]

`impl<'insert> Insertable<table> for NewBlock`[src]

`type Values = <(Option<Eq<block_type, String>>, Option<Eq<created_at, SystemTime>>, Option<Eq<updated_at, SystemTime>>, Option<Eq<block_data, String>>, Option<Eq<owner_id, i32>>) as Insertable<table>>::Values`

`fn values(self) -> Self::Values`[src]

`impl<'insert> Insertable<table> for &'insert NewProperty`[src]

`type Values = <(Option<Eq<property_name, &'insert String>>, Option<Eq<parent_id, &'insert i64>>, Option<Eq<value_id, &'insert i64>>, Option<Eq<annotation, &'insert String>>) as Insertable<table>>::Values`

`fn values(self) -> Self::Values`[src]

`impl<'insert> Insertable<table> for NewProperty`[src]

`type Values = <(Option<Eq<property_name, String>>, Option<Eq<parent_id, i64>>, Option<Eq<value_id, i64>>, Option<Eq<annotation, String>>) as Insertable<table>>::Values`

`fn values(self) -> Self::Values`[src]

`impl<'insert> Insertable<table> for &'insert NewUser`[src]

`type Values = <(Option<Eq<username, &'insert String>>, Option<Eq<localuname, &'insert String>>, Option<Eq<password, &'insert String>>, Option<Eq<email, &'insert String>>, Option<Eq<credits, &'insert i32>>, Option<Eq<display_name, &'insert String>>) as Insertable<table>>::Values`

`fn values(self) -> Self::Values`[src]

`impl<'insert> Insertable<table> for NewUser`[src]

`type Values = <(Option<Eq<username, String>>, Option<Eq<localuname, String>>, Option<Eq<password, String>>, Option<Eq<email, String>>, Option<Eq<credits, i32>>, Option<Eq<display_name, String>>) as Insertable<table>>::Values`

`fn values(self) -> Self::Values`[src]

`impl<T> Insertable<T> for block_tools::db::schema::blocks::table where <table as AsQuery>::Query: Insertable<T>,` [src]

`type Values = <<table as AsQuery>::Query as Insertable<T>>::Values`

`fn values(self) -> Self::Values`[src]

`impl<T> Insertable<T> for block_tools::db::schema::potential_users::table where <table as AsQuery>::Query: Insertable<T>,` [src]

`type Values = <<table as AsQuery>::Query as Insertable<T>>::Values`

`fn values(self) -> Self::Values`[src]

`impl<T> Insertable<T> for block_tools::db::schema::properties::table where <table as AsQuery>::Query: Insertable<T>,` [src]

`type Values = <<table as AsQuery>::Query as Insertable<T>>::Values`

`fn values(self) -> Self::Values`[src]

`impl<T> Insertable<T> for block_tools::db::schema::users::table where <table as AsQuery>::Query: Insertable<T>,` [src]

`type Values = <<table as AsQuery>::Query as Insertable<T>>::Values`

`fn values(self) -> Self::Values`[src]

Loading content...

Trait block_tools::db::use_diesel::prelude::Insertable[−][src]

Deriving

Associated Types

type Values[src]

Required methods

pub fn values(self) -> Self::Values[src]

Provided methods

pub fn insert_into( self, table: T) -> InsertStatement<T, Self::Values, Insert, NoReturningClause>[src]

Example

Implementations on Foreign Types

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>, [src]

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

pub fn values( self) -> <&'a (A, B, C, D, E, F, G, H, I) as Insertable<Tab>>::Values[src]

impl<T, Tab> Insertable<Tab> for Vec<T, Global> where T: Insertable<Tab> + UndecoratedInsertRecord<Tab>, [src]

type Values = OwnedBatchInsert<<T as Insertable<Tab>>::Values, Tab>

pub fn values(self) -> <Vec<T, Global> as Insertable<Tab>>::Values[src]

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, &'a Q, &'a R, &'a S, &'a T, &'a U, &'a V, &'a W, &'a X) as Insertable<Tab>>::Values

pub fn values( self) -> <&'a (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X) as Insertable<Tab>>::Values[src]

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, &'a Q, &'a R, &'a S, &'a T, &'a U, &'a V, &'a W, &'a X, &'a Y, &'a Z, &'a AA, &'a AB, &'a AC) as Insertable<Tab>>::Values

pub fn values( self) -> <&'a (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC) as Insertable<Tab>>::Values[src]

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>, [src]

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

pub fn values(self) -> <&'a (A, B, C, D, E, F) as Insertable<Tab>>::Values[src]

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>, [src]

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

pub fn values(self) -> <&'a (A, B, C, D, E) as Insertable<Tab>>::Values[src]

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>, [src]

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

pub fn values( self) -> <&'a (A, B, C, D, E, F, G, H, I, J, K, L) as Insertable<Tab>>::Values[src]

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

pub fn values( self) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) as Insertable<Tab>>::Values[src]

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

pub fn values( self) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M) as Insertable<Tab>>::Values[src]

type Values = ValuesClause<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY), Tab>

pub fn values( self) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y) as Insertable<Tab>>::Values[src]

type Values = ValuesClause<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD), Tab>

pub fn values( self) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD) as Insertable<Tab>>::Values[src]

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>, [src]

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

pub fn values(self) -> <&'a (A, B, C, D) as Insertable<Tab>>::Values[src]

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, &'a Q, &'a R, &'a S, &'a T, &'a U, &'a V, &'a W, &'a X, &'a Y, &'a Z, &'a AA, &'a AB, &'a AC, &'a AD) as Insertable<Tab>>::Values

pub fn values( self) -> <&'a (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD) as Insertable<Tab>>::Values[src]

type Values = ValuesClause<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA), Tab>

pub fn values( self) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA) as Insertable<Tab>>::Values[src]

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, &'a Q, &'a R, &'a S, &'a T, &'a U, &'a V, &'a W, &'a X, &'a Y) as Insertable<Tab>>::Values

pub fn values( self) -> <&'a (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y) as Insertable<Tab>>::Values[src]

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>>, [src]

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

pub fn values(self) -> <(A, B) as Insertable<Tab>>::Values[src]

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

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

pub fn values(self) -> <&'a [T] as Insertable<Tab>>::Values[src]

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

pub fn values( self) -> <(A, B, C, D, E, F, G, H, I, J) as Insertable<Tab>>::Values[src]

impl<T, Tab> Insertable<Tab> for Option<T> where T: Insertable<Tab>, <T as Insertable<Tab>>::Values: Default, [src]

type Values = <T as Insertable<Tab>>::Values

pub fn values(self) -> <Option<T> as Insertable<Tab>>::Values[src]

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, &'a Q, &'a R, &'a S) as Insertable<Tab>>::Values

pub fn values( self) -> <&'a (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) as Insertable<Tab>>::Values[src]

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

pub fn values( self) -> <(A, B, C, D, E, F, G, H, I, J, K, L) as Insertable<Tab>>::Values[src]

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, &'a Q, &'a R, &'a S, &'a T, &'a U, &'a V, &'a W, &'a X, &'a Y, &'a Z) as Insertable<Tab>>::Values

pub fn values( self) -> <&'a (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z) as Insertable<Tab>>::Values[src]

impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, Tab> Insertable<Tab> for &'a (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) 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, &'a Q): Insertable<Tab>, [src]

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, &'a Q) as Insertable<Tab>>::Values

pub fn values( self) -> <&'a (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) as Insertable<Tab>>::Values[src]

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>, [src]

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

pub fn values( self) -> <&'a (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) as Insertable<Tab>>::Values[src]

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

pub fn values(self) -> <(A, B, C, D, E) as Insertable<Tab>>::Values[src]

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

pub fn values( self) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) as Insertable<Tab>>::Values[src]

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>, [src]

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

pub fn values(self) -> <&'a (A, B, C, D, E, F, G) as Insertable<Tab>>::Values[src]

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

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

pub fn values(self) -> <(A, B, C, D) as Insertable<Tab>>::Values[src]

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, &'a Q, &'a R, &'a S, &'a T, &'a U) as Insertable<Tab>>::Values

`type Values`[src]

`pub fn values(self) -> Self::Values`[src]

`pub fn insert_into( self, table: T ) -> InsertStatement<T, Self::Values, Insert, NoReturningClause>`[src]

`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>,` [src]

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

`pub fn values( self ) -> <&'a (A, B, C, D, E, F, G, H, I) as Insertable<Tab>>::Values`[src]

`impl<T, Tab> Insertable<Tab> for Vec<T, Global> where T: Insertable<Tab> + UndecoratedInsertRecord<Tab>,` [src]

`type Values = OwnedBatchInsert<<T as Insertable<Tab>>::Values, Tab>`

`pub fn values(self) -> <Vec<T, Global> as Insertable<Tab>>::Values`[src]

`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, &'a Q, &'a R, &'a S, &'a T, &'a U, &'a V, &'a W, &'a X) as Insertable<Tab>>::Values`

`pub fn values( self ) -> <&'a (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X) as Insertable<Tab>>::Values`[src]

`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, &'a Q, &'a R, &'a S, &'a T, &'a U, &'a V, &'a W, &'a X, &'a Y, &'a Z, &'a AA, &'a AB, &'a AC) as Insertable<Tab>>::Values`

`pub fn values( self ) -> <&'a (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC) as Insertable<Tab>>::Values`[src]

`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>,` [src]

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

`pub fn values(self) -> <&'a (A, B, C, D, E, F) as Insertable<Tab>>::Values`[src]

`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>,` [src]

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

`pub fn values(self) -> <&'a (A, B, C, D, E) as Insertable<Tab>>::Values`[src]

`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>,` [src]

`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`

`pub fn values( self ) -> <&'a (A, B, C, D, E, F, G, H, I, J, K, L) as Insertable<Tab>>::Values`[src]

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

`pub fn values( self ) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) as Insertable<Tab>>::Values`[src]

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

`pub fn values( self ) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M) as Insertable<Tab>>::Values`[src]

`type Values = ValuesClause<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY), Tab>`

`pub fn values( self ) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y) as Insertable<Tab>>::Values`[src]

`type Values = ValuesClause<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA, SAB, SAC, SAD), Tab>`

`pub fn values( self ) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD) as Insertable<Tab>>::Values`[src]

`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>,` [src]

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

`pub fn values(self) -> <&'a (A, B, C, D) as Insertable<Tab>>::Values`[src]

`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, &'a Q, &'a R, &'a S, &'a T, &'a U, &'a V, &'a W, &'a X, &'a Y, &'a Z, &'a AA, &'a AB, &'a AC, &'a AD) as Insertable<Tab>>::Values`

`pub fn values( self ) -> <&'a (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD) as Insertable<Tab>>::Values`[src]

`type Values = ValuesClause<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP, SQ, SR, SS, ST, SU, SV, SW, SX, SY, SZ, SAA), Tab>`

`pub fn values( self ) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA) as Insertable<Tab>>::Values`[src]

`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, &'a Q, &'a R, &'a S, &'a T, &'a U, &'a V, &'a W, &'a X, &'a Y) as Insertable<Tab>>::Values`

`pub fn values( self ) -> <&'a (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y) as Insertable<Tab>>::Values`[src]

`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>>,` [src]

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

`pub fn values(self) -> <(A, B) as Insertable<Tab>>::Values`[src]

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

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

`pub fn values(self) -> <&'a [T] as Insertable<Tab>>::Values`[src]

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

`pub fn values( self ) -> <(A, B, C, D, E, F, G, H, I, J) as Insertable<Tab>>::Values`[src]

`impl<T, Tab> Insertable<Tab> for Option<T> where T: Insertable<Tab>, <T as Insertable<Tab>>::Values: Default,` [src]

`type Values = <T as Insertable<Tab>>::Values`

`pub fn values(self) -> <Option<T> as Insertable<Tab>>::Values`[src]

`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, &'a Q, &'a R, &'a S) as Insertable<Tab>>::Values`

`pub fn values( self ) -> <&'a (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) as Insertable<Tab>>::Values`[src]

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

`pub fn values( self ) -> <(A, B, C, D, E, F, G, H, I, J, K, L) as Insertable<Tab>>::Values`[src]

`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, &'a Q, &'a R, &'a S, &'a T, &'a U, &'a V, &'a W, &'a X, &'a Y, &'a Z) as Insertable<Tab>>::Values`

`pub fn values( self ) -> <&'a (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z) as Insertable<Tab>>::Values`[src]

`impl<'a, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, Tab> Insertable<Tab> for &'a (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) 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, &'a Q): Insertable<Tab>,` [src]

`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, &'a Q) as Insertable<Tab>>::Values`

`pub fn values( self ) -> <&'a (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) as Insertable<Tab>>::Values`[src]

`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>,` [src]

`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`

`pub fn values( self ) -> <&'a (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) as Insertable<Tab>>::Values`[src]

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

`pub fn values(self) -> <(A, B, C, D, E) as Insertable<Tab>>::Values`[src]

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

`pub fn values( self ) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) as Insertable<Tab>>::Values`[src]

`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>,` [src]

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

`pub fn values(self) -> <&'a (A, B, C, D, E, F, G) as Insertable<Tab>>::Values`[src]

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

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

`pub fn values(self) -> <(A, B, C, D) as Insertable<Tab>>::Values`[src]

`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, &'a Q, &'a R, &'a S, &'a T, &'a U) as Insertable<Tab>>::Values`

`pub fn values( self ) -> <&'a (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) as Insertable<Tab>>::Values`[src]

`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>,` [src]

`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`

`pub fn values( self ) -> <&'a (A, B, C, D, E, F, G, H, I, J) as Insertable<Tab>>::Values`[src]

`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>,` [src]

`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`

`pub fn values( self ) -> <&'a (A, B, C, D, E, F, G, H, I, J, K) as Insertable<Tab>>::Values`[src]