next.jdbc.sql — com.github.seancorfield/next.jdbc 1.3.967

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.

aggregate-by-keys clj

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

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.

find-by-keys clj

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

get-by-id clj

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

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.

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!

query clj

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

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.