Clojure - Datenbanken

Um die Datenbankfunktionalität nutzen zu können, müssen Sie zuerst die herunterladen jdbc files von der folgenden URL - https://codeload.github.com/clojure/java.jdbc/zip/master

Sie finden eine Zip-Datei mit den erforderlichen Treibern, damit Clojure eine Verbindung zu Datenbanken herstellen kann. Stellen Sie nach dem Extrahieren der Zip-Datei sicher, dass Sie den entpackten Speicherort Ihrem Klassenpfad hinzufügen.

Die Hauptdatei für die Datenbankkonnektivität ist eine Datei mit dem Namen jdbc.clj in der Location Clojure / Java.

Der Clojure JDBC-Connector unterstützt eine Vielzahl von Datenbanken, von denen einige die folgenden sind.

• H2Database
• Oracle
• Microsoft SQL Server
• MySQL
• PostgreSQL

In unserem Beispiel verwenden wir MySQL DB als Beispiel.

Die folgenden Operationen sind in Clojure in Bezug auf Datenbanken möglich.

Datenbankverbindung

Stellen Sie vor dem Herstellen einer Verbindung zu einer MySQL-Datenbank Folgendes sicher:

• Sie haben eine Datenbank TESTDB erstellt.

• Sie haben in TESTDB eine Tabelle EMPLOYEE erstellt.

• Diese Tabelle enthält die Felder FIRST_NAME, LAST_NAME, AGE, SEX und INCOME.

• Die Benutzer-ID "testuser" und das Kennwort "test123" sind für den Zugriff auf TESTDB festgelegt.

• Stellen Sie sicher, dass Sie die 'MySQL-JAR-Datei' heruntergeladen und die Datei Ihrem Klassenpfad hinzugefügt haben.

• Sie haben das MySQL-Tutorial durchgearbeitet, um die MySQL-Grundlagen zu verstehen .

Syntax

Im Folgenden finden Sie die Syntax zum Erstellen einer Verbindung in Clojure.

(def connection_name {
   :subprotocol “protocol_name”
   :subname “Location of mysql DB”
   :user “username” :password “password” })

Parameters- 'Verbindungsname' ist der Name, der der Verbindung gegeben werden soll. 'Unterprotokoll' ist das Protokoll, das für die Verbindung verwendet werden soll. Standardmäßig verwenden wir das MySQL-Protokoll. 'subname' ist die URL, über die zusammen mit dem Datenbanknamen eine Verbindung zur MySQL-Datenbank hergestellt werden soll. 'Benutzer' ist der Benutzername, mit dem eine Verbindung zur Datenbank hergestellt wird. 'Passwort' ist das Passwort, mit dem eine Verbindung zur Datenbank hergestellt wird.

Return Value - Dadurch wird eine Verbindungszeichenfolge bereitgestellt, die in nachfolgenden MySQL-Operationen verwendet werden kann.

Das folgende Beispiel zeigt, wie Sie eine Verbindung zu den Tabellen im Informationsschema herstellen und alle Daten in der Tabelle abrufen.

Beispiel

(ns test.core
   (:require [clojure.java.jdbc :as sql]))
(defn -main []
   (def mysql-db {
      :subprotocol "mysql"
      :subname "//127.0.0.1:3306/information_schema"
      :user "root"
      :password "shakinstev"})
   (println (sql/query mysql-db
      ["select table_name from tables"]
      :row-fn :table_name)))

Daten abfragen

Das Abfragen von Daten in einer beliebigen Datenbank bedeutet, einige nützliche Informationen aus der Datenbank abzurufen. Sobald eine Datenbankverbindung hergestellt ist, können Sie eine Abfrage in dieser Datenbank durchführen. Es folgt die Syntax, mit der Daten mit Clojure abgefragt werden können.

Syntax

clojure.java.jdbc/query dbconn
["query"]
   :row-fn :sequence

Parameters- 'dbconn' ist der Name der Verbindung, über die eine Verbindung zur Datenbank hergestellt wird. 'query' ist die Abfragezeichenfolge, mit der Daten aus der Datenbank abgerufen werden. ': sequence' sind standardmäßig alle aus der Datenbank abgerufenen Datenzeilen und werden als Sequenz zurückgegeben. Die erforderlichen Operationen an der Sequenz können dann ausgeführt werden, um zu sehen, welche Daten abgerufen wurden.

Return Value - Dies gibt eine Sequenz zurück, die die Datenzeilen der Abfrageoperation enthält.

Das folgende Beispiel zeigt, wie Sie eine Verbindung zur Mitarbeitertabelle herstellen und die Spalte Vorname der Zeilen in der Tabelle abrufen.

Beispiel

(ns test.core
   (:require [clojure.java.jdbc :as sql]))
(defn -main []
   (def mysql-db {
      :subprotocol "mysql"
      :subname "//127.0.0.1:3306/testdb"
      :user "root"
      :password "shakinstev"})
   (println (sql/query mysql-db
      ["select first_name from employee"]
      :row-fn :first_name)))

Aus dem obigen Code können wir das sehen

• Die Abfrage "Vorname vom Mitarbeiter auswählen" wird als Abfragezeichenfolge übergeben.

• Der: first_name ist die Sequenz, die als Ergebnis der Abrufoperation zurückgegeben wird.

Wenn wir davon ausgehen, dass unsere Datenbank nur eine Zeile enthält, die den Wert first_name von John enthält, folgt die Ausgabe des obigen Programms.

(John)

Daten einfügen

Dies ist erforderlich, wenn Sie Ihre Datensätze in einer Datenbanktabelle erstellen möchten. Es folgt die Syntax, mit der Daten mit Clojure eingefügt werden können. Dies geschieht mit dem‘insert!’ Funktion.

Syntax

clojure.java.jdbc/insert!
   :table_name {:column_namen columnvalue}

Parameters- ': table_name' ist der Name der Tabelle, in die eingefügt werden muss. '{: column_namen columnvalue}' ist eine Zuordnung aller Spaltennamen und -werte, die als Zeile in die Tabelle eingefügt werden müssen.

Return Value - Dies gibt null zurück, wenn das Einfügen erfolgreich durchgeführt wurde.

Das folgende Beispiel zeigt, wie ein Datensatz in die Mitarbeitertabelle in der testdb-Datenbank eingefügt wird.

Beispiel

(ns test.core
   (:require [clojure.java.jdbc :as sql]))
(defn -main []
   (def mysql-db {
      :subprotocol "mysql"
      :subname "//127.0.0.1:3306/testdb"
      :user "root"
      :password "shakinstev"})
   (sql/insert! mysql-db
      :employee {:first_name "John" :last_name "Mark" :sex "M" :age 30 :income 30}))

Wenn Sie jetzt Ihre MySQL-Datenbank und die Mitarbeitertabelle überprüfen, werden Sie feststellen, dass die obige Zeile erfolgreich in die Tabelle eingefügt wurde.

Daten löschen

Zeilen können mit der Taste aus einer Tabelle gelöscht werden ‘delete!’Funktion. Im Folgenden finden Sie die Syntax, wie diese Operation ausgeführt werden kann.

Syntax

clojure.java.jdbc/delete!
   :table_name [condition]

Parameters- ': table_name' ist der Name der Tabelle, in die eingefügt werden muss. 'Bedingung' ist die Bedingung, mit der bestimmt wird, welche Zeile aus der Tabelle gelöscht werden muss.

Return Value - Dies gibt die Anzahl der gelöschten Zeilen zurück.

Das folgende Beispiel zeigt, wie Sie einen Datensatz aus der Mitarbeitertabelle in der testdb-Datenbank löschen. In diesem Beispiel wird eine Zeile aus der Tabelle gelöscht, basierend auf der Bedingung, dass das Alter 30 Jahre beträgt.

Beispiel

(ns test.core
   (:require [clojure.java.jdbc :as sql]))
(defn -main []
   (def mysql-db {
      :subprotocol "mysql"
      :subname "//127.0.0.1:3306/testdb"
      :user "root"
      :password "shakinstev"})
   (println (sql/delete! mysql-db
      :employee ["age = ? " 30])))

Wenn Sie einen Datensatz mit einer Zeile hatten, deren Alter dem Wert 30 entspricht, wird diese Zeile gelöscht.

Daten aktualisieren

Zeilen können mithilfe der Tabelle aus einer Tabelle aktualisiert werden ‘update!’Funktion. Im Folgenden finden Sie die Syntax, wie diese Operation ausgeführt werden kann.

Syntax

clojure.java.jdbc/update!
   :table_name
{setcondition}
[condition]

Parameters- ': table_name' ist der Name der Tabelle, in die eingefügt werden muss. 'setcondition' ist die Spalte, die wie in einer Karte angegeben aktualisiert werden muss. 'Bedingung' ist die Bedingung, mit der bestimmt wird, welche Zeile aus der Tabelle gelöscht werden muss.

Return Value - Dies gibt die Anzahl der aktualisierten Zeilen zurück.

Das folgende Beispiel zeigt, wie ein Datensatz aus der Mitarbeitertabelle in der testdb-Datenbank gelöscht wird. Das Beispiel aktualisiert eine Zeile aus der Tabelle basierend auf der Bedingung, dass das Alter 30 Jahre beträgt, und aktualisiert den Wert des Einkommens auf 40 Jahre.

(ns test.core
   (:require [clojure.java.jdbc :as sql]))
(defn -main []
   (def mysql-db {
      :subprotocol "mysql"
      :subname "//127.0.0.1:3306/testdb"
      :user "root"
      :password "shakinstev"})
   (println (sql/update! mysql-db
      :employee
      {:income 40}
      ["age = ? " 30])))

Wenn Sie einen Datensatz mit einer Zeile hatten, deren Alter dem Wert 30 entspricht, wird diese Zeile aktualisiert, wobei der Wert des Einkommens auf 40 festgelegt wird.

Transaktionen

Transaktionen sind Mechanismen, die die Datenkonsistenz gewährleisten. Transaktionen haben die folgenden vier Eigenschaften:

• Atomicity - Entweder wird eine Transaktion abgeschlossen oder es passiert überhaupt nichts.

• Consistency - Eine Transaktion muss in einem konsistenten Zustand beginnen und das System in einem konsistenten Zustand belassen.

• Isolation - Zwischenergebnisse einer Transaktion sind außerhalb der aktuellen Transaktion nicht sichtbar.

• Durability - Sobald eine Transaktion festgeschrieben wurde, bleiben die Auswirkungen auch nach einem Systemausfall bestehen.

Beispiel

Das folgende Beispiel zeigt, wie Transaktionen in Clojure implementiert werden. Alle Operationen, die in einer Transaktion ausgeführt werden müssen, müssen in die eingebettet werden‘with-dbtransaction’ Klausel.

(ns test.core
   (:require [clojure.java.jdbc :as sql]))
(defn -main []
   (def mysql-db {
      :subprotocol "mysql"
      :subname "//127.0.0.1:3306/testdb"
      :user "root"
      :password "shakinstev"})
   (sql/with-db-transaction [t-con mysql-db]
      (sql/update! t-con
         :employee
         {:income 40}
         ["age = ? " 30])))