Not to mention: How would these protocol implementations know to translate between the Postgres column name (for a tstzrange) and the tick :tick/beginning and `:tick/end` Clojure hashmap key names

For setting parameters, you could add metadata to your tick hash map so it would implement SettableParameter as needed. Or you could extend SettableParameter to hash maps but that would likely conflict with any other code trying to do that.

For ReadableColumn, there's nothing specific you can do. However, there are various -adapter versions of the result set builders that let you override the column reading (the builder-adapter is probably the better way to do that since you can use it to wrap an existing builder).

Further thoughts: The tick docs state:

In tick, an interval is a span of time defined by two points in time, the first being before the second.

Intervals are maps containing both a tick/beginning and a tick/end entry. This flexible design allows any Clojure map to be treated as an interval.

No, you'd need to preprocess your hash maps.

OK

For an arbitrary PreparedStatement, you can try calling https://docs.oracle.com/en/java/javase/11/docs/api/java.sql/java/sql/PreparedStatement.html#getParameterMetaData() and see if that gives you enough information to figure out what parameter ix corresponds to.

Note that those don't correspond to columns because those aren't actually known at that point.

(columns -- labels -- are only known for result sets)

OIC, that seems like it might be good enough.... I already extend SettableParameter to clojure.lang.IPersistentMap in order to convert hashmaps to either jsonb or json (which I determine via something like:

(let [meta      (.getParameterMetaData ps)
      type-name (.getParameterTypeName meta i)

Note that those don't correspond to columns because those aren't actually known at that point.

I don't need/want to know the column/label

Yeah, you can get the types of the parameters but not any associated name (since they might not correspond to columns anyway).

I handle postgres tstzrange and tsrange to tick intervals in my clojure hobby project, and do it as follows. Extend the protocol for PGObjects:

(defmulti pgobject->clj
  #(keyword (when % (.getType ^org.postgresql.util.PGobject %))))

(extend-protocol rs/ReadableColumn
  ;; Convert Postgres objects to some clojure value.
  org.postgresql.util.PGobject
  (read-column-by-label [^org.postgresql.util.PGobject v _]
    (pgobject->clj v))
  (read-column-by-index [^org.postgresql.util.PGobject v _2 _3]
    (pgobject->clj v)))

(defn ^:private parse-range
  [^String s]
  (let [[start end] (-> (subs s 1 (dec (count s)))
                        (string/replace #"\"" "")
                        (string/split #","))]
    [(str (first s))
     start
     end
     (str (last s))]))

(defn ^:private pgobject->interval
  "Converts Postgres range string into tstzrange or tsrange depending
   on which date parse function f is passed as argument. Attaches :type
   :interval metadata to result for consistency with input type."
  [f s]
  (let [[_ start end _] (parse-range s)]
    (-> (zipmap [:tick/beginning :tick/end]
                (map #(some-> % (string/replace #" " "T") f)
                     [start end]))
        (with-meta {:ajanottaja/type :interval}))))

;; Read PG tstzrange and tsrange
(defmethod pgobject->clj :tstzrange
  [^org.postgresql.util.PGobject x]
  (some->> x
           .getValue
           (pgobject->interval (comp t/instant t/zoned-date-time))))


(defmethod pgobject->clj :tsrange
  [^org.postgresql.util.PGobject x]
  (some->> x
           .getValue
           (pgobject->interval (comp t/instant t/date-time))))

For the opposite direction I simply add metadata to the clojure map like ^{:ns/type :interval} and then dispatch on that in the settable parameter protocol extension. 🙂