Groovy - Base de datos

El módulo groovy-sql de Groovy proporciona una abstracción de nivel superior sobre la tecnología JDBC de Java actual. Groovy sql API admite una amplia variedad de bases de datos, algunas de las cuales se muestran a continuación.

HSQLDB
Oracle
servidor SQL
MySQL
MongoDB

En nuestro ejemplo, usaremos MySQL DB como ejemplo. Para usar MySQL con Groovy, lo primero que debe hacer es descargar el archivo jar jdbc de MySQL desde el sitio mysql.The format de MySQL se mostrará a continuación.

mysql-connector-java-5.1.38-bin

Luego, asegúrese de agregar el archivo jar anterior a la ruta de clase en su estación de trabajo.

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

El siguiente ejemplo muestra cómo conectarse con la base de datos 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()  
   } 
}

Mientras ejecuta este script, produce el siguiente resultado:

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

Crear tabla de base de datos

El siguiente paso después de conectarse a la base de datos es crear las tablas en nuestra base de datos. El siguiente ejemplo muestra cómo crear una tabla en la base de datos usando Groovy. El método de ejecución de la clase Sql se utiliza para ejecutar declaraciones en la base de datos.

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

Insertar operación

Es necesario cuando desea crear sus registros en una tabla de base de datos.

Ejemplo

El siguiente ejemplo insertará un registro en la tabla de empleados. El código se coloca en un bloque try catch para que, si el registro se ejecuta correctamente, la transacción se confirme en la base de datos. Si la transacción falla, se realiza una reversión.

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

Supongamos que solo desea seleccionar ciertas filas según un criterio. El siguiente código muestra cómo puede agregar un marcador de posición de parámetro para buscar valores. El ejemplo anterior también se puede escribir para incluir parámetros como se muestra en el siguiente código. El símbolo $ se usa para definir un parámetro que luego puede ser reemplazado por valores cuando se ejecuta la instrucción sql.

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

Operación LEER

READ Operar en cualquier base de datos significa obtener información útil de la base de datos. Una vez que se establezca nuestra conexión de base de datos, estará listo para realizar una consulta en esta base de datos.

La operación de lectura se realiza utilizando el método eachRow de la clase sql.

Sintaxis

eachRow(GString gstring, Closure closure)

Realiza la consulta SQL dada llamando al Closure dado con cada fila del conjunto de resultados.

Parameters

Gstring - La instrucción sql que debe ejecutarse.
Closure- La declaración de cierre para procesar las filas recuperadas de la operación de lectura. Realiza la consulta SQL dada llamando al Closure dado con cada fila del conjunto de resultados.

El siguiente ejemplo de código muestra cómo recuperar todos los registros de la tabla de empleados.

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

La salida del programa anterior sería:

[Mac, Mohan, 20, M, 2000.0]

Operación de actualización

ACTUALIZAR Operar en cualquier base de datos significa actualizar uno o más registros, que ya están disponibles en la base de datos. El siguiente procedimiento actualiza todos los registros que tienen SEXO como 'M'. Aquí, aumentamos la EDAD de todos los machos en un año.

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', 
         '[email protected]', '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()
   } 
}

Operación DELETE

La operación DELETE es necesaria cuando desea eliminar algunos registros de su base de datos. A continuación se muestra el procedimiento para eliminar todos los registros de EMPLEADO donde la EDAD es mayor de 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', 
         '[email protected]', '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()
   } 
}

Realización de transacciones

Las transacciones son un mecanismo que garantiza 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.

A continuación, se muestra un ejemplo sencillo de cómo implementar transacciones. Ya hemos visto este ejemplo de nuestro tema anterior de la operación 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 operación

La operación de confirmación es lo que le dice a la base de datos que proceda con la operación y finalice todos los cambios en la base de datos.

En nuestro ejemplo anterior, esto se logra mediante la siguiente declaración:

sql.commit()

Operación de reversión

Si no está satisfecho con uno o más de los cambios y desea revertirlos por completo, utilice el método de reversión. En nuestro ejemplo anterior, esto se logra mediante la siguiente declaración:

sql.rollback()

Desconectar bases de datos

Para desconectar la conexión de la base de datos, utilice el método de cierre.

sql.close()

↰ Previous page Next page ↱