#

| Chapter 6 Database Interaction and Cursors |

## 6.11 SELECT FOR UPDATE in Cursors

When you issue a SELECT statement against the database to query some records, no locks are placed on the selected rows. In general, this is a wonderful feature because the number of records locked at any given time is (by default) kept to the absolute minimum: only those records which have been changed but not yet committed are locked. Even then, others will be able to read those records as they appeared before the change (the "before image" of the data).

There are times, however, when you will want to lock a set of records even before you change them in your program. Oracle offers the FOR UPDATE clause of the SELECT statement to perform this locking.

When you issue a SELECT...FOR UPDATE statement, the RDBMS automatically obtains exclusive row-level locks on all the rows identified by the SELECT statement, holding the records "for your changes only" as you move through the rows retrieved by the cursor. No one else will be able to change any of these records until you perform a ROLLBACK or a COMMIT.

Here are two examples of the FOR UPDATE clause used in a cursor:

>     CURSOR toys_cur IS
>        SELECT name, manufacturer, preference_level, sell_at_yardsale_flag
>          FROM my_sons_collection
>         WHERE hours_used = 0
>           FOR UPDATE;

>     CURSOR fall_jobs_cur IS
>        SELECT task, expected_hours, tools_required, do_it_yourself_flag
>          FROM winterize
>         WHERE year = TO_CHAR (SYSDATE, 'YYYY')
>           FOR UPDATE OF task;

The first cursor uses the unqualified FOR UPDATE clause, while the second cursor qualifies the FOR UPDATE with a column name from the query.

You can use the FOR UPDATE clause in a SELECT against multiple tables. In this case, rows in a table are locked only if the FOR UPDATE clause references a column in that table. In the following example the FOR UPDATE clause does not result in any locked rows in the winterize table:

>     CURSOR fall_jobs_cur IS
>        SELECT w.task, w.expected_hours,
>               w.tools_required, w.do_it_yourself_flag
>          FROM winterize w, husband_config hc
>         WHERE year = TO_CHAR (SYSDATE, 'YYYY')
>           FOR UPDATE OF husband_config.max_procrastination_allowed;

The FOR UPDATE OF clause only mentions the max_procrastination_allowed column; no columns in the winterize table are listed.

The OF list of the FOR UPDATE clause does not restrict you to changing only those columns listed. Locks are still placed on all rows; the OF list just gives you a way to document more clearly what you intend to change. If you simply state FOR UPDATE in the query and do not include one or more columns after the OF keyword, then the database will then lock all identified rows across all tables listed in the FROM clause.

Furthermore, you do not have to actually UPDATE or DELETE any records just because you issued a SELECT...FOR UPDATE -- that act simply states your intention to be able to do so.

Finally, you can append the optional keyword NOWAIT to the FOR UPDATE clause to tell Oracle not to wait if the table has been locked by another user. In this case, control will be returned immediately to your program so that you can perform other work or simply wait for a period of time before trying again. Without the NOWAIT clause, your process will block until the table is available. There is no limit to the wait time unless the table is remote. For remote objects, the Oracle initialization parameter, DISTRIBUTED_LOCK_TIMEOUT, is used to set the limit.

### 6.11.1 Releasing Locks with COMMIT

As soon as a cursor with a FOR UPDATE clause is OPENed, all rows identified in the result set of the cursor are locked and remain locked until your session issues either a COMMIT statement to save any changes or a ROLLBACK statement to cancel those changes. When either of these actions occurs, the locks on the rows are released. As a result, you cannot execute another FETCH against a FOR UPDATE cursor after you COMMIT or ROLLBACK. You will have lost your position in the cursor.

Consider the following program, which assigns winterization chores:[1]

> [1] Caveat: I don't want to set false expectations with anyone, especially my wife. The code in this block is purely an example. In reality, I set the max_procrastination_allowed to five years and let my house decay until I can afford to pay someone to do something, or my wife does it, or she gives me an ultimatum. Now you know why I decided to write a book...

>     DECLARE
>        /* All the jobs in the Fall to prepare for the Winter */
>        CURSOR fall_jobs_cur
>        IS
>           SELECT task, expected_hours, tools_required, do_it_yourself_flag
>             FROM winterize
>            WHERE year = TO_CHAR (SYSDATE, 'YYYY')
>              AND completed_flag = 'NOTYET'
>            FOR UPDATE OF task;
>     BEGIN
>        /* For each job fetched by the cursor... */
>        FOR job_rec IN fall_jobs_cur
>        LOOP
>           IF job_rec.do_it_yourself_flag = 'YOUCANDOIT'
>           THEN
>              /*
>              || I have found my next job. Assign it to myself (like someone
>              || is going to do it!) and then commit the changes.
>              */
>              UPDATE winterize SET responsible = 'STEVEN'
>               WHERE task = job_rec.task
>                 AND year = TO_CHAR (SYSDATE, 'YYYY');
>              COMMIT;
>           END IF;
>        END LOOP;
>     END;

Suppose this loop finds its first YOUCANDOIT job. It then commits an assignment of a job to STEVEN. When it tries to FETCH the next record, the program raises the following exception:

>     ORA-01002: fetch out of sequence

If you ever need to execute a COMMIT or ROLLBACK as you FETCH records from a SELECT FOR UPDATE cursor, you should include code (such as a loop EXIT or other conditional logic) to halt any further fetches from the cursor.

### 6.11.2 The WHERE CURRENT OF Clause

PL/SQL provides the WHERE CURRENT OF clause for both UPDATE and DELETE statements inside a cursor in order to allow you to easily make changes to the most recently fetched row of data.

The general format for the WHERE CURRENT OF clause is as follows:

>     UPDATE table_name
>        SET set_clause
>      WHERE CURRENT OF cursor_name;

>     DELETE
>       FROM table_name
>      WHERE CURRENT OF cursor_name;

Notice that the WHERE CURRENT OF clause references the cursor and not the record into which the next fetched row is deposited.

The most important advantage to using WHERE CURRENT OF where you need to change the row fetched last is that you do not have to code in two (or more) places the criteria used to uniquely identify a row in a table. Without WHERE CURRENT OF, you would need to repeat the WHERE clause of your cursor in the WHERE clause of the associated UPDATEs and DELETEs. As a result, if the table structure changes in a way that affects the construction of the primary key, you have to make sure that each SQL statement is upgraded to support this change. If you use WHERE CURRENT OF, on the other hand, you only have to modify the WHERE clause of the SELECT statement.

This might seem like a relatively minor issue, but it is one of many areas in your code where you can leverage subtle features in PL/SQL to minimize code redundancies. Utilization of WHERE CURRENT OF, %TYPE, and %ROWTYPE declaration attributes, cursor FOR loops, local modularization, and other PL/SQL language constructs can have a big impact on reducing the pain you may experience when you maintain your Oracle-based applications.

Let's see how this clause would improve the previous example. In the jobs cursor FOR loop above, I want to UPDATE the record that was currently FETCHed by the cursor. I do this in the UPDATE statement by repeating the same WHERE used in the cursor because (task, year) makes up the primary key of this table:

>     WHERE task = job_rec.task
>       AND year = TO_CHAR (SYSDATE, 'YYYY');

This is a less than ideal situation, as explained above: I have coded the same logic in two places, and this code must be kept synchronized. It would be so much more convenient and natural to be able to code the equivalent of the following statements:

Delete the record I just fetched.

or:

Update these columns in that row I just fetched.

A perfect fit for WHERE CURRENT OF! The next version of my winterization program below uses this clause. I have also switched to a simple loop from FOR loop because I want to exit conditionally from the loop:

>     DECLARE
>        CURSOR fall_jobs_cur IS SELECT ... same as before ... ;
>        job_rec fall_jobs_cur%ROWTYPE;
>     BEGIN
>        OPEN fall_jobs_cur;
>        LOOP
>           FETCH fall_jobs_cur INTO job_rec;

>           IF fall_jobs_cur%NOTFOUND
>           THEN
>              EXIT;

>           ELSIF job_rec.do_it_yourself_flag = 'YOUCANDOIT'
>           THEN
>              UPDATE winterize SET responsible = 'STEVEN'
>               WHERE CURRENT OF fall_jobs_cur;
>              COMMIT;
>              EXIT;
>           END IF;
>        END LOOP;
>        CLOSE fall_jobs_cur;
>     END;

6.10 Cursor Parameters |  | 6.12 Cursor Variables

Copyright (c) 2000 O'Reilly & Associates. All rights reserved.