Clojure - Bancos de dados

Para usar a funcionalidade de banco de dados, certifique-se de primeiro fazer o download do jdbc files do seguinte url - https://codeload.github.com/clojure/java.jdbc/zip/master

Você encontrará um arquivo zip que contém os drivers necessários para que o Clojure possa se conectar aos bancos de dados. Depois que o arquivo zip for extraído, certifique-se de adicionar o local descompactado ao seu classpath.

O arquivo principal para conectividade de banco de dados é um arquivo chamado jdbc.clj no local clojure / java.

O conector clojure jdbc suporta uma grande variedade de bancos de dados, alguns dos quais são os seguintes.

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

Em nosso exemplo, usaremos o banco de dados MySQL como exemplo.

As seguintes operações são possíveis no Clojure com relação aos bancos de dados.

Conexão de banco de dados

Antes de se conectar a um banco de dados MySQL, certifique-se do seguinte -

  • Você criou um banco de dados TESTDB.

  • Você criou uma tabela EMPLOYEE em TESTDB.

  • Esta tabela contém os campos FIRST_NAME, LAST_NAME, AGE, SEX e INCOME.

  • O ID do usuário "testuser" e a senha "test123" são definidos para acessar o TESTDB.

  • Certifique-se de ter baixado o 'arquivo jar mysql' e adicionado o arquivo ao seu classpath.

  • Você passou pelo tutorial do MySQL para entender os fundamentos do MySQL .

Sintaxe

A seguir está a sintaxe para criar uma conexão no Clojure.

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

Parameters- 'connection_name' é o nome a ser dado à conexão. 'subprotocol' é o protocolo a ser usado para a conexão. Por padrão, usaremos o protocolo mysql. 'subname' é a url para conectar ao banco de dados mysql junto com o nome do banco de dados. 'usuário' é o nome de usuário usado para se conectar ao banco de dados. 'senha' é a senha a ser usada para conectar ao banco de dados.

Return Value - Isso fornecerá uma string de conexão, que pode ser usada em operações subsequentes do mysql.

O exemplo a seguir mostra como se conectar às tabelas no esquema de informações e recuperar todos os dados da tabela.

Exemplo

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

Consultando dados

Consultar dados em qualquer banco de dados significa buscar algumas informações úteis do banco de dados. Assim que uma conexão de banco de dados for estabelecida, você estará pronto para fazer uma consulta a esse banco de dados. A seguir está a sintaxe pela qual os dados podem ser consultados usando Clojure.

Sintaxe

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

Parameters- 'dbconn' é o nome da conexão usada para conectar ao banco de dados. 'consulta' é a string de consulta usada para buscar dados do banco de dados. ': sequência' é, por padrão, todas as linhas de dados buscadas no banco de dados e é retornado como uma sequência. As operações necessárias na sequência podem então ser feitas para ver quais dados foram buscados.

Return Value - Isso retornará uma sequência, que terá as linhas de dados da operação de consulta.

O exemplo a seguir mostra como se conectar à tabela de funcionários e buscar a coluna first_name das linhas da tabela.

Exemplo

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

Pelo código acima, podemos ver que

  • A consulta de “selecionar o nome do funcionário” é passada como string de consulta.

  • O: first_name é a sequência, que é retornada como resultado da operação de busca.

Se assumirmos que há apenas uma linha em nosso banco de dados que contém um valor first_name de John, a seguir será a saída do programa acima.

(John)

Inserindo Dados

É necessário quando você deseja criar seus registros em uma tabela de banco de dados. A seguir está a sintaxe pela qual os dados podem ser inseridos usando Clojure. Isso é feito usando o‘insert!’ função.

Sintaxe

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

Parameters- ': table_name' é o nome da tabela em que a inserção deve ser feita. '{: column_namen columnvalue}' é um mapa de todos os nomes e valores de coluna, que precisam ser adicionados como uma linha na tabela.

Return Value - Isso retornará nulo se a inserção for feita com sucesso.

O exemplo a seguir mostra como inserir um registro na tabela de funcionários no banco de dados testdb.

Exemplo

(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 você verificar agora seu banco de dados MySQL e a tabela de funcionários, verá que a linha acima será inserida com êxito na tabela.

Excluindo Dados

As linhas podem ser excluídas de uma tabela usando o ‘delete!’função. A seguir está a sintaxe de como essa operação pode ser executada.

Sintaxe

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

Parameters- ': table_name' é o nome da tabela em que a inserção deve ser feita. 'condição' é a condição usada para determinar qual linha precisa ser excluída da tabela.

Return Value - Isso retornará o número de linhas excluídas.

O exemplo a seguir mostra como excluir um registro da tabela de funcionários no banco de dados testdb. O exemplo exclui uma linha da tabela com base na condição de que a idade seja igual a 30.

Exemplo

(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 você tinha um registro com uma linha com idade igual ao valor 30, essa linha será excluída.

Atualizando Dados

As linhas podem ser atualizadas a partir de uma tabela usando o ‘update!’função. A seguir está a sintaxe de como essa operação pode ser executada.

Sintaxe

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

Parameters- ': table_name' é o nome da tabela em que a inserção deve ser feita. 'setcondition' é a coluna que precisa ser atualizada conforme mencionado em termos de um mapa. 'condição' é a condição que é usada para determinar qual linha precisa ser excluída da tabela.

Return Value - Isso retornará o número de linhas atualizadas.

O exemplo a seguir mostra como excluir um registro da tabela de funcionários no banco de dados testdb. O exemplo atualiza uma linha da tabela com base na condição de que a idade seja igual a 30 e atualiza o valor da renda para 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 você tivesse um registro com uma linha com idade igual ao valor 30, essa linha será atualizada e o valor da renda será definido como 40.

Transações

As transações são mecanismos que garantem a consistência dos dados. As transações têm as seguintes quatro propriedades -

  • Atomicity - Ou uma transação é concluída ou nada acontece.

  • Consistency - Uma transação deve começar em um estado consistente e deixar o sistema em um estado consistente.

  • Isolation - Os resultados intermediários de uma transação não são visíveis fora da transação atual.

  • Durability - Depois que uma transação foi confirmada, os efeitos são persistentes, mesmo após uma falha do sistema.

Exemplo

O exemplo a seguir mostra como implementar transações em Clojure. Todas as operações que precisam ser realizadas em uma transação precisam ser incorporadas no‘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])))