- 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://: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://: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://: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://: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://: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://: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://: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://: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://: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://: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://: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