YeSQL mit Verbindungspool?

Question

Ich überprüfe, ob YeSQL in meinem Clojure-Projekt helfen kann, aber ich kann kein Beispiel für YeSQL finden, das einen Verbindungspool verwendet.

bedeutet dies, dass YeSQL eine neue Verbindung zu jeder Anweisung erstellt?

Ich fand auch ein Beispiel zur Verwendung von Transaktionen mit clojure.java.jdbc/with-db-transaction, aber ich finde, es ist veraltet (ich habe es noch nicht versucht).

Bedeutet dies, dass YeSQL von clojure.java.jdbc abhängt, um die Kontrolle zu übernehmen? sollte ich in diesem Fall nicht nur clojure.java.jdbc alleine verwenden, da YeSQL nicht viel mehr bietet (abgesehen von der Benennung meiner Abfragen und ihrer Externalisierung)?

Dank im Voraus

Answer 1

YeSQL keine Verbindungen oder Verbindungs-Pooling nicht handhaben. Sie müssen es extern behandeln und eine Verbindungsinstanz für die Abfragefunktion bereitstellen.

Wie Sie aus dem YeSQL Beispiel von README sehen:

; 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")}) 

Wenn Sie fragen, wie Connection-Pool hinzufügen Umgang Sie könnten ein Beispiel aus Clojure Cookbook überprüfen.

Wie für die Transaktionsabwicklung ist YeSQL Dokumentation keine, aber source ist ganz einfach zu verstehen:

(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)))))) 

So wird es nur eine Funktion erzeugen, die entweder clojure.java.jdbc/execute! oder clojure.java.jdbc/insert! mit der erzeugten Abfrage nennen. Möglicherweise müssen Sie für weitere Details auf die Dokumentation dieser Funktionen zurückgreifen.

Answer 2

Bei Transaktionen, die YesQL verwenden, wickle ich die YesQL-Aufrufe in einen Aufruf von clojure.java.jdbc/with-db-transation und übergebe die generierten Verbindungsdetails an den YesQL-Funktionsaufruf, den sie verwenden die standardmäßige Nicht-Transaktionsverbindung, falls angegeben. Zum Beispiel:

;; 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})) 

Alle gewickelten YesQL Anrufe der {:connection t-con} Karte verwenden, werden Teil derselben Transaktion.