diesel/expression/
assume_not_null.rs

1use crate::Column;
2use crate::expression::*;
3use crate::query_builder::*;
4use crate::query_source::joins::ToInnerJoin;
5use crate::result::QueryResult;
6use crate::sql_types::{DieselNumericOps, IntoNotNullable};
7
8#[derive(#[automatically_derived]
impl<T: ::core::default::Default> ::core::default::Default for
    AssumeNotNull<T> {
    #[inline]
    fn default() -> AssumeNotNull<T> {
        AssumeNotNull(::core::default::Default::default())
    }
}Default, #[automatically_derived]
impl<T: ::core::fmt::Debug> ::core::fmt::Debug for AssumeNotNull<T> {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::debug_tuple_field1_finish(f, "AssumeNotNull",
            &&self.0)
    }
}Debug, #[automatically_derived]
impl<T: ::core::marker::Copy> ::core::marker::Copy for AssumeNotNull<T> { }Copy, #[automatically_derived]
impl<T: ::core::clone::Clone> ::core::clone::Clone for AssumeNotNull<T> {
    #[inline]
    fn clone(&self) -> AssumeNotNull<T> {
        AssumeNotNull(::core::clone::Clone::clone(&self.0))
    }
}Clone, const _: () =
    {
        use diesel;
        use diesel::internal::derives::numeric_ops as ops;
        use diesel::expression::{Expression, AsExpression};
        use diesel::sql_types::ops::{Add, Sub, Mul, Div};
        use diesel::sql_types::{SqlType, SingleValue};
        impl<T, __Rhs> ::core::ops::Add<__Rhs> for AssumeNotNull<T> where
            Self: Expression, Self: Expression,
            <Self as Expression>::SqlType: Add,
            <<Self as Expression>::SqlType as Add>::Rhs: SqlType +
            SingleValue,
            __Rhs: AsExpression<<<Self as Expression>::SqlType as Add>::Rhs> {
            type Output = ops::Add<Self, __Rhs::Expression>;
            fn add(self, rhs: __Rhs) -> Self::Output {
                ops::Add::new(self, rhs.as_expression())
            }
        }
        impl<T, __Rhs> ::core::ops::Sub<__Rhs> for AssumeNotNull<T> where
            Self: Expression, Self: Expression,
            <Self as Expression>::SqlType: Sub,
            <<Self as Expression>::SqlType as Sub>::Rhs: SqlType +
            SingleValue,
            __Rhs: AsExpression<<<Self as Expression>::SqlType as Sub>::Rhs> {
            type Output = ops::Sub<Self, __Rhs::Expression>;
            fn sub(self, rhs: __Rhs) -> Self::Output {
                ops::Sub::new(self, rhs.as_expression())
            }
        }
        impl<T, __Rhs> ::core::ops::Mul<__Rhs> for AssumeNotNull<T> where
            Self: Expression, Self: Expression,
            <Self as Expression>::SqlType: Mul,
            <<Self as Expression>::SqlType as Mul>::Rhs: SqlType +
            SingleValue,
            __Rhs: AsExpression<<<Self as Expression>::SqlType as Mul>::Rhs> {
            type Output = ops::Mul<Self, __Rhs::Expression>;
            fn mul(self, rhs: __Rhs) -> Self::Output {
                ops::Mul::new(self, rhs.as_expression())
            }
        }
        impl<T, __Rhs> ::core::ops::Div<__Rhs> for AssumeNotNull<T> where
            Self: Expression, Self: Expression,
            <Self as Expression>::SqlType: Div,
            <<Self as Expression>::SqlType as Div>::Rhs: SqlType +
            SingleValue,
            __Rhs: AsExpression<<<Self as Expression>::SqlType as Div>::Rhs> {
            type Output = ops::Div<Self, __Rhs::Expression>;
            fn div(self, rhs: __Rhs) -> Self::Output {
                ops::Div::new(self, rhs.as_expression())
            }
        }
    };DieselNumericOps, const _: () =
    {
        use diesel;
        impl<T, __GroupByClause>
            diesel::expression::ValidGrouping<__GroupByClause> for
            AssumeNotNull<T> where
            T: diesel::expression::ValidGrouping<__GroupByClause> {
            type IsAggregate =
                <T as
                diesel::expression::ValidGrouping<__GroupByClause>>::IsAggregate;
        }
    };ValidGrouping)]
9pub struct AssumeNotNull<T>(T);
10
11impl<T> AssumeNotNull<T> {
12    pub fn new(expr: T) -> Self {
13        AssumeNotNull(expr)
14    }
15}
16
17impl<T> Expression for AssumeNotNull<T>
18where
19    T: Expression,
20    T::SqlType: IntoNotNullable,
21    <T::SqlType as IntoNotNullable>::NotNullable: TypedExpressionType,
22{
23    type SqlType = <T::SqlType as IntoNotNullable>::NotNullable;
24}
25
26impl<T, DB> QueryFragment<DB> for AssumeNotNull<T>
27where
28    DB: Backend,
29    T: QueryFragment<DB>,
30{
31    fn walk_ast<'b>(&'b self, pass: AstPass<'_, 'b, DB>) -> QueryResult<()> {
32        self.0.walk_ast(pass)
33    }
34}
35
36impl<T, QS> AppearsOnTable<QS> for AssumeNotNull<T>
37where
38    T: AppearsOnTable<QS>,
39    AssumeNotNull<T>: Expression,
40{
41}
42
43impl<T: QueryId> QueryId for AssumeNotNull<T> {
44    type QueryId = T::QueryId;
45
46    const HAS_STATIC_QUERY_ID: bool = T::HAS_STATIC_QUERY_ID;
47}
48
49impl<T, QS> SelectableExpression<QS> for AssumeNotNull<T>
50where
51    Self: AppearsOnTable<QS>,
52    QS: ToInnerJoin,
53    T: SelectableExpression<QS::InnerJoin>,
54{
55}
56
57impl<T> SelectableExpression<NoFromClause> for AssumeNotNull<T> where
58    Self: AppearsOnTable<NoFromClause>
59{
60}
61
62impl<T> Column for AssumeNotNull<T>
63where
64    T: Column<SqlType: IntoNotNullable<NotNullable: TypedExpressionType>>,
65{
66    type Table = T::Table;
67
68    const NAME: &'static str = T::NAME;
69}
diesel/expression/assume_not_null.rs

diesel/expression/
assume_not_null.rs
