CRUD 연산 수행
Clojure에서 관계형 데이터베이스의 데이터를 생성, 조회, 수정 및 삭제하는 방법을 숙달합니다.
CRUD 연산 수행은(는) CoddyKit의 무료 Clojure Functional Programming & JVM Backend Development 강의입니다. 이것은 4개 중 2번째 강의입니다. 아래에서 전체 강의를 무료로 읽을 수 있으며, 내장 코드 에디터와 24/7 AI 튜터와 함께 브라우저에서 직접 실습할 수 있습니다. 이 강의는 Clojure Functional Programming & JVM Backend Development 학습 경로의 일부이며, 진행 상황이 웹과 CoddyKit 앱에 동기화됩니다. Clojure Functional Programming & JVM Backend Development 강의에는 총 4개의 강의가 포함되어 있습니다.
이 강의의 일부는 아직 번역되지 않았으며 영어로 표시됩니다.
What is CRUD?
When you build applications, you'll constantly interact with databases. The fundamental operations for managing data are often summarized by the acronym CRUD.
- Create: Adding new data.
- Read: Retrieving existing data.
- Update: Modifying existing data.
- Delete: Removing data.
In this lesson, we'll master how to perform these essential operations using Clojure's next.jdbc library.
Database Connection Setup
Before we perform CRUD operations, we need a database connection. We'll use next.jdbc with an in-memory SQLite database for our examples.
Remember from the previous lesson, we define a database specification (db-spec) and obtain a data source (ds) or a direct connection.
We'll create a simple users table for our examples.
Create: Inserting New Records
To add new data, we use the next.jdbc.sql/insert! function. It takes a connection, table name, and a map of column-value pairs.
Try running this example to create a users table and insert your first user:
(ns coddykit.core
(:require [next.jdbc :as jdbc]
[next.jdbc.sql :as sql]))
(defn -main
"Insert a new user into the database."
[& args]
(let [db-spec {:dbtype "sqlite" :dbname ":memory:"}]
(with-open [conn (jdbc/get-connection db-spec)]
(jdbc/execute! conn ["DROP TABLE IF EXISTS users;"])
(jdbc/execute! conn ["CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT, email TEXT)"])
(println "Inserting new user...")
(let [new-user {:name "Alice" :email "alice@example.com"}
result (sql/insert! conn :users new-user)]
(println "Insert result:" result))
(println "\nUsers in database:")
(doseq [user (sql/select! conn ["SELECT * FROM users"])]
(println user)))))Create: Inserting Multiple Records
What if you need to add many records at once? The next.jdbc.sql/insert-multi! function is perfect for this. It takes a sequence of maps, each representing a row to insert.
It's more efficient than calling insert! repeatedly in a loop.
(ns coddykit.core
(:require [next.jdbc :as jdbc]
[next.jdbc.sql :as sql]))
(defn -main
"Insert multiple users into the database."
[& args]
(let [db-spec {:dbtype "sqlite" :dbname ":memory:"}]
(with-open [conn (jdbc/get-connection db-spec)]
(jdbc/execute! conn ["DROP TABLE IF EXISTS users;"])
(jdbc/execute! conn ["CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT, email TEXT)"])
(println "Inserting multiple users...")
(let [new-users [{:name "Bob" :email "bob@example.com"}
{:name "Charlie" :email "charlie@example.com"}]
result (sql/insert-multi! conn :users new-users)]
(println "Insert result:" result))
(println "\nUsers in database:")
(doseq [user (sql/select! conn ["SELECT * FROM users"])]
(println user)))))Read: Fetching All Data
To retrieve all records from a table, use next.jdbc.sql/select-all!. It takes a connection and the table name (as a keyword or string).
The function returns a sequence of maps, where each map represents a row.
(ns coddykit.core
(:require [next.jdbc :as jdbc]
[next.jdbc.sql :as sql]))
(defn -main
"Select all users from the database."
[& args]
(let [db-spec {:dbtype "sqlite" :dbname ":memory:"}]
(with-open [conn (jdbc/get-connection db-spec)]
(jdbc/execute! conn ["DROP TABLE IF EXISTS users;"])
(jdbc/execute! conn ["CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT, email TEXT)"])
(sql/insert! conn :users {:name "Alice" :email "alice@example.com"})
(sql/insert! conn :users {:name "Bob" :email "bob@example.com"})
(println "Fetching all users...")
(let [all-users (sql/select-all! conn :users)]
(doseq [user all-users]
(println user))))))Read: Filtering Data with `WHERE`
Often, you only want specific records. Use next.jdbc.sql/select! with a WHERE clause to filter results. The WHERE clause is provided as a map.
For example, to find users with a specific name or email:
(ns coddykit.core
(:require [next.jdbc :as jdbc]
[next.jdbc.sql :as sql]))
(defn -main
"Select users with a specific name."
[& args]
(let [db-spec {:dbtype "sqlite" :dbname ":memory:"}]
(with-open [conn (jdbc/get-connection db-spec)]
(jdbc/execute! conn ["DROP TABLE IF EXISTS users;"])
(jdbc/execute! conn ["CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT, email TEXT)"])
(sql/insert! conn :users {:name "Alice" :email "alice@example.com"})
(sql/insert! conn :users {:name "Bob" :email "bob@example.com"})
(sql/insert! conn :users {:name "Alice" :email "alice2@example.com"})
(println "Fetching users named Alice...")
(let [alices (sql/select! conn :users {:name "Alice"})]
(doseq [user alices]
(println user))))))Update: Modifying Existing Data
To change existing records, use next.jdbc.sql/update!. It takes a connection, table name, a map of columns to update, and a WHERE clause map to specify which records to modify.
Always be careful with your WHERE clause when updating!
(ns coddykit.core
(:require [next.jdbc :as jdbc]
[next.jdbc.sql :as sql]))
(defn -main
"Update a user's email address."
[& args]
(let [db-spec {:dbtype "sqlite" :dbname ":memory:"}]
(with-open [conn (jdbc/get-connection db-spec)]
(jdbc/execute! conn ["DROP TABLE IF EXISTS users;"])
(jdbc/execute! conn ["CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT, email TEXT)"])
(sql/insert! conn :users {:name "Alice" :email "alice@example.com"})
(println "Original user:")
(println (first (sql/select! conn :users {:name "Alice"})))
(println "\nUpdating Alice's email...")
(let [result (sql/update! conn :users {:email "alice.new@example.com"} {:name "Alice"})]
(println "Update result:" result))
(println "\nUpdated user:")
(println (first (sql/select! conn :users {:name "Alice"})))))Delete: Removing Data
To remove records from a table, use next.jdbc.sql/delete!. Similar to update!, it requires a connection, table name, and a WHERE clause map to specify which records to remove.
A missing or empty WHERE clause can delete ALL records, so use with extreme caution!
(ns coddykit.core
(:require [next.jdbc :as jdbc]
[next.jdbc.sql :as sql]))
(defn -main
"Delete a user from the database."
[& args]
(let [db-spec {:dbtype "sqlite" :dbname ":memory:"}]
(with-open [conn (jdbc/get-connection db-spec)]
(jdbc/execute! conn ["DROP TABLE IF EXISTS users;"])
(jdbc/execute! conn ["CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT, email TEXT)"])
(sql/insert! conn :users {:name "Alice" :email "alice@example.com"})
(sql/insert! conn :users {:name "Bob" :email "bob@example.com"})
(println "Users before delete:")
(doseq [user (sql/select-all! conn :users)] (println user))
(println "\nDeleting Bob...")
(let [result (sql/delete! conn :users {:name "Bob"})]
(println "Delete result:" result))
(println "\nUsers after delete:")
(doseq [user (sql/select-all! conn :users)] (println user)))))Atomic Operations with Transactions
Sometimes you need multiple CRUD operations to succeed or fail as a single, atomic unit. This is where transactions come in.
If any operation within a transaction fails, all changes are rolled back, ensuring data consistency. Use next.jdbc/with-transaction for this.
(ns coddykit.core
(:require [next.jdbc :as jdbc]
[next.jdbc.sql :as sql]))
(defn -main
"Demonstrate a database transaction."
[& args]
(let [db-spec {:dbtype "sqlite" :dbname ":memory:"}]
(with-open [conn (jdbc/get-connection db-spec)]
(jdbc/execute! conn ["DROP TABLE IF EXISTS accounts;"])
(jdbc/execute! conn ["CREATE TABLE accounts (id INTEGER PRIMARY KEY, name TEXT, balance INTEGER)"])
(sql/insert! conn :accounts {:name "Alice" :balance 100})
(sql/insert! conn :accounts {:name "Bob" :balance 50})
(println "Balances before transaction:")
(doseq [acc (sql/select-all! conn :accounts)] (println acc))
(println "\nAttempting to transfer $20 from Alice to Bob...")
(try
(jdbc/with-transaction [tx conn]
(sql/update! tx :accounts {:balance [- :balance 20]} {:name "Alice"})
(sql/update! tx :accounts {:balance [+ :balance 20]} {:name "Bob"})
(println "Transfer successful!"))
(catch Exception e
(println "Transfer failed:" (.getMessage e))))
(println "\nBalances after transaction:")
(doseq [acc (sql/select-all! conn :accounts)] (println acc)))))CRUD Quick Check
You've learned the core functions for interacting with databases. Let's test your understanding!
Recap: Mastering CRUD
Congratulations! You've mastered the essential CRUD operations for database interaction in Clojure using next.jdbc:
- Create:
insert!andinsert-multi!to add data. - Read:
select!andselect-all!to retrieve data. - Update:
update!to modify existing data. - Delete:
delete!to remove data.
You also learned about using transactions with with-transaction for atomic operations, ensuring data integrity. These are the building blocks for almost any data-driven application!
자주 묻는 질문
“CRUD 연산 수행” 강의는 무료인가요?
네 — “CRUD 연산 수행” 전체 내용을 이 웹사이트에서 무료로 읽을 수 있습니다. 인터랙티브하게 실습하려면(내장 코드 에디터와 24/7 AI 튜터), CoddyKit PRO로 업그레이드하면 Clojure Functional Programming & JVM Backend Development 강의 전체를 잠금 해제할 수 있습니다. Clojure Functional Programming & JVM Backend Development 강의에는 총 4개의 강의가 포함되어 있습니다.
“CRUD 연산 수행”에서 뭘 배우나요?
Clojure에서 관계형 데이터베이스의 데이터를 생성, 조회, 수정 및 삭제하는 방법을 숙달합니다. 브라우저에서 직접 실행하는 실습 코드로 Clojure Functional Programming & JVM Backend Development을(를) 배우며, 24/7 AI 튜터가 강의를 진행하면서 질문에 답변해줍니다.
Clojure Functional Programming & JVM Backend Development을(를) 시작하는 데 경험이 필요한가요?
사전 경험은 필요하지 않습니다. CoddyKit의 Clojure Functional Programming & JVM Backend Development은(는) 초급자부터 고급 학습자까지를 위해 구성되어 있으므로, 여기서 시작하거나 처음부터 시작할 수 있으며 자신의 속도대로 진행할 수 있습니다. 이것은 4개 중 2번째 강의입니다.
“CRUD 연산 수행” 강의는 얼마나 걸리나요?
대부분의 CoddyKit 강의는 약 5~10분이 소요됩니다. 각 강의는 간결하고 인터랙티브하여 꾸준한 진행이 가능하며, 웹과 앱에서 중단한 부분부터 바로 시작할 수 있습니다.
이 Clojure Functional Programming & JVM Backend Development 강의에서 코드를 작성하고 실행할 수 있나요?
네. 모든 Clojure Functional Programming & JVM Backend Development 강의에는 내장 코드 에디터가 포함되어 있으므로, 브라우저에서 바로 실제 코드를 작성하고 실행한 후 즉시 AI 피드백을 받을 수 있습니다 — 로컬 설정이 필요 없습니다.