Oracle for Absolute Beginners: Part 5 –

PL/SQL
A wise man* once said, all software programming is about hoops and loops. You take some

variables, give them hoops to jump through and, depending on their success or failure, you give

them some actions to loop through a number of times. Might sound basic, but that’s what all

software code – from Angry Birds to the space shuttle –

A wise man* once said, all software programming is about hoops and loops. You take
some variables, give them hoops to jump through and, depending on their success or
failure, you give them some actions to loop through a number of times.
Might sound basic, but that’s what all software code – from Angry Birds to the space
shuttle – consists of: hoops and loops.
Let me show you how.
[*that wise man was me, by the way]
PL/SQL
But first I must introduce you to PL/SQL.
PL/SQL is Oracle’s procedural language extension to SQL. You know how I said
programming is taking variables, giving them hoops to jump through and actions to loop
through a number of times? SQL is the language of those actions (select, update, delete,
insert), but it’s PL/SQL that brings the hoops and loops to the carnival.
SQL is great, but if we want to apply logic to our actions, we need more than it can give us,
and that’s where PL/SQL comes in.
Let me give you a scenario. You’ve decided to throw a party and want to invite all your
friends. You know you’ve got all their addresses in your database, and you know how to
write a select statement to get their names and to get their addresses. But some of your
friends live together: instead of writing “I would like to invite Chandler to my party” you
would want to write “I would like to invite Chandler and Monica to my party”.
SQL can’t help you; you need PL/SQL.
Let me show you how.
Anonymous Blocks
But first I must introduce you to anonymous blocks.
Thus far – in SQL-land – we have executed each action individually, statement by
statement. In order to group actions together in PL/SQL, we put them in something called
a block. This way, we can ask Oracle to simply execute the block and it will run all the
statements in that block in sequence.
Blocks are structured as follows:
DECLARE
<Variable declaration section> (Optional)
BEGIN
<Statements>
END;
We haven’t talked about variables yet, so I’d best tell you what they are. A variable is a
named storage location which can contain a value. Let me give you an example: if we
wanted to find out how many of our friends live with Joey Tribiani, we could write a select
statement to find out the address_id of Joey’s residence, store that address_id in a
variable, and then use that variable to find the friend_id of anyone else who lived at that
address.  So variables, in effect, are kinda like Tupperware that you can store values in.
In the declaration section of our block, we must define all the variables that we plan to use:
if our block doesn’t need any variables, this section does not need to exist.
To define a variable, we must give it a name, tell Oracle its datatype and,
optionally, initialize it with a value (i.e. give it an initial value).
The main body of our block starts with BEGIN and, obviously, must exist.
Let’s go back to our Joey Tribiani example and I’ll show you what I mean.
DECLARE
v_addr_id      NUMBER;
v_joey_id       NUMBER;
v_friend_count   NUMBER;
BEGIN
-- Find out Joey’s address id and put it in our variable.
SELECT fa.address_id, fn.friend_id
INTO v_addr_id, v_joey_id
FROM friend_name fn, friend_address fa
WHERE fn.friend_id = fa.friend_id
AND UPPER(fn.LAST_name) = 'TRIBIANI';

/*
Now we have the address_id, find out how many other friends live
there.
We need to exclude Joey himself from our count, obviously.
*/

SELECT COUNT(*)
INTO v_friend_count
FROM friend_address
WHERE address_id = v_addr_id
AND friend_id <> v_joey_id;

-- The number of friends is in our variable. Print it out to the

screen.
DBMS_OUTPUT.PUT_LINE('The number of friends that live with Joey
is '||v_friend_count);
 END;
There are a few things I’d like you to note.
 Hopefully, the point of the declaration section is now clear. We defined 3 variables (they all
happen to be of the number datatype, but they could just as easily be dates or varchar2).
We gave them sensible names; I followed the convention of prefixing variable names with
v_.
 In PL/SQL you can SELECT … INTO a variable. This puts the return value into the variable.
(This method of populating variables is fraught with dangers; we’ll talk about them later.)
There are a few other, incidental, things that I would like you to note too:
  You can comment single lines using the double-dash (–). To comment multiple lines we put
a /* before the comment, and end it with a */.
 Dbms_output.put_line() is a function that prints text to the screen. With SQL, we could
simply run our query and view our output; not so with PL/SQL. Try commenting out the
dbms_output.put_line() line and rerunning your anonymous block, and see what output you
get.
 You can concatenate (in other words, join) multiple strings using the double-pipe (||).
Notice how, in our output line, we use it to print some words with v_friend_count.
Loops
But what if we didn’t want a count of the people who have lived with Joey? What if we
wanted to loop through each one printing out their name?
Let’s start with a definition, even though you probably don’t need one at this point. A loop
controls the execution flow of a program and causes it to iterate through some actions a
specified number of times or until a specified condition is met.
When it comes to loops, Oracle have spoilt us for choice. It’s like Ben and Jerry’s Ice Cream
– there’s a flavour for every occasion and every taste. Let me show you.
Booleans
But first I must introduce you to Booleans.
The Boolean – named after the great 19th Century mathematician George Boole, about
whom I know absolutely nothing – is a datatype that represents a logical value: TRUE or
FALSE. (Or NULL.)
Similar to VARCHAR2s, NUMBERs and DATEs, you can create BOOLEAN variables in
PL/SQL and assign values to them (more on value assignment later). But Booleans are
useful beyond that. Think about it: every logical expression is a Boolean expression. Want
an example? The statement Mike Tyson is a man resolves to TRUE (I dare you to tell him
he’s a little girl to his face). And the statement 2 + 2 = 5 is FALSE. And you know those
WHERE statements that we use in SELECTs, DELETEs and UPDATEs? They’re just
Booleans too: select/delete/update rows from a table where these conditions are TRUE.
Booleans, explicitly or implicitly, are all over PL/SQL. Now that I’ve told you about them,
you’ll start noticing them everywhere.
But, for now, let’s get back to those loops of ours.
Loops cont’d
As I said, there are a few different types of loops, each suited to different scenarios. Below
is the names and syntax of a few of them:
Simple loops LOOP<<actions to carry Simple loops must contain an
out>>EXIT;END LOOP; EXIT or they will loop
endlessly; the EXIT will
usually only be called when a
specific condition is
TRUE.Simple loops always
run at least once.
While loops WHILE <<Boolean While loops iterate for as
expression>> long as the Boolean
LOOP<<actions to carry expression is TRUE. The
out>>END LOOP; expression is tested with
each new iteration.While
loops may not iterate even
once if the Boolean
expression is FALSE from
the start.
For loops FOR indx IN A For Loop will run n times.
1 .. n LOOP<<actions to
carry out>>END LOOP;
Cursor loops For (SELECT statement) This loop will iterate once
LOOP<<actions to carry for every record returned in
out>>END LOOP; the select statement.These
loops are useful in cases
where you want to use the
values selected in your query
in the loop actions.Are we
allowed to have favourites?
This is the loop I use 80% of
the time.
Now that we’ve met the different types of loops, let me show you how to use them.
Value Assignment
But first I must introduce you to value assignment.
You’ll remember that I said that variables are like Tupperware containers that we store
values in. And I showed you how, using SELECT … INTO, we can put values into our
variables. However, this is not the only – or even the most popular – way of assigning
values in PL/SQL. That honour goes to the following symbol:
:=
Here are some examples of it in use (assume that we have already declared our variables
v_number, v_varchar2, v_date and v_boolean):
v_number := 12;
v_number := 2 * 2;
v_number := v_number + 21;

v_varchar2 := 'Mike Tyson is a snotty little girl';

v_varchar2 := 'I am going to concatenate this string'||' with this
one';

v_date := SYSDATE;
v_date := SYSDATE + 365;

v_boolean := TRUE; -- TRUE is a Boolean value; 'TRUE' is a

varchar2 string.
v_boolean := FALSE;
It is important to point out that the assignment symbol (:=) is completely different from the
equals to sign in PL/SQL. In PL/SQL we use the equals to sign to create Boolean
expressions (2+2=4 is TRUE); to assign values to variables we always use :=.
Loops cont’d
Let’s write an anonymous block in which we loop through all the addresses in our
ADDRESS table and print out the names of the people who have ever lived there.
DECLARE
v_string VARCHAR2(500); -- when declaring a varchar2
variable you must specify its size. This one can take 500
characters.

BEGIN
-- Loop round all our addresses.
FOR i IN (SELECT *
FROM address) LOOP
v_string := 'Apartment '||i.apartment||', '||
i.house_no||' '||i.street||', '||i.city||' '||i.zipcode;
dbms_output.put_line(v_string);

-- Now let's find everyone who has lived at this

address.
FOR j IN (SELECT fn.first_name, fn.last_name
FROM friend_name fn,
friend_address fa
WHERE fa.address_id =
i.address_id
AND fn.friend_id = fa.friend_id)
LOOP

v_string := j.first_name||' '||

j.last_name;
dbms_output.put_line(v_string);
END LOOP;
END LOOP;
END;
Did you notice how we just nested a loop inside another loop? That’s why, for every
iteration of the Address loop (for which we have used the index i) we carry out multiple
iterations of the Friend name loop (for which we’ve used the index j. When you nest loops
you’ve got to use different indexes). Notice also how, to reference the columns selected in
the loop, we precede them with the index name.
Conditional statements
I promised you loops and hoops. It’s time to meet the hoops.
Conditional statements are, well, exactly what they sound like. We test a Boolean
statement and, depending on if it proves to be TRUE or FALSE, we carry out some
actions. If the weatherman says it’s going to rain, then we take an umbrella. If the time is
not yet half past five, then  we stay in the office. And if you’re paying, then  of course I’m
gonna have another drink!
The syntax for If statements in PL/SQL is as follows:
IF <Boolean statement> THEN
<actions>
END IF;
IF <Boolean condition> THEN
<actions>
ELSE
<actions>
END IF;
IF <Boolean condition> THEN
<actions>
ELSIF <Boolean condition> THEN
<actions>
ELSE
<actions>
END IF;
The kind of if statement you use depends, of course, on what you want to do. Sometimes
you will want to carry out an action if a condition is true, and do nothing otherwise; other
times you may want to carry out some actions if a condition is true, and other actions if it’s
false.
An example might help.  What if, rather than list the name of everyone who lives at an
address in our previous anonymous block, we want to differentiate between people who
currently live there and those who used to live there.
DECLARE
v_address VARCHAR2(500);
v_curr_resident VARCHAR2(32767);
v_past_resident VARCHAR2(32767);

BEGIN
-- Loop round all our addresses.
FOR i IN (SELECT *
FROM address) LOOP
v_address := 'Apartment '||i.apartment||', '||
i.house_no||' '||i.street||', '||i.city||' '||i.zipcode;
dbms_output.put_line(v_address);

v_curr_resident := NULL;
v_past_resident := NULL;
 -- Now let's find everyone who has lived at this
address.
FOR j IN (SELECT fn.first_name, fn.last_name,
fa.moved_in, fa.moved_out
FROM friend_name fn,
friend_address fa
WHERE fa.address_id =
i.address_id
AND fn.friend_id = fa.friend_id)
LOOP

IF (j.moved_out IS NULL OR
j.moved_out >= SYSDATE) THEN -- current resident.
IF v_curr_resident IS NULL
THEN
-- because the
variable is null, we know this is the first current resident for
this address.
v_curr_resident :=
j.first_name||' '||j.last_name;
ELSE
-- this isn't the
first current resident; concatenate so we don't overwrite the
previous name.
v_curr_resident :=
v_curr_resident||CHR(10)||CHR(9)||j.first_name||' '||j.last_name;
-- chr(10) is a line break. chr(9) is a tab.
END IF;
ELSE -- past residents
IF v_past_resident IS NULL
THEN
-- because the
variable is null, we know this is the first current resident for
this address.
v_past_resident :=
j.first_name||' '||j.last_name;
ELSE
-- this isn't the
first past resident; concatenate so we don't overwrite the
previous name.
v_past_resident :=
v_past_resident||CHR(10)||CHR(9)||j.first_name||' '||j.last_name;
END IF;
END IF;

END LOOP;

-- let's print out the names we've found.

IF v_curr_resident IS NOT NULL THEN
dbms_output.put_line(CHR(9)||'The following
friends live at this address.');
dbms_output.put_line(CHR(9)||v_curr_resident);
END IF;

IF v_past_resident IS NOT NULL THEN

 dbms_output.put_line(CHR(9)||'The following
friends used to live at this address.');
dbms_output.put_line(CHR(9)||v_past_resident);
END IF;
END LOOP;
END;
Conclusion
So there you have it: hoops and loops. Conditional and iterative statements. PL/SQL, the
procedural icing on the SQL cake.
But that’s not all there is to PL/SQL. Next time we’ll talk about functions and procedures.
But for now, I’d like you to try writing a few more anonymous blocks. How about you loop
through the records in the FRIEND_NAME table and print out your male and female friends
in separate lists? And remember how I was talking about printing out a list of each person
at each address and concatenating their names (as in Chandler and Monica)? I’ve run out
of space, but why don’t you do it?
 

Next Article: Oracle for Absolute Beginners: Part 6 – Procedures and Functions