Cursores.ppt

Copyright © 2007, Oracle. All rights reserved.
Introduction to PL/SQL

1 - 2
Objectives
After completing this lesson, you should be able to do the
following:
• Explain the need for PL/SQL
• Explain the benefits of PL/SQL
• Identify the different types of PL/SQL blocks
• Output messages in PL/SQL

1 - 3
About PL/SQL
PL/SQL:
• Stands for “Procedural Language extension to SQL”
• Is Oracle Corporation’s standard data access language for
relational databases
• Seamlessly integrates procedural constructs with SQL

1 - 4
About PL/SQL
PL/SQL:
• Provides a block structure for executable units of code.
Maintenance of code is made easier with such a well-defined
structure.
• Provides procedural constructs such as:
– Variables, constants, and data types
– Control structures such as conditional statements and loops
– Reusable program units that are written once and executed
many times

1 - 5
PL/SQL Environment
PL/SQL engine
Oracle database server
SQL statement
executor
Procedural
statement
executor
procedural
SQL
PL/SQL
block

1 - 6
Benefits of PL/SQL
• Integration of procedural constructs with SQL
• Improved performance
SQL
IF...THEN
SQL
ELSE
SQL
END IF;
SQL
SQL 1
SQL 2
…

1 - 7
Benefits of PL/SQL
• Modularized program development
• Integration with Oracle tools
• Portability
• Exception handling

1 - 9
PL/SQL Block Structure
• DECLARE (optional)
– Variables, cursors, user-defined exceptions
• BEGIN (mandatory)
– SQL statements
– PL/SQL statements
• EXCEPTION (optional)
– Actions to perform
when errors occur
• END; (mandatory)

1 - 11
Block Types
Anonymous Procedure Function
[DECLARE]
BEGIN
--statements
[EXCEPTION]
END;
PROCEDURE name
IS
BEGIN
--statements
[EXCEPTION]
END;
FUNCTION name
RETURN datatype
IS
BEGIN
--statements
RETURN value;
[EXCEPTION]
END;

1 - 13
Program Constructs
Application triggers
Application packages
Application procedures
or functions
Anonymous blocks
Tools Constructs
Object types
Database triggers
Stored packages
Stored procedures or
functions
Anonymous blocks
Database Server
Constructs
Object types

1 - 15
Create an Anonymous Block
Enter the anonymous block in the SQL Developer workspace:

1 - 16
Execute an Anonymous Block
Click the Run Script button to execute the anonymous block:
Run Script

1 - 17
Test the Output of a PL/SQL Block
• Enable output in SQL Developer by clicking the Enable
DBMS Output button on the DBMS Output tab:
• Use a predefined Oracle package and its procedure:
– DBMS_OUTPUT.PUT_LINE
DBMS_OUTPUT.PUT_LINE(' The First Name of the
Employee is ' || f_name);
…
Enable DBMS
Output
DBMS Output
Tab

1 - 18
Test the Output of a PL/SQL Block

1 - 19
Summary
In this lesson, you should have learned how to:
• Integrate SQL statements with PL/SQL program constructs
• Describe the benefits of PL/SQL
• Differentiate between PL/SQL block types
• Output messages in PL/SQL

1 - 20
Practice 1: Overview
This practice covers the following topics:
• Identifying the PL/SQL blocks that execute successfully
• Creating and executing a simple PL/SQL block

Declaring PL/SQL Variables

2 - 23
Objectives
following:
• Recognize valid and invalid identifiers
• List the uses of variables
• Declare and initialize variables
• List and describe various data types
• Identify the benefits of using the %TYPE attribute
• Declare, use, and print bind variables

2 - 24
Use of Variables
Variables can be used for:
• Temporary storage of data
• Manipulation of stored values
• Reusability
SELECT
first_name,
department_id
INTO
v_fname,
v_deptno
FROM …
v_fname
v_deptno
Jennifer
10

2 - 25
Requirements for Variable Names
A variable name:
• Must start with a letter
• Can include letters or numbers
• Can include special characters (such as $, _, and # )
• Must contain no more than 30 characters
• Must not include reserved words

2 - 26
Handling Variables in PL/SQL
Variables are:
• Declared and initialized in the declarative section
• Used and assigned new values in the executable section
• Passed as parameters to PL/SQL subprograms
• Used to hold the output of a PL/SQL subprogram

2 - 27
Declaring and Initializing PL/SQL Variables
Syntax:
Examples:
identifier [CONSTANT] datatype [NOT NULL]
[:= | DEFAULT expr];
DECLARE
v_hiredate DATE;
v_deptno NUMBER(2) NOT NULL := 10;
v_location VARCHAR2(13) := 'Atlanta';
c_comm CONSTANT NUMBER := 1400;

2 - 28
Declaring and Initializing PL/SQL Variables
DECLARE
v_myName VARCHAR2(20);
BEGIN
DBMS_OUTPUT.PUT_LINE('My name is: '|| v_myName);
v_myName := 'John';
END;
/
DECLARE
v_myName VARCHAR2(20):= 'John';
BEGIN
v_myName := 'Steven';
END;
/
1
2

2 - 29
Delimiters in String Literals
DECLARE
v_event VARCHAR2(15);
BEGIN
v_event := q'!Father's day!';
DBMS_OUTPUT.PUT_LINE('3rd Sunday in June is :
'|| v_event );
v_event := q'[Mother's day]';
DBMS_OUTPUT.PUT_LINE('2nd Sunday in May is :
'|| v_event );
END;
/

2 - 30
Types of Variables
• PL/SQL variables:
– Scalar
– Composite
– Reference
– Large object (LOB)
• Non-PL/SQL variables: Bind variables

2 - 31
TRUE
Types of Variables
25-JAN-01
Atlanta
256120.08
Snow White
Long, long ago,
in a land far, far away,
there lived a princess called
Snow White. . .

2 - 32
Guidelines for Declaring and Initializing
PL/SQL Variables
• Follow naming conventions.
• Use meaningful identifiers for variables.
• Initialize variables designated as NOT NULL and
CONSTANT.
• Initialize variables with the assignment operator (:=) or
the DEFAULT keyword:
• Declare one identifier per line for better readability and
code maintenance.
v_myName VARCHAR2(20):='John';
v_myName VARCHAR2(20) DEFAULT 'John';

2 - 33
Guidelines for Declaring PL/SQL Variables
• Avoid using column names as identifiers.
• Use the NOT NULL constraint when the variable must
hold a value.
DECLARE
employee_id NUMBER(6);
BEGIN
SELECT employee_id
INTO employee_id
FROM employees
WHERE last_name = 'Kochhar';
END;
/

2 - 34
Scalar Data Types
• Hold a single value
• Have no internal components
Atlanta
TRUE 25-JAN-01
256120.08
The soul of the lazy man
desires, and he has nothing;
but the soul of the diligent
shall be made rich.

2 - 35
Base Scalar Data Types
• CHAR [(maximum_length)]
• VARCHAR2 (maximum_length)
• NUMBER [(precision, scale)]
• BINARY_INTEGER
• PLS_INTEGER
• BOOLEAN
• BINARY_FLOAT
• BINARY_DOUBLE

2 - 37
Base Scalar Data Types
• DATE
• TIMESTAMP
• TIMESTAMP WITH TIME ZONE
• TIMESTAMP WITH LOCAL TIME ZONE
• INTERVAL YEAR TO MONTH
• INTERVAL DAY TO SECOND

2 - 39
Declaring Scalar Variables
Examples:
DECLARE
v_emp_job VARCHAR2(9);
v_count_loop BINARY_INTEGER := 0;
v_dept_total_sal NUMBER(9,2) := 0;
v_orderdate DATE := SYSDATE + 7;
c_tax_rate CONSTANT NUMBER(3,2) := 8.25;
v_valid BOOLEAN NOT NULL := TRUE;
...

2 - 40
%TYPE Attribute
• Is used to declare a variable according to:
– A database column definition
– Another declared variable
• Is prefixed with:
– The database table and column
– The name of the declared variable

2 - 42
Declaring Variables
with the %TYPE Attribute
Syntax
Examples
...
emp_lname employees.last_name%TYPE;
...
identifier table.column_name%TYPE;
...
balance NUMBER(7,2);
min_balance balance%TYPE := 1000;
...

2 - 43
Declaring Boolean Variables
• Only the TRUE, FALSE, and NULL values can be assigned
to a Boolean variable.
• Conditional expressions use the logical operators AND
and OR and the unary operator NOT to check the variable
values.
• The variables always yield TRUE, FALSE, or NULL.
• Arithmetic, character, and date expressions can be used
to return a Boolean value.

2 - 44
Bind Variables
Bind variables are:
• Created in the environment
• Also called host variables
• Created with the VARIABLE keyword
• Used in SQL statements and PL/SQL blocks
• Accessed even after the PL/SQL block is executed
• Referenced with a preceding colon

2 - 46
Printing Bind Variables
Example:
VARIABLE b_emp_salary NUMBER
BEGIN
SELECT salary INTO :b_emp_salary
FROM employees WHERE employee_id = 178;
END;
/
PRINT b_emp_salary
SELECT first_name, last_name FROM employees
WHERE salary=:b_emp_salary;

2 - 47
Printing Bind Variables
Example:
VARIABLE b_emp_salary NUMBER
SET AUTOPRINT ON
DECLARE
v_empno NUMBER(6):=&empno;
BEGIN
SELECT salary INTO :b_emp_salary
FROM employees WHERE employee_id = v_empno;
END;
7000
Output:

2 - 48
LOB Data Type Variables
Book
(CLOB)
Photo
(BLOB)
Movie
(BFILE)
NCLOB

2 - 49
Composite Data Types
TRUE 23-DEC-98 ATLANTA
1 5000
2 2345
3 12
4 3456
1 SMITH
2 JONES
3 NANCY
4 TIM
PL/SQL table structure PL/SQL table structure
PLS_INTEGER
VARCHAR2
PLS_INTEGER
NUMBER

2 - 50
Summary
• Recognize valid and invalid identifiers
• Declare variables in the declarative section of a PL/SQL
block
• Initialize variables and use them in the executable section
• Differentiate between scalar and composite data types
• Use the %TYPE attribute
• Use bind variables

2 - 51
• Determining valid identifiers
• Determining valid variable declarations
• Declaring variables within an anonymous block
• Using the %TYPE attribute to declare variables
• Declaring and printing a bind variable
• Executing a PL/SQL block

Writing Executable Statements

3 - 55
Objectives
following:
• Identify lexical units in a PL/SQL block
• Use built-in SQL functions in PL/SQL
• Describe when implicit conversions take place and when
explicit conversions have to be dealt with
• Write nested blocks and qualify variables with labels
• Write readable code with appropriate indentation
• Use sequences in PL/SQL expressions

3 - 56
Lexical Units in a PL/SQL Block
Lexical units:
• Are building blocks of any PL/SQL block
• Are sequences of characters including letters, numerals,
tabs, spaces, returns, and symbols
• Can be classified as:
– Identifiers: v_fname, c_percent
– Delimiters: ; , +, -
– Literals: John, 428, True
– Comments: --, /* */

3 - 58
PL/SQL Block Syntax and Guidelines
• Literals
– Character and date literals must be enclosed in single
quotation marks.
– Numbers can be simple values or in scientific notation.
• Statements can span several lines.
name := 'Henderson';
1
2
3

3 - 59
Commenting Code
• Prefix single-line comments with two hyphens (--).
• Place multiple-line comments between the symbols /*
and */.
Example:
DECLARE
...
v_annual_sal NUMBER (9,2);
BEGIN
/* Compute the annual salary based on the
monthly salary input from the user */
v_annual_sal := monthly_sal * 12;
--The following line displays the annual salary
DBMS_OUTPUT.PUT_LINE(v_annual_sal);
END;
/

3 - 60
SQL Functions in PL/SQL
• Available in procedural statements:
– Single-row functions
• Not available in procedural statements:
– DECODE
– Group functions

3 - 61
SQL Functions in PL/SQL: Examples
• Get the length of a string:
• Get the number of months an employee has worked:
v_desc_size INTEGER(5);
v_prod_description VARCHAR2(70):='You can use this
product with your radios for higher frequency';
-- get the length of the string in prod_description
v_desc_size:= LENGTH(prod_description);
v_tenure:= MONTHS_BETWEEN (CURRENT_DATE, v_hiredate);

3 - 62
Using Sequences in PL/SQL Expressions
Starting in 11g:
Before 11g:
DECLARE
v_new_id NUMBER;
BEGIN
SELECT my_seq.NEXTVAL INTO v_new_id FROM Dual;
END;
/
DECLARE
v_new_id NUMBER;
BEGIN
v_new_id := my_seq.NEXTVAL;
END;
/

3 - 63
Data Type Conversion
• Converts data to comparable data types
• Is of two types:
– Implicit conversion
– Explicit conversion
• Functions:
– TO_CHAR
– TO_DATE
– TO_NUMBER
– TO_TIMESTAMP

3 - 65
Data Type Conversion
date_of_joining DATE:= '02-Feb-2000';
date_of_joining DATE:= 'February 02,2000';
date_of_joining DATE:= TO_DATE('February
02,2000','Month DD, YYYY');
1
2
3

3 - 66
Nested Blocks
PL/SQL blocks can be nested.
• An executable section (BEGIN … END)
can contain nested blocks.
• An exception section can contain
nested blocks.

3 - 67
Nested Blocks
Example:
DECLARE
v_outer_variable VARCHAR2(20):='GLOBAL VARIABLE';
BEGIN
DECLARE
v_inner_variable VARCHAR2(20):='LOCAL VARIABLE';
BEGIN
DBMS_OUTPUT.PUT_LINE(v_inner_variable);
DBMS_OUTPUT.PUT_LINE(v_outer_variable);
END;
DBMS_OUTPUT.PUT_LINE(v_outer_variable);
END;

3 - 68
Variable Scope and Visibility
DECLARE
v_father_name VARCHAR2(20):='Patrick';
v_date_of_birth DATE:='20-Apr-1972';
BEGIN
DECLARE
v_child_name VARCHAR2(20):='Mike';
v_date_of_birth DATE:='12-Dec-2002';
BEGIN
DBMS_OUTPUT.PUT_LINE('Father''s Name: '||v_father_name);
DBMS_OUTPUT.PUT_LINE('Date of Birth: '||v_date_of_birth);
DBMS_OUTPUT.PUT_LINE('Child''s Name: '||v_child_name);
END;
END;
/
1
2

3 - 70
Qualify an Identifier
BEGIN <<outer>>
DECLARE
v_father_name VARCHAR2(20):='Patrick';
v_date_of_birth DATE:='20-Apr-1972';
BEGIN
DECLARE
v_child_name VARCHAR2(20):='Mike';
v_date_of_birth DATE:='12-Dec-2002';
BEGIN
DBMS_OUTPUT.PUT_LINE('Father''s Name: '||v_father_name);
DBMS_OUTPUT.PUT_LINE('Date of Birth: '
||outer.v_date_of_birth);
DBMS_OUTPUT.PUT_LINE('Child''s Name: '||v_child_name);
END;
END;
END outer;

3 - 71
Quiz: Determining Variable Scope
BEGIN <<outer>>
DECLARE
v_sal NUMBER(7,2) := 60000;
v_comm NUMBER(7,2) := v_sal * 0.20;
v_message VARCHAR2(255) := ' eligible for commission';
BEGIN
DECLARE
v_sal NUMBER(7,2) := 50000;
v_comm NUMBER(7,2) := 0;
v_total_comp NUMBER(7,2) := v_sal + v_comm;
BEGIN
v_message := 'CLERK not'||v_message;
outer.v_comm := v_sal * 0.30;
END;
v_message := 'SALESMAN'||v_message;
END;
END outer;
/
1
2

3 - 73
Operators in PL/SQL
• Logical
• Arithmetic
• Concatenation
• Parentheses to control order
of operations
• Exponential operator (**)
Same as in SQL
}

3 - 74
Operators in PL/SQL: Examples
• Increment the counter for a loop.
• Set the value of a Boolean flag.
• Validate whether an employee number contains a value.
loop_count := loop_count + 1;
good_sal := sal BETWEEN 50000 AND 150000;
valid := (empno IS NOT NULL);

3 - 75
Programming Guidelines
Make code maintenance easier by:
• Documenting code with comments
• Developing a case convention for the code
• Developing naming conventions for identifiers and other
objects
• Enhancing readability by indenting

3 - 76
Indenting Code
For clarity, indent each level of code.
BEGIN
IF x=0 THEN
y:=1;
END IF;
END;
/
DECLARE
deptno NUMBER(4);
location_id NUMBER(4);
BEGIN
SELECT department_id,
location_id
INTO deptno,
location_id
FROM departments
WHERE department_name
= 'Sales';
...
END;
/

3 - 77
Summary
• Identify lexical units in a PL/SQL block
• Use built-in SQL functions in PL/SQL
• Write nested blocks to break logically related
functionalities
• Decide when to perform explicit conversions
• Qualify variables in nested blocks
• Use sequences in PL/SQL expressions

3 - 78
• Reviewing scoping and nesting rules
• Writing and testing PL/SQL blocks

Interacting with the Oracle Database Server

4 - 83
Objectives
following:
• Determine the SQL statements that can be directly
included in a PL/SQL executable block
• Manipulate data with DML statements in PL/SQL
• Use transaction control statements in PL/SQL
• Make use of the INTO clause to hold the values returned
by a SQL statement
• Differentiate between implicit cursors and explicit cursors
• Use SQL cursor attributes

4 - 84
SQL Statements in PL/SQL
• Retrieve a row from the database by using the SELECT
command.
• Make changes to rows in the database by using DML
commands.
• Control a transaction with the COMMIT, ROLLBACK, or
SAVEPOINT command.

4 - 85
SELECT Statements in PL/SQL
Retrieve data from the database with a SELECT statement.
Syntax:
SELECT select_list
INTO {variable_name[, variable_name]...
| record_name}
FROM table
[WHERE condition];

4 - 87
SELECT Statements in PL/SQL
• The INTO clause is required.
• Queries must return only one row.
Example:
DECLARE
v_fname VARCHAR2(25);
BEGIN
SELECT first_name INTO v_fname
FROM employees WHERE employee_id=200;
DBMS_OUTPUT.PUT_LINE(' First Name is : '||v_fname);
END;
/

4 - 89
Retrieving Data in PL/SQL
Retrieve hire_date and salary for the specified
employee.
Example:
DECLARE
v_emp_hiredate employees.hire_date%TYPE;
v_emp_salary employees.salary%TYPE;
BEGIN
SELECT hire_date, salary
INTO v_emp_hiredate, v_emp_salary
FROM employees
WHERE employee_id = 100;
END;
/

4 - 90
DECLARE
v_sum_sal NUMBER(10,2);
v_deptno NUMBER NOT NULL := 60;
BEGIN
SELECT SUM(salary) -- group function
INTO v_sum_sal FROM employees
WHERE department_id = v_deptno;
DBMS_OUTPUT.PUT_LINE ('The sum of salary is ' || v_sum_sal);
END;
Retrieving Data in PL/SQL
Return the sum of the salaries for all the employees in the
specified department.
Example:

4 - 91
Naming Conventions
DECLARE
hire_date employees.hire_date%TYPE;
sysdate hire_date%TYPE;
employee_id employees.employee_id%TYPE := 176;
BEGIN
SELECT hire_date, sysdate
INTO hire_date, sysdate
FROM employees
WHERE employee_id = employee_id;
END;
/

4 - 92
Naming Conventions
• Use a naming convention to avoid ambiguity in the
WHERE clause.
• Avoid using database column names as identifiers.
• Syntax errors can arise because PL/SQL checks the
database first for a column in the table.
• The names of local variables and formal parameters take
precedence over the names of database tables.
• The names of database table columns take precedence
over the names of local variables.

4 - 93
Using PL/SQL to Manipulate Data
Make changes to database tables by using DML commands:
• INSERT
• UPDATE
• DELETE
• MERGE
INSERT
UPDATE
DELETE
MERGE

4 - 94
Inserting Data
Add new employee information to the EMPLOYEES table.
Example:
BEGIN
INSERT INTO employees
(employee_id, first_name, last_name, email,
hire_date, job_id, salary)
VALUES(employees_seq.NEXTVAL, 'Ruth', 'Cores',
'RCORES',CURRENT_DATE, 'AD_ASST', 4000);
END;
/

4 - 95
Updating Data
Increase the salary of all employees who are stock clerks.
Example:
DECLARE
sal_increase employees.salary%TYPE := 800;
BEGIN
UPDATE employees
SET salary = salary + sal_increase
WHERE job_id = 'ST_CLERK';
END;
/

4 - 96
Deleting Data
Delete rows that belong to department 10 from the
employees table.
Example:
DECLARE
deptno employees.department_id%TYPE := 10;
BEGIN
DELETE FROM employees
WHERE department_id = deptno;
END;
/

4 - 97
Merging Rows
Insert or update rows in the copy_emp table to match the
employees table.
BEGIN
MERGE INTO copy_emp c
USING employees e
ON (e.employee_id = c.empno)
WHEN MATCHED THEN
UPDATE SET
c.first_name = e.first_name,
c.last_name = e.last_name,
c.email = e.email,
. . .
WHEN NOT MATCHED THEN
INSERT VALUES(e.employee_id, e.first_name, e.last_name,
. . .,e.department_id);
END;
/

4 - 99
SQL Cursor
• A cursor is a pointer to the private memory area
allocated by the Oracle server.
• A cursor is used to handle the result set of a SELECT
statement.
• There are two types of cursors:
– Implicit: Created and managed internally by the Oracle
server to process SQL statements
– Explicit: Declared explicitly by the programmer

4 - 101
SQL Cursor Attributes for Implicit Cursors
Using SQL cursor attributes, you can test the outcome of
your SQL statements.
SQL%FOUND Boolean attribute that evaluates to TRUE if the
most recent SQL statement returned at least
one row
SQL%NOTFOUND Boolean attribute that evaluates to TRUE if
the most recent SQL statement did not
return even one row
SQL%ROWCOUNT An integer value that represents the number of
rows affected by the most recent SQL
statement

4 - 102
SQL Cursor Attributes for Implicit Cursors
Delete rows that have the specified employee ID from the
employees table. Print the number of rows deleted.
Example:
DECLARE
v_rows_deleted VARCHAR2(30)
v_empno employees.employee_id%TYPE := 176;
BEGIN
WHERE employee_id = v_empno;
v_rows_deleted := (SQL%ROWCOUNT ||
' row deleted.');
DBMS_OUTPUT.PUT_LINE (v_rows_deleted);
END;

4 - 103
Summary
• Embed DML statements, transaction control statements,
and DDL statements in PL/SQL
• Use the INTO clause, which is mandatory for all SELECT
statements in PL/SQL
• Differentiate between implicit cursors and explicit cursors
• Use SQL cursor attributes to determine the outcome of
SQL statements

4 - 104
• Selecting data from a table
• Inserting data into a table
• Updating data in a table
• Deleting a record from a table

Writing Control Structures

5 - 108
Objectives
following:
• Identify the uses and types of control structures
• Construct an IF statement
• Use CASE statements and CASE expressions
• Construct and identify loop statements
• Use guidelines when using conditional control structures

5 - 109
Controlling Flow of Execution
for
loop
while

5 - 110
IF Statement
Syntax:
IF condition THEN
statements;
[ELSIF condition THEN
statements;]
[ELSE
statements;]
END IF;

5 - 112
Simple IF Statement
DECLARE
v_myage number:=31;
BEGIN
IF v_myage < 11
THEN
DBMS_OUTPUT.PUT_LINE(' I am a child ');
END IF;
END;
/
Output:

5 - 113
IF THEN ELSE Statement
DECLARE
v_myage number:=31;
BEGIN
IF v_myage < 11
THEN
ELSE
DBMS_OUTPUT.PUT_LINE(' I am not a child ');
END IF;
END;
/
Output:

5 - 114
IF ELSIF ELSE Clause
DECLARE
v_myage number:=31;
BEGIN
IF v_myage < 11 THEN
ELSIF v_myage < 20 THEN
DBMS_OUTPUT.PUT_LINE(' I am young ');
DBMS_OUTPUT.PUT_LINE(' I am in my twenties');
DBMS_OUTPUT.PUT_LINE(' I am in my thirties');
ELSE
DBMS_OUTPUT.PUT_LINE(' I am always young ');
END IF;
END;
/
Output:

5 - 115
NULL Value in IF Statement
DECLARE
v_myage number;
BEGIN
IF v_myage < 11 THEN
ELSE
DBMS_OUTPUT.PUT_LINE(' I am not a child ');
END IF;
END;
/

5 - 116
CASE Expressions
• A CASE expression selects a result and returns it.
• To select the result, the CASE expression uses
expressions. The value returned by these expressions is
used to select one of several alternatives.
CASE selector
WHEN expression1 THEN result1
WHEN expression2 THEN result2
...
WHEN expressionN THEN resultN
[ELSE resultN+1]
END;
/

5 - 117
CASE Expressions: Example
SET VERIFY OFF
DECLARE
v_grade CHAR(1) := UPPER('&grade');
appraisal VARCHAR2(20);
BEGIN
appraisal := CASE v_grade
WHEN 'A' THEN 'Excellent'
WHEN 'B' THEN 'Very Good'
WHEN 'C' THEN 'Good'
ELSE 'No such grade'
END;
DBMS_OUTPUT.PUT_LINE ('Grade: '|| v_grade || '
Appraisal ' || appraisal);
END;
/

5 - 118
Searched CASE Expressions
DECLARE
v_grade CHAR(1) := UPPER('&grade');
appraisal VARCHAR2(20);
BEGIN
appraisal := CASE
WHEN v_grade = 'A' THEN 'Excellent'
WHEN v_grade IN ('B','C') THEN 'Good'
ELSE 'No such grade'
END;
DBMS_OUTPUT.PUT_LINE ('Grade: '|| v_grade || '
Appraisal ' || appraisal);
END;
/

5 - 119
CASE Statement
DECLARE
v_deptid NUMBER;
v_deptname VARCHAR2(20);
v_emps NUMBER;
v_mngid NUMBER:= 108;
BEGIN
CASE v_mngid
WHEN 108 THEN
SELECT department_id, department_name
INTO v_deptid, v_deptname FROM departments
WHERE manager_id=108;
SELECT count(*) INTO v_emps FROM employees
WHERE department_id=v_deptid;
WHEN 200 THEN
...
END CASE;
DBMS_OUTPUT.PUT_LINE ('You are working in the '|| deptname||
' department. There are '||v_emps ||' employees in this
department');
END;
/

5 - 120
Handling Nulls
When working with nulls, you can avoid some common
mistakes by keeping in mind the following rules:
• Simple comparisons involving nulls always yield NULL.
• Applying the logical operator NOT to a null yields NULL.
• If the condition yields NULL in conditional control
statements, its associated sequence of statements is not
executed.

5 - 121
Logic Tables
Build a simple Boolean condition with a comparison
operator.
AND
TRUE
FALSE
NULL
TRUE FALSE NULL
TRUE
NULL NULL
NULL
FALSE FALSE
FALSE
FALSE
FALSE
NOT
TRUE
FALSE
NULL
FALSE
TRUE
NULL
TRUE
NULL
OR TRUE FALSE NULL
TRUE
TRUE
TRUE
TRUE
TRUE
FALSE
NULL NULL
NULL
FALSE

5 - 122
Boolean Conditions
What is the value of flag in each case?
REORDER_FLAG AVAILABLE_FLAG FLAG
TRUE TRUE
TRUE FALSE
NULL TRUE
NULL FALSE
flag := reorder_flag AND available_flag;
? (1)
? (2)
? (3)
? (4)

5 - 123
Iterative Control: LOOP Statements
• Loops repeat a statement (or sequence of statements)
multiple times.
• There are three loop types:
– Basic loop
– FOR loop
– WHILE loop

5 - 124
Basic Loops
Syntax:
LOOP
statement1;
. . .
EXIT [WHEN condition];
END LOOP;

5 - 125
DECLARE
v_countryid locations.country_id%TYPE := 'CA';
v_loc_id locations.location_id%TYPE;
v_counter NUMBER(2) := 1;
v_new_city locations.city%TYPE := 'Montreal';
BEGIN
SELECT MAX(location_id) INTO v_loc_id FROM locations
WHERE country_id = v_countryid;
LOOP
INSERT INTO locations(location_id, city, country_id)
VALUES((v_loc_id + v_counter), v_new_city, v_countryid);
v_counter := v_counter + 1;
EXIT WHEN v_counter > 3;
END LOOP;
END;
/
Basic Loops
Example:

5 - 126
WHILE Loops
Syntax:
Use the WHILE loop to repeat statements while a condition
is TRUE.
WHILE condition LOOP
statement1;
statement2;
. . .
END LOOP;

5 - 127
WHILE Loops
Example
DECLARE
v_counter NUMBER := 1;
BEGIN
SELECT MAX(location_id) INTO v_loc_id FROM locations
WHILE v_counter <= 3 LOOP
VALUES((v_loc_id + v_counter), v_new_city, v_countryid);
v_counter := v_counter + 1;
END LOOP;
END;
/

5 - 128
FOR Loops
• Use a FOR loop to shortcut the test for the number of
iterations.
• Do not declare the counter; it is declared implicitly.
FOR counter IN [REVERSE]
lower_bound..upper_bound LOOP
statement1;
statement2;
. . .
END LOOP;

5 - 130
FOR Loops
Example:
DECLARE
BEGIN
SELECT MAX(location_id) INTO v_loc_id
FROM locations
FOR i IN 1..3 LOOP
VALUES((v_loc_id + i), v_new_city, v_countryid );
END LOOP;
END;
/

5 - 131
FOR Loops
Guidelines
• Reference the counter within the loop only; it is
undefined outside the loop.
• Do not reference the counter as the target of an
assignment.
• Neither loop bound should be NULL.

5 - 132
Guidelines for Loops
• Use the basic loop when the statements inside the loop
must execute at least once.
• Use the WHILE loop if the condition must be evaluated at
the start of each iteration.
• Use a FOR loop if the number of iterations is known.

5 - 133
Nested Loops and Labels
• You can nest loops to multiple levels.
• Use labels to distinguish between blocks and loops.
• Exit the outer loop with the EXIT statement that
references the label.

5 - 134
Nested Loops and Labels
...
BEGIN
<<Outer_loop>>
LOOP
v_counter := v_counter+1;
EXIT WHEN v_counter>10;
<<Inner_loop>>
LOOP
...
EXIT Outer_loop WHEN total_done = 'YES';
-- Leave both loops
EXIT WHEN inner_done = 'YES';
-- Leave inner loop only
...
END LOOP Inner_loop;
...
END LOOP Outer_loop;
END;
/

5 - 135
PL/SQL CONTINUE Statement
• Definition
– Adds the functionality to begin the next loop iteration
– Provides programmers with the ability to transfer control
to the next iteration of a loop
– Uses parallel structure and semantics to the EXIT
statement
• Benefits
– Eases the programming process
– May see a small performance improvement over the
previous programming workarounds to simulate the
CONTINUE statement

5 - 136
PL/SQL CONTINUE Statement: Example
DECLARE
v_total SIMPLE_INTEGER := 0;
BEGIN
FOR i IN 1..10 LOOP
v_total := v_total + i;
dbms_output.put_line
('Total is: '|| v_total);
CONTINUE WHEN i > 5;
v_total := v_total + i;
('Out of Loop Total is:
'|| v_total);
END LOOP;
END;
/
1
2
anonymous block completed
Total is: 1
Out of Loop Total is: 2
Total is: 4
Total is: 9
Total is: 16
Total is: 25
Total is: 36
Total is: 43
Total is: 51
Total is: 60
Total is: 70

5 - 137
PL/SQL CONTINUE Statement: Example
DECLARE
v_total NUMBER := 0;
BEGIN
<<BeforeTopLoop>>
FOR i IN 1..10 LOOP
v_total := v_total + 1;
('Total is: ' || v_total);
FOR j IN 1..10 LOOP
CONTINUE BeforeTopLoop WHEN i + j > 5;
v_total := v_total + 1;
END LOOP;
END LOOP;
END two_loop;
anonymous block completed
Total is: 1
Total is: 6
Total is: 10
Total is: 13
Total is: 15
Total is: 16
Total is: 17
Total is: 18
Total is: 19
Total is: 20

5 - 138
Summary
In this lesson, you should have learned how to change the
logical flow of statements by using the following control
structures:
• Conditional (IF statement)
• CASE expressions and CASE statements
• Loops:
– Basic loop
– FOR loop
– WHILE loop
• EXIT statement
• CONTINUE statement

5 - 139
• Performing conditional actions by using IF statements
• Performing iterative steps by using LOOP structures

Working with

6 - 143
Objectives
following:
• Create user-defined PL/SQL records
• Create a record with the %ROWTYPE attribute
• Create an INDEX BY table
• Create an INDEX BY table of records
• Describe the differences among records, tables, and
tables of records

6 - 144
• Can hold multiple values (unlike scalar types)
• Are of two types:
– PL/SQL records
– PL/SQL collections
— INDEX BY tables or associative arrays
— Nested table
— VARRAY

6 - 145
• Use PL/SQL records when you want to store values of
different data types but only one occurrence at a time.
• Use PL/SQL collections when you want to store values of
the same data type.

6 - 146
PL/SQL Records
• Must contain one or more components (called fields) of
any scalar, RECORD, or INDEX BY table data type
• Are similar to structures in most third-generation
languages (including C and C++)
• Are user defined and can be a subset of a row in a table
• Treat a collection of fields as a logical unit
• Are convenient for fetching a row of data from a table for
processing

6 - 147
Creating a PL/SQL Record
Syntax:
TYPE type_name IS RECORD
(field_declaration[, field_declaration]…);
field_name {field_type | variable%TYPE
| table.column%TYPE | table%ROWTYPE}
[[NOT NULL] {:= | DEFAULT} expr]
identifier type_name;
1
2
field_declaration:

6 - 148
Creating a PL/SQL Record
Declare variables to store the name, job, and salary of a
new employee.
Example:
DECLARE
type t_rec is record
(v_sal number(8),
v_minsal number(8) default 1000,
v_hire_date employees.hire_date%type,
v_rec1 employees%rowtype);
v_myrec t_rec;
BEGIN
v_myrec.v_sal := v_myrec.v_minsal + 500;
v_myrec.v_hire_date := sysdate;
SELECT * INTO v_myrec.v_rec1
FROM employees WHERE employee_id = 100;
DBMS_OUTPUT.PUT_LINE(v_myrec.v_rec1.last_name ||' '||
to_char(v_myrec.v_hire_date) ||' '|| to_char(v_myrec.v_sal));
END;

6 - 149
PL/SQL Record Structure
Example:
100 King AD_PRES
employee_id number(6) last_name varchar2(25) job_id varchar2(10)
Field2 (data type) Field3 (data type)
Field1 (data type)
Field2 (data type) Field3 (data type)
Field1 (data type)

6 - 150
%ROWTYPE Attribute
• Declare a variable according to a collection of columns
in a database table or view.
• Prefix %ROWTYPE with the database table or view.
• Fields in the record take their names and data types from
the columns of the table or view.
Syntax:
DECLARE
identifier reference%ROWTYPE;

6 - 152
Advantages of Using %ROWTYPE
• The number and data types of the underlying database
columns need not be known—and, in fact, might change
at run time.
• The %ROWTYPE attribute is useful when retrieving a row
with the SELECT * statement.

6 - 153
%ROWTYPE Attribute: Example
DECLARE
v_employee_number number:= 124;
v_emp_rec employees%ROWTYPE;
BEGIN
SELECT * INTO v_emp_rec FROM employees
WHERE employee_id = v_employee_number;
INSERT INTO retired_emps(empno, ename, job, mgr,
hiredate, leavedate, sal, comm, deptno)
VALUES (v_emp_rec.employee_id, v_emp_rec.last_name,
v_emp_rec.job_id, v_emp_rec.manager_id,
v_emp_rec.hire_date, SYSDATE,
v_emp_rec.salary, v_emp_rec.commission_pct,
v_emp_rec.department_id);
END;
/

6 - 154
Inserting a Record
by Using %ROWTYPE
...
DECLARE
v_emp_rec retired_emps%ROWTYPE;
BEGIN
SELECT employee_id, last_name, job_id, manager_id,
hire_date, hire_date, salary, commission_pct,
department_id INTO v_emp_rec FROM employees
WHERE employee_id = v_employee_number;
INSERT INTO retired_emps VALUES v_emp_rec;
END;
/
SELECT * FROM retired_emps;

6 - 155
Updating a Row in a Table
by Using a Record
SET VERIFY OFF
DECLARE
v_emp_rec retired_emps%ROWTYPE;
BEGIN
SELECT * INTO v_emp_rec FROM retired_emps;
v_emp_rec.leavedate:=CURRENT_DATE;
UPDATE retired_emps SET ROW = v_emp_rec WHERE
empno=v_employee_number;
END;
/
SELECT * FROM retired_emps;

6 - 156
INDEX BY Tables or Associative Arrays
• Are PL/SQL structures with two columns:
– Primary key of integer or string data type
– Column of scalar or record data type
• Are unconstrained in size. However, the size depends on
the values that the key data type can hold.

6 - 157
Creating an INDEX BY Table
Syntax:
Declare an INDEX BY table to store the last names of
employees:
TYPE type_name IS TABLE OF
{column_type | variable%TYPE
| table.column%TYPE} [NOT NULL]
| table%ROWTYPE
[INDEX BY PLS_INTEGER | BINARY_INTEGER
| VARCHAR2(<size>)];
identifier type_name;
...
TYPE ename_table_type IS TABLE OF
employees.last_name%TYPE
INDEX BY PLS_INTEGER;
...
ename_table ename_table_type;

6 - 159
INDEX BY Table Structure
Unique key Value
... ...
1 Jones
5 Smith
3 Maduro
... ...
PLS_INTEGER Scalar

6 - 160
Creating an INDEX BY Table
DECLARE
TYPE ename_table_type IS TABLE OF
employees.last_name%TYPE
TYPE hiredate_table_type IS TABLE OF DATE
ename_table ename_table_type;
hiredate_table hiredate_table_type;
BEGIN
ename_table(1) := 'CAMERON';
hiredate_table(8) := SYSDATE + 7;
IF ename_table.EXISTS(1) THEN
INSERT INTO ...
...
END;
/

6 - 161
Using INDEX BY Table Methods
The following methods make INDEX BY tables easier to use:
• EXISTS
• COUNT
• FIRST
• LAST
• PRIOR
• NEXT
• DELETE

6 - 162
INDEX BY Table of Records
Define an INDEX BY table variable to hold an entire row
from a table.
Example:
DECLARE
TYPE dept_table_type IS TABLE OF
departments%ROWTYPE
INDEX BY VARCHAR2(20);
dept_table dept_table_type;
-- Each element of dept_table is a record

6 - 164
INDEX BY Table of Records: Example
DECLARE
TYPE emp_table_type IS TABLE OF
employees%ROWTYPE INDEX BY PLS_INTEGER;
my_emp_table emp_table_type;
max_count NUMBER(3):= 104;
BEGIN
FOR i IN 100..max_count
LOOP
SELECT * INTO my_emp_table(i) FROM employees
WHERE employee_id = i;
END LOOP;
FOR i IN my_emp_table.FIRST..my_emp_table.LAST
LOOP
DBMS_OUTPUT.PUT_LINE(my_emp_table(i).last_name);
END LOOP;
END;
/

6 - 165
Nested Tables
1
2
3
4
..
2 GB
Bombay
Sydney
Oxford
London
....

6 - 167
Bombay
Sydney
Oxford
London
....
VARRAY
Tokyo
1
2
3
4
..
10

6 - 168
Summary
• Define and reference PL/SQL variables of composite
data types
– PL/SQL record
– INDEX BY table
– INDEX BY table of records
• Define a PL/SQL record by using the %ROWTYPE attribute

6 - 169
• Declaring INDEX BY tables
• Processing data by using INDEX BY tables
• Declaring a PL/SQL record
• Processing data by using a PL/SQL record

Using Explicit Cursors

7 - 174
Objectives
following:
• Distinguish between implicit and explicit cursors
• Discuss the reasons for using explicit cursors
• Declare and control explicit cursors
• Use simple loops and cursor FOR loops to fetch data
• Declare and use cursors with parameters
• Lock rows with the FOR UPDATE clause
• Reference the current row with the WHERE CURRENT OF
clause

7 - 175
Cursors
Every SQL statement executed by the Oracle server has an
associated individual cursor:
• Implicit cursors: Declared and managed by PL/SQL for
all DML and PL/SQL SELECT statements
• Explicit cursors: Declared and managed by the
programmer

7 - 176
Explicit Cursor Operations
Active set
Table
100 King AD_PRES
101 Kochhar AD_VP
102 De Haan AD_VP
. . .
. . .
. . .
139 Seo ST_CLERK
140 Patel ST_CLERK
. . .

7 - 177
Controlling Explicit Cursors
• Load the
current
row into
variables.
FETCH
• Test for
existing
rows.
EMPTY?
• Return to
FETCH if
rows are
found.
No
• Release the
active set.
CLOSE
Yes
• Create a
named
SQL area.
DECLARE
• Identify the
active set.
OPEN

7 - 178
Controlling Explicit Cursors
Fetch a row.
Close the cursor.
Cursor
pointer
Open the cursor.
1
2
3
Cursor
pointer
Cursor
pointer

7 - 179
Declaring the Cursor
Syntax:
Examples:
CURSOR cursor_name IS
select_statement;
DECLARE
CURSOR c_emp_cursor IS
SELECT employee_id, last_name FROM employees
WHERE department_id =30;
DECLARE
v_locid NUMBER:= 1700;
CURSOR c_dept_cursor IS
SELECT * FROM departments
WHERE location_id = v_locid;
...

7 - 181
Opening the Cursor
DECLARE
...
BEGIN
OPEN c_emp_cursor;

7 - 182
Fetching Data from the Cursor
DECLARE
v_empno employees.employee_id%TYPE;
v_lname employees.last_name%TYPE;
BEGIN
OPEN c_emp_cursor;
FETCH c_emp_cursor INTO v_empno, v_lname;
DBMS_OUTPUT.PUT_LINE( v_empno ||' '||v_lname);
END;
/

7 - 184
Fetching Data from the Cursor
DECLARE
v_lname employees.last_name%TYPE;
BEGIN
OPEN c_emp_cursor;
LOOP
FETCH c_emp_cursor INTO v_empno, v_lname;
EXIT WHEN c_emp_cursor%NOTFOUND;
END LOOP;
END;
/

7 - 185
Closing the Cursor
...
LOOP
FETCH c_emp_cursor INTO empno, lname;
END LOOP;
CLOSE c_emp_cursor;
END;
/

7 - 186
Cursors and Records
Process the rows of the active set by fetching values into a
PL/SQL record.
DECLARE
v_emp_record c_emp_cursor%ROWTYPE;
BEGIN
OPEN c_emp_cursor;
LOOP
FETCH c_emp_cursor INTO v_emp_record;
DBMS_OUTPUT.PUT_LINE( v_emp_record.employee_id
||' '||v_emp_record.last_name);
END LOOP;
CLOSE c_emp_cursor;
END;

7 - 187
Cursor FOR Loops
Syntax:
• The cursor FOR loop is a shortcut to process explicit
cursors.
• Implicit open, fetch, exit, and close occur.
• The record is implicitly declared.
FOR record_name IN cursor_name LOOP
statement1;
statement2;
. . .
END LOOP;

7 - 188
Cursor FOR Loops
DECLARE
BEGIN
FOR emp_record IN c_emp_cursor
LOOP
DBMS_OUTPUT.PUT_LINE( emp_record.employee_id
||' ' ||emp_record.last_name);
END LOOP;
END;
/

7 - 189
Explicit Cursor Attributes
Use explicit cursor attributes to obtain status information
about a cursor.
Attribute Type Description
%ISOPEN Boolean Evaluates to TRUE if the cursor is open
%NOTFOUND Boolean Evaluates to TRUE if the most recent fetch
does not return a row
%FOUND Boolean Evaluates to TRUE if the most recent fetch
returns a row; complement of %NOTFOUND
%ROWCOUNT Number Evaluates to the total number of rows
returned so far

7 - 190
%ISOPEN Attribute
• Fetch rows only when the cursor is open.
• Use the %ISOPEN cursor attribute before performing a
fetch to test whether the cursor is open.
Example:
IF NOT c_emp_cursor%ISOPEN THEN
OPEN c_emp_cursor;
END IF;
LOOP
FETCH c_emp_cursor...

7 - 191
%ROWCOUNT and %NOTFOUND: Example
DECLARE
CURSOR c_emp_cursor IS SELECT employee_id,
last_name FROM employees;
v_emp_record c_emp_cursor%ROWTYPE;
BEGIN
OPEN c_emp_cursor;
LOOP
FETCH c_emp_cursor INTO v_emp_record;
EXIT WHEN c_emp_cursor%ROWCOUNT > 10 OR
c_emp_cursor%NOTFOUND;
DBMS_OUTPUT.PUT_LINE( v_emp_record.employee_id
||' '||v_emp_record.last_name);
END LOOP;
CLOSE c_emp_cursor;
END ;
/

7 - 192
Cursor FOR Loops Using Subqueries
There is no need to declare the cursor.
Example:
BEGIN
FOR emp_record IN (SELECT employee_id, last_name
FROM employees WHERE department_id =30)
LOOP
DBMS_OUTPUT.PUT_LINE( emp_record.employee_id
||' '||emp_record.last_name);
END LOOP;
END;
/

7 - 193
Cursors with Parameters
Syntax:
• Pass parameter values to a cursor when the cursor is
opened and the query is executed.
• Open an explicit cursor several times with a different
active set each time.
CURSOR cursor_name
[(parameter_name datatype, ...)]
IS
select_statement;
OPEN cursor_name(parameter_value,.....) ;

7 - 194
Cursors with Parameters
DECLARE
CURSOR c_emp_cursor (deptno NUMBER) IS
SELECT employee_id, last_name
FROM employees
WHERE department_id = deptno;
...
BEGIN
OPEN c_emp_cursor (10);
...
CLOSE c_emp_cursor;
OPEN c_emp_cursor (20);
...

7 - 195
FOR UPDATE Clause
Syntax:
• Use explicit locking to deny access to other sessions for
the duration of a transaction.
• Lock the rows before the update or delete.
SELECT ...
FROM ...
FOR UPDATE [OF column_reference][NOWAIT | WAIT n];

7 - 197
WHERE CURRENT OF Clause
Syntax:
• Use cursors to update or delete the current row.
• Include the FOR UPDATE clause in the cursor query to
lock the rows first.
• Use the WHERE CURRENT OF clause to reference the
current row from an explicit cursor.
WHERE CURRENT OF cursor ;
UPDATE employees
SET salary = ...
WHERE CURRENT OF c_emp_cursor;

7 - 198
Cursors with Subqueries
Example:
DECLARE
CURSOR my_cursor IS
SELECT t1.department_id, t1.department_name,
t2.staff
FROM departments t1, (SELECT department_id,
COUNT(*) AS staff
FROM employees
GROUP BY department_id) t2
WHERE t1.department_id = t2.department_id
AND t2.staff >= 3;
...

7 - 199
Summary
• Distinguish cursor types:
– Implicit cursors are used for all DML statements and
single-row queries.
– Explicit cursors are used for queries of zero, one, or more
rows.
• Create and handle explicit cursors
• Use simple loops and cursor FOR loops to handle
multiple rows in the cursors
• Evaluate the cursor status by using the cursor attributes
• Use the FOR UPDATE and WHERE CURRENT OF clauses
to update or delete the current fetched row

7 - 200
• Declaring and using explicit cursors to query rows of a
table
• Using a cursor FOR loop
• Applying cursor attributes to test the cursor status
• Declaring and using cursors with parameters
• Using the FOR UPDATE and WHERE CURRENT OF clauses

Handling Exceptions

8 - 205
Objectives
following:
• Define PL/SQL exceptions
• Recognize unhandled exceptions
• List and use different types of PL/SQL exception
handlers
• Trap unanticipated errors
• Describe the effect of exception propagation in nested
blocks
• Customize PL/SQL exception messages

8 - 206
Example of an Exception
DECLARE
v_lname VARCHAR2(15);
BEGIN
SELECT last_name INTO v_lname
FROM employees
WHERE first_name='John';
DBMS_OUTPUT.PUT_LINE ('John''s last name is :'
||v_lname);
END;

8 - 207
Example of an Exception
DECLARE
v_lname VARCHAR2(15);
BEGIN
SELECT last_name INTO v_lname
FROM employees
WHERE first_name='John';
DBMS_OUTPUT.PUT_LINE ('John''s last name is :'
||v_lname);
EXCEPTION
WHEN TOO_MANY_ROWS THEN
DBMS_OUTPUT.PUT_LINE (' Your select statement
retrieved multiple rows. Consider using a
cursor.');
END;
/

8 - 208
Handling Exceptions with PL/SQL
• An exception is a PL/SQL error that is raised during
program execution.
• An exception can be raised:
– Implicitly by the Oracle server
– Explicitly by the program
• An exception can be handled:
– By trapping it with a handler
– By propagating it to the calling environment

8 - 209
Handling Exceptions
Exception
is raised.
Is the
exception
trapped?
Yes
Execute statements
in the EXCEPTION
section.
Terminate
gracefully.
No
Terminate
abruptly.
Propagate the
exception.

8 - 210
Exception Types
• Predefined Oracle server
• Non-predefined Oracle server
• User-defined
}Implicitly raised
Explicitly raised

8 - 211
Trapping Exceptions
Syntax:
EXCEPTION
WHEN exception1 [OR exception2 . . .] THEN
statement1;
statement2;
. . .
[WHEN exception3 [OR exception4 . . .] THEN
statement1;
statement2;
. . .]
[WHEN OTHERS THEN
statement1;
statement2;
. . .]

8 - 213
Guidelines for Trapping Exceptions
• The EXCEPTION keyword starts the exception-handling
section.
• Several exception handlers are allowed.
• Only one handler is processed before leaving the block.
• WHEN OTHERS is the last clause.

8 - 214
Trapping Predefined Oracle Server Errors
• Reference the predefined name in the exception-
handling routine.
• Sample predefined exceptions:
– NO_DATA_FOUND
– TOO_MANY_ROWS
– INVALID_CURSOR
– ZERO_DIVIDE
– DUP_VAL_ON_INDEX

8 - 217
Trapping Non-Predefined
Oracle Server Errors
Declarative section
Declare
Name the
exception.
Use PRAGMA
EXCEPTION_INIT.
EXCEPTION section
Handle the raised
exception.
Associate Reference

8 - 218
DECLARE
e_insert_excep EXCEPTION;
PRAGMA EXCEPTION_INIT(e_insert_excep, -01400);
BEGIN
INSERT INTO departments
(department_id, department_name) VALUES (280, NULL);
EXCEPTION
WHEN e_insert_excep THEN
DBMS_OUTPUT.PUT_LINE('INSERT OPERATION FAILED');
DBMS_OUTPUT.PUT_LINE(SQLERRM);
END;
/
Non-Predefined Error
To trap Oracle server error number –01400
(“cannot insert NULL”):
1
2
3

8 - 219
Functions for Trapping Exceptions
• SQLCODE: Returns the numeric value for the error code
• SQLERRM: Returns the message associated with the error
number

8 - 220
Functions for Trapping Exceptions
Example
DECLARE
error_code NUMBER;
error_message VARCHAR2(255);
BEGIN
...
EXCEPTION
...
WHEN OTHERS THEN
ROLLBACK;
error_code := SQLCODE ;
error_message := SQLERRM ;
INSERT INTO errors (e_user, e_date, error_code,
error_message) VALUES(USER,SYSDATE,error_code,
error_message);
END;
/

8 - 221
Trapping User-Defined Exceptions
Declarative
section
Name the
exception.
Executable
section
Explicitly raise
the exception by
using the RAISE
statement.
Exception-handling
section
Handle the raised
exception.
Raise Reference
Declare

8 - 222
Trapping User-Defined Exceptions
DECLARE
v_deptno NUMBER := 500;
v_name VARCHAR2(20) := 'Testing';
e_invalid_department EXCEPTION;
BEGIN
UPDATE departments
SET department_name = v_name
WHERE department_id = v_deptno;
IF SQL % NOTFOUND THEN
RAISE e_invalid_department;
END IF;
COMMIT;
EXCEPTION
WHEN e_invalid_department THEN
DBMS_OUTPUT.PUT_LINE('No such department id.');
END;
/
1
2
3

8 - 223
Propagating Exceptions in a Subblock
DECLARE
. . .
e_no_rows exception;
e_integrity exception;
PRAGMA EXCEPTION_INIT (e_integrity, -2292);
BEGIN
FOR c_record IN emp_cursor LOOP
BEGIN
SELECT ...
UPDATE ...
IF SQL%NOTFOUND THEN
RAISE e_no_rows;
END IF;
END;
END LOOP;
EXCEPTION
WHEN e_integrity THEN ...
WHEN e_no_rows THEN ...
END;
/
Subblocks can handle
an exception or pass
the exception to the
enclosing block.

8 - 224
RAISE_APPLICATION_ERROR Procedure
Syntax:
• You can use this procedure to issue user-defined error
messages from stored subprograms.
• You can report errors to your application and avoid
returning unhandled exceptions.
raise_application_error (error_number,
message[, {TRUE | FALSE}]);

8 - 225
• Used in two different places:
– Executable section
– Exception section
• Returns error conditions to the user in a manner
consistent with other Oracle server errors

8 - 226
Executable section:
Exception section:
BEGIN
...
WHERE manager_id = v_mgr;
IF SQL%NOTFOUND THEN
RAISE_APPLICATION_ERROR(-20202,
'This is not a valid manager');
END IF;
...
...
EXCEPTION
WHEN NO_DATA_FOUND THEN
RAISE_APPLICATION_ERROR (-20201,
'Manager is not a valid employee.');
END;
/

8 - 227
Summary
• Define PL/SQL exceptions
• Add an EXCEPTION section to the PL/SQL block to deal
with exceptions at run time
• Handle different types of exceptions:
– Predefined exceptions
– Non-predefined exceptions
– User-defined exceptions
• Propagate exceptions in nested blocks and call
applications

8 - 228
• Handling named exceptions
• Creating and invoking user-defined exceptions

Creating Stored Procedures and Functions

9 - 232
Objectives
following:
• Differentiate between anonymous blocks and
subprograms
• Create a simple procedure and invoke it from an
anonymous block
• Create a simple function
• Create a simple function that accepts a parameter
• Differentiate between procedures and functions

9 - 233
Procedures and Functions
• Are named PL/SQL blocks
• Are called PL/SQL subprograms
• Have block structures similar to anonymous blocks:
– Optional declarative section (without the DECLARE
keyword)
– Mandatory executable section
– Optional section to handle exceptions

9 - 234
Differences Between Anonymous
Blocks and Subprograms
Anonymous Blocks Subprograms
Unnamed PL/SQL blocks Named PL/SQL blocks
Compiled every time Compiled only once
Not stored in the database Stored in the database
Cannot be invoked by other
applications
Named and, therefore, can be invoked
by other applications
Do not return values Subprograms called functions must
return values.
Cannot take parameters Can take parameters

9 - 235
Procedure: Syntax
CREATE [OR REPLACE] PROCEDURE procedure_name
[(argument1 [mode1] datatype1,
argument2 [mode2] datatype2,
. . .)]
IS|AS
procedure_body;

9 - 236
Procedure: Example
...
CREATE TABLE dept AS SELECT * FROM departments;
CREATE PROCEDURE add_dept IS
v_dept_id dept.department_id%TYPE;
v_dept_name dept.department_name%TYPE;
BEGIN
v_dept_id:=280;
v_dept_name:='ST-Curriculum';
INSERT INTO dept(department_id,department_name)
VALUES(v_dept_id,v_dept_name);
DBMS_OUTPUT.PUT_LINE(' Inserted '|| SQL%ROWCOUNT
||' row ');
END;

9 - 238
Invoking the Procedure
BEGIN
add_dept;
END;
/
SELECT department_id, department_name FROM dept
WHERE department_id=280;

9 - 239
Function: Syntax
CREATE [OR REPLACE] FUNCTION function_name
[(argument1 [mode1] datatype1,
argument2 [mode2] datatype2,
. . .)]
RETURN datatype
IS|AS
function_body;

9 - 240
Function: Example
CREATE FUNCTION check_sal RETURN Boolean IS
v_dept_id employees.department_id%TYPE;
v_sal employees.salary%TYPE;
v_avg_sal employees.salary%TYPE;
BEGIN
v_empno:=205;
SELECT salary,department_id INTO v_sal,v_dept_id FROM
employees
WHERE employee_id= v_empno;
SELECT avg(salary) INTO v_avg_sal FROM employees WHERE
department_id=v_dept_id;
IF v_sal > v_avg_sal THEN
RETURN TRUE;
ELSE
RETURN FALSE;
END IF;
EXCEPTION
WHEN NO_DATA_FOUND THEN
RETURN NULL;
END;

9 - 241
Invoking the Function
BEGIN
IF (check_sal IS NULL) THEN
DBMS_OUTPUT.PUT_LINE('The function returned
NULL due to exception');
ELSIF (check_sal) THEN
DBMS_OUTPUT.PUT_LINE('Salary > average');
ELSE
DBMS_OUTPUT.PUT_LINE('Salary < average');
END IF;
END;
/

9 - 242
Passing a Parameter to the Function
DROP FUNCTION check_sal;
CREATE FUNCTION check_sal(p_empno employees.employee_id%TYPE)
RETURN Boolean IS
v_dept_id employees.department_id%TYPE;
v_sal employees.salary%TYPE;
v_avg_sal employees.salary%TYPE;
BEGIN
SELECT salary,department_id INTO v_sal,v_dept_id FROM employees
WHERE employee_id=p_empno;
SELECT avg(salary) INTO v_avg_sal FROM employees
WHERE department_id=v_dept_id;
IF v_sal > v_avg_sal THEN
RETURN TRUE;
ELSE
RETURN FALSE;
END IF;
EXCEPTION
...

9 - 243
Invoking the Function with a Parameter
BEGIN
DBMS_OUTPUT.PUT_LINE('Checking for employee with id 205');
IF (check_sal(205) IS NULL) THEN
ELSIF (check_sal(205)) THEN
DBMS_OUTPUT.PUT_LINE('Salary > average');
ELSE
DBMS_OUTPUT.PUT_LINE('Salary < average');
END IF;
DBMS_OUTPUT.PUT_LINE('Checking for employee with id 70');
IF (check_sal(70) IS NULL) THEN
ELSIF (check_sal(70)) THEN
...
END IF;
END;
/

9 - 244
Summary
• Create a simple procedure
• Invoke the procedure from an anonymous block
• Create a simple function
• Create a simple function that accepts parameters
• Invoke the function from an anonymous block

9 - 245
• Converting an existing anonymous block to a procedure
• Modifying the procedure to accept a parameter
• Writing an anonymous block to invoke the procedure

Cursores.ppt

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to Cursores.ppt

Similar to Cursores.ppt (20)

Recently uploaded

Recently uploaded (20)

Cursores.ppt