Liking cljdoc? Tell your friends :D

next.jdbc.sql

Some utility functions that make common operations easier by providing some syntactic sugar over execute!/execute-one!.

This is intended to provide a minimal level of parity with clojure.java.jdbc (insert!, insert-multi!, query, find-by-keys, get-by-id, update!, and delete!).

For anything more complex, use a library like HoneySQL https://github.com/seancorfield/honeysql to generate SQL + parameters.

The following options are supported:

  • :table-fn -- specify a function used to convert table names (strings) to SQL entity names -- see the next.jdbc.quoted namespace for the most common quoting strategy functions,
  • :column-fn -- specify a function used to convert column names (strings) to SQL entity names -- see the next.jdbc.quoted namespace for the most common quoting strategy functions.

In addition, find-by-keys supports :order-by to add an ORDER BY clause to the generated SQL.

Some utility functions that make common operations easier by
providing some syntactic sugar over `execute!`/`execute-one!`.

This is intended to provide a minimal level of parity with
`clojure.java.jdbc` (`insert!`, `insert-multi!`, `query`, `find-by-keys`,
`get-by-id`, `update!`, and `delete!`).

For anything more complex, use a library like HoneySQL
https://github.com/seancorfield/honeysql to generate SQL + parameters.

The following options are supported:
* `:table-fn` -- specify a function used to convert table names (strings)
    to SQL entity names -- see the `next.jdbc.quoted` namespace for the
    most common quoting strategy functions,
* `:column-fn` -- specify a function used to convert column names (strings)
    to SQL entity names -- see the `next.jdbc.quoted` namespace for the
    most common quoting strategy functions.

In addition, `find-by-keys` supports `:order-by` to add an `ORDER BY`
clause to the generated SQL.
raw docstring

aggregate-by-keysclj

(aggregate-by-keys connectable table aggregate key-map)
(aggregate-by-keys connectable table aggregate key-map opts)

A wrapper over find-by-keys that additionally takes an aggregate SQL expression (a string), and returns just a single result: the value of that of that aggregate for the matching rows.

Accepts all the same options as find-by-keys except :columns since that is used internally by this wrapper to pass the aggregate expression in.

A wrapper over `find-by-keys` that additionally takes an aggregate SQL
expression (a string), and returns just a single result: the value of that
of that aggregate for the matching rows.

Accepts all the same options as `find-by-keys` except `:columns` since that
is used internally by this wrapper to pass the aggregate expression in.
sourceraw docstring

delete!clj

(delete! connectable table where-params)
(delete! connectable table where-params opts)

Syntactic sugar over execute-one! to make certain common deletes easier.

Given a connectable object, a table name, and either a hash map of columns and values to search on or a vector of a SQL where clause and parameters, perform a delete on the table.

Syntactic sugar over `execute-one!` to make certain common deletes easier.

Given a connectable object, a table name, and either a hash map of columns
and values to search on or a vector of a SQL where clause and parameters,
perform a delete on the table.
sourceraw docstring

find-by-keysclj

(find-by-keys connectable table key-map)
(find-by-keys connectable table key-map opts)

Syntactic sugar over execute! to make certain common queries easier.

Given a connectable object, a table name, and either a hash map of columns and values to search on or a vector of a SQL where clause and parameters, returns a vector of hash maps of rows that match.

If :all is passed instead of a hash map or vector -- the query will select all rows in the table, subject to any pagination options below.

If :columns is passed, only that specified subset of columns will be returned in each row (otherwise all columns are selected).

If the :order-by option is present, add an ORDER BY clause. :order-by should be a vector of column names or pairs of column name / direction, which can be :asc or :desc.

If the :top option is present, the SQL Server SELECT TOP ? syntax is used and the value of the option is inserted as an additional parameter.

If the :limit option is present, the MySQL LIMIT ? OFFSET ? syntax is used (using the :offset option if present, else OFFSET ? is omitted). PostgreSQL also supports this syntax.

If the :offset option is present (without :limit), the standard OFFSET ? ROWS FETCH NEXT ? ROWS ONLY syntax is used (using the :fetch option if present, else FETCH... is omitted).

Syntactic sugar over `execute!` to make certain common queries easier.

Given a connectable object, a table name, and either a hash map of
columns and values to search on or a vector of a SQL where clause and
parameters, returns a vector of hash maps of rows that match.

If `:all` is passed instead of a hash map or vector -- the query will
select all rows in the table, subject to any pagination options below.

If `:columns` is passed, only that specified subset of columns will be
returned in each row (otherwise all columns are selected).

If the `:order-by` option is present, add an `ORDER BY` clause. `:order-by`
should be a vector of column names or pairs of column name / direction,
which can be `:asc` or `:desc`.

If the `:top` option is present, the SQL Server `SELECT TOP ?` syntax
is used and the value of the option is inserted as an additional parameter.

If the `:limit` option is present, the MySQL `LIMIT ? OFFSET ?` syntax
is used (using the `:offset` option if present, else `OFFSET ?` is omitted).
PostgreSQL also supports this syntax.

If the `:offset` option is present (without `:limit`), the standard
`OFFSET ? ROWS FETCH NEXT ? ROWS ONLY` syntax is used (using the `:fetch`
option if present, else `FETCH...` is omitted).
sourceraw docstring

get-by-idclj

(get-by-id connectable table pk)
(get-by-id connectable table pk opts)
(get-by-id connectable table pk pk-name opts)

Syntactic sugar over execute-one! to make certain common queries easier.

Given a connectable object, a table name, and a primary key value, returns a hash map of the first row that matches.

By default, the primary key is assumed to be id but that can be overridden in the five-argument call.

As with find-by-keys, you can specify :columns to return just a subset of the columns in the returned row.

Technically, this also supports :order-by, :top, :limit, :offset, and :fetch -- like find-by-keys -- but they don't make as much sense here since only one row is ever returned.

Syntactic sugar over `execute-one!` to make certain common queries easier.

Given a connectable object, a table name, and a primary key value, returns
a hash map of the first row that matches.

By default, the primary key is assumed to be `id` but that can be overridden
in the five-argument call.

As with `find-by-keys`, you can specify `:columns` to return just a
subset of the columns in the returned row.

Technically, this also supports `:order-by`, `:top`, `:limit`, `:offset`,
and `:fetch` -- like `find-by-keys` -- but they don't make as much sense
here since only one row is ever returned.
sourceraw docstring

insert!clj

(insert! connectable table key-map)
(insert! connectable table key-map opts)

Syntactic sugar over execute-one! to make inserting hash maps easier.

Given a connectable object, a table name, and a data hash map, inserts the data as a single row in the database and attempts to return a map of generated keys.

Syntactic sugar over `execute-one!` to make inserting hash maps easier.

Given a connectable object, a table name, and a data hash map, inserts the
data as a single row in the database and attempts to return a map of generated
keys.
sourceraw docstring

insert-multi!clj

(insert-multi! connectable table hash-maps)
(insert-multi! connectable table hash-maps opts)
(insert-multi! connectable table cols rows)
(insert-multi! connectable table cols rows opts)

Syntactic sugar over execute! or execute-batch! to make inserting columns/rows easier.

Given a connectable object, a table name, a sequence of column names, and a vector of rows of data (vectors of column values), inserts the data as multiple rows in the database and attempts to return a vector of maps of generated keys.

Given a connectable object, a table name, a sequence of hash maps of data, which all have the same set of keys, inserts the data as multiple rows in the database and attempts to return a vector of maps of generated keys.

If called with :batch true will call execute-batch! - see its documentation for situations in which the generated keys may or may not be returned as well as additional options that can be passed.

Note: without :batch this expands to a single SQL statement with placeholders for every value being inserted -- for large sets of rows, this may exceed the limits on SQL string size and/or number of parameters for your JDBC driver or your database!

Syntactic sugar over `execute!` or `execute-batch!` to make inserting
columns/rows easier.

Given a connectable object, a table name, a sequence of column names, and
a vector of rows of data (vectors of column values), inserts the data as
multiple rows in the database and attempts to return a vector of maps of
generated keys.

Given a connectable object, a table name, a sequence of hash maps of data,
which all have the same set of keys, inserts the data as multiple rows in
the database and attempts to return a vector of maps of generated keys.

If called with `:batch` true will call `execute-batch!` - see its documentation
for situations in which the generated keys may or may not be returned as well as
additional options that can be passed.

Note: without `:batch` this expands to a single SQL statement with placeholders for
every value being inserted -- for large sets of rows, this may exceed the limits
on SQL string size and/or number of parameters for your JDBC driver or your
database!
sourceraw docstring

queryclj

(query connectable sql-params)
(query connectable sql-params opts)

Syntactic sugar over execute! to provide a query alias.

Given a connectable object, and a vector of SQL and its parameters, returns a vector of hash maps of rows that match.

Syntactic sugar over `execute!` to provide a query alias.

Given a connectable object, and a vector of SQL and its parameters,
returns a vector of hash maps of rows that match.
sourceraw docstring

update!clj

(update! connectable table key-map where-params)
(update! connectable table key-map where-params opts)

Syntactic sugar over execute-one! to make certain common updates easier.

Given a connectable object, a table name, a hash map of columns and values to set, and either a hash map of columns and values to search on or a vector of a SQL where clause and parameters, perform an update on the table.

Syntactic sugar over `execute-one!` to make certain common updates easier.

Given a connectable object, a table name, a hash map of columns and values
to set, and either a hash map of columns and values to search on or a vector
of a SQL where clause and parameters, perform an update on the table.
sourceraw docstring

cljdoc is a website building & hosting documentation for Clojure/Script libraries

× close