Oracle PL/SQL程序设计（第6版 上下册）

目录（上）
第1部分　用PL/SQL编程
第1章　PL/SQL介绍\t3
1．1　什么是PL/SQL\t3
1．2　PL/SQL的起源\t4
1．2．1　早期的PL/SQL\t4
1．2．2　提高应用的可移植性\t4
1．2．3　提高执行权限控制和交易
完整性\t5
1．2．4　低调开始，持续改进\t5
1．3　这就是PL/SQL\t6
1．3．1　与SQL的集成\t6
1．3．2　控制和条件逻辑\t7
1．3．3　出错处理\t8
1．4　关于PL/SQL版本\t9
1．4．1　Oracle数据库12c中PL/SQL
的新特性\t10
1．5　可供PL/SQL开发者使用的
资源\t12
1．5．1　O’Reilly的PL/SQL系列图书\t13
1．5．2　网络上的PL/SQL资源\t14
1．6　一些建议\t15
1．6．1　别急，慢慢来\t15
1．6．2　不要畏惧寻求帮助\t16
1．6．3　采用有创造性的甚至激进的
方法\t17
第2章　创建和运行PL/SQL
代码\t18
2．1　在数据库中导航\t18
2．2　创建和编辑源代码\t19
2．3　SQL*Plus\t19
2．3．1　启动SQL*Plus\t21
2．3．2　运行SQL语句\t22
2．3．3　运行PL/SQL程序\t22
2．3．4　运行一个脚本\t24
2．3．5　什么是“当前目录”\t24
2．3．6　其他SQL*Plus任务\t25
2．3．7　SQL*Plus中的异常处理\t29
2．3．8　为什么SQL*Plus让我们
又爱又恨\t30
2．4　执行基本的PL/SQL任务\t30
2．4．1　创建存储程序\t31
2．4．2　执行存储的程序\t33
2．4．3　显示存储程序\t34
2．4．4　存储程序的授权和别名\t35
2．4．5　删除一个存储程序\t36
2．4．6　隐藏存储程序的源代码\t36
2．5　编辑PL/SQL的环境\t37
2．6　从其他语言中调用PL/SQL\t37
2．6．1　C语言，使用Oracle预编辑器
（Pro*C）\t38
2．6．2　Java：使用JDBC\t39
2．6．3　Perl：使用Perl DBI和DBD：：
Oracle\t40
2．6．4　PHP：使用Oracle扩展\t41
2．6．5　PL/SQL Server Pages\t42
2．6．6　其他\t43
第3章　语言基础\t44
3．1　PL/SQL块结构\t44
3．1．1　匿名块\t46
3．1．2　命名块\t47
3．1．3　嵌套块\t47
3．1．4　作用范围\t48
3．1．5　规范SQL语句中对变量和
列的引用\t49
3．1．6　可见性\t51
3．2　PL/SQL字符集\t54
3．3　标识符\t56
3．3．1　保留字\t57
3．3．2　空白和关键字\t58
3．4　直接量\t59
3．4．1　NULL\t60
3．4．2　在一个直接量字符串中嵌入
单引号\t61
3．4．3　数字直接量\t61
3．4．4　布尔直接量\t62
3．5　分号分隔符\t62
3．6　注释\t63
3．6．1　单行注释语法\t63
3．6．2　多行注释语法\t63
3．7　PRAGMA关键字\t64
3．8　标签\t65
第2部分　PL/SQL程序结构
第4章　条件与顺序控制\t69
4．1　IF语句\t69
4．1．1　IF-THEN组合\t69
4．1．2　IF-THEN-ELSE的组合\t71
4．1．3　IF-THEN-ELSIF组合\t73
4．1．4　避免IF语法陷阱\t73
4．1．5　嵌套的IF语句\t75
4．1．6　短路估算\t75
4．2　CASE语句和表达式\t77
4．2．1　简单的CASE语句\t77
4．2．2　搜索CASE语句\t79
4．2．3　嵌套CASE语句\t81
4．2．4　CASE表达式\t81
4．3　GOTO语句\t83
4．4　NULL语句\t84
4．4．1　提高程序的可读性\t84
4．4．2　在标签后使用NULL\t84
第5章　循环迭代处理\t86
5．1　循环的基础知识\t86
5．1．1　不同循环的示例\t86
5．1．2　PL/SQL循环的结构\t88
5．2　简单循环\t89
5．2．1　终止简单循环：EXIT
和EXIT WHEN\t89
5．2．2　模仿REPEAT UNTIL循环\t90
5．2．3　故意的无限循环\t91
5．3　WHILE循环\t92
5．4　数值型FOR循环\t93
5．4．1　数值型FOR循环的规则\t94
5．4．2　数值型FOR循环的示例\t94
5．4．3　处理特殊增量\t95
5．5　游标FOR循环\t96
5．5．1　游标FOR循环的示例\t97
5．6　循环标签\t98
5．7　CONTINUE语句\t99
5．8　迭代处理技巧\t102
5．8．1　为循环索引使用可理解的
名称\t102
5．8．2　以正确的方式说再见\t102
5．8．3　获取FOR循环执行的信息\t103
5．8．4　循环SQL语句\t104
第6章　异常处理\t106
6．1　异常处理概念和术语\t106
6．2　定义异常\t108
6．2．1　声明命名异常\t108
6．2．2　关联异常名称与错误代码\t109
6．2．3　命名的系统异常\t112
6．2．4　异常作用范围\t114
6．3　引发异常\t115
6．3．1　RAISE语句\t115
6．3．2　使用RAISE_APPLICATION_
ERROR\t116
6．4　处理异常\t117
6．4．1　内置错误函数\t118
6．4．2　单一处理句柄中结合多个
异常\t122
6．4．3　未处理异常\t123
6．4．4　未处理异常的传播\t123
6．4．5　继续过去的异常\t125
6．4．6　编写WHEN OTHERS处理
代码\t127
6．5　构建有效的错误管理架构\t129
6．5．1　确定我们的异常管理策略\t129
6．5．2　对不同类型异常进行标准化
处理\t130
6．5．3　程序特定错误代码的组织
使用\t133
6．5．4　使用标准的错误管理程序\t133
6．5．5　使用自己的异常“对象”\t135
6．5．6　创建常见错误处理的标准
模板\t137
6．6　充分利用PL/SQL错误
管理\t138
第3部分　PL/SQL程序数据
第7章　使用程序数据\t141
7．1　程序数据的命名\t141
7．2　PL/SQL数据类型概述\t143
7．2．1　字符数据\t143
7．2．2　数字\t144
7．2．3　日期、时间戳和时间间隔\t145
7．2．4　布尔类型\t145
7．2．5　二进制数据类型\t146
7．2．6　ROWID\t146
7．2．7　REF CURSOR\t146
7．2．8　Internet数据类型\t147
7．2．9 “Any”数据类型\t147
7．2．10　用户自定义数据类型\t147
7．3　程序数据的声明\t147
7．3．1　声明一个变量\t148
7．3．2　声明常量\t148
7．3．3　NOT NULL语句\t149
7．3．4　锚定声明\t149
7．3．5　游标和表的锚\t151
7．3．6　使用锚定声明的益处\t152
7．3．7　NOT NULL数据类型的锚\t153
7．4　程序员定义的子类型\t153
7．5　数据类型转换\t154
7．5．1　隐式类型转换\t155
7．5．2　显式类型转换\t156
第8章　字符串\t162
8．1　字符串类型\t162
8．1．1　VARCHAR2数据类型\t163
8．1．2　CHAR数据类型\t164
8．1．3　String子类型\t164
8．2　使用字符串\t165
8．2．1　指定字符串常量\t165
8．2．2　不可打印字符\t167
8．2．3　拼接字符串\t168
8．2．4　处理大小写\t169
8．2．5　传统的检索、提取和替换\t172
8．2．6　填充\t174
8．2．7　剪裁\t176
8．2．8　正则表达式的检索、提取和
替换\t177
8．2．9　使用空字符串\t187
8．2．10　混用CHAR和
VARCHAR2\t188
8．3　字符串函数快速参考\t190
第9章　数字\t199
9．1　数值型数字类型\t199
9．1．1　NUMBER类型\t200
9．1．2　PLS_INTEGER类型\t204
9．1．3　BINARY_INTEGER类型\t205
9．1．4　SIMPLE_INTEGER类型\t205
9．1．5　BINARY_FLOAT和
BINARY_DOUBLE类型\t207
9．1．6　SIMPLE_FLOAT和
SIMPLE_DOUBLE类型\t212
9．1．7　数字子类型\t212
9．2　数字转换\t213
9．2．1　TO_NUMBER函数\t213
9．2．2　TO_CHAR函数\t216
9．2．3　CAST函数\t221
9．2．4　隐式转换\t222
9．3　数字运算符\t224
9．4　数字函数\t224
9．4．1　四舍五入和截断函数\t224
9．4．2　三角函数\t225
9．4．3　数字函数的快速参考\t225
第10章　日期和时间戳\t230
10．1　Datetime数据类型\t230
10．1．1　声明日期时间变量\t233
10．1．2　选择日期时间数据类型\t233
10．2　获取当前日期和时间\t234
10．3　INTERVAL数据类型\t236
10．3．1　声明INTERVAL变量\t237
10．3．2　什么时候使用INTERVAL\t238
10．4　日期时间转换\t240
10．4．1　从字符串到日期时间\t240
10．4．2　从日期时间到字符串\t242
10．4．3　使用时区\t245
10．4．4　精确匹配需要格式掩码\t247
10．4．5　让精确匹配更轻松\t248
10．4．6　解释滑动窗口中两位数字的
年份\t248
10．4．7　把时区转换成字符串\t249
10．4．8　用填充模式把输出补齐\t250
10．5　日期和时间戳直接量\t251
10．6　时间间隔的转换\t252
10．6．1　从数字到时间间隔的转换\t252
10．6．2　把字符串转换成间隔\t253
10．6．3　时间间隔的格式化显示\t254
10．7　时间间隔直接量\t254
10．8　CAST和EXTRACT\t256
10．8．1　CAST函数\t256
10．8．2　EXTRACT函数\t258
10．9　日期时间的算法\t258
10．9．1　时间间隔和日期时间的
算法\t259
10．9．2　DATE数据类型的日期
算法\t260
10．9．3　计算两个日期时间之间的
时间间隔\t260
10．9．4　DATE和TIMESTAMP混合
计算\t262
10．9．5　时间间隔的加减运算\t263
10．9．6　时间间隔的乘除运算\t264
10．9．7　使用不受限制的时间间隔
类型\t264
10．10　日期/时间函数的快速
参考\t266
第11章　记录类型\t269
11．1　PL/SQL中的记录\t269
11．1．1　使用记录的好处\t270
11．1．2　声明记录\t271
11．1．3　程序员自定义的记录类型\t273
11．1．4　使用记录类型\t275
11．1．5　记录的比较\t281
11．1．6　触发器伪记录\t282
第12章　集合\t284
12．1　集合概述\t285
12．1．1　集合概念和术语\t285
12．1．2　集合类型\t287
12．1．3　集合示例\t288
12．1．4　使用集合的场合\t291
12．1．5　选择一个集合类型\t296
12．2　集合方法（内置）\t297
12．2．1　COUNT方法\t298
12．2．2　DELETE方法\t299
12．2．3　EXISTS方法\t300
12．2．4　EXTEND方法\t300
12．2．5　FIRST和LAST方法\t301
12．2．6　LIMIT方法\t302
12．2．7　PRIOR和NEXT方法\t303
12．2．8　TRIM方法\t304
12．3　使用集合\t305
12．3．1　声明集合类型\t306
12．3．2　集合变量的声明和初始化\t310
12．3．3　用数据填充集合\t313
12．3．4　访问集合内的数据\t318
12．3．5　使用字符串索引的集合\t319
12．3．6　复杂数据类型的集合\t324
12．3．7　多级集合\t327
12．3．8　在SQL中使用集合\t335
12．4　嵌套表的多重集合操作\t342
12．4．1　测试嵌套表是否相等及成员
归属\t343
12．4．2　检查元素是否是嵌套表的
成员\t344
12．4．3　执行高级别集合操作\t345
12．4．4　嵌套表中的去重\t346
12．5　schema级别集合的维护\t347
12．5．1　必需的权限\t347
12．5．2　集合和数据字典\t348
第13章　其他数据类型\t349
13．1　BOOLEAN类型\t349
13．2　RAW数据类型\t350
13．3　UROWID和ROWID数据
类型\t351
13．3．1　获取ROWID\t352
13．3．2　使用ROWID\t352
13．4　LOB数据类型\t353
13．5　使用LOB\t354
13．5．1　理解LOB定位符\t356
13．5．2　LOB的空和NULL\t357
13．5．3　向LOB中写入数据\t359
13．5．4　读取LOB数据\t361
13．5．5　BFILE的不同之处\t363
13．5．6　SecureFiles和BasicFiles\t367
13．5．7　临时LOB\t369
13．5．8　原生的LOB操作\t372
13．5．9　LOB转换函数\t376
13．6　预定义的对象类型\t376
13．6．1　XMLType类型\t376
13．6．2　URI类型\t379
13．6．3　Any类型\t381
第4部分　PL/SQL中的SQL
第14章　DML和事务管理\t387
14．1　PL/SQL中的DML\t388
14．1．1　DML简介\t388
14．1．2　DML操作符的游标属性\t391
14．1．3　从DML语句返回信息\t392
14．1．4　DML和异常处理\t393
14．1．5　DML和记录\t394
14．2　事务管理\t397
14．2．1　COMMIT语句\t397
14．2．2　ROLLBACK语句\t398
14．2．3　SAVEPOINT语句\t399
14．2．4　SET TRANSACTION语句\t399
14．2．5　LOCK TABLE语句\t400
14．3　自治事务\t400
14．3．1　定义自治事务\t401
14．3．2　自治事务的规则和限制\t402
14．3．3　事务的可见性\t403
14．3．4　何时使用自治事务\t403
14．3．5　创建自治日志记录机制\t404
第15章　数据提取\t407
15．1　游标基础\t408
15．1．1　一些数据提取术语\t408
15．1．2　典型的查询操作\t410
15．1．3　游标属性介绍\t411
15．1．4　在游标中引用PL/SQL
变量\t413
15．1．5　显式与隐式游标之间的
选择\t414
15．2　使用隐式游标\t414
15．2．1　隐式游标示例\t415
15．2．2　隐式游标的异常处理\t416
15．2．3　隐式SQL游标的属性\t418
15．3　使用显式游标\t419
15．3．1　声明显式游标\t420
15．3．2　打开显式游标\t423
15．3．3　从显式游标获取\t424
15．3．4　显式游标中的列别名\t425
15．3．5　关闭显式游标\t426
15．3．6　显式游标属性\t427
15．3．7　游标参数\t429
15．4　SELECT…FOR UPDATE\t432
15．4．1　COMMIT释放锁定\t433
15．4．2　WHERE CURRENT
OF子句\t434
15．5　游标变量和REF
CURSOR\t435
15．5．1　为什么使用游标变量\t436
15．5．2　与静态游标的相似之处\t437
15．5．3　声明REF CURSOR类型\t437
15．5．4　声明游标变量\t438
15．5．5　打开游标变量\t439
15．5．6　从游标变量中提取数据\t440
15．5．7　游标变量的使用规则\t442
15．5．8　将游标变量作为参数传递\t445
15．5．9　游标变量的约束限制\t447
15．6　游标表达式\t447
15．6．1　使用游标表达式\t448
15．6．2　游标表达式的约束限制\t450
第16章　动态SQL和动态
PL/SQL\t451
16．1　NDS语句\t452
16．1．1　EXECUTE IMMEDIATE
语句\t452
16．1．2　OPEN FOR语句\t455
16．1．3　4种动态SQL方法\t460
16．2　绑定变量\t462
16．2．1　参数模式\t463
16．2．2　重复的占位符\t465
16．2．3　传递NULL值\t465
16．3　使用对象和集合\t466
16．4　动态PL/SQL\t468
16．4．1　建立动态PL/SQL块\t469
16．4．2　用动态块替换重复代码\t470
16．5　NDS建议\t471
16．5．1　对共享程序使用调用者
权限\t471
16．5．2　预测并处理动态错误\t472
16．5．3　使用绑定而非拼接\t474
16．5．4　减少代码注入的危险\t475
16．6　何时使用DBMS_SQL\t478
16．6．1　获得查询列信息\t478
16．6．2　实现第四种方法的动态
SQL需求\t479
16．6．3　最小化动态游标解析\t485
16．6．4　Oracle数据库11g新动态
SQL特性\t486
16．6．5　DBMS_SQL增强安全\t490
目录（下）
第5部分　构造PL/SQL应用程序
第17章　过程、函数和参数\t497
17．1　代码模块化\t497
17．2　过程\t499
17．2．1　调用一个过程\t501
17．2．2　过程头部\t501
17．2．3　过程体\t501
17．2．4　END标签\t502
17．2．5　RETURN语句\t502
17．3　函数\t502
17．3．1　函数的结构\t503
17．3．2　返回的数据类型\t504
17．3．3　END标签\t506
17．3．4　调用函数\t506
17．3．5　不带参数的函数\t507
17．3．6　函数头\t508
17．3．7　函数体\t508
17．3．8　RETURN语句\t509
17．4　参数\t510
17．4．1　定义参数\t511
17．4．2　实参和形参\t511
17．4．3　参数模式\t512
17．4．4　在PL/SQL中显式地关联
实参和形参\t515
17．4．5　NOCOPY参数模式限定符\t519
17．4．6　缺省值\t519
17．5　局部或者嵌套模块\t520
17．5．1　使用局部模块的益处\t521
17．5．2　局部模块的作用范围\t523
17．5．3　用局部模块使得代码更
整洁\t524
17．6　模块的重载\t524
17．6．1　重载的益处\t525
17．6．2　重载的限制\t528
17．6．3　数字类型的重载\t528
17．7　前置声明\t529
17．8　高级主题\t530
17．8．1　在SQL内部调用我们的
函数\t530
17．8．2　表函数\t536
17．8．3　确定性函数\t545
17．8．4　隐式游标结果（Oracle
数据库12c）\t546
17．9　将模块化进行到底\t547
第18章　程序包\t548
18．1　为什么使用程序包\t548
18．1．1　演示程序包的能力\t549
18．1．2　与程序包相关的一些概念\t552
18．1．3　图示私有性\t553
18．2　构建程序包的规则\t554
18．2．1　程序包说明\t554
18．2．2　包体\t555
18．2．3　包的初始化\t557
18．3　包元素的调用规则\t561
18．4　使用包数据\t562
18．4．1　在一个Oracle会话内全局
可见\t562
18．4．2　全局公有数据\t563
18．4．3　包游标\t563
18．4．4　包的串行化\t568
18．5　何时使用包\t570
18．5．1　封装对数据的访问\t570
18．5．2　避免直接量的硬编码\t573
18．5．3　提高内置特性的可用性\t575
18．5．4　把逻辑上相关的功能组织
在一起\t576
18．5．5　缓存静态的会话数据\t576
18．6　包和对象类型\t577
第19章　触发器\t578
19．1　DML触发器\t579
19．1．1　DML触发器的概念\t580
19．1．2　创建DML触发器\t581
19．1．3　DML触发器的例子：严禁
作弊！\t586
19．1．4　同一类型的多个触发器\t591
19．1．5　如何对触发顺序排序\t592
19．1．6　突变表的错误\t594
19．1．7　复合触发器：聚在一处\t595
19．2　DDL触发器\t598
19．2．1　创建DDL触发器\t598
19．2．2　可用事件\t600
19．2．3　可用属性\t601
19．2．4　使用事件和属性\t602
19．2．5　删除不可删除的\t606
19．2．6　INSTEAD OFCREATE
触发器\t606
19．3　数据库事件触发器\t607
19．3．1　创建数据库事件触发器\t608
19．3．2　STARTUP触发器\t609
19．3．3　SHUTDOWN触发器\t610
19．3．4　LOGON触发器\t610
19．3．5　LOGOFF触发器\t610
19．3．6　SERVERERROR触发器\t611
19．4　INSTEAD OF触发器\t615
19．4．1　创建INSTEAD OF触发器\t615
19．4．2　INSTEAD OF INSERT
触发器\t616
19．4．3　INSTEAD OF UPDATE
触发器\t618
19．4．4　INSTEAD OF DELETE
触发器\t619
19．4．5　填充表\t619
19．4．6　嵌套表的lNSTEAD OF
触发器\t620
19．5　AFTER SUSPEND触发器\t621
19．5．1　建立AFTER SUSPEND
触发器\t622
19．5．2　看看真实的触发器\t623
19．5．3　ORA_SPACE_ERROR_lNFO
函数\t624
19．5．4　DBMS_RESUMABLE包\t625
19．5．5　捕获多个时间\t626
19．5．6　是否该处理？\t627
19．6　维护触发器\t628
19．6．1　禁用、启用以及删除
触发器\t628
19．6．2　创建一个禁用的触发器\t628
19．6．3　查看触发器\t629
19．6．4　检查触发器的有效性\t630
第20章　管理PL/SQL代码\t631
20．1　管理数据库内的代码\t632
20．1．1　数据字典视图概述\t632
20．1．2　显示存储对象的信息\t634
20．1．3　源代码的显示和搜索\t635
20．1．4　根据程序的大小确定Pinning
需求\t637
20．1．5　获得存储代码的属性\t637
20．1．6　通过视图分析和更改触发器
状态\t638
20．1．7　分析参数信息\t639
20．1．8　分析标识符的使用（Oracle
数据库11g的PL/Scope）\t640
20．2　管理依赖关系及重编译
代码\t643
20．2．1　通过数据字典视图分析依赖
关系\t643
20．2．2　细粒度依赖（Oracle
数据库11g）\t647
20．2．3　远程依赖\t648
20．2．4　Oracle的远程调用模式的
限制\t650
20．2．5　重编译无效的程序单元\t651
20．3　编译时刻警告\t655
20．3．1　一个快速示例\t655
20．3．2　开启编译时刻告警\t656
20．3．3　一些有用的警告\t657
20．4　测试PL/SQL程序\t664
20．4．1　典型的、华而不实的测试
技术\t665
20．4．2　PL/SQL代码测试的一般
建议\t668
20．4．3　PL/SQL的自动测试选项\t669
20．5　跟踪PL/SQL的执行\t670
20．5．1　DBMS_UTILITY．FORMAT_
CALL_STACK\t671
20．5．2　UTL_CALL_STACK（Oracle
数据库12c）\t673
20．5．3　DBMS_APPLICATION_
INFO\t676
20．5．4　使用opp_trace进行跟踪\t677
20．5．5　DBMS_TRACE工具包\t678
20．6　PL/SQL程序的调试\t681
20．6．1　错误的调试方法\t682
20．6．2　调试技巧和策略\t683
20．7　使用白名单来控制对程序
单元的访问\t687
20．8　存储代码的保护\t689
20．8．1　封装的约束和局限\t690
20．8．2　使用封装程序\t690
20．8．3　使用DBMS_DDL进行动态
封装\t690
20．8．4　封装代码的使用指导\t691
20．9　基于版本的重定义（Oracle
数据库11g R2版本）\t692
第21章　PL/SQL的性能优化\t695
21．1　辅助优化的工具\t696
21．1．1　内存使用分析\t696
21．1．2　发现PL/SQL代码中的瓶颈\t697
21．1．3　计算花费时间\t701
21．1．4　选择最快的程序\t703
21．1．5　避免无限循环\t704
21．1．6　性能相关的警告\t706
21．2　优化编译器\t706
21．2．1　优化器工作原理\t707
21．2．2　循环Fetch操作的运行
时优化\t710
21．3　数据缓存技术\t710
21．3．1　基于包的缓存\t711
21．3．2　确定性函数的缓存\t716
21．3．3　函数结果缓存（Oracle
数据库11g）\t718
21．3．4　缓存总结\t731
21．4　重复的SQL的语句批
处理\t732
21．4．1　通过BULK COLLECT加速
查询\t733
21．4．2　使用FORALL加速DML\t739
21．5　利用管道化的表函数提升
性能\t749
21．5．1　用基于管道化函数的加载
方式替换基于行的插入\t750
21．5．2　用管道函数调优Merge
操作\t756
21．5．3　用并行管道函数进行异步
数据导出\t758
21．5．4　并行管道函数中的分区和
流子句对性能的影响\t761
21．5．5　管道函数和基于成本的
优化器\t763
21．5．6　用管道函数优化负载的数据
加载\t768
21．5．7　管道函数结束语\t775
21．6　专用的优化技术\t775
21．6．1　使用NOCOPY参数模式
提示符\t775
21．6．2　使用正确的数据类型\t778
21．6．3　SQL（12．1及更高版本）的
函数性能优化\t779
21．7　性能回顾\t780
第22章　I/O操作和PL/SQL\t781
22．1　显示信息\t781
22．1．1　启用DBMS_OUTPUT\t782
22．1．2　向缓存中写入行\t782
22．1．3　从缓存中读取内容\t783
22．2　文件的读写\t784
22．2．1　UTL_FILE_DIR参数\t784
22．2．2　使用Oracle目录\t786
22．2．3　打开文件\t787
22．2．4　文件已经打开了吗？\t789
22．2．5　关闭文件\t789
22．2．6　读取文件\t790
22．2．7　向文件中写\t792
22．2．8　复制文件\t795
22．2．9　删除文件\t795
22．2．10　改名和移动文件\t796
22．2．11　提取文件属性\t797
22．3　发送邮件\t798
22．3．1　Oracle的前提条件\t798
22．3．2　设置网络安全\t799
22．3．3　发送一个短的（小于32767字
节）的纯文本消息\t799
22．3．4　在邮件地址中加上“界面友
好的”的名字\t801
22．3．5　发送任意长度的纯文本
消息\t802
22．3．6　发送带有小附件（小于32767
字节）的消息\t803
22．3．7　以附件形式发送一个小文件
（小于32767字节）\t805
22．3．8　任意大小的附件\t805
22．4　使用基于Web的数据
（HTTP）\t808
22．4．1 “分片”获得一个Web页面\t808
22．4．2　把页面提取到一个LOB中\t809
22．4．3　使用HTTP的用户名/密码
验证\t810
22．4．4　获取一个SSL加密的Web页面
（使用HTTPS）\t811
22．4．5　通过GET或者POST向Web页
面提交数据\t812
22．4．6　禁用cookie或者使cookie
持久化\t816
22．4．7　从FTP服务器获取数据\t816
22．4．8　使用代理服务器\t817
22．5　PL/SQL中可用的其他I/O
类型\t817
22．5．1　数据库管道、队列、告警\t817
22．5．2　TCPSocket\t818
22．5．3　Oracle的内置Web服务器\t818

第6部分　高级PL/SQL主题
第23章　应用系统安全与
PL/SQL\t821
23．1　安全概述\t821
23．2　加密\t822
23．2．1　密钥长度\t823
23．2．2　算法\t824
23．2．3　填补和连接\t825
23．2．4　DBMS_CRYPTO包\t825
23．2．5　数据加密\t827
23．2．6　LOB的加密\t830
23．2．7　安全文件\t830
23．2．8　数据解密\t831
23．2．9　生成密钥\t832
23．2．10　密钥的管理\t833
23．2．11　加密哈希\t838
23．2．12　使用消息验证码\t839
23．2．13　使用透明数据加密
（TDE）\t841
23．2．14　透明的表空间加密\t843
23．3　行级安全\t844
23．3．1　为什么要学习RLS\t846
23．3．2　一个简单的RLS示例\t847
23．3．3　静态与动态策略\t850
23．3．4　使用列敏感的RLS\t854
23．3．5　RLS调试\t857
23．4　应用程序上下文\t861
23．4．1　使用应用程序上下文\t862
23．4．2　上下文的安全\t863
23．4．3　把上下文用作RLS的谓词
条件\t863
23．4．4　识别出非数据库的用户\t867
23．5　细粒度审计\t868
23．5．1　为什么要学习FGA\t869
23．5．2　一个简单的FGA示例\t870
23．5．3　访问多少列\t872
23．5．4　查看审计跟踪信息\t873
23．5．5　使用绑定变量\t874
23．5．6　使用句柄模块\t875
第24章　PL/SQL架构\t877
24．1　DIANA\t877
24．2　Oracle如何执行PL/SQL
代码\t878
24．2．1　一个示例\t879
24．2．2　编译器的限制\t881
24．3　PL/SQL的缺省包\t882
24．4　执行权限模型\t884
24．4．1　定义者权限模型\t885
24．4．2　调用者权限模型\t889
24．4．3　组合权限模型\t891
24．4．4　给PL/SQL程序单元授予角色
（Oracle数据库12c）\t892
24．4．5 “谁调用了我？”函数
（Oracle数据库12c）\t895
24．4．6　视图的BEQUEATH CURRENT_
USER子句（Oracle数据库
12c）\t895
24．4．7　调用者权限优点的限制
（Oracle数据库12c）\t897
24．5　条件编译\t898
24．5．1　条件编译的示例\t899
24．5．2　查询指令\t900
24．5．3　$IF指令\t903
24．5．4　$ERROR指令\t904
24．5．5　将代码与包常量同步\t905
24．5．6　用查询指令实现程序专有
设置\t906
24．5．7　使用预处理后的代码\t907
24．6　PL/SQL和数据库实例
内存\t908
24．6．1　SGA、PGA和UGA\t908
24．6．2　游标、内存及其他\t909
24．6．3　减少内存使用的技巧\t910
24．6．4　内存用光了怎么办\t920
24．7　原生式编译\t922
24．7．1　什么时候使用解释模式\t922
24．7．2　什么时候使用原生模式\t922
24．7．3　原生编译和数据库版本\t923
24．8　一些须知\t923
第25章　PL/SQL的全球化和
本地化\t925
25．1　概述和术语\t926
25．2　Unicode入门\t928
25．2．1　国家字符集的数据类型\t929
25．2．2　字符编码\t929
25．2．3　和全球化支持相关的参数\t930
25．2．4　Unicode函数\t931
25．3　字符语义\t938
25．4　字符串排序顺序\t941
25．4．1　二进制排序\t942
25．4．2　单语言排序\t943
25．4．3　多语言排序\t945
25．5　多语言信息检索\t946
25．5．1　信息检索和PL/SQL\t948
25．6　日期/时间\t950
25．6．1　时间戳数据类型\t951
25．6．2　日期/时间格式\t952
25．7　货币转换\t955
25．8　PL/SQL的全球化开发
工具箱\t957
25．8．1　UTL_I18N工具包\t957
25．8．2　UTL_LMS异常处理包\t960
25．8．3　GDK实现选项\t961
第26章　PL/SQL的面向对象
特性\t963
26．1　Oracle对象特性的介绍\t963
26．2　对象类型示例\t965
26．2．1　创建一个基类\t966
26．2．2　创建子类型\t967
26．2．3　方法\t968
26．2．4　在Oracle数据库11g及以后
版本中调用父类的方法\t972
26．2．5　保存、提取、使用持久化
对象\t974
26．2．6　演变和创建\t981
26．2．7　回到指针吗？\t983
26．2．8　泛化数据：ANY类型\t989
26．2．9　我们自己做\t993
26．2．10　对象的比较\t996
26．3　对象视图\t1001
26．3．1　一个关系型系统的示例\t1002
26．3．2　带有集合属性的对象视图\t1003
26．3．3　对象子视图\t1006
26．3．4　带有反关系的对象视图\t1008
26．3．5　INSTEAD OF触发器\t1008
26．3．6　对象视图和对象表的区别\t1010
26．4　维护对象类型和对象视图\t1012
26．4．1　数据字典\t1012
26．4．2　权限\t1013
26．5　来自一个关系开发者的总结
思考（C551， E1200）\t1015
第27章　从PL/SQL中调用
Java\t1017
27．1　Oracle和Java\t1017
27．2　准备好在Oracle中使用
Java\t1018
27．2．1　安装Java\t1019
27．2．2　创建和编译我们的Java
代码\t1019
27．2．3　设置Java开发和执行的
权限\t1020
27．3　一个简单的演示\t1022
27．3．1　查找Java功能\t1023
27．3．2　创建一个自定义Java类\t1023
27．3．3　编译和加载到Oracle\t1025
27．3．4　创建一个PL/SQL的
包装器\t1026
27．3．5　从PL/SQL删除文件\t1027
27．4　使用loadjava\t1028
27．5　使用dropjava\t1030
27．6　管理数据库中的Java\t1030
27．6．1　Oracle中的Java命名空间\t1030
27．6．2　检查加载的Java元素\t1031
27．7　使用DBMS_JAVA\t1032
27．7．1　LONGNAME：转换Java
长名字\t1032
27．7．2　GET_、SET_和RESET_
COMPILER_OPTION：
得到和设置（一些）
编译器选项\t1033
27．7．3　SET_OUTPUT：允许从
Java中输出\t1034
27．7．4　EXPORT_SOURCE、EXPORT_
RESOURCE和EXPORT_
CLASS：导出模式对象\t1034
27．8　在PL/SQL中发布与
使用Java\t1036
27．8．1　调用规范\t1036
27．8．2　一些调用规范的规则\t1037
27．8．3　映射数据类型\t1038
27．8．4　在SQL中调用Java方法\t1039
27．8．5　Java的异常处理\t1040
27．8．6　扩展文件I/O功能\t1042
27．8．7　其他示例\t1046
第28章　外部过程\t1049
28．1　外部过程介绍\t1050
28．1．1　示例：调用一个系统命令\t1050
28．1．2　外部过程的架构\t1052
28．2　Oracle网络配置\t1053
28．2．1　定义监听配置\t1053
28．2．2　配置的安全特性\t1055
28．3　设置多线程模式\t1056
28．4　创建一个Oracle库\t1058
28．5　编写调用规范\t1059
28．5．1　调用规范：整体语法\t1060
28．5．2　参数映射：示例重温\t1061
28．5．3　参数映射：完整的内容\t1063
28．5．4　更多的语法：参数子句\t1064
28．5．5　参数属性\t1065
28．6　从调用的C程序中引发
一个异常\t1068
28．7　非默认的代理\t1071
28．8　维护外部过程\t1073
28．8．1　删除库\t1073
28．8．2　数据字典\t1074
28．8．3　规则和警示\t1074
附录A　正则表达式元字符和函数
参数\t1075
附录B　数字格式模型\t1080
附录C　日期格式模型\t1083