H2 Database 简明教程
H2 Database - Introduction
H2 是一个开源轻型 Java 数据库。它可以嵌入在 Java 应用程序中,或在客户端-服务器模式下运行。H2 数据库主要可以配置为内存数据库运行,这意味着数据不会保存在磁盘上。由于是嵌入式数据库,因此它不会用于生产开发,而是主要用于开发和测试。
此数据库可以在嵌入模式或服务器模式下使用。以下是 H2 数据库的主要功能 -
-
极其快速,开源,JDBC API
-
嵌入式和服务器模式可用;内存数据库
-
Browser-based Console application
-
占用空间少 - 大约 1.5MB 的 jar 文件大小
Features of H2 Database
H2 数据库的主要功能如下 -
-
它是一个极其快速的数据库引擎。
-
H2 是开源的,使用 Java 编写。
-
它支持标准 SQL 和 JDBC API。它也可以使用 PostgreSQL ODBC 驱动程序。
-
它有嵌入式和服务器模式。
-
H2 支持 clustering 和 multi-version concurrency 。
-
它具有强大的安全功能。
H2 Database - Installation
H2 是用 Java 编写的数据库。我们可以使用 JDBC 轻松地将该数据库嵌入到应用程序中。我们可以在许多不同的平台或任何版本的 Java 运行时环境中运行它。但是,在安装数据库之前,应该在系统中安装 Java。
Verify Java Installation
如果在系统中安装了 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 。
Install H2 Database
我们可以在许多不同的平台上运行该数据库。在本章中,我们将了解 H2 数据库在 Windows 上的安装方法。
以下是 Windows 操作系统下安装 H2 数据库的步骤。
Step 1: Download H2 Setup File
从提供的链接下载最新版本的 H2 Database 。在该链接中,您将获得以两种类型提供的 H2 数据库的最新版本。一种是 Windows Installer 类型(即 .exe 文件),另一种是适用于其他操作系统的平台无关的 zip 文件。
下载 .exe 文件后,单击 Windows 安装程序以下载 Windows 支持的 H2 数据库。在此案例中,我们将使用带有版本 1.4.192 的 H2 数据库。
Step 2: Install H2 Database
下载后,我们在“下载”目录中获取 H2 Windows 安装程序文件(即 h2-setup-yyyy-mm-dd.exe)。要启动 H2 数据库的安装过程,请双击安装程序文件。
以下屏幕是安装过程的第一步。提供一个位置,以便像以下屏幕截图所示的那样安装 H2 数据库服务器。
如以上屏幕截图所示,默认情况下它会将 C:\ProgramFiles (x86)\H2 作为目标文件夹。单击下一步继续执行下一步。然后会弹出以下屏幕。
在以上屏幕截图中,单击“安装”按钮以启动安装过程。安装后,我们会看到以下屏幕截图。
单击“完成”以完成安装过程。
Step 3: Verify H2 Database Installation
安装后,让我们验证系统中的数据库安装。单击 Windows → 键入 H2 控制台 → 单击 H2 控制台图标。连接到 URL http://localhost:8082 。在连接时,H2 数据库将要求进行数据库注册,如下面的屏幕截图所示。
在上述对话框中填写所有详细信息,例如已保存设置、设置名称、驱动程序类、JDBC URL、用户名以及密码。在 JDBC URL 中,指定数据库的位置和数据库名称。用户名和密码是数据库用户名和密码的字段。单击“连接”。
由此数据库欢迎页面会弹出,如下所示。
H2 Database - Select
选择命令用于从一个或多个表中获取记录数据。如果我们设计了一个选择查询,它将以 result sets 称为结果表的形式返回数据。
Syntax
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;
Example
考虑 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 |
+----+----------+-----+-----------+----------+
要获取 CUSTOMER 表中已给出的数据,执行以下查询。
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 Database - Insert
SQL INSERT 语句用于将新行的数据添加到数据库中的表。
Syntax
以下是 INSERT INTO 语句的基本语法。
INSERT INTO tableName
{ [ ( columnName [,...] ) ]
{ VALUES
{ ( { DEFAULT | expression } [,...] ) } [,...] | [ DIRECT ] [ SORTED ] select } } |
{ SET { columnName = { DEFAULT | expression } } [,...] }
使用这个 INSERT 语句,我们可以往表中插入一条新记录或多行新记录。当使用 DIRECT 子句时,结果会直接影响目标表,没有任何中间步骤。然而,在为表的所有列添加值的同时,确保值的顺序与表中的列相同。
Example
我们举一个例子,并尝试将以下给定的记录插入到 Customer 表中。
ID |
Name |
Age |
Address |
Salary |
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 |
我们可以通过执行以下命令将所有给定的记录放入 customer 表中。
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 Database - Update
UPDATE 查询用于更新或修改表中的现有记录。我们可以将 WHERE 子句和 UPDATE 查询结合在一起,用于更新选定的行,否则所有行都会受到影响。
Syntax
以下是 UPDATE 查询的基本语法。
UPDATE tableName [ [ AS ] newTableAlias ] SET
{ { columnName = { DEFAULT | expression } } [,...] } |
{ ( columnName [,...] ) = ( select ) }
[ WHERE expression ] [ ORDER BY order [,...] ] [ LIMIT expression ]
在这个 UPDATE 语法中,我们可以通过使用 AND 或 OR 子句组合超过一个条件。
Example
考虑具有以下记录的 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 Database - Delete
SQL DELETE 查询用于从表中删除现有记录。我们可以对 DELETE 查询使用 WHERE 子句来删除选定的记录,否则将删除所有记录。
Syntax
以下是 delete 命令的通用查询语法。
DELETE [ TOP term ] FROM tableName [ WHERE expression ] [ LIMIT term ]
以上语法从表中删除行。如果指定了 TOP 或 LIMIT,则最多删除指定数量的行(如果为 null 或小于零,则无限制)。
Example
考虑具有以下记录的 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 表中 DELETE 所有记录,则不使用 WHERE 子句。DELETE 查询如下。
DELETE FROM CUSTOMER;
执行以上命令后,Customer 表中将没有任何记录。
H2 Database - Explain
H2 Database - Merge
MERGE 命令用于更新现有行和将新行插入表中。主键列在此命令的使用过程中发挥着重要作用;它用于查找行。
Syntax
以下是 MERGE 命令的通用语法。
MERGE INTO tableName [ ( columnName [,...] ) ]
[ KEY ( columnName [,...] ) ]
{ VALUES { ( { DEFAULT | expression } [,...] ) } [,...] | select }
在上面的语法中,KEY 子句用于指定主键列名。除了 VALUES 子句,我们可以使用基元值插入或使用 select 命令检索另一个表中的值并将其存储到此表中。
Example
在此示例中,我们尝试向 Customers 表中添加一条新记录。以下是表中新记录的详细信息。
Column Name |
Value |
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
通过执行以下查询来验证 Customers 表中的记录。
SELECT * FROM CUSTOMER;
以上查询将产生以下输出。
ID |
Name |
Age |
Address |
Salary |
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 命令更新记录。以下是将要更新的记录的详细信息。
Column Name |
Value |
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
通过执行以下查询来验证 Customers 表中的记录。
SELECT * FROM CUSTOMER;
上面的查询生成以下输出 −
ID |
Name |
Age |
Address |
Salary |
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 Database - Create
CREATE 是用于在 H2 数据库服务器中创建表、模式、序列、视图和用户的通用 SQL 命令。
Create Table
创建表是用于在当前数据库中创建用户自定义表的命令。
Syntax
以下是创建表命令的通用语法。
CREATE [ CACHED | MEMORY ] [ TEMP | [ GLOBAL | LOCAL ] TEMPORARY ]
TABLE [ IF NOT EXISTS ] name
[ ( { columnDefinition | constraint } [,...] ) ]
[ ENGINE tableEngineName [ WITH tableEngineParamName [,...] ] ]
[ NOT PERSISTENT ] [ TRANSACTIONAL ]
[ AS select ]
通过使用创建表命令的通用语法,我们可以创建不同类型的表,如缓存表、内存表和临时表。以下是描述给定语法中不同子句的列表。
-
CACHED − 缓存表是常规表的默认类型。这意味着行数不受主内存的限制。
-
MEMORY − 内存表是临时表的默认类型。这意味着内存表不应过大并且索引数据存储在主内存中。
-
TEMPORARY − 关闭或打开数据库时会删除临时表。基本上,临时表有两种类型 −GLOBAL 类型 − 所有连接都可以访问。LOCAL 类型 − 当前连接可以访问。临时表的默认类型是全局类型。临时表的索引保留在主内存中,除非使用 CREATE CACHED TABLE 创建临时表。
-
ENGINE − 仅当使用自定义表实现时才需要 ENGINE 选项。
-
NOT PERSISTENT − 它是一个修饰词,用于将完整表数据保留在内存中,并且在关闭数据库时所有行都将丢失。
-
TRANSACTIONAL − 它是一个提交打开的事务的关键字,此命令仅支持临时表。
Example
在这个示例中,让我们使用以下给定数据创建一个名为 tutorials_tbl 的表。
Sr.No |
Column Name |
Data Type |
1 |
ID |
Int |
2 |
Title |
Varchar(50) |
3 |
Author |
Varchar(20) |
4 |
Submission_date |
Date |
以下查询用于创建表 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 Sequence
序列是一个用于通过遵循 id 或任何随机列值的序列生成数字的概念。
Syntax
以下是 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 。在此序列中,即使事务回滚,值也不会被重新使用。
H2 Database - Alter
ALTER 是一个用于通过向 alter 命令中添加不同的子句从而改变表结构的命令。根据场景,我们需要向 alter 命令添加相应的子句。在此章节中,我们将讨论 alter 命令的多种场景。
Alter Table Add
Alter Table Add 是一个用于向表中添加一个新列和相应数据类型的一个命令。此命令将提交此连接中的事务。
Alter Table Add Constraint
Alter table add constraint 是一个用于向表中添加不同约束的命令,例如果键、外键、非空等等。
如果所需的索引尚不存在,则系统将会自动创建它们。不可能禁用对唯一约束的检查。此命令会提交此连接中的一个打开事务。
Alter Table Rename Constraint
此命令用于重命名特定关系表的约束名。此命令会提交此连接中的一个打开事务。
Alter Table Alter Column
此命令用于改变特定表中列的结构和属性。改变属性指的是改变列的数据类型、重命名列、改变标识值,或者改变选择性。
Syntax
以下是修改表修改列命令的通用语法。
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。
H2 Database - Drop
DROP 是从通用 SQL 语法中获取的命令。此命令用于从内存中删除数据库组件及其结构。本章将讨论使用 Drop 命令的不同情况。
Drop Table
Drop Table 是一个删除相应表及其结构的命令。
H2 Database - Commit
H2 Database - Grant
Grant 是一条来自 SQL 语法的命令,用于向用户或角色授予表的权限。执行此命令需要管理员权限。此命令会提交此连接中的打开事务。
在本章中,我们将讨论 Grant 命令的不同场景。
Grant Right
Grant Right 是一条向用户或角色授予表的管理员权限的命令。
H2 Database - Rollback
回滚是 SQL 语法的命令,用于将事务回滚到保存点或前一个事务。通过使用此命令,我们可以回滚到特定保存点,也可以回滚到之前执行的事务。
Syntax
ROLLABCK 命令有两种不同的语法。
以下是对回滚命令的通用语法。
ROLLBACK [ TO SAVEPOINT savepointName ]
以下是回滚命令的通用语法,适用于特定事务。
ROLLBACK TRANSACTION transactionName
H2 Database - JDBC Connection
H2 是一个 JAVA 数据库。我们可以使用 JDBC 与此数据库进行交互。在本章中,我们将看到如何使用 JDBC 连接 H2 数据库以及 H2 数据库的 CRUD 操作。
通常,有五步来创建 JDBC 连接。
Step 1 − 注册 JDBC 数据库驱动程序。
Class.forName ("org.h2.Driver");
Step 2 − 打开连接。
Connection conn = DriverManager.getConnection ("jdbc:h2:~/test", "sa","");
Step 3 − 创建一个语句。
Statement st = conn.createStatement();
Step 4 − 执行语句并接收 Resultset。
Stmt.executeUpdate("sql statement");
Step 5 − 关闭连接。
conn.close();
在继续创建完整程序之前,我们需要将 h2-1.4.192.jar file 添加到 CLASSPATH。我们可以从文件夹中获得这个 jar C:\Program Files (x86)\H2\bin 。
Create Table
在这个例子中,我们将编写一个创建表的程序。考虑一张名为 Registration 的表,它有以下字段。
S.No |
Column Name |
Data Type |
NOT NULL |
Primary Key |
1 |
ID |
Number |
Yes |
Yes |
2 |
First |
Varchar(255) |
No |
No |
3 |
Last |
Varchar(255) |
No |
No |
4 |
Age |
Number |
No |
No |
以下是一个名为 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 界面检查创建的表。
Insert Records
在这个例子中,我们将编写一个插入记录的程序。让我们将以下记录插入到注册表中。
ID |
First |
Last |
Age |
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!
Read Record
在这个例子中,我们将编写一个读取记录的程序。让我们尝试从表 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!
Update Records
在这个示例中,我们将编写一个程序来更新记录。让我们尝试从表 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!
Delete Records
在这个示例中,我们将编写一个程序来删除记录。让我们尝试从表 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!