sqlosure.core — de.active-group/sqlosure 0.3.0

! clj

(! rel name)

! selects an attribute from a relation.

Example: (! t "id") corresponds to SQL "t.id".

$< clj

$<= clj

$= clj

$> clj

$>= clj

$and clj

$any clj

($any val)

$avg clj

($avg aref)

Aggregation. Calculates average of column aref.

$avg* clj

Aggregation. Calculate average of whole relation (AVG(*)).

$between clj

$blob clj

($blob val)

$blob-null clj

($blob-null val)

$blob-null-t clj

$blob-t clj

$boolean clj

($boolean val)

$boolean-t clj

$bytea clj

($bytea val)

$bytea-null clj

($bytea-null val)

$bytea-null-t clj

$bytea-t clj

$concat clj

$count clj

($count aref)

Aggregation. Count column aref.

$count* clj

Aggregation. Count whole relation (COUNT(*)).

$date clj

($date val)

$date-null-t clj

$date-t clj

$double clj

($double val)

$double-null clj

($double-null val)

$double-null-t clj

$double-t clj

$in clj

$integer clj

($integer val)

$integer-null clj

($integer-null val)

$integer-null-t clj

$integer-t clj

$is-not-null? clj

$is-null? clj

$like clj

$lower clj

$max clj

($max aref)

Aggretation. Calculates maximum of column aref.

$max* clj

Aggregation. Calculate maximum of whole relation (MAX(*)).

$min clj

($min aref)

Aggregation. Calculates minimum of column aref.

$min* clj

Aggregation. Calculate minimum of whole relation (MIN(*)).

$minus clj

$not clj

$null clj

($null val)

$or clj

$plus clj

$std-dev clj

Aggregation. Calculate standart deviation of whole relation (STDEV(*)).

$std-dev-p clj

$string clj

($string val)

$string-null clj

($string-null val)

$string-null-t clj

$string-t clj

$sum clj

($sum aref)

Aggregation. Sum column aref.

$sum* clj

Aggregation. Sum up whole relation (SUM(*)).

$timestamp clj

($timestamp val)

$timestamp-t clj

$upper clj

$var clj

Aggregation. Calculate variance of whole relation (VAR(*)).

$var-p clj

<- clj

(<- q)

Embed a RA query into the current query.

aggregate clj

(aggregate aggregation-op & attribute)

aggregate takes an aggregation-operator (:count, :avg, etc.) an optionally an sqlosure.relational-algebra/attribute-ref and returns an aggregation. If no attribute is provided, returns an aggregation on the whole relation, otherwise on the specified attribute.

db-connect clj

(db-connect db-spec backend)

db-connect takes a connection map and returns a db-connection-record for that backend. Dispatches on the :classname key in db-spec.

distinct! clj

distinct! is used to define queries that only return distinct rows. Will result in a DISTINCT clause in the resulting SQL.

group clj

(group alist)

group! clj

(group! alist)

Group by specified seq of column references [rel name]. Example (query [t (<- embed t-table)] (group [t "some_field"])

order clj

(order alist)

order! clj

(order! alist)

(order! attr direction & more-orders)

Takes an alist of [[attribute-ref] :descending/:ascending] to order the result by this attribute.

Example: (query [t (embed t-table)] (order {(! t "foo") :ascending}) (project {"foo" (! t "foo")}))

The corresponding SQL statemant would be "SELECT foo FROM t ORDER BY foo ASC".

project clj

(project alist-or-relation)

(project project-name project-field & more-projections)

Project some columns of the current query. Returns the resulting state.

Example: (query [t (<- embed t-table)] (project {"foo" (! t "foo") "bar" (! t "bar"))

The corresponding SQL statemant would be "SELECT foo, bar FROM t".

put-query clj

(put-query q & {:keys [optimize?]})

put-query takes a (relational algebra) query and returns it's (SQL-) string representation. Uses the default printer from sqlosure.sql-put.

query clj macro

(query & ?forms)

query takes a series of relational algebra statements (projection, selection, grouping, etc.) and returns an executable relational algebra query. The last statement must be a monadic return (either return or projection).

restrict clj

(restrict expr)

restrict! clj

(restrict! expr)

Restrict the current query by a condition.

expr -> query(nil)

Note this doesn't return anything.

restrict-outer clj

(restrict-outer expr)

restrict-outer! clj

(restrict-outer! expr)

Restrict outer part of the current query by a condition.

expr -> query(nil)

Note: this is a monadic action that doesn't return anything.

restricted clj

(restricted expr)

restricted! clj

(restricted! expr)

Restrict the current query by a condition. Returns the resulting state.

Example: (query [t (<- embed t-table)] (restricted t ($<= (! t "id") ($integer 1))

The corresponding SQL statement would be "SELECT <all cols of t> FROM t WHERE id <= 1"

relation expr -> query(relation).

table clj

(table sql-name map & opts)

Returns a sqlosure.relational-algebra/base-relation. sql-name ist the name of the table in the DBMS, map is a map of column-name -> sqlosure.type-type. opts may contain a :universe key and a universe (defaults to nil).

top clj

top! clj

(top! n)

(top! offset n)

top is used to define queries that return a cerain number of entries. When called with one argument n, top constructs a query that only returns the first n elements. Whan called with two arguments offset and n, top constructs a query that returns the first n elements with an offset of offset.

variadic->alist clj

(variadic->alist arg1 arg2 args)