#12: Add support for UUID and JSON/JSONB

Author: alaisi

README.md

@@ -116,20 +116,29 @@ Channel-returning functions can be composed with `dosql` macro that returns resu
 ; {:now-promoting [{:id 1, product_id 1002}]}
 ```
 
+## JSON and JSONB
+
+Using JSON types requires `[cheshire "5.5.0"]` and reading the ns `postgres.async.json`. 
+
+```clojure
+(require '[postgres.async.json])
+
+(<!! (query! db ["select $1::JSONB" {:hello "world"}]))
+; [{:jsonb {:hello "world"}}]
+```
+
 ## Custom column types
 
 Support for custom types can be added by extending `IPgParameter` protocol and `from-pg-value` multimethod.
 
 ```clojure
-(require '[cheshire.core :as json])
-
 (extend-protocol IPgParameter 
-  clojure.lang.IPersistentMap
-  (to-pg-value [value]
-    (.getBytes (json/generate-string value))))
+  com.example.MyHStore
+  (to-pg-value [store]
+    (.getBytes (str store) "UTF-8")))
 
-(defmethod from-pg-value com.github.pgasync.impl.Oid/JSON [oid value]
-  (json/parse-string (String. value))
+(defmethod from-pg-value com.github.pgasync.impl.Oid/HSTORE [oid ^bytes value]
+  (my-h-store/parse-string (String. value "UTF-8)))
 ```
 
 ## Dependencies

project.clj

@@ -7,7 +7,8 @@
         :url "http://github.com/alaisi/postgres.async.git"}
   :dependencies [[org.clojure/clojure "1.6.0"]
                  [org.clojure/core.async "0.1.346.0-17112a-alpha"]
-                 [com.github.alaisi.pgasync/postgres-async-driver "0.5"]]
+                 [com.github.alaisi.pgasync/postgres-async-driver "0.6"]
+                 [cheshire "5.5.0" :scope "provided"]]
   :lein-release {:deploy-via :clojars}
   :global-vars {*warn-on-reflection* true}
   :target-path "target/%s"

src/postgres/async/json.clj

@@ -0,0 +1,27 @@
+(ns postgres.async.json
+  (:require [postgres.async :refer [from-pg-value IPgParameter]]
+            [cheshire.core :as json]
+            [cheshire.parse])
+  (:import [java.nio.charset StandardCharsets]))
+
+(defn- json->coll [^bytes value]
+  (binding [cheshire.parse/*use-bigdecimals?* true]
+    (json/parse-string (String. value StandardCharsets/UTF_8) true)))
+
+(defn- coll->json [coll]
+  (.getBytes (json/generate-string coll) StandardCharsets/UTF_8))
+
+(extend-protocol IPgParameter 
+  clojure.lang.IPersistentCollection
+  (to-pg-value [coll]
+    (coll->json coll))
+  clojure.lang.IPersistentMap
+  (to-pg-value [map]
+    (coll->json map)))
+
+(defmethod from-pg-value com.github.pgasync.impl.Oid/JSON [oid value]
+  (json->coll value))
+
+(defmethod from-pg-value com.github.pgasync.impl.Oid/JSONB [oid value]
+  (json->coll value))
+

test/postgres/async/json_test.clj

@@ -0,0 +1,36 @@
+(ns postgres.async.json-test
+  (:require [postgres.async :refer :all]
+            [postgres.async.json]
+            [clojure.test :refer :all]
+            [postgres.async-test :refer [db-fixture wait *db*]]))
+
+(use-fixtures :each db-fixture)
+
+(deftest json-queries
+
+  (testing "json is returned as json using keywords"
+    (let [rs (wait (query! *db*
+                           ["select '{\"name\":\"demo\",\"c\":[1,2]}'::JSON as j"]))]
+      (is (= "demo" (get-in rs [0 :j :name])))
+      (is (= [1 2] (get-in rs [0 :j :c])))))
+
+  (testing "json array parameter is returned as vec"
+        (let [rs (wait (query! *db* ["select $1::JSON as j" ["a" "b"]]))]
+          (is (= ["a" "b"] (get-in rs [0 :j])))))
+
+  (testing "json parameter is returned as map"
+    (let [rs (wait (query! *db* ["select $1::JSON as j" {:a "b"}]))]
+      (is (= {:a "b"} (get-in rs [0 :j]))))))
+
+(deftest jsonb-queries
+
+  (testing "jsonb array parameter is returned as vec"
+        (let [rs (wait (query! *db* ["select $1::JSONB as j" ["a" [1 2]]]))]
+          (is (= ["a" [1 2]] (get-in rs [0 :j])))))
+
+  (testing "jsonb parameter is returned as map"
+    (let [rs (wait (query! *db* ["select $1::JSONB as j" {:a nil :b true :c "s"}]))]
+      (is (nil? (get-in rs [0 :j :a])))
+      (is (= true (get-in rs [0 :j :b])))
+      (is (= "s" (get-in rs [0 :j :c]))))))
+

test/postgres/async_test.clj

@@ -3,10 +3,10 @@
             [clojure.core.async :refer [<!! go]]
             [postgres.async :refer :all]))
 
-(def ^:private ^:dynamic *db*)
+(def ^:dynamic *db*)
 (def table "clj_pg_test")
 
-(defn- wait [channel]
+(defn wait [channel]
   (let [r (<!! channel)]
     (if (instance? Throwable r)
       (throw r))
@@ -17,7 +17,7 @@
   (wait (execute! db [(str "create table " table " (
                            id serial, t varchar(10))")])))
 
-(defn- db-fixture [f]
+(defn db-fixture [f]
   (letfn [(env [name default]
             (or (System/getenv name) default))]
     (binding [*db* (open-db {:hostname (env "PG_HOST" "localhost")
@@ -34,25 +34,31 @@
 (use-fixtures :each db-fixture)
 
 (deftest queries
+
   (testing "query returns rows as map"
     (let [rs (wait (query! *db* ["select 1 as x"]))]
       (is (= 1 (get-in rs [0 :x]))))))
 
 (deftest query-for-array
+
   (testing "arrays are converted to vectors"
     (let [rs (wait (query! *db* ["select '{1,2}'::INT[] as a"]))]
       (is (= [1 2] (get-in rs [0 :a])))))
+
   (testing "nested arrays are converted to vectors"
     (let [rs (wait (query! *db* ["select '{{1,2},{3,4},{5,NULL}}'::INT[][] as a"]))]
       (is (= [[1 2] [3 4] [5 nil]] (get-in rs [0 :a]))))))
 
 (deftest inserts
+
   (testing "insert returns row count"
     (let [rs (wait (insert! *db* {:table table} {:t "x"}))]
       (is (= 1 (:updated rs)))))
+
   (testing "insert with returning returns generated keys"
     (let [rs (wait (insert! *db* {:table table :returning "id"} {:t "y"}))]
       (is (get-in rs [:rows 0 :id]))))
+
   (testing "multiple rows can be inserted"
     (let [rs (wait (insert! *db*
                              {:table table :returning "id"}
@@ -61,6 +67,7 @@
       (is (= 2 (count (:rows rs)))))))
 
 (deftest updates
+
   (testing "update returns row count"
     (let [rs (wait (insert! *db*
                              {:table table :returning "id"}
@@ -73,13 +80,15 @@
       (is (= 2 (:updated rs))))))
 
 (deftest sql-macro
+
   (testing "dosql returns last form"
     (is (= "123" (wait (go (dosql
                             [tx (begin! *db*)
                              rs (query! tx ["select 123 as x"])
                              rs (query! tx ["select $1::text as t" (:x (first rs))])
                              _  (commit! tx)]
                             (:t (first rs))))))))
+
   (testing "dosql short-circuits on errors"
     (let [e (Exception. "Oops!")
           executed (atom 0)]