Database H2 - Guida rapida

H2 è un database Java leggero open source. Può essere incorporato in applicazioni Java o eseguito in modalità client-server. Principalmente, il database H2 può essere configurato per essere eseguito come database in memoria, il che significa che i dati non persistono sul disco. A causa del database incorporato, non viene utilizzato per lo sviluppo della produzione, ma principalmente per lo sviluppo e il test.

Questo database può essere utilizzato in modalità incorporata o in modalità server. Di seguito sono riportate le caratteristiche principali del database H2:

  • API JDBC estremamente veloce, open source
  • Disponibile in modalità incorporata e server; database in memoria
  • Applicazione console basata su browser
  • Ingombro ridotto: circa 1,5 MB di dimensioni del file jar

Caratteristiche di H2 Database

Le caratteristiche principali di H2 Database sono le seguenti:

  • È un motore di database estremamente veloce.

  • H2 è open source e scritto in Java.

  • Supporta SQL standard e API JDBC. Può utilizzare anche il driver ODBC PostgreSQL.

  • Ha incorporato e la modalità Server.

  • H2 supporta clustering e multi-version concurrency.

  • Ha forti caratteristiche di sicurezza.

Caratteristiche aggiuntive

Di seguito sono riportate alcune funzionalità aggiuntive di H2 Database:

  • H2 è un database e tabelle basati su disco o in memoria, supporto per database di sola lettura, tabelle temporanee.

  • H2 fornisce supporto per le transazioni (read committed), connessioni multiple con commit a 2 fasi, blocco a livello di tabella.

  • H2 è un ottimizzatore basato sui costi, che utilizza un algoritmo genetico per query complesse, zero amministrazione.

  • H2 contiene supporto per set di risultati scorrevole e aggiornabile, set di risultati di grandi dimensioni, ordinamento esterno dei risultati, le funzioni possono restituire un set di risultati.

  • H2 supporta database crittografati (AES), crittografia password SHA-256, funzioni di crittografia e SSL.

Componenti nel database H2

Per utilizzare H2 Database, è necessario disporre dei seguenti componenti:

  • Un browser web
  • Un server console H2

Questa è un'applicazione client / server, quindi per eseguirla sono necessari sia il server che il client (un browser).

H2 è un database scritto in Java. Possiamo facilmente incorporare questo database nella nostra applicazione utilizzando JDBC. Possiamo eseguirlo su molte piattaforme diverse o qualsiasi versione di Java Runtime Environment. Tuttavia, prima di installare il database, dovrebbe esserci Java installato nel sistema.

Verifica l'installazione di Java

Se JDK è installato nel sistema, provare il seguente comando per verificare la versione di Java.

java –version

Se JDk è installato correttamente nel sistema, otterremo 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 JDK non è installato nel sistema, visitare il seguente collegamento per installare JDK .

Installa H2 Database

Possiamo eseguire questo database su molte piattaforme diverse. In questo capitolo impareremo l'installazione di H2 Database su Windows.

Di seguito sono riportati i passaggi per installare H2 Database sul sistema operativo Windows.

Passaggio 1: scarica il file di installazione H2

Scarica l'ultima versione di H2 Database dal link indicato. In questo collegamento, otterrai l'ultima versione del database H2 in due tipi. Uno è il tipo di Windows Installer (ovvero il file .exe) e il secondo è il file zip indipendente dalla piattaforma per altri sistemi operativi.

Fare clic sul programma di installazione di Windows per scaricare il database H2 compatibile con Windows dopo aver scaricato il file .exe. In questo caso, stiamo usando H2 Database con la versione 1.4.192.

Passaggio 2: installa il database H2

Dopo il download otteniamo il file di installazione di Windows H2 (ad esempio h2-setup-yyyy-mm-dd.exe) nella directory Download. Per avviare il processo di installazione di H2 Database, fai doppio clic sul file di installazione.

La schermata seguente è il primo passo nel processo di installazione. Fornire un percorso in cui si desidera installare il server del database H2 come mostrato nello screenshot seguente.

Come si vede nello screenshot qui sopra, per impostazione predefinita ci vorrà C:\ProgramFiles (x86)\H2come cartella di destinazione. Fare clic su Avanti per procedere al passaggio successivo. Viene visualizzata la seguente schermata.

Nella schermata sopra, fai clic sul pulsante Installa per avviare il processo di installazione. Dopo l'installazione, otteniamo il seguente screenshot.

Fare clic su Fine per completare il processo di installazione.

Passaggio 3: verifica l'installazione del database H2

Dopo l'installazione, verifichiamo l'installazione del database nel sistema. Fare clic su Windows → digitare H2 Console → Fare clic sull'icona della console H2. Collegati all'URLhttp://localhost:8082. Al momento della connessione, il database H2 chiederà la registrazione del database come mostrato nella seguente schermata.

Inserisci tutti i dettagli nella finestra di dialogo sopra come Impostazioni salvate, Nome impostazioni, Classe driver, URL JDBC, Nome utente e Password. Nell'URL JDBC, specificare il database si trova e il nome del database. Nome utente e password sono i campi per il nome utente e la password del database. Fare clic su Connetti.

Viene visualizzata la pagina di benvenuto del database come mostrato nello screenshot seguente.

Il comando Seleziona viene utilizzato per recuperare i dati dei record da una o più tabelle. Se progettiamo una query di selezione, restituisce i dati sotto forma di tabella dei risultati chiamataresult sets.

Sintassi

La sintassi di base dell'istruzione SELECT è la seguente:

SELECT [ TOP term ] [ DISTINCT | ALL ] selectExpression [,...] 
FROM tableExpression [,...] [ WHERE expression ] 
[ GROUP BY expression [,...] ] [ HAVING expression ] 
[ { UNION [ ALL ] | MINUS | EXCEPT | INTERSECT } select ] [ ORDER BY order [,...] ] 
[ [ LIMIT expression ] [ OFFSET expression ] [ SAMPLE_SIZE rowCountInt ] ] 
[ FOR UPDATE ]

Per recuperare tutti i campi disponibili, utilizzare la seguente sintassi.

SELECT * FROM table_name;

Esempio

Considera la tabella CLIENTI con i seguenti record:

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

Per ottenere la tabella dei clienti insieme ai dati forniti, eseguire le seguenti query.

CREATE TABLE CUSTOMER (id number, name varchar(20), age number, address varchar(20), 
salary number);  

INSERT into CUSTOMER values (1, 'Ramesh', 32, 'Ahmedabad', 2000); 
INSERT into CUSTOMER values (2, 'Khilan', 25, 'Delhi', 1500); 
INSERT into CUSTOMER values (3, 'kaushik', 23, 'Kota', 2000); 
INSERT into CUSTOMER values (4, 'Chaitali', 25, 'Mumbai', 6500); 
INSERT into CUSTOMER values (5, 'Hardik', 27, 'Bhopal', 8500); 
INSERT into CUSTOMER values (6, 'Komal', 22, 'MP', 4500); 
INSERT into CUSTOMER values (7, 'Muffy', 24, 'Indore', 10000);

Il comando seguente è un esempio, che recupera i campi ID, Nome e Salario dei clienti disponibili nella tabella CUSTOMER.

SELECT ID, NAME, SALARY FROM CUSTOMERS;

Il comando precedente produce il seguente risultato.

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

Utilizzare la seguente query per recuperare tutti i campi della tabella CUSTOMERS.

SQL> SELECT * FROM CUSTOMERS;

La query precedente produce il seguente risultato:

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

L'istruzione SQL INSERT viene utilizzata per aggiungere nuove righe di dati a una tabella nel database.

Sintassi

Di seguito è riportata la sintassi di base dell'istruzione INSERT INTO.

INSERT INTO tableName 
{ [ ( columnName [,...] ) ] 
{ VALUES 
{ ( { DEFAULT | expression } [,...] ) } [,...] | [ DIRECT ] [ SORTED ] select } } | 
{ SET { columnName = { DEFAULT | expression } } [,...] }

Usando questa istruzione INSERT, possiamo inserire un nuovo record o nuove righe in una tabella. Quando si utilizza la clausola DIRECT, i risultati vengono influenzati direttamente nella tabella di destinazione senza alcun passaggio intermedio. Tuttavia, durante l'aggiunta di valori per tutte le colonne della tabella, assicurati che l'ordine dei valori sia nello stesso ordine delle colonne nella tabella.

Esempio

Facciamo un esempio e proviamo a inserire i seguenti dati nella tabella Cliente.

ID Nome Età Indirizzo Stipendio
1 Ramesh 32 Ahmedabad 2000
2 Khilan 25 Delhi 1500
3 Kaushik 23 Kota 2000
4 Chaitail 25 Mumbai 6500
5 Hardik 27 Bhopal 8500
6 Komal 22 MP 4500
7 Muffy 24 Indore 10000

Possiamo ottenere tutti i record dati nella tabella clienti eseguendo i seguenti comandi.

INSERT INTO CUSTOMER VALUES (1, 'Ramesh', 32, 'Ahmedabad', 2000); 
INSERT INTO CUSTOMER VALUES (2, 'Khilan', 25, 'Delhi', 1500); 
INSERT INTO CUSTOMER VALUES (3, 'kaushik', 23, 'Kota', 2000); 
INSERT INTO CUSTOMER VALUES (4, 'Chaitali', 25, 'Mumbai', 6500); 
INSERT INTO CUSTOMER VALUES (5, 'Hardik', 27, 'Bhopal', 8500); 
INSERT INTO CUSTOMER VALUES (6, 'Komal', 22, 'MP', 4500); 
INSERT INTO CUSTOMER VALUES (7, 'Muffy', 24, 'Indore', 10000);

La query UPDATE viene utilizzata per aggiornare o modificare i record esistenti in una tabella. Possiamo usare la clausola WHERE con la query UPDATE per aggiornare le righe selezionate, altrimenti tutte le righe sarebbero interessate.

Sintassi

Di seguito è riportata la sintassi di base della query UPDATE.

UPDATE tableName [ [ AS ] newTableAlias ] SET 
{ { columnName = { DEFAULT | expression } } [,...] } | 
{ ( columnName [,...] ) = ( select ) } 
[ WHERE expression ] [ ORDER BY order [,...] ] [ LIMIT expression ]

In questa sintassi UPDATE, possiamo combinare più di una condizione utilizzando le clausole AND o OR.

Esempio

Considera la tabella CLIENTE con i seguenti record.

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

Se desideri ottenere la tabella dei clienti insieme ai dati forniti, esegui le seguenti query.

CREATE TABLE CUSTOMER (id number, name varchar(20), age number, address varchar(20), 
   salary number);  
INSERT into CUSTOMER values (1, 'Ramesh', 32, 'Ahmedabad', 2000); 
INSERT into CUSTOMER values (2, 'Khilan', 25, 'Delhi', 1500); 
INSERT into CUSTOMER values (3, 'kaushik', 23, 'Kota', 2000); 
INSERT into CUSTOMER values (4, 'Chaitali', 25, 'Mumbai', 6500); 
INSERT into CUSTOMER values (5, 'Hardik', 27, 'Bhopal', 8500); 
INSERT into CUSTOMER values (6, 'Komal', 22, 'MP', 4500); 
INSERT into CUSTOMER values (7, 'Muffy', 24, 'Indore', 10000);

Il seguente comando è un esempio, che aggiorna ADDRESS per un cliente il cui ID è 6 -

UPDATE CUSTOMERS SET ADDRESS = 'Pune' WHERE ID = 6;

Ora, la tabella CLIENTI avrebbe i seguenti record. Possiamo controllare i record della tabella dei clienti eseguendo la seguente query.

SELECT * FROM CUSTOMERS;

La query precedente produce il seguente risultato.

+----+----------+-----+-----------+----------+ 
| 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 | Pune      |  4500.00 | 
|  7 | Muffy    |  24 | Indore    | 10000.00 | 
+----+----------+-----+-----------+----------+

Per modificare tutti i valori delle colonne ADDRESS e SALARY nella tabella CUSTOMERS, non è necessario utilizzare la clausola WHERE. La query UPDATE sarebbe la seguente:

UPDATE CUSTOMERS SET ADDRESS = 'Pune', SALARY = 1000.00;

Ora, la tabella CLIENTI avrebbe i seguenti record. Possiamo controllare i record della tabella dei clienti eseguendo la seguente query.

SELECT * FROM CUSTOMERS;

La query precedente produce il seguente risultato:

+----+----------+-----+---------+---------+ 
| ID | NAME     | AGE | ADDRESS | SALARY  | 
+----+----------+-----+---------+---------+ 
|  1 | Ramesh   |  32 | Pune    | 1000.00 | 
|  2 | Khilan   |  25 | Pune    | 1000.00 | 
|  3 | kaushik  |  23 | Pune    | 1000.00 | 
|  4 | Chaitali |  25 | Pune    | 1000.00 | 
|  5 | Hardik   |  27 | Pune    | 1000.00 | 
|  6 | Komal    |  22 | Pune    | 1000.00 | 
|  7 | Muffy    |  24 | Pune    | 1000.00 | 
+----+----------+-----+---------+---------+

La query SQL DELETE viene utilizzata per eliminare i record esistenti da una tabella. Possiamo usare la clausola WHERE con la query DELETE per eliminare i record selezionati, altrimenti tutti i record verranno eliminati.

Sintassi

Di seguito è riportata la sintassi della query generica del comando delete.

DELETE [ TOP term ] FROM tableName [ WHERE expression ] [ LIMIT term ]

La sintassi precedente elimina le righe da una tabella. Se viene specificato TOP o LIMIT, viene eliminato al massimo il numero di righe specificato (nessun limite se null o inferiore a zero).

Esempio

Considera la tabella CLIENTE con i seguenti record.

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

Il comando seguente cancellerà i dettagli del cliente, il cui ID è 6.

DELETE FROM CUSTOMERS WHERE ID = 6;

Dopo aver eseguito il comando precedente, controllare la tabella Clienti eseguendo il seguente comando.

SELECT * FROM CUSTOMERS;

Il comando precedente produce il seguente output:

+----+----------+-----+-----------+----------+ 
| 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 | 
|  7 | Muffy    |  24 | Indore    | 10000.00 | 
+----+----------+-----+-----------+----------+

Se vogliamo CANCELLARE tutti i record dalla tabella CUSTOMERS, non usiamo la clausola WHERE. La query DELETE sarebbe la seguente.

DELETE FROM CUSTOMER;

Dopo aver eseguito il comando precedente, nessun record sarà disponibile nella tabella Cliente.

BACKUP è il comando utilizzato per eseguire il backup del database in un file .zip separato. Gli oggetti non sono bloccati e quando esegue il backup viene copiato anche il log delle transazioni. I diritti di amministratore sono necessari per eseguire questo comando.

Sintassi

Di seguito è riportata la sintassi generica del comando Backup.

BACKUP TO fileNameString;

Esempio

In questo esempio, eseguiamo un backup del database corrente in backup.zipfile. Usa il seguente comando per lo stesso.

BACKUP TO 'backup.zip';

Eseguendo il comando precedente, otterrai il file backup.zip nel tuo file system locale.

CALL è un comando SQL che appartiene al server di database H2. Questo comando viene utilizzato per calcolare un'espressione semplice. Restituisce il risultato dell'espressione data in un campo a colonna singola. Quando restituisce una matrice di risultati, ogni elemento della matrice viene visualizzato come valore di colonna.

Sintassi

Di seguito è riportata la sintassi generica del comando CALL.

CALL expression;

Possiamo usare l'espressione aritmetica in questa sintassi.

Esempio

Facciamo un esempio ed eseguiamo un'espressione aritmetica (15 * 25) usando il comando call.

CALL 15*25;

Il comando precedente produce il seguente output.

375
375

Il comando EXPLAIN visualizza il piano di esecuzione per un'istruzione. Quando eseguiamo un'istruzione utilizzando il comando EXPLAIN ANALYZE, il piano di query includerà il conteggio effettivo delle scansioni di righe per ciascuna tabella.

Sintassi

Di seguito è riportata la sintassi generica del comando EXPLAIN.

EXPLAIN { [ PLAN FOR ] | ANALYZE } { select | insert | update | delete | merge}

Insieme a questa sintassi possiamo usare select, insert, delete e merge.

Esempio

Questo esempio spiega i dettagli del piano di query del cliente con ID 1.

EXPLAIN SELECT * FROM CUSTOMER WHERE ID = 1;

Il comando precedente produce il seguente output:

Il comando MERGE viene utilizzato per aggiornare le righe esistenti e inserire nuove righe in una tabella. La colonna della chiave primaria gioca un ruolo importante durante l'utilizzo di questo comando; è usato per trovare la riga.

Sintassi

Di seguito è riportata la sintassi generica del comando MERGE.

MERGE INTO tableName [ ( columnName [,...] ) ] 
[ KEY ( columnName [,...] ) ] 
{ VALUES { ( { DEFAULT | expression } [,...] ) } [,...] | select }

Nella sintassi precedente, la clausola KEY viene utilizzata per specificare il nome della colonna della chiave primaria. Insieme alla clausola VALUES, possiamo utilizzare valori primitivi da inserire oppure possiamo recuperare e memorizzare altri valori di tabella in questa tabella utilizzando il comando select.

Esempio

In questo esempio, proviamo ad aggiungere un nuovo record nella tabella Clienti. Di seguito sono riportati i dettagli del nuovo record nella tabella.

Nome colonna Valore
ID 8
NOME Lokesh
ETÀ 32
INDIRIZZO Hyderabad
STIPENDIO 2500

Utilizzando la seguente query, inseriamo il record specificato nella query del database H2.

MERGE INTO CUSTOMER KEY (ID) VALUES (8, 'Lokesh', 32, 'Hyderabad', 2500);

La query precedente produce il seguente output.

Update count: 1

Cerchiamo di verificare i record della tabella Customer eseguendo la seguente query.

SELECT * FROM CUSTOMER;

La query precedente produce il seguente output.

ID Nome Età Indirizzo Stipendio
1 Ramesh 32 Ahmedabad 2000
2 Khilan 25 Delhi 1500
3 Kaushik 23 Kota 2000
4 Chaitali 25 Mumbai 6500
5 Hardik 27 Bhopal 8500
6 Komal 22 MP 4500
7 Muffy 24 Indore 10000
8 Lokesh 32 Hyderabad 2500

Ora proviamo ad aggiornare il record utilizzando il Mergecomando. Di seguito sono riportati i dettagli del record da aggiornare.

Nome colonna Valore
ID 8
NOME Loki
ETÀ 32
INDIRIZZO Hyderabad
STIPENDIO 3000

Utilizzare la seguente query per inserire il record specificato nella query del database H2.

MERGE INTO CUSTOMER KEY (ID) VALUES (8, 'Loki', 32, 'Hyderabad', 3000);

La query precedente produce il seguente output.

Update count: 1

Cerchiamo di verificare i record della tabella Customer eseguendo la seguente query.

SELECT * FROM CUSTOMER;

La query precedente produce il seguente output:

ID Nome Età Indirizzo Stipendio
1 Ramesh 32 Ahmedabad 2000
2 Khilan 25 Delhi 1500
3 Kaushik 23 Kota 2000
4 Chaitali 25 Mumbai 6500
5 Hardik 27 Bhopal 8500
6 Komal 22 MP 4500
7 Muffy 24 Indore 10000
8 Loki 32 Hyderabad 3000

SHOW è un comando utilizzato per visualizzare l'elenco di schemi, tabelle o colonne della tabella.

Sintassi

Di seguito è riportata la sintassi generica del comando SHOW.

SHOW { SCHEMAS | TABLES [ FROM schemaName ] | 
COLUMNS FROM tableName [ FROM schemaName ] }

Esempio

Il seguente comando può essere utilizzato per ottenere l'elenco delle tabelle nel database corrente.

SHOW TABLES;

Il comando precedente produce il seguente output.

TABLE_NAME TABLE_SCHEMA
CLIENTE PUBBLICO
EMP PUBBLICO

CREATE è un comando SQL generico utilizzato per creare tabelle, schemi, sequenze, visualizzazioni e utenti nel server del database H2.

Crea tabella

Crea tabella è un comando utilizzato per creare una tabella definita dall'utente nel database corrente.

Sintassi

Di seguito è riportata la sintassi generica per il comando Crea tabella.

CREATE [ CACHED | MEMORY ] [ TEMP | [ GLOBAL | LOCAL ] TEMPORARY ] 
TABLE [ IF NOT EXISTS ] name 
[ ( { columnDefinition | constraint } [,...] ) ] 
[ ENGINE tableEngineName [ WITH tableEngineParamName [,...] ] ] 
[ NOT PERSISTENT ] [ TRANSACTIONAL ] 
[ AS select ]

Utilizzando la sintassi generica del comando Crea tabella, possiamo creare diversi tipi di tabelle come tabelle memorizzate nella cache, tabelle di memoria e tabelle temporanee. Di seguito è riportato l'elenco per descrivere clausole diverse dalla sintassi data.

  • CACHED- Le tabelle memorizzate nella cache sono il tipo predefinito per le tabelle normali. Ciò significa che il numero di righe non è limitato dalla memoria principale.

  • MEMORY- Le tabelle di memoria sono il tipo predefinito per le tabelle temporanee. Ciò significa che le tabelle di memoria non dovrebbero diventare troppo grandi e i dati dell'indice vengono conservati nella memoria principale.

  • TEMPORARY- Le tabelle temporanee vengono eliminate durante la chiusura o l'apertura di un database. Fondamentalmente, le tabelle temporanee sono di due tipi:

    • Tipo GLOBALE - Accessibile da tutte le connessioni.

    • Tipo LOCALE - Accessibile dalla connessione corrente.

    Il tipo predefinito per le tabelle temporanee è il tipo globale. Gli indici delle tabelle temporanee vengono conservati nella memoria principale, a meno che la tabella temporanea non venga creata utilizzando CREATE CACHED TABLE.

  • ENGINE - L'opzione ENGINE è richiesta solo quando vengono utilizzate implementazioni di tabelle personalizzate.

  • NOT PERSISTENT - È un modificatore per mantenere in memoria i dati completi della tabella e tutte le righe vengono perse quando il database viene chiuso.

  • TRANSACTIONAL - È una parola chiave che esegue il commit di una transazione aperta e questo comando supporta solo tabelle temporanee.

Esempio

In questo esempio, creiamo una tabella denominata tutorials_tbl utilizzando i seguenti dati forniti.

Suor n Nome colonna Tipo di dati
1 ID Int
2 Titolo Varchar (50)
3 Autore Varchar (20)
4 Data di presentazione Data

La seguente query viene utilizzata per creare una tabella tutorials_tbl insieme ai dati della colonna specificati.

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

La query precedente produce il seguente output.

(0) rows effected

Crea schema

Crea schema è un comando utilizzato per creare uno schema dipendente dall'utente con una particolare autorizzazione (con l'utente attualmente registrato).

Sintassi

Di seguito è riportata la sintassi generica del comando Crea schema.

CREATE SCHEMA [ IF NOT EXISTS ] name [ AUTHORIZATION ownerUserName ]

Nella sintassi generica sopra, AUTORIZZAZIONE è una parola chiave utilizzata per fornire il rispettivo nome utente. Questo comando è opzionale, il che significa che se non forniamo il nome utente, considererà l'utente corrente. L'utente che esegue il comando deve disporre dei diritti di amministratore, così come il proprietario.

Questo comando salva una transazione aperta in questa connessione.

Esempio

In questo esempio, creiamo uno schema denominato test_schema sotto Utente SA, utilizzando il seguente comando.

CREATE SCHEMA test_schema AUTHORIZATION sa;

Il comando precedente produce il seguente output.

(0) rows effected

Crea sequenza

La sequenza è un concetto utilizzato per generare un numero seguendo una sequenza per id o qualsiasi valore di colonna casuale.

Sintassi

Di seguito è riportata la sintassi generica del comando di creazione della sequenza.

CREATE SEQUENCE [ IF NOT EXISTS ] newSequenceName [ START WITH long ] 
[ INCREMENT BY long ] 
[ MINVALUE long | NOMINVALUE | NO MINVALUE ] 
[ MAXVALUE long | NOMAXVALUE | NO MAXVALUE ] 
[ CYCLE long | NOCYCLE | NO CYCLE ] 
[ CACHE long | NOCACHE | NO CACHE ]

Questa sintassi generica viene utilizzata per creare una sequenza. Il tipo di dati di una sequenza èBIGINT. In questa sequenza, i valori non vengono mai riutilizzati, anche quando viene eseguito il rollback della transazione.

Esempio

In questo esempio, creiamo una sequenza denominata SEQ_ID, utilizzando la seguente query.

CREATE SEQUENCE SEQ_ID;

La query precedente produce il seguente output.

(0) rows effected

ALTER è un comando utilizzato per modificare la struttura della tabella aggiungendo diverse clausole al file altercomando. In base allo scenario, dobbiamo aggiungere la rispettiva clausola al comando alter. In questo capitolo, discuteremo vari scenari di alter command.

Alter Table Add

Alter Table Add è un comando utilizzato per aggiungere una nuova colonna a una tabella insieme al rispettivo tipo di dati. Questo comando esegue il commit della transazione in questa connessione.

Sintassi

Di seguito è riportata la sintassi generica del comando Alter Table Add.

ALTER TABLE [ IF EXISTS ] tableName ADD [ COLUMN ] 
{ [ IF NOT EXISTS ] columnDefinition [ { BEFORE | AFTER } columnName ] 
   | ( { columnDefinition } [,...] ) }

Esempio

In questo esempio, aggiungeremo una nuova colonna start_date al tavolo tutorials_tbl. Il tipo di dati per data_inizio è Data. Di seguito è riportata la query per aggiungere una nuova colonna.

ALTER TABLE tutorials_tbl ADD start_date DATE;

La query precedente produce il seguente output.

(6) rows effected

Modifica tabella Aggiungi vincolo

Alter table add constraint è un comando utilizzato per aggiungere diversi vincoli alla tabella come chiave primaria, chiave esterna, non null, ecc.

Gli indici richiesti vengono creati automaticamente se non esistono ancora. Non è possibile disabilitare il controllo del vincolo univoco. Questo comando salva una transazione aperta in questa connessione.

Sintassi

Di seguito è riportata la sintassi generica del comando Modifica vincolo di aggiunta della tabella.

ALTER TABLE [ IF EXISTS ] tableName ADD constraint [ CHECK | NOCHECK ]

Esempio

In questo esempio, aggiungiamo un vincolo di chiave primaria (tutorials_tbl_pk) all'ID colonna della tabella tutorials_tbl, utilizzando la seguente query.

ALTER TABLE tutorials_tbl ADD CONSTRAINT tutorials_tbl_pk PRIMARYKEY(id);

La query precedente produce il seguente output.

(6) row (s) effected

Modifica vincolo di rinomina tabella

Questo comando viene utilizzato per rinominare il nome del vincolo di una particolare tabella di relazione. Questo comando salva una transazione aperta in questa connessione.

Sintassi

Di seguito è riportata la sintassi generica del comando Alter Table Rename Constraint.

ALTER TABLE [ IF EXISTS ] tableName RENAME oldConstraintName TO newConstraintName

Durante l'utilizzo di questa sintassi, assicurarsi che il vecchio nome del vincolo esista con la rispettiva colonna.

Esempio

In questo esempio, cambieremo il nome del vincolo di chiave primaria della tabella tutorials_tbl a partire dal tutorials_tbl_pk per tutorials_tbl_pk_constraint. Di seguito è la domanda per farlo.

ALTER TABLE tutorials_tbl RENAME CONSTRAINT 
tutorials_tbl_pk TO tutorials_tbl_pk_constraint;

La query precedente produce il seguente output.

(1) row (s) effected

Modifica tabella Modifica colonna

Questo comando viene utilizzato per modificare la struttura e le proprietà della colonna di una particolare tabella. Modificare le proprietà significa modificare il tipo di dati di una colonna, rinominare una colonna, modificare il valore di identità o modificare la selettività.

Sintassi

Di seguito è riportata la sintassi generica del comando Alter Table Alter Column.

ALTER TABLE [ IF EXISTS ] tableName ALTER COLUMN columnName 
{ { dataType [ DEFAULT expression ] [ [ NOT ] NULL ] [ AUTO_INCREMENT | IDENTITY ] } 
| { RENAME TO name } 
| { RESTART WITH long } 
| { SELECTIVITY int } 
| { SET DEFAULT expression } 
| { SET NULL } 
| { SET NOT NULL } }

Nella sintassi sopra -

  • RESTART - il comando cambia il valore successivo di una colonna di incremento automatico.

  • SELECTIVITY- il comando imposta la selettività (1-100) per una colonna. In base al valore di selettività possiamo visualizzare il valore della colonna.

  • SET DEFAULT - modifica il valore predefinito di una colonna.

  • SET NULL - imposta la colonna per consentire NULL.

  • SET NOT NULL - imposta la colonna per consentire NOT NULL.

Esempio

In questo esempio, rinomineremo la colonna della tabella tutorials_tbl a partire dal Title per Tutorial_Title utilizzando la seguente query.

ALTER TABLE tutorials_tbl ALTER COLUMN title RENAME TO tutorial_title;

La query precedente produce il seguente output.

(0) row(s) effected

In modo simile, possiamo eseguire diversi scenari con il comando ALTER.

DROP è un comando tratto dalla grammatica SQL generica. Questo comando viene utilizzato per eliminare un componente del database e la sua struttura dalla memoria. Ci sono diversi scenari con il comando Drop che discuteremo in questo capitolo.

Drop Table

Drop Table è un comando che elimina la rispettiva tabella e la sua struttura.

Sintassi

Di seguito è riportata la sintassi generica del comando Drop Table.

DROP TABLE [ IF EXISTS ] tableName [,...] [ RESTRICT | CASCADE ]

Il comando fallirà se stiamo usando RESTRICT e la tabella con viste dipendenti esistono. Tutte le viste dipendenti vengono eliminate quando si utilizza la parola chiave CASCADE.

Esempio

In questo esempio, elimineremo una tabella denominata test utilizzando la seguente query.

DROP TABLE test;

La query precedente produce il seguente output.

(6) row (s) effected

Schema di rilascio

Drop Schema è un comando che elimina un rispettivo schema dal server del database. Non funzionerà dallo schema corrente.

Sintassi

DROP SCHEMA [ IF EXISTS ] schemaName

Esempio

In questo esempio, elimineremo uno schema denominato test_schema utilizzando la seguente query.

DROP SCHEMA TEST_SCHEMA;

La query precedente produce il seguente output.

(0) row(s) effected

Sequenza di rilascio

Drop Sequence è un comando utilizzato per eliminare una sequenza dalla struttura della tabella.

Sintassi

Di seguito è riportata la sintassi generica del comando Drop Sequence.

DROP SEQUENCE [ IF EXISTS ] sequenceName

Questo comando salva una transazione aperta in questa connessione.

Esempio

In questo esempio, rilasciamo una sequenza denominata sequence_id. Di seguito è riportato il comando.

DROP SEQUENCE sequence_id;

Il comando precedente produce il seguente output.

(0) row (s) effected

Drop View

Drop View è un comando utilizzato per eliminare la visualizzazione esistente. Anche tutte le viste dipendenti vengono eliminate se viene utilizzata la clausola CASCADE.

Sintassi

Di seguito è riportata la sintassi generica del comando Drop View.

DROP VIEW [ IF EXISTS ] viewName [ RESTRICT | CASCADE ]

Esempio

In questo esempio, elimineremo una vista denominata sample_view utilizzando la seguente query.

DROP VIEW sample_view;

La query precedente produce il seguente output.

(0) row (s) effected

TRUNCATE è un comando utilizzato per eliminare i dati dalla tabella. A differenza di DELETE FROM senza la clausola WHERE, questo comando non può essere annullato. Questo comando salva una transazione aperta in questa connessione.

Sintassi

Di seguito è riportata la sintassi generica del comando truncate.

TRUNCATE TABLE tableName

Esempio

In questo esempio, tronceremo una tabella denominata test utilizzando la seguente query.

TRUNCATE TABLE test;

La query precedente produce il seguente output.

(6) row (s) effected

COMMIT è un comando della grammatica SQL utilizzato per eseguire il commit della transazione. Possiamo eseguire il commit della transazione specifica oppure possiamo eseguire il commit della transazione attualmente eseguita.

Sintassi

Esistono due diverse sintassi per il comando COMMIT.

Di seguito è riportata la sintassi generica per il comando commit per eseguire il commit della transazione corrente.

COMMIT [ WORK ]

Di seguito è riportata la sintassi generica per il comando commit per eseguire il commit della transazione specifica.

COMMIT TRANSACTION transactionName

Esempio 1

In questo esempio, eseguiamo il commit della transazione corrente utilizzando il seguente comando.

COMMIT

Il comando precedente produce il seguente output.

Committed successfully

Esempio 2

In questo esempio, eseguiremo il commit della transazione denominata tx_test utilizzando il seguente comando.

COMMIT TRANSACTION tx_test;

Il comando precedente produce il seguente output.

Committed successfully

Grant è un comando proveniente dalla grammatica SQL utilizzato per concedere i diritti a una tabella, a un utente o a un ruolo. I diritti di amministratore sono necessari per eseguire questo comando. Questo comando salva una transazione aperta in questa connessione.

In questo capitolo, discuteremo i diversi scenari del comando Grant.

Concedi a destra

Concedi diritti è un comando per fornire diritti di amministratore a una tabella, a un utente o a un ruolo.

Sintassi

Di seguito è riportata la sintassi generica del comando Grant.

GRANT { SELECT | INSERT | UPDATE | DELETE | ALL } [,...] ON 
{ { SCHEMA schemaName } | { tableName [,...] } } 
TO { PUBLIC | userName | roleName }

Esempio

In questo esempio, concederemo la tabella di test come di sola lettura utilizzando il seguente comando.

GRANT SELECT ON TEST TO READONLY

Il comando precedente produce il seguente output.

Grant successfully

Concedi alterare qualsiasi schema

Grant Alter Any Schema è un comando per concedere i diritti di modifica dello schema a un rispettivo utente.

Sintassi

Di seguito è riportata la sintassi generica del comando Grant Alter Any Schema.

GRANT ALTER ANY SCHEMA TO userName

Esempio

In questo esempio, concederemo la modifica dei privilegi di uno schema a un utente denominato test_user. Assicurati che test_user esista. Di seguito è riportata la query per concedere i privilegi di modifica.

GRANT ALTER ANY SCHEMA TO test_user;

La query precedente produce il seguente output.

Granted successfully to test_user

SAVEPOINT è un comando utilizzato per salvare temporaneamente la transazione. È meglio mantenere i punti di salvataggio nella transazione poiché è utile ripristinare la transazione al rispettivo punto di salvataggio ogni volta che è necessario.

Sintassi

Di seguito è riportata la sintassi generica del comando Savepoint.

SAVEPOINT savepointName

Esempio

In questo esempio, creeremo un punto di salvataggio denominato Half_Done utilizzando il seguente comando.

SAVEPOINT Half_Done;

Il comando precedente produce il seguente output.

Savepoint created

ROLLBACK è un comando della grammatica SQL utilizzato per eseguire il rollback della transazione a un punto di salvataggio o alla transazione precedente. Usando questo comando, possiamo ripristinare lo specifico punto di salvataggio oppure possiamo tornare alla transazione eseguita in precedenza.

Sintassi

Esistono due diverse sintassi per il comando ROLLABCK.

Di seguito è riportata la sintassi generica per il comando rollback.

ROLLBACK [ TO SAVEPOINT savepointName ]

Di seguito è riportata la sintassi generica del comando Rollback per la transazione specifica.

ROLLBACK TRANSACTION transactionName

Esempio 1

In questo esempio, eseguiremo il rollback della transazione corrente a un punto di salvataggio denominato sp1_test utilizzando il seguente comando.

ROLLBACK sp1_test;

Il comando precedente produce il seguente output.

Rollback successfully

Esempio 2

Nel seguente esempio, eseguiremo il rollback della transazione completa denominata tx_test usando il comando dato.

ROLLBACK TRANSACTION tx_test;

Il comando precedente produce il seguente output.

Rollback successfully

H2 è un database JAVA. Possiamo interagire con questo database utilizzando JDBC. In questo capitolo vedremo come creare una connessione JDBC con il database H2 e le operazioni CRUD con il database H2.

In genere, ci sono cinque passaggi per creare una connessione JDBC.

Step 1 - Registrazione del driver del database JDBC.

Class.forName ("org.h2.Driver");

Step 2 - Apertura della connessione.

Connection conn = DriverManager.getConnection ("jdbc:h2:~/test", "sa","");

Step 3 - Creare una dichiarazione.

Statement st = conn.createStatement();

Step 4 - Esecuzione di una dichiarazione e ricezione di Resultset.

Stmt.executeUpdate("sql statement");

Step 5 - Chiusura di una connessione.

conn.close();

Prima di passare alla creazione di un programma completo, dobbiamo aggiungere h2-1.4.192.jar filea CLASSPATH. Possiamo ottenerlojar dalla cartella C:\Program Files (x86)\H2\bin.

Crea tabella

In questo esempio, scriveremo un programma per creare tabella. Considera una tabella denominataRegistration con i seguenti campi.

S.No Nome colonna Tipo di dati NON NULLO Chiave primaria
1 ID Numero sì sì
2 Primo Varchar (255) No No
3 Scorso Varchar (255) No No
4 Età Numero No No

Di seguito è riportato un programma di esempio denominato H2jdbcCreateDemo.

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

public class H2jdbcCreateDemo { 
   // JDBC driver name and database URL 
   static final String JDBC_DRIVER = "org.h2.Driver";   
   static final String DB_URL = "jdbc:h2:~/test";  
   
   //  Database credentials 
   static final String USER = "sa"; 
   static final String PASS = ""; 
  
   public static void main(String[] args) { 
      Connection conn = null; 
      Statement stmt = null; 
      try { 
         // STEP 1: Register JDBC driver 
         Class.forName(JDBC_DRIVER); 
             
         //STEP 2: Open a connection 
         System.out.println("Connecting to database..."); 
         conn = DriverManager.getConnection(DB_URL,USER,PASS);  
         
         //STEP 3: Execute a query 
         System.out.println("Creating table in given database..."); 
         stmt = conn.createStatement(); 
         String sql =  "CREATE TABLE   REGISTRATION " + 
            "(id INTEGER not NULL, " + 
            " first VARCHAR(255), " +  
            " last VARCHAR(255), " +  
            " age INTEGER, " +  
            " PRIMARY KEY ( id ))";  
         stmt.executeUpdate(sql);
         System.out.println("Created table in given database..."); 
         
         // STEP 4: Clean-up environment 
         stmt.close(); 
         conn.close(); 
      } catch(SQLException se) { 
         //Handle errors for JDBC 
         se.printStackTrace(); 
      } catch(Exception e) { 
         //Handle errors for Class.forName 
         e.printStackTrace(); 
      } finally { 
         //finally block used to close resources 
         try{ 
            if(stmt!=null) stmt.close(); 
         } catch(SQLException se2) { 
         } // nothing we can do 
         try { 
            if(conn!=null) conn.close(); 
         } catch(SQLException se){ 
            se.printStackTrace(); 
         } //end finally try 
      } //end try 
      System.out.println("Goodbye!");
   } 
}

Salva il programma sopra in H2jdbcCreateDemo.java. Compilare ed eseguire il programma precedente eseguendo i seguenti comandi nel prompt dei comandi.

\>javac H2jdbcCreateDemo.java 
\>java H2jdbcCreateDemo

Il comando precedente produce il seguente output.

Connecting to database... 
Creating table in given database... 
Created table in given database... 
Goodbye!

Dopo questa esecuzione, possiamo controllare la tabella creata utilizzando l'interfaccia H2 SQL.

Inserisci record

In questo esempio, scriveremo un programma per inserire record. Inseriamo i seguenti record nella tabella Registrazione.

ID Primo Scorso Età
100 Zara Ali 18
101 Mahnaz Fatma 25
102 Zaid Khan 30
103 Sumit Mital 28

Di seguito è riportato un programma di esempio denominato H2jdbcInsertDemo.

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

public class H2jdbcInsertDemo { 
   // JDBC driver name and database URL 
   static final String JDBC_DRIVER = "org.h2.Driver";   
   static final String DB_URL = "jdbc:h2:~/test";  
   
   //  Database credentials 
   static final String USER = "sa"; 
   static final String PASS = ""; 
  
   public static void main(String[] args) { 
      Connection conn = null; 
      Statement stmt = null; 
      try{
         // STEP 1: Register JDBC driver 
         Class.forName(JDBC_DRIVER);  
         
         // STEP 2: Open a connection 
         System.out.println("Connecting to a selected database..."); 
         conn = DriverManager.getConnection(DB_URL,USER,PASS); 
         System.out.println("Connected database successfully..."); 
         
         // STEP 3: Execute a query 
         stmt = conn.createStatement();  
         String sql = "INSERT INTO Registration " + "VALUES (100, 'Zara', 'Ali', 18)"; 
         
         stmt.executeUpdate(sql); 
         sql = "INSERT INTO Registration " + "VALUES (101, 'Mahnaz', 'Fatma', 25)";  
         
         stmt.executeUpdate(sql); 
         sql = "INSERT INTO Registration " + "VALUES (102, 'Zaid', 'Khan', 30)"; 
         
         stmt.executeUpdate(sql); 
         sql = "INSERT INTO Registration " + "VALUES(103, 'Sumit', 'Mittal', 28)"; 
         
         stmt.executeUpdate(sql); 
         System.out.println("Inserted records into the table..."); 
         
         // STEP 4: Clean-up environment 
         stmt.close(); 
         conn.close(); 
      } catch(SQLException se) { 
         // Handle errors for JDBC 
         se.printStackTrace(); 
      } catch(Exception e) { 
         // Handle errors for Class.forName 
         e.printStackTrace(); 
      } finally { 
         // finally block used to close resources 
         try {
            if(stmt!=null) stmt.close();  
         } catch(SQLException se2) { 
         } // nothing we can do 
         try { 
            if(conn!=null) conn.close(); 
         } catch(SQLException se) { 
            se.printStackTrace(); 
         } // end finally try 
      } // end try 
      System.out.println("Goodbye!"); 
   } 
}

Salva il programma sopra in H2jdbcInsertDemo.java. Compilare ed eseguire il programma precedente eseguendo i seguenti comandi nel prompt dei comandi.

\>javac H2jdbcInsertDemo.java 
\>java H2jdbcInsertDemo

Il comando precedente produce il seguente output.

Connecting to a selected database... 
Connected database successfully... 
Inserted records into the table... 
Goodbye!

Leggi record

In questo esempio, scriveremo un programma per leggere i record. Proviamo a leggere tutti i record dalla tabellaRegistration.

Di seguito è riportato un programma di esempio denominato H2jdbcRecordDemo.

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

public class H2jdbcReadDemo { 
   // JDBC driver name and database URL 
   static final String JDBC_DRIVER = "org.h2.Driver";   
   static final String DB_URL = "jdbc:h2:~/test";  
   
   //  Database credentials 
   static final String USER = "sa"; 
   static final String PASS = ""; 
   
   public static void main(String[] args) { 
      Connection conn = null; 
      Statement stmt = null; 
      try { 
         // STEP 1: Register JDBC driver 
         Class.forName(JDBC_DRIVER); 
         
         // STEP 2: Open a connection 
         System.out.println("Connecting to database..."); 
         conn = DriverManager.getConnection(DB_URL,USER,PASS);  
         
         // STEP 3: Execute a query 
         System.out.println("Connected database successfully..."); 
         stmt = conn.createStatement(); 
         String sql = "SELECT id, first, last, age FROM Registration"; 
         ResultSet rs = stmt.executeQuery(sql); 
         
         // STEP 4: Extract data from result set 
         while(rs.next()) { 
            // Retrieve by column name 
            int id  = rs.getInt("id"); 
            int age = rs.getInt("age"); 
            String first = rs.getString("first"); 
            String last = rs.getString("last");  
            
            // Display values 
            System.out.print("ID: " + id); 
            System.out.print(", Age: " + age); 
            System.out.print(", First: " + first); 
            System.out.println(", Last: " + last); 
         } 
         // STEP 5: Clean-up environment 
         rs.close(); 
      } catch(SQLException se) { 
         // Handle errors for JDBC 
         se.printStackTrace(); 
      } catch(Exception e) { 
         // Handle errors for Class.forName 
         e.printStackTrace(); 
      } finally { 
         // finally block used to close resources 
         try { 
            if(stmt!=null) stmt.close();  
         } catch(SQLException se2) { 
         } // nothing we can do 
         try { 
            if(conn!=null) conn.close(); 
         } catch(SQLException se) { 
            se.printStackTrace(); 
         } // end finally try 
      } // end try 
      System.out.println("Goodbye!"); 
   } 
}

Salva il programma sopra in H2jdbcReadDemo.java. Compilare ed eseguire il programma precedente eseguendo i seguenti comandi nel prompt dei comandi.

\>javac H2jdbcReadDemo.java 
\>java H2jdbcReadDemo

Il comando precedente produce il seguente output.

Connecting to a selected database... 
Connected database successfully... 
ID: 100, Age: 18, First: Zara, Last: Ali 
ID: 101, Age: 25, First: Mahnaz, Last: Fatma 
ID: 102, Age: 30, First: Zaid, Last: Khan 
ID: 103, Age: 28, First: Sumit, Last: Mittal 
Goodbye!

Aggiorna record

In questo esempio, scriveremo un programma per aggiornare i record. Proviamo a leggere tutti i record dalla tabellaRegistration.

Di seguito è riportato un programma di esempio denominato H2jdbcUpdateDemo.

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

public class H2jdbcUpdateDemo { 
   // JDBC driver name and database URL 
   static final String JDBC_DRIVER = "org.h2.Driver";   
   static final String DB_URL = "jdbc:h2:~/test";  
   
   // Database credentials 
   static final String USER = "sa"; 
   static final String PASS = ""; 
   
   public static void main(String[] args) { 
      Connection conn = null; 
      Statement stmt = null; 
      try { 
         // STEP 1: Register JDBC driver 
         Class.forName(JDBC_DRIVER); 
         
         // STEP 2: Open a connection 
         System.out.println("Connecting to a database..."); 
         conn = DriverManager.getConnection(DB_URL,USER,PASS);  
         
         // STEP 3: Execute a query 
         System.out.println("Connected database successfully..."); 
         stmt = conn.createStatement(); 
         String sql = "UPDATE Registration " + "SET age = 30 WHERE id in (100, 101)"; 
         stmt.executeUpdate(sql);  
         
         // Now you can extract all the records 
         // to see the updated records 
         sql = "SELECT id, first, last, age FROM Registration"; 
         ResultSet rs = stmt.executeQuery(sql);  
         
         while(rs.next()){ 
            // Retrieve by column name 
            int id  = rs.getInt("id"); 
            int age = rs.getInt("age"); 
            String first = rs.getString("first"); 
            String last = rs.getString("last");  
            
            // Display values 
            System.out.print("ID: " + id); 
            System.out.print(", Age: " + age); 
            System.out.print(", First: " + first); 
            System.out.println(", Last: " + last); 
         } 
         rs.close();    
      } catch(SQLException se) { 
         // Handle errors for JDBC 
         se.printStackTrace(); 
      } catch(Exception e) { 
         // Handle errors for Class.forName 
         e.printStackTrace(); 
      } finally { 
         // finally block used to close resources  
         try { 
            if(stmt!=null) stmt.close(); 
         } catch(SQLException se2) { 
         } // nothing we can do 
         try { 
            if(conn!=null) conn.close(); 
         } catch(SQLException se) { 
            se.printStackTrace(); 
         } // end finally try 
      } // end try 
      System.out.println("Goodbye!"); 
   } 
}

Salva il programma sopra in H2jdbcUpdateDemo.java. Compilare ed eseguire il programma precedente eseguendo i seguenti comandi nel prompt dei comandi.

\>javac H2jdbcUpdateDemo.java 
\>java H2jdbcUpdateDemo

Il comando precedente produce il seguente output.

Connecting to a selected database... 
Connected database successfully... 
ID: 100, Age: 30, First: Zara, Last: Ali 
ID: 101, Age: 30, First: Mahnaz, Last: Fatma 
ID: 102, Age: 30, First: Zaid, Last: Khan 
ID: 103, Age: 28, First: Sumit, Last: Mittal 
Goodbye!

Elimina record

In questo esempio, scriveremo un programma per eliminare i record. Proviamo a leggere tutti i record dalla tabellaRegistration.

Di seguito è riportato un programma di esempio denominato H2jdbcDeleteDemo.

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

public class H2jdbcDeleteDemo { 
   // JDBC driver name and database URL 
   static final String JDBC_DRIVER = "org.h2.Driver";   
   static final String DB_URL = "jdbc:h2:~/test";  
   
   // Database credentials 
   static final String USER = "sa"; 
   static final String PASS = ""; 
  
   public static void main(String[] args) { 
      Connection conn = null; 
      Statement stmt = null; 
      try { 
         // STEP 1: Register JDBC driver 
         Class.forName(JDBC_DRIVER);  
         
         // STEP 2: Open a connection 
         System.out.println("Connecting to database..."); 
         conn = DriverManager.getConnection(DB_URL,USER,PASS);  
         
         // STEP 3: Execute a query
         System.out.println("Creating table in given database..."); 
         stmt = conn.createStatement();  
         String sql = "DELETE FROM Registration " + "WHERE id = 101"; 
         stmt.executeUpdate(sql);  
         
         // Now you can extract all the records 
         // to see the remaining records 
         sql = "SELECT id, first, last, age FROM Registration"; 
         ResultSet rs = stmt.executeQuery(sql);  
         
         while(rs.next()){ 
            // Retrieve by column name 
            int id  = rs.getInt("id"); 
            int age = rs.getInt("age"); 
            String first = rs.getString("first"); 
            String last = rs.getString("last");  
            
            // Display values 
            System.out.print("ID: " + id); 
            System.out.print(", Age: " + age); 
            System.out.print(", First: " + first); 
            System.out.println(", Last: " + last); 
         } 
         rs.close(); 
      } catch(SQLException se) { 
         // Handle errors for JDBC 
         se.printStackTrace();  
      } catch(Exception e) { 
         // Handle errors for Class.forName 
         e.printStackTrace(); 
      } finally { 
         // finally block used to close resources 
         try { 
            if(stmt!=null) stmt.close(); 
         } catch(SQLException se2) { 
         } // nothing we can do 
         try { 
            if(conn!=null) conn.close(); 
         } catch(SQLException se) { 
            se.printStackTrace(); 
         } // end finally try
      } // end try 
      System.out.println("Goodbye!"); 
   } 
}

Salva il programma sopra in H2jdbcDeleteDemo.java. Compilare ed eseguire il programma precedente eseguendo i seguenti comandi nel prompt dei comandi.

\>javac H2jdbcDeleteDemo.java 
\>java H2jdbcDeleteDemo

Il comando precedente produce il seguente output.

Connecting to a selected database... 
Connected database successfully... 
ID: 100, Age: 30, First: Zara, Last: Ali 
ID: 102, Age: 30, First: Zaid, Last: Khan 
ID: 103, Age: 28, First: Sumit, Last: Mittal 
Goodbye!
ja/tutorial
es/tutorial
de/tutorial
fr/tutorial
th/tutorial
pt/tutorial
ru/tutorial
vi/tutorial
it/tutorial
ko/tutorial
tr/tutorial
id/tutorial
pl/tutorial
hi/tutorial
japost
espost
depost
frpost
thpost
ptpost
rupost
vipost
itpost
kopost
trpost
idpost
plpost
hipost

© Copyright 2021 - 2024 | All Rights Reserved