Merge pull request #4322 from weiznich/feature/function_expressions

Support for window functions and other aggregate function expressions

Author: weiznich

CHANGELOG.md

@@ -34,6 +34,7 @@ in a way that makes the pools suitable for use in parallel tests.
 * Support `[print_schema] allow_tables_to_appear_in_same_query_config = "none"` to generate no `allow_tables_to_appear_in_same_query!` calls. (Default: `"all_tables"`.). ([#4333](https://github.com/diesel-rs/diesel/issues/4333))
 * Add `[print_schema] pg_domains_as_custom_types` parameter to generate custom types for [PostgreSQL domains](https://www.postgresql.org/docs/current/domains.html) that matches any of the regexes in the given list. (Default: `[]`.) This option allows an application to selectively give special meaning for the serialization/deserialization of these types, avoiding the default behavior of treating the domain as the underlying type. ([#4592](https://github.com/diesel-rs/diesel/discussions/4592))
 * Add support for batch insert and upsert statements with returning for SQLite
+* Add support for window functions and aggregate expressions. 
 
 ### Fixed 
 

diesel/src/backend.rs

@@ -317,6 +317,27 @@ pub trait SqlDialect: self::private::TrustedBackend {
         doc = "See [`sql_dialect::alias_syntax`] for provided default implementations"
     )]
     type AliasSyntax;
+
+    /// Configures how this backend support the `GROUP` frame unit for window functions
+    #[cfg_attr(
+        feature = "i-implement-a-third-party-backend-and-opt-into-breaking-changes",
+        doc = "See [`sql_dialect::window_frame_clause_group_support`] for provided default implementations"
+    )]
+    type WindowFrameClauseGroupSupport;
+
+    /// Configures how this backend supports frame exclusion clauses
+    #[cfg_attr(
+        feature = "i-implement-a-third-party-backend-and-opt-into-breaking-changes",
+        doc = "See [`sql_dialect::window_frame_exclusion_support`] for provided default implementations"
+    )]
+    type WindowFrameExclusionSupport;
+
+    /// Configures how this backend supports aggregate function expressions
+    #[cfg_attr(
+        feature = "i-implement-a-third-party-backend-and-opt-into-breaking-changes",
+        doc = "See [`sql_dialect::window_frame_clause_group_support`] for provided default implementations"
+    )]
+    type AggregateFunctionExpressions;
 }
 
 /// This module contains all options provided by diesel to configure the [`SqlDialect`] trait.
@@ -539,6 +560,50 @@ pub(crate) mod sql_dialect {
         #[derive(Debug, Copy, Clone)]
         pub struct AsAliasSyntax;
     }
+
+    /// This module contains all reusable options to configure [`SqlDialect::WindowFrameClauseGroupSupport`]
+    #[diesel_derives::__diesel_public_if(
+        feature = "i-implement-a-third-party-backend-and-opt-into-breaking-changes"
+    )]
+    pub mod window_frame_clause_group_support {
+        /// Indicates that this backend does not support the `GROUPS` frame unit
+        #[derive(Debug, Copy, Clone)]
+        pub struct NoGroupWindowFrameUnit;
+
+        /// Indicates that this backend does support the `GROUPS` frame unit as specified by the standard
+        #[derive(Debug, Copy, Clone)]
+        pub struct IsoGroupWindowFrameUnit;
+    }
+
+    /// This module contains all reusable options to configure [`SqlDialect::AggregateFunctionExpressions`]
+    #[diesel_derives::__diesel_public_if(
+        feature = "i-implement-a-third-party-backend-and-opt-into-breaking-changes"
+    )]
+    pub mod aggregate_function_expressions {
+        /// Indicates that this backend does not support aggregate function expressions
+        #[derive(Debug, Copy, Clone)]
+        pub struct NoAggregateFunctionExpressions;
+
+        /// Indicates that this backend supports aggregate function expressions similar to PostgreSQL
+        #[derive(Debug, Copy, Clone)]
+        pub struct PostgresLikeAggregateFunctionExpressions;
+    }
+
+    /// This module contains all reusable options to configure [`SqlDialect::WindowFrameExclusionSupport`]
+    #[diesel_derives::__diesel_public_if(
+        feature = "i-implement-a-third-party-backend-and-opt-into-breaking-changes"
+    )]
+    pub mod window_frame_exclusion_support {
+        /// Indicates that this backend support frame exclusion clauses
+        /// for window functions
+        #[derive(Debug, Copy, Clone)]
+        pub struct FrameExclusionSupport;
+
+        /// Indicates that this backend does not support frame exclusion clauses
+        /// for window functions
+        #[derive(Debug, Copy, Clone)]
+        pub struct NoFrameFrameExclusionSupport;
+    }
 }
 
 // These traits are not part of the public API

diesel/src/connection/instrumentation.rs

@@ -356,6 +356,12 @@ impl DynInstrumentation {
     #[diesel_derives::__diesel_public_if(
         feature = "i-implement-a-third-party-backend-and-opt-into-breaking-changes"
     )]
+    #[cfg(any(
+        feature = "postgres",
+        feature = "sqlite",
+        feature = "mysql",
+        feature = "i-implement-a-third-party-backend-and-opt-into-breaking-changes"
+    ))]
     pub(crate) fn default_instrumentation() -> Self {
         Self {
             inner: get_default_instrumentation(),
@@ -367,6 +373,12 @@ impl DynInstrumentation {
     #[diesel_derives::__diesel_public_if(
         feature = "i-implement-a-third-party-backend-and-opt-into-breaking-changes"
     )]
+    #[cfg(any(
+        feature = "postgres",
+        feature = "sqlite",
+        feature = "mysql",
+        feature = "i-implement-a-third-party-backend-and-opt-into-breaking-changes"
+    ))]
     pub(crate) fn none() -> Self {
         Self {
             inner: None,
@@ -378,6 +390,12 @@ impl DynInstrumentation {
     #[diesel_derives::__diesel_public_if(
         feature = "i-implement-a-third-party-backend-and-opt-into-breaking-changes"
     )]
+    #[cfg(any(
+        feature = "postgres",
+        feature = "sqlite",
+        feature = "mysql",
+        feature = "i-implement-a-third-party-backend-and-opt-into-breaking-changes"
+    ))]
     pub(crate) fn on_connection_event(&mut self, event: InstrumentationEvent<'_>) {
         // This implementation is not necessary to be able to call this method on this object
         // because of the already existing Deref impl.

diesel/src/expression/count.rs

@@ -1,7 +1,7 @@
 use std::marker::PhantomData;
 
 use super::functions::declare_sql_function;
-use super::{is_aggregate, AsExpression};
+use super::is_aggregate;
 use super::{Expression, ValidGrouping};
 use crate::backend::Backend;
 use crate::query_builder::*;
@@ -17,8 +17,18 @@ extern "SQL" {
     /// it specifically as `diesel::dsl::count`, or glob import
     /// `diesel::dsl::*`
     ///
+    /// ## Window Function Usage
+    ///
+    /// This function can be used as window function. See [`WindowExpressionMethods`] for details
+    ///
+    /// ## Aggregate Function Expression
+    ///
+    /// This function can be used as aggregate expression. See [`AggregateExpressionMethods`] for details.
+    ///
     /// # Examples
     ///
+    /// ## Normal function usage
+    ///
     /// ```rust
     /// # include!("../doctest_setup.rs");
     /// # use diesel::dsl::*;
@@ -29,7 +39,34 @@ extern "SQL" {
     /// assert_eq!(Ok(1), animals.select(count(name)).first(connection));
     /// # }
     /// ```
+    ///
+    /// ## Window function
+    ///
+    /// ```rust
+    /// # include!("../doctest_setup.rs");
+    /// # use diesel::dsl::*;
+    /// #
+    /// # fn main() {
+    /// #     use schema::animals::dsl::*;
+    /// #     let connection = &mut establish_connection();
+    /// assert_eq!(Ok(1), animals.select(count(name).partition_by(id)).first(connection));
+    /// # }
+    /// ```
+    ///
+    /// ## Aggregate function expression
+    ///
+    /// ```rust
+    /// # include!("../doctest_setup.rs");
+    /// # use diesel::dsl::*;
+    /// #
+    /// # fn main() {
+    /// #     use schema::animals::dsl::*;
+    /// #     let connection = &mut establish_connection();
+    /// assert_eq!(Ok(1), animals.select(count(name).aggregate_distinct()).first(connection));
+    /// # }
+    /// ```
     #[aggregate]
+    #[window]
     fn count<T: SqlType + SingleValue>(expr: T) -> BigInt;
 }
 
@@ -77,30 +114,13 @@ impl<DB: Backend> QueryFragment<DB> for CountStar {
 
 impl_selectable_expression!(CountStar);
 
-/// Creates a SQL `COUNT(DISTINCT ...)` expression
-///
-/// As with most bare functions, this is not exported by default. You can import
-/// it specifically as `diesel::dsl::count_distinct`, or glob import
-/// `diesel::dsl::*`
-///
-/// # Examples
-///
-/// ```rust
-/// # #[macro_use] extern crate diesel;
-/// # include!("../doctest_setup.rs");
-/// # use diesel::dsl::*;
-/// #
-/// # fn main() {
-/// #     use schema::posts::dsl::*;
-/// #     let connection = &mut establish_connection();
-/// let unique_user_count = posts.select(count_distinct(user_id)).first(connection);
-/// assert_eq!(Ok(2), unique_user_count);
-/// # }
-/// ```
+#[doc(hidden)]
+#[cfg(all(feature = "with-deprecated", not(feature = "without-deprecated")))]
+#[deprecated(note = "Use `AggregateExpressionMethods::aggregate_distinct` instead")]
 pub fn count_distinct<T, E>(expr: E) -> CountDistinct<T, E::Expression>
 where
     T: SqlType + SingleValue,
-    E: AsExpression<T>,
+    E: crate::expression::AsExpression<T>,
 {
     CountDistinct {
         expr: expr.as_expression(),