CREATE PROCEDURE procedure_name AS   ...

For example, to use the example , you can create a text (source) file called get_emp.sql containing the following code:

CREATE PROCEDURE procedure_name AS ...

For example, to use the example , you can create a text (source) file called get_emp.sql containing the following code:

CREATE PROCEDURE get_emp_rec (emp_number IN emp.empno%TYPE,

emp_ret OUT emp%ROWTYPE) AS

BEGIN

SELECT empno, ename, job, mgr, hiredate, sal, comm, deptno

INTO emp_ret

FROM emp

WHERE empno = emp_number;

END;

Then, using an interactive too such as SQL*Plus, load the text file containing the procedure by entering the command

SQLPLUS> @get_emp

to load the procedure into the current schema. (.SQL is the default file extension.) Note the slash (/) at the end of the code. This is not part of the code; it just activates the loading of the procedure.

When developing a new procedure, it is usually much more convenient to use the CREATE OR REPLACE . . . PROCEDURE command. This replaces any previous version of that procedure in the same schema with the newer version. This is done with no warning.

You can use either the keyword IS or AS after the procedure parameter list.

Privileges Required to Create Procedures

To create a stand-alone procedure or function, or package specification or body, you must meet the following prerequisites:

• You must have the CREATE PROCEDURE system privilege to create a procedure or package in your schema, or the CREATE ANY PROCEDURE system privilege to create a procedure or package in another user’s schema.

Attention: To create without errors, that is, to compile the procedure or package successfully, requires the following additional privileges:

>> The owner of the procedure or package must have been explicitly granted the necessary object privileges for all objects referenced within the body of the code;

>>The owner cannot have obtained required privileges through roles.

>> If the privileges of a procedure’s or package’s owner change, the procedure must be reauthenticated before it is executed.

>>If a necessary privilege to a referenced object is revoked from the owner of the procedure (or package), the procedure cannot be executed.

>>The EXECUTE privilege on a procedure gives a user the right to execute a procedure owned by another user.

>>Privileged users execute the procedure under the security domain of the procedure’s owner.

>>Therefore, users never have to be granted the privileges to the objects referenced by a procedure.

>>This allows for more disciplined and efficient security strategies with database applications and their users.

>>Furthermore, all procedures and packages are stored in the data dictionary

>>No quota controls the amount of space available to a user who creates procedures and packages.

Altering Stored Procedures

To alter a stored procedure , you must:-

>>  first DROP it, using the DROP PROCEDURE  command.

>> then recreate it using the CREATE PROCEDURE command.

>>Alternatively, use the CREATE OR REPLACE PROCEDURE command, which first drops the procedure or function if it exists, then recreates it as specified.

>>  The procedure  is dropped with no warning.

PROCEDURE get_emp_names (dept_num IN NUMBER) IS
emp_name VARCHAR2(10);
CURSOR c1 (depno NUMBER) IS
SELECT ename FROM emp
WHERE deptno = depno;
BEGIN
OPEN c1(dept_num);
LOOP
FETCH c1 INTO emp_name;
EXIT WHEN c1%NOTFOUND;
DBMS_OUTPUT.PUT_LINE(emp_name);
END LOOP;
CLOSE c1;
END;

In the stored procedure example, the department number is an input parameter, which is used when the parameterized cursor C1 is opened.

-The formal parameters of a procedure have three major parts:

1)name :

The name of the parameter, which must be a legal PL/SQL identifier.

2)mode :

The parameter mode, which indicates whether the parameter is an input-only parameter (IN), an output-only parameter (OUT), or is both an input and an output parameter (IN OUT). If the mode is not specified, IN is assumed.

3)datatype :

The parameter datatype is a standard PL/SQL datatype.

Parameter Modes

-You use parameter modes to define the behavior of formal parameters.

-          The three parameter modes, IN (the default), OUT, and IN OUT, can be used with any subprogram.

-          However, avoid using the OUT and IN OUT modes with functions. The purpose of a function is to take zero or more arguments and return a single value. It is poor programming practice to have a function return multiple values. Also, functions should be free from side effects, which change the values of variables not local to the subprogram.

The following table summarizes the information about parameter modes.

Parameter Datatypes

The datatype of a formal parameter consists of one of the following:

• an unconstrained type name, such as NUMBER or VARCHAR2.

• a type that is constrained using the %TYPE or %ROWTYPE attributes.

Attention: Numerically constrained types such as NUMBER(2) or VARCHAR2(20) are not allowed in a parameter list.

%TYPE and %ROWTYPE Attributes

-          However, you can use the type attributes %TYPE and %ROWTYPE to constrain the parameter.

-           For example, the GET_EMP_NAMES procedure specification could be written as

      PROCEDURE get_emp_names(dept_num IN emp.deptno%TYPE) 

-          to have the DEPT_NUM parameter take the same datatype as the DEPTNO column in the EMP table. The column and table must be available when a declaration using %TYPE (or %ROWTYPE) is elaborated.

-          Using %TYPE is recommended, since if the type of the column in the table changes, it is not necessary to change the application code.

-          If the GET_EMP_NAMES procedure is part of a package, then you can use previously-declared public (package) variables to constrain a parameter datatype. For example:
dept_number    number(2);
...
PROCEDURE get_emp_names(dept_num IN dept_number%TYPE);
-          You use the %ROWTYPE attribute to create a record that contains all the columns of the specified table. The following example defines the GET_EMP_REC procedure, that returns all the columns of the EMP table in a PL/SQL record, for the given EMPNO:
PROCEDURE get_emp_rec (emp_number IN emp.empno%TYPE,
emp_ret OUT emp%ROWTYPE) IS
BEGIN
SELECT empno, ename, job, mgr, hiredate, sal, comm, deptno
INTO emp_ret
FROM emp
WHERE empno = emp_number;
END;
You could call this procedure from a PL/SQL block as follows:


DECLARE
emp_row emp%ROWTYPE; -- declare a record matching a
-- row in the EMP table
BEGIN
get_emp_rec(7499, emp_row); -- call for emp# 7499
DBMS_OUTPUT.PUT(emp_row.ename || ' ' || emp_row.empno);
DBMS_OUTPUT.PUT(' ' || emp_row.job || ' ' || emp_row.mgr);
DBMS_OUTPUT.PUT(' ' || emp_row.hiredate || ' ' || emp_row.sal);
DBMS_OUTPUT.PUT(' ' || emp_row.comm || ' ' || emp_row.deptno);
DBMS_OUTPUT.NEW_LINE;
END;
- Stored functions can also return values that are declared using %ROWTYPE. For example:
FUNCTION get_emp_rec (dept_num IN emp.deptno%TYPE)
RETURN emp%ROWTYPE IS ...

Tables and Records

- You can pass PL/SQL tables as parameters to stored procedures and functions.

- You can also pass tables of records as parameters.

Default Parameter Values

- Parameters can take default values. You use the DEFAULT keyword or the assignment operator to give a parameter a default value. For example, the specification for the GET_EMP_NAMES procedure could be written as
PROCEDURE get_emp_names (dept_num IN NUMBER DEFAULT 20) IS ...
or as
PROCEDURE get_emp_names (dept_num IN NUMBER := 20) IS ...
- When a parameter takes a default value, it can be omitted from the actual parameter list when you call the procedure.

- When you do specify the parameter value on the call, it overrides the default value.

DECLARE Keyword

- Unlike in an anonymous PL/SQL block, you do not use the keyword DECLARE before the declarations of variables, cursors, and exceptions in a stored procedure.

- In fact, it is an error to use it.

A procedure may take one or more parameters. If a procedure takes parameters then these parameters are to be supplied at the time of calling the procedure

You write procedures using the syntax :-

PROCEDURE name [(parameter[, parameter, ...])] IS
[local declarations]
BEGIN
executable statements
[EXCEPTION
exception handlers]
END [name];

where :-

>>parameter stands for the following syntax:

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

>>You cannot impose the NOT NULL constraint on a parameter.

>>you cannot specify a constraint on the datatype. For example, the following declaration of emp_id is illegal:

PROCEDURE ... (emp_id NUMBER(4)) IS  -- illegal; should be NUMBER

BEGIN ... END;

>> A procedure has two parts:

>> the specification.

>>the body.

Procedure specification

>>begins with the keyword PROCEDURE .

>>ends with the procedure name or a parameter list.

>>Parameter declarations are optional. Procedures that take no parameters are written without parentheses.

>>The procedure body begins with the keyword IS and ends with the keyword END followed by an optional procedure name.

>> The procedure body has three parts:

>> a declarative part.

>> an executable part.

>>and an optional exception-handling part.

>>The declarative part contains:

local declarations, which are placed between the keywords IS and   BEGIN.

The keyword DECLARE, which introduces declarations in an  anonymous PL/SQL block, is not used.

>> The executable part contains:

statements, which are placed between the keywords BEGIN and EXCEPTION (or END).

At least one statement must appear in the executable part of a procedure.

The NULL statement meets this requirement.

>>  The exception-handling part contains:

exception handlers, which are placed between the keywords EXCEPTION and END.

Example 1

Consider the procedure raise_salary, which increases the salary of an employee:

PROCEDURE raise_salary (emp_id INTEGER, increase REAL) IS

   current_salary REAL;

   salary_missing EXCEPTION;

BEGIN

   SELECT sal INTO current_salary FROM emp

      WHERE empno = emp_id;

   IF current_salary IS NULL THEN

      RAISE salary_missing;

   ELSE

      UPDATE emp SET sal = sal + increase

         WHERE empno = emp_id;

   END IF;

EXCEPTION

   WHEN NO_DATA_FOUND THEN

      INSERT INTO emp_audit VALUES (emp_id, 'No such number');

   WHEN salary_missing THEN

      INSERT INTO emp_audit VALUES (emp_id, 'Salary is null');

END raise_salary;

When called:

-this procedure accepts an employee number and a salary increase amount.

-          It uses the employee number to select the current salary from the emp database table.

-          If the employee number is not found or if the current salary is null, an exception is raised. Otherwise, the salary is updated.

A procedure is called as a PL/SQL statement. For example, you might call the procedure raise_salary as follows:

CALLING: raise_salary(emp_num, amount);

Example 2

Consider the procedure compute_stud_score, which computes the total mark and average of an student and storing into stud_score table:

PROCEDURE compute_stud_score (stud_id INTEGER) IS

mark_1     number(3);
mark_2     number(3);
mark_3     number(3);
total_mark number(4);
mark_avg   number(3);

BEGIN

SELECT mark1,mark2,mark3 INTO mark_1,mark_2,mark_3  FROM student
 WHERE student_id = stud_id;

total_mark:=mark_1+mark_2+mark_3;

mark_avg  =total_mark /3;
-- inserting mark and average into stud_score table

INSERT INTO stud_score

VALUES( stud_id,total_mark,mark_avg);

EXCEPTION

WHEN NO_DATA_FOUND THEN

  INSERT INTO stud_audit
    VALUES (stud_id, 'No such Idr');

END compute_stud_score;