HSQLDB - Guida rapida

HyperSQL Database (HSQLDB) è un moderno gestore di database relazionale che è strettamente conforme allo standard SQL: 2011 e alle specifiche JDBC 4. Supporta tutte le funzionalità principali e RDBMS. HSQLDB viene utilizzato per lo sviluppo, il test e la distribuzione di applicazioni di database.

La caratteristica principale e unica di HSQLDB è la conformità agli standard. Può fornire l'accesso al database all'interno del processo dell'applicazione dell'utente, all'interno di un server delle applicazioni o come processo del server separato.

Caratteristiche di HSQLDB

• HSQLDB utilizza la struttura in memoria per operazioni veloci sul server DB. Utilizza la persistenza del disco in base alla flessibilità dell'utente, con un ripristino da arresto anomalo affidabile.

• HSQLDB è adatto anche per business intelligence, ETL e altre applicazioni che elaborano set di dati di grandi dimensioni.

• HSQLDB offre un'ampia gamma di opzioni di distribuzione aziendale, come transazioni XA, origini dati di pool di connessioni e autenticazione remota.

• HSQLDB è scritto nel linguaggio di programmazione Java e viene eseguito in una Java Virtual Machine (JVM). Supporta l'interfaccia JDBC per l'accesso al database.

Componenti di HSQLDB

Ci sono tre diversi componenti nel pacchetto jar HSQLDB.

• Motore HyperSQL RDBMS (HSQLDB)

• Driver JDBC HyperSQL

• Database Manager (strumento di accesso al database GUI, con versioni Swing e AWT)

HyperSQL RDBMS e JDBC Driver forniscono le funzionalità principali. I Database Manager sono strumenti di accesso al database generici che possono essere utilizzati con qualsiasi motore di database dotato di un driver JDBC.

Un jar aggiuntivo chiamato sqltool.jar, contiene Sql Tool, che è uno strumento di accesso al database della riga di comando. Questo è un comando generico. Strumento di accesso al database in linea che può essere utilizzato anche con altri motori di database.

HSQLDB è un sistema di gestione di database relazionali implementato in Java puro. Puoi incorporare facilmente questo database nella tua applicazione utilizzando JDBC. Oppure puoi usare le operazioni separatamente.

Prerequisiti

Segui i prerequisiti di installazione del software per HSQLDB.

Verifica l'installazione di Java

Poiché HSQLDB è un sistema di gestione di database relazionali implementato in Java puro, è necessario installare il software JDK (Java Development Kit) prima di installare HSQLDB. Se hai già installato JDK nel tuo sistema, prova il seguente comando per verificare la versione di Java.

java –version

Se JDK è stato installato con successo nel tuo sistema, otterrai il seguente output.

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)

Se non hai JDK installato nel tuo sistema, visita il seguente link per installare JDK.

Installazione di HSQLDB

Di seguito sono riportati i passaggi per installare HSQLDB.

Step 1 − Download HSQLDB bundle

Scarica l'ultima versione del database HSQLDB dal seguente collegamento https://sourceforge.net/projects/hsqldb/files/. Dopo aver fatto clic sul collegamento, otterrai il seguente screenshot.

Fare clic su HSQLDB e il download inizierà immediatamente. Infine, otterrai il file zip denominatohsqldb-2.3.4.zip.

Step 2 − Extract the HSQLDB zip file

Estrai il file zip e inseriscilo nel file C:\directory. Dopo l'estrazione, otterrai una struttura di file come mostrato nello screenshot seguente.

Step 3 − Create a default database

Non esiste un database predefinito per HSQLDB, quindi è necessario creare un database per HSQLDB. Creiamo un file delle proprietà denominatoserver.properties che definisce un nuovo database denominato demodb. Dai un'occhiata alle seguenti proprietà del server di database.

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

Posiziona questo file server.properties nella directory home di HSQLDB, ovvero C:\hsqldb- 2.3.4\hsqldb\.

Ora esegui il seguente comando sul prompt dei comandi.

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

Dopo l'esecuzione del comando precedente, riceverai lo stato del server come mostrato nello screenshot seguente.

Successivamente, troverai la seguente struttura di cartelle della directory hsqldb nella directory home di HSQLDB che è C:\hsqldb-2.3.4\hsqldb. Questi file sono file temporanei, file lck, file di registro, file delle proprietà e file di script del database demodb creato dal server di database HSQLDB.

Step 4 − Start the database server

Una volta terminata la creazione di un database, è necessario avviare il database utilizzando il seguente comando.

\>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

Dopo l'esecuzione del comando precedente, si ottiene il seguente stato.

Ora puoi aprire la schermata iniziale del database che è runManagerSwing.bat a partire dal C:\hsqldb-2.3.4\hsqldb\binPosizione. Questo file bat aprirà il file della GUI per il database HSQLDB. Prima di ciò, ti chiederà le impostazioni del database tramite una finestra di dialogo. Dai un'occhiata al seguente screenshot. In questa finestra di dialogo, inserisci il nome dell'impostazione, l'URL come mostrato sopra e fai clic su Ok.

Otterrai la schermata della GUI del database HSQLDB come mostrato nello screenshot seguente.

Nel capitolo sull'installazione, abbiamo discusso di come connettere il database manualmente. In questo capitolo, discuteremo come connettere il database a livello di programmazione (utilizzando la programmazione Java).

Dai un'occhiata al seguente programma, che avvierà il server e creerà una connessione tra l'applicazione Java e il database.

Esempio

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

Salva questo codice in ConnectDatabase.javafile. Dovrai avviare il database utilizzando il seguente comando.

\>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

È possibile utilizzare il seguente comando per compilare ed eseguire il codice.

\>javac ConnectDatabase.java
\>java ConnectDatabase

Dopo l'esecuzione del comando precedente, riceverai il seguente output:

Connection created successfully

Questo capitolo spiega i diversi tipi di dati di HSQLDB. Il server HSQLDB offre sei categorie di tipi di dati.

Tipi di dati numerici esatti

Tipo di dati	A partire dal	Per
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
tinyint	0	255
po	0	1
decimale	-10 ^ 38 +1	10 ^ 38-1
numerico	-10 ^ 38 +1	10 ^ 38-1
i soldi	-922.337.203.685.477.5808	+922.337.203.685.477.5807
smallmoney	-214.748,3648	+214.748.3647

Tipi di dati numerici approssimativi

Tipo di dati	A partire dal	Per
galleggiante	-1,79 E + 308	1,79 E + 308
vero	-3,40E + 38	3.40E + 38

Tipi di dati di data e ora

Tipo di dati	A partire dal	Per
appuntamento	1 gennaio 1753	31 dicembre 9999
smalldatetime	1 gennaio 1900	6 giugno 2079
Data	Memorizza una data come il 30 giugno 1991
tempo	Memorizza un'ora del giorno come le 12:30

Note - Qui, datetime ha una precisione di 3,33 millisecondi mentre il piccolo datetime ha una precisione di 1 minuto.

Tipi di dati di stringhe di caratteri

Tipo di dati	Descrizione
char	Lunghezza massima di 8.000 caratteri (caratteri non Unicode a lunghezza fissa)
varchar	Massimo 8.000 caratteri (dati non Unicode a lunghezza variabile)
varchar (max)	Lunghezza massima di 231 caratteri, dati non Unicode di lunghezza variabile (solo SQL Server 2005)
testo	Dati non Unicode a lunghezza variabile con una lunghezza massima di 2.147.483.647 caratteri

Tipi di dati di stringhe di caratteri Unicode

Tipo di dati	Descrizione
nchar	Lunghezza massima di 4.000 caratteri (Unicode a lunghezza fissa)
nvarchar	Lunghezza massima di 4.000 caratteri (lunghezza variabile Unicode)
nvarchar (max)	Lunghezza massima di 231 caratteri (solo SQL Server 2005), (lunghezza variabile Unicode)
ntext	Lunghezza massima di 1.073.741.823 caratteri (lunghezza variabile Unicode)

Tipi di dati binari

Tipo di dati	Descrizione
binario	Lunghezza massima di 8.000 byte (dati binari a lunghezza fissa)
varbinary	Lunghezza massima di 8.000 byte (dati binari a lunghezza variabile)
varbinary (max)	Lunghezza massima di 231 byte (solo SQL Server 2005), (dati binari a lunghezza variabile)
Immagine	Lunghezza massima di 2.147.483.647 byte (dati binari a lunghezza variabile)

Tipi di dati vari

Tipo di dati	Descrizione
sql_variant	Archivia i valori di vari tipi di dati supportati da SQL Server, ad eccezione di text, ntext e timestamp
timestamp	Memorizza un numero univoco a livello di database che viene aggiornato ogni volta che viene aggiornata una riga
identificativo unico	Memorizza un identificatore univoco globale (GUID)
xml	Memorizza i dati XML. È possibile archiviare istanze xml in una colonna o una variabile (solo SQL Server 2005)
cursore	Riferimento a un oggetto cursore
tavolo	Memorizza un set di risultati per l'elaborazione successiva

I requisiti obbligatori di base per creare una tabella sono il nome della tabella, i nomi dei campi e i tipi di dati di tali campi. Facoltativamente, puoi anche fornire i vincoli chiave alla tabella.

Sintassi

Dai un'occhiata alla seguente sintassi.

CREATE TABLE table_name (column_name column_type);

Esempio

Creiamo una tabella denominata tutorials_tbl con i nomi dei campi come id, title, author e submission_date. Dai un'occhiata alla seguente query.

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

Dopo l'esecuzione della query precedente, riceverai il seguente output:

(0) rows effected

HSQLDB - Programma JDBC

Di seguito è riportato il programma JDBC utilizzato per creare una tabella denominata tutorials_tbl nel database HSQLDB. Salvare il programma inCreateTable.java file.

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");
   }
}

È possibile avviare il database utilizzando il seguente comando.

\>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

Compilare ed eseguire il programma precedente utilizzando il seguente comando.

\>javac CreateTable.java
\>java CreateTable

Dopo l'esecuzione del comando precedente, riceverai il seguente output:

Table created successfully

È molto facile eliminare una tabella HSQLDB esistente. Tuttavia, è necessario prestare molta attenzione durante l'eliminazione di qualsiasi tabella esistente poiché i dati persi non verranno recuperati dopo l'eliminazione di una tabella.

Sintassi

Di seguito è riportata una sintassi SQL generica per eliminare una tabella HSQLDB.

DROP TABLE table_name;

Esempio

Consideriamo un esempio per eliminare una tabella denominata dipendente dal server HSQLDB. Di seguito è riportata la query per eliminare una tabella denominata dipendente.

DROP TABLE employee;

Dopo l'esecuzione della query precedente, riceverai il seguente output:

(0) rows effected

HSQLDB - Programma JDBC

Di seguito è riportato il programma JDBC utilizzato per eliminare il dipendente della tabella dal server HSQLDB.

Salva il codice seguente in DropTable.java file.

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");
   }
}

È possibile avviare il database utilizzando il seguente comando.

\>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

Compilare ed eseguire il programma precedente utilizzando il seguente comando.

\>javac DropTable.java
\>java DropTable

Dopo l'esecuzione del comando precedente, riceverai il seguente output:

Table dropped successfully

È possibile ottenere l'istruzione Inserisci query in HSQLDB utilizzando il comando INSERT INTO. È necessario fornire i dati definiti dall'utente seguendo l'ordine dei campi della colonna dalla tabella.

Sintassi

Di seguito è riportata la sintassi generica per INSERT una domanda.

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

Per inserire dati di tipo stringa in una tabella, sarà necessario utilizzare virgolette doppie o singole per fornire un valore stringa nell'istruzione di inserimento della query.

Esempio

Consideriamo un esempio che inserisce un record in una tabella denominata tutorials_tbl con i valori id = 100, title = Learn PHP, Author = John Poul e la data di invio è la data corrente.

Di seguito è riportata la query per l'esempio fornito.

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

Dopo l'esecuzione della query precedente, riceverai il seguente output:

1 row effected

HSQLDB - Programma JDBC

Ecco il programma JDBC per inserire il record nella tabella con i valori dati, id = 100, title = Learn PHP, Author = John Poul e la data di invio è la data corrente. Dai un'occhiata al programma indicato. Salva il codice nel fileInserQuery.java file.

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"); 
   } 
}

È possibile avviare il database utilizzando il seguente comando.

\>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

Compilare ed eseguire il programma precedente utilizzando il seguente comando.

\>javac InsertQuery.java 
\>java InsertQuery

Dopo l'esecuzione del comando precedente, riceverai il seguente output:

1 rows effected 
Rows inserted successfully

Prova a inserire i seguenti record nel file tutorials_tbl tabella utilizzando il INSERT INTO comando.

Id	Titolo	Autore	Data di presentazione
101	Impara C	Yaswanth	Adesso()
102	Impara MySQL	Abdul S	Adesso()
103	Impara Excell	Bavya kanna	Adesso()
104	Impara JDB	Ajith kumar	Adesso()
105	Impara Junit	Sathya Murthi	Adesso()

Il comando SELECT viene utilizzato per recuperare i dati del record dal database HSQLDB. Qui, è necessario menzionare l'elenco dei campi obbligatori nell'istruzione Select.

Sintassi

Ecco la sintassi generica per la query di selezione.

SELECT field1, field2,...fieldN table_name1, table_name2...
[WHERE Clause]
[OFFSET M ][LIMIT N]

• È possibile recuperare uno o più campi in un singolo comando SELECT.

• È possibile specificare asterisco (*) al posto dei campi. In questo caso, SELECT restituirà tutti i campi.

• È possibile specificare qualsiasi condizione utilizzando la clausola WHERE.

• È possibile specificare un offset utilizzando OFFSET da cui SELECT inizierà a restituire i record. Per impostazione predefinita, l'offset è zero.

• Puoi limitare il numero di resi utilizzando l'attributo LIMIT.

Esempio

Ecco un esempio che recupera i campi id, title e author di tutti i record da tutorials_tbltavolo. Possiamo ottenere ciò utilizzando l'istruzione SELECT. Di seguito è riportata la query per l'esempio.

SELECT id, title, author FROM tutorials_tbl

Dopo l'esecuzione della query precedente, riceverai il seguente output.

+------+----------------+-----------------+
|  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 - Programma JDBC

Ecco il programma JDBC che recupererà i campi id, titolo e autore di tutti i record da tutorials_tbltavolo. Salva il codice seguente nel fileSelectQuery.java file.

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

È possibile avviare il database utilizzando il seguente comando.

\>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

Compilare ed eseguire il codice precedente utilizzando il seguente comando.

\>javac SelectQuery.java
\>java SelectQuery

Dopo l'esecuzione del comando precedente, riceverai il seguente output:

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

Generalmente, utilizziamo il comando SELECT per recuperare i dati dalla tabella HSQLDB. Possiamo usare la clausola condizionale WHERE per filtrare i dati risultanti. Utilizzando WHERE possiamo specificare i criteri di selezione per selezionare i record richiesti da una tabella.

Sintassi

Di seguito è riportata la sintassi della clausola WHERE del comando SELECT per recuperare i dati dalla tabella HSQLDB.

SELECT field1, field2,...fieldN table_name1, table_name2...
[WHERE condition1 [AND [OR]] condition2.....

• È possibile utilizzare una o più tabelle separate da virgola per includere varie condizioni utilizzando una clausola WHERE, ma la clausola WHERE è una parte facoltativa del comando SELECT.

• È possibile specificare qualsiasi condizione utilizzando la clausola WHERE.

• È possibile specificare più di una condizione utilizzando gli operatori AND o OR.

• Una clausola WHERE può anche essere utilizzata insieme al comando SQL DELETE o UPDATE per specificare una condizione.

Possiamo filtrare i dati del record utilizzando le condizioni. Stiamo usando diversi operatori nella clausola WHERE condizionale. Di seguito è riportato l'elenco degli operatori, che possono essere utilizzati con la clausola WHERE.

Operatore	Descrizione	Esempio
=	Controlla se i valori di due operandi sono uguali o meno, in caso affermativo la condizione diventa vera.	(A = B) non è vero
! =	Controlla se i valori di due operandi sono uguali o meno, se i valori non sono uguali la condizione diventa vera.	(A! = B) è vero
>	Controlla se il valore dell'operando sinistro è maggiore del valore dell'operando destro, in caso affermativo la condizione diventa vera.	(A> B) non è vero
<	Verifica se il valore dell'operando sinistro è inferiore al valore dell'operando destro, in caso affermativo la condizione diventa vera.	(A <B) è vero
> =	Controlla se il valore dell'operando sinistro è maggiore o uguale al valore dell'operando destro, in caso affermativo la condizione diventa vera.	(A> = B) non è vero
<=	Controlla se il valore dell'operando sinistro è minore o uguale al valore dell'operando destro, in caso affermativo la condizione diventa vera.	(A <= B) è vero

Esempio

Di seguito è riportato un esempio che recupera i dettagli come id, titolo e l'autore del libro intitolato "Learn C". È possibile utilizzando la clausola WHERE nel comando SELECT. Di seguito è riportata la query per lo stesso.

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

Dopo l'esecuzione della query precedente, riceverai il seguente output.

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

HSQLDB - Programma JDBC

Ecco il programma JDBC che recupera i dati del record dalla tabella tutorials_tblhaving il titolo Learn C. Salva il codice seguente inWhereClause.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);
      }
   }

}

È possibile avviare il database utilizzando il seguente comando.

\>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

Compilare ed eseguire il codice precedente utilizzando il seguente comando.

\>javac WhereClause.java
\>java WhereClause

Dopo l'esecuzione del comando precedente, riceverai il seguente output.

101 | Learn C | Yaswanth

Ogni volta che si desidera modificare i valori di una tabella, è possibile utilizzare il comando UPDATE. Ciò modificherà qualsiasi valore di campo da qualsiasi tabella HSQLDB.

Sintassi

Ecco la sintassi generica per il comando UPDATE.

UPDATE table_name SET field1 = new-value1, field2 = new-value2 [WHERE Clause]

• Puoi aggiornare uno o più campi insieme.
• È possibile specificare qualsiasi condizione utilizzando la clausola WHERE.
• È possibile aggiornare i valori in una singola tabella alla volta.

Esempio

Si consideri un esempio che aggiorna il titolo del tutorial da "Learn C" a "C and Data Structures" con id "101". Di seguito è riportata la query per l'aggiornamento.

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

Dopo l'esecuzione della query precedente, riceverai il seguente output.

(1) Rows effected

HSQLDB - Programma JDBC

Ecco il programma JDBC che aggiornerà il titolo di un tutorial da Learn C per C and Data Structures avere un id 101. Salvare il seguente programma nel fileUpdateQuery.java file.

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");
   }
}

È possibile avviare il database utilizzando il seguente comando.

\>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

Compilare ed eseguire il programma precedente utilizzando il seguente comando.

\>javac UpdateQuery.java
\>java UpdateQuery

Dopo l'esecuzione del comando precedente, riceverai il seguente output:

1 Rows effected

Ogni volta che si desidera eliminare un record da qualsiasi tabella HSQLDB, è possibile utilizzare il comando DELETE FROM.

Sintassi

Ecco la sintassi generica per il comando DELETE per eliminare i dati da una tabella HSQLDB.

DELETE FROM table_name [WHERE Clause]

• Se la clausola WHERE non è specificata, tutti i record verranno eliminati dalla tabella MySQL data.

• È possibile specificare qualsiasi condizione utilizzando la clausola WHERE.

• È possibile eliminare i record in una singola tabella alla volta.

Esempio

Consideriamo un esempio che cancella i dati del record dalla tabella denominata tutorials_tbl avendo id 105. Di seguito è riportata la query che implementa l'esempio fornito.

DELETE FROM tutorials_tbl WHERE id = 105;

Dopo l'esecuzione della query precedente, riceverai il seguente output:

(1) rows effected

HSQLDB - Programma JDBC

Ecco il programma JDBC che implementa l'esempio fornito. Salva il seguente programma inDeleteQuery.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");
   }
}

È possibile avviare il database utilizzando il seguente comando.

\>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

Compilare ed eseguire il programma precedente utilizzando il seguente comando.

\>javac DeleteQuery.java
\>java DeleteQuery

Dopo l'esecuzione del comando precedente, riceverai il seguente output:

1 Rows effected

C'è una clausola WHERE nella struttura RDBMS. Puoi usare la clausola WHERE con un segno di uguale a (=) dove vogliamo fare una corrispondenza esatta. Ma potrebbe esserci un requisito in cui si desidera filtrare tutti i risultati in cui il nome dell'autore deve contenere "john". Questo può essere gestito utilizzando la clausola SQL LIKE insieme alla clausola WHERE.

Se la clausola SQL LIKE viene utilizzata insieme ai caratteri%, funzionerà come un metacarattere (*) in UNIX mentre elenca tutti i file o le directory al prompt dei comandi.

Sintassi

Di seguito è riportata la sintassi SQL generica della clausola LIKE.

SELECT field1, field2,...fieldN table_name1, table_name2...
WHERE field1 LIKE condition1 [AND [OR]] filed2 = 'somevalue'

• È possibile specificare qualsiasi condizione utilizzando la clausola WHERE.

• È possibile utilizzare la clausola LIKE insieme alla clausola WHERE.

• È possibile utilizzare la clausola LIKE al posto del segno di uguale a.

• Quando la clausola LIKE viene utilizzata insieme al segno%, funzionerà come una ricerca di metacaratteri.

• È possibile specificare più di una condizione utilizzando gli operatori AND o OR.

• Una clausola WHERE ... LIKE può essere utilizzata insieme al comando DELETE o UPDATE SQL per specificare una condizione.

Esempio

Consideriamo un esempio che recupera l'elenco dei dati delle esercitazioni con cui inizia il nome dell'autore John. Di seguito è riportata la query HSQLDB per l'esempio fornito.

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

Dopo l'esecuzione della query precedente, riceverai il seguente output.

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

HSQLDB - Programma JDBC

Di seguito è riportato il programma JDBC che recupera l'elenco dei dati delle esercitazioni con cui inizia il nome dell'autore John. Salva il codice inLikeClause.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);
      }
   }
}

È possibile avviare il database utilizzando il seguente comando.

\>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

Compilare ed eseguire il codice precedente utilizzando il seguente comando.

\>javac LikeClause.java
\>java LikeClause

Dopo l'esecuzione del seguente comando, riceverai il seguente output.

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

Il comando SQL SELECT recupera i dati dalla tabella HSQLDB ogni volta che è presente un requisito che segue un ordine particolare durante il recupero e la visualizzazione dei record. In tal caso, possiamo usare ilORDER BY clausola.

Sintassi

Ecco la sintassi del comando SELECT insieme alla clausola ORDER BY per ordinare i dati da HSQLDB.

SELECT field1, field2,...fieldN table_name1, table_name2...
ORDER BY field1, [field2...] [ASC [DESC]]

• È possibile ordinare il risultato restituito su qualsiasi campo a condizione che il campo sia elencato.

• Puoi ordinare il risultato su più di un campo.

• È possibile utilizzare la parola chiave ASC o DESC per ottenere il risultato in ordine crescente o decrescente. Per impostazione predefinita, è in ordine crescente.

• È possibile utilizzare la clausola WHERE ... LIKE nel modo consueto per inserire una condizione.

Esempio

Consideriamo un esempio che recupera e ordina i record di tutorials_tbltabella ordinando il nome dell'autore in ordine crescente. Di seguito è riportata la query per lo stesso.

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

Dopo l'esecuzione della query precedente, riceverai il seguente output.

+------+----------------+-----------------+
| 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 - Programma JDBC

Ecco il programma JDBC che recupera e ordina i record di tutorials_tbltabella ordinando il nome dell'autore in ordine crescente. Salva il seguente programma inOrderBy.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);
      }
   }
}

È possibile avviare il database utilizzando il seguente comando.

\>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

Compilare ed eseguire il programma precedente utilizzando il seguente comando.

\>javac OrderBy.java
\>java OrderBy

Dopo l'esecuzione del comando precedente, riceverai il seguente output.

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

Ogni volta che è necessario recuperare i dati da più tabelle utilizzando una singola query, è possibile utilizzare JOINS da RDBMS. È possibile utilizzare più tabelle nella singola query SQL. L'atto di unirsi in HSQLDB si riferisce a frantumare due o più tabelle in una singola tabella.

Considera le seguenti tabelle Clienti e Ordini.

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  |
+-----+---------------------+-------------+--------+

Ora, proviamo a recuperare i dati dei clienti e l'importo dell'ordine che il rispettivo cliente ha effettuato. Ciò significa che stiamo recuperando i dati dei record sia dalla tabella dei clienti che da quella degli ordini. Possiamo ottenere ciò utilizzando il concetto JOINS in HSQLDB. Di seguito è la query JOIN per lo stesso.

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

Dopo l'esecuzione della query precedente, riceverai il seguente output.

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

Tipi di JOIN

Sono disponibili diversi tipi di join in HSQLDB.

• INNER JOIN - Restituisce le righe quando c'è una corrispondenza in entrambe le tabelle.

• LEFT JOIN - Restituisce tutte le righe della tabella di sinistra, anche se non ci sono corrispondenze nella tabella di destra.

• RIGHT JOIN - Restituisce tutte le righe della tabella di destra, anche se non ci sono corrispondenze nella tabella di sinistra.

• FULL JOIN - Restituisce le righe quando c'è una corrispondenza in una delle tabelle.

• SELF JOIN - Utilizzato per unire una tabella a se stessa come se la tabella fosse due tabelle, rinominando temporaneamente almeno una tabella nell'istruzione SQL.

Inner Join

Il join più utilizzato e importante è INNER JOIN. Viene anche definito EQUIJOIN.

INNER JOIN crea una nuova tabella dei risultati combinando i valori di colonna di due tabelle (table1 e table2) in base al predicato di join. La query confronta ogni riga di table1 con ogni riga di table2 per trovare tutte le coppie di righe che soddisfano il predicato di join. Quando il predicato di join è soddisfatto, i valori di colonna per ciascuna coppia di righe A e B abbinate vengono combinati in una riga di risultati.

Sintassi

La sintassi di base di INNER JOIN è la seguente.

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

Esempio

Considera le seguenti due tabelle, una intitolata tabella CLIENTI e un'altra intitolata tabella ORDINI come segue:

+----+----------+-----+-----------+----------+
| 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   |
+-----+---------------------+-------------+--------+

Ora, uniamo queste due tabelle usando la query INNER JOIN come segue:

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

Dopo l'esecuzione della query precedente, riceverai il seguente output.

+----+----------+--------+---------------------+
| 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 |
+----+----------+--------+---------------------+

Unisciti a sinistra

HSQLDB LEFT JOIN restituisce tutte le righe dalla tabella di sinistra, anche se non ci sono corrispondenze nella tabella di destra. Ciò significa che se la clausola ON corrisponde a 0 (zero) record nella tabella di destra, il join restituirà comunque una riga nel risultato, ma con NULL in ogni colonna della tabella di destra.

Ciò significa che un join sinistro restituisce tutti i valori dalla tabella di sinistra, più i valori corrispondenti dalla tabella di destra o NULL in caso di nessun predicato di join corrispondente.

Sintassi

La sintassi di base di LEFT JOIN è la seguente:

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

Qui la condizione data potrebbe essere qualsiasi espressione data in base alle tue esigenze.

Esempio

Considera le seguenti due tabelle, una intitolata tabella CLIENTI e un'altra intitolata tabella ORDINI come segue:

+----+----------+-----+-----------+----------+
| 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   |
+-----+---------------------+-------------+--------+

Ora, uniamo queste due tabelle utilizzando la query LEFT JOIN come segue:

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

Dopo l'esecuzione della query precedente, riceverai il seguente output:

+----+----------+--------+---------------------+
| 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         |
+----+----------+--------+---------------------+

Right Join

HSQLDB RIGHT JOIN restituisce tutte le righe della tabella di destra, anche se non sono presenti corrispondenze nella tabella di sinistra. Ciò significa che se la clausola ON corrisponde a 0 (zero) record nella tabella di sinistra, il join restituirà comunque una riga nel risultato, ma con NULL in ogni colonna della tabella di sinistra.

Ciò significa che un join destro restituisce tutti i valori dalla tabella di destra, più i valori corrispondenti dalla tabella di sinistra o NULL in caso di nessun predicato di join corrispondente.

Sintassi

La sintassi di base di RIGHT JOIN è il seguente -

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

Esempio

Considera le seguenti due tabelle, una intitolata tabella CLIENTI e un'altra intitolata tabella ORDINI come segue:

+----+----------+-----+-----------+----------+
| 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  |
+-----+---------------------+-------------+--------+

Ora, uniamo queste due tabelle usando la query RIGHT JOIN come segue:

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

Dopo l'esecuzione della query precedente, riceverai il seguente risultato.

+------+----------+--------+---------------------+
|  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 |
+------+----------+--------+---------------------+

Join completo

HSQLDB FULL JOIN combina i risultati dei join esterni sinistro e destro.

La tabella unita conterrà tutti i record di entrambe le tabelle e inserirà NULL per le corrispondenze mancanti su entrambi i lati.

Sintassi

La sintassi di base di FULL JOIN è la seguente:

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

Qui la condizione data potrebbe essere qualsiasi espressione data in base alle tue esigenze.

Esempio

Considera le seguenti due tabelle, una intitolata tabella CLIENTI e un'altra intitolata tabella ORDINI come segue:

+----+----------+-----+-----------+----------+
| 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   |
+-----+---------------------+-------------+--------+

Ora, uniamo queste due tabelle usando la query FULL JOIN come segue:

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

Dopo l'esecuzione della query precedente, riceverai il seguente risultato.

+------+----------+--------+---------------------+
|  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 |
+------+----------+--------+---------------------+

Self Join

SQL SELF JOIN viene utilizzato per unire una tabella a se stessa come se la tabella fosse due tabelle, rinominando temporaneamente almeno una tabella nell'istruzione SQL.

Sintassi

La sintassi di base di SELF JOIN è la seguente:

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

In questo caso, la clausola WHERE potrebbe essere una qualsiasi espressione in base alle tue esigenze.

Esempio

Considera le seguenti due tabelle, una intitolata tabella CLIENTI e un'altra intitolata tabella ORDINI come segue:

+----+----------+-----+-----------+----------+
| 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 |
+----+----------+-----+-----------+----------+

Ora, uniamoci a questa tabella utilizzando la query SELF JOIN come segue:

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

Dopo l'esecuzione della query precedente, riceverai il seguente output:

+----+----------+---------+
| 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 è un termine utilizzato per rappresentare un valore mancante. Un valore NULL in una tabella è un valore in un campo che sembra essere vuoto. Ogni volta che proviamo a dare una condizione, che confronta il valore del campo o della colonna con NULL, non funziona correttamente.

Possiamo gestire i valori NULL usando le tre cose.

• IS NULL - L'operatore restituisce true se il valore della colonna è NULL.

• IS NOT NULL - L'operatore restituisce true se il valore della colonna NON è NULL.

• <=> - L'operatore confronta i valori, che (a differenza dell'operatore =) è vero anche per due valori NULL.

Per cercare colonne NULL o NOT NULL, utilizzare rispettivamente IS NULL o IS NOT NULL.

Esempio

Consideriamo un esempio in cui è presente un tavolo tcount_tblche contiene due colonne, autore e tutorial_count. Possiamo fornire valori NULL a tutorial_count indica che l'autore non ha pubblicato nemmeno un tutorial. Pertanto, il valore tutorial_count per il rispettivo autore è NULL.

Esegui le seguenti query.

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);

Utilizzare il comando seguente per visualizzare tutti i record dal file tcount_tbl tavolo.

select * from tcount_tbl;

Dopo l'esecuzione del comando precedente, riceverai il seguente output.

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

Per trovare i record in cui la colonna tutorial_count È NULL, la seguente è la query.

SELECT * FROM tcount_tbl WHERE tutorial_count IS NULL;

Dopo l'esecuzione della query, riceverai il seguente output.

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

Per trovare i record in cui la colonna tutorial_count NON È NULL, la seguente è la query.

SELECT * FROM tcount_tbl WHERE tutorial_count IS NOT NULL;

Dopo l'esecuzione della query, riceverai il seguente output.

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

HSQLDB - Programma JDBC

Ecco il programma JDBC che recupera i record separatamente dalla tabella tcount_tbl dove tutorial_ count è NULL e tutorial_count è NOT NULL. Salva il seguente programma inNullValues.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);
      }
   }
}

Compilare ed eseguire il programma precedente utilizzando il seguente comando.

\>javac NullValues.java
\>Java NullValues

Dopo l'esecuzione del comando precedente, riceverai il seguente output.

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 supporta alcuni simboli speciali per operazioni di corrispondenza dei modelli basate su espressioni regolari e l'operatore REGEXP.

Di seguito è riportata la tabella del modello, che può essere utilizzata insieme all'operatore REGEXP.

Modello	Ciò che il modello corrisponde
^	Inizio della stringa
$	Fine della stringa
.	Qualsiasi singolo carattere
[...]	Qualsiasi carattere elencato tra parentesi quadre
[^ ...]	Qualsiasi carattere non elencato tra parentesi quadre
p1 | p2 | p3	Alternanza; corrisponde a uno qualsiasi dei modelli p1, p2 o p3
*	Zero o più istanze dell'elemento precedente
+	Una o più istanze dell'elemento precedente
{n}	n istanze dell'elemento precedente
{m, n}	da m a n istanze dell'elemento precedente

Esempio

Proviamo con diverse query di esempio per soddisfare i nostri requisiti. Dai un'occhiata alle seguenti domande.

Prova questa query per trovare tutti gli autori il cui nome inizia con "^ A".

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

Dopo l'esecuzione della query precedente, riceverai il seguente output.

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

Prova questa query per trovare tutti gli autori il cui nome termina con "ul $".

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

Dopo l'esecuzione della query precedente, riceverai il seguente output.

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

Prova questa query per trovare tutti gli autori il cui nome contiene "th".

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

Dopo l'esecuzione della query precedente, riceverai il seguente output.

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

Prova questa query per trovare tutti gli autori il cui nome inizia con la vocale (a, e, i, o, u).

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

Dopo l'esecuzione della query precedente, riceverai il seguente output.

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

UN Transactionè un gruppo sequenziale di operazioni di manipolazione del database, che viene eseguito e considerato come una singola unità di lavoro. In altre parole, quando tutte le operazioni sono state eseguite con successo, solo allora l'intera transazione sarà completata. Se qualsiasi operazione all'interno della transazione fallisce, l'intera transazione fallirà.

Proprietà delle transazioni

Fondamentalmente, la transazione supporta 4 proprietà standard. Possono essere denominate proprietà ACID.

Atomicity - Tutte le operazioni nelle transazioni vengono eseguite con successo, altrimenti la transazione viene interrotta al punto di errore e le operazioni precedenti vengono riportate alla posizione precedente.

Consistency - Il database cambia correttamente gli stati su una transazione confermata con successo.

Isolation - Consente alla transazione di operare in modo indipendente e trasparente l'uno con l'altro.

Durability - Il risultato o l'effetto di una transazione confermata persiste in caso di guasto del sistema.

Commit, Rollback e Savepoint

Queste parole chiave vengono utilizzate principalmente per le transazioni HSQLDB.

Commit- La transazione andata a buon fine deve essere sempre completata eseguendo il comando COMMIT.

Rollback - Se si verifica un errore nella transazione, è necessario eseguire il comando ROLLBACK per riportare ogni tabella a cui si fa riferimento nella transazione al suo stato precedente.

Savepoint - Crea un punto all'interno del gruppo di transazioni in cui eseguire il rollback.

Esempio

Il seguente esempio spiega il concetto di transazioni insieme a commit, rollback e Savepoint. Consideriamo la tabella Clienti con le colonne id, nome, età, indirizzo e stipendio.

Id	Nome	Età	Indirizzo	Stipendio
1	Ramesh	32	Ahmedabad	2000.00
2	Karun	25	Delhi	1500.00
3	Kaushik	23	Kota	2000.00
4	Chaitanya	25	Mumbai	6500.00
5	Harish	27	Bhopal	8500.00
6	Kamesh	22	MP	1500.00
7	Murali	24	Indore	10000.00

Utilizzare i seguenti comandi per creare la tabella dei clienti sulla falsariga dei dati precedenti.

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);

Esempio per COMMIT

La seguente query elimina le righe dalla tabella con età = 25 e utilizza il comando COMMIT per applicare tali modifiche nel database.

DELETE FROM CUSTOMERS WHERE AGE = 25;
COMMIT;

Dopo l'esecuzione della query precedente, riceverai il seguente output.

2 rows effected

Dopo aver eseguito correttamente il comando precedente, controllare i record della tabella clienti eseguendo il comando indicato di seguito.

Select * from Customer;

Dopo l'esecuzione della query precedente, riceverai il seguente output.

+----+----------+-----+-----------+----------+
| 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  |
+----+----------+-----+-----------+----------+

Esempio di rollback

Consideriamo la stessa tabella Customer come input.

Id	Nome	Età	Indirizzo	Stipendio
1	Ramesh	32	Ahmedabad	2000.00
2	Karun	25	Delhi	1500.00
3	Kaushik	23	Kota	2000.00
4	Chaitanya	25	Mumbai	6500.00
5	Harish	27	Bhopal	8500.00
6	Kamesh	22	MP	1500.00
7	Murali	24	Indore	10000.00

Ecco la query di esempio che spiega la funzionalità di rollback eliminando i record dalla tabella con età = 25 e quindi ROLLBACK le modifiche nel database.

DELETE FROM CUSTOMERS WHERE AGE = 25;
ROLLBACK;

Dopo aver eseguito correttamente le due query precedenti, è possibile visualizzare i dati del record nella tabella Customer utilizzando il seguente comando.

Select * from Customer;

Dopo l'esecuzione del comando precedente, riceverai il seguente output.

+----+----------+-----+-----------+----------+
| 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 query di eliminazione elimina i dati del record dei clienti la cui età = 25. Il comando Rollback esegue il rollback di tali modifiche nella tabella Customer.

Esempio per Savepoint

Il punto di salvataggio è un punto in una transazione in cui puoi riportare la transazione a un certo punto senza ripristinare l'intera transazione.

Consideriamo la stessa tabella Customer come input.

Id	Nome	Età	Indirizzo	Stipendio
1	Ramesh	32	Ahmedabad	2000.00
2	Karun	25	Delhi	1500.00
3	Kaushik	23	Kota	2000.00
4	Chaitanya	25	Mumbai	6500.00
5	Harish	27	Bhopal	8500.00
6	Kamesh	22	MP	1500.00
7	Murali	24	Indore	10000.00

Consideriamo in questo esempio, si prevede di eliminare i tre diversi record dalla tabella Clienti. Si desidera creare un punto di salvataggio prima di ogni eliminazione, in modo da poter tornare a qualsiasi punto di salvataggio in qualsiasi momento per riportare i dati appropriati al loro stato originale.

Ecco la serie di operazioni.

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

Ora hai creato tre punti di salvataggio e cancellato tre record. In questa situazione, se si desidera ripristinare i record con ID 2 e 3, utilizzare il seguente comando Rollback.

ROLLBACK TO SP2;

Si noti che è stata eseguita solo la prima eliminazione da quando è stato eseguito il rollback a SP2. Utilizza la seguente query per visualizzare tutti i record dei clienti.

Select * from Customer;

Dopo l'esecuzione della query precedente, riceverai il seguente output.

+----+----------+-----+-----------+----------+
| 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   |
+----+----------+-----+-----------+----------+

Rilascia Savepoint

Possiamo rilasciare il punto di salvataggio usando il comando RELEASE. Di seguito è riportata la sintassi generica.

RELEASE SAVEPOINT SAVEPOINT_NAME;

Ogni volta che è necessario modificare il nome di una tabella o di un campo, modificare l'ordine dei campi, modificare il tipo di dati dei campi o qualsiasi struttura di tabella, è possibile ottenere lo stesso risultato utilizzando il comando ALTER.

Esempio

Consideriamo un esempio che spiega il comando ALTER utilizzando diversi scenari.

Utilizza la seguente query per creare una tabella denominata testalter_tbl con i campi ' id e 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';

Dopo l'esecuzione della query precedente, riceverai il seguente output.

+------------+-------------+------------+-----------+-----------+------------+
|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     |
+------------+-------------+------------+-----------+-----------+------------+

Eliminazione o aggiunta di una colonna

Ogni volta che si desidera DROP una colonna esistente dalla tabella HSQLDB, è possibile utilizzare la clausola DROP insieme al comando ALTER.

Utilizzare la seguente query per eliminare una colonna (name) dalla tabella testalter_tbl.

ALTER TABLE testalter_tbl DROP name;

Dopo aver eseguito con successo la query di cui sopra, puoi sapere se il campo del nome è stato eliminato dalla tabella testalter_tbl utilizzando il seguente comando.

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

Dopo l'esecuzione del comando precedente, riceverai il seguente output.

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

Ogni volta che si desidera aggiungere una colonna alla tabella HSQLDB, è possibile utilizzare la clausola ADD insieme al comando ALTER.

Utilizza la seguente query per aggiungere una colonna denominata NAME al tavolo testalter_tbl.

ALTER TABLE testalter_tbl ADD name VARCHAR(10);

Dopo aver eseguito con successo la query sopra, puoi sapere se il campo del nome è stato aggiunto alla tabella testalter_tbl utilizzando il seguente comando.

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

Dopo l'esecuzione della query precedente, riceverai il seguente output.

+------------+-------------+------------+-----------+-----------+------------+
|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     |
+------------+-------------+------------+-----------+-----------+------------+

Modifica della definizione o del nome di una colonna

Ogni volta che è necessario modificare la definizione della colonna, utilizzare il MODIFY o CHANGE clausola insieme alla ALTER comando.

Consideriamo un esempio che spiegherà come utilizzare la clausola CHANGE. La tavolatestalter_tblcontiene due campi, id e nome, con tipi di dati rispettivamente int e varchar. Ora proviamo a cambiare il tipo di dati di id da INT a BIGINT. Di seguito è riportata la query per apportare la modifica.

ALTER TABLE testalter_tbl CHANGE id id BIGINT;

Dopo aver eseguito con successo la query precedente, la struttura della tabella può essere verificata utilizzando il seguente comando.

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

Dopo l'esecuzione del comando precedente, riceverai il seguente output.

+------------+-------------+------------+-----------+-----------+------------+
|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     |
+------------+-------------+------------+-----------+-----------+------------+

Ora proviamo ad aumentare la dimensione di una colonna NOME da 10 a 20 nel file testalter_tbltavolo. Di seguito è riportata la query per ottenere ciò utilizzando la clausola MODIFY insieme al comando ALTER.

ALTER TABLE testalter_tbl MODIFY name VARCHAR(20);

Dopo aver eseguito con successo la query precedente, la struttura della tabella può essere verificata utilizzando il seguente comando.

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

Dopo l'esecuzione del comando precedente, riceverai il seguente output.

+------------+-------------+------------+-----------+-----------+------------+
|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      |
+------------+-------------+------------+-----------+-----------+------------+

UN database indexè una struttura dati che migliora la velocità delle operazioni in una tabella. Gli indici possono essere creati utilizzando una o più colonne, fornendo la base sia per rapide ricerche casuali che per un efficiente ordinamento dell'accesso ai record.

Durante la creazione di un indice, è necessario considerare quali sono le colonne che verranno utilizzate per eseguire query SQL e creare uno o più indici su tali colonne.

In pratica, gli indici sono anche tipi di tabelle, che mantengono la chiave primaria o il campo indice e un puntatore a ciascun record nella tabella effettiva.

Gli utenti non possono vedere gli indici. Sono utilizzati solo per velocizzare le query e verranno utilizzati dal Motore di ricerca database per individuare rapidamente i record.

Le istruzioni INSERT e UPDATE richiedono più tempo sulle tabelle con indici, mentre le istruzioni SELECT vengono eseguite più velocemente su quelle tabelle. Il motivo è che durante l'inserimento o l'aggiornamento, il database deve inserire o aggiornare anche i valori dell'indice.

Indice semplice e unico

Puoi creare un indice univoco su una tabella. UNunique indexsignifica che due righe non possono avere lo stesso valore di indice. Di seguito è riportata la sintassi per creare un indice su una tabella.

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

È possibile utilizzare una o più colonne per creare un indice. Ad esempio, crea un indice su tutorials_tbl usando tutorial_author.

CREATE UNIQUE INDEX AUTHOR_INDEX
ON tutorials_tbl (tutorial_author)

Puoi creare un semplice indice su una tabella. Basta omettere la parola chiave UNIQUE dalla query per creare un semplice indice. UNsimple index consente valori duplicati in una tabella.

Se vuoi indicizzare i valori in una colonna in ordine decrescente, puoi aggiungere la parola riservata DESC dopo il nome della colonna.

CREATE UNIQUE INDEX AUTHOR_INDEX
ON tutorials_tbl (tutorial_author DESC)

Comando ALTER per aggiungere e rilasciare INDICE

Esistono quattro tipi di istruzioni per l'aggiunta di indici a una tabella:

• ALTER TABLE tbl_name ADD PRIMARY KEY (column_list) - Questa istruzione aggiunge una PRIMARY KEY, il che significa che i valori indicizzati devono essere univoci e non possono essere NULL.

• ALTER TABLE tbl_name ADD UNIQUE index_name (column_list) - Questa istruzione crea un indice per il quale i valori devono essere univoci (ad eccezione dei valori NULL, che possono apparire più volte).

• ALTER TABLE tbl_name ADD INDEX index_name (column_list) - Questo aggiunge un indice ordinario in cui qualsiasi valore può apparire più di una volta.

• ALTER TABLE tbl_name ADD FULLTEXT index_name (column_list) - Questo crea uno speciale indice FULLTEXT che viene utilizzato per scopi di ricerca di testo.

Di seguito è riportata la query per aggiungere l'indice in una tabella esistente.

ALTER TABLE testalter_tbl ADD INDEX (c);

È possibile eliminare qualsiasi INDICE utilizzando la clausola DROP insieme al comando ALTER. Di seguito è riportata la query per eliminare l'indice creato sopra.

ALTER TABLE testalter_tbl DROP INDEX (c);

Visualizzazione delle informazioni INDICE

È possibile utilizzare il comando SHOW INDEX per elencare tutti gli indici associati a una tabella. L'output in formato verticale (specificato da \ G) è spesso utile con questa istruzione, per evitare il wraparound di righe lunghe.

Di seguito è riportata la sintassi generica per visualizzare le informazioni di indice su una tabella.

SHOW INDEX FROM table_name\G