删除Ｂ－－－3
修改Ｂ－－－4
添加Ｂ－－－5

……

　　理论上可以有Ｎ个操作，这取决于你用于储存用户权限值的数据类型了。

　　这样，如果用户有权限：添加Ａ－－－2；删除Ｂ－－－3；修改Ｂ－－－4。那用户的权限值 purview =2^2+2^3+2^4＝28，也就是2的权的和了。化成二进制可以表示为11100。这样，如果要验证用户是否有删除Ｂ的权限，就可以通过位与运算来实现。在Ｊａｖａ里，位与运算运算符号为＆，即是：

int value = purview &((int)Math.pow(2,3));

　　你会发现，当用户有操作权限时，运算出来的结果都会等于这个操作需要的权限值！

　　原理：

　　位与运算，顾名思义就是对位进行与运算：

　　以上面的式子为例：purview & 2^3 也就是　28&8

　　将它们化成二进制有

　11100
＆ 01000
-------------------
　 01000 == 8(十进制)　＝＝　2^3

　　同理，如果要验证是否有删除Ａ－－－0的权限

　　可以用：purview &((int)Math.pow(2,0));

　　即：

　11100
＆ 00001
------------------------
　 00000 == 0(十进制)　　！＝　2^0

　　这种算法的一个优点是速度快。可以同时处理Ｎ个权限。如果想验证是否同时有删除Ａ－－－0和删除Ｂ－－－3的权限，可以用purview&(2^0+2^3)==(2^0+2^3)?true:false;设置多角色用户。根据权限值判断用户的角色。

　　下面提供一个java的单操作权限判断的代码：

//userPurview是用户具有的总权限
//optPurview是一个操作要求的权限为一个整数（没有经过权的！）
public static boolean checkPower(int userPurview, int optPurview)
{
  int purviewValue = (int)Math.pow(2, optPurview);
  return (userPurview & purviewValue) == purviewValue;
}

　　当然，多权限的验证只要扩展一下就可以了。

　　几点注意事项：首先，一个系统可能有很多的操作，因此，请建立数据字典，以便查阅，修改时使用。其次，如果用数据库储存用户权限，请注意数值的有效范围。操作权限值请用唯一的整数！ 

简介

本 系列 的前几篇文章已经：

• 介绍了 Apache Derby 数据库。
• 介绍了 ij 工具。
• 演示了如何创建数据库模式、设计关系数据库表以及将数据插入表中。
• 演示了如何通过编写 SQL 查询提取数据。

尚未介绍的一个重要任务是如何修改现有数据。本文介绍 SQL DELETE 和 UPDATE 语句，您可以使用它们有选择地删除或修改 Apache Derby 数据库中的现有数据。

要进行本文的示例，您需要：

1. 具有可工作的 Apache Derby 数据库安装，本系列的 第一篇文章 有介绍。
2. 熟悉 Apache Derby ij 命令行工具，本系列的 第二篇文章 有介绍。
3. 具有正确初始化的 Bigdog 的 Surf Shop 示例数据库，本系列的 第四篇文章 和 第五篇文章 有详细介绍。
4. 熟悉 SQL SELECT 语句的基础知识，本系列的 第五篇文章 有介绍。

如果您还不具备这些条件，请确保在继续下文之前完成上述步骤，通过回顾本系列的前几篇文章可以很容易地实现。

回页首

删除数据

本文将介绍的第一个数据修改技术是删除数据。要删除 Apache Derby 数据库中的数据，可以使用 SQL DELETE 语句，它可以删除表中的所有行，也可以删除特定的行子集。可以用于 Apache Derby 数据库的 SQL DELETE 语句的正式语法相当简单，如下所示：

DELETE 语句从指定表中删除满足可选 WHERE 子句的所有行。如果没有包括任何 WHERE 子句，则删除表中的所有行。为了演示 DELETE 语句的这种用法，创建一个临时表，插入几行，然后全部删除，如 清单 1 所示。

ij> CREATE TABLE bigdog.temp (aValue INT) ;
            0 rows inserted/updated/deleted
            ij> INSERT INTO bigdog.temp VALUES(0), (1), (2), (3) ;
            4 rows inserted/updated/deleted
            ij> SELECT COUNT(*) AS COUNT FROM bigdog.temp ;
            COUNT
            -----------
            4
            1 row selected
            ij> DELETE FROM bigdog.temp ;
            4 rows inserted/updated/deleted
            ij> SELECT COUNT(*) AS COUNT FROM bigdog.temp ;
            COUNT
            -----------
            0
            1 row selected
            ij> DROP TABLE bigdog.temp ;
            0 rows inserted/updated/deleted

本例创建保存整数值的单列临时表。您将四行插入数据库中，然后执行 SELECT 语句以验证新表包含四行。通过使用无约束的 DELETE 语句，将删除临时表中的全部四行，这通过来自 Apache Derby 的消息 4 rows inserted/updated/deleted 和第二个 SELECT 语句来验证，该语句指明临时表包含 0 行。最后，DROP TABLE 语句删除模式中的空表。

但是，一般地，您不希望删除表中的所有行；而是有选择地删除行。为此，创建一个适当的 WHERE 子句来标识所有相关行。与 DELETE 一起使用的 WHERE 子句的语法与 第 4 部分 中讨论的语法一样，该部分提供了完全的 SQL SELECT 语句语法。在 WHERE 子句中构造布尔表达式的基本构建块在那篇文章的表 1 提供，并在本文的 清单 2 中演示，在此您将删除至少满足两个条件之一的所有行。

ij> DELETE FROM bigdog.products
            WHERE description LIKE '%towel%' OR itemNumber <= 3 ;
            5 rows inserted/updated/deleted
            ij> SELECT itemNumber, description FROM bigdog.products ;
            ITEMNUMBER |DESCRIPTION
            ----------------------------------------------------
            4          |Male bathing suit, blue
            5          |Female bathing suit, one piece, aqua
            6          |Child sand toy set
            9          |Flip-flop
            10         |Open-toed sandal
            5 rows selected

在本例中，DELETE 语句包括了一个标识 5 行的 WHERE 子句，您可以通过 ij 工具由 Apache Derby 返回的帮助消息 5 rows inserted/updated/deleted 中看到。WHERE 子句包含由 OR 操作符联结的两个表达式，这意味着对于特定行，如果任一表达式值为 TRUE，则将删除该行。

第一个表达式查找产品描述中包含单词 “towel” 的所有行。如果回忆本系列前几篇文章（或者在 DELETE 语句之前执行 SELECT 语句），则 bigdog.products 表中有两个 towel，其 itemNumber 列值为 7 和 8。另一个表达式选择 itemNumber 列值小于或等于 3 的所有行。bigdog.products 表的内容最终用一个简单的 SELECT 语句显示，展示了只有原来 10 行中的 5 行保留在表中。

您还可以包括 第 5 部分 中讨论的 SQL 函数以获得对删除行的选择的更多控制，但是本例中没有明确演示这些函数的使用。可用于 DELETE 语句的 WHERE 子句中的相同函数和其他操作符还可以与 UPDATE 语句一起使用，从而有选择地修改表中行的值，如下一节所述。

回页首

更新数据

您需要进行的处理数据的最后一个 SQL 任务是更新表中选定行的特定列值。在某种程度上，SQL UPDATE 语句是 SQL INSERT 和 DELETE 语句的联合，因为您必须选择要修改的行，还必须指定如何修改它们。形式上，UPDATE 语句语法非常简单，因为您必须指定要更新的行集合的新的列值，如 清单 3 所示。

UPDATE tableName
            SET columnName = Value
            [ , columnName = Value} ]*
            [WHERE clause]

如该 SQL 语法所示，SQL UPDATE 语句必须至少具有一个 SET 组件来更新一列，以及一个或多个 SET 组件和一个 WHERE 子句，这些是可选的。如果没有包括 WHERE 子句，则 UPDATE 语句将修改表中所有行的指定列。

执行 UPDATE 语句相当容易，如 清单 4 所示，其中修改了单个行的两列。

ij> SELECT itemNumber, price, stockDate FROM bigdog.products WHERE itemNumber = 6 ;
            ITEMNUMBER |PRICE   |STOCKDATE
            -------------------------------
            6          |9.95    |2006-01-15
            1 row selected
            ij> UPDATE bigdog.products
            SET price = price * 1.25, stockDate = CURRENT_DATE
            WHERE itemNumber = 6 ;
            1 row inserted/updated/deleted
            ij> SELECT itemNumber, price, stockDate FROM bigdog.products WHERE itemNumber = 6 ;
            ITEMNUMBER |PRICE   |STOCKDATE
            -------------------------------
            6          |12.43   |2006-06-20
            1 row selected

本示例在 UPDATE 语句的前后都使用了 SELECT 语句，以证实对目标行的更改。SELECT 语句从 bigdog.products 表选择了单个行（itemNumber 列值为 6 的行）的三列。UPDATE 语句修改该特定行的 price 和 stockDate 列。price 列中的值增加 25%（例如，可能由于货品很抢手），stockDate 列被修改以保存当前日期，通过在 SQL 查询中使用 CURRENT_DATE 内置函数，可以在 Apache Derby 中很容易获得该日期。

Apache Derby 包括一些内置函数，您可以使用它们获得与当前数据库连接相关的数据。这些内置函数的完整列表如 表 1 所示。

上例演示了如何修改单个表中特定行的多个列值。但是有时候，用于选择要更新的行的逻辑比较复杂。例如，假设您需要修改 bigdog.products 表中从 Quiet Beach Industries 中获得的所有对象的价格，Quiet Beach Industries 在 bigdog.vendors 表中 vendorNumber 列的值为 3。为此，您需要使用嵌入式查询，如 清单 5 所示。

ij> UPDATE bigdog.products
            SET price = price * 1.10, description = 'NEW: ' || description
            WHERE itemNumber IN
            ( SELECT v.itemNumber
            FROM bigdog.products as p, bigdog.vendors as v
            WHERE p.itemNumber = v.itemNumber AND v.vendorNumber = 3 ) ;
            2 rows inserted/updated/deleted
            ij> SELECT * FROM bigdog.products ;
            ITEMNUMBER |PRICE   |STOCKDATE |DESCRIPTION
            ------------------------------------------------------------------------
            4          |29.95   |2006-02-10|Male bathing suit, blue
            5          |49.95   |2006-02-20|Female bathing suit, one piece, aqua
            6          |12.43   |2006-06-20|Child sand toy set
            9          |14.24   |2006-03-12|NEW: Flip-flop
            10         |38.44   |2006-01-24|NEW: Open-toed sandal
            5 rows selected

在本例中，UPDATE 语句修改从 bigdog.vendors 表中 vendorNumber 列值为 3 的供应商获得的所有产品的 price 和 description 列。因为不能在 UPDATE 语句中进行简单联结，所以必须在 WHERE 子句中包括子查询，以提取与来自 Quiet Beach Industries 的产品对应的 itemNumber 行。UPDATE 中的 WHERE 子句使用 IN 操作符选择 itemNumber 列值属于嵌入式子查询所选的值集合的那些行。

两种查询可以用于 UPDATE 语句的 WHERE 子句中：标量子查询 和表子查询。标量子查询是一种嵌入式查询，返回包含单个列的单个行，本质上就是单个值，该值称为标量。可以使用标量子查询选择将用于 WHERE 子句的表达式中的特定值。例如，itemNumber = (标量子查询) 更新 itemNumber 列值与标量子查询结果匹配的任何行。

另一方面，表子查询可以返回多个行，这些行通常只有一列。在某些情况下，表子查询可以包含多个列。要使用表子查询，需要使用 SQL 操作符将嵌入式查询与布尔表达式组合在一起。例如，如上一代码清单所示，IN 操作符选择 bigdog.products 表中由 Quiet Beach Industries 生产的所有行。IN 操作符是可以用于表子查询的四个 SQL 操作符之一。全部四个操作符如 表 2 所述。

通过使用 表 2 中的信息，应该看到如果您重新编写 清单 4 中 UPDATE 语句中的 WHERE 子句，以使用量化比较和相同的表子查询 WHERE itemNumber = ANY (...)，您将获得相同的结果。如果使用 ALL 操作符和相同的表子查询，则不更新任何行，因为 bigdog.products 表中的所有 itemNumber 值不在表查询中。另一方面，如果使用 EXISTS 操作符，则将修改所有行，因为至少有一个 itemNumber 值存在于表子查询中。

回页首

修改表模式

上一节讨论了修改表中现有的数据。还可以修改数据库表的结构或模式。这可以采用添加列、更改列的数据类型、添加约束或者甚至删除列的方式来实现。 该过程并不简单，所以当您开始设计模式时一定要认真。如果不需要修改表的结构，则需要使用临时表，如 清单 6 所示。

ij> CREATE TABLE bigdog.newProducts (
            itemNumber INT NOT NULL,
            price DECIMAL(5, 2),
            stockDate DATE,
            count INT NOT NULL DEFAULT 0,
            description VARCHAR(40)
            ) ;
            0 rows inserted/updated/deleted
            ij> INSERT INTO bigdog.newProducts(itemNumber, price, stockDate, description)
            SELECT itemNumber, price, stockDate, description FROM bigdog.products ;
            5 rows inserted/updated/deleted
            ij> DROP TABLE bigdog.products ;
            0 rows inserted/updated/deleted
            ij> RENAME TABLE bigdog.newProducts TO products ;
            0 rows inserted/updated/deleted
            ij> SELECT * FROM bigdog.products ;
            ITEMNUMBER |PRICE   |STOCKDATE |COUNT      |DESCRIPTION
            ------------------------------------------------------------------------------------
            4          |29.95   |2006-02-10|0          |Male bathing suit, blue
            5          |49.95   |2006-02-20|0          |Female bathing suit, one piece, aqua
            6          |12.43   |2006-06-20|0          |Child sand toy set
            9          |14.24   |2006-03-12|0          |NEW: Flip-flop
            10         |38.44   |2006-01-24|0          |NEW: Open-toed sandal
            5 rows selected

如本例所示，要修改表，在本例中是将一个新列 count 添加到 bigdog.products 表中，首先要创建一个具有需要的正确模式的表。本例需要包括列约束 NOT NULL 使之始终具有有效的值，并通过使用列约束 DEFAULT 0 为 count 列分配默认值 0。注意如何通过将列顺序列出来合并多列约束。

下一步是将现有数据从原始表复制到新表中。可以通过使用 SQL INSERT 语句来实现，该语句使用一个子查询来获得要插入的值。这是一种功能强大的技术，允许您很容易地将现有表的全部或部分复制到第二个表中。

创建新表并复制了合适的数据之后，通过使用 SQL DROP TABLE 语句删除旧表，并通过使用 SQL RENAME TABLE 语句将新表重命名为原来的名称。重命名操作十分简单：将 oldTableName 重命名为 newTableName，但不为新表名提供模式名称，因为 RENAME 操作不能在不同的数据模式间移动表。本例最后执行 SELECT 语句以显示新 bigdog.products 表的模式和内容。可以看到，新表具有 5 列，count 列始终为 0。这时，真正的应用程序将通过执行必要的 SQL UPDATE 语句来适当修改 count 列。

回页首

结束语

本文专门介绍修改 Apache Derby 数据库中的数据。讨论的第一种数据修改技术是数据删除，这通过使用 SQL DELETE 语句来执行。然后使用 SQL UPDATE 语句来修改表中选定行的列值。最后，使用临时表来修改现有数据表的结果。本文还演示了如何通过使用嵌入式子查询来修改比较复杂的数据库模式。下一篇文章将介绍其他一些高级的数据库主题，之后本系列将开始讨论如何从 Java 应用程序连接到 Apache Derby 数据库。

SQL 脚本

在本系列的上一篇文章 “用 Apache Derby 进行数据库开发，第 2 部分：模式”（2006 年 4 月），在 ij 工具的提示符处直接执行 SQL 命令。通过使用 ij 工具，可以简单地用不同的 SQL 或 Derby 命令进行试验。但是，通常您将需要执行多个复杂的命令。为了简化调试一组复杂的 SQL 命令，将其写入文本文件中然后一次执行文本文件中的所有命令通常更加容易。该操作被称为运行 SQL 脚本，可以通过使用 Apache Derby 很容易地实现该操作。通过将 SQL 命令放置在脚本文件中，您将获得能够根据需要多次执行命令的附加好处。

脚本文件不难使用，如 清单 1 所示的第一个 Derby SQL 脚本示例。

-- Ignore the database not created warning if present
            connect 'jdbc:derby:test;create=true' ;
            -- First delete the tables if they exist.
            -- Ignore the table does not exist error if present
            DROP TABLE bigdog.products ;
            DROP TABLE bigdog.vendors ;
            -- CREATE the products table for bigdog's Surf Shop
            CREATE TABLE bigdog.products (
            itemNumber INT NOT NULL,
            price DECIMAL(5, 2),
            stockDate DATE,
            description VARCHAR(128)
            ) ;
            -- CREATE the products table for bigdog's Surf Shop
            CREATE TABLE bigdog.vendors (
            itemNumber INT NOT NULL,
            vendornumber INT NOT NULL,
            vendorName CHAR(64)
            ) ;
            exit ;
            

清单 1 所示的脚本重新创建了本系列上一篇文章中演示的 bigdog 模式和两个表（products 和 vendors）。如果不清楚其中任何一个概念，在继续本文之前您应该返回并 阅读该文章。因为本文将介绍将数据插入表的基本原理，所以您首先需要创建准备接受新数据的表。

编辑 Derby SQL 脚本 脚本文件只是一种包含可以从 Apache Derby ij 工具直接运行的 SQL 命令和 Apache Derby 命令的组合的文本文件。脚本文件简化了 Apache Derby 数据库的开发和维护，并提供了一种用于构建数据库的自文档化技术。您应该将这些文件存储为 ASCII 文本文件，而非 RTF 文件（或其他任何格式），以防止文本编码错误。一些文本应用程序（比如 Microsoft® Windows® 系统中的写字板）可能试图将文件自动保存为富文本文件。一定要小心这一点，否则可能在尝试执行脚本文件时出现问题。

无需将用于创建表的 SQL 命令直接输入到 Derby ij 工具中，您可以将其放入文本文件中，并让 ij 工具直接运行文件中的命令。本文包括一个 .zip 文件（参阅 下载 一节以访问该文件），其中包含两个脚本文件；一个是 derby.create.sql，如 清单 1 所示。因为本文将逐步介绍该脚本文件中的代码行，所以您既可以参照 清单 1 所示的代码，也可以用您偏爱的文本编辑器打开该脚本文件。

该脚本文件包括了用两个破折号 (--) 开头的几行。这些行是 SQL 注释；您应该使用它们来提供脚本文件中每个主要组件的用途的基本描述。 脚本中的第一个实际命令是 Derby connect 命令，它告诉 ij 工具连接 test 数据库，必要的话要先创建数据库。下一个命令是 SQL DROP 语句，它删除 bigdog 模式中的产品和供应商表。如果表不存在（当数据库刚创建时就会出现这种情况），将显示一条错误消息；但前面的 SQL 注释指明，您可以安全地忽略这些消息。

如果存在的话，首先放弃这些表，以便您可以用所需的正确的列定义创建新表。后两条 SQL 语句就执行该操作，在 bigdog 模式中创建产品和供应商表。脚本以 exit 命令结束，终止了与数据库的连接，并允许 ij 工具优雅地退出。下一步将学习如何执行 Derby 脚本文件。

在 ij 中运行脚本

脚本文件仅在可用于执行文件中列出的命令时才有用。要执行 SQL 脚本文件中的命令，最简单的方法是从 ij 工具中运行脚本文件。但是，在可以运行之前，需要创建一个测试目录并展开 derby4.zip 文件，该文件可在本文下载（参阅 下载 一节）。该过程如 清单 2 所示。

rb$ mkdir test
            rb$ cp derby4.zip test/
            rb$ cd test/
            rb$ unzip derby4.zip
            Archive:  derby4.zip
            inflating: derby.create.sql
            inflating: derby.insert.sql
            rb$ ls
            derby.create.sql      derby.insert.sql      derby4.zip
            rb$ java org.apache.derby.tools.ij
            ij version 10.1
            ij> run 'derby.create.sql' ;
            ij> -- Ignore the database not created warning if present
            connect 'jdbc:derby:test;create=true' ;
            ij> -- First delete the tables if they exist.
            -- Ignore the table does not exist error if present
            DROP TABLE bigdog.products ;
            ERROR 42Y07: Schema 'BIGDOG' does not exist
            ij> DROP TABLE bigdog.vendors ;
            ERROR 42Y07: Schema 'BIGDOG' does not exist
            ij> -- CREATE the products table for Bigdog's Surf Shop
            CREATE TABLE bigdog.products (
            itemNumber INT NOT NULL,
            price DECIMAL(5, 2),
            stockDate DATE,
            description VARCHAR(128)
            ) ;
            0 rows inserted/updated/deleted
            ij> -- CREATE the products table for Bigdog's Surf Shop
            CREATE TABLE bigdog.vendors (
            itemNumber INT NOT NULL,
            vendornumber INT NOT NULL,
            vendorName CHAR(64)
            ) ;
            0 rows inserted/updated/deleted
            ij> exit ;
            

虽然 清单 2 似乎对于执行 Derby 脚本有些冗长，但过程十分简单。该示例假设您具有开放的终端（或Windows Command 进程窗口，但要注意，本例中的一些步骤是特定于 UNIX® 的），并且您已经更改到保存包含本文提供的 两个脚本文件 的 derby4.zip 文件的目录。要最小化任何错误的几率，首先创建一个新目录，将 derby4.zip 文件复制到新目录中，并更改到这个新目录。然后展开示例 .zip 文件。如目录清单所示，现在您在新目录中具有三个文件：derby4.zip、derby.create.sql 和 derby.insert.sql。现在，您将只使用 create 脚本文件； insert 脚本文件将在本文的最后使用。

如果出问题怎么办？ 有时候，不管您怎么努力，事情不会总是如您所愿。如果不能安全地执行 derby.create.sql 脚本，有许多可能性需要检查： 确保 Derby ij 工具正确启动。若非如此，您可能遇到 CLASSPATH 工具问题。 确保具有创建新数据库的空闲磁盘空间。 确保在试图执行脚本文件的目录中具有正确的权限（读取脚本文件和创建新数据库）。 确保脚本文件是简单的 ASCII 文本文件。 如果全都不是，则检查最新的 Derby 文档，该文档可从 Apache Derby Web 站点（参阅 参考资料 一节中的链接）上免费获得，或在 Derby 邮件列表中询问您的问题。

清单 2 的其余部分展示如何从 Derby ij 工具中执行 derby.create.sql 脚本文件。 首先启动 ij 工具。如果启动时出现问题，您可能需要回顾 本系列第一篇文章 中提供的 Derby 安装验证步骤。看到 ij> 提示之后，就可以运行合适的脚本文件了。通过使用 run 命令可实现该操作，该命令接受单个参数：单引号括起的脚本文件名。

当该脚本执行时，您可能会看到新 ij> 提示、命令和警告或错误消息的组合。这种显示可能有些笨拙，但 run 命令会执行您的脚本文件，就像您直接将命令键入 ij 工具中一样。最后，处理 exit 命令，脚本完成，关闭 ij 工具。如果第一个脚本执行的输出与 清单 2 所示的相匹配，那么恭喜您了。您现在已经有了一个带有两个可以保存数据的新表的新测试数据库了。

虽然从 ij 工具中执行脚本十分有效，但是有时候进一步自动化该过程会更加容易。下一节将讨论如何从命令行直接执行 Derby 脚本文件。

从命令行运行脚本

本节介绍从命令行运行脚本的两种方法。第一种方法如 清单 3 所示。

rb$ java org.apache.derby.tools.ij derby.create.sql
            ij version 10.1
            ij> -- Ignore the database not created warning if present
            connect 'jdbc:derby:test;create=true' ;
            WARNING 01J01: Database 'test' not created, connection made to existing database instead.
            ij> -- First delete the tables if they exist.
            -- Ignore the table does not exist error if present
            DROP TABLE bigdog.products ;
            0 rows inserted/updated/deleted
            ij> DROP TABLE bigdog.vendors ;
            0 rows inserted/updated/deleted
            ij> -- CREATE the products table for Bigdog's Surf Shop
            CREATE TABLE bigdog.products (
            itemNumber INT NOT NULL,
            price DECIMAL(5, 2),
            stockDate DATE,
            description VARCHAR(128)
            ) ;
            0 rows inserted/updated/deleted
            ij> -- CREATE the products table for Bigdog's Surf Shop
            CREATE TABLE bigdog.vendors (
            itemNumber INT NOT NULL,
            vendornumber INT NOT NULL,
            vendorName CHAR(64)
            ) ;
            0 rows inserted/updated/deleted
            ij> exit ;
            

清单 3 展示了直接从命令行执行脚本文件的第一种方法。在这种情况下，提供脚本文件名作为 ij 工具的命令行参数。脚本文件中的行像以前一样读取，并顺序处理。如果首先从 ij 工具中直接执行 derby.create.sql 文件，现在在命令行运行相同目录中的同一脚本文件，您应该会看到类似于 清单 3 中的输出（一切都在清单中第一行之后）。如上所示，您收到一条警告消息，指明测试数据库未创建，因为它已经存在。但是，这次您不会收到指明不能放弃两个表的错误消息，因为您已经创建了它们（如 清单 2 所示）。在放弃产品和供应商表之后，您重新创建它们，脚本退出。

还有另一种方法来运行 Derby 脚本：重定向 ij 工具的标准输入以从脚本文件中读取。在基于 UNIX 的操作系统中，通过使用适合您的 shell 的 STDIN 重定向字符最容易实现了，比如为 Bash shell 使用小于号 (<)。这种方法在 清单 4 中展示，具有减少屏幕上显示的输出量的好处。

rb$ java org.apache.derby.tools.ij < derby.create.sql
            ij version 10.1
            ij> WARNING 01J01: Database 'test' not created, connection made to existing database instead.
            |-------- XML error:  The previous line is longer than the max of 90 characters ---------|
            ij> 0 rows inserted/updated/deleted
            ij> 0 rows inserted/updated/deleted
            ij> 0 rows inserted/updated/deleted
            ij> 0 rows inserted/updated/deleted
            ij>
            rb$
            

在 清单 4 中可以看到，当您通过重定向 ij 工具的标准输入执行脚本时，惟一显示的文本是来自 ij 工具的消息，其中包括 0 rows inserted/updated/deleted 等信息消息或警告和错误消息。如果想要消除这些消息，可以重定向 ij 工具的标准输出和标准错误。例如，如果正在 Bash shell 中工作，则可以使用

java org.apache.derby.tools.ij < derby.create.sql > derby.create.out 2> derby.create.err

实现这一点，它运行 derby.create.sql 脚本文件，将输出消息保存到 derby.create.out 中，并将所有 ij 错误消息保存到 derby.create.err 中。

现在您将关注使用 Apache Derby 将数据插入表的过程。要继续进行，您需要一个 Derby 数据库，它必须具有可用的产品表。如果您还未实现此步骤，您需要执行 derby.create.sql 脚本文件。

回页首

在 Apache Derby 中插入数据

构建数据库应用程序时最重要的任务之一是将数据插入到数据库中。这与数据库软件的好坏无关，如果将坏数据放入数据库中，其他一切都不重要了。有许多方法可以将数据插入数据库中，但下文将主要使用 SQL INSERT 语句将数据插入 Apache Derby 数据库中。

SQL INSERT 语句

在使用 SQL INSERT 语句将数据插入 Apache Derby 数据库中之前，必须知道如果正确地使用该语句。清单 5 提供了 Apache Derby 中 SQL INSERT 语句的完整语法。

INSERT INTO table-Name
            [ (Simple-column-Name [ , Simple-column-Name]* ) ]
            Expression
            

该语法应该比较熟悉。如本系列的 上一篇文章 所述，方括号 ([ ]) 包括可选参数。其用途不是立即清楚的惟一组件是 Expression；但这个简单的短语能够有多复杂呢？当然，外表可能会蒙蔽人；Expression 词可以扩展为下列四个不同的结构之一：

• 单行 VALUES 列表
• 多行 VALUES 列表
• SELECT 表达式
• UNION 表达式

其中，最后两个超出了本文范围，将在后续文章中详细介绍。前两个相似；惟一的区别在于第一种形式将一行插入表中，而后一种形式将多行插入表中。

可以使用 SQL INSERT 语句的可选部分指定要插入到表中的值的列顺序。默认情况下，数据插入到表中的列顺序与创建表时列的列出顺序相同。有时候您希望更改这种顺序或可能希望只为具有 NOT NULL 约束的列指定值。通过在 SQL INSERT 语句中显式列出列，您将获得对操作的更多控制，并可以更容易地处理这些特定的用例。

SQL VALUES 表达式的语法相当简单，如 清单 6 所示。

{
            VALUES ( Value {, Value }* )
            [ , ( Value {, Value }* ) ]* |
            VALUES Value [ , Value ]*
            }
            

该语法首先显示多行格式，然后是单行格式（记住，竖线字符 | 表示或者，星号字符 * 表示一个或多个）。value 词表示想要插入特定列的值。要将数据插入多列，必须将一行的数据括在逗号分隔的括号内。

下面两节展示要实现的语法示例。

使用 SQL 插入数据

如 清单 7 所示，要将数据插入表中，首先需要启动 ij 工具并连接数据库。记住，要将数据插入表中，表必须存在。如果还没有表的话，则执行本文之前所述的用于创建表的脚本。

rb$ java org.apache.derby.tools.ij
            ij version 10.1
            ij> connect 'jdbc:derby:test' ;
            ij> INSERT INTO bigdog.products
            VALUES(1, 19.95, '2006-03-31', 'Hooded sweatshirt') ;
            1 row inserted/updated/deleted
            ij> INSERT INTO bigdog.products(itemNumber, price, stockDate, description)
            VALUES(2, 99.99, '2006-03-29', 'Beach umbrella') ;
            1 row inserted/updated/deleted
            ij> INSERT INTO bigdog.products(itemNumber, price, stockDate)
            VALUES(3, 0.99, '2006-02-28') ;
            1 row inserted/updated/deleted
            ij> exit ;
            

本例展示了对 bigdog.products 表的三个单行插入。第一个 SQL INSERT 语句没有提供列列表；它插入 itemNumber、price、stockDate 和 description。注意，插入到 stockDate 和 description 列的值括在单引号字符中。description 列是长度可变的字符串，所以它预计是一个字符串（通过将字符数据括在单引号中指明）。另一方面，stockDate 列是一个日期列；它需要您将日期括在单引号中以正确解析出正确的日、月和年信息。（有关 SQL INSERT 操作期间数据类型格式的更多指南，请阅读联机文档或参阅本系列的 上一篇文章。）

第二个 SQL INSERT 语句显式列出所有四列并相应地插入新值。最后一个 SQL INSERT 语句只列出三列并只插入三个值。description 列留为空白，这意味着它将具有 NULL 值。

虽然单行 SQL INSERT 语句可能有用，但当您需要插入多行时，直接插入多行可能更有效，如 清单 8 所示。

rb$ java org.apache.derby.tools.ij
            ij version 10.1
            ij> connect 'jdbc:derby:test' ;
            ij> INSERT INTO bigdog.products(itemNumber, price, stockDate, description)
            VALUES (4, 29.95, '2006-02-10', 'Male bathing suit, blue'),
            (5, 49.95, '2006-02-20', 'Female bathing suit, one piece, aqua'),
            (6, 9.95, '2006-01-15', 'Child sand toy set'),
            (7, 24.95, '2005-12-20', 'White beach towel'),
            (8, 32.95, '2005-12-22', 'Blue-striped beach towel'),
            (9, 12.95, '2006-03-12', 'Flip-flop'),
            (10, 34.95, '2006-01-24', 'Open-toed sandal') ;
            7 rows inserted/updated/deleted
            ij> exit ;
            

在本例中，首先启动 ij 工具并连接数据库。下一代码行通过显式列出所有四列并为每行提供新值，将 7 行插入数据库中。如前所述，多行插入将每个新行的值包括在括号内，这些值之间用逗号分隔。该 SQL INSERT 语句执行之后，ij 工具报告这 7 新行已经插入。

在 Apache Derby 中插入数据

多行插入优于多个单行插入；但更好的方法是将 SQL INSERT 语句放在脚本文件中，运行脚本来插入数据。这种方法允许您更容易地修复错误或根据需要重新插入数据，而无需重新创建必需的 SQL INSERT 语句。如前所述，可以 随本文下载 的 .zip 文件包括两个 SQL 脚本文件。第二个脚本文件 (derby.insert.sql) 将上一节提供的 10 行插入到数据库中，并执行简单查询以显示结果，从而验证插入操作。执行查询操作的机制将在下一篇文章中详细讨论，但您不必理解查询就能够运行插入脚本。

要执行脚本，可以选择本文开头展示的三个方法之一。在 清单 9 中，通过重定向 ij 工具的标准输入以从脚本文件中读取的方式，来执行插入脚本。插入 10 行，然后结果显示到屏幕上。

$ java org.apache.derby.tools.ij < derby.insert.sql
            ij version 10.1
            ij> ij> 10 rows inserted/updated/deleted
            ij> ITEMNUMBER |PRICE   |STOCKDATE |DESCRIPTION
            -------------------------------------------------------------------------------
            1          |19.95   |2006-03-31|Hooded sweatshirt
            2          |99.99   |2006-03-29|Beach umbrella
            3          |0.99    |2006-02-28|
            4          |29.95   |2006-02-10|Male bathing suit, blue
            5          |49.95   |2006-02-20|Female bathing suit, one piece, aqua
            6          |9.95    |2006-01-15|Child sand toy set
            7          |24.95   |2005-12-20|White beach towel
            8          |32.95   |2005-12-22|Blue-striped beach towel
            9          |12.95   |2006-03-12|Flip-flop
            10         |34.95   |2006-01-24|Open-toed sandal
            10 rows selected
            ij> ij> rb$
            

回页首

结束语

本文讨论了两个主要主题。首先向您介绍了 SQL 脚本文件的概念，该脚本文件可用于以自动方式执行多个 SQL（或 Derby）命令。使用 Apache Derby ij 工具执行 SQL 脚本文件有三种方法：从工具中、使用 run 命令或直接从命令行使用这两种方法之一。然后，您回顾了 INSERT 语句的 SQL 语法，并查看了如何使用该语句将数据插入 Derby 数据库中的示例。后续文章将在此基础上查询、更新和删除 Apache Derby 数据库中的数据。

回页首

下载

	关于下载方法的信息

关系数据库系统基础

在开发数据库应用程序之前，需要理解它的基本概念。这一节介绍在 Apache Derby 中可以使用的数据类型，以及对设计和创建有用的 Derby 数据库应用程序的能力有影响的规则。

关系数据库容纳数据。数据可以是不同类型的，例如数值型、字符型或日期型。在数据库中，数据被组织到叫做表 的逻辑单元中。表就像工作簿一样，因为它包含数据行。每行由许多列组成。列容纳特定数据类型的数据，例如整型值或字符串。在多数情况下，一个数据库有多个表。为了将表关联在一起，数据库设计师利用表之间的自然（或人为）链接。在工作簿中，可以通过单元格的值链接不同工作簿中的行。同样的概念在关系数据库中也存在，用来进行链接的列叫做键列（key column）。

为了让表或列的用途更容易理解，应当选择合适的名称。对于不同的数据库，命名约定可能不同。对于 Apache Derby 数据库系统，名称应当：

• 不区分大小。
• 最长 128 个字符。
• 必须以字母开头。
• 必须只包含 Unicode 字母、下划线和 Unicode 数字。

通过把名称放在双引号中，可以避开 这些规则，使用双引号允许名称区分大小写以及包含附加字符（包括空格）。但是，这么做通常是不好的做法：它要求名称总被括在双引号中，很容易把维护代码的其他人弄糊涂。

Derby 风格 这个 文章系列 遵守特定的风格：所有 SQL 命令都用大写，项目名称采用 camelCase 方式，在 camelCase 风格中，单词被连在一起，第一个单词之后的每个单词的第一个字母大写，例如 aLongIdentifier。把这两种风格组合在一起，这些文章写 SQL 命令时的风格是这样：SELECT aLongIdentifier FROM bigdog.dataTable ;.

关联的表通常组织在一起，形成一个模式（schema）。可以把模式当成特定数据库中所有相关结构定义的容器。在指定模式中，表的名称必须惟一。所以，通过使用模式，可以在不同模式的范围内拥有名称相同的对象（例如表）。在使用 Apache Derby 数据库时，表总在模式中。如果没有显式地指定模式，Derby 就会隐式地使用内置的 apps 模式。叫做 sys 的第二个内置模式用来隔离系统表。

可以用模式名对名称进行限定（qualify）。要做这件事，可以在模式名后加圆点，然后加表名。例如，bigdog.products 表示 bigdog 模式中的 products 表。没有相应的模式名，表名就被认为是未限定的（unqualified），例如 products。当模式名和表名都完全指定的时候，就像 bigdog.products，名称被称为完全限定的（fully qualified）。

从抽象意义上来说，这些数据库概念看起来可能让人混淆。但在实践上，它们相当简单。例如，假设有一个商店，叫做 Bigdog's Surf Shop，这家店销售各种商品，例如太阳镜、衬衫等等。如果想赢利，就必须管理库存，以便可以容易地订购额外的商品或改变供应商，从而把开支控制在最小。跟踪这些信息的一个简单方法，就是用表格式编写条目，如 图 1 所示。

从这个简单的可视设计中，可以容易地把业务逻辑直接映射到数据库表。有两个表：Products 和 Vendors，它们自然地通过商品名称链接在一起。列的数据类型很容易确定。这篇文章其余的部分将侧重于在 Derby 数据库中创建 Bigdog's Surf Shop 的示例模式 —— 模式中包含这两个表。

回页首

处理关系数据库：结构化查询语言

SQL NULL 类型 在开始创建数据库表之前，必须知道列没有指定值的时候要做什么。为了理解这一点，请想像一下填写 Web 表单时的情况。如果某个具体列为空，那么插到数据库中的是什么呢？可以想像，如果必须跟踪无值 标记，问题会很麻烦。幸运的是，SQL 定义了一个特殊值，NULL，表示列没有值。

数据库系统会成为软件中复杂的部分，特别是在规模扩大到支持企业级应用程序的时候。所以，可以想像每个数据库都会有自己的应用程序编程接口（API），而这些 API 可能彼此不同。当关系数据库刚开发出来的时候，情况就是这样。但是，幸运的是，许多开发商同意开发一个标准的语言，用来访问和操纵数据库。这个语言称作结构化查询语言（或 SQL，发音是 sea-quill）。至今已经形成了多个官方标准版本，包括 1992 年的版本，这一版被称为 SQL-92，还有 1999 年的版本被称为 SQL-99。Apache Derby 数据库为 SQL-92 标准提供了几乎完整的实现，所以用 Deryby 开发的应用程序可以容易地移植到其他数据库系统。

SQL 有两个主要部分：数据定义语言（DDL）和数据操纵语言（DML）。DDL 命令用来创建、修改或删除数据库中的项目（例如表）。DML 命令用来在数据库表中添加、修改、删除或选择数据。这篇文章后面的部分将提供对 SQL 的 DDL 部分的基本介绍。未来的文章将侧重于 DML 命令和更高级的 DDL 命令。

SQL 数据类型

SQL 作为一个编程语言，定义了丰富的数据类型层次结构。数据库已经变得更强大了，所以这个类型层次结构也变得更复杂。但是最简单的数据库并不要求使用所有允许的类型，通常只需要保存数值型、字符型和日期（或时间）数据。为了简单，表 1、2、3、4 显示了 Derby 中实现的基本 SQL 数据类型。

如表 1 所示，Derby 提供了对三种整型数据类型的支持。这些类型由它们可以保存的整数的范围区分，也就是由它们在数据库中需要的存储空间区分。在设计数据库时要记住的一个关键问题就是，应当一直把表使用的空间控制在最小。一般来说，表越小，性能越高。但是必须能够在生成的表中保存需要的数据。2³¹ 等于 2,147,483,648，2⁶³ 等于 9,223,372,036,854,775,808，所以使用这些类型可以保存非常大的整数！

多数数值型数据不能用整数表示。Derby 对实数提供了多种格式的支持：单精度浮点、双精度浮点以及准确的算术表示，如表 2 所示。

如果从未遇到过准确精度数据类型，那么对算术类型和浮点类型可能有些迷惑。区别在于一个事实：计算机中使用的浮点数据类型无法包含每个实数。这看起来可能有些怪，但是想想实数的数量是无限的。大多数实数都无法保存在几个字节的内存中。对于某些应用程序，精度的损失是可以接受的，而在许多情况下，则不可接受。例如，财务应用程序不能容忍仅仅因为某个数字不能保存在计算机中，就损失金钱。

这个问题的解决方案是使用 DECIMAL 数据类型，它可以控制计算机存储的数字位数（精度）和小数点后的位数（刻度）。要创建算术类型，应当指定保存的数据的精度，并可选地指定数据的刻度。DECIMAL 数据类型需要的存储空间通常要比浮点数据类型大得多。所以应当小心地使用这个类型，否则应用程序的性能会降低。默认情况下，DECIMAL 类型的刻度为 0，这意味着 DECIMAL 数据类型模拟了整数类型。

数值类型有多个同义词。例如，DECIMAL 数据类型可以缩短为 DEC 或表示为 NUMERIC。DOUBLE 类型也可以表示为 DOUBLE PRECISION，虽然为什么在需要双精度数字时要输入额外的单词，原因不明。更常用的同义词是 FLOAT 类型，它拥有任意的浮点精度，可以在声明数据类型时指定，例如 FLOAT(val)。精度必须是小于 53 的正整数；如果不是，就会出错。如果指定了小于等于 23 的精度值，FLOAT(val) 就等价于 REAL；如果精度在 24 和 53 之间，那么 FLOAT(val) 等价于 DOUBLE。

除了数值类型，数据库中最常用的保存数据的另一个类型是字符数据。字符数据的示例包括产品说明、人名或地址信息。Derby 提供了保存字符数据的两个简单技术：CHAR 类型和 VARCHAR 类型，详情如表 3 所示。对于这两种类型，都可以指定 length 参数，如果没指定，默认为 1。在这两个字符数据类型之间有两个主要区别。首先，CHAR 类型的最大长度是 254 个字符，而 VARCHAR 类型最多可以容纳 32,672 个字符。第二个区别比较微妙：CHAR 类型的长度总是指定的长度。如果没有指定足够的字符，那么会插入额外的空白来填满剩余位置。而使用 VARCHAR 时，字符的数量是可变的，不执行额外的填充。

因为长度可变，所以 VARCHAR 类型在实际的存储空间方面会更有效率，但在性能上效率就会更低。CHAR 数据类型有助于性能提高，因为数据库确切地知道每个 CHAR 列有多大，所以在读写数据时就可以执行某种性能优化。VARCHAR 列的最大长度看起来可能足够大了，但是 Derby 还提供了更大的字符数据类型，这个类型将在未来的文章中讨论。

Derby 提供了最后一类简单的数据类型来保存日期和时间，如表 4 所示。TIME 数据类型以 24 小时格式保存小时、分钟和秒（HH:MM:SS）。DATE 数据类型保存月、日和年，可以用不同的格式指定，包括以下格式：

• yyyy-mm-dd
• mm/dd/yyyy
• dd.mm.yyyy

Derby 还提供了 TIMESTAMP 数据类型，把 TIME 和 DATE 数据类型组合到一个类型中，表示准确的时间。

回页首

在 Derby 中创建表

目前为止，已经学习了如何设计表，包括规划表的列和定义每个列的数据类型。在正确地设计了表之后，用 SQL 创建表的方法就很简单了。清单 1 显示了在 Derby 中创建表的正式语法。

--  Comment describing the purpose and layout of the table
            CREATE TABLE [schemaName.]tableName (
            { <columnDefinition> | <tableLevelConstraint>  } [,
            { <columnDefinition> | <tableLevelConstraint>  }
            ]*
            ) ;
            

第一次看这个语法时，可能感觉到迷惑不解。但是有了基础之后，接下来就容易了；而且如果想掌握 Derby，对正式语法的理解是必需的。方括号（[ 和 ]）中的是可选参数。从正式语法中可以看出，模式名是可选的，在必需的头一个列之后（创建连一个列都没有的表是没有意义的），其他列定义或表级约束都是可选的。

您可能理解列定义的含义，但是可能不理解约束 的意义。约束有两种类型：表级约束和列约束。约束通过某种方式对列或表进行限制。例如，可以用约束要求列总要有实际的值（没有 NULL 值），或者列中的每个项必须是惟一的，或者列被自动分配默认值。在未来的文章中将更详细地介绍约束。

最后一个结束方括号之后的星号（*）代表可以包含一个或多个包含项。这意味着表必须有一个或多个列级或表级约束。竖线（|）表明 “可有可无” 条件。在这个语法示例中，必须定义一个新列或者定义一个表级约束。花括号（{ 和 }）把相关项组织在一起，而圆括号（( 和 )）中是必需的元素 。最后，分号（;）表示 SQL 语句的结束。

把这些规则投入使用则相当简单。清单 2 显示了如何用 Derby 提供的 ij 创建前面在 图 1 中演示的表。

rb$ java org.apache.derby.tools.ij
            ij version 10.1
            ij> connect 'jdbc:derby:test;create=true' ;
            ij> CREATE TABLE bigdog.products (
            itemNumber INT NOT NULL,
            price DECIMAL(5, 2),
            stockDate DATE,
            description VARCHAR(128)
            ) ;
            0 rows inserted/updated/deleted
            ij> CREATE TABLE bigdog.vendors (
            itemNumber INT NOT NULL,
            vendorNumber INT NOT NULL,
            vendorName CHAR(64)
            ) ;
            0 rows inserted/updated/deleted
            ij> exit ;
            

与 Derby 数据库进行交互的最简单方式是使用 ij 工具，在这个系列的第一篇文章 “用 Apache Derby 进行开发 —— 取得节节胜利：Apache Derby 介绍”（developerWorks，2006 年 2 月）中已经介绍过。如果按照 清单 2 中的步骤进行，就会创建一个新的数据库，名为 test。如果 test 数据库已经存在，在发出 connect 语句时，会得到警告消息。可以安全地忽略这个警告。接下来，隐式地创建一个名为 bigdog 的新模式，并显式地创建两个新表 —— products 和 vendors —— 这两个表保存在 bigdog 模式中。模式的创建所以是隐式的，是因为没有发出 CREATE SCHEMA 语句。

products 表有四个列：itemNumber、price、stockDate 和 description。itemNumber 列提供了每个商品（或列）的惟一标识，它上面还有列级约束，强制要求提供正确的值（NOT NULL）。如果没有这个要求，itemNumber 列就无法保持惟一，因为多个行都可能被分配 NULL 值。price 列创建为 DECIMAL 数据类型，精度为 5，刻度为 2。这意味着每个商品的最高价格可以是 $999.99。最后两个列很简单：stockDate 列以 Date 类型保存，description 列以字符串类型保存，最长 128 个字符，使用的空间是实际的字符串长度。

vendors 表有三列：itemNumber、 vendorNumber 和 vendorName。在这个示例中，itemNumber 和 vendorNumber 列都有列级约束（NOT NULL）。另外，vendorName 列以字符串类型保存，最大长度为 64。因为 vendorName 列用 CHAR 数据类型保存，所以总是保留 64 个字符空间。

在创建了各种项目之后，可能想知道是否有种简单的方式可以查看数据库中保存了什么项目。幸运的是，答案是肯定的，可以使用 dblook 工具。运行这个工具，如 清单 3 所示，提供了特定数据库中已经创建的项目的详细清单。

rb$ java org.apache.derby.tools.dblook -d jdbc:derby:test
            -- Timestamp: 2006-03-04 10:52:34.056
            -- Source database is: test
            -- Connection URL is: jdbc:derby:test
            -- appendLogs: false
            -- ----------------------------------------------
            -- DDL Statements for schemas
            -- ----------------------------------------------
            CREATE SCHEMA "BIGDOG";
            -- ----------------------------------------------
            -- DDL Statements for tables
            -- ----------------------------------------------
            CREATE TABLE "BIGDOG"."PRODUCTS" (
            "ITEMNUMBER" INTEGER NOT NULL,
            "PRICE" DECIMAL(5,2),
            "STOCKDATE" DATE,
            "DESCRIPTION" VARCHAR(128));
            CREATE TABLE "BIGDOG"."VENDORS" (
            "ITEMNUMBER" INTEGER NOT NULL,
            "VENDORNUMBER" INTEGER NOT NULL,
            "VENDORNAME" CHAR(64));
            

dblook 工具是一个 Java 类，可以用它方便地把数据库的内容输出到控制台。在命令行上运行它，就像运行其他 Java 程序一样；惟一增加的就是使用 -d jdbc:derby:test 参数，这个参数指定 dblook 工具应当查询的数据库。如果能运行 ij 工具，那么 dblook 类文件就已经存在于 CLASSPATH 中了。如果不是这样，请参考这个系列中的 第一篇文章，获得正确设置 CLASSPATH 的详细说明。正如 dblook 工具的输出所示，test 数据库包含 bigdog 模式，这个模式包含 products 和 vendors 表。另外，对这两个表的列也有详细描述。

回页首

删除 Derby 中的表

没有什么事情是完美的。当错误地创建了表或者表不再需要的时候，该怎么办？简单的答案是从数据库中删除表。而且，如果必要，再创建一个替代表。删除表很容易，当然这意味着，在做这件事的时候应当非常小心 —— 不会弹出对话框要求您确认是否真的想删除！

从数据库中删除（或者更正式地说，撤下（drop））一个表的完整语法是：

语法很简单：把完全限定名称和分号放在 DROP TABLE SQL 命令后面，就完成了。清单 4 中在新创建的临时表上演示了删除表的过程。

rb$ java org.apache.derby.tools.ij
            ij version 10.1
            ij> connect 'jdbc:derby:test' ;
            ij> CREATE TABLE temp ( aColumn INT ) ;
            0 rows inserted/updated/deleted
            ij> DROP TABLE temp ;
            0 rows inserted/updated/deleted
            ij> exit ;
            

回页首

结束语

现在您已经走上了操作 Apache Derby 数据库的道路。目前您已经掌握了基本的数据库概念，包括模式、表和列，还看到了使用名为 Bigdog's Surf Shop 的虚拟公司对这些概念的演示。要操作像 Derby 这样的数据库，需要学习 SQL，它是与数据库进行交互的标准语言。这篇文章还介绍了可以用来在 Derby 数据库中保存数据的基本数据类型。把这些概念融合在一起，您学习了如何用 Derby 创建和删除表，还使用 Derby 的 dblook 工具输出了数据库的模式内容。

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=1370905

然后做了一个ARP监听器，没想到被老师看上了，说是国内JPCAP研究的人不多，可以考虑写一篇论文，老师给我推荐发表。

于是有了这么一篇东西。不过现在还不知道老师发哪个刊物去了。。。老师说，还没回音。。

 注：由于字数限制，分成2部分发。

数据成员
NetworkInterfaceAddress[]	addresses     这个接口的网络地址。设定为数组应该是考虑到有些设备同时连接多条线路，例如路由器。但我们的PC机的网卡一般只有一条线路，所以我们一般取addresses[0]就够了。
java.lang.String	datalink_description.     数据链路层的描述。描述所在的局域网是什么网。例如，以太网（Ethernet）、无线LAN网（wireless LAN）、令牌环网(token ring)等等。
java.lang.String	datalink_name    该网络设备所对应数据链路层的名称。具体来说，例如Ethernet10M、100M、1000M等等。
java.lang.String	description    网卡是XXXX牌子XXXX型号之类的描述。例如我的网卡描述：Realtek RTL8169/8110 Family Gigabit Ethernet NIC
boolean	Loopback     标志这个设备是否loopback设备。
byte[]	mac_address    网卡的MAC地址，6个字节。
java.lang.String	Name     这个设备的名称。例如我的网卡名称：\Device\NPF_{3CE5FDA5-E15D-4F87-B217-255BCB351CD5}

数据成员
int	dropped_packets  抛弃的包的数目。
protected  int	ID     这个数据成员在官方文档中并没有做任何说明，查看JPCAP源代码可以发现这个ID实际上在其JNI的C代码部分传进来的，这类本身并没有做出定义，所以是供其内部使用的。实际上在对JpcapCator实例的使用中也没有办法调用此数据成员。
protected static boolean[]	instanciatedFlag    同样在官方文档中没有做任何说明，估计其为供内部使用。
protected static int	MAX_NUMBER_OF_INSTANCE 同样在官方文档中没有做任何说明，估计其为供内部使用。
int	received_packets         收到的包的数目
方法成员
static NetworkInterface[]	getDeviceList()           返回一个网络设备列表。
static JpcapCaptor	openDevice(NetworkInterface interface, int snaplen, boolean promisc, int to_ms)          创建一个与指定设备的连接并返回该连接。注意，以上两个方法都是静态方法。       Interface：要打开连接的设备的实例；       Snaplen：这个是比较容易搞混的一个参数。其实这个参数不是限制只能捕捉多少数据包，而是限制每一次收到一个数据包，只提取该数据包中前多少字节；       Promisc：设置是否混杂模式。处于混杂模式将接收所有数据包，若之后又调用了包过滤函数setFilter()将不起任何作用；       To_ms：这个参数主要用于processPacket()方法，指定超时的时间；
void	Close()           关闭调用该方法的设备的连接，相对于openDivece()打开连接。
JpcapSender	getJpcapSenderInstance()           该返回一个JpcapSender实例，JpcapSender类是专门用于控制设备的发送数据包的功能的类。
Packet	getPacket()           捕捉并返回一个数据包。这是JpcapCaptor实例中四种捕捉包的方法之一。
int	loopPacket(int count, PacketReceiver handler)           捕捉指定数目的数据包，并交由实现了PacketReceiver接口的类的实例处理，并返回捕捉到的数据包数目。如果count参数设为－1，那么无限循环地捕捉数据。       这个方法不受超时的影响。还记得openDivice()中的to_ms参数么？那个参数对这个方法没有影响，如果没有捕捉到指定数目数据包，那么这个方法将一直阻塞等待。 PacketReceiver中只有一个抽象方法void receive(Packet p)。
int	processPacket(int count, PacketReceiver handler)            跟loopPacket()功能一样，唯一的区别是这个方法受超时的影响，超过指定时间自动返回捕捉到数据包的数目。
int	dispatchPacket(int count, PacketReceiver handler)         跟processPacket()功能一样，区别是这个方法可以处于“non-blocking”模式工作，在这种模式下dispatchPacket()可能立即返回，即使没有捕捉到任何数据包。
void	setFilter(java.lang.String condition, boolean optimize)           .condition：设定要提取的包的关键字。        Optimize：这个参数在说明文档以及源代码中都没有说明，只是说这个参数如果为真，那么过滤器将处于优化模式。
void	setNonBlockingMode(boolean nonblocking)      如果值为“true”，那么设定为“non-blocking”模式。
void	breakLoop()      当调用processPacket()和loopPacket()后，再调用这个方法可以强制让processPacket()和loopPacket()停止。

方法成员
void	close()           强制关闭这个连接。
static JpcapSender	openRawSocket()      这个方法返回的JpcapSender实例发送数据包时将自动填写数据链路层头部分。
void	sendPacket(Packet packet)           JpcapSender最重要的功能，发送数据包。需要注意的是，如果调用这个方法的实例是由JpcapCaptor的getJpcapSenderInstance()得到的话，需要自己设定数据链路层的头，而如果是由上面的openRawSocket()得到的话，那么无需也不能设置，数据链路层的头部将由系统自动生成。

我们不可能列举所有可能的顽固，我们会针对几种最常见的问题进行处理。当然了，正如前面说到的，如果我们自己使用java.net.HttpURLConnection来搞定这些问题是很恐怖的事情，因此在开始之前我们先要介绍一下一个开放源码的项目，这个项目就是Apache开源组织中的httpclient，它隶属于Jakarta的commons项目，目前的版本是2.0RC2。commons下本来已经有一个net的子项目，但是又把httpclient单独提出来，可见http服务器的访问绝非易事。

Commons-httpclient项目就是专门设计来简化HTTP客户端与服务器进行各种通讯编程。通过它可以让原来很头疼的事情现在轻松的解决，例如你不再管是HTTP或者HTTPS的通讯方式，告诉它你想使用HTTPS方式，剩下的事情交给httpclient替你完成。本文会针对我们在编写HTTP客户端程序时经常碰到的几个问题进行分别介绍如何使用httpclient来解决它们，为了让读者更快的熟悉这个项目我们最开始先给出一个简单的例子来读取一个网页的内容，然后循序渐进解决掉前进中的所形侍狻?/font>

1． 读取网页(HTTP/HTTPS)内容

• IPMsg 是一款局域网内即时通信软件, 基于 TCP/IP(UDP).
• 可运行于多种操作平台(Win/Mac/UNIX/Java), 并实现跨平台信息交流.
• 不需要服务器支持.
• 支持文件/文件夹的传送 (2.00版以上)
• 通讯数据采用 RSA/Blofish 加密 (2.00版以上)
• 十分小巧, 简单易用, 而且你可以完全免费使用它
• 目前已有的版本包括: Win32, Win16, MacOS, MacOSX, X11, GTK, GNOME,Java 等, 并且公开源代码。