shadow.pgsql — thheller/shadow-pgsql 0.13.0

as-query clj

(as-query db args)

as-statement clj

(as-statement db args)

build-types clj

(build-types type-map table-naming column-naming)

(build-types type-registry type-map table-naming column-naming)

ConnectionScope clj protocol

-get-connection clj

(-get-connection _)

-with-connection clj

(-with-connection _ task-fn)

create-insert-sql clj

(create-insert-sql {:keys [types column-naming table-naming] :as db}
                   {:keys [table columns returning] :as spec})

create-update-sql clj

(create-update-sql {:keys [types table-naming column-naming] :as db}
                   {:keys [table columns where where-params] :as spec})

date-type clj

defquery clj macro

(defquery name sql & kv)

edn-type clj

(edn-type)

(edn-type edn-opts)

execute clj

(execute db stmt)

(execute db stmt params)

get-connection clj

(get-connection db)

hstore-keyword-type clj

hstore-string-type clj

insert clj

(insert db spec data)

insert-one clj

(insert-one db stmt data)

insert-one! clj

(insert-one! db table data)

(insert-one! db table data return-column)

shorthand for insert-one, but potential DANGER!

don't use with maps you got from an untrusted source will insert all values contained in the data map

if you expect {:user "name" :password "me"} but the user sends you {:user "name" :password "me" :admin true} you might run into trouble

use insert-one and specify {:columns [:user :password]} if you want to be safe.

(sql/insert-one! db :table data) returns the inserted data (sql/insert-one! db :table data :id) returns the id of the inserted row (sql/insert-one! db :table data [:id]) returns the data merged with the resulting map {:id ...}

int-set-type clj

int-type clj

int-vec-type clj

int2-type clj

int2-vec-type clj

int4-set-type clj

int4-type clj

int4-vec-type clj

int8-set-type clj

int8-type clj

int8-vec-type clj

keyword-set-type clj

keyword-type clj

stores keywords as-is

keyword-vec-type clj

legacy-keyword-type clj

stores keywords without leading ":"

long-set-type clj

long-type clj

long-vec-type clj

Naming clj protocol

from-sql-name clj

(from-sql-name this string)

to-sql-name clj

(to-sql-name this value)

now clj

(now)

numeric-type clj

numeric-vec-type clj

prepare clj

(prepare db stmt)

prepare-insert clj

(prepare-insert db spec)

prepare-query clj

(prepare-query db stmt)

prepare-update clj

(prepare-update db spec)

query clj

(query db q)

(query db query params)

result->map clj

(result->map key-fn)

(result->map key-fn value-fn)

(result->map key-fn value-fn init)

{:sql "SELECT * FROM something" :result (sql/result->map :id)}

will return {id1 row1, id2 row2, ...}

{:sql "SELECT key, value FROM something" :result (sql/result->map :key :value)}

returns {key1 value1, key2, value2, ...}

result->one-row clj

result is return as nil or row

result->vec clj

row->map clj

row->map-transform clj

(row->map-transform transform-fn)

returns row as map after calling (transform-fn map)

row->one-column clj

row is returned as the value of the first (only) column

set-type clj

(set-type item-type)

(set-type item-type requires-quoting)

short-type clj

start clj

(start {:keys [host port user database pool table-naming column-naming types
               metric-registry metric-collector]
        :or {host "localhost"
             port 5432
             table-naming (DefaultNaming.)
             column-naming (DefaultNaming.)
             types TypeRegistry/DEFAULT}
        :as opts})

stop clj

(stop db)

text-type clj

text-vec-type clj

timestamp-type clj

timestamp-vec-type clj

timestamptz-type clj

timestamptz-vec-type clj

update! clj

(update! db table data)

(update! {:keys [table-naming column-naming types] :as db}
         table
         data
         where
         params)

(sql/update! db :table {:column value, ...} "id = $1" id) this is also potentially dangerous since all columns are updated

vec-type clj

(vec-type item-type)

(vec-type item-type requires-quoting)

with-connection clj macro

(with-connection db & body)

with-dashes clj

(with-dashes x)

with-default-types clj

(with-default-types db & handlers)

with-transaction clj macro

(with-transaction db & body)

with-types clj

(with-types {:keys [table-naming column-naming] :as db} type-map)

copy db instance with custom type handlers {table-name {column-name type-handler}} types can also be declared per query

with-underscores clj

(with-underscores x)