Databases - Stored Routines

Jianxin Li

School of Computer Science & Software Engineering

University of Western Australia

Jianxin Li (UWA) Stored routines 1 / 31

This lecture

We continue our coverage of the fundamentals of SQL/MySQL with stored

routines.

(This material will appear in the remaining lab sessions, but will not be on the
final exam.)

Jianxin Li (UWA) Stored routines 2 / 31

 Stored Routines

Stored Routines

A stored routine is a named set of SQL statements that is stored on the server
and which can be initiated by a single call.
Normally, we imagine the stored routine as being written by the DBA and
called by the client programs.
Stored routines are further subdivided into:
Stored procedures do not return anything
Stored procedures can however assign values to variables etc.
Stored functions that return values to the client

Jianxin Li (UWA) Stored routines 3 / 31

 Stored Routines

Rationale for stored routines

A stored routine is maintained on the server, which has various consequences

both positive and negative:
A complex sequence of SQL statements can be prepared once by a
professional DBA and then made available to all client programs
Stored routines can access confidential or sensitive tables without
exposing them to client programs
Processing becomes more centralized with the server taking on a greater
computational load

Jianxin Li (UWA) Stored routines 4 / 31

 Stored Routines

Basic Syntax

The basic syntax for creating the simplest possible procedure, one with no
parameters and consisting of a single SQL statement is as follows:
CREATE PROCEDURE myproc()
/* An SQL statement */

For example, in the world database we could issue the command:

CREATE PROCEDURE listCapitals()
SELECT C.name, T.name
FROM country C, city T
WHERE C.capital = T.id;

So the procedures name is listCapitals and its body is the single

SELECT statement.

Jianxin Li (UWA) Stored routines 5 / 31

 Stored Routines

Calling a user-defined procedure

CALL listCapitals();
+-----------------------------+-----------------------------------+
| name | name |
+-----------------------------+-----------------------------------+
| Aruba | Oranjestad |
| Afghanistan | Kabul |
| Angola | Luanda |
| Anguilla | The Valley |

A stored procedure belongs to a specific database, namely the one that was
being used when CREATE PROCEDURE command was issued.

Jianxin Li (UWA) Stored routines 6 / 31

 Stored Routines

Procedure parameters

In order to do anything more useful than just saving typing, a procedure will
have parameters that the user will specify on calling the procedure
CREATE PROCEDURE listOneCapital(cntry VARCHAR(50))
SELECT C.name, T.name
FROM country C, city T
WHERE C.capital = T.id
AND C.name = cntry;

This procedure has one parameter called cntry which is of type

VARCHAR(50).

Jianxin Li (UWA) Stored routines 7 / 31

 Stored Routines

Calling the procedure

When the procedure is called the caller specifies an actual value, known as
the argument to the procedure.
CALL listOneCapital(Uganda);
+--------+---------+
| name | name |
+--------+---------+
| Uganda | Kampala |
+--------+---------+

Inside the procedure, the argument in this case Uganda will be used
wherever the variable cntry occurs.

Jianxin Li (UWA) Stored routines 8 / 31

 Stored Routines

Output Parameters

A procedure has no RETURN statement and doesnt return a value to the caller.
However the caller can specify a user-variable in the parameter list and the
procedure can assign a value to that variable.
CREATE PROCEDURE regionPop(rgn TEXT, OUT rpop INT)
SELECT SUM(population)
FROM country C
WHERE C.region = rgn
INTO rpop;

The output parameter rpop is indicated by the keyword OUT and the SELECT
statement performs the selection INTO the variable.

Jianxin Li (UWA) Stored routines 9 / 31

 Stored Routines

Using output parameters

When this procedure is called the user must

Specify an actual value for each input variable
Specify a variable name for each output variable
CALL regionpop(North America, @napop);

Nothing appears on the terminal, but the variable @napop has had a value
assigned to it, which can subsequently be used.
SELECT @napop;
+-----------+
| @napop |
+-----------+
| 309632000 |
+-----------+

Jianxin Li (UWA) Stored routines 10 / 31

 Stored Routines

Multiple statements

To enhance our procedures further we need to be able to perform a sequence

of SQL statements inside a procedure, not just a single statement.
This can be done by putting the statements between BEGIN and END.
CREATE PROCEDURE myproc()
BEGIN

/* A whole bunch of MySQL statements */

END

One problem that immediately arises is how to terminate each of the

statements inside the BEGIN / END area if we just use the semicolon then
MySQL will think that the procedure definition has terminated.

Jianxin Li (UWA) Stored routines 11 / 31

 Stored Routines

Temporarily change delimiters

The solution to this is to temporarily change the delimiter so that we can enter
the entire procedure.
DELIMITER ++
CREATE PROCEDURE myproc()
BEGIN

/* A whole bunch of MySQL statements */

/* each terminated with the usual semicolon */

END++
DELIMITER ;

The first line temporarily changes the delimiter to ++, then the entire
procedure is entered, and finally the delimiter is changed back again.

Jianxin Li (UWA) Stored routines 12 / 31

 Stored Routines

Procedure Variables

Of course, in order to use multiple statements effectively it helps to be able to

use local variables within the procedure1 .
CREATE PROCEDURE regionSummary(rgn TEXT)
BEGIN
DECLARE rp INT;
CALL regionPop(rgn, rp);
END

This fragment creates a local variable called rp and then calls the previously
defined procedure to assign the total population of the specified region to that
variable.

1
Henceforth I will not include the DELIMITER statements
Jianxin Li (UWA) Stored routines 13 / 31
 Stored Routines

Multiple statements

We can complete this procedure fragment by using the variable that we have
just evaluated in a subsequent SQL statement.
CREATE PROCEDURE regionSummary(rgn TEXT)
BEGIN
DECLARE rp INT;
CALL regionPop(rgn,rp);
SELECT C.name, C.population,
C.population / rp * 100 as perc
FROM country C
WHERE C.region = rgn
ORDER BY C.population
DESC LIMIT 5;
END

This has simply added one more SELECT statement that performs another
query to list the five most populous countries in that region.

Jianxin Li (UWA) Stored routines 14 / 31

 Stored Routines

Calling this procedure

mysql> CALL regionSummary("Caribbean");

+--------------------+------------+---------+
| name | population | perc |
+--------------------+------------+---------+
| Cuba | 11201000 | 29.3681 |
| Dominican Republic | 8495000 | 22.2732 |
| Haiti | 8222000 | 21.5574 |
| Puerto Rico | 3869000 | 10.1442 |
| Jamaica | 2583000 | 6.7724 |
+--------------------+------------+---------+

Jianxin Li (UWA) Stored routines 15 / 31

 Programming Routines

Other constructs

In addition to this basic functionality, stored procedures can also perform

rudimentary selection and repetition with constructs such as
IF-THEN-ELSE
WHILE...END WHILE
REPEAT...END REPEAT
LOOP...END LOOP

Jianxin Li (UWA) Stored routines 16 / 31

 Programming Routines

Largest and Smallest

Suppose that instead of the top five countries for the specified region, we
wanted to list the most populous and least populous.
We could do this with three SELECT statements one to find the minimum
and maximum country populations in that region, then one each to find which
country has the minimum and the maximum population.
However we could do this with just one SELECT statement provided we
could process the results afterwards.

Jianxin Li (UWA) Stored routines 17 / 31

 Programming Routines

The algorithm

The basic idea is simple:

Suppose I were to read out a sequence of 750 numbers, and then ask you what
the biggest number was? How would you approach this without remembering
all the 750 numbers?

Jianxin Li (UWA) Stored routines 18 / 31

 Programming Routines

The algorithm

The basic idea is simple:

Suppose I were to read out a sequence of 750 numbers, and then ask you what
the biggest number was? How would you approach this without remembering
all the 750 numbers?

Always remember the biggest so far, and as each new number comes
along, compare it to the number that is being remembered and update the
remembered number only if the new number is bigger.

Jianxin Li (UWA) Stored routines 18 / 31

 Programming Routines

A stored procedure

DELIMITER ++
CREATE PROCEDURE regionLimits(rgn TEXT)
BEGIN SET numDone = 1;

DECLARE numRows INT; WHILE numDone < numRows DO

DECLARE numDone INT; FETCH regionOnly INTO cname, cpop;
DECLARE minP INT; IF (cpop < minP) THEN
DECLARE maxP INT; SET minP = cpop;
DECLARE minC VARCHAR(50); SET minC = cname;
DECLARE maxC VARCHAR(50); END IF;
DECLARE cname VARCHAR(50); IF (cpop > maxP) THEN
DECLARE cpop INT; SET maxP = cpop;
SET maxC = cname;
DECLARE regionOnly CURSOR FOR END IF;
SELECT C.name, C.population SET numDone = numDone + 1;
FROM country C END WHILE;
WHERE region = rgn;
CLOSE regionOnly;
OPEN regionOnly;
SELECT FOUND_ROWS() INTO numRows; SELECT minC as smallest,
minP as smallestPop,
FETCH regionOnly INTO cname, cpop; maxC as largest,
SET minP = cpop; maxP as largestPop;
SET maxP = cpop; END++
SET minC = cname; DELIMITER ;
SET maxC = cname;

Jianxin Li (UWA) Stored routines 19 / 31

 Programming Routines

Cursors

A cursor is essentially a mechanism to store the results of a query, and then

process the results row-by-row.
Cursors essentially support only four statements
DECLARE...CURSOR FOR declares a cursor
OPEN... opens the cursor
FETCH...INTO fetches the current row for processing
CLOSE... closes the cursor

Cursors are also the primary mechanism by which client programs interact
with the database.

Jianxin Li (UWA) Stored routines 20 / 31

 Programming Routines

Lifecycle of a cursor conception

Think of a cursor as a machine that runs a SQL query and returns the results
of this query to you one row at a time as you ask for them.
A cursor springs into existence when execution of the stored procedure
reaches a DECLARE...CURSOR statement it does not run the statement at
this point, but just remembers it.
DECLARE myCursor CURSOR FOR
SELECT year, rate
FROM Investments;

myCursor

Jianxin Li (UWA) Stored routines 21 / 31

 Programming Routines

Lifecycle of a cursor birth

At some later stage, when the OPEN statement is executed, the cursor actually
runs the query.
OPEN myCursor;

year rate
myCursor 2007 10.183
2008 -8.954
2009 -11.239
2010 2.110
2011 4.102
2012 5.419
2014 7.451

It does not return the result of the query, but just remembers it.
Jianxin Li (UWA) Stored routines 22 / 31
 Programming Routines

Lifecycle of a cursor working life

The data is extracted from the cursor one row at a time using FETCH.
Each FETCH call causes it to return whichever row it is pointing to
FETCH myCursor INTO a, b;

year rate
2007, 10.183
myCursor 2007 10.183
2008 -8.954
2009 -11.239
2010 2.110
2011 4.102
2012 5.419
2014 7.451

Jianxin Li (UWA) Stored routines 23 / 31

 Programming Routines

Lifecycle of a cursor working life

The data is extracted from the cursor one row at a time using FETCH.
Each FETCH call causes it to return whichever row it is pointing to and then
shift the pointer to the next row.
FETCH myCursor INTO a, b;

year rate
myCursor 2007 10.183
2008 -8.954
2009 -11.239
2010 2.110
2011 4.102
2012 5.419
2014 7.451

Jianxin Li (UWA) Stored routines 23 / 31

 Programming Routines

Lifecycle of a cursor working life

The data is extracted from the cursor one row at a time using FETCH.
Each FETCH call causes it to return whichever row it is pointing to and then
shift the pointer to the next row.
FETCH myCursor INTO a, b;

year rate
myCursor 2007 10.183
2008 -8.954
2009 -11.239
2010 2.110
2011 4.102
2012 5.419
2014 7.451

Jianxin Li (UWA) Stored routines 23 / 31

 Programming Routines

Lifecycle of a cursor death

Eventually, after multiple FETCH statements, the cursor will have gone
through all of the rows and have no more data left to return.

year rate
myCursor 2007 10.183
2008 -8.954
2009 -11.239
2010 2.110
2011 4.102
2012 5.419
2014 7.451

CLOSE myCursor; closes the cursor and reclaims the memory and/or other
resources it is using.
Jianxin Li (UWA) Stored routines 24 / 31
 Programming Routines

Cursor control

CREATE PROCEDURE regionLimits(rgn TEXT)

BEGIN

DECLARE regionOnly CURSOR FOR

SELECT C.name, C.population
FROM country C
WHERE region = rgn;

OPEN regionOnly;

/* process the rows */

CLOSE regionOnly;
END

Jianxin Li (UWA) Stored routines 25 / 31

 Programming Routines

How many rows?

We will use a loop to process each row, and so we need to know how many
rows the cursor contains; this can be found from the MySQL function
FOUND_ROWS() which returns the number of rows that the last query found.

DECLARE numRows INT;

DECLARE numDone INT;

/* Declare and open cursor */

SELECT FOUND_ROWS() INTO numRows;

WHILE numDone < numRows DO

/* Process a row */

SET numDone = numDone + 1;

END WHILE;

Jianxin Li (UWA) Stored routines 26 / 31

 Programming Routines

Storing max and min

In order to use the cursor to process each row, we need to have variables to
store the name and population of the most populous found so far and least
populous found so far, along with variables for the values extracted from
each row as it is processed.

So the declaration section will need to have the following added to it:
DECLARE minP INT;
DECLARE maxP INT;
DECLARE minC VARCHAR(50);
DECLARE maxC VARCHAR(50);

DECLARE cname VARCHAR(50);

DECLARE cpop INT;

Jianxin Li (UWA) Stored routines 27 / 31

 Programming Routines

Initializing

These variables are initialized with the values from the first row (after we have
read just one row, then the name and population are the best-so-far for both
maximum and minimum population.)

So immediately after the SELECT FOUND_ROWS() INTO numRows we put

FETCH regionOnly INTO cname, cpop;

SET minP = cpop;

SET maxP = cpop;

SET minC = cname;

SET maxC = cname;

SET numDone = 1;

Jianxin Li (UWA) Stored routines 28 / 31

 Programming Routines

Inside the loop

In the loop, we fetch the contents of the next row and compare them to the
existing minimum/maximum values:
WHILE numDone < numRows DO
FETCH regionOnly INTO cname, cpop;
IF (cpop < minP) THEN
SET minP = cpop;
SET minC = cname;
END IF;
IF (cpop > maxP) THEN
SET maxP = cpop;
SET maxC = cname;
END IF;
SET numDone = numDone + 1;
END WHILE;

Jianxin Li (UWA) Stored routines 29 / 31

 Programming Routines

Finally

And finally after the loop we print the output.

SELECT minC as smallest,
minP as smallestPop,
maxC as largest,
maxP as largestPop;

The output from the whole procedure is then something like

CALL regionLimits("Caribbean");
+----------+-------------+---------+------------+
| smallest | smallestPop | largest | largestPop |
+----------+-------------+---------+------------+
| Anguilla | 8000 | Cuba | 11201000 |
+----------+-------------+---------+------------+

Jianxin Li (UWA) Stored routines 30 / 31

 Programming Routines

Conclusion

Although MySQL supports stored procedures and functions, the

programming tools available are very rudimentary and awkward compared to
a general-purpose programming language.
Therefore while stored routines are extremely useful when they consist of
things that can be expressed easily in SQL, they become very awkward when
performing general processing.
Therefore in the absence of a compelling reason (e.g. security) to use stored
routines, most non-SQL processing should be performed at the client, and not
on the server.

Jianxin Li (UWA) Stored routines 31 / 31