Trait CompatibleType 

pub trait CompatibleType<U, DB> {
    type SqlType;
}

Available on crate feature i-implement-a-third-party-backend-and-opt-into-breaking-changes only.

Required Associated Types

type SqlType

Dyn Compatibility

This trait is dyn compatible.

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

Implementations on Foreign Types

impl<__T, ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29, ST30, ST31, __DB> CompatibleType<__T, __DB> for (ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29, ST30, ST31)

where __DB: Backend, __T: FromSqlRow<(ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29, ST30, ST31), __DB>,

type SqlType = (ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29, ST30, ST31)

Available on crate feature i-implement-a-third-party-backend-and-opt-into-breaking-changes only.

impl<__T, ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29, ST30, __DB> CompatibleType<__T, __DB> for (ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29, ST30)

where __DB: Backend, __T: FromSqlRow<(ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29, ST30), __DB>,

type SqlType = (ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29, ST30)

Available on crate feature i-implement-a-third-party-backend-and-opt-into-breaking-changes only.

impl<__T, ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29, __DB> CompatibleType<__T, __DB> for (ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29)

where __DB: Backend, __T: FromSqlRow<(ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29), __DB>,

type SqlType = (ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29)

Available on crate feature i-implement-a-third-party-backend-and-opt-into-breaking-changes only.

impl<__T, ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, __DB> CompatibleType<__T, __DB> for (ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28)

where __DB: Backend, __T: FromSqlRow<(ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28), __DB>,

type SqlType = (ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28)

Available on crate feature i-implement-a-third-party-backend-and-opt-into-breaking-changes only.

impl<__T, ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, __DB> CompatibleType<__T, __DB> for (ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27)

where __DB: Backend, __T: FromSqlRow<(ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27), __DB>,

type SqlType = (ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27)

Available on crate feature i-implement-a-third-party-backend-and-opt-into-breaking-changes only.

impl<__T, ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, __DB> CompatibleType<__T, __DB> for (ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26)

where __DB: Backend, __T: FromSqlRow<(ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26), __DB>,

type SqlType = (ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26)

Available on crate feature i-implement-a-third-party-backend-and-opt-into-breaking-changes only.

impl<__T, ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, __DB> CompatibleType<__T, __DB> for (ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25)

where __DB: Backend, __T: FromSqlRow<(ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25), __DB>,

type SqlType = (ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25)

Available on crate feature i-implement-a-third-party-backend-and-opt-into-breaking-changes only.

impl<__T, ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, __DB> CompatibleType<__T, __DB> for (ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24)

where __DB: Backend, __T: FromSqlRow<(ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24), __DB>,

type SqlType = (ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24)

Available on crate feature i-implement-a-third-party-backend-and-opt-into-breaking-changes only.

impl<__T, ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, __DB> CompatibleType<__T, __DB> for (ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23)

where __DB: Backend, __T: FromSqlRow<(ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23), __DB>,

type SqlType = (ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23)

Available on crate feature i-implement-a-third-party-backend-and-opt-into-breaking-changes only.

impl<__T, ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, __DB> CompatibleType<__T, __DB> for (ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22)

where __DB: Backend, __T: FromSqlRow<(ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22), __DB>,

type SqlType = (ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22)

Available on crate feature i-implement-a-third-party-backend-and-opt-into-breaking-changes only.

impl<__T, ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, __DB> CompatibleType<__T, __DB> for (ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21)

where __DB: Backend, __T: FromSqlRow<(ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21), __DB>,

type SqlType = (ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21)

Available on crate feature i-implement-a-third-party-backend-and-opt-into-breaking-changes only.

impl<__T, ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, __DB> CompatibleType<__T, __DB> for (ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20)

where __DB: Backend, __T: FromSqlRow<(ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20), __DB>,

type SqlType = (ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20)

Available on crate feature i-implement-a-third-party-backend-and-opt-into-breaking-changes only.

impl<__T, ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, __DB> CompatibleType<__T, __DB> for (ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19)

where __DB: Backend, __T: FromSqlRow<(ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19), __DB>,

type SqlType = (ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19)

Available on crate feature i-implement-a-third-party-backend-and-opt-into-breaking-changes only.

impl<__T, ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, __DB> CompatibleType<__T, __DB> for (ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18)

where __DB: Backend, __T: FromSqlRow<(ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18), __DB>,

type SqlType = (ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18)

Available on crate feature i-implement-a-third-party-backend-and-opt-into-breaking-changes only.

impl<__T, ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, __DB> CompatibleType<__T, __DB> for (ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17)

where __DB: Backend, __T: FromSqlRow<(ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17), __DB>,

type SqlType = (ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17)

Available on crate feature i-implement-a-third-party-backend-and-opt-into-breaking-changes only.

impl<__T, ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, __DB> CompatibleType<__T, __DB> for (ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16)

where __DB: Backend, __T: FromSqlRow<(ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16), __DB>,

type SqlType = (ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16)

Available on crate feature i-implement-a-third-party-backend-and-opt-into-breaking-changes only.

impl<__T, ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, __DB> CompatibleType<__T, __DB> for (ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15)

where __DB: Backend, __T: FromSqlRow<(ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15), __DB>,

type SqlType = (ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15)

Available on crate feature i-implement-a-third-party-backend-and-opt-into-breaking-changes only.

impl<__T, ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, __DB> CompatibleType<__T, __DB> for (ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14)

where __DB: Backend, __T: FromSqlRow<(ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14), __DB>,

type SqlType = (ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14)

Available on crate feature i-implement-a-third-party-backend-and-opt-into-breaking-changes only.

impl<__T, ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, __DB> CompatibleType<__T, __DB> for (ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13)

where __DB: Backend, __T: FromSqlRow<(ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13), __DB>,

type SqlType = (ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13)

Available on crate feature i-implement-a-third-party-backend-and-opt-into-breaking-changes only.

impl<__T, ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, __DB> CompatibleType<__T, __DB> for (ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12)

where __DB: Backend, __T: FromSqlRow<(ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12), __DB>,

type SqlType = (ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12)

Available on crate feature i-implement-a-third-party-backend-and-opt-into-breaking-changes only.

impl<__T, ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, __DB> CompatibleType<__T, __DB> for (ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11)

where __DB: Backend, __T: FromSqlRow<(ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11), __DB>,

type SqlType = (ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11)

Available on crate feature i-implement-a-third-party-backend-and-opt-into-breaking-changes only.

impl<__T, ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, __DB> CompatibleType<__T, __DB> for (ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10)

where __DB: Backend, __T: FromSqlRow<(ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10), __DB>,

type SqlType = (ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10)

Available on crate feature i-implement-a-third-party-backend-and-opt-into-breaking-changes only.

impl<__T, ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, __DB> CompatibleType<__T, __DB> for (ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9)

where __DB: Backend, __T: FromSqlRow<(ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9), __DB>,

type SqlType = (ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9)

Available on crate feature i-implement-a-third-party-backend-and-opt-into-breaking-changes only.

impl<__T, ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, __DB> CompatibleType<__T, __DB> for (ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8)

where __DB: Backend, __T: FromSqlRow<(ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8), __DB>,

type SqlType = (ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8)

Available on crate feature i-implement-a-third-party-backend-and-opt-into-breaking-changes only.

impl<__T, ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, __DB> CompatibleType<__T, __DB> for (ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7)

where __DB: Backend, __T: FromSqlRow<(ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7), __DB>,

type SqlType = (ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7)

Available on crate feature i-implement-a-third-party-backend-and-opt-into-breaking-changes only.

impl<__T, ST, ST1, ST2, ST3, ST4, ST5, ST6, __DB> CompatibleType<__T, __DB> for (ST, ST1, ST2, ST3, ST4, ST5, ST6)

where __DB: Backend, __T: FromSqlRow<(ST, ST1, ST2, ST3, ST4, ST5, ST6), __DB>,

type SqlType = (ST, ST1, ST2, ST3, ST4, ST5, ST6)

Available on crate feature i-implement-a-third-party-backend-and-opt-into-breaking-changes only.

impl<__T, ST, ST1, ST2, ST3, ST4, ST5, __DB> CompatibleType<__T, __DB> for (ST, ST1, ST2, ST3, ST4, ST5)

where __DB: Backend, __T: FromSqlRow<(ST, ST1, ST2, ST3, ST4, ST5), __DB>,

type SqlType = (ST, ST1, ST2, ST3, ST4, ST5)

Available on crate feature i-implement-a-third-party-backend-and-opt-into-breaking-changes only.

impl<__T, ST, ST1, ST2, ST3, ST4, __DB> CompatibleType<__T, __DB> for (ST, ST1, ST2, ST3, ST4)

where __DB: Backend, __T: FromSqlRow<(ST, ST1, ST2, ST3, ST4), __DB>,

type SqlType = (ST, ST1, ST2, ST3, ST4)

Available on crate feature i-implement-a-third-party-backend-and-opt-into-breaking-changes only.

impl<__T, ST, ST1, ST2, ST3, __DB> CompatibleType<__T, __DB> for (ST, ST1, ST2, ST3)

where __DB: Backend, __T: FromSqlRow<(ST, ST1, ST2, ST3), __DB>,

type SqlType = (ST, ST1, ST2, ST3)

Available on crate feature i-implement-a-third-party-backend-and-opt-into-breaking-changes only.

impl<__T, ST, ST1, ST2, __DB> CompatibleType<__T, __DB> for (ST, ST1, ST2)

where __DB: Backend, __T: FromSqlRow<(ST, ST1, ST2), __DB>,

type SqlType = (ST, ST1, ST2)

Available on crate feature i-implement-a-third-party-backend-and-opt-into-breaking-changes only.

impl<__T, ST, ST1, __DB> CompatibleType<__T, __DB> for (ST, ST1)

where __DB: Backend, __T: FromSqlRow<(ST, ST1), __DB>,

type SqlType = (ST, ST1)

Available on crate feature i-implement-a-third-party-backend-and-opt-into-breaking-changes only.

impl<__T, ST, __DB> CompatibleType<__T, __DB> for (ST,)

where __DB: Backend, __T: FromSqlRow<(ST,), __DB>,

type SqlType = (ST,)

Available on crate feature i-implement-a-third-party-backend-and-opt-into-breaking-changes only.

Implementors

impl<ST, U, DB> CompatibleType<U, DB> for ST

where DB: Backend, ST: SqlType + SingleValue, U: FromSqlRow<ST, DB>,

type SqlType = ST

impl<U, DB> CompatibleType<U, DB> for Untyped

where U: FromSqlRow<Untyped, DB>, DB: Backend,

type SqlType = Untyped

impl<__T, ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29, ST30, ST31, __DB> CompatibleType<Option<__T>, __DB> for Nullable<(ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29, ST30, ST31)>

where __DB: Backend, (ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29, ST30, ST31): CompatibleType<__T, __DB>,

type SqlType = Nullable<<(ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29, ST30, ST31) as CompatibleType<__T, __DB>>::SqlType>

impl<__T, ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29, ST30, __DB> CompatibleType<Option<__T>, __DB> for Nullable<(ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29, ST30)>

where __DB: Backend, (ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29, ST30): CompatibleType<__T, __DB>,

type SqlType = Nullable<<(ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29, ST30) as CompatibleType<__T, __DB>>::SqlType>

impl<__T, ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29, __DB> CompatibleType<Option<__T>, __DB> for Nullable<(ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29)>

where __DB: Backend, (ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29): CompatibleType<__T, __DB>,

type SqlType = Nullable<<(ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, ST29) as CompatibleType<__T, __DB>>::SqlType>

impl<__T, ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28, __DB> CompatibleType<Option<__T>, __DB> for Nullable<(ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28)>

where __DB: Backend, (ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28): CompatibleType<__T, __DB>,

type SqlType = Nullable<<(ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, ST28) as CompatibleType<__T, __DB>>::SqlType>

impl<__T, ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27, __DB> CompatibleType<Option<__T>, __DB> for Nullable<(ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27)>

where __DB: Backend, (ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27): CompatibleType<__T, __DB>,

type SqlType = Nullable<<(ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, ST27) as CompatibleType<__T, __DB>>::SqlType>

impl<__T, ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26, __DB> CompatibleType<Option<__T>, __DB> for Nullable<(ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26)>

where __DB: Backend, (ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26): CompatibleType<__T, __DB>,

type SqlType = Nullable<<(ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, ST26) as CompatibleType<__T, __DB>>::SqlType>

impl<__T, ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25, __DB> CompatibleType<Option<__T>, __DB> for Nullable<(ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25)>

where __DB: Backend, (ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25): CompatibleType<__T, __DB>,

type SqlType = Nullable<<(ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, ST25) as CompatibleType<__T, __DB>>::SqlType>

impl<__T, ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24, __DB> CompatibleType<Option<__T>, __DB> for Nullable<(ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24)>

where __DB: Backend, (ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24): CompatibleType<__T, __DB>,

type SqlType = Nullable<<(ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, ST24) as CompatibleType<__T, __DB>>::SqlType>

impl<__T, ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23, __DB> CompatibleType<Option<__T>, __DB> for Nullable<(ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23)>

where __DB: Backend, (ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23): CompatibleType<__T, __DB>,

type SqlType = Nullable<<(ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, ST23) as CompatibleType<__T, __DB>>::SqlType>

impl<__T, ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22, __DB> CompatibleType<Option<__T>, __DB> for Nullable<(ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22)>

where __DB: Backend, (ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22): CompatibleType<__T, __DB>,

type SqlType = Nullable<<(ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, ST22) as CompatibleType<__T, __DB>>::SqlType>

impl<__T, ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21, __DB> CompatibleType<Option<__T>, __DB> for Nullable<(ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21)>

where __DB: Backend, (ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21): CompatibleType<__T, __DB>,

type SqlType = Nullable<<(ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, ST21) as CompatibleType<__T, __DB>>::SqlType>

impl<__T, ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20, __DB> CompatibleType<Option<__T>, __DB> for Nullable<(ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20)>

where __DB: Backend, (ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20): CompatibleType<__T, __DB>,

type SqlType = Nullable<<(ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, ST20) as CompatibleType<__T, __DB>>::SqlType>

impl<__T, ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19, __DB> CompatibleType<Option<__T>, __DB> for Nullable<(ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19)>

where __DB: Backend, (ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19): CompatibleType<__T, __DB>,

type SqlType = Nullable<<(ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, ST19) as CompatibleType<__T, __DB>>::SqlType>

impl<__T, ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18, __DB> CompatibleType<Option<__T>, __DB> for Nullable<(ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18)>

where __DB: Backend, (ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18): CompatibleType<__T, __DB>,

type SqlType = Nullable<<(ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, ST18) as CompatibleType<__T, __DB>>::SqlType>

impl<__T, ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17, __DB> CompatibleType<Option<__T>, __DB> for Nullable<(ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17)>

where __DB: Backend, (ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17): CompatibleType<__T, __DB>,

type SqlType = Nullable<<(ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, ST17) as CompatibleType<__T, __DB>>::SqlType>

impl<__T, ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16, __DB> CompatibleType<Option<__T>, __DB> for Nullable<(ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16)>

where __DB: Backend, (ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16): CompatibleType<__T, __DB>,

type SqlType = Nullable<<(ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, ST16) as CompatibleType<__T, __DB>>::SqlType>

impl<__T, ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15, __DB> CompatibleType<Option<__T>, __DB> for Nullable<(ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15)>

where __DB: Backend, (ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15): CompatibleType<__T, __DB>,

type SqlType = Nullable<<(ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, ST15) as CompatibleType<__T, __DB>>::SqlType>

impl<__T, ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14, __DB> CompatibleType<Option<__T>, __DB> for Nullable<(ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14)>

where __DB: Backend, (ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14): CompatibleType<__T, __DB>,

type SqlType = Nullable<<(ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, ST14) as CompatibleType<__T, __DB>>::SqlType>

impl<__T, ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13, __DB> CompatibleType<Option<__T>, __DB> for Nullable<(ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13)>

where __DB: Backend, (ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13): CompatibleType<__T, __DB>,

type SqlType = Nullable<<(ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, ST13) as CompatibleType<__T, __DB>>::SqlType>

impl<__T, ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12, __DB> CompatibleType<Option<__T>, __DB> for Nullable<(ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12)>

where __DB: Backend, (ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12): CompatibleType<__T, __DB>,

type SqlType = Nullable<<(ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, ST12) as CompatibleType<__T, __DB>>::SqlType>

impl<__T, ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11, __DB> CompatibleType<Option<__T>, __DB> for Nullable<(ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11)>

where __DB: Backend, (ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11): CompatibleType<__T, __DB>,

type SqlType = Nullable<<(ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, ST11) as CompatibleType<__T, __DB>>::SqlType>

impl<__T, ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10, __DB> CompatibleType<Option<__T>, __DB> for Nullable<(ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10)>

where __DB: Backend, (ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10): CompatibleType<__T, __DB>,

type SqlType = Nullable<<(ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, ST10) as CompatibleType<__T, __DB>>::SqlType>

impl<__T, ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9, __DB> CompatibleType<Option<__T>, __DB> for Nullable<(ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9)>

where __DB: Backend, (ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9): CompatibleType<__T, __DB>,

type SqlType = Nullable<<(ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, ST9) as CompatibleType<__T, __DB>>::SqlType>

impl<__T, ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8, __DB> CompatibleType<Option<__T>, __DB> for Nullable<(ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8)>

where __DB: Backend, (ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8): CompatibleType<__T, __DB>,

type SqlType = Nullable<<(ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, ST8) as CompatibleType<__T, __DB>>::SqlType>

impl<__T, ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7, __DB> CompatibleType<Option<__T>, __DB> for Nullable<(ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7)>

where __DB: Backend, (ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7): CompatibleType<__T, __DB>,

type SqlType = Nullable<<(ST, ST1, ST2, ST3, ST4, ST5, ST6, ST7) as CompatibleType<__T, __DB>>::SqlType>

impl<__T, ST, ST1, ST2, ST3, ST4, ST5, ST6, __DB> CompatibleType<Option<__T>, __DB> for Nullable<(ST, ST1, ST2, ST3, ST4, ST5, ST6)>

where __DB: Backend, (ST, ST1, ST2, ST3, ST4, ST5, ST6): CompatibleType<__T, __DB>,

type SqlType = Nullable<<(ST, ST1, ST2, ST3, ST4, ST5, ST6) as CompatibleType<__T, __DB>>::SqlType>

impl<__T, ST, ST1, ST2, ST3, ST4, ST5, __DB> CompatibleType<Option<__T>, __DB> for Nullable<(ST, ST1, ST2, ST3, ST4, ST5)>

where __DB: Backend, (ST, ST1, ST2, ST3, ST4, ST5): CompatibleType<__T, __DB>,

type SqlType = Nullable<<(ST, ST1, ST2, ST3, ST4, ST5) as CompatibleType<__T, __DB>>::SqlType>

impl<__T, ST, ST1, ST2, ST3, ST4, __DB> CompatibleType<Option<__T>, __DB> for Nullable<(ST, ST1, ST2, ST3, ST4)>

where __DB: Backend, (ST, ST1, ST2, ST3, ST4): CompatibleType<__T, __DB>,

type SqlType = Nullable<<(ST, ST1, ST2, ST3, ST4) as CompatibleType<__T, __DB>>::SqlType>

impl<__T, ST, ST1, ST2, ST3, __DB> CompatibleType<Option<__T>, __DB> for Nullable<(ST, ST1, ST2, ST3)>

where __DB: Backend, (ST, ST1, ST2, ST3): CompatibleType<__T, __DB>,

type SqlType = Nullable<<(ST, ST1, ST2, ST3) as CompatibleType<__T, __DB>>::SqlType>

impl<__T, ST, ST1, ST2, __DB> CompatibleType<Option<__T>, __DB> for Nullable<(ST, ST1, ST2)>

where __DB: Backend, (ST, ST1, ST2): CompatibleType<__T, __DB>,

type SqlType = Nullable<<(ST, ST1, ST2) as CompatibleType<__T, __DB>>::SqlType>

impl<__T, ST, ST1, __DB> CompatibleType<Option<__T>, __DB> for Nullable<(ST, ST1)>

where __DB: Backend, (ST, ST1): CompatibleType<__T, __DB>,

type SqlType = Nullable<<(ST, ST1) as CompatibleType<__T, __DB>>::SqlType>

impl<__T, ST, __DB> CompatibleType<Option<__T>, __DB> for Nullable<(ST,)>

where __DB: Backend, (ST,): CompatibleType<__T, __DB>,

type SqlType = Nullable<<(ST,) as CompatibleType<__T, __DB>>::SqlType>