korma.mysql
count
(count _query_ v)On MySQL, when an argument for COUNT() is a '*', 3 | it must be a simple '*', instead of 'fieldname.*'.
(count _query_ v)On MySQL, when an argument for COUNT() is a '*', 3 | it must be a simple '*', instead of 'fieldname.*'.
(set-delimiters & cs)Set the global default for field delimiters in connections. Delimiters can 3 | either be a string or a vector of the start and end: 4 | 5 | (set-delimiters "`") 6 | (set-delimiters ["[" "]"])
(set-naming strategy)Set the naming strategy to use. The strategy should be a map with transforms
7 | to be applied to field names (:fields) and the keys for generated maps (:keys)
8 | e.g:
9 |
10 | (set-naming {:keys string/lower-case :fields string/upper-case})Tasty SQL for Clojure
Core querying and entity functions
Public variables and functions:
Functions for creating and managing database specifications. 3 |
(connection-pool {:keys [connection-uri subprotocol subname classname excess-timeout idle-timeout initial-pool-size minimum-pool-size maximum-pool-size test-connection-query idle-connection-test-period test-connection-on-checkin test-connection-on-checkout], :or {maximum-pool-size 15, idle-timeout (* 3 60 60), excess-timeout (* 30 60), idle-connection-test-period 0, test-connection-query nil, test-connection-on-checkin false, test-connection-on-checkout false, initial-pool-size 3, minimum-pool-size 3}, :as spec})Create a connection pool for the given database spec. 4 |
(create-db spec)Create a db connection object manually instead of using defdb. This is often 5 | useful for creating connections dynamically, and probably should be followed 6 | up with: 7 | 8 | (default-connection my-new-conn) 9 | 10 | If the spec includes `:make-pool? true` makes a connection pool from the spec.
(default-connection conn)Set the database connection that Korma should use by default when no 11 | alternative is specified.
(defdb db-name spec)Define a database specification. The last evaluated defdb will be used by 12 | default for all queries where no database is specified by the entity.
(delay-pool spec)Return a delay for creating a connection pool for the given spec. 13 |
(firebird {:keys [host port db], :or {host "localhost", port 3050, db ""}, :as opts})Create a database specification for a FirebirdSQL database. Opts should include 14 | keys for :db, :user, :password. You can also optionally set host, port and make-pool?
(get-connection db)Get a connection from the potentially delayed connection object. 15 |
(h2 {:keys [db], :or {db "h2.db"}, :as opts})Create a database specification for a h2 database. Opts should include a key 16 | for :db which is the path to the database file.
(is-rollback?)Returns true if the current transaction will be rolled back 17 |
(msaccess {:keys [db], :or {db ""}, :as opts})Create a database specification for a Microsoft Access database. Opts 18 | should include keys for :db and optionally :make-pool?.
(mssql {:keys [user password db host port], :or {user "dbuser", password "dbpassword", db "", host "localhost", port 1433}, :as opts})Create a database specification for a mssql database. Opts should include keys 19 | for :db, :user, and :password. You can also optionally set host and port.
(mysql {:keys [host port db], :or {host "localhost", port 3306, db ""}, :as opts})Create a database specification for a mysql database. Opts should include keys 20 | for :db, :user, and :password. You can also optionally set host and port. 21 | Delimiters are automatically set to "`".
(odbc {:keys [dsn], :or {dsn ""}, :as opts})Create a database specification for an ODBC DSN. Opts 22 | should include keys for :dsn and optionally :make-pool?.
(oracle {:keys [host port], :or {host "localhost", port 1521}, :as opts})Create a database specification for an Oracle database. Opts should include keys 23 | for :user and :password. You can also optionally set host and port.
(postgres {:keys [host port db], :or {host "localhost", port 5432, db ""}, :as opts})Create a database specification for a postgres database. Opts should include 24 | keys for :db, :user, and :password. You can also optionally set host and 25 | port.
(sqlite3 {:keys [db], :or {db "sqlite.db"}, :as opts})Create a database specification for a SQLite3 database. Opts should include a 27 | key for :db which is the path to the database file.
(transaction body)(transaction options & body)Execute all queries within the body in a single transaction. 28 | Optionally takes as a first argument a map to specify the :isolation and :read-only? properties of the transaction.
(vertica {:keys [host port db], :or {host "localhost", port 5433, db ""}, :as opts})Create a database specification for a vertica database. Opts should include keys 29 | for :db, :user, and :password. You can also optionally set host and port. 30 | Delimiters are automatically set to "`".
(with-db db & body)Execute all queries within the body using the given db spec 31 |
Core querying and entity functions 3 |
(aggregate query agg alias & [group-by])Use a SQL aggregator function, aliasing the results, and optionally grouping by 5 | a field: 6 | 7 | (select users 8 | (aggregate (count :*) :cnt :status)) 9 | 10 | Aggregates available: count, sum, avg, min, max, first, last
(belongs-to ent sub-ent)(belongs-to ent sub-ent opts)Add a belongs-to relationship for the given entity. It is assumed that the foreign key 12 | is on the current entity with the format sub-ent-table_id: email.user_id = user.id. 13 | Can optionally pass a map with a :fk key collection or use the helper `fk` function 14 | to explicitly set the foreign key. 15 | 16 | (belongs-to users email) 17 | (belongs-to users email (fk :userId))
(create-entity table)Create an entity representing a table in a database. 18 |
(defentity ent & body)Define an entity representing a table in the database, applying any modifications in 20 | the body.
(delete ent & body)Creates a delete query, applies any modifying functions in the body and then
21 | executes it. `ent` is either a string or an entity created by defentity.
22 | Returns number of deleted rows as provided by the JDBC driver.
23 |
24 | ex: (delete user
25 | (where {:id 7}))(delete* ent)Create an empty delete query. Ent can either be an entity defined by defentity, 26 | or a string of the table name
(dry-run & body)Wrap around a set of queries to print to the console all SQL that would 27 | be run and return dummy values instead of executing them.
(entity-fields ent & fields)Set the fields to be retrieved in all select queries for the 28 | entity.
(exec-raw conn? & [sql with-results?])Execute a raw SQL string, supplying whether results should be returned. `sql` 30 | can either be a string or a vector of the sql string and its params. You can 31 | also optionally provide the connection to execute against as the first 32 | parameter. 33 | 34 | (exec-raw ["SELECT * FROM users WHERE age > ?" [5]] :results)
(fields query & vs)Set the fields to be selected in a query. Fields can either be a keyword 35 | or a vector of two keywords [field alias]: 36 | 37 | (fields query :name [:firstname :first])
(has-many ent sub-ent)(has-many ent sub-ent opts)Add a has-many relation for the given entity. It is assumed that the foreign key 41 | is on the sub-entity with the format table_id: user.id = email.user_id 42 | Can optionally pass a map with a :fk key collection or use the helper `fk` function 43 | to explicitly set the foreign key. 44 | 45 | (has-many users email) 46 | (has-many users email (fk :emailID))
(has-one ent sub-ent)(has-one ent sub-ent opts)Add a has-one relationship for the given entity. It is assumed that the foreign key 47 | is on the sub-entity with the format table_id: user.id = address.user_id 48 | Can optionally pass a map with a :fk key collection or use the helper `fk` function 49 | to explicitly set the foreign key. 50 | 51 | (has-one users address) 52 | (has-one users address (fk :userId))
(having query form)Add a having clause to the query, expressing the clause in clojure expressions
53 | with keywords used to reference fields.
54 | e.g. (having query (or (= :hits 1) (> :hits 5)))
55 |
56 | Available predicates: and, or, =, not=, <, >, <=, >=, in, like, not, between
57 |
58 | Having can also take a map at any point and will create a clause that compares
59 | keys to values. The value can be a vector with one of the above predicate
60 | functions describing how the key is related to the value:
61 | (having query {:name [like "chris"})
62 |
63 | Having only works if you have an aggregation, using it without one will cause
64 | an error.(having* query clause)Add a having clause to the query. Clause can be either a map or a string, and 65 | will be AND'ed to the other clauses.
(insert ent & body)Creates an insert query, applies any modifying functions in the body
66 | and then executes it. `ent` is either a string or an entity created by
67 | defentity. The return value is the last inserted item, but its
68 | representation is dependent on the database driver used
69 | (e.g. postgresql returns the full row as a hash,
70 | MySQL returns a {:generated_key <ID>} hash,
71 | and MSSQL returns a {:generated_keys <ID>} hash).
72 |
73 | ex: (insert user
74 | (values [{:name "chris"} {:name "john"}]))(insert* ent)Create an empty insert query. Ent can either be an entity defined by defentity, 75 | or a string of the table name
(intersect & body)Creates an intersect query, applies any modifying functions in the body and then
76 | executes it.
77 |
78 | ex: (intersect
79 | (queries (subselect user
80 | (where {:id 7}))
81 | (subselect user-backup
82 | (where {:id 8})))
83 | (order :name))(join query ent)(join query type-or-table ent-or-clause)(join query type table clause)Add a join clause to a select query, specifying an entity defined by defentity, or the table name to 85 | join and the predicate to join on. If the entity relationship uses a join 86 | table then two clauses will be added. Otherwise, only one clause 87 | will be added. 88 | 89 | (join query addresses) 90 | (join query :right addresses) 91 | (join query addresses (= :addres.users_id :users.id)) 92 | (join query :right addresses (= :address.users_id :users.id))
(many-to-many ent sub-ent join-table)(many-to-many ent sub-ent join-table fk1 fk2)(many-to-many ent sub-ent join-table opts)Add a many-to-many relation for the given entity. It is assumed that a join 95 | table is used to implement the relationship and that the foreign keys are in 96 | the join table with the format table_id: 97 | user.id = user_email.user_id 98 | user_email.email_id = email.id 99 | Can optionally pass a map with :lfk and :rfk key collections or use the 100 | helper `lfk`, `rfk` functions to explicitly set the join keys. 101 | 102 | (many-to-many email :user_email) 103 | (many-to-many email :user_email (lfk :user_id) 104 | (rfk :email_id))
(modifier query & modifiers)Add a modifer to the beginning of a query: 105 | 106 | (select orders 107 | (modifier "DISTINCT"))
(order query field dir)(order query field)Add an ORDER BY clause to a select, union, union-all, or intersect query. 109 | field should be a keyword of the field name, dir is ASC by default. 110 | 111 | (order query :created :asc)
(post-query query post)Add a function representing a query that should be executed for each result 113 | in a select. This is done lazily over the result set.
(prepare ent func)Add a function to be applied to records/values going into the database 114 |
(queries query & queries)Adds a group of queries to a union, union-all or intersect 115 |
(query-only & body)Wrap around a set of queries to force them to return their query objects. 116 |
(raw s)Embed a raw string of SQL in a query. This is used when Korma doesn't 117 | provide some specific functionality you're looking for: 118 | 119 | (select users 120 | (fields (raw "PERIOD(NOW(), NOW())")))
(select ent & body)Creates a select query, applies any modifying functions in the body and then
122 | executes it. `ent` is either a string or an entity created by defentity.
123 |
124 | ex: (select user
125 | (fields :name :email)
126 | (where {:id 2}))(select* ent)Create a select query with fields provided in Ent. If fields are not provided, 127 | create an empty select query. Ent can either be an entity defined by defentity, 128 | or a string of the table name
(set-fields query fields-map)Set the fields and values for an update query. 129 |
(sql-only & body)Wrap around a set of queries so that instead of executing, each will return a 130 | string of the SQL that would be used.
(sqlfn func & params)Call an arbitrary SQL function by providing func as a symbol or keyword 131 | and its params
(sqlfn* fn-name & params)Call an arbitrary SQL function by providing the name of the function 132 | and its params
(subselect & parts)Create a subselect clause to be used in queries. This works exactly like
133 | (select ...) execept it will wrap the query in ( .. ) and make sure it can be
134 | used in any current query:
135 |
136 | (select users
137 | (where {:id [in (subselect users2 (fields :id))]}))(table ent t & [alias])Set the name of the table and an optional alias to be used for the entity. 138 | By default the table is the name of entity's symbol.
(transform ent func)Add a function to be applied to results coming from the database 139 |
(union & body)Creates a union query, applies any modifying functions in the body and then
140 | executes it.
141 |
142 | ex: (union
143 | (queries (subselect user
144 | (where {:id 7}))
145 | (subselect user-backup
146 | (where {:id 7})))
147 | (order :name))(union-all & body)Creates a union-all query, applies any modifying functions in the body and then
149 | executes it.
150 |
151 | ex: (union-all
152 | (queries (subselect user
153 | (where {:id 7}))
154 | (subselect user-backup
155 | (where {:id 7})))
156 | (order :name))(update ent & body)Creates an update query, applies any modifying functions in the body and then
158 | executes it. `ent` is either a string or an entity created by defentity.
159 | Returns number of updated rows as provided by the JDBC driver.
160 |
161 | ex: (update user
162 | (set-fields {:name "chris"})
163 | (where {:id 4}))(update* ent)Create an empty update query. Ent can either be an entity defined by defentity, 164 | or a string of the table name.
(values query values)Add records to an insert clause. values can either be a vector of maps or a
165 | single map.
166 |
167 | (values query [{:name "john"} {:name "ed"}])(where query form)Add a where clause to the query, expressing the clause in clojure expressions
168 | with keywords used to reference fields.
169 | e.g. (where query (or (= :hits 1) (> :hits 5)))
170 |
171 | Available predicates: and, or, =, not=, <, >, <=, >=, in, like, not, between
172 |
173 | Where can also take a map at any point and will create a clause that compares keys
174 | to values. The value can be a vector with one of the above predicate functions
175 | describing how the key is related to the value:
176 | (where query {:name [like "chris"]})(where* query clause)Add a where clause to the query. Clause can be either a map or a string, and 177 | will be AND'ed to the other clauses.
(with query ent & body)Add a related entity to the given select query. If the entity has a relationship
178 | type of :belongs-to or :has-one, the requested fields will be returned directly in
179 | the result map. If the entity is a :has-many, a second query will be executed lazily
180 | and a key of the entity name will be assoc'd with a vector of the results.
181 |
182 | (defentity email (entity-fields :email))
183 | (defentity user (has-many email))
184 | (select user
185 | (with email) => [{:name "chris" :email [{email: "c@c.com"}]} ...
186 |
187 | With can also take a body that will further refine the relation:
188 | (select user
189 | (with address
190 | (with state)
191 | (fields :address.city :state.state)
192 | (where {:address.zip x})))(with-batch query ent & body)Add a related entity. This behaves like `with`, except that, for has-many 193 | relationships, it runs a single query to get relations of all fetched rows. 194 | This is faster than regular `with` but it doesn't support many of the 195 | additional options (order, limit, offset, group, having)