HSQLDB - 快速指南

HSQLDB - 简介

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

HSQLDB 的主要且独特的功能是标准合规性。它可以在用户的应用程序进程内、应用程序服务器内或作为单独的服务器进程提供数据库访问。

HSQL数据库的特点

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

HSQLDB 的组件

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

HyperSQL RDBMS 引擎 (HSQLDB)
HyperSQL JDBC 驱动程序
数据库管理器（GUI数据库访问工具，有Swing和AWT版本）

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

另一个名为 sqltool.jar 的 jar 包含 Sql Tool，它是一个命令行数据库访问工具。这是一个通用命令。线路数据库访问工具，也可以与其他数据库引擎一起使用。

HSQlDB - 安装

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

先决条件

遵循 HSQLDB 的必备软件安装。

验证 Java 安装

由于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，请访问以下链接来安装 JDK。

HSQLDB安装

以下是安装 HSQLDB 的步骤。

第 1 步 - 下载 HSQLDB 包

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

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

步骤 2 - 解压 HSQLDB zip 文件

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

步骤 3 - 创建默认数据库

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 数据库服务器创建的 demodb 数据库的临时文件、lck 文件、日志文件、属性文件和脚本文件。

步骤 4 - 启动数据库服务器

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

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

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

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

您将看到 HSQLDB 数据库的 GUI 屏幕，如下图所示。

HSQLDB-连接

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

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

例子

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 - 数据类型

本章介绍 HSQLDB 的不同数据类型。HSQLDB服务器提供六类数据类型。

精确的数字数据类型

数据类型	从	到
大整数	-9,223,372,036,854,775,808	9,223,372,036,854,775,807
整数	-2,147,483,648	2,147,483,647
小整数	-32,768	32,767
小整数	0	255
少量	0	1
小数	-10^38 +1	10^38 -1
数字	-10^38 +1	10^38 -1
钱	-922,337,203,685,477.5808	+922,337,203,685,477.5807
小钱	-214,748.3648	+214,748.3647

近似数字数据类型

数据类型	从	到
漂浮	-1.79E+308	1.79E+308
真实的	-3.40E+38	3.40E+38

日期和时间数据类型

数据类型	从	到
约会时间	1753 年 1 月 1 日	9999 年 12 月 31 日
小日期时间	1900 年 1 月 1 日	2079 年 6 月 6 日
日期	存储日期，如 1991 年 6 月 30 日
时间	存储一天中的某个时间，例如 12:30 PM

注意- 此处，日期时间的精度为 3.33 毫秒，而小日期时间的精度为 1 分钟。

字符串数据类型

数据类型	描述
字符	最大长度为 8,000 个字符（固定长度非 Unicode 字符）
varchar	最多 8,000 个字符（可变长度非 Unicode 数据）
varchar（最大）	最大长度为 231 个字符，可变长度非 Unicode 数据（仅限 SQL Server 2005）
文本	可变长度非 Unicode 数据，最大长度为 2,147,483,647 个字符

Unicode 字符串数据类型

数据类型	描述
恩查尔	最大长度为 4,000 个字符（固定长度 Unicode）
nvarchar	最大长度为 4,000 个字符（可变长度 Unicode）
nvarchar（最大）	最大长度为 231 个字符（仅限 SQL Server 2005），（可变长度 Unicode）
文本	最大长度为 1,073,741,823 个字符（可变长度 Unicode）

二进制数据类型

数据类型	描述
二进制	最大长度 8,000 字节（固定长度二进制数据）
瓦尔二进制	最大长度 8,000 字节（可变长度二进制数据）
varbinary（最大）	最大长度为 231 字节（仅限 SQL Server 2005），（可变长度二进制数据）
图像	最大长度 2,147,483,647 字节（可变长度二进制数据）

其他数据类型

数据类型	描述
sql_variant	存储 SQL Server 支持的各种数据类型的值（text、ntext 和 timestamp 除外）
时间戳	存储数据库范围内的唯一编号，每次更新行时该编号都会更新
唯一标识符	存储全局唯一标识符 (GUID)
XML	存储 XML 数据。您可以将 xml 实例存储在列或变量中（仅限 SQL Server 2005）
光标	对光标对象的引用
桌子	存储结果集以供以后处理

HSQLDB - 创建表

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

句法

看看下面的语法。

CREATE TABLE table_name (column_name column_type);

例子

让我们创建一个名为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 程序

以下是用于在 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 - 删除表

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

句法

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

DROP TABLE table_name;

例子

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

DROP TABLE employee;

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

(0) rows effected

HSQLDB – JDBC 程序

以下是用于从 HSQLDB 服务器删除表员工的 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 INTO命令在HSQLDB中实现插入查询语句。您必须按照表中的列字段顺序提供用户定义的数据。

句法

以下是INSERT查询的通用语法。

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

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

例子

让我们考虑一个示例，该示例将一条记录插入到名为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 程序

以下是 JDBC 程序，用于将记录插入具有给定值的表中，id = 100，title = Learn PHP，Author = John Poul，提交日期为当前日期。看看给定的程序。将代码保存到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表中。

ID	标题	作者	提交日期
101	学习C语言	亚斯旺斯	现在（）
102	学习MySQL	阿卜杜勒·S	现在（）
103	学习卓越	巴维亚卡纳	现在（）
104	学习JDB	阿Guice·库马尔	现在（）
105	学习Junit	沙迪亚穆蒂	现在（）

HSQLDB - 选择查询

SELECT命令用于从HSQLDB数据库中获取记录数据。在这里，您需要在 Select 语句中提及必填字段列表。

句法

以下是选择查询的通用语法。

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

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

例子

下面是一个从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 程序

下面是 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 子句

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

句法

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

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 子句一起使用的运算符列表。

操作员	描述	例子
=	检查两个操作数的值是否相等，如果相等则条件成立。	(A = B) 不正确
!=	检查两个操作数的值是否相等，如果值不相等则条件成立。	(A != B) 为真
>	检查左操作数的值是否大于右操作数的值，如果是，则条件成立。	(A > B) 不正确
<	检查左操作数的值是否小于右操作数的值，如果是，则条件成立。	(A < B) 为真
>=	检查左操作数的值是否大于或等于右操作数的值，如果是，则条件成立。	(A >= B) 不正确
<=	检查左操作数的值是否小于或等于右操作数的值，如果是，则条件为真。	(A <= B) 为真

例子

下面是一个检索名为“Learn C”的书的详细信息（例如 id、标题和作者）的示例。可以通过在 SELECT 命令中使用 WHERE 子句来实现。以下是相同的查询。

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

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

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

HSQLDB – JDBC 程序

下面是从标题为Learn C的表tutorials_tbl 中检索记录数据的 JDBC 程序。将以下代码保存到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 命令。这将修改任何 HSQLDB 表中的任何字段值。

句法

这是 UPDATE 命令的通用语法。

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

您可以更新一个或多个字段。
您可以使用 WHERE 子句指定任何条件。
您一次可以更新单个表中的值。

例子

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

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

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

(1) Rows effected

HSQLDB – JDBC 程序

以下是 JDBC 程序，它将把教程标题从Learn C更新为id 为101的C 和数据结构。将以下程序保存到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 - 删除子句

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

句法

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

DELETE FROM table_name [WHERE Clause]

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

例子

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

DELETE FROM tutorials_tbl WHERE id = 105;

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

(1) rows effected

HSQLDB – JDBC 程序

下面是实现给定示例的 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 子句

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

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

句法

以下是 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 命令一起使用来指定条件。

例子

让我们考虑一个检索教程数据列表的示例，其中作者姓名以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 程序

以下是检索作者姓名以John开头的教程数据列表的 JDBC 程序。将代码保存到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 - 对结果进行排序

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

句法

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

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

您可以对任何字段对返回的结果进行排序，前提是该字段已列出。
您可以对多个字段的结果进行排序。
您可以使用关键字 ASC 或 DESC 来按升序或降序排列结果。默认情况下，它按升序排列。
您可以按照通常的方式使用 WHERE...LIKE 子句来设置条件。

例子

让我们考虑一个示例，该示例通过按作者姓名升序排列来获取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 程序

下面是一个 JDBC 程序，它通过按作者姓名升序来获取和排序tutorials_tbl表的记录。将以下程序保存到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 - 连接

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

考虑以下客户和订单表。

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

现在，让我们尝试检索客户的数据以及相应客户下的订单金额。这意味着我们正在从客户和订单表中检索记录数据。我们可以通过使用 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  |
+----+----------+-----+--------+

连接类型

HSQLDB 中有不同类型的联接可用。

INNER JOIN - 当两个表中存在匹配时返回行。
LEFT JOIN - 返回左表中的所有行，即使右表中没有匹配项。
RIGHT JOIN - 返回右表中的所有行，即使左表中没有匹配项。
FULL JOIN - 当其中一个表中有匹配项时返回行。
SELF JOIN - 用于将表连接到自身，就好像该表是两个表一样，在 SQL 语句中临时重命名至少一个表。

内部联接

最常用和最重要的连接是 INNER JOIN。它也称为 EQUIJOIN。

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

句法

INNER JOIN 的基本语法如下。

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

例子

考虑以下两个表，一个标题为 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 |
+----+----------+--------+---------------------+

左连接

HSQLDB LEFT JOIN 返回左表中的所有行，即使右表中没有匹配项也是如此。这意味着，如果 ON 子句匹配右表中的 0（零）条记录，则联接仍将在结果中返回一行，但右表中的每一列中都包含 NULL。

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

句法

LEFT JOIN 的基本语法如下 -

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

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

例子

考虑以下两个表，一个标题为 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         |
+----+----------+--------+---------------------+

右连接

HSQLDB RIGHT JOIN 返回右表中的所有行，即使左表中没有匹配项也是如此。这意味着，如果 ON 子句匹配左表中的 0（零）条记录，则联接仍将在结果中返回一行，但左表中的每一列中都包含 NULL。

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

句法

RIGHT JOIN的基本语法如下 -

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

例子

考虑以下两个表，一个标题为 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 |
+------+----------+--------+---------------------+

全面加入

HSQLDB FULL JOIN 组合了左外连接和右外连接的结果。

连接的表将包含两个表中的所有记录，并为两侧缺失的匹配项填充 NULL。

句法

FULL JOIN 的基本语法如下 -

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

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

例子

考虑以下两个表，一个标题为 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 |
+------+----------+--------+---------------------+

自加入

SQL SELF JOIN 用于将一个表与其自身连接起来，就好像该表是两个表一样，在 SQL 语句中临时重命名至少一个表。

句法

SELF JOIN 的基本语法如下 -

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

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

例子

考虑以下两个表，一个标题为 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 - 空值

SQL NULL 是一个用于表示缺失值的术语。表中的 NULL 值是字段中显示为空白的值。每当我们尝试给出一个将字段或列值与 NULL 进行比较的条件时，它都无法正常工作。

我们可以使用这三个东西来处理 NULL 值。

IS NULL - 如果列值为 NULL，则运算符返回 true。
IS NOT NULL - 如果列值不为 NULL，则运算符返回 true。
<=> - 该运算符比较值，（与 = 运算符不同）即使对于两个 NULL 值也是如此。

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

例子

让我们考虑一个示例，其中有一个表tcount_tbl，其中包含两列：author 和tutorial_count。我们可以向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 列不为空的记录，请执行以下查询。

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 程序

下面是 JDBC 程序，它从表 tcount_tbl 中单独检索记录，其中tutorial_count 为 NULL，tutorial_count 不为 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);
      }
   }
}

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