Groovy - Banco de dados

O módulo groovy-sql do Groovy fornece uma abstração de alto nível sobre a tecnologia JDBC do Java atual. A API Groovy sql suporta uma grande variedade de bancos de dados, alguns dos quais são mostrados abaixo.

  • HSQLDB
  • Oracle
  • servidor SQL
  • MySQL
  • MongoDB

Em nosso exemplo, usaremos o banco de dados MySQL como exemplo. Para usar o MySQL com Groovy, a primeira coisa a fazer é baixar o arquivo jar jdbc do MySQL do site mysql.The format do MySQL será mostrado abaixo.

mysql-connector-java-5.1.38-bin

Em seguida, certifique-se de adicionar o arquivo jar acima ao classpath em sua estação de trabalho.

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

O exemplo a seguir mostra como se conectar ao banco de dados MySQL "TESTDB".

import java.sql.*; 
import groovy.sql.Sql 

class Example {
   static void main(String[] args) {
      // Creating a connection to the database
      def sql = Sql.newInstance('jdbc:mysql://localhost:3306/TESTDB', 
         'testuser', 'test123', 'com.mysql.jdbc.Driver')
			
      // Executing the query SELECT VERSION which gets the version of the database
      // Also using the eachROW method to fetch the result from the database
   
      sql.eachRow('SELECT VERSION()'){ row ->
         println row[0]
      }
		
      sql.close()  
   } 
}

Ao executar este script, ele está produzindo o seguinte resultado -

5.7.10-log 
The Sql.newInstance method is used to establish a connection to the database.

Criando Tabela de Banco de Dados

A próxima etapa após conectar-se ao banco de dados é criar as tabelas em nosso banco de dados. O exemplo a seguir mostra como criar uma tabela no banco de dados usando Groovy. O método execute da classe Sql é usado para executar instruções no banco de dados.

import java.sql.*; 
import groovy.sql.Sql 

class Example { 
   static void main(String[] args) {
      // Creating a connection to the database
      def sql = Sql.newInstance('jdbc:mysql://localhost:3306/TESTDB', 'testuser',  
         'test123', 'com.mysql.jdbc.Driver')
			
      def sqlstr = """CREATE TABLE EMPLOYEE ( 
         FIRST_NAME CHAR(20) NOT NULL,
         LAST_NAME CHAR(20),
         AGE INT,
         SEX CHAR(1),
         INCOME FLOAT )""" 
							
      sql.execute(sqlstr);
      sql.close() 
   } 
}

Operação de inserção

É necessário quando você deseja criar seus registros em uma tabela de banco de dados.

Exemplo

O exemplo a seguir irá inserir um registro na tabela de funcionários. O código é colocado em um bloco try catch para que, se o registro for executado com sucesso, a transação seja confirmada no banco de dados. Se a transação falhar, um rollback é feito.

import java.sql.*; 
import groovy.sql.Sql 

class Example {
   static void main(String[] args) { 
      // Creating a connection to the database
      def sql = Sql.newInstance('jdbc:mysql://localhost:3306/TESTDB', 'testuser', 
         'test123', 'com.mysql.jdbc.Driver')
			
      sql.connection.autoCommit = false
		
      def sqlstr = """INSERT INTO EMPLOYEE(FIRST_NAME,
         LAST_NAME, AGE, SEX, INCOME) VALUES ('Mac', 'Mohan', 20, 'M', 2000)""" 
      try {
         sql.execute(sqlstr);
         sql.commit()
         println("Successfully committed") 
      }catch(Exception ex) {
         sql.rollback()
         println("Transaction rollback") 
      }
		
      sql.close()
   } 
}

Suponha que você queira apenas selecionar certas linhas com base em um critério. O código a seguir mostra como você pode adicionar um marcador de posição de parâmetro para pesquisar valores. O exemplo acima também pode ser escrito para receber parâmetros conforme mostrado no código a seguir. O símbolo $ é usado para definir um parâmetro que pode ser substituído por valores quando a instrução sql é executada.

import java.sql.*; 
import groovy.sql.Sql
 
class Example {
   static void main(String[] args) {
      // Creating a connection to the database
      def sql = Sql.newInstance('jdbc:mysql://localhost:3306/TESTDB', 'testuser', 
         'test123', 'com.mysql.jdbc.Driver')
			
      sql.connection.autoCommit = false  
      
      def firstname = "Mac"
      def lastname ="Mohan"
      def age = 20
      def sex = "M"
      def income = 2000  
		
      def sqlstr = "INSERT INTO EMPLOYEE(FIRST_NAME,LAST_NAME, AGE, SEX, 
         INCOME) VALUES " + "(${firstname}, ${lastname}, ${age}, ${sex}, ${income} )"
			
      try {
         sql.execute(sqlstr);
         sql.commit()
         println("Successfully committed") 
      } catch(Exception ex) {
         sql.rollback()
         println("Transaction rollback")
      }
		
      sql.close()
   }
}

Operação READ

A operação READ em qualquer banco de dados significa buscar algumas informações úteis do banco de dados. Assim que nossa conexão com o banco de dados for estabelecida, você estará pronto para fazer uma consulta a este banco de dados.

A operação de leitura é executada usando o método eachRow da classe sql.

Sintaxe

eachRow(GString gstring, Closure closure)

Executa a consulta SQL fornecida chamando o Closure fornecido com cada linha do conjunto de resultados.

Parameters

  • Gstring - A instrução sql que precisa ser executada.

  • Closure- A instrução de encerramento para processar as linhas recuperadas da operação de leitura. Executa a consulta SQL fornecida chamando o Closure fornecido com cada linha do conjunto de resultados.

O exemplo de código a seguir mostra como buscar todos os registros da tabela de funcionários.

import java.sql.*; 
import groovy.sql.Sql
 
class Example {
   static void main(String[] args) {
      // Creating a connection to the database
      def sql = Sql.newInstance('jdbc:mysql://localhost:3306/TESTDB', 'testuser', 
         'test123', 'com.mysql.jdbc.Driver')  
			
      sql.eachRow('select * from employee') {
         tp -> 
         println([tp.FIRST_NAME,tp.LAST_NAME,tp.age,tp.sex,tp.INCOME])
      }  
		
      sql.close()
   } 
}

A saída do programa acima seria -

[Mac, Mohan, 20, M, 2000.0]

Operação de atualização

ATUALIZAR Operação em qualquer banco de dados significa atualizar um ou mais registros, que já estão disponíveis no banco de dados. O procedimento a seguir atualiza todos os registros que têm SEXO como 'M'. Aqui, aumentamos a IDADE de todos os homens em um ano.

import java.sql.*; 
import groovy.sql.Sql 

class Example {
   static void main(String[] args){
      // Creating a connection to the database
      def sql = Sql.newInstance('jdbc:mysql://localhost:3306/TESTDB', 'testuser', 
         'test@123', 'com.mysql.jdbc.Driver')
			
      sql.connection.autoCommit = false
      def sqlstr = "UPDATE EMPLOYEE SET AGE = AGE + 1 WHERE SEX = 'M'" 
	  
      try {
         sql.execute(sqlstr);
         sql.commit()
         println("Successfully committed")
      }catch(Exception ex) {
         sql.rollback() 
         println("Transaction rollback")
      }
		
      sql.close()
   } 
}

Operação DELETE

A operação DELETE é necessária quando você deseja excluir alguns registros de seu banco de dados. A seguir está o procedimento para excluir todos os registros de EMPLOYEE onde AGE é maior que 20.

import java.sql.*; 
import groovy.sql.Sql 

class Example {
   static void main(String[] args) {
      // Creating a connection to the database
      def sql = Sql.newInstance('jdbc:mysql://localhost:3306/TESTDB', 'testuser', 
         'test@123', 'com.mysql.jdbc.Driver')
			
      sql.connection.autoCommit = false
      def sqlstr = "DELETE FROM EMPLOYEE WHERE AGE > 20"
   
      try {
         sql.execute(sqlstr);
         sql.commit()
         println("Successfully committed")
      }catch(Exception ex) {
         sql.rollback()
         println("Transaction rollback")
      }
   
      sql.close()
   } 
}

Realizando transações

As transações são um mecanismo que garante 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.

Aqui está um exemplo simples de como implementar transações. Já vimos este exemplo de nosso tópico anterior da operação DELETE.

def sqlstr = "DELETE FROM EMPLOYEE WHERE AGE > 20" 
 
try {
   sql.execute(sqlstr); 
   sql.commit()
   println("Successfully committed") 
}catch(Exception ex) {
   sql.rollback()
   println("Transaction rollback") 
} 
sql.close()

Confirmar operação

A operação de confirmação é o que diz ao banco de dados para prosseguir com a operação e finalizar todas as alterações no banco de dados.

Em nosso exemplo acima, isso é obtido pela seguinte declaração -

sql.commit()

Operação de reversão

Se você não estiver satisfeito com uma ou mais das alterações e quiser reverter essas alterações completamente, use o método de reversão. Em nosso exemplo acima, isso é obtido pela seguinte declaração -

sql.rollback()

Desconectando bancos de dados

Para desconectar a conexão do banco de dados, use o método close.

sql.close()
ja/tutorial
es/tutorial
de/tutorial
fr/tutorial
th/tutorial
pt/tutorial
ru/tutorial
vi/tutorial
it/tutorial
ko/tutorial
tr/tutorial
id/tutorial
pl/tutorial
hi/tutorial
japost
espost
depost
frpost
thpost
ptpost
rupost
vipost
itpost
kopost
trpost
idpost
plpost
hipost

© Copyright 2021 - 2024 | All Rights Reserved