fmnoise.qb — org.clojars.fmnoise/qb 4.1.0

->binding clj

(->binding v & [uniq?])

add-input clj

(add-input q binding source & [expand-coll?])

Adds query input. Last optional agrument turns automatic expanding of collection source into collection binding

exclude clj

(exclude q binding input & [input-name])

find clj

(find bindings)

(find q bindings & [override?])

Adds bindings to query :find

find-coll clj

(find-coll binding)

(find-coll q binding)

Adds collection binding to query :find

find-scalar clj

(find-scalar binding)

(find-scalar q binding)

Adds scalar binding to query :find

in clj

(in q src)

(in q binding source & inputs)

Adds query input. If binding for input is not specified, its added as $ as first argument. If source is set?, the corresponding collection binding is added

not-join clj

(not-join q conditions & [inputs])

or-join clj

(or-join q conditions & [inputs])

query clj

(query data)

(query src data)

Transforms map or vector into query map. Query options can be supplied as keys (only for maps): :in for source binding (defaults to $) :find for defining result binding (defaults to ?e) :from for defining entity binding (defaults to ?e) :nil which indicates how to handle nils, defaults to :missing, possible options are: :missing - replace nil values with [(missing? ...)] :not - replace nil values with [(not [...])] :skip - skip nil values :aggregate which can contain either a keyword (for attribute) or symbol (for function) or collection of function symbol and keyword in any order like [:order/total 'sum] or ['sum :order/total] when aggregation is used, :with instruction is automatically added :where map or vector of query conditions

(query {:user/id 1 :user/type :admin}) ;; => {:query {:find [[?e ...]], :where [[?e :user/id ?user-id] [?e :user/type ?user-type]], :in [?user-id ?user-type]}, :args [1 :admin]}

(query {:find '?user :where {:user/id 1}}) ;; => {:query {:find [[?user ...]], :where [[?user :user/id ?user-id]], :in [?user-id]}, :args [1]}

(query {:aggregate ['sum :order/total] :where {:order/id '_}}) ;; => {:query {:find [(sum ?order-total) .], :where [[?e :order/id] [?e :order/total ?order-total]]}}

(query {:aggregate :order/customer :where [:order/id '_]}) ;; => {:query {:find [[?order-customer ...]], :where [[?e :order/id] [?e :order/customer ?order-customer]]}}

(query [:user/id 1 :user/type :admin]) ;; => {:query {:find [[?e ...]], :where [[?e :user/id ?user-id] [?e :user/type ?user-type]], :in [?user-id ?user-type]}, :args [1 :admin]}

where clj

(where q condition)

(where q condition input)

Adds condition to query. Accepts optional input If input is nil, condition is transformed into (not [...]). If input is set?, the corresponding collection binding is addded

where* clj

(where* q conditions)

Adds multiple conditions/values from supplied collection to query using where. If condition needs to have supplied value, it should be wrapped in vector eg (where* q [[?e :order/id] [['?e :order/customer '?c] customer]

where-> clj

(where-> q & conditions)

Adds multiple conditions/values to query using where. If condition needs to have supplied value, it should be wrapped in vector eg (where-> q ['?e :order/id] [['?e :order/customer '?c] customer]

where-missing clj

(where-missing q condition)

Adds missing? condition to query. Condition may have or may not have source binding, $ is used then

where-not clj

(where-not q condition)

(where-not q condition input)

Adds not condition to query. Accepts optional value. If value is set, it's used as function to filter out conditions

where-not* clj

(where-not* q conditions)

Adds multiple conditions/values from supplied collection to query using where-not. If condition needs to have supplied value, it should be wrapped in vector eg (where-not* q [[?e :order/cancelled] ['?e :order/status '?s] status])

where? clj

(where? q cond-vals)

(where? q condition input)

Adds condition to query only if supplied input is not nil. Accepts either query condition and value or map/list/vector of conditions and values eg: (where? q {'[?e :order/id ?id] id '[?e :order/customer ?c] customer} (where? q ['[?e :order/id ?id] id '[?e :order/customer ?c] customer]

with clj

(with q & bindings)

Adds with part to query