Trait Mod 

pub trait Mod<Q> {
    // Required method
    fn apply(self, q: &mut Q);
}

Something that modifies a query in place.

Mods are the whole composition story: psql::select((a, b, c)) is one mod made of three, applied left to right. The query type is the type parameter, so a mod for a statement that has no such clause simply does not implement Mod<ThatQuery> and the invalid combination fails to compile.

apply consumes self, so a mod can hand owned data straight to the query without cloning.

Required Methods

fn apply(self, q: &mut Q)

Apply this modification to q.

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

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

where A: Mod<Q>, B: Mod<Q>, C: Mod<Q>, D: Mod<Q>, E: Mod<Q>, F: Mod<Q>, G: Mod<Q>, H: Mod<Q>, I: Mod<Q>, J: Mod<Q>, K: Mod<Q>, L: Mod<Q>, M: Mod<Q>, N: Mod<Q>, O: Mod<Q>, P: Mod<Q>,

fn apply(self, q: &mut Q)

impl<Q, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> Mod<Q> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)

where A: Mod<Q>, B: Mod<Q>, C: Mod<Q>, D: Mod<Q>, E: Mod<Q>, F: Mod<Q>, G: Mod<Q>, H: Mod<Q>, I: Mod<Q>, J: Mod<Q>, K: Mod<Q>, L: Mod<Q>, M: Mod<Q>, N: Mod<Q>, O: Mod<Q>,

fn apply(self, q: &mut Q)

impl<Q, A, B, C, D, E, F, G, H, I, J, K, L, M, N> Mod<Q> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N)

where A: Mod<Q>, B: Mod<Q>, C: Mod<Q>, D: Mod<Q>, E: Mod<Q>, F: Mod<Q>, G: Mod<Q>, H: Mod<Q>, I: Mod<Q>, J: Mod<Q>, K: Mod<Q>, L: Mod<Q>, M: Mod<Q>, N: Mod<Q>,

fn apply(self, q: &mut Q)

impl<Q, A, B, C, D, E, F, G, H, I, J, K, L, M> Mod<Q> for (A, B, C, D, E, F, G, H, I, J, K, L, M)

where A: Mod<Q>, B: Mod<Q>, C: Mod<Q>, D: Mod<Q>, E: Mod<Q>, F: Mod<Q>, G: Mod<Q>, H: Mod<Q>, I: Mod<Q>, J: Mod<Q>, K: Mod<Q>, L: Mod<Q>, M: Mod<Q>,

fn apply(self, q: &mut Q)

impl<Q, A, B, C, D, E, F, G, H, I, J, K, L> Mod<Q> for (A, B, C, D, E, F, G, H, I, J, K, L)

where A: Mod<Q>, B: Mod<Q>, C: Mod<Q>, D: Mod<Q>, E: Mod<Q>, F: Mod<Q>, G: Mod<Q>, H: Mod<Q>, I: Mod<Q>, J: Mod<Q>, K: Mod<Q>, L: Mod<Q>,

fn apply(self, q: &mut Q)

impl<Q, A, B, C, D, E, F, G, H, I, J, K> Mod<Q> for (A, B, C, D, E, F, G, H, I, J, K)

where A: Mod<Q>, B: Mod<Q>, C: Mod<Q>, D: Mod<Q>, E: Mod<Q>, F: Mod<Q>, G: Mod<Q>, H: Mod<Q>, I: Mod<Q>, J: Mod<Q>, K: Mod<Q>,

fn apply(self, q: &mut Q)

impl<Q, A, B, C, D, E, F, G, H, I, J> Mod<Q> for (A, B, C, D, E, F, G, H, I, J)

where A: Mod<Q>, B: Mod<Q>, C: Mod<Q>, D: Mod<Q>, E: Mod<Q>, F: Mod<Q>, G: Mod<Q>, H: Mod<Q>, I: Mod<Q>, J: Mod<Q>,

fn apply(self, q: &mut Q)

impl<Q, A, B, C, D, E, F, G, H, I> Mod<Q> for (A, B, C, D, E, F, G, H, I)

where A: Mod<Q>, B: Mod<Q>, C: Mod<Q>, D: Mod<Q>, E: Mod<Q>, F: Mod<Q>, G: Mod<Q>, H: Mod<Q>, I: Mod<Q>,

fn apply(self, q: &mut Q)

impl<Q, A, B, C, D, E, F, G, H> Mod<Q> for (A, B, C, D, E, F, G, H)

where A: Mod<Q>, B: Mod<Q>, C: Mod<Q>, D: Mod<Q>, E: Mod<Q>, F: Mod<Q>, G: Mod<Q>, H: Mod<Q>,

fn apply(self, q: &mut Q)

impl<Q, A, B, C, D, E, F, G> Mod<Q> for (A, B, C, D, E, F, G)

where A: Mod<Q>, B: Mod<Q>, C: Mod<Q>, D: Mod<Q>, E: Mod<Q>, F: Mod<Q>, G: Mod<Q>,

fn apply(self, q: &mut Q)

impl<Q, A, B, C, D, E, F> Mod<Q> for (A, B, C, D, E, F)

where A: Mod<Q>, B: Mod<Q>, C: Mod<Q>, D: Mod<Q>, E: Mod<Q>, F: Mod<Q>,

fn apply(self, q: &mut Q)

impl<Q, A, B, C, D, E> Mod<Q> for (A, B, C, D, E)

where A: Mod<Q>, B: Mod<Q>, C: Mod<Q>, D: Mod<Q>, E: Mod<Q>,

fn apply(self, q: &mut Q)

impl<Q, A, B, C, D> Mod<Q> for (A, B, C, D)

where A: Mod<Q>, B: Mod<Q>, C: Mod<Q>, D: Mod<Q>,

fn apply(self, q: &mut Q)

impl<Q, A, B, C> Mod<Q> for (A, B, C)

where A: Mod<Q>, B: Mod<Q>, C: Mod<Q>,

fn apply(self, q: &mut Q)

impl<Q, A, B> Mod<Q> for (A, B)

where A: Mod<Q>, B: Mod<Q>,

fn apply(self, q: &mut Q)

impl<Q, A> Mod<Q> for (A,)

where A: Mod<Q>,

fn apply(self, q: &mut Q)

impl<Q, M, const N: usize> Mod<Q> for [M; N]

where M: Mod<Q>,

fn apply(self, q: &mut Q)

impl<Q, M> Mod<Q> for Option<M>

where M: Mod<Q>,

None applies nothing, which is how a conditional mod is written: cond.then(|| select::where_(..)). No if statement, no Vec juggling.

fn apply(self, q: &mut Q)

impl<Q, M> Mod<Q> for Vec<M>

where M: Mod<Q>,

fn apply(self, q: &mut Q)

impl<Q> Mod<Q> for ()

No mods at all — psql::select(()).

fn apply(self, _q: &mut Q)

Implementors

impl<Q, F> Mod<Q> for ModFn<F>

where F: FnOnce(&mut Q),

impl<Q, S: TableSlot<Q>> Mod<Q> for TableChain<S>

impl<Q: HasJoins> Mod<Q> for JoinChain

impl<Q: HasOrderBy> Mod<Q> for OrderChain

impl<Q: HasTableRef> Mod<Q> for IntoChain

impl<Q: HasUpserts> Mod<Q> for ConflictMod

impl<Q: HasWith> Mod<Q> for CteChain