- Apache Derby 教程
- Apache Derby - 首页
- Apache Derby - 简介
- Apache Derby - 部署模式
- Apache Derby - 环境设置
- Apache Derby - 工具
- Apache Derby - 语法
- Apache Derby - 数据类型
- Apache Derby - 创建表
- Apache Derby - 删除表
- Apache Derby - 插入数据
- Apache Derby - 检索数据
- Apache Derby - 更新数据
- Apache Derby - 删除数据
- Apache Derby - WHERE 子句
- Apache Derby - GROUP BY 子句
- Apache Derby - ORDER BY 子句
- Apache Derby - HAVING 子句
- ALTER TABLE 语句
- Apache Derby - Derby 索引
- Apache Derby - 存储过程
- Apache Derby - 模式
- Apache Derby - 触发器
- Apache Derby 有用资源
- Apache Derby 快速指南
- Apache Derby - 有用资源
- Apache Derby - 讨论
Apache Derby 快速指南
Apache Derby - 简介
Apache Derby 是一个完全基于 Java 编程语言的关系数据库管理系统 (RDBMS)。它是由 Apache 软件基金会开发的开源数据库。
Oracle 发布了 Apache Derby 的等效产品，名为 JavaDB。
Apache Derby 的特性
以下是 Derby 数据库的显著特性：
平台无关性 - Derby 使用基于磁盘的数据库格式，其数据库存储在磁盘上与数据库同名的目录中的文件中。
无需修改数据 - 正因为如此，您可以将 Derby 数据库移动到其他机器而无需修改数据。
事务支持 - Derby 完全支持事务，确保数据完整性。
包含数据库 - 您可以将预构建/现有数据库包含到您当前的 Derby 应用程序中。
占用空间小 - Derby 数据库占用空间小，易于使用和部署。
嵌入到 Java 应用程序中 - Derby 提供一个嵌入式数据库引擎，可以嵌入到 Java 应用程序中，并在与应用程序相同的 JVM 中运行。只需加载驱动程序即可启动数据库，并随应用程序停止。
Apache Derby 的限制
以下是 Apache Derby 的限制：
Derby 不支持 BLOB 和 LONGVARCHAR 等数据类型的索引。
如果 Derby 没有足够的磁盘空间，它将立即关闭。
数据存储
在存储数据时，Apache Derby 遵循一个称为聚集 (conglomerate) 的概念。其中，表的将存储在单独的文件中。同样，表的每个索引也存储在单独的文件中。因此，数据库中每个表或索引都将有一个单独的文件。
Apache Derby 库/组件
Apache Derby 发行版提供了各种组件。在您下载的 Apache 发行版的 lib 文件夹中，您可以看到表示各种组件的 jar 文件。
| Jar 文件 | 组件 | 描述 |
|---|---|---|
| derby.jar | 数据库引擎和 JDBC 驱动程序 | Apache Derby 的数据库引擎是一个嵌入式关系数据库引擎，支持 JDBC 和 SQL API。 它也充当嵌入式驱动程序，您可以使用它通过 Java 应用程序与 Derby 通信。 |
| derbynet.jar derbyrun.jar | 网络服务器 | Apache Derby 的网络服务器提供客户端服务器功能，客户端可以通过网络连接到 Derby 服务器。 |
| derbyclient.jar | 网络客户端 JDBC 驱动程序 | |
| derbytools.jar | 命令行工具 | 此 jar 文件包含诸如sysinfo、ij 和dblook 等工具。 |
| derbyoptionaltools.jar | 可选命令行实用程序（工具） | 此 jar 文件提供可选工具：databaseMetaData 可选工具、foreignViews 可选工具、luceneSupport 可选工具、rawDBReader 可选工具、simpleJson 可选工具等 |
| derbyLocale_XX.jar | 用于本地化消息的 Jar 文件 | 除了上述 jar 文件之外，您还可以看到几个 derbyLocale_XX.jar（es、fr、hu、it、ja 等）。使用这些，您可以本地化 Apache Derby 的消息。 |
Apache Derby - 部署模式
您可以以两种模式部署 Apache Derby，即嵌入模式和服务器模式。
嵌入模式
您可以使用 Java 应用程序（使用嵌入式驱动程序）在嵌入模式下运行 Derby。如果您在嵌入模式下部署 Derby，则数据库引擎将在与 Java 应用程序相同的 JVM 中运行。它随应用程序启动和停止。您只能通过此应用程序访问数据库。
服务器模式
在服务器模式下，Derby 将在应用程序服务器的 JVM 中运行，您可以向服务器发送请求以访问它。与嵌入模式不同，多个应用程序（Java）可以向服务器发送请求并访问数据库。
Apache Derby - 环境设置
下一章将解释如何下载和安装 Apache Derby。
下载 Apache Derby
访问 Apache Derby 主页 https://db.apache.org/derby/。点击“下载”选项卡。
选择并点击 Apache Derby 最新版本的链接。
点击所选链接后，您将被重定向到 Apache Derby 的发行版页面。在这里您可以看到，Derby 提供的发行版包括 db-derby-bin、db-derbylib.zip、db-derby-lib-debug.zip 和 db-derby-src.zip。
下载db-derby-bin 文件夹。将其内容复制到您想要安装 Apache Derby 的单独文件夹中（例如，C:\Derby）。
现在，要使用 Derby，
确保您已通过传递 Java 安装文件夹的 bin 文件夹的位置设置了JAVA_HOME 变量，并将JAVA_HOME/bin 包含在 PATH 变量中。
创建一个新的环境变量DERBY_HOME，其值为 C:\Derby。
db-derby-bin 发行版的 bin 文件夹（我们将其更改为 C:\Derby\bin）包含所有必需的 jar 文件。
如上所述，Apache Derby 可以通过以下两种方式安装/部署：
嵌入模式 - 在此模式下，您需要使用嵌入式 Derby JDBC 驱动程序访问数据库。您可以通过 Java 应用程序启动和停止 Derby。数据库引擎和您的应用程序都将在同一个 JVM 上运行。
网络服务器模式 - 在此模式下，您可以以典型的客户端服务器方式访问 Derby，其中 Derby 嵌入在服务器系统中。然后，在不同 JVM（服务器的 JVM）中运行的客户端机器将向服务器发送请求，服务器将响应这些请求。
客户端可以是服务器同一系统机器中的另一个 JVM，也可以是来自远程系统的 Java 应用程序。
在嵌入模式下安装 Derby
要在嵌入模式下安装 Apache Derby，请将 jar 文件derby.jar 包含在您的 CLASSPATH 中。
或者，您可以通过运行setEmbeddedCP 命令来设置所需 jar 文件的类路径。浏览 Apache Derby 的bin 目录并运行此文件，如下所示：
C:\Users\MYUSER>cd %DERBY_HOME%/bin C:\Derby\bin>setEmbeddedCP.bat C:\Derby\bin>SET DERBY_HOME=C:\Derby C:\Derby\bin>set CLASSPATH=C:\Derby\lib\derby.jar;C:\Derby\lib\derbytools.jar;C:\Derby/lib/derby optionaltools.jar;C:\Users\Tutorialspoint\Google Drive\Office\Derby\derby_zip\New folder\db-derby-10.12.1.1- bin\lib;C:\EXAMPLES_\Task\jars\*;C:\EXAMPLES\jars\mysql-connector-java-5.1.40- bin.jar;C:\Users\Tutorialspoint\Google Drive\Office\37.Junit Update\jars;C:\Program Files\Apache Software Foundation\Tomcat 8.5\lib\*;C:\Derby\lib\*;
设置 Apache Derby 后，要访问它，请使用嵌入式驱动程序运行 Java 程序。
验证
您可以使用ij 工具验证设置，如下所示：
C:\Derby\bin>ij ij version 10.14 ij> connect 'jdbc:derby:SampleDB;create=true'; ij>
在网络服务器模式下安装 Derby
要在网络服务器模式下安装 Apache Derby，您需要将derbynet.jar 和derbytools.jar 文件包含到 CLASSPATH 中。
或者，您可以通过运行setNetworkServerCP 命令来设置所需 jar 文件的类路径。浏览 Apache Derby 的bin 目录并运行此文件，如下所示：
C:\Users\MYUSER>cd %DERBY_HOME%/bin C:\Derby\bin>setNetworkServerCP.bat C:\Derby\bin>SET DERBY_INSTALL=C:\Derby C:\Derby\bin>set CLASSPATH=C:\Derby\lib\derbynet.jar;C:\Derby\lib\derbytools.jar;C:\Derby/lib/de rbyoptionaltools.jar;C:\Users\Tutorialspoint\Google Drive\Office\Derby\derby_zip\New folder\db-derby-10.12.1.1- bin\lib;C:\EXAMPLES_\Task\jars\*;C:\EXAMPLES\jars\mysql-connector-java-5.1.40- bin.jar;C:\Users\Tutorialspoint\Google Drive\Office\37.Junit Update\jars;C:\Program Files\Apache Software Foundation\Tomcat 8.5\lib\*;C:\Derby\lib\*;
在服务器模式下启动 Derby
您可以通过运行命令startNetworkServer 来启动网络服务器。浏览 Apache Derby 的bin 目录并运行此命令，如下所示：
C:\Derby\bin>startNetworkServer Fri Jan 04 11:20:30 IST 2019 : Security manager installed using the Basic server security policy. Fri Jan 04 11:20:30 IST 2019 : Apache Derby Network Server - 10.14.2.0 - (1828579) started and ready to accept connections on port 1527
或者，您可以使用derbyrun.jar 启动服务器，如下所示：
C:\Users\MYUSER>cd %DERBY_HOME%/lib C:\Derby\lib>java -jar derbyrun.jar server start Fri Jan 04 11:27:20 IST 2019: Security manager installed using the Basic server security policy. Fri Jan 04 11:27:21 IST 2019: Apache Derby Network Server - 10.14.2.0 - (1828579) started and ready to accept connections on port 1527
网络客户端
在客户端中，将 jar 文件derbyclient.jar 和derbytools.jar 添加到 CLASSPATH。或者，运行setNetworkClientCP 命令，如下所示：
C:\Users\MYUSER>cd %DERBY_HOME%/bin C:\Derby\bin>setNetworkClientCP C:\Derby\bin>SET DERBY_HOME=C:\Derby C:\Derby\bin>set CLASSPATH=C:\Derby\lib\derbyclient.jar;C:\Derby\lib\derbytools.jar;C:\Derby/lib /derbyoptionaltools.jar;C:\Derby\lib\derby.jar;C:\Derby\lib\derbytools.jar;C:\D erby/lib/derbyoptionaltools.jar;C:\Users\Tutorialspoint\Google Drive\Office\Derby\derby_zip\New folder\db-derby-10.12.1.1- bin\lib;C:\EXAMPLES_\Task\jars\*;C:\EXAMPLES\jars\mysql-connector-java-5.1.40- bin.jar;C:\Users\Tutorialspoint\Google Drive\Office\37.Junit Update\jars;C:\Program Files\Apache Software Foundation\Tomcat 8.5\lib\*;C:\Derby\lib\*;
然后，您可以从该客户端向服务器发送请求。
验证
您可以使用ij 工具验证设置，如下所示：
C:\Derby\bin>ij ij version 10.14 ij> connect 'jdbc:derby://127.0.0.1:1527/SampleDB;create=true'; ij>
Apache Derby Eclipse 环境
在使用 Eclipse 时，您需要为所有必需的 jar 文件设置构建路径。
步骤 1：创建项目并设置构建路径
打开 Eclipse 并创建一个示例项目。右键单击项目，然后选择选项构建路径 -> 配置构建路径，如下所示：
在Java 构建路径框架的库选项卡中，单击添加外部 JARs。
然后选择 Derby 安装文件夹的 lib 文件夹中所需的jar 文件，然后单击应用并关闭。
Apache Derby - 工具
Apache Derby 提供了sysinfo、ij 和dblook 等工具。
sysinfo 工具
使用此工具，您可以获取有关 Java 和 Derby 环境的信息。
浏览 Derby 安装目录的 bin 文件夹并执行 sysinfo 命令，如下所示：
C:\Users\MY_USER>cd %DERBY_HOME%/bin C:\Derby\bin>sysinfo
执行后，它将提供如下所示的有关 java 和 derby 的系统信息：
------------------ Java Information ------------------ Java Version: 1.8.0_101 Java Vendor: Oracle Corporation Java home: C:\Program Files\Java\jdk1.8.0_101\jre Java classpath: C:\Users\Tutorialspoint\Google Drive\Office\Derby\derby_zip\New folder\db-derby-10.12.1.1- bin\lib;C:\EXAMPLES_\Task\jars\*;C:\EXAMPLES\jars\mysql-connector-java-5.1.40- bin.jar;C:\Users\Tutorialspoint\Google Drive\Office\37.Junit Update\jars;C:\Program Files\Apache Software Foundation\Tomcat 8.5\lib\*;C:\Derby\lib\derby.jar;C:\Derby\lib\derbyclient.jar;C:\Derby\lib\derb yLocale_cs.jar;C:\Derby\lib\derbyLocale_de_DE.jar;C:\Derby\lib\derbyLocale_es.j ar;C:\Derby\lib\derbyLocale_fr.jar;C:\Derby\lib\derbyLocale_hu.jar;C:\Derby\lib \derbyLocale_it.jar;C:\Derby\lib\derbyLocale_ja_JP.jar;C:\Derby\lib\derbyLocale _ko_KR.jar;C:\Derby\lib\derbyLocale_pl.jar;C:\Derby\lib\derbyLocale_pt_BR.jar;C :\Derby\lib\derbyLocale_ru.jar;C:\Derby\lib\derbyLocale_zh_CN.jar;C:\Derby\lib\ derbyLocale_zh_TW.jar;C:\Derby\lib\derbynet.jar;C:\Derby\lib\derbyoptionaltools .jar;C:\Derby\lib\derbyrun.jar;C:\Derby\lib\derbytools.jar;;C:\Derby/lib/derby. jar;C:\Derby/lib/derbynet.jar;C:\Derby/lib/derbyclient.jar;C:\Derby/lib/derbyto ols.jar;C:\Derby/lib/derbyoptionaltools.jar OS name: Windows 10 OS architecture: amd64 OS version: 10.0 Java user name: Tutorialspoint Java user home: C:\Users\Tutorialspoint Java user dir: C:\Derby\bin java.specification.name: Java Platform API Specification java.specification.version: 1.8 java.runtime.version: 1.8.0_101-b13 --------- Derby Information -------- [C:\Derby\lib\derby.jar] 10.14.2.0 - (1828579) [C:\Derby\lib\derbytools.jar] 10.14.2.0 - (1828579) [C:\Derby\lib\derbynet.jar] 10.14.2.0 - (1828579) [C:\Derby\lib\derbyclient.jar] 10.14.2.0 - (1828579) [C:\Derby\lib\derbyoptionaltools.jar] 10.14.2.0 - (1828579) ------------------------------------------------------ ----------------- Locale Information ----------------- Current Locale : [English/United States [en_US]] Found support for locale: [cs] version: 10.14.2.0 - (1828579) Found support for locale: [de_DE] version: 10.14.2.0 - (1828579) Found support for locale: [es] version: 10.14.2.0 - (1828579) Found support for locale: [fr] version: 10.14.2.0 - (1828579) Found support for locale: [hu] version: 10.14.2.0 - (1828579) Found support for locale: [it] version: 10.14.2.0 - (1828579) Found support for locale: [ja_JP] version: 10.14.2.0 - (1828579) Found support for locale: [ko_KR] version: 10.14.2.0 - (1828579) Found support for locale: [pl] version: 10.14.2.0 - (1828579) Found support for locale: [pt_BR] version: 10.14.2.0 - (1828579) Found support for locale: [ru] version: 10.14.2.0 - (1828579) Found support for locale: [zh_CN] version: 10.14.2.0 - (1828579) Found support for locale: [zh_TW] version: 10.14.2.0 - (1828579) ------------------------------------------------------ ------------------------------------------------------
ij 工具
使用此工具，您可以运行 Apache Derby 的脚本和查询。
浏览 Derby 安装目录的 bin 文件夹并执行 ij 命令，如下所示：
C:\Users\MY_USER>cd %DERBY_HOME%/bin C:\Derby\bin>ij
这将为您提供ij shell，您可以在其中执行 Derby 命令和脚本，如下所示：
ij version 10.14 ij>
使用help 命令，您可以获取此 shell 支持的命令列表。
C:\Derby\bin>cd %DERBY_HOME%/bin
C:\Derby\bin>ij
ij version 10.14
ij> help;
Supported commands include:
PROTOCOL 'JDBC protocol' [ AS ident ];
-- sets a default or named protocol
DRIVER 'class for driver'; -- loads the named class
CONNECT 'url for database' [ PROTOCOL namedProtocol ] [ AS connectionName ];
-- connects to database URL
-- and may assign identifier
SET CONNECTION connectionName; -- switches to the specified connection
SHOW CONNECTIONS; -- lists all connections
AUTOCOMMIT [ ON | OFF ]; -- sets autocommit mode for the connection
DISCONNECT [ CURRENT | connectionName | ALL ];
-- drop current, named, or all connections;
-- the default is CURRENT
SHOW SCHEMAS; -- lists all schemas in the current database
SHOW [ TABLES | VIEWS | PROCEDURES | FUNCTIONS | SYNONYMS ] { IN schema };
-- lists tables, views, procedures, functions or
synonyms
SHOW INDEXES { IN schema | FROM table };
-- lists indexes in a schema, or for a table
SHOW ROLES; -- lists all defined roles in the database,
sorted
SHOW ENABLED_ROLES; -- lists the enabled roles for the current
-- connection (to see current role use
-- VALUES CURRENT_ROLE), sorted
SHOW SETTABLE_ROLES; -- lists the roles which can be set for the
-- current connection, sorted
DESCRIBE name; -- lists columns in the named table
COMMIT; -- commits the current transaction
ROLLBACK; -- rolls back the current transaction
PREPARE name AS 'SQL-J text'; -- prepares the SQL-J text
EXECUTE { name | 'SQL-J text' } [ USING { name | 'SQL-J text' } ] ;
-- executes the statement with parameter
-- values from the USING result set row
REMOVE name; -- removes the named previously prepared
statement
RUN 'filename'; -- run commands from the named file
ELAPSEDTIME [ ON | OFF ]; -- sets elapsed time mode for ij
MAXIMUMDISPLAYWIDTH integerValue;
-- sets the maximum display width for
-- each column to integerValue
ASYNC name 'SQL-J text'; -- run the command in another thread
WAIT FOR name; -- wait for result of ASYNC'd command
HOLDFORCONNECTION; -- sets holdability for a connection to HOLD
-- (i.e. ResultSet.HOLD_CURSORS_OVER_COMMIT)
NOHOLDFORCONNECTION; -- sets holdability for a connection to NO HOLD
-- (i.e. ResultSet.CLOSE_CURSORS_AT_COMMIT)
GET [SCROLL INSENSITIVE] [WITH { HOLD | NOHOLD }] CURSOR name AS 'SQL-J
query';
-- gets a cursor (JDBC result set) on the query
-- the default is a forward-only cursor with
holdability
NEXT name; -- gets the next row from the named cursor
FIRST name; -- gets the first row from the named scroll
cursor
LAST name; -- gets the last row from the named scroll
cursor
PREVIOUS name; -- gets the previous row from the named scroll
cursor
ABSOLUTE integer name; -- positions the named scroll cursor at the
absolute row number
-- (A negative number denotes position from the
last row.)
RELATIVE integer name; -- positions the named scroll cursor relative to
the current row
-- (integer is number of rows)
AFTER LAST name; -- positions the named scroll cursor after the
last row
BEFORE FIRST name; -- positions the named scroll cursor before the
first row
GETCURRENTROWNUMBER name; -- returns the row number for the current
position of the named scroll cursor
-- (0 is returned when the cursor is not
positioned on a row.)
CLOSE name; -- closes the named cursor
LOCALIZEDDISPLAY [ ON | OFF ];
-- controls locale sensitive data representation
EXIT; -- exits ij
HELP; -- shows this message
Any unrecognized commands are treated as potential SQL-J commands and executed
directly.
dblook 工具
此工具用于生成数据定义语言 (DDL)。
浏览 Derby 安装目录的 bin 文件夹并执行dblook 命令，如下所示：
C:\Users\MY_USER>cd %DERBY_HOME%/bin C:\Derby\bin>dblook -d myURL
其中，myURL 是您需要为其生成 DDL 的数据库的连接 URL。
Apache Derby - 语法
本章介绍所有 Apache Derby SQL 语句的语法。
所有语句都以 SELECT、INSERT、UPDATE、DELETE、ALTER、DROP、CREATE、USE、SHOW 等关键字中的任何一个开头，所有语句都以分号 (;) 结尾。
Apache Derby 的 SQL 语句不区分大小写，包括表名。
CREATE 语句
CREATE TABLE table_name ( column_name1 column_data_type1 constraint (optional), column_name2 column_data_type2 constraint (optional), column_name3 column_data_type3 constraint (optional) );
DROP TABLE
DROP TABLE table_name;
INSERT 语句
INSERT INTO table_name VALUES (column_name1, column_name2, ...);
SELECT 语句
SELECT column_name, column_name, ... FROM table_name;
UPDATE 语句
UPDATE table_name SET column_name = value, column_name = value, ... WHERE conditions;
DELETE 语句
DELETE FROM table_name WHERE condition;
DESCRIBE 语句
Describe table_name
SQL TRUNCATE TABLE 语句
TRUNCATE TABLE table_name;
ALTER 语句 - 添加列
ALTER TABLE table_name ADD COLUMN column_name column_type;
ALTER 语句 - 添加约束
ALTER TABLE table_name ADD CONSTRAINT constraint_name constraint (column_name);
ALTER 语句 - 删除列
ALTER TABLE table_name DROP COLUMN column_name;
ALTER 语句 - 删除约束
ALTER TABLE table_name DROP CONSTRAINT constraint_name;
WHERE 子句
SELECT * from table_name WHERE condition; or, DELETE from table_name WHERE condition; or, UPDATE table_name SET column_name = value WHERE condition;
GROUP BY 子句
SELECT column1, column2, . . . table_name GROUP BY column1, column2, . . .;
ORDER BY 子句
SELECT * FROM table_name ORDER BY column_name ASC|DESC.
HAVING 子句
SELECT column1, column2 . . . from table_name GROUP BY column having condition;
创建索引
CTREATE INDEX index_name on table_name (column_name);
创建唯一索引
CREATE UNIQUE INDEX index_name on table_name (column_name);
创建复合索引
CREATE INDEX index_name on table_name (column_name1, column_name2);
显示索引
SHOW INDEXES FROM table_name;
删除索引
DROP INDEX index_name;
Apache Derby - 数据类型
数据类型是一种属性，用于指定任何对象的的数据类型。每个列、变量和表达式都有一个相关的数据类型。在创建表时可以使用这些数据类型。您可以根据需要为表列选择数据类型。
Derby 服务器提供以下几类数据类型：
整数数值数据类型
以下是整数数值数据类型的列表：
| 数据类型 | 大小 | 从 | 到 |
|---|---|---|---|
| SMALLINT | 2 字节 | -32768 | 32767 |
| INTEGER | 4 字节 | -2,147,483,648 | 2,147,483,647 |
| BIGINT | 8 字节 | -9223372036854775808 | 9223372036854775808 |
近似数值数据类型
以下是近似数值数据类型的列表：
| 数据类型 | 大小 | 从 | 到 |
|---|---|---|---|
| REAL | 4 字节 | -3.40E + 38 | 3.40E + 38 |
| DOUBLE PRECISION | 8 字节 | -1.79E + 308 | 1.79E + 308 |
| FLOAT | -1.79E + 308 | 1.79E + 308 |
精确数值数据类型
以下是精确数值数据类型的列表：
| 数据类型 | 从 | 到 |
|---|---|---|
| DECIMAL | -10^38 +1 | 10^38 -1 |
| NUMERIC | -10^38 +1 | 10^38 -1 |
Apache Derby - 创建表
CREATE TABLE 语句用于在 Derby 数据库中创建一个新表。
语法
以下是 CREATE 语句的语法。
CREATE TABLE table_name ( column_name1 column_data_type1 constraint (optional), column_name2 column_data_type2 constraint (optional), column_name3 column_data_type3 constraint (optional) );
在 Apache Derby 中创建表的另一种方法是，可以使用查询指定列名和数据类型。此方法的语法如下：
CREATE TABLE table_name AS SELECT * FROM desired_table WITH NO DATA;
示例
以下 SQL 语句创建一个名为 Student 的表，该表包含四列，其中 id 是主键，并且是自动生成的。
ij> CREATE TABLE Student ( Id INT NOT NULL GENERATED ALWAYS AS IDENTITY, Age INT NOT NULL, First_Name VARCHAR(255), last_name VARCHAR(255), PRIMARY KEY (Id) ); > > > > > > > 0 rows inserted/updated/deleted
DESCRIBE 命令通过列出列及其详细信息来描述指定的表（如果表存在）。可以使用此命令来验证表是否已创建。
ij> DESCRIBE Student; COLUMN_NAME |TYPE_NAME |DEC&|NUM&|COLUM&|COLUMN_DEF|CHAR_OCTE&|IS_NULL& ------------------------------------------------------------------------------ ID |INTEGER |0 |10 |10 |AUTOINCRE&|NULL |NO AGE |INTEGER |0 |10 |10 |NULL |NULL |NO FIRST_NAME |VARCHAR |NULL|NULL|255 |NULL |510 |YES LAST_NAME |VARCHAR |NULL|NULL|255 |NULL |510 |YES 4 rows selected
使用 JDBC 程序创建表
本节介绍如何使用 JDBC 应用程序在 Apache Derby 数据库中创建表。
如果要使用网络客户端请求 Derby 网络服务器，请确保服务器正在运行。网络客户端驱动程序的类名为 org.apache.derby.jdbc.ClientDriver，URL 为 jdbc:derby://127.0.0.1:1527/DATABASE_NAME;create=true;user=USER_NAME;password=PASSWORD。
按照以下步骤在 Apache Derby 中创建表：
步骤 1：注册驱动程序
要与数据库通信，首先需要注册驱动程序。Class 类的 forName() 方法接受一个表示类名的字符串值，将其加载到内存中，这会自动注册它。使用此方法注册驱动程序。
步骤 2：获取连接
通常，与数据库通信的第一步是连接到它。Connection 类表示与数据库服务器的物理连接。可以通过调用 DriverManager 类的 getConnection() 方法来创建连接对象。使用此方法创建连接。
步骤 3：创建语句对象
需要创建 Statement、PreparedStatement 或 CallableStatement 对象才能将 SQL 语句发送到数据库。可以使用 createStatement()、prepareStatement() 和 prepareCall() 方法分别创建这些对象。使用适当的方法创建这些对象中的任何一个。
步骤 4：执行查询
创建语句后，需要执行它。Statement 类提供各种方法来执行查询，例如 execute() 方法用于执行返回多个结果集的语句。executeUpdate() 方法执行 INSERT、UPDATE、DELETE 等查询。executeQuery() 方法用于返回数据的查询结果等。使用这些方法中的任何一个并执行先前创建的语句。
示例
下面的 JDBC 示例演示如何使用 JDBC 程序在 Apache Derby 中创建表。在这里，我们使用嵌入式驱动程序连接到名为 sampleDB 的数据库（如果不存在则会创建）。
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
public class CreateTable {
public static void main(String args[]) throws Exception {
//Registering the driver
Class.forName("org.apache.derby.jdbc.EmbeddedDriver");
//Getting the Connection object
String URL = "jdbc:derby:sampleDB;create=true";
Connection conn = DriverManager.getConnection(URL);
//Creating the Statement object
Statement stmt = conn.createStatement();
//Executing the query
String query = "CREATE TABLE Employees( "
+ "Id INT NOT NULL GENERATED ALWAYS AS IDENTITY, "
+ "Name VARCHAR(255), "
+ "Salary INT NOT NULL, "
+ "Location VARCHAR(255), "
+ "PRIMARY KEY (Id))";
stmt.execute(query);
System.out.println("Table created");
}
}
输出
执行上述程序后，将获得以下输出
Table created
Apache Derby - 删除表
DROP TABLE 语句用于删除现有表，包括其所有触发器、约束和权限。
语法
以下是 DROP TABLE 语句的语法。
ij> DROP TABLE table_name;
示例
假设数据库中有一个名为 Student 的表。以下 SQL 语句删除名为 Student 的表。
ij> DROP TABLE Student; 0 rows inserted/updated/deleted
由于我们已删除该表，如果尝试对其进行描述，则会收到如下错误
ij> DESCRIBE Student; IJ ERROR: No table exists with the name STUDENT
使用 JDBC 程序删除表
本节介绍如何使用 JDBC 应用程序在 Apache Derby 数据库中删除表。
如果要使用网络客户端请求 Derby 网络服务器，请确保服务器正在运行。网络客户端驱动程序的类名为 org.apache.derby.jdbc.ClientDriver，URL 为 jdbc:derby://127.0.0.1:1527/DATABASE_NAME;create=true;user=USER_NAME;password=PASSWORD。
按照以下步骤在 Apache Derby 中删除表
步骤 1：注册驱动程序
要与数据库通信，首先需要注册驱动程序。Class 类的 forName() 方法接受一个表示类名的字符串值，将其加载到内存中，这会自动注册它。使用此方法注册驱动程序。
步骤 2：获取连接
通常，与数据库通信的第一步是连接到它。Connection 类表示与数据库服务器的物理连接。可以通过调用 DriverManager 类的 getConnection() 方法来创建连接对象。使用此方法创建连接。
步骤 3：创建语句对象
需要创建 Statement、PreparedStatement 或 CallableStatement 对象才能将 SQL 语句发送到数据库。可以使用 createStatement()、prepareStatement() 和 prepareCall() 方法分别创建这些对象。使用适当的方法创建这些对象中的任何一个。
步骤 4：执行查询
创建语句后，需要执行它。Statement 类提供各种方法来执行查询，例如 execute() 方法用于执行返回多个结果集的语句。executeUpdate() 方法执行 INSERT、UPDATE、DELETE 等查询。executeQuery() 方法用于返回数据的查询结果等。使用这些方法中的任何一个并执行先前创建的语句。
示例
下面的 JDBC 示例演示如何使用 JDBC 程序在 Apache Derby 中删除表。在这里，我们使用嵌入式驱动程序连接到名为 sampleDB 的数据库（如果不存在则会创建）。
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;
public class DropTable {
public static void main(String args[]) throws Exception {
//Registering the driver
Class.forName("org.apache.derby.jdbc.EmbeddedDriver");
//Getting the Connection object
String URL = "jdbc:derby:sampleDB;create=true";
Connection conn = DriverManager.getConnection(URL);
//Creating the Statement object
Statement stmt = conn.createStatement();
//Executing the query
String query = "DROP TABLE Employees";
stmt.execute(query);
System.out.println("Table dropped");
}
}
输出
执行上述程序后，将获得以下输出：
Table dropped
Apache Derby - 插入数据
INSERT 查询插入数据：新记录到表中。
语法
以下是 INSERT 语句的基本语法：
ij>INSERT INTO table_name VALUES (column_name1, column_name2, ...);
其中 column1、column2 是要插入的行中的列值。
示例
以下 SQL INSERT 语句在 Student 表中插入一行新行，其中在id、age、first name和last name列中插入值。
SQL> INSERT INTO Student VALUES (101, 20, 'Zara', 'Ali');
语法 2
或者，您可以通过提及列名来插入两列，如下所示：
ij>INSERT INTO table_name VALUES (column_name1, column_name2, ...) VALUES (value1, value2, ...);
注意 - Apache Derby 自动计算生成列的值。例如，无需为本教程前面创建的 student 表中的 id 列传递值。如果您的表具有生成列，请使用语法 2。
示例
ij> INSERT INTO Student(Age, First_Name, Last_Name) VALUES (21, 'Sucharitha' , 'Tyagi'); 1 row inserted/updated/deleted
并且，您还可以使用一条语句插入两行，如下所示：
ij>INSERT INTO Student(Age, First_Name, Last_Name) VALUES (20, 'Amit', 'Bhattacharya'), (22, 'Rahul', 'Desai'); 2 rows inserted/updated/deleted
您可以使用 SELECT 命令验证表的内容（我们将在本教程的后面部分讨论此命令）。
语法 3
您可以在 insert 语句中使用另一个查询，如下所示：
INSERT INTO table_Name Query
示例
假设数据库中有一个名为First_Year的表，如下所示，其列与 Student 表中的列相似：
ID |AGE |FIRST_NAME |LAST_NAME ----------------------------------------------------------------- 1 |20 |Raju |Pendyala 2 |21 |Bhargav |Prayaga 3 |22 |Deepthi |Yerramilli
您可以使用上述语法将此表中的值插入到 student 表中，如下所示：
ij> INSERT INTO Student (Age, First_Name, Last_Name) SELECT Age, First_Name, Last_Name FROM First_Year; > 3 rows inserted/updated/deleted
执行所有上述 insert 语句后，Student 表将如下所示：
ID |AGE |FIRST_NAME |LAST_NAME ------------------------------------------------------------- 1 |21 |Sucharitha |Tyagi 2 |20 |Amit |Bhattacharya 3 |22 |Rahul |Desai 4 |20 |Raju |Pendyala 5 |21 |Bhargav |Prayaga 6 |22 |Deepthi |Yerramilli
使用 JDBC 程序插入数据
本节介绍如何使用 JDBC 应用程序在 Apache Derby 数据库中将数据插入表中。
如果要使用网络客户端请求 Derby 网络服务器，请确保服务器正在运行。网络客户端驱动程序的类名为 org.apache.derby.jdbc.ClientDriver，URL 为 jdbc:derby://127.0.0.1:1527/DATABASE_NAME;create=true;user=USER_NAME;password=PASSWORD。
按照以下步骤将数据插入 Apache Derby 中的表：
步骤 1：注册驱动程序
要与数据库通信，首先需要注册驱动程序。Class 类的 forName() 方法接受一个表示类名的字符串值，将其加载到内存中，这会自动注册它。使用此方法注册驱动程序。
步骤 2：获取连接
通常，与数据库通信的第一步是连接到它。Connection 类表示与数据库服务器的物理连接。可以通过调用 DriverManager 类的 getConnection() 方法来创建连接对象。使用此方法创建连接。
步骤 3：创建语句对象
需要创建 Statement、PreparedStatement 或 CallableStatement 对象才能将 SQL 语句发送到数据库。可以使用 createStatement()、prepareStatement() 和 prepareCall() 方法分别创建这些对象。使用适当的方法创建这些对象中的任何一个。
步骤 4：执行查询
创建语句后，需要执行它。Statement 类提供各种方法来执行查询，例如 execute() 方法用于执行返回多个结果集的语句。
executeUpdate() 方法执行 INSERT、UPDATE、DELETE 等查询。executeQuery() 方法用于返回数据的查询结果等。使用这些方法中的任何一个并执行先前创建的语句。
示例
下面的 JDBC 示例演示如何使用 JDBC 程序将数据插入 Apache Derby 中的表。在这里，我们使用嵌入式驱动程序连接到名为 sampleDB 的数据库（如果不存在则会创建）。
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
public class InsertData {
public static void main(String args[]) throws Exception {
//Registering the driver
Class.forName("org.apache.derby.jdbc.EmbeddedDriver");
//Getting the Connection object
String URL = "jdbc:derby:SampleDB;create=true";
Connection conn = DriverManager.getConnection(URL);
//Creating the Statement object
Statement stmt = conn.createStatement();
//Creating a table and populating
String query = "CREATE TABLE Employees("
+ "Id INT NOT NULL GENERATED ALWAYS AS IDENTITY, "
+ "Name VARCHAR(255), Salary INT NOT NULL, "
+ "Location VARCHAR(255), "
+ "PRIMARY KEY (Id))";
//Executing the query
String query = "INSERT INTO Employees("
+ "Name, Salary, Location) VALUES "
+ "('Amit', 30000, 'Hyderabad'), "
+ "('Kalyan', 40000, 'Vishakhapatnam'), "
+ "('Renuka', 50000, 'Delhi'), "
+ "('Archana', 15000, 'Mumbai'), "
+ "('Trupthi', 45000, 'Kochin'), "
+ "('Suchatra', 33000, 'Pune'), "
+ "('Rahul', 39000, 'Lucknow'), "
+ "('Trupti', 45000, 'Kochin')";
stmt.execute(query);
System.out.println("Values inserted");
}
}
输出
执行上述程序后，将获得以下输出：
Values inserted
Apache Derby - 检索数据
SELECT 语句用于从表中检索数据。这将以称为结果集的表的形式返回数据。
语法
以下是 SELECT 语句的语法：
ij> SELECT column_name, column_name, ... FROM table_name; Or, Ij>SELECT * from table_name
示例
让我们假设数据库中有一个名为 Employees 的表，如下所示：
ij> CREATE TABLE Employees ( Id INT NOT NULL GENERATED ALWAYS AS IDENTITY, Name VARCHAR(255), Salary INT NOT NULL, Location VARCHAR(255), PRIMARY KEY (Id) ); > > > > > > > 0 rows inserted/updated/deleted
并在其中插入了四条记录，如下所示：
ij> INSERT INTO Employees (Name, Salary, Location) VALUES
('Amit', 30000, 'Hyderabad'),
('Kalyan', 40000, 'Vishakhapatnam'),
('Renuka', 50000, 'Delhi'),
('Archana', 15000, 'Mumbai');
> > > > 4 rows inserted/updated/deleted
以下 SQL 语句检索表中所有员工的姓名、年龄和工资详细信息；
ij> SELECT Id, Name, Salary FROM Employees;
此查询的输出为：
ID |NAME |SALARY ------------------------------------------------------------------------ 1 |Amit |30000 2 |Kalyan |40000 3 |Renuka |50000 4 |Archana|15000 4 rows selected
如果要一次获取此表的所有记录，请使用 * 代替列名。
ij> select * from Employees;
这将产生以下结果：
ID |NAME |SALARY |LOCATION ------------------------------------------------------------------ 1 |Amit |30000 |Hyderabad 2 |Kalyan |40000 |Vishakhapatnam 3 |Renuka |50000 |Delhi 4 |Archana|15000 |Mumbai 4 rows selected
使用 JDBC 程序检索数据
本节介绍如何使用 JDBC 应用程序从 Apache Derby 数据库中的表中检索数据。
如果要使用网络客户端请求 Derby 网络服务器，请确保服务器正在运行。网络客户端驱动程序的类名为 org.apache.derby.jdbc.ClientDriver，URL 为 jdbc:derby://127.0.0.1:1527/DATABASE_NAME;create=true;user=USER_NAME;password=PASSWORD。
按照以下步骤从 Apache Derby 中的表中检索数据：
步骤 1：注册驱动程序
要与数据库通信，首先需要注册驱动程序。Class 类的 forName() 方法接受一个表示类名的字符串值，将其加载到内存中，这会自动注册它。使用此方法注册驱动程序。
步骤 2：获取连接
通常，与数据库通信的第一步是连接到它。Connection 类表示与数据库服务器的物理连接。可以通过调用 DriverManager 类的 getConnection() 方法来创建连接对象。使用此方法创建连接。
步骤 3：创建语句对象
需要创建 Statement、PreparedStatement 或 CallableStatement 对象才能将 SQL 语句发送到数据库。可以使用 createStatement()、prepareStatement() 和 prepareCall() 方法分别创建这些对象。使用适当的方法创建这些对象中的任何一个。
步骤 4：执行查询
创建语句后，需要执行它。Statement 类提供各种方法来执行查询，例如 execute() 方法用于执行返回多个结果集的语句。executeUpdate() 方法执行 INSERT、UPDATE、DELETE 等查询。executeQuery() 方法用于返回数据的查询结果等。使用这些方法中的任何一个并执行先前创建的语句。
示例
下面的 JDBC 示例演示如何使用 JDBC 程序从 Apache Derby 中的表中检索数据。在这里，我们使用嵌入式驱动程序连接到名为 sampleDB 的数据库（如果不存在则会创建）。
executeQuery() 方法返回一个 ResultSet 对象，该对象保存语句的结果。最初，结果集指针将位于第一条记录上，可以使用其 next() 和 getXXX() 方法打印 ResultSet 对象的内容。
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class RetrieveData {
public static void main(String args[]) throws SQLException,
ClassNotFoundException {
//Registering the driver
Class.forName("org.apache.derby.jdbc.EmbeddedDriver");
//Getting the Connection object
String URL = "jdbc:derby:sampleDB;create=true";
Connection conn = DriverManager.getConnection(URL);
//Creating the Statement object
4Statement stmt = conn.createStatement();
//Creating a table and populating it
String query = "CREATE TABLE Employees("
+ "Id INT NOT NULL GENERATED ALWAYS AS IDENTITY, "
+ "Name VARCHAR(255), Salary INT NOT NULL, "
+ "Location VARCHAR(255), "
+ "PRIMARY KEY (Id))";
String query = "INSERT INTO Employees("
+ "Name, Salary, Location) VALUES "
+ "('Amit', 30000, 'Hyderabad'), "
+ "('Kalyan', 40000, 'Vishakhapatnam'), "
+ "('Renuka', 50000, 'Delhi'), "
+ "('Archana', 15000, 'Mumbai'), "
+ "('Trupthi', 45000, 'Kochin'), "
+ "('Suchatra', 33000, 'Pune'), "
+ "('Rahul', 39000, 'Lucknow'), "
+ "('Trupti', 45000, 'Kochin')";
//Executing the query
String query = "SELECT Id, Name, Salary FROM Employees";
ResultSet rs = stmt.executeQuery(query);
while(rs.next()) {
System.out.println("Id: "+rs.getString("Id"));
System.out.println("Name: "+rs.getString("Name"));
System.out.println("Salary: "+rs.getString("Salary"));
System.out.println(" ");
}
}
}
输出
执行上述程序后，将获得以下输出
Id: 1 Name: Amit Salary: 30000 Id: 2 Name: Kalyan Salary: 43000 Id: 3 Name: Renuka Salary: 50000 Id: 4 Name: Archana Salary: 15000 Id: 5 Name: Trupthi Salary: 45000 Id: 6 Name: Suchatra Salary: 33000 Id: 7 Name: Rahul Salary: 39000
Apache Derby - 更新数据
UPDATE 语句用于更新表中的数据。Apache Derby 提供两种类型的更新（语法），即搜索更新和定位更新。
搜索 UPDATE 语句更新表的指定列。
语法
以下是 UPDATE 查询的语法：
ij> UPDATE table_name SET column_name = value, column_name = value, ... WHERE conditions;
WHERE 子句可以使用比较运算符，例如 =、!=、<、>、<= 和 >=，以及 BETWEEN 和 LIKE 运算符。
示例
假设数据库中有一个 Employee 表，其中包含 4 条记录，如下所示：
ID |NAME |SALARY |LOCATION ---------------------------------------------------------- 1 |Amit |30000 |Hyderabad 2 |Kalyan |40000 |Vishakhapatnam 3 |Renuka |50000 |Delhi 4 |Archana|15000 |Mumbai
以下 SQL UPDATE 语句更新姓名为 Kaylan 的员工的位置和工资。
ij> UPDATE Employees SET Location = 'Chennai', Salary = 43000 WHERE Name = 'Kalyan'; 1 rows inserted/updated/deleted
如果您获取 Employees 表的内容，您可以观察到 UPDATE 查询所做的更改。
ij> select * from Employees; ID |NAME |SALARY |LOCATION ---------------------------------------------------------- 1 |Amit |30000 |Hyderabad 2 |Kalyan |43000 |Chennai 3 |Renuka |50000 |Delhi 4 |Archana|15000 |Mumbai 4 rows selected
使用 JDBC 程序更新数据
本节说明如何使用 JDBC 应用程序更新 Apache Derby 数据库中表中现有记录。
如果要使用网络客户端请求 Derby 网络服务器，请确保服务器正在运行。网络客户端驱动程序的类名为 org.apache.derby.jdbc.ClientDriver，URL 为 jdbc:derby://127.0.0.1:1527/DATABASE_NAME;create=true;user=USER_NAME;password=PASSWORD。
请按照以下步骤更新 Apache Derby 中表中现有记录。
步骤 1：注册驱动程序
要与数据库通信，首先需要注册驱动程序。Class 类的 forName() 方法接受一个表示类名的字符串值，将其加载到内存中，这会自动注册它。使用此方法注册驱动程序。
步骤 2：获取连接
通常，我们与数据库通信的第一步是连接到它。Connection 类表示与数据库服务器的物理连接。您可以通过调用 **DriverManager** 类的 **getConnection()** 方法来创建连接对象。使用此方法创建连接。
步骤 3：创建语句对象
您需要创建 **Statement** 或 **PreparedStatement** 或 **CallableStatement** 对象来向数据库发送 SQL 语句。您可以分别使用 **createStatement()**、**prepareStatement()** 和 **prepareCall()** 方法创建这些对象。使用适当的方法创建其中任何一个对象。
步骤 4：执行查询
创建语句后，您需要执行它。**Statement** 类提供各种方法来执行查询，例如 **execute()** 方法执行返回多个结果集的语句。**executeUpdate()** 方法执行 INSERT、UPDATE、DELETE 等查询。**executeQuery()** 方法返回数据。使用这些方法中的任何一种并执行先前创建的语句。
示例
下面的 JDBC 示例演示了如何使用 JDBC 程序更新 Apache Derby 中表中现有记录。在这里，我们使用嵌入式驱动程序连接到名为 sampleDB 的数据库（如果不存在则创建）。
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
public class UpdateData {
public static void main(String args[]) throws Exception {
//Registering the driver
Class.forName("org.apache.derby.jdbc.EmbeddedDriver");
//Getting the Connection object
String URL = "jdbc:derby:sampleDB;create=true";
Connection conn = DriverManager.getConnection(URL);
//Creating the Statement object
Statement stmt = conn.createStatement();
//Creating a table and populating it
String query = "CREATE TABLE Employees("
+ "Id INT NOT NULL GENERATED ALWAYS AS IDENTITY, "
+ "Name VARCHAR(255), Salary INT NOT NULL, "
+ "Location VARCHAR(255), "
+ "PRIMARY KEY (Id))";
String query = "INSERT INTO Employees("
+ "Name, Salary, Location) VALUES "
+ "('Amit', 30000, 'Hyderabad'), "
+ "('Kalyan', 40000, 'Vishakhapatnam'), "
+ "('Renuka', 50000, 'Delhi'), "
+ "('Archana', 15000, 'Mumbai'), "
+ "('Trupthi', 45000, 'Kochin'), "
+ "('Suchatra', 33000, 'Pune'), "
+ "('Rahul', 39000, 'Lucknow'), "
+ "('Trupti', 45000, 'Kochin')";
//Executing the query
String query = "UPDATE Employees SET Location = 'Chennai', Salary = 43000 WHERE
Name = 'Kalyan'";
int num = stmt.executeUpdate(query);
System.out.println("Number of records updated are: "+num);
}
}
输出
执行上述程序后，将获得以下输出：
Number of records updated are: 1
Apache Derby - 删除数据
DELETE 语句用于删除表行。与 UPDATE 语句一样，Apache Derby 提供两种类型的 Delete（语法）：**searched** 删除和 **positioned** 删除。
searched delete 语句删除表中所有指定的列。
语法
DELETE 语句的语法如下：
ij> DELETE FROM table_name WHERE condition;
示例
假设我们有一个名为 employee 的表，其中包含 5 条记录，如下所示：
ID |NAME |SALARY |LOCATION ---------------------------------------------------------------------------- 1 |Amit |30000 |Hyderabad 2 |Kalyan |40000 |Vishakhapatnam 3 |Renuka |50000 |Delhi 4 |Archana|15000 |Mumbai 5 |Trupti |45000 |Kochin 5 rows selected
以下 SQL DELETE 语句删除名为 Trupti 的记录。
ij> DELETE FROM Employees WHERE Name = 'Trupti'; 1 row inserted/updated/deleted
如果您获取 Employees 表的内容，您将只能看到如下所示的四条记录：
ID |NAME |SALARY |LOCATION ---------------------------------------------------------------------------- 1 |Amit |30000 |Hyderabad 2 |Kalyan |40000 |Vishakhapatnam 3 |Renuka |50000 |Delhi 4 |Archana|15000 |Mumbai 4 rows selected
要删除表中的所有记录，请在不使用 where 子句的情况下执行相同的查询。
ij> DELETE FROM Employees; 4 rows inserted/updated/deleted
现在，如果您尝试获取 Employee 表的内容，您将得到一个空表，如下所示：
ij> select * from employees; ID |NAME |SALARY |LOCATION -------------------------------------------------------- 0 rows selected
使用 JDBC 程序删除数据
本节说明如何使用 JDBC 应用程序删除 Apache Derby 数据库中表中现有记录。
如果您想使用网络客户端请求 Derby 网络服务器，请确保服务器已启动并正在运行。网络客户端驱动程序的类名为 org.apache.derby.jdbc.ClientDriver，URL 为 jdbc:derby://127.0.0.1:1527/DATABASE_NAME;create=true;user=USER_NAME;password=PASSWORD"。
请按照以下步骤删除 Apache Derby 中表中现有记录：
步骤 1：注册驱动程序
首先，您需要注册驱动程序才能与数据库通信。**Class** 类的 **forName()** 方法接受一个表示类名的字符串值，将其加载到内存中，这会自动注册它。使用此方法注册驱动程序。
步骤 2：获取连接
通常，我们与数据库通信的第一步是连接到它。**Connection** 类表示与数据库服务器的物理连接。您可以通过调用 **DriverManager** 类的 **getConnection()** 方法来创建连接对象。使用此方法创建连接。
步骤 3：创建语句对象
需要创建 Statement、PreparedStatement 或 CallableStatement 对象才能将 SQL 语句发送到数据库。可以使用 createStatement()、prepareStatement() 和 prepareCall() 方法分别创建这些对象。使用适当的方法创建这些对象中的任何一个。
步骤 4：执行查询
创建语句后，您需要执行它。**Statement** 类提供各种方法来执行查询，例如 **execute()** 方法执行返回多个结果集的语句。**executeUpdate()** 方法执行 INSERT、UPDATE、DELETE 等查询。**executeQuery()** 方法返回数据的结果。使用这些方法中的任何一种并执行先前创建的语句。
示例
下面的 JDBC 示例演示了如何使用 JDBC 程序删除 Apache Derby 中表中现有记录。在这里，我们使用嵌入式驱动程序连接到名为 sampleDB 的数据库（如果不存在则创建）。
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
public class DeleteData {
public static void main(String args[]) throws Exception {
//Registering the driver
Class.forName("org.apache.derby.jdbc.EmbeddedDriver");
//Getting the Connection object
String URL = "jdbc:derby:sampleDB;create=true";
Connection conn = DriverManager.getConnection(URL);
//Creating the Statement object
Statement stmt = conn.createStatement();
//Creating a table and populating it
String query = "CREATE TABLE Employees("
+ "Id INT NOT NULL GENERATED ALWAYS AS IDENTITY, "
+ "Name VARCHAR(255), Salary INT NOT NULL, "
+ "Location VARCHAR(255), "
+ "PRIMARY KEY (Id))";
String query = "INSERT INTO Employees("
+ "Name, Salary, Location) VALUES "
+ "('Amit', 30000, 'Hyderabad'), "
+ "('Kalyan', 40000, 'Vishakhapatnam'), "
+ "('Renuka', 50000, 'Delhi'), "
+ "('Archana', 15000, 'Mumbai'), "
+ "('Trupthi', 45000, 'Kochin'), "
+ "('Suchatra', 33000, 'Pune'), "
+ "('Rahul', 39000, 'Lucknow'), "
+ "('Trupthi', 45000, 'Kochin')";
//Executing the query
String query = "DELETE FROM Employees WHERE Name = 'Trupthi'";
int num = stmt.executeUpdate(query);
System.out.println("Number of records deleted are: "+num);
}
}
输出
执行上述程序后，将获得以下输出：
Number of records deleted are: 1
Apache Derby - WHERE 子句
WHERE 子句用于 SELECT、DELETE 或 UPDATE 语句中，以指定需要对其执行操作的行。通常，此子句后跟一个返回布尔值的条件或表达式，仅对满足给定条件的行执行 Select、delete 或 update 操作。
ij> SELECT * from table_name WHERE condition; or, ij> DELETE from table_name WHERE condition; or, ij> UPDATE table_name SET column_name = value WHERE condition;
WHERE 子句可以使用比较运算符，例如 =、!=、<、>、<= 和 >=，以及 BETWEEN 和 LIKE 运算符。
示例
让我们假设数据库中有一个名为 Employees 的表，其中包含 7 条记录，如下所示：
ID |NAME |SALARY |LOCATION ----------------------------------------------------------------------------- 1 |Amit |30000 |Hyderabad 2 |Kalyan |40000 |Vishakhapatnam 3 |Renuka |50000 |Delhi 4 |Archana |15000 |Mumbai 5 |Trupthi |45000 |Kochin 6 |Suchatra |33000 |Pune 7 |Rahul |39000 |Lucknow
以下 SQL DELETE 语句获取薪水超过 35000 的员工的记录：
ij> SELECT * FROM Employees WHERE Salary>35000;
这将产生以下输出：
ID |NAME |SALARY |LOCATION --------------------------------------------------- 2 |Kalyan |40000 |Vishakhapatnam 3 |Renuka |50000 |Delhi 5 |Trupthi|45000 |Kochin 7 |Rahul |39000 |Lucknow 4 rows selected
同样，您也可以使用此子句删除和更新记录。
以下示例更新薪水低于 30000 的员工的地址。
ij> UPDATE Employees SET Location = 'Vijayawada' WHERE Salary<35000; 3 rows inserted/updated/deleted
如果您验证表的内容，您将看到如下所示的更新后的表：
ij> SELECT * FROM Employees; ID |NAME |SALARY |LOCATION ------------------------------------------------------------------------------ 1 |Amit |30000 |Vijayawada 2 |Kalyan |40000 |Vishakhapatnam 3 |Renuka |50000 |Delhi 4 |Archana |15000 |Vijayawada 5 |Trupthi |45000 |Kochin 6 |Suchatra|33000 |Vijayawada 7 |Rahul |39000 |Lucknow 7 rows selected
Where 子句 JDBC 示例
本节将教您如何在 Apache Derby 数据库中使用 WHERE 子句并使用 JDBC 应用程序对表执行 CURD 操作。
如果您想使用网络客户端请求 Derby 网络服务器，请确保服务器已启动并正在运行。网络客户端驱动程序的类名为 org.apache.derby.jdbc.ClientDriver，URL 为 jdbc:derby://127.0.0.1:1527/DATABASE_NAME;create=true;user=USER_NAME;password=PASSWORD"。
请按照以下步骤使用 WHERE 子句并对 Apache Derby 中的表执行 CURD 操作
步骤 1：注册驱动程序
要与数据库通信，首先需要注册驱动程序。**Class** 类的 **forName()** 方法接受一个表示类名的字符串值，将其加载到内存中，这会自动注册它。使用此方法注册驱动程序
步骤 2：获取连接
通常，与数据库通信的第一步是连接到它。Connection 类表示与数据库服务器的物理连接。可以通过调用 DriverManager 类的 getConnection() 方法来创建连接对象。使用此方法创建连接。
步骤 3：创建语句对象
需要创建 Statement、PreparedStatement 或 CallableStatement 对象才能将 SQL 语句发送到数据库。可以使用 createStatement()、prepareStatement() 和 prepareCall() 方法分别创建这些对象。使用适当的方法创建这些对象中的任何一个。
步骤 4：执行查询
创建语句后，您需要执行它。**Statement** 类提供各种方法来执行查询，例如 **execute()** 方法执行返回多个结果集的语句。**executeUpdate()** 方法执行 INSERT、UPDATE、DELETE 等查询。**executeQuery()** 方法返回数据的结果。使用这些方法中的任何一种并执行先前创建的语句。
示例
下面的 JDBC 示例演示了如何使用 WHERE 子句并使用 JDBC 程序在 Apache Derby 中对表执行 CURD 操作。在这里，我们使用嵌入式驱动程序连接到名为 sampleDB 的数据库（如果不存在则创建）。
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;
import java.sql.ResultSet;
public class WhereClauseExample {
public static void main(String args[]) throws Exception {
//Registering the driver
Class.forName("org.apache.derby.jdbc.EmbeddedDriver");
//Getting the Connection object
String URL = "jdbc:derby:sampleDB;create=true";
Connection conn = DriverManager.getConnection(URL);
//Creating the Statement object
Statement stmt = conn.createStatement();
//Creating a table and populating it
String query = "CREATE TABLE Employees("
+ "Id INT NOT NULL GENERATED ALWAYS AS IDENTITY, "
+ "Name VARCHAR(255), Salary INT NOT NULL, "
+ "Location VARCHAR(255), "
+ "PRIMARY KEY (Id))";
String query = "INSERT INTO Employees("
+ "Name, Salary, Location) VALUES "
+ "('Amit', 30000, 'Hyderabad'), "
+ "('Kalyan', 40000, 'Vishakhapatnam'), "
+ "('Renuka', 50000, 'Delhi'), "
+ "('Archana', 15000, 'Mumbai'), "
+ "('Trupthi', 45000, 'Kochin'), "
+ "('Suchatra', 33000, 'Pune'), "
+ "('Rahul', 39000, 'Lucknow'), "
+ "('Trupti', 45000, 'Kochin')";
//Executing the query
String query = "SELECT * FROM Employees WHERE Salary>35000";
ResultSet rs = stmt.executeQuery(query);
while(rs.next()) {
System.out.println("Id: "+rs.getString("Id"));
System.out.println("Name: "+rs.getString("Name"));
System.out.println("Salary: "+rs.getString("Salary"));
System.out.println("Location: "+rs.getString("Location"));
System.out.println(" ");
}
}
}
输出
执行上述程序后，将获得以下输出：
Id: 2 Name: Kalyan Salary: 43000 Location: Chennai Id: 3 Name: Renuka Salary: 50000 Location: Delhi Id: 5 Name: Trupthi Salary: 45000 Location: Kochin Id: 7 Name: Rahul Salary: 39000 Location: Lucknow
Apache Derby - GROUP BY 子句
GROUP BY 子句与 SELECT 语句一起使用。它用于在数据相同的情况下形成子集。通常，此子句后跟 ORDER BY 子句，并放在 WHERE 子句之后。
语法
以下是 GROUP BY 子句的语法：
ij>SELECT column1, column2, . . . table_name GROUP BY column1, column2, . . .;
示例
假设数据库中有一个名为 Employees 的表，其中包含以下记录：
ID |NAME |SALARY |LOCATION ------------------------------------------------------------------ 1 |Amit |30000 |Hyderabad 2 |Rahul |39000 |Lucknow 3 |Renuka |50000 |Hyderabad 4 |Archana |15000 |Vishakhapatnam 5 |Kalyan |40000 |Hyderabad 6 |Trupthi |45000 |Vishakhapatnam 7 |Raghav |12000 |Lucknow 8 |Suchatra|33000 |Vishakhapatnam 9 |Rizwan |20000 |Lucknow
以下带有 GROUP BY 子句的 SELECT 语句根据地址对表进行分组。它显示了在某个地址向员工支付的总薪水。
ij> SELECT Location, SUM(Salary) from Employees GROUP BY Location;
这将生成以下输出：
LOCATION |2 ------------------------------------------------------- Hyderabad |120000 Lucknow |71000 Vishakhapatnam |93000 3 rows selected
同样，以下查询查找在某个地址上用于员工薪水的平均支出。
ij> SELECT Location, AVG(Salary) from Employees GROUP BY Location;
这将生成以下输出：
LOCATION |2 ----------------------------------------------------- Hyderabad |40000 Lucknow |23666 Vishakhapatnam |31000 3 rows selected
Group By 子句 JDBC 示例
本节将教您如何在 Apache Derby 数据库中使用 Group By 子句并使用 JDBC 应用程序对表执行 CURD 操作。
如果要使用网络客户端请求 Derby 网络服务器，请确保服务器正在运行。网络客户端驱动程序的类名为 org.apache.derby.jdbc.ClientDriver，URL 为 jdbc:derby://127.0.0.1:1527/DATABASE_NAME;create=true;user=USER_NAME;password=PASSWORD。
请按照以下步骤使用 Group By 子句并对 Apache Derby 中的表执行 CURD 操作
步骤 1：注册驱动程序
要与数据库通信，首先需要注册驱动程序。Class 类的 forName() 方法接受一个表示类名的字符串值，将其加载到内存中，这会自动注册它。使用此方法注册驱动程序。
步骤 2：获取连接
通常，与数据库通信的第一步是连接到它。Connection 类表示与数据库服务器的物理连接。可以通过调用 DriverManager 类的 getConnection() 方法来创建连接对象。使用此方法创建连接。
步骤 3：创建语句对象
需要创建 Statement、PreparedStatement 或 CallableStatement 对象才能将 SQL 语句发送到数据库。可以使用 createStatement()、prepareStatement() 和 prepareCall() 方法分别创建这些对象。使用适当的方法创建这些对象中的任何一个。
步骤 4：执行查询
创建语句后，您需要执行它。**Statement** 类提供各种方法来执行查询，例如 **execute()** 方法执行返回多个结果集的语句。**executeUpdate()** 方法用于执行 INSERT、UPDATE、DELETE 等查询。**executeQuery()** 方法返回数据。使用这些方法中的任何一种并执行先前创建的语句。
示例
下面的 JDBC 示例演示了如何使用 **Group By** 子句并使用 JDBC 程序在 Apache Derby 中对表执行 CURD 操作。在这里，我们使用嵌入式驱动程序连接到名为 sampleDB 的数据库（如果不存在则创建）。
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;
import java.sql.ResultSet;
public class GroupByClauseExample {
public static void main(String args[]) throws Exception {
//Registering the driver
Class.forName("org.apache.derby.jdbc.EmbeddedDriver");
//Getting the Connection object
String URL = "jdbc:derby:sampleDB;create=true";
Connection conn = DriverManager.getConnection(URL);
//Creating the Statement object
Statement stmt = conn.createStatement();
//Creating a table and populating it
stmt.execute("CREATE TABLE EmployeesData( "
+ "Id INT NOT NULL GENERATED ALWAYS AS IDENTITY, "
+ "Name VARCHAR(255), "
+ "Salary INT NOT NULL, "
+ "Location VARCHAR(255), "
+ "PRIMARY KEY (Id))");
stmt.execute("INSERT INTO EmployeesData(Name, Salary, Location) "
+ "VALUES ('Amit', 30000, 'Hyderabad'), "
+ "('Rahul', 39000, 'Lucknow'), "
+ "('Renuka', 50000, 'Hyderabad'), "
+ "('Archana', 15000, 'Vishakhapatnam'), "
+ "('Kalyan', 40000, 'Hyderabad'), "
+ "('Trupthi', 45000, 'Vishakhapatnam'), "
+ "('Raghav', 12000, 'Lucknow'), "
+ "('Suchatra', 33000, 'Vishakhapatnam'), "
+ "('Rizwan', 20000, 'Lucknow')");
//Executing the query
String query = "SELECT Location, SUM(Salary) from EmployeesData GROUP BY Location";
ResultSet rs = stmt.executeQuery(query);
while(rs.next()) {
System.out.println("Location: "+rs.getString(1));
System.out.println("Sum of salary: "+rs.getString(2));
System.out.println(" ");
}
}
}
输出
执行上述程序后，将获得以下输出：
Location: Hyderabad Sum of salary: 120000 Location: Lucknow Sum of salary: 71000 Location: Vishakhapatnam Sum of salary: 93000
Apache Derby - ORDER BY 子句
ORDER BY 子句用于按其使用的关键字排列结果集的内容，ASC 表示升序，DESC 表示降序。如果您没有提及任何一个，则内容将默认按升序排列。
语法
以下是 ORDER BY 子句的语法：
SELECT * FROM table_name ORDER BY column_name ASC|DESC.
示例
假设数据库中有一个名为 Employees 的表，其中包含以下记录：
ID |NAME |SALARY |LOCATION ------------------------------------------------------------------------------ 1 |Amit |30000 |Vijayawada 2 |Kalyan |40000 |Vishakhapatnam 3 |Renuka |50000 |Delhi 4 |Archana |15000 |Vijayawada 5 |Trupthi |45000 |Kochin 6 |Suchatra|33000 |Vijayawada 7 |Rahul |39000 |Lucknow
以下查询根据员工姓名按升序排列表的内容。
ij> SELECT * FROM Employees ORDER BY Name;
这将生成以下输出：
ID |NAME |SALARY |LOCATION --------------------------------------------------------------- 1 |Amit |30000 |Hyderabad 4 |Archana |15000 |Mumbai 2 |Kalyan |40000 |Vishakhapatnam 7 |Rahul |39000 |Lucknow 3 |Renuka |50000 |Delhi 6 |Suchatra|33000 |Pune 5 |Trupthi |45000 |Kochin 7 rows selected
同样，以下查询根据员工薪水按降序排列表的内容：
ij> SELECT * FROM Employees ORDER BY Salary DESC;
这将生成以下输出：
ID |NAME |SALARY |LOCATION --------------------------------------------------------------- 3 |Renuka |50000 |Delhi 5 |Trupthi |45000 |Kochin 2 |Kalyan |40000 |Vishakhapatnam 7 |Rahul |39000 |Lucknow 6 |Suchatra |33000 |Pune 1 |Amit |30000 |Hyderabad 4 |Archana |15000 |Mumbai 7 rows selected
使用 JDBC 程序排序数据
本节将教您如何在 Derby 中使用 JDBC 对表的内容进行排序。您可以使用 ORDER BY 子句和关键字 ASC（表示升序）和 DSC（表示降序）按顺序排列记录。
如果您想使用网络客户端请求 Derby 网络服务器，请确保服务器已启动并正在运行。网络客户端驱动程序的类名为 org.apache.derby.jdbc.ClientDriver，URL 为 jdbc:derby://127.0.0.1:1527/DATABASE_NAME;create=true;user=USER_NAME;password=PASSWORD"。
请按照以下步骤对 Apache Derby 中表的记录进行排序：
步骤 1：注册驱动程序
要与数据库通信，首先需要注册驱动程序。Class 类的 forName() 方法接受一个表示类名的字符串值，将其加载到内存中，这会自动注册它。使用此方法注册驱动程序。
步骤 2：获取连接
通常，与数据库通信的第一步是连接到它。Connection 类表示与数据库服务器的物理连接。可以通过调用 DriverManager 类的 getConnection() 方法来创建连接对象。使用此方法创建连接。步骤 3：创建语句对象
需要创建 Statement、PreparedStatement 或 CallableStatement 对象才能将 SQL 语句发送到数据库。可以使用 createStatement()、prepareStatement() 和 prepareCall() 方法分别创建这些对象。使用适当的方法创建这些对象中的任何一个。
步骤 4：执行查询
创建语句后，您需要执行它。**Statement** 类提供各种方法来执行查询，例如 **execute()** 方法执行返回多个结果集的语句。**executeUpdate()** 方法执行 INSERT、UPDATE、DELETE 等查询。**executeQuery()** 方法返回数据。使用这些方法中的任何一种并执行先前创建的语句。
示例
下面的 JDBC 示例演示了如何使用 JDBC 程序对 Apache Derby 中表的记录进行排序。在这里，我们使用嵌入式驱动程序连接到名为 sampleDB 的数据库（如果不存在则创建）。
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class SortData {
public static void main(String args[]) throws SQLException, ClassNotFoundException {
//Registering the driver
Class.forName("org.apache.derby.jdbc.EmbeddedDriver");
//Getting the Connection object
String URL = "jdbc:derby:SampleDB;create=true";
Connection conn = DriverManager.getConnection(URL);
//Creating the Statement object
Statement stmt = conn.createStatement();
//Creating a table and populating it
String query = "CREATE TABLE Employees("
+ "Id INT NOT NULL GENERATED ALWAYS AS IDENTITY, "
+ "Name VARCHAR(255), Salary INT NOT NULL, "
+ "Location VARCHAR(255), "
+ "PRIMARY KEY (Id))";
String query = "INSERT INTO Employees("
+ "Name, Salary, Location) VALUES "
+ "('Amit', 30000, 'Hyderabad'), "
+ "('Kalyan', 40000, 'Vishakhapatnam'), "
+ "('Renuka', 50000, 'Delhi'), "
+ "('Archana', 15000, 'Mumbai'), "
+ "('Trupthi', 45000, 'Kochin'), "
+ "('Suchatra', 33000, 'Pune'), "
+ "('Rahul', 39000, 'Lucknow'), "
+ "('Trupti', 45000, 'Kochin')";
//Executing the query
String query = "SELECT Location, SUM(Salary) " + "from Employees GROUP BY Location";
ResultSet rs = stmt.executeQuery(query);
while(rs.next()) {
System.out.println("Salary: "+rs.getString(1));
System.out.println("Location: "+rs.getString(2));
System.out.println(" ");
}
}
}
输出
执行上述程序后，将获得以下输出：
Salary: Chennai Location: 43000 Salary: Delhi Location: 50000 Salary: Hyderabad Location: 30000 Salary: Kochin Location: 45000 Salary: Lucknow Location: 39000 Salary: Mumbai Location: 15000 Salary: Pune Location: 33000
Apache Derby - HAVING 子句
HAVING 子句使您可以指定条件，以筛选结果中显示哪些组结果。
WHERE 子句对选定的列设置条件，而 HAVING 子句对 GROUP BY 子句创建的组设置条件。
语法
以下是 HAVING 子句的语法：
ij> SELECT column1, column2 . . . from table_name GROUP BY column having condition;
示例
假设数据库中有一个名为 Employees 的表，其中包含如下所示的 13 条记录：
ID |NAME |SALARY |LOCATION ------------------------------------------------------------------ 1 |Amit |30000 |Hyderabad 2 |Rahul |39000 |Lucknow 3 |Kalyan |40000 |Vishakhapatnam 4 |Renuka |50000 |Hyderabad 5 |Archana |15000 |Vishakhapatnam 6 |Krishna |40000 |Hyderabad 7 |Trupthi |45000 |Vishakhapatnam 8 |Raghav |12000 |Lucknow 9 |Radha |50000 |Delhi 10 |Anirudh |15000 |Mumbai 11 |Tara |45000 |Kochin 12 |Sucharita|44000 |Kochin 13 |Rizwan |20000 |Lucknow
以下查询显示至少有 3 名员工的地址中员工的最高薪水：
ij> SELECT Location, MAX(Salary) from Employees GROUP BY Location having count(Location)>=3;
这将生成以下输出：
LOCATION |2 ------------------------------------------------------------ Hyderabad |50000 Lucknow |39000 Vishakhapatnam |45000 3 rows selected
使用 JDBC 程序排序数据
本节将教您如何在 Apache Derby 数据库中使用 Having 子句以及 JDBC 应用程序。
如果要使用网络客户端请求 Derby 网络服务器，请确保服务器正在运行。网络客户端驱动程序的类名为 org.apache.derby.jdbc.ClientDriver，URL 为 jdbc:derby://127.0.0.1:1527/DATABASE_NAME;create=true;user=USER_NAME;password=PASSWORD。
请按照以下步骤对 Apache Derby 中表的记录进行排序
步骤 1：注册驱动程序
要与数据库通信，首先需要注册驱动程序。**Class** 类的 **forName()** 方法接受一个表示类名的字符串值，并将其加载到内存中，这会自动注册它。使用此方法注册驱动程序。
步骤 2：获取连接
通常，与数据库通信的第一步是连接到它。Connection 类表示与数据库服务器的物理连接。可以通过调用 DriverManager 类的 getConnection() 方法来创建连接对象。使用此方法创建连接。
步骤 3：创建语句对象
需要创建 Statement、PreparedStatement 或 CallableStatement 对象才能将 SQL 语句发送到数据库。可以使用 createStatement()、prepareStatement() 和 prepareCall() 方法分别创建这些对象。使用适当的方法创建这些对象中的任何一个。
步骤 4：执行查询
创建语句后，您需要执行它。**Statement** 类提供各种方法来执行查询，例如 **execute()** 方法执行返回多个结果集的语句。**executeUpdate()** 方法执行 INSERT、UPDATE、DELETE 等查询。**executeQuery()** 方法返回数据。使用这些方法中的任何一种并执行先前创建的语句。
示例
下面的 JDBC 示例演示了如何使用 Group By 子句并使用 JDBC 程序在 Apache Derby 中对表执行 CURD 操作。在这里，我们使用嵌入式驱动程序连接到名为 sampleDB 的数据库（如果不存在则创建）。
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;
import java.sql.ResultSet;
public class HavingClauseExample {
public static void main(String args[]) throws Exception {
//Registering the driver
Class.forName("org.apache.derby.jdbc.EmbeddedDriver");
//Getting the Connection object
String URL = "jdbc:derby:sampleDB;create=true";
Connection conn = DriverManager.getConnection(URL);
//Creating the Statement object
Statement stmt = conn.createStatement();
//Creating a table and populating it
stmt.execute("CREATE TABLE EmployeesData( "
+ "Id INT NOT NULL GENERATED ALWAYS AS IDENTITY, "
+ "Name VARCHAR(255), "
+ "Salary INT NOT NULL, "
+ "Location VARCHAR(255), "
+ "PRIMARY KEY (Id))");
stmt.execute("INSERT INTO EmployeesData(Name, Salary, Location) "
+ "VALUES ('Amit', 30000, 'Hyderabad'), "
+ "('Rahul', 39000, 'Lucknow'), "
+ "('Renuka', 50000, 'Hyderabad'), "
+ "('Archana', 15000, 'Vishakhapatnam'), "
+ "('Kalyan', 40000, 'Hyderabad'), "
+ "('Trupthi', 45000, 'Vishakhapatnam'), "
+ "('Raghav', 12000, 'Lucknow'), "
+ "('Suchatra', 33000, 'Vishakhapatnam'), "
+ "('Rizwan', 20000, 'Lucknow')");
//Executing the query
String query = "SELECT Location, MAX(Salary) "
+ "from EmployeesData GROUP BY Location having "
+ "count(Location)>=3";
ResultSet rs = stmt.executeQuery(query);
while(rs.next()) {
System.out.println(rs.getString(1));
System.out.println(rs.getString(2));
System.out.println(" ");
}
}
}
输出
执行上述程序后，将获得以下输出：
Hyderabad 50000 Lucknow 39000 Vishakhapatnam 45000
Apache Derby - ALTER TABLE 语句
ALTER TABLE 语句允许您修改现有表。使用它，您可以执行以下操作：
添加列，添加约束
删除列，删除约束
更改表的行级锁定
让我们假设我们创建了一个名为 Employees 的表，如下所示：
ij> CREATE TABLE Employees ( Id INT NOT NULL GENERATED ALWAYS AS IDENTITY, Name VARCHAR(255), Salary INT NOT NULL, Location VARCHAR(255), PRIMARY KEY (Id) );
并且，使用 insert 语句插入了四条记录，如下所示：
ij> INSERT INTO Employees (Name, Salary, Location) VALUES
('Amit', 30000, 'Hyderabad'),
('Kalyan', 40000, 'Vishakhapatnam'),
('Renuka', 50000, 'Delhi'),
('Archana', 15000, 'Mumbai');
向表中添加列
以下是使用 ALTER 语句向表中添加列的语法。
ALTER TABLE table_name ADD COLUMN column_name column_type;
示例
使用ALTER语句，我们尝试添加一个名为Age的新列，类型为整数。
ALTER TABLE Employees ADD COLUMN Age INT; 0 rows inserted/updated/deleted
添加另一个名为Phone_No的新列，类型为整数。
ALTER TABLE Employees ADD COLUMN Phone_No BIGINT; 0 rows inserted/updated/deleted
DESCRIBE命令描述指定的表，列出其列和详细信息（如果表存在）。如果DESCRIBE Employees表，您可以观察到如下所示新添加的列：
ij> DESCRIBE Employees; COLUMN_NAME |TYPE_NAME|DEC&|NUM&|COLUM&|COLUMN_DEF|CHAR_OCTE&|IS_NULL& ------------------------------------------------------------------------------ ID |INTEGER |0 |10 |10 |AUTOINCRE&|NULL |NO NAME |VARCHAR |NULL|NULL |255 |NULL | 510 |YES SALARY |INTEGER |0 |10 |10 |NULL |NULL |NO LOCATION |VARCHAR |NULL|NULL |255 |NULL | 510 |YES AGE |INTEGER |0 |10 |10 |NULL |NULL |YES PHONE_NO |INTEGER |0 |10 |10 |NULL |NULL |YES 6 rows selected
向表中添加约束
以下是使用ALTER语句向表的列添加约束的语法。
ALTER TABLE table_name ADD CONSTRAINT constraint_name constraint (column_name);
其中constraint可以是NOT NULL、NULL、PRIMARY KEY、UNIQUE、FOREIGN KEY、CHECK。
示例
使用ALTER语句，我们尝试向Phone_No列添加UNIQUE约束。
ij> ALTER TABLE Employees ADD CONSTRAINT New_Constraint UNIQUE(Phone_No); 0 rows inserted/updated/deleted
一旦您向列添加UNIQUE约束，它就不能对两行具有相同的值，即每个员工的电话号码都必须唯一。
如果您尝试添加两列具有相同电话号码，您将收到如下所示的异常。
ij> INSERT INTO Employees (Name, Salary, Location, Age, Phone_No) VALUES
('Amit', 30000, 'Hyderabad', 30, 9848022338);
1 row inserted/updated/deleted
ij> INSERT INTO Employees (Name, Salary, Location, Age, Phone_No) VALUES
('Sumit', 35000, 'Chennai', 25, 9848022338);
ERROR 23505: The statement was aborted because it would have caused a duplicate
key value in a unique or primary key constraint or unique index identified by
'NEW_CONSTRAINT' defined on 'EMPLOYEES'.
从表中删除约束
以下是删除列约束的语法：
ALTER TABLE table_name DROP CONSTRAINT constraint_name;
示例
以下查询删除上面创建的Phone_No列上的约束名New_Constraint。
ij> ALTER TABLE Employees DROP CONSTRAINT New_Constraint; 0 rows inserted/updated/deleted
由于我们已删除Phone_No列上的UNIQUE约束，您可以添加具有相同电话号码的列。
ij> INSERT INTO Employees (Name, Salary, Location, Age, Phone_No) VALUES
('Sumit', 35000, 'Chennai', 25, 9848022338);
1 row inserted/updated/deleted
您可以通过以下方式验证表的內容：`select * from Employees`
ID |NAME |SALARY |LOCATION |AGE |PHONE_NO ------------------------------------------------------------------------- 1 |Amit |30000 |Hyderabad|30 |9848022338 2 |Sumit|35000 |Chennai |25 |9848022338 2 rows selected
从表中删除列
以下是删除列的语法。
ALTER TABLE table_name DROP COLUMN column_name;
示例
以下查询删除名为“员工年龄”的列：
ij> ALTER TABLE Employees DROP COLUMN Age; 0 rows inserted/updated/deleted
如果描述该表，您只能看到4列。
ij> DESCRIBE Employees; COLUMN_NAME |TYPE_NAME|DEC&|NUM&|COLUM&|COLUMN_DEF|CHAR_OCTE&|IS_NULL& ------------------------------------------------------------------------------ ID |INTEGER |0 |10 |10 |AUTOINCRE&|NULL |NO NAME |VARCHAR |NULL|NULL|255 |NULL |510 |YES SALARY |INTEGER |0 |10 |10 |NULL |NULL |NO LOCATION |VARCHAR |NULL|NULL|255 |NULL |510 |YES PHONE_NO |BIGINT |0 |10 |19 |NULL |NULL |YES
使用JDBC程序修改表
以下是使用ALTER查询修改表的JDBC程序：
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class AlterTableExample {
public static void main(String args[]) throws Exception {
//Registering the driver
Class.forName("org.apache.derby.jdbc.EmbeddedDriver");
//Getting the Connection object
String URL = "jdbc:derby:sampleDB;create=true";
Connection conn = DriverManager.getConnection(URL);
//Creating the Statement object
Statement stmt = conn.createStatement();
//Executing the query
String createQuery = "CREATE TABLE Employees( "
+ "Id INT NOT NULL GENERATED ALWAYS AS IDENTITY, "
+ "Name VARCHAR(255), "
+ "Salary INT NOT NULL, "
+ "Location VARCHAR(255), "
+ "PRIMARY KEY (Id))";
stmt.execute(createQuery);
System.out.println("Table created");
System.out.println(" ");
//Executing the query
String insertQuery = "INSERT INTO Employees("
+ "Name, Salary, Location) VALUES "
+ "('Amit', 30000, 'Hyderabad'), "
+ "('Kalyan', 40000, 'Vishakhapatnam'), "
+ "('Renuka', 50000, 'Delhi'), "
+ "('Archana', 15000, 'Mumbai'), "
+ "('Trupti', 45000, 'Kochin')";
stmt.execute(insertQuery);
System.out.println("Values inserted");
System.out.println(" ");
//Executing the query
String selectQuery = "SELECT * FROM Employees";
ResultSet rs = stmt.executeQuery(selectQuery);
System.out.println("Contents of the table after inserting the table");
while(rs.next()) {
System.out.println("Id: "+rs.getString("Id"));
System.out.println("Name: "+rs.getString("Name"));
System.out.println("Salary: "+rs.getString("Salary"));
System.out.println("Location: "+rs.getString("Location"));
}
System.out.println(" ");
//Altering the table
stmt.execute("ALTER TABLE Employees ADD COLUMN Age INT");
stmt.execute("ALTER TABLE Employees ADD COLUMN Phone_No BigINT");
stmt.execute("ALTER TABLE Employees " + "ADD CONSTRAINT New_Constraint UNIQUE(Phone_No)");
stmt.execute("INSERT INTO Employees "
+ "(Name, Salary, Location, Age, Phone_No) "
+ "VALUES ('Amit', 30000, 'Hyderabad', 30, 9848022338)");
ResultSet alterResult = stmt.executeQuery("Select * from Employees");
System.out.println("Contents of the table after altering "
+ "the table and inserting values to it: ");
while(alterResult.next()) {
System.out.println("Id: "+alterResult.getString("Id"));
System.out.println("Name: "+alterResult.getString("Name"));
System.out.println("Salary: "+alterResult.getString("Salary"));
System.out.println("Location: "+alterResult.getString("Location"));
System.out.println("Age: "+alterResult.getString("Age"));
System.out.println("Phone_No: "+alterResult.getString("Phone_No"));
}
}
}
输出
执行上述程序后，将生成以下输出：
Table created Values inserted Contents of the table after inserting the table Id: 1 Name: Amit Salary: 30000 Location: Hyderabad Id: 2 Name: Kalyan Salary: 40000 Location: Vishakhapatnam Id: 3 Name: Renuka Salary: 50000 Location: Delhi Id: 4 Name: Archana Salary: 15000 Location: Mumbai Id: 5 Name: Trupti Salary: 45000 Location: Kochin Contents of the table after altering the table and inserting values to it: Id: 1 Name: Amit Salary: 30000 Location: Hyderabad Age: null Phone_No: null Id: 2 Name: Kalyan Salary: 40000 Location: Vishakhapatnam Age: null Phone_No: null Id: 3 Name: Renuka Salary: 50000 Location: Delhi Age: null Phone_No: null Id: 4 Name: Archana Salary: 15000 Location: Mumbai Age: null Phone_No: null Id: 5 Name: Trupti Salary: 45000 Location: Kochin Age: null Phone_No: null Id: 6 Name: Amit Salary: 30000 Location: Hyderabad Age: 30 Phone_No: 9848022338
Apache Derby - Derby 索引
表中的索引只不过是指向其数据的指针。它们用于加快从表中检索数据的速度。
如果我们使用索引，INSERT和UPDATE语句将以较慢的速度执行。而SELECT和WHERE语句将在较短的时间内执行。
创建索引
CREATE INDEX语句用于在Derby数据库的表中创建一个新的索引。
语法
以下是CREATE INDEX语句的语法：
CTREATE INDEX index_name on table_name (column_name);
示例
假设我们在Apache Derby中创建了一个名为Employees的表，如下所示。
CREATE TABLE Emp ( Id INT NOT NULL GENERATED ALWAYS AS IDENTITY, Name VARCHAR(255), Salary INT NOT NULL, Location VARCHAR(255), Phone_Number BIGINT );
以下SQL语句在Employees表名为Salary的列上创建索引。
ij> CREATE INDEX example_index on Emp (Salary); 0 rows inserted/updated/deleted
创建UNIQUE索引
在Apache Derby中，UNIQUE索引用于数据集成。一旦您在表的列上创建UNIQUE索引，它就不允许重复值。
语法
以下是创建唯一索引的语法。
CREATE UNIQUE INDEX index_name on table_name (column_name);
示例
以下示例在Employee表的Id列上创建一个UNIQUE索引。
ij> CREATE UNIQUE INDEX unique_index on Emp (Phone_Number); 0 rows inserted/updated/deleted
一旦您在列上创建了唯一索引，就不能在另一行中为该列输入相同的值。简而言之，具有UNIQUE索引的列不允许重复值。
如下所示在Emp表中插入一行
ij> INSERT INTO Emp(Name, Salary, Location, Phone_Number) VALUES ('Amit',
45000, 'Hyderabad', 9848022338);
1 row inserted/updated/deleted
由于我们在Phone_No列上创建了唯一索引，如果您尝试输入与上一条记录相同的值，则会显示错误。
ij> INSERT INTO Emp(Name, Salary, Location, Phone_Number) VALUES ('Sumit',
35000, 'Chennai', 9848022338);
ERROR 23505: The statement was aborted because it would have caused a duplicate
key value in a unique or primary key constraint or unique index identified by
'UNIQUE_INDEX' defined on 'EMP'.
创建复合索引
您可以在两行上创建一个单一索引，这称为复合索引。
语法
以下是复合索引的语法。
CREATE INDEX index_name on table_name (column_name1, column_name2);
示例
以下索引在Name和Location列上创建复合索引。
ij> CREATE INDEX composite_index on Emp (Name, Location); 0 rows inserted/updated/deleted
显示索引
SHOW INDEXES查询显示表上索引的列表。
语法
以下是SHOW INDEXES语句的语法：
SHOW INDEXES FROM table_name;
示例
以下示例显示Employees表上的索引。
ij> SHOW INDEXES FROM Emp;
这将产生以下结果。
ij> SHOW INDEXES FROM Emp; TABLE_NAME |COLUMN_NAME |NON_U&|TYPE|ASC&|CARDINA&|PAGES ---------------------------------------------------------------------------- EMP |PHONE_NUMBER|false |3 |A |NULL |NULL EMP |NAME |true |3 |A |NULL |NULL EMP |LOCATION |true |3 |A |NULL |NULL EMP |SALARY |true |3 |A |NULL |NULL 4 rows selected
删除索引
Drop Index语句删除/丢弃列上的给定索引。
语法
以下是DROP INDEX语句的语法。
DROP INDEX index_name;
示例
以下示例删除上面创建的名为composite_index和unique_index的索引。
ij> DROP INDEX composite_index; 0 rows inserted/updated/deleted ij>Drop INDEX unique_index; 0 rows inserted/updated/deleted
现在，如果您验证索引列表，您可以看到一列上的索引，因为我们已经删除了其余的索引。
ij> SHOW INDEXES FROM Emp; TABLE_NAME |COLUMN_NAME |NON_U&|TYPE|ASC&|CARDINA&|PAGES ---------------------------------------------------------------------------- EMP |SALARY |true |3 |A |NULL |NULL 1 row selected
使用JDBC程序处理索引
以下JDBC程序演示如何在表的列上创建和删除索引。
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
public class IndexesExample {
public static void main(String args[]) throws Exception {
//Registering the driver
Class.forName("org.apache.derby.jdbc.EmbeddedDriver");
//Getting the Connection object
String URL = "jdbc:derby:MYDATABASE;create=true";
Connection conn = DriverManager.getConnection(URL);
//Creating the Statement object
Statement stmt = conn.createStatement();
//Creating the Emp table
String createQuery = "CREATE TABLE Emp( "
+ "Id INT NOT NULL GENERATED ALWAYS AS IDENTITY, "
+ "Name VARCHAR(255), "
+ "Salary INT NOT NULL, "
+ "Location VARCHAR(255), "
+ "Phone_Number BIGINT )";
stmt.execute(createQuery);
System.out.println("Table created");
System.out.println(" ");
//Creating an Index on the column Salary
stmt.execute("CREATE INDEX example_index on Emp (Salary)");
System.out.println("Index example_index inserted");
System.out.println(" ");
//Creating an Unique index on the column Phone_Number
stmt.execute("CREATE UNIQUE INDEX unique_index on Emp (Phone_Number)");
System.out.println("Index unique_index inserted");
System.out.println(" ");
//Creating a Composite Index on the columns Name and Location
stmt.execute("CREATE INDEX composite_index on Emp (Name, Location)");
System.out.println("Index composite_index inserted");
System.out.println(" ");
//listing all the indexes
System.out.println("Listing all the columns with indexes");
//Dropping indexes
System.out.println("Dropping indexes unique_index and, composite_index ");
stmt.execute("Drop INDEX unique_index");
stmt.execute("DROP INDEX composite_index");
}
}
输出
执行后，将生成以下结果
Table created Index example_index inserted Index unique_index inserted Index composite_index inserted Listing all the columns with indexes Dropping indexes unique_index and, composite_index
Apache Derby - 存储过程
本章将教您如何在Derby中创建和删除过程。
创建过程
您可以使用CREATE PROCEDURE语句创建过程。
语法
以下是CREATE PROCEDURE语句的语法。
CREATE PROCEDURE procedure_name (parameter_type parameter_name1, parameter_type parameter_name2 . . . .) parameter_style;
示例
假设我们在Derby中创建了一个表，如下所示。
CREATE TABLE Emp ( Id INT NOT NULL GENERATED ALWAYS AS IDENTITY, Name VARCHAR(255), Salary INT NOT NULL, Location VARCHAR(255), Phone_Number BIGINT );
并在其中插入值，如下所示：
INSERT INTO Employees(Name, Salary, Location) VALUES
('Amit', 30000, 'Hyderabad'),
('Kalyan', 40000, 'Vishakhapatnam'),
('Renuka', 50000, 'Delhi'),
('Archana', 15000, 'Mumbai'),
('Trupthi', 45000, 'Kochin')";
以下示例创建一个名为Update_Procedure的过程，它接受JAVA参数。
ij> CREATE PROCEDURE Update_Procedure(IN id INTEGER, IN name VARCHAR(10)) PARAMETER STYLE JAVA READS SQL DATA LANGUAGE JAVA EXTERNAL NAME 'ProcedureExample.testProc'; > 0 rows inserted/updated/deleted
其中ProcedureExample类如下所示：
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
public class ProcedureExample {
public static void testProc(int salary, String name) throws Exception {
String connectionURL = "jdbc:derby:MYDATABASE;create=true";
Connection conn = DriverManager.getConnection(connectionURL);
String query = "UPDATE Employees SET SALARY = ? WHERE NAME = ?";
PreparedStatement pstmt = conn.prepareStatement(query);
pstmt.setInt(1, salary);
pstmt.setString (2, name);
pstmt.executeUpdate();
}
}
您可以使用SHOW PROCEDURES查询验证过程列表。
ij> SHOW PROCEDURES; PROCEDURE_SCHEM |PROCEDURE_NAME |REMARKS ------------------------------------------------------------------------ APP |UPDATE_PROCEDURE |ProcedureExample.te& SALES |EXAMPLE_ PROCEDURE |com.example.sales.c& SQLJ |INSTALL_JAR |org.apache.derby.ca& SQLJ |REMOVE_JAR |org.apache.derby.ca& SQLJ |REPLACE_JAR |org.apache.derby.ca& SYSCS_UTIL |SYSCS_BACKUP_DATABASE |org.apache.derby.ca& . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
在这里您可以观察到新创建的过程。
删除过程
您可以使用DROP PROCEDURE语句删除过程。
语法
以下是DROP PROCEDURE语句的语法。
DROP PROCEDURE procedure_name;
示例
以下示例删除上面创建的名为Update_Procedure的过程。
ij> DROP PROCEDURE Update_Procedure; > 0 rows inserted/updated/deleted
Apache Derby - 模式
数据库模式是表示整个数据库逻辑视图的骨架结构。它定义了数据的组织方式以及它们之间关系的关联方式。它制定了要应用于数据的所有约束。
创建模式
您可以使用CREATE SCHEMA语句在Apache Derby中创建模式。
语法
以下是CREATE SCHEMA语句的语法。
CREATE SCHEMA schema_name AUTHORIZATION id
示例
以下示例在Derby数据库中创建一个名为my_schema的模式。
ij> CREATE SCHEMA AUTHORIZATION my_schema; 0 rows inserted/updated/deleted
然后，您可以在此模式中创建一个表，如下所示。
ij> CREATE TABLE my_schema.Emp ( Id INT NOT NULL GENERATED ALWAYS AS IDENTITY, Name VARCHAR(255), Salary INT NOT NULL, Location VARCHAR(255), Phone_Number BIGINT ); > > > > > 0 rows inserted/updated/deleted
您可以使用SHOW SCHEMAS查询验证模式列表，在这里您可以找到已创建的模式列表。
ij> show schemas; TABLE_SCHEM ------------------------------ APP MY_SCHEMA NULLID SQLJ SYS SYSCAT SYSCS_DIAG SYSCS_UTIL SYSFUN SYSIBM SYSPROC SYSSTAT 12 rows selected
删除模式
您可以使用DROP SCHEMA语句删除现有模式。
语法
以下是DROPS SCHEMA语句的语法。
DROP SCHEMA my_schema RESTRICT;
示例
只有在模式中没有任何对象时才能删除模式。要删除模式，请删除其中的所有表，然后删除模式。
ij> DROP TABLE my_schema.Emp; 0 rows inserted/updated/deleted
以下示例删除上面创建的模式。
ij> DROP SCHEMA my_schema RESTRICT; 0 rows inserted/updated/deleted
JDBC示例
以下JDBC示例创建和删除名为my_schema的模式。
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
public class CreateSchemaExample {
public static void main(String args[]) throws Exception {
//Registering the driver
Class.forName("org.apache.derby.jdbc.EmbeddedDriver");
//Getting the Connection object
String URL = "jdbc:derby:sampleDB;create=true";
Connection conn = DriverManager.getConnection(URL);
//Creating the Statement object
Statement stmt = conn.createStatement();
stmt.execute("CREATE SCHEMA AUTHORIZATION my_schema");
//Executing the query
String query = "CREATE TABLE my_schema.Employees( "
+ "Id INT NOT NULL GENERATED ALWAYS AS IDENTITY, "
+ "Name VARCHAR(255), "
+ "Salary INT NOT NULL, "
+ "Location VARCHAR(255), "
+ "PRIMARY KEY (Id))";
stmt.execute(query);
System.out.println("Table created in schema");
stmt.execute("DROP TABLE my_schema.Employees");
stmt.execute("DROP SCHEMA my_schema RESTRICT");
System.out.println("Schema dropped");
}
}
输出
执行上述程序后，将生成以下示例。
Table created in schema Schema dropped
Apache Derby - 触发器
在数据库中，触发器是在发生事件时执行的语句/代码。一旦您为表的特定事件创建触发器，则每次发生事件时都会执行触发器中指定的代码。您可以在单个表上创建多个触发器。
本章将教您如何使用Apache Derby创建和删除触发器。
创建触发器
您可以使用CREATE TRIGGER语句在Derby中创建触发器。
语法
以下是CREATE TRIGGER查询的语法。
CREATE TRIGGER trigger_name
{ NO CASCADE BEFORE | AFTER }
{INSERT [OR] | UPDATE [OR] | DELETE}[OF col_name]
ON table_name
[REFERENCING OLD AS o NEW AS n]
[FOR EACH ROW]
Statement
示例
假设我们在Derby中创建了一个名为Emp的表，如下所示。
CREATE TABLE Emp ( Id INT NOT NULL, Name VARCHAR(255), Salary INT NOT NULL, Location VARCHAR(255) );
并在其中插入了5行。
INSERT INTO Emp(Id, Name, Salary, Location) VALUES (1, 'Amit', 30000, 'Hyderabad'), (2, 'Kalyan', 40000, 'Vishakhapatnam'), (3,'Renuka', 50000, 'Delhi'), (4, 'Archana', 15000, 'Mumbai'), (5, 'Trupthi', 45000, 'Kochin');
如果我们有另一个名为BackUp的表，并且我们的目的是将从Emp表中删除的行存储在此表中。
CREATE TABLE BackUp ( Id INT NOT NULL, Name VARCHAR(255), Salary INT NOT NULL, Location VARCHAR(255) );
以下查询在名为Emp的DELETE查询表上创建一个触发器。它将Emp的已删除行存储到BackUp表中。
ij> CREATE TRIGGER my_trigger AFTER DELETE ON Emp REFERENCING OLD AS oldRow FOR EACH ROW MODE DB2SQL INSERT INTO BackUp VALUES (oldRow.Id, oldRow.Name, oldRow.Salary, oldRow.Location);
现在，从Emp表中删除一行，如下所示：
ij> Delete From Emp where Name = 'Kalyan'; 1 row inserted/updated/deleted ij> Delete From Emp where Name = 'Amit'; 1 row inserted/updated/deleted
如果您验证BackUp表，您可以观察到其中的已删除行。
ij> select * from BackUp; ID |NAME |SALARY |LOCATION ------------------------------------------------------------------------- 2 |Kalyan |40000 |Vishakhapatnam 1 |Amit |30000 |Hyderabad 2 rows selected
删除触发器
您可以使用DROP TRIGGER语句在Derby中删除触发器。
语法
以下是DROP TRIGGER查询的语法：
ij> Drop trigger tigger_name;
示例
以下示例删除上面创建的触发器my_trigger：
ij> Drop trigger my_trigger; 0 rows inserted/updated/deleted
JDBC示例
以下JDBC程序在Derby中创建和删除触发器。
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class Triggers_Example {
public static void main(String args[]) throws SQLException, ClassNotFoundException {
//Registering the driver
Class.forName("org.apache.derby.jdbc.EmbeddedDriver");
//Getting the Connection object
String URL = "jdbc:derby:TestDataBase;create=true";
Connection conn = DriverManager.getConnection(URL);
//Creating the Statement object
Statement stmt = conn.createStatement();
//Creating the Emp table
stmt.execute("CREATE TABLE Emp ( "
+ "Id INT NOT NULL, "
+ "Name VARCHAR(255), "
+ "Salary INT NOT NULL, "
+ "Location VARCHAR(255))");
//Insert values in to the EMp table
String query = "INSERT INTO Emp(Id, Name, Salary, Location) VALUES \r\n"
+"(1, 'Amit', 30000, 'Hyderabad'), "
+ "(2, 'Kalyan', 40000, 'Vishakhapatnam'), "
+ "(3,'Renuka', 50000, 'Delhi'), "
+ "(4, 'Archana', 15000, 'Mumbai'), "
+ "(5, 'Trupthi', 45000, 'Kochin')";
stmt.execute(query);
//Creating the BackUp table
stmt.execute("CREATE TABLE BackUp ( "
+ "Id INT NOT NULL, "
+ "Name VARCHAR(255), "
+ "Salary INT NOT NULL, "
+ "Location VARCHAR(255))");
//Creating a trigger
String createTrigger = "CREATE TRIGGER my_trigger "
+ "AFTER DELETE ON Emp "
+ "REFERENCING OLD AS oldRow "
+ "FOR EACH ROW MODE DB2SQL "
+ "INSERT INTO BackUp "
+ "VALUES (oldRow.Id, oldRow.Name, oldRow.Salary, oldRow.Location)";
stmt.execute(createTrigger);
System.out.println("Trigger created");
//Deleting records from Emp table
stmt.executeUpdate("Delete From Emp where Name = 'Kalyan'");
stmt.executeUpdate("Delete From Emp where Name = 'Amit'");
//Getting the contents of BackUp table
ResultSet rs = stmt.executeQuery("SELECT * from BackUp");
while(rs.next()){
System.out.println(rs.getInt("Id"));
System.out.println(rs.getString("Name"));
System.out.println(rs.getString("Salary"));
System.out.println(rs.getString("Location"));
System.out.println(" ");
}
}
}
输出
执行上述程序后，将生成以下输出：
Trigger created 2 Kalyan 40000 Vishakhapatnam 1 Amit 30000 Hyderabad