Oracle數據庫之開發PL/SQL子程序和包

PL/SQL塊分為匿名塊與命名塊，命名塊又包含子程序、包和觸發器。

過程和函數統稱為PL/SQL子程序，我們可以將商業邏輯、企業規則寫成過程或函數保存到數據庫中，以便共享。

過程和函數均存儲在數據庫中，並通過參數與其調用者交換信息。過程和函數的唯一區別是函數總向調用者返回數據，而過程不返回數據。

1. 存儲過程概念

存儲過程（Stored Procedure）是在大型數據庫系統中，一組為了完成特定功能的SQL語句集，存儲在數據庫中。經過第一次編譯后再次調用不需要再次編譯，用戶通過指定存儲過程的名字並給出參數（如果該存儲過程帶有參數）來執行它。

存儲過程是數據庫中的一個重要對象，任何一個設計良好的數據庫應用程序都應該用到存儲過程。

2. 創建過程

語法：

CREATE [ OR REPLACE ] PROCEDURE [ schema. ] procedure_name
   [ ( parameter_declaration [, parameter_declaration ]... ) ]
   [ invoker_rights_clause ]
   { IS | AS }
   { [ declare_section ] body | call_spec | EXTERNAL} ;

 

說明：

procedure_name：過程名稱。

parameter_declaration：參數聲明，格式如下：

parameter_name [ [ IN ] datatype [ { := | DEFAULT } expression ] | { OUT | IN OUT } [ NOCOPY ] datatype 

IN：輸入參數。

OUT：輸出參數。

IN OUT：輸入輸出參數。

invoker_rights_clause：這個過程使用誰的權限運行，格式：

AUTHID { CURRENT_USER | DEFINER }

declare_section：聲明部分。

body：過程塊主體，執行部分。

一般只有在確認procedure_name過程是新過程或是要更新的過程時，才使用OR REPALCE關鍵字，否則容易刪除有用的過程。

示例1：

CREATE PROCEDURE remove_emp (employee_id NUMBER) AS
   tot_emps NUMBER;
   BEGIN
      DELETE FROM employees
      WHERE employees.employee_id = remove_emp.employee_id;
      tot_emps := tot_emps - 1;
   END;

 示例2：

CREATE OR REPLACE PROCEDURE insert_emp(
   v_empno     in employees.employee_id%TYPE,
   v_firstname in employees.first_name%TYPE,
   v_lastname  in employees.last_name%TYPE,
   v_deptno    in employees.department_id%TYPE
   )
AS
   empno_remaining EXCEPTION;
   PRAGMA EXCEPTION_INIT(empno_remaining, -1);
BEGIN
   INSERT INTO EMPLOYEES(EMPLOYEE_ID, FIRST_NAME, LAST_NAME, HIRE_DATE,DEPARTMENT_ID)
   VALUES(v_empno, v_firstname,v_lastname, sysdate, v_deptno);
   DBMS_OUTPUT.PUT_LINE('插入成功！');
EXCEPTION
   WHEN empno_remaining THEN
      DBMS_OUTPUT.PUT_LINE('違反數據完整性約束!');
      DBMS_OUTPUT.PUT_LINE(SQLCODE||'---'||SQLERRM);
   WHEN OTHERS THEN
      DBMS_OUTPUT.PUT_LINE(SQLCODE||'---'||SQLERRM);
END;

 

 

3. 使用過程參數

當建立過程時，既可以指定過程參數，也可以不提供任何參數。

過程參數包括輸入參數、輸出參數和輸入輸出參數，其中輸入參數（IN）用於接收調用環境的輸入數據，輸出參數（OUT）用於將輸出數據傳遞到調用環境，而輸入輸出參數（IN OUT）不僅要接收輸入數據，而且還要輸出數據到調用環境。

3.1 帶有輸入參數的過程

通過使用輸入參數，可以將應用程序數據傳遞到過程。當定義過程參數時，默認參數模式是輸入參數，另外可以使用IN關鍵字顯式定義輸入參數。

示例：

CREATE OR REPLACE PROCEDURE insert_emp(
    empno employee.empno%TYPE,
    ename employee.ename%TYPE,
    job employee.job%TYPE,
    sal employee.sal%TYPE,
    comm IN employee.comm%TYPE,
    deptno IN employee.deptno%TYPE
    )
IS
BEGIN
    INSERT INTO employee VALUES(empno, ename, job, sal, comm, depno);
END;

 

 

3.2 帶有輸出參數的過程

通過在過程中使用輸出參數，可以將數據或消息傳遞到調用環境和應用程序。當定義輸出參數時，需要指定參數模式OUT。

示例：

CREATE OR REPLACE PROCEDURE update_sal(
    eno NUMBER,
    salary NUMBER,
    name out VARCHAR2) 
IS
BEGIN
    UPDATE employee SET sal=salary WHERE empno=eno
    RETURNING ename INTO name;
END;

3.3 帶有輸入輸出參數的過程

通過在過程中使用輸入輸出參數，可以在調用過程時輸入數據到過程，在調用結束后輸出數據到調用環境和應用程序。當定義輸入輸出參數時，需要指定參數模式為IN OUT。

示例：

CREATE OR REPLACE PROCEDURE divide(
    num1 IN OUT NUMBER,
    num2 IN OUT NUMBER) 
IS
    v1 NUMBER;
    v2 NUMBER;
BEGIN
    v1 := trunc(num1 / num2);
    v2 := mod(num1,num2);
    num1 := v1;
    num2 := v2;
END; 

 

 

4. 調用過程

當在SQL*PLUS中調用過程時，需要使用CALL或者EXECUTE命令，而在PL/SQL塊中過程可以直接引用。

ORACLE使用EXECUTE語句來調用存儲過程語法：

 EXEC[UTE] procedure_name(parameter1, parameter2, …); 

示例：

-- 調用刪除員工的過程
EXEC remove_emp(1);

-- 調用插入員工的過程
EXECUTE insert_emp(1, 'tommy', 'lin', 2);

 

 示例：

DECLARE
    v_name employee.ename%type;
BEGIN
    update_sal(&eno,&salary,v_name);
    dbms_output.put_line('姓名:'||v_name);
END;

 

 

5. 函數介紹

函數是一段獨立的PL/SQL程序代碼，它執行某個特定的、明確的任務。通常，函數將處理從程序的調用部分傳遞給它的信息，然后返回單個值。信息通過稱為參數的特殊標識符傳遞給函數，然后通過RETURN語句返回。

6. 創建函數

語法：

CREATE [ OR REPLACE ] FUNCTION [ schema. ] function_name
  [ ( parameter_declaration [, parameter_declaration]... ) 
  ]
  RETURN datatype
  [ { invoker_rights_clause
    | DETERMINISTIC
    | parallel_enable_clause
    | RESULT_CACHE  [ relies_on_clause ]
    }...
  ]
  { { AGGREGATE | PIPELINED }  USING [ schema. ] implementation_type
  | [ PIPELINED ] { IS | AS } { [ declare_section ] body 
                              | call_spec
                              | EXTERNAL
                              }
  } ;

 

示例：

CREATE FUNCTION get_bal(acc_no IN NUMBER) 
   RETURN NUMBER 
   IS
     acc_bal NUMBER(11,2);
   BEGIN 
      SELECT order_total INTO acc_bal FROM orders 
      WHERE customer_id = acc_no; 
      RETURN(acc_bal); 
    END;

 

 

函數參數也有輸入、輸出、輸入輸出三種模式：IN、OUT、IN OUT是形參的模式。若省略，則為IN模式。

和過程一樣，IN模式的形參只能將實參傳遞給形參，進入函數內部，但只能讀不能寫，函數返回時實參的值不變。

OUT模式的形參會忽略調用時的實參值（或說該形參的初始值總是NULL），但在函數內部可以被讀或寫，函數返回時形參的值會賦予給實參。

IN OUT具有前兩種模式的特性，即調用時，實參的值總是傳遞給形參，結束時，形參的值傳遞給實參。

調用時，對於IN模式的實參可以是常量或變量，但對於OUT和IN OUT模式的實參必須是變量。

示例：

CREATE OR REPLACE FUNCTION get_salary(
  dept_no IN NUMBER DEFAULT 1,
  emp_count OUT NUMBER)
  RETURN NUMBER
IS
  V_sum NUMBER;
BEGIN
  SELECT SUM(SALARY), count(*) INTO V_sum, emp_count FROM EMPLOYEES
  WHERE DEPARTMENT_ID=dept_no;
  RETURN v_sum;
EXCEPTION
   WHEN NO_DATA_FOUND THEN
      DBMS_OUTPUT.PUT_LINE('數據不存在');
   WHEN OTHERS THEN
      DBMS_OUTPUT.PUT_LINE('其它異常：');
      DBMS_OUTPUT.PUT_LINE('錯誤號：' || SQLCODE||'，錯誤消息：'||SQLERRM);
END get_salary;

 

 

7 函數調用

語法：

function_name([[parameter_name1 =>] value1[, [parameter_name2 =>] value2, ...]]);

 

示例1：

DECLARE
  v_num NUMBER;
  v_sum NUMBER;
BEGIN
  v_sum := get_salary(27, v_num);
  DBMS_OUTPUT.PUT_LINE('部門27的工資總和：'||v_sum||'，人數為：'||v_num);
END;

 

示例二：

DECLARE
  v_num NUMBER;
  v_sum NUMBER;
BEGIN
  v_sum := get_salary(dept_no => 27, emp_count => v_num);
  DBMS_OUTPUT.PUT_LINE('部門27的工資總和：'||v_sum||'，人數為：'||v_num);
END;

 

示例3：

DECLARE
  v_num NUMBER;
  v_sum NUMBER;
BEGIN
  v_sum := get_salary(emp_count => v_num);
  DBMS_OUTPUT.PUT_LINE('部門27的工資總和：'||v_sum||'，人數為：'||v_num);
END;

 

 

8. 刪除過程或函數

刪除過程語法：

DROP PROCEDURE [schema.]procudure_name;

刪除函數語法：

DROP FUNCTION [schema.]function_name;

9. 過程與函數比較

過程	函數
作為PL/SQL語句執行	作為表達式的一部分執行
在規范中不包含RETURN子句	必須在規范中包含RETURN子句
不返回任何值	必須返回單個值
可以RETURN語句，但是與函數不同，它不能用於返回值	必須包含至少一條RETURN語句

過程與函數的相同功能有：

1. 都使用IN模式的參數傳入數據、OUT模式的參數返回數據。
2. 輸入參數都可以接受默認值，都可以傳值或傳引導。
3. 調用時的實際參數都可以使用位置表示法、名稱表示法或組合方法。
4. 都有聲明部分、執行部分和異常處理部分。
5. 其管理過程都有創建、編譯、授權、刪除、顯示依賴關系等。

-- 包

1. 簡介

包(PACKAGE)是一種數據對象，它是一組相關過程、函數、變量、常量和游標等PL/SQL程序設計元素的組合，作為一個完整的單元存儲在數據庫中，用名稱來標識。

包類似於JAVA或C#語言中的類，包中的變量相當於類中的成員變量，過程和函數相當於類方法。

通過使用包，可以簡化應用程序設計，提高應用性能，實現信息隱藏、子程序重載等面向對象語言所具有的功能。

與高級語言中的類相同，包中的程序元素也分為公用元素和私用元素兩種，這兩種元素的區別是他們允許訪問的程序范圍不同。公用元素不僅可以被包中的函數、過程所調用，也可以被包外的PL/SQL程序訪問，而私有元素只能被包內的函數和過程序所訪問。

一般是先編寫獨立的過程與函數，待其較為完善或經過充分驗證無誤后，再按邏輯相關性組織為程序包。

2. 包的優點

1. 模塊化：使用包，可以封裝相關的類型、對象和子程序。把一個大的功能模塊划分成多個小的功能模塊，分別完成各自的功能，這樣組織的程序易於編寫，理解和管理。
2. 更輕松的應用程序設計：包規范部分和包體部分可以分別創建並編譯。換言之，我們可以在沒有編寫包體的情況下編寫包規范的代碼並進行編譯。
3. 信息隱藏：包中的元素可以分為公有元素和私有元素，公有元素可被程序包內的過程、函數等訪問，還可以被包外的PL/SQL訪問。但對於私有元素只能被包內的過程、函數等訪問。對於用戶，只需知道包規范，不用了解包體的具體細節。
4. 性能更佳：應用程序第一次調用程序包中的某個元素時，就將整個程序包加載到內存中，當第二次訪問程序包中的元素時，ORACLE將直接從內在中讀取，而不需要進行磁盤I/O操作而影響速度，同時位於內存中的程序包可被同一會話期間的其它應用程序共享。因此，程序包增加了重用性並改善了多用戶、多應用程序環境的效率。

3. 包的定義

PL/SQL中的包由包規范和包體兩部分組成。建立包時，首先要建立包規范，然后再建立對包規范的實現–包體。

包規范用於聲明包的公用組件，如變量、常量、自定義數據類型、異常、過程、函數、游標等。包規范中定義的公有組件不僅可以在包內使用，還可以由包外其他過程、函數使用。但需要說明與注意的是，為了實現信息的隱藏，建議不要將所有組件都放在包規范處聲明，只應把公共組件放在包規范部分。

包體是包的具體實現細節，它實現在包規范中聲明的所有公有過程、函數、游標等。也可以在包體中聲明僅屬於自己的私有過程、函數、游標等。

3.1 建立包規范

語法：

CREATE [ OR REPLACE ] [ EDITIONABLE | NONEDITIONABLE ]
 PACKAGE [ schema. ] package_name
  [ invoker_rights_clause ]
  { IS | AS } item_list_1 END [ package_name ] ;

item_list_1：聲明包的公用組件列表

{ type_definition -- 數據類型
| cursor_declaration -- 游標
| item_declaration -- 變量、常量等
| function_declaration -- 函數
| procedure_declaration -- 過程
}
  [ { type_definition
    | cursor_declaration
    | item_declaration
    | function_declaration
    | procedure_declaration
    | pragma
    }
  ]...

 

示例：

CREATE OR REPLACE PACKAGE emp_mgmt AS 
   -- 函數
   FUNCTION hire (last_name VARCHAR2, job_id VARCHAR2, 
      manager_id NUMBER, salary NUMBER, 
      commission_pct NUMBER, department_id NUMBER) 
      RETURN NUMBER; 
   FUNCTION create_dept(department_id NUMBER, location_id NUMBER) 
      RETURN NUMBER; 
   -- 過程
   PROCEDURE remove_emp(employee_id NUMBER); 
   PROCEDURE remove_dept(department_id NUMBER); 
   PROCEDURE increase_sal(employee_id NUMBER, salary_incr NUMBER); 
   PROCEDURE increase_comm(employee_id NUMBER, comm_incr NUMBER); 
   -- 異常
   no_comm EXCEPTION; 
   no_sal EXCEPTION; 
END emp_mgmt; 

 

3.2 建立包體
語法：

CREATE [ OR REPLACE ] PACKAGE BODY [ schema. ] package_name
{ IS | AS } 
    BEGIN statement [ statement | pragma ]...
      [ EXCEPTION exception_handler [ exception_handler ]... ]
 [ initialize_section ]
END [ package_name ] ;

 

示例：

CREATE OR REPLACE PACKAGE BODY emp_mgmt AS 
   tot_emps NUMBER; 
   tot_depts NUMBER; 
FUNCTION hire 
   (last_name VARCHAR2, job_id VARCHAR2, 
    manager_id NUMBER, salary NUMBER, 
    commission_pct NUMBER, department_id NUMBER) 
   RETURN NUMBER IS new_empno NUMBER; 
BEGIN 
   SELECT employees_seq.NEXTVAL 
      INTO new_empno 
      FROM DUAL; 
   INSERT INTO employees 
      VALUES (new_empno, 'First', 'Last','[e-mail]', 
              '[phone]','18-JUN-02','IT_PROG',90000000,00, 
              100,110); 
      tot_emps := tot_emps + 1; 
   RETURN(new_empno); 
END; 
FUNCTION create_dept(department_id NUMBER, location_id NUMBER) 
   RETURN NUMBER IS 
      new_deptno NUMBER; 
   BEGIN 
      SELECT departments_seq.NEXTVAL 
         INTO new_deptno 
         FROM dual; 
      INSERT INTO departments 
         VALUES (new_deptno, 'department name', 100, 1700); 
      tot_depts := tot_depts + 1; 
      RETURN(new_deptno); 
   END; 
PROCEDURE remove_emp (employee_id NUMBER) IS 
   BEGIN 
      DELETE FROM employees 
      WHERE employees.employee_id = remove_emp.employee_id; 
      tot_emps := tot_emps - 1; 
   END; 
PROCEDURE remove_dept(department_id NUMBER) IS 
   BEGIN 
      DELETE FROM departments 
      WHERE departments.department_id = remove_dept.department_id; 
      tot_depts := tot_depts - 1; 
      SELECT COUNT(*) INTO tot_emps FROM employees; 
   END; 
PROCEDURE increase_sal(employee_id NUMBER, salary_incr NUMBER) IS 
   curr_sal NUMBER; 
   BEGIN 
      SELECT salary INTO curr_sal FROM employees 
      WHERE employees.employee_id = increase_sal.employee_id; 
      IF curr_sal IS NULL 
         THEN RAISE no_sal; 
      ELSE 
         UPDATE employees 
         SET salary = salary + salary_incr 
         WHERE employee_id = employee_id; 
      END IF; 
   END; 
PROCEDURE increase_comm(employee_id NUMBER, comm_incr NUMBER) IS 
   curr_comm NUMBER; 
   BEGIN 
      SELECT commission_pct 
      INTO curr_comm 
      FROM employees 
      WHERE employees.employee_id = increase_comm.employee_id; 
      IF curr_comm IS NULL 
         THEN RAISE no_comm; 
      ELSE 
         UPDATE employees 
         SET commission_pct = commission_pct + comm_incr; 
      END IF; 
   END; 
END emp_mgmt;

4. 調用包的組件

包的名稱是唯一的，但對於兩個包中的公有組件的名稱可以相同，用“包名.公有組件名“加以區分。

示例：

DECLARE
    new_dno NUMBER; -- 部門編號
BEGIN
    -- 調用emp_mgmt包的create_dept函數創建部門：
    new_dno := emp_mgmt.create_dept(85, 100);
    DBMS_OUTPUT.PUT_LINE('部門編號：' || new_dno);

    -- 調用emp_mgmt包的increase_sal過程為員工加薪：
    emp_mgmt.increase_sal(23, 800);
END;

5. 包中的游標

在包中使用無參游標，示例：

--定義包規范
CREATE OR REPLACE PACKAGE PKG_STU IS
    CURSOR getStuInfo RETURN stuInfo%ROWTYPE; 
END PKG_STU;

--定義包體
CREATE OR REPLACE PACKAGE BODY PKG_STU AS
    CURSOR getStuInfo RETURN stuInfo%ROWTYPE IS
        SELECT * FROM stuInfo; 
END PKG_STU;

--調用包組件
BEGIN
    FOR stu_Record IN PKG_STU.getStuInfo LOOP  
       DBMS_OUTPUT.PUT_LINE('學員姓名:'||stu_Record.name||'，學號:'||stu_Record.id||'，年齡:'||stu_Record.age);      
    END LOOP; 
END;  

在包中使用有參數的游標，示例：

--定義包規范
CREATE OR REPLACE PACKAGE PKG_STU IS
    CURSOR getStuInfo(studentNo VARCHAR2) RETURN stuInfo%ROWTYPE; 
END PKG_STU;

--定義包體
CREATE OR REPLACE PACKAGE BODY PKG_STU AS
    CURSOR getStuInfo(studentNo VARCHAR2) RETURN stuInfo%ROWTYPE IS
        SELECT * FROM stuInfo WHERE id=studentNo; 
END PKG_STU;

--調用包組件
BEGIN
    FOR stu_Record IN PKG_STU.getStuInfo(2) LOOP  
        DBMS_OUTPUT.PUT_LINE('學員姓名:'||stu_Record.name||'，學號:'||stu_Record.id||'，年齡:'||stu_Record.age);      
    END LOOP; 
END;

由於游標變量是一個指針，其狀態是不確定的，因此它不能隨同包存儲在數據庫中，即不能在PL/SQL包中聲明游標變量。但在包中可以創建游標變量參照類型，並可向包中的子程序傳遞游標變量參數。

示例：

-- 創建包規范
CREATE OR REPLACE PACKAGE CURROR_VARIBAL_PKG AS
  TYPE dept_cur_type IS REF CURSOR RETURN dept%ROWTYPE; --強類型

  TYPE cur_type IS REF CURSOR;-- 弱類型

  PROCEDURE proc_open_dept_var(
    dept_cur IN OUT dept_cur_type,
    choice INTEGER DEFAULT 0,
    dept_no NUMBER DEFAULT 50,
    dept_name VARCHAR DEFAULT '%');
END;

-- 創建包體
CREATE OR REPLACE PACKAGE BODY CURROR_VARIBAL_PKG
AS
  PROCEDURE proc_open_dept_var(
    dept_cur IN OUT dept_cur_type,
    choice INTEGER DEFAULT 0,
    dept_no NUMBER DEFAULT 50,
    dept_name VARCHAR DEFAULT '%')
  IS 
  BEGIN
    IF choice = 1 THEN
      OPEN dept_cur FOR SELECT * FROM dept WHERE deptno = dept_no;
    ELSIF choice = 2 THEN
      OPEN dept_cur FOR SELECT * FROM dept WHERE dname LIKE dept_name;
    ELSE
      OPEN dept_cur FOR SELECT * FROM dept;
    END IF;
  END proc_open_dept_var;
END CURROR_VARIBAL_PKG;

 

定義一個過程，打開弱類型的游標變量：

--定義過程
CREATE OR REPLACE PROCEDURE proc_open_cur_type(
  cur IN OUT CURROR_VARIBAL_PKG.cur_type,
  first_cap_in_table_name CHAR) 
AS
BEGIN
  IF first_cap_in_table_name = 'D' THEN
    OPEN cur FOR SELECT * FROM dept;
  ELSE
    OPEN cur FOR SELECT * FROM emp;
  END IF;
END proc_open_cur_type;

測試包中游標變量類型的使用：

DECLARE 
  dept_rec Dept%ROWTYPE;
  emp_rec Emp%ROWTYPE;
  dept_cur CURROR_VARIBAL_PKG.dept_cur_type;
  cur CURROR_VARIBAL_PKG.cur_type;
BEGIN
  DBMS_OUTPUT.PUT_LINE('游標變量強類型：');
  CURROR_VARIBAL_PKG.proc_open_dept_var(dept_cur, 1, 30);
  FETCH dept_cur INTO dept_rec;
  WHILE dept_cur%FOUND LOOP
    DBMS_OUTPUT.PUT_LINE(dept_rec.deptno||':'||dept_rec.dname);
    FETCH dept_cur INTO dept_rec;
  END LOOP;
  CLOSE dept_cur;

  DBMS_OUTPUT.PUT_LINE('游標變量弱類型：');
  CURROR_VARIBAL_PKG.proc_open_dept_var(cur, 2, dept_name => 'A%');
  FETCH cur INTO dept_rec;
  WHILE cur%FOUND LOOP
    DBMS_OUTPUT.PUT_LINE(dept_rec.deptno||':'||dept_rec.dname);
    FETCH cur INTO dept_rec;
  END LOOP;

  DBMS_OUTPUT.PUT_LINE('游標變量弱類型—dept表：');
  proc_open_cur_type(cur, 'D');
  FETCH cur INTO dept_rec;
  WHILE cur%FOUND LOOP
    DBMS_OUTPUT.PUT_LINE(dept_rec.deptno||':'||dept_rec.dname);
    FETCH cur INTO dept_rec;
  END LOOP;

  DBMS_OUTPUT.PUT_LINE('游標變量弱類型—emp表：');
  proc_open_cur_type(cur, 'E');
  FETCH cur INTO emp_rec;
  WHILE cur%FOUND LOOP
    DBMS_OUTPUT.PUT_LINE(emp_rec.empno||':'||emp_rec.ename);
    FETCH cur INTO emp_rec;
  END LOOP;
  CLOSE cur;
END;

 

 

6. 子程序重載

所謂重載時指兩個或多個子程序有相同的名稱，但擁有不同的參數變量、參數順序或參數數據類型。

在調用重載子程序時，主程序將根據實際參數的類型和數目，自動確定調用哪個子程序。

PL/SQL允許對包內子程序和本地子程序進行重載。

示例：

-- 定義包規范
CREATE OR REPLACE PACKAGE PKG_EMP AS
    FUNCTION get_salary(eno NUMBER) RETURN NUMBER;
    FUNCTION get_salary(empname VARCHAR2) RETURN NUMBER;
END PKG_EMP;

-- 定義包體
CREATE OR REPLACE PACKAGE BODY PKG_EMP AS
    FUNCTION get_salary(eno NUMBER) RETURN NUMBER
      IS
        v_salary NUMBER(10, 4);
      BEGIN
        SELECT sal INTO v_salary FROM emp WHERE empno=eno;
        RETURN v_salary;
      END;

    FUNCTION get_salary(empname VARCHAR2) RETURN NUMBER
      IS
        v_salary NUMBER(10, 4);
      BEGIN
        SELECT sal INTO v_salary FROM emp WHERE ename=empname;
        RETURN v_salary;
      END;
END PKG_EMP;

 

 

測試：

DECLARE
  v_sal NUMBER(10, 4);
BEGIN  
  v_sal := PKG_EMP.get_salary(7499);
  DBMS_OUTPUT.PUT_LINE('工資：' || v_sal);
  v_sal := PKG_EMP.get_salary('MARTIN');
  DBMS_OUTPUT.PUT_LINE('工資：' || v_sal);
END;