This is the second in a series of TechTips related to record lock issues. In the first TechTip, I discussed a basic technique for preventing record lock. Most record lock issues are caused by long pauses between the read of a record and its update. The simple solution in the first TechTip eliminates the long pause between the read and the update by not locking the record on the first chain and by chaining again immediately before the update. But this technique exposes the program to potential data loss by allowing the program to overwrite data that another job may have written to the database. To prevent that, additional logic is added to play "traffic cop" and verify that the data in each record is unchanged before allowing the current job to update it.

The result of this solution is that every field is tested, even the ones the program isn't using. Consequently, the user will occasionally be told that there was a conflict when there was none (see Figure 1). In this example, two users access the same record at the same time. One user changes the description and presses Enter, updating the database. The second user updates the on-hand balance and presses Enter. However, rather than updating the database, the traffic cop logic in this program sends an error message to the second user, stating that another user has already updated the record and that the changes must be rekeyed.

Figure 1: User 2 gets a false error report. (Click image to enlarge.)

To minimize the occurrence of these false error reports, the program can be made intelligent enough to check only the fields it is concerned with, rather than the entire record, as shown in Figure 2.

Figure 2: This program logic tests only selected fields.

In this example, the program tests only the on-hand balance, the price, and the cost fields for intervening updates by other programs. To test other fields, simply change the subfields in the R1MAST data structure. If another field, such as the description, is changed while the user is reviewing a given part, no error will occur. Now, two users can update the same record at the same time, as long as they do not update fields that the other program is concerned with.

Note that this example uses an externally described data structure over the reference file, which is used as a data dictionary. This rather large data structure brings every field definition into the application, primarily for use in LIKE keywords to simplify field definitions. To prevent this large data structure from wasting a huge amount of space, the BASED keyword is added, indicating that no memory should be allocated. If you are uncomfortable with pointers, you can leave off the BASED keyword, and the program will function exactly the same except that it will take more disk space and memory and it will run slower.

This solution builds on the example given in my previous TechTip and shows a sophisticated method for eliminating record lock and even allowing concurrent access to the same record. If for some reason you cannot use these techniques that prevent record lock, see my next TechTip on how to detect record lock when it does happen.

Kevin Forsythe has over 18 years of experience working with the iSeries platform and its predecessors. He has been a member of the DMC team for the past nine years. Kevin's primary responsibility is providing iSeries education, but he also provides customers with project management, system design, analysis, and technical construction. In addition to his technical skills (RPG IV, CL, OS/400, SQL, FTP, Query, VB, Net.Data), Kevin possesses the ability to communicate new and complex concepts to his students. He has been the primary instructor for DMC's iSeries-based AS/Credentials training courses since 1997 and has authored courses such as Advanced ILE, SQL, Embedded SQL, Operations Navigator, and Intro to WebSphere Studio. An award-winning speaker, he has spoken at every COMMON Conference since the spring of 2000.