HSQLDB - szybki przewodnik

Baza danych HyperSQL (HSQLDB) to nowoczesny menedżer relacyjnych baz danych, który jest ściśle zgodny ze standardem SQL: 2011 i specyfikacjami JDBC 4. Obsługuje wszystkie podstawowe funkcje i RDBMS. HSQLDB służy do tworzenia, testowania i wdrażania aplikacji bazodanowych.

Główną i unikalną cechą HSQLDB jest zgodność ze standardami. Może zapewniać dostęp do bazy danych w ramach procesu aplikacji użytkownika, na serwerze aplikacji lub jako oddzielny proces serwera.

Funkcje HSQLDB

• HSQLDB wykorzystuje strukturę w pamięci do szybkich operacji na serwerze DB. Wykorzystuje trwałość dysku zgodnie z elastycznością użytkownika, z niezawodnym odzyskiwaniem po awarii.

• HSQLDB nadaje się również do analizy biznesowej, ETL i innych aplikacji przetwarzających duże zbiory danych.

• HSQLDB oferuje szeroki zakres opcji wdrażania w przedsiębiorstwie, takich jak transakcje XA, źródła danych puli połączeń i zdalne uwierzytelnianie.

• HSQLDB jest napisany w języku programowania Java i działa na wirtualnej maszynie Java (JVM). Obsługuje interfejs JDBC umożliwiający dostęp do bazy danych.

Składniki HSQLDB

W pakiecie jar HSQLDB są trzy różne składniki.

• Silnik HyperSQL RDBMS (HSQLDB)

• Sterownik HyperSQL JDBC

• Database Manager (narzędzie dostępu do bazy danych GUI, wersje Swing i AWT)

Podstawową funkcjonalność zapewnia HyperSQL RDBMS i sterownik JDBC. Menedżery baz danych to narzędzia ogólnego przeznaczenia do dostępu do baz danych, których można używać z dowolnym silnikiem bazy danych posiadającym sterownik JDBC.

Dodatkowy plik jar o nazwie sqltool.jar zawiera narzędzie Sql, które jest narzędziem dostępu do bazy danych wiersza poleceń. To jest polecenie ogólnego przeznaczenia. Narzędzie dostępu do liniowej bazy danych, którego można używać również z innymi silnikami baz danych.

HSQLDB to system zarządzania relacyjnymi bazami danych zaimplementowany w czystej Javie. Możesz łatwo osadzić tę bazę danych w swojej aplikacji za pomocą JDBC. Lub możesz użyć operacji osobno.

Wymagania wstępne

Postępuj zgodnie z wymaganiami instalacji oprogramowania dla HSQLDB.

Sprawdź instalację oprogramowania Java

Ponieważ HSQLDB to system zarządzania relacyjnymi bazami danych zaimplementowany w czystej Javie, przed zainstalowaniem HSQLDB należy zainstalować oprogramowanie JDK (Java Development Kit). Jeśli masz już instalację JDK w swoim systemie, wypróbuj następującą komendę, aby sprawdzić wersję Java.

java –version

Jeśli JDK zostanie pomyślnie zainstalowany w twoim systemie, otrzymasz następujące dane wyjściowe.

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)

Jeśli nie masz zainstalowanego JDK w swoim systemie, odwiedź poniższe łącze, aby zainstalować JDK.

Instalacja HSQLDB

Poniżej przedstawiono kroki instalacji HSQLDB.

Step 1 − Download HSQLDB bundle

Pobierz najnowszą wersję bazy danych HSQLDB z poniższego łącza https://sourceforge.net/projects/hsqldb/files/. Po kliknięciu linku otrzymasz następujący zrzut ekranu.

Kliknij HSQLDB, a pobieranie rozpocznie się natychmiast. Na koniec otrzymasz plik zip o nazwiehsqldb-2.3.4.zip.

Step 2 − Extract the HSQLDB zip file

Wyodrębnij plik zip i umieść go w C:\informator. Po wyodrębnieniu otrzymasz strukturę plików, jak pokazano na poniższym zrzucie ekranu.

Step 3 − Create a default database

Nie ma domyślnej bazy danych dla HSQLDB, dlatego należy utworzyć bazę danych dla HSQLDB. Utwórzmy plik właściwości o nazwieserver.properties który definiuje nową bazę danych o nazwie demodb. Przyjrzyj się następującym właściwościom serwera bazy danych.

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

Umieść ten plik server.properties w katalogu głównym HSQLDB C:\hsqldb- 2.3.4\hsqldb\.

Teraz wykonaj następujące polecenie w wierszu polecenia.

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

Po wykonaniu powyższego polecenia otrzymasz status serwera, jak pokazano na poniższym zrzucie ekranu.

Później zobaczysz następującą strukturę folderów katalogu hsqldb w katalogu głównym HSQLDB, czyli C:\hsqldb-2.3.4\hsqldb. Te pliki to plik tymczasowy, plik lck, plik dziennika, plik właściwości i plik skryptu bazy danych demodb utworzonej przez serwer bazy danych HSQLDB.

Step 4 − Start the database server

Po utworzeniu bazy danych musisz uruchomić bazę danych za pomocą następującego polecenia.

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

Po wykonaniu powyższego polecenia uzyskasz następujący status.

Teraz możesz otworzyć główny ekran bazy danych runManagerSwing.bat od C:\hsqldb-2.3.4\hsqldb\binLokalizacja. Ten plik bat otworzy plik GUI dla bazy danych HSQLDB. Wcześniej zapyta Cię o ustawienia bazy danych za pośrednictwem okna dialogowego. Spójrz na poniższy zrzut ekranu. W tym oknie dialogowym wprowadź nazwę ustawienia, adres URL, jak pokazano powyżej, i kliknij OK.

Otrzymasz ekran GUI bazy danych HSQLDB, jak pokazano na poniższym zrzucie ekranu.

W rozdziale dotyczącym instalacji omówiliśmy, jak ręcznie podłączyć bazę danych. W tym rozdziale omówimy programowe połączenie bazy danych (przy użyciu programowania w języku Java).

Przyjrzyj się poniższemu programowi, który uruchomi serwer i utworzy połączenie między aplikacją Java a bazą danych.

Przykład

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

Zapisz ten kod w ConnectDatabase.javaplik. Będziesz musiał uruchomić bazę danych za pomocą następującego polecenia.

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

Możesz użyć następującego polecenia, aby skompilować i wykonać kod.

\>javac ConnectDatabase.java
\>java ConnectDatabase

Po wykonaniu powyższego polecenia otrzymasz następujący wynik -

Connection created successfully

W tym rozdziale opisano różne typy danych HSQLDB. Serwer HSQLDB oferuje sześć kategorii typów danych.

Dokładne numeryczne typy danych

Typ danych	Od	Do
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
kawałek	0	1
dziesiętny	-10 ^ 38 +1	10 ^ 38 -1
numeryczny	-10 ^ 38 +1	10 ^ 38 -1
pieniądze	-922,337,203,685,477,5808	+922,337,203,685,477,5807
małe pieniądze	-214,748,3648	+214,748,3647

Przybliżone numeryczne typy danych

Typ danych	Od	Do
pływak	-1,79E + 308	1,79E + 308
real	-3,40E + 38	3,40E + 38

Typy danych daty i godziny

Typ danych	Od	Do
datetime	1 stycznia 1753	31 grudnia 9999
smalldatetime	1 sty 1900	6 czerwca 2079
data	Przechowuje datę, na przykład 30 czerwca 1991 r
czas	Przechowuje godzinę, na przykład 12:30

Note - Tutaj datetime ma dokładność 3,33 milisekundy, podczas gdy mała datetime ma dokładność 1 minuty.

Typy danych ciągów znaków

Typ danych	Opis
zwęglać	Maksymalna długość 8 000 znaków (o stałej długości znaki inne niż Unicode)
varchar	Maksymalnie 8 000 znaków (dane o zmiennej długości inne niż Unicode)
varchar (maks.)	Maksymalna długość 231 znaków, zmienna długość danych innych niż Unicode (tylko SQL Server 2005)
tekst	Dane inne niż Unicode o zmiennej długości, o maksymalnej długości 2 147 483 647 znaków

Typy danych ciągów znaków Unicode

Typ danych	Opis
nchar	Maksymalna długość 4000 znaków (Unicode o stałej długości)
nvarchar	Maksymalna długość 4000 znaków (Unicode o zmiennej długości)
nvarchar (maks.)	Maksymalna długość 231 znaków (tylko SQL Server 2005), (Unicode o zmiennej długości)
ntext	Maksymalna długość 1 073 741 823 znaków (Unicode o zmiennej długości)

Binarne typy danych

Typ danych	Opis
dwójkowy	Maksymalna długość 8000 bajtów (dane binarne o stałej długości)
varbinary	Maksymalna długość 8000 bajtów (dane binarne o zmiennej długości)
varbinary (max)	Maksymalna długość 231 bajtów (tylko SQL Server 2005), (dane binarne o zmiennej długości)
wizerunek	Maksymalna długość 2147483647 bajtów (dane binarne o zmiennej długości)

Różne typy danych

Typ danych	Opis
sql_variant	Przechowuje wartości różnych typów danych obsługiwanych przez SQL Server, z wyjątkiem text, ntext i timestamp
znak czasu	Przechowuje unikalny numer w całej bazie danych, który jest aktualizowany za każdym razem, gdy aktualizowany jest wiersz
unikalny identyfikator	Przechowuje globalnie unikalny identyfikator (GUID)
xml	Przechowuje dane XML. Wystąpienia XML można przechowywać w kolumnie lub zmiennej (tylko SQL Server 2005)
kursor	Odniesienie do obiektu kursora
stół	Przechowuje zestaw wyników do późniejszego przetwarzania

Podstawowe obowiązkowe wymagania dotyczące tworzenia tabeli to nazwa tabeli, nazwy pól i typy danych w tych polach. Opcjonalnie możesz również podać kluczowe ograniczenia w tabeli.

Składnia

Spójrz na następującą składnię.

CREATE TABLE table_name (column_name column_type);

Przykład

Utwórzmy tabelę o nazwie tutorials_tbl z nazwami pól, takimi jak identyfikator, tytuł, autor i data_przesłania. Spójrz na następujące zapytanie.

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

Po wykonaniu powyższego zapytania otrzymasz następujący wynik -

(0) rows effected

HSQLDB - program JDBC

Poniżej przedstawiono program JDBC używany do tworzenia tabeli o nazwie tutorials_tbl w bazie danych HSQLDB. Zapisz program wCreateTable.java plik.

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

Bazę danych można uruchomić za pomocą następującego polecenia.

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

Skompiluj i uruchom powyższy program, używając następującego polecenia.

\>javac CreateTable.java
\>java CreateTable

Po wykonaniu powyższego polecenia otrzymasz następujący wynik -

Table created successfully

Usunięcie istniejącej tabeli HSQLDB jest bardzo łatwe. Należy jednak zachować ostrożność podczas usuwania istniejącej tabeli, ponieważ utracone dane nie zostaną odzyskane po usunięciu tabeli.

Składnia

Poniżej znajduje się ogólna składnia SQL służąca do usuwania tabeli HSQLDB.

DROP TABLE table_name;

Przykład

Rozważmy przykład usunięcia tabeli o nazwie pracownik z serwera HSQLDB. Poniżej znajduje się zapytanie o usunięcie tabeli o nazwie pracownik.

DROP TABLE employee;

Po wykonaniu powyższego zapytania otrzymasz następujący wynik -

(0) rows effected

HSQLDB - program JDBC

Poniżej znajduje się program JDBC używany do usuwania pracownika tabeli z serwera HSQLDB.

Zapisz następujący kod w DropTable.java plik.

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

Bazę danych można uruchomić za pomocą następującego polecenia.

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

Skompiluj i uruchom powyższy program, używając następującego polecenia.

\>javac DropTable.java
\>java DropTable

Po wykonaniu powyższego polecenia otrzymasz następujący wynik -

Table dropped successfully

Instrukcję wstawiania zapytania można uzyskać w HSQLDB za pomocą polecenia INSERT INTO. Musisz podać dane zdefiniowane przez użytkownika zgodnie z kolejnością pól kolumn z tabeli.

Składnia

Poniżej znajduje się ogólna składnia INSERT zapytanie.

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

Aby wstawić dane typu łańcuchowego do tabeli, należy użyć podwójnych lub pojedynczych cudzysłowów, aby podać wartość ciągu w instrukcji wstawiania zapytania.

Przykład

Rozważmy przykład, który wstawia rekord do tabeli o nazwie tutorials_tbl z wartościami id = 100, title = Learn PHP, Author = John Poul, a data przesłania to aktualna data.

Poniżej znajduje się zapytanie dla podanego przykładu.

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

Po wykonaniu powyższego zapytania otrzymasz następujący wynik -

1 row effected

HSQLDB - program JDBC

Oto program JDBC do wstawiania rekordu do tabeli z podanymi wartościami, id = 100, title = Learn PHP, Author = John Poul, a data przesłania to aktualna data. Spójrz na dany program. Zapisz kod wInserQuery.java plik.

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

Bazę danych można uruchomić za pomocą następującego polecenia.

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

Skompiluj i uruchom powyższy program, używając następującego polecenia.

\>javac InsertQuery.java 
\>java InsertQuery

Po wykonaniu powyższego polecenia otrzymasz następujący wynik -

1 rows effected 
Rows inserted successfully

Spróbuj wstawić następujące rekordy do pliku tutorials_tbl table przy użyciu INSERT INTO Komenda.

ID	Tytuł	Autor	Termin składania
101	Dowiedz się C	Yaswanth	Teraz()
102	Naucz się MySQL	Abdul S	Teraz()
103	Learn Excell	Bavya kanna	Teraz()
104	Dowiedz się JDB	Ajith kumar	Teraz()
105	Learn Junit	Sathya Murthi	Teraz()

Polecenie SELECT służy do pobierania danych rekordu z bazy danych HSQLDB. W tym miejscu należy wspomnieć o liście wymaganych pól w instrukcji Select.

Składnia

Oto ogólna składnia zapytania wybierającego.

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

• Możesz pobrać jedno lub więcej pól za pomocą jednego polecenia SELECT.

• W miejscu pól można podać gwiazdkę (*). W takim przypadku SELECT zwróci wszystkie pola.

• Możesz określić dowolny warunek za pomocą klauzuli WHERE.

• Możesz określić przesunięcie za pomocą OFFSET, od którego SELECT zacznie zwracać rekordy. Domyślnie przesunięcie wynosi zero.

• Możesz ograniczyć liczbę zwrotów za pomocą atrybutu LIMIT.

Przykład

Oto przykład, który pobiera pola identyfikatora, tytułu i autora wszystkich rekordów z tutorials_tblstół. Możemy to osiągnąć za pomocą instrukcji SELECT. Poniżej znajduje się zapytanie dla przykładu.

SELECT id, title, author FROM tutorials_tbl

Po wykonaniu powyższego zapytania otrzymasz następujące dane wyjściowe.

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

Oto program JDBC, który pobierze pola identyfikatora, tytułu i autora wszystkich rekordów z tutorials_tblstół. Zapisz następujący kod w plikuSelectQuery.java plik.

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

Bazę danych można uruchomić za pomocą następującego polecenia.

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

Skompiluj i wykonaj powyższy kod za pomocą następującego polecenia.

\>javac SelectQuery.java
\>java SelectQuery

Po wykonaniu powyższego polecenia otrzymasz następujący wynik -

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

Generalnie do pobrania danych z tabeli HSQLDB używamy polecenia SELECT. Możemy użyć klauzuli warunkowej WHERE do filtrowania danych wynikowych. Używając GDZIE możemy określić kryteria wyboru, aby wybrać wymagane rekordy z tabeli.

Składnia

Poniżej przedstawiono składnię klauzuli SELECT polecenia WHERE do pobierania danych z tabeli HSQLDB.

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

• Możesz użyć jednej lub więcej tabel oddzielonych przecinkami, aby uwzględnić różne warunki za pomocą klauzuli WHERE, ale klauzula WHERE jest opcjonalną częścią polecenia SELECT.

• Możesz określić dowolny warunek za pomocą klauzuli WHERE.

• Za pomocą operatorów AND lub OR można określić więcej niż jeden warunek.

• Klauzuli WHERE można również użyć wraz z poleceniem DELETE lub UPDATE SQL w celu określenia warunku.

Możemy filtrować dane rekordu za pomocą warunków. Używamy różnych operatorów w warunkowej klauzuli WHERE. Oto lista operatorów, których można używać z klauzulą ​​WHERE.

Operator	Opis	Przykład
=	Sprawdza, czy wartości dwóch operandów są równe, czy nie, jeśli tak, warunek staje się prawdziwy.	(A = B) nie jest prawdą
! =	Sprawdza, czy wartości dwóch operandów są równe, czy nie, jeśli wartości nie są równe, warunek staje się prawdziwy.	(A! = B) jest prawdą
>	Sprawdza, czy wartość lewego operandu jest większa niż wartość prawego operandu. Jeśli tak, warunek staje się prawdziwy.	(A> B) nie jest prawdą
<	Sprawdza, czy wartość lewego operandu jest mniejsza niż wartość prawego operandu. Jeśli tak, warunek staje się prawdziwy.	(A <B) jest prawdą
> =	Sprawdza, czy wartość lewego operandu jest większa lub równa wartości prawego operandu, jeśli tak, warunek staje się prawdziwy.	(A> = B) nie jest prawdą
<=	Sprawdza, czy wartość lewego operandu jest mniejsza lub równa wartości prawego operandu, jeśli tak, warunek staje się prawdziwy.	(A <= B) jest prawdą

Przykład

Oto przykład, który pobiera szczegóły, takie jak identyfikator, tytuł i autor książki zatytułowanej „Learn C”. Jest to możliwe dzięki zastosowaniu klauzuli WHERE w poleceniu SELECT. Poniżej znajduje się zapytanie o to samo.

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

Po wykonaniu powyższego zapytania otrzymasz następujące dane wyjściowe.

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

HSQLDB - program JDBC

Oto program JDBC, który pobiera dane rekordu z tabeli tutorials_tblhaving Learn C. Zapisz następujący kod wWhereClause.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);
      }
   }

}

Bazę danych można uruchomić za pomocą następującego polecenia.

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

Skompiluj i wykonaj powyższy kod za pomocą następującego polecenia.

\>javac WhereClause.java
\>java WhereClause

Po wykonaniu powyższego polecenia otrzymasz następujące dane wyjściowe.

101 | Learn C | Yaswanth

Zawsze, gdy chcesz zmodyfikować wartości tabeli, możesz użyć polecenia UPDATE. Spowoduje to zmodyfikowanie dowolnej wartości pola z dowolnej tabeli HSQLDB.

Składnia

Oto ogólna składnia polecenia UPDATE.

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

• Możesz zaktualizować jedno lub więcej pól łącznie.
• Możesz określić dowolny warunek za pomocą klauzuli WHERE.
• Możesz aktualizować wartości w jednej tabeli naraz.

Przykład

Rozważmy przykład, który aktualizuje tytuł samouczka z „Naucz się C” na „C i struktury danych” o identyfikatorze „101”. Poniżej znajduje się zapytanie o aktualizację.

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

Po wykonaniu powyższego zapytania otrzymasz następujące dane wyjściowe.

(1) Rows effected

HSQLDB - program JDBC

Oto program JDBC, który zaktualizuje tytuł samouczka z Learn C do C and Data Structures posiadanie identyfikatora 101. Zapisz następujący program wUpdateQuery.java plik.

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

Bazę danych można uruchomić za pomocą następującego polecenia.

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

Skompiluj i uruchom powyższy program, używając następującego polecenia.

\>javac UpdateQuery.java
\>java UpdateQuery

Po wykonaniu powyższego polecenia otrzymasz następujący wynik -

1 Rows effected

Zawsze, gdy chcesz usunąć rekord z dowolnej tabeli HSQLDB, możesz użyć polecenia DELETE FROM.

Składnia

Oto ogólna składnia polecenia DELETE do usuwania danych z tabeli HSQLDB.

DELETE FROM table_name [WHERE Clause]

• Jeśli klauzula WHERE nie jest określona, ​​wszystkie rekordy zostaną usunięte z podanej tabeli MySQL.

• Możesz określić dowolny warunek za pomocą klauzuli WHERE.

• Możesz usuwać rekordy z jednej tabeli naraz.

Przykład

Rozważmy przykład, który usuwa dane rekordu z tabeli o nazwie tutorials_tbl posiadanie identyfikatora 105. Poniżej znajduje się zapytanie, które implementuje podany przykład.

DELETE FROM tutorials_tbl WHERE id = 105;

Po wykonaniu powyższego zapytania otrzymasz następujący wynik -

(1) rows effected

HSQLDB - program JDBC

Oto program JDBC, który implementuje podany przykład. Zapisz następujący program wDeleteQuery.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");
   }
}

Bazę danych można uruchomić za pomocą następującego polecenia.

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

Skompiluj i uruchom powyższy program, używając następującego polecenia.

\>javac DeleteQuery.java
\>java DeleteQuery

Po wykonaniu powyższego polecenia otrzymasz następujący wynik -

1 Rows effected

W strukturze RDBMS znajduje się klauzula WHERE. Możesz użyć klauzuli WHERE ze znakiem równości (=), gdzie chcemy wykonać dokładne dopasowanie. Ale może istnieć wymóg, w którym będziemy chcieli odfiltrować wszystkie wyniki, w których nazwisko autora powinno zawierać „john”. Można to zrobić za pomocą klauzuli SQL LIKE wraz z klauzulą ​​WHERE.

Jeśli klauzula SQL LIKE jest używana wraz ze znakami%, to będzie działać jak metaznak (*) w systemie UNIX, wyświetlając wszystkie pliki lub katalogi w wierszu polecenia.

Składnia

Poniżej przedstawiono ogólną składnię SQL klauzuli LIKE.

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

• Możesz określić dowolny warunek za pomocą klauzuli WHERE.

• Możesz użyć klauzuli LIKE razem z klauzulą ​​WHERE.

• Możesz użyć klauzuli LIKE zamiast znaku równości.

• Gdy klauzula LIKE jest używana wraz ze znakiem%, będzie działać jak wyszukiwanie metaznaków.

• Za pomocą operatorów AND lub OR można określić więcej niż jeden warunek.

• Klauzula WHERE ... LIKE może być używana wraz z poleceniem DELETE lub UPDATE SQL w celu określenia warunku.

Przykład

Rozważmy przykład, który pobiera listę danych tutoriali, w których nazwisko autora zaczyna się od John. Poniżej znajduje się zapytanie HSQLDB dla podanego przykładu.

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

Po wykonaniu powyższego zapytania otrzymasz następujące dane wyjściowe.

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

HSQLDB - program JDBC

Poniżej znajduje się program JDBC, który pobiera listę danych samouczków, od których zaczyna się nazwisko autora John. Zapisz kod wLikeClause.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);
      }
   }
}

Bazę danych można uruchomić za pomocą następującego polecenia.

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

Skompiluj i wykonaj powyższy kod za pomocą następującego polecenia.

\>javac LikeClause.java
\>java LikeClause

Po wykonaniu następującego polecenia otrzymasz następujące dane wyjściowe.

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

Polecenie SQL SELECT pobiera dane z tabeli HSQLDB zawsze, gdy istnieje wymaganie, które jest zgodne z określoną kolejnością podczas pobierania i wyświetlania rekordów. W takim przypadku możemy użyćORDER BY klauzula.

Składnia

Oto składnia polecenia SELECT wraz z klauzulą ​​ORDER BY do sortowania danych z HSQLDB.

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

• Możesz posortować zwrócony wynik według dowolnego pola, pod warunkiem, że to pole jest wymienione.

• Możesz sortować wynik według więcej niż jednego pola.

• Możesz użyć słowa kluczowego ASC lub DESC, aby uzyskać wynik w porządku rosnącym lub malejącym. Domyślnie jest w porządku rosnącym.

• Aby umieścić warunek, możesz użyć klauzuli WHERE ... LIKE w zwykły sposób.

Przykład

Rozważmy przykład, który pobiera i sortuje rekordy tutorials_tbltabeli, porządkując nazwisko autora w kolejności rosnącej. Poniżej znajduje się zapytanie o to samo.

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

Po wykonaniu powyższego zapytania otrzymasz następujące dane wyjściowe.

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

Oto program JDBC, który pobiera i sortuje rekordy tutorials_tbltabeli, porządkując nazwisko autora w kolejności rosnącej. Zapisz następujący program wOrderBy.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);
      }
   }
}

Bazę danych można uruchomić za pomocą następującego polecenia.

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

Skompiluj i uruchom powyższy program, używając następującego polecenia.

\>javac OrderBy.java
\>java OrderBy

Po wykonaniu powyższego polecenia otrzymasz następujące dane wyjściowe.

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

Zawsze, gdy zachodzi potrzeba pobrania danych z wielu tabel za pomocą jednego zapytania, można użyć JOINS z RDBMS. Możesz użyć wielu tabel w jednym zapytaniu SQL. Czynność łączenia w HSQLDB odnosi się do rozbicia dwóch lub więcej tabel w jedną tabelę.

Rozważ następujące tabele Klienci i zamówienia.

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

Teraz spróbujmy pobrać dane klientów i kwotę zamówienia, które złożył dany klient. Oznacza to, że pobieramy dane rekordu zarówno z tabeli klientów, jak i z tabeli zamówień. Możemy to osiągnąć, używając koncepcji JOINS w HSQLDB. Poniżej znajduje się zapytanie JOIN dla tego samego.

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

Po wykonaniu powyższego zapytania otrzymasz następujące dane wyjściowe.

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

DOŁĄCZ Typy

W HSQLDB dostępne są różne typy sprzężeń.

• INNER JOIN - Zwraca wiersze, jeśli istnieje zgodność w obu tabelach.

• LEFT JOIN - Zwraca wszystkie wiersze z lewej tabeli, nawet jeśli nie ma dopasowań w prawej tabeli.

• RIGHT JOIN - Zwraca wszystkie wiersze z prawej tabeli, nawet jeśli w lewej tabeli nie ma dopasowań.

• FULL JOIN - Zwraca wiersze, jeśli w jednej z tabel występuje zgodność.

• SELF JOIN - Służy do łączenia tabeli ze sobą, tak jakby była to dwie tabele, tymczasowo zmieniając nazwę co najmniej jednej tabeli w instrukcji SQL.

Połączenie wewnętrzne

Najczęściej używanym i najważniejszym z połączeń jest INNER JOIN. Jest również określany jako EQUIJOIN.

INNER JOIN tworzy nową tabelę wynikową, łącząc wartości kolumn z dwóch tabel (tabela1 i tabela2) w oparciu o predykat łączenia. Zapytanie porównuje każdy wiersz tabeli tabela1 z każdym wierszem tabeli tabela2, aby znaleźć wszystkie pary wierszy, które spełniają predykat łączenia. Gdy predykat łączenia jest spełniony, wartości kolumn dla każdej dopasowanej pary wierszy A i B są łączone w wiersz wynikowy.

Składnia

Podstawowa składnia INNER JOIN jest następująca.

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

Przykład

Rozważ dwie poniższe tabele, jedną zatytułowaną CUSTOMERS, a drugą zatytułowaną ORDERS w następujący sposób -

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

Teraz połączmy te dwie tabele za pomocą zapytania INNER JOIN w następujący sposób -

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

Po wykonaniu powyższego zapytania otrzymasz następujące dane wyjściowe.

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

Left Join

HSQLDB LEFT JOIN zwraca wszystkie wiersze z lewej tabeli, nawet jeśli nie ma żadnych dopasowań w prawej tabeli. Oznacza to, że jeśli klauzula ON pasuje do 0 (zero) rekordów w prawej tabeli, sprzężenie nadal zwróci wiersz w wyniku, ale z wartością NULL w każdej kolumnie z prawej tabeli.

Oznacza to, że lewe sprzężenie zwraca wszystkie wartości z lewej tabeli oraz dopasowane wartości z prawej tabeli lub NULL w przypadku braku zgodnego predykatu łączenia.

Składnia

Podstawowa składnia LEFT JOIN jest następująca -

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

Tutaj podanym warunkiem może być dowolne wyrażenie oparte na twoim wymaganiu.

Przykład

Rozważ dwie poniższe tabele, jedną zatytułowaną CUSTOMERS, a drugą zatytułowaną ORDERS w następujący sposób -

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

Teraz połączmy te dwie tabele za pomocą zapytania LEFT JOIN w następujący sposób -

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

Po wykonaniu powyższego zapytania otrzymasz następujący wynik -

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

Right Join

HSQLDB RIGHT JOIN zwraca wszystkie wiersze z prawej tabeli, nawet jeśli nie ma żadnych dopasowań w lewej tabeli. Oznacza to, że jeśli klauzula ON pasuje do 0 (zero) rekordów w lewej tabeli, sprzężenie nadal zwróci wiersz w wyniku, ale z wartością NULL w każdej kolumnie z lewej tabeli.

Oznacza to, że prawe sprzężenie zwraca wszystkie wartości z prawej tabeli, plus dopasowane wartości z lewej tabeli lub NULL w przypadku braku zgodnego predykatu łączenia.

Składnia

Podstawowa składnia RIGHT JOIN wygląda następująco -

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

Przykład

Rozważ dwie poniższe tabele, jedną zatytułowaną CUSTOMERS, a drugą zatytułowaną ORDERS w następujący sposób -

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

Teraz połączmy te dwie tabele za pomocą zapytania RIGHT JOIN w następujący sposób -

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

Po wykonaniu powyższego zapytania otrzymasz następujący wynik.

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

Pełne dołączenie

HSQLDB FULL JOIN łączy wyniki zarówno lewego, jak i prawego sprzężenia zewnętrznego.

Połączona tabela będzie zawierać wszystkie rekordy z obu tabel i wypełnić wartości NULL dla brakujących dopasowań po obu stronach.

Składnia

Podstawowa składnia FULL JOIN jest następująca -

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

Tutaj podanym warunkiem może być dowolne wyrażenie oparte na twoim wymaganiu.

Przykład

Rozważ dwie poniższe tabele, jedną zatytułowaną CUSTOMERS, a drugą zatytułowaną ORDERS w następujący sposób -

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

Teraz połączmy te dwie tabele za pomocą zapytania FULL JOIN w następujący sposób -

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

Po wykonaniu powyższego zapytania otrzymasz następujący wynik.

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

Dołącz do siebie

SQL SELF JOIN służy do łączenia tabeli ze sobą, tak jakby była to dwie tabele, tymczasowo zmieniając nazwę przynajmniej jednej tabeli w instrukcji SQL.

Składnia

Podstawowa składnia SELF JOIN jest następująca -

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

W tym przypadku klauzula WHERE może być dowolnym wyrażeniem opartym na Twoim wymaganiu.

Przykład

Rozważ dwie poniższe tabele, jedną zatytułowaną CUSTOMERS, a drugą zatytułowaną ORDERS w następujący sposób -

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

Teraz dołączmy do tej tabeli za pomocą zapytania SELF JOIN w następujący sposób -

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

Po wykonaniu powyższego zapytania otrzymasz następujący wynik -

+----+----------+---------+
| 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 to termin używany do reprezentowania brakującej wartości. Wartość NULL w tabeli to wartość w polu, które wydaje się puste. Za każdym razem, gdy próbujemy podać warunek, który porównuje wartość pola lub kolumny z wartością NULL, nie działa on poprawnie.

Możemy obsłużyć wartości NULL, używając trzech rzeczy.

• IS NULL - Operator zwraca prawdę, jeśli wartość kolumny jest równa NULL.

• IS NOT NULL - Operator zwraca prawdę, jeśli wartość kolumny NIE jest NULL.

• <=> - Operator porównuje wartości, które (w przeciwieństwie do operatora =) są prawdziwe nawet dla dwóch wartości NULL.

Aby wyszukać kolumny, które mają wartość NULL lub NOT NULL, użyj odpowiednio IS NULL lub IS NOT NULL.

Przykład

Rozważmy przykład, gdzie jest stół tcount_tblktóry zawiera dwie kolumny, autora i tutorial_count. Możemy podać wartości NULL do tutorial_count wskazującego, że autor nie opublikował nawet jednego samouczka. Dlatego wartość tutorial_count dla tego autora to NULL.

Wykonaj następujące zapytania.

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

Użyj następującego polecenia, aby wyświetlić wszystkie rekordy z tcount_tbl stół.

select * from tcount_tbl;

Po wykonaniu powyższego polecenia otrzymasz następujące dane wyjściowe.

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

Aby znaleźć rekordy, w których kolumna tutorial_count JEST NULL, poniżej znajduje się zapytanie.

SELECT * FROM tcount_tbl WHERE tutorial_count IS NULL;

Po wykonaniu zapytania otrzymasz następujące dane wyjściowe.

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

Aby znaleźć rekordy, w których kolumna tutorial_count NIE JEST NULL, poniżej znajduje się zapytanie.

SELECT * FROM tcount_tbl WHERE tutorial_count IS NOT NULL;

Po wykonaniu zapytania otrzymasz następujące dane wyjściowe.

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

HSQLDB - program JDBC

Oto program JDBC, który pobiera rekordy oddzielnie od tabeli tcount_tbl, gdzie tutorial_ count ma wartość NULL, a tutorial_count NIE jest NULL. Zapisz następujący program wNullValues.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);
      }
   }
}

Skompiluj i uruchom powyższy program, używając następującego polecenia.

\>javac NullValues.java
\>Java NullValues

Po wykonaniu powyższego polecenia otrzymasz następujące dane wyjściowe.

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 obsługuje niektóre specjalne symbole do operacji dopasowywania wzorców na podstawie wyrażeń regularnych i operatora REGEXP.

Poniżej znajduje się tabela wzorca, której można używać wraz z operatorem REGEXP.

Wzór	Jaki wzór pasuje
^	Początek łańcucha
$	Koniec łańcucha
.	Dowolny pojedynczy znak
[…]	Dowolny znak wymieniony w nawiasach kwadratowych
[^ ...]	Dowolny znak niewymieniony w nawiasach kwadratowych
p1 | p2 | p3	Alternacja; pasuje do dowolnego ze wzorów p1, p2 lub p3
*	Zero lub więcej wystąpień poprzedniego elementu
+	Co najmniej jedno wystąpienie poprzedniego elementu
{n}	n wystąpień poprzedniego elementu
{m, n}	m do n wystąpień poprzedniego elementu

Przykład

Wypróbujmy różne przykładowe zapytania, aby spełnić nasze wymagania. Spójrz na poniższe zapytania.

Wypróbuj to zapytanie, aby znaleźć wszystkich autorów, których nazwiska zaczynają się od „^ A”.

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

Po wykonaniu powyższego zapytania otrzymasz następujące dane wyjściowe.

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

Spróbuj tego zapytania, aby znaleźć wszystkich autorów, których nazwiska kończą się na „ul $”.

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

Po wykonaniu powyższego zapytania otrzymasz następujące dane wyjściowe.

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

Spróbuj tego zapytania, aby znaleźć wszystkich autorów, których nazwisko zawiera „th”.

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

Po wykonaniu powyższego zapytania otrzymasz następujące dane wyjściowe.

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

Spróbuj tego zapytania, aby znaleźć wszystkich autorów, których nazwiska zaczynają się od samogłoski (a, e, i, o, u).

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

Po wykonaniu powyższego zapytania otrzymasz następujące dane wyjściowe.

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

ZA Transactionto sekwencyjna grupa operacji manipulowania bazą danych, która jest wykonywana i traktowana jako jedna jednostka pracy. Innymi słowy, gdy wszystkie operacje zostaną pomyślnie wykonane, dopiero wtedy cała transakcja zostanie zakończona. Jeśli jakakolwiek operacja w ramach transakcji nie powiedzie się, cała transakcja zakończy się niepowodzeniem.

Właściwości transakcji

Zasadniczo transakcja obsługuje 4 standardowe właściwości. Można je nazwać właściwościami ACID.

Atomicity - Wszystkie operacje w transakcjach są wykonywane pomyślnie, w przeciwnym razie transakcja zostanie przerwana w momencie niepowodzenia, a poprzednie operacje zostaną cofnięte do poprzedniej pozycji.

Consistency - Baza danych prawidłowo zmienia stany po pomyślnym zatwierdzeniu transakcji.

Isolation - Umożliwia niezależne działanie transakcji i wzajemną przejrzystość.

Durability - Wynik lub skutek zatwierdzonej transakcji utrzymuje się w przypadku awarii systemu.

Zatwierdź, Wycofaj i Zapisz

Te słowa kluczowe są używane głównie w transakcjach HSQLDB.

Commit- Zawsze zakończona sukcesem transakcja powinna zostać zakończona wykonaniem polecenia COMMIT.

Rollback - W przypadku niepowodzenia transakcji należy wykonać polecenie ROLLBACK, aby przywrócić poprzedni stan każdej tabeli, do której odwołuje się transakcja.

Savepoint - Tworzy punkt w grupie transakcji, w którym ma nastąpić wycofanie.

Przykład

Poniższy przykład wyjaśnia koncepcję transakcji wraz z zatwierdzaniem, wycofywaniem i zapisywaniem. Rozważmy tabelę Klienci z kolumnami id, imię i nazwisko, wiek, adres i wynagrodzenie.

ID	Nazwa	Wiek	Adres	Wynagrodzenie
1	Ramesh	32	Ahmedabad	2000,00
2	Karun	25	Delhi	1500,00
3	Kaushik	23	Kota	2000,00
4	Chaitanya	25	Bombaj	6500,00
5	Harish	27	Bhopal	8500,00
6	Kamesh	22	poseł	1500,00
7	Murali	24	Indore	10000,00

Użyj następujących poleceń, aby utworzyć tabelę klientów zgodnie z powyższymi danymi.

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

Przykład COMMIT

Następujące zapytanie usuwa wiersze z tabeli mające wiek = 25 i używa polecenia COMMIT, aby zastosować te zmiany w bazie danych.

DELETE FROM CUSTOMERS WHERE AGE = 25;
COMMIT;

Po wykonaniu powyższego zapytania otrzymasz następujące dane wyjściowe.

2 rows effected

Po pomyślnym wykonaniu powyższego polecenia sprawdź rekordy tabeli klientów, wykonując poniższe polecenie.

Select * from Customer;

Po wykonaniu powyższego zapytania otrzymasz następujące dane wyjściowe.

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

Przykład wycofania

Rozważmy tę samą tabelę klienta jako dane wejściowe.

ID	Nazwa	Wiek	Adres	Wynagrodzenie
1	Ramesh	32	Ahmedabad	2000,00
2	Karun	25	Delhi	1500,00
3	Kaushik	23	Kota	2000,00
4	Chaitanya	25	Bombaj	6500,00
5	Harish	27	Bhopal	8500,00
6	Kamesh	22	poseł	1500,00
7	Murali	24	Indore	10000,00

Oto przykładowe zapytanie, które wyjaśnia funkcje wycofywania zmian, usuwając rekordy z tabeli mające wiek = 25, a następnie CZYSZCZENIE zmian w bazie danych.

DELETE FROM CUSTOMERS WHERE AGE = 25;
ROLLBACK;

Po pomyślnym wykonaniu powyższych dwóch zapytań można wyświetlić dane rekordu w tabeli Klient za pomocą następującego polecenia.

Select * from Customer;

Po wykonaniu powyższego polecenia otrzymasz następujące dane wyjściowe.

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

Zapytanie usuwające usuwa dane rekordów klientów, których wiek = 25. Polecenie Wycofywanie cofa te zmiany w tabeli Klient.

Przykład dla Savepoint

Punkt zapisu to punkt w transakcji, w którym można cofnąć transakcję do określonego punktu bez cofania całej transakcji.

Rozważmy tę samą tabelę klienta jako dane wejściowe.

ID	Nazwa	Wiek	Adres	Wynagrodzenie
1	Ramesh	32	Ahmedabad	2000,00
2	Karun	25	Delhi	1500,00
3	Kaushik	23	Kota	2000,00
4	Chaitanya	25	Bombaj	6500,00
5	Harish	27	Bhopal	8500,00
6	Kamesh	22	poseł	1500,00
7	Murali	24	Indore	10000,00

Rozważmy w tym przykładzie, że planujesz usunąć trzy różne rekordy z tabeli Klienci. Chcesz utworzyć punkt zapisu przed każdym usunięciem, aby móc w dowolnym momencie cofnąć się do dowolnego punktu zapisu, aby przywrócić odpowiednie dane do ich pierwotnego stanu.

Oto seria operacji.

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

Teraz utworzyłeś trzy punkty zapisu i usunąłeś trzy rekordy. W tej sytuacji, jeśli chcesz wycofać rekordy o Id 2 i 3, użyj następującego polecenia Wycofaj.

ROLLBACK TO SP2;

Zauważ, że tylko pierwsze usunięcie miało miejsce od czasu przywrócenia dodatku SP2. Użyj następującego zapytania, aby wyświetlić wszystkie rekordy klientów.

Select * from Customer;

Po wykonaniu powyższego zapytania otrzymasz następujące dane wyjściowe.

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

Zwolnij punkt zapisu

Możemy zwolnić punkt zapisu za pomocą polecenia RELEASE. Poniżej znajduje się ogólna składnia.

RELEASE SAVEPOINT SAVEPOINT_NAME;

Zawsze, gdy zachodzi potrzeba zmiany nazwy tabeli lub pola, zmiany kolejności pól, zmiany typu danych pól lub dowolnej struktury tabeli, można to osiągnąć za pomocą polecenia ALTER.

Przykład

Rozważmy przykład, który wyjaśnia polecenie ALTER przy użyciu różnych scenariuszy.

Użyj następującego zapytania, aby utworzyć tabelę o nazwie testalter_tbl z polami id i 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';

Po wykonaniu powyższego zapytania otrzymasz następujące dane wyjściowe.

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

Upuszczanie lub dodawanie kolumny

Ilekroć chcesz DROP istniejącej kolumny z tabeli HSQLDB, możesz użyć klauzuli DROP wraz z poleceniem ALTER.

Użyj następującego zapytania, aby upuścić kolumnę (name) z tabeli testalter_tbl.

ALTER TABLE testalter_tbl DROP name;

Po pomyślnym wykonaniu powyższego zapytania możesz dowiedzieć się, czy pole name zostało usunięte z tabeli testalter_tbl za pomocą następującego polecenia.

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

Po wykonaniu powyższego polecenia otrzymasz następujące dane wyjściowe.

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

Ilekroć chcesz dodać dowolną kolumnę do tabeli HSQLDB, możesz użyć klauzuli ADD wraz z poleceniem ALTER.

Użyj następującego zapytania, aby dodać kolumnę o nazwie NAME na stół testalter_tbl.

ALTER TABLE testalter_tbl ADD name VARCHAR(10);

Po pomyślnym wykonaniu powyższego zapytania możesz dowiedzieć się, czy pole nazwy zostało dodane do tabeli testalter_tbl za pomocą następującego polecenia.

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

Po wykonaniu powyższego zapytania otrzymasz następujące dane wyjściowe.

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

Zmiana definicji lub nazwy kolumny

Ilekroć istnieje potrzeba zmiany definicji kolumny, użyj rozszerzenia MODIFY lub CHANGE klauzula wraz z ALTER Komenda.

Rozważmy przykład, który wyjaśni, jak używać klauzuli CHANGE. Stółtestalter_tblzawiera dwa pola - id i name - mające odpowiednio typy danych int i varchar. Teraz spróbujmy zmienić typ danych id z INT na BIGINT. Poniżej znajduje się zapytanie do wprowadzenia zmiany.

ALTER TABLE testalter_tbl CHANGE id id BIGINT;

Po pomyślnym wykonaniu powyższego zapytania strukturę tabeli można zweryfikować za pomocą następującego polecenia.

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

Po wykonaniu powyższego polecenia otrzymasz następujące dane wyjściowe.

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

Teraz spróbujmy zwiększyć rozmiar kolumny NAME z 10 do 20 w testalter_tblstół. Poniżej znajduje się zapytanie do osiągnięcia tego celu za pomocą klauzuli MODIFY wraz z poleceniem ALTER.

ALTER TABLE testalter_tbl MODIFY name VARCHAR(20);

Po pomyślnym wykonaniu powyższego zapytania strukturę tabeli można zweryfikować za pomocą następującego polecenia.

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

Po wykonaniu powyższego polecenia otrzymasz następujące dane wyjściowe.

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

ZA database indexto struktura danych, która poprawia szybkość operacji w tabeli. Indeksy można tworzyć przy użyciu jednej lub więcej kolumn, co stanowi podstawę zarówno do szybkiego losowego wyszukiwania, jak i efektywnego uporządkowania dostępu do rekordów.

Tworząc indeks, należy się zastanowić, jakie kolumny będą używane do tworzenia zapytań SQL i utworzyć jeden lub więcej indeksów na tych kolumnach.

Praktycznie indeksy są również rodzajem tabel, które przechowują klucz podstawowy lub pole indeksu i wskaźnik do każdego rekordu w rzeczywistej tabeli.

Użytkownicy nie widzą indeksów. Służą one tylko do przyspieszenia zapytań i będą używane przez wyszukiwarkę bazy danych do szybkiego lokalizowania rekordów.

Instrukcje INSERT i UPDATE zajmują więcej czasu w tabelach z indeksami, podczas gdy instrukcje SELECT działają szybciej w tych tabelach. Powodem jest to, że podczas wstawiania lub aktualizacji baza danych musi również wstawiać lub aktualizować wartości indeksu.

Prosty i unikalny indeks

Możesz utworzyć unikalny indeks w tabeli. ZAunique indexoznacza, że ​​dwa wiersze nie mogą mieć tej samej wartości indeksu. Poniżej znajduje się składnia tworzenia indeksu w tabeli.

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

Do utworzenia indeksu można użyć jednej lub kilku kolumn. Na przykład utwórz indeks na tutorials_tbl za pomocą tutorial_author.

CREATE UNIQUE INDEX AUTHOR_INDEX
ON tutorials_tbl (tutorial_author)

Możesz utworzyć prosty indeks w tabeli. Po prostu pomiń słowo kluczowe UNIQUE w zapytaniu, aby utworzyć prosty indeks. ZAsimple index zezwala na zduplikowane wartości w tabeli.

Jeśli chcesz indeksować wartości w kolumnie w porządku malejącym, możesz dodać zarezerwowane słowo DESC po nazwie kolumny.

CREATE UNIQUE INDEX AUTHOR_INDEX
ON tutorials_tbl (tutorial_author DESC)

ALTER Polecenie, aby dodać i upuścić INDEKS

Istnieją cztery typy instrukcji dodawania indeksów do tabeli -

• ALTER TABLE tbl_name ADD PRIMARY KEY (column_list) - Ta instrukcja dodaje KLUCZ PODSTAWOWY, co oznacza, że ​​indeksowane wartości muszą być unikalne i nie mogą mieć wartości NULL.

• ALTER TABLE tbl_name ADD UNIQUE index_name (column_list) - Ta instrukcja tworzy indeks, dla którego wartości muszą być unikalne (z wyjątkiem wartości NULL, które mogą wystąpić wielokrotnie).

• ALTER TABLE tbl_name ADD INDEX index_name (column_list) - To dodaje zwykły indeks, w którym dowolna wartość może pojawić się więcej niż raz.

• ALTER TABLE tbl_name ADD FULLTEXT index_name (column_list) - Tworzy specjalny indeks FULLTEXT, który jest używany do wyszukiwania tekstu.

Poniżej znajduje się zapytanie o dodanie indeksu do istniejącej tabeli.

ALTER TABLE testalter_tbl ADD INDEX (c);

Możesz usunąć dowolny INDEX, używając klauzuli DROP wraz z poleceniem ALTER. Poniżej znajduje się zapytanie o usunięcie utworzonego powyżej indeksu.

ALTER TABLE testalter_tbl DROP INDEX (c);

Wyświetlanie informacji INDEKSU

Możesz użyć polecenia SHOW INDEX, aby wyświetlić listę wszystkich indeksów skojarzonych z tabelą. Wyjście w formacie pionowym (określone przez \ G) jest często przydatne w przypadku tej instrukcji, aby uniknąć zawijania długich linii.

Poniżej znajduje się ogólna składnia służąca do wyświetlania informacji o indeksie tabeli.

SHOW INDEX FROM table_name\G