Practices in the Course

As you perform practices in the course, you will develop a simple application using an
anonymous block. This anonymous block covers the following:
• Writing a declarative section
• Declaring variables of scalar types
• Declaring variables using the %TYPE attribute
• Writing an executable section
• Accepting user inputs for variables
• Retrieving the values from the database and storing the values in the variables by using
the INTO clause
• Writing a nested block within the executable section
• Using the control structures in the executable section to perform business logic
• Using the INDEX BY table to store values and print them
• Handling exceptions

What Is the Functionality of This Application?

This application is a simple HR application and only employees working in the Human
Resources department are authorized to use it. In the employees table, only one employee
is in the HR department. Therefore, you can use employee_id for authentication.
The company has decided to provide salary raises to employees in some of the departments
this quarter. The company has decided the raise percentage depending on the current
salaries. Employees in the following departments are eligible for raises this quarter:

department_id department_name

20 Marketing

60 IT

80 Sales

100 Finance

110 Accounting

The salary range and the raise percentage are as follows:

salary Raise percentage

< 6500 20
> 6500 < 9500 15
> 9500 <12000 8
>12000 3

Oracle Database 10g: PL/SQL Fundamentals I-14

Practice 1
Before you begin this practice, please ensure that you have seen both the viewlets on
iSQL*Plus usage.
The labs folder will be your working directory. You can save your scripts in the labs
folder. Please take the instructor’s help to locate the labs folder for this course. The
solutions for all practices are in the soln folder.

1. Which of the following PL/SQL blocks execute successfully?

a. BEGIN
END;

b. DECLARE
amount INTEGER(10);
END;

c. DECLARE
BEGIN
END;

d. DECLARE
amount INTEGER(10);
BEGIN
DBMS_OUTPUT.PUT_LINE(amount);
END;

2. Create and execute a simple anonymous block that outputs “Hello World.” Execute
and save this script as lab_01_02_soln.sql.

Oracle Database 10g: PL/SQL Fundamentals 1-25

Practice 2
1. Identify valid and invalid identifier names:
a. today
b. last_name
c. today’s_date
d. Number_of_days_in_February_this_year
e. Isleap$year
f. #number
g. NUMBER#
h. number1to7

2. Identify valid and invalid variable declaration and initialization:

a. number_of_copies PLS_INTEGER;
b. printer_name constant VARCHAR2(10);
c. deliver_to VARCHAR2(10):=Johnson;
d. by_when DATE:= SYSDATE+1;

3. Examine the following anonymous block and choose the appropriate statement.
SET SERVEROUTPUT ON
DECLARE
fname VARCHAR2(20);
lname VARCHAR2(15) DEFAULT 'fernandez';
BEGIN
DBMS_OUTPUT.PUT_LINE( FNAME ||' ' ||lname);
END;
/
a. The block will execute successfully and print ‘fernandez’
b. The block will give an error because the fname variable is used without
initializing.
c. The block will execute successfully and print ‘null fernandez’
d. The block will give an error because you cannot use the DEFAULT keyword to
initialize a variable of type VARCHAR2.
e. The block will give an error because the variable FNAME is not declared.

4. Create an anonymous block. In iSQL*Plus, load the script lab_01_02_soln.sql,

which you created in question 2 of practice 1.
a. Add a declarative section to this PL/SQL block. In the declarative section
declare the following variables:
1. Variable today of type DATE. Initialize today with SYSDATE.
2. Variable tomorrow of type today. Use %TYPE attribute to declare this
variable.
b. In the executable section initialize the variable tomorrow with an expression
which calculates tomorrow’s date (add one to the value in today). Print the
value of today and tomorrow after printing ‘Hello World’

Oracle Database 10g: PL/SQL Fundamentals 2-37

Practice 2 (continued)
c. Execute and save this script as lab_02_04_soln.sql. Sample output is
shown below.

5. Edit the lab_02_04_soln.sql script.

a. Add code to create two bind variables.
Create bind variables basic_percent and pf_percent of type NUMBER.
b. In the executable section of the PL/SQL block assign the values 45 and 12 to
basic_percent and pf_percent respectively.
c. Terminate the PL/SQL block with “/” and display the value of the bind variables
by using the PRINT command.
d. Execute and save your script file as lab_02_05_soln.sql. Sample output is
shown below.

Click the Next Page button.

Oracle Database 10g: PL/SQL Fundamentals 2-38

Practice 3
PL/SQL Block
DECLARE
weight NUMBER(3) := 600;
message VARCHAR2(255) := 'Product 10012';
BEGIN
DECLARE
weight NUMBER(3) := 1;
message VARCHAR2(255) := 'Product 11001';
new_locn VARCHAR2(50) := 'Europe';
BEGIN
weight := weight + 1;
new_locn := 'Western ' || new_locn;
1 END;
weight := weight + 1;
message := message || ' is in stock';
new_locn := 'Western ' || new_locn;
2 END;
/

1. Evaluate the PL/SQL block given above and determine the data type and value of each
of the following variables according to the rules of scoping.
a. The value of weight at position 1 is:

b. The value of new_locn at position 1 is:

c. The value of weight at position 2 is:

d. The value of message at position 2 is:

e. The value of new_locn at position 2 is:

Oracle Database 10g: PL/SQL Fundamentals 3-24

Practice 3 (continued)
Scope Example
DECLARE
customer VARCHAR2(50) := 'Womansport';
credit_rating VARCHAR2(50) := 'EXCELLENT';
BEGIN
DECLARE
customer NUMBER(7) := 201;
name VARCHAR2(25) := 'Unisports';
BEGIN
credit_rating :='GOOD';
…
END;
…
END;
/

2. In the PL/SQL block shown above, determine the values and data types for each of the
following cases.
a. The value of customer in the nested block is:

b. The value of name in the nested block is:

c. The value of credit_rating in the nested block is:

d. The value of customer in the main block is:

e. The value of name in the main block is:

f. The value of credit_rating in the main block is:

Oracle Database 10g: PL/SQL Fundamentals 3-25

Practice 3 (continued)
3. Use the same session that you used to execute the practices in Lesson 2. If you have
opened a new session, then execute lab_02_05_soln.sql. Edit
lab_02_05_soln.sql.
a. Use single line comment syntax to comment the lines that create the bind
variables.
b. Use multiple line comments in the executable section to comment the lines that
assign values to the bind variables.
c. Declare two variables: fname of type VARCHAR2 and size 15, and emp_sal of
type NUMBER and size 10.
d. Include the following SQL statement in the executable section:
SELECT first_name, salary
INTO fname, emp_sal FROM employees
WHERE employee_id=110;
e. Change the line that prints ‘Hello World’ to print ‘Hello’ and the first name. You
can comment the lines that display the dates and print the bind variables, if you
want to.
f. Calculate the contribution of the employee towards provident fund (PF).
PF is 12% of the basic salary and basic salary is 45% of the salary. Use the bind
variables for the calculation. Try and use only one expression to calculate the PF.
Print the employee’s salary and his contribution towards PF.
g. Execute and save your script as lab_03_03_soln.sql. Sample output is
shown below.

4. Accept a value at run time using the substitution variable. In this practice, you will
modify the script that you created in exercise 3 to accept user input.
a. Load the script lab_03_04.sql file.
b. Include the PROMPT command to prompt the user with the following message:
‘Please enter your employee number.’
c. Modify the declaration of the empno variable to accept the user input.
d. Modify the select statement to include the variable empno.
e. Execute and save your script as lab_03_04_soln.sql. Sample output is
shown below.

Oracle Database 10g: PL/SQL Fundamentals 3-26

Practice 3 (continued)

Enter 100 and click the Continue button.

5. Execute the script lab_03_05.sql. This script creates a table called

employee_details.
a. The employee and employee_details tables have the same data. You will
update the data in the employee_details table. Do not update or change the
data in the employees table.
b. Open the script lab_03_05b.sql and observe the code in the file. Note that
the code accepts the employee number and the department number from the user.
c. You will use this as the skeleton script to develop the application, which was
discussed in the lesson titled “Introduction.”

Oracle Database 10g: PL/SQL Fundamentals 3-27

Practice 4
1. Create a PL/SQL block that selects the maximum department ID in the
departments table and stores it in the max_deptno variable. Display the
maximum department ID.
a. Declare a variable max_deptno of type NUMBER in the declarative section.
b. Start the executable section with the keyword BEGIN and include a SELECT
statement to retrieve the maximum department_id from the departments
table.
c. Display max_deptno and end the executable block.
d. Execute and save your script as lab_04_01_soln.sql. Sample output is
shown below.

2. Modify the PL/SQL block you created in exercise 1 to insert a new department into the
departments table.
a. Load the script lab_04_01_soln.sql. Declare two variables:
dept_name of type department.department_name.
Bind variable dept_id of type NUMBER.
Assign ‘Education’ to dept_name in the declarative section.
b. You have already retrieved the current maximum department number from the
departments table. Add 10 to it and assign the result to dept_id.
c. Include an INSERT statement to insert data into the department_name,
department_id, and location_id columns of the departments table.
Use values in dept_name, dept_id for department_name,
department_id and use NULL for location_id.
d. Use the SQL attribute SQL%ROWCOUNT to display the number of rows that are
affected.
e. Execute a select statement to check if the new department is inserted. You can
terminate the PL/SQL block with “/” and include the SELECT statement in your
script.
f. Execute and save your script as lab_04_02_soln.sql. Sample output is
shown below.

Oracle Database 10g: PL/SQL Fundamentals 4-25

Practice 4 (continued)
3. In exercise 2, you have set location_id to null. Create a PL/SQL block that
updates the location_id to 3000 for the new department. Use the bind variable
dept_id to update the row.
Note: Skip step a if you have not started a new iSQL*Plus session for this practice.
a. If you have started a new iSQL*Plus session, delete the department that you have
added to the departments table and execute the script
lab_04_02_soln.sql.
b. Start the executable block with the keyword BEGIN. Include the UPDATE
statement to set the location_id to 3000 for the new department. Use the
bind variable dept_id in your UPDATE statement.
c. End the executable block with the keyword END. Terminate the PL/SQL block
with “/” and include a SELECT statement to display the department that you
updated.
d. Finally include a DELETE statement to delete the department that you added.
e. Execute and save your script as lab_04_03_soln.sql. Sample output is
shown below.

4. Load the script lab_03_05b.sql to the iSQL*Plus workspace.

a. Observe that the code has nested blocks. You will see the declarative section of
the outer block. a. Look for the comment “INCLUDE EXECUTABLE
SECTION OF OUTER BLOCK HERE” and start an executable section
b. Include a single SELECT statement, which retrieves the employee_id of the
employee working in the ‘Human Resources’ department. Use the INTO clause
to store the retrieved value in the variable emp_authorization.
c. Save your script as lab_04_04_soln.sql.

Oracle Database 10g: PL/SQL Fundamentals 4-26

Practice 5
1. Execute the command in the file lab_05_01.sql to create the messages table.
Write a PL/SQL block to insert numbers into the messages table.
a. Insert the numbers 1 to 10, excluding 6 and 8.
b. Commit before the end of the block.
c. Execute a SELECT statement to verify that your PL/SQL block worked.
You should see the following output.

2. Execute the script lab_05_02.sql. This script creates an emp table that is a replica
of the employees table. It alters the emp table to add a new column, stars, of
VARCHAR2 data type and size 50. Create a PL/SQL block that inserts an asterisk in the
stars column for every $1000 of the employee’s salary. Save your script as
lab_05_02_soln.sql.
a. Use the DEFINE command to define a variable called empno and initialize it to
176.
b. Start the declarative section of the block and pass the value of empno to the
PL/SQL block through an iSQL*Plus substitution variable. Declare a variable
asterisk of type emp.stars and initialize it to NULL. Create a variable
sal of type emp.salary.
c. In the executable section write logic to append an asterisk (*) to the string for
every $1000 of the salary amount. For example, if the employee earns $8000, the
string of asterisks should contain eight asterisks. If the employee earns $12500,
the string of asterisks should contain 13 asterisks.
d. Update the stars column for the employee with the string of asterisks. Commit
before the end of the block.

Oracle Database 10g: PL/SQL Fundamentals 5-31

Practice 5 (continued)
e. Display the row from the emp table to verify whether your PL/SQL block has
executed successfully.
f. Execute and save your script as lab_05_02_soln.sql. The output is shown
below.

3. Load the script lab_04_04_soln.sql, which you created in question 4 of

Practice 4.
a. Look for the comment “INCLUDE SIMPLE IF STATEMENT HERE” and
include a simple IF statement to check if the values of emp_id and
emp_authorization are the same.
b. Save your script as lab_05_03_soln.sql.

Oracle Database 10g: PL/SQL Fundamentals 5-32

Practice 6
1. Write a PL/SQL block to print information about a given country.
a. Declare a PL/SQL record based on the structure of the countries table.
b. Use the DEFINE command to define a variable countryid. Assign CA to
countryid. Pass the value to the PL/SQL block through an iSQL*Plus
substitution variable.
c. In the declarative section, use the %ROWTYPE attribute and declare the variable
country_record of type countries.
d. In the executable section, get all the information from the countries table by
using countryid. Display selected information about the country. A sample
output is shown below.

e. You may want to execute and test the PL/SQL block for the countries with the
IDs DE, UK, US.

2. Create a PL/SQL block to retrieve the name of some departments from the
departments table and print each department name on the screen, incorporating an
INDEX BY table. Save the script as lab_06_02_soln.sql.
a. Declare an INDEX BY table dept_table_type of type
departments.department_name. Declare a variable my_dept_table
of type dept_table_type to temporarily store the name of the departments.
b. Declare two variables: loop_count and deptno of type NUMBER. Assign 10
to loop_count and 0 to deptno.
c. Using a loop, retrieve the name of 10 departments and store the names in the
INDEX BY table. Start with department_id 10. Increase deptno by 10 for
every iteration of the loop. The following table shows the department_id for
which you should retrieve the department_name and store in the INDEX BY
table.

Oracle Database 10g: PL/SQL Fundamentals 6-29

Practice 6 (continued)

DEPARTMENT_ID DEPARTMENT_NAME
10 Administration
20 Marketing
30 Purchasing
40 Human Resources
50 Shipping
60 IT
70 Public Relations
80 Sales
90 Executive
100 Finance

d. Using another loop, retrieve the department names from the INDEX BY table and
display them.
e. Execute and save your script as lab_06_02_soln.sql. The output is shown
below.

Oracle Database 10g: PL/SQL Fundamentals 6-30

Practice 6 (continued)
3. Modify the block that you created in question 2 to retrieve all information about each
department from the departments table and display the information. Use an
INDEX BY table of records.
a. Load the script lab_06_02_soln.sql.
b. You have declared the INDEX BY table to be of type
departments.department_name. Modify the declaration of the INDEX
BY table, to temporarily store the number, name, and location of the departments.
Use the %ROWTYPE attribute.
c. Modify the select statement to retrieve all department information currently in
the departments table and store it in the INDEX BY table.
d. Using another loop, retrieve the department information from the INDEX BY
table and display the information. A sample output is shown below.

4. Load the script lab_05_03_soln.sql.

a. Look for the comment “DECLARE AN INDEX BY TABLE OF TYPE
VARCHAR2(50). CALL IT ename_table_type” and include the declaration.
b. Look for the comment “DECLARE A VARIABLE ename_table OF TYPE
ename_table_type” and include the declaration.
c. Save your script as lab_06_04_soln.sql.

Oracle Database 10g: PL/SQL Fundamentals 6-31

Practice 7
1. Create a PL/SQL block that determines the top n salaries of the employees.
a. Execute the script lab_07_01.sql to create a new table, top_salaries,
for storing the salaries of the employees.
b. Accept a number n from the user where n represents the number of top n earners
from the employees table. For example, to view the top five salaries, enter 5.
Note: Use the DEFINE command to define a variable p_num to provide the
value for n. Pass the value to the PL/SQL block through an iSQL*Plus
substitution variable.
c. In the declarative section, declare two variables: num of type NUMBER to accept
the substitution variable p_num, sal of type employees.salary. Declare a
cursor, emp_cursor, that retrieves the salaries of employees in descending
order. Remember that the salaries should not be duplicated.
d. In the executable section, open the loop and fetch top n salaries and insert them
into top_salaries table. You can use a simple loop to operate on the data.
Also, try and use %ROWCOUNT and %FOUND attributes for the exit condition.
e. After inserting into the top_salaries table, display the rows with a SELECT
statement. The output shown represents the five highest salaries in the
employees table.

f. Test a variety of special cases, such as n = 0 or where n is greater than the

number of employees in the employees table. Empty the top_salaries
table after each test.
2. Create a PL/SQL block that does the following:
a. Use the DEFINE command to define a variable p_deptno to provide the
department ID.
b. In the declarative section, declare a variable deptno of type NUMBER and
assign the value of p_deptno.
c. Declare a cursor, emp_cursor, that retrieves the last_name, salary, and
manager_id of the employees working in the department specified in
deptno.

Oracle Database 10g: PL/SQL Fundamentals 7-29

Practice 7 (continued)
d. In the executable section use the cursor FOR loop to operate on the data
retrieved. If the salary of the employee is less than 5000 and if the manager ID is
either 101 or 124, display the message <<last_name>> Due for a raise.
Otherwise, display the message <<last_name>> Not due for a raise.
e. Test the PL/SQL block for the following cases:

Department ID Message
10 Whalen Due for a raise
20 Hartstein Not Due for a raise
Fay Not Due for a raise
50 Weiss Not Due for a raise
Fripp Not Due for a raise
Kaufling Not Due for a raise
Vollman Not Due for a raise
Mourgas Not Due for a raise
. . .
. . .
Rajs Due for a raise
80 Russel Not Due for a raise
Partners Not Due for a raise
Errazuriz Not Due for a raise
Cambrault Not Due for a raise
. . .
. . .

Oracle Database 10g: PL/SQL Fundamentals 7-30

Practice 7 (continued)
3. Write a PL/SQL block, which declares and uses cursors with parameters.
In a loop, use a cursor to retrieve the department number and the department name
from the departments table for a department whose department_id is less than
100. Pass the department number to another cursor as a parameter to retrieve from the
employees table the details of employee last name, job, hire date, and salary of
those employees whose employee_id is less than 120 and who work in that
department.
a. In the declarative section declare a cursor dept_cursor to retrieve
department_id, department_name for those departments with
department_id less than 100. Order by department_id.
b. Declare another cursor emp_cursor that takes the department number as
parameter and retrieves last_name, job_id, hire_date, and salary of
those employees with employee_id of less than 120 and who work in that
department.
c. Declare variables to hold the values retrieved from each cursor. Use the %TYPE
attribute while declaring variables.
d. Open the dept_cursor, use a simple loop and fetch values into the variables
declared. Display the department number and department name.
e. For each department, open the emp_cursor by passing the current department
number as a parameter. Start another loop and fetch the values of emp_cursor
into variables and print all the details retrieved from the employees table.
Note: You may want to print a line after you have displayed the details of each
department. Use appropriate attributes for the exit condition. Also check if a
cursor is already open before opening the cursor.
f. Close all the loops and cursors, and end the executable section. Execute the
script.

Oracle Database 10g: PL/SQL Fundamentals 7-31

Practice 7 (continued)
The sample output is shown below.

Oracle Database 10g: PL/SQL Fundamentals 7-32

Practice 7 (continued)
4. Load the script lab_06_04_soln.sql.
a. Look for the comment “DECLARE A CURSOR CALLED emp_records TO
HOLD salary, first_name, and last_name of employees” and include the
declaration. Create the cursor such that it retrieves the salary, first_name, and
last_name of employees in the department specified by the user (substitution
variable emp_deptid). Use the FOR UPDATE clause.
b. Look for the comment “INCLUDE EXECUTABLE SECTION OF INNER
BLOCK HERE” and start the executable block.
c. Only employees working in the departments with department_id 20, 60,
80,100, and 110 are eligible for raises this quarter. Check if the user has entered
any of these department IDs. If the value does not match, display the message
“SORRY, NO SALARY REVISIONS FOR EMPLOYEES IN THIS
DEPARTMENT.” If the value matches, then, open the cursor emp_records.
d. Start a simple loop and fetch the values into emp_sal, emp_fname, and
emp_lname. Use %NOTFOUND for the exit condition.
e. Include a CASE expression. Use the following table as reference for the
conditions in the WHEN clause of the CASE expression.
Note: In your CASE expression use the constants such as c_range1, c_hike1
which are already declared.

salary Hike percentage

< 6500 20
> 6500 < 9500 15
> 9500 <12000 8
>12000 3

For example, if the salary of the employee is less than 6500, then increase the
salary by 20 percent. In every WHEN clause, concatenate the first_name and
last_name of the employee and store it in the INDEX BY table. Increment the
value in variable i so that you can store the string in the next location. Include an
UPDATE statement with the WHERE CURRENT OF clause.
f. Close the loop. Use the %ROWCOUNT attribute and print the number of records
that were modified. Close the cursor.
g. Include a simple loop to print the names of all the employees whose salaries were
revised.
Note: You already have the names of these employees in the INDEX BY table.
Look for the comment “CLOSE THE INNER BLOCK” and include an END IF
statement and an END statement.
h. Save your script as lab_07_04_soln.sql.

Oracle Database 10g: PL/SQL Fundamentals 7-33

Practice 8
1. The purpose of this example is to show the usage of predefined exceptions. Write a
PL/SQL block to select the name of the employee with a given salary value.
a. Delete all records in the messages table. Use the DEFINE command to define
a variable sal and initialize it to 6000.
b. In the declarative section declare two variables: ename of type
employees.last_name and emp_sal of type employees.salary.
Pass the value of the substitution variables to emp_sal.
c. In the executable section retrieve the last names of employees whose salaries are
equal to the value in emp_sal.
Note: Do not use explicit cursors.
If the salary entered returns only one row, insert into the messages table the
employee’s name and the salary amount.
d. If the salary entered does not return any rows, handle the exception with an
appropriate exception handler and insert into the messages table the message
“No employee with a salary of <salary>.”
e. If the salary entered returns more than one row, handle the exception with an
appropriate exception handler and insert into the messages table the message
“More than one employee with a salary of <salary>.”
f. Handle any other exception with an appropriate exception handler and insert into
the messages table the message “Some other error occurred.”
g. Display the rows from the messages table to check whether the PL/SQL block
has executed successfully. Sample output is shown below.

2. The purpose of this example is to show how to declare exceptions with a standard
Oracle server error. Use the Oracle server error ORA-02292 (integrity constraint
violated – child record found).
a. In the declarative section declare an exception childrecord_exists.
Associate the declared exception with the standard Oracle server error –02292.
b. In the executable section display ‘Deleting department 40.....’. Include a
DELETE statement to delete the department with department_id 40.

Oracle Database 10g: PL/SQL Fundamentals 8-27

Practice 8 (continued)
c. Include an exception section to handle the childrecord_exists exception
and display the appropriate message. Sample output is shown below.

3. Load the script lab_07_04_soln.sql.

a. Observe the declarative section of the outer block. Note that the
no_such_employee exception is declared.
b. Look for the comment “RAISE EXCEPTION HERE.” If the value of emp_id is
not between 100 and 206, then raise the no_such_employee exception.
c. Look for the comment “INCLUDE EXCEPTION SECTION FOR OUTER
BLOCK” and handle the exceptions no_such_employee and
too_many_rows. Display appropriate messages when the exceptions occur.
The employees table has only one employee working in the HR department and
therefore the code is written accordingly. The too_many_rows exception is
handled to indicate that the select statement retrieves more than one employee
working in the HR department.
d. Close the outer block.
e. Save your script as lab_08_03_soln.sql.
f. Execute the script. Enter the employee number and the department number and
observe the output. Enter different values and check for different conditions.
The sample output for employee ID 203 and department ID 100 is shown below.

Oracle Database 10g: PL/SQL Fundamentals 8-28

Practice 9
1. In iSQL*Plus, load the script lab_02_04_soln.sql that you created for question
4 of practice 2.
a. Modify the script to convert the anonymous block to a procedure called greet.
b. Execute the script to create the procedure.
c. Save your script as lab_09_01_soln.sql.
d. Click the Clear button to clear the workspace.
e. Create and execute an anonymous block to invoke the procedure greet. Sample
output is shown below.

2. Load the script lab_09_01_soln.sql.

a. Drop the procedure greet by issuing the following command:
DROP PROCEDURE greet
b. Modify the procedure to accept an argument of type VARCHAR2. Call the
argument name.
c. Print Hello <name> instead of printing Hello World.
d. Save your script as lab_09_02_soln.sql.
e. Execute the script to create the procedure.
f. Create and execute an anonymous block to invoke the procedure greet with a
parameter. Sample output is shown below.

Oracle Database 10g: PL/SQL Fundamentals 9-16