Hsqldb 简明教程

HSQLDB - Quick Guide

HSQLDB - Introduction

HyperSQL 数据库 (HSQLDB) 是一款现代关系数据库管理器，完全符合 SQL:2011 标准和 JDBC 4 规范。它支持所有核心特性和 RDBMS。HSQLDB 用于开发、测试和部署数据库应用程序。

HSQLDB 的主要和独特特性是标准合规性。它可以在用户应用程序流程中、应用程序服务器中或作为独立的服务器流程提供数据库访问。

Features of HSQLDB

HSQLDB 使用内存结构来针对数据库服务器执行快速操作。它根据用户的灵活性使用磁盘持久性，并伴有可靠的崩溃恢复。
HSQLDB 也适用于商业智能、ETL 和处理大型数据集的其他应用程序。
HSQLDB 拥有广泛的企业部署选项，例如 XA 事务、连接池数据源和远程身份验证。
HSQLDB 用 Java 编程语言编写并运行在 Java 虚拟机 (JVM) 中。它支持用于访问数据库的 JDBC 接口。

Components of HSQLDB

HSQLDB jar 包中有三个不同的组件。

HyperSQL RDBMS Engine (HSQLDB)
HyperSQL JDBC Driver
数据库管理器（图形用户界面数据库访问工具，提供 Swing 和 AWT 版本）

HyperSQL RDBMS 和 JDBC 驱动程序提供核心功能。数据库管理器是通用数据库访问工具，可与具有 JDBC 驱动程序的任何数据库引擎配合使用。

一个名为 SqlTool 的附加 jar，即 sqltool.jar，它是一个命令行数据库访问工具。这是一个通用命令。行数据库访问工具，也可以与其他数据库引擎配合使用。

HSQlDB - Installation

HSQLDB 是用纯 Java 实现的关系数据库管理系统。您可以使用 JDBC 轻松地将此数据库嵌入应用程序中。或者，您可以单独使用该操作。

Prerequisites

按照 HSQLDB 的先决软件安装指南进行操作。

Verify Java Installation

由于 HSQLDB 是使用纯 Java 实现的关系型数据库管理系统，因此您必须在安装 HSQLDB 之前安装 JDK（Java Development Kit）软件。如果您已经在系统中安装了 JDK，请尝试以下命令来验证 Java 版本。

java –version

如果 JDK 已成功安装在您的系统中，您将收到以下输出。

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)

如果您尚未在系统中安装 JDK，请访问以下链接 Install JDK.

HSQLDB Installation

以下是安装 HSQLDB 的步骤。

Step 1 − Download HSQLDB bundle

从以下链接下载 HSQLDB 数据库的最新版本 https://sourceforge.net/projects/hsqldb/files/. ,一旦您单击该链接，您将看到以下屏幕截图。

单击 HSQLDB，下载将立即开始。最后，您将获得名为 hsqldb-2.3.4.zip 的 zip 文件。

Step 2 − Extract the HSQLDB zip file

解压缩 zip 文件并将其放入 C:\ 目录。解压缩后，您将获得如下屏幕截图所示的文件结构。

Step 3 − Create a default database

HSQLDB 没有默认数据库，因此，您需要为 HSQLDB 创建一个数据库。让我们创建一个名为 server.properties 的属性文件，该文件定义了一个名为 demodb 的新数据库。查看以下数据库服务器属性。

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

将此 server.properties 文件放入 HSQLDB 主目录 C:\hsqldb- 2.3.4\hsqldb\ 中。

现在在命令提示符中执行以下命令。

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

执行上述命令后，您将收到服务器状态，如下面的屏幕截图所示。

稍后，您会在 HSQLDB 主目录中找到 hsqldb 目录的以下文件夹结构，即 C:\hsqldb-2.3.4\hsqldb 。这些文件是 HSQLDB 数据库服务器创建的 temp 文件、lck 文件、日志文件、属性文件和 demodb 数据库的脚本文件。

Step 4 − Start the database server

创建数据库后，您必须使用以下命令启动数据库。

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

执行上述命令后，您将获得以下状态。

现在，您可以打开 runManagerSwing.bat 从 C:\hsqldb-2.3.4\hsqldb\bin 位置的数据库主页。此 bat 文件将打开 HSQLDB 数据库的 GUI 文件。在此之前，它将通过一个对话框询问您数据库设置。请看以下截图。在此对话框中输入设置名称，URL 如上所示，然后单击确定。

您将获得如下截图所示的 HSQLDB 数据库的 GUI 界面。

HSQlDB - Connect

在安装章节中，我们讨论了如何手动连接数据库。在此章节中，我们将讨论如何以编程方式连接数据库（使用 Java 编程）。

看看以下程序，它将启动服务器并在 Java 应用程序和数据库之间建立连接。

Example

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

将此代码保存到 ConnectDatabase.java 文件中。您需要使用以下命令启动数据库。

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

您可以使用以下命令编译并执行代码。

\>javac ConnectDatabase.java
\>java ConnectDatabase

在执行上述命令之后，您将收到以下输出−

Connection created successfully

HSQLDB - Data Types

此章节解释了 HSQLDB 的不同数据类型。HSQLDB 服务器提供了六类数据类型。

Exact Numeric Data Types

Data Type	From	To
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
bit	0	1
decimal	-10^38 +1	10^38 -1
numeric	-10^38 +1	10^38 -1
money	-922,337,203,685,477.5808	+922,337,203,685,477.5807
smallmoney	-214,748.3648	+214,748.3647

Approximate Numeric Data Types

Data Type

From

float

-1.79E + 308

1.79E + 308

real

-3.40E + 38

3.40E + 38

Date and Time Data Types

Data Type

From

datetime

Jan 1, 1753

Dec 31, 9999

smalldatetime

Jan 1, 1900

Jun 6, 2079

date

存储诸如 1991 年 6 月 30 日之类的日期

time

Note - 此处，datetime 的精度为 3.33 毫秒，而 small datetime 的精度为 1 分钟。

Character Strings Data Types

Data Type

Description

char

最长 8,000 个字符（定长非 Unicode 字符）

varchar

最长 8,000 个字符（变长非 Unicode 数据）

varchar(max)

最长 231 个字符，变长非 Unicode 数据（仅限 SQL Server 2005）

text

最长 2,147,483,647 个字符，变长非 Unicode 数据

Unicode Character Strings Data Types

Data Type

Description

nchar

最长 4,000 个字符（定长 Unicode）

nvarchar

最长 4,000 个字符（变长 Unicode）

nvarchar(max)

最长 231 个字符（仅限 SQL Server 2005），（变长 Unicode）

ntext

最长 1,073,741,823 个字符（变长 Unicode）

Binary Data Types

Data Type

Description

binary

最长 8,000 字节（定长二进制数据）

varbinary

最长 8,000 字节（变长二进制数据）

varbinary(max)

长度最多为 231 字节（仅适用于 SQL Server 2005），（可变长度二进制数据）

image

长度最多为 2,147,483,647 字节（可变长度二进制数据）

Misc Data Types

Data Type

Description

sql_variant

存储多种由 SQL Server 支持的数据类型的值，除了文本、ntext 和时间戳以外

timestamp

存储每次更新行时都会更新的、数据库范围内的唯一编号

uniqueidentifier

存储全局唯一标识符 (GUID)

xml

存储 XML 数据。您可以在一个列或一个变量（仅适用于 SQL Server 2005）中存储 xml 实例

cursor

游标对象的引用

table

存储结果集以供稍后处理

HSQLDB - Create Table

创建表的基本强制性要求是表名、字段名和这些字段的数据类型。此外，您还可以向表提供键约束。

Syntax

看一下以下语法。

CREATE TABLE table_name (column_name column_type);

Example

我们创建一个名为 tutorials_tbl 的表，其字段名称为 id、title、author 和 submission_date。看一下以下查询。

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

执行以上查询后，您将收到以下输出 −

(0) rows effected

HSQLDB – JDBC Program

以下是用于在 HSQLDB 数据库中创建一个名为 tutorials_tbl 的表的 JDBC 程序。将程序保存到 CreateTable.java 文件中。

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

您可以使用以下命令启动数据库。

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

使用以下命令编译并执行以上程序。

\>javac CreateTable.java
\>java CreateTable

在执行上述命令之后，您将收到以下输出−

Table created successfully

HSQLDB - Drop Table

删除一个现有的 HSQLDB 表非常容易。但是，在删除任何现有的表时，您需要非常小心，因为删除表后任何丢失的数据都无法恢复。

Syntax

以下是用来删除 HSQLDB 表的通用 SQL 语法。

DROP TABLE table_name;

Example

我们考虑一个示例，从 HSQLDB 服务器删除名为 employee 的表。以下是用来删除名为 employee 的表的查询。

DROP TABLE employee;

执行以上查询后，您将收到以下输出 −

(0) rows effected

HSQLDB – JDBC Program

以下是用于从 HSQLDB 服务器删除名为 employee 的表的 JDBC 程序。

将以下代码另存为 DropTable.java 文件。

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

您可以使用以下命令启动数据库。

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

使用以下命令编译并执行以上程序。

\>javac DropTable.java
\>java DropTable

在执行上述命令之后，您将收到以下输出−

Table dropped successfully

HSQLDB - Insert Query

可以使用 INSERT INTO 命令在 HSQLDB 中执行插入查询语句。你必须按照表中列字段的顺序提供用户定义的数据。

Syntax

以下是 INSERT 查询的一般语法。

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

若要将字符串类型数据插入表中，你必须使用双引号或单引号在插入查询语句中提供字符串值。

Example

我们考虑一个示例，其中将记录插入一个名为 tutorials_tbl 的表中，其中值 id = 100、title = Learn PHP、Author = John Poul，并且提交日期是当前日期。

以下是给定示例的查询。

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

执行以上查询后，您将收到以下输出 −

1 row effected

HSQLDB – JDBC Program

以下是使用给定值（id =100、title = Learn PHP、Author = John Poul 且提交日期为当前日期）将记录插入表中的 JDBC 程序。查看给定程序。将代码另存为 InserQuery.java 文件。

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

您可以使用以下命令启动数据库。

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

使用以下命令编译并执行以上程序。

\>javac InsertQuery.java
\>java InsertQuery

在执行上述命令之后，您将收到以下输出−

1 rows effected
Rows inserted successfully

尝试使用 INSERT INTO 命令将以下记录插入到 tutorials_tbl 表中。

Title

Author

Submission Date

101

Learn C

Yaswanth

Now()

102

Learn MySQL

Abdul S

Now()

103

Learn Excell

Bavya kanna

Now()

104

Learn JDB

Ajith kumar

Now()

105

Learn Junit

Sathya Murthi

Now()

HSQLDB - Select Query

SELECT 命令用于从 HSQLDB 数据库中获取记录数据。在此处，你需要在 Select 语句中提及所需字段列表。

Syntax

以下是 Select 查询的一般语法。

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

你可以在单个 SELECT 命令中获取一个或多个字段。
你可以使用星号 (*) 来代替字段。这种情况下，SELECT 将返回所有字段。
你可以使用 WHERE 从句指定任意条件。
你可以使用 OFFSET 指定 SELECT 从何处开始返回记录。默认情况下，偏移量为零。
你可以使用 LIMIT 属性来限制返回记录的数量。

Example

以下是一个示例，其中获取 tutorials_tbl 表中所有记录的 id、title 和 author 字段。我们可以使用 SELECT 语句来实现该操作。以下是示例的查询。

SELECT id, title, author FROM tutorials_tbl

在执行上述查询后，你将收到以下输出。

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

以下是一个 JDBC 程序，其中将获取 tutorials_tbl 表中所有记录的 id、title 和 author 字段。将以下代码另存为 SelectQuery.java 文件。

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

您可以使用以下命令启动数据库。

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

使用以下命令编译并执行上述代码。

\>javac SelectQuery.java
\>java SelectQuery

在执行上述命令之后，您将收到以下输出−

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 - Where Clause

通常，我们使用 SELECT 命令从 HSQLDB 表中获取数据。我们可以使用 WHERE 条件子句来过滤结果数据。使用 WHERE，我们可以指定选择条件以从表中选择所需的记录。

Syntax

以下是 SELECT 命令 WHERE 子句的语法，用于从 HSQLDB 表中获取数据。

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

使用 WHERE 子句，可以通过逗号分隔使用一个或多个表来包含各种条件，但 WHERE 子句是 SELECT 命令的可选部分。
你可以使用 WHERE 从句指定任意条件。
可以使用 AND 或 OR 运算符指定多个条件。
WHERE 子句还可以与 DELETE 或 UPDATE SQL 命令一起使用，以指定条件。

我们可以使用条件来过滤记录数据。我们正在条件 WHERE 子句中使用不同的运算符。此处的运算符列表可与 WHERE 子句一起使用。

Operator

Description

Example

检查两个操作数的值是否相等，如果相等则条件为真。

(A = B) 不为真

检查两个操作数的值是否相等，如果值不相等则条件变为真。

(A != B) 为真

检查左操作数的值是否大于右操作数的值，如果大于则条件变为真。

(A > B) 不为真

检查左操作数的值是否小于右操作数的值，如果小于则条件变为真。

(A < B) 为真

检查左操作数的值是否大于或等于右操作数的值，如果大于或等于，则条件为真。

(A >= B) 不为真

⇐

检查左操作数的值是否小于或等于右操作数的值，如果小于或等于，则条件为真。

(A ⇐ B) 为真

Example

这里有一个示例，该示例检索有关 ID、标题以及标题为“Learn C”一书的作者的详细信息。这可以通过在 SELECT 命令中使用 WHERE 子句来实现。以下是查询。

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

在执行上述查询后，你将收到以下输出。

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

HSQLDB – JDBC Program

以下 JDBC 程序从表 tutorials_tblhaving 标题 Learn C 中检索记录数据。将以下代码保存到 WhereClause.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);
      }
   }

}

您可以使用以下命令启动数据库。

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

使用以下命令编译并执行上述代码。

\>javac WhereClause.java
\>java WhereClause

执行上述命令后，您将收到以下输出。

101 | Learn C | Yaswanth

HSQLDB - Update Query

每当您要修改表中的值时，都可以使用 UPDATE 命令。这将修改任何 HSQLDB 表中的任何字段值。

Syntax

以下是 UPDATE 命令的通用语法。

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

您可以同时更新一个或多个字段。
你可以使用 WHERE 从句指定任意条件。
一次只能更新单个表中的值。

Example

让我们考虑一个示例，该示例将教程的标题从“学习 C”更新为“C 和数据结构”，其 ID 为“101”。以下是更新的查询。

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

在执行上述查询后，你将收到以下输出。

(1) Rows effected

HSQLDB – JDBC Program

以下是 JDBC 程序，该程序将教程标题从 Learn C 更新为 C and Data Structures ，其 ID 为 101 。将以下程序保存到 UpdateQuery.java 文件中。

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

您可以使用以下命令启动数据库。

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

使用以下命令编译并执行以上程序。

\>javac UpdateQuery.java
\>java UpdateQuery

在执行上述命令之后，您将收到以下输出−

1 Rows effected

HSQLDB - Delete Clause

每当您希望从任何 HSQLDB 表中删除记录时，都可以使用 DELETE FROM 命令。

Syntax

以下是 DELETE 命令用于从 HSQLDB 表中删除数据的通用语法。

DELETE FROM table_name [WHERE Clause]

如果未指定 WHERE 子句，则将从给定的 MySQL 表中删除所有记录。
你可以使用 WHERE 从句指定任意条件。
一次只能删除单个表中的记录。

Example

让我们考虑一个示例，该示例从名为 tutorials_tbl 的表中删除记录数据，其 ID 为 105 。以下是实现给定示例的查询。

DELETE FROM tutorials_tbl WHERE id = 105;

执行以上查询后，您将收到以下输出 −

(1) rows effected

HSQLDB – JDBC Program

以下是实现给定示例的 JDBC 程序。将以下程序保存为 DeleteQuery.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");
   }
}

您可以使用以下命令启动数据库。

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

使用以下命令编译并执行以上程序。

\>javac DeleteQuery.java
\>java DeleteQuery

在执行上述命令之后，您将收到以下输出−

1 Rows effected

HSQLDB - LIKE Clause

RDBMS 结构中有一个 WHERE 子句。您可以在我们希望进行精确匹配的地方使用带等号 (=) 的 WHERE 子句。但可能需要一个要求，我们想要过滤出所有包含“john”的作者姓名的结果。可以使用 SQL LIKE 子句和 WHERE 子句一起处理此问题。

如果 SQL LIKE 子句与 % 字符一起使用，那么在命令提示符处列出所有文件或目录时，它将像 UNIX 中的元字符 (*) 一样工作。

Syntax

以下是 LIKE 子句的通用 SQL 语法。

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

您可以使用 WHERE 子句指定任何条件。
您可以将 LIKE 子句与 WHERE 子句一起使用。
您可以将 LIKE 子句用作等号。
当 LIKE 子句与 % 符号一起使用时，它将像元字符搜索一样工作。
可以使用 AND 或 OR 运算符指定多个条件。
WHERE…LIKE 子句可以与 DELETE 或 UPDATE SQL 命令一起使用来指定条件。

Example

让我们考虑一个例子，其中检索教程数据的列表，其中作者名字以 John 开头。以下是给定例子的HSQLDB查询。

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

在执行上述查询后，你将收到以下输出。

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

HSQLDB – JDBC Program

以下是检索教程数据的列表的JDBC程序，其中作者名字以 John 开头。将代码保存到 LikeClause.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);
      }
   }
}

您可以使用以下命令启动数据库。

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

使用以下命令编译并执行上述代码。

\>javac LikeClause.java
\>java LikeClause

在执行以下命令后，您将收到下面的输出。

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

HSQLDB - Sorting Results

SQL SELECT命令从HSQLDB表中获取数据，只要检索和显示记录时有遵循特定顺序的要求。在这种情况下，我们可以使用 ORDER BY 子句。

Syntax

以下是SELECT命令的语法，以及ORDER BY子句，用于对HSQLDB中的数据进行排序。

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

您可以在任何字段上对返回结果进行排序，前提是字段已列出。
您可以在多个字段上对结果进行排序。
您可以使用关键字ASC或DESC以升序或降序获取结果。默认情况下，它是升序。
您可以照常使用WHERE…LIKE子句来添加条件。

Example

让我们考虑一个例子，通过按升序排列作者姓名来获取并排序 tutorials_tbl 表中的记录。以下是相同的查询。

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

在执行上述查询后，你将收到以下输出。

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

以下是通过按升序排列作者姓名来获取并排序 tutorials_tbl 表中的记录的JDBC程序。将以下程序保存到 OrderBy.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);
      }
   }
}

您可以使用以下命令启动数据库。

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

使用以下命令编译并执行以上程序。

\>javac OrderBy.java
\>java OrderBy

执行上述命令后，您将收到以下输出。

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

HSQLDB - Joins

每当需要使用单个查询从多个表中检索数据时，您可以使用RDBMS中的JOINS。可以在单个SQL查询中使用多个表。在HSQLDB中连接操作是指将两个或更多个表合并成一个表。

考虑以下Customers和Orders表。

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

现在，让我们尝试检索客户数据和相应客户下的订单金额。这意味着我们正在从customers表和orders表中检索记录数据。我们可以通过使用HSQLDB中的JOINS概念来实现此目的。以下是相同的JOIN查询。

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

在执行上述查询后，你将收到以下输出。

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

JOIN Types

HSQLDB中提供不同类型的连接。

INNER JOIN −当两个表中出现匹配时返回行。
LEFT JOIN −从左表返回所有行，即使在右表中没有匹配项。
RIGHT JOIN −从右表返回所有行，即使在左表中没有匹配项。
FULL JOIN −当在一个表中出现匹配项时返回行。
SELF JOIN ― 用于将一个表格自身连接起来，就好像表格是两张表格一样，暂时重命名 SQL 语句中至少一张表格。

Inner Join

最常用且最重要的连接是 INNER JOIN。它也被称为 EQUIJOIN（等值连接）。

INNER JOIN 基于连接谓词通过组合两张表（table1 和 table2）中的列值创建新的结果表。查询会比较 table1 中的每行与 table2 中的每行，以找到满足连接谓词的所有行对。当满足连接谓词时，将每个匹配行对 A 和 B 的列值组合成一行结果。

Syntax

INNER JOIN 的基本语法如下。

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

Example

考虑以下两张表，一张称为 CUSTOMERS 表，另一张称为 ORDERS 表，如下所示：

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

现在，让我们使用 INNER JOIN 查询连接这两张表，如下所示：

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

在执行上述查询后，你将收到以下输出。

+----+----------+--------+---------------------+
| 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 会返回左表中的所有行，即使右表中没有匹配项。这意味着如果 ON 子句与右表中的记录匹配 0（零）条，连接仍会在结果中返回一行，但右表中的每列都是 NULL。

这意味着左连接会返回左表中的所有值，加上右表中的匹配值或在没有匹配连接谓词的情况下返回 NULL。

Syntax

LEFT JOIN 的基本语法如下：

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

这里给定的条件可以是根据您的要求给出的任何表达式。

Example

考虑以下两张表，一张称为 CUSTOMERS 表，另一张称为 ORDERS 表，如下所示：

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

现在，让我们使用 LEFT JOIN 查询连接这两张表，如下所示：

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

执行以上查询后，您将收到以下输出 −

+----+----------+--------+---------------------+
| 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 会返回右表中的所有行，即使左表中没有匹配项。这意味着如果 ON 子句与左表中的记录匹配 0（零）条，连接仍会在结果中返回一行，但左表中的每列都是 NULL。

这意味着右连接会返回右表中的所有值，加上左表中的匹配值或在没有匹配连接谓词的情况下返回 NULL。

Syntax

RIGHT JOIN 的基本语法如下：

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

Example

考虑以下两张表，一张称为 CUSTOMERS 表，另一张称为 ORDERS 表，如下所示：

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

现在，让我们使用 RIGHT JOIN 查询连接这两张表，如下所示：

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

执行以上查询后，您将收到以下结果。

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

Full Join

HSQLDB FULL JOIN 将左外连接和右外连接的结果组合在一起。

连接的表将包含两张表中的所有记录，并在两边填入缺少匹配项的 NULL。

Syntax

FULL JOIN 的基本语法如下：

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

这里给定的条件可以是根据您的要求给出的任何表达式。

Example

考虑以下两张表，一张称为 CUSTOMERS 表，另一张称为 ORDERS 表，如下所示：

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

现在，让我们使用 FULL JOIN 查询连接这两张表，如下所示：

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

执行以上查询后，您将收到以下结果。

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

Self Join

SQL 自联接用于将一个表连接到它自身，就像该表是两个表一样，在 SQL 语句中临时重命名至少一个表。

Syntax

SELF JOIN 的基本语法如下 −

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

这里，WHERE 子句可以是基于您要求的任何给定表达式。

Example

考虑以下两张表，一张称为 CUSTOMERS 表，另一张称为 ORDERS 表，如下所示：

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

现在，我们使用 SELF JOIN 查询如下连接此表 −

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

执行以上查询后，您将收到以下输出 −

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

HsqlDB - Null Values

SQL NULL 是用于表示缺失值的一个术语。表中的 NULL 值是字段中看似空白的值。每当我们尝试给出一个条件（将字段或列值与 NULL 进行比较）时，它并不能正常工作。

我们可以通过使用以下三点来处理 NULL 值。

IS NULL − 如果列值为 NULL，则运算符返回真。
IS NOT NULL − 如果列值不为 NULL，则运算符返回真。
<⇒ − 运算符比较值（不同于 = 运算符），即使对于两个 NULL 值也是真。

要查找 NULL 或 NOT NULL 的列，分别使用 IS NULL 或 IS NOT NULL。

Example

让我们考虑一个示例，其中有一个表 tcount_tbl ，它包含两列，作者和教程计数。我们可以向 tutorial_count 提供 NULL 值，表示作者甚至没有发布一个教程。因此，该相应作者的 tutorial_count 值为 NULL。

执行以下查询。

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

使用以下命令显示 tcount_tbl 表中的所有记录。

select * from tcount_tbl;

执行上述命令后，您将收到以下输出。

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

要查找 tutorial_count 列为 NULL 的记录，以下是要执行的查询。

SELECT * FROM tcount_tbl WHERE tutorial_count IS NULL;

在执行查询后，你将收到以下输出。

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

要查找 tutorial_count 列为 NOT NULL 的记录，以下是要执行的查询。

SELECT * FROM tcount_tbl WHERE tutorial_count IS NOT NULL;

在执行查询后，你将收到以下输出。

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

HSQLDB – JDBC Program

以下是一个 JDBC 程序，它从 tcount_tbl 表中分别检索 tutorial_count 为 NULL 和 tutorial_count 为 NOT NULL 的记录。将以下程序保存到 NullValues.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);
      }
   }
}

使用以下命令编译并执行以上程序。

\>javac NullValues.java
\>Java NullValues

执行上述命令后，您将收到以下输出。

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 - Regular Expressions

HSQLDB 支持一些特殊符号，用于基于正则表达式和 REGEXP 运算符进行模式匹配操作。

以下是模式表，可与 REGEXP 运算符一起使用。

Pattern

What the Pattern Matches

Beginning of the string

End of the string

Any single character

[…]

方括号内列出的任何字符

[^…]

方括号内未列出的任何字符

交替；与模式 p1、p2 或 p3 中的任何一个匹配

前一个元素的零个或多个实例

前一个元素的一个或多个实例

{n}

前一个元素的 n 个实例

{m,n}

前一个元素的 m 到 n 个实例

Example

让我们尝试不同的示例查询来满足我们的要求。查看以下给定的查询。

试用此查询以查找所有名称以“^A”开头的作者。

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

在执行上述查询后，你将收到以下输出。

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

试用此查询以查找所有名称以“ul$”结尾的作者。

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

在执行上述查询后，你将收到以下输出。

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

试用此查询以查找所有名称包含“th”的作者。

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

在执行上述查询后，你将收到以下输出。

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

试用此查询以查找所有名称以元音（a、e、i、o、u）开头的作者。

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

在执行上述查询后，你将收到以下输出。

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

HSQLDB - Transactions

Transaction 是数据库操作的顺序组，它被执行并认为是一个单一的工作单元。换句话说，当所有操作都成功执行时，整个事务才会完成。如果事务中的任何操作失败，那么整个事务将会失败。

Properties of Transactions

基本上，事务支持 4 个标准属性。它们可以称为 ACID 属性。

Atomicity − 事务中的所有操作都成功执行，否则事务将在失败时中止，并且先前的操作回滚到它们先前的状态。

Consistency − 成功提交事务后，数据库将适当地更改状态。

Isolation − 它使事务能够独立操作，彼此透明。

Durability − 在系统故障的情况下，已提交事务的结果或影响会持久存在。

Commit, Rollback, and Savepoint

这些关键字主要用于 HSQLDB 事务。

Commit − 始终应通过执行 COMMIT 命令来完成成功的的事务。

Rollback − 如果事务中出现故障，则应执行 ROLLBACK 命令，以便将事务中引用的所有表返回到其先前状态。

Savepoint - 在交易组内创建一个回滚点。

Example

下面这个示例将解释交易的概念以及提交、回滚和保存点。让我们考虑一下表 Customers 以及列 id、name、age、address 和 salary。

Id	Name	Age	Address	Salary
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

使用下列命令创建与上述数据相类似的客户表。

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

Example for COMMIT

下面这个查询会删除表中 age = 25 的行，并且使用 COMMIT 命令将这些改动应用至数据库。

DELETE FROM CUSTOMERS WHERE AGE = 25;
COMMIT;

在执行上述查询后，你将收到以下输出。

2 rows effected

在上述命令成功执行后，通过执行下面给出的命令检查客户表的记录。

Select * from Customer;

在执行上述查询后，你将收到以下输出。

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

Example for Rollback

让我们考虑同样的 Customer 表作为输入。

Id	Name	Age	Address	Salary
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

这里有一个示例查询可以解释 Rollback 功能，具体是通过删除表中 age = 25 的记录然后 ROLLBACK 数据库中的改动。

DELETE FROM CUSTOMERS WHERE AGE = 25;
ROLLBACK;

在上述两个查询成功执行后，你可以使用下面的命令查看 Customer 表中的记录数据。

Select * from Customer;

执行上述命令后，您将收到以下输出。

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

删除查询会删除年龄为 25 的客户的记录数据。Rollback 命令会回滚 Customer 表上的那些改动。

Example for Savepoint

保存点是事务中的一个点，你可以在此点回滚事务到某个点，而不回滚整个事务。

让我们考虑同样的 Customer 表作为输入。

Id	Name	Age	Address	Salary
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

让我们在本例中考虑一下，你计划删除 Customers 表中的三条不同的记录。你希望在每次删除之前创建一个保存点，以便你可以随时回滚到任意保存点，以将相应的数据返回到其原始状态。

这里有一系列操作。

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

现在，你已经创建了三个保存点并删除了三条记录。在这个情况下，如果你想要回滚 Id 为 2 和 3 的记录，那么使用下面的 Rollback 命令。

ROLLBACK TO SP2;

注意，由于你回滚到了 SP2，因此只发生了第一次删除。使用下面的查询显示所有客户记录。

Select * from Customer;

在执行上述查询后，你将收到以下输出。

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

Release Savepoint

我们可以使用 RELEASE 命令释放保存点。以下是一般语法。

RELEASE SAVEPOINT SAVEPOINT_NAME;

HsqlDB - Alter Command

无论何时需要更改表或字段的名称、更改字段的顺序、更改字段的数据类型或任何表结构，你都可以使用 ALTER 命令。

Example

让我们考虑一个解释 ALTER 命令使用不同场景的示例。

使用下面的查询创建名为 testalter_tbl 的表以及字段 id 和 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';

在执行上述查询后，你将收到以下输出。

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

Dropping or Adding a Column

无论何时想要从 HSQLDB 表中 DROP 现有列时，你都可以将 DROP 子句和 ALTER 命令一起使用。

使用以下查询从表 testalter_tbl 中删除一列 ( name )。

ALTER TABLE testalter_tbl DROP name;

在成功执行以上查询后，你可以使用以下命令了解名称字段是否从表 testalter_tbl 中删除。

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

执行上述命令后，您将收到以下输出。

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

每当你想要向 HSQLDB 表中添加任何列时，你可以在 ALTER 命令中使用 ADD 子句。

使用以下查询，向表 testalter_tbl 中添加一个名为 NAME 的列。

ALTER TABLE testalter_tbl ADD name VARCHAR(10);

在成功执行以上查询后，你可以使用以下命令了解名称字段是否已添加到表 testalter_tbl 。

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

在执行上述查询后，你将收到以下输出。

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

Changing a Column Definition or Name

每当需要更改列定义时，请在 ALTER 命令中使用 MODIFY 或 CHANGE 子句。

让我们考虑一个示例，来说明如何使用 CHANGE 子句。表 testalter_tbl 包含两个字段：id 和 name，分别具有数据类型 int 和 varchar。现在让我们尝试将 id 的数据类型从 INT 更改为 BIGINT。以下是进行更改的查询。

ALTER TABLE testalter_tbl CHANGE id id BIGINT;

在成功执行以上查询后，可以使用以下命令验证表结构。

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

执行上述命令后，您将收到以下输出。

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

现在让我们尝试将表 testalter_tbl 中的列 NAME 的大小从 10 增加到 20。以下是使用 ALTER 命令和 MODIFY 子句实现此操作的查询。

ALTER TABLE testalter_tbl MODIFY name VARCHAR(20);

在成功执行以上查询后，可以使用以下命令验证表结构。

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

执行上述命令后，您将收到以下输出。

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

HSQLDB - Indexes

database index 是一个数据结构，它提高了表中操作的速度。可以使用一列或多列创建索引，为快速随机查找和高效排序对记录的访问提供基础。

在创建索引时，应考虑哪些列将用于创建 SQL 查询，并在这些列上创建一列或多列索引。

实际上，索引也是一种表，它保留主密钥或索引字段以及指向实际表中每个记录的指针。

用户看不到索引。它们仅用于加速查询，并将由数据库搜索引擎使用来快速查找记录。

对具有索引的表，INSERT 和 UPDATE 语句需要更多时间，而 SELECT 语句在这些表上运行得更快。原因是在插入或更新时，数据库也需要插入或更新索引值。

Simple & Unique Index

您可以在表上创建唯一索引。 unique index 表示两行不能具有相同的索引值。以下是创建表索引的语法。

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

可以使用一个或多个列创建索引。例如，使用 tutorial_author 在 tutorials_tbl 上创建索引。

CREATE UNIQUE INDEX AUTHOR_INDEX
ON tutorials_tbl (tutorial_author)

可以在表上创建简单索引。从要创建简单索引的查询中省略该 UNIQUE 关键字。 simple index 允许表中存在重复值。

如果您想按降序对某列中的值进行索引，您可以在列名后添加保留字 DESC。

CREATE UNIQUE INDEX AUTHOR_INDEX
ON tutorials_tbl (tutorial_author DESC)

ALTER Command to Add & Drop INDEX

有四类用于向表中添加索引的语句 −

ALTER TABLE tbl_name ADD PRIMARY KEY (column_list) − 此语句添加一个主键，这意味着索引值必须唯一且不能为 NULL。
ALTER TABLE tbl_name ADD UNIQUE index_name (column_list) − 此语句创建了一个其值必须唯一的索引（除了可能多次出现的 NULL 值）。
ALTER TABLE tbl_name ADD INDEX index_name (column_list) − 这添加了一个普通索引，其中任何值都可能出现多次。
ALTER TABLE tbl_name ADD FULLTEXT index_name (column_list) − 这创建了一个特殊的 FULLTEXT 索引，用于文本搜索目的。

以下是添加到现有表的索引的查询。

ALTER TABLE testalter_tbl ADD INDEX (c);

你可以使用 DROP 子句和 ALTER 命令来删除任何索引。以下是删除上述创建的索引的查询。

ALTER TABLE testalter_tbl DROP INDEX (c);

Displaying INDEX Information

你可以使用 SHOW INDEX 命令列出与表关联的所有索引。此语句经常会使用垂直格式输出（通过 \G 指定），以避免长行换行。

以下是显示表索引信息的通用语法。

SHOW INDEX FROM table_name\G