com.verybigthings.penkala.relation — com.verybigthings/penkala 0.0.3

->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

->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)

Deletable clj

distinct clj

(distinct rel)

(distinct rel distinct-expression)

Adds a distinct or distinct on clause.

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-operator clj

(extract-operator [op-type operator])

from clj

(from updatable from-rel from-alias)

get-delete-query clj

(get-delete-query deletable env params)

get-insert-query clj

(get-insert-query insertable env data)

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)

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)

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

-limit clj

(-limit this limit)

-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)

-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)

-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)

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.

limit clj

(limit rel limit)

Sets the limit parameter.

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)

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)

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-on-conflict-column-references clj

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

process-orders clj

(process-orders rel orders)

process-projection clj

(process-projection rel node-list)

process-value-expression clj

(process-value-expression rel node)

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)

select clj

(select rel projection)

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

spec->relation clj

(spec->relation spec-map)

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-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