H2-Datenbank - Kurzanleitung

H2 ist eine Open-Source-Java-Datenbank. Es kann in Java-Anwendungen eingebettet oder im Client-Server-Modus ausgeführt werden. Hauptsächlich kann die H2-Datenbank so konfiguriert werden, dass sie als Speicherdatenbank ausgeführt wird. Dies bedeutet, dass die Daten nicht auf der Festplatte verbleiben. Aufgrund der eingebetteten Datenbank wird es nicht für die Produktionsentwicklung verwendet, sondern hauptsächlich für die Entwicklung und das Testen.

Diese Datenbank kann im eingebetteten Modus oder im Servermodus verwendet werden. Im Folgenden sind die Hauptfunktionen der H2-Datenbank aufgeführt:

  • Extrem schnelle Open Source JDBC-API
  • Verfügbar im Embedded- und Server-Modus. In-Memory-Datenbanken
  • Browser-basierte Konsolenanwendung
  • Geringer Platzbedarf - ca. 1,5 MB JAR-Dateigröße

Funktionen der H2-Datenbank

Die Hauptfunktionen der H2-Datenbank sind:

  • Es ist eine extrem schnelle Datenbank-Engine.

  • H2 ist Open Source und in Java geschrieben.

  • Es unterstützt die Standard-SQL- und JDBC-API. Es kann auch den PostgreSQL ODBC-Treiber verwenden.

  • Es hat eingebetteten und Server-Modus.

  • H2 unterstützt clustering und multi-version concurrency.

  • Es hat starke Sicherheitsmerkmale.

Zusatzfunktionen

Im Folgenden finden Sie einige zusätzliche Funktionen der H2-Datenbank:

  • H2 ist eine festplattenbasierte oder speicherinterne Datenbank und Tabelle, schreibgeschützte Datenbankunterstützung und temporäre Tabellen.

  • H2 bietet Transaktionsunterstützung (Read Commit), 2-Phasen-Commit für mehrere Verbindungen und Sperren auf Tabellenebene.

  • H2 ist ein kostenbasierter Optimierer, der einen genetischen Algorithmus für komplexe Abfragen ohne Verwaltung verwendet.

  • H2 enthält Unterstützung für scrollbare und aktualisierbare Ergebnismengen, große Ergebnismengen, externe Ergebnissortierung und Funktionen, die eine Ergebnismenge zurückgeben können.

  • H2 unterstützt verschlüsselte Datenbanken (AES), SHA-256-Kennwortverschlüsselung, Verschlüsselungsfunktionen und SSL.

Komponenten in der H2-Datenbank

Um die H2-Datenbank verwenden zu können, benötigen Sie die folgenden Komponenten:

  • Ein Webbrowser
  • Ein H2-Konsolenserver

Dies ist eine Client / Server-Anwendung, daher sind sowohl Server als auch Client (ein Browser) erforderlich, um sie auszuführen.

H2 ist eine in Java geschriebene Datenbank. Wir können diese Datenbank mithilfe von JDBC problemlos in unsere Anwendung einbetten. Wir können dies auf vielen verschiedenen Plattformen oder jeder Version von Java Runtime Environment ausführen. Vor der Installation der Datenbank sollte jedoch Java im System installiert sein.

Überprüfen Sie die Java-Installation

Wenn JDK im System installiert ist, versuchen Sie den folgenden Befehl, um die Java-Version zu überprüfen.

java –version

Wenn JDk erfolgreich im System installiert wurde, erhalten wir die folgende Ausgabe.

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)

Wenn JDK nicht im System installiert ist, besuchen Sie den folgenden Link, um JDK zu installieren .

Installieren Sie die H2-Datenbank

Wir können diese Datenbank auf vielen verschiedenen Plattformen ausführen. In diesem Kapitel erfahren Sie mehr über die Installation der H2-Datenbank unter Windows.

Im Folgenden finden Sie die Schritte zum Installieren der H2-Datenbank unter einem Windows-Betriebssystem.

Schritt 1: Laden Sie die H2-Setup-Datei herunter

Laden Sie die neueste Version der H2-Datenbank über den angegebenen Link herunter . Über diesen Link erhalten Sie die neueste Version der H2-Datenbank in zwei Typen. Einer ist der Windows Installer-Typ (dh die EXE-Datei) und der zweite die plattformunabhängige Zip-Datei für andere Betriebssysteme.

Klicken Sie auf das Windows-Installationsprogramm, um die von Windows unterstützte H2-Datenbank nach dem Herunterladen der EXE-Datei herunterzuladen. In diesem Fall verwenden wir die H2-Datenbank mit der Version 1.4.192.

Schritt 2: Installieren Sie die H2-Datenbank

Nach dem Herunterladen erhalten wir die H2 Windows-Installationsdatei (dh h2-setup-yyyy-mm-dd.exe) im Downloads-Verzeichnis. Doppelklicken Sie auf die Installationsdatei, um den Installationsvorgang der H2-Datenbank zu starten.

Der folgende Bildschirm ist der erste Schritt im Installationsprozess. Geben Sie einen Pfad an, in dem der H2-Datenbankserver installiert werden soll (siehe folgenden Screenshot).

Wie im obigen Screenshot zu sehen, dauert es standardmäßig C:\ProgramFiles (x86)\H2als Zielordner. Klicken Sie auf Weiter, um mit dem nächsten Schritt fortzufahren. Der folgende Bildschirm wird angezeigt.

Klicken Sie im obigen Screenshot auf die Schaltfläche Installieren, um den Installationsvorgang zu starten. Nach der Installation erhalten wir den folgenden Screenshot.

Klicken Sie auf Fertig stellen, um den Installationsvorgang abzuschließen.

Schritt 3: Überprüfen Sie die Installation der H2-Datenbank

Lassen Sie uns nach der Installation die Datenbankinstallation im System überprüfen. Klicken Sie auf Windows → Geben Sie H2 Console ein → Klicken Sie auf das H2 Console-Symbol. Stellen Sie eine Verbindung zur URL herhttp://localhost:8082. Zum Zeitpunkt der Verbindung fordert die H2-Datenbank die Registrierung der Datenbank an, wie im folgenden Screenshot gezeigt.

Füllen Sie im obigen Dialogfeld alle Details aus, z. B. Gespeicherte Einstellungen, Einstellungsname, Treiberklasse, JDBC-URL, Benutzername und Kennwort. Geben Sie in der JDBC-URL die Datenbank und den Datenbanknamen an. Benutzername und Passwort sind die Felder für Benutzername und Passwort der Datenbank. Klicken Sie auf Verbinden.

Die Begrüßungsseite der Datenbank wird angezeigt (siehe folgenden Screenshot).

Mit dem Befehl select werden Datensatzdaten aus einer Tabelle oder mehreren Tabellen abgerufen. Wenn wir eine Auswahlabfrage entwerfen, gibt sie Daten in Form einer aufgerufenen Ergebnistabelle zurückresult sets.

Syntax

Die grundlegende Syntax der SELECT-Anweisung lautet wie folgt:

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 ]

Verwenden Sie die folgende Syntax, um alle verfügbaren Felder abzurufen.

SELECT * FROM table_name;

Beispiel

Betrachten Sie die CUSTOMER-Tabelle mit den folgenden Datensätzen:

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

Führen Sie die folgenden Abfragen aus, um die Kundentabelle mit den angegebenen Daten abzurufen.

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

Der folgende Befehl ist ein Beispiel, mit dem die Felder ID, Name und Gehalt der Kunden abgerufen werden, die in der Tabelle CUSTOMER verfügbar sind.

SELECT ID, NAME, SALARY FROM CUSTOMERS;

Der obige Befehl erzeugt das folgende Ergebnis.

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

Verwenden Sie die folgende Abfrage, um alle Felder der Tabelle CUSTOMERS abzurufen.

SQL> SELECT * FROM CUSTOMERS;

Die obige Abfrage führt zu folgendem Ergebnis:

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

Die SQL INSERT-Anweisung wird verwendet, um einer Tabelle in der Datenbank neue Datenzeilen hinzuzufügen.

Syntax

Es folgt die grundlegende Syntax der INSERT INTO-Anweisung.

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

Mit dieser INSERT-Anweisung können wir einen neuen Datensatz oder neue Zeilen in eine Tabelle einfügen. Bei Verwendung der DIRECT-Klausel wirken sich die Ergebnisse ohne Zwischenschritt direkt auf die Zieltabelle aus. Stellen Sie jedoch beim Hinzufügen von Werten für alle Spalten der Tabelle sicher, dass die Reihenfolge der Werte in derselben Reihenfolge wie die Spalten in der Tabelle liegt.

Beispiel

Nehmen wir ein Beispiel und versuchen Sie, die folgenden angegebenen Datensätze in die Kundentabelle einzufügen.

ICH WÜRDE Name Alter Adresse Gehalt
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

Wir können alle angegebenen Datensätze in die Kundentabelle aufnehmen, indem wir die folgenden Befehle ausführen.

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

Die UPDATE-Abfrage wird verwendet, um die vorhandenen Datensätze in einer Tabelle zu aktualisieren oder zu ändern. Wir können die WHERE-Klausel mit der UPDATE-Abfrage verwenden, um die ausgewählten Zeilen zu aktualisieren, da sonst alle Zeilen betroffen wären.

Syntax

Im Folgenden finden Sie die grundlegende Syntax der UPDATE-Abfrage.

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

In dieser UPDATE-Syntax können wir mehr als eine Bedingung mithilfe von AND- oder OR-Klauseln kombinieren.

Beispiel

Betrachten Sie die CUSTOMER-Tabelle mit den folgenden Datensätzen.

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

Wenn Sie die Kundentabelle mit den angegebenen Daten abrufen möchten, führen Sie die folgenden Abfragen aus.

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

Der folgende Befehl ist ein Beispiel, mit dem ADRESSE für einen Kunden mit der ID 6 aktualisiert wird.

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

Die Tabelle CUSTOMERS enthält nun die folgenden Datensätze. Wir können die Kundentabellendatensätze überprüfen, indem wir die folgende Abfrage ausführen.

SELECT * FROM CUSTOMERS;

Die obige Abfrage führt zu folgendem Ergebnis.

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

Um alle ADDRESS- und SALARY-Spaltenwerte in der CUSTOMERS-Tabelle zu ändern, müssen Sie die WHERE-Klausel nicht verwenden. Die UPDATE-Abfrage würde wie folgt lauten:

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

Die Tabelle CUSTOMERS enthält nun die folgenden Datensätze. Wir können die Kundentabellendatensätze überprüfen, indem wir die folgende Abfrage ausführen.

SELECT * FROM CUSTOMERS;

Die obige Abfrage führt zu folgendem Ergebnis:

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

Die SQL DELETE-Abfrage wird verwendet, um die vorhandenen Datensätze aus einer Tabelle zu löschen. Wir können die WHERE-Klausel mit der DELETE-Abfrage verwenden, um ausgewählte Datensätze zu löschen, andernfalls werden alle Datensätze gelöscht.

Syntax

Es folgt die generische Abfragesyntax des Löschbefehls.

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

Die obige Syntax löscht die Zeilen aus einer Tabelle. Wenn TOP oder LIMIT angegeben ist, wird höchstens die angegebene Anzahl von Zeilen gelöscht (keine Begrenzung, wenn null oder kleiner als Null).

Beispiel

Betrachten Sie die CUSTOMER-Tabelle mit den folgenden Datensätzen.

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

Mit dem folgenden Befehl werden die Details des Kunden gelöscht, dessen ID 6 ist.

DELETE FROM CUSTOMERS WHERE ID = 6;

Überprüfen Sie nach Ausführung des obigen Befehls die Kundentabelle, indem Sie den folgenden Befehl ausführen.

SELECT * FROM CUSTOMERS;

Der obige Befehl erzeugt die folgende Ausgabe -

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

Wenn wir alle Datensätze aus der Tabelle CUSTOMERS löschen möchten, verwenden wir nicht die WHERE-Klausel. Die DELETE-Abfrage lautet wie folgt.

DELETE FROM CUSTOMER;

Nach dem Ausführen des obigen Befehls sind keine Datensätze in der Kundentabelle verfügbar.

BACKUP ist der Befehl, mit dem die Datenbanksicherung in eine separate ZIP-Datei übernommen wird. Objekte werden nicht gesperrt, und bei der Sicherung wird auch das Transaktionsprotokoll kopiert. Zum Ausführen dieses Befehls sind Administratorrechte erforderlich.

Syntax

Es folgt die generische Syntax des Sicherungsbefehls.

BACKUP TO fileNameString;

Beispiel

In diesem Beispiel erstellen wir eine Sicherungskopie der aktuellen Datenbank backup.zipDatei. Verwenden Sie dazu den folgenden Befehl.

BACKUP TO 'backup.zip';

Wenn Sie den obigen Befehl ausführen, erhalten Sie die Datei backup.zip in Ihrem lokalen Dateisystem.

CALL ist ein SQL-Befehl, der zum H2-Datenbankserver gehört. Dieser Befehl wird verwendet, um einen einfachen Ausdruck zu berechnen. Es gibt das Ergebnis des angegebenen Ausdrucks in einem einzelnen Spaltenfeld zurück. Wenn ein Array von Ergebnissen zurückgegeben wird, wird jedes Element im Array als Spaltenwert angezeigt.

Syntax

Es folgt die generische Syntax des Befehls CALL.

CALL expression;

Wir können den arithmetischen Ausdruck in dieser Syntax verwenden.

Beispiel

Nehmen wir ein Beispiel und führen einen arithmetischen Ausdruck (15 * 25) mit dem Befehl call aus.

CALL 15*25;

Der obige Befehl erzeugt die folgende Ausgabe.

375
375

Der Befehl EXPLAIN zeigt den Ausführungsplan für eine Anweisung an. Wenn wir eine Anweisung mit dem Befehl EXPLAIN ANALYZE ausführen, enthält der Abfrageplan die tatsächliche Anzahl der Zeilenscans für jede Tabelle.

Syntax

Es folgt die generische Syntax des EXPLAIN-Befehls.

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

Zusammen mit dieser Syntax können wir auswählen, einfügen, löschen und zusammenführen.

Beispiel

In diesem Beispiel werden die Details des Abfrageplans des Kunden mit der ID 1 erläutert.

EXPLAIN SELECT * FROM CUSTOMER WHERE ID = 1;

Der obige Befehl erzeugt die folgende Ausgabe -

Mit dem Befehl MERGE werden die vorhandenen Zeilen aktualisiert und neue Zeilen in eine Tabelle eingefügt. Die Primärschlüsselspalte spielt bei Verwendung dieses Befehls eine wichtige Rolle. Es wird verwendet, um die Zeile zu finden.

Syntax

Es folgt die generische Syntax des Befehls MERGE.

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

In der obigen Syntax wird die KEY-Klausel verwendet, um den Namen der Primärschlüsselspalte anzugeben. Zusammen mit der VALUES-Klausel können wir primitive Werte zum Einfügen verwenden oder andere Tabellenwerte mit dem Befehl select abrufen und in dieser Tabelle speichern.

Beispiel

In diesem Beispiel versuchen wir, der Tabelle "Kunden" einen neuen Datensatz hinzuzufügen. Im Folgenden finden Sie die Details des neuen Datensatzes in der Tabelle.

Spaltenname Wert
ICH WÜRDE 8
NAME Lokesh
ALTER 32
ADRESSE Hyderabad
GEHALT 2500

Fügen Sie mit der folgenden Abfrage den angegebenen Datensatz in die H2-Datenbankabfrage ein.

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

Die obige Abfrage erzeugt die folgende Ausgabe.

Update count: 1

Lassen Sie uns die Datensätze der Kundentabelle überprüfen, indem Sie die folgende Abfrage ausführen.

SELECT * FROM CUSTOMER;

Die obige Abfrage erzeugt die folgende Ausgabe.

ICH WÜRDE Name Alter Adresse Gehalt
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

Versuchen wir nun, den Datensatz mit dem zu aktualisieren MergeBefehl. Im Folgenden finden Sie die Details des zu aktualisierenden Datensatzes.

Spaltenname Wert
ICH WÜRDE 8
NAME Loki
ALTER 32
ADRESSE Hyderabad
GEHALT 3000

Verwenden Sie die folgende Abfrage, um den angegebenen Datensatz in die H2-Datenbankabfrage einzufügen.

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

Die obige Abfrage erzeugt die folgende Ausgabe.

Update count: 1

Lassen Sie uns die Datensätze der Kundentabelle überprüfen, indem Sie die folgende Abfrage ausführen.

SELECT * FROM CUSTOMER;

Die obige Abfrage erzeugt die folgende Ausgabe:

ICH WÜRDE Name Alter Adresse Gehalt
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 ist ein Befehl zum Anzeigen der Liste der Schemas, Tabellen oder Spalten der Tabelle.

Syntax

Es folgt die generische Syntax des Befehls SHOW.

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

Beispiel

Mit dem folgenden Befehl können Sie die Liste der Tabellen in der aktuellen Datenbank abrufen.

SHOW TABLES;

Der obige Befehl erzeugt die folgende Ausgabe.

TABELLENNAME TABLE_SCHEMA
KUNDE ÖFFENTLICHKEIT
EMP ÖFFENTLICHKEIT

CREATE ist ein generischer SQL-Befehl zum Erstellen von Tabellen, Schemas, Sequenzen, Ansichten und Benutzern auf dem H2-Datenbankserver.

Tabelle erstellen

Tabelle erstellen ist ein Befehl zum Erstellen einer benutzerdefinierten Tabelle in der aktuellen Datenbank.

Syntax

Im Folgenden finden Sie die generische Syntax für den Befehl "Tabelle erstellen".

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

Mithilfe der generischen Syntax des Befehls "Tabelle erstellen" können verschiedene Arten von Tabellen erstellt werden, z. B. zwischengespeicherte Tabellen, Speichertabellen und temporäre Tabellen. Im Folgenden finden Sie eine Liste, in der verschiedene Klauseln aus der angegebenen Syntax beschrieben werden.

  • CACHED- Die zwischengespeicherten Tabellen sind der Standardtyp für reguläre Tabellen. Dies bedeutet, dass die Anzahl der Zeilen nicht durch den Hauptspeicher begrenzt ist.

  • MEMORY- Die Speichertabellen sind der Standardtyp für temporäre Tabellen. Dies bedeutet, dass die Speichertabellen nicht zu groß werden sollten und die Indexdaten im Hauptspeicher gespeichert werden.

  • TEMPORARY- Temporäre Tabellen werden beim Schließen oder Öffnen einer Datenbank gelöscht. Grundsätzlich gibt es zwei Arten von temporären Tabellen:

    • GLOBAL-Typ - Zugänglich für alle Verbindungen.

    • LOKALER Typ - Zugriff über die aktuelle Verbindung.

    Der Standardtyp für temporäre Tabellen ist der globale Typ. Indizes temporärer Tabellen werden im Hauptspeicher gespeichert, es sei denn, die temporäre Tabelle wird mit CREATE CACHED TABLE erstellt.

  • ENGINE - Die Option ENGINE ist nur erforderlich, wenn benutzerdefinierte Tabellenimplementierungen verwendet werden.

  • NOT PERSISTENT - Es ist ein Modifikator, um die vollständigen Tabellendaten im Speicher zu halten, und alle Zeilen gehen verloren, wenn die Datenbank geschlossen wird.

  • TRANSACTIONAL - Es ist ein Schlüsselwort, das eine offene Transaktion festschreibt, und dieser Befehl unterstützt nur temporäre Tabellen.

Beispiel

In diesem Beispiel erstellen wir eine Tabelle mit dem Namen tutorials_tbl unter Verwendung der folgenden angegebenen Daten.

Sr.Nr. Spaltenname Datentyp
1 ICH WÜRDE Int
2 Titel Varchar (50)
3 Autor Varchar (20)
4 Abgabetermin Datum

Die folgende Abfrage wird zum Erstellen einer Tabelle verwendet tutorials_tbl zusammen mit den angegebenen Spaltendaten.

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

Die obige Abfrage erzeugt die folgende Ausgabe.

(0) rows effected

Schema erstellen

Schema erstellen ist ein Befehl zum Erstellen eines benutzerabhängigen Schemas unter einer bestimmten Berechtigung (unter dem aktuell registrierten Benutzer).

Syntax

Im Folgenden finden Sie die generische Syntax des Befehls "Schema erstellen".

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

In der obigen generischen Syntax ist AUTHORIZATION ein Schlüsselwort, mit dem der jeweilige Benutzername angegeben wird. Dieser Befehl ist optional. Wenn wir den Benutzernamen nicht angeben, wird der aktuelle Benutzer berücksichtigt. Der Benutzer, der den Befehl ausführt, muss über Administratorrechte sowie den Eigentümer verfügen.

Dieser Befehl schreibt in diesem Zusammenhang eine offene Transaktion fest.

Beispiel

In diesem Beispiel erstellen wir ein Schema mit dem Namen test_schema Verwenden Sie unter SA-Benutzer den folgenden Befehl.

CREATE SCHEMA test_schema AUTHORIZATION sa;

Der obige Befehl erzeugt die folgende Ausgabe.

(0) rows effected

Sequenz erstellen

Sequenz ist ein Konzept, das verwendet wird, um eine Zahl zu generieren, indem einer Sequenz für ID oder zufällige Spaltenwerte gefolgt wird.

Syntax

Es folgt die generische Syntax des Befehls create sequence.

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 ]

Diese generische Syntax wird zum Erstellen einer Sequenz verwendet. Der Datentyp einer Sequenz istBIGINT. In dieser Sequenz werden Werte niemals wiederverwendet, selbst wenn die Transaktion rückgängig gemacht wird.

Beispiel

In diesem Beispiel erstellen wir eine Sequenz mit dem Namen SEQ_IDmit der folgenden Abfrage.

CREATE SEQUENCE SEQ_ID;

Die obige Abfrage erzeugt die folgende Ausgabe.

(0) rows effected

ALTER ist ein Befehl zum Ändern der Tabellenstruktur durch Hinzufügen verschiedener Klauseln zu alterBefehl. Basierend auf dem Szenario müssen wir dem Befehl alter eine entsprechende Klausel hinzufügen. In diesem Kapitel werden verschiedene Szenarien für den Befehl alter erläutert.

Tabelle ändern Hinzufügen

Tabelle hinzufügen ändern ist ein Befehl zum Hinzufügen einer neuen Spalte zu einer Tabelle zusammen mit dem jeweiligen Datentyp. Dieser Befehl schreibt die Transaktion in diesem Zusammenhang fest.

Syntax

Im Folgenden finden Sie die generische Syntax des Befehls "Tabelle hinzufügen".

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

Beispiel

In diesem Beispiel fügen wir eine neue Spalte hinzu start_date an den Tisch tutorials_tbl. Der Datentyp für start_date ist Date. Es folgt die Abfrage zum Hinzufügen einer neuen Spalte.

ALTER TABLE tutorials_tbl ADD start_date DATE;

Die obige Abfrage erzeugt die folgende Ausgabe.

(6) rows effected

Tabelle ändern Einschränkung hinzufügen

Die Einschränkung zum Hinzufügen einer Tabelle ändern ist ein Befehl, mit dem der Tabelle verschiedene Einschränkungen hinzugefügt werden, z. B. Primärschlüssel, Fremdschlüssel, nicht Null usw.

Die erforderlichen Indizes werden automatisch erstellt, wenn sie noch nicht vorhanden sind. Es ist nicht möglich, die Überprüfung auf eindeutige Einschränkungen zu deaktivieren. Dieser Befehl schreibt in diesem Zusammenhang eine offene Transaktion fest.

Syntax

Im Folgenden finden Sie die generische Syntax des Befehls "Änderung der Tabelle hinzufügen".

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

Beispiel

In diesem Beispiel fügen wir eine Primärschlüsseleinschränkung hinzu (tutorials_tbl_pk) auf die Spalten-ID der Tabelle tutorials_tblmit der folgenden Abfrage.

ALTER TABLE tutorials_tbl ADD CONSTRAINT tutorials_tbl_pk PRIMARYKEY(id);

Die obige Abfrage erzeugt die folgende Ausgabe.

(6) row (s) effected

Ändern Sie die Umbenennungsbeschränkung für Tabellen

Dieser Befehl wird verwendet, um den Einschränkungsnamen einer bestimmten Beziehungstabelle umzubenennen. Dieser Befehl schreibt in diesem Zusammenhang eine offene Transaktion fest.

Syntax

Im Folgenden finden Sie die generische Syntax des Befehls "Änderung zum Umbenennen von Tabellen ändern".

ALTER TABLE [ IF EXISTS ] tableName RENAME oldConstraintName TO newConstraintName

Stellen Sie bei Verwendung dieser Syntax sicher, dass der alte Einschränkungsname in der entsprechenden Spalte vorhanden ist.

Beispiel

In diesem Beispiel ändern wir den Namen der Primärschlüsseleinschränkung der Tabelle tutorials_tbl von tutorials_tbl_pk zu tutorials_tbl_pk_constraint. Es folgt die Abfrage dazu.

ALTER TABLE tutorials_tbl RENAME CONSTRAINT 
tutorials_tbl_pk TO tutorials_tbl_pk_constraint;

Die obige Abfrage erzeugt die folgende Ausgabe.

(1) row (s) effected

Tabelle ändern Spalte ändern

Dieser Befehl wird verwendet, um die Struktur und die Eigenschaften der Spalte einer bestimmten Tabelle zu ändern. Wenn Sie die Eigenschaften ändern, müssen Sie den Datentyp einer Spalte ändern, eine Spalte umbenennen, den Identitätswert ändern oder die Selektivität ändern.

Syntax

Im Folgenden finden Sie die generische Syntax des Befehls "Tabelle ändern".

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

In der obigen Syntax -

  • RESTART - Befehl ändert den nächsten Wert einer Spalte für das automatische Inkrementieren.

  • SELECTIVITY- Befehl legt die Selektivität (1-100) für eine Spalte fest. Basierend auf dem Selektivitätswert können wir den Wert der Spalte abbilden.

  • SET DEFAULT - Ändert den Standardwert einer Spalte.

  • SET NULL - Setzt die Spalte so, dass NULL zulässig ist.

  • SET NOT NULL - Setzt die Spalte so, dass NOT NULL zulässig ist.

Beispiel

In diesem Beispiel werden wir die Spalte der Tabelle umbenennen tutorials_tbl von Title zu Tutorial_Title mit der folgenden Abfrage.

ALTER TABLE tutorials_tbl ALTER COLUMN title RENAME TO tutorial_title;

Die obige Abfrage erzeugt die folgende Ausgabe.

(0) row(s) effected

In ähnlicher Weise können wir mit dem Befehl ALTER verschiedene Szenarien ausführen.

DROP ist ein Befehl aus der generischen SQL-Grammatik. Mit diesem Befehl werden eine Datenbankkomponente und ihre Struktur aus dem Speicher gelöscht. Es gibt verschiedene Szenarien mit dem Befehl Löschen, die wir in diesem Kapitel behandeln werden.

Drop-Tabelle

Tabelle löschen ist ein Befehl, der die jeweilige Tabelle und ihre Struktur löscht.

Syntax

Es folgt die generische Syntax des Befehls "Tabelle löschen".

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

Der Befehl schlägt fehl, wenn wir RESTRICT verwenden und die Tabelle mit abhängigen Ansichten vorhanden ist. Alle abhängigen Ansichten werden gelöscht, wenn das Schlüsselwort CASCADE verwendet wird.

Beispiel

In diesem Beispiel wird eine Tabelle mit dem Namen test mithilfe der folgenden Abfrage gelöscht.

DROP TABLE test;

Die obige Abfrage erzeugt die folgende Ausgabe.

(6) row (s) effected

Schema löschen

Schema löschen ist ein Befehl, der ein entsprechendes Schema vom Datenbankserver löscht. Es funktioniert nicht mit dem aktuellen Schema.

Syntax

DROP SCHEMA [ IF EXISTS ] schemaName

Beispiel

In diesem Beispiel wird ein Schema mit dem Namen gelöscht test_schema mit der folgenden Abfrage.

DROP SCHEMA TEST_SCHEMA;

Die obige Abfrage erzeugt die folgende Ausgabe.

(0) row(s) effected

Drop-Sequenz

Sequenz löschen ist ein Befehl zum Löschen einer Sequenz aus der Tabellenstruktur.

Syntax

Es folgt die generische Syntax des Befehls Drop Sequence.

DROP SEQUENCE [ IF EXISTS ] sequenceName

Dieser Befehl schreibt in diesem Zusammenhang eine offene Transaktion fest.

Beispiel

In diesem Beispiel wird eine Sequenz mit dem Namen gelöscht sequence_id. Es folgt der Befehl.

DROP SEQUENCE sequence_id;

Der obige Befehl erzeugt die folgende Ausgabe.

(0) row (s) effected

Drop View

Ansicht löschen ist ein Befehl zum Löschen der vorhandenen Ansicht. Alle abhängigen Ansichten werden ebenfalls gelöscht, wenn die CASCADE-Klausel verwendet wird.

Syntax

Es folgt die generische Syntax des Befehls Drop View.

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

Beispiel

In diesem Beispiel wird eine Ansicht mit dem Namen gelöscht sample_view mit der folgenden Abfrage.

DROP VIEW sample_view;

Die obige Abfrage erzeugt die folgende Ausgabe.

(0) row (s) effected

TRUNCATE ist ein Befehl zum Löschen der Daten aus der Tabelle. Im Gegensatz zu DELETE FROM ohne WHERE-Klausel kann dieser Befehl nicht zurückgesetzt werden. Dieser Befehl schreibt in diesem Zusammenhang eine offene Transaktion fest.

Syntax

Es folgt die generische Syntax des Befehls truncate.

TRUNCATE TABLE tableName

Beispiel

In diesem Beispiel werden wir eine Tabelle mit dem Namen abschneiden test mit der folgenden Abfrage.

TRUNCATE TABLE test;

Die obige Abfrage erzeugt die folgende Ausgabe.

(6) row (s) effected

COMMIT ist ein Befehl aus der SQL-Grammatik, mit dem die Transaktion festgeschrieben wird. Wir können entweder die spezifische Transaktion oder die aktuell ausgeführte Transaktion festschreiben.

Syntax

Es gibt zwei verschiedene Syntaxen für den Befehl COMMIT.

Im Folgenden finden Sie die generische Syntax für den Befehl commit zum Festschreiben der aktuellen Transaktion.

COMMIT [ WORK ]

Im Folgenden finden Sie die generische Syntax für den Befehl commit zum Festschreiben der spezifischen Transaktion.

COMMIT TRANSACTION transactionName

Beispiel 1

In diesem Beispiel übernehmen wir die aktuelle Transaktion mit dem folgenden Befehl.

COMMIT

Der obige Befehl erzeugt die folgende Ausgabe.

Committed successfully

Beispiel 2

In diesem Beispiel übernehmen wir die genannte Transaktion tx_test mit dem folgenden Befehl.

COMMIT TRANSACTION tx_test;

Der obige Befehl erzeugt die folgende Ausgabe.

Committed successfully

Grant ist ein Befehl aus der SQL-Grammatik, mit dem die Rechte für eine Tabelle, einen Benutzer oder eine Rolle gewährt werden. Zum Ausführen dieses Befehls sind Administratorrechte erforderlich. Dieser Befehl schreibt in diesem Zusammenhang eine offene Transaktion fest.

In diesem Kapitel werden die verschiedenen Szenarien des Grant-Befehls erläutert.

Grant Right

Grant Right ist ein Befehl zum Bereitstellen von Administratorrechten für eine Tabelle, einen Benutzer oder eine Rolle.

Syntax

Es folgt die generische Syntax des Grant-Befehls.

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

Beispiel

In diesem Beispiel gewähren wir die Testtabelle mit dem folgenden Befehl als schreibgeschützt.

GRANT SELECT ON TEST TO READONLY

Der obige Befehl erzeugt die folgende Ausgabe.

Grant successfully

Grant Alter Any Schema

Grant Alter Any Schema ist ein Befehl zum Gewähren von Änderungsrechten für ein Schema an einen jeweiligen Benutzer.

Syntax

Im Folgenden finden Sie die generische Syntax des Befehls "Grant Any Schema".

GRANT ALTER ANY SCHEMA TO userName

Beispiel

In diesem Beispiel gewähren wir einem benannten Benutzer Änderungsberechtigungen für ein Schema test_user. Stellen Sie sicher, dass test_user vorhanden ist. Es folgt die Abfrage zum Gewähren von Änderungsberechtigungen.

GRANT ALTER ANY SCHEMA TO test_user;

Die obige Abfrage erzeugt die folgende Ausgabe.

Granted successfully to test_user

SAVEPOINT ist ein Befehl zum vorübergehenden Speichern der Transaktion. Es ist besser, Sicherungspunkte in Ihrer Transaktion zu verwalten, da es hilfreich ist, die Transaktion bei Bedarf auf den jeweiligen Sicherungspunkt zurückzusetzen.

Syntax

Es folgt die generische Syntax des Befehls Savepoint.

SAVEPOINT savepointName

Beispiel

In diesem Beispiel erstellen wir einen Speicherpunkt mit dem Namen Half_Done mit dem folgenden Befehl.

SAVEPOINT Half_Done;

Der obige Befehl erzeugt die folgende Ausgabe.

Savepoint created

ROLLBACK ist ein Befehl aus der SQL-Grammatik, mit dem die Transaktion auf einen Sicherungspunkt oder auf die vorherige Transaktion zurückgesetzt wird. Mit diesem Befehl können wir entweder einen Rollback auf den bestimmten Speicherpunkt oder einen Rollback auf die zuvor ausgeführte Transaktion durchführen.

Syntax

Es gibt zwei verschiedene Syntaxen für den Befehl ROLLABCK.

Es folgt die generische Syntax für den Rollback-Befehl.

ROLLBACK [ TO SAVEPOINT savepointName ]

Es folgt die generische Syntax des Rollback-Befehls für die jeweilige Transaktion.

ROLLBACK TRANSACTION transactionName

Beispiel 1

In diesem Beispiel wird die aktuelle Transaktion auf einen Savepoint mit dem Namen zurückgesetzt sp1_test mit dem folgenden Befehl.

ROLLBACK sp1_test;

Der obige Befehl erzeugt die folgende Ausgabe.

Rollback successfully

Beispiel 2

Im folgenden Beispiel wird die gesamte genannte Transaktion zurückgesetzt tx_test mit dem angegebenen Befehl.

ROLLBACK TRANSACTION tx_test;

Der obige Befehl erzeugt die folgende Ausgabe.

Rollback successfully

H2 ist eine JAVA-Datenbank. Wir können mit dieser Datenbank mithilfe von JDBC interagieren. In diesem Kapitel erfahren Sie, wie Sie eine JDBC-Verbindung mit der H2-Datenbank und die CRUD-Operationen mit der H2-Datenbank erstellen.

Im Allgemeinen gibt es fünf Schritte zum Erstellen einer JDBC-Verbindung.

Step 1 - Registrieren des JDBC-Datenbanktreibers.

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

Step 2 - Verbindung öffnen.

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

Step 3 - Erstellen einer Erklärung.

Statement st = conn.createStatement();

Step 4 - Ausführen einer Anweisung und Empfangen der Ergebnismenge.

Stmt.executeUpdate("sql statement");

Step 5 - Schließen einer Verbindung.

conn.close();

Bevor wir fortfahren, um ein vollständiges Programm zu erstellen, müssen wir hinzufügen h2-1.4.192.jar filezu CLASSPATH. Wir können das bekommenjar aus dem Ordner C:\Program Files (x86)\H2\bin.

Tabelle erstellen

In diesem Beispiel schreiben wir ein Programm zum Erstellen einer Tabelle. Betrachten Sie eine Tabelle mit dem NamenRegistration mit den folgenden Feldern.

S.No. Spaltenname Datentyp NICHT NULL Primärschlüssel
1 ICH WÜRDE Nummer Ja Ja
2 Zuerst Varchar (255) Nein Nein
3 Zuletzt Varchar (255) Nein Nein
4 Alter Nummer Nein Nein

Es folgt ein Beispielprogramm mit dem Namen 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!");
   } 
}

Speichern Sie das obige Programm in H2jdbcCreateDemo.java. Kompilieren Sie das obige Programm und führen Sie es aus, indem Sie die folgenden Befehle an der Eingabeaufforderung ausführen.

\>javac H2jdbcCreateDemo.java 
\>java H2jdbcCreateDemo

Der obige Befehl erzeugt die folgende Ausgabe.

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

Nach dieser Ausführung können wir die mit der H2 SQL-Schnittstelle erstellte Tabelle überprüfen.

Datensätze einfügen

In diesem Beispiel schreiben wir ein Programm zum Einfügen von Datensätzen. Fügen wir die folgenden Datensätze in die Tabelle Registrierung ein.

ICH WÜRDE Zuerst Zuletzt Alter
100 Zara Ali 18
101 Mahnaz Fatma 25
102 Zaid Khan 30
103 Sumit Mital 28

Es folgt ein Beispielprogramm mit dem Namen 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!"); 
   } 
}

Speichern Sie das obige Programm in H2jdbcInsertDemo.java. Kompilieren Sie das obige Programm und führen Sie es aus, indem Sie die folgenden Befehle an der Eingabeaufforderung ausführen.

\>javac H2jdbcInsertDemo.java 
\>java H2jdbcInsertDemo

Der obige Befehl erzeugt die folgende Ausgabe.

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

Aufzeichnung lesen

In diesem Beispiel schreiben wir ein Programm zum Lesen von Datensätzen. Versuchen wir, alle Datensätze aus der Tabelle zu lesenRegistration.

Es folgt ein Beispielprogramm mit dem Namen 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!"); 
   } 
}

Speichern Sie das obige Programm in H2jdbcReadDemo.java. Kompilieren Sie das obige Programm und führen Sie es aus, indem Sie die folgenden Befehle an der Eingabeaufforderung ausführen.

\>javac H2jdbcReadDemo.java 
\>java H2jdbcReadDemo

Der obige Befehl erzeugt die folgende Ausgabe.

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!

Datensätze aktualisieren

In diesem Beispiel schreiben wir ein Programm zum Aktualisieren von Datensätzen. Versuchen wir, alle Datensätze aus der Tabelle zu lesenRegistration.

Es folgt ein Beispielprogramm mit dem Namen 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!"); 
   } 
}

Speichern Sie das obige Programm in H2jdbcUpdateDemo.java. Kompilieren Sie das obige Programm und führen Sie es aus, indem Sie die folgenden Befehle an der Eingabeaufforderung ausführen.

\>javac H2jdbcUpdateDemo.java 
\>java H2jdbcUpdateDemo

Der obige Befehl erzeugt die folgende Ausgabe.

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!

Datensätze löschen

In diesem Beispiel schreiben wir ein Programm zum Löschen von Datensätzen. Versuchen wir, alle Datensätze aus der Tabelle zu lesenRegistration.

Es folgt ein Beispielprogramm mit dem Namen 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!"); 
   } 
}

Speichern Sie das obige Programm in H2jdbcDeleteDemo.java. Kompilieren Sie das obige Programm und führen Sie es aus, indem Sie die folgenden Befehle an der Eingabeaufforderung ausführen.

\>javac H2jdbcDeleteDemo.java 
\>java H2jdbcDeleteDemo

Der obige Befehl erzeugt die folgende Ausgabe.

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!