Trait diesel::associations::BelongsTo

pub trait BelongsTo<Parent: Identifiable> {
    type ForeignKeyColumn: Column;
    fn foreign_key(&self) -> Option<&Parent::Id>;
    fn foreign_key_column() -> Self::ForeignKeyColumn;
}

Associated Types

type ForeignKeyColumn: Column

Required Methods

fn foreign_key(&self) -> Option<&Parent::Id>

fn foreign_key_column() -> Self::ForeignKeyColumn

Implementations on Foreign Types

impl<A, Parent> BelongsTo<Parent> for (A,) where
    A: BelongsTo<Parent>,
    Parent: Identifiable, 

type ForeignKeyColumn = A::ForeignKeyColumn

fn foreign_key(&self) -> Option<&Parent::Id>

fn foreign_key_column() -> Self::ForeignKeyColumn

impl<A, B, Parent> BelongsTo<Parent> for (A, B) where
    A: BelongsTo<Parent>,
    Parent: Identifiable, 

type ForeignKeyColumn = A::ForeignKeyColumn

fn foreign_key(&self) -> Option<&Parent::Id>

fn foreign_key_column() -> Self::ForeignKeyColumn

impl<A, B, C, Parent> BelongsTo<Parent> for (A, B, C) where
    A: BelongsTo<Parent>,
    Parent: Identifiable, 

type ForeignKeyColumn = A::ForeignKeyColumn

fn foreign_key(&self) -> Option<&Parent::Id>

fn foreign_key_column() -> Self::ForeignKeyColumn

impl<A, B, C, D, Parent> BelongsTo<Parent> for (A, B, C, D) where
    A: BelongsTo<Parent>,
    Parent: Identifiable, 

type ForeignKeyColumn = A::ForeignKeyColumn

fn foreign_key(&self) -> Option<&Parent::Id>

fn foreign_key_column() -> Self::ForeignKeyColumn

impl<A, B, C, D, E, Parent> BelongsTo<Parent> for (A, B, C, D, E) where
    A: BelongsTo<Parent>,
    Parent: Identifiable, 

type ForeignKeyColumn = A::ForeignKeyColumn

fn foreign_key(&self) -> Option<&Parent::Id>

fn foreign_key_column() -> Self::ForeignKeyColumn

impl<A, B, C, D, E, F, Parent> BelongsTo<Parent> for (A, B, C, D, E, F) where
    A: BelongsTo<Parent>,
    Parent: Identifiable, 

type ForeignKeyColumn = A::ForeignKeyColumn

fn foreign_key(&self) -> Option<&Parent::Id>

fn foreign_key_column() -> Self::ForeignKeyColumn

impl<A, B, C, D, E, F, G, Parent> BelongsTo<Parent> for (A, B, C, D, E, F, G) where
    A: BelongsTo<Parent>,
    Parent: Identifiable, 

type ForeignKeyColumn = A::ForeignKeyColumn

fn foreign_key(&self) -> Option<&Parent::Id>

fn foreign_key_column() -> Self::ForeignKeyColumn

impl<A, B, C, D, E, F, G, H, Parent> BelongsTo<Parent> for (A, B, C, D, E, F, G, H) where
    A: BelongsTo<Parent>,
    Parent: Identifiable, 

type ForeignKeyColumn = A::ForeignKeyColumn

fn foreign_key(&self) -> Option<&Parent::Id>

fn foreign_key_column() -> Self::ForeignKeyColumn

impl<A, B, C, D, E, F, G, H, I, Parent> BelongsTo<Parent> for (A, B, C, D, E, F, G, H, I) where
    A: BelongsTo<Parent>,
    Parent: Identifiable, 

type ForeignKeyColumn = A::ForeignKeyColumn

fn foreign_key(&self) -> Option<&Parent::Id>

fn foreign_key_column() -> Self::ForeignKeyColumn

impl<A, B, C, D, E, F, G, H, I, J, Parent> BelongsTo<Parent> for (A, B, C, D, E, F, G, H, I, J) where
    A: BelongsTo<Parent>,
    Parent: Identifiable, 

type ForeignKeyColumn = A::ForeignKeyColumn

fn foreign_key(&self) -> Option<&Parent::Id>

fn foreign_key_column() -> Self::ForeignKeyColumn

impl<A, B, C, D, E, F, G, H, I, J, K, Parent> BelongsTo<Parent> for (A, B, C, D, E, F, G, H, I, J, K) where
    A: BelongsTo<Parent>,
    Parent: Identifiable, 

type ForeignKeyColumn = A::ForeignKeyColumn

fn foreign_key(&self) -> Option<&Parent::Id>

fn foreign_key_column() -> Self::ForeignKeyColumn

impl<A, B, C, D, E, F, G, H, I, J, K, L, Parent> BelongsTo<Parent> for (A, B, C, D, E, F, G, H, I, J, K, L) where
    A: BelongsTo<Parent>,
    Parent: Identifiable, 

type ForeignKeyColumn = A::ForeignKeyColumn

fn foreign_key(&self) -> Option<&Parent::Id>

fn foreign_key_column() -> Self::ForeignKeyColumn

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, Parent> BelongsTo<Parent> for (A, B, C, D, E, F, G, H, I, J, K, L, M) where
    A: BelongsTo<Parent>,
    Parent: Identifiable, 

type ForeignKeyColumn = A::ForeignKeyColumn

fn foreign_key(&self) -> Option<&Parent::Id>

fn foreign_key_column() -> Self::ForeignKeyColumn

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, Parent> BelongsTo<Parent> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N) where
    A: BelongsTo<Parent>,
    Parent: Identifiable, 

type ForeignKeyColumn = A::ForeignKeyColumn

fn foreign_key(&self) -> Option<&Parent::Id>

fn foreign_key_column() -> Self::ForeignKeyColumn

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

type ForeignKeyColumn = A::ForeignKeyColumn

fn foreign_key(&self) -> Option<&Parent::Id>

fn foreign_key_column() -> Self::ForeignKeyColumn

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

type ForeignKeyColumn = A::ForeignKeyColumn

fn foreign_key(&self) -> Option<&Parent::Id>

fn foreign_key_column() -> Self::ForeignKeyColumn

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

type ForeignKeyColumn = A::ForeignKeyColumn

fn foreign_key(&self) -> Option<&Parent::Id>

fn foreign_key_column() -> Self::ForeignKeyColumn

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

type ForeignKeyColumn = A::ForeignKeyColumn

fn foreign_key(&self) -> Option<&Parent::Id>

fn foreign_key_column() -> Self::ForeignKeyColumn

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

type ForeignKeyColumn = A::ForeignKeyColumn

fn foreign_key(&self) -> Option<&Parent::Id>

fn foreign_key_column() -> Self::ForeignKeyColumn

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

type ForeignKeyColumn = A::ForeignKeyColumn

fn foreign_key(&self) -> Option<&Parent::Id>

fn foreign_key_column() -> Self::ForeignKeyColumn

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

type ForeignKeyColumn = A::ForeignKeyColumn

fn foreign_key(&self) -> Option<&Parent::Id>

fn foreign_key_column() -> Self::ForeignKeyColumn

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

type ForeignKeyColumn = A::ForeignKeyColumn

fn foreign_key(&self) -> Option<&Parent::Id>

fn foreign_key_column() -> Self::ForeignKeyColumn

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

type ForeignKeyColumn = A::ForeignKeyColumn

fn foreign_key(&self) -> Option<&Parent::Id>

fn foreign_key_column() -> Self::ForeignKeyColumn

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, Parent> BelongsTo<Parent> 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
    A: BelongsTo<Parent>,
    Parent: Identifiable, 

type ForeignKeyColumn = A::ForeignKeyColumn

fn foreign_key(&self) -> Option<&Parent::Id>

fn foreign_key_column() -> Self::ForeignKeyColumn

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, Parent> BelongsTo<Parent> 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
    A: BelongsTo<Parent>,
    Parent: Identifiable, 

type ForeignKeyColumn = A::ForeignKeyColumn

fn foreign_key(&self) -> Option<&Parent::Id>

fn foreign_key_column() -> Self::ForeignKeyColumn

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, Parent> BelongsTo<Parent> 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
    A: BelongsTo<Parent>,
    Parent: Identifiable, 

type ForeignKeyColumn = A::ForeignKeyColumn

fn foreign_key(&self) -> Option<&Parent::Id>

fn foreign_key_column() -> Self::ForeignKeyColumn

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, Parent> BelongsTo<Parent> 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
    A: BelongsTo<Parent>,
    Parent: Identifiable, 

type ForeignKeyColumn = A::ForeignKeyColumn

fn foreign_key(&self) -> Option<&Parent::Id>

fn foreign_key_column() -> Self::ForeignKeyColumn

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, Parent> BelongsTo<Parent> 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
    A: BelongsTo<Parent>,
    Parent: Identifiable, 

type ForeignKeyColumn = A::ForeignKeyColumn

fn foreign_key(&self) -> Option<&Parent::Id>

fn foreign_key_column() -> Self::ForeignKeyColumn

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, Parent> BelongsTo<Parent> 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
    A: BelongsTo<Parent>,
    Parent: Identifiable, 

type ForeignKeyColumn = A::ForeignKeyColumn

fn foreign_key(&self) -> Option<&Parent::Id>

fn foreign_key_column() -> Self::ForeignKeyColumn

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, Parent> BelongsTo<Parent> 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
    A: BelongsTo<Parent>,
    Parent: Identifiable, 

type ForeignKeyColumn = A::ForeignKeyColumn

fn foreign_key(&self) -> Option<&Parent::Id>

fn foreign_key_column() -> Self::ForeignKeyColumn

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, Parent> BelongsTo<Parent> 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
    A: BelongsTo<Parent>,
    Parent: Identifiable, 

type ForeignKeyColumn = A::ForeignKeyColumn

fn foreign_key(&self) -> Option<&Parent::Id>

fn foreign_key_column() -> Self::ForeignKeyColumn

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, Parent> BelongsTo<Parent> 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
    A: BelongsTo<Parent>,
    Parent: Identifiable, 

type ForeignKeyColumn = A::ForeignKeyColumn

fn foreign_key(&self) -> Option<&Parent::Id>

fn foreign_key_column() -> Self::ForeignKeyColumn

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, AG, Parent> BelongsTo<Parent> 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
    A: BelongsTo<Parent>,
    Parent: Identifiable, 

type ForeignKeyColumn = A::ForeignKeyColumn

fn foreign_key(&self) -> Option<&Parent::Id>

fn foreign_key_column() -> Self::ForeignKeyColumn

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, AG, AH, Parent> BelongsTo<Parent> 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
    A: BelongsTo<Parent>,
    Parent: Identifiable, 

type ForeignKeyColumn = A::ForeignKeyColumn

fn foreign_key(&self) -> Option<&Parent::Id>

fn foreign_key_column() -> Self::ForeignKeyColumn

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, AG, AH, AI, Parent> BelongsTo<Parent> 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
    A: BelongsTo<Parent>,
    Parent: Identifiable, 

type ForeignKeyColumn = A::ForeignKeyColumn

fn foreign_key(&self) -> Option<&Parent::Id>

fn foreign_key_column() -> Self::ForeignKeyColumn

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, AG, AH, AI, AJ, Parent> BelongsTo<Parent> 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
    A: BelongsTo<Parent>,
    Parent: Identifiable, 

type ForeignKeyColumn = A::ForeignKeyColumn

fn foreign_key(&self) -> Option<&Parent::Id>

fn foreign_key_column() -> Self::ForeignKeyColumn

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, AG, AH, AI, AJ, AK, Parent> BelongsTo<Parent> 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
    A: BelongsTo<Parent>,
    Parent: Identifiable, 

type ForeignKeyColumn = A::ForeignKeyColumn

fn foreign_key(&self) -> Option<&Parent::Id>

fn foreign_key_column() -> Self::ForeignKeyColumn

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, AG, AH, AI, AJ, AK, AL, Parent> BelongsTo<Parent> 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
    A: BelongsTo<Parent>,
    Parent: Identifiable, 

type ForeignKeyColumn = A::ForeignKeyColumn

fn foreign_key(&self) -> Option<&Parent::Id>

fn foreign_key_column() -> Self::ForeignKeyColumn

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, AG, AH, AI, AJ, AK, AL, AM, Parent> BelongsTo<Parent> 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
    A: BelongsTo<Parent>,
    Parent: Identifiable, 

type ForeignKeyColumn = A::ForeignKeyColumn

fn foreign_key(&self) -> Option<&Parent::Id>

fn foreign_key_column() -> Self::ForeignKeyColumn

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, AG, AH, AI, AJ, AK, AL, AM, AN, Parent> BelongsTo<Parent> 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
    A: BelongsTo<Parent>,
    Parent: Identifiable, 

type ForeignKeyColumn = A::ForeignKeyColumn

fn foreign_key(&self) -> Option<&Parent::Id>

fn foreign_key_column() -> Self::ForeignKeyColumn

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, Parent> BelongsTo<Parent> 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
    A: BelongsTo<Parent>,
    Parent: Identifiable, 

type ForeignKeyColumn = A::ForeignKeyColumn

fn foreign_key(&self) -> Option<&Parent::Id>

fn foreign_key_column() -> Self::ForeignKeyColumn

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, Parent> BelongsTo<Parent> 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
    A: BelongsTo<Parent>,
    Parent: Identifiable, 

type ForeignKeyColumn = A::ForeignKeyColumn

fn foreign_key(&self) -> Option<&Parent::Id>

fn foreign_key_column() -> Self::ForeignKeyColumn

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, Parent> BelongsTo<Parent> 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
    A: BelongsTo<Parent>,
    Parent: Identifiable, 

type ForeignKeyColumn = A::ForeignKeyColumn

fn foreign_key(&self) -> Option<&Parent::Id>

fn foreign_key_column() -> Self::ForeignKeyColumn

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, Parent> BelongsTo<Parent> 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
    A: BelongsTo<Parent>,
    Parent: Identifiable, 

type ForeignKeyColumn = A::ForeignKeyColumn

fn foreign_key(&self) -> Option<&Parent::Id>

fn foreign_key_column() -> Self::ForeignKeyColumn

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, Parent> BelongsTo<Parent> 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
    A: BelongsTo<Parent>,
    Parent: Identifiable, 

type ForeignKeyColumn = A::ForeignKeyColumn

fn foreign_key(&self) -> Option<&Parent::Id>

fn foreign_key_column() -> Self::ForeignKeyColumn

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, Parent> BelongsTo<Parent> 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
    A: BelongsTo<Parent>,
    Parent: Identifiable, 

type ForeignKeyColumn = A::ForeignKeyColumn

fn foreign_key(&self) -> Option<&Parent::Id>

fn foreign_key_column() -> Self::ForeignKeyColumn

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, Parent> BelongsTo<Parent> 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
    A: BelongsTo<Parent>,
    Parent: Identifiable, 

type ForeignKeyColumn = A::ForeignKeyColumn

fn foreign_key(&self) -> Option<&Parent::Id>

fn foreign_key_column() -> Self::ForeignKeyColumn

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, Parent> BelongsTo<Parent> 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
    A: BelongsTo<Parent>,
    Parent: Identifiable, 

type ForeignKeyColumn = A::ForeignKeyColumn

fn foreign_key(&self) -> Option<&Parent::Id>

fn foreign_key_column() -> Self::ForeignKeyColumn

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, Parent> BelongsTo<Parent> 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
    A: BelongsTo<Parent>,
    Parent: Identifiable, 

type ForeignKeyColumn = A::ForeignKeyColumn

fn foreign_key(&self) -> Option<&Parent::Id>

fn foreign_key_column() -> Self::ForeignKeyColumn

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, Parent> BelongsTo<Parent> 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
    A: BelongsTo<Parent>,
    Parent: Identifiable, 

type ForeignKeyColumn = A::ForeignKeyColumn

fn foreign_key(&self) -> Option<&Parent::Id>

fn foreign_key_column() -> Self::ForeignKeyColumn

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, Parent> BelongsTo<Parent> 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
    A: BelongsTo<Parent>,
    Parent: Identifiable, 

type ForeignKeyColumn = A::ForeignKeyColumn

fn foreign_key(&self) -> Option<&Parent::Id>

fn foreign_key_column() -> Self::ForeignKeyColumn

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, AG, AH, AI, AJ, AK, AL, AM, AN, AO, AP, AQ, AR, AS, AT, AU, AV, AW, AX, AY, AZ, Parent> BelongsTo<Parent> 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
    A: BelongsTo<Parent>,
    Parent: Identifiable, 

type ForeignKeyColumn = A::ForeignKeyColumn

fn foreign_key(&self) -> Option<&Parent::Id>

fn foreign_key_column() -> Self::ForeignKeyColumn

Implementors