How to use MySQL to implement data persistence in Clojure

How to use MySQL to implement data persistence in Clojure

Overview:
In Clojure development, the database is an essential part. As a commonly used relational database management system, MySQL can well meet the needs of data persistence. This article will introduce how to use MySQL to implement data persistence in Clojure and provide corresponding code examples.

Step 1: Install MySQL
First, we need to install the MySQL database locally. You can download and install the corresponding version of MySQL from the MySQL official website.

Step 2: Add MySQL dependency
Add MySQL dependency in the project file of the Clojure project (for example, project.clj). You can use the following code:

:dependencies
[[mysql/mysql-connector-java "8.0.21"]]

Step 3: Connect to the database
First, we need to import the required namespace:

(ns my-namespace
  (:require [clojure.java.jdbc :as jdbc]
            [clojure.java.jdbc.sql :as sql]))

Then, use the following code to connect to the database:

(def db-settings
  {:subprotocol "mysql"
   :subname "//localhost:3306/my-database"
   :user "username"
   :password "password"})

(defn establish-connection []
  (jdbc/get-connection db-settings))

Please make sure to replace my-database in the above code with your database name and replace it with the correct username and password.

Step 4: Create a table
In Clojure, you can use the jdbc/execute! function to execute SQL statements. Here is an example to create a table named users:

(defn create-users-table []
  (jdbc/execute! db-settings
                 ["CREATE TABLE IF NOT EXISTS users
                  (id INT(11) AUTO_INCREMENT PRIMARY KEY,
                  username VARCHAR(255) NOT NULL,
                  email VARCHAR(255) NOT NULL,
                  password VARCHAR(255) NOT NULL)"]))

Step 5: Insert data
You can use the jdbc/execute! function to Data is inserted into the table. The following is an example for inserting a row of data into the users table:

(defn insert-user [username email password]
  (jdbc/execute! db-settings
                 ["INSERT INTO users (username, email, password)
                  VALUES (?, ?, ?)"]
                 username email password))

Step 6: Query the data
Use the jdbc/query function to query the database . The following is an example for querying data for all users:

(defn get-all-users []
  (jdbc/query db-settings
              ["SELECT * FROM users"]))

Step 7: Update data
Use the jdbc/execute! function to update data in the database. The following is an example for updating a row of data in the users table:

(defn update-user [id username email password]
  (jdbc/execute! db-settings
                 ["UPDATE users SET username=?, email=?, password=?
                  WHERE id=?"]
                 username email password id))

Step 8: Delete data
Use the jdbc/execute! function to delete data in the database. The following is an example for deleting a row of data in the users table:

(defn delete-user [id]
  (jdbc/execute! db-settings
                 ["DELETE FROM users WHERE id=?"]
                 id))

Summary:
Through the above steps, we can use MySQL to achieve data persistence in Clojure Function. Although this article only provides some basic examples, you can extend them to suit your needs. I hope this article will help you use MySQL for data persistence in Clojure development!

Reference materials:

• Clojure JDBC library documentation: https://github.com/clojure/java.jdbc

The above is the detailed content of How to use MySQL to implement data persistence in Clojure. For more information, please follow other related articles on the PHP Chinese website!