Clojure - Bases de datos

Para utilizar la funcionalidad de la base de datos, asegúrese de descargar primero el jdbc files de la siguiente URL: https://codeload.github.com/clojure/java.jdbc/zip/master

Encontrará un archivo zip que tiene los controladores necesarios para que Clojure tenga la capacidad de conectarse a bases de datos. Una vez que se extrae el archivo zip, asegúrese de agregar la ubicación descomprimida a su classpath.

El archivo principal para la conectividad de la base de datos es un archivo llamado jdbc.clj en la ubicación clojure / java.

El conector clojure jdbc admite una amplia variedad de bases de datos, algunas de las cuales son las siguientes.

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

En nuestro ejemplo, usaremos MySQL DB como ejemplo.

Las siguientes operaciones son posibles en Clojure con respecto a las bases de datos.

Conexión de base de datos

Antes de conectarse a una base de datos MySQL, asegúrese de lo siguiente:

  • Ha creado una base de datos TESTDB.

  • Ha creado una tabla EMPLOYEE en TESTDB.

  • Esta tabla tiene campos FIRST_NAME, APELLIDO, EDAD, SEXO e INGRESOS.

  • El ID de usuario "testuser" y la contraseña "test123" están configurados para acceder a TESTDB.

  • Asegúrese de haber descargado el 'archivo jar mysql' y agregado el archivo a su classpath.

  • Ha seguido el tutorial de MySQL para comprender los conceptos básicos de MySQL .

Sintaxis

A continuación se muestra la sintaxis para crear una conexión en Clojure.

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

Parameters- 'nombre_conexión' es el nombre que se le dará a la conexión. 'subprotocol' es el protocolo que se utilizará para la conexión. Por defecto usaremos el protocolo mysql. 'subname' es la URL para conectarse a la base de datos mysql junto con el nombre de la base de datos. 'usuario' es el nombre de usuario utilizado para conectarse a la base de datos. 'contraseña' es la contraseña que se utilizará para conectarse a la base de datos.

Return Value - Esto proporcionará una cadena de conexión, que se puede utilizar en operaciones subsiguientes de mysql.

El siguiente ejemplo muestra cómo conectarse a las tablas en el esquema de información y recuperar todos los datos de la tabla.

Ejemplo

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

Consulta de datos

Consultar datos en cualquier base de datos significa obtener información útil de la base de datos. Una vez que se establece una conexión a la base de datos, está listo para realizar una consulta en esta base de datos. A continuación se muestra la sintaxis mediante la cual se pueden consultar los datos usando Clojure.

Sintaxis

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

Parameters- 'dbconn' es el nombre de la conexión utilizada para conectarse a la base de datos. 'consulta' es la cadena de consulta utilizada para obtener datos de la base de datos. ': secuencia' es por defecto todas las filas de datos extraídas de la base de datos y se devuelve como una secuencia. A continuación, se pueden realizar las operaciones necesarias en la secuencia para ver qué datos se han obtenido.

Return Value - Esto devolverá una secuencia, que tendrá las filas de datos de la operación de consulta.

El siguiente ejemplo muestra cómo conectarse a la tabla de empleados y obtener la columna first_name de las filas de la tabla.

Ejemplo

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

En el código anterior, podemos ver que

  • La consulta de "seleccionar el primer nombre del empleado" se pasa como la cadena de consulta.

  • : First_name es la secuencia, que se devuelve como resultado de la operación de búsqueda.

Si asumimos que solo hay una fila en nuestra base de datos que contiene un valor de nombre de pila de John, la siguiente será la salida del programa anterior.

(John)

Insertar datos

Es necesario cuando desea crear sus registros en una tabla de base de datos. A continuación se muestra la sintaxis mediante la cual se pueden insertar datos usando Clojure. Esto se hace usando el‘insert!’ función.

Sintaxis

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

Parameters- ': table_name' es el nombre de la tabla en la que se debe realizar la inserción. '{: column_namen columnvalue}' es un mapa de todos los nombres y valores de las columnas, que deben agregarse como una fila en la tabla.

Return Value - Esto devolverá nil si la inserción se realiza correctamente.

El siguiente ejemplo muestra cómo insertar un registro en la tabla de empleados en la base de datos testdb.

Ejemplo

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

Si ahora verifica su base de datos MySQL y la tabla de empleados, verá que la fila anterior se insertará correctamente en la tabla.

Eliminar datos

Las filas se pueden eliminar de una tabla usando el ‘delete!’función. A continuación se muestra la sintaxis sobre cómo se puede realizar esta operación.

Sintaxis

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

Parameters- ': table_name' es el nombre de la tabla en la que se debe realizar la inserción. 'condición' es la condición que se usa para determinar qué fila debe eliminarse de la tabla.

Return Value - Esto devolverá el número de filas eliminadas.

El siguiente ejemplo muestra cómo eliminar un registro de la tabla de empleados en la base de datos testdb. El ejemplo elimina una fila de la tabla según la condición de que la edad sea igual a 30.

Ejemplo

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

Si tenía un registro que tenía una fila con una edad igual al valor de 30, esa fila se eliminará.

Actualización de datos

Las filas se pueden actualizar desde una tabla usando el ‘update!’función. A continuación se muestra la sintaxis sobre cómo se puede realizar esta operación.

Sintaxis

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

Parameters- ': table_name' es el nombre de la tabla en la que se debe realizar la inserción. 'setcondition' es la columna que debe actualizarse como se menciona en términos de un mapa. 'condición' es la condición que se utiliza para determinar qué fila debe eliminarse de la tabla.

Return Value - Esto devolverá el número de filas actualizadas.

El siguiente ejemplo muestra cómo eliminar un registro de la tabla de empleados en la base de datos testdb. El ejemplo actualiza una fila de la tabla según la condición de que la edad sea igual a 30 y actualiza el valor de los ingresos 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])))

Si tenía un registro que tenía una fila con una edad igual al valor de 30, esa fila se actualizará y el valor de los ingresos se establecerá en 40.

Actas

Las transacciones son mecanismos que garantizan la coherencia de los datos. Las transacciones tienen las siguientes cuatro propiedades:

  • Atomicity - O se completa una transacción o no ocurre nada.

  • Consistency - Una transacción debe comenzar en un estado consistente y dejar el sistema en un estado consistente.

  • Isolation - Los resultados intermedios de una transacción no son visibles fuera de la transacción actual.

  • Durability - Una vez que se ha comprometido una transacción, los efectos son persistentes, incluso después de una falla del sistema.

Ejemplo

El siguiente ejemplo muestra cómo implementar transacciones en Clojure. Cualquier operación que deba realizarse en una transacción debe integrarse en el‘with-dbtransaction’ cláusula.

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