Trait diesel::query_builder::update_statement::changeset::Changeset

pub trait Changeset<DB: Backend> {
    fn is_noop(&self) -> bool;
    fn to_sql(&self, out: &mut DB::QueryBuilder) -> BuildQueryResult;
    fn collect_binds(&self, out: &mut DB::BindCollector) -> QueryResult<()>;
}

Apps should not need to concern themselves with this trait.

Required Methods

fn is_noop(&self) -> bool

fn to_sql(&self, out: &mut DB::QueryBuilder) -> BuildQueryResult

fn collect_binds(&self, out: &mut DB::BindCollector) -> QueryResult<()>

Implementations on Foreign Types

impl<T: Changeset<DB>, DB: Backend> Changeset<DB> for Option<T>

fn is_noop(&self) -> bool

fn to_sql(&self, out: &mut DB::QueryBuilder) -> BuildQueryResult

fn collect_binds(&self, out: &mut DB::BindCollector) -> QueryResult<()>

impl<DB, A> Changeset<DB> for (A,) where
    DB: Backend,
    A: Changeset<DB>, 

fn is_noop(&self) -> bool

fn to_sql(&self, out: &mut DB::QueryBuilder) -> BuildQueryResult

fn collect_binds(&self, out: &mut DB::BindCollector) -> QueryResult<()>

impl<DB, A, B> Changeset<DB> for (A, B) where
    DB: Backend,
    A: Changeset<DB>,
    B: Changeset<DB>, 

fn is_noop(&self) -> bool

fn to_sql(&self, out: &mut DB::QueryBuilder) -> BuildQueryResult

fn collect_binds(&self, out: &mut DB::BindCollector) -> QueryResult<()>

impl<DB, A, B, C> Changeset<DB> for (A, B, C) where
    DB: Backend,
    A: Changeset<DB>,
    B: Changeset<DB>,
    C: Changeset<DB>, 

fn is_noop(&self) -> bool

fn to_sql(&self, out: &mut DB::QueryBuilder) -> BuildQueryResult

fn collect_binds(&self, out: &mut DB::BindCollector) -> QueryResult<()>

impl<DB, A, B, C, D> Changeset<DB> for (A, B, C, D) where
    DB: Backend,
    A: Changeset<DB>,
    B: Changeset<DB>,
    C: Changeset<DB>,
    D: Changeset<DB>, 

fn is_noop(&self) -> bool

fn to_sql(&self, out: &mut DB::QueryBuilder) -> BuildQueryResult

fn collect_binds(&self, out: &mut DB::BindCollector) -> QueryResult<()>

impl<DB, A, B, C, D, E> Changeset<DB> for (A, B, C, D, E) where
    DB: Backend,
    A: Changeset<DB>,
    B: Changeset<DB>,
    C: Changeset<DB>,
    D: Changeset<DB>,
    E: Changeset<DB>, 

fn is_noop(&self) -> bool

fn to_sql(&self, out: &mut DB::QueryBuilder) -> BuildQueryResult

fn collect_binds(&self, out: &mut DB::BindCollector) -> QueryResult<()>

impl<DB, A, B, C, D, E, F> Changeset<DB> for (A, B, C, D, E, F) where
    DB: Backend,
    A: Changeset<DB>,
    B: Changeset<DB>,
    C: Changeset<DB>,
    D: Changeset<DB>,
    E: Changeset<DB>,
    F: Changeset<DB>, 

fn is_noop(&self) -> bool

fn to_sql(&self, out: &mut DB::QueryBuilder) -> BuildQueryResult

fn collect_binds(&self, out: &mut DB::BindCollector) -> QueryResult<()>

impl<DB, A, B, C, D, E, F, G> Changeset<DB> for (A, B, C, D, E, F, G) where
    DB: Backend,
    A: Changeset<DB>,
    B: Changeset<DB>,
    C: Changeset<DB>,
    D: Changeset<DB>,
    E: Changeset<DB>,
    F: Changeset<DB>,
    G: Changeset<DB>, 

fn is_noop(&self) -> bool

fn to_sql(&self, out: &mut DB::QueryBuilder) -> BuildQueryResult

fn collect_binds(&self, out: &mut DB::BindCollector) -> QueryResult<()>

impl<DB, A, B, C, D, E, F, G, H> Changeset<DB> for (A, B, C, D, E, F, G, H) where
    DB: Backend,
    A: Changeset<DB>,
    B: Changeset<DB>,
    C: Changeset<DB>,
    D: Changeset<DB>,
    E: Changeset<DB>,
    F: Changeset<DB>,
    G: Changeset<DB>,
    H: Changeset<DB>, 

fn is_noop(&self) -> bool

fn to_sql(&self, out: &mut DB::QueryBuilder) -> BuildQueryResult

fn collect_binds(&self, out: &mut DB::BindCollector) -> QueryResult<()>

impl<DB, A, B, C, D, E, F, G, H, I> Changeset<DB> for (A, B, C, D, E, F, G, H, I) where
    DB: Backend,
    A: Changeset<DB>,
    B: Changeset<DB>,
    C: Changeset<DB>,
    D: Changeset<DB>,
    E: Changeset<DB>,
    F: Changeset<DB>,
    G: Changeset<DB>,
    H: Changeset<DB>,
    I: Changeset<DB>, 

fn is_noop(&self) -> bool

fn to_sql(&self, out: &mut DB::QueryBuilder) -> BuildQueryResult

fn collect_binds(&self, out: &mut DB::BindCollector) -> QueryResult<()>

impl<DB, A, B, C, D, E, F, G, H, I, J> Changeset<DB> for (A, B, C, D, E, F, G, H, I, J) where
    DB: Backend,
    A: Changeset<DB>,
    B: Changeset<DB>,
    C: Changeset<DB>,
    D: Changeset<DB>,
    E: Changeset<DB>,
    F: Changeset<DB>,
    G: Changeset<DB>,
    H: Changeset<DB>,
    I: Changeset<DB>,
    J: Changeset<DB>, 

fn is_noop(&self) -> bool

fn to_sql(&self, out: &mut DB::QueryBuilder) -> BuildQueryResult

fn collect_binds(&self, out: &mut DB::BindCollector) -> QueryResult<()>

impl<DB, A, B, C, D, E, F, G, H, I, J, K> Changeset<DB> for (A, B, C, D, E, F, G, H, I, J, K) where
    DB: Backend,
    A: Changeset<DB>,
    B: Changeset<DB>,
    C: Changeset<DB>,
    D: Changeset<DB>,
    E: Changeset<DB>,
    F: Changeset<DB>,
    G: Changeset<DB>,
    H: Changeset<DB>,
    I: Changeset<DB>,
    J: Changeset<DB>,
    K: Changeset<DB>, 

fn is_noop(&self) -> bool

fn to_sql(&self, out: &mut DB::QueryBuilder) -> BuildQueryResult

fn collect_binds(&self, out: &mut DB::BindCollector) -> QueryResult<()>

impl<DB, A, B, C, D, E, F, G, H, I, J, K, L> Changeset<DB> for (A, B, C, D, E, F, G, H, I, J, K, L) where
    DB: Backend,
    A: Changeset<DB>,
    B: Changeset<DB>,
    C: Changeset<DB>,
    D: Changeset<DB>,
    E: Changeset<DB>,
    F: Changeset<DB>,
    G: Changeset<DB>,
    H: Changeset<DB>,
    I: Changeset<DB>,
    J: Changeset<DB>,
    K: Changeset<DB>,
    L: Changeset<DB>, 

fn is_noop(&self) -> bool

fn to_sql(&self, out: &mut DB::QueryBuilder) -> BuildQueryResult

fn collect_binds(&self, out: &mut DB::BindCollector) -> QueryResult<()>

impl<DB, A, B, C, D, E, F, G, H, I, J, K, L, M> Changeset<DB> for (A, B, C, D, E, F, G, H, I, J, K, L, M) where
    DB: Backend,
    A: Changeset<DB>,
    B: Changeset<DB>,
    C: Changeset<DB>,
    D: Changeset<DB>,
    E: Changeset<DB>,
    F: Changeset<DB>,
    G: Changeset<DB>,
    H: Changeset<DB>,
    I: Changeset<DB>,
    J: Changeset<DB>,
    K: Changeset<DB>,
    L: Changeset<DB>,
    M: Changeset<DB>, 

fn is_noop(&self) -> bool

fn to_sql(&self, out: &mut DB::QueryBuilder) -> BuildQueryResult

fn collect_binds(&self, out: &mut DB::BindCollector) -> QueryResult<()>

impl<DB, A, B, C, D, E, F, G, H, I, J, K, L, M, N> Changeset<DB> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N) where
    DB: Backend,
    A: Changeset<DB>,
    B: Changeset<DB>,
    C: Changeset<DB>,
    D: Changeset<DB>,
    E: Changeset<DB>,
    F: Changeset<DB>,
    G: Changeset<DB>,
    H: Changeset<DB>,
    I: Changeset<DB>,
    J: Changeset<DB>,
    K: Changeset<DB>,
    L: Changeset<DB>,
    M: Changeset<DB>,
    N: Changeset<DB>, 

fn is_noop(&self) -> bool

fn to_sql(&self, out: &mut DB::QueryBuilder) -> BuildQueryResult

fn collect_binds(&self, out: &mut DB::BindCollector) -> QueryResult<()>

impl<DB, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> Changeset<DB> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) where
    DB: Backend,
    A: Changeset<DB>,
    B: Changeset<DB>,
    C: Changeset<DB>,
    D: Changeset<DB>,
    E: Changeset<DB>,
    F: Changeset<DB>,
    G: Changeset<DB>,
    H: Changeset<DB>,
    I: Changeset<DB>,
    J: Changeset<DB>,
    K: Changeset<DB>,
    L: Changeset<DB>,
    M: Changeset<DB>,
    N: Changeset<DB>,
    O: Changeset<DB>, 

fn is_noop(&self) -> bool

fn to_sql(&self, out: &mut DB::QueryBuilder) -> BuildQueryResult

fn collect_binds(&self, out: &mut DB::BindCollector) -> QueryResult<()>

impl<DB, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> Changeset<DB> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) where
    DB: Backend,
    A: Changeset<DB>,
    B: Changeset<DB>,
    C: Changeset<DB>,
    D: Changeset<DB>,
    E: Changeset<DB>,
    F: Changeset<DB>,
    G: Changeset<DB>,
    H: Changeset<DB>,
    I: Changeset<DB>,
    J: Changeset<DB>,
    K: Changeset<DB>,
    L: Changeset<DB>,
    M: Changeset<DB>,
    N: Changeset<DB>,
    O: Changeset<DB>,
    P: Changeset<DB>, 

fn is_noop(&self) -> bool

fn to_sql(&self, out: &mut DB::QueryBuilder) -> BuildQueryResult

fn collect_binds(&self, out: &mut DB::BindCollector) -> QueryResult<()>

impl<DB, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q> Changeset<DB> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) where
    DB: Backend,
    A: Changeset<DB>,
    B: Changeset<DB>,
    C: Changeset<DB>,
    D: Changeset<DB>,
    E: Changeset<DB>,
    F: Changeset<DB>,
    G: Changeset<DB>,
    H: Changeset<DB>,
    I: Changeset<DB>,
    J: Changeset<DB>,
    K: Changeset<DB>,
    L: Changeset<DB>,
    M: Changeset<DB>,
    N: Changeset<DB>,
    O: Changeset<DB>,
    P: Changeset<DB>,
    Q: Changeset<DB>, 

fn is_noop(&self) -> bool

fn to_sql(&self, out: &mut DB::QueryBuilder) -> BuildQueryResult

fn collect_binds(&self, out: &mut DB::BindCollector) -> QueryResult<()>

impl<DB, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R> Changeset<DB> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) where
    DB: Backend,
    A: Changeset<DB>,
    B: Changeset<DB>,
    C: Changeset<DB>,
    D: Changeset<DB>,
    E: Changeset<DB>,
    F: Changeset<DB>,
    G: Changeset<DB>,
    H: Changeset<DB>,
    I: Changeset<DB>,
    J: Changeset<DB>,
    K: Changeset<DB>,
    L: Changeset<DB>,
    M: Changeset<DB>,
    N: Changeset<DB>,
    O: Changeset<DB>,
    P: Changeset<DB>,
    Q: Changeset<DB>,
    R: Changeset<DB>, 

fn is_noop(&self) -> bool

fn to_sql(&self, out: &mut DB::QueryBuilder) -> BuildQueryResult

fn collect_binds(&self, out: &mut DB::BindCollector) -> QueryResult<()>

impl<DB, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S> Changeset<DB> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) where
    DB: Backend,
    A: Changeset<DB>,
    B: Changeset<DB>,
    C: Changeset<DB>,
    D: Changeset<DB>,
    E: Changeset<DB>,
    F: Changeset<DB>,
    G: Changeset<DB>,
    H: Changeset<DB>,
    I: Changeset<DB>,
    J: Changeset<DB>,
    K: Changeset<DB>,
    L: Changeset<DB>,
    M: Changeset<DB>,
    N: Changeset<DB>,
    O: Changeset<DB>,
    P: Changeset<DB>,
    Q: Changeset<DB>,
    R: Changeset<DB>,
    S: Changeset<DB>, 

fn is_noop(&self) -> bool

fn to_sql(&self, out: &mut DB::QueryBuilder) -> BuildQueryResult

fn collect_binds(&self, out: &mut DB::BindCollector) -> QueryResult<()>

impl<DB, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T> Changeset<DB> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) where
    DB: Backend,
    A: Changeset<DB>,
    B: Changeset<DB>,
    C: Changeset<DB>,
    D: Changeset<DB>,
    E: Changeset<DB>,
    F: Changeset<DB>,
    G: Changeset<DB>,
    H: Changeset<DB>,
    I: Changeset<DB>,
    J: Changeset<DB>,
    K: Changeset<DB>,
    L: Changeset<DB>,
    M: Changeset<DB>,
    N: Changeset<DB>,
    O: Changeset<DB>,
    P: Changeset<DB>,
    Q: Changeset<DB>,
    R: Changeset<DB>,
    S: Changeset<DB>,
    T: Changeset<DB>, 

fn is_noop(&self) -> bool

fn to_sql(&self, out: &mut DB::QueryBuilder) -> BuildQueryResult

fn collect_binds(&self, out: &mut DB::BindCollector) -> QueryResult<()>

impl<DB, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U> Changeset<DB> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) where
    DB: Backend,
    A: Changeset<DB>,
    B: Changeset<DB>,
    C: Changeset<DB>,
    D: Changeset<DB>,
    E: Changeset<DB>,
    F: Changeset<DB>,
    G: Changeset<DB>,
    H: Changeset<DB>,
    I: Changeset<DB>,
    J: Changeset<DB>,
    K: Changeset<DB>,
    L: Changeset<DB>,
    M: Changeset<DB>,
    N: Changeset<DB>,
    O: Changeset<DB>,
    P: Changeset<DB>,
    Q: Changeset<DB>,
    R: Changeset<DB>,
    S: Changeset<DB>,
    T: Changeset<DB>,
    U: Changeset<DB>, 

fn is_noop(&self) -> bool

fn to_sql(&self, out: &mut DB::QueryBuilder) -> BuildQueryResult

fn collect_binds(&self, out: &mut DB::BindCollector) -> QueryResult<()>

impl<DB, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V> Changeset<DB> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) where
    DB: Backend,
    A: Changeset<DB>,
    B: Changeset<DB>,
    C: Changeset<DB>,
    D: Changeset<DB>,
    E: Changeset<DB>,
    F: Changeset<DB>,
    G: Changeset<DB>,
    H: Changeset<DB>,
    I: Changeset<DB>,
    J: Changeset<DB>,
    K: Changeset<DB>,
    L: Changeset<DB>,
    M: Changeset<DB>,
    N: Changeset<DB>,
    O: Changeset<DB>,
    P: Changeset<DB>,
    Q: Changeset<DB>,
    R: Changeset<DB>,
    S: Changeset<DB>,
    T: Changeset<DB>,
    U: Changeset<DB>,
    V: Changeset<DB>, 

fn is_noop(&self) -> bool

fn to_sql(&self, out: &mut DB::QueryBuilder) -> BuildQueryResult

fn collect_binds(&self, out: &mut DB::BindCollector) -> QueryResult<()>

impl<DB, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W> Changeset<DB> 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
    DB: Backend,
    A: Changeset<DB>,
    B: Changeset<DB>,
    C: Changeset<DB>,
    D: Changeset<DB>,
    E: Changeset<DB>,
    F: Changeset<DB>,
    G: Changeset<DB>,
    H: Changeset<DB>,
    I: Changeset<DB>,
    J: Changeset<DB>,
    K: Changeset<DB>,
    L: Changeset<DB>,
    M: Changeset<DB>,
    N: Changeset<DB>,
    O: Changeset<DB>,
    P: Changeset<DB>,
    Q: Changeset<DB>,
    R: Changeset<DB>,
    S: Changeset<DB>,
    T: Changeset<DB>,
    U: Changeset<DB>,
    V: Changeset<DB>,
    W: Changeset<DB>, 

fn is_noop(&self) -> bool

fn to_sql(&self, out: &mut DB::QueryBuilder) -> BuildQueryResult

fn collect_binds(&self, out: &mut DB::BindCollector) -> QueryResult<()>

impl<DB, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X> Changeset<DB> 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
    DB: Backend,
    A: Changeset<DB>,
    B: Changeset<DB>,
    C: Changeset<DB>,
    D: Changeset<DB>,
    E: Changeset<DB>,
    F: Changeset<DB>,
    G: Changeset<DB>,
    H: Changeset<DB>,
    I: Changeset<DB>,
    J: Changeset<DB>,
    K: Changeset<DB>,
    L: Changeset<DB>,
    M: Changeset<DB>,
    N: Changeset<DB>,
    O: Changeset<DB>,
    P: Changeset<DB>,
    Q: Changeset<DB>,
    R: Changeset<DB>,
    S: Changeset<DB>,
    T: Changeset<DB>,
    U: Changeset<DB>,
    V: Changeset<DB>,
    W: Changeset<DB>,
    X: Changeset<DB>, 

fn is_noop(&self) -> bool

fn to_sql(&self, out: &mut DB::QueryBuilder) -> BuildQueryResult

fn collect_binds(&self, out: &mut DB::BindCollector) -> QueryResult<()>

impl<DB, 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> Changeset<DB> 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
    DB: Backend,
    A: Changeset<DB>,
    B: Changeset<DB>,
    C: Changeset<DB>,
    D: Changeset<DB>,
    E: Changeset<DB>,
    F: Changeset<DB>,
    G: Changeset<DB>,
    H: Changeset<DB>,
    I: Changeset<DB>,
    J: Changeset<DB>,
    K: Changeset<DB>,
    L: Changeset<DB>,
    M: Changeset<DB>,
    N: Changeset<DB>,
    O: Changeset<DB>,
    P: Changeset<DB>,
    Q: Changeset<DB>,
    R: Changeset<DB>,
    S: Changeset<DB>,
    T: Changeset<DB>,
    U: Changeset<DB>,
    V: Changeset<DB>,
    W: Changeset<DB>,
    X: Changeset<DB>,
    Y: Changeset<DB>, 

fn is_noop(&self) -> bool

fn to_sql(&self, out: &mut DB::QueryBuilder) -> BuildQueryResult

fn collect_binds(&self, out: &mut DB::BindCollector) -> QueryResult<()>

impl<DB, 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> Changeset<DB> 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
    DB: Backend,
    A: Changeset<DB>,
    B: Changeset<DB>,
    C: Changeset<DB>,
    D: Changeset<DB>,
    E: Changeset<DB>,
    F: Changeset<DB>,
    G: Changeset<DB>,
    H: Changeset<DB>,
    I: Changeset<DB>,
    J: Changeset<DB>,
    K: Changeset<DB>,
    L: Changeset<DB>,
    M: Changeset<DB>,
    N: Changeset<DB>,
    O: Changeset<DB>,
    P: Changeset<DB>,
    Q: Changeset<DB>,
    R: Changeset<DB>,
    S: Changeset<DB>,
    T: Changeset<DB>,
    U: Changeset<DB>,
    V: Changeset<DB>,
    W: Changeset<DB>,
    X: Changeset<DB>,
    Y: Changeset<DB>,
    Z: Changeset<DB>, 

fn is_noop(&self) -> bool

fn to_sql(&self, out: &mut DB::QueryBuilder) -> BuildQueryResult

fn collect_binds(&self, out: &mut DB::BindCollector) -> QueryResult<()>

impl<DB, 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> Changeset<DB> 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
    DB: Backend,
    A: Changeset<DB>,
    B: Changeset<DB>,
    C: Changeset<DB>,
    D: Changeset<DB>,
    E: Changeset<DB>,
    F: Changeset<DB>,
    G: Changeset<DB>,
    H: Changeset<DB>,
    I: Changeset<DB>,
    J: Changeset<DB>,
    K: Changeset<DB>,
    L: Changeset<DB>,
    M: Changeset<DB>,
    N: Changeset<DB>,
    O: Changeset<DB>,
    P: Changeset<DB>,
    Q: Changeset<DB>,
    R: Changeset<DB>,
    S: Changeset<DB>,
    T: Changeset<DB>,
    U: Changeset<DB>,
    V: Changeset<DB>,
    W: Changeset<DB>,
    X: Changeset<DB>,
    Y: Changeset<DB>,
    Z: Changeset<DB>,
    AA: Changeset<DB>, 

fn is_noop(&self) -> bool

fn to_sql(&self, out: &mut DB::QueryBuilder) -> BuildQueryResult

fn collect_binds(&self, out: &mut DB::BindCollector) -> QueryResult<()>

impl<DB, 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> Changeset<DB> 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
    DB: Backend,
    A: Changeset<DB>,
    B: Changeset<DB>,
    C: Changeset<DB>,
    D: Changeset<DB>,
    E: Changeset<DB>,
    F: Changeset<DB>,
    G: Changeset<DB>,
    H: Changeset<DB>,
    I: Changeset<DB>,
    J: Changeset<DB>,
    K: Changeset<DB>,
    L: Changeset<DB>,
    M: Changeset<DB>,
    N: Changeset<DB>,
    O: Changeset<DB>,
    P: Changeset<DB>,
    Q: Changeset<DB>,
    R: Changeset<DB>,
    S: Changeset<DB>,
    T: Changeset<DB>,
    U: Changeset<DB>,
    V: Changeset<DB>,
    W: Changeset<DB>,
    X: Changeset<DB>,
    Y: Changeset<DB>,
    Z: Changeset<DB>,
    AA: Changeset<DB>,
    AB: Changeset<DB>, 

fn is_noop(&self) -> bool

fn to_sql(&self, out: &mut DB::QueryBuilder) -> BuildQueryResult

fn collect_binds(&self, out: &mut DB::BindCollector) -> QueryResult<()>

impl<DB, 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> Changeset<DB> 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
    DB: Backend,
    A: Changeset<DB>,
    B: Changeset<DB>,
    C: Changeset<DB>,
    D: Changeset<DB>,
    E: Changeset<DB>,
    F: Changeset<DB>,
    G: Changeset<DB>,
    H: Changeset<DB>,
    I: Changeset<DB>,
    J: Changeset<DB>,
    K: Changeset<DB>,
    L: Changeset<DB>,
    M: Changeset<DB>,
    N: Changeset<DB>,
    O: Changeset<DB>,
    P: Changeset<DB>,
    Q: Changeset<DB>,
    R: Changeset<DB>,
    S: Changeset<DB>,
    T: Changeset<DB>,
    U: Changeset<DB>,
    V: Changeset<DB>,
    W: Changeset<DB>,
    X: Changeset<DB>,
    Y: Changeset<DB>,
    Z: Changeset<DB>,
    AA: Changeset<DB>,
    AB: Changeset<DB>,
    AC: Changeset<DB>, 

fn is_noop(&self) -> bool

fn to_sql(&self, out: &mut DB::QueryBuilder) -> BuildQueryResult

fn collect_binds(&self, out: &mut DB::BindCollector) -> QueryResult<()>

impl<DB, 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> Changeset<DB> 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
    DB: Backend,
    A: Changeset<DB>,
    B: Changeset<DB>,
    C: Changeset<DB>,
    D: Changeset<DB>,
    E: Changeset<DB>,
    F: Changeset<DB>,
    G: Changeset<DB>,
    H: Changeset<DB>,
    I: Changeset<DB>,
    J: Changeset<DB>,
    K: Changeset<DB>,
    L: Changeset<DB>,
    M: Changeset<DB>,
    N: Changeset<DB>,
    O: Changeset<DB>,
    P: Changeset<DB>,
    Q: Changeset<DB>,
    R: Changeset<DB>,
    S: Changeset<DB>,
    T: Changeset<DB>,
    U: Changeset<DB>,
    V: Changeset<DB>,
    W: Changeset<DB>,
    X: Changeset<DB>,
    Y: Changeset<DB>,
    Z: Changeset<DB>,
    AA: Changeset<DB>,
    AB: Changeset<DB>,
    AC: Changeset<DB>,
    AD: Changeset<DB>, 

fn is_noop(&self) -> bool

fn to_sql(&self, out: &mut DB::QueryBuilder) -> BuildQueryResult

fn collect_binds(&self, out: &mut DB::BindCollector) -> QueryResult<()>

impl<DB, 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> Changeset<DB> 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
    DB: Backend,
    A: Changeset<DB>,
    B: Changeset<DB>,
    C: Changeset<DB>,
    D: Changeset<DB>,
    E: Changeset<DB>,
    F: Changeset<DB>,
    G: Changeset<DB>,
    H: Changeset<DB>,
    I: Changeset<DB>,
    J: Changeset<DB>,
    K: Changeset<DB>,
    L: Changeset<DB>,
    M: Changeset<DB>,
    N: Changeset<DB>,
    O: Changeset<DB>,
    P: Changeset<DB>,
    Q: Changeset<DB>,
    R: Changeset<DB>,
    S: Changeset<DB>,
    T: Changeset<DB>,
    U: Changeset<DB>,
    V: Changeset<DB>,
    W: Changeset<DB>,
    X: Changeset<DB>,
    Y: Changeset<DB>,
    Z: Changeset<DB>,
    AA: Changeset<DB>,
    AB: Changeset<DB>,
    AC: Changeset<DB>,
    AD: Changeset<DB>,
    AE: Changeset<DB>, 

fn is_noop(&self) -> bool

fn to_sql(&self, out: &mut DB::QueryBuilder) -> BuildQueryResult

fn collect_binds(&self, out: &mut DB::BindCollector) -> QueryResult<()>

impl<DB, 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> Changeset<DB> 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
    DB: Backend,
    A: Changeset<DB>,
    B: Changeset<DB>,
    C: Changeset<DB>,
    D: Changeset<DB>,
    E: Changeset<DB>,
    F: Changeset<DB>,
    G: Changeset<DB>,
    H: Changeset<DB>,
    I: Changeset<DB>,
    J: Changeset<DB>,
    K: Changeset<DB>,
    L: Changeset<DB>,
    M: Changeset<DB>,
    N: Changeset<DB>,
    O: Changeset<DB>,
    P: Changeset<DB>,
    Q: Changeset<DB>,
    R: Changeset<DB>,
    S: Changeset<DB>,
    T: Changeset<DB>,
    U: Changeset<DB>,
    V: Changeset<DB>,
    W: Changeset<DB>,
    X: Changeset<DB>,
    Y: Changeset<DB>,
    Z: Changeset<DB>,
    AA: Changeset<DB>,
    AB: Changeset<DB>,
    AC: Changeset<DB>,
    AD: Changeset<DB>,
    AE: Changeset<DB>,
    AF: Changeset<DB>, 

fn is_noop(&self) -> bool

fn to_sql(&self, out: &mut DB::QueryBuilder) -> BuildQueryResult

fn collect_binds(&self, out: &mut DB::BindCollector) -> QueryResult<()>

impl<DB, 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, AG> Changeset<DB> 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, AG) where
    DB: Backend,
    A: Changeset<DB>,
    B: Changeset<DB>,
    C: Changeset<DB>,
    D: Changeset<DB>,
    E: Changeset<DB>,
    F: Changeset<DB>,
    G: Changeset<DB>,
    H: Changeset<DB>,
    I: Changeset<DB>,
    J: Changeset<DB>,
    K: Changeset<DB>,
    L: Changeset<DB>,
    M: Changeset<DB>,
    N: Changeset<DB>,
    O: Changeset<DB>,
    P: Changeset<DB>,
    Q: Changeset<DB>,
    R: Changeset<DB>,
    S: Changeset<DB>,
    T: Changeset<DB>,
    U: Changeset<DB>,
    V: Changeset<DB>,
    W: Changeset<DB>,
    X: Changeset<DB>,
    Y: Changeset<DB>,
    Z: Changeset<DB>,
    AA: Changeset<DB>,
    AB: Changeset<DB>,
    AC: Changeset<DB>,
    AD: Changeset<DB>,
    AE: Changeset<DB>,
    AF: Changeset<DB>,
    AG: Changeset<DB>, 

fn is_noop(&self) -> bool

fn to_sql(&self, out: &mut DB::QueryBuilder) -> BuildQueryResult

fn collect_binds(&self, out: &mut DB::BindCollector) -> QueryResult<()>

impl<DB, 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, AG, AH> Changeset<DB> 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, AG, AH) where
    DB: Backend,
    A: Changeset<DB>,
    B: Changeset<DB>,
    C: Changeset<DB>,
    D: Changeset<DB>,
    E: Changeset<DB>,
    F: Changeset<DB>,
    G: Changeset<DB>,
    H: Changeset<DB>,
    I: Changeset<DB>,
    J: Changeset<DB>,
    K: Changeset<DB>,
    L: Changeset<DB>,
    M: Changeset<DB>,
    N: Changeset<DB>,
    O: Changeset<DB>,
    P: Changeset<DB>,
    Q: Changeset<DB>,
    R: Changeset<DB>,
    S: Changeset<DB>,
    T: Changeset<DB>,
    U: Changeset<DB>,
    V: Changeset<DB>,
    W: Changeset<DB>,
    X: Changeset<DB>,
    Y: Changeset<DB>,
    Z: Changeset<DB>,
    AA: Changeset<DB>,
    AB: Changeset<DB>,
    AC: Changeset<DB>,
    AD: Changeset<DB>,
    AE: Changeset<DB>,
    AF: Changeset<DB>,
    AG: Changeset<DB>,
    AH: Changeset<DB>, 

fn is_noop(&self) -> bool

fn to_sql(&self, out: &mut DB::QueryBuilder) -> BuildQueryResult

fn collect_binds(&self, out: &mut DB::BindCollector) -> QueryResult<()>

impl<DB, 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, AG, AH, AI> Changeset<DB> 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, AG, AH, AI) where
    DB: Backend,
    A: Changeset<DB>,
    B: Changeset<DB>,
    C: Changeset<DB>,
    D: Changeset<DB>,
    E: Changeset<DB>,
    F: Changeset<DB>,
    G: Changeset<DB>,
    H: Changeset<DB>,
    I: Changeset<DB>,
    J: Changeset<DB>,
    K: Changeset<DB>,
    L: Changeset<DB>,
    M: Changeset<DB>,
    N: Changeset<DB>,
    O: Changeset<DB>,
    P: Changeset<DB>,
    Q: Changeset<DB>,
    R: Changeset<DB>,
    S: Changeset<DB>,
    T: Changeset<DB>,
    U: Changeset<DB>,
    V: Changeset<DB>,
    W: Changeset<DB>,
    X: Changeset<DB>,
    Y: Changeset<DB>,
    Z: Changeset<DB>,
    AA: Changeset<DB>,
    AB: Changeset<DB>,
    AC: Changeset<DB>,
    AD: Changeset<DB>,
    AE: Changeset<DB>,
    AF: Changeset<DB>,
    AG: Changeset<DB>,
    AH: Changeset<DB>,
    AI: Changeset<DB>, 

fn is_noop(&self) -> bool

fn to_sql(&self, out: &mut DB::QueryBuilder) -> BuildQueryResult

fn collect_binds(&self, out: &mut DB::BindCollector) -> QueryResult<()>

impl<DB, 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, AG, AH, AI, AJ> Changeset<DB> 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, AG, AH, AI, AJ) where
    DB: Backend,
    A: Changeset<DB>,
    B: Changeset<DB>,
    C: Changeset<DB>,
    D: Changeset<DB>,
    E: Changeset<DB>,
    F: Changeset<DB>,
    G: Changeset<DB>,
    H: Changeset<DB>,
    I: Changeset<DB>,
    J: Changeset<DB>,
    K: Changeset<DB>,
    L: Changeset<DB>,
    M: Changeset<DB>,
    N: Changeset<DB>,
    O: Changeset<DB>,
    P: Changeset<DB>,
    Q: Changeset<DB>,
    R: Changeset<DB>,
    S: Changeset<DB>,
    T: Changeset<DB>,
    U: Changeset<DB>,
    V: Changeset<DB>,
    W: Changeset<DB>,
    X: Changeset<DB>,
    Y: Changeset<DB>,
    Z: Changeset<DB>,
    AA: Changeset<DB>,
    AB: Changeset<DB>,
    AC: Changeset<DB>,
    AD: Changeset<DB>,
    AE: Changeset<DB>,
    AF: Changeset<DB>,
    AG: Changeset<DB>,
    AH: Changeset<DB>,
    AI: Changeset<DB>,
    AJ: Changeset<DB>, 

fn is_noop(&self) -> bool

fn to_sql(&self, out: &mut DB::QueryBuilder) -> BuildQueryResult

fn collect_binds(&self, out: &mut DB::BindCollector) -> QueryResult<()>

impl<DB, 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, AG, AH, AI, AJ, AK> Changeset<DB> 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, AG, AH, AI, AJ, AK) where
    DB: Backend,
    A: Changeset<DB>,
    B: Changeset<DB>,
    C: Changeset<DB>,
    D: Changeset<DB>,
    E: Changeset<DB>,
    F: Changeset<DB>,
    G: Changeset<DB>,
    H: Changeset<DB>,
    I: Changeset<DB>,
    J: Changeset<DB>,
    K: Changeset<DB>,
    L: Changeset<DB>,
    M: Changeset<DB>,
    N: Changeset<DB>,
    O: Changeset<DB>,
    P: Changeset<DB>,
    Q: Changeset<DB>,
    R: Changeset<DB>,
    S: Changeset<DB>,
    T: Changeset<DB>,
    U: Changeset<DB>,
    V: Changeset<DB>,
    W: Changeset<DB>,
    X: Changeset<DB>,
    Y: Changeset<DB>,
    Z: Changeset<DB>,
    AA: Changeset<DB>,
    AB: Changeset<DB>,
    AC: Changeset<DB>,
    AD: Changeset<DB>,
    AE: Changeset<DB>,
    AF: Changeset<DB>,
    AG: Changeset<DB>,
    AH: Changeset<DB>,
    AI: Changeset<DB>,
    AJ: Changeset<DB>,
    AK: Changeset<DB>, 

fn is_noop(&self) -> bool

fn to_sql(&self, out: &mut DB::QueryBuilder) -> BuildQueryResult

fn collect_binds(&self, out: &mut DB::BindCollector) -> QueryResult<()>

impl<DB, 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, AG, AH, AI, AJ, AK, AL> Changeset<DB> 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, AG, AH, AI, AJ, AK, AL) where
    DB: Backend,
    A: Changeset<DB>,
    B: Changeset<DB>,
    C: Changeset<DB>,
    D: Changeset<DB>,
    E: Changeset<DB>,
    F: Changeset<DB>,
    G: Changeset<DB>,
    H: Changeset<DB>,
    I: Changeset<DB>,
    J: Changeset<DB>,
    K: Changeset<DB>,
    L: Changeset<DB>,
    M: Changeset<DB>,
    N: Changeset<DB>,
    O: Changeset<DB>,
    P: Changeset<DB>,
    Q: Changeset<DB>,
    R: Changeset<DB>,
    S: Changeset<DB>,
    T: Changeset<DB>,
    U: Changeset<DB>,
    V: Changeset<DB>,
    W: Changeset<DB>,
    X: Changeset<DB>,
    Y: Changeset<DB>,
    Z: Changeset<DB>,
    AA: Changeset<DB>,
    AB: Changeset<DB>,
    AC: Changeset<DB>,
    AD: Changeset<DB>,
    AE: Changeset<DB>,
    AF: Changeset<DB>,
    AG: Changeset<DB>,
    AH: Changeset<DB>,
    AI: Changeset<DB>,
    AJ: Changeset<DB>,
    AK: Changeset<DB>,
    AL: Changeset<DB>, 

fn is_noop(&self) -> bool

fn to_sql(&self, out: &mut DB::QueryBuilder) -> BuildQueryResult

fn collect_binds(&self, out: &mut DB::BindCollector) -> QueryResult<()>

impl<DB, 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, AG, AH, AI, AJ, AK, AL, AM> Changeset<DB> 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, AG, AH, AI, AJ, AK, AL, AM) where
    DB: Backend,
    A: Changeset<DB>,
    B: Changeset<DB>,
    C: Changeset<DB>,
    D: Changeset<DB>,
    E: Changeset<DB>,
    F: Changeset<DB>,
    G: Changeset<DB>,
    H: Changeset<DB>,
    I: Changeset<DB>,
    J: Changeset<DB>,
    K: Changeset<DB>,
    L: Changeset<DB>,
    M: Changeset<DB>,
    N: Changeset<DB>,
    O: Changeset<DB>,
    P: Changeset<DB>,
    Q: Changeset<DB>,
    R: Changeset<DB>,
    S: Changeset<DB>,
    T: Changeset<DB>,
    U: Changeset<DB>,
    V: Changeset<DB>,
    W: Changeset<DB>,
    X: Changeset<DB>,
    Y: Changeset<DB>,
    Z: Changeset<DB>,
    AA: Changeset<DB>,
    AB: Changeset<DB>,
    AC: Changeset<DB>,
    AD: Changeset<DB>,
    AE: Changeset<DB>,
    AF: Changeset<DB>,
    AG: Changeset<DB>,
    AH: Changeset<DB>,
    AI: Changeset<DB>,
    AJ: Changeset<DB>,
    AK: Changeset<DB>,
    AL: Changeset<DB>,
    AM: Changeset<DB>, 

fn is_noop(&self) -> bool

fn to_sql(&self, out: &mut DB::QueryBuilder) -> BuildQueryResult

fn collect_binds(&self, out: &mut DB::BindCollector) -> QueryResult<()>

impl<DB, 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, AG, AH, AI, AJ, AK, AL, AM, AN> Changeset<DB> 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, AG, AH, AI, AJ, AK, AL, AM, AN) where
    DB: Backend,
    A: Changeset<DB>,
    B: Changeset<DB>,
    C: Changeset<DB>,
    D: Changeset<DB>,
    E: Changeset<DB>,
    F: Changeset<DB>,
    G: Changeset<DB>,
    H: Changeset<DB>,
    I: Changeset<DB>,
    J: Changeset<DB>,
    K: Changeset<DB>,
    L: Changeset<DB>,
    M: Changeset<DB>,
    N: Changeset<DB>,
    O: Changeset<DB>,
    P: Changeset<DB>,
    Q: Changeset<DB>,
    R: Changeset<DB>,
    S: Changeset<DB>,
    T: Changeset<DB>,
    U: Changeset<DB>,
    V: Changeset<DB>,
    W: Changeset<DB>,
    X: Changeset<DB>,
    Y: Changeset<DB>,
    Z: Changeset<DB>,
    AA: Changeset<DB>,
    AB: Changeset<DB>,
    AC: Changeset<DB>,
    AD: Changeset<DB>,
    AE: Changeset<DB>,
    AF: Changeset<DB>,
    AG: Changeset<DB>,
    AH: Changeset<DB>,
    AI: Changeset<DB>,
    AJ: Changeset<DB>,
    AK: Changeset<DB>,
    AL: Changeset<DB>,
    AM: Changeset<DB>,
    AN: Changeset<DB>, 

fn is_noop(&self) -> bool

fn to_sql(&self, out: &mut DB::QueryBuilder) -> BuildQueryResult

fn collect_binds(&self, out: &mut DB::BindCollector) -> QueryResult<()>

impl<DB, 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, AG, AH, AI, AJ, AK, AL, AM, AN, AO> Changeset<DB> 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, AG, AH, AI, AJ, AK, AL, AM, AN, AO) where
    DB: Backend,
    A: Changeset<DB>,
    B: Changeset<DB>,
    C: Changeset<DB>,
    D: Changeset<DB>,
    E: Changeset<DB>,
    F: Changeset<DB>,
    G: Changeset<DB>,
    H: Changeset<DB>,
    I: Changeset<DB>,
    J: Changeset<DB>,
    K: Changeset<DB>,
    L: Changeset<DB>,
    M: Changeset<DB>,
    N: Changeset<DB>,
    O: Changeset<DB>,
    P: Changeset<DB>,
    Q: Changeset<DB>,
    R: Changeset<DB>,
    S: Changeset<DB>,
    T: Changeset<DB>,
    U: Changeset<DB>,
    V: Changeset<DB>,
    W: Changeset<DB>,
    X: Changeset<DB>,
    Y: Changeset<DB>,
    Z: Changeset<DB>,
    AA: Changeset<DB>,
    AB: Changeset<DB>,
    AC: Changeset<DB>,
    AD: Changeset<DB>,
    AE: Changeset<DB>,
    AF: Changeset<DB>,
    AG: Changeset<DB>,
    AH: Changeset<DB>,
    AI: Changeset<DB>,
    AJ: Changeset<DB>,
    AK: Changeset<DB>,
    AL: Changeset<DB>,
    AM: Changeset<DB>,
    AN: Changeset<DB>,
    AO: Changeset<DB>, 

fn is_noop(&self) -> bool

fn to_sql(&self, out: &mut DB::QueryBuilder) -> BuildQueryResult

fn collect_binds(&self, out: &mut DB::BindCollector) -> QueryResult<()>

impl<DB, 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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP> Changeset<DB> 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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP) where
    DB: Backend,
    A: Changeset<DB>,
    B: Changeset<DB>,
    C: Changeset<DB>,
    D: Changeset<DB>,
    E: Changeset<DB>,
    F: Changeset<DB>,
    G: Changeset<DB>,
    H: Changeset<DB>,
    I: Changeset<DB>,
    J: Changeset<DB>,
    K: Changeset<DB>,
    L: Changeset<DB>,
    M: Changeset<DB>,
    N: Changeset<DB>,
    O: Changeset<DB>,
    P: Changeset<DB>,
    Q: Changeset<DB>,
    R: Changeset<DB>,
    S: Changeset<DB>,
    T: Changeset<DB>,
    U: Changeset<DB>,
    V: Changeset<DB>,
    W: Changeset<DB>,
    X: Changeset<DB>,
    Y: Changeset<DB>,
    Z: Changeset<DB>,
    AA: Changeset<DB>,
    AB: Changeset<DB>,
    AC: Changeset<DB>,
    AD: Changeset<DB>,
    AE: Changeset<DB>,
    AF: Changeset<DB>,
    AG: Changeset<DB>,
    AH: Changeset<DB>,
    AI: Changeset<DB>,
    AJ: Changeset<DB>,
    AK: Changeset<DB>,
    AL: Changeset<DB>,
    AM: Changeset<DB>,
    AN: Changeset<DB>,
    AO: Changeset<DB>,
    AP: Changeset<DB>, 

fn is_noop(&self) -> bool

fn to_sql(&self, out: &mut DB::QueryBuilder) -> BuildQueryResult

fn collect_binds(&self, out: &mut DB::BindCollector) -> QueryResult<()>

impl<DB, 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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ> Changeset<DB> 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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ) where
    DB: Backend,
    A: Changeset<DB>,
    B: Changeset<DB>,
    C: Changeset<DB>,
    D: Changeset<DB>,
    E: Changeset<DB>,
    F: Changeset<DB>,
    G: Changeset<DB>,
    H: Changeset<DB>,
    I: Changeset<DB>,
    J: Changeset<DB>,
    K: Changeset<DB>,
    L: Changeset<DB>,
    M: Changeset<DB>,
    N: Changeset<DB>,
    O: Changeset<DB>,
    P: Changeset<DB>,
    Q: Changeset<DB>,
    R: Changeset<DB>,
    S: Changeset<DB>,
    T: Changeset<DB>,
    U: Changeset<DB>,
    V: Changeset<DB>,
    W: Changeset<DB>,
    X: Changeset<DB>,
    Y: Changeset<DB>,
    Z: Changeset<DB>,
    AA: Changeset<DB>,
    AB: Changeset<DB>,
    AC: Changeset<DB>,
    AD: Changeset<DB>,
    AE: Changeset<DB>,
    AF: Changeset<DB>,
    AG: Changeset<DB>,
    AH: Changeset<DB>,
    AI: Changeset<DB>,
    AJ: Changeset<DB>,
    AK: Changeset<DB>,
    AL: Changeset<DB>,
    AM: Changeset<DB>,
    AN: Changeset<DB>,
    AO: Changeset<DB>,
    AP: Changeset<DB>,
    AQ: Changeset<DB>, 

fn is_noop(&self) -> bool

fn to_sql(&self, out: &mut DB::QueryBuilder) -> BuildQueryResult

fn collect_binds(&self, out: &mut DB::BindCollector) -> QueryResult<()>

impl<DB, 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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR> Changeset<DB> 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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR) where
    DB: Backend,
    A: Changeset<DB>,
    B: Changeset<DB>,
    C: Changeset<DB>,
    D: Changeset<DB>,
    E: Changeset<DB>,
    F: Changeset<DB>,
    G: Changeset<DB>,
    H: Changeset<DB>,
    I: Changeset<DB>,
    J: Changeset<DB>,
    K: Changeset<DB>,
    L: Changeset<DB>,
    M: Changeset<DB>,
    N: Changeset<DB>,
    O: Changeset<DB>,
    P: Changeset<DB>,
    Q: Changeset<DB>,
    R: Changeset<DB>,
    S: Changeset<DB>,
    T: Changeset<DB>,
    U: Changeset<DB>,
    V: Changeset<DB>,
    W: Changeset<DB>,
    X: Changeset<DB>,
    Y: Changeset<DB>,
    Z: Changeset<DB>,
    AA: Changeset<DB>,
    AB: Changeset<DB>,
    AC: Changeset<DB>,
    AD: Changeset<DB>,
    AE: Changeset<DB>,
    AF: Changeset<DB>,
    AG: Changeset<DB>,
    AH: Changeset<DB>,
    AI: Changeset<DB>,
    AJ: Changeset<DB>,
    AK: Changeset<DB>,
    AL: Changeset<DB>,
    AM: Changeset<DB>,
    AN: Changeset<DB>,
    AO: Changeset<DB>,
    AP: Changeset<DB>,
    AQ: Changeset<DB>,
    AR: Changeset<DB>, 

fn is_noop(&self) -> bool

fn to_sql(&self, out: &mut DB::QueryBuilder) -> BuildQueryResult

fn collect_binds(&self, out: &mut DB::BindCollector) -> QueryResult<()>

impl<DB, 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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS> Changeset<DB> 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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS) where
    DB: Backend,
    A: Changeset<DB>,
    B: Changeset<DB>,
    C: Changeset<DB>,
    D: Changeset<DB>,
    E: Changeset<DB>,
    F: Changeset<DB>,
    G: Changeset<DB>,
    H: Changeset<DB>,
    I: Changeset<DB>,
    J: Changeset<DB>,
    K: Changeset<DB>,
    L: Changeset<DB>,
    M: Changeset<DB>,
    N: Changeset<DB>,
    O: Changeset<DB>,
    P: Changeset<DB>,
    Q: Changeset<DB>,
    R: Changeset<DB>,
    S: Changeset<DB>,
    T: Changeset<DB>,
    U: Changeset<DB>,
    V: Changeset<DB>,
    W: Changeset<DB>,
    X: Changeset<DB>,
    Y: Changeset<DB>,
    Z: Changeset<DB>,
    AA: Changeset<DB>,
    AB: Changeset<DB>,
    AC: Changeset<DB>,
    AD: Changeset<DB>,
    AE: Changeset<DB>,
    AF: Changeset<DB>,
    AG: Changeset<DB>,
    AH: Changeset<DB>,
    AI: Changeset<DB>,
    AJ: Changeset<DB>,
    AK: Changeset<DB>,
    AL: Changeset<DB>,
    AM: Changeset<DB>,
    AN: Changeset<DB>,
    AO: Changeset<DB>,
    AP: Changeset<DB>,
    AQ: Changeset<DB>,
    AR: Changeset<DB>,
    AS: Changeset<DB>, 

fn is_noop(&self) -> bool

fn to_sql(&self, out: &mut DB::QueryBuilder) -> BuildQueryResult

fn collect_binds(&self, out: &mut DB::BindCollector) -> QueryResult<()>

impl<DB, 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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT> Changeset<DB> 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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT) where
    DB: Backend,
    A: Changeset<DB>,
    B: Changeset<DB>,
    C: Changeset<DB>,
    D: Changeset<DB>,
    E: Changeset<DB>,
    F: Changeset<DB>,
    G: Changeset<DB>,
    H: Changeset<DB>,
    I: Changeset<DB>,
    J: Changeset<DB>,
    K: Changeset<DB>,
    L: Changeset<DB>,
    M: Changeset<DB>,
    N: Changeset<DB>,
    O: Changeset<DB>,
    P: Changeset<DB>,
    Q: Changeset<DB>,
    R: Changeset<DB>,
    S: Changeset<DB>,
    T: Changeset<DB>,
    U: Changeset<DB>,
    V: Changeset<DB>,
    W: Changeset<DB>,
    X: Changeset<DB>,
    Y: Changeset<DB>,
    Z: Changeset<DB>,
    AA: Changeset<DB>,
    AB: Changeset<DB>,
    AC: Changeset<DB>,
    AD: Changeset<DB>,
    AE: Changeset<DB>,
    AF: Changeset<DB>,
    AG: Changeset<DB>,
    AH: Changeset<DB>,
    AI: Changeset<DB>,
    AJ: Changeset<DB>,
    AK: Changeset<DB>,
    AL: Changeset<DB>,
    AM: Changeset<DB>,
    AN: Changeset<DB>,
    AO: Changeset<DB>,
    AP: Changeset<DB>,
    AQ: Changeset<DB>,
    AR: Changeset<DB>,
    AS: Changeset<DB>,
    AT: Changeset<DB>, 

fn is_noop(&self) -> bool

fn to_sql(&self, out: &mut DB::QueryBuilder) -> BuildQueryResult

fn collect_binds(&self, out: &mut DB::BindCollector) -> QueryResult<()>

impl<DB, 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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU> Changeset<DB> 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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU) where
    DB: Backend,
    A: Changeset<DB>,
    B: Changeset<DB>,
    C: Changeset<DB>,
    D: Changeset<DB>,
    E: Changeset<DB>,
    F: Changeset<DB>,
    G: Changeset<DB>,
    H: Changeset<DB>,
    I: Changeset<DB>,
    J: Changeset<DB>,
    K: Changeset<DB>,
    L: Changeset<DB>,
    M: Changeset<DB>,
    N: Changeset<DB>,
    O: Changeset<DB>,
    P: Changeset<DB>,
    Q: Changeset<DB>,
    R: Changeset<DB>,
    S: Changeset<DB>,
    T: Changeset<DB>,
    U: Changeset<DB>,
    V: Changeset<DB>,
    W: Changeset<DB>,
    X: Changeset<DB>,
    Y: Changeset<DB>,
    Z: Changeset<DB>,
    AA: Changeset<DB>,
    AB: Changeset<DB>,
    AC: Changeset<DB>,
    AD: Changeset<DB>,
    AE: Changeset<DB>,
    AF: Changeset<DB>,
    AG: Changeset<DB>,
    AH: Changeset<DB>,
    AI: Changeset<DB>,
    AJ: Changeset<DB>,
    AK: Changeset<DB>,
    AL: Changeset<DB>,
    AM: Changeset<DB>,
    AN: Changeset<DB>,
    AO: Changeset<DB>,
    AP: Changeset<DB>,
    AQ: Changeset<DB>,
    AR: Changeset<DB>,
    AS: Changeset<DB>,
    AT: Changeset<DB>,
    AU: Changeset<DB>, 

fn is_noop(&self) -> bool

fn to_sql(&self, out: &mut DB::QueryBuilder) -> BuildQueryResult

fn collect_binds(&self, out: &mut DB::BindCollector) -> QueryResult<()>

impl<DB, 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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV> Changeset<DB> 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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV) where
    DB: Backend,
    A: Changeset<DB>,
    B: Changeset<DB>,
    C: Changeset<DB>,
    D: Changeset<DB>,
    E: Changeset<DB>,
    F: Changeset<DB>,
    G: Changeset<DB>,
    H: Changeset<DB>,
    I: Changeset<DB>,
    J: Changeset<DB>,
    K: Changeset<DB>,
    L: Changeset<DB>,
    M: Changeset<DB>,
    N: Changeset<DB>,
    O: Changeset<DB>,
    P: Changeset<DB>,
    Q: Changeset<DB>,
    R: Changeset<DB>,
    S: Changeset<DB>,
    T: Changeset<DB>,
    U: Changeset<DB>,
    V: Changeset<DB>,
    W: Changeset<DB>,
    X: Changeset<DB>,
    Y: Changeset<DB>,
    Z: Changeset<DB>,
    AA: Changeset<DB>,
    AB: Changeset<DB>,
    AC: Changeset<DB>,
    AD: Changeset<DB>,
    AE: Changeset<DB>,
    AF: Changeset<DB>,
    AG: Changeset<DB>,
    AH: Changeset<DB>,
    AI: Changeset<DB>,
    AJ: Changeset<DB>,
    AK: Changeset<DB>,
    AL: Changeset<DB>,
    AM: Changeset<DB>,
    AN: Changeset<DB>,
    AO: Changeset<DB>,
    AP: Changeset<DB>,
    AQ: Changeset<DB>,
    AR: Changeset<DB>,
    AS: Changeset<DB>,
    AT: Changeset<DB>,
    AU: Changeset<DB>,
    AV: Changeset<DB>, 

fn is_noop(&self) -> bool

fn to_sql(&self, out: &mut DB::QueryBuilder) -> BuildQueryResult

fn collect_binds(&self, out: &mut DB::BindCollector) -> QueryResult<()>

impl<DB, 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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW> Changeset<DB> 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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW) where
    DB: Backend,
    A: Changeset<DB>,
    B: Changeset<DB>,
    C: Changeset<DB>,
    D: Changeset<DB>,
    E: Changeset<DB>,
    F: Changeset<DB>,
    G: Changeset<DB>,
    H: Changeset<DB>,
    I: Changeset<DB>,
    J: Changeset<DB>,
    K: Changeset<DB>,
    L: Changeset<DB>,
    M: Changeset<DB>,
    N: Changeset<DB>,
    O: Changeset<DB>,
    P: Changeset<DB>,
    Q: Changeset<DB>,
    R: Changeset<DB>,
    S: Changeset<DB>,
    T: Changeset<DB>,
    U: Changeset<DB>,
    V: Changeset<DB>,
    W: Changeset<DB>,
    X: Changeset<DB>,
    Y: Changeset<DB>,
    Z: Changeset<DB>,
    AA: Changeset<DB>,
    AB: Changeset<DB>,
    AC: Changeset<DB>,
    AD: Changeset<DB>,
    AE: Changeset<DB>,
    AF: Changeset<DB>,
    AG: Changeset<DB>,
    AH: Changeset<DB>,
    AI: Changeset<DB>,
    AJ: Changeset<DB>,
    AK: Changeset<DB>,
    AL: Changeset<DB>,
    AM: Changeset<DB>,
    AN: Changeset<DB>,
    AO: Changeset<DB>,
    AP: Changeset<DB>,
    AQ: Changeset<DB>,
    AR: Changeset<DB>,
    AS: Changeset<DB>,
    AT: Changeset<DB>,
    AU: Changeset<DB>,
    AV: Changeset<DB>,
    AW: Changeset<DB>, 

fn is_noop(&self) -> bool

fn to_sql(&self, out: &mut DB::QueryBuilder) -> BuildQueryResult

fn collect_binds(&self, out: &mut DB::BindCollector) -> QueryResult<()>

impl<DB, 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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX> Changeset<DB> 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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX) where
    DB: Backend,
    A: Changeset<DB>,
    B: Changeset<DB>,
    C: Changeset<DB>,
    D: Changeset<DB>,
    E: Changeset<DB>,
    F: Changeset<DB>,
    G: Changeset<DB>,
    H: Changeset<DB>,
    I: Changeset<DB>,
    J: Changeset<DB>,
    K: Changeset<DB>,
    L: Changeset<DB>,
    M: Changeset<DB>,
    N: Changeset<DB>,
    O: Changeset<DB>,
    P: Changeset<DB>,
    Q: Changeset<DB>,
    R: Changeset<DB>,
    S: Changeset<DB>,
    T: Changeset<DB>,
    U: Changeset<DB>,
    V: Changeset<DB>,
    W: Changeset<DB>,
    X: Changeset<DB>,
    Y: Changeset<DB>,
    Z: Changeset<DB>,
    AA: Changeset<DB>,
    AB: Changeset<DB>,
    AC: Changeset<DB>,
    AD: Changeset<DB>,
    AE: Changeset<DB>,
    AF: Changeset<DB>,
    AG: Changeset<DB>,
    AH: Changeset<DB>,
    AI: Changeset<DB>,
    AJ: Changeset<DB>,
    AK: Changeset<DB>,
    AL: Changeset<DB>,
    AM: Changeset<DB>,
    AN: Changeset<DB>,
    AO: Changeset<DB>,
    AP: Changeset<DB>,
    AQ: Changeset<DB>,
    AR: Changeset<DB>,
    AS: Changeset<DB>,
    AT: Changeset<DB>,
    AU: Changeset<DB>,
    AV: Changeset<DB>,
    AW: Changeset<DB>,
    AX: Changeset<DB>, 

fn is_noop(&self) -> bool

fn to_sql(&self, out: &mut DB::QueryBuilder) -> BuildQueryResult

fn collect_binds(&self, out: &mut DB::BindCollector) -> QueryResult<()>

impl<DB, 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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY> Changeset<DB> 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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY) where
    DB: Backend,
    A: Changeset<DB>,
    B: Changeset<DB>,
    C: Changeset<DB>,
    D: Changeset<DB>,
    E: Changeset<DB>,
    F: Changeset<DB>,
    G: Changeset<DB>,
    H: Changeset<DB>,
    I: Changeset<DB>,
    J: Changeset<DB>,
    K: Changeset<DB>,
    L: Changeset<DB>,
    M: Changeset<DB>,
    N: Changeset<DB>,
    O: Changeset<DB>,
    P: Changeset<DB>,
    Q: Changeset<DB>,
    R: Changeset<DB>,
    S: Changeset<DB>,
    T: Changeset<DB>,
    U: Changeset<DB>,
    V: Changeset<DB>,
    W: Changeset<DB>,
    X: Changeset<DB>,
    Y: Changeset<DB>,
    Z: Changeset<DB>,
    AA: Changeset<DB>,
    AB: Changeset<DB>,
    AC: Changeset<DB>,
    AD: Changeset<DB>,
    AE: Changeset<DB>,
    AF: Changeset<DB>,
    AG: Changeset<DB>,
    AH: Changeset<DB>,
    AI: Changeset<DB>,
    AJ: Changeset<DB>,
    AK: Changeset<DB>,
    AL: Changeset<DB>,
    AM: Changeset<DB>,
    AN: Changeset<DB>,
    AO: Changeset<DB>,
    AP: Changeset<DB>,
    AQ: Changeset<DB>,
    AR: Changeset<DB>,
    AS: Changeset<DB>,
    AT: Changeset<DB>,
    AU: Changeset<DB>,
    AV: Changeset<DB>,
    AW: Changeset<DB>,
    AX: Changeset<DB>,
    AY: Changeset<DB>, 

fn is_noop(&self) -> bool

fn to_sql(&self, out: &mut DB::QueryBuilder) -> BuildQueryResult

fn collect_binds(&self, out: &mut DB::BindCollector) -> QueryResult<()>

impl<DB, 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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ> Changeset<DB> 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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ) where
    DB: Backend,
    A: Changeset<DB>,
    B: Changeset<DB>,
    C: Changeset<DB>,
    D: Changeset<DB>,
    E: Changeset<DB>,
    F: Changeset<DB>,
    G: Changeset<DB>,
    H: Changeset<DB>,
    I: Changeset<DB>,
    J: Changeset<DB>,
    K: Changeset<DB>,
    L: Changeset<DB>,
    M: Changeset<DB>,
    N: Changeset<DB>,
    O: Changeset<DB>,
    P: Changeset<DB>,
    Q: Changeset<DB>,
    R: Changeset<DB>,
    S: Changeset<DB>,
    T: Changeset<DB>,
    U: Changeset<DB>,
    V: Changeset<DB>,
    W: Changeset<DB>,
    X: Changeset<DB>,
    Y: Changeset<DB>,
    Z: Changeset<DB>,
    AA: Changeset<DB>,
    AB: Changeset<DB>,
    AC: Changeset<DB>,
    AD: Changeset<DB>,
    AE: Changeset<DB>,
    AF: Changeset<DB>,
    AG: Changeset<DB>,
    AH: Changeset<DB>,
    AI: Changeset<DB>,
    AJ: Changeset<DB>,
    AK: Changeset<DB>,
    AL: Changeset<DB>,
    AM: Changeset<DB>,
    AN: Changeset<DB>,
    AO: Changeset<DB>,
    AP: Changeset<DB>,
    AQ: Changeset<DB>,
    AR: Changeset<DB>,
    AS: Changeset<DB>,
    AT: Changeset<DB>,
    AU: Changeset<DB>,
    AV: Changeset<DB>,
    AW: Changeset<DB>,
    AX: Changeset<DB>,
    AY: Changeset<DB>,
    AZ: Changeset<DB>, 

fn is_noop(&self) -> bool

fn to_sql(&self, out: &mut DB::QueryBuilder) -> BuildQueryResult

fn collect_binds(&self, out: &mut DB::BindCollector) -> QueryResult<()>

Implementors