HSQLDB - Kurzanleitung

HyperSQL Database (HSQLDB) ist ein moderner relationaler Datenbankmanager, der den SQL: 2011-Standard- und JDBC 4-Spezifikationen genau entspricht. Es unterstützt alle Kernfunktionen und RDBMS. HSQLDB wird zum Entwickeln, Testen und Bereitstellen von Datenbankanwendungen verwendet.

Das wichtigste und einzigartige Merkmal von HSQLDB ist die Standardkonformität. Es kann Datenbankzugriff innerhalb des Anwendungsprozesses des Benutzers, innerhalb eines Anwendungsservers oder als separater Serverprozess bereitstellen.

Funktionen von HSQLDB

• HSQLDB verwendet eine In-Memory-Struktur für schnelle Operationen gegen DB-Server. Es verwendet die Festplattenpersistenz gemäß der Benutzerflexibilität mit einer zuverlässigen Wiederherstellung nach einem Absturz.

• HSQLDB eignet sich auch für Business Intelligence, ETL und andere Anwendungen, die große Datenmengen verarbeiten.

• HSQLDB bietet eine breite Palette von Optionen für die Unternehmensbereitstellung, z. B. XA-Transaktionen, Datenquellen für Verbindungspools und Remote-Authentifizierung.

• HSQLDB ist in der Programmiersprache Java geschrieben und läuft in einer Java Virtual Machine (JVM). Es unterstützt die JDBC-Schnittstelle für den Datenbankzugriff.

Komponenten von HSQLDB

Das HSQLDB-JAR-Paket enthält drei verschiedene Komponenten.

• HyperSQL RDBMS Engine (HSQLDB)

• HyperSQL JDBC-Treiber

• Datenbankmanager (GUI-Datenbankzugriffstool mit Swing- und AWT-Versionen)

HyperSQL RDBMS und JDBC Driver bieten die Kernfunktionalität. Datenbankmanager sind universelle Datenbankzugriffstools, die mit jedem Datenbankmodul mit einem JDBC-Treiber verwendet werden können.

Eine zusätzliche JAR mit dem Namen sqltool.jar enthält das SQL-Tool, ein Tool für den Zugriff auf die Befehlszeilendatenbank. Dies ist ein Allzweckbefehl. Zeilendatenbankzugriffstool, das auch mit anderen Datenbankmodulen verwendet werden kann.

HSQLDB ist ein relationales Datenbankverwaltungssystem, das in reinem Java implementiert ist. Sie können diese Datenbank einfach mit JDBC in Ihre Anwendung einbetten. Oder Sie können die Operationen separat verwenden.

Voraussetzungen

Befolgen Sie die erforderlichen Softwareinstallationen für HSQLDB.

Überprüfen Sie die Java-Installation

Da HSQLDB ein relationales Datenbankverwaltungssystem ist, das in reinem Java implementiert ist, müssen Sie vor der Installation von HSQLDB die JDK-Software (Java Development Kit) installieren. Wenn Sie bereits eine JDK-Installation in Ihrem System haben, versuchen Sie den folgenden Befehl, um die Java-Version zu überprüfen.

java –version

Wenn JDK erfolgreich in Ihrem System installiert wurde, erhalten Sie 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 Sie JDK nicht auf Ihrem System installiert haben, besuchen Sie den folgenden Link, um JDK zu installieren.

HSQLDB-Installation

Im Folgenden finden Sie die Schritte zum Installieren von HSQLDB.

Step 1 − Download HSQLDB bundle

Laden Sie die neueste Version der HSQLDB-Datenbank über den folgenden Link herunter https://sourceforge.net/projects/hsqldb/files/. Sobald Sie auf den Link klicken, erhalten Sie den folgenden Screenshot.

Klicken Sie auf HSQLDB und der Download wird sofort gestartet. Schließlich erhalten Sie die Zip-Datei mit dem Namenhsqldb-2.3.4.zip.

Step 2 − Extract the HSQLDB zip file

Extrahieren Sie die Zip-Datei und platzieren Sie sie in der C:\Verzeichnis. Nach dem Extrahieren erhalten Sie eine Dateistruktur, wie im folgenden Screenshot gezeigt.

Step 3 − Create a default database

Es gibt keine Standarddatenbank für HSQLDB, daher müssen Sie eine Datenbank für HSQLDB erstellen. Lassen Sie uns eine Eigenschaftendatei mit dem Namen erstellenserver.properties Hiermit wird eine neue Datenbank mit dem Namen definiert demodb. Sehen Sie sich die folgenden Eigenschaften des Datenbankservers an.

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

Platzieren Sie diese Datei server.properties im HSQLDB-Ausgangsverzeichnis C:\hsqldb- 2.3.4\hsqldb\.

Führen Sie nun den folgenden Befehl an der Eingabeaufforderung aus.

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

Nach Ausführung des obigen Befehls erhalten Sie den Serverstatus wie im folgenden Screenshot gezeigt.

Später finden Sie die folgende Ordnerstruktur des Verzeichnisses hsqldb im HSQLDB-Ausgangsverzeichnis C:\hsqldb-2.3.4\hsqldb. Diese Dateien sind temporäre Dateien, lck-Dateien, Protokolldateien, Eigenschaftendateien und Skriptdateien der vom HSQLDB-Datenbankserver erstellten Demodb-Datenbank.

Step 4 − Start the database server

Wenn Sie mit dem Erstellen einer Datenbank fertig sind, müssen Sie die Datenbank mit dem folgenden Befehl starten.

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

Nach Ausführung des obigen Befehls erhalten Sie den folgenden Status.

Jetzt können Sie den Datenbank-Startbildschirm öffnen runManagerSwing.bat von C:\hsqldb-2.3.4\hsqldb\binStandort. Diese bat-Datei öffnet die GUI-Datei für die HSQLDB-Datenbank. Zuvor werden Sie über ein Dialogfeld nach Datenbankeinstellungen gefragt. Schauen Sie sich den folgenden Screenshot an. Geben Sie in diesem Dialogfeld den Einstellungsnamen und die URL wie oben gezeigt ein und klicken Sie auf OK.

Sie erhalten den GUI-Bildschirm der HSQLDB-Datenbank, wie im folgenden Screenshot gezeigt.

Im Installationskapitel haben wir erläutert, wie die Datenbank manuell verbunden wird. In diesem Kapitel wird erläutert, wie die Datenbank programmgesteuert (mithilfe der Java-Programmierung) verbunden wird.

Schauen Sie sich das folgende Programm an, mit dem der Server gestartet und eine Verbindung zwischen der Java-Anwendung und der Datenbank hergestellt wird.

Beispiel

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

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

Speichern Sie diesen Code in ConnectDatabase.javaDatei. Sie müssen die Datenbank mit dem folgenden Befehl starten.

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

Mit dem folgenden Befehl können Sie den Code kompilieren und ausführen.

\>javac ConnectDatabase.java
\>java ConnectDatabase

Nach Ausführung des obigen Befehls erhalten Sie die folgende Ausgabe:

Connection created successfully

In diesem Kapitel werden die verschiedenen Datentypen von HSQLDB erläutert. Der HSQLDB-Server bietet sechs Kategorien von Datentypen.

Genaue numerische Datentypen

Datentyp	Von	Zu
Bigint	-9,223,372,036,854,775,808	9,223,372,036,854,775,807
int	-2,147,483,648	2,147,483,647
smallint	-32.768	32.767
tinyint	0	255
bisschen	0	1
Dezimal	-10 ^ 38 +1	10 ^ 38 -1
numerisch	-10 ^ 38 +1	10 ^ 38 -1
Geld	-922.337.203.685.477.5808	+922.337.203.685.477.5807
Kleingeld	-214.748,3648	+214.748,3647

Ungefähre numerische Datentypen

Datentyp	Von	Zu
schweben	-1,79E + 308	1,79E + 308
echt	-3,40E + 38	3,40E + 38

Datums- und Uhrzeitdatentypen

Datentyp	Von	Zu
Terminzeit	1. Januar 1753	31. Dezember 9999
kleine Zeit	1. Januar 1900	6. Juni 2079
Datum	Speichert ein Datum wie den 30. Juni 1991
Zeit	Speichert eine Tageszeit wie 12:30 Uhr

Note - Hier hat die Datumszeit eine Genauigkeit von 3,33 Millisekunden, während die kleine Datumszeit eine Genauigkeit von 1 Minute hat.

Datentypen für Zeichenfolgen

Datentyp	Beschreibung
verkohlen	Maximale Länge von 8.000 Zeichen (Nicht-Unicode-Zeichen mit fester Länge)
varchar	Maximal 8.000 Zeichen (Nicht-Unicode-Daten variabler Länge)
varchar (max)	Maximale Länge von 231 Zeichen, Nicht-Unicode-Daten variabler Länge (nur SQL Server 2005)
Text	Nicht-Unicode-Daten variabler Länge mit einer maximalen Länge von 2.147.483.647 Zeichen

Datentypen für Unicode-Zeichenfolgen

Datentyp	Beschreibung
nchar	Maximale Länge von 4.000 Zeichen (Unicode mit fester Länge)
nvarchar	Maximale Länge von 4.000 Zeichen (Unicode mit variabler Länge)
nvarchar (max)	Maximale Länge von 231 Zeichen (nur SQL Server 2005), (Unicode mit variabler Länge)
ntext	Maximale Länge von 1.073.741.823 Zeichen (Unicode mit variabler Länge)

Binäre Datentypen

Datentyp	Beschreibung
binär	Maximale Länge von 8.000 Bytes (Binärdaten mit fester Länge)
varbinary	Maximale Länge von 8.000 Bytes (Binärdaten variabler Länge)
varbinary (max)	Maximale Länge von 231 Byte (nur SQL Server 2005), (Binärdaten variabler Länge)
Bild	Maximale Länge von 2.147.483.647 Bytes (Binärdaten variabler Länge)

Verschiedene Datentypen

Datentyp	Beschreibung
sql_variant	Speichert Werte verschiedener von SQL Server unterstützter Datentypen außer Text, ntext und Zeitstempel
Zeitstempel	Speichert eine datenbankweite eindeutige Nummer, die jedes Mal aktualisiert wird, wenn eine Zeile aktualisiert wird
eindeutige Kennung	Speichert eine global eindeutige Kennung (GUID)
xml	Speichert XML-Daten. Sie können XML-Instanzen in einer Spalte oder einer Variablen speichern (nur SQL Server 2005).
Mauszeiger	Verweis auf ein Cursorobjekt
Tabelle	Speichert eine Ergebnismenge für die spätere Verarbeitung

Die grundlegenden obligatorischen Anforderungen zum Erstellen einer Tabelle sind Tabellenname, Feldnamen und die Datentypen für diese Felder. Optional können Sie auch die wichtigsten Einschränkungen für die Tabelle angeben.

Syntax

Schauen Sie sich die folgende Syntax an.

CREATE TABLE table_name (column_name column_type);

Beispiel

Erstellen wir eine Tabelle mit dem Namen tutorials_tbl mit den Feldnamen wie ID, Titel, Autor und Übermittlungsdatum. Schauen Sie sich die folgende Abfrage an.

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

Nach Ausführung der obigen Abfrage erhalten Sie die folgende Ausgabe:

(0) rows effected

HSQLDB - JDBC-Programm

Das folgende JDBC-Programm wird zum Erstellen einer Tabelle mit dem Namen tutorials_tbl in der HSQLDB-Datenbank verwendet. Speichern Sie das Programm inCreateTable.java Datei.

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

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

Sie können die Datenbank mit dem folgenden Befehl starten.

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

Kompilieren Sie das obige Programm und führen Sie es mit dem folgenden Befehl aus.

\>javac CreateTable.java
\>java CreateTable

Nach Ausführung des obigen Befehls erhalten Sie die folgende Ausgabe:

Table created successfully

Es ist sehr einfach, eine vorhandene HSQLDB-Tabelle zu löschen. Sie müssen jedoch beim Löschen einer vorhandenen Tabelle sehr vorsichtig sein, da verlorene Daten nach dem Löschen einer Tabelle nicht wiederhergestellt werden.

Syntax

Es folgt eine generische SQL-Syntax zum Löschen einer HSQLDB-Tabelle.

DROP TABLE table_name;

Beispiel

Betrachten wir ein Beispiel, um eine Tabelle mit dem Namen employee vom HSQLDB-Server zu löschen. Es folgt die Abfrage zum Löschen einer Tabelle mit dem Namen employee.

DROP TABLE employee;

Nach Ausführung der obigen Abfrage erhalten Sie die folgende Ausgabe:

(0) rows effected

HSQLDB - JDBC-Programm

Im Folgenden finden Sie das JDBC-Programm, mit dem der Tabellenmitarbeiter vom HSQLDB-Server gelöscht wird.

Speichern Sie den folgenden Code in DropTable.java Datei.

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

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

Sie können die Datenbank mit dem folgenden Befehl starten.

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

Kompilieren Sie das obige Programm und führen Sie es mit dem folgenden Befehl aus.

\>javac DropTable.java
\>java DropTable

Nach Ausführung des obigen Befehls erhalten Sie die folgende Ausgabe:

Table dropped successfully

Sie können die Insert-Abfrageanweisung in HSQLDB mit dem Befehl INSERT INTO erreichen. Sie müssen die benutzerdefinierten Daten gemäß der Spaltenfeldreihenfolge aus der Tabelle bereitstellen.

Syntax

Es folgt die generische Syntax zu INSERT eine Anfrage.

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

Um Daten vom Typ Zeichenfolge in eine Tabelle einzufügen, müssen Sie doppelte oder einfache Anführungszeichen verwenden, um den Zeichenfolgenwert in die Anweisung zum Einfügen einer Abfrage bereitzustellen.

Beispiel

Betrachten wir ein Beispiel, das einen Datensatz in eine Tabelle mit dem Namen einfügt tutorials_tbl mit den Werten id = 100, title = Learn PHP, Author = John Poul und dem Einreichungsdatum ist das aktuelle Datum.

Es folgt die Abfrage für das angegebene Beispiel.

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

Nach Ausführung der obigen Abfrage erhalten Sie die folgende Ausgabe:

1 row effected

HSQLDB - JDBC-Programm

Hier ist das JDBC-Programm zum Einfügen des Datensatzes in die Tabelle mit den angegebenen Werten: id = 100, title = Learn PHP, Author = John Poul. Das Übermittlungsdatum ist das aktuelle Datum. Schauen Sie sich das angegebene Programm an. Speichern Sie den Code in derInserQuery.java Datei.

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

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

Sie können die Datenbank mit dem folgenden Befehl starten.

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

Kompilieren Sie das obige Programm und führen Sie es mit dem folgenden Befehl aus.

\>javac InsertQuery.java 
\>java InsertQuery

Nach Ausführung des obigen Befehls erhalten Sie die folgende Ausgabe:

1 rows effected 
Rows inserted successfully

Versuchen Sie, die folgenden Datensätze in das Feld einzufügen tutorials_tbl Tabelle mit der INSERT INTO Befehl.

Ich würde	Titel	Autor	Abgabetermin
101	Lernen Sie C.	Yaswanth	Jetzt()
102	Lerne MySQL	Abdul S.	Jetzt()
103	Lernen Sie Excell	Bavya kanna	Jetzt()
104	Lerne JDB	Ajith Kumar	Jetzt()
105	Lerne Junit	Sathya Murthi	Jetzt()

Mit dem Befehl SELECT werden die Datensatzdaten aus der HSQLDB-Datenbank abgerufen. Hier müssen Sie die Liste der erforderlichen Felder in der Select-Anweisung erwähnen.

Syntax

Hier ist die generische Syntax für die Select-Abfrage.

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

• Sie können ein oder mehrere Felder in einem einzigen SELECT-Befehl abrufen.

• Sie können anstelle von Feldern den Stern (*) angeben. In diesem Fall gibt SELECT alle Felder zurück.

• Sie können jede Bedingung mit der WHERE-Klausel angeben.

• Sie können einen Offset mit OFFSET angeben, von dem aus SELECT Datensätze zurückgibt. Standardmäßig ist der Offset Null.

• Sie können die Anzahl der Rückgaben mit dem LIMIT-Attribut begrenzen.

Beispiel

Hier ist ein Beispiel, in dem ID-, Titel- und Autorenfelder aller Datensätze abgerufen werden tutorials_tblTabelle. Dies können wir mit der SELECT-Anweisung erreichen. Es folgt die Abfrage für das Beispiel.

SELECT id, title, author FROM tutorials_tbl

Nach Ausführung der obigen Abfrage erhalten Sie die folgende Ausgabe.

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

HSQLDB - JDBC-Programm

Hier ist das JDBC-Programm, aus dem ID-, Titel- und Autorenfelder aller Datensätze abgerufen werden tutorials_tblTabelle. Speichern Sie den folgenden Code in derSelectQuery.java Datei.

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

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

Sie können die Datenbank mit dem folgenden Befehl starten.

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

Kompilieren Sie den obigen Code und führen Sie ihn mit dem folgenden Befehl aus.

\>javac SelectQuery.java
\>java SelectQuery

Nach Ausführung des obigen Befehls erhalten Sie die folgende Ausgabe:

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

Im Allgemeinen verwenden wir den Befehl SELECT, um Daten aus der HSQLDB-Tabelle abzurufen. Wir können die WHERE-Bedingungsklausel verwenden, um die resultierenden Daten zu filtern. Mit WHERE können wir die Auswahlkriterien angeben, um die erforderlichen Datensätze aus einer Tabelle auszuwählen.

Syntax

Es folgt die Syntax der WHERE-Klausel des SELECT-Befehls zum Abrufen von Daten aus der HSQLDB-Tabelle.

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

• Sie können eine oder mehrere durch Kommas getrennte Tabellen verwenden, um verschiedene Bedingungen mithilfe einer WHERE-Klausel einzuschließen. Die WHERE-Klausel ist jedoch ein optionaler Bestandteil des SELECT-Befehls.

• Sie können jede Bedingung mit der WHERE-Klausel angeben.

• Sie können mehr als eine Bedingung mit UND- oder ODER-Operatoren angeben.

• Eine WHERE-Klausel kann auch zusammen mit dem SQL-Befehl DELETE oder UPDATE verwendet werden, um eine Bedingung anzugeben.

Wir können die Datensatzdaten unter Verwendung von Bedingungen filtern. Wir verwenden verschiedene Operatoren in der bedingten WHERE-Klausel. Hier ist die Liste der Operatoren, die mit der WHERE-Klausel verwendet werden können.

Operator	Beschreibung	Beispiel
=	Überprüft, ob die Werte von zwei Operanden gleich sind oder nicht. Wenn ja, wird die Bedingung wahr.	(A = B) ist nicht wahr
! =	Überprüft, ob die Werte von zwei Operanden gleich sind oder nicht. Wenn die Werte nicht gleich sind, wird die Bedingung wahr.	(A! = B) ist wahr
>	Überprüft, ob der Wert des linken Operanden größer als der Wert des rechten Operanden ist. Wenn ja, wird die Bedingung erfüllt.	(A> B) ist nicht wahr
<	Überprüft, ob der Wert des linken Operanden kleiner als der Wert des rechten Operanden ist. Wenn ja, wird die Bedingung erfüllt.	(A <B) ist wahr
> =	Überprüft, ob der Wert des linken Operanden größer oder gleich dem Wert des rechten Operanden ist. Wenn ja, wird die Bedingung erfüllt.	(A> = B) ist nicht wahr
<=	Überprüft, ob der Wert des linken Operanden kleiner oder gleich dem Wert des rechten Operanden ist. Wenn ja, wird die Bedingung erfüllt.	(A <= B) ist wahr

Beispiel

Hier ist ein Beispiel, das Details wie ID, Titel und den Autor des Buches mit dem Titel "Learn C" abruft. Dies ist mit der WHERE-Klausel im Befehl SELECT möglich. Es folgt die Abfrage für dasselbe.

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

Nach Ausführung der obigen Abfrage erhalten Sie die folgende Ausgabe.

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

HSQLDB - JDBC-Programm

Hier ist das JDBC-Programm, das die Datensatzdaten aus der Tabelle tutorials_tbl mit dem Titel abruft Learn C. Speichern Sie den folgenden Code inWhereClause.java.

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

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

}

Sie können die Datenbank mit dem folgenden Befehl starten.

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

Kompilieren Sie den obigen Code und führen Sie ihn mit dem folgenden Befehl aus.

\>javac WhereClause.java
\>java WhereClause

Nach Ausführung des obigen Befehls erhalten Sie die folgende Ausgabe.

101 | Learn C | Yaswanth

Wenn Sie die Werte einer Tabelle ändern möchten, können Sie den Befehl UPDATE verwenden. Dadurch wird jeder Feldwert aus einer beliebigen HSQLDB-Tabelle geändert.

Syntax

Hier ist die generische Syntax für den Befehl UPDATE.

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

• Sie können ein oder mehrere Felder insgesamt aktualisieren.
• Sie können jede Bedingung mit der WHERE-Klausel angeben.
• Sie können Werte gleichzeitig in einer einzelnen Tabelle aktualisieren.

Beispiel

Betrachten wir ein Beispiel, das den Titel des Tutorials von "Learn C" auf "C and Data Structures" mit der ID "101" aktualisiert. Es folgt die Abfrage für das Update.

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

Nach Ausführung der obigen Abfrage erhalten Sie die folgende Ausgabe.

(1) Rows effected

HSQLDB - JDBC-Programm

Hier ist das JDBC-Programm, mit dem ein Tutorial-Titel aktualisiert wird Learn C zu C and Data Structures einen Ausweis haben 101. Speichern Sie das folgende Programm in derUpdateQuery.java Datei.

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

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

Sie können die Datenbank mit dem folgenden Befehl starten.

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

Kompilieren Sie das obige Programm und führen Sie es mit dem folgenden Befehl aus.

\>javac UpdateQuery.java
\>java UpdateQuery

Nach Ausführung des obigen Befehls erhalten Sie die folgende Ausgabe:

1 Rows effected

Wenn Sie einen Datensatz aus einer HSQLDB-Tabelle löschen möchten, können Sie den Befehl DELETE FROM verwenden.

Syntax

Hier ist die generische Syntax für den Befehl DELETE zum Löschen von Daten aus einer HSQLDB-Tabelle.

DELETE FROM table_name [WHERE Clause]

• Wenn die WHERE-Klausel nicht angegeben ist, werden alle Datensätze aus der angegebenen MySQL-Tabelle gelöscht.

• Sie können jede Bedingung mit der WHERE-Klausel angeben.

• Sie können Datensätze in einer einzelnen Tabelle gleichzeitig löschen.

Beispiel

Betrachten wir ein Beispiel, bei dem die Datensatzdaten aus der genannten Tabelle gelöscht werden tutorials_tbl mit id 105. Es folgt die Abfrage, die das angegebene Beispiel implementiert.

DELETE FROM tutorials_tbl WHERE id = 105;

Nach Ausführung der obigen Abfrage erhalten Sie die folgende Ausgabe:

(1) rows effected

HSQLDB - JDBC-Programm

Hier ist das JDBC-Programm, das das angegebene Beispiel implementiert. Speichern Sie das folgende Programm inDeleteQuery.java.

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

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

Sie können die Datenbank mit dem folgenden Befehl starten.

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

Kompilieren Sie das obige Programm und führen Sie es mit dem folgenden Befehl aus.

\>javac DeleteQuery.java
\>java DeleteQuery

Nach Ausführung des obigen Befehls erhalten Sie die folgende Ausgabe:

1 Rows effected

In der RDBMS-Struktur gibt es eine WHERE-Klausel. Sie können die WHERE-Klausel mit einem Gleichheitszeichen (=) verwenden, um eine genaue Übereinstimmung zu erzielen. Es kann jedoch eine Anforderung geben, bei der alle Ergebnisse herausgefiltert werden sollen, bei denen der Autorenname "john" enthalten sollte. Dies kann mit der SQL LIKE-Klausel zusammen mit der WHERE-Klausel behandelt werden.

Wenn die SQL LIKE-Klausel zusammen mit% -Zeichen verwendet wird, funktioniert sie unter UNIX wie ein Metazeichen (*), während alle Dateien oder Verzeichnisse an der Eingabeaufforderung aufgelistet werden.

Syntax

Es folgt die generische SQL-Syntax der LIKE-Klausel.

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

• Sie können jede Bedingung mit der WHERE-Klausel angeben.

• Sie können die LIKE-Klausel zusammen mit der WHERE-Klausel verwenden.

• Sie können die LIKE-Klausel anstelle des Gleichheitszeichens verwenden.

• Wenn die LIKE-Klausel zusammen mit dem% -Zeichen verwendet wird, funktioniert sie wie eine Metazeichen-Suche.

• Sie können mehr als eine Bedingung mit UND- oder ODER-Operatoren angeben.

• Eine WHERE ... LIKE-Klausel kann zusammen mit dem Befehl DELETE oder UPDATE SQL verwendet werden, um eine Bedingung anzugeben.

Beispiel

Betrachten wir ein Beispiel, das die Liste der Tutorials abruft, mit denen der Autorenname beginnt John. Es folgt die HSQLDB-Abfrage für das angegebene Beispiel.

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

Nach Ausführung der obigen Abfrage erhalten Sie die folgende Ausgabe.

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

HSQLDB - JDBC-Programm

Das folgende JDBC-Programm ruft die Liste der Tutorials ab, mit denen der Autorenname beginnt John. Speichern Sie den Code inLikeClause.java.

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

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

Sie können die Datenbank mit dem folgenden Befehl starten.

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

Kompilieren Sie den obigen Code und führen Sie ihn mit dem folgenden Befehl aus.

\>javac LikeClause.java
\>java LikeClause

Nach Ausführung des folgenden Befehls erhalten Sie die folgende Ausgabe.

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

Der Befehl SQL SELECT ruft Daten aus der HSQLDB-Tabelle ab, wenn beim Abrufen und Anzeigen von Datensätzen eine Anforderung vorliegt, die einer bestimmten Reihenfolge folgt. In diesem Fall können wir die verwendenORDER BY Klausel.

Syntax

Hier ist die Syntax des Befehls SELECT zusammen mit der ORDER BY-Klausel zum Sortieren von Daten aus HSQLDB.

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

• Sie können das zurückgegebene Ergebnis nach jedem Feld sortieren, sofern dieses Feld aufgelistet wird.

• Sie können das Ergebnis nach mehreren Feldern sortieren.

• Sie können das Schlüsselwort ASC oder DESC verwenden, um das Ergebnis in aufsteigender oder absteigender Reihenfolge abzurufen. Standardmäßig ist es in aufsteigender Reihenfolge.

• Sie können die WHERE ... LIKE-Klausel auf übliche Weise verwenden, um eine Bedingung zu setzen.

Beispiel

Betrachten wir ein Beispiel, das die Aufzeichnungen von abruft und sortiert tutorials_tblTabelle, indem Sie den Autorennamen in aufsteigender Reihenfolge bestellen. Es folgt die Abfrage für dasselbe.

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

Nach Ausführung der obigen Abfrage erhalten Sie die folgende Ausgabe.

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

HSQLDB - JDBC-Programm

Hier ist das JDBC-Programm, das die Datensätze von abruft und sortiert tutorials_tblTabelle, indem Sie den Autorennamen in aufsteigender Reihenfolge bestellen. Speichern Sie das folgende Programm inOrderBy.java.

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

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

Sie können die Datenbank mit dem folgenden Befehl starten.

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

Kompilieren Sie das obige Programm und führen Sie es mit dem folgenden Befehl aus.

\>javac OrderBy.java
\>java OrderBy

Nach Ausführung des obigen Befehls erhalten Sie die folgende Ausgabe.

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

Wenn Daten mit einer einzigen Abfrage aus mehreren Tabellen abgerufen werden müssen, können Sie JOINS aus RDBMS verwenden. Sie können mehrere Tabellen in Ihrer einzelnen SQL-Abfrage verwenden. Der Vorgang des Beitritts zu HSQLDB bezieht sich auf das Zerschlagen von zwei oder mehr Tabellen in einer einzigen Tabelle.

Betrachten Sie die folgenden Kunden- und Auftragstabellen.

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

Lassen Sie uns nun versuchen, die Daten der Kunden und den Bestellbetrag abzurufen, den der jeweilige Kunde aufgegeben hat. Dies bedeutet, dass wir die Datensatzdaten sowohl aus der Kunden- als auch aus der Auftragstabelle abrufen. Wir können dies erreichen, indem wir das JOINS-Konzept in HSQLDB verwenden. Es folgt die JOIN-Abfrage für dasselbe.

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

Nach Ausführung der obigen Abfrage erhalten Sie die folgende Ausgabe.

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

JOIN-Typen

In HSQLDB stehen verschiedene Arten von Joins zur Verfügung.

• INNER JOIN - Gibt die Zeilen zurück, wenn in beiden Tabellen eine Übereinstimmung vorliegt.

• LEFT JOIN - Gibt alle Zeilen aus der linken Tabelle zurück, auch wenn die rechte Tabelle keine Übereinstimmungen enthält.

• RIGHT JOIN - Gibt alle Zeilen aus der rechten Tabelle zurück, auch wenn die linke Tabelle keine Übereinstimmungen enthält.

• FULL JOIN - Gibt die Zeilen zurück, wenn in einer der Tabellen eine Übereinstimmung vorliegt.

• SELF JOIN - Wird verwendet, um eine Tabelle mit sich selbst zu verbinden, als wäre die Tabelle zwei Tabellen, wobei mindestens eine Tabelle in der SQL-Anweisung vorübergehend umbenannt wird.

Inner Join

Die am häufigsten verwendete und wichtigste Verknüpfung ist die INNER JOIN. Es wird auch als EQUIJOIN bezeichnet.

Der INNER JOIN erstellt eine neue Ergebnistabelle, indem die Spaltenwerte von zwei Tabellen (Tabelle1 und Tabelle2) basierend auf dem Join-Prädikat kombiniert werden. Die Abfrage vergleicht jede Zeile von Tabelle1 mit jeder Zeile von Tabelle2, um alle Zeilenpaare zu finden, die das Join-Prädikat erfüllen. Wenn das Join-Prädikat erfüllt ist, werden die Spaltenwerte für jedes übereinstimmende Zeilenpaar A und B zu einer Ergebniszeile zusammengefasst.

Syntax

Die grundlegende Syntax von INNER JOIN lautet wie folgt.

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

Beispiel

Betrachten Sie die folgenden zwei Tabellen, eine mit dem Titel CUSTOMERS-Tabelle und eine mit dem Titel ORDERS-Tabelle wie folgt:

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

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

Lassen Sie uns nun diese beiden Tabellen mit der INNER JOIN-Abfrage wie folgt verbinden:

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

Nach Ausführung der obigen Abfrage erhalten Sie die folgende Ausgabe.

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

Links beitreten

Der HSQLDB LEFT JOIN gibt alle Zeilen aus der linken Tabelle zurück, auch wenn die rechte Tabelle keine Übereinstimmungen enthält. Dies bedeutet, dass, wenn die ON-Klausel mit 0 (Null) Datensätzen in der rechten Tabelle übereinstimmt, der Join weiterhin eine Zeile im Ergebnis zurückgibt, jedoch mit NULL in jeder Spalte aus der rechten Tabelle.

Dies bedeutet, dass ein linker Join alle Werte aus der linken Tabelle sowie übereinstimmende Werte aus der rechten Tabelle oder NULL zurückgibt, falls kein übereinstimmendes Join-Prädikat vorliegt.

Syntax

Die grundlegende Syntax von LEFT JOIN lautet wie folgt:

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

Hier kann die angegebene Bedingung ein beliebiger Ausdruck sein, der auf Ihrer Anforderung basiert.

Beispiel

Betrachten Sie die folgenden zwei Tabellen, eine mit dem Titel CUSTOMERS-Tabelle und eine mit dem Titel ORDERS-Tabelle wie folgt:

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

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

Lassen Sie uns nun diese beiden Tabellen mit der Abfrage LEFT JOIN wie folgt verbinden:

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

Nach Ausführung der obigen Abfrage erhalten Sie die folgende Ausgabe:

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

Right Join

Der HSQLDB RIGHT JOIN gibt alle Zeilen aus der rechten Tabelle zurück, auch wenn die linke Tabelle keine Übereinstimmungen enthält. Dies bedeutet, dass, wenn die ON-Klausel mit 0 (Null) Datensätzen in der linken Tabelle übereinstimmt, der Join weiterhin eine Zeile im Ergebnis zurückgibt, jedoch mit NULL in jeder Spalte aus der linken Tabelle.

Dies bedeutet, dass ein rechter Join alle Werte aus der rechten Tabelle sowie übereinstimmende Werte aus der linken Tabelle oder NULL zurückgibt, falls kein übereinstimmendes Join-Prädikat vorliegt.

Syntax

Die grundlegende Syntax von RIGHT JOIN ist wie folgt -

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

Beispiel

Betrachten Sie die folgenden zwei Tabellen, eine mit dem Titel CUSTOMERS-Tabelle und eine mit dem Titel ORDERS-Tabelle wie folgt:

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

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

Lassen Sie uns nun diese beiden Tabellen mit der Abfrage RIGHT JOIN wie folgt verbinden:

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

Nach Ausführung der obigen Abfrage erhalten Sie das folgende Ergebnis.

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

Vollständige Teilnahme

Der HSQLDB FULL JOIN kombiniert die Ergebnisse der linken und rechten äußeren Verknüpfungen.

Die verknüpfte Tabelle enthält alle Datensätze aus beiden Tabellen und gibt NULL für die fehlenden Übereinstimmungen auf beiden Seiten ein.

Syntax

Die grundlegende Syntax von FULL JOIN lautet wie folgt:

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

Hier kann die angegebene Bedingung ein beliebiger Ausdruck sein, der auf Ihrer Anforderung basiert.

Beispiel

Betrachten Sie die folgenden zwei Tabellen, eine mit dem Titel CUSTOMERS-Tabelle und eine mit dem Titel ORDERS-Tabelle wie folgt:

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

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

Lassen Sie uns nun diese beiden Tabellen mit der FULL JOIN-Abfrage wie folgt verbinden:

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

Nach Ausführung der obigen Abfrage erhalten Sie das folgende Ergebnis.

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

Selbst beitreten

Der SQL SELF JOIN wird verwendet, um eine Tabelle mit sich selbst zu verbinden, als wäre die Tabelle zwei Tabellen, wobei mindestens eine Tabelle in der SQL-Anweisung vorübergehend umbenannt wird.

Syntax

Die grundlegende Syntax von SELF JOIN lautet wie folgt:

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

Hier kann die WHERE-Klausel ein beliebiger Ausdruck sein, der auf Ihrer Anforderung basiert.

Beispiel

Betrachten Sie die folgenden zwei Tabellen, eine mit dem Titel CUSTOMERS-Tabelle und eine mit dem Titel ORDERS-Tabelle wie folgt:

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

Lassen Sie uns nun diese Tabelle mit der SELF JOIN-Abfrage wie folgt verbinden:

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

Nach Ausführung der obigen Abfrage erhalten Sie die folgende Ausgabe:

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

SQL NULL ist ein Begriff, der verwendet wird, um einen fehlenden Wert darzustellen. Ein NULL-Wert in einer Tabelle ist ein Wert in einem Feld, der leer zu sein scheint. Immer wenn wir versuchen, eine Bedingung anzugeben, die den Feld- oder Spaltenwert mit NULL vergleicht, funktioniert dies nicht ordnungsgemäß.

Wir können mit den NULL-Werten umgehen, indem wir die drei Dinge verwenden.

• IS NULL - Der Operator gibt true zurück, wenn der Spaltenwert NULL ist.

• IS NOT NULL - Der Operator gibt true zurück, wenn der Spaltenwert NICHT NULL ist.

• <=> - Der Operator vergleicht Werte, was (im Gegensatz zum Operator =) auch für zwei NULL-Werte gilt.

Verwenden Sie IS NULL bzw. IS NOT NULL, um nach Spalten zu suchen, die NULL oder NOT NULL sind.

Beispiel

Betrachten wir ein Beispiel, in dem es eine Tabelle gibt tcount_tblDas enthält zwei Spalten, author und tutorial_count. Wir können dem tutorial_count NULL-Werte geben. Dies zeigt an, dass der Autor nicht einmal ein Tutorial veröffentlicht hat. Daher ist der Wert tutorial_count für den jeweiligen Autor NULL.

Führen Sie die folgenden Abfragen aus.

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

Verwenden Sie den folgenden Befehl, um alle Datensätze aus dem anzuzeigen tcount_tbl Tabelle.

select * from tcount_tbl;

Nach Ausführung des obigen Befehls erhalten Sie die folgende Ausgabe.

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

Um die Datensätze zu finden, in denen die Spalte tutorial_count NULL ist, folgt die Abfrage.

SELECT * FROM tcount_tbl WHERE tutorial_count IS NULL;

Nach Ausführung der Abfrage erhalten Sie die folgende Ausgabe.

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

Um die Datensätze zu finden, in denen die Spalte tutorial_count NICHT NULL ist, folgt die folgende Abfrage.

SELECT * FROM tcount_tbl WHERE tutorial_count IS NOT NULL;

Nach Ausführung der Abfrage erhalten Sie die folgende Ausgabe.

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

HSQLDB - JDBC-Programm

Hier ist das JDBC-Programm, das die Datensätze getrennt von der Tabelle tcount_tbl abruft, wobei die Anzahl der Lernprogramme NULL und die Anzahl der Lernprogramme NICHT NULL ist. Speichern Sie das folgende Programm inNullValues.java.

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

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

Kompilieren Sie das obige Programm und führen Sie es mit dem folgenden Befehl aus.

\>javac NullValues.java
\>Java NullValues

Nach Ausführung des obigen Befehls erhalten Sie die folgende Ausgabe.

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

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

HSQLDB unterstützt einige spezielle Symbole für Mustervergleichsoperationen, die auf regulären Ausdrücken und dem REGEXP-Operator basieren.

Es folgt die Mustertabelle, die zusammen mit dem REGEXP-Operator verwendet werden kann.

Muster	Was das Muster passt
^	Anfang der Saite
$	Ende der Zeichenfolge
.	Beliebiges einzelnes Zeichen
[...]	Jedes Zeichen in eckigen Klammern
[^ ...]	Alle Zeichen, die nicht in eckigen Klammern aufgeführt sind
p1 | p2 | p3	Wechsel; stimmt mit einem der Muster p1, p2 oder p3 überein
* *	Null oder mehr Instanzen des vorhergehenden Elements
+	Eine oder mehrere Instanzen des vorhergehenden Elements
{n}	n Instanzen des vorhergehenden Elements
{m, n}	m bis n Instanzen des vorhergehenden Elements

Beispiel

Lassen Sie uns verschiedene Beispielabfragen ausprobieren, um unsere Anforderungen zu erfüllen. Schauen Sie sich die folgenden Fragen an.

Versuchen Sie diese Abfrage, um alle Autoren zu finden, deren Name mit '^ A' beginnt.

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

Nach Ausführung der obigen Abfrage erhalten Sie die folgende Ausgabe.

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

Versuchen Sie diese Abfrage, um alle Autoren zu finden, deren Name mit 'ul $' endet.

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

Nach Ausführung der obigen Abfrage erhalten Sie die folgende Ausgabe.

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

Versuchen Sie diese Abfrage, um alle Autoren zu finden, deren Name 'th' enthält.

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

Nach Ausführung der obigen Abfrage erhalten Sie die folgende Ausgabe.

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

Versuchen Sie diese Abfrage, um alle Autoren zu finden, deren Name mit Vokal beginnt (a, e, i, o, u).

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

Nach Ausführung der obigen Abfrage erhalten Sie die folgende Ausgabe.

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

EIN Transactionist eine sequentielle Gruppe von Datenbankmanipulationsvorgängen, die ausgeführt und als eine einzige Arbeitseinheit betrachtet werden. Mit anderen Worten, wenn alle Vorgänge erfolgreich ausgeführt wurden, ist nur dann die gesamte Transaktion abgeschlossen. Wenn eine Operation innerhalb der Transaktion fehlschlägt, schlägt die gesamte Transaktion fehl.

Eigenschaften von Transaktionen

Grundsätzlich unterstützt die Transaktion 4 Standardeigenschaften. Sie können als ACID-Eigenschaften bezeichnet werden.

Atomicity - Alle Vorgänge in den Transaktionen werden erfolgreich ausgeführt, andernfalls wird die Transaktion zum Zeitpunkt des Ausfalls abgebrochen und die vorherigen Vorgänge werden auf ihre vorherige Position zurückgesetzt.

Consistency - Die Datenbank ändert den Status bei einer erfolgreich festgeschriebenen Transaktion ordnungsgemäß.

Isolation - Es ermöglicht der Transaktion, unabhängig voneinander und transparent für einander zu arbeiten.

Durability - Das Ergebnis oder die Wirkung einer festgeschriebenen Transaktion bleibt bei einem Systemausfall bestehen.

Commit, Rollback und Savepoint

Diese Schlüsselwörter werden hauptsächlich für HSQLDB-Transaktionen verwendet.

Commit- Die erfolgreiche Transaktion sollte immer durch Ausführen des Befehls COMMIT abgeschlossen werden.

Rollback - Wenn in der Transaktion ein Fehler auftritt, sollte der Befehl ROLLBACK ausgeführt werden, um jede Tabelle, auf die in der Transaktion verwiesen wird, auf ihren vorherigen Status zurückzusetzen.

Savepoint - Erstellt einen Punkt innerhalb der Gruppe von Transaktionen, in dem ein Rollback durchgeführt werden soll.

Beispiel

Im folgenden Beispiel wird das Transaktionskonzept zusammen mit Commit, Rollback und Savepoint erläutert. Betrachten wir die Tabelle Kunden mit den Spalten ID, Name, Alter, Adresse und Gehalt.

Ich würde	Name	Alter	Adresse	Gehalt
1	Ramesh	32	Ahmedabad	2000.00
2	Karun	25	Delhi	1500.00
3	Kaushik	23	Kota	2000.00
4	Chaitanya	25	Mumbai	6500.00
5	Harish	27	Bhopal	8500.00
6	Kamesh	22	MP	1500.00
7	Murali	24	Indore	10000.00

Verwenden Sie die folgenden Befehle, um die Kundentabelle gemäß den obigen Daten zu erstellen.

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

Beispiel für COMMIT

Die folgende Abfrage löscht Zeilen aus der Tabelle mit dem Alter = 25 und verwendet den Befehl COMMIT, um diese Änderungen in der Datenbank anzuwenden.

DELETE FROM CUSTOMERS WHERE AGE = 25;
COMMIT;

Nach Ausführung der obigen Abfrage erhalten Sie die folgende Ausgabe.

2 rows effected

Überprüfen Sie nach erfolgreicher Ausführung des obigen Befehls die Datensätze der Kundentabelle, indem Sie den unten angegebenen Befehl ausführen.

Select * from Customer;

Nach Ausführung der obigen Abfrage erhalten Sie die folgende Ausgabe.

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

Beispiel für Rollback

Betrachten wir dieselbe Kundentabelle als Eingabe.

Ich würde	Name	Alter	Adresse	Gehalt
1	Ramesh	32	Ahmedabad	2000.00
2	Karun	25	Delhi	1500.00
3	Kaushik	23	Kota	2000.00
4	Chaitanya	25	Mumbai	6500.00
5	Harish	27	Bhopal	8500.00
6	Kamesh	22	MP	1500.00
7	Murali	24	Indore	10000.00

In der folgenden Beispielabfrage wird die Rollback-Funktionalität erläutert, indem Datensätze aus der Tabelle mit dem Alter = 25 gelöscht und anschließend die Änderungen in der Datenbank rückgängig gemacht werden.

DELETE FROM CUSTOMERS WHERE AGE = 25;
ROLLBACK;

Nach erfolgreicher Ausführung der beiden oben genannten Abfragen können Sie die Datensatzdaten in der Kundentabelle mit dem folgenden Befehl anzeigen.

Select * from Customer;

Nach Ausführung des obigen Befehls erhalten Sie die folgende Ausgabe.

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

Die Löschabfrage löscht die Datensatzdaten von Kunden mit einem Alter von 25 Jahren. Mit dem Befehl Rollback werden diese Änderungen in der Kundentabelle zurückgesetzt.

Beispiel für Savepoint

Sicherungspunkt ist ein Punkt in einer Transaktion, an dem Sie die Transaktion auf einen bestimmten Punkt zurücksetzen können, ohne die gesamte Transaktion zurückzusetzen.

Betrachten wir dieselbe Kundentabelle als Eingabe.

Ich würde	Name	Alter	Adresse	Gehalt
1	Ramesh	32	Ahmedabad	2000.00
2	Karun	25	Delhi	1500.00
3	Kaushik	23	Kota	2000.00
4	Chaitanya	25	Mumbai	6500.00
5	Harish	27	Bhopal	8500.00
6	Kamesh	22	MP	1500.00
7	Murali	24	Indore	10000.00

In diesem Beispiel möchten Sie die drei verschiedenen Datensätze aus der Tabelle "Kunden" löschen. Sie möchten vor jedem Löschen einen Sicherungspunkt erstellen, damit Sie jederzeit zu einem beliebigen Sicherungspunkt zurückkehren können, um die entsprechenden Daten in den ursprünglichen Zustand zurückzusetzen.

Hier ist die Reihe von Operationen.

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

Jetzt haben Sie drei Sicherungspunkte erstellt und drei Datensätze gelöscht. Wenn Sie in dieser Situation die Datensätze mit den IDs 2 und 3 zurücksetzen möchten, verwenden Sie den folgenden Rollback-Befehl.

ROLLBACK TO SP2;

Beachten Sie, dass nur das erste Löschen stattgefunden hat, seit Sie ein Rollback auf SP2 durchgeführt haben. Verwenden Sie die folgende Abfrage, um alle Datensätze der Kunden anzuzeigen.

Select * from Customer;

Nach Ausführung der obigen Abfrage erhalten Sie die folgende Ausgabe.

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

Geben Sie Savepoint frei

Wir können den Savepoint mit dem Befehl RELEASE freigeben. Es folgt die generische Syntax.

RELEASE SAVEPOINT SAVEPOINT_NAME;

Wenn Sie den Namen einer Tabelle oder eines Felds ändern, die Reihenfolge der Felder ändern, den Datentyp der Felder oder eine beliebige Tabellenstruktur ändern müssen, können Sie dies mit dem Befehl ALTER erreichen.

Beispiel

Betrachten wir ein Beispiel, in dem der Befehl ALTER anhand verschiedener Szenarien erläutert wird.

Verwenden Sie die folgende Abfrage, um eine Tabelle mit dem Namen zu erstellen testalter_tbl mit den Feldern ' id und name.

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

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

Nach Ausführung der obigen Abfrage erhalten Sie die folgende Ausgabe.

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

Löschen oder Hinzufügen einer Spalte

Wenn Sie eine vorhandene Spalte aus der HSQLDB-Tabelle DROPEN möchten, können Sie die DROP-Klausel zusammen mit dem Befehl ALTER verwenden.

Verwenden Sie die folgende Abfrage, um eine Spalte zu löschen (name) aus der Tabelle testalter_tbl.

ALTER TABLE testalter_tbl DROP name;

Nach erfolgreicher Ausführung der obigen Abfrage können Sie mit dem folgenden Befehl feststellen, ob das Namensfeld aus der Tabelle testalter_tbl entfernt wurde.

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

Nach Ausführung des obigen Befehls erhalten Sie die folgende Ausgabe.

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

Wenn Sie der HSQLDB-Tabelle eine Spalte hinzufügen möchten, können Sie die ADD-Klausel zusammen mit dem Befehl ALTER verwenden.

Verwenden Sie die folgende Abfrage, um eine Spalte mit dem Namen hinzuzufügen NAME an den Tisch testalter_tbl.

ALTER TABLE testalter_tbl ADD name VARCHAR(10);

Nach erfolgreicher Ausführung der obigen Abfrage können Sie feststellen, ob das Namensfeld zur Tabelle hinzugefügt wurde testalter_tbl mit dem folgenden Befehl.

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

Nach Ausführung der obigen Abfrage erhalten Sie die folgende Ausgabe.

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

Ändern einer Spaltendefinition oder eines Spaltennamens

Verwenden Sie die Option, wenn die Spaltendefinition geändert werden muss MODIFY oder CHANGE Klausel zusammen mit der ALTER Befehl.

Betrachten wir ein Beispiel, in dem die Verwendung der CHANGE-Klausel erläutert wird. Der Tischtestalter_tblenthält zwei Felder - id und name - mit den Datentypen int und varchar. Versuchen wir nun, den Datentyp der ID von INT in BIGINT zu ändern. Es folgt die Abfrage, um die Änderung vorzunehmen.

ALTER TABLE testalter_tbl CHANGE id id BIGINT;

Nach erfolgreicher Ausführung der obigen Abfrage kann die Tabellenstruktur mit dem folgenden Befehl überprüft werden.

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

Nach Ausführung des obigen Befehls erhalten Sie die folgende Ausgabe.

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

Versuchen wir nun, die Größe eines Spaltennamens von 10 auf 20 im zu erhöhen testalter_tblTabelle. Es folgt die Abfrage, um dies mithilfe der MODIFY-Klausel zusammen mit dem Befehl ALTER zu erreichen.

ALTER TABLE testalter_tbl MODIFY name VARCHAR(20);

Nach erfolgreicher Ausführung der obigen Abfrage kann die Tabellenstruktur mit dem folgenden Befehl überprüft werden.

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

Nach Ausführung des obigen Befehls erhalten Sie die folgende Ausgabe.

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

EIN database indexist eine Datenstruktur, die die Geschwindigkeit von Operationen in einer Tabelle verbessert. Indizes können mithilfe einer oder mehrerer Spalten erstellt werden. Dies ist die Grundlage für schnelle zufällige Suchvorgänge und eine effiziente Reihenfolge des Zugriffs auf die Datensätze.

Beim Erstellen eines Index sollte berücksichtigt werden, welche Spalten zum Erstellen von SQL-Abfragen verwendet werden, und ein oder mehrere Indizes für diese Spalten erstellt werden.

In der Praxis handelt es sich bei Indizes auch um Tabellentypen, bei denen der Primärschlüssel oder das Indexfeld sowie ein Zeiger auf jeden Datensatz in der tatsächlichen Tabelle enthalten bleiben.

Die Benutzer können die Indizes nicht sehen. Sie werden nur verwendet, um Abfragen zu beschleunigen, und werden von der Datenbanksuchmaschine verwendet, um Datensätze schnell zu finden.

Die Anweisungen INSERT und UPDATE benötigen für Tabellen mit Indizes mehr Zeit, während die Anweisungen SELECT für diese Tabellen schneller ausgeführt werden. Der Grund dafür ist, dass die Datenbank beim Einfügen oder Aktualisieren auch die Indexwerte einfügen oder aktualisieren muss.

Einfacher und einzigartiger Index

Sie können einen eindeutigen Index für eine Tabelle erstellen. EINunique indexbedeutet, dass zwei Zeilen nicht denselben Indexwert haben können. Es folgt die Syntax zum Erstellen eines Index für eine Tabelle.

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

Sie können eine oder mehrere Spalten verwenden, um einen Index zu erstellen. Erstellen Sie beispielsweise mit tutorial_author einen Index für tutorials_tbl.

CREATE UNIQUE INDEX AUTHOR_INDEX
ON tutorials_tbl (tutorial_author)

Sie können einen einfachen Index für eine Tabelle erstellen. Lassen Sie einfach das Schlüsselwort UNIQUE in der Abfrage weg, um einen einfachen Index zu erstellen. EINsimple index ermöglicht doppelte Werte in einer Tabelle.

Wenn Sie die Werte in einer Spalte in absteigender Reihenfolge indizieren möchten, können Sie das reservierte Wort DESC nach dem Spaltennamen hinzufügen.

CREATE UNIQUE INDEX AUTHOR_INDEX
ON tutorials_tbl (tutorial_author DESC)

ALTER Befehl zum Hinzufügen und Löschen von INDEX

Es gibt vier Arten von Anweisungen zum Hinzufügen von Indizes zu einer Tabelle:

• ALTER TABLE tbl_name ADD PRIMARY KEY (column_list) - Diese Anweisung fügt einen PRIMARY KEY hinzu. Dies bedeutet, dass indizierte Werte eindeutig sein müssen und nicht NULL sein dürfen.

• ALTER TABLE tbl_name ADD UNIQUE index_name (column_list) - Diese Anweisung erstellt einen Index, für den die Werte eindeutig sein müssen (mit Ausnahme von NULL-Werten, die möglicherweise mehrmals vorkommen).

• ALTER TABLE tbl_name ADD INDEX index_name (column_list) - Dies fügt einen normalen Index hinzu, in dem jeder Wert mehrmals vorkommen kann.

• ALTER TABLE tbl_name ADD FULLTEXT index_name (column_list) - Dadurch wird ein spezieller FULLTEXT-Index erstellt, der für die Textsuche verwendet wird.

Es folgt die Abfrage zum Hinzufügen eines Index zu einer vorhandenen Tabelle.

ALTER TABLE testalter_tbl ADD INDEX (c);

Sie können jeden INDEX löschen, indem Sie die DROP-Klausel zusammen mit dem Befehl ALTER verwenden. Es folgt die Abfrage zum Löschen des oben erstellten Index.

ALTER TABLE testalter_tbl DROP INDEX (c);

INDEX-Informationen anzeigen

Mit dem Befehl SHOW INDEX können Sie alle einer Tabelle zugeordneten Indizes auflisten. Die Ausgabe im vertikalen Format (angegeben durch \ G) ist bei dieser Anweisung häufig hilfreich, um einen langen Zeilenumbruch zu vermeiden.

Im Folgenden finden Sie die generische Syntax zum Anzeigen der Indexinformationen zu einer Tabelle.

SHOW INDEX FROM table_name\G