Home > Programming > PL/SQL


PL/SQL (Procedural Language/Structured Query Language) is Oracle Corporation’s procedural extension language for SQL and the Oracle relational database. PL/SQL’s general syntax resembles that of Ada or Pascal.
PL/SQL is one of three key programming languages embedded in the Oracle Database, along with SQL itself and Java.
PL/SQL is available in Oracle Database (since version 7), TimesTen in-memory database (since version 11.2.1), and IBM DB2 (since version 9.7).[1]


PL/SQL supports variables, conditions, loops and exceptions. Arrays are also supported, though in a somewhat unusual way, involving the use of PL/SQL collections. PL/SQL collections is a slightly advanced topic.
Implementations from version 8 of Oracle Database onwards have included features associated with object-orientation.
PL/SQL program units (essentially code containers) can be compiled into the Oracle database. Programmers can thus embed PL/SQL units of functionality into the database directly. They also can write scripts containing PL/SQL program units that can be read into the database using the Oracle SQL*Plus tool.
Once the program units have been stored into the database, they become available for execution at a later time.
While programmers can readily embed Data Manipulation Language (DML) statements directly into their PL/SQL code using straightforward SQL statements, Data Definition Language (DDL) requires more complex “Dynamic SQL” statements to be written in the PL/SQL code. However, DML statements underpin the majority of PL/SQL code in typical software applications.
In the case of PL/SQL dynamic SQL, early versions of the Oracle Database required the use of a complicated Oracle DBMS_SQL package library. More recent versions have however introduced a simpler “Native Dynamic SQL”, along with an associated EXECUTE IMMEDIATE syntax.
Oracle Corporation customarily extends package functionality with each successive release of the Oracle Database.

PL/SQL program units

Anonymous blocks

Anonymous blocks form the basis of the simplest PL/SQL code, and have the following structure:

        TYPE / item / FUNCTION / PROCEDURE declarations
        EXCEPTION handlers
END label;

The <> and the DECLARE and EXCEPTION sections are optional.
Exceptions, errors which arise during the execution of the code, have one of two types:

  1. Predefined exceptions
  2. User-defined exceptions.

User-defined exceptions are always raised explicitly by the programmers, using the RAISE or RAISE_APPLICATION_ERROR commands, in any situation where they have determined that it is impossible for normal execution to continue. RAISE command has the syntax:


Oracle Corporation has pre-defined several exceptions like NO_DATA_FOUND, TOO_MANY_ROWS, etc. Each exception has a SQL Error Number and SQL Error Message associated with it. Programmers can access these by using the SQLCODE and SQLERRM functions.
The DECLARE section defines and (optionally) initialises variables. If not initialised specifically, they default to NULL.
For example:

  number1 NUMBER(2);
  number2 number1%TYPE    := 17;             -- value default
  text1   VARCHAR2(12) := 'Hello world';
  text2   DATE         := SYSDATE;        -- current date and time
  SELECT street_number
    INTO number1
    FROM address
   WHERE name = 'INU';

The symbol := functions as an assignment operator to store a value in a variable.
The major datatypes in PL/SQL include NUMBER, INTEGER, CHAR, VARCHAR2, DATE, TIMESTAMP, TEXT etc.


Functions in PL/SQL group together SQL and PL/SQL statements that perform a task and should return a value or values to the calling environment. User-defined functions are used to supplement the many hundreds of functions built-in by Oracle Corporation.
There are two different types of functions in PL/SQL. The traditional function has the form:

CREATE OR REPLACE FUNCTION <function_name> [(input/output variable declarations)]
        [declaration block]
        <PL/SQL block WITH RETURN statement>
        RETURN <return_value>;
        EXCEPTION block]
        RETURN <return_value>;

Pipelined table functions return collections[2] and take the form::

CREATE OR REPLACE FUNCTION <function_name> [(input/output variable declarations)] RETURN return_type
        [declaration block]
        <PL/SQL block WITH RETURN statement>
        PIPE ROW <RETURN type>;
        EXCEPTION block]
        PIPE ROW <RETURN type>;

There are three types of parameter: IN, OUT and IN OUT.

  1. An IN parameter is used as input only. An IN parameter is passed by reference but 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 by default by copying but – with the NOCOPY hint – may be passed by reference.


Procedures are similar to Functions, in that they can be executed to perform work. The primary difference is that procedures cannot be used in a SQL statement. Another difference is that it can return multiple values. Procedures are traditionally the workhorse of the coding world and functions are traditionally the smaller, more specific pieces of code. PL/SQL maintains many of the distinctions between functions and procedures found in many general-purpose programming languages, but in addition, functions can be called from SQL, while procedures cannot.


Packages are groups of conceptually linked functions, procedures, variables, PL/SQL table and record TYPE statements, constants, cursors etc. The use of packages promotes re-use of code. Packages are composed of the package specification and an optional package body. The specification is the interface to the application; it declares the types, variables, constants, exceptions, cursors, and subprograms available. The body fully defines cursors and subprograms, and so implements the spec. Two advantages of packages include:

  1. Modular approach, encapsulation/hiding of business logic, security, performance improvement, re-usability. They support Object-oriented programming features like function overloading and encapsulation.
  2. Using package variables one can declare session level (scoped) variables, since variables declared in the package specification have a session scope.

Numeric variables

variable_name NUMBER(P[,S]) := VALUE;

To define a numeric variable, the programmer appends the variable type NUMBER to the name definition. To specify the (optional) precision(P) and the (optional) scale (S), one can further append these in round brackets, separated by a comma. (“Precision” in this context refers to the number of digits which the variable can hold, “scale” refers to the number of digits which can follow the decimal point.)
A selection of other datatypes for numeric variables would include: binary_float, binary_double, dec, decimal, double precision, float, integer, int, numeric, real, smallint, binary_integer m

Character variables

variable_name VARCHAR2(10) := 'Text';

To define a character variable, the programmer normally appends the variable type VARCHAR2 to the name definition. There follows in brackets the maximum number of characters which the variable can store.
Other datatypes for character variables include: varchar, char, long, raw, long raw, nchar, nchar2, clob, blob, bfile

Date variables

variable_name DATE := TO_DATE('01-01-2005 14:20:23','DD-MM-YYYY hh24:mi:ss');

Date variables can contain date and time. The time may be left out, but there is no way to define a variable that only contains the time. There is no DATETIME type. And there is no TIME type. But there is a TIMESTAMP type that can contain fine grained timestamp up to millisecond or nanosecond. Oracle Datatypes
The TO_DATE function can be used to convert strings to date values. The function converts the first quoted string into a date, using as a definition the second quoted string, for example:



 TO_DATE ('31-Dec-2004','dd-mon-yyyy', 'NLS_DATE_LANGUAGE = American')

To convert the dates to strings one uses the function TO_CHAR (date_string, format_string).
PL/SQL also supports the use of ANSI date and interval literals.[3] The following clause gives an 18-month range:

WHERE dateField BETWEEN DATE '2004-12-31' - INTERVAL '1-6' YEAR TO MONTH
    AND DATE '2004-12-31'

Datatypes for specific columns

Variable_name Table_name.Column_name%type;
This syntax defines a variable of the type of the referenced column on the referenced tables.
Programmers specify user-defined datatypes with the syntax:

type data_type is record (field_1 type_1 :=xyz, field_2 type_2 :=xyz, ..., field_n type_n :=xyz);

For example:

    TYPE t_address IS  RECORD (
        name address.name%TYPE,
        street address.street%TYPE,
        street_number address.street_number%TYPE,
        postcode address.postcode%TYPE);
    v_address t_address;
    SELECT name, street, street_number, postcode INTO v_address FROM address WHERE ROWNUM = 1;

This sample program defines its own datatype, called t_address, which contains the fields name, street, street_number and postcode.
So according to the example, we are able to copy the data from the database to the fields in the program.
Using this datatype the programmer has defined a variable called v_address and loaded it with data from the ADDRESS table.
Programmers can address individual attributes in such a structure by means of the dot-notation, thus: “v_address.street := ‘High Street’;”

Conditional statements

The following code segment shows the IF-THEN-ELSIF construct. The ELSIF and ELSE parts are optional so it is possible to create simpler IF-THEN or, IF-THEN-ELSE constructs.

IF x = 1 THEN

The CASE statement simplifies some large IF-THEN-ELSE structures.

   WHEN x = 1 THEN sequence_of_statements_1;
   WHEN x = 2 THEN sequence_of_statements_2;
   WHEN x = 3 THEN sequence_of_statements_3;
   WHEN x = 4 THEN sequence_of_statements_4;
   WHEN x = 5 THEN sequence_of_statements_5;
   ELSE sequence_of_statements_N;

CASE statement can be used with predefined selector:

   WHEN 1 THEN sequence_of_statements_1;
   WHEN 2 THEN sequence_of_statements_2;
   WHEN 3 THEN sequence_of_statements_3;
   WHEN 4 THEN sequence_of_statements_4;
   WHEN 5 THEN sequence_of_statements_5;
   ELSE sequence_of_statements_N;

Array handling

PL/SQL refers to arrays as “collections”. The language offers three types of collections:

  1. Associative arrays (Index-by tables)
  2. Nested tables
  3. Varrays (variable-size arrays)

Programmers must specify an upper limit for varrays, but need not for index-by tables or for nested tables. The language includes several collection methods used to manipulate collection elements: for example FIRST, LAST, NEXT, PRIOR, EXTEND, TRIM, DELETE, etc. Index-by tables can be used to simulate associative arrays, as in this example of a memo function for Ackermann’s function in PL/SQL.

Associative arrays (Index-by tables)

With index-by tables, the array can be indexed by numbers or strings. It parallels a Java map, which comprises key-value pairs. There is only one dimension and it is unbounded.

Nested tables

With nested tables the programmer needs to understand what is nested. Here, a new type is created that may be composed of a number of components. That type can then be used to make a column in a table, and nested within that column will be those components.

Varrays (variable-size arrays)

With Varrays you need to understand that the word “variable” in the phrase “variable-size arrays” doesn’t apply to the size of the array in the way you might think that it would. The size the array is declared with is in fact fixed. The number of elements in the array is variable up to the declared size. Arguably then, variable-sized arrays aren’t that variable in size.


As a procedural language by definition, PL/SQL provides several iteration constructs, including basic LOOP statements, WHILE loops, FOR loops, and Cursor FOR loops.

LOOP statements

Syntax: –Harmeet


                EXIT parent_loop WHEN <condition>; -- Terminates both loops
                EXIT WHEN <condition>; -- Returns control to parent_loop
        END LOOP;
        IF <condition> THEN
           continue; -- continue to next iteration
        END IF;

        EXIT WHEN <condition>;
END LOOP parent_loop;

Loops can be terminated by using the EXIT keyword, or by raising an exception.

FOR loops

     var NUMBER;
     /*N.B. for loop variables in pl/sql are new declarations, with scope only inside the loop */
     FOR var IN 0 .. 10 LOOP
     END LOOP;

     IF (var IS NULL) THEN
          DBMS_OUTPUT.put_line('var is null');
          DBMS_OUTPUT.put_line('var is not null');
     END IF;

This is the output

 var is null

Cursor FOR loops

FOR RecordIndex IN (SELECT person_code FROM people_table)

Cursor-for loops automatically open a cursor, read in their data and close the cursor again.
As an alternative, the PL/SQL programmer can pre-define the cursor’s SELECT-statement in advance in order (for example) to allow re-use or to make the code more understandable (especially useful in the case of long or complex queries).

  CURSOR cursor_person IS
    SELECT person_code FROM people_table;
  FOR RecordIndex IN cursor_person

The concept of the person_code within the FOR-loop gets expressed with dot-notation (“.”):



Categories: Programming Tags:
  1. No comments yet.
  1. No trackbacks yet.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google+ photo

You are commenting using your Google+ account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )


Connecting to %s

%d bloggers like this: