This tutorial shows you how build a simple Clojure application with CockroachDB using a PostgreSQL-compatible driver. We’ve tested and can recommend the Clojure java.jdbc driver, so that driver is featured here.

Before You Begin

Make sure you have already installed CockroachDB.

Step 1. Install the Clojure java.jdbc driver

Install the Clojure java.jdbc driver as described in the official documentation.

Step 2. Start a cluster

For the purpose of this tutorial, you need only one CockroachDB node running in insecure mode:

# Start node 1:
$ cockroach start --background \
--store=hello-1

But as you might’ve seen in the Start a Local Cluster tutorial, it’s incredibly easy to start and join addition nodes, if you want to simulate a real cluster:

# Start node 2:
$ cockroach start --background \
--store=hello-2 \
--port=26258 \
--http-port=8081 \
--join=localhost:26257

# Start node 3:
$ cockroach start --background \
--store=hello-3 \
--port=26259 \
--http-port=8082 \
--join=localhost:26257

Step 3. Create a user

As the root user, use the cockroach user command to create a new user, maxroach.

$ cockroach user set maxroach

Step 4. Create a database and grant privileges

As the root user, use the built-in SQL client to create a bank database.

$ cockroach sql -e 'CREATE DATABASE bank'

Then grant privileges to the maxroach user

$ cockroach sql -e 'GRANT ALL ON DATABASE bank TO maxroach'

Step 5. Create a table in the new database

As the maxroach user, use the built-in SQL client to create an accounts table in the new database.

$ cockroach sql --database=bank --user=maxroach -e \
'CREATE TABLE accounts (id INT PRIMARY KEY, balance INT)'
CREATE TABLE

Step 6. Run the Clojure code

Basic Statements

The following code connects as the maxroach user and executes some basic SQL statements, inserting rows and reading and printing the rows.

Copy the code or download it directly.

;; Import the driver.
(use 'clojure.java.jdbc)

;; Connect to the "bank" database.
(def db-spec {:subprotocol "postgresql"
              :subname "//localhost:26257/bank"
              :user "maxroach"
              :password ""})

(with-db-connection [conn db-spec]

  ;; Insert two rows into the "accounts" table.
  (insert! conn :accounts {:id 1 :balance 1000} {:id 2 :balance 250})

  ;; Print out the balances.
  (println "Initial balances:")
  (->> (query conn ["SELECT id, balance FROM accounts"])
       (map println)
       doall)

;; The database connection is automatically closed by with-db-connection.
)

Transaction (with retry logic)

The following code again connects as the maxroach user but this time executes a batch of statements as an atomic transaction to transfer funds from one account to another, where all included statements are either committed or aborted.

Copy the code or download it directly.

Because the CockroachDB transaction model requires the client to initiate retries in the case of contention, CockroachDB provides a generic retry function that runs inside a transaction and retries it as needed. You can copy and paste the retry function from here into your code. For more details, see Transaction Retries.
;; Import the driver.
(use 'clojure.java.jdbc)

;; Connect to the cluster.
(def db-spec {:subprotocol "postgresql"
              :subname "//localhost:26257/bank"
              :user "maxroach"
              :password ""})


;; Wrapper for a transaction.
;; This automatically invokes the body again
;; as long as the database server asks the transaction to be retried.
(defmacro with-txn-retry
  [c conn & body]
  `(with-db-transaction [c conn]
     (loop []
       (let [res# (try (let [r# ~@body]
                         {:ok r#})
                       (catch org.postgresql.util.PSQLException e#
                         (if (re-find #"restart transaction" (.getMessage e#))
                           {:retry true}
                           (throw e#))))]
         (if (:retry res#) (recur) (:ok res#))
         ))))

;; The transaction we want to run.
(defn transferFunds
  [txn from to amount]

  ;; Check the current balance.
  (let [fromBalance (->> (query txn ["SELECT balance FROM accounts WHERE id = ?" from])
                         (mapv :balance)
                         (first))]
    (when (< fromBalance amount)
      (throw (Exception. "Insufficient funds"))))

  ;; Perform the transfer.
  (execute! txn [(str "UPDATE accounts SET balance = balance - " amount " WHERE id = " from)])
  (execute! txn [(str "UPDATE accounts SET balance = balance + " amount " WHERE id = " to)])
  )
      

(with-db-connection [conn db-spec]
  ;; Execute the transaction.
  (with-txn-retry [c conn]
     (transferFunds c 1 2 100))

  (println "Balances after transfer:")
  (->> (query conn ["SELECT id, balance FROM accounts"])
       (map println)
       (doall))
  )
  
  


After running the code, to verify that funds were, in fact, transferred from one account to another, you can again use the built-in SQL client:

$ cockroach sql -e 'SELECT id, balance FROM accounts' --database=bank
+----+---------+
| id | balance |
+----+---------+
|  1 |     900 |
|  2 |     350 |
+----+---------+
(2 rows)

What’s Next?

Read more about using the Clojure java.jdbc driver.

You might also be interested in using a local cluster to explore the following core CockroachDB features:



Yes No