Oracle PLSQL程序设计(第6版)(上下册)电子书

内容提要

O'Reilly Media，Inc.介绍

业界评论

前言

本书的目标

本书约定

第1部分 用PL/SQL编程

第1章 PL/SQL介绍

1.1 什么是PL/SQL

1.2 PL/SQL的起源

1.2.1 早期的PL/SQL

1.2.2 提高应用的可移植性

1.2.3 提高执行权限控制和交易完整性

1.2.4 低调开始，持续改进

1.3 这就是PL/SQL

1.3.1 与SQL的集成

1.3.2 控制和条件逻辑

1.3.3 出错处理

1.4 关于PL/SQL版本

1.4.1 Oracle数据库12c中PL/SQL的新特性

1.5 可供PL/SQL开发者使用的资源

1.5.1 O’Reilly的PL/SQL系列图书

1.5.2 网络上的PL/SQL资源

1.6 一些建议

1.6.1 别急，慢慢来

1.6.2 不要畏惧寻求帮助

1.6.3 采用有创造性的甚至激进的方法

第2章 创建和运行PL/SQL代码

2.1 在数据库中导航

2.2 创建和编辑源代码

2.3 SQL*Plus

2.3.1 启动SQL*Plus

2.3.2 运行SQL语句

2.3.3 运行PL/SQL程序

2.3.4 运行一个脚本

2.3.5 什么是“当前目录”

2.3.6 其他SQL*Plus任务

2.3.7 SQL*Plus中的异常处理

2.3.8 为什么SQL*Plus让我们又爱又恨

2.4 执行基本的PL/SQL任务

2.4.1 创建存储程序

2.4.2 执行存储的程序

2.4.3 显示存储程序

2.4.4 存储程序的授权和别名

2.4.5 删除一个存储程序

2.4.6 隐藏存储程序的源代码

2.5 编辑PL/SQL的环境

2.6 从其他语言中调用PL/SQL

2.6.1 C语言，使用Oracle预编辑器（Pro*C）

2.6.2 Java：使用JDBC

2.6.3 Perl：使用Perl DBI和DBD::Oracle

2.6.4 PHP：使用Oracle扩展

2.6.5 PL/SQL Server Pages

2.6.6 其他

第3章 语言基础

3.1 PL/SQL块结构

3.1.1 匿名块

3.1.2 命名块

3.1.3 嵌套块

3.1.4 作用范围

3.1.5 规范SQL语句中对变量和列的引用

3.1.6 可见性

3.2 PL/SQL字符集

3.3 标识符

3.3.1 保留字

3.3.2 空白和关键字

3.4 直接量

3.4.1 NULL

3.4.2 在一个直接量字符串中嵌入单引号

3.4.3 数字直接量

3.4.4 布尔直接量

3.5 分号分隔符

3.6 注释

3.6.1 单行注释语法

3.6.2 多行注释语法

3.7 PRAGMA关键字

3.8 标签

第2部分 PL/SQL程序结构

第4章 条件与顺序控制

4.1 IF语句

4.1.1 IF-THEN组合

4.1.2 IF-THEN-ELSE的组合

4.1.3 IF-THEN-ELSIF组合

4.1.4 避免IF语法陷阱

4.1.5 嵌套的IF语句

4.1.6 短路估算

4.2 CASE语句和表达式

4.2.1 简单的CASE语句

4.2.2 搜索CASE语句

4.2.3 嵌套CASE语句

4.2.4 CASE表达式

4.3 GOTO语句

4.4 NULL语句

4.4.1 提高程序的可读性

4.4.2 在标签后使用NULL

第5章 循环迭代处理

5.1 循环的基础知识

5.1.1 不同循环的示例

5.1.2 PL/SQL循环的结构

5.2 简单循环

5.2.1 终止简单循环：EXIT和EXIT WHEN

5.2.2 模仿REPEAT UNTIL循环

5.2.3 故意的无限循环

5.3 WHILE循环

5.4 数值型FOR循环

5.4.1 数值型FOR循环的规则

5.4.2 数值型FOR循环的示例

5.4.3 处理特殊增量

5.5 游标FOR循环

5.5.1 游标FOR循环的示例

5.6 循环标签

5.7 CONTINUE语句

5.8 迭代处理技巧

5.8.1 为循环索引使用可理解的名称

5.8.2 以正确的方式说再见

5.8.3 获取FOR循环执行的信息

5.8.4 循环SQL语句

第6章 异常处理

6.1 异常处理概念和术语

6.2 定义异常

6.2.1 声明命名异常

6.2.2 关联异常名称与错误代码

6.2.3 命名的系统异常

6.2.4 异常作用范围

6.3 引发异常

6.3.1 RAISE语句

6.3.2 使用RAISE_APPLICATION_ERROR

6.4 处理异常

6.4.1 内置错误函数

6.4.2 单一处理句柄中结合多个异常

6.4.3 未处理异常

6.4.4 未处理异常的传播

6.4.5 继续过去的异常

6.4.6 编写WHEN OTHERS处理代码

6.5 构建有效的错误管理架构

6.5.1 确定我们的异常管理策略

6.5.2 对不同类型异常进行标准化处理

6.5.3 程序特定错误代码的组织使用

6.5.4 使用标准的错误管理程序

6.5.5 使用自己的异常“对象”

6.5.6 创建常见错误处理的标准模板

6.6 充分利用PL/SQL错误管理

第3部分 PL/SQL程序数据

第7章 使用程序数据

7.1 程序数据的命名

7.2 PL/SQL数据类型概述

7.2.1 字符数据

7.2.2 数字

7.2.3 日期、时间戳和时间间隔

7.2.4 布尔类型

7.2.5 二进制数据类型

7.2.6 ROWID

7.2.7 REF CURSOR

7.2.8 Internet数据类型

7.2.9 “Any”数据类型

7.2.10 用户自定义数据类型

7.3 程序数据的声明

7.3.1 声明一个变量

7.3.2 声明常量

7.3.3 NOT NULL语句

7.3.4 锚定声明

7.3.5 游标和表的锚

7.3.6 使用锚定声明的益处

7.3.7 NOT NULL数据类型的锚

7.4 程序员定义的子类型

7.5 数据类型转换

7.5.1 隐式类型转换

7.5.2 显式类型转换

第8章 字符串

8.1 字符串类型

8.1.1 VARCHAR2数据类型

8.1.2 CHAR数据类型

8.1.3 String子类型

8.2 使用字符串

8.2.1 指定字符串常量

8.2.2 不可打印字符

8.2.3 拼接字符串

8.2.4 处理大小写

8.2.5 传统的检索、提取和替换

8.2.6 填充

8.2.7 剪裁

8.2.8 正则表达式的检索、提取和替换

8.2.9 使用空字符串

8.2.10 混用CHAR和VARCHAR2

8.3 字符串函数快速参考

第9章 数字

9.1 数值型数字类型

9.1.1 NUMBER类型

9.1.2 PLS_INTEGER类型

9.1.3 BINARY_INTEGER类型

9.1.4 SIMPLE_INTEGER类型

9.1.5 BINARY_FLOAT和BINARY_DOUBLE类型

9.1.6 SIMPLE_FLOAT和SIMPLE_DOUBLE类型

9.1.7 数字子类型

9.2 数字转换

9.2.1 TO_NUMBER函数

9.2.2 TO_CHAR函数

9.2.3 CAST函数

9.2.4 隐式转换

9.3 数字运算符

9.4 数字函数

9.4.1 四舍五入和截断函数

9.4.2 三角函数

9.4.3 数字函数的快速参考

第10章 日期和时间戳

10.1 Datetime数据类型

10.1.1 声明日期时间变量

10.1.2 选择日期时间数据类型

10.2 获取当前日期和时间

10.3 INTERVAL数据类型

10.3.1 声明INTERVAL变量

10.3.2 什么时候使用INTERVAL

10.4 日期时间转换

10.4.1 从字符串到日期时间

10.4.2 从日期时间到字符串

10.4.3 使用时区

10.4.4 精确匹配需要格式掩码

10.4.5 让精确匹配更轻松

10.4.6 解释滑动窗口中两位数字的年份

10.4.7 把时区转换成字符串

10.4.8 用填充模式把输出补齐

10.5 日期和时间戳直接量

10.6 时间间隔的转换

10.6.1 从数字到时间间隔的转换

10.6.2 把字符串转换成间隔

10.6.3 时间间隔的格式化显示

10.7 时间间隔直接量

10.8 CAST和EXTRACT

10.8.1 CAST函数

10.8.2 EXTRACT函数

10.9 日期时间的算法

10.9.1 时间间隔和日期时间的算法

10.9.2 DATE数据类型的日期算法

10.9.3 计算两个日期时间之间的时间间隔

10.9.4 DATE和TIMESTAMP混合计算

10.9.5 时间间隔的加减运算

10.9.6 时间间隔的乘除运算

10.9.7 使用不受限制的时间间隔类型

10.10 日期/时间函数的快速参考

第11章 记录类型

11.1 PL/SQL中的记录

11.1.1 使用记录的好处

11.1.2 声明记录

11.1.3 程序员自定义的记录类型

11.1.4 使用记录类型

11.1.5 记录的比较

11.1.6 触发器伪记录

第12章 集合

12.1 集合概述

12.1.1 集合概念和术语

12.1.2 集合类型

12.1.3 集合示例

12.1.4 使用集合的场合

12.1.5 选择一个集合类型

12.2 集合方法（内置）

12.2.1 COUNT方法

12.2.2 DELETE方法

12.2.3 EXISTS方法

12.2.4 EXTEND方法

12.2.5 FIRST和LAST方法

12.2.6 LIMIT方法

12.2.7 PRIOR和NEXT方法

12.2.8 TRIM方法

12.3 使用集合

12.3.1 声明集合类型

12.3.2 集合变量的声明和初始化

12.3.3 用数据填充集合

12.3.4 访问集合内的数据

12.3.5 使用字符串索引的集合

12.3.6 复杂数据类型的集合

12.3.7 多级集合

12.3.8 在SQL中使用集合

12.4 嵌套表的多重集合操作

12.4.1 测试嵌套表是否相等及成员归属

12.4.2 检查元素是否是嵌套表的成员

12.4.3 执行高级别集合操作

12.4.4 嵌套表中的去重

12.5 schema级别集合的维护

12.5.1 必需的权限

12.5.2 集合和数据字典

第13章 其他数据类型

13.1 BOOLEAN类型

13.2 RAW数据类型

13.3 UROWID和ROWID数据类型

13.3.1 获取ROWID

13.3.2 使用ROWID

13.4 LOB数据类型

13.5 使用LOB

13.5.1 理解LOB定位符

13.5.2 LOB的空和NULL

13.5.3 向LOB中写入数据

13.5.4 读取LOB数据

13.5.5 BFILE的不同之处

13.5.6 SecureFiles和BasicFiles

13.5.7 临时LOB

13.5.8 原生的LOB操作

13.5.9 LOB转换函数

13.6 预定义的对象类型

13.6.1 XMLType类型

13.6.2 URI类型

13.6.3 Any类型

第4部分 PL/SQL中的SQL

第14章 DML和事务管理

14.1 PL/SQL中的DML

14.1.1 DML简介

14.1.2 DML操作符的游标属性

14.1.3 从DML语句返回信息

14.1.4 DML和异常处理

14.1.5 DML和记录

14.2 事务管理

14.2.1 COMMIT语句

14.2.2 ROLLBACK语句

14.2.3 SAVEPOINT语句

14.2.4 SET TRANSACTION语句

14.2.5 LOCK TABLE语句

14.3 自治事务

14.3.1 定义自治事务

14.3.2 自治事务的规则和限制

14.3.3 事务的可见性

14.3.4 何时使用自治事务

14.3.5 创建自治日志记录机制

第15章 数据提取

15.1 游标基础

15.1.1 一些数据提取术语

15.1.2 典型的查询操作

15.1.3 游标属性介绍

15.1.4 在游标中引用PL/SQL变量

15.1.5 显式与隐式游标之间的选择

15.2 使用隐式游标

15.2.1 隐式游标示例

15.2.2 隐式游标的异常处理

15.2.3 隐式SQL游标的属性

15.3 使用显式游标

15.3.1 声明显式游标

15.3.2 打开显式游标

15.3.3 从显式游标获取

15.3.4 显式游标中的列别名

15.3.5 关闭显式游标

15.3.6 显式游标属性

15.3.7 游标参数

15.4 SELECT…FOR UPDATE

15.4.1 COMMIT释放锁定

15.4.2 WHERE CURRENT OF 子句

15.5 游标变量和REF CURSOR

15.5.1 为什么使用游标变量

15.5.2 与静态游标的相似之处

15.5.3 声明REF CURSOR类型

15.5.4 声明游标变量

15.5.5 打开游标变量

15.5.6 从游标变量中提取数据

15.5.7 游标变量的使用规则

15.5.8 将游标变量作为参数传递

15.5.9 游标变量的约束限制

15.6 游标表达式

15.6.1 使用游标表达式

15.6.2 游标表达式的约束限制

第16章 动态SQL和动态PL/SQL

16.1 NDS语句

16.1.1 EXECUTE IMMEDIATE语句

16.1.2 OPEN FOR语句

16.1.3 4种动态SQL方法

16.2 绑定变量

16.2.1 参数模式

16.2.2 重复的占位符

16.2.3 传递NULL值

16.3 使用对象和集合

16.4 动态PL/SQL

16.4.1 建立动态PL/SQL块

16.4.2 用动态块替换重复代码

16.5 NDS建议

16.5.1 对共享程序使用调用者权限

16.5.2 预测并处理动态错误

16.5.3 使用绑定而非拼接

16.5.4 减少代码注入的危险

16.6 何时使用DBMS_SQL

16.6.1 获得查询列信息

16.6.2 实现第四种方法的动态SQL需求

16.6.3 最小化动态游标解析

16.6.4 Oracle数据库11g新动态SQL特性

16.6.5 DBMS_SQL增强安全

第5部分 构造PL/SQL应用程序

第17章 过程、函数和参数

17.1 代码模块化

17.2 过程

17.2.1 调用一个过程

17.2.2 过程头部

17.2.3 过程体

17.2.4 END标签

17.2.5 RETURN语句

17.3 函数

17.3.1 函数的结构

17.3.2 返回的数据类型

17.3.3 END标签

17.3.4 调用函数

17.3.5 不带参数的函数

17.3.6 函数头

17.3.7 函数体

17.3.8 RETURN语句

17.4 参数

17.4.1 定义参数

17.4.2 实参和形参

17.4.3 参数模式

17.4.4 在PL/SQL中显式地关联实参和形参

17.4.5 NOCOPY参数模式限定符

17.4.6 缺省值

17.5 局部或者嵌套模块

17.5.1 使用局部模块的益处

17.5.2 局部模块的作用范围

17.5.3 用局部模块使得代码更整洁

17.6 模块的重载

17.6.1 重载的益处

17.6.2 重载的限制

17.6.3 数字类型的重载

17.7 前置声明

17.8 高级主题

17.8.1 在SQL内部调用我们的函数

17.8.2 表函数

17.8.3 确定性函数

17.8.4 隐式游标结果（Oracle数据库12c）

17.9 将模块化进行到底

第18章 程序包

18.1 为什么使用程序包

18.1.1 演示程序包的能力

18.1.2 与程序包相关的一些概念

18.1.3 图示私有性

18.2 构建程序包的规则

18.2.1 程序包说明

18.2.2 包体

18.2.3 包的初始化

18.3 包元素的调用规则

18.4 使用包数据

18.4.1 在一个Oracle会话内全局可见

18.4.2 全局公有数据

18.4.3 包游标

18.4.4 包的串行化

18.5 何时使用包

18.5.1 封装对数据的访问

18.5.2 避免直接量的硬编码

18.5.3 提高内置特性的可用性

18.5.4 把逻辑上相关的功能组织在一起

18.5.5 缓存静态的会话数据

18.6 包和对象类型

第19章 触发器

19.1 DML触发器

19.1.1 DML触发器的概念

19.1.2 创建DML触发器

19.1.3 DML触发器的例子：严禁作弊！

19.1.4 同一类型的多个触发器

19.1.5 如何对触发顺序排序

19.1.6 突变表的错误

19.1.7 复合触发器：聚在一处

19.2 DDL触发器

19.2.1 创建DDL触发器

19.2.2 可用事件

19.2.3 可用属性

19.2.4 使用事件和属性

19.2.5 删除不可删除的

19.2.6 INSTEAD OF CREATE触发器

19.3 数据库事件触发器

19.3.1 创建数据库事件触发器

19.3.2 STARTUP触发器

19.3.3 SHUTDOWN触发器

19.3.4 LOGON触发器

19.3.5 LOGOFF触发器

19.3.6 SERVERERROR触发器

19.4 INSTEAD OF触发器

19.4.1 创建INSTEAD OF触发器

19.4.2 INSTEAD OF INSERT触发器

19.4.3 INSTEAD OF UPDATE触发器

19.4.4 INSTEAD OF DELETE触发器

19.4.5 填充表

19.4.6 嵌套表的lNSTEAD OF触发器

19.5 AFTER SUSPEND触发器

19.5.1 建立AFTER SUSPEND触发器

19.5.2 看看真实的触发器

19.5.3 ORA_SPACE_ERROR_lNFO函数

19.5.4 DBMS_RESUMABLE包

19.5.5 捕获多个时间

19.5.6 是否该处理？

19.6 维护触发器

19.6.1 禁用、启用以及删除触发器

19.6.2 创建一个禁用的触发器

19.6.3 查看触发器

19.6.4 检查触发器的有效性

第20章 管理PL/SQL代码

20.1 管理数据库内的代码

20.1.1 数据字典视图概述

20.1.2 显示存储对象的信息

20.1.3 源代码的显示和搜索

20.1.4 根据程序的大小确定Pinning需求

20.1.5 获得存储代码的属性

20.1.6 通过视图分析和更改触发器状态

20.1.7 分析参数信息

20.1.8 分析标识符的使用（Oracle数据库11g的PL/Scope）

20.2 管理依赖关系及重编译代码

20.2.1 通过数据字典视图分析依赖关系

20.2.2 细粒度依赖（Oracle数据库11g）

20.2.3 远程依赖

20.2.4 Oracle的远程调用模式的限制

20.2.5 重编译无效的程序单元

20.3 编译时刻警告

20.3.1 一个快速示例

20.3.2 开启编译时刻告警

20.3.3 一些有用的警告

20.4 测试PL/SQL程序

20.4.1 典型的、华而不实的测试技术

20.4.2 PL/SQL代码测试的一般建议

20.4.3 PL/SQL的自动测试选项

20.5 跟踪PL/SQL的执行

20.5.1 DBMS_UTILITY.FORMAT_CALL_STACK

20.5.2 UTL_CALL_STACK（Oracle数据库12c）

20.5.3 DBMS_APPLICATION_INFO

20.5.4 使用opp_trace进行跟踪

20.5.5 DBMS_TRACE工具包

20.6 PL/SQL程序的调试

20.6.1 错误的调试方法

20.6.2 调试技巧和策略

20.7 使用白名单来控制对程序单元的访问

20.8 存储代码的保护

20.8.1 封装的约束和局限

20.8.2 使用封装程序

20.8.3 使用DBMS_DDL进行动态封装

20.8.4 封装代码的使用指导

20.9 基于版本的重定义（Oracle数据库11g R2版本）

第21章 PL/SQL的性能优化

21.1 辅助优化的工具

21.1.1 内存使用分析

21.1.2 发现PL/SQL代码中的瓶颈

21.1.3 计算花费时间

21.1.4 选择最快的程序

21.1.5 避免无限循环

21.1.6 性能相关的警告

21.2 优化编译器

21.2.1 优化器工作原理

21.2.2 循环Fetch操作的运行时优化

21.3 数据缓存技术

21.3.1 基于包的缓存

21.3.2 确定性函数的缓存

21.3.3 函数结果缓存（Oracle数据库11g）

21.3.4 缓存总结

21.4 重复的SQL的语句批处理

21.4.1 通过BULK COLLECT加速查询

21.4.2 使用FORALL加速DML

21.5 利用管道化的表函数提升性能

21.5.1 用基于管道化函数的加载方式替换基于行的插入

21.5.2 用管道函数调优Merge操作

21.5.3 用并行管道函数进行异步数据导出

21.5.4 并行管道函数中的分区和流子句对性能的影响

21.5.5 管道函数和基于成本的优化器

21.5.6 用管道函数优化负载的数据加载

21.5.7 管道函数结束语

21.6 专用的优化技术

21.6.1 使用NOCOPY参数模式提示符

21.6.2 使用正确的数据类型

21.6.3 SQL（12.1及更高版本）的函数性能优化

21.7 性能回顾

第22章 I/O操作和PL/SQL

22.1 显示信息

22.1.1 启用DBMS_OUTPUT

22.1.2 向缓存中写入行

22.1.3 从缓存中读取内容

22.2 文件的读写

22.2.1 UTL_FILE_DIR参数

22.2.2 使用Oracle目录

22.2.3 打开文件

22.2.4 文件已经打开了吗？

22.2.5 关闭文件

22.2.6 读取文件

22.2.7 向文件中写

22.2.8 复制文件

22.2.9 删除文件

22.2.10 改名和移动文件

22.2.11 提取文件属性

22.3 发送邮件

22.3.1 Oracle的前提条件

22.3.2 设置网络安全

22.3.3 发送一个短的（小于32767字节）的纯文本消息

22.3.4 在邮件地址中加上“界面友好的”的名字

22.3.5 发送任意长度的纯文本消息

22.3.6 发送带有小附件（小于32767字节）的消息

22.3.7 以附件形式发送一个小文件（小于32767字节）

22.3.8 任意大小的附件

22.4 使用基于Web的数据（HTTP）

22.4.1 “分片”获得一个Web页面

22.4.2 把页面提取到一个LOB中

22.4.3 使用HTTP的用户名/密码验证

22.4.4 获取一个SSL加密的Web页面（使用HTTPS）

22.4.5 通过GET或者POST向Web页面提交数据

22.4.6 禁用cookie或者使cookie持久化

22.4.7 从FTP服务器获取数据

22.4.8 使用代理服务器

22.5 PL/SQL中可用的其他I/O类型

22.5.1 数据库管道、队列、告警

22.5.2 TCPSocket

22.5.3 Oracle的内置Web服务器

第6部分 高级PL/SQL主题

第23章 应用系统安全与PL/SQL

23.1 安全概述

23.2 加密

23.2.1 密钥长度

23.2.2 算法

23.2.3 填补和连接

23.2.4 DBMS_CRYPTO包

23.2.5 数据加密

23.2.6 LOB的加密

23.2.7 安全文件

23.2.8 数据解密

23.2.9 生成密钥

23.2.10 密钥的管理

23.2.11 加密哈希

23.2.12 使用消息验证码

23.2.13 使用透明数据加密（TDE）

23.2.14 透明的表空间加密

23.3 行级安全

23.3.1 为什么要学习RLS

23.3.2 一个简单的RLS示例

23.3.3 静态与动态策略

23.3.4 使用列敏感的RLS

23.3.5 RLS调试

23.4 应用程序上下文

23.4.1 使用应用程序上下文

23.4.2 上下文的安全

23.4.3 把上下文用作RLS的谓词条件

23.4.4 识别出非数据库的用户

23.5 细粒度审计

23.5.1 为什么要学习FGA

23.5.2 一个简单的FGA示例

23.5.3 访问多少列

23.5.4 查看审计跟踪信息

23.5.5 使用绑定变量

23.5.6 使用句柄模块

第24章 PL/SQL架构

24.1 DIANA

24.2 Oracle如何执行PL/SQL代码

24.2.1 一个示例

24.2.2 编译器的限制

24.3 PL/SQL的缺省包

24.4 执行权限模型

24.4.1 定义者权限模型

24.4.2 调用者权限模型

24.4.3 组合权限模型

24.4.4 给PL/SQL程序单元授予角色（Oracle数据库12c）

24.4.5 “谁调用了我？”函数（Oracle数据库12c）

24.4.6 视图的BEQUEATH CURRENT_USER子句（Oracle数据库12c）

24.4.7 调用者权限优点的限制（Oracle数据库12c）

24.5 条件编译

24.5.1 条件编译的示例

24.5.2 查询指令

24.5.3 $IF指令

24.5.4 $ERROR指令

24.5.5 将代码与包常量同步

24.5.6 用查询指令实现程序专有设置

24.5.7 使用预处理后的代码

24.6 PL/SQL和数据库实例内存

24.6.1 SGA、PGA和UGA

24.6.2 游标、内存及其他

24.6.3 减少内存使用的技巧

24.6.4 内存用光了怎么办

24.7 原生式编译

24.7.1 什么时候使用解释模式

24.7.2 什么时候使用原生模式

24.7.3 原生编译和数据库版本

24.8 一些须知

第25章 PL/SQL的全球化和本地化

25.1 概述和术语

25.2 Unicode入门

25.2.1 国家字符集的数据类型

25.2.2 字符编码

25.2.3 和全球化支持相关的参数

25.2.4 Unicode函数

25.3 字符语义

25.4 字符串排序顺序

25.4.1 二进制排序

25.4.2 单语言排序

25.4.3 多语言排序

25.5 多语言信息检索

25.5.1 信息检索和PL/SQL

25.6 日期/时间

25.6.1 时间戳数据类型

25.6.2 日期/时间格式

25.7 货币转换

25.8 PL/SQL的全球化开发工具箱

25.8.1 UTL_I18N工具包

25.8.2 UTL_LMS异常处理包

25.8.3 GDK实现选项

第26章 PL/SQL的面向对象特性

26.1 Oracle对象特性的介绍

26.2 对象类型示例

26.2.1 创建一个基类

26.2.2 创建子类型

26.2.3 方法

26.2.4 在Oracle数据库11g及以后版本中调用父类的方法

26.2.5 保存、提取、使用持久化对象

26.2.6 演变和创建

26.2.7 回到指针吗？

26.2.8 泛化数据：ANY类型

26.2.9 我们自己做

26.2.10 对象的比较

26.3 对象视图

26.3.1 一个关系型系统的示例

26.3.2 带有集合属性的对象视图

26.3.3 对象子视图

26.3.4 带有反关系的对象视图

26.3.5 INSTEAD OF触发器

26.3.6 对象视图和对象表的区别

26.4 维护对象类型和对象视图

26.4.1 数据字典

26.4.2 权限

26.5 来自一个关系开发者的总结思考（C551, E1200）

第27章 从PL/SQL中调用Java

27.1 Oracle和Java

27.2 准备好在Oracle中使用Java

27.2.1 安装Java

27.2.2 创建和编译我们的Java代码

27.2.3 设置Java开发和执行的权限

27.3 一个简单的演示

27.3.1 查找Java功能

27.3.2 创建一个自定义Java类

27.3.3 编译和加载到Oracle

27.3.4 创建一个PL/SQL的包装器

27.3.5 从PL/SQL删除文件

27.4 使用loadjava

27.5 使用dropjava

27.6 管理数据库中的Java

27.6.1 Oracle中的Java命名空间

27.6.2 检查加载的Java元素

27.7 使用DBMS_JAVA

27.7.1 LONGNAME：转换Java长名字

27.7.2 GET_、SET_和RESET_COMPILER_OPTION：得到和设置（一些）编译器选项

27.7.3 SET_OUTPUT：允许从Java中输出

27.7.4 EXPORT_SOURCE、EXPORT_RESOURCE和EXPORT_CLASS：导出模式对象

27.8 在PL/SQL中发布与使用Java

27.8.1 调用规范

27.8.2 一些调用规范的规则

27.8.3 映射数据类型

27.8.4 在SQL中调用Java方法

27.8.5 Java的异常处理

27.8.6 扩展文件I/O功能

27.8.7 其他示例

第28章 外部过程

28.1 外部过程介绍

28.1.1 示例：调用一个系统命令

28.1.2 外部过程的架构

28.2 Oracle网络配置

28.2.1 定义监听配置

28.2.2 配置的安全特性

28.3 设置多线程模式

28.4 创建一个Oracle库

28.5 编写调用规范

28.5.1 调用规范：整体语法

28.5.2 参数映射：示例重温

28.5.3 参数映射：完整的内容

28.5.4 更多的语法：参数子句

28.5.5 参数属性

28.6 从调用的C程序中引发一个异常

28.7 非默认的代理

28.8 维护外部过程

28.8.1 删除库

28.8.2 数据字典

28.8.3 规则和警示

附录A 正则表达式元字符和函数参数

A.1 元字符

A.2 函数与参数

A.2.1 正则表达式函数

A.2.2 正则表达式参数

附录B 数字格式模型

B.1 指明货币单位

附录C 日期格式模型