com.verybigthings.penkala.relation — com.verybigthings/penkala 0.9.1

->deletable clj

(->deletable rel)

Converts a relation into an "deletable" record which can be used to compose a delete query

->insertable clj

(->insertable rel)

Converts a relation into an "insertable" record which can be used to compose an insert query

->on-conflict-updates clj

(->on-conflict-updates updates)

->updatable clj

(->updatable rel)

Converts a relation into an "updatable" record which can be used to compose an update query

->writeable clj

(->writeable constructor rel)

-writeable-returning clj

(-writeable-returning rel projection)

all-operations clj

and-predicate clj

(and-predicate rel predicate-type predicate-expression)

as-cte clj macro

(as-cte & args)

cross-join clj

(cross-join rel join-rel join-alias)

(cross-join rel join-rel join-alias join-projection)

cte->base-cte clj

(cte->base-cte cte)

cte->recursive-cte clj

(cte->recursive-cte cte-name recursive-type cte-rel recursive-rel)

cte-cycle clj

(cte-cycle rel col-name virtual-col-name using-virtual-col-name)

cte-extend-virtual clj

(cte-extend-virtual rel virtual-col-name)

cte-materialized clj

(cte-materialized rel is-materialized)

cte-search clj

(cte-search rel search-type col-name virtual-col-name)

cte-search-breadth-first clj

(cte-search-breadth-first rel col-name virtual-col-name)

cte-search-depth-first clj

(cte-search-depth-first rel col-name virtual-col-name)

Deletable clj

distinct clj

(distinct rel)

(distinct rel distinct-expression)

Adds a distinct or distinct on clause.

ensure-join-alias-on-projection clj

(ensure-join-alias-on-projection join-alias join-projection)

ex-info-missing-column clj

(ex-info-missing-column rel node)

except clj

(except rel other-rel)

Creates a relation that is a combination of two relations with the EXCEPT operator

extend clj

(extend rel col-name extend-expression)

Extends a relation with a computed column. This column will be automatically selected. Expression can reference previously extended columns by name:

(-> rel
  (extend :upper-name [:upper :name])
  (extend :lower-upper-name [:lower :upper-name]))

You can use reference these columns in any other value expression, and Penkala will correctly compile them in the generated SQL.

(-> rel
  (extend :upper-name [:upper :name])
  (extend :lower-upper-name [:lower :upper-name])
  (where [:= :lower-upper-name "FOO"]))

extend-with-aggregate clj

(extend-with-aggregate rel col-name agg-expression)

Extends the relation with a computed column that is an aggregate value (e.g. sum, max, min...). Root value expression must be a function. Penkala doesn't have any explicit support for the built in aggregate functions which means you can use whatever your DB supports, including custom aggregate functions.

If an aggregate column is selected, Penkala will automatically add a GROUP BY clause to the generated SQL.

(extend-with-aggregate rel :count [:count 1])

This column will be automatically selected.

extend-with-window clj

(extend-with-window rel col-name window-expression)

(extend-with-window rel col-name window-expression partitions)

(extend-with-window rel col-name window-expression partitions orders)

Extends a relation with a window function column.

extract-fields clj

fetch clj

(fetch rel fetch)

Sets the fetch parameter.

from clj

(from updatable from-rel from-alias)

full-join clj

(full-join rel join-rel join-alias join-on)

(full-join rel join-rel join-alias join-on join-projection)

get-delete-query clj

(get-delete-query deletable env params)

get-insert-query clj

(get-insert-query insertable env)

get-projected-columns clj

(get-projected-columns rel)

(get-projected-columns acc rel path-prefix)

get-select-query clj

(get-select-query rel env)

(get-select-query rel env params)

get-update-query clj

(get-update-query updatable env params)

group-by clj

(group-by rel group-by-clause)

Explicit GROUP BY. Penkala can infer a default GROUP BY expression, so this is not needed in most cases, but you can use it if you want to override the default behavior. Use this function if you want to GROUP BY GROUPING SETS, ROLLUP or CUBE

having clj

(having rel having-expression)

And having operation. If there's already a having clause set, this clause will be joined with AND

IDeletable clj protocol

-using clj

(-using this using-rel using-alias)

IInsertable clj protocol

-on-conflict-do clj

(-on-conflict-do this action conflicts update where-expression)

-with-inserts clj

(-with-inserts this inserts)

inner-join clj

(inner-join rel join-rel join-alias join-on)

(inner-join rel join-rel join-alias join-on join-projection)

inner-lateral-join clj

(inner-lateral-join rel join-rel join-alias join-on)

(inner-lateral-join rel join-rel join-alias join-on join-projection)

Insertable clj

intersect clj

(intersect rel other-rel)

Creates a relation that is a combination of two relations with the INTERSECT operator

IOnly clj protocol

-only clj

(-only this is-only)

IRelation clj protocol

-fetch clj

(-fetch this fetch)

-order-by clj

(-order-by this orders)

-extend-with-window clj

(-extend-with-window this col-name window-expression partitions orders)

-distinct clj

(-distinct this distinct-expression)

-rename clj

(-rename this prev-col-name next-col-name)

-join clj

(-join this join-type join-rel join-alias join-on join-projection)

-union clj

(-union this other-rel)

-select clj

(-select this projection)

-union-all clj

(-union-all this other-rel)

-with-parent clj

(-with-parent this parent)

-extend clj

(-extend this col-name extend-expression)

-intersect clj

(-intersect this other-rel)

-or-having clj

(-or-having this having-expression)

-offset clj

(-offset this offset)

-having clj

(-having this having-expression)

-except clj

(-except this other-rel)

-group-by clj

(-group-by this group-by-clause)

-wrap clj

(-wrap this)

-extend-with-aggregate clj

(-extend-with-aggregate this col-name agg-expression)

-lock clj

(-lock this lock-type locked-rows)

IUpdatable clj protocol

-from clj

(-from this from-rel from-alias)

-with-updates clj

(-with-updates this updates)

IWhere clj protocol

-or-where clj

(-or-where this where-expression)

-where clj

(-where this where-expression)

IWriteable clj protocol

-returning clj

(-returning this projection)

join clj

(join rel join-type join-rel join-alias join-on)

(join rel join-type join-rel join-alias join-on join-projection)

Joins another relation. Supported join types are:

• :inner
• :inner-lateral
• :left
• :left-lateral
• :right
• :full
• :cross

When joining a relation, columns from the joined relation must be referenced with a namespaced key. Key's namespace will be the join alias (e.g. :join-alias/column). If you need to reference a column that's deeply joined, you can use join aliases concatenated with a dot (e.g. :join-alias.another-join-alias/column)

join-on can be any value expression, so you can have as complex join predicates as you need.

left-join clj

(left-join rel join-rel join-alias join-on)

(left-join rel join-rel join-alias join-on join-projection)

left-lateral-join clj

(left-lateral-join rel join-rel join-alias join-on)

(left-lateral-join rel join-rel join-alias join-on join-projection)

limit clj

(limit rel limit)

Sets the fetch parameter. Equivalent to fetch, provided as a convenience

lock clj

(lock rel lock-type)

(lock rel lock-type locked-rows)

Lock selected rows

make-combined-relations-spec clj

(make-combined-relations-spec operator rel1 rel2)

normalize-operator clj

(normalize-operator [op-type operator])

offset clj

(offset rel offset)

Sets the offset parameter

on-conflict-do-nothing clj

(on-conflict-do-nothing insertable)

(on-conflict-do-nothing insertable conflicts)

(on-conflict-do-nothing insertable conflicts where-expression)

on-conflict-do-update clj

(on-conflict-do-update insertable conflicts updates)

(on-conflict-do-update insertable conflicts updates where-expression)

OnConflictUpdates clj

only clj

(only rel)

(only rel is-only)

Adds the only clause to limit the inheritance.

operations clj

or-having clj

(or-having rel having-expression)

Or having operation. If there's already a having clause set, this clause will be joined with OR

or-predicate clj

(or-predicate rel predicate-type predicate-expression)

or-where clj

(or-where rel where-expression)

Or where operation. If there's already a where clause set, this clause will be joined with OR

order-by clj

(order-by rel orders)

Sets order by clause. It accepts a vector of columns by which the order will be performed. Columns can be either a keyword, or vectors if you need to use descending order or you want to set order for null values:

• (order-by rel [:id])
• (order-by rel [[:id :desc]])
• (order-by rel [[:id :desc :nulls-first]])

You can reference columns in joined relations by using namespaced keys

process-conflict-target clj

(process-conflict-target insertable conflict-target)

process-group-by clj

(process-group-by rel group-by-clause)

process-inserts clj

(process-inserts inserts)

process-join-on clj

(process-join-on join-alias with-join join-on)

process-on-conflict-column-references clj

(process-on-conflict-column-references value)

process-on-conflict-updates clj

(process-on-conflict-updates rel
                             {:keys [updates where] :as on-conflict-updates})

process-orders clj

(process-orders rel orders)

process-projection clj

(process-projection rel node-list)

process-value-expression clj

(process-value-expression rel node)

rel->cte clj

(rel->cte cte-name rel)

Relation clj

rename clj

(rename rel prev-col-name next-col-name)

Renames a column. If you rename a column, you must use a new name to reference it after that

(-> rel
  (rename :name :product-name)
  (where [:= :product-name "FOO"]))

resolve-column clj

(resolve-column rel node)

resolve-columns clj

(resolve-columns rel columns)

returning clj

(returning writeable projection)

Selects columns from the write operation (insert, update, delete)

right-join clj

(right-join rel join-rel join-alias join-on)

(right-join rel join-rel join-alias join-on join-projection)

select clj

(select rel projection)

Selects columns from the relation. You can reference any extended columns here.

spec->relation clj

(spec->relation spec-map)

throw-when-not-cte! clj

(throw-when-not-cte! rel)

union clj

(union rel other-rel)

Creates a relation that is a combination of two relations with the UNION operator

union-all clj

(union-all rel other-rel)

Creates a relation that is a combination of two relations with the UNION ALL operator

Updatable clj

using clj

(using deletable using-rel using-alias)

where clj

(where rel where-expression)

And where operation. If there's already a where clause set, this clause will be joined with AND. Accepts a value expression which can be nested as needed. You can reference a column in a joined relation by using namespaced keys:

(-> beta
   (r/join :inner alpha :alpha [:= :alpha-id :alpha/id])
   (r/where [:= :alpha/id 3]))

In this example :alpha/id is referencing the :id column in the relation joined with the :alpha alias.

with-default-columns clj

(with-default-columns rel)

with-default-pk clj

(with-default-pk rel)

with-default-projection clj

(with-default-projection rel)

with-inserts clj

(with-inserts insertable inserts)

with-parent clj

(with-parent rel parent)

with-pk clj

(with-pk rel pk-cols)

with-updates clj

(with-updates updatable updates)

wrap clj

(wrap rel)

Wraps a relation, so the original structure is not visible to other relations. Use this in rare cases where you want to force a sub-select wrap around the relation. There are very rare cases when this is needed, but for instance if you want to have a relation that is joined with other relations, and you want to select only one field, you will need to explicitly wrap that relation.

Wrapped clj