    (wrap-jdbc-fn jdbc/update! table value (prepare-params where-clause param-vals))))
 
 (defn delete!
+  "Delete a record from a table."
+  {:added "0.2.0"}
   ([table]
    (delete! table nil))
   ([table where-clause]

(ns fhofherr.clj-db-util.core
  (:require [clojure.java.jdbc :as jdbc]
            [clojure.tools.logging :as log]
            [clojure.java.io :as io]

(alter-meta! #'map->TransactionState assoc :no-doc true)

(defn transaction-state?
  "Test if the passed object represents an transaction state."
  {:added "0.2.0"}
  [tx-state]
  (instance? TransactionState tx-state))

(def err-transaction-rolled-back {:error "Transaction rolled back"})

(defn- rollback-only?
  [{:keys [t-con]}]
  {:pre [t-con]}
  (jdbc/db-is-rollback-only t-con))

(defn- set-rollback-only!
  [{:keys [t-con] :as tx-state}]
  {:pre [t-con (transaction-state? tx-state)]}
  (jdbc/db-set-rollback-only! t-con)
  tx-state)

(defn ^:dynamic *exception-during-transaction*
  "Handle exceptions that occur during a database transaction. The default implementation
  logs the occured exception and then rolls back the transaction. As this method is
  dynamic it may be rebound to another implementation. Implementors must then take care
  of rolling back the transaction if necessary."
  {:added "0.2.0"}
  [tx-state ^Exception ex]
  (log/warn ex "Exception occured during transaction")
  ;; TODO repeatedly call and log getNextException (if possible) (see java.sql.BatchUpdateException)
