Example 1–1 Declaring Variables in PL/SQL

DECLARE
part_no NUMBER(6);
part_name VARCHAR2(20);
in_stock BOOLEAN;
part_price NUMBER(6,2);
part_desc VARCHAR2(50);

Example 1–2 Assigning Values to Variables With the Assignment Operator

DECLARE
wages NUMBER;
hours_worked NUMBER := 40;
hourly_salary NUMBER := 22.50;
bonus NUMBER := 150;
country VARCHAR2(128);
counter NUMBER := 0;
done BOOLEAN;
valid_id BOOLEAN;
emp_rec1 employees%ROWTYPE;
emp_rec2 employees%ROWTYPE;
TYPE commissions IS TABLE OF NUMBER INDEX BY PLS_INTEGER;
comm_tab commissions;
BEGIN
wages := (hours_worked * hourly_salary) + bonus;
country := 'France';
country := UPPER('Canada');
done := (counter > 100);
valid_id := TRUE;
emp_rec1.first_name := 'Antonio';
emp_rec1.last_name := 'Ortiz';
emp_rec1 := emp_rec2;
comm_tab(5) := 20000 * 0.15;
END;

Example 1–3 Assigning Values to Variables by SELECTing INTO

DECLARE
bonus NUMBER(8,2);
emp_id NUMBER(6) := 100;
BEGIN
SELECT salary * 0.10 INTO bonus FROM employees WHERE employee_id = emp_id;
END;

Example 1–4 Assigning Values to Variables as Parameters of a Subprogram

REM SERVEROUTPUT must be set to ON to display output with DBMS_OUTPUT
SET SERVEROUTPUT ON FORMAT WRAPPED
DECLARE
new_sal NUMBER(8,2);
emp_id NUMBER(6) := 126;
PROCEDURE adjust_salary(emp_id NUMBER, sal IN OUT NUMBER) IS
emp_job VARCHAR2(10);
avg_sal NUMBER(8,2);
BEGIN
SELECT job_id INTO emp_job FROM employees WHERE employee_id = emp_id;
 SELECT AVG(salary) INTO avg_sal FROM employees WHERE job_id = emp_job;
DBMS_OUTPUT.PUT_LINE ('The average salary for ' || emp_job || ' employees: ' || TO_CHAR(avg_sal));
sal := (sal + avg_sal)/2; -- adjust sal value which is returned
END;
BEGIN
SELECT AVG(salary) INTO new_sal FROM employees;
DBMS_OUTPUT.PUT_LINE ('The average salary for all employees: ' || TO_CHAR(new_sal));
adjust_salary(emp_id, new_sal); -- assigns a new value to new_sal
DBMS_OUTPUT.PUT_LINE ('The adjusted salary for employee ' || TO_CHAR(emp_id) || ' is ' ||
TO_CHAR(new_sal)); -- sal has new value
END;

Bind Variables
When you embed an INSERT, UPDATE, DELETE, or SELECT SQL statement directly in your PL/SQL code,
PL/SQL turns the variables in the WHERE and VALUES clauses into bind variables automatically. Oracle can reuse
these SQL statement each time the same code is executed. To run similar statements with different variable values,
you can save parsing overhead by calling a stored procedure that accepts parameters, then issues the statements with
the parameters substituted in the appropriate places. You do need to specify bind variables with dynamic SQL, in
clauses like WHERE and VALUES where you normally use variables. Instead of concatenating literals and variable
values into a single string, replace the variables with the names of bind variables (prefixed by a colon) and specify the
corresponding PL/SQL variables with the USING clause. Using the USING clause, instead of concatenating the
variables into the string, reduces parsing overhead and lets Oracle reuse the SQL statements. For example:

'DELETE FROM employees WHERE employee_id = :id' USING emp_id;

Declaring Constants
Declaring a constant is like declaring a variable except that you must add the keyword
CONSTANT and immediately assign a value to the constant. No further assignments to
the constant are allowed. The following example declares a constant:
credit_limit CONSTANT NUMBER := 5000.00;

Processing Queries with PL/SQL

Processing a SQL query with PL/SQL is like processing files with other languages. For
example, a Perl program opens a file, reads the file contents, processes each line, then
closes the file. In the same way, a PL/SQL program issues a query and processes the
rows from the result set as shown in Example 1–5.
Example 1–5 Processing Query Results in a LOOP
BEGIN
FOR someone IN (SELECT * FROM employees WHERE employee_id < 120 )
LOOP
DBMS_OUTPUT.PUT_LINE('First name = ' || someone.first_name ||
', Last name = ' || someone.last_name);
END LOOP;
END;

Declaring PL/SQL Subprograms

Subprograms are named PL/SQL blocks that can be called with a set of parameters.
PL/SQL has two types of subprograms: procedures and functions. The following is an
example of a declaration of a PL/SQL procedure:
DECLARE
in_string VARCHAR2(100) := 'This is my test string.';
out_string VARCHAR2(200);
PROCEDURE double ( original IN VARCHAR2, new_string OUT VARCHAR2 ) AS
BEGIN
new_string := original || original;
END;

%TYPE
v_last_name employees.last_name%TYPE;

%ROWTYPE
DECLARE
dept_rec departments%ROWTYPE; -- declare record variable
You use dot notation to reference fields, as the following example shows:
v_deptid := dept_rec.department_id;

Example 1–6 Using %ROWTYPE with an Explicit Cursor

DECLARE
CURSOR c1 IS
SELECT last_name, salary, hire_date, job_id FROM employees
WHERE employee_id = 120;
-- declare record variable that represents a row fetched from the employees table
employee_rec c1%ROWTYPE;
BEGIN
-- open the explicit cursor and use it to fetch data into employee_rec
OPEN c1;
FETCH c1 INTO employee_rec;
DBMS_OUTPUT.PUT_LINE('Employee name: ' || employee_rec.last_name);
END;

Conditional Control
Example 1–7 Using the IF-THEN_ELSE and CASE Statement for Conditional Control
DECLARE
jobid employees.job_id%TYPE;
empid employees.employee_id%TYPE := 115;
sal employees.salary%TYPE;
sal_raise NUMBER(3,2);
BEGIN
SELECT job_id, salary INTO jobid, sal from employees WHERE employee_id = empid;
CASE
WHEN jobid = 'PU_CLERK' THEN
IF sal < 3000 THEN sal_raise := .12;
ELSE sal_raise := .09;
END IF;
WHEN jobid = 'SH_CLERK' THEN
IF sal < 4000 THEN sal_raise := .11;
ELSE sal_raise := .08;
END IF;
WHEN jobid = 'ST_CLERK' THEN
IF sal < 3500 THEN sal_raise := .10;
ELSE sal_raise := .07;
END IF;
ELSE
BEGIN
DBMS_OUTPUT.PUT_LINE('No raise for this job: ' || jobid);
END;
END CASE;
UPDATE employees SET salary = salary + salary * sal_raise
WHERE employee_id = empid;
COMMIT;
END;

Iterative Control
Example 1–8 Using the FOR-LOOP
CREATE TABLE sqr_root_sum (num NUMBER, sq_root NUMBER(6,2),
sqr NUMBER, sum_sqrs NUMBER);
DECLARE
s PLS_INTEGER;
BEGIN
FOR i in 1..100 LOOP
s := (i * (i + 1) * (2*i +1)) / 6; -- sum of squares
INSERT INTO sqr_root_sum VALUES (i, SQRT(i), i*i, s );
END LOOP;
END;

Example 1–9 Using WHILE-LOOP for Control

CREATE TABLE temp (tempid NUMBER(6), tempsal NUMBER(8,2), tempname VARCHAR2(25));
DECLARE
sal employees.salary%TYPE := 0;
mgr_id employees.manager_id%TYPE;
lname employees.last_name%TYPE;
starting_empid employees.employee_id%TYPE := 120;
BEGIN
SELECT manager_id INTO mgr_id FROM employees
WHERE employee_id = starting_empid;
WHILE sal <= 15000 LOOP -- loop until sal > 15000
SELECT salary, manager_id, last_name INTO sal, mgr_id, lname
FROM employees WHERE employee_id = mgr_id;
END LOOP;
INSERT INTO temp VALUES (NULL, sal, lname); -- insert NULL for tempid
COMMIT;
EXCEPTION
WHEN NO_DATA_FOUND THEN
INSERT INTO temp VALUES (NULL, NULL, 'Not found'); -- insert NULLs
COMMIT;
END;
Example 1–10 Using the EXIT-WHEN Statement
DECLARE
total NUMBER(9) := 0;
counter NUMBER(6) := 0;
BEGIN
LOOP
counter := counter + 1;
total := total + counter * counter;
-- exit loop when condition is true
EXIT WHEN total > 25000;
END LOOP;
DBMS_OUTPUT.PUT_LINE('Counter: ' || TO_CHAR(counter) || ' Total: ' ||
TO_CHAR(total));
END;
Example 1–11 Using the GOTO Statement
DECLARE
total NUMBER(9) := 0;
counter NUMBER(6) := 0;
BEGIN
<<calc_total>>
counter := counter + 1;
total := total + counter * counter;
-- branch to print_total label when condition is true
IF total > 25000 THEN GOTO print_total;
ELSE GOTO calc_total;
END IF;
<<print_total>>
DBMS_OUTPUT.PUT_LINE('Counter: ' || TO_CHAR(counter) || ' Total: ' ||
TO_CHAR(total));
END;

Example 1–12 Creating a Stored Subprogram

-- including OR REPLACE is more convenient when updating a subprogram
CREATE OR REPLACE PROCEDURE award_bonus (emp_id NUMBER, bonus NUMBER) AS
commission REAL;
comm_missing EXCEPTION;
BEGIN -- executable part starts here
SELECT commission_pct / 100 INTO commission FROM employees
WHERE employee_id = emp_id;
IF commission IS NULL THEN
RAISE comm_missing;
ELSE
UPDATE employees SET salary = salary + bonus*commission
WHERE employee_id = emp_id;
END IF;
EXCEPTION -- exception-handling part starts here
WHEN comm_missing THEN
DBMS_OUTPUT.PUT_LINE('This employee does not receive a commission.');
commission := 0;
WHEN OTHERS THEN
NULL; -- for other exceptions do nothing
END award_bonus;
/
CALL award_bonus(150, 400);

Example 1–13 Creating a Package and Package Body

CREATE OR REPLACE PACKAGE emp_actions AS -- package specification
PROCEDURE hire_employee (employee_id NUMBER, last_name VARCHAR2,
first_name VARCHAR2, email VARCHAR2, phone_number VARCHAR2,
hire_date DATE, job_id VARCHAR2, salary NUMBER, commission_pct NUMBER,
manager_id NUMBER, department_id NUMBER);
PROCEDURE fire_employee (emp_id NUMBER);
FUNCTION num_above_salary (emp_id NUMBER) RETURN NUMBER;
END emp_actions;
/
CREATE OR REPLACE PACKAGE BODY emp_actions AS -- package body
-- code for procedure hire_employee
PROCEDURE hire_employee (employee_id NUMBER, last_name VARCHAR2,
first_name VARCHAR2, email VARCHAR2, phone_number VARCHAR2, hire_date DATE,
job_id VARCHAR2, salary NUMBER, commission_pct NUMBER,
manager_id NUMBER, department_id NUMBER) IS
BEGIN
INSERT INTO employees VALUES (employee_id, last_name, first_name, email,
phone_number, hire_date, job_id, salary, commission_pct, manager_id,
department_id);
END hire_employee;
-- code for procedure fire_employee
PROCEDURE fire_employee (emp_id NUMBER) IS
BEGIN
DELETE FROM employees WHERE employee_id = emp_id;
END fire_employee;
-- code for function num_above salary
FUNCTION num_above_salary (emp_id NUMBER) RETURN NUMBER IS
emp_sal NUMBER(8,2);
num_count NUMBER;
BEGIN
SELECT salary INTO emp_sal FROM employees WHERE employee_id = emp_id;
SELECT COUNT(*) INTO num_count FROM employees WHERE salary > emp_sal;
RETURN num_count;
END num_above_salary;
END emp_actions;

Example 1–14 Calling a Procedure in a Package

CALL emp_actions.hire_employee(300, 'Belden', 'Enrique', 'EBELDEN',
'555.111.2222', '31-AUG-04', 'AC_MGR', 9000, .1, 101, 110);
BEGIN
DBMS_OUTPUT.PUT_LINE( 'Number of employees with higher salary: ' ||
TO_CHAR(emp_actions.num_above_salary(120)));
emp_actions.fire_employee(300);
END;

Inputting and Outputting Data with PL/SQL

Most PL/SQL input and output is through SQL statements, to store data in database
tables or query those tables. All other PL/SQL I/O is done through APIs that interact
with other programs. For example, the DBMS_OUTPUT package has procedures such as
PUT_LINE. To see the result outside of PL/SQL requires another program, such as
SQL*Plus, to read and display the data passed to DBMS_OUTPUT.
SQL*Plus does not display DBMS_OUTPUT data unless you first issue the SQL*Plus
command SET SERVEROUTPUT ON as follows:
SET SERVEROUTPUT ON
For information on the SEVEROUTPUT setting, see the "SQL*Plus Command Reference"
chapter in SQL*Plus User's Guide and Reference.
Other PL/SQL APIs for processing I/O are:
■ HTF and HTP for displaying output on a web page
■ DBMS_PIPE for passing information back and forth between PL/SQL and
operating-system commands
■ UTL_FILE for reading and writing operating-system files
■ UTL_HTTP for communicating with web servers
■ UTL_SMTP for communicating with mail servers

Understanding PL/SQL Data Abstraction

Cursors
A cursor is a name for a specific private SQL area in which information for processing
the specific statement is kept. PL/SQL uses both implicit and explicit cursors. PL/SQL
implicitly declares a cursor for all SQL data manipulation statements on a set of rows,
including queries that return only one row. For queries that return more than one row,
you can explicitly declare a cursor to process the rows individually.
Collections
PL/SQL collection types let you declare high-level datatypes similar to arrays, sets,
and hash tables found in other languages. In PL/SQL, array types are known as
varrays (short for variable-size arrays), set types are known as nested tables, and hash
table types are known as associative arrays. Each kind of collection is an ordered
group of elements, all of the same type. Each element has a unique subscript that
determines its position in the collection. When declaring collections, you use a TYPE
definition.
Example 1–15 Using a PL/SQL Collection Type
DECLARE
TYPE staff_list IS TABLE OF employees.employee_id%TYPE;
staff staff_list;
lname employees.last_name%TYPE;
fname employees.first_name%TYPE;
BEGIN
staff := staff_list(100, 114, 115, 120, 122);
FOR i IN staff.FIRST..staff.LAST LOOP
SELECT last_name, first_name INTO lname, fname FROM employees
WHERE employees.employee_id = staff(i);
DBMS_OUTPUT.PUT_LINE ( TO_CHAR(staff(i)) || ': ' || lname || ', ' || fname );
END LOOP;
END;

Records
Records are composite data structures whose fields can have different datatypes. You
can use records to hold related items and pass them to subprograms with a single
Understanding the Main Features of PL/SQL
Overview of PL/SQL 1-17
parameter. When declaring records, you use a TYPE definition
Example 1–16 Declaring a Record Type
DECLARE
TYPE timerec IS RECORD (hours SMALLINT, minutes SMALLINT);
TYPE meetin_typ IS RECORD (
date_held DATE,
duration timerec, -- nested record
location VARCHAR2(20),
purpose VARCHAR2(50));
BEGIN
-- NULL does nothing but allows unit to be compiled and tested
NULL;
END;

Object Types
PL/SQL supports object-oriented programming through object types. An object type
encapsulates a data structure along with the functions and procedures needed to
manipulate the data. The variables that form the data structure are known as
attributes. The functions and procedures that manipulate the attributes are known as
methods.
Object types reduce complexity by breaking down a large system into logical entities.
This lets you create software components that are modular, maintainable, and
reusable. Object-type definitions, and the code for the methods, are stored in the
database. Instances of these object types can be stored in tables or used as variables
inside PL/SQL code. Example 1–17 shows an object type definition for a bank account.
Example 1–17 Defining an Object Type
CREATE TYPE bank_account AS OBJECT (
acct_number NUMBER(5),
balance NUMBER,
status VARCHAR2(10),
MEMBER PROCEDURE open (SELF IN OUT NOCOPY bank_account, amount IN NUMBER),
MEMBER PROCEDURE close (SELF IN OUT NOCOPY bank_account, num IN NUMBER,
amount OUT NUMBER),
MEMBER PROCEDURE deposit (SELF IN OUT NOCOPY bank_account, num IN NUMBER,
amount IN NUMBER),
MEMBER PROCEDURE withdraw (SELF IN OUT NOCOPY bank_account, num IN NUMBER,
amount IN NUMBER),
MEMBER FUNCTION curr_bal (num IN NUMBER) RETURN NUMBER );

Example 1–18 Techniques for Calling a Standalone Procedure From SQL*Plus

CALL award_bonus(179, 1000);
BEGIN
award_bonus(179, 10000);
END;
/
-- using named notation
BEGIN award_bonus(emp_id=>179, bonus=>10000); END;
/

Database Triggers
A database trigger is a stored subprogram associated with a database table, view, or
event. The trigger can be called once, when some event occurs, or many times, once for
each row affected by an INSERT, UPDATE, or DELETE statement. The trigger can be
called after the event, to record it or take some followup action. Or, the trigger can be
called before the event to prevent erroneous operations or fix new data so that it
conforms to business rules. In Example 1–19 the table-level trigger fires whenever
salaries in the employees table are updated, such as the processing in Example 1–7 on
page 1-10. For each update, the trigger writes a record to the emp_audit table.
Example 1–19 Creating a Database Trigger
CREATE TABLE emp_audit ( emp_audit_id NUMBER(6), up_date DATE,
new_sal NUMBER(8,2), old_sal NUMBER(8,2) );
CREATE OR REPLACE TRIGGER audit_sal
AFTER UPDATE OF salary ON employees FOR EACH ROW
BEGIN
-- bind variables are used here for values
INSERT INTO emp_audit VALUES( :old.employee_id, SYSDATE,
:new.salary, :old.salary );
END;
/

Character Sets and Lexical Units

PL/SQL programs are written as lines of text using a specific set of characters:
■ Upper- and lower-case letters A .. Z and a .. z
■ Numerals 0 .. 9
■ Symbols ( ) + - * / < > = ! ~ ^ ; : . ' @ % , " # $ & _ | { } ? [ ]
■ Tabs, spaces, and carriage returns
PL/SQL keywords are not case-sensitive, so lower-case letters are equivalent to
corresponding upper-case letters except within string and character literals.
A line of PL/SQL text contains groups of characters known as lexical units:
■ Delimiters (simple and compound symbols)
■ Identifiers, which include reserved words
■ Literals
■ Comments
To improve readability, you can separate lexical units by spaces. In fact, you must
separate adjacent identifiers by a space or punctuation. The following line is not
allowed because the reserved words END and IF are joined:
IF x > y THEN high := x; ENDIF; -- not allowed, must be END IF
You cannot embed spaces inside lexical units except for string literals and comments.
For example, the following line is not allowed because the compound symbol for
assignment (:=) is split:
count : = count + 1; -- not allowed, must be :=
To show structure, you can split lines using carriage returns, and indent lines using
spaces or tabs. This formatting makes the first IF statement more readable.
IF x>y THEN max:=x;ELSE max:=y;END IF;
The following is easier to read:
IF x > y THEN
max := x;
ELSE
max := y;
END IF;

Delimiters
A delimiter is a simple or compound symbol that has a special meaning to PL/SQL.
For example, you use delimiters to represent arithmetic operations such as addition
and subtraction. Table 2–1 contains a list of PL/SQL delimiters.
Table 2–1 PL/SQL Delimiters
Symbol Meaning
+ addition operator
% attribute indicator
' character string delimiter
. component selector
/ division operator
( expression or list delimiter
) expression or list delimiter
: host variable indicator
, item separator
* multiplication operator
" quoted identifier delimiter
= relational operator
< relational operator
> relational operator
@ remote access indicator
; statement terminator
- subtraction/negation operator
:= assignment operator
=> association operator
|| concatenation operator
** exponentiation operator
<< label delimiter (begin)
>> label delimiter (end)
/* multi-line comment delimiter (begin)
*/ multi-line comment delimiter (end)
.. range operator
<> relational operator
!= relational operator
~= relational operator
^= relational operator
<= relational operator
>= relational operator
-- single-line comment indicator

Quoted Identifiers
For flexibility, PL/SQL lets you enclose identifiers within double quotes. Quoted
identifiers are seldom needed, but occasionally they can be useful. They can contain
any sequence of printable characters including spaces but excluding double quotes.
Thus, the following identifiers are valid:
"X+Y"
"last name"
"on/off switch"
"employee(s)"
"*** header info ***"
The maximum size of a quoted identifier is 30 characters not counting the double
quotes. Though allowed, using PL/SQL reserved words as quoted identifiers is a poor
programming practice.

Datetime Literals
Datetime literals have various formats depending on the datatype. For example:
Example 2–3 Using DateTime Literals
DECLARE
d1 DATE := DATE '1998-12-25';
t1 TIMESTAMP := TIMESTAMP '1997-10-22 13:01:01';
t2 TIMESTAMP WITH TIME ZONE := TIMESTAMP '1997-01-31 09:26:56.66 +02:00';
-- Three years and two months
-- For greater precision, we would use the day-to-second interval
i1 INTERVAL YEAR TO MONTH := INTERVAL '3-2' YEAR TO MONTH;
-- Five days, four hours, three minutes, two and 1/100 seconds
i2 INTERVAL DAY TO SECOND := INTERVAL '5 04:03:02.01' DAY TO SECOND;

Single-Line Comments
Single-line comments begin with a double hyphen (--) anywhere on a line and extend
to the end of the line. A few examples follow:
Example 2–4 Using Single-Line Comments
DECLARE
howmany NUMBER;
num_tables NUMBER;
BEGIN
-- begin processing
SELECT COUNT(*) INTO howmany FROM USER_OBJECTS
WHERE OBJECT_TYPE = 'TABLE'; -- Check number of tables
num_tables := howmany; -- Compute some other value
END;
Example 2–5 Using Multi-Line Comments
DECLARE
some_condition BOOLEAN;
pi NUMBER := 3.1415926;
radius NUMBER := 15;
area NUMBER;
BEGIN
/* Perform some simple tests and assignments */
IF 2 + 2 = 4 THEN
some_condition := TRUE; /* We expect this THEN to always be performed */
END IF;
/* The following line computes the area of a circle using pi, which is the
ratio between the circumference and diameter. After the area is computed,
the result is displayed. */
area := pi * radius**2;
DBMS_OUTPUT.PUT_LINE('The area is: ' || TO_CHAR(area));
END;

Using DEFAULT
You can use the keyword DEFAULT instead of the assignment operator to initialize
variables. For example, the declaration
blood_type CHAR := 'O';
can be rewritten as follows:
blood_type CHAR DEFAULT 'O';
Use DEFAULT for variables that have a typical value. Use the assignment operator for
variables (such as counters and accumulators) that have no typical value. For example:
hours_worked INTEGER DEFAULT 40;
employee_count INTEGER := 0;

Using NOT NULL

Besides assigning an initial value, declarations can impose the NOT NULL constraint:
DECLARE
acct_id INTEGER(4) NOT NULL := 9999;

Using the %TYPE Attribute

The %TYPE attribute provides the datatype of a variable or database column. As
shown in Example 2–6, variables declared with %TYPE inherit the datatype of a
variable, plus default values and constraints.
Example 2–6 Using %TYPE With the Datatype of a Variable
DECLARE
credit PLS_INTEGER RANGE 1000..25000;
debit credit%TYPE;
v_name VARCHAR2(20);
name VARCHAR2(20) NOT NULL := 'JoHn SmItH';
-- If we increase the length of NAME, the other variables become longer also
upper_name name%TYPE := UPPER(name);
lower_name name%TYPE := LOWER(name);
init_name name%TYPE := INITCAP(name);
BEGIN
-- display inherited default values
DBMS_OUTPUT.PUT_LINE('name: ' || name || ' upper_name: ' || upper_name
|| ' lower_name: ' || lower_name || ' init_name: ' || init_name);
-- lower_name := 'jonathan henry smithson'; invalid, character string is too long
-- lower_name := NULL; invalid, NOT NULL CONSTRAINT
-- debit := 50000; invalid, value out of range
END;

Using the %ROWTYPE Attribute

The %ROWTYPE attribute provides a record type that represents a row in a table or
view. Columns in a row and corresponding fields in a record have the same names and
datatypes. However, fields in a %ROWTYPE record do not inherit constraints, such as
the NOT NULL or check constraint, or default values, as shown in Example 2–8. See also
Example 3–11 on page 3-20.
Example 2–8 Using %ROWTYPE With Table Rows
DECLARE
emprec employees_temp%ROWTYPE;
BEGIN
emprec.empid := NULL; -- this works, null constraint is not inherited
-- emprec.empid := 10000002; -- invalid, number precision too large
emprec.deptid := 50; -- this works, check constraint is not inherited
-- the default value is not inherited in the following
DBMS_OUTPUT.PUT_LINE('emprec.deptname: ' || emprec.deptname);
END;

Example 2–10 Assigning Values to a Record With a %ROWTYPE Declaration

DECLARE
dept_rec1 departments%ROWTYPE;
dept_rec2 departments%ROWTYPE;
CURSOR c1 IS SELECT department_id, location_id FROM departments;
dept_rec3 c1%ROWTYPE;
BEGIN
dept_rec1 := dept_rec2; -- allowed
-- dept_rec2 refers to a table, dept_rec3 refers to a cursor
-- dept_rec2 := dept_rec3; -- not allowed
END;

You can assign a list of column values to a record by using the SELECT or FETCH
statement, as the following example shows. The column names must appear in the
order in which they were defined by the CREATE TABLE or CREATE VIEW statement.
DECLARE
dept_rec departments%ROWTYPE;
BEGIN
SELECT * INTO dept_rec FROM departments
WHERE department_id = 30 and ROWNUM < 2;
END;

Example 2–11 Using an Alias for Column Names

BEGIN
-- We assign an alias (complete_name) to the expression value, because
-- it has no column name.
FOR item IN
( SELECT first_name || ' ' || last_name complete_name
FROM employees WHERE ROWNUM < 11 )
LOOP
-- Now we can refer to the field in the record using this alias.
DBMS_OUTPUT.PUT_LINE('Employee name: ' || item.complete_name);
END LOOP;

PL/SQL Naming Conventions

The same naming conventions apply to all PL/SQL program items and units including
constants, variables, cursors, cursor variables, exceptions, procedures, functions, and
packages. Names can be simple, qualified, remote, or both qualified and remote. For
example, you might use the procedure name raise_salary in any of the following
ways:
raise_salary(...); -- simple
emp_actions.raise_salary(...); -- qualified
raise_salary@newyork(...); -- remote
emp_actions.raise_salary@newyork(...); -- qualified and remote

Case Sensitivity
Like all identifiers, the names of constants, variables, and parameters are not case
sensitive. For instance, PL/SQL considers the following names to be the same:
Example 2–13 Case Sensitivity of Identifiers
DECLARE
zip_code INTEGER;
Zip_Code INTEGER; -- duplicate identifier, despite Z/z case difference
BEGIN
zip_code := 90120; -- raises error here because of duplicate identifiers
END;

Example 2–14 Using a Block Label for Name Resolution

CREATE TABLE employees2 AS SELECT last_name FROM employees;
<<main>>
DECLARE
last_name VARCHAR2(10) := 'King';
v_last_name VARCHAR2(10) := 'King';
BEGIN
-- deletes everyone, because both LAST_NAMEs refer to the column
DELETE FROM employees2 WHERE last_name = last_name;
DBMS_OUTPUT.PUT_LINE('Deleted ' || SQL%ROWCOUNT || ' rows.');
ROLLBACK;
-- OK, column and variable have different names
DELETE FROM employees2 WHERE last_name = v_last_name;
DBMS_OUTPUT.PUT_LINE('Deleted ' || SQL%ROWCOUNT || ' rows.');
ROLLBACK;
-- OK, block name specifies that 2nd last_name is a variable
DELETE FROM employees2 WHERE last_name = main.last_name;
DBMS_OUTPUT.PUT_LINE('Deleted ' || SQL%ROWCOUNT || ' rows.');
ROLLBACK;
END;

Example 2–15 Using a Subprogram Name for Name Resolution

DECLARE
FUNCTION dept_name (department_id IN NUMBER)
RETURN departments.department_name%TYPE
IS
department_name departments.department_name%TYPE;
BEGIN
-- DEPT_NAME.department_name specifies the local variable
-- instead of the table column
SELECT department_name INTO dept_name.department_name
FROM departments
WHERE department_id = dept_name.department_id;
RETURN department_name;
END;
BEGIN
FOR item IN (SELECT department_id FROM departments)
LOOP
DBMS_OUTPUT.PUT_LINE('Department: ' || dept_name(item.department_id));
END LOOP;
END;

Example 2–16 Scope Rules

DECLARE
a CHAR;
b REAL;
BEGIN
-- identifiers available here: a (CHAR), b
DECLARE
a INTEGER;
c REAL;
BEGIN
NULL; -- identifiers available here: a (INTEGER), b, c
END;
DECLARE
d REAL;
BEGIN
NULL; -- identifiers available here: a (CHAR), b, d
END;
-- identifiers available here: a (CHAR), b
END;

Example 2–17 Using a Label Qualifier With Identifiers

<<outer>>
DECLARE
birthdate DATE := '09-AUG-70';
BEGIN
DECLARE
birthdate DATE;
BEGIN
birthdate := '29-SEP-70';
IF birthdate = outer.birthdate THEN
DBMS_OUTPUT.PUT_LINE ('Same Birthday');
ELSE
DBMS_OUTPUT.PUT_LINE ('Different Birthday');
END IF;
END;
END;

Example 2–18 Using Subprogram Qualifier With Identifiers

CREATE OR REPLACE PROCEDURE check_credit(limit NUMBER) AS
rating NUMBER := 3;
FUNCTION check_rating RETURN BOOLEAN IS
rating NUMBER := 1;
over_limit BOOLEAN;
BEGIN
IF check_credit.rating <= limit THEN
over_limit := FALSE;
ELSE
rating := limit;
over_limit := TRUE;
END IF;
RETURN over_limit;
END check_rating;
BEGIN
IF check_rating THEN
DBMS_OUTPUT.PUT_LINE( 'Credit rating over limit (' || TO_CHAR(limit)
|| ').' || ' Rating: ' || TO_CHAR(rating));
ELSE
DBMS_OUTPUT.PUT_LINE( 'Credit rating OK. ' || 'Rating: '
|| TO_CHAR(rating) );
END IF;
END;
/
CALL check_credit(1);

Example 2–19 PL/SQL Block Using Multiple and Duplicate Labels

<<compute_ratio>>
<<another_label>>
DECLARE
numerator NUMBER := 22;
denominator NUMBER := 7;
the_ratio NUMBER;
BEGIN
<<inner_label>>
<<another_label>>
DECLARE
denominator NUMBER := 0;
BEGIN
-- first use the denominator value = 7 from global DECLARE
-- to compute a rough value of pi
the_ratio := numerator/compute_ratio.denominator;
DBMS_OUTPUT.PUT_LINE('Ratio = ' || the_ratio);
-- now use the local denominator value = 0 to raise an exception
-- inner_label is not needed but used for clarification
the_ratio := numerator/inner_label.denominator;
DBMS_OUTPUT.PUT_LINE('Ratio = ' || the_ratio);
-- if you use a duplicate label, you might get errors
-- or unpredictable results
the_ratio := numerator/another_label.denominator;
DBMS_OUTPUT.PUT_LINE('Ratio = ' || the_ratio);
EXCEPTION
WHEN ZERO_DIVIDE THEN
DBMS_OUTPUT.PUT_LINE('Divide-by-zero error: can''t divide '
|| numerator || ' by ' || denominator);
WHEN OTHERS THEN
DBMS_OUTPUT.PUT_LINE('Unexpected error.');
END inner_label;
END compute_ratio;

Assigning BOOLEAN Values

Only the values TRUE, FALSE, and NULL can be assigned to a BOOLEAN variable as
shown in Example 2–21. You can assign these literal values, or expressions such as
comparisons using relational operators.
Example 2–21 Assigning BOOLEAN Values
DECLARE
done BOOLEAN; -- DONE is initially NULL
counter NUMBER := 0;
BEGIN
done := FALSE; -- Assign a literal value
WHILE done != TRUE -- Compare to a literal value
LOOP
counter := counter + 1;
done := (counter > 500); -- If counter > 500, DONE = TRUE
END LOOP;
END;

Assigning a SQL Query Result to a PL/SQL Variable

You can use the SELECT statement to have Oracle assign values to a variable. For each
item in the select list, there must be a corresponding, type-compatible variable in the
INTO list as shown in Example 2–22.
Example 2–22 Assigning a Query Result to a Variable
DECLARE
emp_id employees.employee_id%TYPE := 100;
emp_name employees.last_name%TYPE;
wages NUMBER(7,2);
BEGIN
SELECT last_name, salary + (salary * nvl(commission_pct,0))
INTO emp_name, wages FROM employees
WHERE employee_id = emp_id;
DBMS_OUTPUT.PUT_LINE('Employee ' || emp_name || ' might make ' || wages);
END;

IS NULL Operator
The IS NULL operator returns the BOOLEAN value TRUE if its operand is null or FALSE
if it is not null. Comparisons involving nulls always yield NULL. Test whether a value
is null as follows:
IF variable IS NULL THEN ...
LIKE Operator
You use the LIKE operator to compare a character, string, or CLOB value to a pattern.
Case is significant. LIKE returns the BOOLEAN value TRUE if the patterns match or
FALSE if they do not match.
The patterns matched by LIKE can include two special-purpose characters called
wildcards. An underscore (_) matches exactly one character; a percent sign (%) matches
zero or more characters. For example, if the value of last_name is 'JOHNSON', the
following expression is true:
last_name LIKE 'J%S_N'
To search for the percent sign and underscore characters, you define an escape
character and put that character before the percent sign or underscore. The following
example uses the backslash as the escape character, so that the percent sign in the
string does not act as a wildcard:
IF sale_sign LIKE '50\% off!' ESCAPE '\' THEN...
BETWEEN Operator
The BETWEEN operator tests whether a value lies in a specified range. It means "greater
than or equal to low value and less than or equal to high value." For example, the
following expression is false:
45 BETWEEN 38 AND 44
IN Operator
The IN operator tests set membership. It means "equal to any member of." The set can
contain nulls, but they are ignored. For example, the following expression tests
whether a value is part of a set of values:
letter IN ('a','b','c')
Be careful when inverting this condition. Expressions of the form:
value NOT IN set
yield FALSE if the set contains a null.
Concatenation Operator
Double vertical bars (||) serve as the concatenation operator, which appends one
string (CHAR, VARCHAR2, CLOB, or the equivalent Unicode-enabled type) to another.
For example, the expression
'suit' || 'case'
returns the following value:
>= greater than or equal to
Operator Meaning
PL/SQL Expressions and Comparisons
2-24 Oracle Database PL/SQL User’s Guide and Reference
'suitcase'
If both operands have datatype CHAR, the concatenation operator returns a CHAR
value. If either operand is a CLOB value, the operator returns a temporary CLOB.
Otherwise, it returns a VARCHAR2 valu

Example 2–26 Using the WHEN Clause With a CASE Statement

DECLARE
grade CHAR(1) := 'B';
appraisal VARCHAR2(20);
BEGIN
appraisal :=
CASE grade
WHEN 'A' THEN 'Excellent'
WHEN 'B' THEN 'Very Good'
WHEN 'C' THEN 'Good'
WHEN 'D' THEN 'Fair'
WHEN 'F' THEN 'Poor'
ELSE 'No such grade'
END;
DBMS_OUTPUT.PUT_LINE('Grade ' || grade || ' is ' || appraisal);
END;

Example 2–27 Using a Search Condition With a CASE Statement

DECLARE
grade CHAR(1) := 'B';
appraisal VARCHAR2(120);
id NUMBER := 8429862;
attendance NUMBER := 150;
min_days CONSTANT NUMBER := 200;
FUNCTION attends_this_school(id NUMBER) RETURN BOOLEAN IS
BEGIN RETURN TRUE; END;
BEGIN
appraisal :=
CASE
WHEN attends_this_school(id) = FALSE THEN 'N/A - Student not enrolled'
-- Have to test this condition early to detect good students with bad attendance
WHEN grade = 'F' OR attendance < min_days
THEN 'Poor (poor performance or bad attendance)'
WHEN grade = 'A' THEN 'Excellent'
WHEN grade = 'B' THEN 'Very Good'
WHEN grade = 'C' THEN 'Good'
WHEN grade = 'D' THEN 'Fair'
ELSE 'No such grade'
END;
DBMS_OUTPUT.PUT_LINE('Result for student ' || id || ' is ' || appraisal);
END;

Example 2–28 Using NULLs in Comparisons

DECLARE
x NUMBER := 5;
y NUMBER := NULL;
BEGIN
IF x != y THEN -- yields NULL, not TRUE
DBMS_OUTPUT.PUT_LINE('x != y'); -- not executed
ELSIF x = y THEN -- also yields NULL
DBMS_OUTPUT.PUT_LINE('x = y');
ELSE
DBMS_OUTPUT.PUT_LINE('Can''t tell if x and y are equal or not.');
END IF;
END;

DECLARE
a NUMBER := NULL;
b NUMBER := NULL;
BEGIN
IF a = b THEN -- yields NULL, not TRUE
DBMS_OUTPUT.PUT_LINE('a = b'); -- not executed
ELSIF a != b THEN -- yields NULL, not TRUE
DBMS_OUTPUT.PUT_LINE('a != b'); -- not executed
ELSE
DBMS_OUTPUT.PUT_LINE('Can''t tell if two NULLs are equal');
END IF;
END;

NULLs and the NOT Operator

Recall that applying the logical operator NOT to a null yields NULL. Thus, the following
two IF statements are not always equivalent:
IF x > y THEN high := x; ELSE high := y; END IF;
IF NOT x > y THEN high := y; ELSE high := x; END IF;
The sequence of statements in the ELSE clause is executed when the IF condition
yields FALSE or NULL. If neither x nor y is null, both IF statements assign the same
value to high. However, if either x or y is null, the first IF statement assigns the value
of y to high, but the second IF statement assigns the value of x to high

NULLs and the Concatenation Operator

The concatenation operator ignores null operands. For example, the expression
'apple' || NULL || NULL || 'sauce'
returns the following value:
'applesauce'

Example 2–29 Using the Function DECODE

DECLARE
the_manager VARCHAR2(40);
name employees.last_name%TYPE;
BEGIN
-- NULL is a valid argument to DECODE. In this case, manager_id is null
-- and the DECODE function returns 'nobody'.
SELECT DECODE(manager_id, NULL, 'nobody', 'somebody'), last_name
INTO the_manager, name FROM employees WHERE employee_id = 100;
DBMS_OUTPUT.PUT_LINE(name || ' is managed by ' || the_manager);
END;

Example 2–30 Using the Function NVL

DECLARE
the_manager employees.manager_id%TYPE;
name employees.last_name%TYPE;
BEGIN
-- NULL is a valid argument to NVL. In this case, manager_id is null
-- and the NVL function returns -1.
SELECT NVL(manager_id, -1), last_name
INTO the_manager, name FROM employees WHERE employee_id = 100;
DBMS_OUTPUT.PUT_LINE(name || ' is managed by employee Id: ' || the_manager);
END;

Example 2–31 Using the Function REPLACE

DECLARE
string_type VARCHAR2(60);
old_string string_type%TYPE := 'Apples and oranges';
v_string string_type%TYPE := 'more apples';
-- NULL is a valid argument to REPLACE, but does not match
-- anything so no replacement is done.
new_string string_type%TYPE := REPLACE(old_string, NULL, v_string);
BEGIN
DBMS_OUTPUT.PUT_LINE('Old string = ' || old_string);
DBMS_OUTPUT.PUT_LINE('New string = ' || new_string);
END;

DECLARE
string_type VARCHAR2(60);
dashed string_type%TYPE := 'Gold-i-locks';
-- When the substitution text for REPLACE is NULL,
-- the text being replaced is deleted.
name string_type%TYPE := REPLACE(dashed, '-', NULL);
BEGIN
DBMS_OUTPUT.PUT_LINE('Dashed name = ' || dashed);
DBMS_OUTPUT.PUT_LINE('Dashes removed = ' || name);
END;

Conditional Compilation Examples

This section provides examples using conditional compilation.
Using Conditional Compilation to Specify Code for Database Versions
In Example 2–34, conditional compilation is used to determine whether the
BINARY_DOUBLE datatype can be utilized in the calculations for PL/SQL units in the
database. The BINARY_DOUBLE datatype can only be used in a database version that is
10g or later. This example also shows the use of the PLSQL_CCFLAGS parameter.
Example 2–34 Using Conditional Compilation With Database Versions
-- set flags for displaying debugging code and tracing info
ALTER SESSION SET PLSQL_CCFLAGS = 'my_debug:FALSE, my_tracing:FALSE';
CREATE PACKAGE my_pkg AS
SUBTYPE my_real IS
$IF DBMS_DB_VERSION.VERSION < 10 $THEN NUMBER; -- check database version
$ELSE BINARY_DOUBLE;
$END
my_pi my_real; my_e my_real;
END my_pkg;
/
CREATE PACKAGE BODY my_pkg AS
BEGIN -- set up values for future calculations based on DB version
$IF DBMS_DB_VERSION.VERSION < 10 $THEN
my_pi := 3.14016408289008292431940027343666863227;
my_e := 2.71828182845904523536028747135266249775;
$ELSE
my_pi := 3.14016408289008292431940027343666863227d;
my_e := 2.71828182845904523536028747135266249775d;
$END
END my_pkg;
/
CREATE PROCEDURE circle_area(radius my_pkg.my_real) IS
my_area my_pkg.my_real;
my_datatype VARCHAR2(30);
BEGIN
my_area := my_pkg.my_pi * radius;
DBMS_OUTPUT.PUT_LINE('Radius: ' || TO_CHAR(radius)
|| ' Area: ' || TO_CHAR(my_area) );
$IF $$my_debug $THEN -- if my_debug is TRUE, run some debugging code
SELECT DATA_TYPE INTO my_datatype FROM USER_ARGUMENTS
WHERE OBJECT_NAME = 'CIRCLE_AREA' AND ARGUMENT_NAME = 'RADIUS';
DBMS_OUTPUT.PUT_LINE('Datatype of the RADIUS argument is: ' || my_datatype);
$END
END;
/
If you want to set my_debug to TRUE, you can make this change only for procedure
circle_area with the REUSE SETTINGS clause as shown in Example 2–35.
Example 2–35 Using ALTER PROCEDURE to Set PLSQL_CCFLAGS
ALTER PROCEDURE circle_area COMPILE PLSQL_CCFLAGS = 'my_debug:TRUE'
REUSE SETTINGS;
Null Value Treatement –

SQL> SELECT id, first_name, last_name, NVL(first_name, 'Unknown First Name') FROM employee;

Printing – Defining Variable

SQL> VARIABLE average_salary NUMBER;
SQL>
SQL> UPDATE employee
  2  SET salary =  salary * 0.75
  3  RETURNING AVG(salary) INTO :average_salary;

8 rows updated.

SQL>
SQL> PRINT average_salary;

AVERAGE_SALARY
--------------
    3053.81875

SQL> SET SERVEROUTPUT ON ESCAPE OFF
SQL>
SQL> DECLARE
  2     v_salary employee.salary%TYPE;
  3  BEGIN
  4
  5     SELECT salary
  6     INTO v_salary
  7     FROM employee
  8     WHERE id = '07';
  9
 10     DBMS_OUTPUT.PUT_LINE('The original salary for id 7 was: '||v_salary);
 11
 12     v_salary := v_salary * .9;
 13
 14     UPDATE employee
 15     SET salary = v_salary
 16     WHERE id = '07';
 17
 18     DBMS_OUTPUT.PUT_LINE(CHR(0));
 19  --   DBMS_OUTPUT.PUT_LINE('The new salary for id 7 is: '||v_salary);
 20
 21  EXCEPTION
 22     WHEN OTHERS
 23        THEN DBMS_OUTPUT.PUT_LINE (SQLERRM);
 24  END;
 25  /
The original salary for id 7 was: 7897.78

PL/SQL procedure successfully completed.

Using the SQL Operators

The SQL operators allow you to limit rows based on

1. pattern matching of strings,

2. lists of values,
 3. ranges of values, and
4. null values.

The SQL operators are listed in the following table:

Operator Description
LIKE Matches patterns in strings
IN Matches lists of values
BETWEEN Matches a range of values
IS NULL Matches null values
IS NAN New for Oracle10g. Matches the NaN special value, which means "not a number"
IS INFINITE New for Oracle10g. Matches infinite BINARY_FLOAT and BINARY_DOUBLE values

You can also use the NOT operator to reverse the meaning of LIKE, IN, BETWEEN, and IS NULL:

1. NOT LIKE
2. NOT IN
3. NOT BETWEEN
4. IS NOT NULL
5. IS NOT NAN
6. IS NOT INFINITE

SQL>
SQL> SELECT COUNT(*) num_owned, a.owner
  2      FROM dba_objects a
  3      WHERE 10<(SELECT COUNT(*) FROM dba_objects b
  4      WHERE a.owner=b.owner)
  5      GROUP BY a.owner;

 NUM_OWNED OWNER
---------- ------------------------------
       473 MDSYS
      1143 FLOWS_020100
      2769 PUBLIC
       575 JAVA2S
       339 CTXSYS
        34 HR
        12 FLOWS_FILES
       449 SYSTEM
        46 DBSNMP
       668 XDB
      6631 SYS

11 rows selected.

Subquery with comparison operator

SQL>
SQL>
SQL> SELECT COUNT(*) num_owned, a.owner
  2      FROM dba_objects a
  3      WHERE 100<(SELECT COUNT(*) FROM dba_objects b
  4      WHERE a.owner=b.owner)
  5      GROUP BY a.owner;

 NUM_OWNED OWNER
---------- ------------------------------
       473 MDSYS
      1143 FLOWS_020100
      2769 PUBLIC
       575 JAVA2S
       339 CTXSYS
       449 SYSTEM
       668 XDB
      6631 SYS

8 rows selected.

SQL> SELECT COUNT(*) num_owned, a.owner
  2      FROM dba_objects a
  3      WHERE 10<(SELECT COUNT(*) FROM dba_objects b
  4      WHERE a.owner=b.owner)
  5      GROUP BY a.owner;

select *
  2  from  (select empno, msal
  3         from   history
  4         order  by msal desc)
  5  where  rownum <= 3;

SQL> select job, ename
  2  ,      case
  3           when msal <= 2500
  4           then 'cheap'
  5           else 'expensive'
  6         end         as class
  7  from   employees
  8  where  bdate < date '1964-01-01'
  9  order  by case job
 10            when 'DIRECTOR' then 1
 11            when 'MANAGER'  then 2
 12                            else 3
 13            end;