在PL / SQL编程语言是由Oracle公司在80年代末期为SQL程序扩展语言和Oracle关系数据库开发。以下是关于PL / SQL值得注意的事实：
PL / SQL是完全可移植的，高性能的事务处理语言。
PL / SQL提供了一个内置的解释和独立于操作系统的编程环境。
PL / SQL也可以直接在命令行SQL * Plus接口来调用。
直接呼叫也可以从外部编程语言调用数据库制成。
PL / SQL的一般语法是基于ADA和Pascal编程语言。
除了甲骨文，PL / SQL中的TimesTen内存数据库和IBM DB2可用。
PL / SQL - 环境设置
PL / SQL是不是一个独立的编程语言;它是Oracle编程环境中的工具。 SQL * Plus是一个互动的工具，它允许你在命令提示符下键入SQL和PL / SQL语句。这些命令被发送到数据库进行处理。一旦语句被处理，结果被发回，并在屏幕上显示出来。
要运行PL / SQL程序，你应该安装在你的机器的Oracle RDBMS服务器将采取执行SQL命令的照顾。最近的Oracle RDBMS的版本是11克。您可以从下面的链接的Oracle 11g的试用版：
你将不得不要么下载32位或安装按你的操作系统的64位版本。通常有两个文件，因为我已经下载了64位的Windows7。您还将使用您的操作系统类似的步骤，如果是Linux或Solaris无所谓。
win64_11gR2_database_1of2.zip
win64_11gR2_database_2of2.zip
上述两个文件下载后，您将需要解压他们在一个单一的目录数据库下，你会发现下面的子目录：
最后，点击安装文件开始安装，并按照给定的步骤，直到结束。如果一切都已经成功地做到那么它的时间来验证您的安装。在命令提示符，如果你使用的是Windows使用以下命令： sqlplus "/ as sysdba"
如果一切正常，你应该有SQL提示，你会写你的PL / SQL命令和脚本：
文本编辑器
从运行命令提示符大型程序可能会降落在你不经意间失去了一些工作。因此，一个更好的选择是使用命令文件。要使用命令文件：
在文本编辑器中键入你的代码，如记事本，记事本+，或EditPlus的，等等。
该文件在主目录中的.sql扩展名保存。
启动SQL * Plus命令提示符从创建你的PL / SQL文件的目录。
键入@file_name在SQL * Plus命令提示符下执行程序。
如果您不使用文件来执行PL / SQL脚本，然后简单地复制你的PL / SQL代码，然后右键点击有黑色窗口SQL提示符并使用粘贴选项在命令提示符下粘贴完整代码。最后，只需按enter键来执行代码，如果尚未执行它。
PL / SQL - 基本语法
PL / SQL是一块结构语言，即PL / SQL程序被划分和写入的代码的逻辑块。每块由三个子部分组成：
| SN | 段和说明 |
|---|---|
| 1 | 声明 本节以关键字声明开始。它是一个可选部分，并且限定在程序中使用的所有变量，游标，子程序，和其他元素。 |
| 2 | 可执行命令 这部分是封闭的关键字， 开始和结束 ，这是一个强制性的部分。它包括程序的可执行PL / SQL语句。它应具有的代码的至少一个可执行线，这可能只是一个NULL命令以指示什么都不执行。 |
| 3 | 异常处理 本节以关键字EXCEPTION开始。本节又是可选的，包含在程序处理错误异常（S）。 |
每一个PL / SQL语句都以分号（;）结束。 PL / SQL块可以被嵌套使用BEGIN和END等PL / SQL块中。下面是一个PL / SQL块的基本结构：
DECLARE <declarations section> BEGIN <executable command(s)> EXCEPTION <exception handling> END;
在'世界您好'示例：
DECLARE message varchar2(20):= 'Hello, World!'; BEGIN dbms_output.put_line(message); END; /
结束;行通知PL / SQL块的结束。要运行从SQL命令行的代码，你可能需要在代码的最后一行之后，键入/在第一个空行的开头。当上面的代码在SQL提示符下执行，它会产生以下结果：
Hello World PL/SQL procedure successfully completed.
PL / SQL - 数据类型
PL / SQL变量，常量和参数必须有其指定的存储格式，约束和值的有效范围有效的数据类型。本教程将带您在PL / SQL和其他两种数据类型提供标量和LOB数据类型将在其他章节覆盖。
| 类别 | 描述 |
|---|---|
| 纯量 | 没有内部部件，如数字，日期或布尔单个值。 |
| 大对象（LOB） | 指针从其他数据项，诸如文本，图像，视频剪辑和声音波形分开储存大对象。 |
| 综合 | 具有可单独访问的内部组件的数据项。例如，收集和记录。 |
| 参考 | 指向其他数据项。 |
PL / SQL标量数据类型和子类型
PL / SQL标量数据类型及亚型受到以下几大类：
| 日期类型 | 描述 |
|---|---|
| 数字 | 在其上执行的算术运算的数值。 |
| 字符 | 代表单个字符或字符字符串字母数字值。 |
| 布尔 | 在其上执行的逻辑运算的逻辑值。 |
| 约会时间 | 日期和时间。 |
PL / SQL提供的数据类型的子类型。例如，数据类型NUMBER有一个名为INTEGER亚型。您可以使用亚型在PL / SQL程序，使数据类型与在其他程序中的数据类型兼容，而在另一个程序中嵌入PL / SQL代码，比如Java程序。
PL / SQL数字数据类型和子类型
以下是PL / SQL预定义的数字数据类型及其子类型的详细信息：
| 数据类型 | 描述 |
|---|---|
| PLS_INTEGER | 通过在2,147,483,647 2,147,483,648范围内有符号整数，以32位代表 |
| BINARY_INTEGER | 通过在2,147,483,647 2,147,483,648范围内有符号整数，以32位代表 |
| BINARY_FLOAT | 单精度IEEE 754格式的浮点数 |
| BINARY_DOUBLE | 双精度IEEE 754格式的浮点数 |
| NUMBER（PREC，刻度） | 定点或浮点数字与在范围1E-130（但不包括）绝对值1.0E126。有多个变量也可以代表0。 |
| DEC（PREC，刻度） | ANSI特定的固定点类型具有38位十进制数字最大精度。 |
| DECIMAL（PREC，刻度） | IBM特定的固定点类型具有38位十进制数字最大精度。 |
| NUMERIC（预，黑麦） | 浮动式与38位十进制数字最大精度。 |
| DOUBLE PRECISION | ANSI特定浮点型与126位二进制数字最大精度（约38位十进制数） |
| 浮动 | ANSI和IBM特定的浮点型与126个二进制位（约38位十进制数字）最大精度 |
| INT | ANSI特定整数类型具有38位十进制数字最大精度 |
| 整数 | ANSI和IBM特定整数类型具有38位十进制数字最大精度 |
| SMALLINT | ANSI和IBM特定整数类型具有38位十进制数字最大精度 |
| 真实 | 浮点型与63位二进制数字最大精度（约18位十进制数） |
下面是一个有效的声明：
DECLARE num1 INTEGER; num2 REAL; num3 DOUBLE PRECISION; BEGIN null; END; /
当上述代码被编译和执行时，它产生了以下结果：
PL/SQL procedure successfully completed
PL / SQL字符数据类型和子类型
以下是PL / SQL预先定义的字符数据类型和其子类型的细节：
| 数据类型 | 描述 |
|---|---|
| CHAR | 定长字符串的32,767个字节的最大大小 |
| VARCHAR2 | 变长字符串的32,767个字节的最大大小 |
| 生的 | 可变长度的二进制或字节字符串32,767字节的最大容量，不是由PL / SQL解释 |
| NCHAR | 固定长度的民族性格字符串的32,767个字节的最大大小 |
| NVARCHAR2 | 可变长度民族性字符串的32,767个字节的最大大小 |
| 长 | 变长字符串的32,760字节的最大尺寸 |
| LONG RAW | 可变长度的二进制或字节字符串的32,760字节的最大容量，不是由PL / SQL解释 |
| ROWID | 物理行标识符，行的在一个普通的表的地址 |
| UROWID | 环球行标识符（物理，逻辑或外国行标识符） |
PL / SQL布尔数据类型
这在逻辑操作中使用布尔数据类型存储逻辑值。逻辑值是布尔值的真假NULL值。
但是，SQL没有数据类型等同于布尔。因此，逻辑值不能用于：
SQL语句
内置SQL函数（例如TO_CHAR）
从SQL语句调用PL / SQL函数
PL / SQL datetime和间隔类型
日期数据类型来存储固定长度的日期时间，其中包括从午夜开始一天的秒数。有效日期范围为4712年1月1 BC到12月31日，公元9999。
默认的日期格式是由Oracle初始化参数NLS_DATE_FORMAT设定。例如，默认的可以是“DD-MON-YY'，其包括用于该月的一天的两位数字，月份名称的缩写，和年的最后两位数字，例如，01- OCT-12。
每个日期包括世纪，年，月，日，小时，分钟和秒。下表显示了每个字段的有效值：
| 字段名称 | 有效日期时间值 | 有效的时间间隔值 |
|---|---|---|
| 年 | -4712〜9999（不含一年0） | 任何非零整数 |
| 月 | 01到12 | 0至11 |
| 天 | 01到31（按年份和月份的数值限制，根据日历区域设置的规则） | 任何非零整数 |
| 小时 | 00〜23 | 0到23 |
| 分钟 | 00〜59 | 0到59 |
| 第二 | 00至59.9（n），其中9（n）是时间小数秒精度 | 0至59.9（n），其中9（n）是间隔小数秒精度 |
| TIMEZONE_HOUR | -12到14（范围适应夏令时的变化） | 不适用 |
| TIMEZONE_MINUTE | 00〜59 | 不适用 |
| TIMEZONE_REGION | 发现在动态性能视图V $ TIMEZONE_NAMES | 不适用 |
| TIMEZONE_ABBR | 发现在动态性能视图V $ TIMEZONE_NAMES | 不适用 |
PL / SQL大型对象（LOB）数据类型
大对象（LOB）数据类型是指大到数据项，如文本，图像，视频剪辑和声音波形。 LOB数据类型实现高效，随机，分段对这些数据的访问。以下是预定义的PL / SQL LOB数据类型：
| 数据类型 | 描述 | 尺寸 |
|---|---|---|
| BFILE | 用于大型二进制对象存储在运行数据库以外的系统文件。 | 依赖于系统的。不能超过4千兆字节（GB）。 |
| BLOB | 用于大型二进制对象存储在数据库中。 | 8至128千兆字节（TB） |
| CLOB | 用于字符大块数据存储在数据库中。 | 8至128 TB |
| NCLOB | 用于NCHAR大块数据存储在数据库中。 | 8至128 TB |
PL / SQL用户定义的亚型
A亚型是另一种数据类型，这是所谓的基本类型的子集。 A亚型具有相同的有效操作作为其基底的类型，但只有其有效值的子集。
PL / SQL预定义的配套标准若干亚型。例如，PL / SQL预定义了亚型CHARACTER和INTEGER如下：
SUBTYPE CHARACTER IS CHAR; SUBTYPE INTEGER IS NUMBER(38,0);
您可以定义和使用自己的亚型。下面的程序说明了定义和使用用户定义的子类型：
DECLARE
SUBTYPE name IS char(20);
SUBTYPE message IS varchar2(100);
salutation name;
greetings message;
BEGIN
salutation := 'Reader ';
greetings := 'Welcome to the World of PL/SQL';
dbms_output.put_line('Hello ' || salutation || greetings);
END;
/
当上述代码在SQL提示符执行时，它产生了以下结果：
Hello Reader Welcome to the World of PL/SQL PL/SQL procedure successfully completed.
在PL / SQL的NULL
的PL / SQL空值表示缺失的或未知的数据和它们不是一个整数，字符，或任何其他特定的数据类型。注意，NULL不是相同空数据串或空字符值' 0'。空可以分配，但它不能与任何东西等同，包括它本身。
PL / SQL - 变量
一个PL / SQL变量的名称由后面可以跟更多的字母，数字，美元符号，下划线和数字符号的一封信和应不超过30个字符。默认情况下，变量名是不区分大小写。不能使用保留的PL / SQL关键字作为变量名。
在PL / SQL变量声明
PL / SQL变量必须在声明部分或一个包作为一个全局变量来声明。当你声明一个变量，PL / SQL分配内存变量的值和存储位置由变量名称标识。
对于声明一个变量的语法是：
variable_name [CONSTANT] datatype [NOT NULL] [:= | DEFAULT initial_value]
其中， 变量名是PL / SQL有效的标识符， 数据类型必须是有效的PL / SQL数据类型或者我们已经在上一章中讨论的任何用户定义的数据类型。与他们一起定义了一些有效的变量声明如下所示：
sales number(10, 2); pi CONSTANT double precision := 3.1415; name varchar2(25); address varchar2(100);
当您提供的数据类型的大小，缩放或精度的限制，它被称为约束的声明 。约束的声明需要比不受约束的声明更少的内存。例如：
sales number(10, 2); name varchar2(25); address varchar2(100);
在PL初始化变量/ SQL
当你声明一个变量，PL / SQL为其分配默认值为NULL值。如果您要初始化比NULL值以外的值的变量，你可以声明中这样做，使用下列的：
DEFAULT关键字
赋值运算符
例如：
counter binary_integer := 0; greetings varchar2(20) DEFAULT 'Have a Good Day';
您还可以指定一个变量不应该使用NOT NULL约束NULL值。如果您使用NOT NULL约束，必须明确指定该变量的初始值。
这是一个良好的编程习惯初始化变量正确的，否则，有时程序会产生意想不到的结果。试试下面的例子利用多种类型的变量：
DECLARE
a integer := 10;
b integer := 20;
c integer;
f real;
BEGIN
c := a + b;
dbms_output.put_line('Value of c: ' || c);
f := 70.0/3.0;
dbms_output.put_line('Value of f: ' || f);
END;
/
当执行上面的代码，它产生了以下结果：
Value of c: 30 Value of f: 23.333333333333333333 PL/SQL procedure successfully completed.
在PL / SQL变量的作用域
PL / SQL允许块的嵌套，也就是说，每个程序块可以包含其他内部块。如果一个变量的内部块中声明，它是不给外部块访问。然而，如果一个变量声明和可访问到的外座，它也给所有嵌套内部块访问。有两种类型的可变范围的：
局部变量 -在内部块声明和外块不能访问的变量。
全局变量 -在最外层块或包中声明的变量。
以下示例显示了其简单的形式局部和全局变量的用法：
DECLARE
-- Global variables
num1 number := 95;
num2 number := 85;
BEGIN
dbms_output.put_line('Outer Variable num1: ' || num1);
dbms_output.put_line('Outer Variable num2: ' || num2);
DECLARE
-- Local variables
num1 number := 195;
num2 number := 185;
BEGIN
dbms_output.put_line('Inner Variable num1: ' || num1);
dbms_output.put_line('Inner Variable num2: ' || num2);
END;
END;
/
当执行上面的代码，它产生了以下结果：
Outer Variable num1: 95 Outer Variable num2: 85 Inner Variable num1: 195 Inner Variable num2: 185 PL/SQL procedure successfully completed.
PL / SQL - 常量和文字
恒定认为，一旦申报了价值，在节目中不会改变。常量声明指定了自己的名字，数据类型和价值，并为它分配存储空间。宣言还可以强制NOT NULL约束。
声明一个常数
常量使用常量关键字声明。它需要一个初始值，并且不允许被改变该值。例如：
PI CONSTANT NUMBER := 3.141592654;
DECLARE
-- constant declaration
pi constant number := 3.141592654;
-- other declarations
radius number(5,2);
dia number(5,2);
circumference number(7, 2);
area number (10, 2);
BEGIN
-- processing
radius := 9.5;
dia := radius * 2;
circumference := 2.0 * pi * radius;
area := pi * radius * radius;
-- output
dbms_output.put_line('Radius: ' || radius);
dbms_output.put_line('Diameter: ' || dia);
dbms_output.put_line('Circumference: ' || circumference);
dbms_output.put_line('Area: ' || area);
END;
/
当上述代码在SQL提示符执行时，它产生了以下结果：
Radius: 9.5 Diameter: 19 Circumference: 59.69 Area: 283.53 Pl/SQL procedure successfully completed.
在PL / SQL字面
文本是一个明确的数字，字符，字符串或布尔值不是一个标识符表示。例如，TRUE，786，NULL'tutorialspoint'是布尔类型，数字或字符串的所有文字。 PL / SQL，文字是区分大小写的。 PL / SQL支持以下几种类型的文字：
数字文字
字符文字
字符串字面
布尔文字
日期和时间文字
| 文字类型 | 例： |
|---|---|
| 数字文字 | 050 78 -14 0 +32767 6.6667 0.0 -12.0 3.14159 7800.00 6E5 1.0E-8 3.14159e0 -1E38 -9.5e-3 |
| 字符文字 | 'A''％''9''''Z''（' |
| 字符串字面 | '你好，世界！' “教程点” '19 -nov-12' |
| 布尔文字 | TRUE，FALSE和NULL。 |
| 日期和时间文字 | DATE'1978年12月25日“; TIMESTAMP“2012年10月29日12时01分01秒”; |
要在字符串中嵌入单引号，将两个单引号相邻，如下图所示：
DECLARE message varchar2(20):= 'That''s tutorialspoint.com!'; BEGIN dbms_output.put_line(message); END; /
当上述代码在SQL提示符执行时，它产生了以下结果：
That's tutorialspoint.com! PL/SQL procedure successfully completed.
PL / SQL - 操作员
运算符是告诉执行特定数学或逻辑运算的编译器的符号。 PL / SQL语言是丰富的内置运营商，并提供以下类型的运算符：
算术运算符
关系运算符
比较运算符
逻辑运算符
字符串运算符
本教程将介绍算术，关系比较和逻辑运算符一个接一个。弦乐运营商将在本章下进行讨论：PL / SQL -字符串 。
算术运算符
下表列出了所有的PL / SQL支持的算术运算符。假设变量A持有10和变量B持有5则：
| 操作者 | 描述 | 例 |
|---|---|---|
| + | 再添两个操作数 | A + B将给予15 |
| - | 减去来自第一第二操作数 | A - B就给予5 |
| * | 相乘两个操作数 | A * B将给予50 |
| / | 通过去分子除以分母 | A / B将给予2 |
| ** | 乘方运算，提出了一个操作数为其他电源 | A ** B就给予100000 |
关系运算符
关系运算符比较两个表达式或值，并返回一个布尔结果。下表列出了所有的PL / SQL支持的关系运算符。假设变量A持有10和变量B持有20，则：
| 操作者 | 描述 | 例 |
|---|---|---|
| = | 检查，如果两个操作数的值相等与否，如果是，则条件变为真。 | （A = B）是不正确的。 |
| ！= <> 〜= | 检查，如果两个操作数的值相等与否，如果值不相等，则条件变为真。 | （A！= B）为真。 |
| > | 检查左操作数的值大于右操作数的值，如果是，则条件为真。 | （A> B）是不正确的。 |
| < | 检查左操作数的值小于右操作数的值，如果是，则条件为真。 | （A <B）为真。 |
| > = | 检查左操作数的值大于或等于右边的操作数的值，如果是，则条件为真。 | （A> = B）是不正确的。 |
| <= | 检查左操作数的值小于或等于右边的操作数的值，如果是，则条件为真。 | （A <= B）为真。 |
比较运算符
比较运算符用于一个表达比较到另一个。结果始终是TRUE，FALSE或NULL。
| 操作者 | 描述 | 例 |
|---|---|---|
| 喜欢 | LIKE操作符的字符，字符串或CLOB值与一个模式，如果这个值，如果它不匹配模式和FALSE返回TRUE。 | 如果“扎拉阿里”像'Z％A_I'返回一个true，而“努哈阿里'像'Z％A_I'返回布尔值false。 |
| 之间 | BETWEEN运算测试是否价值在于在规定范围内。点¯xa和b之间意味着x> = A和X <= B。 | 如果x = 10然后，×11和20返回假之间返回5和20之间的真正中，x回报5和10之间真实的，但X]。 |
| 在 | IN操作符测试集合成员资格。中的X（组）表示x等于组的任何成员。 | 如果x ='M'，那么，X在（'A'，'B'，'C'）返回布尔值false但在X（'M'，'N'，'O'）返回布尔真值。 |
| IS NULL | 在IS NULL操作者如果操作数为NULL或FALSE，如果它不为空返回布尔值true。涉及NULL值的比较总是产生NULL。 | 如果x ='M'，那么'x是空'返回布尔假的。 |
逻辑运算符
下表显示了PL / SQL支持的逻辑运算。所有这些操作符布尔运算工作，并产生布尔结果。假设变量A持有真实变量B持有假的，那么：
| 操作者 | 描述 | 例 |
|---|---|---|
| 和 | 所谓逻辑AND运算。如果两个操作数为真，则条件为真。 | （A和B）是假的。 |
| 要么 | 所谓逻辑或操作。如果任何两个操作数为真，那么条件变为真。 | （A或B）为真。 |
| 不 | 所谓逻辑NOT操作。用来扭转操作数的逻辑状态。如果条件为真，那么逻辑非运算符将使它假的。 | 没有（A和B）是真实的。 |
PL / SQL运算符优先级
运算符优先级决定术语的表达分组。这会影响一个表达式是如何计算。某些运营商比其他人更高的优先级;例如，乘法运算符具有比加法运算符更高的优先级：
例如X = 7 + 3 * 2;这里，x被分配13，而不是20因为操作员*具有优先级高于+，所以它首先被用3 * 2相乘，然后添加到7。
这里具有最高优先级操作员出现在表的顶部，那些具有最低出现在底部。在一个表达式，更高的优先级运营商将首先计算。
| 操作者 | 手术 |
|---|---|
| ** | 幂 |
| +， - | 身份，否定 |
| *，/ | 乘法，除法 |
| +， - ， - || | 加，减，并置 |
| =，<，>，<=，> =，<>，！=，=〜^ =， IS NULL，LIKE，BETWEEN，IN | 对照 |
| 不 | 逻辑否定 |
| 和 | 连词 |
| 要么 | 包容 |
PL / SQL - 条件
决策结构需要程序员指定要评估或由程序进行测试的一个或多个的条件下，用一条或多条语句一起被执行，如果确定条件是真实的，以及任选，如果要执行的其它语句条件被确定为假的。
IF-THEN声明
它是IF控制声明，在决策和改变节目执行的控制流经常使用的最简单的形式。
IF语句由关键字THEN和END IF封闭的语句序列相关联的条件。如果条件为真 ，语句被执行，如果条件为FALSE或NULL，那么IF语句什么都不做。
句法：
语法IF-THEN语句是：
IF condition THEN S; END IF;
其中， 条件是一个布尔或关系条件，S是简单或复合语句。一个IF-THEN语句的例子是：
IF (a <= 20) THEN c:= c+1; END IF;
如果布尔表达式条件计算结果为真，那么if语句内的代码块将被执行。如果布尔表达式的if语句结束后计算为false，那么第一套代码（如果收盘结束后）将被执行。
流程图：
IF-THEN-ELSE声明
的IF-THEN语句后面可以跟ELSE语句，当条件为假其中执行的可选序列的序列。
句法：
语法IF-THEN-ELSE语句是：
IF condition THEN S1; ELSE S2; END IF;
其中，S1和S2是语句的不同序列。在IF-THEN-ELSE语句，当测试条件为TRUE，则该语句S1被执行和S2被跳过;当测试条件为FALSE，那么S1被忽略，被执行的语句S2。例如，
IF color = red THEN
dbms_output.put_line('You have chosen a red car')
ELSE
dbms_output.put_line('Please choose a color for your car');
END IF;
如果布尔表达式条件计算结果为真，那么IF-THEN代码块将被执行，否则代码else块将被执行。
流程图：
IF-THEN-ELSIF声明
在IF-THEN-ELSIF语句可以几个备选方案之间进行选择。一个IF-THEN语句可以跟着一个可选的ELSIF ... else语句。该ELSIF子句允许您添加附加条件。
当使用IF-THEN-ELSIF语句有几点要牢记。
这ELSIF，不是ELSEIF
一个IF-THEN语句可以有零个或一个人的，它必须跟从任何ELSIF的。
一个IF-THEN语句可以有0到多个ELSIF的，他们必须出现在人之前。
一旦成功ELSIF，没有其余ELSIF的，否则的将受到考验。
句法：
在PL / SQL编程语言中的IF-THEN-ELSIF语句的语法是：
IF(boolean_expression 1)THEN S1; -- Executes when the boolean expression 1 is true ELSIF( boolean_expression 2) THEN S2; -- Executes when the boolean expression 2 is true ELSIF( boolean_expression 3) THEN S3; -- Executes when the boolean expression 3 is true ELSE S4; -- executes when the none of the above condition is true END IF;
CASE语句
像IF语句，CASE语句选择要执行的语句一个序列。但是，选择顺序，CASE语句使用一个选择而不是多个布尔表达式。选择器是一个表达式，其值被用来选择几种选择中的一个。
句法：
在PL case语句的语法/ SQL是：
CASE selector
WHEN 'value1' THEN S1;
WHEN 'value2' THEN S2;
WHEN 'value3' THEN S3;
...
ELSE Sn; -- default case
END CASE;
流程图：
搜索CASE语句
CASE搜索语句没有选择和WHEN子句包含给布尔值的搜索条件。
句法：
在PL搜查case语句的语法/ SQL是：
CASE
WHEN selector = 'value1' THEN S1;
WHEN selector = 'value2' THEN S2;
WHEN selector = 'value3' THEN S3;
...
ELSE Sn; -- default case
END CASE;
流程图：
嵌套IF-THEN-ELSE语句
它总是在PL / SQL编程法律嵌套的if-else语句，这意味着你可以使用一个IF 否则IF语句在另一个IF 否则IF语句（S）。
句法：
IF( boolean_expression 1)THEN
-- executes when the boolean expression 1 is true
IF(boolean_expression 2) THEN
-- executes when the boolean expression 2 is true
sequence-of-statements;
END IF;
ELSE
-- executes when the boolean expression 1 is not true
else-statements;
END IF;
PL / SQL - 循环
可能有一种情况，当你需要执行的代码几次数块。在一般情况下，语句顺序执行：在一个函数的第一个语句首先执行，然后是第二个，等等。
编程语言提供了各种控制结构，使更多的复杂的执行路径。
循环语句可以让我们执行的语句多次声明或组，下面是大多数编程语言的循环语句的一般形式：
基本的循环语句
基本循环结构包围在LOOP和END LOOP语句之间的语句序列。每次迭代，语句序列被执行，然后在循环的顶部控制简历。
句法：
在PL / SQL编程语言中的基本循环的语法是：
LOOP Sequence of statements; END LOOP;
在这里，声明（S）的顺序可以是单个语句或语句块。 EXIT指令或要求语句来打破循环出口。
WHILE循环语句
在PL / SQL编程语言while循环语句只要给定条件为真，重复执行的目标声明。
句法：
WHILE condition LOOP sequence_of_statements END LOOP;
FOR循环语句
for循环是一个循环控制结构，可以有效地编写一个循环，需要执行的特定次数。
句法：
FOR counter IN initial_value .. final_value LOOP sequence_of_statements; END LOOP;
以下是PL / SQL循环的一些特点：
该initial_value和循环变量或柜台 final_value可以文字，变量或表达式，但必须评估为数字。否则，PL / SQL就会抛出预定义异常VALUE_ERROR。
该initial_value不必为1;然而， 循环计数器增量（或减量）必须为1。
PL / SQL允许动态地确定在运行时的循环范围。
嵌套循环
PL / SQL允许使用的另一循环内一个循环。下文将介绍几个例子来说明这一概念。
在PL / SQL嵌套基本LOOP语句的语法如下：
LOOP
Sequence of statements1
LOOP
Sequence of statements2
END LOOP;
END LOOP;
FOR在PL / SQL LOOP语句嵌套的语法如下：
FOR counter1 IN initial_value1 .. final_value1 LOOP
sequence_of_statements1
FOR counter2 IN initial_value2 .. final_value2 LOOP
sequence_of_statements2
END LOOP;
END LOOP;
在帕斯卡嵌套WHILE循环语句的语法如下：
WHILE condition1 LOOP
sequence_of_statements1
WHILE condition2 LOOP
sequence_of_statements2
END LOOP;
END LOOP;
退出声明
在PL / SQL编程语言中的EXIT语句有以下两种用法：
当一个循环内遇到EXIT语句，循环立即终止，程序控制继续在循环之后的下一条语句。
如果您是使用嵌套循环（即彼此循环内循环），EXIT指令将停止内部循环的执行，并开始块之后执行的下一行代码。
句法：
在PL / SQL中的EXIT语句的语法如下：
EXIT;
流程图：
continue语句
continue语句使循环跳过它的身体的其余部分，并立即重申之前重新测试其状态。换句话说，它迫使循环的下一次迭代中发生，跳过在之间的任何代码。
句法：
对于continue语句的语法如下：
CONTINUE;
流程图：
GOTO语句
在PL / SQL编程语言中的GOTO语句提供了从GOTO到带标签的语句在同一个子程序的无条件跳转。
注：GOTO语句使用任何编程语言是高度沮丧，因为它使得难以追踪程序的控制流，使程序难以理解和难以修改。使用一个GOTO任何程序可以改写，以便它不需要GOTO。
句法：
在PL / SQL中的GOTO语句的语法如下：
GOTO label; .. .. << label >> statement;
流程图：
PL / SQL - 字符串
在PL / SQL字符串实际上是字符的一个可选尺寸规格的序列。字符可以是数字，字母，空白，特殊字符或所有的组合。 PL / SQL提供了三种字符串：
固定长度的字符串 ：在这样的字符串，程序员指定长度，同时宣布该字符串。该字符串是右填充空格以使指定的长度。
变长字符串 ：在这样的字符串，最大长度可达32,767，字符串是指定的，没有填充发生。
字符大对象（CLOB）：这些是变长字符串，最长可达128兆兆字节。
PL / SQL字符串可以是变量或常量。字符串文字是引号括起来。例如，
'This is a string literal.' Or 'hello world'
要包含字符串内使用单引号的文字，你需要输入两个单引号彼此相邻，如：
'this isn''t what it looks like'
声明字符串变量
Oracle数据库提供了大量的数据类型的字符串，比如，CHAR，NCHAR，VARCHAR2，NVARCHAR2，CLOB和NCLOB。与“N”开头的数据类型为“国家字符集”数据类型，即存储Unicode字符数据。
如果你需要声明一个可变长度的字符串时，必须提供该字符串的最大长度。例如，VARCHAR2数据类型。下面的例子说明声明和使用一些字符串变量：
DECLARE
name varchar2(20);
company varchar2(30);
introduction clob;
choice char(1);
BEGIN
name := 'John Smith';
company := 'Infotech';
introduction := ' Hello! I''m John Smith from Infotech.';
choice := 'y';
IF choice = 'y' THEN
dbms_output.put_line(name);
dbms_output.put_line(company);
dbms_output.put_line(introduction);
END IF;
END;
/
当上述代码在SQL提示符执行时，它产生了以下结果：
John Smith Infotech Corporation Hello! I'm John Smith from Infotech. PL/SQL procedure successfully completed
要声明一个固定长度的字符串，使用CHAR数据类型。在这里，您不必指定一个固定长度可变的最大长度。如果您离开了长度的限制，Oracle数据库会自动使用所需的最大长度。所以下面的下面两个声明是相同的：
red_flag CHAR(1) := 'Y'; red_flag CHAR := 'Y';
PL / SQL - 阵列
PL / SQL程序设计语言提供了一种数据结构被称为VARRAY，其可以存储相同类型的元素的一个固定大小的连续集合。一个VARRAY用于存储数据的有序集合，但认为阵列为一体的相同类型的变量的集合是往往更为有用。
所有可变数组由连续存储单元。最低的地址对应于第一元件和最高地址的最后一个元素。
阵列是集合类型的数据的一部分，并且它代表可变大小的数组。我们将在后面的章节“PL / SQL集合”研究其他集合类型。
在一个VARRAY的每个元素具有与之相关联的索引。它还具有可以动态改变一个最大大小。
创建VARRAY类型
一个VARRAY类型是用CREATE TYPE语句创建。必须指定的最大大小，并存储在VARRAY元素的类型。
在架构层面创造一个VRRAY类型的基本语法是：
CREATE OR REPLACE TYPE varray_type_name IS VARRAY(n) of <element_type>
哪里，
varray_type_name是一个有效的属性名称，
n是VARRAY元件（最大值）的数量，
ELEMENT_TYPE是阵列中的元素的数据类型。
一个VARRAY的最大尺寸可以使用ALTER TYPE语句进行更改。
例如，
CREATE Or REPLACE TYPE namearray AS VARRAY(3) OF VARCHAR2(10); / Type created.
对于内的PL / SQL块是创建一个VRRAY类型的基本语法：
TYPE varray_type_name IS VARRAY(n) of <element_type>
例如：
TYPE namearray IS VARRAY(5) OF VARCHAR2(10); Type grades IS VARRAY(5) OF INTEGER;
PL / SQL - 过程
子程序是程序单元/模块执行特定的任务。这些子程序被组合以形成更大的程序。这基本上是被称为“模块化设计”。一个子程序可以由另一个子程序或程序被称为调用程序调用。
一个子程序可以创建：
在模式级
里面包
里面一个PL / SQL块
一个模式级子程序是一个独立的子程序 。它与CREATE PROCEDURE或CREATE FUNCTION语句创建的。它被存储在数据库中，并可以与DROP PROCEDURE或DROP FUNCTION语句被删除。
包内创建一个子程序是一个打包的子程序 。它被存储在数据库中，仅当包用DROP PACKAGE语句删除可以删除。我们将讨论在本章软件包的PL / SQL - 包“。
的PL / SQL子程序被命名为可以与一组参数被调用PL / SQL块。 PL / SQL提供两种子程序：
功能 ：这些子程序返回一个值，主要用于计算并返回一个值。
程序 ：这些子程序不直接返回，主要用于执行操作的值。
本章将介绍一个PL / SQL过程的重要方面，我们将覆盖下一章PL / SQL函数 。
一个PL / SQL子程序的零件
每个PL / SQL子程序有一个名称，并且可以具有一个参数列表。像匿名PL / SQL块，并命名块子程序也将有以下三个部分：
| SN | 零件与说明 |
|---|---|
| 1 | 声明部分 这是一个可选部分。然而，对于一个子程序声明部分不与DECLARE关键字开始。它包含的类型，游标，常量，变量，异常和子程序嵌套声明。这些项目是本地子程序和停止时，子程序完成执行存在。 |
| 2 | 可执行部分 这是一个强制性的一部分，包含执行指定的动作语句。 |
| 3 | 异常处理 这又是一个可选的部分。它包含处理运行时错误的代码。 |
创建过程
的过程是用CREATE OR REPLACE PROCEDURE语句创建的。为CREATE OR REPLACE PROCEDURE语句的简化的语法如下：
CREATE [OR REPLACE] PROCEDURE procedure_name
[(parameter_name [IN | OUT | IN OUT] type [, ...])]
{IS | AS}
BEGIN
< procedure_body >
END procedure_name;
哪里，
程序-name指定过程的名称。
[OR REPLACE]选项允许修改现有的程序。
可选的参数列表包含名称，模式和类型的参数。在表示该值将来自外部的传递和OUT表示该参数将被用于该过程的外面返回一个值。
过程的主体部分包含可执行部分。
AS关键字来代替在IS关键字创建一个独立的过程。
PL / SQL - 功能
PL / SQL的功能是一样的，除了它返回一个值的过程。
创建函数
使用CREATE FUNCTION语句创建一个独立的功能。为CREATE OR REPLACE PROCEDURE语句的简化的语法如下：
CREATE [OR REPLACE] FUNCTION function_name
[(parameter_name [IN | OUT | IN OUT] type [, ...])]
RETURN return_datatype
{IS | AS}
BEGIN
< function_body >
END [function_name];
哪里，
函数名指定函数的名称。
[OR REPLACE]选项允许修改现有的功能。
可选的参数列表包含名称，模式和类型的参数。在表示该值将来自外部的传递和OUT表示该参数将被用于该过程的外面返回一个值。
RETURN子句指定数据类型你会从函数返回。
函数体包含了可执行的部分。
函数体必须包含一个return语句 。
AS关键字被用来代替IS关键字来创建一个独立的函数。
PL / SQL - 游标
甲骨文创建的存储区，被称为上下文区域，用于处理SQL语句，其中包含所需的处理语句，例如所有的信息，行数处理等。
游标是一个指向此背景下区域。 PL / SQL控制通过游标上下文区域。游标持有的行通过SQL语句返回（一个或多个）。行集光标保持的被称为活动组 。
可以命名一个光标，以便它可以在程序中获取和处理由SQL语句，一次一个返回的行中提及。有两种类型的光标：
隐式游标
显式游标
隐式游标
每当执行SQL语句的时候，有对语句没有显式游标隐式游标自动由Oracle创建。程序员无法控制隐式游标，并在它的信息。
每当一个DML语句（INSERT，UPDATE和DELETE）发出后，隐式游标与此语句关联。对于INSERT操作，光标认为需要插入的数据。对于UPDATE和DELETE操作，光标标识会受到影响的行。
在PL / SQL，你可以参考最近的隐式游标的SQL游标 ，它总是有类似％FOUND，％ISOPEN，％NOTFOUND和％ROWCOUNT属性。 SQL游标有额外的属性，％BULK_ROWCOUNT和％BULK_EXCEPTIONS，设计用于FORALL语句中使用。
显式游标
显式游标是获得对上下文区域更多的控制程序员定义游标。显式游标应在PL / SQL块的声明部分中定义。它是在SELECT语句返回多个行创建。
创建显式游标的语法是：
CURSOR cursor_name IS select_statement;
用显式游标工作包括四个步骤：
声明光标在存储器初始化
打开游标分配内存
获取光标用于检索数据
关闭游标来释放内存分配
声明游标
声明游标定义游标的名称和相关的SELECT语句。例如：
CURSOR c_customers IS SELECT id, name, address FROM customers;
打开游标
打开游标游标分配内存，使得它已经准备好获取由SQL语句到它返回的行。例如，我们将按照下列步骤打开上面定义光标：
OPEN c_customers;
获取光标
获取光标涉及一次访问一行。例如，我们会从上面打开的游标如下读取行：
FETCH c_customers INTO c_id, c_name, c_addr;
关闭游标
关闭游标来释放分配的内存。例如，我们将紧跟上面打开的游标：
CLOSE c_customers;
例：
下面是一个完整的例子来说明明确游标的概念：
DECLARE
c_id customers.id%type;
c_name customers.name%type;
c_addr customers.address%type;
CURSOR c_customers is
SELECT id, name, address FROM customers;
BEGIN
OPEN c_customers;
LOOP
FETCH c_customers into c_id, c_name, c_addr;
dbms_output.put_line(c_id || ' ' || c_name || ' ' || c_addr);
EXIT WHEN c_customers%notfound;
END LOOP;
CLOSE c_customers;
END;
/
当上述代码在SQL提示符执行时，它产生了以下结果：
1 Ramesh Ahmedabad 2 Khilan Delhi 3 kaushik Kota 4 Chaitali Mumbai 5 Hardik Bhopal 6 Komal MP PL/SQL procedure successfully completed.
PL / SQL - 记录
PL / SQL 记录是一种数据结构，可以容纳不同种类的数据项。记录由不同的领域，类似于数据库表中的一排。
的PL / SQL可以处理以下类型的记录：
基于表格的
基于游标的记录
用户自定义记录
基于表的记录
该ROWTYPE％属性使程序员创建基于光标 表型和记录。
下面的例子将说明的基于表的记录的概念。我们将使用我们已经创建，并在前面的章节中使用CUSTOMERS表：
DECLARE
customer_rec customers%rowtype;
BEGIN
SELECT * into customer_rec
FROM customers
WHERE id = 5;
dbms_output.put_line('Customer ID: ' || customer_rec.id);
dbms_output.put_line('Customer Name: ' || customer_rec.name);
dbms_output.put_line('Customer Address: ' || customer_rec.address);
dbms_output.put_line('Customer Salary: ' || customer_rec.salary);
END;
/
当上述代码在SQL提示符执行时，它产生了以下结果：
Customer ID: 5 Customer Name: Hardik Customer Address: Bhopal Customer Salary: 9000 PL/SQL procedure successfully completed.
基于游标的记录
下面的例子可以说明的基于游标的记录的概念。我们将使用我们已经创建，并在前面的章节中使用CUSTOMERS表：
DECLARE
CURSOR customer_cur is
SELECT id, name, address
FROM customers;
customer_rec customer_cur%rowtype;
BEGIN
OPEN customer_cur;
LOOP
FETCH customer_cur into customer_rec;
EXIT WHEN customer_cur%notfound;
DBMS_OUTPUT.put_line(customer_rec.id || ' ' || customer_rec.name);
END LOOP;
END;
/
当上述代码在SQL提示符执行时，它产生了以下结果：
1 Ramesh 2 Khilan 3 kaushik 4 Chaitali 5 Hardik 6 Komal PL/SQL procedure successfully completed.
用户自定义记录
PL / SQL提供了一个用户定义的记录类型，允许你定义不同的记录结构。记录由不同的领域。假设你要跟踪你的图书馆中的书籍。你可能想跟踪有关每本书以下属性：
标题
作者
学科
图书ID
定义记录
记录类型定义为：
TYPE type_name IS RECORD ( field_name1 datatype1 [NOT NULL] [:= DEFAULT EXPRESSION], field_name2 datatype2 [NOT NULL] [:= DEFAULT EXPRESSION], ... field_nameN datatypeN [NOT NULL] [:= DEFAULT EXPRESSION); record-name type_name;
这里是你将申报书记录的方式：
DECLARE
TYPE books IS RECORD
(title varchar(50),
author varchar(50),
subject varchar(100),
book_id number);
book1 books;
book2 books;
访问字段
要访问记录的任何领域，我们使用点（。）运算。成员访问运算编码为记录变量名，我们希望访问字段之间的时间段。以下是解释记录的使用的例子：
DECLARE
type books is record
(title varchar(50),
author varchar(50),
subject varchar(100),
book_id number);
book1 books;
book2 books;
BEGIN
-- Book 1 specification
book1.title := 'C Programming';
book1.author := 'Nuha Ali ';
book1.subject := 'C Programming Tutorial';
book1.book_id := 6495407;
-- Book 2 specification
book2.title := 'Telecom Billing';
book2.author := 'Zara Ali';
book2.subject := 'Telecom Billing Tutorial';
book2.book_id := 6495700;
-- Print book 1 record
dbms_output.put_line('Book 1 title : '|| book1.title);
dbms_output.put_line('Book 1 author : '|| book1.author);
dbms_output.put_line('Book 1 subject : '|| book1.subject);
dbms_output.put_line('Book 1 book_id : ' || book1.book_id);
-- Print book 2 record
dbms_output.put_line('Book 2 title : '|| book2.title);
dbms_output.put_line('Book 2 author : '|| book2.author);
dbms_output.put_line('Book 2 subject : '|| book2.subject);
dbms_output.put_line('Book 2 book_id : '|| book2.book_id);
END;
/
当上述代码在SQL提示符执行时，它产生了以下结果：
Book 1 title : C Programming Book 1 author : Nuha Ali Book 1 subject : C Programming Tutorial Book 1 book_id : 6495407 Book 2 title : Telecom Billing Book 2 author : Zara Ali Book 2 subject : Telecom Billing Tutorial Book 2 book_id : 6495700 PL/SQL procedure successfully completed.
PL / SQL - 例外
程序执行过程中的错误情况被称为PL / SQL异常。 PL / SQL支持程序员在程序中使用异常块捕获这样的条件和适当的采取行动反对错误条件。有两种类型的异常：
系统定义异常
用户定义的异常
语法异常处理
一般语法异常处理如下。在这里，你可以列出下跌多达你想处理异常。默认的异常将使用别人的时候THEN处理：
DECLARE
<declarations section>
BEGIN
<executable command(s)>
EXCEPTION
<exception handling goes here >
WHEN exception1 THEN
exception1-handling-statements
WHEN exception2 THEN
exception2-handling-statements
WHEN exception3 THEN
exception3-handling-statements
........
WHEN others THEN
exception3-handling-statements
END;
例
让我们写一些简单的代码来说明这一概念。我们将使用我们已经创建，并在前面的章节中使用CUSTOMERS表：
DECLARE
c_id customers.id%type := 8;
c_name customers.name%type;
c_addr customers.address%type;
BEGIN
SELECT name, address INTO c_name, c_addr
FROM customers
WHERE id = c_id;
DBMS_OUTPUT.PUT_LINE ('Name: '|| c_name);
DBMS_OUTPUT.PUT_LINE ('Address: ' || c_addr);
EXCEPTION
WHEN no_data_found THEN
dbms_output.put_line('No such customer!');
WHEN others THEN
dbms_output.put_line('Error!');
END;
/
当上述代码在SQL提示符执行时，它产生了以下结果：
No such customer! PL/SQL procedure successfully completed.
上述程序显示一个客户的ID给出的名字和地址。由于没有客户在我们的数据库ID值8，该方案提高了它在EXCEPTION块捕获的运行时异常NO_DATA_FOUND。
PL / SQL - 触发器
触发器是存储程序，当一些事件发生时自动执行或解雇。触发器，事实上，写入响应于以下任一事件要执行的：
数据库操作（DML）语句（DELETE，INSERT，UPDATE或）。
数据库定义（DDL）语句（创建，变更或删除）。
数据库操作（SERVERERROR，登录，注销，启动或关机）。
触发器可以在表，视图，模式或与该事件相关联的数据库中被定义。
创建触发器
创建触发器的语法如下：
CREATE [OR REPLACE ] TRIGGER trigger_name
{BEFORE | AFTER | INSTEAD OF }
{INSERT [OR] | UPDATE [OR] | DELETE}
[OF col_name]
ON table_name
[REFERENCING OLD AS o NEW AS n]
[FOR EACH ROW]
WHEN (condition)
DECLARE
Declaration-statements
BEGIN
Executable-statements
EXCEPTION
Exception-handling-statements
END;
哪里，
CREATE [OR REPLACE] TRIGGER TRIGGER_NAME：创建或使用TRIGGER_NAME替换现有触发器。
{BEFORE | AFTER | INSTEAD OF}：指定当触发将被执行。在INSTEAD OF子句用于在视图中创建触发器。
{INSERT [OR] | UPDATE [OR] |删除}：指定DML操作。
[OF COL_NAME]：指定将被更新的列名。
[开TABLE_NAME]：此指定与触发器关联的表的名称。
[REFERENCING OLD AS o新的为n]：这可以让你参考新旧价值观各种DML语句，如INSERT，UPDATE和DELETE。
[FOR EACH ROW]：指定一个行级触发器，即触发器将每一行受到影响执行。否则，在执行SQL语句，它被称为表级触发器触发将执行一次。
WHEN（条件）：此为行提供了条件该触发器将触发。该条款仅适用于行级触发器有效。
例：
首先，我们将使用CUSTOMERS表：
Select * from customers; +----+----------+-----+-----------+----------+ | ID | NAME | AGE | ADDRESS | SALARY | +----+----------+-----+-----------+----------+ | 1 | Ramesh | 32 | Ahmedabad | 2000.00 | | 2 | Khilan | 25 | Delhi | 1500.00 | | 3 | kaushik | 23 | Kota | 2000.00 | | 4 | Chaitali | 25 | Mumbai | 6500.00 | | 5 | Hardik | 27 | Bhopal | 8500.00 | | 6 | Komal | 22 | MP | 4500.00 | +----+----------+-----+-----------+----------+
下面的程序创建了客户表，将火INSERT或UPDATE或DELETE Customers表进行操作的行级触发器。该触发器将显示旧值和新值之间的差异薪水：
CREATE OR REPLACE TRIGGER display_salary_changes
BEFORE DELETE OR INSERT OR UPDATE ON customers
FOR EACH ROW
WHEN (NEW.ID > 0)
DECLARE
sal_diff number;
BEGIN
sal_diff := :NEW.salary - :OLD.salary;
dbms_output.put_line('Old salary: ' || :OLD.salary);
dbms_output.put_line('New salary: ' || :NEW.salary);
dbms_output.put_line('Salary difference: ' || sal_diff);
END;
/
当上述代码在SQL提示符执行时，它产生了以下结果：
Trigger created.
在这里，以下两点非常重要，应认真注意的是：
OLD和NEW引用是不可用于表级触发器，而你可以将它们用于记录级别的触发器。
如果您想查询表中相同的触发，那么你应该使用关键字后，由于触发器可以查询表或再次更改后，才初步改变被应用，该表是早在一个一致的状态。
上述触发已经写在这样一种方式，它会之前的任何DELETE火灾或表的INSERT或UPDATE操作，但你可以写在一个或多个操作触发器，例如BEFORE DELETE，这将触发每当一个记录将使用表的DELETE操作被删除。
PL / SQL - 包
PL / SQL包是组逻辑相关的PL / SQL类型，变量和子程序模式对象。
一个包将有两个强制性的部分：
包装规格
包体或定义
包装规格
本说明书是接口到包。它只是声明的类型，变量，常量，异常，游标和子程序可从封装外部引用。换句话说，它包含有关该包的内容的所有信息，但不包括用于子程序的代码。
放置在说明书中的所有对象被称为公共对象。在封装主体中没有包规范但编码任何子程序被称为私有对象。
下面的代码片段展示了具有单个程序包规范。你可以有一个包中定义的全局变量和多过程或函数。
CREATE PACKAGE cust_sal AS PROCEDURE find_sal(c_id customers.id%type); END cust_sal; /
当上述代码在SQL提示符执行时，它产生了以下结果：
Package created.
包主体
包体在包规范和其他私人声明宣称的各种方法，这是从代码隐藏在包外的代码。
创建包BODY语句用于创建包体。下面的代码片段显示了包体声明上面创建的cust_sal包。我认为我们已经在提到在我们的数据库中CUSTOMERS表创建PL / SQL -变量一章。
CREATE OR REPLACE PACKAGE BODY cust_sal AS
PROCEDURE find_sal(c_id customers.id%TYPE) IS
c_sal customers.salary%TYPE;
BEGIN
SELECT salary INTO c_sal
FROM customers
WHERE id = c_id;
dbms_output.put_line('Salary: '|| c_sal);
END find_sal;
END cust_sal;
/
当上述代码在SQL提示符执行时，它产生了以下结果：
Package body created.
使用包装元素
包元素（变量，过程或函数）与以下语法访问：
package_name.element_name;
想想，我们已经上文包在我们的数据库模式中创建，下面的程序使用cust_sal包find_sal方法：
DECLARE code customers.id%type := &cc_id; BEGIN cust_sal.find_sal(code); END; /
当上面的代码在SQL提示符下执行，它提示输入客户ID，当你输入一个ID，它会显示相应的薪酬如下：
Enter value for cc_id: 1 Salary: 3000 PL/SQL procedure successfully completed.
PL / SQL - 收藏
集合是具有相同的数据类型元素的有序组。每个元件由一个唯一的标表示其集合中的位置识别。
PL / SQL提供了三种集合类型：
索引表或关联数组
嵌套表
可变大小的数组或VARRAY
索引表
一个索引表（也称为关联数组）是一组键-值对。每个键是唯一的，并且用于定位对应的值。键可以是整数或字符串。
一个索引表是使用以下语法创建。在这里，我们正在创建一个索引表名为TABLE_NAME，它的键会subscript_type和相关的值将ELEMENT_TYPE的
TYPE type_name IS TABLE OF element_type [NOT NULL] INDEX BY subscript_type; table_name type_name;
例：
下面的例子如何创建一个表来存储整数值与名称一起，后来它打印的名称相同的列表。
DECLARE
TYPE salary IS TABLE OF NUMBER INDEX BY VARCHAR2(20);
salary_list salary;
name VARCHAR2(20);
BEGIN
-- adding elements to the table
salary_list('Rajnish') := 62000;
salary_list('Minakshi') := 75000;
salary_list('Martin') := 100000;
salary_list('James') := 78000;
-- printing the table
name := salary_list.FIRST;
WHILE name IS NOT null LOOP
dbms_output.put_line
('Salary of ' || name || ' is ' || TO_CHAR(salary_list(name)));
name := salary_list.NEXT(name);
END LOOP;
END;
/
当上述代码在SQL提示符执行时，它产生了以下结果：
Salary of James is 78000 Salary of Martin is 100000 Salary of Minakshi is 75000 Salary of Rajnish is 62000 PL/SQL procedure successfully completed.
嵌套表
嵌套表是像元件的任意数量的一维数组。然而，嵌套表不同于在以下几个方面的数组：
数组元素有一个申报号，但嵌套表没有。嵌套表的大小可以动态地增加。
数组总是密密麻麻即它总是有连续的下标。嵌套数组是密集最初，但当元素从它删除，它可以变得稀疏。
一个嵌套表是使用以下语法创建的：
TYPE type_name IS TABLE OF element_type [NOT NULL]; table_name type_name;
这个声明是类似于索引表的声明，但没有索引BY子句。
嵌套表可以存储在数据库列，所以它可用于简化在那里你加入一个较大的表中的单个列的表的SQL操作。关联数组不能存储在数据库中。
例：
以下实施例说明使用嵌套表：
DECLARE
TYPE names_table IS TABLE OF VARCHAR2(10);
TYPE grades IS TABLE OF INTEGER;
names names_table;
marks grades;
total integer;
BEGIN
names := names_table('Kavita', 'Pritam', 'Ayan', 'Rishav', 'Aziz');
marks:= grades(98, 97, 78, 87, 92);
total := names.count;
dbms_output.put_line('Total '|| total || ' Students');
FOR i IN 1 .. total LOOP
dbms_output.put_line('Student:'||names(i)||', Marks:' || marks(i));
end loop;
END;
/
当上述代码在SQL提示符执行时，它产生了以下结果：
Total 5 Students Student:Kavita, Marks:98 Student:Pritam, Marks:97 Student:Ayan, Marks:78 Student:Rishav, Marks:87 Student:Aziz, Marks:92 PL/SQL procedure successfully completed.
PL / SQL - 交易
数据库事务工作的基本单位，可能会由一个或多个相关的SQL语句。这就是所谓的原子弹，因为数据库修改所带来的构成一个事务中的SQL语句可以共同被提交，即成为永久性的数据库或轧制从数据库返回的（撤消）。
一个成功执行的SQL语句和提交的事务都不一样。即使成功执行SQL语句，除非包含该语句的事务被提交，它可以回滚，并使用statement（s）的所有修改都可以撤销。
启动一个结束交易
事务有开始和结束 。当下列事件之一发生事务开始：
第一个SQL语句连接到数据库后执行。
在交易后发出的每个新的SQL语句完成。
当下列事件之一发生事务结束：
COMMIT或ROLLBACK语句发出。
DDL语句，如CREATE TABLE语句，已发出;因为在这种情况下，一个将自动执行COMMIT。
一个DCL语句，例如GRANT语句，已发出;因为在这种情况下，一个将自动执行COMMIT。
用户从数据库中断开。
从SQL * Plus用户退出通过发出EXIT指令中，提交自动执行。
在SQL * Plus异常终止，自动执行ROLLBACK。
一个DML语句失败;在这种情况下一个ROLLBACK对于撤销该DML语句自动执行。
提交事务
事务是通过发出SQL命令COMMIT永久。为COMMIT命令的一般语法是：
COMMIT;
回滚事务
没有提交到数据库所做的更改可以使用ROLLBACK命令撤消。
为ROLLBACK命令的一般语法是：
ROLLBACK [TO SAVEPOINT < savepoint_name>];
当一个事务因中止一些前所未有的情况，如系统故障，则整个事务，因为提交自动回退。如果你不使用savepoiny，然后只需使用下面的语句来回滚所有的变化：
ROLLBACK;
保存点
保存点是排序的标记，通过设置一些关卡拆分长事务分成更小的单位帮助。由一个长事务中保存点的设置，你可以根据需要回滚到一个检查点。这是通过发出SAVEPOINT命令来完成。
对于SAVEPOINT命令的一般语法是：
SAVEPOINT < savepoint_name >;
自动事务控制
要执行一个自动执行COMMIT每当一个INSERT，UPDATE或DELETE命令执行，你可以设置AUTOCOMMIT环境变量：
SET AUTOCOMMIT ON;
您可以关闭自动使用以下命令提交方式：
SET AUTOCOMMIT OFF;
PL / SQL - 日期和时间
PL / SQL提供了两个班的日期和时间相关的数据类型：
日期时间数据类型
间隔数据类型
datetime数据类型有：
日期
TIMESTAMP
TIMESTAMP WITH TIME ZONE
WITH LOCAL TIME ZONE TIMESTAMP
该区间的数据类型是：
INTERVAL YEAR TO MONTH
INTERVAL DAY TO SECOND
datetime数据类型
下面是日期时间数据类型：
日期 -它存储在字符和数字数据类型的日期和时间信息。它是由上世纪，年，月，日，小时，分钟和秒的信息。它被规定为：
时间戳 -它是日期数据类型的扩展。它存储了年，月，和日期数据类型的天，小时，分钟和秒值一起。它是用于存储精确的时间值是有用的。
WITH TIME ZONE TIMESTAMP -这是TIMESTAMP的变体，其中包括一个时区的区域名称或时区的偏移值。时区偏移量是本地时间和UTC之间的差值（以小时和分钟）。此数据类型是收集和评估不同地理区域的最新信息是有用的。
WITH LOCAL TIME ZONE TIMESTAMP -这是TIMESTAMP的另一个变种，其中包括一个时区的偏移值。
例子：
SELECT SYSDATE FROM DUAL;
输出：
08/31/2012 5:25:34 PM
SELECT TO_CHAR(CURRENT_DATE, 'DD-MM-YYYY HH:MI:SS') FROM DUAL;
输出：
31-08-2012 05:26:14
SELECT ADD_MONTHS(SYSDATE, 5) FROM DUAL;
输出：
01/31/2013 5:26:31 PM
SELECT LOCALTIMESTAMP FROM DUAL;
输出：
8/31/2012 5:26:55.347000 PM
该区间数据类型
以下是间隔的数据类型：
INTERVAL YEAR TO MONTH - 它存储使用年份和月份日期时间字段的一段时间。
INTERVAL DAY TO SECOND - 它存储在天，小时，分钟和秒来一段时间。
PL / SQL - DBMS输出
该DBMS_OUTPUT是一个内置的软件包，使您能够显示输出，显示调试信息，并从PL / SQL块，子程序，包和触发器发送消息。
例：
DECLARE
lines dbms_output.chararr;
num_lines number;
BEGIN
-- enable the buffer with default size 20000
dbms_output.enable;
dbms_output.put_line('Hello Reader!');
dbms_output.put_line('Hope you have enjoyed the tutorials!');
dbms_output.put_line('Have a great time exploring pl/sql!');
num_lines := 3;
dbms_output.get_lines(lines, num_lines);
FOR i IN 1..num_lines LOOP
dbms_output.put_line(lines(i));
END LOOP;
END;
/
当上述代码在SQL提示符执行时，它产生了以下结果：
Hello Reader! Hope you have enjoyed the tutorials! Have a great time exploring pl/sql! PL/SQL procedure successfully completed.
PL / SQL - 面向对象
的PL / SQL允许定义一个对象类型，这有助于在甲骨文设计的面向对象的数据库。对象类型可以让你的箱子复合类型。使用对象允许您实现数据的特定结构现实世界中的对象和方法操作它。对象有属性和方法。属性是一个对象的属性，并用于存储对象的状态;和方法用于模拟其行为。
对象是使用CREATE [OR REPLACE] TYPE语句创建。下面是创建包含一些属性的简单地址对象的例子：
CREATE OR REPLACE TYPE address AS OBJECT (house_no varchar2(10), street varchar2(30), city varchar2(20), state varchar2(10), pincode varchar2(10) ); /
当上述代码在SQL提示符执行时，它产生了以下结果：
Type created.
让我们再创建一个对象的客户 ，我们将包的属性和方法 ，共同拥有的面向对象的感觉：
CREATE OR REPLACE TYPE customer AS OBJECT (code number(5), name varchar2(30), contact_no varchar2(12), addr address, member procedure display ); /
当上述代码在SQL提示符执行时，它产生了以下结果：
Type created.
实例化对象
定义对象类型提供对象的蓝图。要使用这个对象，你需要创建这个对象的实例。可以访问的属性和使用的实例名和访问算子如下所述对象的方法（）：
DECLARE
residence address;
BEGIN
residence := address('103A', 'M.G.Road', 'Jaipur', 'Rajasthan','201301');
dbms_output.put_line('House No: '|| residence.house_no);
dbms_output.put_line('Street: '|| residence.street);
dbms_output.put_line('City: '|| residence.city);
dbms_output.put_line('State: '|| residence.state);
dbms_output.put_line('Pincode: '|| residence.pincode);
END;
/
当上述代码在SQL提示符执行时，它产生了以下结果：
House No: 103A Street: M.G.Road City: Jaipur State: Rajasthan Pincode: 201301 PL/SQL procedure successfully completed.
继承了PL / SQL对象：
PL / SQL允许从现有的基础对象创建的对象。为了实现继承，基本对象应声明为没有最终确定。默认是最终决定。
下面的程序说明了在PL / SQL对象继承。让我们创建另一个命名对象桌面型这是从Rectangle对象继承。创建基本矩形对象：
CREATE OR REPLACE TYPE rectangle AS OBJECT (length number, width number, member function enlarge( inc number) return rectangle, NOT FINAL member procedure display) NOT FINAL /
当上述代码在SQL提示符执行时，它产生了以下结果：
Type created.
创建基本类型体：
CREATE OR REPLACE TYPE BODY rectangle AS
MEMBER FUNCTION enlarge(inc number) return rectangle IS
BEGIN
return rectangle(self.length + inc, self.width + inc);
END enlarge;
MEMBER PROCEDURE display IS
BEGIN
dbms_output.put_line('Length: '|| length);
dbms_output.put_line('Width: '|| width);
END display;
END;
/
当上述代码在SQL提示符执行时，它产生了以下结果：
Type body created.
创建子对象桌面 ：
CREATE OR REPLACE TYPE tabletop UNDER rectangle ( material varchar2(20), OVERRIDING member procedure display ) /
当上述代码在SQL提示符执行时，它产生了以下结果：
Type created.
创建类型机构的子对象桌面 ：
CREATE OR REPLACE TYPE BODY tabletop AS
OVERRIDING MEMBER PROCEDURE display IS
BEGIN
dbms_output.put_line('Length: '|| length);
dbms_output.put_line('Width: '|| width);
dbms_output.put_line('Material: '|| material);
END display;
/
当上述代码在SQL提示符执行时，它产生了以下结果：
Type body created.
使用桌面对象及其成员函数：
DECLARE t1 tabletop; t2 tabletop; BEGIN t1:= tabletop(20, 10, 'Wood'); t2 := tabletop(50, 30, 'Steel'); t1.display; t2.display; END; /
当上述代码在SQL提示符执行时，它产生了以下结果：
Length: 20 Width: 10 Material: Wood Length: 50 Width: 30 Material: Steel PL/SQL procedure successfully completed.
在PL / SQL抽象对象
在不实例化子句允许你声明一个抽象的对象。因为这是你不能使用抽象对象;你必须创建这些对象的子类型或子类型使用其功能。
例如，
CREATE OR REPLACE TYPE rectangle AS OBJECT (length number, width number, NOT INSTANTIABLE NOT FINAL MEMBER PROCEDURE display) NOT INSTANTIABLE NOT FINAL /
当上述代码在SQL提示符执行时，它产生了以下结果：
Type created.