com.verybigthings.penkala.statement — com.verybigthings/penkala 0.9.1

*cte-registry* clj

*current-cte* clj

*scopes* clj

*use-column-db-name-for* clj

any-join-has-projection? clj

(any-join-has-projection? joins)

compile-case-else clj

(compile-case-else acc env rel else)

compile-case-value clj

(compile-case-value acc env rel value)

compile-case-whens clj

(compile-case-whens acc env rel whens)

compile-function-call clj multimethod

compile-order-by clj

(compile-order-by acc env rel order-by)

compile-updatable-value clj

(compile-updatable-value acc env rel value)

compile-value-expression clj multimethod

empty-acc clj

format-delete-query clj

format-delete-query-without-params-resolution clj

(format-delete-query-without-params-resolution env deletable)

format-insert-query clj

(format-insert-query env insertable)

format-select-query clj

format-select-query-without-params-resolution clj

(format-select-query-without-params-resolution env rel)

format-update-query clj

format-update-query-without-params-resolution clj

(format-update-query-without-params-resolution env updatable)

get-insertable-columns clj

(get-insertable-columns insertable data)

get-resolved-column-identifier clj

(get-resolved-column-identifier env rel resolved-col col-def)

make-format-query-with-params-resolution clj

(make-format-query-with-params-resolution query-fn)

register-cte! clj

(register-cte! rel)

rel-should-be-implicitely-grouped-by? clj

(rel-should-be-implicitely-grouped-by? {:keys [projection aliases->ids columns
                                               joins]})

sort-ctes clj

(sort-ctes ctes-acc)

with-cte clj

(with-cte env acc cte)

with-cte-cycle clj

(with-cte-cycle env acc cte)

with-cte-registry! clj macro

(with-cte-registry! env & body)

Binds a cte-registry if it's not bound yet. Otherwise, it leaves the binding in place. This ensures that only the entry function will bind the registry, and then process it, since format-query functions can be called recursively.

Since we can ancounter an CTE anywhere in the tree, we need a registry, so we could place the CTE queries before the normal query.

with-cte-search clj

(with-cte-search env acc cte)

with-ctes clj

(with-ctes env acc)

(with-ctes env acc ctes-acc)

with-distinct clj

(with-distinct acc env rel)

with-explicit-group-by clj

(with-explicit-group-by acc env {:keys [group-by] :as rel})

with-fetch clj

(with-fetch acc _ rel)

with-group-by clj

(with-group-by acc env {:keys [group-by] :as rel})

with-having clj

(with-having acc env rel)

with-implicit-group-by clj

(with-implicit-group-by acc env rel path-prefix)

with-insertable-column-value clj

(with-insertable-column-value acc env insertable col-value)

with-insertable-columns-and-values clj

(with-insertable-columns-and-values acc env insertable)

with-insertable-values clj

(with-insertable-values acc env insertable insertable-columns data)

with-joins clj

(with-joins acc env rel)

(with-joins acc env rel path-prefix)

with-lock clj

(with-lock acc _ rel)

with-offset clj

(with-offset acc _ rel)

with-on-conflict clj

(with-on-conflict acc env insertable)

with-on-conflict-conflict-target clj

(with-on-conflict-conflict-target acc env insertable)

with-on-conflict-updates clj

(with-on-conflict-updates acc env insertable)

with-on-conflict-where clj

(with-on-conflict-where acc env insertable)

with-order-by clj

(with-order-by acc env rel)

with-projection clj

(with-projection acc env rel)

(with-projection acc env rel path-prefix)

with-returning clj

(with-returning acc env rel)

with-selectable-from clj

(with-selectable-from acc env rel)

with-updatable-from clj

(with-updatable-from acc env updatable)

with-updates clj

(with-updates acc env updatable)

with-using clj

(with-using acc env deletable)

with-where clj

(with-where acc env rel)