jOOQ 3.9.0 seems to have added support for PostgreSQL's INSERT INTO ... ON CONFLICT (AKA upsert) feature. Will this be added to Suricatta?

Had a problem exists between chair and keyboard moment.

Though dsl/join was referred into namespace clojure string join was accidentally used in code.

Hi. I was trying to use extended types and stumbled upon this problem.
In documentation you gives an example of extending types to support json. And it works perfectly if one inserts with raw sql (insert into t1...). However if one uses insert-values:

(with-open [ctx (connection)]
  (sc/execute ctx (-> (dsl/insert-into :table)
                      (dsl/insert-values {:data {:a 1}}))))

It fails with exception:

2. Unhandled org.jooq.exception.DataAccessException
   SQL [insert into shipments (data) values ('{"a":1}'::jsonb)]; The
   column index is out of range: 1, number of columns: 0.

1. Caused by org.postgresql.util.PSQLException
   The column index is out of range: 1, number of columns: 0.

If I add (fmt/get-sql) after insert-values it'll work.

Can one create a table index with the Suricatta DSL?

Hi,
Really enjoying using suricatta in my project but I have the follow question.
I am trying to add support for async queries to my project The docs suggest to do the following,

(defn execute
  ([ctx q] (execute ctx q {}))
  ([ctx q opts]
   (let [act (.-act ctx)
         fun #(% (exc/try-on (sc/execute ctx q)))]
     (p/promise
      (fn [deliver]
        (send-off act (fn [_] (fun deliver))))))))

(defn fetch
  ([ctx q]
   (fetch ctx q {}))
  ([ctx q opts]
   (let [act (.-act ctx)
         fun #(% (exc/try-on (sc/fetch ctx q opts)))]
     (p/promise
      (fn [deliver]
        (send-off act (fn [_] (fun deliver))))))))

However I get the following error

java.lang.IllegalArgumentException: No matching field found: act for class suricatta.types.Context

So it seems like I don't have access to the actor for that type. I am assuming that -act is the actor we we use send-off later on.

I can see that the actor was refactor out in this commit,
d599e22
What is the correct way to support aysnc queries? Was this removal on purpose?

Thanks

In a clean repl without requiring suricatta.format this:

(db/fetch-one conn (-> (dsl/insert-into :table)
                       (dsl/insert-values {:xxx "yyy"})))

will fail with an error:

IllegalArgumentException No implementation of method: :-sql of protocol:
#'suricatta.proto/IRenderer found for class: org.jooq.impl.InsertImpl  clojure.core/-cache-protocol-fn (core_deftype.clj:568)

after requiring suricatta.format everything works fine.

user=> (fmt/sqlvec (-> (dsl/update :foo) (dsl/set :foo nil)))
["update foo set foo = ?" nil]
user=> (fmt/sqlvec (-> (dsl/update :foo) (dsl/set :foo nil)) {:dialect :postgresql})
["update foo set foo = cast(? as varchar)" nil]

Most likely an issue with jOOQ.

> (-> (dsl/select :name)
      (dsl/from :book)
      (dsl/offset 100)
      (dsl/limit 10)
      (fmt/get-sql))

"select name from book limit ?"

This is because of:

SelectOffsetStep limit(int numberOfRows)
This is the same as calling limit(int, int) with offset = 0, or calling .limit(numberOfRows).offset(0)

http://www.jooq.org/javadoc/latest/org/jooq/SelectLimitStep.html#limit-int-