DBMS - Topic No.-05 - MSBTE-Questions & Answers
DBMS - Topic No.-05 - MSBTE-Questions & Answers
PL/SQL - Overview
The PL/SQL programming language was developed by Oracle Corporation in the late 1980s as
procedural extension language for SQL and the Oracle relational database. Following are
notable facts about PL/SQL:
PL/SQL can also directly be called from the command-line SQL*Plus interface.
Direct call can also be made from external programming language calls to database.
PL/SQL's general syntax is based on that of ADA and Pascal programming language.
Apart from Oracle, PL/SQL is available in TimesTen in-memory database and IBM
DB2.
Features of PL/SQL
PL/SQL has the following features:
SQL is the standard database language and PL/SQL is strongly integrated with SQL.
PL/SQL supports both static and dynamic SQL. Static SQL supports DML operations
and transaction control from PL/SQL block. Dynamic SQL is SQL allows embedding
DDL statements in PL/SQL blocks.
PL/SQL allows sending an entire block of statements to the database at one time. This
reduces network traffic and provides high performance for the applications.
PL/SQL gives high productivity to programmers as it can query, transform, and update
data in a database.
PL/SQL saves time on design and debugging by strong features, such as exception
handling, encapsulation, data hiding, and object-oriented data types.
PL/SQL provides support for Developing Web Applications and Server Pages.
PL/SQL is a block-structured language, meaning that PL/SQL programs are divided and
written in logical blocks of code. Each block consists of three sub-parts:
Advantages of PL/SQL
These are the Advantages of PL/SQL
Block Structures: PL SQL consists of blocks of code, which can be nested within each
other. Each block forms a unit of a task or a logical module. PL/SQL Blocks can be stored in
the database and reused.
Procedural Language Capability: PL SQL consists of procedural language constructs such
as conditional statements (if else statements) and loops like (FOR loops).
Better Performance: PL SQL engine processes multiple SQL statements simultaneously as
a single block, thereby reducing network traffic.
Error Handling: PL/SQL handles errors or exceptions effectively during the execution of a
PL/SQL program. Once an exception is caught, specific actions can be taken depending
upon the type of the exception or it can be displayed to the user with a message.
1 Declarations
This section starts with the keyword DECLARE. It is an optional section and defines all
variables, cursors, subprograms, and other elements to be used in the program.
2 Executable Commands
This section is enclosed between the keywords BEGIN and END and it is a mandatory
section. It consists of the executable PL/SQL statements of the program. It should have at
least one executable line of code, which may be just a NULL command to indicate that
nothing should be executed.
3 Exception Handling
This section starts with the keyword EXCEPTION. This section is again optional and
contains exception(s) that handle errors in the program.
Every PL/SQL statement ends with a semicolon (;). PL/SQL blocks can be nested within
other PL/SQL blocks using BEGIN and END. Here is the basic structure of a PL/SQL
block:
DECLARE
<declarations section>
BEGIN
<executable command(s)>
EXCEPTION
<exception handling>
END;
The end; line signals the end of the PL/SQL block. To run the code from SQL command line,
you may need to type / at the beginning of the first blank line after the last line of the code.
When the above code is executed at SQL prompt, it produces the following result:
Hello World
Category Description
Large Object (LOB) Pointers to large objects that are stored separately from other data
items, such as text, graphic images, video clips, and sound
waveforms.
Composite Data items that have internal components that can be accessed
individually. For example, collections and records.
PL/SQL provides subtypes of data types. For example, the data type NUMBER has a subtype
called INTEGER. You can use subtypes in your PL/SQL program to make the data types
compatible with data types in other programs while embedding PL/SQL code in another
program, such as a Java program.
INTEGER ANSI and IBM specific integer type with maximum precision of
38 decimal digits
SMALLINT ANSI and IBM specific integer type with maximum precision of
38 decimal digits
DECLARE
num1 INTEGER;
num2 REAL;
num3 DOUBLE PRECISION;
BEGIN
null;
END;
/
When the above code is compiled and executed, it produces the following result:
PL/SQL procedure successfully completed
LONG RAW Variable-length binary or byte string with maximum size of 32,760
bytes, not interpreted by PL/SQL
However, SQL has no data type equivalent to BOOLEAN. Therefore, Boolean values cannot be
used in:
SQL statements
The default date format is set by the Oracle initialization parameter NLS_DATE_FORMAT.
For example, the default might be 'DD-MON-YY', which includes a two-digit number for the
day of the month, an abbreviation of the month name, and the last two digits of the year, for
example, 01-OCT-12.
Each DATE includes the century, year, month, day, hour, minute, and second. The following
table shows the valid values for each field:
MONTH 01 to 12 0 to 11
DAY 01 to 31 (limited by the Any nonzero integer
values of MONTH and
YEAR, according to the
rules of the calendar for
the locale)
HOUR 00 to 23 0 to 23
MINUTE 00 to 59 0 to 59
DECLARE
SUBTYPE name IS char(20);
SUBTYPE message IS varchar2(100);
salutation name;
greetings message;
BEGIN
salutation := 'Reader ';
greetings := 'Welcome to the World of PL/SQL';
dbms_output.put_line('Hello ' || salutation || greetings);
END;
/
When the above code is executed at SQL prompt, it produces the following result:
NULLs in PL/SQL
PL/SQL NULL values represent missing or unknown data and they are not an integer, a
character, or any other specific data type. Note that NULL is not the same as an empty data
string or the null character value '\0'. A null can be assigned but it cannot be equated with
anything, including itself.
PL/SQL - Variables
A variable is nothing but a name given to a storage area that our programs can manipulate. Each
variable in PL/SQL has a specific data type, which determines the size and layout of the
variable's memory; the range of values that can be stored within that memory and the set of
operations that can be applied to the variable.
The name of a PL/SQL variable consists of a letter optionally followed by more letters,
numerals, dollar signs, underscores, and number signs and should not exceed 30 characters. By
default, variable names are not case-sensitive. You cannot use a reserved PL/SQL keyword as a
variable name.
PL/SQL programming language allows to define various types of variables, which we will
cover in subsequent chapters like date time data types, records, collections, etc. For this chapter,
let us study only basic variable types.
Where, variable_name is a valid identifier in PL/SQL, datatype must be a valid PL/SQL data
type or any user defined data type which we already have discussed in last chapter. Some valid
variable declarations along with their definition are shown below:
When you provide a size, scale or precision limit with the data type, it is called a constrained
declaration. Constrained declarations require less memory than unconstrained declarations. For
example:
For example:
counter binary_integer := 0;
greetings varchar2(20) DEFAULT 'Have a Good Day';
You can also specify that a variable should not have a NULL value using theNOT
NULL constraint. If you use the NOT NULL constraint, you must explicitly assign an initial
value for that variable.
DECLARE
a integer := 10;
b integer := 20;
c integer;
f real;
BEGIN
c := a + b;
dbms_output.put_line('Value of c: ' || c);
f := 70.0/3.0;
dbms_output.put_line('Value of f: ' || f);
END;
/
Value of c: 30
Value of f: 23.333333333333333333
PL/SQL procedure successfully completed.
Local variables - variables declared in an inner block and not accessible to outer blocks.
Following example shows the usage of Local and Global variables in its simple form:
DECLARE
-- Global variables
num1 number := 95;
num2 number := 85;
BEGIN
dbms_output.put_line('Outer Variable num1: ' || num1);
dbms_output.put_line('Outer Variable num2: ' || num2);
DECLARE
-- Local variables
num1 number := 195;
num2 number := 185;
BEGIN
dbms_output.put_line('Inner Variable num1: ' || num1);
dbms_output.put_line('Inner Variable num2: ' || num2);
END;
END;
/
Table Created
The following program assigns values from the above table to PL/SQL variables using the
SELECT INTO clause of SQL:
DECLARE
c_id customers.id%type := 1;
c_name customers.name%type;
c_addr customers.address%type;
c_sal customers.salary%type;
BEGIN
SELECT name, address, salary INTO c_name, c_addr, c_sal
FROM customers
WHERE id = c_id;
dbms_output.put_line
('Customer ' ||c_name || ' from ' || c_addr || ' earns ' || c_sal);
END;
/
PL/SQL - Constants
Declaring a Constant
A constant is declared using the CONSTANT keyword. It requires an initial value and does not
allow that value to be changed. For example:
DECLARE
salary_increase CONSTANT number (3) := 10;
You must assign a value to a constant at the time you declare it. If you do not assign a value to a
constant while declaring it and try to assign a value in the execution section, you will get a error.
If you execute the below Pl/SQL block you will get error.
DECLARE
salary_increase CONSTANT number(3);
BEGIN
salary_increase := 100;
dbms_output.put_line (salary_increase);
END;
PI CONSTANT NUMBER := 3.141592654;
Ex.- pi constant number := 3.141592654;
PL/SQL - Operators
An operator is a symbol that tells the compiler to perform specific mathematical or logical
manipulation. PL/SQL language is rich in built-in operators and provides the following types of
operators:
Arithmetic operators
Relational operators
Comparison operators
Logical operators
String operators
This tutorial will explain the arithmetic, relational, comparison and logical operators one by
one. The String operators will be discussed under the chapter:PL/SQL - Strings.
Arithmetic Operators
Following table shows all the arithmetic operators supported by PL/SQL. Assume variable A
holds 10 and variable B holds 5 then:
Show Examples
Relational Operators
Relational operators compare two expressions or values and return a Boolean result. Following
table shows all the relational operators supported by PL/SQL. Assume variable A holds 10 and
variable B holds 20, then:
Show Examples
!=
<>
~=
Comparison Operators
Comparison operators are used for comparing one expression to another. The result is always
either TRUE, FALSE OR NULL.
Show Examples
LIKE The LIKE operator compares a character, string, or CLOB value If 'Zara
to a pattern and returns TRUE if the value matches the pattern Ali' like
and FALSE if it does not. 'Z% A_i'
returns a
Boolean
true,
whereas,
'Nuha
Ali' like
'Z% A_i'
returns a
Boolean
false.
Logical Operators
Following table shows the Logical operators supported by PL/SQL. All these operators work on
Boolean operands and produces Boolean results. Assume variable A holds true and variable B
holds false, then:
Show Examples
and Called logical AND operator. If both the operands are true then (A and
condition becomes true. B) is
false.
not Called logical NOT Operator. Used to reverse the logical state of not (A
its operand. If a condition is true then Logical NOT operator will and B) is
make it false. true.
For example x = 7 + 3 * 2; here, x is assigned 13, not 20 because operator * has higher
precedence than +, so it first gets multiplied with 3*2 and then adds into 7.
Here, operators with the highest precedence appear at the top of the table, those with the lowest
appear at the bottom. Within an expression, higher precedence operators will be evaluated first.
Show Examples
Operator Operation
** exponentiation
+, - identity, negation
*, / multiplication, division
comparison
AND conjunction
OR inclusion
PL/SQL - Conditions
IF statement
It is the simplest form of IF control statement, frequently used in decision making and changing
the control flow of the program execution.
The IF statement associates a condition with a sequence of statements enclosed by the
keywords THEN and END IF. If the condition is TRUE, the statements get executed, and if
the condition is FALSE or NULL, then the IFstatement does nothing.
Syntax:
Syntax for IF-THEN statement is:
IF condition THEN
S;
END IF;
If the Boolean expression condition evaluates to true then the block of code inside the if
statement will be executed. If Boolean expression evaluates to false then the first set of code
after the end of the if statement (after the closing end if) will be executed.
Flow Diagram:
Example 1:
Let us try a complete example that would illustrate the concept:
DECLARE
a number(2) := 10;
BEGIN
a:= 10;
-- check the boolean condition using if statement
IF( a < 20 ) THEN
-- if condition is true then print the following
dbms_output.put_line('a is less than 20 ' );
END IF;
dbms_output.put_line('value of a is : ' || a);
END;
/
When the above code is executed at SQL prompt, it produces the following result:
a is less than 20
value of a is : 10
IF-THEN-ELSE Statement
A sequence of IF-THEN statements can be followed by an optional sequence
ofELSE statements, which execute when the condition is FALSE.
IF condition THEN
S1;
ELSE
S2;
END IF;
Where, S1 and S2 are different sequence of statements. In the IF-THEN-ELSE statements, when
the test condition is TRUE, the statement S1 is executed andS2 is skipped; when the
test condition is FALSE, then S1 is bypassed and statement S2 is executed. For example:
If the Boolean expression condition evaluates to true, then the if-then block of code will be
executed otherwise the else block of code will be executed.
Flow Diagram:
Example:
Let us try a complete example that would illustrate the concept:
DECLARE
a number(3) := 100;
BEGIN
-- check the boolean condition using if statement
IF( a < 20 ) THEN
-- if condition is true then print the following
dbms_output.put_line('a is less than 20 ' );
ELSE
dbms_output.put_line('a is not less than 20 ' );
END IF;
dbms_output.put_line('value of a is : ' || a);
END;
/
When the above code is executed at SQL prompt, it produces the following result:
IF-THEN-ELSIF
The IF-THEN-ELSIF statement allows you to choose between several alternatives. An IF-
THEN statement can be followed by an optionalELSIF...ELSE statement. The ELSIF clause
lets you add additional conditions.
When using IF-THEN-ELSIF statements there are few points to keep in mind.
An IF-THEN statement can have zero or one ELSE's and it must come after any ELSIF's.
An IF-THEN statement can have zero to many ELSIF's and they must come before the
ELSE.
Once an ELSIF succeeds, none of the remaining ELSIF's or ELSE's will be tested.
Syntax:
The syntax of an IF-THEN-ELSIF Statement in PL/SQL programming language is:
IF(boolean_expression 1)THEN
S1; -- Executes when the boolean expression 1 is true
ELSIF( boolean_expression 2) THEN
S2; -- Executes when the boolean expression 2 is true
ELSIF( boolean_expression 3) THEN
S3; -- Executes when the boolean expression 3 is true
ELSE
S4; -- executes when the none of the above condition is true
END IF;
Example:
DECLARE
a number(3) := 100;
BEGIN
IF ( a = 10 ) THEN
dbms_output.put_line('Value of a is 10' );
ELSIF ( a = 20 ) THEN
dbms_output.put_line('Value of a is 20' );
ELSIF ( a = 30 ) THEN
dbms_output.put_line('Value of a is 30' );
ELSE
dbms_output.put_line('None of the values is matching');
END IF;
dbms_output.put_line('Exact value of a is: '|| a );
END;
/
When the above code is executed at SQL prompt, it produces the following result:
None of the values is matching
Exact value of a is: 100
Syntax:
The syntax for case statement in PL/SQL is:
CASE selector
WHEN 'value1' THEN S1;
WHEN 'value2' THEN S2;
WHEN 'value3' THEN S3;
...
ELSE Sn; -- default case
END CASE;
Flow Diagram:
Example:
DECLARE
grade char(1) := 'A';
BEGIN
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('Well done');
when 'D' then dbms_output.put_line('You passed');
when 'F' then dbms_output.put_line('Better try again');
else dbms_output.put_line('No such grade');
END CASE;
END;
/
When the above code is executed at SQL prompt, it produces the following result:
Excellent
Syntax:
The syntax for searched case statement in PL/SQL is:
CASE
WHEN selector = 'value1' THEN S1;
WHEN selector = 'value2' THEN S2;
WHEN selector = 'value3' THEN S3;
...
ELSE Sn; -- default case
END CASE;
Flow Diagram:
Example:
DECLARE
grade char(1) := 'B';
BEGIN
case
when grade = 'A' then dbms_output.put_line('Excellent');
when grade = 'B' then dbms_output.put_line('Very good');
when grade = 'C' then dbms_output.put_line('Well done');
when grade = 'D' then dbms_output.put_line('You passed');
when grade = 'F' then dbms_output.put_line('Better try again');
else dbms_output.put_line('No such grade');
end case;
END;
/
When the above code is executed at SQL prompt, it produces the following result:
Very good
Syntax:
IF( boolean_expression 1)THEN
-- executes when the boolean expression 1 is true
IF(boolean_expression 2) THEN
-- executes when the boolean expression 2 is true
sequence-of-statements;
END IF;
ELSE
-- executes when the boolean expression 1 is not true
else-statements;
END IF;
Example:
DECLARE
a number(3) := 100;
b number(3) := 200;
BEGIN
-- check the boolean condition
IF( a = 100 ) THEN
-- if condition is true then check the following
IF( b = 200 ) THEN
-- if condition is true then print the following
dbms_output.put_line('Value of a is 100 and b is 200' );
END IF;
END IF;
dbms_output.put_line('Exact value of a is : ' || a );
dbms_output.put_line('Exact value of b is : ' || b );
END;
/
When the above code is executed at SQL prompt, it produces the following result:
PL/SQL - Loops
A loop statement allows us to execute a statement or group of statements multiple times and
following is the general form of a loop statement in most of the programming languages:
PL/SQL - Basic Loop Statement
Basic loop structure encloses sequence of statements in between the LOOPand END
LOOP statements. With each iteration, the sequence of statements is executed and then control
resumes at the top of the loop.
Syntax:
The syntax of a basic loop in PL/SQL programming language is:
LOOP
Sequence of statements;
END LOOP;
Example:
DECLARE
x number := 10;
BEGIN
LOOP
dbms_output.put_line(x);
x := x + 10;
IF x > 50 THEN
exit;
END IF;
END LOOP;
-- after exit, control resumes here
dbms_output.put_line('After Exit x is: ' || x);
END;
/
When the above code is executed at SQL prompt, it produces the following result:
10
20
30
40
50
After Exit x is: 60
PL/SQL procedure successfully completed.
You can use the EXIT WHEN statement instead of the EXIT statement:
DECLARE
x number := 10;
BEGIN
LOOP
dbms_output.put_line(x);
x := x + 10;
exit WHEN x > 50;
END LOOP;
-- after exit, control resumes here
dbms_output.put_line('After Exit x is: ' || x);
END;
/
When the above code is executed at SQL prompt, it produces the following result:
10
20
30
40
50
After Exit x is: 60
PL/SQL procedure successfully completed.
Syntax:
WHILE condition LOOP
sequence_of_statements
END LOOP;
Example:
DECLARE
a number(2) := 10;
BEGIN
WHILE a < 20 LOOP
dbms_output.put_line('value of a: ' || a);
a := a + 1;
END LOOP;
END;
/
When the above code is executed at SQL prompt, it produces the following result:
value of a: 10
value of a: 11
value of a: 12
value of a: 13
value of a: 14
value of a: 15
value of a: 16
value of a: 17
value of a: 18
value of a: 19
PL/SQL procedure successfully completed.
Syntax:
FOR counter IN initial_value .. final_value LOOP
sequence_of_statements;
END LOOP;
The initial step is executed first, and only once. This step allows you to declare and
initialize any loop control variables.
Next, the condition, i.e., initial_value .. final_value is evaluated. If it is TRUE, the body
of the loop is executed. If it is FALSE, the body of the loop does not execute and flow of
control jumps to the next statement just after the for loop.
After the body of the for loop executes, the value of the counter variable is increased or
decreased.
The condition is now evaluated again. If it is TRUE, the loop executes and the process
repeats itself (body of loop, then increment step, and then again condition). After the
condition becomes FALSE, the FOR-LOOP terminates.
The initial_value and final_value of the loop variable or counter can be literals,
variables, or expressions but must evaluate to numbers. Otherwise, PL/SQL raises the
predefined exception VALUE_ERROR.
The initial_value need not to be 1; however, the loop counter increment (or
decrement) must be 1.
When the above code is executed at SQL prompt, it produces the following result:
value of a: 10
value of a: 11
value of a: 12
value of a: 13
value of a: 14
value of a: 15
value of a: 16
value of a: 17
value of a: 18
value of a: 19
value of a: 20
PL/SQL procedure successfully completed.
However, you must write the range bounds in ascending (not descending) order. The following
program illustrates this:
DECLARE
a number(2) ;
BEGIN
FOR a IN REVERSE 10 .. 20 LOOP
dbms_output.put_line('value of a: ' || a);
END LOOP;
END;
/
When the above code is executed at SQL prompt, it produces the following result:
value of a: 20
value of a: 19
value of a: 18
value of a: 17
value of a: 16
value of a: 15
value of a: 14
value of a: 13
value of a: 12
value of a: 11
value of a: 10
PL/SQL procedure successfully completed.
LOOP
Sequence of statements1
LOOP
Sequence of statements2
END LOOP;
END LOOP;
Example:
The following program uses a nested basic loop to find the prime numbers from 2 to 100:
DECLARE
i number(3);
j number(3);
BEGIN
i := 2;
LOOP
j:= 2;
LOOP
exit WHEN ((mod(i, j) = 0) or (j = i));
j := j +1;
END LOOP;
IF (j = i ) THEN
dbms_output.put_line(i || ' is prime');
END IF;
i := i + 1;
exit WHEN i = 50;
END LOOP;
END;
/
When the above code is executed at SQL prompt, it produces the following result:
2 is prime
3 is prime
5 is prime
7 is prime
11 is prime
13 is prime
17 is prime
19 is prime
23 is prime
29 is prime
31 is prime
37 is prime
41 is prime
43 is prime
47 is prime
PL/SQL procedure successfully completed.
DECLARE
i number(1);
j number(1);
BEGIN
<< outer_loop >>
FOR i IN 1..3 LOOP
<< inner_loop >>
FOR j IN 1..3 LOOP
dbms_output.put_line('i is: '|| i || ' and j is: ' || j);
END loop inner_loop;
END loop outer_loop;
END;
/
When the above code is executed at SQL prompt, it produces the following result:
When the EXIT statement is encountered inside a loop, the loop is immediately
terminated and program control resumes at the next statement following the loop.
If you are using nested loops (i.e. one loop inside another loop), the EXIT statement will
stop the execution of the innermost loop and start executing the next line of code after
the block.
Syntax:
The syntax for an EXIT statement in PL/SQL is as follows:
EXIT;
Flow Diagram:
Example:
DECLARE
a number(2) := 10;
BEGIN
-- while loop execution
WHILE a < 20 LOOP
dbms_output.put_line ('value of a: ' || a);
a := a + 1;
IF a > 15 THEN
-- terminate the loop using the exit statement
EXIT;
END IF;
END LOOP;
END;
/
When the above code is executed at SQL prompt, it produces the following result:
value of a: 10
value of a: 11
value of a: 12
value of a: 13
value of a: 14
value of a: 15
PL/SQL procedure successfully completed.
Following are two important aspects for the EXIT WHEN statement:
Until the condition is true, the EXIT-WHEN statement acts like a NULL statement,
except for evaluating the condition, and does not terminate the loop.
A statement inside the loop must change the value of the condition.
Syntax:
The syntax for an EXIT WHEN statement in PL/SQL is as follows:
The EXIT WHEN statement replaces a conditional statement like if-thenused with the EXIT
statement.
Example:
DECLARE
a number(2) := 10;
BEGIN
-- while loop execution
WHILE a < 20 LOOP
dbms_output.put_line ('value of a: ' || a);
a := a + 1;
-- terminate the loop using the exit when statement
EXIT WHEN a > 15;
END LOOP;
END;
/
When the above code is executed at SQL prompt, it produces the following result:
value of a: 10
value of a: 11
value of a: 12
value of a: 13
value of a: 14
value of a: 15
PL/SQL procedure successfully completed.
Syntax:
The syntax for a CONTINUE statement is as follows:
CONTINUE;
Flow Diagram:
Example:
DECLARE
a number(2) := 10;
BEGIN
-- while loop execution
WHILE a < 20 LOOP
dbms_output.put_line ('value of a: ' || a);
a := a + 1;
IF a = 15 THEN
-- skip the loop using the CONTINUE statement
a := a + 1;
CONTINUE;
END IF;
END LOOP;
END;
/
When the above code is executed at SQL prompt, it produces the following result:
value of a: 10
value of a: 11
value of a: 12
value of a: 13
value of a: 14
value of a: 16
value of a: 17
value of a: 18
value of a: 19
NOTE: Use of GOTO statement is highly discouraged in any programming language because it
makes difficult to trace the control flow of a program, making the program hard to understand
and hard to modify. Any program that uses a GOTO can be rewritten so that it doesn't need the
GOTO.
Syntax:
The syntax for a GOTO statement in PL/SQL is as follows:
GOTO label;
..
..
<< label >>
statement;
Flow Diagram:
Example:
DECLARE
a number(2) := 10;
BEGIN
<<loopstart>>
-- while loop execution
WHILE a < 20 LOOP
dbms_output.put_line ('value of a: ' || a);
a := a + 1;
IF a = 15 THEN
a := a + 1;
GOTO loopstart;
END IF;
END LOOP;
END;
/
When the above code is executed at SQL prompt, it produces the following result:
value of a: 10
value of a: 11
value of a: 12
value of a: 13
value of a: 14
value of a: 16
value of a: 17
value of a: 18
value of a: 19
PL/SQL procedure successfully completed.
A GOTO statement cannot branch from one IF statement clause to another or from one
CASE statement WHEN clause to another.
A GOTO statement cannot branch from an outer block into a sub-block (that is, an inner
BEGIN-END block).
A GOTO statement cannot branch from an exception handler back into the current
BEGIN-END block. However, a GOTO statement can branch from an exception handler
into an enclosing block.
PL/SQL - Exceptions
An error condition during a program execution is called an exception in PL/SQL. PL/SQL
supports programmers to catch such conditions using EXCEPTIONblock in the program and
an appropriate action is taken against the error condition. There are two types of exceptions:
System-defined exceptions
User-defined exceptions
DECLARE
<declarations section>
BEGIN
<executable command(s)>
EXCEPTION
<exception handling goes here >
WHEN exception1 THEN
exception1-handling-statements
WHEN exception2 THEN
exception2-handling-statements
WHEN exception3 THEN
exception3-handling-statements
........
WHEN others THEN
exception3-handling-statements
END;
Example
Let us write some simple code to illustrate the concept. We will be using the CUSTOMERS
table we had created and used in the previous chapters:
DECLARE
c_id customers.id%type := 8;
c_name customers.name%type;
c_addr customers.address%type;
BEGIN
SELECT name, address INTO c_name, c_addr
FROM customers
WHERE id = c_id;
When the above code is executed at SQL prompt, it produces the following result:
No such customer!
PL/SQL procedure successfully completed.
The above program displays the name and address of a customer whose ID is given. Since there
is no customer with ID value 8 in our database, the program raises the run-time
exception NO_DATA_FOUND, which is captured inEXCEPTION block.
Raising Exceptions
Exceptions are raised by the database server automatically whenever there is any internal
database error, but exceptions can be raised explicitly by the programmer by using the
command RAISE. Following is the simple syntax of raising an exception:
DECLARE
exception_name EXCEPTION;
BEGIN
IF condition THEN
RAISE exception_name;
END IF;
EXCEPTION
WHEN exception_name THEN
statement;
END;
You can use above syntax in raising Oracle standard exception or any user-defined exception.
Next section will give you an example on raising user-defined exception, similar way you can
raise Oracle standard exceptions as well.
User-defined Exceptions
PL/SQL allows you to define your own exceptions according to the need of your program. A
user-defined exception must be declared and then raised explicitly, using either a RAISE
statement or the procedure DBMS_STANDARD.RAISE_APPLICATION_ERROR.
DECLARE
my-exception EXCEPTION;
Example:
The following example illustrates the concept. This program asks for a customer ID, when the
user enters an invalid ID, the exception invalid_id is raised.
DECLARE
c_id customers.id%type := &cc_id;
c_name customers.name%type;
c_addr customers.address%type;
-- user defined exception
ex_invalid_id EXCEPTION;
BEGIN
IF c_id <= 0 THEN
RAISE ex_invalid_id;
ELSE
SELECT name, address INTO c_name, c_addr
FROM customers
WHERE id = c_id;
When the above code is executed at SQL prompt, it produces the following result:
PL/SQL - Cursors
Implicit Cursors
Implicit cursors are automatically created by Oracle whenever an SQL statement is executed,
when there is no explicit cursor for the statement. Programmers cannot control the implicit
cursors and the information in it.
Whenever a DML statement (INSERT, UPDATE and DELETE) is issued, an implicit cursor is
associated with this statement. For INSERT operations, the cursor holds the data that needs to
be inserted. For UPDATE and DELETE operations, the cursor identifies the rows that would be
affected.
In PL/SQL, you can refer to the most recent implicit cursor as the SQL cursor, which always
has the attributes like %FOUND, %ISOPEN, %NOTFOUND, and %ROWCOUNT. The SQL
cursor has additional attributes, %BULK_ROWCOUNT and %BULK_EXCEPTIONS,
designed for use with the FORALL statement. The following table provides the description of
the most used attributes:
Attribute Description
%ISOPEN Always returns FALSE for implicit cursors, because Oracle closes
the SQL cursor automatically after executing its associated SQL
statement.
Any SQL cursor attribute will be accessed as sql%attribute_name as shown below in the
example.
Example:
We will be using the CUSTOMERS table we had created and used in the previous chapters.
+----+----------+-----+-----------+----------+
| ID | NAME | AGE | ADDRESS | SALARY |
+----+----------+-----+-----------+----------+
| 1 | Ramesh | 32 | Ahmedabad | 2000.00 |
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
+----+----------+-----+-----------+----------+
The following program would update the table and increase salary of each customer by 500 and
use the SQL%ROWCOUNT attribute to determine the number of rows affected:
DECLARE
total_rows number(2);
BEGIN
UPDATE customers
SET salary = salary + 500;
IF sql%notfound THEN
dbms_output.put_line('no customers selected');
ELSIF sql%found THEN
total_rows := sql%rowcount;
dbms_output.put_line( total_rows || ' customers selected ');
END IF;
END;
/
When the above code is executed at SQL prompt, it produces the following result:
6 customers selected
If you check the records in customers table, you will find that the rows have been updated:
+----+----------+-----+-----------+----------+
| ID | NAME | AGE | ADDRESS | SALARY |
+----+----------+-----+-----------+----------+
| 1 | Ramesh | 32 | Ahmedabad | 2500.00 |
| 2 | Khilan | 25 | Delhi | 2000.00 |
| 3 | kaushik | 23 | Kota | 2500.00 |
| 4 | Chaitali | 25 | Mumbai | 7000.00 |
| 5 | Hardik | 27 | Bhopal | 9000.00 |
| 6 | Komal | 22 | MP | 5000.00 |
+----+----------+-----+-----------+----------+
Explicit Cursors
Explicit cursors are programmer defined cursors for gaining more control over the context
area. An explicit cursor should be defined in the declaration section of the PL/SQL Block. It is
created on a SELECT Statement which returns more than one row.
The syntax for creating an explicit cursor is :
CURSOR c_customers IS
SELECT id, name, address FROM customers;
OPEN c_customers;
CLOSE c_customers;
Example:
Following is a complete example to illustrate the concepts of explicit cursors:
DECLARE
c_id customers.id%type;
c_name customers.name%type;
c_addr customers.address%type;
CURSOR c_customers is
SELECT id, name, address FROM customers;
BEGIN
OPEN c_customers;
LOOP
FETCH c_customers into c_id, c_name, c_addr;
EXIT WHEN c_customers%notfound;
dbms_output.put_line(c_id || ' ' || c_name || ' ' || c_addr);
END LOOP;
CLOSE c_customers;
END;
/
When the above code is executed at SQL prompt, it produces the following result:
1 Ramesh Ahmedabad
2 Khilan Delhi
3 kaushik Kota
4 Chaitali Mumbai
5 Hardik Bhopal
6 Komal MP
PL/SQL - Records
PL/SQL can handle the following types of records:
Table-based
Cursor-based records
User-defined records
Table-Based Records
The %ROWTYPE attribute enables a programmer to create table-based andcursor-
based records.
The following example would illustrate the concept of table-based records. We will be using
the CUSTOMERS table we had created and used in the previous chapters:
DECLARE
customer_rec customers%rowtype;
BEGIN
SELECT * into customer_rec
FROM customers
WHERE id = 5;
When the above code is executed at SQL prompt, it produces the following result:
Customer ID: 5
Customer Name: Hardik
Customer Address: Bhopal
Customer Salary: 9000
PL/SQL procedure successfully completed.
Cursor-Based Records
The following example would illustrate the concept of cursor-based records. We will be using
the CUSTOMERS table we had created and used in the previous chapters:
DECLARE
CURSOR customer_cur is
SELECT id, name, address
FROM customers;
customer_rec customer_cur%rowtype;
BEGIN
OPEN customer_cur;
LOOP
FETCH customer_cur into customer_rec;
EXIT WHEN customer_cur%notfound;
DBMS_OUTPUT.put_line(customer_rec.id || ' ' || customer_rec.name);
END LOOP;
END;
/
When the above code is executed at SQL prompt, it produces the following result:
1 Ramesh
2 Khilan
3 kaushik
4 Chaitali
5 Hardik
6 Komal
PL/SQL procedure successfully completed.
PL/SQL Cursors For Loop
PL/SQL cursor FOR loop has one great advantage of loop continued until row not found. In
sometime you require to use explicit cursor with FOR loop instead of use OPEN, FETCH,
and CLOSE statement.
FOR loop iterate repeatedly and fetches rows of values from database until row not found.
Example Code
cursor_for_loop.sql
SQL>set serveroutput on
SQL>edit cursor_for_loop
DECLARE
cursor c is select * from emp_information
where emp_no <=2;
tmp emp_information%rowtype;
BEGIN
OPEN c;
FOR tmp IN c LOOP
FETCH c into tmp;
dbms_output.put_line('EMP_No: '||tmp.emp_no);
dbms_output.put_line('EMP_Name: '||tmp.emp_name);
dbms_output.put_line('EMP_Dept: '||tmp.emp_dept);
dbms_output.put_line('EMP_Salary:'||tmp.emp_salary);
END Loop;
CLOSE c;
END;
/
Example Result
SQL>@cursor_for_loop
EMP_No: 1
EMP_Name: Forbs ross
EMP_Dept: Web Developer
EMP_Salary:45k
EMP_No: 2
EMP_Name: marks jems
EMP_Dept: Program Developer
EMP_Salary:38k
PL/SQL Parameterized cursor define only datatype of parameter and not need to define it's
length.
Default values is assigned to the Cursor parameters. and scope of the parameters are locally.
Parameterized cursors are also saying static cursors that can passed parameter value when
cursor are opened.
Example Code
Cursor display employee information from emp_information table whose emp_no four (4).
SQL>set serveroutput on
SQL>edit parameter_cursor_demo
DECLARE
cursor c(no number) is select * from emp_information
where emp_no = no;
tmp emp_information%rowtype;
BEGIN
OPEN c(4);
FOR tmp IN c(4) LOOP
dbms_output.put_line('EMP_No: '||tmp.emp_no);
dbms_output.put_line('EMP_Name: '||tmp.emp_name);
dbms_output.put_line('EMP_Dept: '||tmp.emp_dept);
dbms_output.put_line('EMP_Salary:'||tmp.emp_salary);
END Loop;
CLOSE c;
END;
/
Example Result
SQL>@parameter_cursor_demo
EMP_No: 4
EMP_Name: Zenia Sroll
EMP_Dept: Web Developer
EMP_Salary: 42k
PL/SQL procedure successfully completed.
PL/SQL Procedures
PL/SQL procedures create using CREATE PROCEDURE statement. The major difference
between PL/SQL function or procedure, function return always value where as procedure may
or may not return value.
When you create a function or procedure, you have to define IN/OUT/INOUT parameters
parameters.
1. IN : IN parameter referring to the procedure or function and allow to overwritten the value of
parameter.
2. OUT : OUT parameter referring to the procedure or function and allow to overwritten the
value of parameter.
3. IN OUT : Both IN OUT parameter referring to the procedure or function to pass both IN
OUT parameter, modify/update by the function or procedure and also get returned.
IN/OUT/INOUT parameters you define in procedure argument list that get returned back to a
result. When you create the procedure default IN parameter is passed in argument list. It's
means value is passed but not returned. Explicitly you have define OUT/IN OUT parameter in
argument list.
In this example we are creating a procedure to pass employee number argument and get that
employee information from table. We have emp1 table having employee information,
EMP_NO EMP_NAME EMP_DEPT EMP_SALARY
Create PROCEDURE
In this example passing IN parameter (no) and inside procedure SELECT ... INTO statement
to get the employee information.
SQL>dit pro1
CREATE or REPLACE PROCEDURE pro1(no in number,temp out emp1%rowtype)
IS
BEGIN
SELECT * INTO temp FROM emp1 WHERE eno = no;
END;
/
Execute PROCEDURE
After write the PL/SQL Procedure you need to execute the procedure.
SQL>@pro1
Procedure created.
This program (pro) call the above define procedure with pass employee number and get that
employee information.
SQL>edit pro
DECLARE
temp emp1%rowtype;
no number :=&no;
BEGIN
pro1(no,temp);
dbms_output.put_line(temp.eno||' '||
temp.ename||' '||
temp.edept||' '||
temp.esalary||' '||);
END;
/
Procedure dropped.
PL/SQL Functions
PL/SQL functions block create using CREATE FUNCTION statement. The major difference
between PL/SQL function or procedure, function return always value where as procedure may
or may not return value.
When you create a function or procedure, you have to define IN/OUT/INOUT parameters
parameters.
1. IN : IN parameter referring to the procedure or function and allow to overwritten the value of
parameter.
2. OUT : OUT parameter referring to the procedure or function and allow to overwritten the
value of parameter.
3. IN OUT : Both IN OUT parameter referring to the procedure or function to pass both IN
OUT parameter, modify/update by the function or procedure and also get returned.
IN/OUT/INOUT parameters you define in function argument list that get returned back to a
result. When you create the function default IN parameter is passed in argument list. It's
means value is passed but not returned. Explicitly you have define OUT/IN OUT parameter in
argument list.
In this example we are creating a function to pass employee number and get that employee
name from table. We have emp1 table having employee information,
EMP_NO EMP_NAME EMP_DEPT EMP_SALARY
Create Function
So lets start passing IN parameter (no). Return datatype set varchar2. Now inside function
SELECT ... INTO statement to get the employee name.
SQL>edit fun1
CREATE or REPLACE FUNCTION fun1(no in number)
RETURN varchar2
IS
name varchar2(20);
BEGIN
select ename into name from emp1 where eno = no;
return name;
END;
/
Execute Function
After write the PL/SQL function you need to execute the function.
SQL>@fun1
Function created.
This program call the above define function with pass employee number and get that
employee name.
SQL>edit fun
DECLARE
no number :=&no;
name varchar2(20);
BEGIN
name := fun1(no);
dbms_output.put_line('Name:'||' '||name);
end;
/
Function dropped.
PL/SQL Triggers
What is Trigger?
Oracle engine invokes automatically whenever a specified event occurs.
Trigger is stored into database and invoked repeatedly, when specific condition match.
You can change trigger mode activate/deactivate but you can't explicitly run.
Trigger automatically associated with DML statement, when DML statement execute trigger
implicitly execute.
You can create trigger using the CREATE TRIGGER statement. If trigger activated,
implicitly fire DML statement and if trigger deactivated can't fire.
Component of Trigger
Triggering SQL statement : SQL DML (INSERT, UPDATE and DELETE) statement that
execute and implicitly called trigger to execute.
Trigger Action : When the triggering SQL statement is execute, trigger automatically call and
PL/SQL trigger block execute.
Trigger Restriction : We can specify the condition inside trigger to when trigger is fire.
Type of Triggers
1. BEFORE Trigger : BEFORE trigger execute before the triggering DML statement (INSERT,
UPDATE, DELETE) execute. Triggering SQL statement is may or may not execute,
depending on the BEFORE trigger conditions block.
2. AFTER Trigger : AFTER trigger execute after the triggering DML statement (INSERT,
UPDATE, DELETE) executed. Triggering SQL statement is execute as soon as followed by
the code of trigger before performing Database operation.
3. ROW Trigger : ROW trigger fire for each and every record which are performing INSERT,
UPDATE, DELETE from the database table. If row deleting is define as trigger event, when
trigger file, deletes the five rows each times from the table.
4. Statement Trigger : Statement trigger fire only once for each statement. If row deleting is
define as trigger event, when trigger file, deletes the five rows at once from the table.
5. Combination Trigger : Combination trigger are combination of two trigger type,
1. Before Statement Trigger : Trigger fire only once for each statement before the triggering
DML statement.
2. Before Row Trigger : Trigger fire for each and every record before the triggering DML
statement.
3. After Statement Trigger : Trigger fire only once for each statement after the triggering
DML statement executing.
4. After Row Trigger : Trigger fire for each and every record after the triggering DML
statement executing.
DECLARE
[declaration_section
variable declarations;
constant declarations;
]
BEGIN
[executable_section
PL/SQL execute/subprogram body
]
EXCEPTION
[exception_section
PL/SQL Exception block
]
END;
Syntax Description
1. CREATE [OR REPLACE] TRIGGER trigger_name : Create a trigger with the given name. If
already have overwrite the existing trigger with defined same name.
2. BEFORE | AFTER : Indicates when the trigger get fire. BEFORE trigger execute before
when statement execute before. AFTER trigger execute after the statement execute.
5. Referencing [ OLD AS OLD | NEW AS NEW ] : Give referencing to a old and new values of
the data. :old means use existing row to perform event and :new means use executing new
row to perform event. You can set referencing names user define name from old (or new).
You can't referencing old values when inserting a record, or new values when deleting a
record, because It's does not exist.
6. FOR EACH ROW | FOR EACH STATEMENT : Trigger must fire when each row gets
Affected (ROW Trigger). and fire only once when the entire sql statement is execute
(STATEMENT Trigger).
7. WHEN Condition : Optional. Use only for row level trigger. Trigger fire when specified
condition is satisfy.
You can make your own trigger using trigger syntax referencing. Here are fewer trigger
example.
Inserting Trigger
PL/SQL Security
Locks :-
Locks are mechanisms used to ensure data integrity while allowing maximum concurrent
access of data.
The oracle engine(server machine)locks table data while executing SQL stmt.This type of
locking is called “implicit locking”.
Since the oracle engine has a fully automatic strategy ,it has to decide on two issues:-
• Types of Lock:-
Shared Locks
Exclusive Locks
1) Shared Locks:-
a)Shared locks are placed on resource whenever a READ operation(select)is performed.
2) Exclusive Locks:-
a)Exclusive locks are placed on resource whenever WRITE operations (Insert, Update &
Delete) are performed.
• Level Of Locks:-
A table can be decomposed into rows & a row can be further decomposed into fields.
1)Row Level
2)Page Level
3)Table Level
1)Row Level:-If the Where clause evaluates to only one row in the table.
3)Table Level:- If there is no Where clause(i.e. the query accesses the entire table).
• Explicit Locking:-
The technique of lock taken on a table or its resources by a user is called “Explicit Locking”.
Users can lock tables they own or any table on which they have been granted table
privilege(select ,insert, update , delete)
Table or rows can be explicitly locked by using either the select …for update stmt. Or Lock table
stmt.
This clause is generally used to signal the oracle engine that data currently being used needs to
be updated.
Example
Output:-
Table Locked.
Releasing locks:-
All locks are released under the following circumstances:
specified savepoint.
Example
Table(s) Locked.
14 rows updated.