HSQLdb

Introduction

HSQLDB est un Système de Gestion de Base de Données relationnelles écrit en Java. Il offre un moteur de base de données rapide et léger. Il supporte presque toutes les fonctions JDBC et une grande partie des standards SQL. Sa particularité vient du fait qu’il existe sous forme de SGBD embarqué. On peut donc la transporter directement avec une application. Cette base de données est déjà utilisée dans de nombreux projets (Open Office, JBoss, Hibernate), donc vous ne risquez rien à l’utiliser.

Il est très apprécié pour sa taille minuscule, sa vitesse et son habileté à être exécuté entièrement en mémoire. Cela est très pratique pour le développement d’applications. Notamment dans le cadre où l’on veut avoir des données facilement utilisables pour effectuer des tests sur la manipulation des données dans l’application.

Site Officiel

Vous trouverez le site officiel de HSQLDB à l’adresse suivante : http://hsqldb.org/

Wikipédia

Je vous invite à consulter les articles français et anglais de la célèbre encyclopédie Wikipédia à propos de HSQLDB.

Tutoriel

Avant d’entamer ce tutoriel, vérifiez que vous avez bien les prérequis :

    • Le JDK doit être installé sur votre machine.
    • Eclipse doit être installé sur votre machine (il est conseillé d’utiliser la version Eclipse IDE for Java EE Developers pour ce tutoriel).


Création du projet dans Eclipse

  • Lancer Eclipse.
  • On crée un nouveau projet. Pour cela on ouvre le menu File → New → Java Project.
  • La fenêtre de wizard apparaît alors. Nous allons simplement indiquer ici le nom du projet dans le champ Project name : sf-tutorial-hsqldb
  • On peut ensuite cliquer sur Finish. Le projet apparaît alors dans l’onglet Project Explorer qui répertorie les différents projets du workspace.


Ajout des librairies

  • Il faut télécharger la librairie HSQLDB à l’adresse : http://downloads.sourceforge.net/hsqldb/hsqldb_1_8_0_10.zip?use_mirror=
  • On va ensuite extraire le contenu de l’archive zip dans notre projet. Pour ce faire, on ouvre un explorateur de fichiers, pour accéder au workspace (sous Ubuntu il sera situé par défaut dans /home/user/workspace), on va dans le répertoire du projet, dans lequel on crée un nouveau répertoire lib qui contiendra les librairies. On extrait ensuite l’archive dedans.

Si le répertoire lib n’apparait pas dans votre projet sous Eclipse, sélectionnez votre projet et appuyez sur F5 pour rafraîchir le projet.

  • Il faut ensuite spécifier à Eclipse dans notre projet qu’on a ajouté une librairie pour pouvoir l’utiliser. On fait un clic droit sur le projet dans le package explorer qui ouvre un menu contextuel : on ouvre Build Path > Configure Build Path. On clic sur l’onglet Libraries, puis sur le bouton add JARS….Il suffit ensuite de sélectionner le fichier hsqldb.jar situé dans le répertoire lib/hsqldb/lib du projet sf-tutorial-hsqldb. On valide les modifications sur le projet en cliquant sur OK. Nous sommes maintenant prêts à débuter le code!


Création de la classe et connexion à la base de données

Nous allons créer une classe java tout ce qu’il y a de plus classique. C’est un exemple volontairement simpliste afin de se concentrer sur HSQLDB.

    • On se place sur le répertoire src du projet sf-tutorial-hsqldb, puis on fait un clic droit, New → Class.
    • La fenêtre de wizard New Java Class est normalement apparue. On indique dans le champ Package com.scub.foundation.tutorial.hsqldb et on entre dans Name le nom GestionnaireUtilisateurs puis on clique sur Finish.
    • La classe a du être créé, on va coder maintenant les premières fonctions connexionDB() qui va nous permettre de se connecter à la base de données et arretDB() qui va arrêter proprement HSQLDB. Voici le code de la classe avec des explications ci-dessous :
package com.scub.foundation.tutorial.hsqldb;
 
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
 
/**
 * Classe modélisant la gestion d'une base de données utilisateurs.
 * @author Scub-Foundation
 */
public class GestionnaireUtilisateurs {
 
	/** Service Connexion. */
	private Connection connexion;
 
	/** driver JDBC. */
	private String jdbcDriver = "org.hsqldb.jdbcDriver";
 
	/** mode mémoire. */
	private String database = "jdbc:hsqldb:mem:database";
 
	/** utilisateur qui se connecte à la base de données. */
	private String user = "sa";
 
	/** mot de passe pour se connecter à la base de données. */
	private String password = "";
 
	/**
	 * Fonction de connexion à la base de données.
	 */
	public void connexionDB() {
		try {
			// On commence par charger le driver JDBC d'HSQLDB
			Class.forName(jdbcDriver).newInstance();
		} catch (InstantiationException e) {
			System.out.println("ERROR: failed to load HSQLDB JDBC driver.");
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
 
		try {
			// Puis on se connecte à la base de données en mode mémoire
			connexion = DriverManager.getConnection(database, user, password);
		} catch (SQLException e) {
			e.printStackTrace();
		}
	}
 
	/**
	 * Arrête correctement HSQLDB.
	 * @throws SQLException SQL exception
	 */
	public void arretDB() throws SQLException {
		Statement st = connexion.createStatement();
 
		// On envoie l'instruction pour arreter proprement HSQLDB
		st.execute("SHUTDOWN");
		// On ferme la connexion
		connexion.close();
 
	}
}

Nous avons ici fait le choix d’utiliser le mode mémoire. Ce mode fait tourner le système comme une sous-partie d’une application dans la même JVM (Java Virtual Machine). Il est largement utilisé dans le cadre de tests JUnit car il permet de fournir une base de données sans devoir installer de serveur dédié à la base de données.

L’avantage de cette approche est d’avoir un moyen rapide et efficace de disposer d’une base de données mais l’inconvénient est qu’il n’est pas possible de se connecter à cette base de données en dehors de l’application concernée. Cela implique qu’il n’est pas possible de venir contrôler le contenu ou la structure des tables via un outil externe.

Création d’une table et insertion de données

Maintenant qu’on peut se connecter à la base de données, nous allons voir comment créer la structure de la base de données et la remplir. Encore une fois, l’exemple est simple, il s’agit ici de comprendre les principes d’HSQLDB. On ajoute les deux fonctions ci dessous à la classe :

	/**
	 * Execute la requete passée en paramètre.
	 * @param requete contient la requête SQL
	 * @throws SQLException SQL exception
	 */
	public void executerUpdate(String requete) throws SQLException {
		Statement statement;
		statement = connexion.createStatement();
		statement.executeUpdate(requete);
	}
 
	/**
	 * Execute la requete passée en paramètre.
	 * @param requete contient la requête SQL
	 * @throws SQLException
	 */
	public ResultSet executerRequete(String requete) throws SQLException {
		Statement statement;
		statement = connexion.createStatement();
		ResultSet resultat = statement.executeQuery(requete);
		return resultat;
	}

La première fonction permet d’effectuer une requête SQL de type UPDATE sur la base, alors que la seconde exécute n’importe quelle requête, mais renvoie le résultat, ce qui sert par exemple dans le cas d’une requête de type SELECT. Il s’agit maintenant d’utiliser les méthodes que l’on a créé. Pour cela nous allons créer une nouvelle classe de Test.

    • On se place sur le répertoire src du projet sf-tutorial-hsqldb, puis on fait un clic droit, New → Class.
    • La fenêtre de wizard New Java Class est normalement apparue. On indique dans le champ Package com.scub.foundation.tutorial.hsqldb et on entre dans Name le nom GestionnaireUtilisateurTest et on coche la case public static void main(String[] args) puis on clique sur Finish.
    • La classe a du être créé, avec une méthode statique main() où l’on va appeler et tester les fonctions codées précédemment. Voici le code ci-dessous :
package com.scub.foundation.tutorial.hsqldb;
 
import java.sql.ResultSet;
import java.sql.SQLException;
 
/**
 * Classe de test du tutoriel sur HSQLDB.
 * @author Scub-Foundation
 */
public class GestionnaireUtilisateurTest {
 
    // instance statique de la classe gestionnaireUtilisateur que l'on va utiliser pour faire appel aux méthodes
    private static GestionnaireUtilisateurs gestionnaireUtilisateurs = new GestionnaireUtilisateurs();
 
    /**
     * Fonction de test des fonctionnalités d'HSQLDB.
     * @param args
     * @throws SQLException
     */
    public static void main(String[] args) throws SQLException {
        // On se connecte à la base
        gestionnaireUtilisateurs.connexionDB();
        // On créer une table users
        // On commence par créer la requête SQL
        String requeteTableUsers = "CREATE TABLE users ( idUser INTEGER IDENTITY, login VARCHAR(256), password VARCHAR(256))";
        // Puis on l'execute
        gestionnaireUtilisateurs.executerUpdate(requeteTableUsers);
 
        // On insère ensuite quelques utilisateurs
        String requeteUser1 = "INSERT INTO users(login,password) VALUES('straumat', 'straumat16')";
        String requeteUser2 = "INSERT INTO users(login,password) VALUES('jgoncalves', 'jgoncalves16')";
        String requeteUser3 = "INSERT INTO users(login,password) VALUES('sgoumard', 'sgoumard16')";
 
        // Puis on l'execute
        gestionnaireUtilisateurs.executerUpdate(requeteUser1);
        gestionnaireUtilisateurs.executerUpdate(requeteUser2);
        gestionnaireUtilisateurs.executerUpdate(requeteUser3);
 
        // On créé la requête SQL
        String requeteSelectUsers = "SELECT * FROM users";
 
        // Puis on l'execute
        ResultSet resultat = gestionnaireUtilisateurs.executerRequete(requeteSelectUsers);
 
        // On parcours le résultat de la requête et on l'affiche dans la console
        System.out.println("idUser\t\tlogin\t\t\tpassword");
        while (resultat.next()) {
            System.out.println(resultat.getString("idUser") + "\t\t" + resultat.getString("login") + "\t\t" + resultat.getString("password"));
        }
    }
}

Dans cette classe de test, on crée une table users dans laquelle on insère trois utilisateurs, et on va ensuite effectuer une requête sur la base de données pour afficher le contenu de la table.

Il suffit de lancer la classe GestionnaireUtilisateursTest, pour cela on sélectionne la classe dans le package explorer, clic droit dessus puis Run As > Java Application. On a alors dans la console le contenu de la table users qui doit être affiché comme sur la copie d’écran ci dessous :



Pourquoi utiliser HSQLDB?

L’exemple présenté dans ce tutoriel est simple, mais il faut comprendre que de nos jours, rares sont les applications qui n’exploitent pas de base de données. Lors du développement d’une application, on utilise des données de test par exemple pour les tests unitaires avec JUnit, et dans ces cas-là , la base ne contient pas des millions de données. HSQLDB se révèle alors un outil indispensable!

Un outil léger et rapide

HSQLDB est largement utilisé dans de nombreux projets tels que Hibernate et JBoss car ils possèdent un moteur de base de données rapide et léger permettant la persistance sur le disque et en mémoire vive. Il évite d’avoir à mettre en place des SGBD comme PostGreSQL ou Oracle sur des serveurs de test lors du développement de l’application et des tests unitaires.

Un gain de temps pour les développeurs

En effet, les développeurs ont besoin de valider les fonctionnalités de l’application à l’aide de tests unitaires au fur et à mesure de son évolution. En utilisant HSQLBD, il est possible d’avoir un SGBD en mémoire portable accessible avec des données de test suffisantes pour valider les tests sans avoir à aller perdre du temps avec un SGBD classique et gourmand en ressources comme PostGreSQL ou Oracle. Ainsi les développeurs peuvent relancer à l’infini des tests unitaires avec ces données sans aucun soucis.

Télécharger les sources

Les sources du projet Eclipse pour ce tutoriel sont téléchargeables sur Source Forge à l’adresse suivante.