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!