博客园_侧身向南边

ORACLE HANDBOOK系列之九：高级队列（Advanced Queuing）

2012-03-30T02:47:00Z

Oracle Streams Advanced Queuing (AQ) is a robust and feature-rich message queuing system integrated with Oracle Database. When an organization has different systems that must communicate with each other, a messaging environment can provide a standard, reliable way to transport critical information between these systems. AQ is implemented in database tables.

Oracle AQ是Oracle数据库中集成的一种消息队列机制，可以用于不同应用程序间的消息交互，例如PL/SQL可以通过相应的Package访问队列、C#应该程序可以通过ODP.NET访问队列、Java应用程序则可以通过OJMS访问队列。AQ内部是通过数据库表实现的（即消息实际上是存储在数据库表中）。

随笔展示了PL/SQL中使用AQ的基本用法，希望对各位有帮助。示例假设了一个场景：A是一个被频繁调用的存储过程，每次调用A之前需要调用过程B，B消耗大量的时间，假设A的执行并不依赖于B的执行结果，我们可以把调用B的上下文先存入AQ中，而后异步地进行处理，从而减小了B对应用程序性能的影响。

1. 创建AQ所需要的权限

GRANT EXECUTE ON DBMS_AQ TO user1;
GRANT EXECUTE ON DBMS_AQADM TO user1;
BEGIN
DBMS_AQADM.GRANT_SYSTEM_PRIVILEGE('ENQUEUE_ANY', 'user1', FALSE);
DBMS_AQADM.GRANT_SYSTEM_PRIVILEGE('DEQUEUE_ANY', 'user1', FALSE);
END;

需要使用sys或system用户发起这些授权语句，欲创建及管理AQ，需要获得两个至关重要的包dbms_aq, dbms_aqadm的执行权限。后两个通过grant_system_privilege进行的授权是可选的，它们表示的是：

ENQUEUE_ANY means users granted this privilege are allowed to enqueue messages to any queues in the database. DEQUEUE_ANY means users granted this privilege are allowed to dequeue messages from any queues in the database.

2. 创建一个payload类型

CREATE OR REPLACE TYPE t_spl_queue_payload AS OBJECT
(
ID CHAR(36),
EXEC_DATE TIMESTAMP(6),
PARAMETER1 NUMBER,
PARAMETER2 VARCHAR2(500),
FLAG CHAR(1)
);

通常我们会定义一个对象，用于存储将来需要放置在AQ队列中的信息。

3. 创建AQ相关表

BEGIN
DBMS_AQADM.CREATE_QUEUE_TABLE(queue_table => 'user1. Spl_queue_table',
multiple_consumers => TRUE,
queue_payload_type => 'user1.t_spl_queue_payload');
END;

执行的结果是生成了表Spl_queue_table，以及若干个aq$_ spl_queue_table_表。表Spl_queue_table中除了AQ队列自身需要的一些字段外，有一个类型为t_spl_queue_payload的USER_DATA字段，用于存储队列消息，这也印证了上面说的：AQ内部是通过数据库表实现的。

4. 创建及启动AQ

BEGIN
DBMS_AQADM.CREATE_QUEUE(queue_name => 'user1.spl_aq',
queue_table => 'user1.spl_queue_table');
END;
--
BEGIN
DBMS_AQADM.START_QUEUE(queue_name => 'user1.spl_aq');
END;

如何停止及删除AQ：

BEGIN
DBMS_AQADM.STOP_QUEUE (queue_name => 'user1.spl_aq');
DBMS_AQADM.DROP_QUEUE (queue_name => 'user1.spl_aq');
DBMS_AQADM.DROP_QUEUE_TABLE (queue_table => 'user1.spl_queue_table');
END;

5. 消息的入队

PROCEDURE enqueue(p_payload IN t_spl_queue_payload) IS
--PRAGMA AUTONOMOUS_TRANSACTION;
enqueue_options dbms_aq.enqueue_options_t;
message_properties dbms_aq.message_properties_t;
message_handle RAW(16);
recipients DBMS_AQ.aq$_recipient_list_t;
BEGIN
recipients(1) := sys.aq$_agent('someguy', 'user1.SPL_AQ', NULL);
message_properties.recipient_list := recipients;
message_properties.priority := -5;
message_properties.delay := dbms_aq.no_delay;
message_properties.expiration := dbms_aq.never;
--enqueue_options.visibility := dbms_aq.on_commit;
enqueue_options.visibility := dbms_aq.immediate;
enqueue_options.sequence_deviation := null;

dbms_aq.enqueue(queue_name => 'user1.SPL_AQ',
enqueue_options => enqueue_options,
message_properties => message_properties,
payload => p_payload,
msgid => message_handle);

--COMMIT;
END enqueue;

(1) recipient，其中“someguy”指定的是消息的接收者，出队时你需要指定一样的名字才能接收到消息。(2)visibility，可以是on_commit或者immediate，如果使用on_commit，需要手工调用commit语句之后消息才进入队列（这种情况下，最好使用自治事务）；如果使用immediate，则dbms_aq.enqueue完成时消息就进入队列，不需commit，并且默认使用自治事务。

6. 消息的出队

PROCEDURE dequeue IS
l_payload t_spl_queue_payload;
l_queue_record NUMBER;
dequeue_options dbms_aq.dequeue_options_t;
message_properties dbms_aq.message_properties_t;
message_handle RAW(16);
BEGIN
dequeue_options.consumer_name := 'someguy';
dequeue_options.dequeue_mode := dbms_aq.remove;
dequeue_options.navigation := dbms_aq.next_message;
dequeue_options.visibility := dbms_aq.immediate;
--dequeue_options.wait := dbms_aq.forever;
dequeue_options.wait := dbms_aq.no_wait;
dequeue_options.msgid := null;
--
SELECT COUNT(*)
INTO l_queue_record
FROM AQ$SPL_QUEUE_TABLE
WHERE msg_state = 'READY';
--
FOR i IN 1 .. l_queue_record LOOP
dbms_aq.dequeue(queue_name => 'user1.SPL_AQ',
dequeue_options => dequeue_options,
message_properties => message_properties,
payload => l_payload,
msgid => message_handle);
--
/*……………………………………….
some time consuming calculation
………………………………………….*/
END LOOP;
END;

(1) consumer_name需要和前面在入队时指定的recipient一致。(2)wait的两个值forever和no_wait是指如果当前队列中无消息时，是否进行等待，默认等待。(3) navigation的两个值first_message和next_message，一般出于性能考虑我们使用后者，或者在第一次出队时使用前者而在随后的出队中使用后者：

The FIRST_MESSAGE navigation option performs a SELECT on the queue. The NEXT_ MESSAGE navigation option fetches from the results of the SELECT run in the FIRST_ MESSAGE navigation. Thus performance is optimized because subsequent dequeues need not run the entire SELECT again.

本文链接

ORACLE HANDBOOK系列之八：分区（Partition）

2012-03-22T08:34:00Z

Partitioning enables you to decompose very large tables and indexes into smaller and more manageable pieces called partitions. Each partition is an independent object with its own name and optionally its own storage characteristics.

Oracle允许用户将大表以及大的索引拆分成小块，每一块都是一个单独的对象，称为分区，分区技术可以用于提高查询及DML性能、以及更便捷地管理数据。

1. 分区表

1.1. 分区表主要包括三种：

Range Partitioning

List Partitioning

Hash partitioning

1.2. 分区表创建语法示例（Range分区）：

CREATE TABLE tab_part_0309(val DATE, val2 VARCHAR2(200))
PARTITION BY RANGE(val)
(
PARTITION p1 VALUES LESS THAN (TO_DATE('20120308','yyyymmdd'))
);

1.3. ORA-14400错误

如果在插入数据时Oracle无法找到合适的分区，就会产生ORA-14400错误，”inserted partition key does not map to any partition”。例如（假设当前为2012-03-09）：

INSERT INTO tab_part_0309 VALUES(SYSDATE,'abrownfox');

1.4. 如何添加分区

ALTER TABLE tab_part_0309 ADD PARTITION p2 VALUES LESS THAN (TO_DATE('20120309','yyyymmdd'));
ALTER TABLE tab_part_0309 ADD PARTITION p3 VALUES LESS THAN (TO_DATE('20120310','yyyymmdd'));

1.5. 查询

SELECT * FROM tab_part_0309 PARTITION(p3);

查询时我们可以指定分区。不过更常见的是Oracle自动的Partition Pruning，即如果查询时Where子句中包括用于分区的列（示例中的val列），Oracle会自动定位分区，而不用我们手工指定分区。

1.6. 删除分区

ALTER TABLE tab_part_0309 DROP PARTITION p3;

1.7. MAXVALUE

一些情况下，我们会通过定时任务（Scheduler）来定期创建分区，这时候我们需要考虑一个问题，如果定时任务失败了导致分区没有建立，那么后斯的数据插入就会遇到ORA-14400错误。有一种方法可以避免这种错误，使用MAXVALUE：

CREATE TABLE tab_part_0309_2(val DATE, val2 VARCHAR2(200))
PARTITION BY RANGE(val)
(
PARTITION p1 VALUES LESS THAN (TO_DATE('20120308','yyyymmdd')),
PARTITION pm VALUES LESS THAN (MAXVALUE)
);

使用MAXVALUE后，无法再添加新的分区：

ALTER TABLE tab_part_0309_2 ADD PARTITION p2 VALUES LESS THAN (TO_DATE('20120310','yyyymmdd'))
ORA-14074, partition bound must be collate higher than that of the last partition

但是我们可以从pm分区中进行拆分：

ALTER TABLE tab_part_0309_2
SPLIT PARTITION pm AT (TO_DATE('20120310','yyyymmdd'))
INTO (PARTITION p2, PARTITION pm)

这样的好处是，即便执行拆分的定时任务失败了，数据仍然可以正常插入（只不过进入了pm分区）。同时，发现错误后，我们可以进行补救，手工拆分出一个分区，这样，pm中符合新分区条件的数据，会自动进行新的分区。

1.8. Interval partitioning

11G中引入了一个更为强大的分区机制：Interval partitioning，可以按一定条件自动创建分区。创建语法是这样的：

CREATE TABLE tab_part_0309_3(val DATE, val2 VARCHAR2(200))
PARTITION BY RANGE(val)
INTERVAL (NUMTOYMINTERVAL(1,'MONTH'))
(
PARTITION p1 VALUES LESS THAN (TO_DATE('20120308','yyyymmdd'))
);

Interval分区表必须指定一个根分区（上例的p1），使用Interval指定分区的间隔，它使用了NumToYMInterval函数，该函数第一个参数是number，后一个是单位，包括’MONTH’, ‘YEAR’，上例表示间隔为一个月，目前看一个月应该是最小的间隔了，你可以指定0.5或者0.3，但最终的效果还是一个月。

假设当前时间为2012-03-09，执行下述语句

INSERT INTO tab_part_0309_3 VALUES(SYSDATE, 'abrownfox');

1）导致自动创建新分区

2）分区字段值为2012-04-08，是从根分区往后的一个月时间。

3）分区名称自动生成，如SYS_P21

4）如果插入的时间在两个月以后或者更久，则Oracle只生成必须的分区，并不会生成连续分区。例如insert的时间是2012-06-01，则只会生成2012-06-08分区，至于中间的2012-05-08，2012-04-08分区并不生成。

2. 分区索引

跟表一样，索引也分为普通索引与文艺索引（就当分区索引比较文艺一点吧）。可以为一张普通表创建分区索引（不过不能创建Local分区索引，后面解释），也可以为一张分区表创建普通索引。

2.1. 分区索引分两类

全局分区索引(global partitioning index)

本地分区索引(local partitioning index)

2.2. 全局分区索引

与表的分区没有关系，创建索引时可以指定任意的列作为索引分区的Key，创建语法如下：

CREATE TABLE tab_part_0321_2(val DATE, val2 NUMBER)
PARTITION BY RANGE(val)
(
PARTITION p1 VALUES LESS THAN (TO_DATE('20120308','yyyymmdd'))
);

CREATE INDEX tab_part_0321_2_idx ON tab_part_0321_2 (val2)
GLOBAL PARTITION BY RANGE (val2)
(PARTITION p1 VALUES LESS THAN (2),
PARTITION p2 VALUES LESS THAN (3),
PARTITION p3 VALUES LESS THAN (MAXVALUE));

注意这里使用了global关键字，并且索引分区使用的Key是val2字段，而不是表分区使用的val字段。

那么是否可以在为字段val2创建索引但是使用val字段作为分区的key呢？

CREATE INDEX tab_part_0321_2_idx2 ON tab_part_0321_2 (val2)
GLOBAL PARTITION BY RANGE (val)
(PARTITION pa VALUES LESS THAN (to_date('20120308','yyyymmdd')),
PARTITION pb VALUES LESS THAN (to_date('20120408','yyyymmdd')),
PARTITION pc VALUES LESS THAN (MAXVALUE));
ORA-14038 global partitioned index must be prefixed.

Prefixed即“前缀索引”，指索引键与分区键是相同的，Oracle无法创建非前缀的全局分区索引。

2.3. 本地分区索引

只有分区表才能创建本地分区索引，本地分区索引始终使用与分区表相同的字段进行分区（不需要partition by子句），因此索引的分区与表的分区是一一对应的。我们看看语法：

CREATE INDEX tab_part_0321_2_idx3 ON tab_part_0321_2 (val) LOCAL

尝试：

CREATE INDEX tab_part_0321_2_idx4 ON tab_part_0321_2 (val2) LOCAL
ORA-01408 such column list already indexed

这是因为在前一小节我们在这个列上创建过索引了，我们回去把tab_part_0321_2_idx移除，重新执行上面的语句便可创建成功，这说明跟global分区索引不同，local分区索引允许创建“非前缀索引”。

注：关于前面提到的本地前缀索引(local prefixed index)与本地非前缀索引(local non-prefixed index)的概念，有兴趣的可以看看OTN的一些讨论帖子，比如：https://forums.oracle.com/forums/thread.jspa?threadID=2150455&start=0&tstart=0

本文链接

字符集、编码以及Oracle的那些事

2011-11-11T02:58:00Z

第一部分 字符集与编码常识

字符集：

人们根据需要把某些字符收集到一处，并赋以名称，于是便有了某某字符集。

编码：

当前面收集的工作完成以后，为了让只认识数字的“愚蠢”的计算机也能够存储字符，人们不得不为集合里的每一个字符分配”身份证号码”，这就是编码，从此，终于可以以存储编码的方式在计算机中存储字符了。

在字符集与编码世界的漫漫历史长河里（伪），出现过若干个让计算机工作者们如雷贯耳的名字，这些名字，有些已经成了浮云飘散了，有些还在我们的代码中折腾。

ASCII：

ü ASCII字符集：包含大小写英文、阿拉伯数字、标点，以及一些不可见的控制符共128个。

ü ASCII编码：使用7位表示一个字符。编码范围是[0-127]（即Hex[00-7F]），其中[0-31]（Hex[00-1F]）部分以及127（Hex7F）是控制符，其余的都是些可见字符。

GB2312:

ü GB2312字符集：ASCII字符集+7000左右汉字字符。

ü GB2312编码：兼容ASCII编码。对字节进行判断，如值<=127，则意义等同于ASCII编码；如值>127，则它需要跟其后的另一个字节合并表示一个字符。其理论汉字编码空间为128X256，超过3万个字符。

GBK：

ü GBK字符集：GB2312字符集+20000左右汉字字符。

ü GBK编码：兼容GB2312编码。利用了GB2312编码闲置的编码空间。

GB18030:

ü GB18030字符集：GBK字符集+若干汉字+若干少数民族字符，为目前国内最新的字符集。

ü GB18030编码：兼容GBK编码。继续利用GBK编码闲置的编码空间，对于超出编码空间的则采用4个字节表示。

BIG5：

ü BIG5字符集：ASCII字符集+13000左右汉字（繁体）。

ü BIG编码：兼容ASCII编码。其编码模式类似于GB2312.

UNICODE：（UNICODE一词在日常使用中显得宽泛、混乱，在不同的语境中可以是以下意思之一。）

ü UNICODE标准：由一些组织提出的一套标准，对人类文字的显示、编码等进行了一系列的规定。

ü UNICODE字符集：目前最新版的UNICODE字符集中已经包含各种语言的超过10万的字符。

ü UNICODE编码：（狭义的UNICODE编码可能指UCS-2，也可能指UTF-16；广义的UNICODE编码可以指包括以下四种在内的若干种对UNICODE标准的编码实现。）

1. UTF-32编码：固定使用4个字节来表示一个字符，存在空间利用效率的问题。

2. UTF-16编码：对相对常用的60000余个字符使用两个字节进行编码，其余的(即’补充字符supplementary characters’)使用4字节。

3. UCS-2编码：是对UNICODE早期版本的实现，它与UTF-16的唯一区别是它不包括’补充字符’，所以它对字符的编码只使用两个字节。目前此编码模式已过时。

4. UTF-8编码：兼容ASCII编码；拉丁文、希腊文等使用两个字节；包括汉字在内的其它常用字符使用三个字节；剩下的极少使用的字符使用四个字节。

ISO8859-1：（使用Oracle的同志们可能见过这个WE8ISO89859P1，没错，就是它。）

ü ISO8859-1字符集：ASCII字符集+若干西欧字符，例如字母Â、Ë。

ü ISO8859-1编码：使用8位表示一个字符，同时移除了原ASCII编码中的控制符（即[0-31]，及127）。

Code page：（可以把”code page”认为是”编码”的近义词。至于为什么有这个名称？历史遗留问题。）

ü ANSI code pages：你一定见过ANSI，想想另存文本文件时。ANSI code pages实际上是一系列的编码集合，根据操作系统区域设置而激活其中一种作为默认ANSI编码。例如公司电脑（英文系统）上的ANSI code page可能是1252，而家里的中文系统则可能是936。所以在家里可以用ANSI存储一个包含中文的文本文件，在公司则不行。可以在注册表键：HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\NLS\CodePage\ACP中查看到当前使用的ANSI code page。 C#可以通过Encoding.Default查看。

ü OEM code pages： OEM code pages是给控制台应用程序（如SQLPLUS）使用的。除CJK环境（Chinese-Japanese-Korean）外，Windows使用不同的ANSI code page和OEM code page。例如，公司英文系统上使用的是437。可以使用CHCP命令查看当前使用的OEM code page， C#可以通过Console.OutputEncoding查看。

Code page 1252：

ü cp1252字符集：ASCII字符集+若干西欧字符+若干特殊符号，比如™、‰.

ü cp1252编码：使用8位表示一个字符。编码范围是[0-255]（即Hex[00-FF]），[0-127]部分与ASCII相同，新增的大部分是西欧的字符，例如一些带上标的字母Â、Ë，以及像这样一类特殊符号）

PS1：现实中两台PC上的code page信息

PC 1：英文版Windows XP，ANSI code page=1252, OEM code page=437

PC 2：中文版Windows 7，ANSI code page=936, OEM code page=936

PS2：cp1252与cp437编码表下载请猛击这里，早期控制台应用程序常常需要画一些粗糙的表格等等图形，所以可以在437中看到不少不同的横线竖线这一类的特殊符号。

PS3：CP1252、ISO8859-1、ASCII比较，就实际使用的编码范围来说：CP1252>ISO8859-1>ASCII。ASCII是[0-127]，CP1252是[0-255]，ISO8859-1则移除了cp1252中[0-31]及127这些不可见的控制符，同进移除了[128-159]（即Hex[80-9F]）中的特殊符号。

第二部分 Oracle中的编码与字符集

1.为什么需要两个字符集？

Oracle中有两个字符集：

1）数据库字符集

2）国家字符集

为什么要有两个字符集？如果我知道只需要英文，设置数据库字符集=US7ASCII，如果我知道只需要西欧字符，设置数据库字符集=WE8MSWIN1252或者WE8ISO89859P1，或者干脆就用AL32UTF8。你看，我只需要设定“数据库字符集”，那么“国家字符集”有什么必要呢？

其实，考虑到历史遗留问题以及数据库创建者们无法避免的“短视”，很多现有数据库都无法支持UNICODE字符集，例如要在现有的US7ASCII数据库字符集的数据库中存储中文，这个时候“国家字符集”+NVARCHAR2这样的组合就能救你一命了。对于数据类型为NVARCHAR2(以及NCHAR, NCLOB)的字段，它使用是国家字符集，与数据库字符集的设置无关。自9i以后，国家字符集可选的只有AL16UTF16与AL32UTF8，UTF-16与UTF-8都是UNICODE编码标准的实现，因些可以表示世界上几乎所有的文字。

当然，如果数据库字符集本身就使了UNICODE字符集，就没有必要使用NVARCHAR2, NCHAR, NCLOB这些类型了。

2.字符集名称的玄机

Oracle对字符集的命名实际上有一定的规则可寻，例如：

AL32UTF8

【AL】支持所有语言（All Language）。

【32】每字符最多占用32位（4字节）。

【UTF8】编码为UTF-8。

WE8MSWIN1252

【WE】支持西欧语言（Western Europe）。

【8】每字符需要占用8位（单字节）。

【MSWIN1252】编码为CP1252。

US7ASCII

【US】表示美国（United States）。

【7】每字符需要占用7位。

【ASCII】编码为ASCII。

其它如ZHS16GBK，ZHT16BIG5，US8PC437（编码为OEM cp437），都可以类推。

3.例子很重要

3.1.准备两个数据库

上帝说要有例子，于是有了两个相同版本的数据库，A跟B：

SELECT parameter, VALUE
FROM nls_database_parameters
WHERE parameter IN ('NLS_CHARACTERSET', 'NLS_NCHAR_CHARACTERSET')

--数据库A：
PARAMETER                      VALUE
------------------------------ -------------------
NLS_CHARACTERSET               WE8MSWIN1252
NLS_NCHAR_CHARACTERSET         AL16UTF16

--数据库B：
PARAMETER                      VALUE
------------------------------ -----------------
NLS_CHARACTERSET               AL32UTF8
NLS_NCHAR_CHARACTERSET         AL16UTF16

--在A和B中分别创建一张表。
CREATE TABLE charset_test
(id NUMBER(4) PRIMARY KEY,
vc VARCHAR2(20),
nvc NVARCHAR2(20));

3.2.工具很重要

在测试之前，为避免工具本身的特性给人造成的困惑，介绍一下几个客户端工具对UNICODE 的支持情况：

ü SQLPLUS：不支持UNICODE字符集。是否支持中文取决于当前的OEM code page，如果是cp437，无论输入还是显示中文都是不可能的。但如果是cp936，则可以支持中文输入输出。

ü PLSQL Developer：7.0版本的查询结果窗口支持UNICODE字符集，但是编辑窗口(即输入SQL语句的窗口)不支持。8.0版完全支持UNICODE。

ü Oracle SQL Developer：查询结果窗口与编辑窗口都支持UNICODE字符集。

3.3.出现乱码了

这里使用Oracle SQL Developer，分别在A、B中插入并查询中文：

INSERT INTO charset_test VALUES(1,'中','中');
COMMIT;

--A库
SELECT * FROM charset_test;
1 ¿ ¿

--B库
SELECT * FROM charset_test;
1 中中

暂时先跳过VARCHAR2字段，先来关注NVARCHAR2字段，为什么在A库不能正常显示？无非有这几种可能：

ü 客户端操作系统不支持显示中文。

ü Oracle客户端工具（这里是Oracle SQL Developer）不支持显示中文。

ü Oracle客户端有相关设置（比如NLS_LANG）不正确。

ü 存储在数据库中的数据已经是不正确的数据。

第一点，客户端操作系统是否支持中文对运行于其上的应用程序有影响吗？应该有两种情况，一种是应用程序依赖于操作系统的中文支持；另一种是有一些软件自己带有语言包及字体（比如Adobe的一些产品，.NET程序在编译的时候也可以选择将字体文件打包进去），那么它应该不依赖于操作系统。

我猜测Oracle SQL Developer应该是属于前一种，同时我检查了操作系统，确定其已经支持东亚语言（Control panel—Regional and language options—Language tab—Supplemental languages support—Install files for East Asian languages，如果checkbox已经选中，说明已经安装东亚语言包）。

第二点，无论查询结果窗口还是编辑窗口都支持UNICODE字符集。

第三点，由于不依赖于Oracle client的OCI，客户端注册表中的NLS_LANG设置对像Oracle SQL Developer没有影响。

第四点，我们借助DUMP()函数来确定NVARCHAR2字段中具体的内容。

DUMP()的语法：DUMP(<value>[,<format>[,<offset>[,<length>]]])

其中的format参数：如果是8则表示结果使用8进制表示，如果是16则表示16进制，如果是0到16间的其它数则都使用10进制。如果是大于16的数，则分几种情况：如果是可见的ASCII字符则直接打印此字符，如果是控制字符则打印成“^x”，其它情况则把结果按16进制显示。为format加上1000则表示除了输出结果之外，还会附带输出所使用的字符集信息。

这里我们使用：

SELECT DUMP(nvc,1016) FROM charset_test;
--A库
Typ=1 Len=2 CharacterSet=AL16UTF16: 0,bf

--B库
Typ=1 Len=2 CharacterSet=AL16UTF16: 4e,2d

我们知道“中”字的UTF-16编码是4E2D，显然在A库中存储的数据已经是不对的，00BF实际上就是一个倒的问号字符，其存储在数据库中的原始数据已经不对了，更何况是客户端的显示。

3.4.找不同

那么为什么两个库会不一样呢？嫌疑很快就落在了数据库字符集上，因为A和B的区别只在数据库字符集上，一个是WE8MSWIN1252，另一个是AL32UTF8。经过测试，结论是：

Oracle SQL Developer忽略NLS_LANG，字符串直接以照数据库字符集进行编码后由客户端传输到服务器端。由于A库数据库字符集不支持汉字，很不幸地被替换成了默认的BF并最终被存储到数据库中，永远地错下去。B库则相反，中文在传输的过程中“存活”下来并成功到达服务器端，最终自动转换成NVARCHAR2所用的编码并存储到库中。

3.5.如何让NVARCHAR2字段工作

看起来似乎A库中的NVARCHAR2字段永远也无法正常使用了，并非这样，对于Oracle SQL Developer，通过一些设置，就可以让NVARCHAR2可以正常地插入、查询。

找到{ORACLE_HOME}\sqldeveloper\sqldeveloper\bin\sqldeveloper.conf（依赖于你的Oracle SQL Developer安装路径），添加一行配置：

AddVMOption -Doracle.jdbc.convertNcharLiterals=true

同时在中文字符串前添加“N”前缀：

INSERT INTO charset_test VALUES(2,'中',N'中');
--NVARCHAR2列中的中文不再是乱码了
SELECT * FROM charset_test WHERE id=2;
2 ¿ 中

这个配置起到的作用是这样的：在INSERT语句从客户端传输到服务器端之前，Oracle SQL Developer检测（实际上是JDBC检测）语句，如果发现“N”前缀，则事先将这部分的字符串按UTF-16进行编码得到16进制串。也就是相当于执行了这个命令：

INSERT INTO charset_test VALUES(2,’中’,UNISTR('\4e2d'));

C#不需要做特殊的配置来让NVARCHAR2正常工作，只需要在执行INSERT时使用参数并选择正确的参数类型选：

cmd.CommandText = "insert into charset_test values(3,:vc,:nvc)";
OracleParameter p1 = new OracleParameter("vc", OracleDbType.Varchar2);
OracleParameter p2 = new OracleParameter("nvc", OracleDbType.NVarchar2);
p1.Value = "中";
p2.Value = "中";
cmd.Parameters.Add(p1);
cmd.Parameters.Add(p2);
cmd.ExecuteNonQuery();

4.客户端的NLS_LANG设置及编码转换

前面我说过Oracle SQL Developer忽略客户端NLS_LANG设置，那么对于其它的工具呢？（这里我们主要关注字符集及编码，不讨论NLS_LANG对日期格式、排序方式、数字显示格式等等的影响）

ü SQLPLUS，插入与查询都依赖于客户端NLS_LANG设置。通常，客户端NLS_LANG设置要与当前的OEM Codepage一致，比如US8PC437。

ü PL/SQL Developer，插入与查询都依赖于客户端NLS_LANG设置。通常，客户端NLS_LANG设置要与数据库字符集一致。

使用SQLPLUS可以清晰地看到Oracle编码转换的过程：

1) 在Oracle客户端向服务器端提交SQL语句时，Oracle客户端根据NLS_LANG和数据库字符集，对从应用程序接传送过来的字符串编码进行转换处理。如果NLS_LANG与数据库字符集相同，不作转换，否则要转换成数据库字符集并传送到服务器。服务器在接收到字符串编码之后，对于普通的CHAR或VARCHAR2类型，直接存储；对于NCHAR或NVARCHAR2类型，服务器端将其转换为国家字符集再存储。

2) 在查询数据时，服务器端原样返回存储在库中的数据，由客户端根据返回的元数据中的字符集信息与NLS_LANG和NLS_NCHAR的设置进行比较（如果NLS_NCHAR没有设置，则其默认值为NLS_LANG中的字符集设置），如果元数据中的字符集信息与客户端设置一致，不进行转换，否则要进行转换。国家字符集的转换根据NLS_NCHAR设置进行转换。

这里我也举几个使用SQLPLUS的测试例子，分别在A、B两库执行相同的语句，然后通过网络抓包查看从Oracle client传输到服务器的具体内容。

例1 客户端NLS_LANG：WE8MSWIN1252

SQL命令：insert into charset_test values(1,'æ',null);

网络抓包(A库，数据库字符集为WE8MSWIN1252)：91

解释：由于应用程序(即SQLPLUS)使用的编码是Codepage437，所以æ的编码是91。当91被传给Oracle client后，Oracle client根据NLS_LANG误判其使用的编码是Codepage1252，又由于NLS_LANG设置与数据库字符集一致，于是Oracle client不进行编码转换，91被直接传给服务器并存储，考虑到数据库字符集是Codepage1252，很显然91是错误的数据(字符[æ]在Codepage1252下的编码是E6，而非91)。

这个错误导致了一个有趣的现象，那就是在同一个客户端使用SQLPLUS查询居然可以看到正确字符[æ]，这是由于SELECT的时候91也被直接返回，并且在Oracle client也不进行编码转换而是直接传给了应用程序，恰巧应用程序根据自己使用的编码可以正确解析91。但是换一个客户端机器，或者换一个客户端工具都可能得到不一样的查询结果。

网络抓包(B库，数据库字符集为AL32UTF8)：E2 80 98

解释：由于应用程序(即SQLPLUS)使用的编码是Codepage437，所以æ的编码是91。当91被传给Oracle client后，Oracle client根据NLS_LANG误判其使用的编码是Codepage1252，而91在Codepage1252中对应的是字符[‘]，根据Codepage1252到数据字符集UTF8的转换，最终转换成了E2 80 98，即UTF8下的[‘]。

例2 客户端NLS_LANG：US7ASCII

SQL命令：insert into charset_test values(1,'æ',null);

网络抓包(A库)：BF

解释：由于应用程序(即SQLPLUS)使用的编码是Codepage437，所以æ的编码是91。当91被传给Oracle client后，Oracle client根据NLS_LANG误判其使用的编码是ASCII，而91在ASCII中是无效编码，根据ASCII到数据字符集Codepage1252的转换，最终转换成了BF，BF是Codepage1252遇到无效编码时使用的默认替换编码。

网络抓包(B库)： EF BF BD

解释：由于应用程序(即SQLPLUS)使用的编码是Codepage437，所以æ的编码是91。当91被传给Oracle client后，Oracle client根据NLS_LANG误判其使用的编码是ASCII，而91在ASCII中是无效编码，根据ASCII到数据字符集UTF8的转换，最终转换成了EF BF BD，EF BF BD是UTF8遇到无效编码时使用的默认替换编码。

例3 客户端NLS_LANG：US8PC437

SQL命令：insert into charset_test values(1,'æ',null);

网络抓包(A库)：E6

解释：E6是字符[æ]的正确的Codepage1252编码，此次由于应用程序(即SQLPLUS)使用的是Codepage437，Oracle client从NLS_LANG获得的编码信息也是Codepage437，于是进行了正确的编码转换。

网络抓包(B库)：C3 A6

解释：C3 A6是字符[æ]的正确的UTF8编码，此次由于应用程序(即SQLPLUS)使用的是Codepage437，Oracle client从NLS_LANG获得的编码信息也是Codepage437，于是进行了正确的编码转换。

我觉得，只有SQLPLUS的日子总是那么美好，一切看起来既合理又可解释。当其它工具出现之后，世界就变得一团乱麻了，Oracle SQL Developer完全忽略客户端NLS_LANG设置倒是让事情变得简单，不过PL/SQL Developer则是另一回事，我花了4天时间企图搞明白其中的编码转换过程，最终只证明它就是个不可理喻的玩意儿，唯一目前看起来还正确的结论是：如果要用PL/SQL Developer，只好还是把NLS_LANG设置得跟数据库字符集一致。其它就只能自求多福了。

5.NLS_LANG对ODP.NET的影响

cmd.CommandText = "select * from charset_test where id=6";
OracleDataReader odr = cmd.ExecuteReader();
while (odr.Read())
{
    OracleString c1 = odr.GetOracleString(1);//varchar2 field, value ‘æ’
    OracleString c2 = odr.GetOracleString(2);//nvarchar2 field, value ‘æ’
    byte[] bs1 = c1.GetNonUnicodeBytes();//230(using WE8MSWIN1252);63(using US7ASCII)
    byte[] bs3 = c2.GetNonUnicodeBytes();//230(using WE8MSWIN1252);63(using US7ASCII)
}

唯一受客户端NLS_LANG影响的是OracleString的GetNonUnicodeBytes()方法，此方法依赖于客户端本地设置的字符集，例如我们把NLS_LANG从AMERICAN_AMERICA.WE8MSWIN1252改成AMERICAN_AMERICA.US7ASCII

其中230（即HexE6）正是字符‘æ’的编码，而63（即Hex3F）是ASCII中的问号（由于ASCII字符集中没有‘æ’，故用问号代替）。

6.关于VARCHAR2, NVARCHAR2的其它问题

NVARCHAR2(N)，其中的N是指字符数，不是字节数。不过其最大长度是以字节为单位，即4000字节。

VARCHAR2(N)，其中的N可能是指字符数，也可能是指字节数。你可以显式地在声明的时候指定，比如VARCHAR2(10 BYTE)或者VARCHAR2(10 CHAR)，未显式指明时，则由参数NLS_LENGTH_SEMANTICS决定。需要注意的是你能成功声明VARCHAR2(4000 CHAR)并不能保证你能真的存储4000个字符，如果超过4000字节，该报错Oracle还是会报错。

【参考及引用】：

1. http://www.cnblogs.com/skynet/archive/2011/05/03/2035105.html

2. http://www.laoxiong.net/category/oracle/orainternal/page/2

3. http://en.wikipedia.org/wiki/Windows-1252

4. http://en.wikipedia.org/wiki/ASCII

5. http://en.wikipedia.org/wiki/Code_page_936

6. http://en.wikipedia.org/wiki/Code_page_437

7. http://en.wikipedia.org/wiki/UTF-8

8. http://en.wikipedia.org/wiki/UTF-16/UCS-2

9. http://en.wikipedia.org/wiki/UTF-32/UCS-4

10. http://en.wikipedia.org/wiki/GB_18030

11. http://en.wikipedia.org/wiki/Unicode

12. OReilly Oracle PL SQL Programming 5th Edition，Steven Feuerstein, Bill Pribyl

13. http://www.laruence.com/2009/08/22/1059.html

14. http://en.wikipedia.org/wiki/Windows_code_page

本文链接

ORACLE HANDBOOK系列之七：时间与时区（Time and Time Zone）

2011-10-12T01:49:00Z

一）

Oracle中的四种时间类型

Date

Timestamp

Timestamp with local time zone

Timestamp with time zone

这四种类型中，前两个与时区完全无关，它们的“行为”就像varchar2或者number类型一样，就是你插入时是什么值，那么存储的也是一样的值，同时查询出来的也是一样的值（包括你在.NET环境下用ADO.NET或者ODP.NET进行查询），不存在任何所谓的“参数”设置可以改变它们（当然，你可以改变它们的显示格式，但不是值）。

后两个类型则跟时区信息紧密相关，但它们之间又有较大的不同。timestamp with local time zone事实上并不存储时区信息，在向此类型的列中插入值时，用户提供时区信息，但是Oracle会自动将其转换成dbtimezone下的时间进行存储，所以，timestamp with local time zone有时区信息，即数据库时区，但它并不存储时区信息。当查询发生时，Oracle再将时间转化到客户端的时区（sessiontimezone）进行显示。

不同于timestamp with local time zone这种把时区的转换委托给Oracle服务器，timestamp with time zone则是单纯地把你在insert时提供的时间+时区信息保存到数据库中。

二）

两个与时区相关的参数

Dbtimezone

Sessiontimezone

前者表示数据库时区，后者表示客户端时区。只有timestamp with local time zone才会受时区修改的影响。这两个参数都可以通过alter命令进行修改。

对客户端操作系统时区的修改将会影响此机器上的oracle客户端的sessiontimezone；修改服务器操作系统时区并不会改变dbtimezone。

SQL> select dbtimezone from dual;
DBTIMEZONE
------------------------------
-06:00

SQL> select sessiontimezone from dual;
SESSIONTIMEZONE
------------------------------
+08:00

修改客户端或数据库时区的alter命令：

alter session set time_zone='+10:00';
alter database set time_zone='+10:00';

如果数据库中存在有timestamp with local time zone类型的字段，则在修改dbtimezone时会出现ORA-30079: cannot alter database timezone when database has TIMESTAMP WITH LOCAL TIME ZONE columns

三）

如何向数据库插入一个timestamp with time zone或者timestamp with local time zone类型

SQL> create table tz1(twtz timestamp with time zone, twltz timestamp with local time zone);

SQL> insert into tz1 values(timestamp'2011-01-03 15:00:00.000000 +05:00',timestamp'2011-01-03 15:00:00.000000 +05:00');

SQL> select sessiontimezone from dual;
SESSIONTIMEZONE
---------------------------------------------------------------------------
+08:00

SQL> select * from tz1;
TWTZ                                    TWLTZ
---------------------------------------------------------------------------
03-JAN-11 03.00.00.000000 PM +05:00     03-JAN-11 06.00.00.000000 PM

SQL> alter session set time_zone='-06:00';

SQL> select * from tz1;
TWTZ                                    TWLTZ
---------------------------------------------------------------------------
03-JAN-11 03.00.00.000000 PM +05:00     03-JAN-11 04.00.00.000000 AM

除了采用类似“+05:00”这种形式的时区标识外，还可以使用时区的缩写，比如GMT,PST等等（可以查看系统视图 V$TIMEZONE_NAMES）。如果在insert时未给出时区信息，那么默认为当前客户端的时区。

四）

一些与时区相关的函数：

函数	返回值	返回值类型
SYSTIMESTAMP	Current date/time, in Database TZ	TIMESTAMP WITH TIME ZONE
CURRENT_TIMESTAMP	Current date/time, in Client Session TZ	TIMESTAMP WITH TIME ZONE
LOCALTIMESTAMP	Local date/time in Client Session, but with no TZ info	TIMESTAMP
DBTIMEZONE	Database time zone, in HH:MI offset from GMT	VARCHAR2
SESSIONTIMEZONE	Session time zone, in HH:MI offset from GMT	VARCHAR2
EXTRACT (part FROM date_time)	Extracts year, hour, seconds, time zone name, etc. from a supplied datetime or interval expression.	VARCHAR2
SYS_EXTRACT_UTC(date_time with TZ)	GMT (UTC) time of date/time supplied	TIMESTAMP
TZ_OFFSET(TZ)	Returns hour/minute offset from GMT of TZ	VARCHAR2
FROM_TZ(timestamp,TZ)	Converts a TIMESTAMP to TIMESTAMP WITH TIME ZONE	TIMESTAMP WITH TIME ZONE
TO_TIMESTAMP	Convert char + fmt model to TIMESTAMP	TIMESTAMP
TO_TIMESTAMP_TZ	Convert char + fmt model to TIMESTAMP WITH TIME ZONE	TIMESTAMP WITH TIME ZONE

五）

时区的基本换算

时区分东西，东时区都带+号标识，西时区用-号。在一个特定的时间点，时区号越大（考虑正负号）的地方，时间越晚，比如北京在+08:00区, St. Louis在-06:00区，北京已经是傍晚了，St. Louis还在凌晨，它们之前相差即+08:00-(-06:00)=14（受夏时制的影响，可能会有一个小时的误差）。

六）

应该选择哪种时间类型？

如果需要记录的时间精度超过秒，选择timestamp类型。

如果需要将时间在数据库时区与客户端时区之间进行自动转换，选择timestamp with local time zone。

如果需要记录客户插入的时区信息，选择timestamp with time zone。

七）

ODP.NET与OracleGlobalization

对于timestamp with time zone类型，由于包含了原始时区信息，所以应用程序中对其进行手动的转换也不困难。除了手动方法，我们还可以通过设置OracleGlobalization下的相关属性让ODP.NET为你进行自动转换。看一个例子：

conn.Open();//connection should be opened before SetSessionInfo() could be invoked.
//
OracleGlobalization og = OracleGlobalization.GetClientInfo();
og.TimeZone = "America/Chicago";
OracleGlobalization.SetThreadInfo(og);
conn.SetSessionInfo(og);
//
OracleCommand cmd = new OracleCommand();
cmd.Connection = conn;
cmd.CommandText = "select twtz from tz1";
OracleDataReader dr = cmd.ExecuteReader();
if (dr.HasRows)
{
    while (dr.Read())
    {
        OracleTimeStampTZ otstz = dr.GetOracleTimeStampTZ(dr.GetOrdinal("twtz"));
        Console.WriteLine("twtz: " + otstz.ToString());
    }
}
dr.Close();
//
//an alias is necessary when using 'AT LOCAL' predicate
cmd.CommandText = "select twtz AT LOCAL as twtz from tz1";
dr = cmd.ExecuteReader();
if (dr.HasRows)
{
    while (dr.Read())
    {
        OracleTimeStampTZ otstz = dr.GetOracleTimeStampTZ(dr.GetOrdinal("twtz"));
        Console.WriteLine("twtz AT LOCAL: " + otstz.ToString());
    }
}
dr.Close();

//output:
twtz:                   03-JAN-11 03.00.00.000000 PM +05:00

twtz AT LOCAL: 03-JAN-11 04.00.00.000000 AM AMERICA/CHICAGO

可以看到当设置了时区，并在sql语句中使用了‘AT LOCAL’后，原来的时间被自动转换到了芝加哥的时间（芝加哥在西6区，所以与原时间的时区东5区差为11小时）。

本文链接

ORACLE HANDBOOK系列之六：VPD

2011-08-23T09:15:00Z

VPD，Oracle Virtual Private Database，即【Oracle虚拟专用数据库】，通过应用一些策略，使得用户只能访问被允许访问的那部分数据。其原理相对简单，Oracle根据策略自动为相应用户提交的语句添加Where句，从而控制用户可以访问和操作的数据。

首先我们准备演示用的几张表，并插入少量的测试数据：

CREATE TABLE vpdsample_clothing(
clothing_id NUMBER,
type VARCHAR2(30),
brand VARCHAR2(30),
descripton VARCHAR2(100)
);
--
INSERT INTO vpdsample_clothing VALUES(10002,'jacket','ABC','autumn style');
INSERT INTO vpdsample_clothing VALUES(10003,'t-shirt','XYZ','summer style');
commit;

CREATE TABLE vpdsample_books(
book_id NUMBER,
name VARCHAR2(30),
author VARCHAR2(20)
);
--
INSERT INTO vpdsample_books VALUES(10005,'Country Driving','Peter Hessler');
INSERT INTO vpdsample_books VALUES(10006,'Life without limits','Nick Vujicic');
commit;

（以上两个表模拟一个简单的库存情况，库中有两类物品，服装、图书。这里我们需要满足两个表中的ID的唯一性（可以通过sequence来实现）。）

CREATE TABLE vpdsample_users(
user_name VARCHAR2(20),
user_privilege NUMBER
);
--
INSERT INTO vpdsample_users VALUES('Jack',1);
INSERT INTO vpdsample_users VALUES('Rose',2);
COMMIT;

（这个表存储用户的权限信息，其中的权限即后表vpdsample_privileges中的权限ID字段。）

CREATE TABLE vpdsample_privileges(
privilege_id NUMBER,
object_id NUMBER
);
--
INSERT INTO vpdsample_privileges VALUES(1,10002);
INSERT INTO vpdsample_privileges VALUES(1,10005);
INSERT INTO vpdsample_privileges VALUES(2,10003);
INSERT INTO vpdsample_privileges VALUES(2,10006);
COMMIT;

（这个表存储每个权限ID对应的权限信息，即对哪些对象（服装或图书）有权限。）

第二步，我们要创建一个context（实际上是【context名称空间】）。可以简单地把context理解为一个定义在内存中的容器，在此容器中我们可以定义若干个键值对，这些键值对可以在一定的范围内被共享（比如同一个session中，或者同一个Oracle实例中）

首先，使用system用户登录，赋予创建者相应的权限：

grant create any context to user1;

然后通过：

CREATE OR REPLACE CONTEXT VPD USING pkg_vpdsample ACCESSED GLOBALLY;

这里我们创建了一个叫’vpd’的context，’using’后面的是一个PLSQL package的名字，出于安全性考虑，Oracle需要你在创建context时指定一个包名，表示后续对些context的修改只能通过此包中的存储过程进行修改，不能通过dbms_session.set_context()直接进行修改。创建context时，package不存在并不会导致编译错误。

最后’accessed globally’是一个可选项，如果未添加此项，表示此context使用范围是某一session；如果指定了此项，则表示该context可以在整个数据库实例范围内共享。

欲删除context同样需要赋予相应的权限：

grant drop any context to user1;

drop context VPD;

第三步，建立一个package（即上面的pkg_vpdsample），包中的各个函数及存储过程的作用会随后逐一给出：

CREATE OR REPLACE PACKAGE pkg_vpdsample
IS
PROCEDURE enable_vpd;
PROCEDURE disable_vpd;
PROCEDURE set_context(p_user_name IN VARCHAR2);
FUNCTION gen_vpd_predicate(p_column_name IN VARCHAR2) RETURN VARCHAR2;
FUNCTION apply_vpd_clothing(p1 in varchar2,p2 in varchar2) RETURN VARCHAR2;
FUNCTION apply_vpd_books(p1 in varchar2,p2 in varchar2) RETURN VARCHAR2;
END;

CREATE OR REPLACE PACKAGE BODY pkg_vpdsample IS
PROCEDURE enable_vpd IS
BEGIN
    DBMS_SESSION.set_context(namespace => 'VPD',
                             attribute => 'ENABLE',
                             value     => '1');
END;

/*======================*/
PROCEDURE disable_vpd IS
BEGIN
    DBMS_SESSION.set_context(namespace => 'VPD',
                             attribute => 'ENABLE',
                             value     => '0');
END;

/*======================*/
PROCEDURE set_context(p_user_name IN VARCHAR2) IS
    l_privilege VARCHAR2(10);
BEGIN
    SELECT user_privilege
      INTO l_privilege
      FROM vpdsample_users
     WHERE user_name = p_user_name;
    DBMS_SESSION.set_identifier(client_id => l_privilege);
END;

/*======================*/
FUNCTION gen_vpd_predicate(p_column_name IN VARCHAR2) RETURN VARCHAR2 IS
    l_vpd_flag VARCHAR2(1);
    l_privilege VARCHAR2(10);
BEGIN
    l_vpd_flag := NVL(SYS_CONTEXT('VPD', 'ENABLE'), '0');
    IF l_vpd_flag = 0 THEN
      RETURN NULL;
    ELSE
      l_privilege := SYS_CONTEXT('USERENV', 'CLIENT_IDENTIFIER');
      IF l_privilege IS NULL THEN
        RETURN '1=2';
      ELSE
        RETURN p_column_name || ' IN (SELECT object_id FROM vpdsample_privileges WHERE privilege_id=' || l_privilege || ')';
      END IF;
    END IF;
END;

/*======================*/
FUNCTION apply_vpd_clothing(p1 in varchar2, p2 in varchar2) RETURN VARCHAR2 IS
BEGIN
    RETURN gen_vpd_predicate('clothing_id');
END;

/*======================*/
FUNCTION apply_vpd_books(p1 in varchar2, p2 in varchar2) RETURN VARCHAR2 IS
BEGIN
    RETURN gen_vpd_predicate('book_id');
END;
END;

enable_vpd,disable_vpd：这两个存储过程用于设置context vpd下的一个自定义属性’enable’，1表是启用vpd，0表禁用vpd，由于我们在创建此context时指定了accessed globally，所以这些属性是可以被跨session访问的。这两个存储过程调用了dbms_session，因此需要被赋予相应的权限：grant execute on dbms_session to user1;

set_context：上面我们提到了context，并且在enable_vpd与disable_vpd中使用了dbms_session.set_context来设置自定义的属性，其实除了这样自定义的context外，Oracle还提供了预定义的context ’userenv’，该名称空间下有若干预定义的属性，比如’client_identifier’，设置此属性我们不使用set_context，而是使用dbms_session.set_identifier()。

本例中此存储过程根据传入的用户名，查找到该用户的权限ID，并将此ID作为client_identifier保存到context ’userenv’中，以便后续使用。

在实际应用中，此存储过程应该是由外部的应用程序调用的，应用程序可以在登录验证完成后，调用此存储过程写入context。

gen_vpd_predicate：根据传入的字段名称生成一个语法正确的where子句。这里首先判断了是否启用了vpd，未设置vpd.enable属性的也认为的已经启用了。随后判断是否已设置userenv.client_identifier属性，如果未设置，则返回一个始终为false的where子句以防止用户查看数据。最后生成的语句中，根据取到的client_identifier（即用户的权限ID）查找权限表vpdsample_privileges得到该用户有权限的所有对象ID。

apply_vpd_clothing, apply_vpd_books：由名字可见，这两个函数将被用于两个不同的表，因为服装表与图书表所用于权限验证的字段有着不同的名字。另外，大家可以看到这两个将被用于vpd的函数都有两个看似没用的参数p1与p2，这是vpd接口的要求，第一个用于接收schema名，第二个用于接收table/view/synonym名称，我们定义函数必须符合接口的要求。当然除了p1,p2外，你可以有自己额外的参数。

一切准备完毕，开始调用Oracle提供的dbms_rls包应用vpd策略，在调用之前，需要赋予用户相应权限：

grant execute on dbms_rls to user1;

然后：

begin
dbms_rls.add_policy(object_name => 'VPDSAMPLE_CLOTHING',policy_name => 'POL_CLOTHING',policy_function => 'PKG_VPDSAMPLE.APPLY_VPD_CLOTHING');
dbms_rls.add_policy(object_name => 'VPDSAMPLE_BOOKS',policy_name => 'pol_books',policy_function => 'pkg_vpdsample.apply_vpd_books');
end;

其中policy_name可以自定义。

随后我们启用vpd：

begin
pkg_vpdsample.enable_vpd;
end;

（需要说明的是，DBMS_RLS包本身有ENABLE_POLICY()方法用于启用或禁用一个vpd策略，但它只能一次启用/禁用一张表上的一个vpd策略，为了一次性启用/禁用所有表上的vpd策略，可以采取类似上面的做法。）

并设置context：

begin
pkg_vpdsample.set_context('Jack');
end;

随后我们查询vpdsample_clothing表，只返回了ID为10002的服装信息；查询vpdsample_books也类似，只返回了ID为10005的图书信息。

可以更换用户：

begin
pkg_vpdsample.set_context('Rose');
end;

删除vpd策略则使用：

begin
dbms_rls.drop_policy(object_name => 'VPDSAMPLE_CLOTHING',policy_name => 'POL_CLOTHING');
dbms_rls.drop_policy(object_name => 'VPDSAMPLE_BOOKS',policy_name => 'pol_books');
end;

本文链接

ORACLE HANDBOOK系列之五：事务（Transaction）

2011-06-08T09:15:00Z

1概述

（在一个会话中）事务何时开始：当数据库遇到第一个DML（UPDATE/INSERT/DELETE/MERGE）语句。

（在一个会话中）事务何时结束：结束于第一个COMMIT/ROLLBACK/DDL/GRANT/REVOKE。对于DLL/GRANT/REVOKE，这些命令的内部嵌套了一个COMMIT语句。

上面的两句话是基本教义，就好比8荣8耻之于和谐社会一样重要。

2事务级与语句级

CREATE TABLE t_trans_sample(fnum NUMBER(3));

insert into t_trans_sample values(1); --sql-1
insert into t_trans_sample values(2); --sql-2

根据教义，sql-1，sql-2属于同一事务，此时如果我们执行commit/rollback，两条语句将同时被提交/回滚，即‘事务级’提交/回滚。

如果是这样呢：

insert into t_trans_sample values(1); --sql-1
insert into t_trans_sample values(‘a’); --sql-2

sql-2出错，此时只有出错的语句被回滚（当然受该语句影响的可能是多行数据），sql-1仍然处于‘未提交’状态，即 ‘语句级’回滚。

总结一下：用户显式执行的提交/回滚，通常总是‘事务级’的；当语句出错时由Oracle自动执行的回滚，通常总是‘语句级’的。

3隐式保存点

insert into t_trans_sample values(1);              --sql-1
begin
insert into t_trans_sample values(2);           --sql-2
insert into t_trans_sample values(‘a’);       --sql-3
end;

此时的结果是sql-2也被自动回滚了，只剩下sql-1的结果处于未提交状态。为什么，不是说应该是语句级的么？这是因为，执行PL/SQL匿名块、或者调用存储过程，会在紧挨着调用之前插入一个隐式的savepoint，当块内部出错并自动回滚时，并非是语句级的，而是回滚到此savepoint为止。

但是，如果语句块中有exception处理模块：

insert into t_trans_sample values(1);              --sql-1
begin
insert into t_trans_sample values(2);           --sql-2
insert into t_trans_sample values(‘a’);       --sql-3
exception
   when others then
    null;
end;

此时只有sql-3被回滚，sql-1跟sql-2仍处于未提交状态。

还有一点需要注意，savepoint只针对回滚的情况，对于提交操作无影响，下面示例中的commit会将三条结果都提交：

insert into t_trans_sample values(1);              --sql-1
begin
insert into t_trans_sample values(2);           --sql-2
insert into t_trans_sample values(3);           --sql-3
commit;
end;

4触发器与事务

触发器代码中不允许发出任何事务控制语句，触发器与触发该触发器的SQL语句同属于一个事务，它只能随着外部事务的提交/回滚而提交/回滚。如果触发器内的DML（如果有的话）出错，则此DML被回滚，同时引发此触发器的DML也将被回滚。

（但在oracle8i 以及更高的版本中，你可以创建作为自治事务而执行的触发器，在这种情况下，触发器可以做提交或回滚操作，而与触发该触发器的外部SQL所在的事务无关，自治事务见后文）

5 Db link与事务

Oracle可以透明地处理分布式事务，意思就是，即便一个事务中涉及的表可能位于不同的oracle server上（通过Db link进行访问），对事务本身没有任何影响。这里就不作示例测试了。

6自治事务

普通的事务是无法进行嵌套的，例如你有一个大事务涉及10条DML，你想先commit中间的3条是无法实现的。自治事务的出现很好地解决了这个问题，它可以使嵌套中的事务保持各自的独立，对比下面两个例子：

（1）

insert into t_trans_sample values(1);
begin
insert into t_trans_sample values(2);
commit;
end;
/

（2）

insert into t_trans_sample values(1);
declare
     pragma autonomous_transaction;
begin
     insert into t_trans_sample values(2);
     commit;
end;
/

（1）中两条语句都被提交，这在前面的文章里已经提过了，（2）中只有第二个insert语句被提交，第一个仍然处于未提交的状态，可以看到自治事务的效果。在实际应用中，自治事务常常用于记录错误日志，通常来说，记录错误日志的事务应该独立出来，不应该与主事务杂揉在一起，这种情况下就应该使用自治事务了。

本文链接

ORACLE HANDBOOK系列之四：ODP.NET与复杂的PL/SQL数据类型(Using ODP.NET To Deal With Complex PLSQL Data Types)

2011-04-21T05:45:00Z

在开始介绍之前，先给出文章里用到的所有PL/SQL代码：

（类型定义）

CREATE OR REPLACE TYPE T_Nested_Tab_Str IS TABLE OF VARCHAR2(25);
--
CREATE OR REPLACE TYPE T_Object IS OBJECT
(
employee_id number(6),
last_name varchar2(25)
);
--
CREATE OR REPLACE TYPE T_VARRAY_STR IS VARRAY(10) OF VARCHAR2(25);
--
CREATE OR REPLACE TYPE T_Nested_Tab_Obj IS TABLE OF T_Object;

（包的声明）

CREATE OR REPLACE PACKAGE pkg_odp_dotnet IS
TYPE T_Ref_Cursor IS REF CURSOR;
TYPE T_Asso_Array_Num IS TABLE OF employees_bk.employee_id%TYPE INDEX BY PLS_INTEGER;
TYPE T_Asso_Array_Str IS TABLE OF employees_bk.last_name%TYPE INDEX BY PLS_INTEGER;
--
PROCEDURE proc_ref_cursor(p_ref_cursor OUT T_Ref_Cursor);
PROCEDURE proc_sys_refcursor(p_sys_refcursor OUT SYS_REFCURSOR);
--
PROCEDURE proc_asso_array_num_in(p_asso_array_num IN T_Asso_Array_Num);
PROCEDURE proc_asso_array_num_out(p_asso_array_num OUT T_Asso_Array_Num);
PROCEDURE proc_asso_array_str_out(p_asso_array_str OUT T_Asso_Array_Str);
--
PROCEDURE proc_nested_tab_str_in(p_nested_tab_str IN T_Nested_Tab_Str);
PROCEDURE proc_nested_tab_str_out(p_nested_tab_str OUT T_Nested_Tab_Str);
--
PROCEDURE proc_obj_in(p_obj IN T_Object);
--
PROCEDURE proc_nested_tab_obj_in(p_nested_tab_obj IN T_Nested_Tab_Obj);
--
PROCEDURE proc_varray_str_in(p_varray_str IN T_Varray_Str);
END;

（包体）

CREATE OR REPLACE PACKAGE BODY pkg_odp_dotnet IS
/*This proc is invoked by .NET to test the ref cursor
    Retrieve the employees whose id less than 105*/
PROCEDURE proc_ref_cursor(p_ref_cursor OUT T_Ref_Cursor)
IS
BEGIN
    OPEN p_ref_cursor FOR
    SELECT employee_id,first_name,last_name FROM employees_bk WHERE employee_id<105;
END;

---------------------------------------------------------------------------------------------------------------------------------
/*This proc is invoked by .NET to test the pre-defined sys_refcursor
    Retrieve the employees whose id less than 105*/
PROCEDURE proc_sys_refcursor(p_sys_refcursor OUT SYS_REFCURSOR)
IS
BEGIN
    OPEN p_sys_refcursor FOR
    SELECT employee_id,first_name,last_name FROM employees_bk WHERE employee_id<105;
END;

---------------------------------------------------------------------------------------------------------------------------------
/*This proc is invoked by .NET to test the input parameter with the type of associative array,
    and the type of the collection element is number
    Loop through each employee id in the given associative array, then update its salary*/
PROCEDURE proc_asso_array_num_in(p_asso_array_num    IN T_Asso_Array_Num)
IS
    idx PLS_INTEGER;
BEGIN
    idx:=p_asso_array_num.FIRST;
    WHILE(idx IS NOT NULL) LOOP
      UPDATE employees_bk SET salary=salary+1 WHERE employee_id=p_asso_array_num(idx);
      idx:=p_asso_array_num.NEXT(idx);
    END LOOP;
    COMMIT;
END;

---------------------------------------------------------------------------------------------------------------------------------
/*This proc is invoked by .NET to test the output parameter with the type of associative array,
    and the type of the collection element is varchar2
    Retrieve the employees whose id less than 105*/
PROCEDURE proc_asso_array_str_out(p_asso_array_str OUT T_Asso_Array_Str)
IS
BEGIN
    SELECT last_name BULK COLLECT INTO p_asso_array_str FROM employees_bk WHERE employee_id<105;
END;

---------------------------------------------------------------------------------------------------------------------------------
/*This proc is invoked by .NET to test the output parameter with the type of associative array,
    and the type of the collection element is number
    Retrieve the employees whose id less than 105*/
PROCEDURE proc_asso_array_num_out(p_asso_array_num OUT T_Asso_Array_Num)
IS
BEGIN
    SELECT employee_id BULK COLLECT INTO p_asso_array_num FROM employees_bk WHERE employee_id<105;
END;

---------------------------------------------------------------------------------------------------------------------------------
/*This proc is invoked by .NET to test the input parameter with the type of nested table,
    and the type of the collection element is number
    Loop through each last name in the given nested table, then update its salary*/
PROCEDURE proc_nested_tab_str_in(p_nested_tab_str IN T_Nested_Tab_Str)
IS
BEGIN
    FORALL i IN p_nested_tab_str.FIRST..p_nested_tab_str.LAST
     UPDATE employees_bk SET salary=salary+1 WHERE last_name=p_nested_tab_str(i);
    COMMIT;
END;

---------------------------------------------------------------------------------------------------------------------------------
/*This proc is invoked by .NET to test the output parameter with the type of nested table,
    and the type of the collection element is varchar2
    Retrieve the employees whose id less than 105*/
PROCEDURE proc_nested_tab_str_out(p_nested_tab_str OUT T_Nested_Tab_Str)
IS
BEGIN
    SELECT last_name BULK COLLECT INTO p_nested_tab_str FROM employees_bk WHERE employee_id<105;
END;

---------------------------------------------------------------------------------------------------------------------------------
/*This proc is invoked by .NET to test the output parameter with the type of VARRAY,
    and the type of the collection element is varchar2
    Loop through each last name in the given varray, then update its salary*/
PROCEDURE proc_varray_str_in(p_varray_str IN T_Varray_Str)
IS
BEGIN
    FORALL i IN p_varray_str.FIRST..p_varray_str.LAST
      UPDATE employees_bk SET salary=salary+1 WHERE last_name=p_varray_str(i);
    COMMIT;
END;

---------------------------------------------------------------------------------------------------------------------------------
/*This proc is invoked by .NET to test the output parameter with the type of object
    Update the last_name according to two fields last_name, employee_id in the given object*/
PROCEDURE proc_obj_in(p_obj IN T_Object)
IS
BEGIN
    UPDATE employees_bk SET last_name=p_obj.last_name WHERE employee_id=p_obj.employee_id;
    COMMIT;
END;

---------------------------------------------------------------------------------------------------------------------------------
/*This proc is invoked by .NET to test the output parameter with the type of nested table,
    and the type of the collection element is object
    Loop through each object in the given nested table, then update the last name of employee*/
PROCEDURE proc_nested_tab_obj_in(p_nested_tab_obj IN T_Nested_Tab_Obj)
IS
BEGIN
    FORALL idx IN p_nested_tab_obj.FIRST..p_nested_tab_obj.LAST
      UPDATE employees_bk SET last_name=p_nested_tab_obj(idx).last_name WHERE employee_id=p_nested_tab_obj(idx).employee_id;
    COMMIT;
END;
END;

1.引用游标（REF Cursor）

引用游标作为输出参数的情况十分常见。相较于MS SQL Server，Oracle存储过程无法直接返回结果集，而需要借助REF Cursor。REF Cursor实际上是指向服务器内存的指针，也就是说客户端调用获取的是一个指针，它指向服务器内存中的结果集数据。

虽然可能令熟悉MS SQL Server平台的开发者困惑，但是使用REF Cursor带来两个明显的好处：1）它可以延迟数据的交付，客户端获取的只是指针，数据只有在被请求时才传递；2）使用REF Cursor在存储过程之间传递结果集，可以最小化对性能影响，毕竟传递的只是指针而不是真实数据。

（使用DataReader）

cmd.CommandText = "pkg_odp_dotnet.proc_ref_cursor";
cmd.CommandType = CommandType.StoredProcedure;
//
OracleParameter op = new OracleParameter();
op.ParameterName = "p_ref_cursor";
op.Direction = ParameterDirection.Output;
op.OracleDbType = OracleDbType.RefCursor;
cmd.Parameters.Add(op);
OracleDataReader odr = cmd.ExecuteReader();
//
if (odr.HasRows)
{
    while (odr.Read())
    {
        string s = odr.GetDecimal(odr.GetOrdinal("employee_id")) + " "
            + odr.GetString(odr.GetOrdinal("first_name")) + " "
            + odr.GetString(odr.GetOrdinal("last_name"));
        Console.WriteLine(s);
    }
}

（使用DataAdapter）

cmd.CommandText = "pkg_odp_dotnet.proc_ref_cursor";
cmd.CommandType = CommandType.StoredProcedure;
//
OracleParameter op = new OracleParameter();
op.ParameterName = "p_ref_cursor";
op.Direction = ParameterDirection.Output;
op.OracleDbType = OracleDbType.RefCursor;
cmd.Parameters.Add(op);
OracleDataAdapter oda = new OracleDataAdapter(cmd);
DataSet ds = new DataSet();
oda.Fill(ds);
//
for (int i = 0; i < ds.Tables[0].Rows.Count; i++)
{
    string s = ds.Tables[0].Rows[i]["employee_id"] + " "
            + ds.Tables[0].Rows[i]["first_name"] + " "
            + ds.Tables[0].Rows[i]["last_name"];
    Console.WriteLine(s);
}

注意上面的Tables[0]，如果有多个输出参数是REF Cursor，则可以使用Tables[0]、Tables[1]，以此类推。DataReader似乎无法在有多个输出的REF Cursor有情况下使用。

方便起见，可以使用Oracle预定义的SYS_REFCURSOR，这样可以省去TYPE定义。在用法上与自定义的REF Cursor相同，就不再举具体的实例了。

2.关联数组（Associative array）

关于PL/SQL中的集合类型，已经在上一篇文章《ORACLE HANDBOOK系统之三:PL/SQL中的集合类型(COLLECTIONS IN PL/SQL)》中介绍了（http://www.cnblogs.com/KissKnife/archive/2011/04/07/2008158.html），这里介绍C#与Oracle交互时如何使用关联数组。

（作为输入参数）

cmd.CommandText = "pkg_odp_dotnet.proc_asso_array_num_in";
cmd.CommandType = CommandType.StoredProcedure;
//
OracleParameter op = new OracleParameter();
op.ParameterName = "p_asso_array_num";
op.Direction = ParameterDirection.Input;
op.OracleDbType = OracleDbType.Decimal;
//
op.CollectionType = OracleCollectionType.PLSQLAssociativeArray;
op.Value = new decimal[] { 100, 101, 102 };
//
cmd.Parameters.Add(op);
cmd.ExecuteNonQuery();

相应的，如果定义的Associative array的元素是Varchar2，则OracleParameter.OracleDbType就是OracleDbType.Varchar2，为OracleParameter.value赋值要使用string[]。

（作为输出参数）

using Oracle.DataAccess.Types;
…
cmd.CommandText = "pkg_odp_dotnet.proc_asso_array_str_out";
cmd.CommandType = CommandType.StoredProcedure;
//
OracleParameter op = new OracleParameter();
op.ParameterName = "p_asso_array_str";
op.Direction = ParameterDirection.Output;
op.OracleDbType = OracleDbType.Varchar2;
//
op.CollectionType = OracleCollectionType.PLSQLAssociativeArray;
//
op.Size = 12;
int[] iArray = new int[op.Size];
for (int i = 0; i < iArray.Length; i++)
{
iArray[i] = 25;
}
op.ArrayBindSize = iArray;
//
cmd.Parameters.Add(op);
cmd.ExecuteNonQuery();
//
OracleString[] osArray = (OracleString[])op.Value;
for (int i = 0; i <= osArray.GetUpperBound(0); i++)
{
Console.WriteLine(osArray[i].Value + ",");
}

OracleParameter.Size，如果给定的Size比实际查询所得的行数小，则会报ORA-06513错误，所以如果无法确定实际返回的集合长度，需要往大了取。

OracleParameter.ArrayBindSize，这里集合元素是变长的VARCHAR2，因此需要为每个元素指定其长度，由于表中last_name的长度是25，所以这里定义成了25，比25小不会报错，但是可能导致字符串被截断。如果要返回的集合元素是NUMBER，则可以不指定ArrayBindSize，

OracleString，不要天真地以为可以使用string[]数组来接收返回的集合，NO！需要OracleString[]，使用string[]将导致转化出错。如果要返回的集合元素是NUMBER，通常用OracleDecimal[]而不能直接用decimal[]。

通常来说，以集合类型作为输出参数类型的情况相对较少，对于结果集，使用REF Cursor是更好的选择。

3.嵌套表（Nested table）

对于Nested table，有两种方案可以选择，1）直接映射成C#中的数组，2）映射成C#的自定义类型。

第一种方案，需要首先声明一个Factory类并实现IOracleArrayTypeFactory接口，并使用OracleCustomTypeMappingAttribute(schema.type_name)指定需要映射的Nested table的名称，schema.type_name需要大写。

可以看到我们使用了OracleDbType.Array，并且指定了参数的UdtTypeName。赋值时直接使用了string[]。

[OracleCustomTypeMappingAttribute("HR.T_NESTED_TAB_STR")]
public class Nested_Tab_Mapping_To_Array_Factory : IOracleArrayTypeFactory
{
    public Array CreateArray(int i)
    {
        return new string[i];
    }
    //
    public Array CreateStatusArray(int i)
    {
        return new OracleUdtStatus[i];
    }
}

（作为输入参数）

cmd.CommandText = "pkg_odp_dotnet.proc_nested_tab_str_in";
cmd.CommandType = CommandType.StoredProcedure;
//
OracleParameter op = new OracleParameter();
op.ParameterName = "p_nested_tab_str";
op.Direction = ParameterDirection.Input;
op.OracleDbType = OracleDbType.Array;
op.UdtTypeName = "HR.T_NESTED_TAB_STR";
op.Value = new string[] { "King", "Olsen" };
//
cmd.Parameters.Add(op);
cmd.ExecuteNonQuery();

（作为输出参数，同样需要上面的Factory类）

cmd.CommandText = "pkg_odp_dotnet.proc_nested_tab_str_out";
cmd.CommandType = CommandType.StoredProcedure;
//
OracleParameter op = new OracleParameter();
op.ParameterName = "p_nested_tab_str";
op.Direction = ParameterDirection.Output;
op.OracleDbType = OracleDbType.Array;
op.UdtTypeName = "HR.T_NESTED_TAB_STR";
//
cmd.Parameters.Add(op);
cmd.ExecuteNonQuery();
//
if (op.Value != DBNull.Value)
{
    string[] result = (string[])op.Value;
    foreach (string s in result)
    {
        Console.WriteLine(s);
    }
}

对比而言，第一种方案中将Nested table映射成C#数组的做法更简洁。下面我们介绍第二种方案，稍微繁杂一点，除了需要Factory类（需要同时实现IOracleArrayTypeFactory与IOracleCustomTypeFactory两个接口）外，它还需要一个自定义类型：

[OracleCustomTypeMappingAttribute("HR.T_NESTED_TAB_STR")]
public class Nested_Tab_Mapping_To_Object_Factory : IOracleCustomTypeFactory, IOracleArrayTypeFactory
{
    public IOracleCustomType CreateObject()
    {
        return new Nested_Tab_Mapping_To_Object();
    }
    //
    public Array CreateArray(int i)
    {
        return new String[i];
    }
    //
    public Array CreateStatusArray(int i)
    {
        return new OracleUdtStatus[i];
    }
}

public class Nested_Tab_Mapping_To_Object : IOracleCustomType, INullable
{
    [OracleArrayMapping()]
    public string[] container;
    //
    private OracleUdtStatus[] statusArray;
    public OracleUdtStatus[] StatusArray
    {
        get
        {
            return statusArray;
        }
        set
        {
            statusArray = value;
        }
    }
    //
    private bool isNull;
    public bool IsNull
    {
        get
        {
            return isNull;
        }
    }
    //
    public static Nested_Tab_Mapping_To_Object Null
    {
        get
        {
            Nested_Tab_Mapping_To_Object nt = new Nested_Tab_Mapping_To_Object();
            nt.isNull = true;
            return nt;
        }
    }
    //
    public void ToCustomObject(OracleConnection conn, IntPtr pUdt)
    {
        object outStatusArray;
        container = (string[])OracleUdt.GetValue(conn, pUdt, 0, out outStatusArray);
        statusArray = (OracleUdtStatus[])outStatusArray;
    }
    public void FromCustomObject(OracleConnection conn, IntPtr pUdt)
    {
        OracleUdt.SetValue(conn, pUdt, 0, container, statusArray);
    }
}

（作为输入参数）

cmd.CommandText = "pkg_odp_dotnet.proc_nested_tab_str_in";
cmd.CommandType = CommandType.StoredProcedure;
//
OracleParameter op = new OracleParameter();
op.ParameterName = "p_nested_tab_str";
op.Direction = ParameterDirection.Input;
op.OracleDbType = OracleDbType.Object;
op.UdtTypeName = "HR.T_NESTED_TAB_STR";
Nested_Tab_Mapping_To_Object nt = new Nested_Tab_Mapping_To_Object();
nt.container = new string[] { "King", "Olsen" };
op.Value = nt;
//
cmd.Parameters.Add(op);
cmd.ExecuteNonQuery();

（作为输出参数）

cmd.CommandText = "pkg_odp_dotnet.proc_nested_tab_str_out";
cmd.CommandType = CommandType.StoredProcedure;
//
OracleParameter op = new OracleParameter();
op.ParameterName = "p_nested_tab_str";
op.Direction = ParameterDirection.Output;
op.OracleDbType = OracleDbType.Object;
op.UdtTypeName = "HR.T_NESTED_TAB_STR";
//
cmd.Parameters.Add(op);
cmd.ExecuteNonQuery();
//
if (op.Value != DBNull.Value)
{
    Nested_Tab_Mapping_To_Object o = (Nested_Tab_Mapping_To_Object)op.Value;
    foreach (string s in o.container)
    {
        Console.WriteLine(s);
    }
}

4.动态数组（VARRAY）

与Nested table用法相同。

5.对象（Object）

Oracle中Object类型的定义可以参见文章开头的T_Object。遇到T_Object时，处理起来类似于第4节中将Nested table映射成自定义对象的情况，同样需要一个自定义类型以及一个Factory类。

[OracleCustomTypeMappingAttribute("HR.T_OBJECT")]
public class Ora_Object_Factory : IOracleCustomTypeFactory
{
    public virtual IOracleCustomType CreateObject()
    {
        Ora_Object o = new Ora_Object();
        return o;
    }
}

public class Ora_Object : IOracleCustomType, INullable
{
    private bool isNull;
    private int employeeId;
    private string lastName;
    //
    public bool IsNull
    {
        get
        {
            return this.isNull;
        }
    }
    //
    public static Ora_Object Null
    {
        get
        {
            Ora_Object mo = new Ora_Object();
            mo.isNull = true;
            return mo;
        }
    }
    //
    [OracleObjectMappingAttribute("EMPLOYEE_ID")]
    public int EmployeeId
    {
        get
        {
            return employeeId;
        }
        set
        {
            employeeId = value;
        }
    }
    //
    [OracleObjectMappingAttribute("LAST_NAME")]
    public string LastName
    {
        get
        {
            return lastName;
        }
        set
        {
            lastName = value;
        }
    }
    //
    public void FromCustomObject(Oracle.DataAccess.Client.OracleConnection conn, System.IntPtr pUdt)
    {
        OracleUdt.SetValue(conn, pUdt, "EMPLOYEE_ID", this.EmployeeId);
        OracleUdt.SetValue(conn, pUdt, "LAST_NAME", this.LastName);
    }
    public void ToCustomObject(Oracle.DataAccess.Client.OracleConnection conn, System.IntPtr pUdt)
    {
        this.EmployeeId = ((int)(OracleUdt.GetValue(conn, pUdt, "EMPLOYEE_ID")));
        this.LastName = ((string)(OracleUdt.GetValue(conn, pUdt, "LAST_NAME")));
    }
}

（作为输入参数）

cmd.CommandText = "pkg_odp_dotnet.proc_obj_in";
cmd.CommandType = CommandType.StoredProcedure;
//
OracleParameter op = new OracleParameter();
op.ParameterName = "p_obj";
op.Direction = ParameterDirection.Input;
op.OracleDbType = OracleDbType.Object;
op.UdtTypeName = "HR.T_OBJECT";
//
Ora_Object mo = new Ora_Object();
mo.EmployeeId = 100;
mo.LastName = "abcd";
op.Value = mo;
//
cmd.Parameters.Add(op);
cmd.ExecuteNonQuery();

作为输出参数的情况很简单，这里就不重复了。

6.对象集合（Object collection）

来到终极篇，所谓对象集合，这里指的是本身是个集合类型，并且集合元素是Oracle的Object，例如我们在最开始定义的T_Nested_Tab_Obj。

由于它是Nested table，则我们可以按照第3节中的作法将其转化成C#中的Array，于是，我们需要一个Factory类并实现IOracleArrayTypeFactory接口：

[OracleCustomTypeMappingAttribute("HR.T_NESTED_TAB_OBJ")]
public class Nested_Tab_Obj_Mapping_To_Array_Factory : IOracleArrayTypeFactory
{
    public Array CreateArray(int i)
    {
        return new Ora_Object[i];
    }
    //
    public Array CreateStatusArray(int i)
    {
        return new OracleUdtStatus[i];
    }
}

又由于集合的元素是Oracle的Object类型，仿照第5节中的做法，我们分别需要一个自定义类型以及一个Factory类，由于集合元素也是使用的T_Object，所以这两个类与第5节中相同，这里不再重复写了。下面我们看看具体的调用代码：

cmd.CommandText = "pkg_odp_dotnet.proc_nested_tab_obj_in";
cmd.CommandType = CommandType.StoredProcedure;
//
OracleParameter op = new OracleParameter();
op.ParameterName = "p_nested_tab_obj";
op.Direction = ParameterDirection.Input;
op.OracleDbType = OracleDbType.Array;
op.UdtTypeName = "HR.T_NESTED_TAB_OBJ";
//
Ora_Object mo = new Ora_Object();
mo.EmployeeId = 100;
mo.LastName = "00000";
Ora_Object mo2 = new Ora_Object();
mo2.EmployeeId = 102;
mo2.LastName = "00000";
op.Size = 2;
op.Value = new Ora_Object[] { mo, mo2 };
//
cmd.Parameters.Add(op);
cmd.ExecuteNonQuery();

作为输出参数的情况也很容易写，这里就不举例子了，VARRAY的情况与Nested table基本一样，也不举例了。到这里，关于在C#中如何处理几类主要的复杂参数类型，已经基本介绍完了，对于一些更为复杂的，比如Object中包含Object等等情况，不太常见，就不介绍了。

PS，虽然Associative array中的元素也可以是Object，但在与C#类型做映射时似乎不能成功，可能根Associative array是PL/SQL类型（即不能通过CREATE TYPE创建独立的类型）有关，还没有找到相关的文档。

本文链接

ORACLE HANDBOOK系列之三：PL/SQL中的集合类型(Collections in PL/SQL)

2011-04-07T09:26:00Z

1)集合的分类

Oracle支持3种类型的集合：

关联数组（Associative array，即Index-by table）

嵌套表（Nested table）

变长数组（VARRAY）

它们的区别之一是， Nested table与VARRY既可以被用于PL/SQL，也可以被直接用于数据库中，但是Associative array不行，也就是说，Associative array是不能通过CREATE TYPE语句进行单独创建，只能在PL/SQL块（或Package）中进行定义并使用（即适用范围是PL/SQL Block级别），而Nested table与VARRAY则可以使用CREATE TYPE进行创建（即适用范围是Schema级别），它们还可以直接作为数据库表中列的类型。

BTW，为了避免误解，以下显式提到“索引”的地方，并非指的是数据库表的索引，而是特指访问集合元素时使用的“下标”，即Collection_Name(index)中的index。

2)集合类型的声明与初始化

2.1)Associative array

首先看一下Associative array的声明及初始化，示例中的第一部分显示，Associative array不能使用CREATE TYPE来创建。第二部分使用一个匿名PL/SQL块来演示Associative array使用，可以看到用法还是相对简单的。

Associative array的索引可以是稀疏的（即可以不连续）。

SQL> CREATE OR REPLACE TYPE ib_planguage IS TABLE OF VARCHAR2(10) INDEX BY PLS_INTEGER;
2 /
Warning: Type created with compilation errors.
SQL> SHOW ERROR;
Errors for TYPE IB_PLANGUAGE:
LINE/COL ERROR
-------- -----------------------------------------------------------------
0/0      PL/SQL: Compilation unit analysis terminated
1/22     PLS-00355: use of pl/sql table not allowed in this context

DECLARE
TYPE ib_planguage IS TABLE OF VARCHAR2(10) INDEX BY PLS_INTEGER;
lang ib_planguage;
idx PLS_INTEGER;
BEGIN
lang(1):='java';
lang(9):='c#';
lang(3):='c++';
idx:=lang.FIRST;
WHILE(idx IS NOT NULL) LOOP
    DBMS_OUTPUT.PUT_LINE(lang(idx));
    idx:=lang.NEXT(idx);
END LOOP;
END;
SQL> /
java
c++
c#

2.2)Nested table

接着来看Nested table的声明及初始化，Nested table既可以通过CREATE TYPE声明成全局类型，也可以在PL/SQL块中声明块级别的类型。

与Associative array不同，Nested table变量需要显式初始化，其语法类似于C#，只是不用new关键字。额外地，Nested table初始化之后还需要调用EXTEND过程，扩展此集合的“容量”。

示例的第二部分提供了一种相对简单的初始化方法，即可以在构造器中直接传入集合成员。这种简便的初始化方法不适用于Associative array。

SQL> CREATE OR REPLACE TYPE nt_planguage IS TABLE OF VARCHAR2(10);
2 /
Type created.

DECLARE
lang nt_planguage;
BEGIN
lang:=nt_planguage();
lang.EXTEND(3);
lang(1):='java';
lang(2):='c#';
lang(3):='c++';
FOR i IN 1..lang.COUNT LOOP
DBMS_OUTPUT.PUT_LINE(lang(i));
END LOOP;
END;
SQL> /
java
c#
c++

或者可以简单地写成：

DECLARE
lang nt_planguage;
BEGIN
lang:=nt_planguage('java','c#','c++');
FOR i IN 1..lang.COUNT LOOP
DBMS_OUTPUT.PUT_LINE(lang(i));
END LOOP;
END;

2.3)VARRAY

最后我们来看VARRAY的声明及初始化，它与Nested table比较类似，但仍然存在一些区别，包括(1)VARRAY可以在声明时限制集合的长度，EXTEND的长度不能大于集合声明时的长度（下例中长度是8），但是在给集合成员赋值时，以EXTEND为准，例如下例中可以使用的只有3个集合成员。；(2)其索引总是连续的，而Nested table的索引在初始化赋值时是连续的，不过随着集合元素被删除，可能变得不连续。

SQL> CREATE OR REPLACE TYPE va_planguage IS VARRAY(8) OF VARCHAR2(10);
2 /
Type created.

DECLARE
lang va_planguage;
BEGIN
lang:=va_planguage();
lang.EXTEND(3);
lang(1):='java';
lang(2):='c#';
lang(3):='c++';
FOR i IN 1..lang.COUNT LOOP
DBMS_OUTPUT.PUT_LINE(lang(i));
END LOOP;

END；

同样，也可以简单地写成：

DECLARE
lang va_planguage;
BEGIN
lang:=va_planguage('java','c#','c++');
FOR i IN 1..lang.COUNT LOOP
DBMS_OUTPUT.PUT_LINE(lang(i));
END LOOP;
END;

3)如何选择适用的集合类型

通常来说，对集合类型的第一选择应该是Associative array，因为它不需要初始化或者EXTEND操作，并且是迄今为止最高效的集合类型。唯一不足的一点是它只能用于PL/SQL而不能直接用于数据库。

如果你需要允许使用负数索引，应该选择Associative array；

如果你需要使用10g，11g中的那些集合操作，应该选择Nested table；

如果你需要限制集合元素的个数，应该选择VARRAY

4)其它

一个非常令人费解的地方是，位于PL/SQL语句块中的TYPE声明，必须使用关键字IS，而不能使用AS，但是在使用CREATE TYPE声明全局类型时，这两个是通用的。

本来，说到这里就应该介绍完了，但是，Oracle引入了OO，导致我还要稍微说一下Object的声明及初始化，因为在某些情况下，你还会遇到集合成员是对象类型的情况。

SQL> CREATE OR REPLACE TYPE o_planguage IS OBJECT(lang VARCHAR2(10),lang_desc VARCHAR2(100));
2 /
Type created.

DECLARE
lang o_planguage;
BEGIN
lang:=o_planguage('java','java is an OO programming language...');
DBMS_OUTPUT.PUT_LINE(lang.lang_desc);

END;

注意，Object不能在PL/SQL语句块中声明。

注意2，我们不能使用如下代码进行初始化：

lang:=o_planguage();

lang.lang:=’java’;

lang.lang_desc:=’java is an OO programming language…’

这样的语法会导致出现{PLS-00306: 调用 'lang' 时参数个数或类型错误}，即Object类型没有默认的无参构造器。介绍完这个，那么即使集合的成员是Object时，也可以如法炮制去声明、初始化了。

本文链接

ORACLE HANDBOOK系列之二：批量SQL(BULK SQL)

2011-03-26T06:18:00Z

PL/SQL引入过程化语言的相应元素，比如条件分支或者循环，不过，SQL本身仍然作为主体嵌套于其中，由于需要SQL引擎才能执行SQL命令，对于PL/SQL程序，往往存在许多PL/SQL引擎 - SQL引擎之间的交互，过多这样的交互会对性能产生负面影响。

Oracle在PL/SQL中引入了BULK SQL，用于尽量减少PL/SQL – SQL引擎之间的交互，以期提高性能。具体而言，Oracle BULK SQL包括FORALL语句、BULK COLLECT子句。前者将多条语句（通常是DML）一次性发送给SQL引擎；后者将SQL引擎所获得的结果一次性返回给PL/SQL引擎。

（1）FORALL

下面的两个例子对比了FORALL与FOR循环之间的区别：

SQL> create table t_bulk as select * from employees;
SQL> desc t_bulk;
Name           Type         Nullable Default Comments
-------------- ------------ -------- ------- --------
EMPLOYEE_ID    NUMBER(6)    Y
FIRST_NAME     VARCHAR2(20) Y
LAST_NAME      VARCHAR2(25)
EMAIL          VARCHAR2(25)
PHONE_NUMBER   VARCHAR2(20) Y
HIRE_DATE      DATE
JOB_ID         VARCHAR2(10)
SALARY         NUMBER(8,2)  Y
COMMISSION_PCT NUMBER(2,2)  Y
MANAGER_ID     NUMBER(6)    Y
DEPARTMENT_ID  NUMBER(4)    Y

DECLARE
  TYPE NumList IS VARRAY(20) OF NUMBER;
  depts NumList := NumList(10, 30, 70);
BEGIN
  FOR i IN depts.FIRST..depts.LAST LOOP
    DELETE FROM t_bulk
    WHERE department_id = depts(i);
  END LOOP;
END;

DECLARE
  TYPE NumList IS VARRAY(20) OF NUMBER;
  depts NumList := NumList(10, 30, 70);  -- department numbers
BEGIN
  FORALL i IN depts.FIRST..depts.LAST
    DELETE FROM t_bulk
    WHERE department_id = depts(i);
END;

虽然从内部执行机制上来说，两个循环有很大的区别，但从语法上来说，还是非常类似的。不过有一个小细节需要注意，就是FORALL语句并没有对应的END语句。

我们再来看看使用FORALL的情况下对异常的处理：

CREATE TABLE t_bulk2(f1 NUMBER(3));
DECLARE
  TYPE type1 IS TABLE OF NUMBER;
  v type1:=type1(1, 2, 3000, 4, 5, 6, 77777, 8, 9, 10001);
BEGIN
  EXECUTE IMMEDIATE 'TRUNCATE TABLE t_bulk2';
  --
  FORALL idx IN v.FIRST..v.LAST
    INSERT INTO t_bulk2 VALUES(v(idx));
  --
EXCEPTION
  WHEN OTHERS THEN
    DBMS_OUTPUT.PUT_LINE(SQLERRM);
END;
ORA-01438: 值大于为此列指定的允许精度
PL/SQL procedure successfully completed
SQL> SELECT * FROM t_bulk2;
  F1
----
   1
   2

Oracle 9i中引入了SAVE EXCEPTIONS语法及与之对应的“ORA-24381： error(s) in array DML”异常，使用它们，我们可以跳过FORALL中出现异常的语句，并将异常保存在SQL%BULK_EXCEPTIONSP这个集合中：

DECLARE
  TYPE type1 IS TABLE OF NUMBER;
  v type1:=type1(1, 2, 3000, 4, 5, 6, 77777, 8, 9, 10001);
  --
  BULK_ERROR EXCEPTION;
  PRAGMA EXCEPTION_INIT(BULK_ERROR, -24381);
BEGIN
  EXECUTE IMMEDIATE 'TRUNCATE TABLE t_bulk2';
  --
  FORALL idx IN v.FIRST..v.LAST SAVE EXCEPTIONS
    INSERT INTO t_bulk2 VALUES(v(idx));
  --
EXCEPTION
  WHEN BULK_ERROR THEN
    FOR i IN 1..SQL%BULK_EXCEPTIONS.COUNT LOOP
      DBMS_OUTPUT.PUT_LINE(SQLERRM(-SQL%BULK_EXCEPTIONS(i).ERROR_CODE)||', Statement: #'||SQL%BULK_EXCEPTIONS(i).ERROR_INDEX);
    END LOOP;
  WHEN OTHERS THEN
    NULL;
END;
ORA-01438: 值大于为此列指定的允许精度, Statement: #3
ORA-01438: 值大于为此列指定的允许精度, Statement: #7
ORA-01438: 值大于为此列指定的允许精度, Statement: #10
PL/SQL procedure successfully completed
SQL> SELECT * FROM t_bulk2;
  F1
----
   1
   2
   4
   5
   6
   8
   9

（注意使用ERROR_CODE时要加上负号。）

下面介绍如何获取第一条语句所影响的行数，这需要使用SQL%BULK_ROWCOUNT:

create table t_bulk3(fid number);
insert into t_bulk3 values(1);
insert into t_bulk3 values(2);
insert into t_bulk3 values(2);
insert into t_bulk3 values(3);
insert into t_bulk3 values(3);
insert into t_bulk3 values(3);
insert into t_bulk3 values(3);
DECLARE
  TYPE type1 IS TABLE OF NUMBER;
  v type1:=type1(1, 2, 3, 4);
  --
  BULK_ERROR EXCEPTION;
  PRAGMA EXCEPTION_INIT(BULK_ERROR, -24381);
BEGIN
  FORALL idx IN v.FIRST..v.LAST SAVE EXCEPTIONS
    DELETE FROM t_bulk3 WHERE fid=v(idx);
  --
  FOR idx IN v.FIRST..v.LAST LOOP
    DBMS_OUTPUT.PUT_LINE('Statement: #'||idx||', '||SQL%BULK_ROWCOUNT(idx)||' rows were impacted.');
  END LOOP;
  --
EXCEPTION
  WHEN BULK_ERROR THEN
    FOR i IN 1..SQL%BULK_EXCEPTIONS.COUNT LOOP
      DBMS_OUTPUT.PUT_LINE(SQLERRM(-SQL%BULK_EXCEPTIONS(i).ERROR_CODE)||', Statement: #'||SQL%BULK_EXCEPTIONS(i).ERROR_INDEX);
    END LOOP;
  WHEN OTHERS THEN
    NULL;
END;
Statement: #1, 1 rows were impacted.
Statement: #2, 2 rows were impacted.
Statement: #3, 4 rows were impacted.
Statement: #4, 0 rows were impacted.
PL/SQL procedure successfully completed

（2）BULK COLLECT

假设有一条SQL查询，返回的记录中包含5行，那么如果在PL/SQL中执行此查询，会有5次的PL/SQL – SQL交互，如果使用BULK COLLECT，可以降低到1次。

BULK COLLECT子句可以出现在以下语句中：

SELECT INTO

FETCH

RETURNING INTO

create table t_bulk4(fid number, fval varchar2(20));
insert into t_bulk4 values(1,'abc');
insert into t_bulk4 values(2,'def');
insert into t_bulk4 values(3,'xyz');
insert into t_bulk4 values(4,'xxx');
insert into t_bulk4 values(5,'123');
commit;
DECLARE
  TYPE type1 IS TABLE OF t_bulk4%ROWTYPE;
  v type1;
BEGIN
  SELECT * BULK COLLECT INTO v FROM t_bulk4;
  --
  FOR i IN 1..v.COUNT LOOP
    DBMS_OUTPUT.PUT_LINE(v(i).fid||' '||v(i).fval);
  END LOOP;
END;
1 abc
2 def
3 xyz
4 xxx
5 123
PL/SQL procedure successfully completed

另一个INDEX BY集合的示例（实际上使用跟上例一样的FOR循环也可以）：

DECLARE
  TYPE type1 IS TABLE OF t_bulk4%ROWTYPE INDEX BY PLS_INTEGER;
  v type1;
  idx PLS_INTEGER;
BEGIN
  SELECT * BULK COLLECT INTO v FROM t_bulk4;
  --
  idx:=v.FIRST;
  WHILE(idx IS NOT NULL) LOOP
    DBMS_OUTPUT.PUT_LINE(v(idx).fid||' '||v(idx).fval);
    idx := v.NEXT(idx);
  END LOOP;
END;

FETCH cursor BULK COLLECT INTO的使用与上述例子都类似，不多写了。

关于RETURNING INTO + BULK COLLECT，我们来一个综合的例子：

create table t_bulk5(fid number);
DECLARE
  TYPE type1 IS TABLE OF NUMBER;
  v type1:=type1(1, 2, 3, 5);
  --
  TYPE type2 IS TABLE OF t_bulk5.fid%TYPE;
  v2 type2;
BEGIN
  FORALL idx IN v.FIRST..v.LAST
    INSERT INTO t_bulk5 VALUES(v(idx)) RETURNING fid BULK COLLECT INTO v2;
  --
  DBMS_OUTPUT.PUT_LINE(v2.COUNT);
END;
4
PL/SQL procedure successfully completed

顺便比较一下使用FOR循环时是什么结果：

DECLARE
  TYPE type1 IS TABLE OF NUMBER;
  v type1:=type1(1, 2, 3, 5);
  --
  TYPE type2 IS TABLE OF t_bulk5.fid%TYPE;
  v2 type2;
BEGIN
  FOR idx IN v.FIRST..v.LAST LOOP
    INSERT INTO t_bulk5 VALUES(v(idx)) RETURNING fid BULK COLLECT INTO v2;
  END LOOP;
  --
  DBMS_OUTPUT.PUT_LINE(v2.COUNT);
END;
1
PL/SQL procedure successfully completed

这实际上也好理解，因为上面的INSERT语句每次影响的只有一行，所以第二例中，保留的是循环中最后一次执行的INSERT所影响的行数，当然是1；而由于FORALL语句会将所有语句一次性提交到数据库，这也使得我们可以使用RETURNING INTO + BULK COLLECT获取所有插入的数据。

本文链接

Oracle Handbook系列之一：结构化查询(Hierarchical Queries)

2011-02-25T06:07:00Z

一）准备测试数据

闲话少说，直入正题。建立一张简单的职工表 t_hierarchical:

|-Emp 职工编号

|-Mgr 职工的直接上司（Mgr本身也是职工）

|-Emp_name 职工姓名

插入一些测试数据，除了大老板AA，其它的职工都各有自己的Manager。

select emp, mgr, emp_name from t_hierarchical t;

1 AA

2 1 BB

3 2 CC

4 3 DD

5 2 EE

6 3 FF

二）CONNECT BY

select emp, mgr, LEVEL from t_hierarchical t
CONNECT BY PRIOR emp=mgr
order by emp;

1 1

2 1 2

2 1 1

3 2 1

3 2 3

3 2 2

4 3 4

4 3 1

4 3 2

4 3 3

5 2 3

5 2 2

5 2 1

6 3 2

6 3 3

6 3 4

6 3 1

解释一下，CONNECT BY用于指定父-子记录的关系（PRIOR我们在下例中解释，更直观一些）。举emp 2为例，他隶属于emp 1，如果我们以emp 1为根节点，显然LEVEL=2；以emp 2自身为根节点，则LEVEL=1，这就是为什么上述查询结果中出现共色标识部分那两行记录，其它的类推。

三）START WITH

通常我们需要更直观、更具有实用性的结果，这需要用到结构化查询中的START WITH子句，用于指定根节点：

select emp, mgr, LEVEL from t_hierarchical t
START WITH emp=1
CONNECT BY PRIOR emp=mgr;

1 1

2 1 2

3 2 3

4 3 4

6 3 4

5 2 3

这里我们指定了根节点是emp 1，这样的结果直观了许多，例如，以emp 1为根节点，那么emp 3位于第三级（emp 1—emp 2—emp 3），这里补充一下 PRIOR 关键字的说明，个人观点：“PRIOR emp=mgr”表示前一条记录的emp编号 = 当前记录的mgr编号，从查询结果中可以看出这一点。同时，从查询结果中还能发现明显的递归痕迹，参见不同颜色标识的数字。

四）SYS_CONNECT_BY_PATH()

不得不介绍一下非常牛波依的SYS_CONNECT_BY_PATH()函数，我们可以得到层次结构或者说树状结构的路径，参见如下：

select emp, mgr, LEVEL, SYS_CONNECT_BY_PATH(emp,'/') path from t_hierarchical t
START WITH emp=1
CONNECT BY PRIOR emp=mgr;

1 1 /1

2 1 2 /1/2

3 2 3 /1/2/3

4 3 4 /1/2/3/4

6 3 4 /1/2/3/6

5 2 3 /1/2/5

五）CONNECT_BY_ISLEAF

非常好用的CONNECT_BY_ISLEAF虚列。何谓LEAF（叶子），即没有任何节点隶属于该节点：

select emp, mgr, LEVEL, SYS_CONNECT_BY_PATH(emp,'/') path from t_hierarchical t
where CONNECT_BY_ISLEAF=1
START WITH emp=1
CONNECT BY PRIOR emp=mgr;

4 3 4 /1/2/3/4

6 3 4 /1/2/3/6

5 2 3 /1/2/5

六）CONNECT BY与WHERE子句

下面再说说，关于引入结构化查询后，SQL语句的执行顺序问题，根据Oracle文档，先后是：

1）JOIN，无论用的是JOIN ON的写法，还是在WHERE中做的关联

2）CONNECT BY

3）其它的WHERE条件

看一个例子，假设上面的各位职工，需要保存一些注释信息，同时这些信息根据中文、英文分成两个不同版本，我们可以简单设计一下这个注释表：

|-Emp 职工编号

|-Lang 语言（中文或英文）

|-Emp_desc 职工的具体描述

select emp, lang, emp_desc from t_desc;

1 chinese 这是注释

1 english this is comment

2 chinese 这是注释

2 english this is comment

3 chinese 这是注释

3 english this is comment

4 chinese 这是注释

4 english this is comment

5 chinese 这是注释

5 english this is comment

6 chinese 这是注释

6 english this is comment

现在需要在原有的职工结构化查询中包括每个职工的中文注释信息，我们看看下面的查询：

select t.emp, t.mgr, td.emp_desc, LEVEL
from t_hierarchical t, t_desc td
where t.emp=td.emp and td.lang='chinese'
START WITH t.emp=1
CONNECT BY PRIOR t.emp=t.mgr;

1 chinese 这是注释 1

2 1 chinese 这是注释 2

3 2 chinese 这是注释 3

4 3 chinese 这是注释 4

6 3 chinese 这是注释 4

4 3 chinese 这是注释 4

6 3 chinese 这是注释 4

5 2 chinese 这是注释 3

3 2 chinese 这是注释 3

4 3 chinese 这是注释 4

6 3 chinese 这是注释 4

4 3 chinese 这是注释 4

6 3 chinese 这是注释 4

5 2 chinese 这是注释 3

2 1 chinese 这是注释 2

3 2 chinese 这是注释 3

4 3 chinese 这是注释 4

6 3 chinese 这是注释 4

4 3 chinese 这是注释 4

6 3 chinese 这是注释 4

5 2 chinese 这是注释 3

3 2 chinese 这是注释 3

4 3 chinese 这是注释 4

6 3 chinese 这是注释 4

4 3 chinese 这是注释 4

6 3 chinese 这是注释 4

5 2 chinese 这是注释 3

再看这个查询，看起来与前者是一样的：

select t.emp, t.mgr, td.emp_desc, LEVEL
from t_hierarchical t join t_desc td
on (t.emp=td.emp and td.lang='chinese')
START WITH t.emp=1
CONNECT BY PRIOR t.emp=t.mgr;

1 这是注释 1

2 1 这是注释 2

3 2 这是注释 3

4 3 这是注释 4

6 3 这是注释 4

5 2 这是注释 3

第二个是我们期望的结果，第二个则相去甚远。追究原因，是因为前一个例子中第二个条件 td.lang=’chinese’不被认为是JOIN条件，所以在CONNECT BY之后执行；后一个例子中由于显式地把第二个条件写在了JOIN ON子句中，所以它在CONNECT BY之前执行。

由于缺少第二个条件的JOIN（即本节第一例）会导致每个的职工出现两次，换一个数据少一点的例子，看看CONNECT BY遇到这样的重复数据的时候是怎么处理的。

select emp, mgr, lang from t2;

1 chinese

1 english

2 1 chinese

2 1 english

CONNECT BY之后：

select emp, mgr, lang from t2
start with emp=1
connect by prior emp=mgr;

1 chinese

2 1 chinese

2 1 english

1 english

2 1 chinese

2 1 english

lang=’chinese’过滤之后：

1 chinese

2 1 chinese

出现重复行，显然不是我们期望的结果。

七）CONNECT BY LEVEL

下面我再来看看一个特殊的用法 CONNECT BY LEVEL，这是一个理解起来令人头痛，但同时在某些情境下又是非常有用的：

select LEVEL from dual CONNECT BY LEVEL<=6;

如果你以前从未使用过，但是不幸你猜中了结果，我深表佩服，我至今没有想通，事实上，它甚至不太符合结构化查询CONNECT BY的语法，因为根据Oracle文档，CONNECT BY条件中至少有一个表达式要使用PRIOR关键字。以至于有人觉得CONNECT BY LEVEL是一个BUG，怀疑Oracle可能在后续的版本中加以纠正。

无论如何，CONNECT BY LEVEL在Oracle 10g/11g中运行良好，如果你不想费劲想通这其中的原由，可以简单地把想认为是构造了一个循环，因此如果你写成CONNECT BY 1=1，则会输出1到无穷大的数。

本文链接