Connecting to Databases with next.jdbc
Learn to establish database connections and execute SQL queries using the `next.jdbc` library.
Connecting to Databases with next.jdbc is a free Clojure Functional Programming & JVM Backend Development lesson on CoddyKit — lesson 1 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the Clojure Functional Programming & JVM Backend Development learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.
Database Access in Clojure
Welcome to connecting Clojure with databases! Most real-world applications need to store and retrieve data, and databases are central to this.
In this lesson, you'll learn how to use next.jdbc, Clojure's popular library, to interact with various databases.
Meet next.jdbc
next.jdbc is a modern, idiomatic Clojure wrapper for JDBC (Java Database Connectivity). JDBC is the standard Java API for connecting to relational databases.
- It simplifies database operations.
- It provides a clean, functional interface.
- It's fast and efficient.
- It supports a wide range of databases (PostgreSQL, MySQL, H2, SQLite, etc.).
Adding Dependencies
Before we write any code, we need to add next.jdbc and a database driver to our project's dependencies. We'll use H2, an in-memory database, for easy examples.
Add these to your deps.edn file:
{:deps {org.clojure/clojure {:mvn/version "1.11.1"}
seancorfield/next.jdbc {:mvn/version "1.3.909"}
com.h2database/h2 {:mvn/version "2.2.220"}}}The Connection String (JDBC URL)
To connect to a database, you need a JDBC URL. This string tells next.jdbc (and the underlying JDBC driver) how to find and connect to your database.
For an in-memory H2 database, a common URL looks like this:
jdbc:h2:mem:testdb: Connects to an H2 database named 'testdb' in memory.jdbc:sqlite:my-data.db: Connects to a SQLite file.jdbc:postgresql://localhost/mydb: Connects to a PostgreSQL database.
Establishing a Datasource
A datasource is an object that represents a connection pool or factory for database connections. It's usually created once and reused.
next.jdbc's get-datasource function takes a map of connection parameters, including the JDBC URL.
Getting a Connection with <code>with-open</code>
After getting a datasource, you can obtain a connection. It's crucial to close connections after use to free up resources.
Clojure's with-open macro is perfect for this. It ensures that resources like database connections are automatically closed when they go out of scope.
Runnable: Connect & Disconnect
Let's see how to establish and close a database connection using next.jdbc and an in-memory H2 database. Run this code:
(ns my-app.core
(:require [next.jdbc :as jdbc]))
(defn -main
"Connects to an H2 in-memory database and closes the connection."
[]
(let [db-spec {:dbtype "h2" :dbname "mem:testdb"}]
(println "Attempting to connect...")
(with-open [conn (jdbc/get-connection db-spec)]
(println "Successfully connected to H2!\nConnection object:")
(println conn))
(println "Connection closed.")))
(-main)Executing Simple SQL Queries
Once connected, you can execute SQL queries. next.jdbc provides functions like jdbc/execute! for DDL (Data Definition Language) and DML (Data Manipulation Language) operations, and jdbc/execute-one! for queries expecting a single row result.
Queries are passed as vectors, with the SQL string followed by any parameters.
Runnable: Execute a Query
Now, let's create a table and insert some data into our in-memory H2 database, then query it. Notice how execute! returns a vector of maps.
(ns my-app.core
(:require [next.jdbc :as jdbc]))
(defn -main
"Connects, creates a table, inserts data, and queries it."
[]
(let [db-spec {:dbtype "h2" :dbname "mem:testdb"}]
(with-open [conn (jdbc/get-connection db-spec)]
(println "Connected. Creating table...")
(jdbc/execute! conn ["CREATE TABLE IF NOT EXISTS users (id INT PRIMARY KEY, name VARCHAR(255))"])
(println "Table created. Inserting data...")
(jdbc/execute! conn ["INSERT INTO users (id, name) VALUES (?, ?)" 1 "Alice"])
(jdbc/execute! conn ["INSERT INTO users (id, name) VALUES (?, ?)" 2 "Bob"])
(println "Data inserted. Querying data...")
(let [result (jdbc/execute! conn ["SELECT id, name FROM users"])]
(println "Query Result:")
(doseq [row result] (println row))))
(println "Operations complete. Connection closed.")))
(-main)Quick Check on Connections
What is the primary purpose of using with-open when dealing with database connections in Clojure?
Recap: Connecting to Databases
You've taken the first step into database interaction with Clojure!
- We introduced
next.jdbcas a powerful library for database access. - You learned how to add necessary dependencies (
next.jdbcand a JDBC driver like H2). - We covered JDBC URLs and how to establish a datasource and connection.
- You saw how
with-openensures connections are properly managed. - Finally, we executed basic DDL and DML queries using
jdbc/execute!.
Next, we'll dive deeper into CRUD operations!
Frequently asked questions
Is the “Connecting to Databases with next.jdbc” lesson free?
Yes — the full text of “Connecting to Databases with next.jdbc” is free to read here on the web, and the Clojure Functional Programming & JVM Backend Development course includes 4 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the Clojure Functional Programming & JVM Backend Development course, upgrade to CoddyKit PRO.
What will I learn in “Connecting to Databases with next.jdbc”?
Learn to establish database connections and execute SQL queries using the `next.jdbc` library. You practise Clojure Functional Programming & JVM Backend Development with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.
Do I need any experience to start Clojure Functional Programming & JVM Backend Development?
No prior experience is required. Clojure Functional Programming & JVM Backend Development on CoddyKit is structured for beginners through advanced learners; this is — lesson 1 of 4, so you can start here or from the beginning and move at your own pace.
How long does the “Connecting to Databases with next.jdbc” lesson take?
Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.
Can I write and run code in this Clojure Functional Programming & JVM Backend Development lesson?
Yes. Every Clojure Functional Programming & JVM Backend Development lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.
All lessons in this course
- Connecting to Databases with next.jdbc
- Performing CRUD Operations
- Database Migrations & Schema Management
- Connection Pooling & Transactions