UNIT – V
Transaction – the Basics of PL/SQL creating and using stored procedures, Functions and Packages –
Retrieving Data with cursors. Enforcing Business Rules with Database triggers.
. Basic Structure of PL/SQL
PL/SQL stands for Procedural Language/SQL. PL/SQL extends SQL by adding
constructs found in procedural languages, resulting in a structural language that is more powerful
than SQL. 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 he
program.
A block has the following structure:
DECLARE
/* Declarative section: variables, types, and local subprograms. */
BEGIN
/* Executable section: procedural and SQL statements go here. */
/* This is the only section of the block that is required. */
EXCEPTION
/* Exception handling section: error handling statements go here. */
END;
Only the executable section is required. The other sections are optional. The only
SQL statements allowed in a PL/SQL program are SELECT, INSERT, UPDATE, DELETE and several
other data manipulation statements plus some transaction control. However, the SELECT
statement has a special form in which a single tuple is placed in variables. Data definition
statements like CREATE, DROP, or ALTER are not allowed. The executable section also contains
constructs such as assignments, branches, loops, procedure calls, and triggers. PL/SQL is
not case sensitive. C style comments (/* ... */) may be used.
To execute a PL/SQL program, we must follow the program text itself by


A line with a single dot ("."), and then
A line with run;
As with Oracle SQL programs, we can invoke a PL/SQL program either by typing it in sqlplus
.
Variables and Types
Information is transmitted between a PL/SQL program and the database through variables.
Every variable has a specific type associated with it. That type can be



One of the types used by SQL for database columns
A generic type used in PL/SQL such as NUMBER
Declared to be the same as the type of some database column
The most commonly used generic type is NUMBER. Variables of type NUMBER can hold either an
integer or a real number. The most commonly used character string type is VARCHAR(n), where n
is the maximum length of the string in bytes. This length is required, and there is no default. For
example, we might declare:
DECLARE
price
NUMBER;
myBeer VARCHAR(20);
Note that PL/SQL allows BOOLEAN variables, even though Oracle does not support BOOLEAN as a
type for database columns.
DECLARE
myBeer Beers.name%TYPE;
gives PL/SQL variable myBeer whatever
Beers.
type was declared for the name column in relation
A variable may also have a type that is a record with several fields. The simplest way to declare
such a variable is to use %ROWTYPE on a relation name. The result is a record type in which the
fields have the same names and types as the attributes of the relation. For instance:
DECLARE
beerTuple Beers%ROWTYPE;
makes variable beerTuple be a record with fields name
relation has the schema Beers(name, manufacture).
and manufacture, assuming that the
The initial value of any variable, regardless of its type, is NULL. We can assign values to
variables, using the ":=" operator. The assignment can occur either immediately after the type of
the variable is declared, or anywhere in the executable portion of the program. An example:
DECLARE
a NUMBER := 3;
BEGIN
a := a + 1;
END;
run;
This program has no effect when run, because there are no changes to the database.
Procedures
PL/SQL procedures behave very much like procedures in other programming language.
Here is an example of a PL/SQL procedure addtuple1 that, given an integer i, inserts the tuple
(i, 'xxx') into the following example relation:
CREATE TABLE T2 (
a INTEGER,
b CHAR(10)
);
CREATE PROCEDURE addtuple1(i IN NUMBER) AS
BEGIN
INSERT INTO T2 VALUES(i, 'xxx');
END addtuple1;
run;
A procedure is introduced by the keywords CREATE PROCEDURE followed by the
procedure name and its parameters. An option is to follow CREATE by OR REPLACE. The
advantage of doing so is that should you have already made the definition, you will not get an
error. On the other hand, should the previous definition be a different procedure of the same
name, you will not be warned, and the old procedure will be lost.
There can be any number of parameters, each followed by a mode and a type. The possible
modes are IN (read-only), OUT (write-only), and INOUT (read and write
Following the arguments is the keyword AS (IS is a synonym). Then comes the body, which is
essentially a PL/SQL block. We have repeated the name of the procedure after the END, but this
is optional. However, the DECLARE section should not start with the keyword DECLARE. Rather,
following AS we have:
... AS
<local_var_declarations>
BEGIN
<procedure_body>
END;
.
run;
The run at the end runs the statement that creates the procedure; it does not execute the
procedure. To execute the procedure, use another PL/SQL statement, in which the procedure is
invoked as an executable statement. For example:
BEGIN addtuple1(99); END;
.
run;
Printing Variables
. A more couth way is to define a bind variable, which is the only kind that may be printed with
a print command. Bind variables are the kind that must be prefixed with a colon in PL/SQL
statements, such as :new discussed in the section on triggers.
The steps are as follows:
1. We declare a bind variable as follows:
VARIABLE <name> <type>
where the type can be only one of three things: NUMBER, CHAR, or CHAR(n).
2. We may then assign to the variable in a following PL/SQL statement, but we must prefix
it with a colon.
3. Finally, we can execute a statement
PRINT :<name>;
outside the PL/SQL statement
Here is a trivial example, which prints the value 1.
VARIABLE x NUMBER
BEGIN
:x := 1;
END;
.
run;
PRINT :x;
Stored Procedure
A stored procedure or in simple a proc is a named PL/SQL block which performs one
or more specific task. This is similar to a procedure in other programming languages. A
procedure has a header and a body. The header consists of the name of the procedure and the
parameters or variables passed to the procedure. The body consists or declaration section,
execution section and exception section similar to a general PL/SQL Block. A procedure is
similar to an anonymous PL/SQL Block but it is named for repeated usage.
We
can
pass
1)IN-parameters
2)OUT-parameters
3) IN OUT-parameters
parameters
to
procedures
in
A procedure may or may not return any value.
General Syntax to create a procedure is:
CREATE [OR REPLACE] PROCEDURE proc_name [list of parameters]
IS
three
ways.
Declaration section
BEGIN
Execution section
EXCEPTION
Exception section
END;
IS - marks the beginning of the body of the procedure and is similar to DECLARE in anonymous
PL/SQL Blocks. The code between IS and BEGIN forms the Declaration section.
The syntax within the brackets [ ] indicate they are optional. By using CREATE OR REPLACE
together the procedure is created if no other procedure with the same name exists or the existing
procedure is replaced with the current code.
Execution of a Stored Procedure.
There are two ways to execute a procedure.
1) From the SQL prompt.
EXECUTE [or EXEC] procedure_name;
2) Within another procedure – simply use the procedure name.
procedure_name;
PL/SQL Packages
A package is a schema object that groups logically related PL/SQL types, items, and
subprograms. Packages usually have two parts, a specification and a body, although sometimes
the body is unnecessary. The specification (spec for short) is the interface to your applications; it
declares the types, variables, constants, exceptions, cursors, and subprograms available for use.
The body fully defines cursors and subprograms, and so implements the spec.
To create packages, use the CREATE PACKAGE statement, which you can execute interactively
from SQL*Plus. Here is the syntax:
CREATE [OR REPLACE] PACKAGE package_name
[AUTHID {CURRENT_USER | DEFINER}]
{IS | AS}
[PRAGMA SERIALLY_REUSABLE;]
[collection_type_definition ...]
[record_type_definition ...]
[subtype_definition ...]
[collection_declaration ...]
[constant_declaration ...]
[exception_declaration ...]
[object_declaration ...]
[record_declaration ...]
[variable_declaration ...]
[cursor_spec ...]
[function_spec ...]
[procedure_spec ...]
[call_spec ...]
[PRAGMA RESTRICT_REFERENCES(assertions) ...]
END [package_name];
The spec holds public declarations, which are visible to your application. You must declare
subprograms at the end of the spec after all other items (except pragmas that name a specific
function; such pragmas must follow the function spec).
The body holds implementation details and private declarations, which are hidden from your
application. Following the declarative part of the package body is the optional initialization part,
which typically holds statements that initialize package variables.
A call spec lets you publish a Java method or external C function in the Oracle data dictionary.
The call spec publishes the routine by mapping its name, parameter types, and return type to their
SQL counterparts..
Advantages of PL/SQL Packages
Modularity
Packages let you encapsulate logically related types, items, and subprograms in a named PL/SQL
module. Each package is easy to understand, and the interfaces between packages are simple,
clear, and well defined. This aids application development.
Easier Application Design
When designing an application, all you need initially is the interface information in the package
specs. You can code and compile a spec without its body. Then, stored subprograms that
reference the package can be compiled as well. You need not define the package bodies fully
until you are ready to complete the application.
Information Hiding
With packages, you can specify which types, items, and subprograms are public (visible and
accessible) or private (hidden and inaccessible). For example, if a package contains four
subprograms, three might be public and one private. The package hides the implementation of
the private subprogram so that only the package (not your application) is affected if the
implementation changes. This simplifies maintenance and enhancement. Also, by hiding
implementation details from users, you protect the integrity of the package.
Added Functionality
Packaged public variables and cursors persist for the duration of a session. So, they can be shared
by all subprograms that execute in the environment. Also, they allow you to maintain data across
transactions without having to store it in the database.
Better Performance
When you call a packaged subprogram for the first time, the whole package is loaded into
memory. So, later calls to related subprograms in the package require no disk I/O. Also,
packages stop cascading dependencies and thereby avoid unnecessary recompiling.
Cursor
A cursor is a variable that runs through the tuples of some relation. This relation can
be a stored table, or it can be the answer to some query. A cursor is a temporary work area
created in the system memory when a SQL statement is executed. A cursor contains information
on a select statement and the rows of data accessed by it. This temporary work area is used to
store the data retrieved from the database, and manipulate this data. A cursor can hold more than
one row, but can process only one row at a time. The set of rows the cursor holds is called the
active set.
To use cursors in SQL procedures, you need to do the following:
1. Declare a cursor that defines a result set.
2. Open the cursor to establish the result set.
3. Fetch the data into local variables as needed from the cursor, one row at a time.
4. Close the cursor when done
To work with cursors you must use the following SQL statements:
 DECLARE CURSOR
 OPEN
 FETCH
 CLOSE
There are two types of cursors in PL/SQL:
Implicit cursors:
These are created by default when DML statements like, INSERT, UPDATE, and
DELETE statements are executed. They are also created when a SELECT statement that returns
just one row is executed.
Explicit cursors:
They must be created when you are executing a SELECT statement that returns more
than one row. Even though the cursor stores multiple records, only one record can be processed
at a time, which is called as current row. When you fetch a row the current row position moves
to next row.
Both implicit and explicit cursors have the same functionality, but they differ in the way they are
accessed.
The following example demonstrates the basic use of a read-only cursor within an SQL procedure:
CREATE PROCEDURE sum_salaries(OUT sum INTEGER)
LANGUAGE SQL
BEGIN
DECLARE SQLSTATE CHAR(5) DEFAULT '00000';
DECLARE p_sum INTEGER;
DECLARE p_sal INTEGER;
DECLARE c CURSOR FOR SELECT SALARY FROM EMPLOYEE;
SET p_sum = 0;
OPEN c;
FETCH FROM c INTO p_sal;
WHILE(SQLSTATE = '00000') DO
SET p_sum = p_sum + p_sal;
FETCH FROM c INTO p_sal;
END WHILE;
CLOSE c;
SET sum = p_sum;
END%
Functions
PL/SQL Functions
What is a Function in PL/SQL?
A function is a named PL/SQL Block which is similar to a procedure. The major difference
between a procedure and a function is, a function must always return a value, but a
procedure
may
or
may
not
return
a
value.
The General Syntax to create a function is:
CREATE [OR REPLACE] FUNCTION function_name [parameters]
RETURN return_datatype;
IS
Declaration_section
BEGIN
Execution_section
Return return_variable;
EXCEPTION
exception section
Return return_variable;
END;
1) Return Type: The header section defines the return type of the function. The return
datatype can be any of the oracle datatype like varchar, number etc.
2) The execution and exception section both should return a value which is of the datatype
defined in the header section.
For example, let’s create a frunction called ''employer_details_func' similar to the one created in
stored proc
1> CREATE OR REPLACE FUNCTION employer_details_func
2>
RETURN VARCHAR(20);
3> IS
5>
emp_name VARCHAR(20);
6> BEGIN
7>
SELECT first_name INTO emp_name
8>
FROM emp_tbl WHERE empID = '100';
9>
RETURN emp_name;
10> END;
11> /
In the example we are retrieving the ‘first_name’ of employee with empID 100 to variable
‘emp_name’.
The return type of the function is VARCHAR which is declared in line no 2.
The function returns the 'emp_name' which is of type VARCHAR as the return value in line no
9.
How to execute a PL/SQL Function?
A function can be executed in the following ways.
1) Since a function returns a value we can assign it to a variable.
employee_name
:=
employer_details_func;
If ‘employee_name’ is of datatype varchar we can store the name of the employee by assigning
the return type of the function to it.
2) As a part of a SELECT statement
SELECT employer_details_func FROM dual;
3) In a PL/SQL Statements like,
dbms_output.put_line(employer_details_func);
This line displays the value returned by the function.
Triggers
A trigger is a pl/sql block structure which is fired when a DML statements like Insert,
Delete, Update is executed on a database table. A trigger is triggered automatically when an
associated DML statement is executed.
Syntax of Triggers
The Syntax for creating a trigger is:
CREATE [OR REPLACE ] TRIGGER trigger_name
{BEFORE | AFTER | INSTEAD OF }
{INSERT [OR] | UPDATE [OR] | DELETE}
[OF col_name]
ON table_name
[REFERENCING OLD AS name1 NEW AS name2]
[FOR EACH ROW]
WHEN (condition)
BEGIN
--- sql statements
END;









CREATE [OR REPLACE ] TRIGGER trigger_name - This clause creates a trigger with the given name
or overwrites an existing trigger with the same name.
{BEFORE | AFTER | INSTEAD OF } - This clause indicates at what time should the trigger get fired.
i.e for example: before or after updating a table. INSTEAD OF is used to create a trigger on a
view. before and after cannot be used to create a trigger on a view.
{INSERT [OR] | UPDATE [OR] | DELETE} - This clause determines the triggering event. More than
one triggering events can be used together separated by OR keyword. The trigger gets fired at
all the specified triggering event.
[OF col_name] - This clause is used with update triggers. This clause is used when you want to
trigger an event only when a specific column is updated.
CREATE [OR REPLACE ] TRIGGER trigger_name - This clause creates a trigger with the given name
or overwrites an existing trigger with the same name.
[ON table_name] - This clause identifies the name of the table or view to which the trigger is
associated.
[REFERENCING OLD AS o NEW AS n] - This clause is used to reference the old and new values of
the data being changed. By default, you reference the values as :old.column_name or
:new.column_name. The reference names can also be changed from old (or new) to any other
user-defined name. You cannot reference old values when inserting a record, or new values
when deleting a record, because they do not exist.
[FOR EACH ROW] - This clause is used to determine whether a trigger must fire when each row
gets affected ( i.e. a Row Level Trigger) or just once when the entire sql statement is
executed(i.e.statement level Trigger).
WHEN (condition) - This clause is valid only for row level triggers. The trigger is fired only for
rows that satisfy the condition specified.
Types of PL/SQL Triggers
There are two types of triggers based on the which level it is triggered.
1) Row level trigger - An event is triggered for each row upated, inserted or deleted.
2) Statement level trigger - An event is triggered for each sql statement executed.