1

ORACLE:
PL/SQL
QUICK

REFERENCE

By:
Gajendra Reddy Atla

PL/SQL Quick Reference By A.G.Reddy

 2

CONTENTS
1. INTRODUCTION TO PL/SQL 4
• About PL/SQL
• Advantages of PL/SQL
• PL/SQL Execution Environment
• PL/SQL block structure
• PL/SQL Block types
• Parameters

2. VARIABLES 9

3. CONTROL STRUCTURES 12
• Conditional Control
• Iterative Control
• Sequential Control

4. CURSORS 17
• Types of Cursors
• Difference B/W Normal Cursor & Ref Cursor
• Cursor For Loop
• Cursor with Return statement
• Cursor attributes

5. PACKAGES 22
• Introduction
• Advantages
• Package Components
• Types of Packages
• Creating New Package
• Referencing Package Components
• Using Oracle Supplied Packages

6. TRIGGERS 26
• Introduction
• Parts of a Trigger
• Types of Triggers
• Order of Trigger Firing
• Dropping, Disabling and Enabling
• Examples

7. EXCEPTION HANDLING 32
• Introduction
• Predefined Exception
PL/SQL Quick Reference By A.G.Reddy
 3
• User-defined Exception
• RAISE_APPLICATION_ERROR
• WHEN OTHERS Clause
• SQLCODE and SQLERRM
• Raising Exceptions

8. COLLECTIONS 35
• Introduction
• Nested Table
• Varray
• Index-By Table
• Collection Methods
• Bulk Collect

9. OVERLOADING 40

10. FREQUENTLY ASKED QUESTIONS 42

1. INTRODUCTION TO PL/SQL
PL/SQL Quick Reference By A.G.Reddy
 4

About PL/SQL:
• PL/SQL stands for Procedural Language/SQL.
• Pl/SQL is the procedural extension to SQL with design features of programming languages.
• Data manipulation and query statements of SQL are included with in procedural units of code.
• The basic unit in PL/SQL is a block.
• All PL/SQL programs are made up of blocks, which can be nested within each other.
• Typically, each block performs a logical action in the program.

Advantages of PL/SQL:
PL/SQL is a completely portable, high-performance transaction processing language that offers the
following advantages:
1) Support for SQL.
2) Higher productivity.
3) Better performance.
4) Portability.
5) Integration with Oracle.
6) Modularize program development.
a) We can Group logically related statements with in blocks.
b) We can place reusable PL/SQL code for future use in libraries.
7) Programming with control structures. (Like for, while loops).

Support for SQL:

SQL has become the standard database language because it is flexible, powerful, and easy to learn. A few
English-like commands such as INSERT, UPDATE, and DELETE make it easy to manipulate the data
stored in a relational database.
SQL is non-procedural, meaning that you can state what you want done without stating how to do it.
Oracle determines the best way to carry out your request. There is no necessary connection between
consecutive statements because Oracle executes SQL statements one at a time.
PL/SQL lets you use all the SQL data manipulation, cursor control, and transaction control commands, as
well as all the SQL functions, operators, and pseudo columns. So, you can manipulate Oracle data flexibly
and safely.

Higher Productivity:
PL/SQL adds functionality to non-procedural tools such as Oracle Forms and Oracle Reports. With PL/SQL in
these tools, you can use familiar procedural constructs to build applications. For example, you can use an entire
PL/SQL block in an Oracle Forms trigger. You need not use multiple trigger steps, macros, or user exits.
Thus, PL/SQL increases productivity by putting better tools in your hands. Moreover, PL/SQL is the same
in all environments. As soon as you master PL/SQL with one Oracle tool, you can transfer your
knowledge to other tools, and so multiply the productivity gains. For example, scripts written with one
tool can be used by other tools.

Better Performance
Without PL/SQL, Oracle must process SQL statements one at a time. Each SQL statement results in
another call to Oracle and higher performance overhead. In a networked environment, the overhead can
become significant. Every time a SQL statement is issued, it must be sent over the network, creating more
traffic. However, with PL/SQL, an entire block of statements can be sent to Oracle at one time. This can
drastically reduce communication between your application and Oracle.
Portability:

PL/SQL Quick Reference By A.G.Reddy

 5
Applications written in PL/SQL are portable to any operating system and platform on which Oracle runs.
In other words, PL/SQL programs can run anywhere Oracle can run; you need not tailor them to each new
environment. That means you can write portable program libraries, which can be reused in different
environments.

Integration with Oracle:

Both PL/SQL and Oracle are based on SQL. Moreover, PL/SQL supports all the SQL datatypes.
Combined with the direct access that SQL provides, these shared datatypes integrate PL/SQL with the
Oracle data dictionary. The %TYPE and %ROWTYPE attributes further integrate PL/SQL with the data
dictionary. For example, you can use the %TYPE attribute to declare variables, basing the declarations on
the definitions of database columns. If a definition changes, the variable declaration changes accordingly
at run time. This provides data independence, reduces maintenance costs, and allows programs to adapt as
the database changes to meet new business needs.

PL/SQL Execution Environment:

The PL/SQL engine resides in the oracle engine, the oracle engine processes not only single SQL
statements but also entire PL/SQL blocks.
3. First the PL/SQL blocks are sent to the PL/SQL engine.
4. Procedural statements are executed in procedural statement executor.
5. The SQL statements are sent to the SQL statement executor in the oracle engine.

The call to the oracle engine needs to be made only once to execute any number of SQL statements, if
these SQL statements are bundled inside a PL/SQL block.

PL/SQL block structure:

PL/SQL is a block-structured language. That is, the basic units (procedures, functions, and anonymous
blocks) that make up a PL/SQL program are logical blocks, which can contain any number of nested sub-
blocks. Typically, each logical block corresponds to a problem or sub problem to be solved. Thus,
PL/SQL supports the divide-and-conquer approach to problem solving called stepwise refinement.
The PL/SQL block contains following sections.
1. Declare (Optional)
2. Begin (Mandatory)
3. Exception (Optional)
4. End (Mandatory)

PL/SQL block structure

PL/SQL Quick Reference By A.G.Reddy
 6
DECLARE (Optional)
Variables, Cursors, User-Defined Exceptions
BEGIN (Mandatory)
-SQL Statements
-PL/SQL Statements
EXCEPTION (Optional)
Actions to perform when errors occur
END; (Mandatory)

PL/SQL Block types:

The PL/SQL programming contains the following types of blocks.
1. Procedure
2. Function
3. Anonymous block

1. PROCEDURE:
• PL/SQL procedures behave very much like procedures in other programming language.
• Procedures are traditionally the workhorse of the coding world.

Simple Procedure
/* Finds the given number is odd or even */
create or replace procedure prc_even_odd(i_number in number,
o_result out varchar2)
is
begin
if (mod(i_number,2) = 0) then
o_result := 'EVEN';
else
o_result := 'ODD';
end prc_even;

To execute the above code, run the following statement:

1. Var a varchar2(10);
2. Exec prc_even_odd(10, :a);
3. print a;
The first one is bind variable declaration. We need to supply some bind variables to the procedures at
the time their calling to capture the output data. The print command prints the data held by variable a.

2. FUNCTION:
• Functions are traditionally the smaller, more specific pieces of code.
• Functions must return a value.
• Generally used for calculations.

Simple Function

PL/SQL Quick Reference By A.G.Reddy

 7
/* Calculates simple Interest */
create or replace function f_sim_intr(p in number,
t in number,
r in number) return number
is
si number(10);
begin
si:=(p*t*r)/100;
return si;
end;

To test the above function, run the following statement:

1. Select f_sim_intr (1000,3,2) from dual;

Differences B/w Function and Procedure:

FUNCTION PROCEDURE
1 A function MUST return a value A procedure cannot return a value

The return statement in a function returns The return statement of a procedure

2 control to the calling program and returns returns control to the calling program and
the results of the function cannot return a value

3 Functions can be called from SQL, procedure cannot

4 Functions are considered expressions, procedure are not

5 Functions used for calculation purpose Used for data processing purpose

Restrictions in executing procedures and functions:

• We can not call a function from a select statement if the function has any DML operations.
• We can not call a function from a select statement if the function has IN OUT parameter.
• We can not execute a procedure with execute statement if the function has IN OUT parameter.

To overcome all these The PL/SQL has one more block called “Anonymous Block”.

3 ANONYMOUS BLOCK:
Anonymous blocks are unnamed PL/SQL blocks. The anonymous block is missing the header section
altogether. Instead it simply uses the DECLARE reserved word to mark the beginning of its optional
declaration section. Anonymous blocks can also serve as nested blocks inside procedures, functions, and
other anonymous blocks.

The Below function objective is to select salary of a particular employee and ‘y’ if data exists. But
the function is able to return one value. To overcome this we have declared one out parameter & one
return statement.

PL/SQL Quick Reference By A.G.Reddy

 8
create or replace function fn_Test(i_num in number
,o_res out number)
return varchar2
is
begin
select salary into o_res from employees where employee_id = i_num;
return 'Y';
exception
when others then
return 'N';
end;

To execute this function use the following anonymous block.

Anonymous Block

declare
a number;
b varchar2(10);
begin
b := fn_test(101,a);
dbms_output.put_line(b);
dbms_output.put_line(a);
end;

Parameters:
• Named PL/SQL programs (procedures and functions) can take parameters.
• Parameters are named variables that are available to a program and that modify program
behavior and/or data.
• Parameters are optional on both procedures and functions.
• Parameters are declared when a procedure or function are declared and are declared
between an open and a close parenthesis (()).
• There are three types of parameter:
1. IN
2. OUT and
3. IN OUT
1) An IN parameter is used an input only. An IN parameter cannot be changed
by the called program.
2) An OUT parameter is initially NULL. The program assigns the parameter a
value and that value is returned to the calling program.
3) An IN OUT parameter may or may not have an initial value. That initial
value may or may not be modified by the called program. Any changes made to the parameter
are returned to the calling program.

Parameters are declared with data types but without data type length or precision. That means that
a parameter may be declared as VARCHAR2 but it will not be declared with a length component
(VARCHAR2 (30) would not be valid). Parameters may also be assigned a default value. You can either
use the assignment operator (:=) or use the DEFAULT keyword. When a parameter has a default value,
you do not need to include that parameter in the call. You MUST always include IN OUT and OUT
parameters.

PL/SQL Quick Reference By A.G.Reddy

 9

2. VARIABLES
Information is transmitted between a PL/SQL program and the database through variables. Every
variable has a specific type associated with it.

Variables can be used for:

1. Temporary storage of data.
2. Manipulation of stored values.
3. Reusability.
4. Ease of maintenance.

Handling of variables in pl/sql:

1. Declare and initialize variables in the declaration section.
2. Assign new values to variables in the executable section.
3. Pass values into pl/sql blocks through parameters.
4. View results through output variables.

Types of variables:
S.No Type Sub Type

Scalar
Composite

1 PL/SQL Variables Reference

LOB (Large Objects)

2 Non- PL/SQL Variables Bind and Host Variables

The syntax for declaring variables is:

1 Declaring a variable: Name varchar2 (40);

2 Declaring a constant: Pie CONSTANT numeric (1, 3):=

3.142;

3 Declaring a variable with an initial value (not a Message varchar2 (10):= 'Example';
constant):

Scalar Data Types:

scalar data types are those which hold a single value and do not have any internal
components
S.No Datatype S.No Datatype
1 char 4 date
2 Varchar2 5 timestamp
3 long 6 Boolean etc…

PL/SQL Quick Reference By A.G.Reddy

10
Composite Data Type:
A scalar has no internal components. A composite has internal components that can be manipulated
individually. Composite data types are reusable. Composite data types (also known as collections) are of
• TABLE
• RECORD
• NESTED TABLE
• VARRAY

LOB Data type variables:

With the LOB data types you can store blocks of unstructured data (such as text, graphic, image,
video clips and sound wave forms) up to 4 gigabytes in size. Oracle provides four LOB data types:
1. BFILE (Binary File): Large binary objects stored in operating system files outside of the database;
for example, a bitmap image file.
2. BLOB (Binary large object): Large objects consisting of unstructured binary data.
3. CLOB (Character large object): Large objects consisting of single-byte fixed-width character data.
4. NCLOB (National language character large object): Large binary objects consisting of single-byte
or multiple-byte fixed-width character data.

Internal and external LOBs:

There are two categories of LOBs, depending upon their location with respect to the physical
database:
1) Internal LOBs (of datatypes BLOB, CLOB, and NCLOB) are stored in the database and
can participate in transactions. Changes to internal LOB values can be rolled back or committed.
A cursor can select an internal LOB FOR UPDATE. Uncommitted changes to an internal LOB
are not seen by a separate session.
2) External LOBs (of datatype BFILE) are stored outside of the database in operating system
files and cannot participate in transactions. Instead, the underlying operating system provides the
data integrity. Access to external LOBs is read-only.

Using Bind Variables:

Bind variables are used in SQL and PL/SQL statements for holding data or result sets. They are
commonly used in SQL statements to optimize statement performance. A statement with a bind variable
may be re-executed multiple times without needing to be re-parsed. Their values can be set and referenced
in PL/SQL blocks. They can be referenced in SQL statements e.g. SELECT. Except in the VARIABLE
and PRINT commands, bind variable references should be prefixed with a colon.
Bind variables are created with the VARIABLE command. The following PL/SQL block sets a
bind variable:
1. variable bv number
2. begin
:bv := 8;
end;
Once a value is set, you can show it with the PRINT command.
• print bv;

DBMS_OUTPUT.PUT_LINE:
• An Oracle-supplied packaged procedure
• An alternative for displaying data from a PL/SQL block
• Must be enabled in SQL*Plus with
SET SERVEROUTPUT ON

PL/SQL Quick Reference By A.G.Reddy

11
DBMS_OUTPUT.PUT_LINE
create or replace procedure prc_emp_details(i_deptno in emp.deptno%type)
is
cursor c_emp_dtls is
select *
from emp
where deptno = i_deptno;
begin
for emp_rec in c_emp_dtls loop
dbms_output.put_line(emp_rec.deptno ||' '|| emp_rec.empno);
end loop;
end;
To execute the above code, run the following statement:
• Exec prc_emp_details (10, :a);

PL/SQL Quick Reference By A.G.Reddy

12
3. CONTROL STRUCTURES
This chapter shows you how to structure the flow of control through a PL/SQL program. You learn
how statements are connected by simple but powerful control structures that have a single entry and exit
point. Collectively, these structures can handle any situation. Their proper use leads naturally to a well-
structured program.

TYPES OF CONTROL STRUCTURES:

S.No Type Sub Types
1 1). IF-THEN-END IF
Conditional Control 2). IF-THEN-ELSE-END IF
3). IF-THEN-ELSIF-END IF
1). BASIC LOOP
2 Iterative Control 2). FOR LOOP
3). WHILE LOOP
3 Sequential Control 1). GOTO
2). NULL

According to the structure theorem, any computer program can be written using the basic control
structures shown in Figure. They can be combined in any way necessary to deal with a given problem.
Control Structures:

CONDITIONAL CONTROL:
Often, it is necessary to take alternative actions depending on circumstances. The IF statement lets
you execute a sequence of statements conditionally. That is, whether the sequence is executed or not
depends on the value of a condition. There are three forms of IF statements: IF-THEN, IF-THEN-ELSE,
and IF-THEN-ELSIF.

1). IF-THEN-END IF:

The simplest form of IF statement associates a condition with a sequence of statements enclosed
by the keywords THEN and END IF (not ENDIF), as follows:

PL/SQL Quick Reference By A.G.Reddy

13
IF-THEN-END IF
create or replace procedure prc_cs
is
n number;
begin
dbms_output.put_line('Enter any number');
n:=&number;
if n>5 then
dbms_output.put_line('Entered number is greater than 5');
end if;
End;

2). IF-THEN-ELSE-END IF:

The second form of IF statement adds the keyword ELSE followed by an alternative sequence of
statements, as follows:

IF-THEN-ELSE-END IF
create or replace procedure prc_cs
is
n number;
begin
dbms_output.put_line('Enter any number');
n:=&number;
if n>5 then
dbms_output.put_line('Entered number greater than 5');
else
dbms_output.put_line('Entered number less than 5');
end if;
end;

3). IF-THEN-ELSIF-END IF:

Sometimes you want to select an action from several mutually exclusive alternatives. The third
form of IF statement uses the keyword ELSIF (not ELSEIF) to introduce additional conditions, as follows:

IF-THEN-ELSEIF-ELSE-END IF
create or replace procedure prc_test
is
day varchar2(3):=to_char(sysdate,'dy');
begin
if day='sat' then
dbms_output.put_line('enjoy weekend');
elsif day='sun' then
dbms_output.put_line('enjoy weekend');
else
dbms_output.put_line('have a nice day');
end if;
end;

PL/SQL Quick Reference By A.G.Reddy

14

Using CASE Statements:

Like the IF statement, the CASE statement selects one sequence of statements to execute.
However, to select the sequence, the CASE statement uses a selector rather than multiple Boolean
expressions. A selector is an expression whose value is used to select one of several alternatives.

Using Case statement

Create or replace procedure prc_grade
is
Grade CHAR(1);
BEGIN
Grade := 'B';
CASE Grade
WHEN 'A' THEN DBMS_OUTPUT.PUT_LINE('Excellent');
WHEN 'B' THEN DBMS_OUTPUT.PUT_LINE('Very Good');
WHEN 'C' THEN DBMS_OUTPUT.PUT_LINE('Good');
WHEN 'D' THEN DBMS_OUTPUT.PUT_LINE('Fair');
WHEN 'F' THEN DBMS_OUTPUT.PUT_LINE('Poor');
ELSE DBMS_OUTPUT.PUT_LINE('No Such Grade');
END CASE;
END;

ITERATIVE CONTROL:
LOOP statement executes the body statements multiple times. The statements are placed between
LOOP – END LOOP keywords. EXIT statement is used inside LOOP to terminate it.

1). BASIC LOOP:

The simplest form of LOOP statement is the basic loop, which encloses a sequence of statements
between the keywords LOOP and END LOOP, as follows:

BASIC LOOP
create or replace procedure prc_num
is
n number:=0;
begin
loop
dbms_output.put_line(n);
n:=n+1;
exit when n>10;
end loop;
end;

2). FOR LOOP:

Simple FOR loops iterate over a specified range of integers. The number of iterations is known
before the loop is entered. A double dot (..) serves as the range operator. The range is evaluated when the
FOR loop is first entered and is never re-evaluated. If the lower bound equals the higher bound, the loop
body is executed once.

PL/SQL Quick Reference By A.G.Reddy

15

FOR LOOP
create or replace procedure prc_num1
is
n number:=0;
begin
for i in 1..100 loop
dbms_output.put_line(n);
n:=n+1;
end loop;
end;

3). WHILE LOOP:

The WHILE-LOOP statement executes the statements in the loop as long as a condition is true:
WHILE LOOP
create or replace procedure prc_num1
is
n number:=0;
begin
while n<100 loop
dbms_output.put_line(n);
n:=n+1;
end loop;
end;

SEQUENTIAL CONTROL:
Unlike the IF and LOOP statements, the GOTO and NULL statements are not crucial to PL/SQL
programming. The GOTO statement is seldom needed. Occasionally, it can simplify logic enough to
warrant its use. The NULL statement can improve readability by making the meaning and action of
conditional statements clear.
1). GOTO: The GOTO statement branches to a label unconditionally. The label must be unique within its
scope and must precede an executable statement or a PL/SQL block. When executed, the GOTO statement
transfers control to the labeled statement or block. The labeled statement or block can be down or up in
the sequence of statements.

GOTO Statement
create or replace procedure prc_goto is
n number;
begin
dbms_output.put_line('Enter any Number');
n:=&number;
if n>10 then
goto print;
end if;
dbms_output.put_line('less than 10');
<<print>>
dbms_output.put_line('Greater than 10');
end;

PL/SQL Quick Reference By A.G.Reddy

16
2). NULL: The NULL statement does nothing, and passes control to the next statement. Some languages
refer to such an instruction as a no-op (no operation).
NULL Statement
create or replace procedure prc_cs
is
n number;
begin
dbms_output.put_line('Enter any number');
n:=&number;
if n>5 then
dbms_output.put_line('Entered number greater than 5');
else
NULL;
end if;
end;

PL/SQL Quick Reference By A.G.Reddy

17
4. CURSORS
The Cursor is a handle (name or a pointer) for the memory associated with a specific statement. A
cursor is basically an Area allocated by Oracle for executing the Sql Statements. Every SQL statement
executed by the RDBMS has a private SQL area that contains information about the SQL statement and
the set of data returned. In PL/SQL, a cursor is a name assigned to a specific private SQL area for a
specific SQL statement. There can be either static cursors, whose SQL statement is determined at compile
time, or dynamic cursors, whose SQL statement is determined at runtime.
• It is a temporary memory location.
• Used to hold the transactional data in the logical memory.
• It is valid in PL/SQL block only.
• It is not stored in the database permanently.
• It is not a reusable component.

Types of Cursors:
S.No TYPES OF CURSORS
1 Implicit Cursor -------
a). Simple cursor
2 Explicit Cursor b). Parameterized cursor
c). Ref Cursor
d). Cursor With Return
Statement

1). Implicit Cursor:

Whenever a SQL statement is directly in the execution or exception section of a PL/SQL block,
you are working with implicit cursors. These statements include INSERT, UPDATE, DELETE, and
SELECT INTO statements. Unlike explicit cursors, implicit cursors do not need to be declared, OPENED,
FETCHED, or CLOSED.
SELECT statements handle the %FOUND and %NOTFOUND attributes differently from explicit
cursors. When an implicit SELECT statement does not return any rows, PL/SQL immediately raises the
NO_DATA_FOUND exception and control passes to the exception section. When an implicit SELECT
returns more than one row, PL/SQL immediately raises the TOO_MANY_ROWS exception and control
passes to the exception section.

2). Explicit Cursor:

When a cursor name is explicitly assigned to a SELECT statement through CURSOR statement, it
is called an explicit cursor. Explicit cursors are generally used to work with more than one row within
PL/SQL. There exist mainly four steps to work with explicit cursor. The following are those four steps:
1. Declare cursor
2. Open cursor
3. Fetch rows (or values) from cursor (each row at a time)
4. Close cursor

Declaring a cursor is possible through CURSOR statement. Opening a cursor is possible through
OPEN statement. Fetching rows from the cursor is possible through FETCH statement. Closing a cursor is
possible through CLOSE statement. So, it is very easy to remember all four operations with the
cursor. These four options are all automatically handled by Oracle in the case of IMPLICIT cursor (like
implicit FOR loop with SELECT).

PL/SQL Quick Reference By A.G.Reddy

18

2a). Simple Cursor:

Simple Cursor is a cursor without parameters, such as:
Simple Cursor
create or replace procedure prc_emp_dtls
is
cursor c_emp_dtls is select deptno, max(sal) max_sal
from emp
group by deptno;
lr_emp c_emp_dtls%rowtype;
a number;
begin
open c_emp_dtls;
loop
fetch c_emp_dtls into lr_emp;
exit when c_emp_dtls%notfound;
insert into high_sal_emp(deptno, sal)
values (lr_emp.deptno
,lr_emp.max_sal );
end loop;
close c_emp_dtls;
commit;
end;

2b). Parameterized cursor:

Parameterized cursor is a cursor that accepts arguments through a parameter list:

Parameterized cursor
create or replace procedure prc_cur_details(i_location in dept.loc%type)
is
cursor c_loc is select deptno
from dept
where loc = i_location;
cursor c_emp(l_deptno dept.deptno%type) is select *
from emp
where deptno = l_deptno;
begin
for rec_loc in c_loc loop
for rec_emp in c_emp(rec_loc.deptno) loop
dbms_output.put_line(rec_emp.deptno ||' '||rec_emp.empno||' '||rec_emp.ename);
end loop;
end loop;
end;

2c). Ref Cursor:

Cursor variables are like pointers to result sets. You use them when you want to perform a query in
one subprogram, and process the results in a different subprogram (possibly one written in a different
language). A cursor variable has data type REF CURSOR, and you might see them referred to informally
as REF Cursors.

PL/SQL Quick Reference By A.G.Reddy

19
A REF CURSOR is majorly used when we want to execute a dynamic select statement causes to
retrieve more than one record. We can pass Ref cursor result as a out parameter which can be used in other
subprograms.
Reference cursors have 2 types.
1. Strong cursors and
2. Week-cursors
In strong cursor we given return type. In week cursor no return type

Ref Cursor
1 create or replace procedure prc_ref(i_deptno in dept.deptno%type
2 ,o_result out sys_refcursor)
3 is
4 begin
5 open o_result for select empno
6 ,ename
7 ,sal
8 ,job
9 ,hiredate
10 from emp
11 where deptno = i_deptno;
12 end;

To execute this code run the following statements:

1. Var a refcursor;
2. Exec prc_ref (40, :a);
3. Print a;
Differences B/W Cursor and Ref Cursor:
S.No CURSOR REF CURSOR

1 Doesn't have return type. Have a return type. Basically a data type
2 Normal cursors are static cursors. Ref cursors are Dynamic cursors.
3 We can't able to pass like parameter. Ref cursor used for passing cursor parameter.
4 The SQL query has to be defined at The cursor declaration is not associated with any
the time of declaring the cursor itself. SQL query; it is associated with a query at a
later stage this brings in a lot of flexibility as
different SQL queries can be associated with the
cursor.
5 Explicit cursors are generally used to Ref cursor is a cursor variable that point to any
work with more than one row cursor, mainly used for returning the cursor
output.
Cursor For Loop:
A cursor FOR loop is a loop that is associated with (actually defined by) an explicit cursor or a
SELECT statement incorporated directly within the loop boundary. Use the cursor FOR loop whenever
(and only if) you need to fetch and process each and every record from a cursor. The CURSOR FOR Loop
will terminate when all of the records in the cursor have been fetched.
The beauty of using a PL/SQL cursor FOR LOOP is that Oracle automatically Opens the cursor,
the results are automatically Fetched and when all rows have been returned, Oracle automatically Closes
the cursor for you.

PL/SQL Quick Reference By A.G.Reddy

20

In the previous section we have learned that a sequence of steps is followed to define and use a
cursor as follows.

1. Open the cursor.

2. Start a loop.
3. Fetch a row of data.
4. Check for a new row, exit if not.
5. Process the data.
6. End the loop.
7. Close the cursor.

Since these steps are almost always followed, Oracle provides a way to let PL/SQL perform most
of the steps. This is called the CURSOR FOR loop. As in the name, it uses a FOR loop to process the
cursor.

Cursor For Loop

create or replace procedure prc_emp_details(i_deptno in emp.deptno%type)
is
cursor c_emp_dtls is
select *
from emp
where deptno = i_deptno;
begin
for emp_rec in c_emp_dtls loop
dbms_output.put_line(emp_rec.deptno ||' '|| emp_rec.empno);
end loop;
end;

Cursors with Return Statement:

REF CURSORS allow record sets to be returned from stored procedures, functions and packages. The
example below uses a ref cursor to return a subset of the records in the Employees table.

First, a package definition is needed to hold the ref cursor type:

Create or replace package pkg_emp as

Type ref_emp is ref cursor returns employees%rowtype;
End pkg_emp;

Cursors with Return Statement

create or replace procedure prc_emp_dtls(i_deptno in employees.department_id%type,
o_result out pkg_emp.ref_emp)
is
begin
open o_result for
select *
from employees
where department_id = i_deptno;
end;

To execute this code run the following statements:

PL/SQL Quick Reference By A.G.Reddy

21
4. Var a refcursor;
5. Exec prc_ref (50, :a);
6. Print a;

Cursor attributes:
Cursor attributes are variables that take some value about the status of the cursor. These values are
automatically set by Oracle and the programmer can read them not write values for them. There are four
cursor attributes. They are

1. %FOUND
2. %ISOPEN
3. %NOTFOUND
4. %ROWCOUNT
1. %FOUND:
After a cursor is opened before the first fetch, the value of this variable is null. After the first fetch,
if the query returns one or more rows as result set, this variable is set to TRUE. When a fetch is made after
the last row of the result set is reached, this variable is set to FALSE.
This variable is extensively used to in stored procedures to handle exceptions when a query returns
no data set. If this variable is referenced before the cursor is opened, an exception INVALID_CURSOR is
raised.
2. %ISOPEN
This variable is set to TRUE if a cursor is opened and false when the cursor is closed.
3. %NOTFOUND
This variable is a logical opposite of %FOUND. This variable is set to TRUE if the last fetch
returns no rows an FALSE when the last fetch returns a row. This can also be used in exception handing
when a query returns no rows.
4. %ROWCOUNT
This variable acts like a counter. It is set to zero when a cursor is opened. Thereafter, with each
fetch, the value of this variable is incremented by 1 if the fetch returns a row. This variable is handy when
processing needs to be done for only a few rows of the result set.

PL/SQL Quick Reference By A.G.Reddy

22

5. PACKAGES
Introduction:
A package is a collection of PL/SQL elements that are "packaged" or grouped together within a
special BEGIN-END syntax, a kind of "meta-block." Here is a partial list of the kinds of elements you can
place in a package:

1. Cursors
2. Variables (scalars, records, tables, etc.) and constants
3. Exception names and pragmas for associating an error number with an exception
4. PL/SQL table and record TYPE statements
5. Procedures and functions

Packages are among the least understood and most underutilized features of PL/SQL. That's a
shame because the package structure is also one of the most useful constructs for building well-designed
PL/SQL-based applications. Packages provide a structure to organize your modules and other PL/SQL
elements. They encourage proper structured programming techniques in an environment that often
befuddles the implementation of structured programming. When you place a program unit into a package
you automatically create a "context" for that program. By collecting related PL/SQL elements in a
package, you express that relationship in the very structure of the code itself. Packages are often called
"the poor man's objects" because they support some, but not all, object-oriented rules.

Advantages:
Packages have many advantages over standalone procedures and functions. For example, they:
• Let you organize your application development more efficiently.
• Let you grant privileges more efficiently.
• Let you modify package objects without recompiling dependent schema objects.
• Enable Oracle to read multiple package objects into memory at once.
• Let you overload procedures or functions. Overloading means creating multiple procedures
with the same name in the same package, each taking arguments of different number or data type.
• Can contain global variables and cursors that are available to all procedures and functions
in the package.

Package Components:
PL/SQL packages have two parts:
1. The specification and
2. The body

The specification is the interface to your application; it declares the types, variables, constants,
exceptions, cursors, and subprograms available for use. The specification holds public declarations that
are visible to your application.

The body fully defines cursors and subprograms, and so implements the specification. The body holds
implementation details and private declarations that are hidden from your application.

PL/SQL Quick Reference By A.G.Reddy

23
Unlike subprograms, packages cannot be called, parameterized, or nested. However, the formats of
a package and a subprogram are similar. You can debug, enhance, or replace a package body without
changing the specification. You can change a package body without recompiling calling programs because
the implementation details in the body are hidden from your application.

Types of Package:
Although any PL/SQL package must have the same structure and follow the same rules, there are
different types of packages that will play different roles in your application.

S.No TYPES OF DESCRIPTION

PACKAGE
A built in package is provided to you by Oracle Corporation,
built right into the PL/SQL language as installed. (A built in
1 Built in package could reside in the database as stored code or could
instead be imbedded in a client tool, such as Oracle
Developer/2000.)
Prebuilt packages are libraries of packages that are built by
2 Prebuilt third parties or other developers that are installed in and used
by your PL/SQL environment.
The very best kind of package: the one you build yourself, or
3 Build-Your-Own it is built by your application development team.
(BYO)

Creating New Packages:

To create packages and store them permanently in an Oracle database, use the CREATE
PACKAGE and CREATE PACKAGE BODY statements. You can execute these statements interactively
from SQL*Plus or Enterprise Manager. To create a new package, do the following:

1). Create the package specification with the CREATE PACKAGE statement:
You can declare program objects in the package specification. Such objects are called public
objects. Public objects can be referenced outside the package, as well as by other objects in the package.

2). Create the package body with the CREATE PACKAGE BODY statement.
You can declare and define program objects in the package body.

• You must define public objects declared in the package specification.

• You can declare and define additional package objects, called private objects. Private objects are
declared in the package body rather than in the package specification, so they can be referenced
only by other objects in the package. They cannot be referenced outside the package.

Example1:
The following example shows a package specification for a package named pck_const.

Package Specification
create or replace package pck_const is

type rec is record(ename varchar2(50),sal number);

type t_emp is table of rec;
a constant number := 10 ;

PL/SQL Quick Reference By A.G.Reddy

24
emp_retire_age constant number := 65;
cursor c is select * from employees;
type ref_test is ref cursor return employees%rowtype;
procedure prc_test (pn_empno in number);

end pck_const;
The body for this package defines the prc_test procedure as follows:

Package Body
create or replace package body pck_const is

procedure prc_test (pn_empno in number)

is
begin
if (pn_empno > 0) then
null;
end if;
end;
end pck_const;

Example2:
The following example shows a package specification for a package named Employee_Management. The
package contains one stored function and two stored procedures.

Package Specification

CREATE PACKAGE employee_management AS

FUNCTION hire_emp (name VARCHAR2, job VARCHAR2,
mgr NUMBER, hiredate DATE, sal NUMBER, comm NUMBER,
deptno NUMBER) RETURN NUMBER;
PROCEDURE fire_emp (emp_id NUMBER);
PROCEDURE sal_raise (emp_id NUMBER, sal_incr NUMBER);
END employee_management;

The body for this package defines the function and the procedures:

Package Body

CREATE PACKAGE BODY employee_management AS

FUNCTION hire_emp (name VARCHAR2, job VARCHAR2,
mgr NUMBER, hiredate DATE, sal NUMBER, comm NUMBER,
deptno NUMBER) RETURN NUMBER IS

/*The function accepts all arguments for the fields in the employee table except for the
employee number. A value for this field is supplied by a sequence. The function returns the
sequence number generated by the call to this function.*/

new_empno NUMBER(10);

BEGIN
SELECT emp_sequence.NEXTVAL INTO new_empno FROM dual;

PL/SQL Quick Reference By A.G.Reddy

25
INSERT INTO emp VALUES (new_empno, name, job, mgr,
hiredate, sal, comm, deptno);
RETURN (new_empno);
END hire_emp;

PROCEDURE fire_emp(emp_id IN NUMBER) AS

/*The procedure deletes the employee with an employee number that corresponds
to the argument emp_id. If no employee is found, then an exception is
raised.*/

BEGIN
DELETE FROM emp WHERE empno = emp_id;
IF SQL%NOTFOUND THEN
raise_application_error(-20011, 'Invalid Employee
Number: ' || TO_CHAR(emp_id));
END IF;
END fire_emp;

PROCEDURE sal_raise (emp_id IN NUMBER, sal_incr IN NUMBER) AS

/*The procedure accepts two arguments. Emp_id is a number that corresponds to

an employee number. Sal_incr is the amount by which to increase the
employee's salary.*/

BEGIN
-- If employee exists, then update salary with increase.
UPDATE emp
SET sal = sal + sal_incr
WHERE empno = emp_id;
IF SQL%NOTFOUND THEN
raise_application_error(-20011, 'Invalid Employee
Number: ' || TO_CHAR(emp_id));
END IF;
END sal_raise;

END employee_management;

Referencing Package Contents:

To reference the types, items, and subprograms declared in a package specification, use the dot
notation. For example:
• package_name.type_name
• package_name.item_name
• package_name.subprogram_name

Using Oracle Supplied Packages:

Most Oracle supplied packages are automatically installed when the database is created and the
CATPROC.SQL script is run. For example, to create the DBMS_ALERT package, the DBMSALRT.SQL
and PRVTALRT.PLB scripts must be run when connected as the user SYS. These scripts are run
automatically by the CATPROC.SQL script.

PL/SQL Quick Reference By A.G.Reddy

26

Certain packages are not installed automatically. For these packages Special installation instructions
are needed.

To call a PL/SQL function from SQL, you must either own the function or have EXECUTE privileges
on the function. To select from a view defined with a PL/SQL function, you must have SELECT
privileges on the view. No separate EXECUTE privileges are needed to select from the view.
6. TRIGGERS
Introduction:
Triggers are a special PL/SQL construct similar to procedures. However, a procedure is executed
explicitly from another block via a procedure call, while a trigger is executed implicitly whenever the
triggering event happens. The triggering event is either a INSERT, DELETE, or UPDATE command. The
timing can be either BEFORE or AFTER. The trigger can be either row-level or statement-level, where
the former fires once for each row affected by the triggering statement and the latter fires once for the
whole statement.

Below figure shows a database application with some SQL statements that implicitly fire several
triggers stored in the database. Notice that the database stores triggers separately from their associated
tables.

PARTS OF A TRIGGER:
A trigger has three basic parts:
1. A triggering event or statement
2. A trigger restriction
3. A trigger action

1). The Triggering Event or Statement:

A triggering event or statement is the SQL statement, database event, or user event that causes a
trigger to fire. A triggering event can be one or more of the following:

 An INSERT, UPDATE, or DELETE statement on a specific table (or view, in some cases)
 A CREATE, ALTER, or DROP statement on any schema object
 A database startup or instance shutdown
 A specific error message or any error message
 A user logon or logoff

PL/SQL Quick Reference By A.G.Reddy

27

2). Trigger Restriction:

A trigger restriction specifies a Boolean expression that must be true for the trigger to fire. The trigger
action is not run if the trigger restriction evaluates to false or unknown.

3). Trigger Action

A trigger action is the procedure (PL/SQL block, Java program, or C callout) that contains the SQL
statements and code to be run when the following events occur:
• A triggering statement is issued.
• The trigger restriction evaluates to true.

Like stored procedures, a trigger action can:

• Contain SQL, PL/SQL, or Java statements
• Define PL/SQL language constructs such as variables, constants, cursors, exceptions
• Define Java language constructs
• Call stored procedures

If the triggers are row triggers, the statements in a trigger action have access to column values of the
row being processed by the trigger. Correlation names provide access to the old and new values for each
column.

TYPES OF TRIGGERS:
This section describes the different types of triggers:
1. Row Triggers and Statement Triggers
2. BEFORE and AFTER Triggers
3. INSTEAD OF Triggers
4. Triggers on System Events and User Events
1). Row Triggers and Statement Triggers
When you define a trigger, you can specify the number of times the trigger action is to be run:
• Once for every row affected by the triggering statement, such as a trigger fired by an UPDATE
statement that updates many rows
• Once for the triggering statement, no matter how many rows it affects

Row Triggers:
A row trigger is fired each time the table is affected by the triggering statement. For example, if an
UPDATE statement updates multiple rows of a table, a row trigger is fired once for each row affected by
the UPDATE statement. If a triggering statement affects no rows, a row trigger is not run.

Row triggers are useful if the code in the trigger action depends on data provided by the triggering
statement or rows that are affected. For example, Figure 17-3 illustrates a row trigger that uses the values
of each row affected by the triggering statement.

Statement Triggers:
A statement trigger is fired once on behalf of the triggering statement, regardless of the number of
rows in the table that the triggering statement affects, even if no rows are affected. For example, if a
DELETE statement deletes several rows from a table, a statement-level DELETE trigger is fired only
once.

PL/SQL Quick Reference By A.G.Reddy

28

Statement triggers are useful if the code in the trigger action does not depend on the data provided by
the triggering statement or the rows affected. For example, use a statement trigger to:
• Make a complex security check on the current time or user
• Generate a single audit record

2). BEFORE and AFTER Triggers:

When defining a trigger, you can specify the trigger timing--whether the trigger action is to be run
before or after the triggering statement. BEFORE and AFTER apply to both statement and row triggers.

BEFORE and AFTER triggers fired by DML statements can be defined only on tables, not on views.
However, triggers on the base tables of a view are fired if an INSERT, UPDATE, or DELETE statement is
issued against the view. BEFORE and AFTER triggers fired by DDL statements can be defined only on
the database or a schema, not on particular tables.

BEFORE Triggers:
BEFORE triggers run the trigger action before the triggering statement is run. This type of trigger is
commonly used in the following situations:
• When the trigger action determines whether the triggering statement should be allowed to
complete. Using a BEFORE trigger for this purpose, you can eliminate unnecessary processing
of the triggering statement and its eventual rollback in cases where an exception is raised in the
trigger action.
• To derive specific column values before completing a triggering INSERT or UPDATE
statement.

AFTER Triggers:
AFTER triggers run the trigger action after the triggering statement is run.

Trigger Type Combinations:

Using the options listed previously, you can create four types of row and statement triggers:

 BEFORE statement trigger: Before executing the triggering statement, the trigger action is
run.

 BEFORE row trigger: Before modifying each row affected by the triggering statement and
before checking appropriate integrity constraints, the trigger action is run, if the trigger
restriction was not violated.
 AFTER row trigger: After modifying each row affected by the triggering statement and
possibly applying appropriate integrity constraints, the trigger action is run for the current row
provided the trigger restriction was not violated. Unlike BEFORE row triggers, AFTER row
triggers lock rows.

 AFTER statement trigger: After executing the triggering statement and applying any
deferred integrity constraints, the trigger action is run.

PL/SQL Quick Reference By A.G.Reddy

29
3). INSTEAD OF Triggers:
INSTEAD OF triggers provide a transparent way of modifying views that cannot be modified directly
through DML statements (INSERT, UPDATE, and DELETE). These triggers are called INSTEAD OF
triggers because, unlike other types of triggers, Oracle fires the trigger instead of executing the triggering
statement.

You can write normal INSERT, UPDATE, and DELETE statements against the view and the
INSTEAD OF trigger is fired to update the underlying tables appropriately. INSTEAD OF triggers are
activated for each row of the view that gets modified.
4). Triggers on System Events and User Events
You can use triggers to publish information about database events to subscribers. Applications can
subscribe to database events just as they subscribe to messages from other applications. These database
events can include:

 System events
• Database startup and shutdown
• Server error message events

 User events
• User logon and logoff
• DDL statements (CREATE, ALTER, and DROP)
• DML statements (INSERT, DELETE, and UPDATE)

Triggers on system events can be defined at the database level or schema level. For example, a
database shutdown trigger is defined at the database level:

CREATE TRIGGER register_shutdown

ON DATABASE
SHUTDOWN
BEGIN
...
DBMS_AQ.ENQUEUE(...);
...
END;
Triggers on DDL statements or logon/logoff events can also be defined at the database level or
schema level. Triggers on DML statements can be defined on a table or view. A trigger defined at the
database level fires for all users, and a trigger defined at the schema or table level fires only when the
triggering event involves that schema or table.

ORDER OF TRIGGER FIRING:

If two or more triggers with different timing points (BEFORE, AFTER, INSTEAD OF) are defined for
the same statement on the same table, then they fire in the following order:

1. All BEFORE statement triggers

2. All BEFORE row triggers
3. All AFTER row triggers
4. All AFTER statement triggers

Dropping Triggers:
To drop a trigger:
• drop trigger <trigger_name>;

PL/SQL Quick Reference By A.G.Reddy

30

Disabling/Enabling Triggers:
To disable or enable a trigger:
• alter trigger <trigger_name> {disable|enable};

TRIGGER EXAMPLES:

TRIGGER EXAMPLE#1

CREATE OR REPLACE TRIGGER SCOTT.trg_student

before insert on student
for each row
declare
pragma autonomous_transaction;
begin
insert into student1(sno
,sname
,marks)
values(:new.sno
,:new.sname
,:new.marks);
commit;
end trg_student;

TRIGGER EXAMPLE#2

CREATE OR REPLACE TRIGGER SCOTT.trg_student_row

before insert or update or delete on student
for each row
declare
pragma autonomous_transaction;
begin
if inserting then
insert into student1(sno
,sname
,marks)
values(:new.sno
,:new.sname
,:new.marks
);

elsif updating then

update student1
set sno = :new.sno
,sname = :new.sname
,marks = :new.marks
where sno = :new.sno;

PL/SQL Quick Reference By A.G.Reddy

31

elsif deleting then

delete from student1
where sno = :old.sno;
end if;
commit;
end trg_student;

TRIGGER EXAMPLE#3

CREATE OR REPLACE TRIGGER SCOTT.trg_student_sta

before insert or update or delete on student
declare
pragma autonomous_transaction;

begin
if inserting then
insert into audit_log(user_name
,date1
,action)
values(USER
,sysdate
,'INSERT');
elsif updating then
insert into audit_log(user_name
,date1
,action)
values(USER
,sysdate
,'UPDATE');
elsif deleting then
insert into audit_log(user_name
,date1
,action)
values(user
,sysdate
,'DELETE');
end if;
commit;

end trg_student;

PL/SQL Quick Reference By A.G.Reddy

32

7. EXCEPTION HANDLING
INTRODUCTION:
An exception is an abnormal situation which becomes an obstacle in the normal flow of the
program. When you are writing a PL/SQL block which is a procedural extension of SQL, there comes the
following sequence of blocks:
1). Declare. 2) Begin.3). Exception, 4). End

In the exception block we have to define a user defined Exception handler or system defined
handler to track the error occurred line. This is called Exception handling in Oracle which helps to handle
datatype discrepancies or Constraint type problems or any other kinds of abnormal situations.

When an exception occurs (is raised) in a PL/SQL block, its execution section immediately
terminates. Control is passed to the exception section.

PREDEFINED EXCEPTION:
Predefined exception is raised automatically whenever there is a violation of Oracle coding rules.
Predefined exceptions are those like ZERO_DIVIDE, which is raised automatically when we try to divide
a number by zero. Other built-in exceptions are given below. You can handle unexpected Oracle errors
using OTHERS handler. It can handle all raised exceptions that are not handled by any other handler. It
must always be written as the last handler in exception block.

• CURSOR_ALREADY_OPEN – Raised when we try to open an already open cursor.

• DUP_VAL_ON_INDEX – When you try to insert a duplicate value into a unique column
• INVALID_CURSOR – It occurs when we try accessing an invalid cursor
• INVALID_NUMBER – On usage of something other than number in place of number value.
• LOGIN_DENIED – At the time when user login is denied
• TOO_MANY_ROWS – When a select query returns more than one row and the destination
variable can take only single value.
• VALUE_ERROR – When an arithmetic, value conversion, truncation, or constraint error occurs.

Predefined exception handlers are declared globally in package STANDARD. Hence we need not
have to define them rather just use them. Every exception in PL/SQL has an error number and error
message; some exceptions also have names as below:

PL/SQL Quick Reference By A.G.Reddy

33

S.n Error Named Exception S.n Error Named Exception

o o
1 ORA- DUP_VAL_ON_INDEX 11 ORA- INVALID_NUMBER
00001 01722
2 ORA- TIMEOUT_ON_RESOURCE 12 ORA- STORAGE_ERROR
00051 06500
3 ORA- INVALID_CURSOR 13 ORA- PROGRAM_ERROR
01001 06501
4 ORA- NOT_LOGGED_ON 14 ORA- VALUE_ERROR
01012 06502
5 ORA- LOGIN_DENIED 15 ORA- ROWTYPE_MISMATCH
01017 06504
6 ORA- NO_DATA_FOUND 16 ORA- CURSOR_ALREADY_OPEN
01403 06511
7 ORA- SYS_INVALID_ROWID 17 ORA- ACCESS_INTO_NULL
01410 06530
8 ORA- TOO_MANY_ROWS 18 ORA- COLLECTION_IS_NULL
01422 06531
9 ORA- ZERO_DIVIDE 19 ORA- SUBSCRIPT_OUTSIDE_LIMIT
01476 06532
10 ORA- SUBSCRIPT_BEYOND_COUNT 20
06533

Example#1: Following example gives the usage of ZERO_DIVIDE exception.

ZERO_DIVIDE Exception
create or replace procedure prc_zero
Is
N number;
Begin
N:=10/0;
Exception
When ZERO_DIVIDE then
dbms_output.put_line(‘Zero Devide Error’);
end;

Example#2 Following example gives the usage of NO_DATA_FOUND exception.

NO_DATA_FOUND Exception
create or replace procedure prc_emp_details(i_eno in number,
Name out varchar2,
Salary out number,
Dept out number)
Is
Begin
Select ename, sal, deptno into name, salary, dept
From emp
Where empno=i_eno;
Exception
When NO_DATA_FOUND then
dbms_output.put_line(‘Employee number does not exists’);

PL/SQL Quick Reference By A.G.Reddy

34
end;

USER-DEFINED EXCEPTION:
A User-defined exception has to be defined by the programmer. User-defined exceptions are
declared in the declaration section with their type as exception. They must be raised explicitly using
RAISE statement, unlike pre-defined exceptions that are raised implicitly. RAISE statement can also be
used to raise internal exceptions.

User-defined exception:

create or replace procedure prc_user_exce

Is
Myexception exception;
Begin
If to_char(sysdate,’dy’)=’sun’ then
Raise myexception;
End if;
Exception
Dbms_output.put_line(‘To day holiday’);
end;

RAISE_APPLICATION_ERROR:
To display your own error messages one can use the built-in RAISE_APPLICATION_ERROR.
They display the error message in the same way as Oracle errors. You should use a negative number
between –20000 to –20999 for the error number and the error message should not exceed 512 characters.

RAISE_APPLICATION_ERROR:

create or replace procedure prc_raise_exce(i_no in number)

Is
Begin
If i_no<10 then
Raise_application_error(-20888,’Less than 10’);
else
Raise_application_error(-20222,’greater than 10’);
End if;
end;

THE WHEN OTHERS CLAUSE:

Use the WHEN OTHERS clause in the exception handler as a catch-all to trap any exceptions that
are not handled by specific WHEN clauses in the exception section. If present, this clause must be the last
exception handler in the exception section.

The WHEN OTHERS clause:

create or replace function fn_bulk_collect(i_dept_id in departments.department_id%type)

return t_varchar
is
cursor c_emp is select first_name

PL/SQL Quick Reference By A.G.Reddy

35
from employees
where department_id = i_dept_id;
lt_emp t_varchar := t_varchar();
begin
open c_emp;
fetch c_emp bulk collect into lt_emp limit 100;
close c_emp;
return lt_emp;
exception
when others then
dbms_output.put_line(substr(sqlerrm,1,150));
end;

SQLCODE AND SQLERRM:

SQLCODE and SQLERRM are built-in functions that provide the SQL error code and message for
the current exception. Use these functions inside the exception section's WHEN OTHERS clause to handle
specific errors by number.

RAISING EXCEPTIONS:
With the above explanation it is clear that an exception can be raised in three ways:
1. By the PL/SQL runtime engine
2. By an explicit RAISE statement in your code
3. By a call to the built-in function RAISE_APPLICATION_ERROR

8. COLLECTIONS
INTRODUCTION:
Just about all modern programming languages provide support for collections. A collection can be
loosely defined as a group of ordered elements, all of the same type, that allows programmatic access to
its elements through an index. Commonly used collection types used in the programming world include
arrays, maps, and lists.

Probably the biggest advantage a collection can provide is improved application performance.
Developers utilize collections to 'cache' static data that needs to be regularly accessed. This results in
reduced calls to a database. As I stated earlier, PL/SQL programs are a good place to make expensive SQL
calls but that doesn't mean that we shouldn't try to keep those calls to a minimum.

Oracle uses collections in PL/SQL the same way other languages use arrays. Oracle provides three
basic collections, each with an assortment of methods.

1. Nested Table Collections

2. Varray Collections
3. Index-By Tables

NESTED TABLE COLLECTIONS:

Nested table collections are an extension of the index-by tables. The main difference between the
two is that nested tables can be stored in a database column but index-by tables cannot. In addition some
DML operations are possible on nested tables when they are stored in the database. During creation the
collection must be dense, having consecutive subscripts for the elements. Once created elements can be

PL/SQL Quick Reference By A.G.Reddy

36
deleted using the DELETE method to make the collection sparse. The NEXT method overcomes the
problems of traversing sparse collections.

Nested Table Collection

SET SERVEROUTPUT ON SIZE 1000000
DECLARE
TYPE table_type IS TABLE OF NUMBER(10);
v_tab table_type;
v_idx NUMBER;
BEGIN

-- Initialise the collection with two values.

v_tab := table_type(1, 2);

-- Extend the collection with extra values.

<< load_loop >>
FOR i IN 3 .. 5 LOOP
v_tab.extend;
v_tab(v_tab.last) := i;
END LOOP load_loop;

-- Delete the third item of the collection.

v_tab.DELETE(3);

-- Traverse sparse collection

v_idx := v_tab.FIRST;
<< display_loop >>
WHILE v_idx IS NOT NULL LOOP
DBMS_OUTPUT.PUT_LINE('The number ' || v_tab(v_idx));
v_idx := v_tab.NEXT(v_idx);
END LOOP display_loop;
END;
/

The number 1
The number 2
The number 4
The number 5

PL/SQL procedure successfully completed.

VARRAY COLLECTIONS:
A VARRAY is similar to a nested table except you must specify an upper bound in the declaration.
Like nested tables they can be stored in the database, but unlike nested tables individual elements cannot
be deleted so they remain dense:

Varray Collections
SET SERVEROUTPUT ON SIZE 1000000
DECLARE
TYPE table_type IS VARRAY(5) OF NUMBER(10);
v_tab table_type;
v_idx NUMBER;
BEGIN
-- Initialise the collection with two values.
v_tab := table_type(1, 2);

PL/SQL Quick Reference By A.G.Reddy

37
-- Extend the collection with extra values.
<< load_loop >>
FOR i IN 3 .. 5 LOOP
v_tab.extend;
v_tab(v_tab.last) := i;
END LOOP load_loop;

-- Can't delete from a VARRAY.

-- v_tab.DELETE(3);

-- Traverse collection
v_idx := v_tab.FIRST;
<< display_loop >>
WHILE v_idx IS NOT NULL LOOP
DBMS_OUTPUT.PUT_LINE('The number ' || v_tab(v_idx));
v_idx := v_tab.NEXT(v_idx);
END LOOP display_loop;
END;
/

The number 1
The number 2
The number 3
The number 4
The number 5

PL/SQL procedure successfully completed.

INDEX-BY TABLES:
The first type of collection is known as index-by tables. These behave in the same way as arrays
except that have no upper bounds, allowing them to constantly extend. As the name implies, the collection
is indexed using BINARY_INTEGER values, which do not need to be consecutive. The collection is
extended by assigning values to an element using an index value that does not currently exist.

Index-By Table
SET SERVEROUTPUT ON SIZE 1000000
DECLARE
TYPE table_type IS TABLE OF NUMBER(10)
INDEX BY BINARY_INTEGER;

v_tab table_type;
v_idx NUMBER;
BEGIN
-- Initialise the collection.
<< load_loop >>
FOR i IN 1 .. 5 LOOP
v_tab(i) := i;
END LOOP load_loop;

-- Delete the third item of the collection.

v_tab.DELETE(3);

-- Traverse sparse collection

v_idx := v_tab.FIRST;
<< display_loop >>
WHILE v_idx IS NOT NULL LOOP

PL/SQL Quick Reference By A.G.Reddy

38
DBMS_OUTPUT.PUT_LINE('The number ' || v_tab(v_idx));
v_idx := v_tab.NEXT(v_idx);
END LOOP display_loop;
END;
/

The number 1
The number 2
The number 4
The number 5

PL/SQL procedure successfully completed.

COLLECTION METHODS:
A variety of methods exist for collections, but not all are relevant for every collection type:

1. EXISTS (n) - Returns TRUE if the specified element exists.

2. COUNT - Returns the number of elements in the collection.
3. LIMIT - Returns the maximum number of elements for a VARRAY, or NULL for nested
tables.
4. FIRST - Returns the index of the first element in the collection.
5. LAST - Returns the index of the last element in the collection.
6. PRIOR (n) - Returns the index of the element prior to the specified element.
7. NEXT (n) - Returns the index of the next element after the specified element.
8. EXTEND - Appends a single null element to the collection.
9. EXTEND (n) - Appends n null elements to the collection.
10. EXTEND (n1, n2) - Appends n1 copies of the n2th element to the collection.
11. TRIM - Removes a single element from the end of the collection.
12. TRIM (n) - Removes n elements from the end of the collection.
13. DELETE - Removes all elements from the collection.
14. DELETE (n) - Removes element n from the collection.
15. DELETE(n1,n2) - Removes all elements from n1 to n2 from the collection

Examlple#1:
In the below example t_varchar is declared in a package
Nested table

create or replace function f_emp_tab(i_dept_id in departments.department_id%type)

return t_varchar
is
cursor c_ename is select first_name
from employees
where department_id = i_dept_id;
lt_ename t_varchar := t_varchar();
i number := 1;
begin
for emp_rec in c_ename loop
lt_ename.extend;
lt_ename(i) := emp_rec.first_name;
i := i + 1;
end loop;
return lt_ename;
end;

PL/SQL Quick Reference By A.G.Reddy

39

Using Nested table methods

create or replace function f_emp_tab(i_dept_id in departments.department_id%type)return t_varchar

is
cursor c_ename is select first_name
from employees
where department_id = i_dept_id;
lt_ename t_varchar := t_varchar();
i number := 1;
begin
for emp_rec in c_ename loop
lt_ename.extend;
lt_ename(i) := emp_rec.first_name;
i := i + 1;
end loop;
if (lt_ename.exists(3)) then
dbms_output.put_line('yes');
else
dbms_output.put_line('no');
end if;
dbms_output.put_line(lt_ename.first);
dbms_output.put_line(lt_ename.last);
dbms_output.put_line(lt_ename.count);
for i in lt_ename.first ..lt_ename.last loop
dbms_output.put_line(lt_ename(i));
end loop;
return lt_ename;end;

BULKCOLLECT:
Executing SQL statements in PLSQL programs causes a context switch between the PLSQL
engine and the SQL engine. Too many context switches may degrade performance dramatically. In order
to reduce the number of these context switches we can use a feature named bulk binding. Bulk binding lets
us to transfer rows between the SQL engine and the PLSQL engine as collections. Bulk binding is
available for select, insert, delete and update statements.

BULKCOLLECT#1

create or replace function fn_bulk_collect(i_dept_id in departments.department_id%type)

return t_varchar
is
cursor c_emp is select first_name
from employees
where department_id = i_dept_id;
lt_emp t_varchar := t_varchar();
begin
open c_emp;
fetch c_emp bulk collect into lt_emp limit 100;
close c_emp;
return lt_emp;
exception
when others then
dbms_output.put_line(substr(sqlerrm,1,150));
end;

PL/SQL Quick Reference By A.G.Reddy

40

BULKCOLLECT#2

create or replace function fn_bulk_collect1(i_dept_id in departments.department_id%type)

return pck_const.t_emp
is
lt_emp pck_const.t_emp := pck_const.t_emp();
begin
select first_name,salary
bulk collect into lt_emp
from employees
where department_id = i_dept_id;
for i in 1..lt_emp.count loop
dbms_output.put_line(lt_emp(i).ename || lt_emp(i).sal);
end loop;
return lt_emp;
exception
when others then
dbms_output.put_line(substr(sqlerrm,1,150));
return null;
end;

9. OVERLOADING FUNCTIONS AND PROCEDURES

More than one function may be defined with the same SQL name, so long as the arguments they
take are different. In other words, function names can be overloaded. When a query is executed, the server
will determine which function to call from the data types and the number of the provided arguments.
Overloading can also be used to simulate functions with a variable number of arguments, up to a finite
maximum number.

You can declare local or packaged stored procedures with exactly the same name, as long as their
parameters are different by at least one of these factors:
1. The Number Of Parameters,
2. Names Of Parameters,
3. Order Of Parameters, Or
4. The Datatype Family Of The Parameters.

The Number Of Parameters

SQL> declare
2 function getArea(i_rad NUMBER)
3 return NUMBER
4 is
5 v_pi NUMBER:=3.14;

PL/SQL Quick Reference By A.G.Reddy

41
6 begin
7 return v_pi * (i_rad ** 2);
8 end;
9 function getArea(i_length NUMBER, i_width NUMBER)
10 return NUMBER
11 is
12 begin
13 return i_length * i_width;
14 end;
15 begin
16 DBMS_OUTPUT.put_line('Area (R=3):'||getArea(3));
17 DBMS_OUTPUT.put_line('Area (2x3):'||getArea(2,3));
18 end;
19 /
Area (R=3):28.26
Area (2x3):6

PL/SQL procedure successfully completed.

Names Of Parameters
SQL> declare
2 function getArea(i_rad NUMBER, i_prec NUMBER)
3 return NUMBER
4 is
5 v_pi NUMBER:=3.14;
6 begin
7 return trunc(v_pi * (i_rad ** 2),i_prec);
8 end;
9 function getArea(i_length NUMBER, i_width NUMBER)
10 return NUMBER
11 is
12 begin
13 return i_length * i_width;
14 end;
15 begin
16 DBMS_OUTPUT.put_line('Area (R=3): '||getArea(i_rad=>3,i_prec=>1));
17 DBMS_OUTPUT.put_line('Area (2x3): '||getArea(i_length=>2,i_width=>3));
18 end;
19 /
Area (R=3): 28.2
Area (2x3): 6

PL/SQL procedure successfully completed.

The Datatype Family Of The Parameters

SQL> declare
2 function getArea(i_rad NUMBER, i_prec NUMBER) return NUMBER is
3 v_pi NUMBER:=3.14;
4 begin
5 return trunc(v_pi * (i_rad ** 2),i_prec);
6 end;
7 function getArea(i_rad NUMBER, i_ignore_yn VARCHAR2) return NUMBER is
8 v_pi NUMBER:=3.14;
9 begin
10 if i_ignore_yn='Y' and i_rad < 5 then

PL/SQL Quick Reference By A.G.Reddy

42
11 return 0;
12 else
13 return v_pi * (i_rad ** 2);
14 end if;
15 end;
16 begin
17 DBMS_OUTPUT.put_line('Area (R=3):'||getArea(3,1));
18 DBMS_OUTPUT.put_line('Area (R=3):'||getArea(3,'N'));
19 end;
20 /
Area (R=3):28.2
Area (R=3):28.26

PL/SQL procedure successfully completed.

Restrictions on overloading:
1. You can't overload standalone procedures or functions.
2. The second definition simply overwrites the first one.
3. You can't overload functions that differ only by the datatype of the return value.
4. If you need to implement this requirement, use overloaded procedures with OUT
parameters.

10. FREQUENTLY ASKED QUESTIONS

SET#1:
1. What is PL/SQL and what is it used for?
SQL is a declarative language that allows database programmers to write a SQL declaration and hand
it to the database for execution. As such, SQL cannot be used to execute procedural code with conditional,
iterative and sequential statements. To overcome this limitation, PL/SQL was created.

PL/SQL is Oracle's Procedural Language extension to SQL. PL/SQL's language syntax, structure and
data types. Some of the statements provided by PL/SQL:

2. What is the difference between SQL and PL/SQL?

Both SQL and PL/SQL are languages used to access data within Oracle databases

Some of the differences:

• SQL is executed one statement at a time. PL/SQL is executed as a block of code.
• SQL tells the database what to do (declarative), not how to do it. In contrast, PL/SQL tell the
database how to do things (procedural).
• SQL is used to code queries, DML and DDL statements. PL/SQL is used to code program blocks,
triggers, functions, procedures and packages.

PL/SQL Quick Reference By A.G.Reddy

43
• You can embed SQL in a PL/SQL program, but you cannot embed PL/SQL within a SQL
statement.

3. Should one use PL/SQL or Java to code procedures and triggers?

Both PL/SQL and Java can be used to create Oracle stored procedures and triggers.
PL/SQL:
• Can be used to create Oracle packages, procedures and triggers
• Data centric and tightly integrated into the database
• Proprietary to Oracle and difficult to port to other database systems
• Data manipulation is slightly faster in PL/SQL than in Java
• Easier to use than Java (depending on your background)
• Pl/SQL is a traditional procedural programming language
Java:
• Can be used to create Oracle packages, procedures and triggers
• Open standard, not proprietary to Oracle
• Incurs some data conversion overhead between the Database and Java type systems
• Java is more difficult to use (depending on your background)
• Java is an Object Orientated language, and modules are structured into classes
• Java can be used to produce complete applications

4. How can one see if somebody modified any code?

The source code for stored procedures, functions and packages are stored in the Oracle Data
Dictionary. One can detect code changes by looking at the TIMESTAMP and LAST_DDL_TIME column
in the USER_OBJECTS dictionary view. Example:
SELECT OBJECT_NAME,
TO_CHAR(CREATED, 'DD-Mon-RR HH24:MI') CREATE_TIME,
TO_CHAR(LAST_DDL_TIME, 'DD-Mon-RR HH24:MI') MOD_TIME,
STATUS
FROM USER_OBJECTS
WHERE LAST_DDL_TIME > '&CHECK_FROM_DATE';
5. How can one search PL/SQL code for a string/ key value?
The following query is handy if you want to know where certain tables, columns and expressions are
referenced in your PL/SQL source code.
SELECT type, name, line
FROM user_source
WHERE UPPER(text) LIKE '%&KEYWORD%';

6. How can one keep a history of PL/SQL code changes?

One can build a history of PL/SQL code changes by setting up an AFTER CREATE schema (or
database) level trigger (available from Oracle 8.1.7). This way one can easily revert to previous code
should someone make any catastrophic changes.

7. How can I protect my PL/SQL source code?

Oracle provides a binary wrapper utility that can be used to scramble PL/SQL source code. This utility
was introduced in Oracle7.2 (PL/SQL V2.2) and is located in the ORACLE_HOME/bin directory.

wrap iname=myscript.pls oname=xxxx.plb

8. Can one print to the screen from PL/SQL?

PL/SQL Quick Reference By A.G.Reddy

44
One can use the DBMS_OUTPUT package to write information to an output buffer. This buffer can be
displayed on the screen from SQL*Plus if you issue the SET SERVEROUTPUT ON; command. For
example:

set serveroutput on
begin
dbms_output.put_line('Look Ma, I can print from PL/SQL!!!');
end;

9. Can one read/write files from PL/SQL?

The UTL_FILE database package can be used to read and write operating system files. A DBA user
needs to grant you access to read from/ write to a specific directory before using this package.

10. Can one call DDL statements from PL/SQL?

One can call DDL statements like CREATE, DROP, TRUNCATE, etc. from PL/SQL by using the
"EXECUTE IMMEDIATE" statement (native SQL). Examples:
begin
EXECUTE IMMEDIATE 'CREATE TABLE X(A DATE)';
end;
begin execute Immediate 'TRUNCATE TABLE emp'; end;
DECLARE
var VARCHAR2(100);
BEGIN
var := 'CREATE TABLE temp1(col1 NUMBER(2))';
EXECUTE IMMEDIATE var;
END;

11. Can one use dynamic SQL statements from PL/SQL?

Yes we can use

12. What is the difference between %TYPE and %ROWTYPE?

Both %TYPE and %ROWTYPE are used to define variables in PL/SQL as it is defined within the
database.
• %TYPE is used to declare a field with the same type as that of a specified table's column.
• %ROWTYPE is used to declare a record with the same types as found in the specified database
table, view or cursor.

13. What is the result of comparing NULL with NULL?

NULL is neither equal to NULL, nor it is not equal to NULL. Any comparison to NULL is evaluated
to NULL. Look at this code example to convince yourself:
declare
a number := NULL;
b number := NULL;
begin
if a=b then
dbms_output.put_line('True, NULL = NULL');
elsif a<>b then
dbms_output.put_line('False, NULL <> NULL');
else
dbms_output.put_line('Undefined NULL is neither = nor <> to NULL');
end if;
end;

PL/SQL Quick Reference By A.G.Reddy

45
The output would be:

Undefined NULL is neither = nor <> to NULL

14. How does one get the value of a sequence into a PL/SQL variable?
As you might know, one cannot use sequences directly from PL/SQL. Oracle (for some silly reason)
prohibits this:

i := sq_sequence.NEXTVAL;
However, one can use embedded SQL statements to obtain sequence values:

select sq_sequence.NEXTVAL into :i from dual;

15. Can one execute an operating system command from PL/SQL?

There is no direct way to execute operating system commands from PL/SQL. PL/SQL doesn't have a
"HOST" command, like in SQL*Plus, that allows users to call OS commands

16. How does one loop through tables in PL/SQL?

One can make use of cursors to loop through data within tables. Look at the following nested loops
code example. ‘

DECLARE
CURSOR dept_cur IS
SELECT deptno
FROM dept
ORDER BY deptno;

-- Employee cursor all employees for a dept number

CURSOR emp_cur (v_dept_no DEPT.DEPTNO%TYPE) IS
SELECT ename
FROM emp
WHERE deptno = v_dept_no;
BEGIN
FOR dept_rec IN dept_cur LOOP
dbms_output.put_line('Employees in Department '||TO_CHAR(dept_rec.deptno));

FOR emp_rec in emp_cur(dept_rec.deptno) LOOP

dbms_output.put_line('...Employee is '||emp_rec.ename);
END LOOP;

END LOOP;
END;

17. How often should one COMMIT in a PL/SQL loop? / What is the best commit strategy?
Contrary to popular belief, one should COMMIT less frequently within a PL/SQL loop to prevent
ORA-1555 (Snapshot too old) errors. The higher the frequency of commit, the sooner the extents in the
undo/ rollback segments will be cleared for new transactions, causing ORA-1555 errors.

18. I can SELECT from SQL*Plus but not from PL/SQL. What is wrong?
PL/SQL respect object privileges given directly to the user, but does not observe privileges given
through roles. The consequence is that a SQL statement can work in SQL*Plus, but will give an error in
PL/SQL. Choose one of the following solutions:

PL/SQL Quick Reference By A.G.Reddy

46
• Grant direct access on the tables to your user. Do not use roles!

GRANT select ON scott.emp TO my_user;

• Define your procedures with invoker rights (Oracle 8i and higher);

create or replace procedure proc1

authid current_user is
begin
...
• Move all the tables to one user/schema.

19. What is a mutating and constraining table?

"Mutating" means "changing". A mutating table is a table that is currently being modified by an
update, delete, or insert statement. When a trigger tries to reference a table that is in state of flux (being
changed), it is considered "mutating" and raises an error since Oracle should not return data that has not
yet reached its final state.

Another way this error can occur is if the trigger has statements to change the primary, foreign or
unique key columns of the table off which it fires. If you must have triggers on tables that have referential
constraints, the workaround is to enforce the referential integrity through triggers as well.

There are several restrictions in Oracle regarding triggers:

• A row-level trigger cannot query or modify a mutating table. (Of course, NEW and OLD still
can be accessed by the trigger).
• A statement-level trigger cannot query or modify a mutating table if the trigger is fired as the
result of a CASCADE delete.
• Etc.

20. Can one pass an object/table as an argument to a remote procedure?

The only way to reference an object type between databases is via a database link. Note that it is not
enough to just use "similar" type definitions. Look at this example:

-- Database A: receives a PL/SQL table from database B

CREATE OR REPLACE PROCEDURE pcalled(TabX DBMS_SQL.VARCHAR2S) IS
BEGIN
-- do something with TabX from database B
null;
END;
/
-- Database B: sends a PL/SQL table to database A
CREATE OR REPLACE PROCEDURE pcalling IS
TabX DBMS_SQL.VARCHAR2S@DBLINK2;
BEGIN
pcalled@DBLINK2(TabX);
END;

21. What is the difference between stored procedures and functions?

22. Is there a PL/SQL Engine in SQL*Plus?

PL/SQL Quick Reference By A.G.Reddy

 47
No. Unlike Oracle Forms, SQL*Plus does not have an embedded PL/SQL engine. Thus, all your
PL/SQL code is sent directly to the database engine for execution. This makes it much more efficient as
SQL statements are not stripped off and sent to the database individually.

23. Is there a limit on the size of a PL/SQL block?

Yes, the max size is not an explicit byte limit, but related to the parse tree that is created when you
compile the code. You can run the following select statement to query the size of an existing package or
procedure:

SQL> select * from dba_object_size where name = 'procedure_name';

24. Can one COMMIT/ ROLLBACK from within a trigger?

Changes made within triggers should be committed or rolled back as part of the transaction in which
they execute. Thus, triggers are NOT allowed to execute COMMIT or ROLLBACK statements (with the
exception of autonomous triggers).

As workaround, one can use autonomous transactions. Autonomous transactions execute separate from
the current transaction. Unlike regular triggers, autonomous triggers can contain COMMIT and
ROLLBACK statements.

SET#2
1. What Is PL/SQL Language Case Sensitive?
PL/SQL language is not case sensitive:

2. How to Place Comments in PL/SQL?

3. What Are the Types PL/SQL Code Blocks?
4. What Is an Anonymous Block?
5. What Is a Named Program Unit?
6. What Is a Procedure?
7. What Is a Function?
8. How to Declare a Local Variable?

9. How to Initialize Variables with Default Values?

Price REAL DEFAULT 999999.99;
10. How to Assign Values to Variables?
Counter NUMBER: = 0;

11. What Are the Arithmetic Operations?

12. What Are the Numeric Comparison Operations?
13. What Are the Logical Operations?
14. How Many Categories of Data Types?
15. How Many Scalar Data Types Are Supported in PL/SQL?
PL/SQL supports many scalar data types divided into 4 groups:
a. Numeric Types
b. Character Types
c. Boolean Types
d. Date Types

16. How To Convert Character Types to Numeric Types?

You can convert character types to numeric types in two ways:

PL/SQL Quick Reference By A.G.Reddy

 48
1. Explicitly by using TO_NUMBER () function.
2. Implicitly by putting character data in a numeric operation.

17. What Are the Execution Control Statements?

18. How To Use "IF" Statements on Multiple Conditions?
19. How To Use "WHILE" Statements?
20. How to Use "FOR" Statements?
21. What Is NULL in PL/SQL?
NULL is a reserved key word and it stands for two things in PL/SQL:
1. NULL is an executable statement, and means doing nothing.
2. NULL is a data value, and means no value.

22. How to Test NULL Values?

There ate two special comparison operators you can use on NULL values:
1. "Variable IS NULL" - Returns TRUE if the variable value is NULL.
2. "Variable IS NOT NULL" - Return TRUE if the variable value is not NULL.

PL/SQL Quick Reference By A.G.Reddy