HSQLDB - Guide rapide

HyperSQL Database (HSQLDB) est un gestionnaire de base de données relationnelle moderne qui se conforme étroitement à la norme SQL: 2011 et aux spécifications JDBC 4. Il prend en charge toutes les fonctionnalités de base et le SGBDR. HSQLDB est utilisé pour le développement, le test et le déploiement d'applications de base de données.

La caractéristique principale et unique de HSQLDB est la conformité standard. Il peut fournir un accès à la base de données dans le processus d'application de l'utilisateur, dans un serveur d'applications ou en tant que processus serveur distinct.

Caractéristiques de HSQLDB

  • HSQLDB utilise une structure en mémoire pour des opérations rapides sur le serveur DB. Il utilise la persistance du disque selon la flexibilité de l'utilisateur, avec une récupération après incident fiable.

  • HSQLDB convient également à l'intelligence d'affaires, à l'ETL et à d'autres applications qui traitent de grands ensembles de données.

  • HSQLDB propose une large gamme d'options de déploiement d'entreprise, telles que les transactions XA, les sources de données de regroupement de connexions et l'authentification à distance.

  • HSQLDB est écrit dans le langage de programmation Java et s'exécute dans une machine virtuelle Java (JVM). Il prend en charge l'interface JDBC pour l'accès à la base de données.

Composants de HSQLDB

Il existe trois composants différents dans le package jar HSQLDB.

  • Moteur SGBDR HyperSQL (HSQLDB)

  • Pilote JDBC HyperSQL

  • Gestionnaire de base de données (outil d'accès à la base de données GUI, avec les versions Swing et AWT)

Le SGBDR HyperSQL et le pilote JDBC fournissent les fonctionnalités de base. Les gestionnaires de bases de données sont des outils d'accès aux bases de données à usage général qui peuvent être utilisés avec n'importe quel moteur de base de données doté d'un pilote JDBC.

Un fichier jar supplémentaire appelé sqltool.jar, contient Sql Tool, qui est un outil d'accès à la base de données en ligne de commande. Il s'agit d'une commande à usage général. Outil d'accès à la base de données en ligne qui peut également être utilisé avec d'autres moteurs de base de données.

HSQLDB est un système de gestion de base de données relationnelle implémenté en Java pur. Vous pouvez facilement intégrer cette base de données à votre application à l'aide de JDBC. Ou vous pouvez utiliser les opérations séparément.

Conditions préalables

Suivez les installations logicielles requises pour HSQLDB.

Vérifier l'installation de Java

Comme HSQLDB est un système de gestion de base de données relationnelle implémenté en Java pur, vous devez installer le logiciel JDK (Java Development Kit) avant d'installer HSQLDB. Si vous avez déjà une installation JDK sur votre système, essayez la commande suivante pour vérifier la version Java.

java –version

Si JDK est correctement installé sur votre système, vous obtiendrez la sortie suivante.

java version "1.8.0_91"
Java(TM) SE Runtime Environment (build 1.8.0_91-b14)
Java HotSpot(TM) 64-Bit Server VM (build 25.91-b14, mixed mode)

Si JDK n'est pas installé sur votre système, visitez le lien suivant pour installer JDK.

Installation de HSQLDB

Voici les étapes pour installer HSQLDB.

Step 1 − Download HSQLDB bundle

Téléchargez la dernière version de la base de données HSQLDB à partir du lien suivant https://sourceforge.net/projects/hsqldb/files/. Une fois que vous avez cliqué sur le lien, vous obtiendrez la capture d'écran suivante.

Cliquez sur HSQLDB et le téléchargement commencera immédiatement. Enfin, vous obtiendrez le fichier zip nomméhsqldb-2.3.4.zip.

Step 2 − Extract the HSQLDB zip file

Extrayez le fichier zip et placez-le dans le C:\annuaire. Après l'extraction, vous obtiendrez une structure de fichier comme indiqué dans la capture d'écran suivante.

Step 3 − Create a default database

Il n'y a pas de base de données par défaut pour HSQLDB, par conséquent, vous devez créer une base de données pour HSQLDB. Créons un fichier de propriétés nomméserver.properties qui définit une nouvelle base de données nommée demodb. Jetez un œil aux propriétés suivantes du serveur de base de données.

server.database.0 = file:hsqldb/demodb
server.dbname.0 = testdb

Placez ce fichier server.properties dans le répertoire de base HSQLDB C:\hsqldb- 2.3.4\hsqldb\.

Exécutez maintenant la commande suivante sur l'invite de commande.

\>cd C:\hsqldb-2.3.4\hsqldb
hsqldb>java -classpath lib/hsqldb.jar org.hsqldb.server.Server

Après l'exécution de la commande ci-dessus, vous recevrez l'état du serveur comme indiqué dans la capture d'écran suivante.

Plus tard, vous trouverez la structure de dossiers suivante du répertoire hsqldb dans le répertoire de base HSQLDB qui est C:\hsqldb-2.3.4\hsqldb. Ces fichiers sont le fichier temporaire, le fichier lck, le fichier journal, le fichier de propriétés et le fichier de script de la base de données demodb créée par le serveur de base de données HSQLDB.

Step 4 − Start the database server

Une fois que vous avez terminé de créer une base de données, vous devez démarrer la base de données à l'aide de la commande suivante.

\>cd C:\hsqldb-2.3.4\hsqldb
hsqldb>java -classpath lib/hsqldb.jar org.hsqldb.server.Server --database.0
file:hsqldb/demodb --dbname.0 testdb

Après l'exécution de la commande ci-dessus, vous obtenez l'état suivant.

Maintenant, vous pouvez ouvrir l'écran d'accueil de la base de données runManagerSwing.bat de C:\hsqldb-2.3.4\hsqldb\binemplacement. Ce fichier bat ouvrira le fichier GUI de la base de données HSQLDB. Avant cela, il vous demandera les paramètres de la base de données via une boîte de dialogue. Jetez un œil à la capture d'écran suivante. Dans cette boîte de dialogue, entrez le nom du paramètre, l'URL comme indiqué ci-dessus et cliquez sur OK.

Vous obtiendrez l'écran GUI de la base de données HSQLDB comme indiqué dans la capture d'écran suivante.

Dans le chapitre d'installation, nous avons expliqué comment connecter la base de données manuellement. Dans ce chapitre, nous verrons comment connecter la base de données par programmation (en utilisant la programmation Java).

Jetez un œil au programme suivant, qui démarrera le serveur et créera une connexion entre l'application Java et la base de données.

Exemple

import java.sql.Connection;
import java.sql.DriverManager;

public class ConnectDatabase {
   public static void main(String[] args) {
      Connection con = null;
      
      try {
         //Registering the HSQLDB JDBC driver
         Class.forName("org.hsqldb.jdbc.JDBCDriver");
         //Creating the connection with HSQLDB
         con = DriverManager.getConnection("jdbc:hsqldb:hsql://localhost/testdb", "SA", "");
         if (con!= null){
            System.out.println("Connection created successfully");
            
         }else{
            System.out.println("Problem with creating connection");
         }
      
      }  catch (Exception e) {
         e.printStackTrace(System.out);
      }
   }
}

Enregistrez ce code dans ConnectDatabase.javafichier. Vous devrez démarrer la base de données à l'aide de la commande suivante.

\>cd C:\hsqldb-2.3.4\hsqldb
hsqldb>java -classpath lib/hsqldb.jar org.hsqldb.server.Server --database.0
file:hsqldb/demodb --dbname.0 testdb

Vous pouvez utiliser la commande suivante pour compiler et exécuter le code.

\>javac ConnectDatabase.java
\>java ConnectDatabase

Après l'exécution de la commande ci-dessus, vous recevrez la sortie suivante -

Connection created successfully

Ce chapitre explique les différents types de données de HSQLDB. Le serveur HSQLDB propose six catégories de types de données.

Types de données numériques exacts

Type de données De À
bigint -9 223 372 036 854 775 808 9 223 372 036 854 775 807
int -2 147 483 648 2 147 483 647
smallint -32 768 32 767
minuscule 0 255
bit 0 1
décimal -10 ^ 38 +1 10 ^ 38-1
numérique -10 ^ 38 +1 10 ^ 38-1
argent -922 337 203 685 477,5808 +922 337 203 685 477 5807
petit argent -214 748,3648 +214 748,3647

Types de données numériques approximatifs

Type de données De À
flotte -1,79E + 308 1,79E + 308
réel -3,40E + 38 3,40E + 38

Types de données de date et d'heure

Type de données De À
datetime 1 janv.1753 31 déc.9999
smalldatetime 1 janv.1900 6 juin 2079
Date Stocke une date comme le 30 juin 1991
temps Enregistre une heure de la journée comme 12h30

Note - Ici, le datetime a une précision de 3,33 millisecondes alors que le petit datetime a une précision d'une minute.

Types de données de chaînes de caractères

Type de données La description
carboniser Longueur maximale de 8 000 caractères (caractères non Unicode de longueur fixe)
varchar Maximum de 8 000 caractères (données non Unicode de longueur variable)
varchar (max) Longueur maximale de 231 caractères, données non Unicode de longueur variable (SQL Server 2005 uniquement)
texte Données non Unicode de longueur variable d'une longueur maximale de 2 147 483 647 caractères

Types de données de chaînes de caractères Unicode

Type de données La description
nchar Longueur maximale de 4000 caractères (Unicode de longueur fixe)
nvarchar Longueur maximale de 4000 caractères (Unicode de longueur variable)
nvarchar (max) Longueur maximale de 231 caractères (SQL Server 2005 uniquement), (Unicode de longueur variable)
ntext Longueur maximale de 1073741823 caractères (Unicode de longueur variable)

Types de données binaires

Type de données La description
binaire Longueur maximale de 8 000 octets (données binaires de longueur fixe)
varbinary Longueur maximale de 8 000 octets (données binaires de longueur variable)
varbinary (max) Longueur maximale de 231 octets (SQL Server 2005 uniquement), (données binaires de longueur variable)
image Longueur maximale de 2147483647 octets (données binaires de longueur variable)

Types de données divers

Type de données La description
sql_variant Stocke les valeurs de divers types de données pris en charge par SQL Server, à l'exception du texte, du ntext et de l'horodatage
horodatage Stocke un numéro unique à l'échelle de la base de données qui est mis à jour chaque fois qu'une ligne est mise à jour
identifiant unique Stocke un identifiant global unique (GUID)
xml Stocke les données XML. Vous pouvez stocker des instances xml dans une colonne ou une variable (SQL Server 2005 uniquement)
le curseur Référence à un objet curseur
table Stocke un jeu de résultats pour un traitement ultérieur

Les exigences de base obligatoires pour créer une table sont le nom de la table, les noms de champ et les types de données de ces champs. Si vous le souhaitez, vous pouvez également fournir les principales contraintes à la table.

Syntaxe

Jetez un œil à la syntaxe suivante.

CREATE TABLE table_name (column_name column_type);

Exemple

Créons une table nommée tutorials_tbl avec les noms de champ tels que id, title, author et submit_date. Jetez un œil à la requête suivante.

CREATE TABLE tutorials_tbl (
   id INT NOT NULL,
   title VARCHAR(50) NOT NULL,
   author VARCHAR(20) NOT NULL,
   submission_date DATE,
   PRIMARY KEY (id) 
);

Après l'exécution de la requête ci-dessus, vous recevrez la sortie suivante -

(0) rows effected

HSQLDB - Programme JDBC

Voici le programme JDBC utilisé pour créer une table nommée tutorials_tbl dans la base de données HSQLDB. Enregistrez le programme dansCreateTable.java fichier.

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;

public class CreateTable {
   
   public static void main(String[] args) {
      
      Connection con = null;
      Statement stmt = null;
      int result = 0;
      
      try {
         Class.forName("org.hsqldb.jdbc.JDBCDriver");
         con = DriverManager.getConnection("jdbc:hsqldb:hsql://localhost/testdb", "SA", "");
         stmt = con.createStatement();
         
         result = stmt.executeUpdate("CREATE TABLE tutorials_tbl (
            id INT NOT NULL, title VARCHAR(50) NOT NULL,
            author VARCHAR(20) NOT NULL, submission_date DATE,
            PRIMARY KEY (id));
         ");
			
      }  catch (Exception e) {
         e.printStackTrace(System.out);
      }
      System.out.println("Table created successfully");
   }
}

Vous pouvez démarrer la base de données à l'aide de la commande suivante.

\>cd C:\hsqldb-2.3.4\hsqldb
hsqldb>java -classpath lib/hsqldb.jar org.hsqldb.server.Server --database.0
file:hsqldb/demodb --dbname.0 testdb

Compilez et exécutez le programme ci-dessus à l'aide de la commande suivante.

\>javac CreateTable.java
\>java CreateTable

Après l'exécution de la commande ci-dessus, vous recevrez la sortie suivante -

Table created successfully

Il est très facile de supprimer une table HSQLDB existante. Cependant, vous devez être très prudent lors de la suppression d'une table existante car les données perdues ne seront pas récupérées après la suppression d'une table.

Syntaxe

Voici une syntaxe SQL générique pour supprimer une table HSQLDB.

DROP TABLE table_name;

Exemple

Prenons un exemple pour supprimer une table nommée employee du serveur HSQLDB. Voici la requête pour supprimer une table nommée employé.

DROP TABLE employee;

Après l'exécution de la requête ci-dessus, vous recevrez la sortie suivante -

(0) rows effected

HSQLDB - Programme JDBC

Voici le programme JDBC utilisé pour supprimer l'employé de table du serveur HSQLDB.

Enregistrez le code suivant dans DropTable.java fichier.

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;

public class DropTable {
   public static void main(String[] args) {
      Connection con = null;
      Statement stmt = null;
      int result = 0;
      
      try {
         Class.forName("org.hsqldb.jdbc.JDBCDriver");
         con = DriverManager.getConnection("jdbc:hsqldb:hsql://localhost/testdb", "SA", "");
         stmt = con.createStatement();
         result = stmt.executeUpdate("DROP TABLE employee");
      }catch (Exception e) {
         e.printStackTrace(System.out);
      }
      
      System.out.println("Table dropped successfully");
   }
}

Vous pouvez démarrer la base de données à l'aide de la commande suivante.

\>cd C:\hsqldb-2.3.4\hsqldb
hsqldb>java -classpath lib/hsqldb.jar org.hsqldb.server.Server --database.0
file:hsqldb/demodb --dbname.0 testdb

Compilez et exécutez le programme ci-dessus à l'aide de la commande suivante.

\>javac DropTable.java
\>java DropTable

Après l'exécution de la commande ci-dessus, vous recevrez la sortie suivante -

Table dropped successfully

Vous pouvez obtenir une instruction de requête d'insertion dans HSQLDB à l'aide de la commande INSERT INTO. Vous devez fournir les données définies par l'utilisateur en suivant l'ordre des champs de colonne de la table.

Syntaxe

Voici la syntaxe générique pour INSERT une requête.

INSERT INTO table_name (field1, field2,...fieldN)
VALUES (value1, value2,...valueN );

Pour insérer des données de type chaîne dans une table, vous devrez utiliser des guillemets doubles ou simples pour fournir une valeur de chaîne dans l'instruction d'insertion de requête.

Exemple

Prenons un exemple qui insère un enregistrement dans une table nommée tutorials_tbl avec les valeurs id = 100, title = Learn PHP, Author = John Poul, et la date de soumission est la date actuelle.

Voici la requête pour l'exemple donné.

INSERT INTO tutorials_tbl VALUES (100,'Learn PHP', 'John Poul', NOW());

Après l'exécution de la requête ci-dessus, vous recevrez la sortie suivante -

1 row effected

HSQLDB - Programme JDBC

Voici le programme JDBC pour insérer l'enregistrement dans la table avec les valeurs données, id = 100, title = Learn PHP, Author = John Poul, et la date de soumission est la date actuelle. Jetez un œil au programme donné. Enregistrez le code dans leInserQuery.java fichier.

import java.sql.Connection; 
import java.sql.DriverManager; 
import java.sql.Statement;  

public class InsertQuery {
   public static void main(String[] args) { 
      Connection con = null; 
      Statement stmt = null; 
      int result = 0; 
      try { 
         Class.forName("org.hsqldb.jdbc.JDBCDriver"); 
         con = DriverManager.getConnection( 
            "jdbc:hsqldb:hsql://localhost/testdb", "SA", ""); 
         stmt = con.createStatement(); 
         result = stmt.executeUpdate("INSERT INTO tutorials_tbl 
            VALUES (100,'Learn PHP', 'John Poul', NOW())"); 
         con.commit(); 
      }catch (Exception e) { 
         e.printStackTrace(System.out); 
      } 
      System.out.println(result+" rows effected"); 
      System.out.println("Rows inserted successfully"); 
   } 
}

Vous pouvez démarrer la base de données à l'aide de la commande suivante.

\>cd C:\hsqldb-2.3.4\hsqldb 
hsqldb>java -classpath lib/hsqldb.jar org.hsqldb.server.Server --database.0 
file:hsqldb/demodb --dbname.0 testdb

Compilez et exécutez le programme ci-dessus à l'aide de la commande suivante.

\>javac InsertQuery.java 
\>java InsertQuery

Après l'exécution de la commande ci-dessus, vous recevrez la sortie suivante -

1 rows effected 
Rows inserted successfully

Essayez d'insérer les enregistrements suivants dans le tutorials_tbl table en utilisant le INSERT INTO commander.

Id Titre Auteur Date de soumission
101 Apprendre C Yaswanth Maintenant()
102 Apprenez MySQL Abdul S Maintenant()
103 Apprenez Excell Bavya kanna Maintenant()
104 Apprenez JDB Ajith Kumar Maintenant()
105 Apprendre Junit Sathya Murthi Maintenant()

La commande SELECT est utilisée pour récupérer les données d'enregistrement de la base de données HSQLDB. Ici, vous devez mentionner la liste des champs obligatoires dans l'instruction Select.

Syntaxe

Voici la syntaxe générique de la requête Select.

SELECT field1, field2,...fieldN table_name1, table_name2...
[WHERE Clause]
[OFFSET M ][LIMIT N]
  • Vous pouvez récupérer un ou plusieurs champs en une seule commande SELECT.

  • Vous pouvez spécifier une étoile (*) à la place des champs. Dans ce cas, SELECT retournera tous les champs.

  • Vous pouvez spécifier n'importe quelle condition à l'aide de la clause WHERE.

  • Vous pouvez spécifier un décalage à l'aide de OFFSET à partir duquel SELECT commencera à renvoyer les enregistrements. Par défaut, le décalage est égal à zéro.

  • Vous pouvez limiter le nombre de retours à l'aide de l'attribut LIMIT.

Exemple

Voici un exemple qui récupère les champs id, title et author de tous les enregistrements de tutorials_tbltable. Nous pouvons y parvenir en utilisant l'instruction SELECT. Voici la requête de l'exemple.

SELECT id, title, author FROM tutorials_tbl

Après l'exécution de la requête ci-dessus, vous recevrez la sortie suivante.

+------+----------------+-----------------+
|  id  |      title     |    author       |
+------+----------------+-----------------+
| 100  |     Learn PHP  |    John Poul    |
| 101  |     Learn C    |    Yaswanth     |
| 102  |   Learn MySQL  |     Abdul S     |
| 103  |   Learn Excell |   Bavya kanna   |
| 104  |   Learn JDB    |    Ajith kumar  |
| 105  |   Learn Junit  |   Sathya Murthi |
+------+----------------+-----------------+

HSQLDB - Programme JDBC

Voici le programme JDBC qui récupérera les champs id, title et author de tous les enregistrements depuis tutorials_tbltable. Enregistrez le code suivant dans leSelectQuery.java fichier.

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;

public class SelectQuery {
   
   public static void main(String[] args) {
      Connection con = null;
      Statement stmt = null;
      ResultSet result = null;
      
      try {
         Class.forName("org.hsqldb.jdbc.JDBCDriver");
         con = DriverManager.getConnection(
            "jdbc:hsqldb:hsql://localhost/testdb", "SA", "");
         stmt = con.createStatement();
         result = stmt.executeQuery(
            "SELECT id, title, author FROM tutorials_tbl");
         
         while(result.next()){
            System.out.println(result.getInt("id")+" | "+
               result.getString("title")+" | "+
               result.getString("author"));
         }
      } catch (Exception e) {
         e.printStackTrace(System.out);
      }
   }
}

Vous pouvez démarrer la base de données à l'aide de la commande suivante.

\>cd C:\hsqldb-2.3.4\hsqldb
hsqldb>java -classpath lib/hsqldb.jar org.hsqldb.server.Server --database.0
file:hsqldb/demodb --dbname.0 testdb

Compilez et exécutez le code ci-dessus à l'aide de la commande suivante.

\>javac SelectQuery.java
\>java SelectQuery

Après l'exécution de la commande ci-dessus, vous recevrez la sortie suivante -

100 | Learn PHP | John Poul
101 | Learn C | Yaswanth
102 | Learn MySQL | Abdul S
103 | Learn Excell | Bavya Kanna
104 | Learn JDB | Ajith kumar
105 | Learn Junit | Sathya Murthi

Généralement, nous utilisons la commande SELECT pour récupérer les données de la table HSQLDB. Nous pouvons utiliser la clause conditionnelle WHERE pour filtrer les données résultantes. En utilisant WHERE, nous pouvons spécifier les critères de sélection pour sélectionner les enregistrements requis dans une table.

Syntaxe

Voici la syntaxe de la clause WHERE de la commande SELECT pour récupérer les données de la table HSQLDB.

SELECT field1, field2,...fieldN table_name1, table_name2...
[WHERE condition1 [AND [OR]] condition2.....
  • Vous pouvez utiliser une ou plusieurs tables séparées par des virgules pour inclure diverses conditions à l'aide d'une clause WHERE, mais la clause WHERE est une partie facultative de la commande SELECT.

  • Vous pouvez spécifier n'importe quelle condition à l'aide de la clause WHERE.

  • Vous pouvez spécifier plusieurs conditions à l'aide des opérateurs AND ou OR.

  • Une clause WHERE peut également être utilisée avec la commande SQL DELETE ou UPDATE pour spécifier une condition.

Nous pouvons filtrer les données d'enregistrement en utilisant des conditions. Nous utilisons différents opérateurs dans la clause WHERE conditionnelle. Voici la liste des opérateurs, qui peuvent être utilisés avec la clause WHERE.

Opérateur La description Exemple
= Vérifie si les valeurs de deux opérandes sont égales ou non, si oui, la condition devient vraie. (A = B) n'est pas vrai
! = Vérifie si les valeurs de deux opérandes sont égales ou non, si les valeurs ne sont pas égales, la condition devient vraie. (A! = B) est vrai
> Vérifie si la valeur de l'opérande gauche est supérieure à la valeur de l'opérande droit, si oui, la condition devient vraie. (A> B) n'est pas vrai
< Vérifie si la valeur de l'opérande de gauche est inférieure à la valeur de l'opérande de droite, si oui, la condition devient vraie. (A <B) est vrai
> = Vérifie si la valeur de l'opérande gauche est supérieure ou égale à la valeur de l'opérande droit, si oui, la condition devient vraie. (A> = B) n'est pas vrai
<= Vérifie si la valeur de l'opérande gauche est inférieure ou égale à la valeur de l'opérande droit, si oui, la condition devient vraie. (A <= B) est vrai

Exemple

Voici un exemple qui récupère les détails tels que l'identifiant, le titre et l'auteur du livre intitulé "Learn C". C'est possible en utilisant la clause WHERE dans la commande SELECT. Voici la requête pour le même.

SELECT id, title, author FROM tutorials_tbl WHERE title = 'Learn C';

Après l'exécution de la requête ci-dessus, vous recevrez la sortie suivante.

+------+----------------+-----------------+
| id   |      title     |    author       |
+------+----------------+-----------------+
| 101  |      Learn C   |   Yaswanth      |
+------+----------------+-----------------+

HSQLDB - Programme JDBC

Voici le programme JDBC qui récupère les données d'enregistrement de la table tutorials_tbl ayant le titre Learn C. Enregistrez le code suivant dansWhereClause.java.

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;

public class WhereClause {
   
   public static void main(String[] args) {
      Connection con = null;
      Statement stmt = null;
      ResultSet result = null;
      try {
         Class.forName("org.hsqldb.jdbc.JDBCDriver");
         con = DriverManager.getConnection(
            "jdbc:hsqldb:hsql://localhost/testdb", "SA", "");
         stmt = con.createStatement();
         result = stmt.executeQuery(
            "SELECT id, title, author FROM tutorials_tbl
            WHERE title = 'Learn C'");
         
         while(result.next()){
            System.out.println(result.getInt("id")+" |
               "+result.getString("title")+" |
               "+result.getString("author"));
         }
      } catch (Exception e) {
         e.printStackTrace(System.out);
      }
   }

}

Vous pouvez démarrer la base de données à l'aide de la commande suivante.

\>cd C:\hsqldb-2.3.4\hsqldb
hsqldb>java -classpath lib/hsqldb.jar org.hsqldb.server.Server --database.0
file:hsqldb/demodb --dbname.0 testdb

Compilez et exécutez le code ci-dessus à l'aide de la commande suivante.

\>javac WhereClause.java
\>java WhereClause

Après l'exécution de la commande ci-dessus, vous recevrez la sortie suivante.

101 | Learn C | Yaswanth

Chaque fois que vous souhaitez modifier les valeurs d'une table, vous pouvez utiliser la commande UPDATE. Cela modifiera toute valeur de champ de n'importe quelle table HSQLDB.

Syntaxe

Voici la syntaxe générique de la commande UPDATE.

UPDATE table_name SET field1 = new-value1, field2 = new-value2 [WHERE Clause]
  • Vous pouvez mettre à jour un ou plusieurs champs ensemble.
  • Vous pouvez spécifier n'importe quelle condition à l'aide de la clause WHERE.
  • Vous pouvez mettre à jour les valeurs dans une seule table à la fois.

Exemple

Prenons un exemple qui met à jour le titre du tutoriel de "Learn C" à "C and Data Structures" ayant un id "101". Voici la requête pour la mise à jour.

UPDATE tutorials_tbl SET title = 'C and Data Structures' WHERE id = 101;

Après l'exécution de la requête ci-dessus, vous recevrez la sortie suivante.

(1) Rows effected

HSQLDB - Programme JDBC

Voici le programme JDBC qui mettra à jour un titre de tutoriel à partir de Learn C à C and Data Structures avoir une identité 101. Enregistrez le programme suivant dans leUpdateQuery.java fichier.

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;

public class UpdateQuery {
   
   public static void main(String[] args) {
      Connection con = null;
      Statement stmt = null;
      int result = 0;
      
      try {
         Class.forName("org.hsqldb.jdbc.JDBCDriver");
         con = DriverManager.getConnection(
            "jdbc:hsqldb:hsql://localhost/testdb", "SA", "");
         stmt = con.createStatement();
         result = stmt.executeUpdate(
            "UPDATE tutorials_tbl SET title = 'C and Data Structures' WHERE id = 101");
      } catch (Exception e) {
         e.printStackTrace(System.out);
      }
      System.out.println(result+" Rows effected");
   }
}

Vous pouvez démarrer la base de données à l'aide de la commande suivante.

\>cd C:\hsqldb-2.3.4\hsqldb
hsqldb>java -classpath lib/hsqldb.jar org.hsqldb.server.Server --database.0
file:hsqldb/demodb --dbname.0 testdb

Compilez et exécutez le programme ci-dessus à l'aide de la commande suivante.

\>javac UpdateQuery.java
\>java UpdateQuery

Après l'exécution de la commande ci-dessus, vous recevrez la sortie suivante -

1 Rows effected

Chaque fois que vous souhaitez supprimer un enregistrement d'une table HSQLDB, vous pouvez utiliser la commande DELETE FROM.

Syntaxe

Voici la syntaxe générique de la commande DELETE pour supprimer des données d'une table HSQLDB.

DELETE FROM table_name [WHERE Clause]
  • Si la clause WHERE n'est pas spécifiée, tous les enregistrements seront supprimés de la table MySQL donnée.

  • Vous pouvez spécifier n'importe quelle condition à l'aide de la clause WHERE.

  • Vous pouvez supprimer des enregistrements dans une seule table à la fois.

Exemple

Prenons un exemple qui supprime les données d'enregistrement de la table nommée tutorials_tbl avoir une identité 105. Voici la requête qui implémente l'exemple donné.

DELETE FROM tutorials_tbl WHERE id = 105;

Après l'exécution de la requête ci-dessus, vous recevrez la sortie suivante -

(1) rows effected

HSQLDB - Programme JDBC

Voici le programme JDBC qui implémente l'exemple donné. Enregistrez le programme suivant dansDeleteQuery.java.

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;

public class DeleteQuery {
   
   public static void main(String[] args) {
      Connection con = null;
      Statement stmt = null;
      int result = 0;
      
      try {
         Class.forName("org.hsqldb.jdbc.JDBCDriver");
         con = DriverManager.getConnection(
            "jdbc:hsqldb:hsql://localhost/testdb", "SA", "");
         stmt = con.createStatement();
         result = stmt.executeUpdate(
            "DELETE FROM tutorials_tbl   WHERE id=105");
      } catch (Exception e) {
      
         e.printStackTrace(System.out);
      }
      System.out.println(result+" Rows effected");
   }
}

Vous pouvez démarrer la base de données à l'aide de la commande suivante.

\>cd C:\hsqldb-2.3.4\hsqldb
hsqldb>java -classpath lib/hsqldb.jar org.hsqldb.server.Server --database.0
file:hsqldb/demodb --dbname.0 testdb

Compilez et exécutez le programme ci-dessus à l'aide de la commande suivante.

\>javac DeleteQuery.java
\>java DeleteQuery

Après l'exécution de la commande ci-dessus, vous recevrez la sortie suivante -

1 Rows effected

Il existe une clause WHERE dans la structure du SGBDR. Vous pouvez utiliser la clause WHERE avec un signe égal à (=) où nous voulons faire une correspondance exacte. Mais il peut y avoir une exigence où nous voulons filtrer tous les résultats où le nom de l'auteur doit contenir "john". Cela peut être géré à l'aide de la clause SQL LIKE avec la clause WHERE.

Si la clause SQL LIKE est utilisée avec% caractères, elle fonctionnera comme un métacaractère (*) sous UNIX tout en listant tous les fichiers ou répertoires à l'invite de commande.

Syntaxe

Voici la syntaxe SQL générique de la clause LIKE.

SELECT field1, field2,...fieldN table_name1, table_name2...
WHERE field1 LIKE condition1 [AND [OR]] filed2 = 'somevalue'
  • Vous pouvez spécifier n'importe quelle condition à l'aide de la clause WHERE.

  • Vous pouvez utiliser la clause LIKE avec la clause WHERE.

  • Vous pouvez utiliser la clause LIKE à la place du signe égal à.

  • Lorsque la clause LIKE est utilisée avec le signe%, cela fonctionnera comme une recherche de métacaractères.

  • Vous pouvez spécifier plusieurs conditions à l'aide des opérateurs AND ou OR.

  • Une clause WHERE ... LIKE peut être utilisée avec la commande DELETE ou UPDATE SQL pour spécifier une condition.

Exemple

Prenons un exemple qui récupère la liste des données des tutoriels où le nom de l'auteur commence par John. Voici la requête HSQLDB pour l'exemple donné.

SELECT * from tutorials_tbl WHERE author LIKE 'John%';

Après l'exécution de la requête ci-dessus, vous recevrez la sortie suivante.

+-----+----------------+-----------+-----------------+
|  id |      title     |   author  | submission_date |
+-----+----------------+-----------+-----------------+
| 100 |    Learn PHP   | John Poul | 2016-06-20      |
+-----+----------------+-----------+-----------------+

HSQLDB - Programme JDBC

Voici le programme JDBC qui récupère la liste des données des didacticiels où le nom de l'auteur commence par John. Enregistrez le code dansLikeClause.java.

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;

public class LikeClause {
   
   public static void main(String[] args) {
      Connection con = null;
      Statement stmt = null;
      ResultSet result = null;
      
      try {
         Class.forName("org.hsqldb.jdbc.JDBCDriver");
         con = DriverManager.getConnection(
            "jdbc:hsqldb:hsql://localhost/testdb", "SA", "");
         stmt = con.createStatement();
         result = stmt.executeQuery(
            "SELECT * from tutorials_tbl WHERE author LIKE 'John%';");
         
         while(result.next()){
            System.out.println(result.getInt("id")+" |
               "+result.getString("title")+" |
               "+result.getString("author")+" |
               "+result.getDate("submission_date"));
         }
      } catch (Exception e) {
         e.printStackTrace(System.out);
      }
   }
}

Vous pouvez démarrer la base de données à l'aide de la commande suivante.

\>cd C:\hsqldb-2.3.4\hsqldb
hsqldb>java -classpath lib/hsqldb.jar org.hsqldb.server.Server --database.0
file:hsqldb/demodb --dbname.0 testdb

Compilez et exécutez le code ci-dessus à l'aide de la commande suivante.

\>javac LikeClause.java
\>java LikeClause

Après l'exécution de la commande suivante, vous recevrez la sortie suivante.

100 | Learn PHP | John Poul | 2016-06-20

La commande SQL SELECT récupère les données de la table HSQLDB chaque fois qu'une exigence suit un ordre particulier lors de la récupération et de l'affichage des enregistrements. Dans ce cas, nous pouvons utiliser leORDER BY clause.

Syntaxe

Voici la syntaxe de la commande SELECT avec la clause ORDER BY pour trier les données de HSQLDB.

SELECT field1, field2,...fieldN table_name1, table_name2...
ORDER BY field1, [field2...] [ASC [DESC]]
  • Vous pouvez trier le résultat renvoyé sur n'importe quel champ à condition que ce champ soit répertorié.

  • Vous pouvez trier le résultat sur plusieurs champs.

  • Vous pouvez utiliser le mot-clé ASC ou DESC pour obtenir le résultat dans un ordre croissant ou décroissant. Par défaut, c'est dans un ordre croissant.

  • Vous pouvez utiliser la clause WHERE ... LIKE de manière habituelle pour placer une condition.

Exemple

Prenons un exemple qui récupère et trie les enregistrements de tutorials_tbltable en classant le nom de l'auteur dans un ordre croissant. Voici la requête pour le même.

SELECT id, title, author from tutorials_tbl ORDER BY author ASC;

Après l'exécution de la requête ci-dessus, vous recevrez la sortie suivante.

+------+----------------+-----------------+
| id   |     title      |     author      |
+------+----------------+-----------------+
| 102  |  Learn MySQL   |     Abdul S     | 
| 104  |  Learn JDB     |    Ajith kumar  |
| 103  |  Learn Excell  |    Bavya kanna  |
| 100  |  Learn PHP     |    John Poul    |
| 105  |  Learn Junit   |   Sathya Murthi |
| 101  |  Learn C       |    Yaswanth     |
+------+----------------+-----------------+

HSQLDB - Programme JDBC

Voici le programme JDBC qui récupère et trie les enregistrements de tutorials_tbltable en classant le nom de l'auteur dans un ordre croissant. Enregistrez le programme suivant dansOrderBy.java.

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;

public class OrderBy {
   
   public static void main(String[] args) {
      Connection con = null;
      Statement stmt = null;
      ResultSet result = null;
      
      try {
         Class.forName("org.hsqldb.jdbc.JDBCDriver");
         con = DriverManager.getConnection(
            "jdbc:hsqldb:hsql://localhost/testdb", "SA", "");
         stmt = con.createStatement();
         result = stmt.executeQuery(
            "SELECT id, title, author from tutorials_tbl
            ORDER BY author ASC");
         
         while(result.next()){
            System.out.println(result.getInt("id")+" |
            "+result.getString("title")+" |
            "+result.getString("author"));
         }
      } catch (Exception e) {
         e.printStackTrace(System.out);
      }
   }
}

Vous pouvez démarrer la base de données à l'aide de la commande suivante.

\>cd C:\hsqldb-2.3.4\hsqldb
hsqldb>java -classpath lib/hsqldb.jar org.hsqldb.server.Server --database.0
file:hsqldb/demodb --dbname.0 testdb

Compilez et exécutez le programme ci-dessus à l'aide de la commande suivante.

\>javac OrderBy.java
\>java OrderBy

Après l'exécution de la commande ci-dessus, vous recevrez la sortie suivante.

102 | Learn MySQL           | Abdul S
104 | Learn JDB             | Ajith kumar
103 | Learn Excell          | Bavya Kanna
100 | Learn PHP             | John Poul
105 | Learn Junit           | Sathya Murthi
101 | C and Data Structures | Yaswanth

Chaque fois qu'il est nécessaire de récupérer des données de plusieurs tables à l'aide d'une seule requête, vous pouvez utiliser JOINS à partir du SGBDR. Vous pouvez utiliser plusieurs tables dans votre seule requête SQL. L'acte de se joindre dans HSQLDB fait référence à l'écrasement de deux ou plusieurs tables en une seule table.

Considérez les tableaux Clients et Commandes suivants.

Customer:
+----+----------+-----+-----------+----------+
| ID |   NAME   | AGE |  ADDRESS  |  SALARY  |
+----+----------+-----+-----------+----------+
| 1  |  Ramesh  | 32  | Ahmedabad |  2000.00 |
| 2  |  Khilan  | 25  |   Delhi   |  1500.00 |
| 3  |  kaushik | 23  |   Kota    |  2000.00 |
| 4  | Chaitali | 25  |   Mumbai  |  6500.00 |
| 5  |  Hardik  | 27  |   Bhopal  |  8500.00 |
| 6  |  Komal   | 22  |    MP     |  4500.00 |
| 7  |  Muffy   | 24  |   Indore  | 10000.00 |
+----+----------+-----+-----------+----------+
Orders:
+-----+---------------------+-------------+--------+
|OID  |         DATE        | CUSTOMER_ID | AMOUNT |
+-----+---------------------+-------------+--------+
| 102 | 2009-10-08 00:00:00 |      3      |  3000  |
| 100 | 2009-10-08 00:00:00 |      3      |  1500  |
| 101 | 2009-11-20 00:00:00 |      2      |  1560  |
| 103 | 2008-05-20 00:00:00 |      4      |  2060  |
+-----+---------------------+-------------+--------+

Maintenant, essayons de récupérer les données des clients et le montant de la commande que le client respectif a passé. Cela signifie que nous récupérons les données d'enregistrement de la table des clients et des commandes. Nous pouvons y parvenir en utilisant le concept JOINS dans HSQLDB. Voici la requête JOIN pour le même.

SELECT ID, NAME, AGE, AMOUNT FROM CUSTOMERS, ORDERS WHERE CUSTOMERS.ID =
ORDERS.CUSTOMER_ID;

Après l'exécution de la requête ci-dessus, vous recevrez la sortie suivante.

+----+----------+-----+--------+
| ID |   NAME   | AGE | AMOUNT |
+----+----------+-----+--------+
|  3 | kaushik  |  23 |  3000  |
|  3 | kaushik  |  23 |  1500  |
|  2 | Khilan   |  25 |  1560  |
|  4 | Chaitali |  25 |  2060  |
+----+----------+-----+--------+

JOIN Types

Il existe différents types de jointures disponibles dans HSQLDB.

  • INNER JOIN - Renvoie les lignes lorsqu'il y a une correspondance dans les deux tables.

  • LEFT JOIN - Renvoie toutes les lignes de la table de gauche, même s'il n'y a pas de correspondance dans la table de droite.

  • RIGHT JOIN - Renvoie toutes les lignes de la table de droite, même s'il n'y a aucune correspondance dans la table de gauche.

  • FULL JOIN - Renvoie les lignes lorsqu'il y a une correspondance dans l'une des tables.

  • SELF JOIN - Utilisé pour joindre une table à elle-même comme si la table était deux tables, renommant temporairement au moins une table dans l'instruction SQL.

Jointure interne

La jointure la plus fréquemment utilisée et la plus importante est INNER JOIN. Il est également appelé EQUIJOIN.

INNER JOIN crée une nouvelle table de résultats en combinant les valeurs de colonne de deux tables (table1 et table2) en fonction du prédicat de jointure. La requête compare chaque ligne de table1 avec chaque ligne de table2 pour trouver toutes les paires de lignes qui satisfont le prédicat de jointure. Lorsque le prédicat de jointure est satisfait, les valeurs de colonne pour chaque paire correspondante de lignes A et B sont combinées dans une ligne de résultat.

Syntaxe

La syntaxe de base de INNER JOIN est la suivante.

SELECT table1.column1, table2.column2...
FROM table1
INNER JOIN table2
ON table1.common_field = table2.common_field;

Exemple

Considérez les deux tableaux suivants, l'un intitulé comme table CUSTOMERS et un autre intitulé comme table ORDERS comme suit -

+----+----------+-----+-----------+----------+
| ID |   NAME   | AGE |  ADDRESS  | SALARY   |
+----+----------+-----+-----------+----------+
| 1  |  Ramesh  | 32  | Ahmedabad | 2000.00  |
| 2  |  Khilan  | 25  |   Delhi   | 1500.00  |
| 3  |  kaushik | 23  |   Kota    | 2000.00  |
| 4  | Chaitali | 25  |   Mumbai  | 6500.00  |
| 5  |  Hardik  | 27  |   Bhopal  | 8500.00  |
| 6  |  Komal   | 22  |     MP    | 4500.00  |
| 7  |  Muffy   | 24  |   Indore  | 10000.00 |
+----+----------+-----+-----------+----------+

+-----+---------------------+-------------+--------+
| OID |         DATE        | CUSTOMER_ID | AMOUNT |
+-----+---------------------+-------------+--------+
| 102 | 2009-10-08 00:00:00 |      3      | 3000   |
| 100 | 2009-10-08 00:00:00 |      3      | 1500   |
| 101 | 2009-11-20 00:00:00 |      2      | 1560   |
| 103 | 2008-05-20 00:00:00 |      4      | 2060   |
+-----+---------------------+-------------+--------+

Maintenant, joignons ces deux tables en utilisant la requête INNER JOIN comme suit -

SELECT ID, NAME, AMOUNT, DATE FROM CUSTOMERS
INNER JOIN ORDERS
ON CUSTOMERS.ID = ORDERS.CUSTOMER_ID;

Après l'exécution de la requête ci-dessus, vous recevrez la sortie suivante.

+----+----------+--------+---------------------+
| ID |   NAME   | AMOUNT |         DATE        |
+----+----------+--------+---------------------+
| 3  |  kaushik |  3000  | 2009-10-08 00:00:00 |
| 3  |  kaushik |  1500  | 2009-10-08 00:00:00 |
| 2  |  Khilan  |  1560  | 2009-11-20 00:00:00 |
| 4  | Chaitali |  2060  | 2008-05-20 00:00:00 |
+----+----------+--------+---------------------+

Joint gauche

HSQLDB LEFT JOIN renvoie toutes les lignes de la table de gauche, même s'il n'y a aucune correspondance dans la table de droite. Cela signifie que si la clause ON correspond à 0 (zéro) enregistrements dans la table de droite, la jointure renverra toujours une ligne dans le résultat, mais avec NULL dans chaque colonne de la table de droite.

Cela signifie qu'une jointure gauche renvoie toutes les valeurs de la table de gauche, plus les valeurs correspondantes de la table de droite ou NULL en cas d'absence de prédicat de jointure correspondant.

Syntaxe

La syntaxe de base de LEFT JOIN est la suivante -

SELECT table1.column1, table2.column2...
FROM table1
LEFT JOIN table2
ON table1.common_field = table2.common_field;

Ici, la condition donnée peut être n'importe quelle expression donnée en fonction de vos besoins.

Exemple

Considérez les deux tableaux suivants, l'un intitulé comme table CUSTOMERS et un autre intitulé comme table ORDERS comme suit -

+----+----------+-----+-----------+----------+
| ID |   NAME   | AGE |  ADDRESS  | SALARY   |
+----+----------+-----+-----------+----------+
| 1  |  Ramesh  | 32  | Ahmedabad | 2000.00  |
| 2  |  Khilan  | 25  |   Delhi   | 1500.00  |
| 3  |  kaushik | 23  |   Kota    | 2000.00  |
| 4  | Chaitali | 25  |   Mumbai  | 6500.00  |
| 5  |  Hardik  | 27  |   Bhopal  | 8500.00  |
| 6  |  Komal   | 22  |    MP     | 4500.00  |
| 7  |  Muffy   | 24  |  Indore   | 10000.00 |
+----+----------+-----+-----------+----------+

+-----+---------------------+-------------+--------+
| OID |        DATE         | CUSTOMER_ID | AMOUNT |
+-----+---------------------+-------------+--------+
| 102 | 2009-10-08 00:00:00 |     3       | 3000   |
| 100 | 2009-10-08 00:00:00 |     3       | 1500   |
| 101 | 2009-11-20 00:00:00 |     2       | 1560   |
| 103 | 2008-05-20 00:00:00 |     4       | 2060   |
+-----+---------------------+-------------+--------+

Maintenant, joignons ces deux tables en utilisant la requête LEFT JOIN comme suit -

SELECT ID, NAME, AMOUNT, DATE FROM CUSTOMERS
LEFT JOIN ORDERS
ON CUSTOMERS.ID = ORDERS.CUSTOMER_ID;

Après l'exécution de la requête ci-dessus, vous recevrez la sortie suivante -

+----+----------+--------+---------------------+
| ID |   NAME   | AMOUNT |         DATE        |
+----+----------+--------+---------------------+
|  1 |  Ramesh  |  NULL  |        NULL         |
|  2 |  Khilan  |  1560  | 2009-11-20 00:00:00 |
|  3 |  kaushik |  3000  | 2009-10-08 00:00:00 |
|  3 |  kaushik |  1500  | 2009-10-08 00:00:00 |
|  4 | Chaitali |  2060  | 2008-05-20 00:00:00 |
|  5 |  Hardik  |  NULL  |        NULL         |
|  6 |  Komal   |  NULL  |        NULL         |
|  7 |  Muffy   |  NULL  |        NULL         |
+----+----------+--------+---------------------+

Jointure droite

HSQLDB RIGHT JOIN renvoie toutes les lignes de la table de droite, même s'il n'y a aucune correspondance dans la table de gauche. Cela signifie que si la clause ON correspond à 0 (zéro) enregistrements dans la table de gauche, la jointure renverra toujours une ligne dans le résultat, mais avec NULL dans chaque colonne de la table de gauche.

Cela signifie qu'une jointure droite renvoie toutes les valeurs de la table de droite, plus les valeurs correspondantes de la table de gauche ou NULL en cas d'absence de prédicat de jointure correspondant.

Syntaxe

La syntaxe de base de RIGHT JOIN est comme suit -

SELECT table1.column1, table2.column2...
FROM table1
RIGHT JOIN table2
ON table1.common_field = table2.common_field;

Exemple

Considérez les deux tableaux suivants, l'un intitulé comme table CUSTOMERS et un autre intitulé comme table ORDERS comme suit -

+----+----------+-----+-----------+----------+
| ID |   NAME   | AGE |  ADDRESS  |  SALARY  |
+----+----------+-----+-----------+----------+
| 1  |  Ramesh  | 32  | Ahmedabad |  2000.00 |
| 2  |  Khilan  | 25  |   Delhi   |  1500.00 |
| 3  |  kaushik | 23  |   Kota    |  2000.00 |
| 4  | Chaitali | 25  |   Mumbai  |  6500.00 |
| 5  |  Hardik  | 27  |   Bhopal  |  8500.00 |
| 6  |  Komal   | 22  |     MP    |  4500.00 |
| 7  |  Muffy   | 24  |   Indore  | 10000.00 |
+----+----------+-----+-----------+----------+

+-----+---------------------+-------------+--------+
| OID |       DATE          | CUSTOMER_ID | AMOUNT |
+-----+---------------------+-------------+--------+
| 102 | 2009-10-08 00:00:00 |      3      |  3000  |
| 100 | 2009-10-08 00:00:00 |      3      |  1500  |
| 101 | 2009-11-20 00:00:00 |      2      |  1560  |
| 103 | 2008-05-20 00:00:00 |      4      |  2060  |
+-----+---------------------+-------------+--------+

Maintenant, joignons ces deux tables en utilisant la requête RIGHT JOIN comme suit -

SELECT ID, NAME, AMOUNT, DATE FROM CUSTOMERS
RIGHT JOIN ORDERS
ON CUSTOMERS.ID = ORDERS.CUSTOMER_ID;

Après l'exécution de la requête ci-dessus, vous recevrez le résultat suivant.

+------+----------+--------+---------------------+
|  ID  |   NAME   | AMOUNT |        DATE         |
+------+----------+--------+---------------------+
|  3   |  kaushik |  3000  | 2009-10-08 00:00:00 |
|  3   |  kaushik |  1500  | 2009-10-08 00:00:00 |
|  2   |  Khilan  |  1560  | 2009-11-20 00:00:00 |
|  4   | Chaitali |  2060  | 2008-05-20 00:00:00 |
+------+----------+--------+---------------------+

Joindre complet

Le HSQLDB FULL JOIN combine les résultats des jointures externes gauche et droite.

La table jointe contiendra tous les enregistrements des deux tables et remplira les valeurs NULL pour les correspondances manquantes de chaque côté.

Syntaxe

La syntaxe de base de FULL JOIN est la suivante -

SELECT table1.column1, table2.column2...
FROM table1
FULL JOIN table2
ON table1.common_field = table2.common_field;

Ici, la condition donnée peut être n'importe quelle expression donnée en fonction de vos besoins.

Exemple

Considérez les deux tableaux suivants, l'un intitulé comme table CUSTOMERS et un autre intitulé comme table ORDERS comme suit -

+----+----------+-----+-----------+----------+
| ID |   NAME   | AGE |  ADDRESS  |  SALARY  |
+----+----------+-----+-----------+----------+
|  1 |  Ramesh  | 32  | Ahmedabad | 2000.00  |
|  2 |  Khilan  | 25  |   Delhi   | 1500.00  |
|  3 |  kaushik | 23  |   Kota    | 2000.00  |
|  4 | Chaitali | 25  |   Mumbai  | 6500.00  |
|  5 |  Hardik  | 27  |   Bhopal  | 8500.00  |
|  6 |  Komal   | 22  |   MP      | 4500.00  |
|  7 |  Muffy   | 24  |   Indore  | 10000.00 |
+----+----------+-----+-----------+----------+

+-----+---------------------+-------------+--------+
| OID |         DATE        | CUSTOMER_ID | AMOUNT |
+-----+---------------------+-------------+--------+
| 102 | 2009-10-08 00:00:00 |    3        | 3000   |
| 100 | 2009-10-08 00:00:00 |    3        | 1500   |
| 101 | 2009-11-20 00:00:00 |    2        | 1560   |
| 103 | 2008-05-20 00:00:00 |    4        | 2060   |
+-----+---------------------+-------------+--------+

Maintenant, joignons ces deux tables en utilisant la requête FULL JOIN comme suit -

SELECT ID, NAME, AMOUNT, DATE FROM CUSTOMERS
FULL JOIN ORDERS
ON CUSTOMERS.ID = ORDERS.CUSTOMER_ID;

Après l'exécution de la requête ci-dessus, vous recevrez le résultat suivant.

+------+----------+--------+---------------------+
|  ID  |    NAME  | AMOUNT |        DATE         |
+------+----------+--------+---------------------+
|   1  |  Ramesh  |  NULL  |        NULL         |
|   2  |  Khilan  |  1560  | 2009-11-20 00:00:00 |
|   3  |  kaushik |  3000  | 2009-10-08 00:00:00 |
|   3  |  kaushik |  1500  | 2009-10-08 00:00:00 |
|   4  | Chaitali |  2060  | 2008-05-20 00:00:00 |
|   5  |  Hardik  |  NULL  |        NULL         |
|   6  |   Komal  |  NULL  |        NULL         |
|   7  |   Muffy  |  NULL  |        NULL         |
|   3  |  kaushik |  3000  | 2009-10-08 00:00:00 |
|   3  |  kaushik |  1500  | 2009-10-08 00:00:00 |
|   2  |  Khilan  |  1560  | 2009-11-20 00:00:00 |
|   4  | Chaitali |  2060  | 2008-05-20 00:00:00 |
+------+----------+--------+---------------------+

Auto-rejoindre

Le SQL SELF JOIN est utilisé pour joindre une table à elle-même comme si la table était deux tables, renommant temporairement au moins une table dans l'instruction SQL.

Syntaxe

La syntaxe de base de SELF JOIN est la suivante -

SELECT a.column_name, b.column_name...
FROM table1 a, table1 b
WHERE a.common_field = b.common_field;

Ici, la clause WHERE peut être une expression donnée en fonction de vos besoins.

Exemple

Considérez les deux tableaux suivants, l'un intitulé comme table CUSTOMERS et un autre intitulé comme table ORDERS comme suit -

+----+----------+-----+-----------+----------+
| ID |    NAME  | AGE |   ADDRESS |   SALARY |
+----+----------+-----+-----------+----------+
|  1 |  Ramesh  |  32 | Ahmedabad | 2000.00  |
|  2 |  Khilan  |  25 |   Delhi   | 1500.00  |
|  3 |  kaushik |  23 |   Kota    | 2000.00  |
|  4 | Chaitali |  25 |   Mumbai  | 6500.00  |
|  5 |  Hardik  |  27 |   Bhopal  | 8500.00  |
|  6 |  Komal   |  22 |   MP      | 4500.00  |
|  7 |  Muffy   |  24 |   Indore  | 10000.00 |
+----+----------+-----+-----------+----------+

Maintenant, joignons cette table en utilisant la requête SELF JOIN comme suit -

SELECT a.ID, b.NAME, a.SALARY FROM CUSTOMERS a, CUSTOMERS b
WHERE a.SALARY > b.SALARY;

Après l'exécution de la requête ci-dessus, vous recevrez la sortie suivante -

+----+----------+---------+
| ID |   NAME   | SALARY  |
+----+----------+---------+
| 2  |  Ramesh  | 1500.00 |
| 2  |  kaushik | 1500.00 |
| 1  | Chaitali | 2000.00 |
| 2  | Chaitali | 1500.00 |
| 3  | Chaitali | 2000.00 |
| 6  | Chaitali | 4500.00 |
| 1  |  Hardik  | 2000.00 |
| 2  |  Hardik  | 1500.00 |
| 3  |  Hardik  | 2000.00 |
| 4  |  Hardik  | 6500.00 |
| 6  |  Hardik  | 4500.00 |
| 1  |  Komal   | 2000.00 |
| 2  |  Komal   | 1500.00 |
| 3  |  Komal   | 2000.00 |
| 1  |  Muffy   | 2000.00 |
| 2  |  Muffy   | 1500.00 |
| 3  |  Muffy   | 2000.00 |
| 4  |  Muffy   | 6500.00 |
| 5  |  Muffy   | 8500.00 |
| 6  |  Muffy   | 4500.00 |
+----+----------+---------+

SQL NULL est un terme utilisé pour représenter une valeur manquante. Une valeur NULL dans une table est une valeur dans un champ qui semble vide. Chaque fois que nous essayons de donner une condition, qui compare la valeur du champ ou de la colonne à NULL, cela ne fonctionne pas correctement.

Nous pouvons gérer les valeurs NULL en utilisant les trois choses.

  • IS NULL - L'opérateur renvoie true si la valeur de la colonne est NULL.

  • IS NOT NULL - L'opérateur renvoie true si la valeur de la colonne est NOT NULL.

  • <=> - L'opérateur compare les valeurs, ce qui (contrairement à l'opérateur =) est vrai même pour deux valeurs NULL.

Pour rechercher des colonnes NULL ou NOT NULL, utilisez respectivement IS NULL ou IS NOT NULL.

Exemple

Prenons un exemple où il y a une table tcount_tblqui contient deux colonnes, author et tutorial_count. Nous pouvons fournir des valeurs NULL au tutorial_count indique que l'auteur n'a même pas publié un seul tutoriel. Par conséquent, la valeur tutorial_count pour cet auteur respectif est NULL.

Exécutez les requêtes suivantes.

create table tcount_tbl(author varchar(40) NOT NULL, tutorial_count INT);
INSERT INTO tcount_tbl values ('Abdul S', 20);
INSERT INTO tcount_tbl values ('Ajith kumar', 5);
INSERT INTO tcount_tbl values ('Jen', NULL);
INSERT INTO tcount_tbl values ('Bavya kanna', 8);
INSERT INTO tcount_tbl values ('mahran', NULL);
INSERT INTO tcount_tbl values ('John Poul', 10);
INSERT INTO tcount_tbl values ('Sathya Murthi', 6);

Utilisez la commande suivante pour afficher tous les enregistrements du tcount_tbl table.

select * from tcount_tbl;

Après l'exécution de la commande ci-dessus, vous recevrez la sortie suivante.

+-----------------+----------------+
|     author      | tutorial_count |
+-----------------+----------------+
|      Abdul S    |      20        |
|    Ajith kumar  |      5         |
|        Jen      |     NULL       |
|    Bavya kanna  |      8         |
|       mahran    |     NULL       |
|     John Poul   |      10        |
|   Sathya Murthi |      6         |
+-----------------+----------------+

Pour trouver les enregistrements dans lesquels la colonne tutorial_count EST NULL, voici la requête.

SELECT * FROM tcount_tbl WHERE tutorial_count IS NULL;

Après l'exécution de la requête, vous recevrez la sortie suivante.

+-----------------+----------------+
|     author      | tutorial_count |
+-----------------+----------------+
|       Jen       |     NULL       |
|      mahran     |     NULL       |
+-----------------+----------------+

Pour rechercher les enregistrements dans lesquels la colonne tutorial_count N'EST PAS NULL, voici la requête.

SELECT * FROM tcount_tbl WHERE tutorial_count IS NOT NULL;

Après l'exécution de la requête, vous recevrez la sortie suivante.

+-----------------+----------------+
|      author     | tutorial_count |
+-----------------+----------------+
|      Abdul S    |      20        |
|     Ajith kumar |       5        |
|     Bavya kanna |       8        |
|     John Poul   |      10        |
|   Sathya Murthi |       6        |
+-----------------+----------------+

HSQLDB - Programme JDBC

Voici le programme JDBC qui récupère les enregistrements séparément de la table tcount_tbl où le tutorial_ count est NULL et le tutorial_count est NOT NULL. Enregistrez le programme suivant dansNullValues.java.

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;

public class NullValues {
   public static void main(String[] args) {
      Connection con = null;
      Statement stmt_is_null = null;
      Statement stmt_is_not_null = null;
      ResultSet result = null;
      try {
         Class.forName("org.hsqldb.jdbc.JDBCDriver");
         con = DriverManager.getConnection(
            "jdbc:hsqldb:hsql://localhost/testdb", "SA", "");
         stmt_is_null = con.createStatement();
         stmt_is_not_null = con.createStatement();
         result = stmt_is_null.executeQuery(
            "SELECT * FROM tcount_tbl WHERE tutorial_count IS NULL;");
         System.out.println("Records where the tutorial_count is NULL");
         
         while(result.next()){
            System.out.println(result.getString("author")+" |
            "+result.getInt("tutorial_count"));
         }
         result = stmt_is_not_null.executeQuery(
            "SELECT * FROM tcount_tbl WHERE tutorial_count IS NOT NULL;");
         System.out.println("Records where the tutorial_count is NOT NULL");
         
         while(result.next()){
            System.out.println(result.getString("author")+" |
            "+result.getInt("tutorial_count"));
         }
      } catch (Exception e) {
         e.printStackTrace(System.out);
      }
   }
}

Compilez et exécutez le programme ci-dessus à l'aide de la commande suivante.

\>javac NullValues.java
\>Java NullValues

Après l'exécution de la commande ci-dessus, vous recevrez la sortie suivante.

Records where the tutorial_count is NULL
Jen         | 0
mahran      | 0

Records where the tutorial_count is NOT NULL
Abdul S        | 20
Ajith kumar    | 5
Bavya kanna    | 8
John Poul      | 10
Sathya Murthi  | 6

HSQLDB prend en charge certains symboles spéciaux pour l'opération de correspondance de modèle basée sur des expressions régulières et l'opérateur REGEXP.

Voici le tableau des motifs, qui peut être utilisé avec l'opérateur REGEXP.

Modèle À quoi correspond le motif
^ Début de la chaîne
$ Fin de la chaîne
. Tout caractère unique
[...] Tout caractère répertorié entre les crochets
[^ ...] Tout caractère non répertorié entre les crochets
p1 | p2 | p3 Alternance; correspond à l'un des motifs p1, p2 ou p3
* Zéro ou plusieurs instances de l'élément précédent
+ Une ou plusieurs instances de l'élément précédent
{n} n instances de l'élément précédent
{m, n} m à n instances de l'élément précédent

Exemple

Essayons différents exemples de requêtes pour répondre à nos besoins. Jetez un œil aux requêtes suivantes.

Essayez cette requête pour trouver tous les auteurs dont le nom commence par «^ A».

SELECT author FROM tcount_tbl WHERE REGEXP_MATCHES(author,'^A.*');

Après l'exécution de la requête ci-dessus, vous recevrez la sortie suivante.

+-----------------+
|     author      |
+-----------------+
|     Abdul S     |
|    Ajith kumar  |
+-----------------+

Essayez cette requête pour trouver tous les auteurs dont le nom se termine par «ul $».

SELECT author FROM tcount_tbl WHERE REGEXP_MATCHES(author,'.*ul$');

Après l'exécution de la requête ci-dessus, vous recevrez la sortie suivante.

+-----------------+
|     author      |
+-----------------+
|    John Poul    |
+-----------------+

Essayez cette requête pour trouver tous les auteurs dont le nom contient «th».

SELECT author FROM tcount_tbl WHERE REGEXP_MATCHES(author,'.*th.*');

Après l'exécution de la requête ci-dessus, vous recevrez la sortie suivante.

+-----------------+
|     author      |
+-----------------+
|    Ajith kumar  | 
|     Abdul S     |
+-----------------+

Essayez cette requête pour trouver tous les auteurs dont le nom commence par voyelle (a, e, i, o, u).

SELECT author FROM tcount_tbl WHERE REGEXP_MATCHES(author,'^[AEIOU].*');

Après l'exécution de la requête ci-dessus, vous recevrez la sortie suivante.

+-----------------+
|     author      |
+-----------------+
|     Abdul S     |
|    Ajith kumar  |
+-----------------+

UNE Transactionest un groupe séquentiel d'opérations de manipulation de base de données, qui est effectué et considéré comme une seule unité de travail. En d'autres termes, lorsque toutes les opérations sont exécutées avec succès, alors seulement la transaction entière sera terminée. Si une opération au sein de la transaction échoue, la transaction entière échouera.

Propriétés des transactions

Fondamentalement, la transaction prend en charge 4 propriétés standard. Ils peuvent être appelés propriétés ACID.

Atomicity - Toutes les opérations des transactions sont exécutées avec succès, sinon la transaction est abandonnée au point d'échec et les opérations précédentes sont restaurées à leur position précédente.

Consistency - La base de données change correctement d'état après une transaction validée avec succès.

Isolation - Il permet à la transaction de fonctionner de manière indépendante et transparente les unes par rapport aux autres.

Durability - Le résultat ou l'effet d'une transaction validée persiste en cas de défaillance du système.

Commit, Rollback et Savepoint

Ces mots clés sont principalement utilisés pour les transactions HSQLDB.

Commit- La transaction réussie doit toujours être terminée en exécutant la commande COMMIT.

Rollback - Si un échec se produit dans la transaction, la commande ROLLBACK doit être exécutée pour ramener chaque table référencée dans la transaction à son état précédent.

Savepoint - Crée un point dans le groupe de transactions dans lequel revenir en arrière.

Exemple

L'exemple suivant explique le concept des transactions avec la validation, la restauration et le point de sauvegarde. Considérons la table Clients avec les colonnes id, nom, âge, adresse et salaire.

Id Nom Âge Adresse Un salaire
1 Ramesh 32 Ahmedabad 2000,00
2 Karun 25 Delhi 1500,00
3 Kaushik 23 Kota 2000,00
4 Chaitanya 25 Bombay 6500,00
5 Harish 27 Bhopal 8500,00
6 Kamesh 22 MP 1500,00
sept Murali 24 Indore 10000,00

Utilisez les commandes suivantes pour créer la table client en suivant les lignes des données ci-dessus.

CREATE TABLE Customer (id INT NOT NULL, name VARCHAR(100) NOT NULL, age INT NOT
NULL, address VARCHAR(20), Salary INT, PRIMARY KEY (id));
Insert into Customer values (1, "Ramesh", 32, "Ahmedabad", 2000);
Insert into Customer values (2, "Karun", 25, "Delhi", 1500);
Insert into Customer values (3, "Kaushik", 23, "Kota", 2000);
Insert into Customer values (4, "Chaitanya", 25, "Mumbai", 6500);
Insert into Customer values (5, "Harish", 27, "Bhopal", 8500);
Insert into Customer values (6, "Kamesh", 22, "MP", 1500);
Insert into Customer values (7, "Murali", 24, "Indore", 10000);

Exemple pour COMMIT

La requête suivante supprime les lignes de la table ayant age = 25 et utilise la commande COMMIT pour appliquer ces modifications dans la base de données.

DELETE FROM CUSTOMERS WHERE AGE = 25;
COMMIT;

Après l'exécution de la requête ci-dessus, vous recevrez la sortie suivante.

2 rows effected

Après l'exécution réussie de la commande ci-dessus, vérifiez les enregistrements de la table client en exécutant la commande ci-dessous.

Select * from Customer;

Après l'exécution de la requête ci-dessus, vous recevrez la sortie suivante.

+----+----------+-----+-----------+----------+
| ID |   NAME   | AGE |   ADDRESS |  SALARY  |
+----+----------+-----+-----------+----------+
| 1  |  Ramesh  |  32 | Ahmedabad |   2000   |
| 3  |  kaushik |  23 |   Kota    |   2000   |
| 5  |  Harish  |  27 |   Bhopal  |   8500   |
| 6  |  Kamesh  |  22 |    MP     |   4500   |
| 7  |  Murali  |  24 |   Indore  |   10000  |
+----+----------+-----+-----------+----------+

Exemple de restauration

Considérons la même table Client comme entrée.

Id Nom Âge Adresse Un salaire
1 Ramesh 32 Ahmedabad 2000,00
2 Karun 25 Delhi 1500,00
3 Kaushik 23 Kota 2000,00
4 Chaitanya 25 Bombay 6500,00
5 Harish 27 Bhopal 8500,00
6 Kamesh 22 MP 1500,00
sept Murali 24 Indore 10000,00

Voici l'exemple de requête qui explique la fonctionnalité de restauration en supprimant les enregistrements de la table ayant age = 25, puis en ROLLBACK les modifications dans la base de données.

DELETE FROM CUSTOMERS WHERE AGE = 25;
ROLLBACK;

Après l'exécution réussie des deux requêtes ci-dessus, vous pouvez afficher les données d'enregistrement dans la table Client à l'aide de la commande suivante.

Select * from Customer;

Après l'exécution de la commande ci-dessus, vous recevrez la sortie suivante.

+----+----------+-----+-----------+----------+
| ID |   NAME   | AGE |   ADDRESS |  SALARY  |
+----+----------+-----+-----------+----------+
|  1 |  Ramesh  |  32 | Ahmedabad |   2000   |
|  2 |  Karun   |  25 |   Delhi   |   1500   |
|  3 |  Kaushik |  23 |   Kota    |   2000   |
|  4 | Chaitanya|  25 |   Mumbai  |   6500   |
|  5 |  Harish  |  27 |   Bhopal  |   8500   |
|  6 |  Kamesh  |  22 |     MP    |   4500   |
|  7 |  Murali  |  24 |    Indore |   10000  |
+----+----------+-----+-----------+----------+

La requête de suppression supprime les données d'enregistrement des clients dont l'âge = 25. La commande Rollback annule ces modifications sur la table Customer.

Exemple pour Savepoint

Savepoint est un point dans une transaction où vous pouvez restaurer la transaction à un certain point sans annuler la transaction entière.

Considérons la même table Client comme entrée.

Id Nom Âge Adresse Un salaire
1 Ramesh 32 Ahmedabad 2000,00
2 Karun 25 Delhi 1500,00
3 Kaushik 23 Kota 2000,00
4 Chaitanya 25 Bombay 6500,00
5 Harish 27 Bhopal 8500,00
6 Kamesh 22 MP 1500,00
sept Murali 24 Indore 10000,00

Prenons dans cet exemple, vous prévoyez de supprimer les trois enregistrements différents de la table Clients. Vous souhaitez créer un point de sauvegarde avant chaque suppression, afin de pouvoir revenir à n'importe quel point de sauvegarde à tout moment pour ramener les données appropriées à leur état d'origine.

Voici la suite des opérations.

SAVEPOINT SP1;
DELETE FROM CUSTOMERS WHERE ID = 1;
SAVEPOINT SP2;
DELETE FROM CUSTOMERS WHERE ID = 2;
SAVEPOINT SP3;
DELETE FROM CUSTOMERS WHERE ID = 3;

Maintenant, vous avez créé trois points de sauvegarde et supprimé trois enregistrements. Dans ce cas, si vous souhaitez restaurer les enregistrements ayant les Id 2 et 3, utilisez la commande Rollback suivante.

ROLLBACK TO SP2;

Notez que seule la première suppression a eu lieu depuis que vous êtes revenu au SP2. Utilisez la requête suivante pour afficher tous les enregistrements des clients.

Select * from Customer;

Après l'exécution de la requête ci-dessus, vous recevrez la sortie suivante.

+----+----------+-----+-----------+----------+
| ID |   NAME   | AGE |   ADDRESS |  SALARY  |
+----+----------+-----+-----------+----------+
|  2 |   Karun  |  25 |  Delhi    |   1500   |
|  3 |  Kaushik |  23 |  Kota     |   2000   |
|  4 | Chaitanya|  25 |  Mumbai   |   6500   |
|  5 |  Harish  |  27 |  Bhopal   |   8500   |
|  6 |  Kamesh  |  22 |  MP       |   4500   |
|  7 |  Murali  |  24 |  Indore   |  10000   |
+----+----------+-----+-----------+----------+

Libérer le point de sauvegarde

Nous pouvons libérer le point de sauvegarde à l'aide de la commande RELEASE. Voici la syntaxe générique.

RELEASE SAVEPOINT SAVEPOINT_NAME;

Chaque fois qu'il est nécessaire de changer le nom d'une table ou d'un champ, de changer l'ordre des champs, de changer le type de données des champs ou toute structure de table, vous pouvez obtenir la même chose en utilisant la commande ALTER.

Exemple

Prenons un exemple qui explique la commande ALTER en utilisant différents scénarios.

Utilisez la requête suivante pour créer une table nommée testalter_tbl avec les champs ' id et name.

//below given query is to create a table testalter_tbl table.
create table testalter_tbl(id INT, name VARCHAR(10));

//below given query is to verify the table structure testalter_tbl.
Select * From INFORMATION_SCHEMA.SYSTEM_COLUMNS as C Where C.TABLE_SCHEM =
   'PUBLIC' AND C.TABLE_NAME = 'TESTALTER_TBL';

Après l'exécution de la requête ci-dessus, vous recevrez la sortie suivante.

+------------+-------------+------------+-----------+-----------+------------+
|TABLE_SCHEM |  TABLE_NAME | COLUMN_NAME| DATA_TYPE | TYPE_NAME | COLUMN_SIZE|
+------------+-------------+------------+-----------+-----------+------------+
|   PUBLIC   |TESTALTER_TBL|     ID     |     4     |   INTEGER |     4      |
|   PUBLIC   |TESTALTER_TBL|    NAME    |     12    |   VARCHAR |     10     |
+------------+-------------+------------+-----------+-----------+------------+

Déposer ou ajouter une colonne

Chaque fois que vous souhaitez SUPPRIMER une colonne existante de la table HSQLDB, vous pouvez utiliser la clause DROP avec la commande ALTER.

Utilisez la requête suivante pour supprimer une colonne (name) de la table testalter_tbl.

ALTER TABLE testalter_tbl DROP name;

Après l'exécution réussie de la requête ci-dessus, vous pouvez savoir si le champ de nom est supprimé de la table testalter_tbl à l'aide de la commande suivante.

Select * From INFORMATION_SCHEMA.SYSTEM_COLUMNS as C Where C.TABLE_SCHEM =
   'PUBLIC' AND C.TABLE_NAME = 'TESTALTER_TBL';

Après l'exécution de la commande ci-dessus, vous recevrez la sortie suivante.

+------------+-------------+------------+-----------+-----------+------------+
|TABLE_SCHEM |  TABLE_NAME | COLUMN_NAME| DATA_TYPE | TYPE_NAME | COLUMN_SIZE|
+------------+-------------+------------+-----------+-----------+------------+
|  PUBLIC    |TESTALTER_TBL|      ID    |      4    |   INTEGER |     4      |
+------------+-------------+------------+-----------+-----------+------------+

Chaque fois que vous souhaitez ajouter une colonne dans la table HSQLDB, vous pouvez utiliser la clause ADD avec la commande ALTER.

Utilisez la requête suivante pour ajouter une colonne nommée NAME à la table testalter_tbl.

ALTER TABLE testalter_tbl ADD name VARCHAR(10);

Après l'exécution réussie de la requête ci-dessus, vous pouvez savoir si le champ de nom est ajouté à la table testalter_tbl en utilisant la commande suivante.

Select * From INFORMATION_SCHEMA.SYSTEM_COLUMNS as C Where C.TABLE_SCHEM =
   'PUBLIC' AND C.TABLE_NAME = 'TESTALTER_TBL';

Après l'exécution de la requête ci-dessus, vous recevrez la sortie suivante.

+------------+-------------+------------+-----------+-----------+------------+
|TABLE_SCHEM |  TABLE_NAME | COLUMN_NAME| DATA_TYPE | TYPE_NAME | COLUMN_SIZE|
+------------+-------------+------------+-----------+-----------+------------+
|  PUBLIC    |TESTALTER_TBL|      ID    |     4     |   INTEGER |     4      |
|  PUBLIC    |TESTALTER_TBL|     NAME   |     12    |   VARCHAR |     10     |
+------------+-------------+------------+-----------+-----------+------------+

Modification d'une définition ou d'un nom de colonne

Chaque fois qu'il est nécessaire de modifier la définition de colonne, utilisez le MODIFY ou CHANGE clause avec la ALTER commander.

Prenons un exemple qui expliquera comment utiliser la clause CHANGE. La tabletestalter_tblcontient deux champs - id et name - ayant respectivement les types de données int et varchar. Essayons maintenant de changer le type de données de id de INT à BIGINT. Voici la requête pour effectuer le changement.

ALTER TABLE testalter_tbl CHANGE id id BIGINT;

Après l'exécution réussie de la requête ci-dessus, la structure de la table peut être vérifiée à l'aide de la commande suivante.

Select * From INFORMATION_SCHEMA.SYSTEM_COLUMNS as C Where C.TABLE_SCHEM =
   'PUBLIC' AND C.TABLE_NAME = 'TESTALTER_TBL';

Après l'exécution de la commande ci-dessus, vous recevrez la sortie suivante.

+------------+-------------+------------+-----------+-----------+------------+
|TABLE_SCHEM |  TABLE_NAME | COLUMN_NAME| DATA_TYPE | TYPE_NAME | COLUMN_SIZE|
+------------+-------------+------------+-----------+-----------+------------+
|  PUBLIC    |TESTALTER_TBL|      ID    |     4     |   BIGINT  |     4      |
|  PUBLIC    |TESTALTER_TBL|     NAME   |     12    |   VARCHAR |     10     |
+------------+-------------+------------+-----------+-----------+------------+

Essayons maintenant d'augmenter la taille d'une colonne NAME de 10 à 20 dans le testalter_tbltable. Voici la requête pour y parvenir en utilisant la clause MODIFY avec la commande ALTER.

ALTER TABLE testalter_tbl MODIFY name VARCHAR(20);

Après l'exécution réussie de la requête ci-dessus, la structure de la table peut être vérifiée à l'aide de la commande suivante.

Select * From INFORMATION_SCHEMA.SYSTEM_COLUMNS as C Where C.TABLE_SCHEM =
   'PUBLIC' AND C.TABLE_NAME = 'TESTALTER_TBL';

Après l'exécution de la commande ci-dessus, vous recevrez la sortie suivante.

+------------+-------------+------------+-----------+-----------+------------+
|TABLE_SCHEM |  TABLE_NAME | COLUMN_NAME| DATA_TYPE | TYPE_NAME | COLUMN_SIZE|
+------------+-------------+------------+-----------+-----------+------------+
|  PUBLIC    |TESTALTER_TBL|    ID      |      4    |    BIGINT |     4      |
|  PUBLIC    |TESTALTER_TBL|    NAME    |     12    |   VARCHAR |    20      |
+------------+-------------+------------+-----------+-----------+------------+

UNE database indexest une structure de données qui améliore la vitesse des opérations dans une table. Les index peuvent être créés en utilisant une ou plusieurs colonnes, fournissant la base à la fois à des recherches aléatoires rapides et à un ordre efficace d'accès aux enregistrements.

Lors de la création d'un index, il convient de prendre en compte les colonnes qui seront utilisées pour effectuer des requêtes SQL et de créer un ou plusieurs index sur ces colonnes.

En pratique, les index sont également des types de tables, qui conservent la clé primaire ou le champ d'index et un pointeur vers chaque enregistrement dans la table réelle.

Les utilisateurs ne peuvent pas voir les index. Ils sont simplement utilisés pour accélérer les requêtes et seront utilisés par le moteur de recherche de base de données pour localiser rapidement les enregistrements.

Les instructions INSERT et UPDATE prennent plus de temps sur les tables ayant des index, tandis que les instructions SELECT s'exécutent plus rapidement sur ces tables. La raison étant lors de l'insertion ou de la mise à jour, la base de données doit également insérer ou mettre à jour les valeurs d'index.

Index simple et unique

Vous pouvez créer un index unique sur une table. UNEunique indexsignifie que deux lignes ne peuvent pas avoir la même valeur d'index. Voici la syntaxe pour créer un index sur une table.

CREATE UNIQUE INDEX index_name
ON table_name (column1, column2,...);

Vous pouvez utiliser une ou plusieurs colonnes pour créer un index. Par exemple, créez un index sur tutorials_tbl à l'aide de tutorial_author.

CREATE UNIQUE INDEX AUTHOR_INDEX
ON tutorials_tbl (tutorial_author)

Vous pouvez créer un index simple sur une table. Omettez simplement le mot clé UNIQUE de la requête pour créer un index simple. UNEsimple index autorise les valeurs en double dans une table.

Si vous souhaitez indexer les valeurs d'une colonne dans un ordre décroissant, vous pouvez ajouter le mot réservé DESC après le nom de la colonne.

CREATE UNIQUE INDEX AUTHOR_INDEX
ON tutorials_tbl (tutorial_author DESC)

Commande ALTER pour ajouter et supprimer INDEX

Il existe quatre types d'instructions pour ajouter des index à une table -

  • ALTER TABLE tbl_name ADD PRIMARY KEY (column_list) - Cette instruction ajoute une PRIMARY KEY, ce qui signifie que les valeurs indexées doivent être uniques et ne peuvent pas être NULL.

  • ALTER TABLE tbl_name ADD UNIQUE index_name (column_list) - Cette instruction crée un index pour lequel les valeurs doivent être uniques (à l'exception des valeurs NULL, qui peuvent apparaître plusieurs fois).

  • ALTER TABLE tbl_name ADD INDEX index_name (column_list) - Cela ajoute un index ordinaire dans lequel toute valeur peut apparaître plusieurs fois.

  • ALTER TABLE tbl_name ADD FULLTEXT index_name (column_list) - Cela crée un index FULLTEXT spécial qui est utilisé à des fins de recherche de texte.

Voici la requête pour ajouter un index dans une table existante.

ALTER TABLE testalter_tbl ADD INDEX (c);

Vous pouvez supprimer n'importe quel INDEX en utilisant la clause DROP avec la commande ALTER. Voici la requête pour supprimer l'index créé ci-dessus.

ALTER TABLE testalter_tbl DROP INDEX (c);

Affichage des informations INDEX

Vous pouvez utiliser la commande SHOW INDEX pour lister tous les index associés à une table. La sortie au format vertical (spécifiée par \ G) est souvent utile avec cette instruction, pour éviter le bouclage de longues lignes.

Voici la syntaxe générique pour afficher les informations d'index sur une table.

SHOW INDEX FROM table_name\G