diesel/expression/
count.rs

1use std::marker::PhantomData;
2
3use super::functions::define_sql_function;
4use super::{is_aggregate, AsExpression};
5use super::{Expression, ValidGrouping};
6use crate::backend::Backend;
7use crate::query_builder::*;
8use crate::result::QueryResult;
9use crate::sql_types::{BigInt, DieselNumericOps, SingleValue, SqlType};
10use crate::{AppearsOnTable, SelectableExpression};
11
12define_sql_function! {
13    /// Creates a SQL `COUNT` expression
14    ///
15    /// As with most bare functions, this is not exported by default. You can import
16    /// it specifically as `diesel::dsl::count`, or glob import
17    /// `diesel::dsl::*`
18    ///
19    /// # Examples
20    ///
21    /// ```rust
22    /// # include!("../doctest_setup.rs");
23    /// # use diesel::dsl::*;
24    /// #
25    /// # fn main() {
26    /// #     use schema::animals::dsl::*;
27    /// #     let connection = &mut establish_connection();
28    /// assert_eq!(Ok(1), animals.select(count(name)).first(connection));
29    /// # }
30    /// ```
31    #[aggregate]
32    fn count<T: SqlType + SingleValue>(expr: T) -> BigInt;
33}
34
35/// Creates a SQL `COUNT(*)` expression
36///
37/// For selecting the count of a query, and nothing else, you can just call
38/// [`count`](crate::query_dsl::QueryDsl::count())
39/// on the query instead.
40///
41/// As with most bare functions, this is not exported by default. You can import
42/// it specifically as `diesel::dsl::count_star`, or glob import
43/// `diesel::dsl::*`
44///
45/// # Examples
46///
47/// ```rust
48/// # include!("../doctest_setup.rs");
49/// # use diesel::dsl::*;
50/// #
51/// # fn main() {
52/// #     use schema::users::dsl::*;
53/// #     let connection = &mut establish_connection();
54/// assert_eq!(Ok(2), users.select(count_star()).first(connection));
55/// # }
56/// ```
57pub fn count_star() -> CountStar {
58    CountStar
59}
60
61#[derive(Debug, Clone, Copy, QueryId, DieselNumericOps, ValidGrouping)]
62#[diesel(aggregate)]
63#[doc(hidden)]
64pub struct CountStar;
65
66impl Expression for CountStar {
67    type SqlType = BigInt;
68}
69
70impl<DB: Backend> QueryFragment<DB> for CountStar {
71    fn walk_ast<'b>(&'b self, mut out: AstPass<'_, 'b, DB>) -> QueryResult<()> {
72        out.push_sql("COUNT(*)");
73        Ok(())
74    }
75}
76
77impl_selectable_expression!(CountStar);
78
79/// Creates a SQL `COUNT(DISTINCT ...)` expression
80///
81/// As with most bare functions, this is not exported by default. You can import
82/// it specifically as `diesel::dsl::count_distinct`, or glob import
83/// `diesel::dsl::*`
84///
85/// # Examples
86///
87/// ```rust
88/// # #[macro_use] extern crate diesel;
89/// # include!("../doctest_setup.rs");
90/// # use diesel::dsl::*;
91/// #
92/// # fn main() {
93/// #     use schema::posts::dsl::*;
94/// #     let connection = &mut establish_connection();
95/// let unique_user_count = posts.select(count_distinct(user_id)).first(connection);
96/// assert_eq!(Ok(2), unique_user_count);
97/// # }
98/// ```
99pub fn count_distinct<T, E>(expr: E) -> CountDistinct<T, E::Expression>
100where
101    T: SqlType + SingleValue,
102    E: AsExpression<T>,
103{
104    CountDistinct {
105        expr: expr.as_expression(),
106        _marker: PhantomData,
107    }
108}
109
110#[derive(Debug, Clone, Copy, QueryId, DieselNumericOps)]
111#[doc(hidden)]
112pub struct CountDistinct<T, E> {
113    expr: E,
114    _marker: PhantomData<T>,
115}
116
117impl<T, E> Expression for CountDistinct<T, E>
118where
119    T: SqlType + SingleValue,
120    E: Expression,
121{
122    type SqlType = BigInt;
123}
124
125impl<T, E, GB> ValidGrouping<GB> for CountDistinct<T, E>
126where
127    T: SqlType + SingleValue,
128{
129    type IsAggregate = is_aggregate::Yes;
130}
131
132impl<T, E, QS> SelectableExpression<QS> for CountDistinct<T, E>
133where
134    Self: AppearsOnTable<QS>,
135    E: SelectableExpression<QS>,
136{
137}
138
139impl<T, E, QS> AppearsOnTable<QS> for CountDistinct<T, E>
140where
141    Self: Expression,
142    E: AppearsOnTable<QS>,
143{
144}
145
146impl<T, E, DB> QueryFragment<DB> for CountDistinct<T, E>
147where
148    T: SqlType + SingleValue,
149    DB: Backend,
150    E: QueryFragment<DB>,
151{
152    fn walk_ast<'b>(&'b self, mut out: AstPass<'_, 'b, DB>) -> QueryResult<()> {
153        out.push_sql("COUNT(DISTINCT ");
154        self.expr.walk_ast(out.reborrow())?;
155        out.push_sql(")");
156        Ok(())
157    }
158}
diesel/expression/count.rs

diesel/expression/
count.rs
