YeSQL con pool di connessioni?

Question

Sto verificando se YeSQL può aiutare nel mio progetto Clojure, ma non riesco a trovare alcun esempio di YeSQL utilizzando un pool di connessioni.

significa che YeSQL crea una nuova connessione a ogni istruzione?

Ho anche trovato un esempio su come utilizzare le transazioni utilizzando clojure.java.jdbc/con-db-transaction, ma ritengo che sia obsoleto (non ho ancora provato).

significa che YeSQL dipende da clojure.java.jdbc per il controllo di commit/rollback? in questo caso, non dovrei usare solo clojure.java.jdbc, dal momento che YeSQL non offre molto di più (oltre a nominare le mie query e esternarle)?

grazie in anticipo

Answer 1

YeSQL non gestisce connessioni o pool di connessioni. È necessario gestirlo esternamente e fornire un'istanza di connessione alla funzione di query.

Come si può vedere dall'esempio YeSQL da README:

; Define a database connection spec. (This is standard clojure.java.jdbc.) 
(def db-spec {:classname "org.postgresql.Driver" 
       :subprotocol "postgresql" 
       :subname "//localhost:5432/demo" 
       :user "me"}) 

; Use it standalone. Note that the first argument is the db-spec. 
(users-by-country db-spec "GB") 
;=> ({:count 58}) 

; Use it in a clojure.java.jdbc transaction. 
(require '[clojure.java.jdbc :as jdbc]) 
(jdbc/with-db-transaction [connection db-spec] 
    {:limeys (users-by-country connection "GB") 
    :yanks (users-by-country connection "US")}) 

Se si chiede come aggiungere pool di connessione movimentazione si potrebbe verificare un esempio da Clojure Cookbook.

Per quanto riguarda la gestione delle transazioni, la documentazione YeSQL è nessuno, ma source è abbastanza facile da capire:

(defn- emit-query-fn 
    "Emit function to run a query. 
    - If the query name ends in `!` it will call `clojure.java.jdbc/execute!`, 
    - If the query name ends in `<!` it will call `clojure.java.jdbc/insert!`, 
    - otherwise `clojure.java.jdbc/query` will be used." 
    [{:keys [name docstring statement]}] 
    (let [split-query (split-at-parameters statement) 
     {:keys [query-args display-args function-args]} (split-query->args split-query) 
     jdbc-fn (cond 
       (= [\< \!] (take-last 2 name)) `insert-handler 
       (= \! (last name)) `execute-handler 
       :else `jdbc/query)] 
    `(def ~(fn-symbol (symbol name) docstring statement display-args) 
     (fn [db# ~@function-args] 
     (~jdbc-fn db# 
        (reassemble-query '~split-query 
            ~query-args)))))) 

quindi sarà solo creare una funzione che sia chiamata clojure.java.jdbc/execute! o clojure.java.jdbc/insert! con la query generato. Potrebbe essere necessario fare riferimento alla documentazione di tali funzioni per ulteriori dettagli.

Answer 2

Quando si eseguono transazioni utilizzando YesQL, eseguo il wrapping delle chiamate YesQL in una chiamata clojure.java.jdbc/with-db-transation e passa i dettagli della connessione generata alla chiamata della funzione YesQL, che verranno utilizzati al posto di la connessione standard senza transazione, se fornita. Per esempio:

;; supply a name for the transaction connection, t-con, based on the existing db connection 
(jdbc/with-db-transaction [t-con db-spec] 
    ;; this is the yesql call with a second map specifying the transaction connection 
    (create-client-order<! {...} {:connection t-con})) 

Tutte le chiamate YesQL avvolto utilizzando la mappa {:connection t-con} faranno parte della stessa transazione.