diesel/expression/
grouped.rs

1use crate::backend::{Backend, DieselReserveSpecialization};
2use crate::expression::{Expression, ValidGrouping};
3use crate::query_builder::*;
4use crate::result::QueryResult;
5use crate::sql_types::DieselNumericOps;
6
7#[derive(#[automatically_derived]
impl<T: ::core::fmt::Debug> ::core::fmt::Debug for Grouped<T> {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::debug_tuple_field1_finish(f, "Grouped",
            &&self.0)
    }
}Debug, #[automatically_derived]
impl<T: ::core::marker::Copy> ::core::marker::Copy for Grouped<T> { }Copy, #[automatically_derived]
impl<T: ::core::clone::Clone> ::core::clone::Clone for Grouped<T> {
    #[inline]
    fn clone(&self) -> Grouped<T> {
        Grouped(::core::clone::Clone::clone(&self.0))
    }
}Clone, const _: () =
    {
        use diesel;
        #[allow(non_camel_case_types)]
        impl<T: diesel::query_builder::QueryId> diesel::query_builder::QueryId
            for Grouped<T> {
            type QueryId =
                Grouped<<T as diesel::query_builder::QueryId>::QueryId>;
            const HAS_STATIC_QUERY_ID: bool =
                <T as diesel::query_builder::QueryId>::HAS_STATIC_QUERY_ID &&
                    true;
            const IS_WINDOW_FUNCTION: bool =
                <T as diesel::query_builder::QueryId>::IS_WINDOW_FUNCTION ||
                    false;
        }
    };QueryId, #[automatically_derived]
impl<T: ::core::default::Default> ::core::default::Default for Grouped<T> {
    #[inline]
    fn default() -> Grouped<T> {
        Grouped(::core::default::Default::default())
    }
}Default, 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> ::std::ops::Add<__Rhs> for Grouped<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> ::std::ops::Sub<__Rhs> for Grouped<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> ::std::ops::Mul<__Rhs> for Grouped<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> ::std::ops::Div<__Rhs> for Grouped<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 Grouped<T>
            where T: diesel::expression::ValidGrouping<__GroupByClause> {
            type IsAggregate =
                <T as
                diesel::expression::ValidGrouping<__GroupByClause>>::IsAggregate;
        }
    };ValidGrouping)]
8#[doc(hidden)]
9pub struct Grouped<T>(pub(crate) T);
10
11impl<T: Expression> Expression for Grouped<T> {
12    type SqlType = T::SqlType;
13}
14
15impl<T, DB> QueryFragment<DB> for Grouped<T>
16where
17    T: QueryFragment<DB>,
18    DB: Backend + DieselReserveSpecialization,
19{
20    fn walk_ast<'b>(&'b self, mut out: AstPass<'_, 'b, DB>) -> QueryResult<()> {
21        out.push_sql("(");
22        self.0.walk_ast(out.reborrow())?;
23        out.push_sql(")");
24        Ok(())
25    }
26}
27
28impl<T, QS> crate::expression::SelectableExpression<QS> for Grouped<T> where
    Grouped<T>: crate::expression::AppearsOnTable<QS>,
    T: crate::expression::SelectableExpression<QS> {}
impl<T, QS> crate::expression::AppearsOnTable<QS> for Grouped<T> where
    Grouped<T>: crate::expression::Expression,
    T: crate::expression::AppearsOnTable<QS> {}impl_selectable_expression!(Grouped<T>);
diesel/expression/grouped.rs

diesel/expression/
grouped.rs
