H2 数据库 - 快速指南

H2 数据库 - 简介

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

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

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

H2数据库的特点

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

  • 它是一个非常快的数据库引擎。

  • H2 是开源的，用 Java 编写。

  • 它支持标准 SQL 和 JDBC API。它也可以使用 PostgreSQL ODBC 驱动程序。

  • 它有嵌入式和服务器模式。

  • H2支持集群和多版本并发。

  • 它具有很强的安全功能。

附加功能

以下是 H2 数据库的一些附加功能 -

  • H2是基于磁盘或内存中的数据库和表，支持只读数据库、临时表。

  • H2 提供事务支持（读已提交）、两阶段提交多个连接、表级锁定。

  • H2是一个基于成本的优化器，使用遗传算法进行复杂查询，零管理。

  • H2包含可滚动和可更新的结果集支持，大结果集，外部结果排序，函数可以返回结果集。

  • H2支持加密数据库（AES）、SHA-256密码加密、加密函数和SSL。

H2数据库中的组件

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

  • 网络浏览器
  • 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 Installer 类型（即 .exe 文件），第二种是适用于其他操作系统的平台无关 zip 文件。

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

第2步：安装H2数据库

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

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

安装H2数据库

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

目的地

在上面的屏幕截图中，单击“安装”按钮开始安装过程。安装完成后，我们得到如下截图。

安装按钮

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

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

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

数据库安装

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

弹出数据库欢迎页面，如下图所示。

弹出窗口

H2 数据库 - 选择

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 数据库 - 插入

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

句法

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

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

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

例子

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

ID 姓名 年龄 地址 薪水
1 拉梅什 32 艾哈迈达巴德 2000年
2 基兰 25 德里 1500
3 考希克 23 科塔 2000年
4 柴泰尔 25 孟买 6500
5 哈迪克 27 博帕尔 8500
6 科马尔 22 国会议员 4500
7 莫菲 24 印多尔 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 查询用于更新或修改表中的现有记录。我们可以使用 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 的客户的地址 -

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 数据库 - 删除

SQL DELETE 查询用于从表中删除现有记录。我们可以将 WHERE 子句与 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 TO fileNameString;

例子

在此示例中，让我们将当前数据库备份到backup.zip文件中。使用以下命令进行相同的操作。

BACKUP TO 'backup.zip';

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

H2 数据库 - 调用

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

句法

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

CALL expression;

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

例子

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

CALL 15*25;

上述命令产生以下输出。

第375章
第375章

H2 数据库 - 解释

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

句法

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

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

除了这个语法之外，我们还可以使用选择、插入、删除和合并。

例子

此示例说明 ID 为 1 的客户的查询计划详细信息。

EXPLAIN SELECT * FROM CUSTOMER WHERE ID = 1;

上面的命令产生以下输出 -

解释输出

H2 数据库 - 合并

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

句法

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

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

在上面的语法中，KEY 子句用于指定主键列名称。与 VALUES 子句一起，我们可以使用原始值来插入，或者我们可以使用 select 命令检索另一个表值并将其存储到该表中。

例子

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

列名称 价值
ID 8
姓名 洛克什
年龄 32
地址 海得拉巴
薪水 2500

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

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

上述查询产生以下输出。

Update count: 1

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

SELECT * FROM CUSTOMER;

上述查询产生以下输出。

ID 姓名 年龄 地址 薪水
1 拉梅什 32 艾哈迈达巴德 2000年
2 基兰 25 德里 1500
3 考希克 23 科塔 2000年
4 柴塔利 25 孟买 6500
5 哈迪克 27 博帕尔 8500
6 科马尔 22 国会议员 4500
7 莫菲 24 印多尔 10000
8 洛克什 32 海得拉巴 2500

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

列名称 价值
ID 8
姓名 洛基
年龄 32
地址 海得拉巴
薪水 3000

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

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

上述查询产生以下输出。

Update count: 1

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

SELECT * FROM CUSTOMER;

上述查询产生以下输出 -

ID 姓名 年龄 地址 薪水
1 拉梅什 32 艾哈迈达巴德 2000年
2 基兰 25 德里 1500
3 考希克 23 科塔 2000年
4 柴塔利 25 孟买 6500
5 哈迪克 27 博帕尔 8500
6 科马尔 22 国会议员 4500
7 莫菲 24 印多尔 10000
8 洛基 32 海得拉巴 3000

H2 数据库 - 显示

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

句法

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

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

例子

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

SHOW TABLES;

上述命令产生以下输出。

表名 TABLE_SCHEMA
顾客 民众
电磁脉冲 民众

H2 数据库 - 创建

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

创建表

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 - 关闭或打开数据库时删除临时表。基本上，临时表有两种类型 -

    • GLOBAL 类型 - 所有连接均可访问。

    • LOCAL 类型 - 当前连接可访问。

    临时表的默认类型是全局类型。临时表的索引保存在主内存中，除非临时表是使用 CREATE CACHED TABLE 创建的。

  • ENGINE - 仅当使用自定义表实现时才需要 ENGINE 选项。

  • NOT PERSISTENT - 它是一个修饰符，用于将完整的表数据保留在内存中，并且当数据库关闭时所有行都会丢失。

  • TRANSACTIONAL - 这是提交打开事务的关键字，此命令仅支持临时表。

例子

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

先生编号 列名称 数据类型
1 ID INT
2 标题 varchar(50)
3 作者 可变字符型(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 [ IF NOT EXISTS ] name [ AUTHORIZATION ownerUserName ]

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

该命令在此连接中提交一个打开的事务。

例子

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

CREATE SCHEMA test_schema AUTHORIZATION sa;

上述命令产生以下输出。

(0) rows effected

创建序列

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

句法

以下是创建序列命令的通用语法。

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 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 的数据类型是日期。以下是添加新列的查询。

ALTER TABLE tutorials_tbl ADD start_date DATE;

上述查询产生以下输出。

(6) rows effected

修改表添加约束

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

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

句法

以下是 Alter table 添加约束命令的通用语法。

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

例子

在此示例中，让我们使用以下查询将主键约束(tutorials_tbl_pk)添加到表tutorials_tbl的列 id。

ALTER TABLE tutorials_tbl ADD CONSTRAINT tutorials_tbl_pk PRIMARYKEY(id);

上述查询产生以下输出。

(6) row (s) effected

更改表重命名约束

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

句法

以下是更改表重命名约束命令的通用语法。

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 [ 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 - 将列设置为允许 NOT NULL。

例子

在此示例中，我们将使用以下查询将表tutorials_tbl的列从Title重命名为Tutorial_Title 。

ALTER TABLE tutorials_tbl ALTER COLUMN title RENAME TO tutorial_title;

上述查询产生以下输出。

(0) row(s) effected

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

H2 数据库 - 掉落

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

掉落表

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

句法

以下是删除表命令的通用语法。

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

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

例子

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

DROP TABLE test;

上述查询产生以下输出。

(6) row (s) effected

删除架构

删除架构是从数据库服务器删除相应架构的命令。它在当前模式下不起作用。

句法

DROP SCHEMA [ IF EXISTS ] schemaName

例子

在此示例中，我们将使用以下查询删除名为test_schema的模式。

DROP SCHEMA TEST_SCHEMA;

上述查询产生以下输出。

(0) row(s) effected

掉落顺序

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

句法

以下是“删除序列”命令的通用语法。

DROP SEQUENCE [ IF EXISTS ] sequenceName

该命令在此连接中提交一个打开的事务。

例子

在此示例中，我们将删除一个名为sequence_id的序列。以下是命令。

DROP SEQUENCE sequence_id;

上述命令产生以下输出。

(0) row (s) effected

下拉视图

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

句法

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

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

例子

在此示例中，我们将使用以下查询删除名为example_view的视图。

DROP VIEW sample_view;

上述查询产生以下输出。

(0) row (s) effected

H2 数据库 - 截断

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

句法

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

TRUNCATE TABLE tableName

例子

在此示例中，我们将使用以下查询截断名为test的表。

TRUNCATE TABLE test;

上述查询产生以下输出。

(6) row (s) effected

H2 数据库 - 提交

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

句法

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

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

COMMIT [ WORK ]

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

COMMIT TRANSACTION transactionName

实施例1

在此示例中，让我们使用以下命令提交当前事务。

COMMIT

上述命令产生以下输出。

Committed successfully

实施例2

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

COMMIT TRANSACTION tx_test;

上述命令产生以下输出。

Committed successfully

H2 数据库 - 格兰特

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

在本章中，我们将讨论 Grant 命令的不同场景。

授予权利

Grant Right 是一个向表、用户或角色提供管理权限的命令。

句法

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

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

例子

在此示例中，我们将使用以下命令将测试表授予只读权限。

GRANT SELECT ON TEST TO READONLY

上述命令产生以下输出。

Grant successfully

授予更改任何架构

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 savepointName

例子

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

SAVEPOINT Half_Done;

上述命令产生以下输出。

Savepoint created

H2数据库-回滚

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

句法

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

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

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 与该数据库进行交互。在本章中，我们将看到如何创建与H2数据库的JDBC连接以及如何与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 - 执行语句并接收结果集。

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 扎拉 阿里 18
101 马赫纳兹 法特玛 25
102 扎伊德 汗 30
103 苏米特 米塔尔 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!