Compare commits
No commits in common. "develop" and "v2.6.1203" have entirely different histories.
35 changed files with 320 additions and 1281 deletions
|
|
@ -1 +0,0 @@
|
|||
{:lint-as {babashka.fs/with-temp-dir clojure.core/let}}
|
||||
|
|
@ -1,3 +0,0 @@
|
|||
|
||||
{:hooks
|
||||
{:analyze-call {org.httpkit.server/with-channel httpkit.with-channel/with-channel}}}
|
||||
|
|
@ -1,16 +0,0 @@
|
|||
(ns httpkit.with-channel
|
||||
(:require [clj-kondo.hooks-api :as api]))
|
||||
|
||||
(defn with-channel [{node :node}]
|
||||
(let [[request channel & body] (rest (:children node))]
|
||||
(when-not (and request channel) (throw (ex-info "No request or channel provided" {})))
|
||||
(when-not (api/token-node? channel) (throw (ex-info "Missing channel argument" {})))
|
||||
(let [new-node
|
||||
(api/list-node
|
||||
(list*
|
||||
(api/token-node 'let)
|
||||
(api/vector-node [channel (api/vector-node [])])
|
||||
request
|
||||
body))]
|
||||
|
||||
{:node new-node})))
|
||||
|
|
@ -1,5 +0,0 @@
|
|||
{:lint-as
|
||||
{rewrite-clj.zip/subedit-> clojure.core/->
|
||||
rewrite-clj.zip/subedit->> clojure.core/->>
|
||||
rewrite-clj.zip/edit-> clojure.core/->
|
||||
rewrite-clj.zip/edit->> clojure.core/->>}}
|
||||
|
|
@ -1 +0,0 @@
|
|||
{:hooks {:analyze-call {taoensso.encore/defalias taoensso.encore/defalias}}}
|
||||
|
|
@ -1,16 +0,0 @@
|
|||
(ns taoensso.encore
|
||||
(:require
|
||||
[clj-kondo.hooks-api :as hooks]))
|
||||
|
||||
(defn defalias [{:keys [node]}]
|
||||
(let [[sym-raw src-raw] (rest (:children node))
|
||||
src (if src-raw src-raw sym-raw)
|
||||
sym (if src-raw
|
||||
sym-raw
|
||||
(symbol (name (hooks/sexpr src))))]
|
||||
{:node (with-meta
|
||||
(hooks/list-node
|
||||
[(hooks/token-node 'def)
|
||||
(hooks/token-node (hooks/sexpr sym))
|
||||
(hooks/token-node (hooks/sexpr src))])
|
||||
(meta src))}))
|
||||
2
.github/workflows/test-and-release.yml
vendored
2
.github/workflows/test-and-release.yml
vendored
|
|
@ -19,7 +19,7 @@ jobs:
|
|||
- name: Setup Clojure
|
||||
uses: DeLaGuardo/setup-clojure@master
|
||||
with:
|
||||
cli: '1.12.0.1530'
|
||||
cli: '1.12.0.1479'
|
||||
- name: Cache All The Things
|
||||
uses: actions/cache@v4
|
||||
with:
|
||||
|
|
|
|||
4
.github/workflows/test-and-snapshot.yml
vendored
4
.github/workflows/test-and-snapshot.yml
vendored
|
|
@ -17,7 +17,7 @@ jobs:
|
|||
- name: Setup Clojure
|
||||
uses: DeLaGuardo/setup-clojure@master
|
||||
with:
|
||||
cli: '1.12.0.1530'
|
||||
cli: '1.12.0.1479'
|
||||
- name: Cache All The Things
|
||||
uses: actions/cache@v4
|
||||
with:
|
||||
|
|
@ -49,7 +49,7 @@ jobs:
|
|||
- name: Clojure CLI
|
||||
uses: DeLaGuardo/setup-clojure@master
|
||||
with:
|
||||
cli: '1.12.0.1530'
|
||||
cli: '1.12.0.1479'
|
||||
- name: Cache All The Things
|
||||
uses: actions/cache@v4
|
||||
with:
|
||||
|
|
|
|||
33
.github/workflows/test-bb.yml
vendored
33
.github/workflows/test-bb.yml
vendored
|
|
@ -1,33 +0,0 @@
|
|||
name: Babashka tests
|
||||
|
||||
on:
|
||||
pull_request:
|
||||
push:
|
||||
branches:
|
||||
- develop
|
||||
|
||||
jobs:
|
||||
build:
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- uses: actions/setup-java@v4
|
||||
with:
|
||||
distribution: 'temurin'
|
||||
java-version: 21
|
||||
- name: Clojure CLI
|
||||
uses: DeLaGuardo/setup-clojure@master
|
||||
with:
|
||||
cli: '1.12.0.1530'
|
||||
bb: latest
|
||||
- name: Cache All The Things
|
||||
uses: actions/cache@v4
|
||||
with:
|
||||
path: |
|
||||
~/.m2/repository
|
||||
~/.gitlibs
|
||||
~/.clojure
|
||||
~/.cpcache
|
||||
key: ${{ runner.os }}-${{ hashFiles('**/deps.edn', '**/bb.edn') }}
|
||||
- name: Run Tests
|
||||
run: bb test
|
||||
2
.github/workflows/test.yml
vendored
2
.github/workflows/test.yml
vendored
|
|
@ -17,7 +17,7 @@ jobs:
|
|||
- name: Clojure CLI
|
||||
uses: DeLaGuardo/setup-clojure@master
|
||||
with:
|
||||
cli: '1.12.0.1530'
|
||||
cli: '1.12.0.1479'
|
||||
- name: Cache All The Things
|
||||
uses: actions/cache@v4
|
||||
with:
|
||||
|
|
|
|||
23
.gitpod.yml
Normal file
23
.gitpod.yml
Normal file
|
|
@ -0,0 +1,23 @@
|
|||
image:
|
||||
file: .gitpod.dockerfile
|
||||
|
||||
vscode:
|
||||
extensions:
|
||||
- betterthantomorrow.calva
|
||||
- mauricioszabo.clover
|
||||
|
||||
tasks:
|
||||
- name: Prepare deps/clover
|
||||
init: |
|
||||
clojure -A:test -P
|
||||
echo 50505 > .socket-repl-port
|
||||
mkdir ~/.config/clover
|
||||
cp .clover/config.cljs ~/.config/clover/
|
||||
- name: Start REPL
|
||||
command: clojure -J-Dclojure.server.repl="{:address \"0.0.0.0\" :port 50505 :accept clojure.core.server/repl}" -A:test
|
||||
- name: See Changes
|
||||
command: code CHANGELOG.md
|
||||
|
||||
github:
|
||||
prebuilds:
|
||||
develop: true
|
||||
19
.vscode/settings.json
vendored
Normal file
19
.vscode/settings.json
vendored
Normal file
|
|
@ -0,0 +1,19 @@
|
|||
{
|
||||
"calva.replConnectSequences": [
|
||||
{
|
||||
"name": "HoneySQL (Jack-In)",
|
||||
"projectType": "deps.edn",
|
||||
"autoSelectForJackIn": true,
|
||||
"menuSelections": {
|
||||
"cljAliases": ["1.12", "dev/repl", "portal", "test"]
|
||||
}
|
||||
},
|
||||
{
|
||||
"name": "HoneySQL (Connect)",
|
||||
"projectType": "deps.edn",
|
||||
"autoSelectForConnect": true
|
||||
}
|
||||
],
|
||||
"calva.autoStartRepl": true,
|
||||
"calva.autoConnectRepl": true
|
||||
}
|
||||
45
CHANGELOG.md
45
CHANGELOG.md
|
|
@ -1,46 +1,5 @@
|
|||
# Changes
|
||||
|
||||
* 2.7.next in progress
|
||||
* Address [#440](https://github.com/seancorfield/honeysql/issues/440) by supporting multiple tables in `:truncate`.
|
||||
* Support `USING HASH` as well as `USING GIN`.
|
||||
* Fix [#571](https://github.com/seancorfield/honeysql/issues/571) by allowing `:order-by` to take an empty sequence of columns (and be omitted).
|
||||
* Update dev/build deps.
|
||||
|
||||
* 2.7.1295 -- 2025-03-12
|
||||
* Address #570 by adding `:.:.` as special syntax for Snowflake's JSON path syntax, and `:at` as special syntax for general `[`..`]` path syntax.
|
||||
* Drop support for Clojure 1.9 [#561](https://github.com/seancorfield/honeysql/issues/561).
|
||||
|
||||
* 2.6.1281 -- 2025-03-06
|
||||
* Address [#568](https://github.com/seancorfield/honeysql/issues/568) by adding `honey.sql/semicolon` to merge multiple SQL+params vectors into one (with semicolons separating the SQL statements).
|
||||
* Address [#567](https://github.com/seancorfield/honeysql/issues/567) by adding support for `ASSERT` clause.
|
||||
* Address [#566](https://github.com/seancorfield/honeysql/issues/566) by adding `IS [NOT] DISTINCT FROM` operators.
|
||||
* Add examples of `:alias` with `:group-by` (syntax is slightly different to existing examples for `:order-by`).
|
||||
|
||||
* 2.6.1270 -- 2025-01-17
|
||||
* Fix autoboxing introduced in 2.6.1267 via PR [#564](https://github.com/seancorfield/honeysql/pull/564) [@alexander-yakushev](https://github.com/alexander-yakushev).
|
||||
|
||||
* 2.6.1267 -- 2025-01-16
|
||||
* Support expressions in `WITH` clauses via PR [#563](https://github.com/seancorfield/honeysql/pull/563) [@krevedkokun](https://github.com/krevedkokun).
|
||||
* More performance optimizations via PRs [#560](https://github.com/seancorfield/honeysql/pull/560) and [#562](https://github.com/seancorfield/honeysql/pull/562) [@alexander-yakushev](https://github.com/alexander-yakushev).
|
||||
* Fix two broken links to the [HoneySQL web app](https://john.shaffe.rs/honeysql/) via PR [#559](https://github.com/seancorfield/honeysql/pull/559) [@whatacold](https://github.com/whatacold).
|
||||
* Make SQL Server dialect auto-lift Boolean values to parameters since SQL Server has no `TRUE` / `FALSE` literals.
|
||||
* Fix bug in `DEFAULT` values clause (that omitted some values).
|
||||
|
||||
* 2.6.1243 -- 2024-12-13
|
||||
* Address [#558](https://github.com/seancorfield/honeysql/issues/558) by adding `:patch-into` (and `patch-into` helper) for XTDB (but in core).
|
||||
* Address [#556](https://github.com/seancorfield/honeysql/issues/556) by adding an XTDB section to the documentation with examples.
|
||||
* Address [#555](https://github.com/seancorfield/honeysql/issues/555) by supporting `SETTING` clause for XTDB.
|
||||
* Replace `assert` calls with proper validation, throwing `ex-info` on failure (like other existing validation in HoneySQL).
|
||||
* Experimental `:xtdb` dialect removed (since XTDB no longer supports qualified column names).
|
||||
* Update dev/test deps.
|
||||
|
||||
* 2.6.1230 -- 2024-11-23
|
||||
* Fix [#553](https://github.com/seancorfield/honeysql/issues/553) by adding `:not-between` as special syntax via PR [#554](https://github.com/seancorfield/honeysql/pull/554) [@plooney81](https://github.com/plooney81)
|
||||
* Fix [#552](https://github.com/seancorfield/honeysql/issues/552) by changing the assert-on-load behavior into an explicit test in the test suite.
|
||||
* Fix [#551](https://github.com/seancorfield/honeysql/issues/551) by supporting multiple `WINDOW` clauses.
|
||||
* Fix [#549](https://github.com/seancorfield/honeysql/issues/549) by using `:bb` conditionals to support Babashka (and still support Clojure 1.9.0), and add testing against Babashka so it is fully-supported as a target via PR [#550](https://github.com/seancorfield/honeysql/pull/550) [@borkdude](https://github.com/borkdude)
|
||||
* Address [#532](https://github.com/seancorfield/honeysql/issues/532) by adding support for XTDB SQL extensions `ERASE`, `EXCLUDE`, `OBJECT`, `RECORD`, `RECORDS`, and `RENAME`, along with inline hash maps (as records) and `:get-in` for object navigation, and starting to write tests for XTDB compatibility.
|
||||
|
||||
* 2.6.1203 -- 2024-10-22
|
||||
* Fix [#548](https://github.com/seancorfield/honeysql/issues/548) which was a regression introduced in [#526](https://github.com/seancorfield/honeysql/issues/526) (in 2.6.1161).
|
||||
* Address [#542](https://github.com/seancorfield/honeysql/issues/542) by adding support for `WITH` query tail options for PostgreSQL.
|
||||
|
|
@ -77,7 +36,7 @@
|
|||
* Address [#524](https://github.com/seancorfield/honeysql/issues/524) by adding example of `{:nest ..}` in `:union` clause reference docs.
|
||||
* Address [#523](https://github.com/seancorfield/honeysql/issues/523) by expanding examples in README **Functions** to show aliases.
|
||||
* Address [#522](https://github.com/seancorfield/honeysql/issues/522) by supporting metadata on table specifications in `:from` and `:join` clauses to provide index hints (SQL Server).
|
||||
* ~Address [#521](https://github.com/seancorfield/honeysql/issues/521) by adding initial experimental support for an XTDB dialect.~ _[This was removed in 2.6.1243 since XTDB no longer supports qualified column names]_
|
||||
* Address [#521](https://github.com/seancorfield/honeysql/issues/521) by adding initial experimental support for an XTDB dialect.
|
||||
* Address [#520](https://github.com/seancorfield/honeysql/issues/520) by expanding how `:inline` works, to support a sequence of arguments.
|
||||
* Fix [#518](https://github.com/seancorfield/honeysql/issues/518) by moving temporal clause before alias.
|
||||
* Address [#495](https://github.com/seancorfield/honeysql/issues/495) by adding `formatv` macro (`.clj` only!) -- and removing the experimental `formatf` function (added for discussion in 2.4.1045).
|
||||
|
|
@ -276,7 +235,7 @@
|
|||
* Fixes #344 by no longer dropping the qualifier on columns in a `SET` clause _for the `:mysql` dialect only_; the behavior is unchanged for all other dialects.
|
||||
* Fixes #340 by making the "hyphen to space" logic more general so _operators_ containing `-` should retain the hyphen without special cases.
|
||||
* Documentation improvements: `:fetch`, `:lift`, `:limit`, `:offset`, `:param`, `:select`; also around JSON/PostgreSQL.
|
||||
* Link to the [HoneySQL web app](https://john.shaffe.rs/honeysql/) in both the README and **Getting Started**.
|
||||
* Link to the [HoneySQL web app](https://www.john-shaffer.com/honeysql/) in both the README and **Getting Started**.
|
||||
* Switch to `tools.build` for running tests and JAR building etc.
|
||||
|
||||
* 2.0.0-rc5 (for testing; 2021-07-17)
|
||||
|
|
|
|||
12
README.md
12
README.md
|
|
@ -4,19 +4,17 @@ SQL as Clojure data structures. Build queries programmatically -- even at runtim
|
|||
|
||||
## Build
|
||||
|
||||
[](https://clojars.org/com.github.seancorfield/honeysql)
|
||||
[](https://cljdoc.org/d/com.github.seancorfield/honeysql/CURRENT)
|
||||
[](https://clojars.org/com.github.seancorfield/honeysql)
|
||||
[](https://cljdoc.org/d/com.github.seancorfield/honeysql/CURRENT)
|
||||
[](https://clojurians.slack.com/app_redirect?channel=honeysql)
|
||||
[](http://clojurians.net)
|
||||
[](https://clojurians.zulipchat.com/#narrow/channel/152091-honeysql)
|
||||
|
||||
|
||||
This project follows the version scheme MAJOR.MINOR.COMMITS where MAJOR and MINOR provide some relative indication of the size of the change, but do not follow semantic versioning. In general, all changes endeavor to be non-breaking (by moving to new names rather than by breaking existing names). COMMITS is an ever-increasing counter of commits since the beginning of this repository.
|
||||
|
||||
> Note: every commit to the **develop** branch runs CI (GitHub Actions) and successful runs push a MAJOR.MINOR.9999-SNAPSHOT build to Clojars so the very latest version of HoneySQL is always available either via that [snapshot on Clojars](https://clojars.org/com.github.seancorfield/honeysql) or via a git dependency on the latest SHA.
|
||||
|
||||
HoneySQL 2.7.y requires Clojure 1.10.3 or later.
|
||||
Earlier versions of HoneySQL support Clojure 1.9.0.
|
||||
It also supports recent versions of ClojureScript and Babashka.
|
||||
HoneySQL 2.x requires Clojure 1.9 or later.
|
||||
|
||||
Compared to the [legacy 1.x version](#1.x), HoneySQL 2.x provides a streamlined codebase and a simpler method for extending the DSL. It also supports SQL dialects out-of-the-box and will be extended to support vendor-specific language features over time (unlike 1.x).
|
||||
|
||||
|
|
@ -48,7 +46,7 @@ section of the documentation before trying to use HoneySQL to build your own que
|
|||
From Clojure:
|
||||
<!-- {:test-doc-blocks/reader-cond :clj} -->
|
||||
```clojure
|
||||
(refer-clojure :exclude '[assert distinct filter for group-by into partition-by set update])
|
||||
(refer-clojure :exclude '[distinct filter for group-by into partition-by set update])
|
||||
(require '[honey.sql :as sql]
|
||||
;; CAUTION: this overwrites several clojure.core fns:
|
||||
;;
|
||||
|
|
|
|||
8
bb.edn
8
bb.edn
|
|
@ -1,8 +0,0 @@
|
|||
{:paths ["src"]
|
||||
:tasks
|
||||
{test
|
||||
{:extra-paths ["test"]
|
||||
:extra-deps {io.github.cognitect-labs/test-runner
|
||||
{:git/tag "v0.5.1" :git/sha "dfb30dd"}}
|
||||
:task (exec 'cognitect.test-runner.api/test)
|
||||
:exec-args {:patterns ["^(?!honey.cache).*-test$"]}}}}
|
||||
10
build.clj
10
build.clj
|
|
@ -19,7 +19,7 @@
|
|||
[deps-deploy.deps-deploy :as dd]))
|
||||
|
||||
(def lib 'com.github.seancorfield/honeysql)
|
||||
(defn- the-version [patch] (format "2.7.%s" patch))
|
||||
(defn- the-version [patch] (format "2.6.%s" patch))
|
||||
(def version (the-version (b/git-count-revs nil)))
|
||||
(def snapshot (the-version "9999-SNAPSHOT"))
|
||||
(def class-dir "target/classes")
|
||||
|
|
@ -47,7 +47,8 @@
|
|||
"Generate and run doc tests.
|
||||
|
||||
Optionally specify :aliases vector:
|
||||
[:1.10] -- test against Clojure 1.10.3 (the default)
|
||||
[:1.9] -- test against Clojure 1.9 (the default)
|
||||
[:1.10] -- test against Clojure 1.10.3
|
||||
[:1.11] -- test against Clojure 1.11.0
|
||||
[:1.12] -- test against Clojure 1.12.0
|
||||
[:cljs] -- test against ClojureScript"
|
||||
|
|
@ -62,7 +63,6 @@
|
|||
|
||||
(defn test "Run basic tests." [opts]
|
||||
(run-task [:test :runner :1.11])
|
||||
(run-task [:test :runner :cljs])
|
||||
opts)
|
||||
|
||||
(defn- pom-template [version]
|
||||
|
|
@ -98,10 +98,10 @@
|
|||
(defn ci
|
||||
"Run the CI pipeline of tests (and build the JAR).
|
||||
|
||||
Default Clojure version is 1.10.3 (:1.10) so :elide
|
||||
Default Clojure version is 1.9.0 (:1.9) so :elide
|
||||
tests for #409 on that version."
|
||||
[opts]
|
||||
(let [aliases [:cljs :elide :1.11 :1.12]
|
||||
(let [aliases [:cljs :elide :1.10 :1.11 :1.12]
|
||||
opts (jar-opts opts)]
|
||||
(b/delete {:path "target"})
|
||||
(doseq [alias aliases]
|
||||
|
|
|
|||
|
|
@ -16,8 +16,7 @@
|
|||
;;"doc/operator-reference.md"
|
||||
"doc/options.md"
|
||||
"doc/postgresql.md"
|
||||
"doc/special-syntax.md"
|
||||
"doc/xtdb.md"]
|
||||
"doc/special-syntax.md"]
|
||||
regen-reason (if (not (fs/exists? success-marker))
|
||||
"a previous successful gen result not found"
|
||||
(let [newer-thans (fs/modified-since target
|
||||
|
|
|
|||
7
deps.edn
7
deps.edn
|
|
@ -1,13 +1,14 @@
|
|||
{:mvn/repos {"sonatype" {:url "https://oss.sonatype.org/content/repositories/snapshots/"}}
|
||||
:paths ["src"]
|
||||
:deps {org.clojure/clojure {:mvn/version "1.10.3"}}
|
||||
:deps {org.clojure/clojure {:mvn/version "1.9.0"}}
|
||||
:aliases
|
||||
{;; for help: clojure -A:deps -T:build help/doc
|
||||
:build {:deps {io.github.clojure/tools.build {:mvn/version "0.10.8"}
|
||||
:build {:deps {io.github.clojure/tools.build {:mvn/version "0.10.5"}
|
||||
slipset/deps-deploy {:mvn/version "0.2.2"}}
|
||||
:ns-default build}
|
||||
|
||||
;; versions to test against:
|
||||
:1.9 {:override-deps {org.clojure/clojure {:mvn/version "1.9.0"}}}
|
||||
:1.10 {:override-deps {org.clojure/clojure {:mvn/version "1.10.3"}}}
|
||||
:1.11 {:override-deps {org.clojure/clojure {:mvn/version "1.11.4"}}}
|
||||
:1.12 {:override-deps {org.clojure/clojure {:mvn/version "1.12.0"}}}
|
||||
|
|
@ -30,7 +31,7 @@
|
|||
:main-opts ["-m" "cljs-test-runner.main"]}
|
||||
|
||||
:gen-doc-tests {:replace-paths ["build"]
|
||||
:extra-deps {babashka/fs {:mvn/version "0.5.24"}
|
||||
:extra-deps {babashka/fs {:mvn/version "0.5.22"}
|
||||
com.github.lread/test-doc-blocks {:mvn/version "1.1.20"}}
|
||||
:main-opts ["-m" "honey.gen-doc-tests"]}
|
||||
|
||||
|
|
|
|||
|
|
@ -149,14 +149,6 @@ user=> (sql/format {:create-index [:my-idx [:fruit :using-gin :appearance]]})
|
|||
["CREATE INDEX my_idx ON fruit USING GIN (appearance)"]
|
||||
```
|
||||
|
||||
As of 2.7.next, `USING HASH` index creation is also possible using the keyword
|
||||
`:using-hash` after the table name (or the symbol `using-hash`):
|
||||
|
||||
```clojure
|
||||
user=> (sql/format {:create-index [:my-idx [:fruit :using-hash :appearance]]})
|
||||
["CREATE INDEX my_idx ON fruit USING HASH (appearance)"]
|
||||
```
|
||||
|
||||
### rename-table
|
||||
|
||||
Used with `:alter-table`,
|
||||
|
|
@ -678,9 +670,9 @@ user=> (sql/format '{select * bulk-collect-into [arrv 100] from mytable})
|
|||
["SELECT * BULK COLLECT INTO arrv LIMIT ? FROM mytable" 100]
|
||||
```
|
||||
|
||||
## insert-into, replace-into, patch-into
|
||||
## insert-into, replace-into
|
||||
|
||||
There are three use cases with `:insert-into` etc.
|
||||
There are three use cases with `:insert-into`.
|
||||
|
||||
The first case takes just a table specifier (either a
|
||||
table name or a table/alias pair),
|
||||
|
|
@ -698,10 +690,6 @@ For the first and second cases, you'll use the `:values` clause
|
|||
to specify rows of values to insert. See [**values**](#values) below
|
||||
for more detail on the `:values` clause.
|
||||
|
||||
`:patch-into` is only supported by XTDB but is
|
||||
part of HoneySQL's "core" dialect anyway. It produces a `PATCH INTO`
|
||||
statement but otherwise has identical syntax to `:insert-into`.
|
||||
|
||||
`:replace-into` is only supported by MySQL and SQLite but is
|
||||
part of HoneySQL's "core" dialect anyway. It produces a `REPLACE INTO`
|
||||
statement but otherwise has identical syntax to `:insert-into`.
|
||||
|
|
@ -806,7 +794,7 @@ You can also `UPDATE .. FROM (VALUES ..) ..` where you might also need `:composi
|
|||
["UPDATE table SET a = v.a FROM (VALUES (?, ?, ?), (?, ?, ?)) AS v (a, b, c) WHERE (x = v.b) AND (y > v.c)" 1 2 3 4 5 6]
|
||||
```
|
||||
|
||||
## delete, delete-from, erase-from
|
||||
## delete, delete-from
|
||||
|
||||
`:delete-from` is the simple use case here, accepting just a
|
||||
SQL entity (table name). `:delete` allows for deleting from
|
||||
|
|
@ -823,30 +811,16 @@ user=> (sql/format {:delete [:order :item]
|
|||
["DELETE order, item FROM order INNER JOIN item ON order.item_id = item.id WHERE item.id = ?" 42]
|
||||
```
|
||||
|
||||
`:erase-from` is only supported by XTDB and produces an `ERASE FROM`
|
||||
statement but otherwise has identical syntax to `:delete-from`. It
|
||||
is a "hard" delete as opposed to a temporal delete.
|
||||
|
||||
## truncate
|
||||
|
||||
`:truncate` accepts a simple SQL entity (table name)
|
||||
or a table name followed by various options, or a
|
||||
sequence that starts with a sequence of one or more table names,
|
||||
optionally followed by various options:
|
||||
or a table name followed by various options:
|
||||
|
||||
```clojure
|
||||
user=> (sql/format '{truncate transport})
|
||||
["TRUNCATE TABLE transport"]
|
||||
user=> (sql/format '{truncate (transport)})
|
||||
["TRUNCATE TABLE transport"]
|
||||
user=> (sql/format '{truncate (transport restart identity)})
|
||||
["TRUNCATE TABLE transport RESTART IDENTITY"]
|
||||
user=> (sql/format '{truncate ((transport))})
|
||||
["TRUNCATE TABLE transport"]
|
||||
user=> (sql/format '{truncate ((transport other))})
|
||||
["TRUNCATE TABLE transport, other"]
|
||||
user=> (sql/format '{truncate ((transport other) restart identity)})
|
||||
["TRUNCATE TABLE transport, other RESTART IDENTITY"]
|
||||
```
|
||||
|
||||
## columns
|
||||
|
|
@ -1088,9 +1062,6 @@ The `:where` clause can have a single SQL expression, or
|
|||
a sequence of SQL expressions prefixed by either `:and`
|
||||
or `:or`. See examples of `:where` in various clauses above.
|
||||
|
||||
If `:where` is given an empty sequence, the `WHERE` clause will
|
||||
be omitted from the generated SQL.
|
||||
|
||||
Sometimes it is convenient to construct a `WHERE` clause that
|
||||
tests several columns for equality, and you might have a Clojure
|
||||
hash map containing those values. `honey.sql/map=` exists to
|
||||
|
|
@ -1112,11 +1083,6 @@ user=> (sql/format '{select (*) from (table)
|
|||
["SELECT * FROM table GROUP BY status, YEAR(created_date)"]
|
||||
```
|
||||
|
||||
You can `GROUP BY` expressions, column names (`:col1`), or table and column (`:table.col1`),
|
||||
or aliases (`:some.alias`). Since there is ambiguity between the formatting
|
||||
of those, you can use the special syntax `[:alias :some.thing]` to tell
|
||||
HoneySQL to treat `:some.thing` as an alias instead of a table/column name.
|
||||
|
||||
## having
|
||||
|
||||
The `:having` clause works identically to `:where` above
|
||||
|
|
@ -1124,7 +1090,7 @@ but is rendered into the SQL later in precedence order.
|
|||
|
||||
## window, partition-by (and over)
|
||||
|
||||
`:window` accept alternating pairs of SQL entity (the window name)
|
||||
`:window` accepts a pair of SQL entity (the window name)
|
||||
and the window "function" as a SQL clause (a hash map).
|
||||
|
||||
`:partition-by` accepts the same arguments as `:select` above
|
||||
|
|
@ -1150,25 +1116,6 @@ SELECT id, AVG(salary) OVER (PARTITION BY department ORDER BY designation ASC) A
|
|||
FROM employee
|
||||
WINDOW w AS (PARTITION BY department)
|
||||
"]
|
||||
;; multiple windows:
|
||||
user=> (sql/format {:select [:id
|
||||
[[:over
|
||||
[[:avg :salary]
|
||||
{:partition-by [:department]
|
||||
:order-by [:designation]}
|
||||
:Average]
|
||||
[[:max :salary]
|
||||
:w
|
||||
:MaxSalary]]]]
|
||||
:from [:employee]
|
||||
:window [:w {:partition-by [:department]}
|
||||
:x {:partition-by [:salary]}]}
|
||||
{:pretty true})
|
||||
["
|
||||
SELECT id, AVG(salary) OVER (PARTITION BY department ORDER BY designation ASC) AS Average, MAX(salary) OVER w AS MaxSalary
|
||||
FROM employee
|
||||
WINDOW w AS (PARTITION BY department), x AS (PARTITION BY salary)
|
||||
"]
|
||||
;; easier to write with helpers (and easier to read!):
|
||||
user=> (sql/format (-> (select :id
|
||||
(over [[:avg :salary] (-> (partition-by :department) (order-by :designation)) :Average]
|
||||
|
|
@ -1181,18 +1128,6 @@ SELECT id, AVG(salary) OVER (PARTITION BY department ORDER BY designation ASC) A
|
|||
FROM employee
|
||||
WINDOW w AS (PARTITION BY department)
|
||||
"]
|
||||
;; multiple window clauses:
|
||||
user=> (sql/format (-> (select :id
|
||||
(over [[:avg :salary] (-> (partition-by :department) (order-by :designation)) :Average]
|
||||
[[:max :salary] :w :MaxSalary]))
|
||||
(from :employee)
|
||||
(window :w (partition-by :department))
|
||||
(window :x (partition-by :salary))) {:pretty true})
|
||||
["
|
||||
SELECT id, AVG(salary) OVER (PARTITION BY department ORDER BY designation ASC) AS Average, MAX(salary) OVER w AS MaxSalary
|
||||
FROM employee
|
||||
WINDOW w AS (PARTITION BY department), x AS (PARTITION BY salary)
|
||||
"]
|
||||
```
|
||||
|
||||
The window function in the `:over` expression may be `{}` or `nil`:
|
||||
|
|
@ -1231,15 +1166,12 @@ user=> (sql/format {:select [[[:over
|
|||
|
||||
## order-by
|
||||
|
||||
`:order-by` accepts a sequence of zero or more ordering
|
||||
`:order-by` accepts a sequence of one or more ordering
|
||||
expressions. Each ordering expression is either a simple
|
||||
SQL entity or a pair of a SQL expression and a direction
|
||||
(which can be `:asc`, `:desc`, `:nulls-first`, `:desc-null-last`,
|
||||
etc -- or the symbol equivalent).
|
||||
|
||||
If `:order-by` is given an empty sequence, the `ORDER BY` clause will
|
||||
be omitted from the generated SQL.
|
||||
|
||||
If you want to order by an expression, you should wrap it
|
||||
as a pair with a direction:
|
||||
|
||||
|
|
@ -1450,7 +1382,7 @@ user=> (sql/format {:insert-into :table
|
|||
:values [{:a 1 :b 2 :c 3}
|
||||
:default
|
||||
{:a 4 :b 5 :c 6}]})
|
||||
["INSERT INTO table (a, b, c) VALUES (?, ?, ?), DEFAULT, (?, ?, ?)" 1 2 3 4 5 6]
|
||||
["INSERT INTO table (a, b, c) VALUES (?, ?, ?), DEFAULT, (?, ?, ?)" 6 5 4]
|
||||
user=> (sql/format {:insert-into :table
|
||||
:values [[1 2 3] :default [4 5 6]]})
|
||||
["INSERT INTO table VALUES (?, ?, ?), DEFAULT, (?, ?, ?)" 1 2 3 4 5 6]
|
||||
|
|
|
|||
|
|
@ -7,7 +7,6 @@
|
|||
["SQL Operator Reference" {:file "doc/operator-reference.md"}]
|
||||
["SQL 'Special Syntax'" {:file "doc/special-syntax.md"}]
|
||||
["PostgreSQL Support" {:file "doc/postgresql.md"}]
|
||||
["XTDB Support" {:file "doc/xtdb.md"}]
|
||||
["New Relic NRQL Support" {:file "doc/nrql.md"}]
|
||||
["Other Databases" {:file "doc/databases.md"}]]
|
||||
["All the Options" {:file "doc/options.md"}]
|
||||
|
|
|
|||
|
|
@ -1,8 +1,6 @@
|
|||
# Other Databases
|
||||
|
||||
There are dedicated sections for [New Relic Query Language Support](nrql.md),
|
||||
[PostgreSQL Support](postgres.md), and
|
||||
[XTDB Support](xtdb.md).
|
||||
There is a dedicated section for [PostgreSQL Support](postgres.md).
|
||||
This section provides hints and tips for generating SQL for other
|
||||
databases.
|
||||
|
||||
|
|
|
|||
|
|
@ -9,7 +9,7 @@ The DSL itself -- the data structures that both versions convert to SQL and para
|
|||
If you are using Clojure 1.11, you can invoke `format` with a mixture of named arguments and a trailing hash
|
||||
map of additional options, if you wish.
|
||||
|
||||
HoneySQL 1.x supported Clojure 1.7 and later. HoneySQL 2.7.y requires Clojure 1.10.3 or later. Earlier versions of HoneySQL 2.x support Clojure 1.9.0.
|
||||
HoneySQL 1.x supported Clojure 1.7 and later. HoneySQL 2.x requires Clojure 1.9 or later.
|
||||
|
||||
## Group, Artifact, and Namespaces
|
||||
|
||||
|
|
@ -63,7 +63,7 @@ Supported Clojure versions: 1.7 and later.
|
|||
In `deps.edn`:
|
||||
<!-- :test-doc-blocks/skip -->
|
||||
```clojure
|
||||
com.github.seancorfield/honeysql {:mvn/version "2.7.1295"}
|
||||
com.github.seancorfield/honeysql {:mvn/version "2.6.1203"}
|
||||
```
|
||||
|
||||
Required as:
|
||||
|
|
@ -90,7 +90,7 @@ The new namespaces are:
|
|||
* `honey.sql` -- the primary API (just `format` now),
|
||||
* `honey.sql.helpers` -- helper functions to build the DSL.
|
||||
|
||||
Supported Clojure versions: 1.10.3 and later.
|
||||
Supported Clojure versions: 1.9 and later.
|
||||
|
||||
## API Changes
|
||||
|
||||
|
|
|
|||
|
|
@ -10,14 +10,14 @@ For the Clojure CLI, add the following dependency to your `deps.edn` file:
|
|||
|
||||
<!-- :test-doc-blocks/skip -->
|
||||
```clojure
|
||||
com.github.seancorfield/honeysql {:mvn/version "2.7.1295"}
|
||||
com.github.seancorfield/honeysql {:mvn/version "2.6.1203"}
|
||||
```
|
||||
|
||||
For Leiningen, add the following dependency to your `project.clj` file:
|
||||
|
||||
<!-- :test-doc-blocks/skip -->
|
||||
```clojure
|
||||
[com.github.seancorfield/honeysql "2.7.1295"]
|
||||
[com.github.seancorfield/honeysql "2.6.1203"]
|
||||
```
|
||||
|
||||
HoneySQL produces SQL statements but does not execute them.
|
||||
|
|
@ -26,7 +26,7 @@ To execute SQL statements, you will also need a JDBC wrapper like
|
|||
|
||||
You can also experiment with HoneySQL directly in a browser -- no installation
|
||||
required -- using [John Shaffer](https://github.com/john-shaffer)'s awesome
|
||||
[HoneySQL web app](https://john.shaffe.rs/honeysql/), written in ClojureScript!
|
||||
[HoneySQL web app](https://www.john-shaffer.com/honeysql/), written in ClojureScript!
|
||||
|
||||
## Basic Concepts
|
||||
|
||||
|
|
@ -415,8 +415,7 @@ If you want to use a dialect _and_ use the default quoting strategy (automatical
|
|||
```
|
||||
|
||||
Out of the box, as part of the extended ANSI SQL support,
|
||||
HoneySQL supports quite a few [PostgreSQL extensions](postgresql.md)
|
||||
and [XTDB extensions](xtdb.md).
|
||||
HoneySQL supports quite a few [PostgreSQL extensions](postgresql.md).
|
||||
|
||||
> Note: the [nilenso/honeysql-postgres](https://github.com/nilenso/honeysql-postgres) library which provided PostgreSQL support for HoneySQL 1.x does not work with HoneySQL 2.x. However, HoneySQL 2.x includes all of the functionality from that library (up to 0.4.112) out of the box!
|
||||
|
||||
|
|
|
|||
|
|
@ -29,14 +29,6 @@ and strings.
|
|||
:from :b
|
||||
:order-by [[[:alias :'some-alias]]]})
|
||||
;;=> ["SELECT column_name AS \"some-alias\" FROM b ORDER BY \"some-alias\" ASC"]
|
||||
(sql/format {:select [[:column-name "some-alias"]]
|
||||
:from :b
|
||||
:group-by [[:alias "some-alias"]]})
|
||||
;;=> ["SELECT column_name AS \"some-alias\" FROM b GROUP BY \"some-alias\""]
|
||||
(sql/format {:select [[:column-name "some-alias"]]
|
||||
:from :b
|
||||
:group-by [[:alias :'some-alias]]})
|
||||
;;=> ["SELECT column_name AS \"some-alias\" FROM b GROUP BY \"some-alias\""]
|
||||
```
|
||||
|
||||
## array
|
||||
|
|
@ -88,29 +80,6 @@ In the subquery case, produces `ARRAY(subquery)`:
|
|||
;;=> ["SELECT ARRAY(SELECT * FROM table) AS arr"]
|
||||
```
|
||||
|
||||
## at
|
||||
|
||||
If addition to dot navigation (for JSON) -- see the `.` and `.:.` syntax below --
|
||||
HoneySQL also supports bracket notation for JSON navigation.
|
||||
|
||||
The first argument to `:at` is treated as an expression that identifies
|
||||
the column, and subsequent arguments are treated as field names or array
|
||||
indices to navigate into that document.
|
||||
|
||||
```clojure
|
||||
user=> (sql/format {:select [[[:at :col :field1 :field2]]]})
|
||||
["SELECT col.field1.field2"]
|
||||
user=> (sql/format {:select [[[:at :table.col 0 :field]]]})
|
||||
["SELECT table.col[0].field"]
|
||||
```
|
||||
|
||||
If you want an array index to be a parameter, use `:lift`:
|
||||
|
||||
```clojure
|
||||
user=> (sql/format {:select [[[:at :col [:lift 0] :field]]]})
|
||||
["SELECT col[?].field" 0]
|
||||
```
|
||||
|
||||
## at time zone
|
||||
|
||||
Accepts two arguments: an expression (assumed to be a date/time of some sort)
|
||||
|
|
@ -124,7 +93,7 @@ and a time zone name or identifier (can be a string, a symbol, or a keyword):
|
|||
The time zone name or identifier will be inlined (as a string) and therefore
|
||||
cannot be an expression.
|
||||
|
||||
## between and not-between
|
||||
## between
|
||||
|
||||
Accepts three arguments: an expression, a lower bound, and
|
||||
an upper bound:
|
||||
|
|
@ -132,9 +101,6 @@ an upper bound:
|
|||
```clojure
|
||||
(sql/format-expr [:between :id 1 100])
|
||||
;;=> ["id BETWEEN ? AND ?" 1 100]
|
||||
|
||||
(sql/format-expr [:not-between :id 1 100])
|
||||
;;=> ["id NOT BETWEEN ? AND ?" 1 100]
|
||||
```
|
||||
|
||||
## case
|
||||
|
|
@ -234,23 +200,15 @@ Accepts a single expression and prefixes it with `DISTINCT `:
|
|||
;;=> ["SELECT COUNT(DISTINCT status) AS n FROM table"]
|
||||
```
|
||||
|
||||
## dot . .:.
|
||||
## dot .
|
||||
|
||||
Accepts an expression and one or more fields (or columns). Plain dot produces
|
||||
plain dotted selection:
|
||||
Accepts an expression and a field (or column) selection:
|
||||
|
||||
```clojure
|
||||
(sql/format {:select [ [[:. :t :c]] [[:. :s :t :c]] ]})
|
||||
;;=> ["SELECT t.c, s.t.c"]
|
||||
```
|
||||
|
||||
Dot colon dot produces Snowflake-style dotted selection:
|
||||
|
||||
```clojure
|
||||
(sql/format {:select [ [[:.:. :t :c]] [[:.:. :s :t :c]] ]})
|
||||
;;=> ["SELECT t:c, s:t.c"]
|
||||
```
|
||||
|
||||
Can be used with `:nest` for field selection from composites:
|
||||
|
||||
```clojure
|
||||
|
|
@ -258,9 +216,6 @@ Can be used with `:nest` for field selection from composites:
|
|||
;;=> ["SELECT (v).*, (MYFUNC(x)).y"]
|
||||
```
|
||||
|
||||
See also [`get-in`](xtdb.md#object-navigation-expressions)
|
||||
and [`at`](#at) for additional path navigation functions.
|
||||
|
||||
## entity
|
||||
|
||||
Accepts a single keyword or symbol argument and produces a
|
||||
|
|
|
|||
220
doc/xtdb.md
220
doc/xtdb.md
|
|
@ -1,220 +0,0 @@
|
|||
# XTDB Support
|
||||
|
||||
As of 2.6.1230, HoneySQL provides support for most of XTDB's SQL
|
||||
extensions, with additional support being added in subsequent releases.
|
||||
|
||||
For the most part, XTDB's SQL is based on
|
||||
[SQL:2011](https://en.wikipedia.org/wiki/SQL:2011), including the
|
||||
bitemporal features, but also includes a number of SQL extensions
|
||||
to support additional XTDB-specific features.
|
||||
|
||||
HoneySQL attempts to support all of these XTDB features in the core
|
||||
ANSI dialect, and this section documents most of those XTDB features.
|
||||
|
||||
For more details, see the XTDB documentation:
|
||||
* [SQL Overview](https://docs.xtdb.com/quickstart/sql-overview.html)
|
||||
* [SQL Queries](https://docs.xtdb.com/reference/main/sql/queries.html)
|
||||
* [SQL Transactions/DML](https://docs.xtdb.com/reference/main/sql/txs.html)
|
||||
|
||||
## Code Examples
|
||||
|
||||
The code examples herein assume:
|
||||
```clojure
|
||||
(refer-clojure :exclude '[update set])
|
||||
(require '[honey.sql :as sql]
|
||||
'[honey.sql.helpers :refer [select from where
|
||||
delete-from erase-from
|
||||
insert-into patch-into values
|
||||
records]])
|
||||
```
|
||||
|
||||
Clojure users can opt for the shorter `(require '[honey.sql :as sql] '[honey.sql.helpers :refer :all])` but this syntax is not available to ClojureScript users.
|
||||
|
||||
## `select` Variations
|
||||
|
||||
XTDB allows you to omit `SELECT` in a query. `SELECT *` is assumed if
|
||||
it is omitted. In HoneySQL, you can simply omit the `:select` clause
|
||||
from the DSL to achieve this.
|
||||
|
||||
```clojure
|
||||
user=> (sql/format '{select * from foo where (= status "active")})
|
||||
["SELECT * FROM foo WHERE status = ?" "active"]
|
||||
user=> (sql/format '{from foo where (= status "active")})
|
||||
["FROM foo WHERE status = ?" "active"]
|
||||
```
|
||||
|
||||
You can also `SELECT *` and then exclude columns and/or rename columns.
|
||||
|
||||
```clojure
|
||||
user=> (sql/format {:select [[:* {:exclude :_id :rename [[:title, :name]]}]]})
|
||||
["SELECT * EXCLUDE _id RENAME title AS name"]
|
||||
user=> (sql/format '{select ((a.* {exclude _id})
|
||||
(b.* {rename ((title, name))}))
|
||||
from ((foo a))
|
||||
join ((bar b) (= a._id b.foo_id))})
|
||||
["SELECT a.* EXCLUDE _id, b.* RENAME title AS name FROM foo AS a INNER JOIN bar AS b ON a._id = b.foo_id"]
|
||||
```
|
||||
|
||||
`:exclude` can accept a single column, or a sequence of columns.
|
||||
`:rename` accepts a sequence of pairs (column name, new name).
|
||||
|
||||
```clojure
|
||||
user=> (sql/format {:select [[:* {:exclude [:_id :upc]
|
||||
:rename [[:title, :name]
|
||||
[:price, :cost]]}]]})
|
||||
["SELECT * EXCLUDE (_id, upc) RENAME (title AS name, price AS cost)"]
|
||||
```
|
||||
|
||||
## Nested Sub-Queries
|
||||
|
||||
XTDB can produce structured results from `SELECT` queries containing
|
||||
sub-queries, using `NEST_ONE` and `NEST_MANY`. In HoneySQL, these are
|
||||
supported as regular function syntax in `:select` clauses.
|
||||
|
||||
```clojure
|
||||
user=> (sql/format '{select (a.*
|
||||
((nest_many {select * from bar where (= foo_id a._id)})
|
||||
b))
|
||||
from ((foo a))})
|
||||
["SELECT a.*, NEST_MANY (SELECT * FROM bar WHERE foo_id = a._id) AS b FROM foo AS a"]
|
||||
```
|
||||
|
||||
Remember that function calls in `:select` clauses need to be nested three
|
||||
levels of parentheses (brackets):
|
||||
`:select [:col-a [:col-b :alias-b] [[:fn-call :col-c] :alias-c]]`.
|
||||
|
||||
## `records` Clause
|
||||
|
||||
XTDB provides a `RECORDS` clause to specify a list of structured documents,
|
||||
similar to `VALUES` but specifically for documents rather than a collection
|
||||
of column values. HoneySQL supports a `:records` clauses and automatically
|
||||
lifts hash map values to parameters (rather than treating them as DSL fragments).
|
||||
You can inline a hash map to produce XTDB's inline document syntax.
|
||||
See also `insert` and `patch` below.
|
||||
|
||||
```clojure
|
||||
user=> (sql/format {:records [{:_id 1 :status "active"}]})
|
||||
["RECORDS ?" {:_id 1, :status "active"}]
|
||||
user=> (sql/format {:records [[:inline {:_id 1 :status "active"}]]})
|
||||
["RECORDS {_id: 1, status: 'active'}"]
|
||||
```
|
||||
|
||||
## `object` (`record`) Literals
|
||||
|
||||
While `RECORDS` exists in parallel to the `VALUES` clause, XTDB also provides
|
||||
a syntax to construct documents in other contexts in SQL, via the `OBJECT`
|
||||
literal syntax. `RECORD` is a synonym for `OBJECT`. HoneySQL supports both
|
||||
`:object` and `:record` as special syntax:
|
||||
|
||||
```clojure
|
||||
user=> (sql/format {:select [[[:object {:_id 1 :status "active"}]]]})
|
||||
["SELECT OBJECT (_id: 1, status: 'active')"]
|
||||
user=> (sql/format {:select [[[:record {:_id 1 :status "active"}]]]})
|
||||
["SELECT RECORD (_id: 1, status: 'active')"]
|
||||
```
|
||||
|
||||
A third option is to use `:inline` with a hash map:
|
||||
|
||||
```clojure
|
||||
user=> (sql/format {:select [[[:inline {:_id 1 :status "active"}]]]})
|
||||
["SELECT {_id: 1, status: 'active'}"]
|
||||
```
|
||||
|
||||
## Object Navigation Expressions
|
||||
|
||||
In order to deal with nested documents, XTDB provides syntax to navigate
|
||||
into them, via field names and/or array indices. HoneySQL supports this
|
||||
via the `:get-in` special syntax, intended to be familiar to Clojure users.
|
||||
|
||||
The first argument to `:get-in` is treated as an expression that produces
|
||||
the document, and subsequent arguments are treated as field names or array
|
||||
indices to navigate into that document.
|
||||
|
||||
```clojure
|
||||
user=> (sql/format {:select [[[:get-in :doc :field1 :field2]]]})
|
||||
["SELECT (doc).field1.field2"]
|
||||
user=> (sql/format {:select [[[:get-in :table.col 0 :field]]]})
|
||||
["SELECT (table.col)[0].field"]
|
||||
```
|
||||
|
||||
If you want an array index to be a parameter, use `:lift`:
|
||||
|
||||
```clojure
|
||||
user=> (sql/format {:select [[[:get-in :doc [:lift 0] :field]]]})
|
||||
["SELECT (doc)[?].field" 0]
|
||||
```
|
||||
|
||||
## Temporal Queries
|
||||
|
||||
XTDB allows any query to be run in a temporal context via the `SETTING`
|
||||
clause (ahead of the `SELECT` clause). HoneySQL supports this via the
|
||||
`:setting` clause. It accepts a sequence of identifiers and expressions.
|
||||
An identifier ending in `-time` is assumed to be a temporal identifier
|
||||
(e.g., `:system-time` mapping to `SYSTEM_TIME`). Other identifiers are assumed to
|
||||
be regular SQL (so `-` is mapped to a space, e.g., `:as-of` mapping to `AS OF`).
|
||||
A timestamp literal, such as `DATE '2024-11-24'` can be specified in HoneySQL
|
||||
using `[:inline [:DATE "2024-11-24"]]` (note the literal case of `:DATE`
|
||||
to produce `DATE`).
|
||||
|
||||
See [XTDB's Top-level queries documentation](https://docs.xtdb.com/reference/main/sql/queries.html#_top_level_queries) for more details.
|
||||
|
||||
Here's one fairly complex example:
|
||||
|
||||
```clojure
|
||||
user=> (sql/format {:setting [[:snapshot-time :to [:inline :DATE "2024-11-24"]]
|
||||
[:default :valid-time :to :between [:inline :DATE "2022"] :and [:inline :DATE "2023"]]]})
|
||||
["SETTING SNAPSHOT_TIME TO DATE '2024-11-24', DEFAULT VALID_TIME TO BETWEEN DATE '2022' AND DATE '2023'"]
|
||||
```
|
||||
|
||||
Table references (e.g., in a `FROM` clause) can also have temporal qualifiers.
|
||||
See [HoneySQL's `from` clause documentation](clause-reference.md#from) for
|
||||
examples of that, one of which is reproduced here:
|
||||
|
||||
```clojure
|
||||
user=> (sql/format {:select [:username]
|
||||
:from [[:user :for :system-time :as-of [:inline "2019-08-01 15:23:00"]]]
|
||||
:where [:= :id 9]})
|
||||
["SELECT username FROM user FOR SYSTEM_TIME AS OF '2019-08-01 15:23:00' WHERE id = ?" 9]
|
||||
```
|
||||
|
||||
## `delete` and `erase`
|
||||
|
||||
In XTDB, `DELETE` is a temporal deletion -- the data remains in the database
|
||||
but is no longer visible in queries that don't specify a time range prior to
|
||||
the deletion. XTDB provides a similar `ERASE` operation that can permanently
|
||||
delete the data. HoneySQL supports `:erase-from` with the same syntax as
|
||||
`:delete-from`.
|
||||
|
||||
```clojure
|
||||
user=> (sql/format {:delete-from :foo :where [:= :status "inactive"]})
|
||||
["DELETE FROM foo WHERE status = ?" "inactive"]
|
||||
user=> (sql/format {:erase-from :foo :where [:= :status "inactive"]})
|
||||
["ERASE FROM foo WHERE status = ?" "inactive"]
|
||||
```
|
||||
|
||||
## `insert` and `patch`
|
||||
|
||||
XTDB supports `PATCH` as an upsert operation: it will update existing
|
||||
documents (via merging the new data) or insert new documents if they
|
||||
don't already exist. HoneySQL supports `:patch-into` with the same syntax
|
||||
as `:insert-into` with `:records`.
|
||||
|
||||
```clojure
|
||||
user=> (sql/format {:insert-into :foo
|
||||
:records [{:_id 1 :status "active"}]})
|
||||
["INSERT INTO foo RECORDS ?" {:_id 1, :status "active"}]
|
||||
user=> (sql/format {:patch-into :foo
|
||||
:records [{:_id 1 :status "active"}]})
|
||||
["PATCH INTO foo RECORDS ?" {:_id 1, :status "active"}]
|
||||
```
|
||||
|
||||
## `assert`
|
||||
|
||||
XTDB supports an `ASSERT` operation that will throw an exception if the
|
||||
asserted predicate is not true:
|
||||
|
||||
```clojure
|
||||
user=> (sql/format '{assert (not-exists {select 1 from users where (= email "james @example.com")})}
|
||||
:inline true)
|
||||
["ASSERT NOT EXISTS (SELECT 1 FROM users WHERE email = 'james @example.com')"]
|
||||
```
|
||||
|
|
@ -1,4 +1,4 @@
|
|||
;; copyright (c) 2020-2025 sean corfield, all rights reserved
|
||||
;; copyright (c) 2020-2024 sean corfield, all rights reserved
|
||||
|
||||
(ns honey.sql
|
||||
"Primary API for HoneySQL 2.x.
|
||||
|
|
@ -31,9 +31,7 @@
|
|||
(:require [clojure.string :as str]
|
||||
#?(:clj [clojure.template])
|
||||
[honey.sql.protocols :as p]
|
||||
[honey.sql.util :refer [str join split-by-separator into*]]))
|
||||
|
||||
#?(:clj (set! *warn-on-reflection* true))
|
||||
[honey.sql.util :refer [str join]]))
|
||||
|
||||
;; default formatting for known clauses
|
||||
|
||||
|
|
@ -57,13 +55,12 @@
|
|||
:refresh-materialized-view
|
||||
:create-index
|
||||
;; then SQL clauses in priority order:
|
||||
:setting
|
||||
:raw :nest :with :with-recursive :intersect :union :union-all :except :except-all
|
||||
:table :assert ; #567 XTDB
|
||||
:table
|
||||
:select :select-distinct :select-distinct-on :select-top :select-distinct-top
|
||||
:distinct :expr :exclude :rename
|
||||
:distinct :expr
|
||||
:into :bulk-collect-into
|
||||
:insert-into :patch-into :replace-into :update :delete :delete-from :erase-from :truncate
|
||||
:insert-into :replace-into :update :delete :delete-from :truncate
|
||||
:columns :set :from :using
|
||||
:join-by
|
||||
:join :left-join :right-join :inner-join :outer-join :full-join
|
||||
|
|
@ -72,7 +69,7 @@
|
|||
;; NRQL extension:
|
||||
:facet
|
||||
:window :partition-by
|
||||
:order-by :limit :offset :fetch :for :lock :values :records
|
||||
:order-by :limit :offset :fetch :for :lock :values
|
||||
:on-conflict :on-constraint :do-nothing :do-update-set :on-duplicate-key-update
|
||||
:returning
|
||||
:with-data
|
||||
|
|
@ -114,15 +111,17 @@
|
|||
(assoc m k (assoc v :dialect k)))
|
||||
{}
|
||||
{:ansi {:quote #(strop "\"" % "\"")}
|
||||
:sqlserver {:quote #(strop "[" % "]")
|
||||
:auto-lift-boolean true}
|
||||
:sqlserver {:quote #(strop "[" % "]")}
|
||||
:mysql {:quote #(strop "`" % "`")
|
||||
:clause-order-fn
|
||||
#(add-clause-before % :set :where)}
|
||||
:nrql {:quote #(strop "`" % "`")
|
||||
:col-fn #(if (keyword? %) (subs (str %) 1) (str %))
|
||||
:parts-fn vector}
|
||||
:oracle {:quote #(strop "\"" % "\"") :as false}})))
|
||||
:oracle {:quote #(strop "\"" % "\"") :as false}
|
||||
:xtdb {:quote #(strop "\"" % "\"")
|
||||
:col-fn #(if (keyword? %) (subs (str %) 1) (str %))
|
||||
:parts-fn #(str/split % #"\.")}})))
|
||||
|
||||
; should become defonce
|
||||
(def ^:private default-dialect (atom (:ansi @dialects)))
|
||||
|
|
@ -229,8 +228,7 @@
|
|||
|
||||
Hyphens at the start or end of a string should not be touched."
|
||||
[s]
|
||||
(cond-> s
|
||||
(str/includes? s "-") (str/replace #"(\w)-(?=\w)" "$1 ")))
|
||||
(str/replace s #"(\w)-(?=\w)" "$1 "))
|
||||
|
||||
(defn- namespace-_
|
||||
"Return the namespace portion of a symbol, with dashes converted."
|
||||
|
|
@ -319,7 +317,7 @@
|
|||
[n %]
|
||||
(if aliased
|
||||
[%]
|
||||
(split-by-separator % "."))))
|
||||
(str/split % #"\."))))
|
||||
parts (parts-fn col-e)
|
||||
entity (join "." (map #(cond-> % (not= "*" %) (quote-fn))) parts)]
|
||||
(suspicious-entity-check entity)
|
||||
|
|
@ -370,29 +368,6 @@
|
|||
(keyword (name s)))
|
||||
s))
|
||||
|
||||
(defn- kw->sym
|
||||
"Given a keyword, produce a symbol, retaining the namespace
|
||||
qualifier, if any."
|
||||
[k]
|
||||
(if (keyword? k)
|
||||
#?(:bb (if-let [n (namespace k)]
|
||||
(symbol n (name k))
|
||||
(symbol (name k)))
|
||||
:clj (.sym ^clojure.lang.Keyword k)
|
||||
:default (if-let [n (namespace k)]
|
||||
(symbol n (name k))
|
||||
(symbol (name k))))
|
||||
k))
|
||||
|
||||
(defn- inline-map [x & [open close]]
|
||||
(str (or open "{")
|
||||
(join ", " (map (fn [[k v]]
|
||||
(str (format-entity k)
|
||||
": "
|
||||
(p/sqlize v))))
|
||||
x)
|
||||
(or close "}")))
|
||||
|
||||
(extend-protocol p/InlineValue
|
||||
nil
|
||||
(sqlize [_] "NULL")
|
||||
|
|
@ -404,17 +379,11 @@
|
|||
(sqlize [x] (sql-kw x))
|
||||
#?(:cljs PersistentVector :default clojure.lang.IPersistentVector)
|
||||
(sqlize [x] (str "[" (join ", " (map p/sqlize) x) "]"))
|
||||
#?(:cljs PersistentArrayMap :default clojure.lang.IPersistentMap)
|
||||
(sqlize [x] (inline-map x))
|
||||
#?@(:cljs [PersistentHashMap
|
||||
(sqlize [x] (inline-map x))])
|
||||
#?@(:clj [java.util.UUID
|
||||
;; issue 385: quoted UUIDs for PostgreSQL/ANSI
|
||||
(sqlize [x] (str \' x \'))])
|
||||
#?(:cljs default :default Object)
|
||||
(sqlize [x] (if (string? x)
|
||||
(str \' (str/replace x "'" "''") \')
|
||||
(str x))))
|
||||
(sqlize [x] (str x)))
|
||||
|
||||
(defn- sqlize-value [x] (p/sqlize x))
|
||||
|
||||
|
|
@ -450,8 +419,7 @@
|
|||
(defn- format-simple-var
|
||||
([x]
|
||||
(let [c (if (keyword? x)
|
||||
#?(:bb (subs (str x) 1)
|
||||
:clj (str (.sym ^clojure.lang.Keyword x))
|
||||
#?(:clj (str (.sym ^clojure.lang.Keyword x)) ;; Omits leading colon
|
||||
:default (subs (str x) 1))
|
||||
(str x))]
|
||||
(format-simple-var x c {})))
|
||||
|
|
@ -459,8 +427,8 @@
|
|||
(if (str/starts-with? c "'")
|
||||
(do
|
||||
(reset! *formatted-column* true)
|
||||
(subs c 1))
|
||||
(format-entity x opts))))
|
||||
[(subs c 1)])
|
||||
[(format-entity x opts)])))
|
||||
|
||||
(defn- format-var
|
||||
([x] (format-var x {}))
|
||||
|
|
@ -469,12 +437,11 @@
|
|||
;; for multiple / in the %fun.call case so that
|
||||
;; qualified column names can be used:
|
||||
(let [c (if (keyword? x)
|
||||
#?(:bb (subs (str x) 1)
|
||||
:clj (str (.sym ^clojure.lang.Keyword x))
|
||||
#?(:clj (str (.sym ^clojure.lang.Keyword x)) ;; Omits leading colon
|
||||
:default (subs (str x) 1))
|
||||
(str x))]
|
||||
(cond (str/starts-with? c "%")
|
||||
(let [[f & args] (split-by-separator (subs c 1) ".")]
|
||||
(let [[f & args] (str/split (subs c 1) #"\.")]
|
||||
[(str (format-fn-name f) "("
|
||||
(join ", " (map #(format-entity (keyword %) opts)) args)
|
||||
")")])
|
||||
|
|
@ -487,7 +454,7 @@
|
|||
:else
|
||||
["?" (->param k)]))
|
||||
:else
|
||||
[(format-simple-var x c opts)]))))
|
||||
(format-simple-var x c opts)))))
|
||||
|
||||
(defn- format-entity-alias [x]
|
||||
(cond (sequential? x)
|
||||
|
|
@ -542,10 +509,14 @@
|
|||
:else
|
||||
(throw (ex-info "bigquery * only supports except and replace"
|
||||
{:clause k :arg arg})))]
|
||||
(into* [(cond->> sql' sql (str sql " "))] params params')))
|
||||
(-> [(cond->> sql' sql (str sql " "))]
|
||||
(into params)
|
||||
(into params'))))
|
||||
[]
|
||||
(partition-all 2 x))]
|
||||
(into* [(str sql " " sql')] params params')))
|
||||
(-> [(str sql " " sql')]
|
||||
(into params)
|
||||
(into params'))))
|
||||
|
||||
(comment
|
||||
(bigquery-*-except-replace? [:* :except [:a :b :c]])
|
||||
|
|
@ -660,17 +631,10 @@
|
|||
[sql & params] (if (map? selectable)
|
||||
(format-dsl selectable {:nested true})
|
||||
(format-expr selectable))
|
||||
*-qualifier (and (map? alias)
|
||||
(some #(contains? alias %)
|
||||
[:exclude :rename
|
||||
'exclude 'rename]))
|
||||
[sql' & params'] (when alias
|
||||
(cond (sequential? alias)
|
||||
(if (sequential? alias)
|
||||
(let [[sqls params] (format-expr-list alias {:aliased true})]
|
||||
(into [(join " " sqls)] params))
|
||||
*-qualifier
|
||||
(format-dsl alias)
|
||||
:else
|
||||
(format-selectable-dsl alias {:aliased true})))
|
||||
[sql'' & params''] (when temporal
|
||||
(format-temporal temporal))]
|
||||
|
|
@ -680,16 +644,17 @@
|
|||
(str " " sql''))
|
||||
(when sql' ; alias
|
||||
(str (if as
|
||||
(if (or *-qualifier
|
||||
(and (contains? *dialect* :as)
|
||||
(not (:as *dialect*))))
|
||||
(if (and (contains? *dialect* :as)
|
||||
(not (:as *dialect*)))
|
||||
" "
|
||||
" AS ")
|
||||
" ")
|
||||
sql'))
|
||||
(when hints
|
||||
(str " WITH (" hints ")")))]
|
||||
(into* params params' params'')))))
|
||||
(into params)
|
||||
(into params')
|
||||
(into params'')))))
|
||||
|
||||
(defn- format-selectable-dsl
|
||||
([x] (format-selectable-dsl x {}))
|
||||
|
|
@ -763,8 +728,9 @@
|
|||
(let [[cur & params] (peek result)
|
||||
[sql & params'] (first exprs)]
|
||||
(recur (rest exprs) args' false (conj (pop result)
|
||||
(into* [(str cur " " sql)]
|
||||
params params'))))
|
||||
(-> [(str cur " " sql)]
|
||||
(into params)
|
||||
(into params')))))
|
||||
(recur (rest exprs) args' false (conj result (first exprs))))))
|
||||
(reduce-sql result)))))
|
||||
|
||||
|
|
@ -802,40 +768,33 @@
|
|||
(defn- format-columns [k xs]
|
||||
(if (and (= :columns k)
|
||||
(or (contains-clause? :insert-into)
|
||||
(contains-clause? :patch-into)
|
||||
(contains-clause? :replace-into)))
|
||||
[]
|
||||
(let [[sqls params] (format-expr-list xs {:drop-ns true})]
|
||||
(into [(str "(" (join ", " sqls) ")")] params))))
|
||||
|
||||
(defn- format-selects-common
|
||||
([prefix as xs] (format-selects-common prefix as xs nil))
|
||||
([prefix as xs wrap]
|
||||
(defn- format-selects-common [prefix as xs]
|
||||
(let [qualifier (format-meta xs)
|
||||
prefix (if prefix
|
||||
(cond-> prefix qualifier (str " " qualifier))
|
||||
qualifier)
|
||||
[pre post] (when (and wrap (sequential? xs) (< 1 (count xs)))
|
||||
["(" ")"])]
|
||||
qualifier)]
|
||||
(if (sequential? xs)
|
||||
(let [[sqls params] (reduce-sql (map #(format-selectable-dsl % {:as as})) xs)]
|
||||
(when-not (= :none *checking*)
|
||||
(when (empty? xs)
|
||||
(throw (ex-info (str prefix " empty column list is illegal")
|
||||
{:clause (into [prefix] xs)}))))
|
||||
(into [(str (when prefix (str prefix " ")) pre (join ", " sqls) post)] params))
|
||||
(into [(str (when prefix (str prefix " ")) (join ", " sqls))] params))
|
||||
(let [[sql & params] (format-selectable-dsl xs {:as as})]
|
||||
(into [(str (when prefix (str prefix " ")) sql)] params))))))
|
||||
(into [(str (when prefix (str prefix " ")) sql)] params)))))
|
||||
|
||||
(defn- format-selects [k xs]
|
||||
(format-selects-common
|
||||
(sql-kw k)
|
||||
(#{:select :select-distinct :rename :from :window :delete-from :facet
|
||||
'select 'select-distinct 'rename 'from 'window 'delete-from 'facet
|
||||
}
|
||||
(#{:select :select-distinct :from :window :delete-from :facet
|
||||
'select 'select-distinct 'from 'window 'delete-from 'facet}
|
||||
k)
|
||||
xs
|
||||
(#{:exclude :rename 'exclude 'rename} k)))
|
||||
xs))
|
||||
|
||||
(defn- format-selects-on [_ xs]
|
||||
(let [[on & cols] xs
|
||||
|
|
@ -846,7 +805,7 @@
|
|||
(str (sql-kw :select) " " sql)
|
||||
true
|
||||
cols)]
|
||||
(into* [sql'] params params')))
|
||||
(-> [sql'] (into params) (into params'))))
|
||||
|
||||
(defn- format-select-top [k xs]
|
||||
(let [[top & cols] xs
|
||||
|
|
@ -874,7 +833,7 @@
|
|||
(join " " (map sql-kw) parts))
|
||||
true
|
||||
cols)]
|
||||
(into* [sql'] params params')))
|
||||
(-> [sql'] (into params) (into params'))))
|
||||
|
||||
(defn- format-select-into [k xs]
|
||||
(let [[v e] (ensure-sequential xs)
|
||||
|
|
@ -960,20 +919,25 @@
|
|||
(map
|
||||
(fn [[x expr & tail :as with]]
|
||||
(let [[sql & params] (format-with-part x)
|
||||
non-query-expr? (not (map? expr))
|
||||
non-query-expr? (or (ident? expr) (string? expr))
|
||||
[sql' & params'] (if non-query-expr?
|
||||
(format-expr expr)
|
||||
(format-dsl expr))
|
||||
[sql'' & params'' :as sql-params'']
|
||||
(if non-query-expr?
|
||||
(into* [(str sql' " AS " sql)] params' params)
|
||||
(cond-> [(str sql' " AS " sql)]
|
||||
params' (into params')
|
||||
params (into params))
|
||||
;; according to docs, CTE should _always_ be wrapped:
|
||||
(into* [(str sql " " (as-fn with) " " (str "(" sql' ")"))]
|
||||
params params'))
|
||||
(cond-> [(str sql " " (as-fn with) " " (str "(" sql' ")"))]
|
||||
params (into params)
|
||||
params' (into params')))
|
||||
[tail-sql & tail-params]
|
||||
(format-with-query-tail tail)]
|
||||
(if (seq tail-sql)
|
||||
(into* [(str sql'' " " tail-sql)] params'' tail-params)
|
||||
(cond-> [(str sql'' " " tail-sql)]
|
||||
params'' (into params'')
|
||||
tail-params (into tail-params))
|
||||
sql-params''))))
|
||||
xs)]
|
||||
(into [(str (sql-kw k) " " (join ", " sqls))] params)))
|
||||
|
|
@ -981,9 +945,6 @@
|
|||
(defn- format-selector [k xs]
|
||||
(format-selects k [xs]))
|
||||
|
||||
(defn- format-window [k xs]
|
||||
(format-selects k (into [] (partition-all 2 xs))))
|
||||
|
||||
(declare columns-from-values)
|
||||
|
||||
(defn- format-insert [k table]
|
||||
|
|
@ -1017,7 +978,10 @@
|
|||
(str cols-sql' " "))
|
||||
overriding
|
||||
sql)]
|
||||
(into* t-params c-params cols-params' params)))
|
||||
(into t-params)
|
||||
(into c-params)
|
||||
(into cols-params')
|
||||
(into params)))
|
||||
(sequential? (second table))
|
||||
(let [[table cols] table
|
||||
[t-sql & t-params] (format-entity-alias table)
|
||||
|
|
@ -1027,20 +991,23 @@
|
|||
(join ", " c-sqls)
|
||||
")"
|
||||
overriding)]
|
||||
(into* t-params c-params)))
|
||||
(into t-params)
|
||||
(into c-params)))
|
||||
:else
|
||||
(let [[sql & params] (format-entity-alias table)]
|
||||
(-> [(str (sql-kw k) " " sql
|
||||
(when (seq cols')
|
||||
(str " " cols-sql'))
|
||||
overriding)]
|
||||
(into* cols-params' params))))
|
||||
(into cols-params')
|
||||
(into params))))
|
||||
(let [[sql & params] (format-entity-alias table)]
|
||||
(-> [(str (sql-kw k) " " sql
|
||||
(when (seq cols')
|
||||
(str " " cols-sql'))
|
||||
overriding)]
|
||||
(into* cols-params' params))))))
|
||||
(into cols-params')
|
||||
(into params))))))
|
||||
|
||||
(comment
|
||||
(format-insert :insert-into [[[:raw ":foo"]] {:select :bar}])
|
||||
|
|
@ -1068,10 +1035,12 @@
|
|||
(str "("
|
||||
(join ", " u-sqls)
|
||||
")"))
|
||||
(into* params params-j u-params)])
|
||||
(-> params (into params-j) (into u-params))])
|
||||
(let [[sql & params'] (when e (format-expr e))]
|
||||
[(cond-> sqls e (conj "ON" sql))
|
||||
(into* params params-j params')])))))
|
||||
(-> params
|
||||
(into params-j)
|
||||
(into params'))])))))
|
||||
[[] []]
|
||||
clauses)]
|
||||
(into [(join " " sqls)] params)))
|
||||
|
|
@ -1133,13 +1102,11 @@
|
|||
dirs (map #(when (sequential? %) (second %)) xs)
|
||||
[sqls params]
|
||||
(format-expr-list (map #(if (sequential? %) (first %) %) xs))]
|
||||
(if (seq sqls)
|
||||
(into [(str (sql-kw k) " "
|
||||
(join ", " (map (fn [sql dir]
|
||||
(str sql " " (sql-kw (or dir :asc))))
|
||||
sqls
|
||||
dirs)))] params)
|
||||
[])))
|
||||
dirs)))] params)))
|
||||
|
||||
(defn- format-lock-strength [k xs]
|
||||
(let [[strength tables nowait] (ensure-sequential xs)]
|
||||
|
|
@ -1195,17 +1162,17 @@
|
|||
x))
|
||||
xs)))
|
||||
[sqls params]
|
||||
(reduce (fn [[sql params] x]
|
||||
(if (sequential? x)
|
||||
(let [[sqls' params'] (format-expr-list x)]
|
||||
(reduce (fn [[sql params] [sqls' params']]
|
||||
[(conj sql
|
||||
(if (sequential? sqls')
|
||||
(str "(" (join ", " sqls') ")")
|
||||
sqls'))
|
||||
(into* params params')])
|
||||
[(conj sql (sql-kw x)) params]))
|
||||
(into params params')])
|
||||
[[] []]
|
||||
xs')
|
||||
(map #(if (sequential? %)
|
||||
(format-expr-list %)
|
||||
[(sql-kw %)])
|
||||
xs'))
|
||||
sqls (if row-ctr (map #(str "ROW" %) sqls) sqls)]
|
||||
(into [(str (sql-kw k) " " (join ", " sqls))] params))
|
||||
|
||||
|
|
@ -1213,30 +1180,29 @@
|
|||
;; [{:a 1 :b 2 :c 3}]
|
||||
(let [[cols cols-sql]
|
||||
(columns-from-values xs (or (contains-clause? :insert-into)
|
||||
(contains-clause? :patch-into)
|
||||
(contains-clause? :replace-into)
|
||||
(contains-clause? :columns)))
|
||||
[sqls params]
|
||||
(reduce
|
||||
(fn [[sql params] x]
|
||||
(if (map? x)
|
||||
(let [[sqls' params']
|
||||
(reduce-sql (map #(format-expr
|
||||
(get x %
|
||||
;; issue #366: use NULL or DEFAULT
|
||||
;; for missing column values:
|
||||
(if (contains? *values-default-columns* %)
|
||||
[:default]
|
||||
nil))))
|
||||
cols)]
|
||||
(reduce (fn [[sql params] [sqls' params']]
|
||||
[(conj sql
|
||||
(if (sequential? sqls')
|
||||
(str "(" (join ", " sqls') ")")
|
||||
sqls'))
|
||||
(into* params params')])
|
||||
[(conj sql (sql-kw x)) params]))
|
||||
(if params' (into params params') params')])
|
||||
[[] []]
|
||||
xs)]
|
||||
(map (fn [m]
|
||||
(if (map? m)
|
||||
(format-expr-list
|
||||
(map #(get m
|
||||
%
|
||||
;; issue #366: use NULL or DEFAULT
|
||||
;; for missing column values:
|
||||
(if (contains? *values-default-columns* %)
|
||||
[:default]
|
||||
nil))
|
||||
cols))
|
||||
[(sql-kw m)]))
|
||||
xs))]
|
||||
(into [(str (when cols-sql
|
||||
(str cols-sql " "))
|
||||
(sql-kw k)
|
||||
|
|
@ -1281,7 +1247,8 @@
|
|||
(str " (" (join ", " sqls) ")"))
|
||||
(when sql
|
||||
(str " " sql)))]
|
||||
(into* expr-params clause-params)))
|
||||
(into expr-params)
|
||||
(into clause-params)))
|
||||
(format-on-conflict k [x])))
|
||||
|
||||
(defn- format-do-update-set [k x]
|
||||
|
|
@ -1300,7 +1267,8 @@
|
|||
where (or (:where x) ('where x))
|
||||
[sql & params] (when where (format-dsl {:where where}))]
|
||||
(-> [(str sets (when sql (str " " sql)))]
|
||||
(into* set-params params)))
|
||||
(into set-params)
|
||||
(into params)))
|
||||
(format-set-exprs k x))
|
||||
(sequential? x)
|
||||
(let [[cols clauses] (split-with (complement map?) x)]
|
||||
|
|
@ -1388,17 +1356,20 @@
|
|||
[(butlast coll) (last coll) nil]))]
|
||||
(into [(join " " (map sql-kw) prequel)
|
||||
(when table
|
||||
(format-simple-var table))
|
||||
(let [[v & more] (format-simple-var table)]
|
||||
(when (seq more)
|
||||
(throw (ex-info (str "DDL syntax error at: "
|
||||
(pr-str table)
|
||||
" - expected table name")
|
||||
{:unexpected more})))
|
||||
v))
|
||||
(when ine (sql-kw ine))]
|
||||
(when opts
|
||||
(format-ddl-options opts context)))))
|
||||
|
||||
(defn- format-truncate [_ xs]
|
||||
(let [[table & options] (ensure-sequential xs)
|
||||
table (if (or (ident? table) (string? table))
|
||||
(format-simple-var table)
|
||||
(join ", " (map format-simple-var table)))
|
||||
[pre _ ine options] (destructure-ddl-item [nil options] "truncate")]
|
||||
[pre table ine options] (destructure-ddl-item [table options] "truncate")]
|
||||
(when (seq pre) (throw (ex-info "TRUNCATE syntax error" {:unexpected pre})))
|
||||
(when (seq ine) (throw (ex-info "TRUNCATE syntax error" {:unexpected ine})))
|
||||
[(join " " (cond-> ["TRUNCATE TABLE" table]
|
||||
|
|
@ -1411,11 +1382,6 @@
|
|||
(destructure-ddl-item [:id [:int :unsigned :auto-increment]] "test")
|
||||
(destructure-ddl-item [[[:foreign-key :bar]] :quux [[:wibble :wobble]]] "test")
|
||||
(format-truncate :truncate [:foo])
|
||||
(format-truncate :truncate ["foo, bar"])
|
||||
(format-truncate :truncate "foo, bar")
|
||||
(format-truncate :truncate [[:foo :bar]])
|
||||
(format-truncate :truncate :foo)
|
||||
(format {:truncate [[:foo] :x]})
|
||||
)
|
||||
|
||||
(defn- format-create [q k item as]
|
||||
|
|
@ -1434,12 +1400,10 @@
|
|||
(defn- format-create-index [k clauses]
|
||||
(let [[index-spec [table & exprs]] clauses
|
||||
[pre entity ine & more] (destructure-ddl-item index-spec (str (sql-kw k) " options"))
|
||||
[using & exprs]
|
||||
(let [item (first exprs)]
|
||||
(if (and (ident? item)
|
||||
(str/starts-with? (str (kw->sym item)) "using-"))
|
||||
[using & exprs] (if (contains? #{:using-gin 'using-gin}
|
||||
(first exprs))
|
||||
exprs
|
||||
(cons nil exprs)))
|
||||
(cons nil exprs))
|
||||
[sqls params] (format-expr-list exprs)]
|
||||
(into [(join " " (remove empty?)
|
||||
(-> ["CREATE" pre "INDEX" ine entity
|
||||
|
|
@ -1574,40 +1538,6 @@
|
|||
(let [[sql & params] (format-expr n)]
|
||||
(into [(str (sql-kw k) " " sql)] params)))))
|
||||
[(str (sql-kw k) " " (sql-kw args))]))
|
||||
|
||||
(defn- format-records
|
||||
"Records can take a single map or a sequence of maps.
|
||||
|
||||
A map will be inherently treated as a lifted parameter.
|
||||
Records can be inlined [:inline some-map]"
|
||||
[k args]
|
||||
(if (sequential? args)
|
||||
(let [args (if (every? map? args)
|
||||
(map #(vector :lift %) args)
|
||||
args)
|
||||
[sqls params] (format-expr-list args)]
|
||||
(into [(str (sql-kw k) " " (join ", " sqls))] params))
|
||||
(format-records k [args])))
|
||||
|
||||
(defn- format-setting
|
||||
[k args]
|
||||
(if (and (sequential? args) (ident? (first args)))
|
||||
(format-setting k [args])
|
||||
(let [[sqls params]
|
||||
(reduce-sql
|
||||
(map (fn [arg]
|
||||
(let [[sqls params]
|
||||
(reduce-sql (map (fn [x]
|
||||
(if (ident? x)
|
||||
[(if (str/ends-with? (name x) "-time")
|
||||
(format-fn-name x)
|
||||
(sql-kw x))]
|
||||
(format-expr x)))
|
||||
arg))]
|
||||
(into [(join " " sqls)] params)))
|
||||
args))]
|
||||
(into [(str (sql-kw k) " " (join ", " sqls))] params))))
|
||||
|
||||
(defn- check-where
|
||||
"Given a formatter function, performs a pre-flight check that there is
|
||||
a non-empty where clause if at least basic checking is enabled."
|
||||
|
|
@ -1661,7 +1591,6 @@
|
|||
:drop-materialized-view #'format-drop-items
|
||||
:refresh-materialized-view (fn [_ x] (format-create :refresh :materialized-view x nil))
|
||||
:create-index #'format-create-index
|
||||
:setting #'format-setting
|
||||
:raw (fn [_ x] (raw-render x))
|
||||
:nest (fn [_ x]
|
||||
(let [[sql & params] (format-dsl x {:nested true})]
|
||||
|
|
@ -1674,27 +1603,20 @@
|
|||
:except #'format-on-set-op
|
||||
:except-all #'format-on-set-op
|
||||
:table #'format-selector
|
||||
:assert (fn [k xs]
|
||||
(let [[sql & params] (format-expr xs)]
|
||||
(into [(str (sql-kw k) " " sql)] params)))
|
||||
:select #'format-selects
|
||||
:select-distinct #'format-selects
|
||||
:select-distinct-on #'format-selects-on
|
||||
:select-top #'format-select-top
|
||||
:select-distinct-top #'format-select-top
|
||||
:exclude #'format-selects
|
||||
:rename #'format-selects
|
||||
:distinct (fn [k xs] (format-selects k [[xs]]))
|
||||
:expr (fn [_ xs] (format-selects nil [[xs]]))
|
||||
:into #'format-select-into
|
||||
:bulk-collect-into #'format-select-into
|
||||
:insert-into #'format-insert
|
||||
:patch-into #'format-insert
|
||||
:replace-into #'format-insert
|
||||
:update (check-where #'format-selector)
|
||||
:delete (check-where #'format-selects)
|
||||
:delete-from (check-where #'format-selector)
|
||||
:erase-from (check-where #'format-selector)
|
||||
:truncate #'format-truncate
|
||||
:columns #'format-columns
|
||||
:set #'format-set-exprs
|
||||
|
|
@ -1711,7 +1633,7 @@
|
|||
:where #'format-on-expr
|
||||
:group-by #'format-group-by
|
||||
:having #'format-on-expr
|
||||
:window #'format-window
|
||||
:window #'format-selector
|
||||
:partition-by #'format-selects
|
||||
:order-by #'format-order-by
|
||||
:limit #'format-on-expr
|
||||
|
|
@ -1730,7 +1652,6 @@
|
|||
:for #'format-lock-strength
|
||||
:lock #'format-lock-strength
|
||||
:values #'format-values
|
||||
:records #'format-records
|
||||
:on-conflict #'format-on-conflict
|
||||
:on-constraint #'format-selector
|
||||
:do-nothing (fn [k _] (vector (sql-kw k)))
|
||||
|
|
@ -1750,6 +1671,16 @@
|
|||
(set @current-clause-order)
|
||||
(set (keys @clause-format))))
|
||||
|
||||
(defn- kw->sym
|
||||
"Given a keyword, produce a symbol, retaining the namespace
|
||||
qualifier, if any."
|
||||
[k]
|
||||
(if (keyword? k)
|
||||
(if-let [n (namespace k)]
|
||||
(symbol n (name k))
|
||||
(symbol (name k)))
|
||||
k))
|
||||
|
||||
(defn format-dsl
|
||||
"Given a hash map representing a SQL statement and a hash map
|
||||
of options, return a vector containing a string -- the formatted
|
||||
|
|
@ -1798,7 +1729,6 @@
|
|||
"like" "not-like" "regexp" "~" "&&"
|
||||
"ilike" "not-ilike" "similar-to" "not-similar-to"
|
||||
"is" "is-not" "not=" "!=" "regex"
|
||||
"is-distinct-from" "is-not-distinct-from"
|
||||
"with-ordinality"}
|
||||
(into (map str "+-*%|&^=<>"))
|
||||
(into (keys infix-aliases))
|
||||
|
|
@ -1844,18 +1774,23 @@
|
|||
(= 1 (count params-y))
|
||||
(coll? v1))
|
||||
(let [sql (str "(" (join ", " (repeat (count v1) "?")) ")")]
|
||||
(into* [(str sql-x " " (sql-kw in) " " sql)] params-x v1))
|
||||
(-> [(str sql-x " " (sql-kw in) " " sql)]
|
||||
(into params-x)
|
||||
(into v1)))
|
||||
(and *numbered*
|
||||
(= (str "$" (count @*numbered*)) sql-y)
|
||||
(= 1 (count params-y))
|
||||
(coll? v1))
|
||||
(let [vs (for [v v1] (->numbered v))
|
||||
sql (str "(" (join ", " (map first) vs) ")")]
|
||||
(into* [(str sql-x " " (sql-kw in) " " sql)]
|
||||
params-x [nil] (map second vs)))
|
||||
(-> [(str sql-x " " (sql-kw in) " " sql)]
|
||||
(into params-x)
|
||||
(conj nil)
|
||||
(into (map second vs))))
|
||||
:else
|
||||
(into* [(str sql-x " " (sql-kw in) " " sql-y)]
|
||||
params-x (if *numbered* values params-y)))))
|
||||
(-> [(str sql-x " " (sql-kw in) " " sql-y)]
|
||||
(into params-x)
|
||||
(into (if *numbered* values params-y))))))
|
||||
|
||||
(defn- function-0 [k xs]
|
||||
[(str (sql-kw k)
|
||||
|
|
@ -1899,7 +1834,7 @@
|
|||
(let [[sql-e & params-e] (format-expr e)
|
||||
[sql-c & params-c] (format-dsl c {:nested true})]
|
||||
[(conj sqls (str sql-e " " (sql-kw k) " " sql-c))
|
||||
(into* params params-e params-c)]))
|
||||
(-> params (into params-e) (into params-c))]))
|
||||
[[] []]
|
||||
(partition 2 pairs))]
|
||||
(into [(join ", " sqls)] params)))
|
||||
|
|
@ -1918,7 +1853,7 @@
|
|||
(= 'else condition))
|
||||
(conj sqls (sql-kw :else) sqlv)
|
||||
(conj sqls (sql-kw :when) sqlc (sql-kw :then) sqlv))
|
||||
(into* params paramsc paramsv)]))
|
||||
(-> params (into paramsc) (into paramsv))]))
|
||||
[[] []]
|
||||
(partition 2 (if case-expr? (rest clauses) clauses)))]
|
||||
(-> [(str (sql-kw :case) " "
|
||||
|
|
@ -1926,53 +1861,13 @@
|
|||
(str sqlx " "))
|
||||
(join " " sqls)
|
||||
" " (sql-kw :end))]
|
||||
(into* paramsx params))))
|
||||
(into paramsx)
|
||||
(into params))))
|
||||
|
||||
(defn- between-fn
|
||||
"For both :between and :not-between"
|
||||
[k [x a b]]
|
||||
(let [[sql-x & params-x] (format-expr x {:nested true})
|
||||
[sql-a & params-a] (format-expr a {:nested true})
|
||||
[sql-b & params-b] (format-expr b {:nested true})]
|
||||
(into* [(str sql-x " " (sql-kw k) " " sql-a " AND " sql-b)]
|
||||
params-x params-a params-b)))
|
||||
|
||||
(defn- object-record-literal
|
||||
[k [x]]
|
||||
[(str (sql-kw k) " " (inline-map x "(" ")"))])
|
||||
|
||||
(defn- get-in-navigation
|
||||
"[:get-in expr key-or-index1 key-or-index2 ...]"
|
||||
[wrap [expr & kix]]
|
||||
(let [[sql & params] (format-expr expr)
|
||||
[sqls params']
|
||||
(reduce-sql (map #(cond (number? %)
|
||||
[(str "[" % "]")]
|
||||
(string? %)
|
||||
[(str "[" (sqlize-value %) "]")]
|
||||
(ident? %)
|
||||
[(str "." (format-entity %))]
|
||||
:else
|
||||
(let [[sql' & params'] (format-expr %)]
|
||||
(cons (str "[" sql' "]") params')))
|
||||
kix))]
|
||||
(into* [(str (if wrap (str "(" sql ")") sql)
|
||||
(join "" sqls))]
|
||||
params
|
||||
params')))
|
||||
|
||||
(defn- ignore-respect-nulls [k [x]]
|
||||
(defn ignore-respect-nulls [k [x]]
|
||||
(let [[sql & params] (format-expr x)]
|
||||
(into [(str sql " " (sql-kw k))] params)))
|
||||
|
||||
(defn- dot-navigation [sep [expr col & subcols]]
|
||||
(let [[sql & params] (format-expr expr)]
|
||||
(into [(str sql sep (format-simple-expr col "dot navigation")
|
||||
(when (seq subcols)
|
||||
(str "." (join "." (map #(format-simple-expr % "dot navigation")
|
||||
subcols)))))]
|
||||
params)))
|
||||
|
||||
(def ^:private special-syntax
|
||||
(atom
|
||||
{;; these "functions" are mostly used in column
|
||||
|
|
@ -1993,9 +1888,12 @@
|
|||
:references #'function-1
|
||||
:unique #'function-1-opt
|
||||
;; dynamic dotted name creation:
|
||||
:. (fn [_ data] (dot-navigation "." data))
|
||||
;; snowflake variant #570:
|
||||
:.:. (fn [_ data] (dot-navigation ":" data))
|
||||
:. (fn [_ [expr col subcol]]
|
||||
(let [[sql & params] (format-expr expr)]
|
||||
(into [(str sql "." (format-entity col)
|
||||
(when subcol
|
||||
(str "." (format-entity subcol))))]
|
||||
params)))
|
||||
;; used in DDL to force rendering as a SQL entity instead
|
||||
;; of a SQL keyword:
|
||||
:entity (fn [_ [e]] [(format-entity e)])
|
||||
|
|
@ -2020,7 +1918,6 @@
|
|||
(let [[sqls params] (format-expr-list arr)
|
||||
type-str (when type (str "::" (sql-kw type) "[]"))]
|
||||
(into [(str "ARRAY[" (join ", " sqls) "]" type-str)] params))))
|
||||
:at (fn [_ data] (get-in-navigation false data))
|
||||
:at-time-zone
|
||||
(fn [_ [expr tz]]
|
||||
(let [[sql & params] (format-expr expr {:nested true})
|
||||
|
|
@ -2028,8 +1925,15 @@
|
|||
(binding [*inline* true]
|
||||
(format-expr (if (ident? tz) (name tz) tz)))]
|
||||
(into [(str sql " AT TIME ZONE " tz-sql)] params)))
|
||||
:between #'between-fn
|
||||
:not-between #'between-fn
|
||||
:between
|
||||
(fn [_ [x a b]]
|
||||
(let [[sql-x & params-x] (format-expr x {:nested true})
|
||||
[sql-a & params-a] (format-expr a {:nested true})
|
||||
[sql-b & params-b] (format-expr b {:nested true})]
|
||||
(-> [(str sql-x " BETWEEN " sql-a " AND " sql-b)]
|
||||
(into params-x)
|
||||
(into params-a)
|
||||
(into params-b))))
|
||||
:case #'case-clauses
|
||||
:case-expr #'case-clauses
|
||||
:cast
|
||||
|
|
@ -2038,7 +1942,9 @@
|
|||
[sql' & params'] (if (ident? type)
|
||||
[(sql-kw type)]
|
||||
(format-expr type))]
|
||||
(into* [(str "CAST(" sql " AS " sql' ")")] params params')))
|
||||
(-> [(str "CAST(" sql " AS " sql' ")")]
|
||||
(into params)
|
||||
(into params'))))
|
||||
:composite
|
||||
(fn [_ [& args]]
|
||||
(let [[sqls params] (format-expr-list args)]
|
||||
|
|
@ -2051,14 +1957,15 @@
|
|||
(fn [_ [pattern escape-chars]]
|
||||
(let [[sql-p & params-p] (format-expr pattern)
|
||||
[sql-e & params-e] (format-expr escape-chars)]
|
||||
(into* [(str sql-p " " (sql-kw :escape) " " sql-e)] params-p params-e)))
|
||||
(-> [(str sql-p " " (sql-kw :escape) " " sql-e)]
|
||||
(into params-p)
|
||||
(into params-e))))
|
||||
:filter expr-clause-pairs
|
||||
:get-in (fn [_ data] (get-in-navigation true data))
|
||||
:ignore-nulls ignore-respect-nulls
|
||||
:inline
|
||||
(fn [_ xs]
|
||||
(binding [*inline* true]
|
||||
[(join " " (mapcat #(format-expr % {:record true})) xs)]))
|
||||
[(join " " (mapcat format-expr) xs)]))
|
||||
:interval format-interval
|
||||
:join
|
||||
(fn [_ [e & js]]
|
||||
|
|
@ -2092,13 +1999,13 @@
|
|||
(fn [_ [x]]
|
||||
(let [[sql & params] (format-expr x {:nested true})]
|
||||
(into [(str "NOT " sql)] params)))
|
||||
:object #'object-record-literal
|
||||
:record #'object-record-literal
|
||||
:order-by
|
||||
(fn [k [e & qs]]
|
||||
(let [[sql-e & params-e] (format-expr e)
|
||||
[sql-q & params-q] (format-dsl {k qs})]
|
||||
(into* [(str sql-e " " sql-q)] params-e params-q)))
|
||||
(-> [(str sql-e " " sql-q)]
|
||||
(into params-e)
|
||||
(into params-q))))
|
||||
:over
|
||||
(fn [_ [& args]]
|
||||
(let [[sqls params]
|
||||
|
|
@ -2109,7 +2016,7 @@
|
|||
[(format-entity p)])]
|
||||
[(conj sqls (str sql-e " OVER " sql-p
|
||||
(when a (str " AS " (format-entity a)))))
|
||||
(into* params params-e params-p)]))
|
||||
(-> params (into params-e) (into params-p))]))
|
||||
[[] []]
|
||||
args)]
|
||||
(into [(join ", " sqls)] params)))
|
||||
|
|
@ -2150,7 +2057,8 @@
|
|||
(cond-> nested
|
||||
(as-> s (str "(" s ")")))
|
||||
(vector)
|
||||
(into* p1 p2))))
|
||||
(into p1)
|
||||
(into p2))))
|
||||
|
||||
(defn- format-infix-expr [op' op expr nested]
|
||||
(let [args (cond->> (rest expr)
|
||||
|
|
@ -2196,11 +2104,11 @@
|
|||
This is intended to be used when writing your own formatters to
|
||||
extend the DSL supported by HoneySQL."
|
||||
([expr] (format-expr expr {}))
|
||||
([expr {:keys [nested record] :as opts}]
|
||||
([expr {:keys [nested] :as opts}]
|
||||
(cond (ident? expr)
|
||||
(format-var expr opts)
|
||||
|
||||
(and (map? expr) (not record))
|
||||
(map? expr)
|
||||
(format-dsl expr (assoc opts :nested true))
|
||||
|
||||
(sequential? expr)
|
||||
|
|
@ -2223,9 +2131,7 @@
|
|||
(into [(str "(" (join ", " sqls) ")")] params))))
|
||||
|
||||
(boolean? expr)
|
||||
(if (:auto-lift-boolean *dialect*)
|
||||
["?" expr]
|
||||
[(upper-case (str expr))])
|
||||
[(upper-case (str expr))]
|
||||
|
||||
(nil? expr)
|
||||
["NULL"]
|
||||
|
|
@ -2416,8 +2322,7 @@
|
|||
[clause formatter before]
|
||||
(let [clause (sym->kw clause)
|
||||
before (sym->kw before)]
|
||||
(when-not (keyword? clause)
|
||||
(throw (ex-info "The clause must be a keyword or symbol" {:clause clause})))
|
||||
(assert (keyword? clause))
|
||||
(let [k (sym->kw formatter)
|
||||
f (if (keyword? k)
|
||||
(get @clause-format k)
|
||||
|
|
@ -2484,8 +2389,7 @@
|
|||
DSL."
|
||||
[function formatter]
|
||||
(let [function (sym->kw function)]
|
||||
(when-not (keyword? function)
|
||||
(throw (ex-info "The function must be a keyword or symbol" {:function function})))
|
||||
(assert (keyword? function))
|
||||
(let [k (sym->kw formatter)
|
||||
f (if (keyword? k)
|
||||
(get @special-syntax k)
|
||||
|
|
@ -2506,8 +2410,7 @@
|
|||
construct the DSL)."
|
||||
[op & {:keys [ignore-nil]}]
|
||||
(let [op (sym->kw op)]
|
||||
(when-not (keyword? op)
|
||||
(throw (ex-info "The operator must be a keyword or symbol" {:operator op})))
|
||||
(assert (keyword? op))
|
||||
(swap! infix-ops conj op)
|
||||
(when ignore-nil
|
||||
(swap! op-ignore-nil conj op))))
|
||||
|
|
@ -2535,22 +2438,6 @@
|
|||
(first clauses)
|
||||
(into [:and] clauses))))
|
||||
|
||||
(defn semicolon
|
||||
"Given either a vector of formatted SQL+params vectors, or two or more
|
||||
SQL+params vectors as arguments, merge them into a single SQL+params
|
||||
vector with the SQL strings separated by semicolons."
|
||||
([sql+params-vector]
|
||||
(reduce into
|
||||
[(str/join "; " (map first sql+params-vector))]
|
||||
(map rest sql+params-vector)))
|
||||
([sql+params & more]
|
||||
(semicolon (cons sql+params more))))
|
||||
|
||||
(comment
|
||||
(semicolon [ ["foo" 1 2 3] ["bar" 4 5 6] ])
|
||||
(semicolon ["foo" 1 2 3] ["bar" 4 5 6] ["baz" 7 8 9] )
|
||||
)
|
||||
|
||||
;; aids to migration from HoneySQL 1.x -- these are deliberately undocumented
|
||||
;; so as not to encourage their use for folks starting fresh with 2.x!
|
||||
|
||||
|
|
@ -2558,10 +2445,6 @@
|
|||
|
||||
(comment
|
||||
(format {:truncate :foo})
|
||||
(format [:and])
|
||||
(format [:and] {:dialect :sqlserver})
|
||||
(format {:select :* :from :table :where (map= {})})
|
||||
(format {:select :* :from :table :where (map= {})} {:dialect :sqlserver})
|
||||
(format-expr [:= :id 1])
|
||||
(format-expr [:+ :id 1])
|
||||
(format-expr [:+ 1 [:+ 1 :quux]])
|
||||
|
|
@ -2727,7 +2610,4 @@
|
|||
:select [:*]
|
||||
:from [(keyword "'`a-b.b-c.c-d`")]}
|
||||
(sql/format))
|
||||
(sql/format {:select :* :from [[[:json_to_recordset :my-json-column] [:b {:with-columns [[:c :int] [:d :text]]}]]]})
|
||||
(sql/format {:select :* :from :my_publications :where [:= :is_published true]}
|
||||
{:dialect :sqlserver})
|
||||
)
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
;; copyright (c) 2020-2025 sean corfield, all rights reserved
|
||||
;; copyright (c) 2020-2024 sean corfield, all rights reserved
|
||||
|
||||
(ns honey.sql.helpers
|
||||
"Helper functions for the built-in clauses in honey.sql.
|
||||
|
|
@ -58,12 +58,10 @@
|
|||
bulk-collect-info [& args]
|
||||
|
||||
(as they are for all helper functions)."
|
||||
(:refer-clojure :exclude [assert distinct filter for group-by into partition-by set update])
|
||||
(:refer-clojure :exclude [distinct filter for group-by into partition-by set update])
|
||||
(:require [clojure.core :as c]
|
||||
[honey.sql :as h]))
|
||||
|
||||
#?(:clj (set! *warn-on-reflection* true))
|
||||
|
||||
;; implementation helpers:
|
||||
|
||||
(defn- default-merge [current args]
|
||||
|
|
@ -401,11 +399,6 @@
|
|||
[& args]
|
||||
(generic :create-index args))
|
||||
|
||||
(defn setting
|
||||
"Accepts one or more time settings for a query."
|
||||
[& args]
|
||||
(generic :setting args))
|
||||
|
||||
(defn with
|
||||
"Accepts one or more CTE definitions.
|
||||
|
||||
|
|
@ -452,14 +445,6 @@
|
|||
[& clauses]
|
||||
(generic :except-all (cons {} clauses)))
|
||||
|
||||
(defn assert
|
||||
"Accepts an expression (predicate).
|
||||
|
||||
Produces: ASSERT expression"
|
||||
{:arglists '([expr])}
|
||||
[& args]
|
||||
(generic-1 :assert args))
|
||||
|
||||
(defn select
|
||||
"Accepts any number of column names, or column/alias
|
||||
pairs, or SQL expressions (optionally aliased):
|
||||
|
|
@ -513,12 +498,6 @@
|
|||
[& args]
|
||||
(generic :select-distinct-top args))
|
||||
|
||||
(defn records
|
||||
"Produces RECORDS {...}, {...}, ...
|
||||
Like `values` so it accepts a collection of maps."
|
||||
[& args]
|
||||
(generic-1 :records args))
|
||||
|
||||
(defn distinct
|
||||
"Like `select-distinct` but produces DISTINCT..."
|
||||
[& args]
|
||||
|
|
@ -529,16 +508,6 @@
|
|||
[& args]
|
||||
(generic-1 :expr args))
|
||||
|
||||
(defn exclude
|
||||
"Accepts one or more column names to exclude from a select list."
|
||||
[& args]
|
||||
(generic :exclude args))
|
||||
|
||||
(defn rename
|
||||
"Accepts one or more column names with aliases to rename in a select list."
|
||||
[& args]
|
||||
(generic :rename args))
|
||||
|
||||
(defn into
|
||||
"Accepts table name, optionally followed a database name."
|
||||
{:arglists '([table] [table dbname])}
|
||||
|
|
@ -552,14 +521,6 @@
|
|||
[& args]
|
||||
(generic :bulk-collect-into args))
|
||||
|
||||
(defn- stuff-into [k args]
|
||||
(let [[data & args :as args']
|
||||
(if (map? (first args)) args (cons {} args))
|
||||
[table cols statement] args]
|
||||
(if (and (sequential? cols) (map? statement))
|
||||
(generic k [data [table cols] statement])
|
||||
(generic k args'))))
|
||||
|
||||
(defn insert-into
|
||||
"Accepts a table name or a table/alias pair. That
|
||||
can optionally be followed by a collection of
|
||||
|
|
@ -575,20 +536,12 @@
|
|||
(-> (select :*) (from :other)))"
|
||||
{:arglists '([table] [table cols] [table statement] [table cols statement])}
|
||||
[& args]
|
||||
(stuff-into :insert-into args))
|
||||
|
||||
(defn patch-into
|
||||
"Accepts a table name or a table/alias pair. That
|
||||
can optionally be followed by a collection of
|
||||
column names. That can optionally be followed by
|
||||
a (select) statement clause.
|
||||
|
||||
The arguments are identical to insert-into.
|
||||
The PATCH INTO statement is only supported by
|
||||
XTDB."
|
||||
{:arglists '([table] [table cols] [table statement] [table cols statement])}
|
||||
[& args]
|
||||
(stuff-into :patch-into args))
|
||||
(let [[data & args :as args']
|
||||
(if (map? (first args)) args (cons {} args))
|
||||
[table cols statement] args]
|
||||
(if (and (sequential? cols) (map? statement))
|
||||
(generic :insert-into [data [table cols] statement])
|
||||
(generic :insert-into args'))))
|
||||
|
||||
(defn replace-into
|
||||
"Accepts a table name or a table/alias pair. That
|
||||
|
|
@ -601,7 +554,7 @@
|
|||
MySQL and SQLite."
|
||||
{:arglists '([table] [table cols] [table statement] [table cols statement])}
|
||||
[& args]
|
||||
(stuff-into :replace-into args))
|
||||
(apply insert-into args))
|
||||
|
||||
(defn update
|
||||
"Accepts either a table name or a table/alias pair.
|
||||
|
|
@ -629,15 +582,6 @@
|
|||
[& args]
|
||||
(generic :delete-from args))
|
||||
|
||||
(defn erase-from
|
||||
"For erasing (hard delete) from a single table (XTDB).
|
||||
Accepts a single table name to erase from.
|
||||
|
||||
(-> (erase-from :films) (where [:= :id 1]))"
|
||||
{:arglists '([table])}
|
||||
[& args]
|
||||
(generic :erase-from args))
|
||||
|
||||
(defn truncate
|
||||
"Accepts a single table name to truncate."
|
||||
{:arglists '([table])}
|
||||
|
|
@ -1232,6 +1176,20 @@
|
|||
[k args]
|
||||
(generic-1 k args))
|
||||
|
||||
#?(:clj
|
||||
(do
|
||||
;; #409 this assert is only valid when :doc metadata is not elided:
|
||||
(when (-> #'generic-helper-unary meta :doc)
|
||||
;; ensure #295 stays true (all public functions have docstring):
|
||||
(assert (empty? (->> (ns-publics *ns*) (vals) (c/filter (comp not :doc meta))))))
|
||||
;; ensure all public functions match clauses:
|
||||
(assert (= (c/set (conj @#'honey.sql/default-clause-order
|
||||
:composite :filter :lateral :over :within-group
|
||||
:upsert
|
||||
:generic-helper-variadic :generic-helper-unary))
|
||||
(c/set (conj (map keyword (keys (ns-publics *ns*)))
|
||||
:nest :raw))))))
|
||||
|
||||
(comment
|
||||
(-> (delete-from :table)
|
||||
(where [:in (composite :first :second)
|
||||
|
|
|
|||
|
|
@ -25,8 +25,6 @@
|
|||
(:refer-clojure :exclude [-> ->> -])
|
||||
(:require [honey.sql :as sql]))
|
||||
|
||||
#?(:clj (set! *warn-on-reflection* true))
|
||||
|
||||
;; see https://www.postgresql.org/docs/current/functions-json.html
|
||||
|
||||
(def ->
|
||||
|
|
|
|||
|
|
@ -4,7 +4,5 @@
|
|||
"InlineValue -- a protocol that defines how to inline
|
||||
values; (sqlize x) produces a SQL string for x.")
|
||||
|
||||
#?(:clj (set! *warn-on-reflection* true))
|
||||
|
||||
(defprotocol InlineValue :extend-via-metadata true
|
||||
(sqlize [this] "Render value inline in a SQL string."))
|
||||
|
|
|
|||
|
|
@ -3,8 +3,6 @@
|
|||
(:refer-clojure :exclude [str])
|
||||
(:require clojure.string))
|
||||
|
||||
#?(:clj (set! *warn-on-reflection* true))
|
||||
|
||||
(defn str
|
||||
"More efficient implementation of `clojure.core/str` because it has more
|
||||
non-variadic arities. Optimization is Clojure-only, on other platforms it
|
||||
|
|
@ -77,33 +75,3 @@
|
|||
|
||||
:default
|
||||
(clojure.string/join separator (transduce xform conj [] coll)))))
|
||||
|
||||
(defn split-by-separator
|
||||
"More efficient implementation of `clojure.string/split` for cases when a
|
||||
literal string (not regex) is used as a separator, and for cases where the
|
||||
separator is not present in the haystack at all."
|
||||
[s sep]
|
||||
(loop [start 0, res []]
|
||||
(if-some [sep-idx (clojure.string/index-of s sep start)]
|
||||
(let [sep-idx (long sep-idx)]
|
||||
(recur (inc sep-idx) (conj res (subs s start sep-idx))))
|
||||
(if (= start 0)
|
||||
;; Fastpath - zero separators in s
|
||||
[s]
|
||||
(conj res (subs s start))))))
|
||||
|
||||
(defn into*
|
||||
"An extension of `clojure.core/into` that accepts multiple \"from\" arguments.
|
||||
Doesn't support `xform`."
|
||||
([to from1] (into* to from1 nil nil nil))
|
||||
([to from1 from2] (into* to from1 from2 nil nil))
|
||||
([to from1 from2 from3] (into* to from1 from2 from3 nil))
|
||||
([to from1 from2 from3 from4]
|
||||
(if (or from1 from2 from3 from4)
|
||||
(as-> (transient to) to'
|
||||
(reduce conj! to' from1)
|
||||
(reduce conj! to' from2)
|
||||
(reduce conj! to' from3)
|
||||
(reduce conj! to' from4)
|
||||
(persistent! to'))
|
||||
to)))
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
;; copyright (c) 2023-2025 sean corfield, all rights reserved
|
||||
;; copyright (c) 2023-2024 sean corfield, all rights reserved
|
||||
|
||||
(ns honey.ops-test
|
||||
(:refer-clojure :exclude [format])
|
||||
|
|
@ -9,11 +9,3 @@
|
|||
(is (= ["SELECT a - b - c AS x"]
|
||||
(-> {:select [[[:- :a :b :c] :x]]}
|
||||
(sut/format)))))
|
||||
|
||||
(deftest issue-566
|
||||
(is (= ["SELECT * FROM table WHERE a IS DISTINCT FROM b"]
|
||||
(-> {:select :* :from :table :where [:is-distinct-from :a :b]}
|
||||
(sut/format))))
|
||||
(is (= ["SELECT * FROM table WHERE a IS NOT DISTINCT FROM b"]
|
||||
(-> {:select :* :from :table :where [:is-not-distinct-from :a :b]}
|
||||
(sut/format)))))
|
||||
|
|
|
|||
|
|
@ -2,43 +2,24 @@
|
|||
|
||||
(ns honey.sql.helpers-test
|
||||
(:refer-clojure :exclude [filter for group-by partition-by set update])
|
||||
#_{:clj-kondo/ignore [:unused-namespace]}
|
||||
(:require [clojure.core :as c]
|
||||
[clojure.test :refer [deftest is testing]]
|
||||
(:require [clojure.test :refer [deftest is testing]]
|
||||
[honey.sql :as sql]
|
||||
[honey.sql.helpers :as h
|
||||
:refer [add-column alter-table columns create-table create-table-as create-view
|
||||
create-materialized-view
|
||||
:refer [add-column add-index alter-table columns create-table create-table-as create-view
|
||||
create-materialized-view drop-view drop-materialized-view
|
||||
create-index
|
||||
bulk-collect-into
|
||||
cross-join do-update-set drop-column drop-table
|
||||
cross-join do-update-set drop-column drop-index drop-table
|
||||
filter from full-join
|
||||
group-by having insert-into replace-into
|
||||
join-by join left-join limit offset on-conflict
|
||||
group-by having insert-into
|
||||
join-by join lateral left-join limit offset on-conflict
|
||||
on-duplicate-key-update
|
||||
order-by over partition-by refresh-materialized-view
|
||||
returning right-join
|
||||
select select-distinct select-top
|
||||
rename-column rename-table returning right-join
|
||||
select select-distinct select-top select-distinct-top
|
||||
values where window with with-columns
|
||||
with-data within-group]]))
|
||||
|
||||
#?(:clj
|
||||
(deftest helpers-are-complete
|
||||
(let [helpers-ns (find-ns 'honey.sql.helpers)]
|
||||
(testing "all public helpers have docstrings"
|
||||
;; #409 this assert is only valid when :doc metadata is not elided:
|
||||
(when (-> #'h/generic-helper-unary meta :doc)
|
||||
;; ensure #295 stays true (all public functions have docstring):
|
||||
(is (= [] (->> (ns-publics helpers-ns) (vals) (c/filter (comp not :doc meta)))))))
|
||||
(testing "all clauses have public helpers"
|
||||
;; ensure all public functions match clauses:
|
||||
(is (= (c/set (conj @#'honey.sql/default-clause-order
|
||||
:composite :filter :lateral :over :within-group
|
||||
:upsert
|
||||
:generic-helper-variadic :generic-helper-unary))
|
||||
(c/set (conj (map keyword (keys (ns-publics helpers-ns)))
|
||||
:nest :raw))))))))
|
||||
|
||||
(deftest test-select
|
||||
(testing "large helper expression"
|
||||
(let [m1 (-> (with [:cte (-> (select :*)
|
||||
|
|
@ -552,33 +533,6 @@
|
|||
" MAX(salary) OVER w AS MaxSalary"
|
||||
" FROM employee"
|
||||
" WINDOW w AS (PARTITION BY department)")]))
|
||||
;; multiple window tests
|
||||
(is (= (-> (select :id
|
||||
(over [[:avg :salary] (-> (partition-by :department) (order-by :designation)) :Average]
|
||||
[[:max :salary] :w :MaxSalary]))
|
||||
(from :employee)
|
||||
(window :w (partition-by :department))
|
||||
(window :x (partition-by :salary))
|
||||
sql/format)
|
||||
[(str "SELECT id,"
|
||||
" AVG(salary) OVER (PARTITION BY department ORDER BY designation ASC) AS Average,"
|
||||
" MAX(salary) OVER w AS MaxSalary"
|
||||
" FROM employee"
|
||||
" WINDOW w AS (PARTITION BY department)"
|
||||
", x AS (PARTITION BY salary)")]))
|
||||
(is (= (-> (select :id
|
||||
(over [[:avg :salary] (-> (partition-by :department) (order-by :designation)) :Average]
|
||||
[[:max :salary] :w :MaxSalary]))
|
||||
(from :employee)
|
||||
(window :w (partition-by :department)
|
||||
:x (partition-by :salary))
|
||||
sql/format)
|
||||
[(str "SELECT id,"
|
||||
" AVG(salary) OVER (PARTITION BY department ORDER BY designation ASC) AS Average,"
|
||||
" MAX(salary) OVER w AS MaxSalary"
|
||||
" FROM employee"
|
||||
" WINDOW w AS (PARTITION BY department)"
|
||||
", x AS (PARTITION BY salary)")]))
|
||||
;; test nil / empty window function clause:
|
||||
(is (= (-> (select :id
|
||||
(over [[:avg :salary] {} :Average]
|
||||
|
|
@ -836,10 +790,7 @@
|
|||
["INSERT INTO transport (id, name) SELECT * FROM cars"]))
|
||||
;; three arguments with an alias and columns:
|
||||
(is (= (sql/format (insert-into '(transport t) '(id, name) '{select (*) from (cars)}))
|
||||
["INSERT INTO transport AS t (id, name) SELECT * FROM cars"]))
|
||||
;; and again with replace-into:
|
||||
(is (= (sql/format (replace-into '(transport t) '(id, name) '{select (*) from (cars)}))
|
||||
["REPLACE INTO transport AS t (id, name) SELECT * FROM cars"])))
|
||||
["INSERT INTO transport AS t (id, name) SELECT * FROM cars"])))
|
||||
|
||||
;; these tests are adapted from Cam Saul's PR #283
|
||||
|
||||
|
|
@ -1038,15 +989,11 @@
|
|||
(sql/format (create-index [:unique :my-column-idx :if-not-exists] [:my-table :my-column]))))
|
||||
(is (= ["CREATE INDEX my_column_idx ON my_table (LOWER(my_column))"]
|
||||
(sql/format (create-index :my-column-idx [:my-table :%lower.my-column])))))
|
||||
(testing "PostgreSQL extensions (USING GIN/HASH)"
|
||||
(testing "PostgreSQL extensions (USING GIN)"
|
||||
(is (= ["CREATE INDEX my_column_idx ON my_table USING GIN (my_column)"]
|
||||
(sql/format {:create-index [:my-column-idx [:my-table :using-gin :my-column]]})))
|
||||
(is (= ["CREATE INDEX my_column_idx ON my_table USING GIN (my_column)"]
|
||||
(sql/format (create-index :my-column-idx [:my-table :using-gin :my-column]))))
|
||||
(is (= ["CREATE INDEX my_column_idx ON my_table USING HASH (my_column)"]
|
||||
(sql/format {:create-index [:my-column-idx [:my-table :using-hash :my-column]]})))
|
||||
(is (= ["CREATE INDEX my_column_idx ON my_table USING HASH (my_column)"]
|
||||
(sql/format (create-index :my-column-idx [:my-table :using-hash :my-column]))))))
|
||||
(sql/format (create-index :my-column-idx [:my-table :using-gin :my-column]))))))
|
||||
|
||||
(deftest join-with-alias
|
||||
(is (= ["SELECT * FROM foo LEFT JOIN (populatons AS pm INNER JOIN customers AS pc ON (pm.id = pc.id) AND (pm.other_id = pc.other_id)) ON foo.fk_id = pm.id"]
|
||||
|
|
|
|||
|
|
@ -1,148 +0,0 @@
|
|||
;; copyright (c) 2020-2025 sean corfield, all rights reserved
|
||||
|
||||
(ns honey.sql.xtdb-test
|
||||
(:require [clojure.test :refer [deftest is testing]]
|
||||
[honey.sql :as sql]
|
||||
[honey.sql.helpers :as h
|
||||
:refer [select exclude rename from]]))
|
||||
|
||||
(deftest select-tests
|
||||
(testing "select, exclude, rename"
|
||||
(is (= ["SELECT * EXCLUDE _id RENAME value AS foo_value FROM foo"]
|
||||
(sql/format (-> (select :*) (exclude :_id) (rename [:value :foo_value])
|
||||
(from :foo)))))
|
||||
(is (= ["SELECT * EXCLUDE (_id, a) RENAME value AS foo_value FROM foo"]
|
||||
(sql/format (-> (select :*) (exclude :_id :a) (rename [:value :foo_value])
|
||||
(from :foo)))))
|
||||
(is (= ["SELECT * EXCLUDE _id RENAME (value AS foo_value, a AS b) FROM foo"]
|
||||
(sql/format (-> (select :*) (exclude :_id)
|
||||
(rename [:value :foo_value]
|
||||
[:a :b])
|
||||
(from :foo)))))
|
||||
(is (= ["SELECT * EXCLUDE _id RENAME value AS foo_value, c.x FROM foo"]
|
||||
(sql/format (-> (select [:* (-> (exclude :_id) (rename [:value :foo_value]))]
|
||||
:c.x)
|
||||
(from :foo)))))
|
||||
(is (= ["SELECT * EXCLUDE (_id, a) RENAME value AS foo_value, c.x FROM foo"]
|
||||
(sql/format (-> (select [:* (-> (exclude :_id :a) (rename [:value :foo_value]))]
|
||||
:c.x)
|
||||
(from :foo)))))
|
||||
(is (= ["SELECT * EXCLUDE _id RENAME (value AS foo_value, a AS b), c.x FROM foo"]
|
||||
(sql/format (-> (select [:* (-> (exclude :_id)
|
||||
(rename [:value :foo_value]
|
||||
[:a :b]))]
|
||||
:c.x)
|
||||
(from :foo))))))
|
||||
(testing "select, nest_one, nest_many"
|
||||
(is (= ["SELECT a._id, NEST_ONE (SELECT * FROM foo AS b WHERE b_id = a._id) FROM bar AS a"]
|
||||
(sql/format '{select (a._id,
|
||||
((nest_one {select * from ((foo b)) where (= b_id a._id)})))
|
||||
from ((bar a))})))
|
||||
(is (= ["SELECT a._id, NEST_MANY (SELECT * FROM foo AS b) FROM bar AS a"]
|
||||
(sql/format '{select (a._id,
|
||||
((nest_many {select * from ((foo b))})))
|
||||
from ((bar a))})))))
|
||||
|
||||
(deftest dotted-array-access-tests
|
||||
(is (= ["SELECT (a.b).c"] ; old, partial support:
|
||||
(sql/format '{select (((. (nest :a.b) :c)))})))
|
||||
(is (= ["SELECT (a.b).c"] ; new, complete support:
|
||||
(sql/format '{select (((:get-in :a.b :c)))})))
|
||||
(is (= ["SELECT (a).b.c"] ; the first expression is always parenthesized:
|
||||
(sql/format '{select (((:get-in :a :b :c)))}))))
|
||||
|
||||
(deftest erase-from-test
|
||||
(is (= ["ERASE FROM foo WHERE foo.id = ?" 42]
|
||||
(-> {:erase-from :foo
|
||||
:where [:= :foo.id 42]}
|
||||
(sql/format))))
|
||||
(is (= ["ERASE FROM foo WHERE foo.id = ?" 42]
|
||||
(-> (h/erase-from :foo)
|
||||
(h/where [:= :foo.id 42])
|
||||
(sql/format)))))
|
||||
|
||||
(deftest inline-record-body
|
||||
(is (= ["{_id: 1, name: 'foo', info: {contact: [{loc: 'home', tel: '123'}, {loc: 'work', tel: '456'}]}}"]
|
||||
(sql/format [:inline {:_id 1 :name "foo"
|
||||
:info {:contact [{:loc "home" :tel "123"}
|
||||
{:loc "work" :tel "456"}]}}]))))
|
||||
|
||||
(deftest records-statement
|
||||
(testing "auto-lift maps"
|
||||
(is (= ["RECORDS ?, ?" {:_id 1 :name "cat"} {:_id 2 :name "dog"}]
|
||||
(sql/format {:records [{:_id 1 :name "cat"}
|
||||
{:_id 2 :name "dog"}]}))))
|
||||
(testing "explicit inline"
|
||||
(is (= ["RECORDS {_id: 1, name: 'cat'}, {_id: 2, name: 'dog'}"]
|
||||
(sql/format {:records [[:inline {:_id 1 :name "cat"}]
|
||||
[:inline {:_id 2 :name "dog"}]]}))))
|
||||
(testing "insert with records"
|
||||
(is (= ["INSERT INTO foo RECORDS {_id: 1, name: 'cat'}, {_id: 2, name: 'dog'}"]
|
||||
(sql/format {:insert-into :foo
|
||||
:records [[:inline {:_id 1 :name "cat"}]
|
||||
[:inline {:_id 2 :name "dog"}]]})))
|
||||
(is (= ["INSERT INTO foo RECORDS {_id: 1, name: 'cat'}, {_id: 2, name: 'dog'}"]
|
||||
(sql/format {:insert-into :foo
|
||||
:records [[:inline {:_id 1 :name "cat"}]
|
||||
[:inline {:_id 2 :name "dog"}]]})))
|
||||
(is (= ["INSERT INTO foo RECORDS ?, ?" {:_id 1 :name "cat"} {:_id 2 :name "dog"}]
|
||||
(sql/format {:insert-into [:foo ; as a sub-clause
|
||||
{:records [{:_id 1 :name "cat"}
|
||||
{:_id 2 :name "dog"}]}]})))))
|
||||
|
||||
(deftest patch-statement
|
||||
(testing "patch with records"
|
||||
(is (= ["PATCH INTO foo RECORDS {_id: 1, name: 'cat'}, {_id: 2, name: 'dog'}"]
|
||||
(sql/format {:patch-into [:foo]
|
||||
:records [[:inline {:_id 1 :name "cat"}]
|
||||
[:inline {:_id 2 :name "dog"}]]})))
|
||||
(is (= ["PATCH INTO foo RECORDS ?, ?" {:_id 1 :name "cat"} {:_id 2 :name "dog"}]
|
||||
(sql/format {:patch-into [:foo ; as a sub-clause
|
||||
{:records [{:_id 1 :name "cat"}
|
||||
{:_id 2 :name "dog"}]}]})))
|
||||
(is (= ["PATCH INTO foo RECORDS ?, ?" {:_id 1 :name "cat"} {:_id 2 :name "dog"}]
|
||||
(sql/format (h/patch-into :foo
|
||||
(h/records [{:_id 1 :name "cat"}
|
||||
{:_id 2 :name "dog"}])))))))
|
||||
|
||||
(deftest object-record-expr
|
||||
(testing "object literal"
|
||||
(is (= ["SELECT OBJECT (_id: 1, name: 'foo')"]
|
||||
(sql/format {:select [[[:object {:_id 1 :name "foo"}]]]})))
|
||||
(is (= ["SELECT OBJECT (_id: 1, name: 'foo')"]
|
||||
(sql/format '{select (((:object {:_id 1 :name "foo"})))}))))
|
||||
(testing "record literal"
|
||||
(is (= ["SELECT RECORD (_id: 1, name: 'foo')"]
|
||||
(sql/format {:select [[[:record {:_id 1 :name "foo"}]]]})))
|
||||
(is (= ["SELECT RECORD (_id: 1, name: 'foo')"]
|
||||
(sql/format '{select (((:record {:_id 1 :name "foo"})))}))))
|
||||
(testing "inline map literal"
|
||||
(is (= ["SELECT {_id: 1, name: 'foo'}"]
|
||||
(sql/format {:select [[[:inline {:_id 1 :name "foo"}]]]})))))
|
||||
|
||||
(deftest navigation-dot-index
|
||||
(is (= ["SELECT (a.b).c[1].d"]
|
||||
(sql/format '{select (((get-in a.b c 1 d)))})))
|
||||
(is (= ["SELECT (a.b).c[?].d" 1]
|
||||
(sql/format '{select (((get-in a.b c (lift 1) d)))})))
|
||||
(is (= ["SELECT (a.b).c[?].d" 1]
|
||||
(sql/format '{select (((get-in (. a b) c (lift 1) d)))})))
|
||||
(is (= ["SELECT (OBJECT (_id: 1, b: 'thing').b).c[?].d" 1]
|
||||
(sql/format '{select (((get-in (. (object {_id 1 b "thing"}) b) c (lift 1) d)))}))))
|
||||
|
||||
(deftest assert-statement
|
||||
(testing "quoted sql"
|
||||
(is (= ["ASSERT NOT EXISTS (SELECT 1 FROM users WHERE email = 'james @example.com')"]
|
||||
(sql/format '{assert (not-exists {select 1 from users where (= email "james @example.com")})}
|
||||
:inline true)))
|
||||
(is (= ["ASSERT TRUE"]
|
||||
(sql/format '{assert true}
|
||||
:inline true))))
|
||||
(testing "helper"
|
||||
(is (= ["ASSERT NOT EXISTS (SELECT 1 FROM users WHERE email = 'james @example.com')"]
|
||||
(-> (h/assert [:not-exists {:select 1 :from :users :where [:= :email "james @example.com"]}])
|
||||
(sql/format {:inline true}))))
|
||||
(is (= ["ASSERT NOT EXISTS (SELECT 1 FROM users WHERE email = 'james @example.com')"]
|
||||
(-> {}
|
||||
(h/assert [:not-exists {:select 1 :from :users :where [:= :email "james @example.com"]}])
|
||||
(sql/format {:inline true}))))))
|
||||
|
|
@ -1,4 +1,4 @@
|
|||
;; copyright (c) 2021-2025 sean corfield, all rights reserved
|
||||
;; copyright (c) 2021-2024 sean corfield, all rights reserved
|
||||
|
||||
(ns honey.sql-test
|
||||
(:refer-clojure :exclude [format])
|
||||
|
|
@ -22,8 +22,6 @@
|
|||
(sut/format-expr [:is :id nil])))
|
||||
(is (= ["id = TRUE"]
|
||||
(sut/format-expr [:= :id true])))
|
||||
(is (= ["[id] = ?" true]
|
||||
(sut/format [:= :id true] {:dialect :sqlserver})))
|
||||
(is (= ["id IS TRUE"]
|
||||
(sut/format-expr [:is :id true])))
|
||||
(is (= ["id <> TRUE"]
|
||||
|
|
@ -221,26 +219,7 @@
|
|||
:from [:hits :stuff]
|
||||
:where [:= :EventDate :ts_upper_bound]})
|
||||
["WITH ? AS ts_upper_bound, stuff AS (SELECT * FROM songs) SELECT * FROM hits, stuff WHERE EventDate = ts_upper_bound"
|
||||
"2019-08-01 15:23:00"])))
|
||||
(testing "Use expression in a WITH clause"
|
||||
(is (= (format
|
||||
{:with [[:s [:sum :bytes]]]
|
||||
:select [:s]
|
||||
:from [:table]})
|
||||
["WITH SUM(bytes) AS s SELECT s FROM table"]))
|
||||
|
||||
(is (= (format
|
||||
{:with [[:v [:raw "m['k']"]]]
|
||||
:select [:v]
|
||||
:from [:table]})
|
||||
["WITH m['k'] AS v SELECT v FROM table"]))
|
||||
|
||||
(is (= (format
|
||||
{:with [[:cond [:and [:= :a 1] [:= :b 2] [:= :c 3]]]]
|
||||
:select [:v]
|
||||
:from [:table]
|
||||
:where :cond})
|
||||
["WITH (a = ?) AND (b = ?) AND (c = ?) AS cond SELECT v FROM table WHERE cond" 1 2 3]))))
|
||||
"2019-08-01 15:23:00"]))))
|
||||
|
||||
(deftest insert-into
|
||||
(is (= (format {:insert-into :foo})
|
||||
|
|
@ -575,15 +554,13 @@
|
|||
(-> {:delete-from :foo
|
||||
:where [:= :foo.id 42]}
|
||||
(format :dialect :mysql :pretty true)))))
|
||||
(let [version #?(:cljs *clojurescript-version*
|
||||
:default (clojure-version))]
|
||||
(when (or (str/starts-with? version "1.12")
|
||||
(str/starts-with? version "1.11"))
|
||||
(when (str/starts-with? #?(:cljs *clojurescript-version*
|
||||
:default (clojure-version)) "1.11")
|
||||
(testing "format can be called with mixed arguments"
|
||||
(is (= ["\nDELETE FROM `foo`\nWHERE `foo`.`id` = ?\n" 42]
|
||||
(-> {:delete-from :foo
|
||||
:where [:= :foo.id 42]}
|
||||
(format :dialect :mysql {:pretty true}))))))))
|
||||
(format :dialect :mysql {:pretty true})))))))
|
||||
|
||||
(deftest delete-from-test
|
||||
(is (= ["DELETE FROM `foo` WHERE `foo`.`id` = ?" 42]
|
||||
|
|
@ -614,12 +591,6 @@
|
|||
(format {:dialect :mysql}))))
|
||||
(is (= ["TRUNCATE TABLE `foo` CONTINUE IDENTITY"]
|
||||
(-> {:truncate [:foo :continue :identity]}
|
||||
(format {:dialect :mysql}))))
|
||||
(is (= ["TRUNCATE TABLE `t1`, `t2`"]
|
||||
(-> {:truncate [[:t1 :t2]]}
|
||||
(format {:dialect :mysql}))))
|
||||
(is (= ["TRUNCATE TABLE `t1`, `t2` CONTINUE IDENTITY"]
|
||||
(-> {:truncate [[:t1 :t2] :continue :identity]}
|
||||
(format {:dialect :mysql})))))
|
||||
|
||||
(deftest inlined-values-are-stringified-correctly
|
||||
|
|
@ -1184,10 +1155,9 @@ ORDER BY id = ? DESC
|
|||
|
||||
(deftest issue-474-dot-selection
|
||||
(testing "basic dot selection"
|
||||
(is (= ["SELECT a.b, c.d, a.d.x, a.d.x.y"]
|
||||
(is (= ["SELECT a.b, c.d, a.d.x"]
|
||||
(let [t :a c :d]
|
||||
(sut/format {:select [[[:. t :b]] [[:. :c c]]
|
||||
[[:. t c :x]] [[:. t c :x :y]]]}))))
|
||||
(sut/format {:select [[[:. t :b]] [[:. :c c]] [[:. t c :x]]]}))))
|
||||
(is (= ["SELECT [a].[b], [c].[d], [a].[d].[x]"]
|
||||
(let [t :a c :d]
|
||||
(sut/format {:select [[[:. t :b]] [[:. :c c]] [[:. t c :x]]]}
|
||||
|
|
@ -1201,54 +1171,8 @@ ORDER BY id = ? DESC
|
|||
(sut/format '{select (((. (nest v) *))
|
||||
((. (nest w) x))
|
||||
((. (nest (y z)) *)))}
|
||||
{:dialect :mysql})))
|
||||
(is (= ["SELECT (v).*, (w).x, (Y(z)).*"]
|
||||
(sut/format '{select (((get-in v *))
|
||||
((get-in w x))
|
||||
((get-in (y z) *)))})))
|
||||
(is (= ["SELECT (`v`).*, (`w`).`x`, (Y(`z`)).*"]
|
||||
(sut/format '{select (((get-in v *))
|
||||
((get-in w x))
|
||||
((get-in (y z) *)))}
|
||||
{:dialect :mysql})))))
|
||||
|
||||
(deftest issue-570-snowflake-dot-selection
|
||||
(testing "basic colon selection"
|
||||
(is (= ["SELECT a:b, c:d, a:d.x, a:d.x.y"]
|
||||
(let [t :a c :d]
|
||||
(sut/format {:select [[[:.:. t :b]] [[:.:. :c c]]
|
||||
[[:.:. t c :x]] [[:.:. t c :x :y]]]}))))
|
||||
(is (= ["SELECT [a]:[b], [c]:[d], [a]:[d].[x]"]
|
||||
(let [t :a c :d]
|
||||
(sut/format {:select [[[:.:. t :b]] [[:.:. :c c]] [[:.:. t c :x]]]}
|
||||
{:dialect :sqlserver})))))
|
||||
(testing "basic field selection from composite"
|
||||
(is (= ["SELECT (v):*, (w):x, (Y(z)):*"]
|
||||
(sut/format '{select (((.:. (nest v) *))
|
||||
((.:. (nest w) x))
|
||||
((.:. (nest (y z)) *)))})))
|
||||
(is (= ["SELECT (`v`):*, (`w`):`x`, (Y(`z`)):*"]
|
||||
(sut/format '{select (((.:. (nest v) *))
|
||||
((.:. (nest w) x))
|
||||
((.:. (nest (y z)) *)))}
|
||||
{:dialect :mysql}))))
|
||||
(testing "bracket selection"
|
||||
(is (= ["SELECT a['b'], c['b'], a['d'].x, a:e[0].name"]
|
||||
(sut/format {:select [[[:at :a [:inline "b"]]]
|
||||
[[:at :c "b"]]
|
||||
[[:at :a [:inline "d"] :x]]
|
||||
[[:.:. :a [:at :e [:inline 0]] :name]]]})))
|
||||
(is (= ["SELECT a[?].name" 0]
|
||||
(sut/format '{select (((at a (lift 0) name)))})))
|
||||
;; sanity check, compare with get-in:
|
||||
(is (= ["SELECT (a)[?].name" 0]
|
||||
(sut/format '{select (((get-in a (lift 0) name)))})))
|
||||
(is (= ["SELECT (a)['b'], (c)['b'], (a)['d'].x, a:(e)[0].name"]
|
||||
(sut/format {:select [[[:get-in :a [:inline "b"]]]
|
||||
[[:get-in :c "b"]]
|
||||
[[:get-in :a [:inline "d"] :x]]
|
||||
[[:.:. :a [:get-in :e [:inline 0]] :name]]]})))))
|
||||
|
||||
(deftest issue-476-raw
|
||||
(testing "single argument :raw"
|
||||
(is (= ["@foo := 42"]
|
||||
|
|
@ -1475,41 +1399,6 @@ ORDER BY id = ? DESC
|
|||
(is (= [(str "CREATE TABLE \"" table "\"")]
|
||||
(sut/format {:create-table table}))))))
|
||||
|
||||
(deftest issue-555-setting
|
||||
(testing "setting default time"
|
||||
(is (= ["SETTING DEFAULT SYSTEM_TIME AS OF DATE '2024-11-24'"]
|
||||
(sut/format {:setting [:default :system-time :as-of [:inline :DATE "2024-11-24"]]})))
|
||||
(is (= ["SETTING SNAPSHOT_TIME TO DATE '2024-11-24', DEFAULT VALID_TIME TO BETWEEN DATE '2022' AND DATE '2023'"]
|
||||
(sut/format {:setting [[:snapshot-time :to [:inline :DATE "2024-11-24"]]
|
||||
[:default :valid-time :to :between [:inline :DATE "2022"] :and [:inline :DATE "2023"]]]})))
|
||||
(is (= ["SETTING DEFAULT SYSTEM_TIME AS OF DATE '2024-11-24' SELECT * FROM table"]
|
||||
(sut/format (-> (h/setting :default :system-time :as-of [:inline :DATE "2024-11-24"])
|
||||
(h/select :*)
|
||||
(h/from :table)))))
|
||||
(is (= ["SETTING SNAPSHOT_TIME TO DATE '2024-11-24', DEFAULT VALID_TIME TO BETWEEN DATE '2022' AND DATE '2023' SELECT * FROM table"]
|
||||
(sut/format (-> (h/setting [:snapshot-time :to [:inline :DATE "2024-11-24"]]
|
||||
[:default :valid-time :to :between [:inline :DATE "2022"] :and [:inline :DATE "2023"]])
|
||||
(h/select :*)
|
||||
(h/from :table)))))))
|
||||
|
||||
(deftest issue-571
|
||||
(testing "an empty where clause is omitted"
|
||||
(is (= ["SELECT * FROM foo"]
|
||||
(sut/format {:select :* :from :foo :where []})))
|
||||
#?(:clj
|
||||
(is (thrown? clojure.lang.ExceptionInfo
|
||||
(sut/format {:select :* :from :foo :where nil}))))
|
||||
(is (= ["SELECT * FROM foo WHERE 1 = 1"]
|
||||
(sut/format {:select :* :from :foo :where [:= 1 1]} {:inline true}))))
|
||||
(testing "an empty order by clause is omitted"
|
||||
(is (= ["SELECT * FROM foo"]
|
||||
(sut/format {:select :* :from :foo :order-by []})))
|
||||
#?(:clj
|
||||
(is (thrown? clojure.lang.ExceptionInfo
|
||||
(sut/format {:select :* :from :foo :order-by nil}))))
|
||||
(is (= ["SELECT * FROM foo ORDER BY bar ASC"]
|
||||
(sut/format {:select :* :from :foo :order-by [:bar]})))))
|
||||
|
||||
(comment
|
||||
;; partial (incorrect!) workaround for #407:
|
||||
(sut/format {:select :f.* :from [[:foo [:f :for :system-time]]] :where [:= :f.id 1]})
|
||||
|
|
@ -1522,9 +1411,4 @@ ORDER BY id = ? DESC
|
|||
:select [:*]
|
||||
:from [:a-b.b-c.c-d]}
|
||||
(sut/format {:dialect :nrql}))
|
||||
(sut/format {:select :a:b.c}) ; quotes a:b
|
||||
(sut/format [:. :a :b :c]) ; a.b.c
|
||||
(sut/format [:. :a :b :c :d]) ; drops d ; a.b.c
|
||||
(sut/format [:.:. :a :b :c]) ; .(a, b, c)
|
||||
(sut/format '(.:. a b c)) ; .(a, b, c)
|
||||
)
|
||||
|
|
|
|||
|
|
@ -43,20 +43,3 @@
|
|||
(is (= "1, 2, 3, 4"
|
||||
(sut/join ", " (remove nil?) [1 nil 2 nil 3 nil nil nil 4])))
|
||||
(is (= "" (sut/join ", " (remove nil?) [nil nil nil nil]))))
|
||||
|
||||
(deftest split-by-separator-test
|
||||
(is (= [""] (sut/split-by-separator "" ".")))
|
||||
(is (= ["" ""] (sut/split-by-separator "." ".")))
|
||||
(is (= ["hello"] (sut/split-by-separator "hello" ".")))
|
||||
(is (= ["h" "e" "l" "l" "o"] (sut/split-by-separator "h.e.l.l.o" ".")))
|
||||
(is (= ["" "h" "e" "" "" "l" "" "l" "o" ""]
|
||||
(sut/split-by-separator ".h.e...l..l.o." "."))))
|
||||
|
||||
(deftest into*-test
|
||||
(is (= [1] (sut/into* [1] nil)))
|
||||
(is (= [1] (sut/into* [1] [])))
|
||||
(is (= [1] (sut/into* [1] nil [] nil [])))
|
||||
(is (= [1 2 3] (sut/into* [1] [2 3])))
|
||||
(is (= [1 2 3 4 5 6] (sut/into* [1] [2 3] [4 5 6])))
|
||||
(is (= [1 2 3 4 5 6 7] (sut/into* [1] [2 3] [4 5 6] [7])))
|
||||
(is (= [1 2 3 4 5 6 7 8 9] (sut/into* [1] [2 3] [4 5 6] [7] [8 9]))))
|
||||
|
|
|
|||
Loading…
Reference in a new issue