Clojure - Database

Per utilizzare la funzionalità del database, assicurati di scaricare prima il file jdbc files dal seguente url - https://codeload.github.com/clojure/java.jdbc/zip/master

Troverai un file zip che ha i driver necessari affinché Clojure abbia la capacità di connettersi ai database. Una volta che il file zip è stato estratto, assicurati di aggiungere la posizione decompressa al tuo classpath.

Il file principale per la connettività del database è un file chiamato jdbc.clj nella posizione clojure / java.

Il connettore clojure jdbc supporta un'ampia varietà di database, alcuni dei quali sono i seguenti.

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

Nel nostro esempio, useremo MySQL DB come esempio.

Le seguenti operazioni sono possibili in Clojure per quanto riguarda i database.

Connessione al database

Prima di connetterti a un database MySQL, assicurati di quanto segue:

• Hai creato un database TESTDB.

• Hai creato una tabella EMPLOYEE in TESTDB.

• Questa tabella ha i campi FIRST_NAME, LAST_NAME, AGE, SEX e INCOME.

• L'ID utente "testuser" e la password "test123" sono impostati per accedere a TESTDB.

• Assicurati di aver scaricato il "file jar mysql" e di aver aggiunto il file al tuo classpath.

• Hai seguito il tutorial su MySQL per comprendere le basi di MySQL .

Sintassi

Di seguito è riportata la sintassi per creare una connessione in Clojure.

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

Parameters- "connection_name" è il nome da assegnare alla connessione. 'subprotocol' è il protocollo da utilizzare per la connessione. Per impostazione predefinita utilizzeremo il protocollo mysql. 'subname' è l'URL per connettersi al database mysql insieme al nome del database. "utente" è il nome utente utilizzato per connettersi al database. 'password' è la password da utilizzare per connettersi al database.

Return Value - Questo fornirà una stringa di connessione, che può essere utilizzata nelle successive operazioni mysql.

L'esempio seguente mostra come connettersi alle tabelle nello schema delle informazioni e recuperare tutti i dati nella tabella.

Esempio

(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)))

Interrogazione dei dati

Interrogare i dati su qualsiasi database significa recuperare alcune informazioni utili dal database. Una volta stabilita una connessione al database, sei pronto per eseguire una query in questo database. Di seguito è riportata la sintassi con cui è possibile eseguire query sui dati utilizzando Clojure.

Sintassi

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

Parameters- "dbconn" è il nome della connessione utilizzata per connettersi al database. "query" è la stringa di query utilizzata per recuperare i dati dal database. ': sequenza' è per impostazione predefinita tutte le righe di dati recuperate dal database e viene restituito come sequenza. Le operazioni necessarie sulla sequenza possono quindi essere eseguite per vedere quali dati sono stati recuperati.

Return Value - Questo restituirà una sequenza, che avrà le righe di dati dall'operazione di query.

Il seguente esempio mostra come connettersi alla tabella dei dipendenti e recuperare la colonna first_name delle righe nella tabella.

Esempio

(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)))

Dal codice sopra, possiamo vederlo

• La query di "seleziona first_name da dipendente" viene passata come stringa di query.

• Il: first_name è la sequenza, che viene restituita come risultato dell'operazione di recupero.

Se assumiamo che ci sia solo una riga nel nostro database che contiene un valore first_name di John, il seguente sarà l'output del programma precedente.

(John)

Inserimento di dati

È necessario quando si desidera creare i record in una tabella di database. Di seguito è la sintassi con cui i dati possono essere inseriti utilizzando Clojure. Questo viene fatto usando il‘insert!’ funzione.

Sintassi

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

Parameters- ': table_name' è il nome della tabella in cui deve essere effettuato l'inserimento. "{: column_namen columnvalue}" è una mappa di tutti i nomi e i valori delle colonne, che devono essere aggiunti come riga nella tabella.

Return Value - Questo restituirà zero se l'inserimento viene eseguito correttamente.

L'esempio seguente mostra come inserire un record nella tabella dei dipendenti nel database testdb.

Esempio

(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}))

Se ora controlli il tuo database MySQL e la tabella dei dipendenti, vedrai che la riga sopra verrà inserita correttamente nella tabella.

Eliminazione dei dati

Le righe possono essere eliminate da una tabella utilizzando il ‘delete!’funzione. Di seguito è riportata la sintassi su come eseguire questa operazione.

Sintassi

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

Parameters- ': table_name' è il nome della tabella in cui deve essere effettuato l'inserimento. "condition" è la condizione utilizzata per determinare quale riga deve essere eliminata dalla tabella.

Return Value - Questo restituirà il numero di righe eliminate.

L'esempio seguente mostra come eliminare un record dalla tabella dei dipendenti nel database testdb. L'esempio elimina una riga dalla tabella in base alla condizione che l'età sia uguale a 30.

Esempio

(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])))

Se hai un record con una riga con età uguale al valore di 30, quella riga verrà eliminata.

Aggiornamento dei dati

Le righe possono essere aggiornate da una tabella utilizzando il ‘update!’funzione. Di seguito è riportata la sintassi su come eseguire questa operazione.

Sintassi

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

Parameters- ': table_name' è il nome della tabella in cui deve essere effettuato l'inserimento. 'setcondition' è la colonna che deve essere aggiornata come menzionato in termini di mappa. "condition" è la condizione utilizzata per determinare quale riga deve essere eliminata dalla tabella.

Return Value - Questo restituirà il numero di righe aggiornate.

L'esempio seguente mostra come eliminare un record dalla tabella dei dipendenti nel database testdb. L'esempio aggiorna una riga della tabella in base alla condizione che l'età sia uguale a 30 e aggiorna il valore del reddito a 40.

(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])))

Se avevi un record con una riga con età pari al valore di 30, quella riga verrà aggiornata in cui il valore del reddito sarà impostato a 40.

Transazioni

Le transazioni sono meccanismi che garantiscono la coerenza dei dati. Le transazioni hanno le seguenti quattro proprietà:

• Atomicity - O una transazione viene completata o non accade nulla.

• Consistency - Una transazione deve iniziare in uno stato coerente e lasciare il sistema in uno stato coerente.

• Isolation - I risultati intermedi di una transazione non sono visibili al di fuori della transazione corrente.

• Durability - Una volta che una transazione è stata confermata, gli effetti sono persistenti, anche dopo un errore di sistema.

Esempio

L'esempio seguente mostra come implementare le transazioni in Clojure. Qualsiasi operazione che deve essere eseguita in una transazione deve essere incorporata nel file‘with-dbtransaction’ clausola.

(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])))