seaquell.to-sql — seaquell 0.5.0

alias-to-sql clj

(alias-to-sql as)

arith-bin-ops clj

as-coll clj

(as-coll xs)

as-join-op clj

(as-join-op x)

begin-clause clj

(begin-clause begin)

between-to-sql clj

(between-to-sql parent-prec op [e1 e2 e3])

bin-op-to-sql clj

(bin-op-to-sql parent-prec op args)

bound-to-sql clj

(bound-to-sql bound)

case-to-sql clj

(case-to-sql v cases)

cases-to-sql clj

(cases-to-sql cases)

cast-to-sql clj

(cast-to-sql e t)

collate-clause clj

(collate-clause collate)

column-def-to-sql clj

(column-def-to-sql col)

column-defs-to-sql clj

(column-defs-to-sql cols)

column-to-sql clj

(column-to-sql col)

columns-to-sql clj

(columns-to-sql cols)

cond-to-sql clj

(cond-to-sql cases)

constraint-to-sql clj

(constraint-to-sql {{:keys [check collate default foreign-key generated not-null
                            primary-key references unique]
                     :as c}
                      :constraint
                    id :id})

constraints-to-sql clj

(constraints-to-sql xs join-fn)

cte-to-sql clj

(cte-to-sql {:keys [cte columns as]})

ctype-to-sql clj

(ctype-to-sql ctype)

db-entity clj

(db-entity ent idx tbl trg view)

deferrable-clause clj

(deferrable-clause {:keys [initially modifier] :as deferrable})

delimit clj

(delimit l r x)

do-clause clj

(do-clause action)

else? clj

(else? x)

expr-to-sql clj

expr-to-sql* clj

(expr-to-sql* prec x)

field-to-sql clj

(field-to-sql x)

fields-to-sql clj

(fields-to-sql fs)

filter-clause clj

(filter-clause fw)

fn-call-to-sql clj

(fn-call-to-sql func args)

fn-map clj

foreign-key-clause clj

(foreign-key-clause {:keys [columns references]})

frame-to-sql clj

(frame-to-sql {:keys [frame bound lo-bound hi-bound exclude] :as f})

from-clause clj

(from-clause from)

generated-clause clj

(generated-clause {:keys [always as stored virtual]})

group-by-clause clj

(group-by-clause group-by)

having-clause clj

(having-clause having)

in-parens clj

in-quotes clj

in-ticks clj

interval-to-sql clj

(interval-to-sql {:keys [interval units]})

join-but-nils clj

(join-but-nils sep xs)

join-by-comma clj

join-by-space clj

join-op-to-sql clj

(join-op-to-sql {:keys [source op on using] :as join})

join-src-to-sql clj

(join-src-to-sql {:keys [source as indexed-by] :or {indexed-by ""} :as src})

limit-clause clj

(limit-clause l)

map-to-expr clj

(map-to-expr m)

modifier-to-sql clj

name-to-sql clj

(name-to-sql x)

normalize-fn-or-op clj

(normalize-fn-or-op op)

not-null-to-sql clj

(not-null-to-sql {:keys [on-conflict]})

offset-clause clj

(offset-clause o)

on-clause clj

(on-clause on)

on-conflict-clause clj

(on-conflict-clause on-conflict)

order-by-clause clj

(order-by-clause xs)

order-item clj

(order-item x)

order-item? clj

(order-item? x)

order-map clj

over-clause clj

(over-clause oc)

partition-by-clause clj

(partition-by-clause part-by)

pk-or-unique-to-sql clj

(pk-or-unique-to-sql prefix {:keys [columns order on-conflict autoincrement]})

precedence clj

precedence-levels clj

predicate? clj

(predicate? x)

query-clauses clj

(query-clauses xs semi)

raw-to-sql clj

(raw-to-sql {:keys [raw]})

references-to-sql clj

(references-to-sql {:keys [table columns match on-delete on-update deferrable]})

rel-bin-ops clj

rel-op-to-sql clj

(rel-op-to-sql parent-prec op args)

renamed-ops clj

select-clause clj

(select-clause modifier fields)

set-clause clj

(set-clause set-c)

to-sql clj multimethod

to-sql-keywords clj

(to-sql-keywords x)

trigger-ev-to-sql clj

(trigger-ev-to-sql {:keys [fire op] :as stmt})

unary-op-to-sql clj

(unary-op-to-sql op arg)

unary-ops clj

unary-prec clj

using-clause clj

(using-clause using)

values-to-sql clj

(values-to-sql values)

where-clause clj

(where-clause w)

win-to-sql clj

(win-to-sql {:keys [win as] :as w})

windef-to-sql clj

(windef-to-sql {:keys [base-win partition-by order-by] :as w})

window-clause clj

(window-clause {:keys [wins] :as w})

with-clause clj

(with-clause {:keys [ctes recursive] :as w})