devbox
weixin_40725706
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Oracle—包和包体（转）_oracle包和包体的区别

作者：weixin_40725706 | 2024-03-30 20:54:36

赞

踩

oracle包和包体的区别

包


包的概念和组成

包是用来存储相关程序结构的对象，它存储于数据字典中。包由两个分离的部分组成：包头(PACKAGE)和包体(PACKAGE BODY)。 包头是包的说明部分，是对外的操作接口，对应用是可见的； 包体是包的代码和实现部分，对应用来说是不可见的黑盒。

包中可以包含的程序结构如下所示。

  1. 过程(PROCUDURE)   带参数的命名的程序模块  
  2. 函数(FUNCTION)    带参数、具有返回值的命名的程序模块  
  3. 变量(VARIABLE)    存储变化的量的存储单元  
  4. 常量(CONSTANT)    存储不变的量的存储单元  
  5. 游标(CURSOR)      用户定义的数据操作缓存区，在可执行部分使用  
  6. 类型(TYPE)        用户定义的新的结构类型  
  7. 异常(EXCEPTION)   在标准包中定义或由用户自定义，用于处理程序错误
说明部分可以出现在包的三个不同的部分：出现在包头中的称为 公有元素，出现在包体中的称为 私有元素，出现在包体的过程(或函数)中的称为 局部变量。它们的性质有所不同，如下所示。 
  1.     公有元素(PUBLIC)    在包头中说明，在包体中具体定义   在包外可见并可以访问，对整个应用的全过程有效  
  2.     私有元素(PRIVATE)   在包体的说明部分说明             只能被包内部的其他部分访问  
  3.     局部变量(LOCAL)     在过程或函数的说明部分说明       只能在定义变量的过程或函数中使用
在包体中出现的过程或函数，如果需要对外公用，就必须在包头中说明，包头中的说明应该和包体中的说明一致。
包有以下优点：
  * 包可以方便地将存储过程和函数组织到一起，每个包又是相互独立的。在不同的包中，过程、函数都可以重名，这解决了在同一个用户环境中命名的冲突问题。
  * 包增强了对存储过程和函数的安全管理，对整个包的访问权只需一次授予。
  * 在同一个会话中，公用变量的值将被保留，直到会话结束。
  * 区分了公有过程和私有过程，包体的私有过程增加了过程和函数的保密性。

  * 包在被首次调用时，就作为一个整体被全部调入内存，减少了多次访问过程或函数的I/O次数。


创建包和包体
包由包头和包体两部分组成， 包的创建应该先创建包头部分，然后创建包体部分。创建、删除和编译包的权限同创建、删除和编译存储过程的权限相同。
创建包头的简要语句如下： 
  1. CREATE [OR REPLACE] PACKAGE 包名
  2. {IS|AS}
  3. 公有变量定义
  4. 公有类型定义
  5. 公有游标定义
  6. 公有异常定义
  7. 函数说明
  8. 过程说明
  9. END;
创建包体的简要语法如下： 
  1. CREATE [OR REPLACE] PACKAGE BODY 包名
  2. {IS|AS}
  3. 私有变量定义
  4. 私有类型定义
  5. 私有游标定义
  6. 私有异常定义
  7. 函数定义
  8. 过程定义
  9. END;
包的其他操作命令包括：
删除包头： 
DROP PACKAGE 包头名
删除包体： 
DROP PACKAGE BODY 包体名
重新编译包头： 
ALTER PACKAGE 包名 COMPILE PACKAGE
重新编译包体： 
ALTER PACKAGE 包名 COMPILE PACKAGE BODY
在包头中说明的对象可以在包外调用，调用的方法和调用单独的过程或函数的方法基本相同，惟一的区别就是 要在调用的过程或函数名前加上包的名字(中间用“.”分隔)。但要注意，不同的会话将单独对包的公用变量进行初始化，所以不同的会话对包的调用属于不同的应用。
系统包
Oracle预定义了很多标准的系统包，这些包可以在应用中直接使用，比如在训练中我们使用的 DBMS_OUTPUT包，就是系统包。 PUT_LINE是该包的一个函数。常用系统包下所示。 
  1.     DBMS_OUTPUT         在SQL*Plus环境下输出信息  
  2.     DBMS_DDL            编译过程函数和包  
  3.     DBMS_SESSION        改变用户的会话，初始化包等  
  4.     DBMS_TRANSACTION    控制数据库事务  
  5.     DBMS_MAIL           连接Oracle*Mail  
  6.     DBMS_LOCK           进行复杂的锁机制管理  
  7.     DBMS_ALERT          识别数据库事件告警  
  8.     DBMS_PIPE           通过管道在会话间传递信息  
  9.     DBMS_JOB            管理Oracle的作业  
  10.     DBMS_LOB            操纵大对象  
  11.     DBMS_SQL            执行动态SQL语句
包的应用
在SQL*Plus环境下，包和包体可以分别编译，也可以一起编译。如果分别编译，则要先编译包头，后编译包体。如果在一起编译，则包头写在前，包体在后，中间用“/”分隔。
可以将已经存在的存储过程或函数添加到包中，方法是去掉过程或函数创建语句的CREATE OR REPLACE部分，将存储过程或函数复制到包体中 ，然后重新编译即可。
   如果需要将私有过程或函数变成共有过程或函数的话，将过程或函数说明部分复制到包头说明部分，然后重新编译就可以了。
【训练1】  创建管理雇员信息的包EMPLOYE，它具有从EMP表获得雇员信息，修改雇员名称，修改雇员工资和写回EMP表的功能。
步骤1：登录SCOTT账户，输入以下代码并编译： 
  1.     CREATE OR REPLACE PACKAGE EMPLOYE --包头部分   
  2.             IS  
  3.      PROCEDURE SHOW_DETAIL;   
  4.      PROCEDURE GET_EMPLOYE(P_EMPNO NUMBER);   
  5.      PROCEDURE SAVE_EMPLOYE;   
  6.      PROCEDURE CHANGE_NAME(P_NEWNAME VARCHAR2);   
  7.      PROCEDURE CHANGE_SAL(P_NEWSAL NUMBER);   
  8.     END EMPLOYE;  
  9.  
  10.             /  --包头和包体分隔符
  11.  
  12.    CREATE OR REPLACE PACKAGE BODY EMPLOYE --包体部分   
  13.             IS  
  14.      EMPLOYE EMP%ROWTYPE;  
  15.     ------------------ 显示雇员信息 ---------------  
  16.             PROCEDURE SHOW_DETAIL  
  17.              AS  
  18.             BEGIN  
  19.              DBMS_OUTPUT.PUT_LINE(‘----- 雇员信息 -----’);     
  20.              DBMS_OUTPUT.PUT_LINE('雇员编号：'||EMPLOYE.EMPNO);  
  21.              DBMS_OUTPUT.PUT_LINE('雇员名称：'||EMPLOYE.ENAME);  
  22.              DBMS_OUTPUT.PUT_LINE('雇员职务：'||EMPLOYE.JOB);  
  23.              DBMS_OUTPUT.PUT_LINE('雇员工资：'||EMPLOYE.SAL);  
  24.              DBMS_OUTPUT.PUT_LINE('部门编号：'||EMPLOYE.DEPTNO);  
  25.             END SHOW_DETAIL;  
  26.     ----------------- 从EMP表取得一个雇员 --------------------  
  27.             PROCEDURE GET_EMPLOYE(P_EMPNO NUMBER)  
  28.              AS  
  29.             BEGIN  
  30.              SELECT * INTO EMPLOYE FROM EMP WHERE EMPNO=P_EMPNO;  
  31.              DBMS_OUTPUT.PUT_LINE('获取雇员'||EMPLOYE.ENAME||'信息成功');  
  32.             EXCEPTION  
  33.              WHEN OTHERS THEN  
  34.              DBMS_OUTPUT.PUT_LINE('获取雇员信息发生错误！');  
  35.             END GET_EMPLOYE;  
  36.     ---------------------- 保存雇员到EMP表 --------------------------  
  37.             PROCEDURE SAVE_EMPLOYE  
  38.              AS  
  39.             BEGIN  
  40.              UPDATE EMP SET ENAME=EMPLOYE.ENAME, SAL=EMPLOYE.SAL WHERE EMPNO=EMPLOYE.EMPNO;  
  41.              DBMS_OUTPUT.PUT_LINE('雇员信息保存完成！');  
  42.             END SAVE_EMPLOYE;  
  43.     ---------------------------- 修改雇员名称 ------------------------------  
  44.             PROCEDURE CHANGE_NAME(P_NEWNAME VARCHAR2)  
  45.              AS  
  46.             BEGIN  
  47.              EMPLOYE.ENAME:=P_NEWNAME;  
  48.              DBMS_OUTPUT.PUT_LINE('修改名称完成！');  
  49.             END CHANGE_NAME;  
  50.     ---------------------------- 修改雇员工资 --------------------------  
  51.             PROCEDURE CHANGE_SAL(P_NEWSAL NUMBER)  
  52.              AS  
  53.             BEGIN  
  54.              EMPLOYE.SAL:=P_NEWSAL;  
  55.              DBMS_OUTPUT.PUT_LINE('修改工资完成！');  
  56.             END CHANGE_SAL;  
  57.             END EMPLOYE;
步骤2：获取雇员7788的信息: 
  1.     SET SERVEROUTPUT ON  
  2.     EXECUTE EMPLOYE.GET_EMPLOYE(7788);
结果为： 
  1.     获取雇员SCOTT信息成功  
  2.             PL/SQL 过程已成功完成。
步骤3：显示雇员信息： 
    EXECUTE EMPLOYE.SHOW_DETAIL;
结果为： 
  1. ------------------ 雇员信息 ------------------  
  2.         雇员编号：7788  
  3.         雇员名称：SCOTT  
  4.         雇员职务：ANALYST  
  5.         雇员工资：3000  
  6.         部门编号：20  
  7.         PL/SQL 过程已成功完成。
步骤4：修改雇员工资： 
EXECUTE EMPLOYE.CHANGE_SAL(3800);
结果为： 
  1.     修改工资完成！  
  2.             PL/SQL 过程已成功完成。
步骤5：将修改的雇员信息存入EMP表 
    EXECUTE EMPLOYE.SAVE_EMPLOYE;
结果为： 
  1. 雇员信息保存完成！  
  2.         PL/SQL 过程已成功完成。

说明：该包完成将EMP表中的某个雇员的信息取入内存记录变量，在记录变量中进行修改编辑，在确认显示信息正确后写回EMP表的功能。记录变量EMPLOYE用来存储取得的雇员信息，定义为私有变量，只能被包的内部模块访问。


阶段训练
下面的训练通过定义和创建完整的包EMP_PK并综合运用本章的知识，完成对雇员表的插入、删除等功能，包中的主要元素解释如下所示。 

  1. 程序结构      类  型      说    明  
  2. V_EMP_COUNT     公有变量    跟踪雇员的总人数变化，插入、删除雇员的同时修改该变量的值  
  3. INIT            公有过程    对包进行初始化，初始化雇员人数和工资修改的上、下限  
  4. LIST_EMP        公有过程    显示雇员列表  
  5. INSERT_EMP      公有过程    通过编号插入新雇员  
  6. DELETE_EMP      公有过程    通过编号删除雇员  
  7. CHANGE_EMP_SAL  公有过程    通过编号修改雇员工资  
  8. V_MESSAGE       私有变量    存放准备输出的信息  
  9. C_MAX_SAL       私有变量    对工资修改的上限  
  10. C_MIN_SAL       私有变量    对工资修改的下限  
  11. SHOW_MESSAGE    私有过程    显示私有变量V_MESSAGE中的信息  
  12. EXIST_EMP       私有函数    判断某个编号的雇员是否存在，该函数被INSERT_EMP、DELETE_EMP和CHANGE_EMP_SAL等过程调用
【训练1】  完整的雇员包EMP_PK的创建和应用。
步骤1：在SQL*Plus中登录SCOTT账户，输入以下包头和包体部分，按“执行”按钮编译： 

  1.         CREATE OR REPLACE PACKAGE EMP_PK   
  2.         --包头部分   
  3.           IS  
  4.          V_EMP_COUNT NUMBER(5);                      --雇员人数  
  5.          PROCEDURE INIT(P_MAX NUMBER,P_MIN NUMBER);  --初始化  
  6.          PROCEDURE LIST_EMP;                         --显示雇员列表  
  7.          PROCEDURE INSERT_EMP(P_EMPNO NUMBER,P_ENAME VARCHAR2,P_JOB VARCHAR2,P_SAL NUMBER);     --插入雇员  
  8.          PROCEDURE DELETE_EMP(P_EMPNO NUMBER);       --删除雇员  
  9.          PROCEDURE CHANGE_EMP_SAL(P_EMPNO NUMBER,P_SAL NUMBER);   --修改雇员工资  
  10.         END EMP_PK;  
  11.         
  12.           /
  13.    
  14.         CREATE OR REPLACE PACKAGE BODY EMP_PK   --包体部分   
  15.           IS  
  16.          V_MESSAGE VARCHAR2(50); --显示信息  
  17.          V_MAX_SAL NUMBER(7); --工资上限  
  18.          V_MIN_SAL NUMBER(7); --工资下限  
  19.          FUNCTION EXIST_EMP(P_EMPNO NUMBER)  RETURN  BOOLEAN; --判断雇员是否存在函数  
  20.          PROCEDURE SHOW_MESSAGE; --显示信息过程  
  21.         ------------------------------- 初始化过程 ----------------------------  
  22.          PROCEDURE INIT(P_MAX NUMBER,P_MIN NUMBER)   
  23.           IS   
  24.          BEGIN  
  25.           SELECT COUNT(*) INTO V_EMP_COUNT FROM EMP;  
  26.           V_MAX_SAL:=P_MAX;  
  27.           V_MIN_SAL:=P_MIN;  
  28.           V_MESSAGE:='初始化过程已经完成！';  
  29.           SHOW_MESSAGE;   
  30.          END INIT;  
  31.         ---------------------------- 显示雇员列表过程 ---------------------  
  32.          PROCEDURE LIST_EMP   
  33.           IS   
  34.          BEGIN  
  35.           DBMS_OUTPUT.PUT_LINE('姓名       职务      工资');  
  36.           FOR emp_rec IN (SELECT * FROM EMP)  
  37.           LOOP  
  38.            DBMS_OUTPUT.PUT_LINE(RPAD(emp_rec.ename,10,'')||RPAD(emp_rec.job,10,' ')||TO_CHAR(emp_rec.sal));  
  39.           END LOOP;  
  40.           DBMS_OUTPUT.PUT_LINE('雇员总人数'||V_EMP_COUNT);  
  41.          END LIST_EMP;  
  42.         ----------------------------- 插入雇员过程 -----------------------------  
  43.          PROCEDUREINSERT_EMP(P_EMPNO     NUMBER,P_ENAMEVARCHAR2,P_JOB    VARCHAR2,P_SAL NUMBER)  
  44.           IS   
  45.          BEGIN  
  46.           IF NOT EXIST_EMP(P_EMPNO) THEN  
  47.            INSERT INTO EMP(EMPNO,ENAME,JOB,SAL)        VALUES(P_EMPNO,P_ENAME,P_JOB,P_SAL);  
  48.            COMMIT;   
  49.            V_EMP_COUNT:=V_EMP_COUNT+1;  
  50.            V_MESSAGE:='雇员'||P_EMPNO||'已插入!';  
  51.           ELSE  
  52.            V_MESSAGE:='雇员'||P_EMPNO||'已存在,不能插入!';  
  53.           END IF;  
  54.            SHOW_MESSAGE;   
  55.          EXCEPTION  
  56.           WHEN OTHERS THEN  
  57.           V_MESSAGE:='雇员'||P_EMPNO||'插入失败!';  
  58.           SHOW_MESSAGE;  
  59.          END INSERT_EMP;  
  60.         --------------------------- 删除雇员过程 --------------------  
  61.          PROCEDURE DELETE_EMP(P_EMPNO NUMBER)   
  62.           IS   
  63.          BEGIN   
  64.           IF EXIST_EMP(P_EMPNO) THEN  
  65.            DELETE FROM EMP WHERE EMPNO=P_EMPNO;  
  66.            COMMIT;  
  67.            V_EMP_COUNT:=V_EMP_COUNT-1;  
  68.            V_MESSAGE:='雇员'||P_EMPNO||'已删除!';  
  69.           ELSE  
  70.            V_MESSAGE:='雇员'||P_EMPNO||'不存在，不能删除!';  
  71.           END IF;  
  72.           SHOW_MESSAGE;  
  73.          EXCEPTION  
  74.           WHEN OTHERS THEN  
  75.           V_MESSAGE:='雇员'||P_EMPNO||'删除失败!';  
  76.           SHOW_MESSAGE;  
  77.          END DELETE_EMP;  
  78.         --------------------------------------- 修改雇员工资过程 ------------------------------------  
  79.          PROCEDURE CHANGE_EMP_SAL(P_EMPNO NUMBER,P_SAL NUMBER)   
  80.           IS   
  81.          BEGIN   
  82.           IF (P_SAL>V_MAX_SAL OR P_SAL<V_MIN_SAL) THEN  
  83.            V_MESSAGE:='工资超出修改范围!';  
  84.           ELSIF NOT EXIST_EMP(P_EMPNO) THEN  
  85.            V_MESSAGE:='雇员'||P_EMPNO||'不存在，不能修改工资!';  
  86.           ELSE  
  87.            UPDATE EMP SET SAL=P_SAL WHERE EMPNO=P_EMPNO;  
  88.            COMMIT;  
  89.            V_MESSAGE:='雇员'||P_EMPNO||'工资已经修改!';  
  90.           END IF;  
  91.            SHOW_MESSAGE;  
  92.          EXCEPTION  
  93.           WHEN OTHERS THEN  
  94.           V_MESSAGE:='雇员'||P_EMPNO||'工资修改失败!';  
  95.           SHOW_MESSAGE;  
  96.          END CHANGE_EMP_SAL;  
  97.         ---------------------------- 显示信息过程 ----------------------------  
  98.          PROCEDURE SHOW_MESSAGE   
  99.           IS   
  100.          BEGIN  
  101.           DBMS_OUTPUT.PUT_LINE('提示信息：'||V_MESSAGE);  
  102.          END SHOW_MESSAGE;  
  103.         ------------------------ 判断雇员是否存在函数 -------------------  
  104.          FUNCTION EXIST_EMP(P_EMPNO NUMBER)  
  105.          RETURN BOOLEAN   
  106.           IS  
  107.          V_NUM NUMBER; --局部变量  
  108.          BEGIN  
  109.           SELECT COUNT(*) INTO V_NUM FROM EMP WHERE EMPNO=P_EMPNO;  
  110.           IF V_NUM=1 THEN   
  111.             RETURN TRUE;  
  112.           ELSE  
  113.            RETURN FALSE;  
  114.           END IF;   
  115.          END EXIST_EMP;  
  116.         -----------------------------  
  117.         END EMP_PK;
步骤2：初始化包： 
  1.     SET SERVEROUTPUT ON  
  2.     EXECUTE EMP_PK.INIT(6000,600);
结果为： 
提示信息：初始化过程已经完成！
步骤3：显示雇员列表： 
EXECUTE EMP_PK.LIST_EMP;
结果为： 
  1.             姓名          职务          工资  
  2.             SMITH         CLERK         1560  
  3.             ALLEN         SALESMAN      1936  
  4.             WARD          SALESMAN      1830  
  5.             JONES         MANAGER       2975  
  6.             ...  
  7.             雇员总人数：14  
  8.             PL/SQL 过程已成功完成。
步骤4：插入一个新记录： 
    EXECUTE EMP_PK.INSERT_EMP(8001,'小王','CLERK',1000);
显示结果为： 
  1.     提示信息：雇员8001已插入!  
  2.     PL/SQL 过程已成功完成。
步骤5：通过全局变量V_EMP_COUNT查看雇员人数： 
  1.     BEGIN  
  2.     DBMS_OUTPUT.PUT_LINE(EMP_PK.V_EMP_COUNT);  
  3.     END;
显示结果为： 
  1. 15  
  2. PL/SQL 过程已成功完成。
步骤6：删除新插入记录： 
EXECUTE EMP_PK.DELETE_EMP(8001);
显示结果为： 
  1.     提示信息：雇员8001已删除!  
  2.             PL/SQL 过程已成功完成。
再次删除该雇员： 
    EXECUTE EMP_PK.DELETE_EMP(8001);
结果为： 
提示信息：雇员8001不存在，不能删除!
步骤7：修改雇员工资： 
EXECUTE EMP_PK.CHANGE_EMP_SAL(7788,8000);
显示结果为： 
  1. 提示信息：工资超出修改范围!  
  2.         PL/SQL 过程已成功完成。
步骤8：授权其他用户调用包：
如果是另外一个用户要使用该包，必须由包的所有者授权，下面授予STUDEN账户对该包的使用权： 
    GRANT EXECUTE ON EMP_PK TO STUDENT;
每一个新的会话要为包中的公用变量开辟新的存储空间，所以需要重新执行初始化过程。两个会话的进程互不影响。
步骤9：其他用户调用包。
启动另外一个SQL*Plus，登录STUDENT账户，执行以下过程： 
  1.     SET SERVEROUTPUT ON  
  2.             EXECUTE SCOTT.EMP_PK. EMP_PK.INIT(5000,700);
结果为： 
  1. 提示信息：初始化过程已经完成！  
  2.         PL/SQL 过程已成功完成。
说明：在初始化中设置雇员的总人数和修改工资的上、下限，初始化后V_EMP_COUNT为14人，插入雇员后V_EMP_COUNT为15人。V_EMP_COUNT为公有变量，所以可以在外部程序中使用DBMS_OUTPUT.PUT_LINE输出，引用时用EMP_PK.V_EMP_COUNT的形式，说明所属的包。而私有变量V_MAX_SAL和V_MIN_SAL不能被外部访问，只能通过内部过程来修改。同样，EXIST_EMP和SHOW_MESSAGE也是私有过程，也只能在过程体内被其他模块引用。
注意：在最后一个步骤中，因为STUDENT模式调用了SCOTT模式的包，所以包名前要增加模式名SCOTT。不同的会话对包的调用属于不同的应用，所以需要重新进行初始化。


























































声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/weixin_40725706/article/detail/341668
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号