H2 数据库 - 快速指南

H2 数据库 - 简介

H2 是一个开源的轻量级 Java 数据库。它可以嵌入到 Java 应用程序中，也可以在客户端-服务器模式下运行。主要的是，H2 数据库可以配置为内存数据库，这意味着数据不会持久化到磁盘。由于是嵌入式数据库，因此不适用于生产开发，主要用于开发和测试。

该数据库可以在嵌入模式或服务器模式下使用。以下是 H2 数据库的主要特性：

极快、开源、JDBC API
支持嵌入式和服务器模式；内存数据库
基于浏览器的控制台应用程序
占用空间小 - 大约 1.5MB 的 jar 文件大小

H2 数据库的特性

H2 数据库的主要特性如下：

它是一个极快的数据库引擎。
H2 是开源的，并用 Java 编写。
它支持标准 SQL 和 JDBC API。它也可以使用 PostgreSQL ODBC 驱动程序。
它具有嵌入式和服务器模式。
H2 支持集群和多版本并发。
它具有强大的安全特性。

附加特性

以下是 H2 数据库的一些附加特性：

H2 是基于磁盘或内存的数据库和表，支持只读数据库，临时表。
H2 提供事务支持（读已提交），两阶段提交，多个连接，表级锁。
H2 是一个基于成本的优化器，使用遗传算法处理复杂查询，零管理。
H2 包含可滚动和可更新的结果集支持，大型结果集，外部结果排序，函数可以返回结果集。
H2 支持加密数据库 (AES)，SHA-256 密码加密，加密函数和 SSL。

H2 数据库中的组件

为了使用 H2 数据库，您需要具备以下组件：

一个 Web 浏览器
一个 H2 控制台服务器

这是一个客户端/服务器应用程序，因此需要服务器和客户端（浏览器）才能运行它。

H2 数据库 - 安装

H2 是一个用 Java 编写的数据库。我们可以使用 JDBC 将此数据库轻松嵌入到我们的应用程序中。我们可以在许多不同的平台或任何版本的 Java 运行时环境上运行它。但是，在安装数据库之前，系统中应该已经安装了 Java。

验证 Java 安装

如果系统中已安装 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。

安装 H2 数据库

我们可以在许多不同的平台上运行这个数据库。在本节中，我们将学习如何在 Windows 上安装 H2 数据库。

以下是如何在 Windows 操作系统上安装 H2 数据库的步骤。

步骤 1：下载 H2 安装文件

从给定的链接下载最新版本的H2 数据库。在这个链接中，您可以获得两种类型的最新版本 H2 数据库。一种是 Windows 安装程序类型（即 .exe 文件），另一种是适用于其他操作系统的平台无关 zip 文件。

单击 Windows 安装程序以下载支持 Windows 的 H2 数据库，下载 .exe 文件后。在本例中，我们使用版本为 1.4.192 的 H2 数据库。

步骤 2：安装 H2 数据库

下载后，我们在下载目录中获得 H2 Windows 安装程序文件（即 h2-setup-yyyy-mm-dd.exe）。要启动 H2 数据库的安装过程，请双击安装程序文件。

以下屏幕是安装过程的第一步。提供我们想要安装 H2 数据库服务器的路径，如下面的屏幕截图所示。

如上图所示，默认情况下它将采用C:\ProgramFiles (x86)\H2作为目标文件夹。单击下一步继续到下一步。将弹出以下屏幕。

在上图中，单击“安装”按钮以启动安装过程。安装后，我们将看到以下屏幕截图。

单击“完成”以完成安装过程。

步骤 3：验证 H2 数据库安装

安装后，让我们验证系统中的数据库安装。单击 Windows → 输入 H2 Console → 单击 H2 控制台图标。连接到 URL https://:8082。连接时，H2 数据库将要求进行数据库注册，如下面的屏幕截图所示。

在上面的对话框中填写所有详细信息，例如已保存的设置、设置名称、驱动程序类、JDBC URL、用户名和密码。在 JDBC URL 中，指定数据库的位置和数据库名称。用户名和密码是数据库用户名和密码的字段。单击连接。

数据库欢迎页面将弹出，如下面的屏幕截图所示。

H2 数据库 - 查询 (Select)

SELECT 语句用于从一个或多个表中提取记录数据。如果我们设计一个 SELECT 查询，则它将以称为结果集的结果表的形式返回数据。

语法

SELECT 语句的基本语法如下：

SELECT [ TOP term ] [ DISTINCT | ALL ] selectExpression [,...] 
FROM tableExpression [,...] [ WHERE expression ] 
[ GROUP BY expression [,...] ] [ HAVING expression ] 
[ { UNION [ ALL ] | MINUS | EXCEPT | INTERSECT } select ] [ ORDER BY order [,...] ] 
[ [ LIMIT expression ] [ OFFSET expression ] [ SAMPLE_SIZE rowCountInt ] ] 
[ FOR UPDATE ]

要提取所有可用字段，请使用以下语法。

SELECT * FROM table_name;

示例

考虑具有以下记录的 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 | 
+----+----------+-----+-----------+----------+

要获取包含给定数据的客户表，请执行以下查询。

CREATE TABLE CUSTOMER (id number, name varchar(20), age number, address varchar(20), 
salary number);  

INSERT into CUSTOMER values (1, 'Ramesh', 32, 'Ahmedabad', 2000); 
INSERT into CUSTOMER values (2, 'Khilan', 25, 'Delhi', 1500); 
INSERT into CUSTOMER values (3, 'kaushik', 23, 'Kota', 2000); 
INSERT into CUSTOMER values (4, 'Chaitali', 25, 'Mumbai', 6500); 
INSERT into CUSTOMER values (5, 'Hardik', 27, 'Bhopal', 8500); 
INSERT into CUSTOMER values (6, 'Komal', 22, 'MP', 4500); 
INSERT into CUSTOMER values (7, 'Muffy', 24, 'Indore', 10000);

以下命令是一个示例，它将提取 CUSTOMER 表中客户的 ID、Name 和 Salary 字段。

SELECT ID, NAME, SALARY FROM CUSTOMERS;

上述命令产生以下结果。

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

使用以下查询来提取 CUSTOMERS 表的所有字段。

SQL> SELECT * FROM CUSTOMERS;

上述查询产生以下结果：

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

H2 数据库 - 插入 (Insert)

SQL INSERT 语句用于向数据库中的表添加新的数据行。

语法

以下是 INSERT INTO 语句的基本语法。

INSERT INTO tableName 
{ [ ( columnName [,...] ) ] 
{ VALUES 
{ ( { DEFAULT | expression } [,...] ) } [,...] | [ DIRECT ] [ SORTED ] select } } | 
{ SET { columnName = { DEFAULT | expression } } [,...] }

使用此 INSERT 语句，我们可以向表中插入新记录或新行。当使用 DIRECT 子句时，结果将直接影响目标表，无需任何中间步骤。但是，在为表的所有列添加值时，请确保值的顺序与表中的列顺序相同。

示例

让我们举个例子，尝试将以下给定的记录插入 Customer 表。

ID	姓名	年龄	地址	薪水
1	Ramesh	32	Ahmedabad	2000
2	Khilan	25	Delhi	1500
3	Kaushik	23	Kota	2000
4	Chaitail	25	Mumbai	6500
5	Hardik	27	Bhopal	8500
6	Komal	22	MP	4500
7	Muffy	24	Indore	10000

我们可以通过执行以下命令将所有给定的记录放入客户表中。

INSERT INTO CUSTOMER VALUES (1, 'Ramesh', 32, 'Ahmedabad', 2000); 
INSERT INTO CUSTOMER VALUES (2, 'Khilan', 25, 'Delhi', 1500); 
INSERT INTO CUSTOMER VALUES (3, 'kaushik', 23, 'Kota', 2000); 
INSERT INTO CUSTOMER VALUES (4, 'Chaitali', 25, 'Mumbai', 6500); 
INSERT INTO CUSTOMER VALUES (5, 'Hardik', 27, 'Bhopal', 8500); 
INSERT INTO CUSTOMER VALUES (6, 'Komal', 22, 'MP', 4500); 
INSERT INTO CUSTOMER VALUES (7, 'Muffy', 24, 'Indore', 10000);

H2 数据库 - 更新 (Update)

UPDATE 查询用于更新或修改表中现有的记录。我们可以将 WHERE 子句与 UPDATE 查询一起使用以更新选定的行，否则所有行都将受到影响。

语法

以下是 UPDATE 查询的基本语法。

UPDATE tableName [ [ AS ] newTableAlias ] SET 
{ { columnName = { DEFAULT | expression } } [,...] } | 
{ ( columnName [,...] ) = ( select ) } 
[ WHERE expression ] [ ORDER BY order [,...] ] [ LIMIT expression ]

在这个 UPDATE 语法中，我们可以使用 AND 或 OR 子句组合多个条件。

示例

考虑具有以下记录的 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 | 
+----+----------+-----+-----------+----------+

如果要获取包含给定数据的客户表，请执行以下查询。

CREATE TABLE CUSTOMER (id number, name varchar(20), age number, address varchar(20), 
   salary number);  
INSERT into CUSTOMER values (1, 'Ramesh', 32, 'Ahmedabad', 2000); 
INSERT into CUSTOMER values (2, 'Khilan', 25, 'Delhi', 1500); 
INSERT into CUSTOMER values (3, 'kaushik', 23, 'Kota', 2000); 
INSERT into CUSTOMER values (4, 'Chaitali', 25, 'Mumbai', 6500); 
INSERT into CUSTOMER values (5, 'Hardik', 27, 'Bhopal', 8500); 
INSERT into CUSTOMER values (6, 'Komal', 22, 'MP', 4500); 
INSERT into CUSTOMER values (7, 'Muffy', 24, 'Indore', 10000);

以下命令是一个示例，它将更新 ID 为 6 的客户的 ADDRESS：

UPDATE CUSTOMERS SET ADDRESS = 'Pune' WHERE ID = 6;

现在，CUSTOMERS 表将具有以下记录。我们可以通过执行以下查询来检查客户表记录。

SELECT * FROM CUSTOMERS;

上述查询产生以下结果。

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

要修改 CUSTOMERS 表中的所有 ADDRESS 和 SALARY 列值，我们不需要使用 WHERE 子句。UPDATE 查询将如下所示：

UPDATE CUSTOMERS SET ADDRESS = 'Pune', SALARY = 1000.00;

现在，CUSTOMERS 表将具有以下记录。我们可以通过执行以下查询来检查客户表记录。

SELECT * FROM CUSTOMERS;

上述查询产生以下结果：

+----+----------+-----+---------+---------+ 
| ID | NAME     | AGE | ADDRESS | SALARY  | 
+----+----------+-----+---------+---------+ 
|  1 | Ramesh   |  32 | Pune    | 1000.00 | 
|  2 | Khilan   |  25 | Pune    | 1000.00 | 
|  3 | kaushik  |  23 | Pune    | 1000.00 | 
|  4 | Chaitali |  25 | Pune    | 1000.00 | 
|  5 | Hardik   |  27 | Pune    | 1000.00 | 
|  6 | Komal    |  22 | Pune    | 1000.00 | 
|  7 | Muffy    |  24 | Pune    | 1000.00 | 
+----+----------+-----+---------+---------+

H2 数据库 - 删除 (Delete)

SQL DELETE 查询用于从表中删除现有记录。我们可以将 WHERE 子句与 DELETE 查询一起使用以删除选定的记录，否则所有记录都将被删除。

语法

以下是 delete 命令的通用查询语法。

DELETE [ TOP term ] FROM tableName [ WHERE expression ] [ LIMIT term ]

上述语法从表中删除行。如果指定了 TOP 或 LIMIT，则最多删除指定数量的行（如果为 null 或小于零，则没有限制）。

示例

考虑具有以下记录的 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 | 
+----+----------+-----+-----------+----------+

以下命令将删除 ID 为 6 的客户的详细信息。

DELETE FROM CUSTOMERS WHERE ID = 6;

执行上述命令后，通过执行以下命令检查 Customer 表。

SELECT * FROM CUSTOMERS;

上述命令产生以下输出：

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

如果我们想要从 CUSTOMERS 表中删除所有记录，我们不使用 WHERE 子句。DELETE 查询将如下所示。

DELETE FROM CUSTOMER;

执行上述命令后，Customer 表中将没有任何记录。

H2 数据库 - 备份

BACKUP 命令用于将数据库备份到单独的 .zip 文件中。对象不会被锁定，并且在进行备份时也会复制事务日志。执行此命令需要管理员权限。

语法

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

BACKUP TO fileNameString;

示例

在这个例子中，让我们将当前数据库备份到backup.zip文件中。为此，请使用以下命令。

BACKUP TO 'backup.zip';

执行上述命令后，您将在本地文件系统中获得 backup.zip 文件。

H2 数据库 - 调用 (Call)

CALL 是一个属于 H2 数据库服务器的 SQL 命令。此命令用于计算简单的表达式。它将给定表达式的结果返回到单个列字段中。当它返回一个结果数组时，数组中的每个元素都将显示为列值。

语法

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

CALL expression;

我们可以在此语法中使用算术表达式。

示例

让我们来看一个例子，使用call命令执行算术表达式(15 * 25)。

CALL 15*25;

以上命令产生以下输出。

375
375

H2 数据库 - 解释 (Explain)

EXPLAIN命令显示语句的执行计划。当我们使用EXPLAIN ANALYZE命令执行语句时，查询计划将包含每个表的实际行扫描计数。

语法

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

EXPLAIN { [ PLAN FOR ] | ANALYZE } { select | insert | update | delete | merge}

除了这个语法，我们还可以使用select、insert、delete和merge。

示例

此示例解释了ID为1的客户的查询计划详细信息。

EXPLAIN SELECT * FROM CUSTOMER WHERE ID = 1;

上述命令产生以下输出：

H2 数据库 - 合并 (Merge)

MERGE命令用于更新现有行并将新行插入表中。主键列在此命令中起着重要作用；它用于查找行。

语法

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

MERGE INTO tableName [ ( columnName [,...] ) ] 
[ KEY ( columnName [,...] ) ] 
{ VALUES { ( { DEFAULT | expression } [,...] ) } [,...] | select }

在上述语法中，KEY子句用于指定主键列名。结合VALUES子句，我们可以使用原始值进行插入，也可以使用select命令检索并存储另一个表的数值到此表中。

示例

在这个例子中，让我们尝试向Customers表中添加一条新记录。以下是表中新记录的详细信息。

列名	值
ID	8
NAME	Lokesh
AGE	32
ADDRESS	Hyderabad
SALARY	2500

使用以下查询，让我们将给定的记录插入到H2数据库查询中。

MERGE INTO CUSTOMER KEY (ID) VALUES (8, 'Lokesh', 32, 'Hyderabad', 2500);

以上查询产生以下输出。

Update count: 1

让我们通过执行以下查询来验证Customer表的记录。

SELECT * FROM CUSTOMER;

以上查询产生以下输出。

ID	姓名	年龄	地址	薪水
1	Ramesh	32	Ahmedabad	2000
2	Khilan	25	Delhi	1500
3	Kaushik	23	Kota	2000
4	Chaitali	25	Mumbai	6500
5	Hardik	27	Bhopal	8500
6	Komal	22	MP	4500
7	Muffy	24	Indore	10000
8	Lokesh	32	Hyderabad	2500

现在让我们尝试使用**Merge**命令更新记录。以下是待更新记录的详细信息。

列名	值
ID	8
NAME	Loki
AGE	32
ADDRESS	Hyderabad
SALARY	3000

使用以下查询将给定的记录插入到H2数据库查询中。

MERGE INTO CUSTOMER KEY (ID) VALUES (8, 'Loki', 32, 'Hyderabad', 3000);

以上查询产生以下输出。

Update count: 1

让我们通过执行以下查询来验证Customer表的记录。

SELECT * FROM CUSTOMER;

以上查询产生以下输出：

ID	姓名	年龄	地址	薪水
1	Ramesh	32	Ahmedabad	2000
2	Khilan	25	Delhi	1500
3	Kaushik	23	Kota	2000
4	Chaitali	25	Mumbai	6500
5	Hardik	27	Bhopal	8500
6	Komal	22	MP	4500
7	Muffy	24	Indore	10000
8	Loki	32	Hyderabad	3000

H2 数据库 - 显示 (Show)

SHOW是一个用于显示表模式、表或列列表的命令。

语法

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

SHOW { SCHEMAS | TABLES [ FROM schemaName ] | 
COLUMNS FROM tableName [ FROM schemaName ] }

示例

可以使用以下命令获取当前数据库中的表列表。

SHOW TABLES;

以上命令产生以下输出。

表名	表模式
CUSTOMER	PUBLIC
EMP	PUBLIC

H2 数据库 - 创建 (Create)

CREATE是用于在H2数据库服务器中创建表、模式、序列、视图和用户的通用SQL命令。

创建表

Create Table是一个用于在当前数据库中创建用户定义表的命令。

语法

以下是Create Table命令的通用语法。

CREATE [ CACHED | MEMORY ] [ TEMP | [ GLOBAL | LOCAL ] TEMPORARY ] 
TABLE [ IF NOT EXISTS ] name 
[ ( { columnDefinition | constraint } [,...] ) ] 
[ ENGINE tableEngineName [ WITH tableEngineParamName [,...] ] ] 
[ NOT PERSISTENT ] [ TRANSACTIONAL ] 
[ AS select ]

使用Create Table命令的通用语法，我们可以创建不同类型的表，例如缓存表、内存表和临时表。以下是描述给定语法中不同子句的列表。

**CACHED** - 缓存表是常规表的默认类型。这意味着行的数量不受主内存限制。
**MEMORY** - 内存表是临时表的默认类型。这意味着内存表不应该太大，索引数据保存在主内存中。
**TEMPORARY** - 关闭或打开数据库时将删除临时表。基本上，临时表有两种类型：
- 全局类型 - 可被所有连接访问。
- 本地类型 - 可被当前连接访问。
临时表的默认类型是全局类型。除非使用CREATE CACHED TABLE创建临时表，否则临时表的索引保存在主内存中。
**ENGINE** - 只有在使用自定义表实现时才需要ENGINE选项。
**NOT PERSISTENT** - 这是一个修饰符，用于将完整的表数据保存在内存中，并且在关闭数据库时所有行都将丢失。
**TRANSACTIONAL** - 这是一个提交打开事务的关键字，此命令仅支持临时表。

示例

在这个例子中，让我们使用以下给定的数据创建一个名为tutorials_tbl的表。

序号	列名	数据类型
1	ID	Int
2	标题	Varchar(50)
3	作者	Varchar(20)
4	提交日期	日期

以下查询用于创建表**tutorials_tbl**以及给定的列数据。

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

以上查询产生以下输出。

(0) rows effected

创建模式

Create Schema是一个用于在特定授权下（在当前注册的用户下）创建用户依赖的模式的命令。

语法

以下是Create Schema命令的通用语法。

CREATE SCHEMA [ IF NOT EXISTS ] name [ AUTHORIZATION ownerUserName ]

在上述通用语法中，AUTHORIZATION是一个用于提供相应用户名关键字。此命令是可选的，这意味着如果我们没有提供用户名，则它将考虑当前用户。执行该命令的用户必须具有管理员权限以及所有者权限。

此命令会提交此连接中的打开事务。

示例

在这个例子中，让我们使用以下命令在SA用户下创建一个名为**test_schema**的模式。

CREATE SCHEMA test_schema AUTHORIZATION sa;

以上命令产生以下输出。

(0) rows effected

创建序列

序列是一个用于生成数字的概念，它遵循id或任何随机列值的序列。

语法

以下是create sequence命令的通用语法。

CREATE SEQUENCE [ IF NOT EXISTS ] newSequenceName [ START WITH long ] 
[ INCREMENT BY long ] 
[ MINVALUE long | NOMINVALUE | NO MINVALUE ] 
[ MAXVALUE long | NOMAXVALUE | NO MAXVALUE ] 
[ CYCLE long | NOCYCLE | NO CYCLE ] 
[ CACHE long | NOCACHE | NO CACHE ]

此通用语法用于创建一个序列。序列的数据类型为**BIGINT**。在此序列中，即使事务回滚，值也不会被重复使用。

示例

在这个例子中，让我们使用以下查询创建一个名为**SEQ_ID**的序列。

CREATE SEQUENCE SEQ_ID;

以上查询产生以下输出。

(0) rows effected

H2 数据库 - 修改 (Alter)

ALTER是一个用于通过向**alter**命令添加不同的子句来更改表结构的命令。根据场景，我们需要向alter命令添加相应的子句。在本章中，我们将讨论alter命令的各种场景。

Alter Table Add

Alter Table Add是一个用于向表添加新列以及相应数据类型的命令。此命令会提交此连接中的事务。

语法

以下是Alter Table Add命令的通用语法。

ALTER TABLE [ IF EXISTS ] tableName ADD [ COLUMN ] 
{ [ IF NOT EXISTS ] columnDefinition [ { BEFORE | AFTER } columnName ] 
   | ( { columnDefinition } [,...] ) }

示例

在这个例子中，我们将向表**tutorials_tbl**添加一个名为**start_date**的新列。start_date的数据类型为Date。以下是添加新列的查询。

ALTER TABLE tutorials_tbl ADD start_date DATE;

以上查询产生以下输出。

(6) rows effected

Alter Table Add Constraint

Alter table add constraint是一个用于向表添加不同约束的命令，例如主键、外键、not null等。

如果所需索引尚不存在，则会自动创建它们。无法禁用唯一约束检查。此命令会提交此连接中的打开事务。

语法

以下是Alter table add constraint命令的通用语法。

ALTER TABLE [ IF EXISTS ] tableName ADD constraint [ CHECK | NOCHECK ]

示例

在这个例子中，让我们使用以下查询向表**tutorials_tbl**的id列添加一个主键约束**(tutorials_tbl_pk)**。

ALTER TABLE tutorials_tbl ADD CONSTRAINT tutorials_tbl_pk PRIMARYKEY(id);

以上查询产生以下输出。

(6) row (s) effected

Alter Table Rename Constraint

此命令用于重命名特定关系表的约束名称。此命令会提交此连接中的打开事务。

语法

以下是Alter Table Rename Constraint命令的通用语法。

ALTER TABLE [ IF EXISTS ] tableName RENAME oldConstraintName TO newConstraintName

使用此语法时，请确保旧约束名称与相应的列一起存在。

示例

在这个例子中，我们将表**tutorials_tbl**的主键约束名称从**tutorials_tbl_pk**更改为**tutorials_tbl_pk_constraint**。以下是执行此操作的查询。

ALTER TABLE tutorials_tbl RENAME CONSTRAINT 
tutorials_tbl_pk TO tutorials_tbl_pk_constraint;

以上查询产生以下输出。

(1) row (s) effected

Alter Table Alter Column

此命令用于更改特定表的列的结构和属性。更改属性意味着更改列的数据类型、重命名列、更改标识值或更改选择性。

语法

以下是Alter Table Alter Column命令的通用语法。

ALTER TABLE [ IF EXISTS ] tableName ALTER COLUMN columnName 
{ { dataType [ DEFAULT expression ] [ [ NOT ] NULL ] [ AUTO_INCREMENT | IDENTITY ] } 
| { RENAME TO name } 
| { RESTART WITH long } 
| { SELECTIVITY int } 
| { SET DEFAULT expression } 
| { SET NULL } 
| { SET NOT NULL } }

在上述语法中：

**RESTART** - 命令更改自动递增列的下一个值。
**SELECTIVITY** - 命令设置列的选择性 (1-100)。根据选择性值，我们可以想象列的值。
**SET DEFAULT** - 更改列的默认值。
**SET NULL** - 设置列允许NULL。
**SET NOT NULL** - 设置列不允许NULL。

示例

在这个例子中，我们将使用以下查询将表**tutorials_tbl**的列名称从**Title**重命名为**Tutorial_Title**。

ALTER TABLE tutorials_tbl ALTER COLUMN title RENAME TO tutorial_title;

以上查询产生以下输出。

(0) row(s) effected

以类似的方式，我们可以使用ALTER命令执行不同的场景。

H2 数据库 - 删除 (Drop)

DROP是从通用SQL语法中提取的命令。此命令用于从内存中删除数据库组件及其结构。本章将讨论DROP命令的不同场景。

Drop Table

Drop Table是一个删除相应表及其结构的命令。

语法

以下是Drop Table命令的通用语法。

DROP TABLE [ IF EXISTS ] tableName [,...] [ RESTRICT | CASCADE ]

如果我们使用RESTRICT并且表存在依赖视图，则命令将失败。当我们使用CASCADE关键字时，所有依赖视图都将被删除。

示例

在这个例子中，我们将使用以下查询删除名为test的表。

DROP TABLE test;

以上查询产生以下输出。

(6) row (s) effected

Drop Schema

Drop Schema是一个从数据库服务器删除相应模式的命令。它不能从当前模式工作。

语法

DROP SCHEMA [ IF EXISTS ] schemaName

示例

在这个例子中，我们将使用以下查询删除名为**test_schema**的模式。

DROP SCHEMA TEST_SCHEMA;

以上查询产生以下输出。

(0) row(s) effected

Drop Sequence

Drop Sequence是一个用于从表结构中删除序列的命令。

语法

以下是Drop Sequence命令的通用语法。

DROP SEQUENCE [ IF EXISTS ] sequenceName

此命令会提交此连接中的打开事务。

示例

在这个例子中，我们将删除名为**sequence_id**的序列。以下是命令。

DROP SEQUENCE sequence_id;

以上命令产生以下输出。

(0) row (s) effected

Drop View

Drop View是一个用于删除现有视图的命令。如果使用CASCADE子句，所有依赖视图也将被删除。

语法

以下是Drop View命令的通用语法。

DROP VIEW [ IF EXISTS ] viewName [ RESTRICT | CASCADE ]

示例

在这个例子中，我们将使用以下查询删除名为**sample_view**的视图。

DROP VIEW sample_view;

以上查询产生以下输出。

(0) row (s) effected

H2 数据库 - 截断 (Truncate)

TRUNCATE是一个用于删除表中数据的命令。与不带WHERE子句的DELETE FROM不同，此命令无法回滚。此命令会提交此连接中的打开事务。

语法

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

TRUNCATE TABLE tableName

示例

在这个例子中，我们将使用以下查询截断名为**test**的表。

TRUNCATE TABLE test;

以上查询产生以下输出。

(6) row (s) effected

H2 数据库 - 提交 (Commit)

COMMIT是来自SQL语法的用于提交事务的命令。我们可以提交特定事务，也可以提交当前执行的事务。

语法

COMMIT命令有两种不同的语法。

以下是提交当前事务的commit命令的通用语法。

COMMIT [ WORK ]

以下是提交特定事务的commit命令的通用语法。

COMMIT TRANSACTION transactionName

示例1

在这个例子中，我们将使用以下命令提交当前事务。

COMMIT

以上命令产生以下输出。

Committed successfully

示例 2

在这个例子中，我们将使用以下命令提交名为tx_test的事务。

COMMIT TRANSACTION tx_test;

以上命令产生以下输出。

Committed successfully

H2 数据库 - 授权 (Grant)

Grant 是来自 SQL 语法的命令，用于授予用户或角色对表的权限。执行此命令需要管理员权限。此命令会提交此连接中的打开事务。

本章将讨论 Grant 命令的不同场景。

授予权限

Grant Right 命令用于向用户或角色授予对表的管理员权限。

语法

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

GRANT { SELECT | INSERT | UPDATE | DELETE | ALL } [,...] ON 
{ { SCHEMA schemaName } | { tableName [,...] } } 
TO { PUBLIC | userName | roleName }

示例

在这个例子中，我们将使用以下命令将 test 表授予只读权限。

GRANT SELECT ON TEST TO READONLY

以上命令产生以下输出。

Grant successfully

Grant Alter Any Schema

Grant Alter Any Schema 命令用于向相应用户授予更改模式的权限。

语法

以下是 Grant Alter Any Schema 命令的通用语法。

GRANT ALTER ANY SCHEMA TO userName

示例

在这个例子中，我们将向名为test_user的用户授予模式的更改权限。请确保 test_user 存在。以下是授予更改权限的查询。

GRANT ALTER ANY SCHEMA TO test_user;

以上查询产生以下输出。

Granted successfully to test_user

H2 数据库 - 保存点 (Savepoint)

SAVEPOINT 命令用于临时保存事务。最好在事务中维护保存点，因为这有助于在需要时将事务回滚到相应的保存点。

语法

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

SAVEPOINT savepointName

示例

在这个例子中，我们将使用以下命令创建一个名为 Half_Done 的保存点。

SAVEPOINT Half_Done;

以上命令产生以下输出。

Savepoint created

H2 数据库 - 回滚 (Rollback)

ROLLBACK 是来自 SQL 语法的命令，用于将事务回滚到保存点或上一个事务。使用此命令，我们可以回滚到特定的保存点，也可以回滚到之前执行的事务。

语法

ROLLABCK 命令有两种不同的语法。

以下是回滚命令的通用语法。

ROLLBACK [ TO SAVEPOINT savepointName ]

以下是将事务回滚到特定事务的通用语法。

ROLLBACK TRANSACTION transactionName

示例1

在这个例子中，我们将使用以下命令将当前事务回滚到名为sp1_test的保存点。

ROLLBACK sp1_test;

以上命令产生以下输出。

Rollback successfully

示例 2

在下面的例子中，我们将使用给定的命令回滚名为tx_test的完整事务。

ROLLBACK TRANSACTION tx_test;

以上命令产生以下输出。

Rollback successfully

H2 数据库 - JDBC 连接

H2 是一个 JAVA 数据库。我们可以使用 JDBC 与此数据库交互。本章将介绍如何使用 JDBC 连接 H2 数据库以及 H2 数据库的 CRUD 操作。

通常，创建 JDBC 连接需要五个步骤。

步骤 1 - 注册 JDBC 数据库驱动程序。

Class.forName ("org.h2.Driver");

步骤 2 - 打开连接。

Connection conn = DriverManager.getConnection ("jdbc:h2:~/test", "sa","");

步骤 3 - 创建语句。

Statement st = conn.createStatement();

步骤 4 - 执行语句并接收 Resultset。

Stmt.executeUpdate("sql statement");

步骤 5 - 关闭连接。

conn.close();

在继续创建完整程序之前，我们需要将h2-1.4.192.jar 文件添加到 CLASSPATH。我们可以从C:\Program Files (x86)\H2\bin文件夹中获取此jar文件。

创建表

在这个例子中，我们将编写一个创建表的程序。考虑一个名为Registration的表，它具有以下字段。

序号	列名	数据类型	非空	主键
1	ID	数字	是	是
2	名字	Varchar(255)	否	否
3	姓氏	Varchar(255)	否	否
4	年龄	数字	否	否

以下是一个名为H2jdbcCreateDemo的示例程序。

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

public class H2jdbcCreateDemo { 
   // JDBC driver name and database URL 
   static final String JDBC_DRIVER = "org.h2.Driver";   
   static final String DB_URL = "jdbc:h2:~/test";  
   
   //  Database credentials 
   static final String USER = "sa"; 
   static final String PASS = ""; 
  
   public static void main(String[] args) { 
      Connection conn = null; 
      Statement stmt = null; 
      try { 
         // STEP 1: Register JDBC driver 
         Class.forName(JDBC_DRIVER); 
             
         //STEP 2: Open a connection 
         System.out.println("Connecting to database..."); 
         conn = DriverManager.getConnection(DB_URL,USER,PASS);  
         
         //STEP 3: Execute a query 
         System.out.println("Creating table in given database..."); 
         stmt = conn.createStatement(); 
         String sql =  "CREATE TABLE   REGISTRATION " + 
            "(id INTEGER not NULL, " + 
            " first VARCHAR(255), " +  
            " last VARCHAR(255), " +  
            " age INTEGER, " +  
            " PRIMARY KEY ( id ))";  
         stmt.executeUpdate(sql);
         System.out.println("Created table in given database..."); 
         
         // STEP 4: Clean-up environment 
         stmt.close(); 
         conn.close(); 
      } catch(SQLException se) { 
         //Handle errors for JDBC 
         se.printStackTrace(); 
      } catch(Exception e) { 
         //Handle errors for Class.forName 
         e.printStackTrace(); 
      } finally { 
         //finally block used to close resources 
         try{ 
            if(stmt!=null) stmt.close(); 
         } catch(SQLException se2) { 
         } // nothing we can do 
         try { 
            if(conn!=null) conn.close(); 
         } catch(SQLException se){ 
            se.printStackTrace(); 
         } //end finally try 
      } //end try 
      System.out.println("Goodbye!");
   } 
}

将上述程序保存到 H2jdbcCreateDemo.java 中。通过在命令提示符中执行以下命令来编译和执行上述程序。

\>javac H2jdbcCreateDemo.java 
\>java H2jdbcCreateDemo

以上命令产生以下输出。

Connecting to database... 
Creating table in given database... 
Created table in given database... 
Goodbye!

执行此操作后，我们可以使用 H2 SQL 界面检查创建的表。

插入记录

在这个例子中，我们将编写一个插入记录的程序。让我们将以下记录插入到 Registration 表中。

ID	名字	姓氏	年龄
100	Zara	Ali	18
101	Mahnaz	Fatma	25
102	Zaid	Khan	30
103	Sumit	Mital	28

以下是一个名为H2jdbcInsertDemo的示例程序。

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

public class H2jdbcInsertDemo { 
   // JDBC driver name and database URL 
   static final String JDBC_DRIVER = "org.h2.Driver";   
   static final String DB_URL = "jdbc:h2:~/test";  
   
   //  Database credentials 
   static final String USER = "sa"; 
   static final String PASS = ""; 
  
   public static void main(String[] args) { 
      Connection conn = null; 
      Statement stmt = null; 
      try{
         // STEP 1: Register JDBC driver 
         Class.forName(JDBC_DRIVER);  
         
         // STEP 2: Open a connection 
         System.out.println("Connecting to a selected database..."); 
         conn = DriverManager.getConnection(DB_URL,USER,PASS); 
         System.out.println("Connected database successfully..."); 
         
         // STEP 3: Execute a query 
         stmt = conn.createStatement();  
         String sql = "INSERT INTO Registration " + "VALUES (100, 'Zara', 'Ali', 18)"; 
         
         stmt.executeUpdate(sql); 
         sql = "INSERT INTO Registration " + "VALUES (101, 'Mahnaz', 'Fatma', 25)";  
         
         stmt.executeUpdate(sql); 
         sql = "INSERT INTO Registration " + "VALUES (102, 'Zaid', 'Khan', 30)"; 
         
         stmt.executeUpdate(sql); 
         sql = "INSERT INTO Registration " + "VALUES(103, 'Sumit', 'Mittal', 28)"; 
         
         stmt.executeUpdate(sql); 
         System.out.println("Inserted records into the table..."); 
         
         // STEP 4: Clean-up environment 
         stmt.close(); 
         conn.close(); 
      } catch(SQLException se) { 
         // Handle errors for JDBC 
         se.printStackTrace(); 
      } catch(Exception e) { 
         // Handle errors for Class.forName 
         e.printStackTrace(); 
      } finally { 
         // finally block used to close resources 
         try {
            if(stmt!=null) stmt.close();  
         } catch(SQLException se2) { 
         } // nothing we can do 
         try { 
            if(conn!=null) conn.close(); 
         } catch(SQLException se) { 
            se.printStackTrace(); 
         } // end finally try 
      } // end try 
      System.out.println("Goodbye!"); 
   } 
}

将上述程序保存到 H2jdbcInsertDemo.java 中。通过在命令提示符中执行以下命令来编译和执行上述程序。

\>javac H2jdbcInsertDemo.java 
\>java H2jdbcInsertDemo

以上命令产生以下输出。

Connecting to a selected database... 
Connected database successfully... 
Inserted records into the table... 
Goodbye!

读取记录

在这个例子中，我们将编写一个读取记录的程序。让我们尝试从Registration表中读取所有记录。

以下是一个名为H2jdbcRecordDemo的示例程序。

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

public class H2jdbcReadDemo { 
   // JDBC driver name and database URL 
   static final String JDBC_DRIVER = "org.h2.Driver";   
   static final String DB_URL = "jdbc:h2:~/test";  
   
   //  Database credentials 
   static final String USER = "sa"; 
   static final String PASS = ""; 
   
   public static void main(String[] args) { 
      Connection conn = null; 
      Statement stmt = null; 
      try { 
         // STEP 1: Register JDBC driver 
         Class.forName(JDBC_DRIVER); 
         
         // STEP 2: Open a connection 
         System.out.println("Connecting to database..."); 
         conn = DriverManager.getConnection(DB_URL,USER,PASS);  
         
         // STEP 3: Execute a query 
         System.out.println("Connected database successfully..."); 
         stmt = conn.createStatement(); 
         String sql = "SELECT id, first, last, age FROM Registration"; 
         ResultSet rs = stmt.executeQuery(sql); 
         
         // STEP 4: Extract data from result set 
         while(rs.next()) { 
            // Retrieve by column name 
            int id  = rs.getInt("id"); 
            int age = rs.getInt("age"); 
            String first = rs.getString("first"); 
            String last = rs.getString("last");  
            
            // Display values 
            System.out.print("ID: " + id); 
            System.out.print(", Age: " + age); 
            System.out.print(", First: " + first); 
            System.out.println(", Last: " + last); 
         } 
         // STEP 5: Clean-up environment 
         rs.close(); 
      } catch(SQLException se) { 
         // Handle errors for JDBC 
         se.printStackTrace(); 
      } catch(Exception e) { 
         // Handle errors for Class.forName 
         e.printStackTrace(); 
      } finally { 
         // finally block used to close resources 
         try { 
            if(stmt!=null) stmt.close();  
         } catch(SQLException se2) { 
         } // nothing we can do 
         try { 
            if(conn!=null) conn.close(); 
         } catch(SQLException se) { 
            se.printStackTrace(); 
         } // end finally try 
      } // end try 
      System.out.println("Goodbye!"); 
   } 
}

将上述程序保存到 H2jdbcReadDemo.java 中。通过在命令提示符中执行以下命令来编译和执行上述程序。

\>javac H2jdbcReadDemo.java 
\>java H2jdbcReadDemo

以上命令产生以下输出。

Connecting to a selected database... 
Connected database successfully... 
ID: 100, Age: 18, First: Zara, Last: Ali 
ID: 101, Age: 25, First: Mahnaz, Last: Fatma 
ID: 102, Age: 30, First: Zaid, Last: Khan 
ID: 103, Age: 28, First: Sumit, Last: Mittal 
Goodbye!

更新记录

在这个例子中，我们将编写一个更新记录的程序。让我们尝试从Registration表中读取所有记录。

以下是一个名为H2jdbcUpdateDemo的示例程序。

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

public class H2jdbcUpdateDemo { 
   // JDBC driver name and database URL 
   static final String JDBC_DRIVER = "org.h2.Driver";   
   static final String DB_URL = "jdbc:h2:~/test";  
   
   // Database credentials 
   static final String USER = "sa"; 
   static final String PASS = ""; 
   
   public static void main(String[] args) { 
      Connection conn = null; 
      Statement stmt = null; 
      try { 
         // STEP 1: Register JDBC driver 
         Class.forName(JDBC_DRIVER); 
         
         // STEP 2: Open a connection 
         System.out.println("Connecting to a database..."); 
         conn = DriverManager.getConnection(DB_URL,USER,PASS);  
         
         // STEP 3: Execute a query 
         System.out.println("Connected database successfully..."); 
         stmt = conn.createStatement(); 
         String sql = "UPDATE Registration " + "SET age = 30 WHERE id in (100, 101)"; 
         stmt.executeUpdate(sql);  
         
         // Now you can extract all the records 
         // to see the updated records 
         sql = "SELECT id, first, last, age FROM Registration"; 
         ResultSet rs = stmt.executeQuery(sql);  
         
         while(rs.next()){ 
            // Retrieve by column name 
            int id  = rs.getInt("id"); 
            int age = rs.getInt("age"); 
            String first = rs.getString("first"); 
            String last = rs.getString("last");  
            
            // Display values 
            System.out.print("ID: " + id); 
            System.out.print(", Age: " + age); 
            System.out.print(", First: " + first); 
            System.out.println(", Last: " + last); 
         } 
         rs.close();    
      } catch(SQLException se) { 
         // Handle errors for JDBC 
         se.printStackTrace(); 
      } catch(Exception e) { 
         // Handle errors for Class.forName 
         e.printStackTrace(); 
      } finally { 
         // finally block used to close resources  
         try { 
            if(stmt!=null) stmt.close(); 
         } catch(SQLException se2) { 
         } // nothing we can do 
         try { 
            if(conn!=null) conn.close(); 
         } catch(SQLException se) { 
            se.printStackTrace(); 
         } // end finally try 
      } // end try 
      System.out.println("Goodbye!"); 
   } 
}

将上述程序保存到 H2jdbcUpdateDemo.java 中。通过在命令提示符中执行以下命令来编译和执行上述程序。

\>javac H2jdbcUpdateDemo.java 
\>java H2jdbcUpdateDemo

以上命令产生以下输出。

Connecting to a selected database... 
Connected database successfully... 
ID: 100, Age: 30, First: Zara, Last: Ali 
ID: 101, Age: 30, First: Mahnaz, Last: Fatma 
ID: 102, Age: 30, First: Zaid, Last: Khan 
ID: 103, Age: 28, First: Sumit, Last: Mittal 
Goodbye!

删除记录

在这个例子中，我们将编写一个删除记录的程序。让我们尝试从Registration表中读取所有记录。

以下是一个名为H2jdbcDeleteDemo的示例程序。

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

public class H2jdbcDeleteDemo { 
   // JDBC driver name and database URL 
   static final String JDBC_DRIVER = "org.h2.Driver";   
   static final String DB_URL = "jdbc:h2:~/test";  
   
   // Database credentials 
   static final String USER = "sa"; 
   static final String PASS = ""; 
  
   public static void main(String[] args) { 
      Connection conn = null; 
      Statement stmt = null; 
      try { 
         // STEP 1: Register JDBC driver 
         Class.forName(JDBC_DRIVER);  
         
         // STEP 2: Open a connection 
         System.out.println("Connecting to database..."); 
         conn = DriverManager.getConnection(DB_URL,USER,PASS);  
         
         // STEP 3: Execute a query
         System.out.println("Creating table in given database..."); 
         stmt = conn.createStatement();  
         String sql = "DELETE FROM Registration " + "WHERE id = 101"; 
         stmt.executeUpdate(sql);  
         
         // Now you can extract all the records 
         // to see the remaining records 
         sql = "SELECT id, first, last, age FROM Registration"; 
         ResultSet rs = stmt.executeQuery(sql);  
         
         while(rs.next()){ 
            // Retrieve by column name 
            int id  = rs.getInt("id"); 
            int age = rs.getInt("age"); 
            String first = rs.getString("first"); 
            String last = rs.getString("last");  
            
            // Display values 
            System.out.print("ID: " + id); 
            System.out.print(", Age: " + age); 
            System.out.print(", First: " + first); 
            System.out.println(", Last: " + last); 
         } 
         rs.close(); 
      } catch(SQLException se) { 
         // Handle errors for JDBC 
         se.printStackTrace();  
      } catch(Exception e) { 
         // Handle errors for Class.forName 
         e.printStackTrace(); 
      } finally { 
         // finally block used to close resources 
         try { 
            if(stmt!=null) stmt.close(); 
         } catch(SQLException se2) { 
         } // nothing we can do 
         try { 
            if(conn!=null) conn.close(); 
         } catch(SQLException se) { 
            se.printStackTrace(); 
         } // end finally try
      } // end try 
      System.out.println("Goodbye!"); 
   } 
}

将上述程序保存到 H2jdbcDeleteDemo.java 中。通过在命令提示符中执行以下命令来编译和执行上述程序。

\>javac H2jdbcDeleteDemo.java 
\>java H2jdbcDeleteDemo

以上命令产生以下输出。

Connecting to a selected database... 
Connected database successfully... 
ID: 100, Age: 30, First: Zara, Last: Ali 
ID: 102, Age: 30, First: Zaid, Last: Khan 
ID: 103, Age: 28, First: Sumit, Last: Mittal 
Goodbye!

打印页面