[][src]Trait diesel::sql_types::IntoNullable

pub trait IntoNullable {
    type Nullable;
}

Converts a type which may or may not be nullable into its nullable representation.

Associated Types

type Nullable

The nullable representation of this type.

For all types except Nullable, this will be Nullable<Self>.

Loading content...

Implementations on Foreign Types

impl<A: SqlType> IntoNullable for (A,) where
    Self: SqlType
[src]

type Nullable = Nullable<(A,)>

impl<A: SqlType, B: SqlType> IntoNullable for (A, B) where
    Self: SqlType
[src]

type Nullable = Nullable<(A, B)>

impl<A: SqlType, B: SqlType, C: SqlType> IntoNullable for (A, B, C) where
    Self: SqlType
[src]

type Nullable = Nullable<(A, B, C)>

impl<A: SqlType, B: SqlType, C: SqlType, D: SqlType> IntoNullable for (A, B, C, D) where
    Self: SqlType
[src]

type Nullable = Nullable<(A, B, C, D)>

impl<A: SqlType, B: SqlType, C: SqlType, D: SqlType, E: SqlType> IntoNullable for (A, B, C, D, E) where
    Self: SqlType
[src]

type Nullable = Nullable<(A, B, C, D, E)>

impl<A: SqlType, B: SqlType, C: SqlType, D: SqlType, E: SqlType, F: SqlType> IntoNullable for (A, B, C, D, E, F) where
    Self: SqlType
[src]

type Nullable = Nullable<(A, B, C, D, E, F)>

impl<A: SqlType, B: SqlType, C: SqlType, D: SqlType, E: SqlType, F: SqlType, G: SqlType> IntoNullable for (A, B, C, D, E, F, G) where
    Self: SqlType
[src]

type Nullable = Nullable<(A, B, C, D, E, F, G)>

impl<A: SqlType, B: SqlType, C: SqlType, D: SqlType, E: SqlType, F: SqlType, G: SqlType, H: SqlType> IntoNullable for (A, B, C, D, E, F, G, H) where
    Self: SqlType
[src]

type Nullable = Nullable<(A, B, C, D, E, F, G, H)>

impl<A: SqlType, B: SqlType, C: SqlType, D: SqlType, E: SqlType, F: SqlType, G: SqlType, H: SqlType, I: SqlType> IntoNullable for (A, B, C, D, E, F, G, H, I) where
    Self: SqlType
[src]

type Nullable = Nullable<(A, B, C, D, E, F, G, H, I)>

impl<A: SqlType, B: SqlType, C: SqlType, D: SqlType, E: SqlType, F: SqlType, G: SqlType, H: SqlType, I: SqlType, J: SqlType> IntoNullable for (A, B, C, D, E, F, G, H, I, J) where
    Self: SqlType
[src]

type Nullable = Nullable<(A, B, C, D, E, F, G, H, I, J)>

impl<A: SqlType, B: SqlType, C: SqlType, D: SqlType, E: SqlType, F: SqlType, G: SqlType, H: SqlType, I: SqlType, J: SqlType, K: SqlType> IntoNullable for (A, B, C, D, E, F, G, H, I, J, K) where
    Self: SqlType
[src]

type Nullable = Nullable<(A, B, C, D, E, F, G, H, I, J, K)>

impl<A: SqlType, B: SqlType, C: SqlType, D: SqlType, E: SqlType, F: SqlType, G: SqlType, H: SqlType, I: SqlType, J: SqlType, K: SqlType, L: SqlType> IntoNullable for (A, B, C, D, E, F, G, H, I, J, K, L) where
    Self: SqlType
[src]

type Nullable = Nullable<(A, B, C, D, E, F, G, H, I, J, K, L)>

impl<A: SqlType, B: SqlType, C: SqlType, D: SqlType, E: SqlType, F: SqlType, G: SqlType, H: SqlType, I: SqlType, J: SqlType, K: SqlType, L: SqlType, M: SqlType> IntoNullable for (A, B, C, D, E, F, G, H, I, J, K, L, M) where
    Self: SqlType
[src]

type Nullable = Nullable<(A, B, C, D, E, F, G, H, I, J, K, L, M)>

impl<A: SqlType, B: SqlType, C: SqlType, D: SqlType, E: SqlType, F: SqlType, G: SqlType, H: SqlType, I: SqlType, J: SqlType, K: SqlType, L: SqlType, M: SqlType, N: SqlType> IntoNullable for (A, B, C, D, E, F, G, H, I, J, K, L, M, N) where
    Self: SqlType
[src]

type Nullable = Nullable<(A, B, C, D, E, F, G, H, I, J, K, L, M, N)>

impl<A: SqlType, B: SqlType, C: SqlType, D: SqlType, E: SqlType, F: SqlType, G: SqlType, H: SqlType, I: SqlType, J: SqlType, K: SqlType, L: SqlType, M: SqlType, N: SqlType, O: SqlType> IntoNullable for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) where
    Self: SqlType
[src]

type Nullable = Nullable<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)>

impl<A: SqlType, B: SqlType, C: SqlType, D: SqlType, E: SqlType, F: SqlType, G: SqlType, H: SqlType, I: SqlType, J: SqlType, K: SqlType, L: SqlType, M: SqlType, N: SqlType, O: SqlType, P: SqlType> IntoNullable for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) where
    Self: SqlType
[src]

type Nullable = Nullable<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)>

impl<A: SqlType, B: SqlType, C: SqlType, D: SqlType, E: SqlType, F: SqlType, G: SqlType, H: SqlType, I: SqlType, J: SqlType, K: SqlType, L: SqlType, M: SqlType, N: SqlType, O: SqlType, P: SqlType, Q: SqlType> IntoNullable for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) where
    Self: SqlType
[src]

type Nullable = Nullable<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)>

impl<A: SqlType, B: SqlType, C: SqlType, D: SqlType, E: SqlType, F: SqlType, G: SqlType, H: SqlType, I: SqlType, J: SqlType, K: SqlType, L: SqlType, M: SqlType, N: SqlType, O: SqlType, P: SqlType, Q: SqlType, R: SqlType> IntoNullable for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) where
    Self: SqlType
[src]

type Nullable = Nullable<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)>

impl<A: SqlType, B: SqlType, C: SqlType, D: SqlType, E: SqlType, F: SqlType, G: SqlType, H: SqlType, I: SqlType, J: SqlType, K: SqlType, L: SqlType, M: SqlType, N: SqlType, O: SqlType, P: SqlType, Q: SqlType, R: SqlType, S: SqlType> IntoNullable for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) where
    Self: SqlType
[src]

type Nullable = Nullable<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)>

impl<A: SqlType, B: SqlType, C: SqlType, D: SqlType, E: SqlType, F: SqlType, G: SqlType, H: SqlType, I: SqlType, J: SqlType, K: SqlType, L: SqlType, M: SqlType, N: SqlType, O: SqlType, P: SqlType, Q: SqlType, R: SqlType, S: SqlType, T: SqlType> IntoNullable for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) where
    Self: SqlType
[src]

type Nullable = Nullable<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)>

impl<A: SqlType, B: SqlType, C: SqlType, D: SqlType, E: SqlType, F: SqlType, G: SqlType, H: SqlType, I: SqlType, J: SqlType, K: SqlType, L: SqlType, M: SqlType, N: SqlType, O: SqlType, P: SqlType, Q: SqlType, R: SqlType, S: SqlType, T: SqlType, U: SqlType> IntoNullable for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) where
    Self: SqlType
[src]

type Nullable = Nullable<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)>

impl<A: SqlType, B: SqlType, C: SqlType, D: SqlType, E: SqlType, F: SqlType, G: SqlType, H: SqlType, I: SqlType, J: SqlType, K: SqlType, L: SqlType, M: SqlType, N: SqlType, O: SqlType, P: SqlType, Q: SqlType, R: SqlType, S: SqlType, T: SqlType, U: SqlType, V: SqlType> IntoNullable for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) where
    Self: SqlType
[src]

type Nullable = Nullable<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)>

impl<A: SqlType, B: SqlType, C: SqlType, D: SqlType, E: SqlType, F: SqlType, G: SqlType, H: SqlType, I: SqlType, J: SqlType, K: SqlType, L: SqlType, M: SqlType, N: SqlType, O: SqlType, P: SqlType, Q: SqlType, R: SqlType, S: SqlType, T: SqlType, U: SqlType, V: SqlType, W: SqlType> IntoNullable 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
    Self: SqlType
[src]

type Nullable = Nullable<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)>

impl<A: SqlType, B: SqlType, C: SqlType, D: SqlType, E: SqlType, F: SqlType, G: SqlType, H: SqlType, I: SqlType, J: SqlType, K: SqlType, L: SqlType, M: SqlType, N: SqlType, O: SqlType, P: SqlType, Q: SqlType, R: SqlType, S: SqlType, T: SqlType, U: SqlType, V: SqlType, W: SqlType, X: SqlType> IntoNullable 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
    Self: SqlType
[src]

type Nullable = Nullable<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)>

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

type Nullable = Nullable<(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)>

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

type Nullable = Nullable<(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)>

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

type Nullable = Nullable<(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)>

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

type Nullable = Nullable<(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)>

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

type Nullable = Nullable<(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)>

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

type Nullable = Nullable<(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)>

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

type Nullable = Nullable<(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)>

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

type Nullable = Nullable<(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)>

Loading content...

Implementors

impl<T> IntoNullable for Nullable<T> where
    T: SqlType
[src]

type Nullable = Self

impl<T> IntoNullable for T where
    T: SqlType<IsNull = NotNull> + SingleValue
[src]

type Nullable = Nullable<T>

Loading content...