PL/SQL

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 the program. A PL/SQL Block consists of three sections:

The Declaration section (optional). The Execution section (mandatory). The Exception (or Error) Handling section (optional).

Declaration Section:
The Declaration section of a PL/SQL Block starts with the reserved keyword DECLARE. This section is optional and is used to declare any placeholders like variables, constants, records and cursors, which are used to manipulate data in the execution section. Placeholders may be any of Variables, Constants and Records, which stores data temporarily. Cursors are also declared in this section.

Execution Section:
The Execution section of a PL/SQL Block starts with the reserved keyword BEGIN and ends with END. This is a mandatory section and is the section where the program logic is written to perform any task. The programmatic constructs like loops, conditional statement and SQL statements form the part of execution section.

Exception Section:
The Exception section of a PL/SQL Block starts with the reserved keyword EXCEPTION. This section is optional. Any errors in the program can be handled in this section, so that the PL/SQL Blocks terminates gracefully. If the PL/SQL Block contains exceptions that cannot be handled, the Block terminates abruptly with errors. Every statement in the above three sections must end with a semicolon ;. PL/SQL blocks can be nested within other PL/SQL blocks. C style comments (/* ... */) may be used to document code.

This is how a sample PL/SQL Block looks. DECLARE Variable declaration BEGIN Program Execution EXCEPTION Exception handling END;

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. 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.

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;

PL/SQL Placeholders

Placeholders are temporary storage area. Placeholders can be any of Variables, Constants and Records. Oracle defines placeholders to store data temporarily, which are used to manipulate data during the execution of a PL SQL block. Depending on the kind of data we want to store, we can define placeholders with a name and a datatype. Few of the datatypes used to define placeholders are as given below. Number (n,m) , Char (n) , Varchar2 (n) , Date , Long , Long raw, Raw, Blob, Clob, Nclob, Bfile

PL/SQL Variables
These are placeholders that store the values that can change through the PL/SQL Block. The General Syntax to declare a variable is:
variable_name datatype [NOT NULL := value ];

variable_name is the name of the variable. datatype is a valid PL/SQL datatype. NOT NULL is an optional specification on the variable. value or DEFAULT valueis also an optional specification, where you can initialize a variable. Each variable declaration is a separate statement and must be terminated by a semicolon.

For example, if you want to store the current salary of an employee, you can use a variable.
DECLARE salary number (6);

* salary is a variable of datatype number and of length 6. When a variable is specified as NOT NULL, you must initialize the variable when it is declared.

For example: The below example declares two variables, one of which is a not null.
DECLARE salary number(4); dept varchar2(10) NOT NULL := HR Dept;

The value of a variable can change in the execution or exception section of the PL/SQL Block. We can assign values to variables in the two ways given below. 1) We can directly assign values to variables. The General Syntax is: variable_name := value; 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;

2) We can assign values to variables directly from the database columns by using a SELECT.. INTO statement. The General Syntax is:
SELECT column_name INTO variable_name FROM table_name [WHERE condition]; DECLARE var_salary number(6); var_emp_id number(6) = 500; BEGIN SELECT salary INTO var_salary FROM employee WHERE emp_id = var_emp_id;

END; . run;

Scope of Variables
PL/SQL allows the nesting of Blocks within Blocks i.e, the Execution section of an outer block can contain inner blocks. Therefore, a variable which is accessible to an outer Block is also accessible to all nested inner Blocks. The variables declared in the inner blocks are not accessible to outer blocks. Based on their declaration we can classify variables into two types.

Local variables - These are declared in a inner block and cannot be referenced by outside Blocks. Global variables - These are declared in a outer block and can be referenced by its itself and by its inner blocks.

For Example: The variable 'var_mult' is declared in the inner block, so cannot be accessed in the outer block i.e. it cannot be accessed after line 11. The variables 'var_num1' and 'var_num2' can be accessed anywhere in the block.
1> DECLARE 2> var_num1 number; 3> var_num2 number; 4> BEGIN 5> var_num1 := 100; 6> var_num2 := 200; 7> DECLARE 8> var_mult number; 9> BEGIN 10> var_mult := var_num1 * var_num2; 11> END; 12> END; 13> . 14> run

PL/SQL Constants

As the name implies a constant is a value used in a PL/SQL Block that remains unchanged throughout the program. A constant is a user-defined literal value. We can declare a constant and use it instead of actual value.
The General Syntax to declare a constant is:
constant_name CONSTANT datatype := VALUE;

For example, to declare salary_increase, you can write code as follows:

1. DECLARE salary_increase CONSTANT number (3) := 10;

We must assign a value to a constant at the time we declare it. If we do not assign a value to a constant while declaring it and try to assign a value in the execution section, we will get an error.
2. DECLARE salary_increase CONSTANT number(3); BEGIN salary_increase := 100; END;

Second code gives error as constant salary_increase is assigned value in execution section but constants must be assigned value in declaration section only.

PL/SQL Records

What are records?

Records are another type of datatypes which oracle allows to be defined as a placeholder. Records are composite datatypes, which means it is a combination of different scalar datatypes like char, varchar, number etc. Each scalar data types in the record holds a value. A record can be visualized as a row of data. It can contain all the contents of a row.

Declaring a record:
To declare a record, we must first define a composite datatype; then declare a record for that type. The General Syntax to define a composite datatype is:
TYPE record_type_name IS RECORD (first_col_name column_datatype, second_col_name column_datatype, ...);

record_type_name it is the name of the composite type we want to define. first_col_name, second_col_name, etc.,- it is the names the fields/columns within the record. column_datatype defines the scalar datatype of the fields.

There are different ways we can declare the datatype of the fields. 1) We can declare the field in the same way as we declare the fieds while creating the

table. Col_name column_datatype;

2)

If a field is based on a column from database table, we can define the field_type as follows:
col_name table_name.column_name%type;

By declaring the field datatype in the above method, the datatype of the column is dynamically applied to the field. This method is useful when we are altering the column specification of the table, because we do not need to change the code again.
NOTE: we can use also %type to declare variables and constants. The General Syntax to declare a record of a user-defined datatype is:
record_name record_type_name;

The following code shows how to declare a record called employee_rec based on a user-defined type.
DECLARE TYPE employee_type IS RECORD (employee_id number(5), employee_first_name varchar2(25), employee_last_name employee.last_name%type, employee_dept employee.dept%type); employee_salary employee.salary%type; employee_rec employee_type;

If all the fields of a record are based on the columns of a table, we can declare the record as follows:
record_name table_name%ROWTYPE;

For example, the above declaration of employee_rec can be as follows:

DECLARE employee_rec employee%ROWTYPE;

The advantages of declaring the record as a ROWTYPE are: 1) We do not need to explicitly declare variables for all the columns in a table. 2) If we alter the column specification in the database table, we do not need to update the code. The disadvantage of declaring the record as a ROWTYPE is: 1) When we create a record as a ROWTYPE, fields will be created for all the columns in the table and memory will be used to create the datatype for all the fields. So we must use ROWTYPE only when we are using all the columns of the table in the program.

When we are creating a record, we are just creating a datatype, similar to creating a variable. We need to assign values to the record to use them.

The following table consolidates the different ways in which you can define and declare a pl/sql record. Usage
Syntax

TYPE record_type_name IS RECORD (column_name1 datatype, column_name2 datatype, ...); col_name table_name.column_name%type; record_name record_type_name; record_name table_name%ROWTYPE;

Define a composite datatype, where each field is scalar. Dynamically define the datatype of a column based on a database column. Declare a record based on a user-defined type.
Dynamically declare a record based on an entire row of a table. Each column in the table corresponds to a field in the record.

Passing Values To and From a Record

When we assign values to a record, you actually assign values to the fields within it. The General Syntax to assign a value to a column within a record direclty is:
record_name.col_name := value;

If we use %ROWTYPE to declare a record, we can assign values as shown:

record_name.column_name := value;

We can assign values to records using SELECT Statements as shown:

SELECT col1, col2 INTO record_name.col_name1, record_name.col_name2 FROM table_name [WHERE clause];

If %ROWTYPE is used to declare a record then we can directly assign values to the whole record instead of each column separately. In this case, we must SELECT all the columns from the table into the record as shown:
SELECT * INTO record_name FROM table_name [WHERE clause];

Lets see how we can get values from a record. The General Syntax to retrieve a value from a specific field into another variable is:
var_name := record_name.col_name;

The following table consolidates the different ways you can assign values to and from a record:
Syntax

Usage

record_name.col_name := value;

To directly assign a value to a specific column of a record. record_name.column_name := value; To directly assign a value to a specific column of a record, if the record is declared using %ROWTYPE. SELECT col1, col2 INTO record_name.col_name1, To assign values to each field of a record_name.col_name2 FROM table_name record from the database table. [WHERE clause]; SELECT * INTO record_name FROM table_name To assign a value to all fields in the [WHERE clause]; record from a database table. variable_name := record_name.col_name; To get a value from a record column and assigning it to a variable.

Conditional Statements in PL/SQL

As the name implies, PL/SQL supports programming language features like conditional statements, iterative statements.

The programming constructs are similar to how we use in programming languages like Java and C++. IF THEN ELSE STATEMENT
IF condition THEN statement 1; ELSE statement 2; END IF;

Iterative Statements in PL/SQL

An iterative control Statements are used when we want to repeat the execution of one or more statements for specified number of times. These are similar to those in

There are three types of loops in PL/SQL: Simple Loop While Loop For Loop

1) Simple Loop
A Simple Loop is used when a set of statements is to be executed at least once before the loop terminates. An EXIT condition must be specified in the loop, otherwise the loop will get into an infinite number of iterations. When the EXIT condition is satisfied the process exits from the loop.
The General Syntax to write a Simple Loop is:
LOOP statements; EXIT; {or EXIT WHEN condition;} END LOOP;

These are the important steps to be followed while using Simple Loop.

1) Initialise a variable before the loop body. 2) Increment the variable in the loop. 3) Use a EXIT WHEN statement to exit from the Loop. If you use a EXIT statement without WHEN condition, the statements in the loop is executed only once.

2) While Loop
A WHILE LOOP is used when a set of statements has to be executed as long as a condition is true. The condition is evaluated at the beginning of each iteration. The iteration continues until the condition becomes false.
The General Syntax to write a WHILE LOOP is:
WHILE <condition> LOOP statements; END LOOP;

Important steps to follow when executing a while loop:

1) Initialise a variable before the loop body. 2) Increment the variable in the loop. 3) EXIT WHEN statement and EXIT statements can be used in while loops but it's not done oftenly.

3) FOR Loop
A FOR LOOP is used to execute a set of statements for a predetermined number of times. Iteration occurs between the start and end integer values given. The counter is always incremented by 1. The loop exits when the counter reachs the value of the end integer. The General Syntax to write a FOR LOOP is:
FOR counter IN val1..val2 LOOP statements; END LOOP;

val1 - Start integer value. val2 - End integer value.

Important steps to follow when executing a while loop:

1) The counter variable is implicitly declared in the declaration section, so it's not necessary to declare it explicity. 2) The counter variable is incremented by 1 and does not need to be incremented explicitly. 3) EXIT WHEN statement and EXIT statements can be used in FOR loops but it's not done oftenly.