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 Runtime Environment上运行它。但是，在安装数据库之前，应在系统中安装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，则访问下面的Install JDK链接。
安装H2数据库
我们可以在许多不同的平台上运行此数据库。在本章中，我们将学习在Windows上安装H2数据库的知识。
以下是在Windows操作系统上安装H2数据库的步骤。
步骤1：下载H2设定档
从给定的链接下载最新版本的H2数据库。在此链接中，您将获得两种类型的H2数据库的最新版本。一种是Windows Installer类型（即.exe文件），另一种是其他操作系统的与平台无关的zip文件。
下载.exe文件后，单击Windows安装程序以下载Windows支持的H2数据库。在这种情况下，我们将使用H2数据库的1.4.192版本。
步骤2：安装H2数据库
下载后，我们在下载目录中获得了H2 Windows安装程序文件（即h2-setup-yyyy-mm-dd.exe）。要开始H2数据库的安装过程，请双击安装程序文件。
以下屏幕是安装过程的第一步。提供一个我们要在其中安装H2数据库服务器的路径，如以下屏幕快照所示。
如上面的屏幕截图所示，默认情况下它将以C：\ ProgramFiles（x86）\ H2作为目标文件夹。单击下一步继续进行下一步。弹出以下屏幕。
在上面的屏幕截图中，单击“安装”按钮以开始安装过程。安装后，我们得到以下屏幕截图。
单击完成以完成安装过程。
步骤3：验证H2数据库安装
安装后，让我们验证系统中的数据库安装。单击Windows→键入H2控制台→单击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，名称和薪水字段。
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 |
MP |
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的客户更新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数据库-删除
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是属于H2数据库服务器的SQL命令。此命令用于计算简单表达式。它在单个列字段中返回给定表达式的结果。当它返回结果数组时，该数组中的每个元素都显示为列值。
句法
以下是CALL命令的通用语法。
CALL expression;
我们可以在这种语法中使用算术表达式。
例
让我们举个例子，并使用调用命令执行算术表达式（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命令将另一个表值检索并存储到该表中。
例
在此示例中，让我们尝试将新记录添加到“客户”表中。以下是表中新记录的详细信息。
| 栏名 |
值 |
| 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 |
Chaitali |
25 |
孟买 |
6500 |
| 5 |
哈迪克 |
27 |
博帕尔 |
8500 |
| 6 |
科马尔 |
22 |
MP |
4500 |
| 7 |
玛菲 |
24 |
印多尔 |
10000 |
| 8 |
洛克希 |
32 |
海得拉巴 |
2500 |
现在让我们尝试使用Merge命令更新记录。以下是要更新的记录的详细信息。
| 栏名 |
值 |
| 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 |
Chaitali |
25 |
孟买 |
6500 |
| 5 |
哈迪克 |
27 |
博帕尔 |
8500 |
| 6 |
科马尔 |
22 |
MP |
4500 |
| 7 |
玛菲 |
24 |
印多尔 |
10000 |
| 8 |
洛基 |
32 |
海得拉巴 |
3000 |
H2数据库-显示
SHOW是用于显示表的架构，表或列的列表的命令。
句法
以下是SHOW命令的通用语法。
SHOW { SCHEMAS | TABLES [ FROM schemaName ] |
COLUMNS FROM tableName [ FROM schemaName ] }
例
以下命令可用于获取当前数据库中的表列表。
SHOW TABLES;
上面的命令产生以下输出。
| TABLE_NAME |
TABLE_SCHEMA |
| 顾客 |
上市 |
| 电磁脉冲 |
上市 |
H2数据库-创建
CREATE是一个通用的SQL命令，用于在H2数据库服务器中创建表，模式，序列，视图和用户。
建立表格
创建表是用于在当前数据库中创建用户定义表的命令。
句法
以下是“创建表”命令的通用语法。
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 -缓存表是常规表的默认类型。这意味着行数不受主存储器的限制。
- 内存-内存表是临时表的默认类型。这意味着内存表不应太大，索引数据将保留在主内存中。
-
TEMPORARY-在关闭或打开数据库时删除临时表。基本上，临时表有两种类型-
- 全局类型-所有连接均可访问。
- 本地类型-当前连接可访问。
临时表的默认类型是全局类型。临时表的索引保留在主内存中，除非使用CREATE CACHED TABLE创建临时表。
- ENGINE-仅当使用自定义表实现时才需要ENGINE选项。
- NOT PERSISTENT-这是一个修饰符，用于将完整的表数据保留在内存中，并且在关闭数据库时所有行都会丢失。
- TRANSACTIONAL-这是一个提交开放事务的关键字，此命令仅支持临时表。
例
在此示例中，让我们使用以下给定数据创建一个名为tutorials_tbl的表。
| 序号 |
栏名 |
数据类型 |
| 1个 |
ID |
整数 |
| 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 [ 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 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
更改表添加约束
更改表添加约束是用于向表添加不同约束的命令，例如主键，外键，非null等。
如果所需的索引尚不存在，则会自动创建它们。无法禁用唯一约束检查。该命令在此连接中提交一个打开的事务。
句法
以下是“更改表添加约束”命令的通用语法。
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
放下视图
删除视图是用于删除现有视图的命令。如果使用CASCADE子句，所有从属视图也将被删除。
句法
以下是Drop View命令的通用语法。
DROP VIEW [ IF EXISTS ] viewName [ RESTRICT | CASCADE ]
例
在此示例中，我们将使用以下查询删除名为sample_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命令提交当前事务的通用语法。
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命令的通用语法。
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 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语法中的命令，用于将事务回滚到Savepoint或上一个事务。通过使用此命令，我们可以回滚到特定的保存点，也可以回滚到先前执行的事务。
句法
ROLLABCK命令有两种不同的语法。
以下是rollback命令的通用语法。
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 |
第一 |
瓦尔查（255） |
没有 |
没有 |
| 3 |
持续 |
瓦尔查（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!