Groovy - Database

Il modulo groovy-sql di Groovy fornisce un'astrazione di livello superiore rispetto all'attuale tecnologia JDBC di Java. L'API Groovy sql supporta un'ampia varietà di database, alcuni dei quali sono mostrati di seguito.

HSQLDB
Oracle
server SQL
MySQL
MongoDB

Nel nostro esempio, useremo MySQL DB come esempio. Per utilizzare MySQL con Groovy, la prima cosa da fare è scaricare il file jar jdbc di MySQL dal sito mysql.The format di MySQL verrà mostrato di seguito.

mysql-connector-java-5.1.38-bin

Quindi assicurati di aggiungere il file jar sopra al classpath nella tua workstation.

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 averlo aggiunto al tuo classpath.
Hai seguito il tutorial di MySQL per comprendere le basi di MySQL

Il seguente esempio mostra come connettersi al database 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()  
   } 
}

Durante l'esecuzione di questo script, produce il seguente risultato:

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

Creazione della tabella del database

Il passaggio successivo dopo la connessione al database è creare le tabelle nel nostro database. L'esempio seguente mostra come creare una tabella nel database utilizzando Groovy. Il metodo di esecuzione della classe Sql viene utilizzato per eseguire istruzioni sul database.

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

Inserisci operazione

È necessario quando si desidera creare i record in una tabella di database.

Esempio

Il seguente esempio inserirà un record nella tabella dei dipendenti. Il codice viene inserito in un blocco try catch in modo che, se il record viene eseguito correttamente, la transazione viene salvata nel database. Se la transazione fallisce, viene eseguito un rollback.

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

Supponiamo di voler selezionare solo determinate righe in base a un criterio. Il codice seguente mostra come aggiungere un segnaposto di parametro per cercare i valori. L'esempio precedente può anche essere scritto per accettare i parametri come mostrato nel codice seguente. Il simbolo $ viene utilizzato per definire un parametro che può quindi essere sostituito da valori quando viene eseguita l'istruzione 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()
   }
}

Operazione READ

READ Operare su qualsiasi database significa prelevare alcune informazioni utili dal database. Una volta stabilita la connessione al database, sei pronto per eseguire una query in questo database.

L'operazione di lettura viene eseguita utilizzando il metodo eachRow della classe sql.

Sintassi

eachRow(GString gstring, Closure closure)

Esegue la query SQL specificata chiamando il Closure specificato con ogni riga del set di risultati.

Parameters

Gstring - L'istruzione sql che deve essere eseguita.
Closure- L'istruzione di chiusura per elaborare le righe recuperate dall'operazione di lettura. Esegue la query SQL specificata chiamando il Closure specificato con ogni riga del set di risultati.

Il seguente esempio di codice mostra come recuperare tutti i record dalla tabella Employee.

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

L'output del programma precedente sarebbe:

[Mac, Mohan, 20, M, 2000.0]

Operazione di aggiornamento

AGGIORNAMENTO Operare su qualsiasi database significa aggiornare uno o più record, già disponibili nel database. La seguente procedura aggiorna tutti i record che hanno SEX come "M". Qui, aumentiamo l'ETÀ di tutti i maschi di un anno.

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

Operazione DELETE

L'operazione DELETE è necessaria quando si desidera eliminare alcuni record dal database. Di seguito è riportata la procedura per eliminare tutti i record da DIPENDENTE di cui ETÀ è superiore a 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()
   } 
}

Esecuzione di transazioni

Le transazioni sono un meccanismo che garantisce 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.

Ecco un semplice esempio di come implementare le transazioni. Abbiamo già visto questo esempio dal nostro argomento precedente dell'operazione 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()

Commit Operation

L'operazione di commit è ciò che dice al database di procedere con l'operazione e finalizzare tutte le modifiche al database.

Nel nostro esempio sopra, ciò si ottiene con la seguente dichiarazione:

sql.commit()

Operazione di rollback

Se non sei soddisfatto di una o più modifiche e desideri ripristinarle completamente, utilizza il metodo di rollback. Nel nostro esempio sopra, ciò si ottiene con la seguente dichiarazione:

sql.rollback()

Disconnessione dei database

Per disconnettere la connessione al database, utilizzare il metodo di chiusura.

sql.close()

↰ Previous page Next page ↱