/
core.clj
103 lines (88 loc) · 2.48 KB
/
core.clj
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
(ns clj-util.db.core
(:require [clojure.java.jdbc :as jdbc]
[honeysql.core :as sql]
[clojure.string :as str]
[taoensso.timbre :as log])
(:import [java.sql Timestamp]
[java.time Instant]
[java.util UUID]))
(defn ^:private prefixed-column
[prefix column]
(keyword (str (name prefix) \. (name column))))
(defn ^:private prefixed-columns
[prefix columns]
(map (partial prefixed-column prefix) columns))
(defn columns
([schema]
(columns schema (:columns schema)))
([schema columns]
(prefixed-columns (:table schema) columns)))
(defn aliased-columns
([schema]
(aliased-columns schema (:columns schema)))
([schema columns]
(prefixed-columns (:alias schema) columns)))
(defn column
[schema column]
(prefixed-column (:table schema) column))
(defn aliased-column
[schema column]
(prefixed-column (:alias schema) column))
(defn table
[schema]
(:table schema))
(defn aliased-table
[schema]
[(:table schema) (:alias schema)])
(defn ^:private clj->sql
[x]
(-> x
(name)
(str/replace #"-" "_")))
(defn ^:private sql->clj
[x]
(-> x
(str/lower-case)
(str/replace #"_" "-")
(keyword)))
(defn ^:private prepare-insert
[row]
(let [created-at (Timestamp/from (Instant/now))]
(merge {:id (UUID/randomUUID)
:created-at created-at
:updated-at created-at}
(into {} (map (fn [[k v]]
{k (if (instance? Instant v)
(Timestamp/from v)
v)})
row)))))
(defn query
[spec sqlmap]
(let [sql (sql/format sqlmap)]
(log/debug "query" sql)
(->> (jdbc/query spec sql
{:identifiers sql->clj
:entities clj->sql}))))
(defn fetch!
[spec table id]
(log/debug "fetch!" table id)
(-> (query spec {:select [:*]
:from [table]
:where [:= :id id]})
(first)))
(defn insert!
[spec table row]
(log/debug "insert!" table row)
(-> (jdbc/insert! spec table
(prepare-insert row)
{:identifiers sql->clj
:entities clj->sql})
(first)))
(defn delete!
[spec table where]
(log/debug "delete!" table where)
(let [sql (sql/format {:delete-from table
:where where})]
(jdbc/execute! spec sql
{:identifiers sql->clj
:entities clj->sql})))