Support FILTER for aggregate expressions (#42)

Also bumps the honeysql version to 1.0.461

Co-authored-by: Akshay Gupta <kitallis@gmail.com>

Author: scimetfoo

README.md

@@ -4,13 +4,15 @@ PostgreSQL extensions for the widely used [honeysql](https://github.com/jkk/hone
 
 This library aims to extend the features of honeysql to support postgres specific SQL clauses and some basic SQL DDL in addition to the ones supported by the parent library. This keeps honeysql clean and single-purpose, any vendor-specific additions can simply be separate libraries that work on top.
 
+## Breaking Change
+Implementation of `over` has been changed (from 0.2.2) to accept alias as an option and define the aggregator-function within the over clause and not in the select clause, this allows the inclusion of multiple window-function which was not possible in the previous implementation.
+
+The query creation and usage is exactly the same as honeysql.
+
 ## Index
 
 - [Usage](#usage)
-  - [Leiningen](#leiningen)
-  - [Maven](#maven)
   - [REPL](#REPL)
-  - [Breaking Change](#breaking-change)
   - [distinct on](#distinct-on)
   - [upsert](#upsert)
   - [insert into with alias](#insert-into-with-alias)
@@ -21,6 +23,7 @@ This library aims to extend the features of honeysql to support postgres specifi
   - [alter table](#alter-table)
   - [pattern matching](#pattern-matching)
   - [except](#except)
+  - [filter](#filter)
   - [SQL functions](#sql-functions)
 - [License](#license)
 
@@ -33,14 +36,9 @@ This library aims to extend the features of honeysql to support postgres specifi
          '[honeysql-postgres.helpers :as psqlh])
 ```
 
-### Breaking Change
-Implementation of `over` has been changed (from 0.2.2) to accept alias as an option and define the aggregator-function within the over clause and not in the select clause, this allows the inclusion of multiple window-function which was not possible in the previous implementation.
-
-The query creation and usage is exactly the same as honeysql.
-
 ### distinct-on
 `select` can be written with a `distinct on` clause
-``` clj
+``` clojure
 (-> (select :column-1 :column-2 :column-3)
     (from :table-name)
     (modifiers :distinct-on :column-1 :column-2)
@@ -180,6 +178,7 @@ The `ilike` and `not-ilike` operators can be used to query data using a pattern
     sql/format)
 => ["SELECT name FROM products WHERE name NOT ILIKE ?" "%name%"]
 ```
+
 ### except
 ```clojure
 (sql/format
@@ -190,6 +189,17 @@ The `ilike` and `not-ilike` operators can be used to query data using a pattern
 ```
 `except-all` works the same way as `except`.
 
+### filter
+
+``` clojure
+(-> (select (sql/call :count :*))
+    (filter [(sql/call :count :*) (where [:< :i 5]) :foo]
+            [(sql/call :count :*) (where [:between :i 3 10]) :bar])
+    (from (sql/raw "generate_series(1,10) AS s(i)"))
+    (sql/format))
+=> ["SELECT count(*) , count(*) FILTER (WHERE i < ?) AS foo, count(*) FILTER (WHERE i BETWEEN ? AND ?) AS bar FROM generate_series(1,10) AS s(i)" 5 3 10]
+```
+
 ### SQL functions
 The following are the SQL functions added in `honeysql-postgres`
 - not
@@ -249,8 +259,9 @@ The following are the SQL functions added in `honeysql-postgres`
 (sql/format (sql/call :check [:= :a :b] [:= :c :d]))
 ["CHECK(a = b AND c = d)"]
 ```
+
 ## License
 
-Copyright © 2020 Nilenso
+Copyright © 2021 Nilenso
 
 Distributed under the Eclipse Public License, the same as Clojure.

deps.edn

@@ -1,4 +1,4 @@
-{:deps    {honeysql/honeysql {:mvn/version "0.9.5" :exclusions [org.clojure/clojurescript]}}
+{:deps    {honeysql/honeysql {:mvn/version "1.0.461" :exclusions [org.clojure/clojurescript]}}
  :paths   ["src"]
  :aliases {:test        {:extra-paths ["test"]}
            :runner      {:extra-deps {com.cognitect/test-runner

pom.xml

@@ -23,7 +23,7 @@
     <dependency>
       <groupId>honeysql</groupId>
       <artifactId>honeysql</artifactId>
-      <version>0.9.5</version>
+      <version>1.0.461</version>
       <exclusions>
         <exclusion>
           <groupId>org.clojure</groupId>

src/honeysql_postgres/format.cljc

@@ -1,8 +1,8 @@
 (ns ^{:doc "Extension of the honeysql format functions specifically for postgreSQL"}
  honeysql-postgres.format
-  (:require [honeysql.format :as sqlf :refer [fn-handler format-clause format-modifiers]] ;; multi-methods
-            [honeysql-postgres.util :as util]
-            [clojure.string :as string]))
+  (:require [clojure.string :as string]
+            [honeysql.format :as sqlf :refer [fn-handler format-clause format-modifiers]] ;; multi-methods
+            [honeysql-postgres.util :as util]))
 
 (def ^:private custom-additions
   {:create-table 10
@@ -13,8 +13,9 @@
    :add-column 30
    :drop-column 40
    :create-view 40
-   :insert-into-as 60
+   :filter 54
    :over 55
+   :insert-into-as 60
    :partition-by 165
    :window 195
    :upsert 225
@@ -115,6 +116,18 @@
   (str "DO UPDATE SET " (sqlf/comma-join (for [[k v] values]
                                            (str (sqlf/to-sql k) " = " (sqlf/to-sql v))))))
 
+(defmethod format-clause :filter [[_ expr] sql-map]
+  (let [format (fn [expr]
+                 (let [[expression clause alias] (mapv sqlf/to-sql expr)]
+                   (->> alias
+                        (str " AS ")
+                        (when alias)
+                        (str expression " FILTER " clause))))]
+    (->> expr
+         (map format)
+         sqlf/comma-join
+         (str (when (seq (:select sql-map)) ", ")))))
+
 (defmethod format-clause :do-update-set [[_ values] _]
   (let [fields (or (:fields values) values)
         where  (:where values)]

src/honeysql_postgres/helpers.cljc

@@ -1,5 +1,5 @@
 (ns honeysql-postgres.helpers
-  (:refer-clojure :exclude [partition-by])
+  (:refer-clojure :exclude [partition-by filter])
   (:require [honeysql-postgres.format]
             [honeysql.helpers :as sqlh #?(:clj :refer :cljs :refer-macros) [defhelper]]))
 
@@ -13,6 +13,9 @@
 (defhelper do-update-set [m args]
   (assoc m :do-update-set (sqlh/collify args)))
 
+(defhelper filter [m args]
+  (assoc m :filter (sqlh/collify args)))
+
 (defhelper do-update-set! [m args]
   (assoc m :do-update-set! args))
 

test/honeysql_postgres/postgres_test.cljc

@@ -1,12 +1,12 @@
 (ns honeysql-postgres.postgres-test
-  (:refer-clojure :exclude [update partition-by])
+  (:refer-clojure :exclude [update partition-by filter])
   (:require [honeysql-postgres.helpers :as sqlph :refer [upsert on-conflict do-nothing on-conflict-constraint
                                                          returning do-update-set do-update-set!
                                                          alter-table rename-column drop-column
                                                          add-column partition-by insert-into-as
                                                          create-table rename-table drop-table
                                                          window create-view over with-columns
-                                                         create-extension drop-extension]]
+                                                         create-extension drop-extension filter]]
             [honeysql.helpers :as sqlh :refer [insert-into values where select columns
                                                from order-by update sset query-values
                                                modifiers]]
@@ -66,6 +66,17 @@
                          :do-update-set {:fields [:phone :name]
                                          :where  [:= :user.active false]}}}))))
 
+(deftest filter-test
+  (is (= ["count(*) FILTER (WHERE NOT i BETWEEN ? AND ?) AS a" 3 5]
+         (sql/format (filter [(sql/call :count :*) (where [:not [:between :i 3 5]]) :a]))))
+
+  (is (= ["SELECT count(*) , count(*) FILTER (WHERE s.i < ?) AS foo, count(*) FILTER (WHERE s.i BETWEEN ? AND ?) AS bar FROM generate_series(1,10) AS s(i)" 5 3 10]
+         (-> (select (sql/call :count :*))
+             (filter [(sql/call :count :*) (where [:< :s.i 5]) :foo]
+                     [(sql/call :count :*) (where [:between :s.i 3 10]) :bar])
+             (from (sql/raw "generate_series(1,10) AS s(i)"))
+             (sql/format)))))
+
 (deftest returning-test
   (testing "returning clause in sql generation for postgresql"
     (is (= ["DELETE FROM distributors WHERE did > 10 RETURNING *"]