firstrecord loop Name = upper(Name) downrecord until info("stopped")
But what if we made a mistake, and forgot to include the downrecord statement?
firstrecord loop Name = upper(Name) until info("stopped")
Now the loop will stay stuck at the top of the database. It will never reach the bottom of the database (unless the database contains only one record), so the loop will never stop – it will run endlessly.
If a loop is running endlessly, you can stop it by pressing the SHIFT, COMMAND and ESCAPE keys all at the same time. (Note: This feature was not available in Panorama X 10.1 or earlier.)
This combination was purposefully designed to require two hands, so that you don’t abort a loop accidentally when you don’t mean to. When the abort occurs, it’s as if there was a stop statement in the code – Panorama immediately stops and the rest of the code is ignored.
You cannot abort slow code in general. For example, suppose you have a large database and sorting by state takes 2 minutes. In that situation, you might think that you could stop the sort after 1 minute by pressing SHIFT-COMMAND-ESCAPE.
field State sortup field City sortupwithin
But this doesn’t happen, because the abort only applies to loops. In the code above, there is no chance of an endless loop, because there is no loop at all. The program will finish eventually, no matter what. So the abort key sequence doesn’t apply.
In the previous section it was stated that when an abort key sequence is detected Panorama immediately stops and the rest of the code is ignored, but that’s actually not quite true. What actually happens is that an error occurs. Normally this stops the procedure, but you can use the try/catch statements to intercept the error and then continue (see Error Handling). This example displays a helpful message and then stops the program, but the code could possibly attempt to continue.
firstrecord let n=1 try loop Name = upper(Name) downrecord n = n+1 until info("stopped") catch message "Only "+n+" of "+info("selected")+" records completed!" return endcatch
If the code inside try/catch could generate other types of errors, you can check info(“error”) to see if
Shift-Command-ESCAPE abort. is actually the error.
In some situations it’s very important that a loop runs until it is finished, no matter how much time it takes. As a programmer, you may want to make sure that a loop isn’t aborted early, leaving a task half finished. In that situation you have two methods you can use to disable the SHIFT-COMMAND-ESCAPE abort key sequence.
The first method is to use the disableabort statement.
firstrecord disableabort loop Name = upper(Name) downrecord until info("stopped") enableabort
In this case the enableabort statement on the end isn’t really needed, Panorama automaticaly re-enables aborts when the procedure finishes.
Loop aborts aren’t just disabled for the current procedure, they are also disabled for any subroutines called by the code. In this example, a subroutine named DoSomeThings is called. If DoSomeThings has any loops, you won’t be able to abort them. This extends to any additional subroutines called by DoSomeThings
firstrecord disableabort loop call DoSomeThings downrecord until info("stopped") enableabort
You can also automatically disable aborts for all procedures in a particular database. Simply use the File>Database Options>General panel to enable the Prevent early abort of procedures in this database. option. ProVUE uses this option in all of Panorama’s libraries, because it’s important that the library code not be aborted. (Even when this option is used, you can still use the enableabort statement to temporarily allow loops to be aborted.)
Note that the Prevent early abort of procedures in this database. option applies any time code in that database runs – even if that database is not the currently active database. It will also apply any subroutines called by code in the database.
When you use either of these techniques to disable aborts, you will of course want to be extra careful to make sure that you don’t write a loop that will never end. If you do that, the loop will run endlessly until you force quit Panorama or reboot the entire computer.
In addition to the ability to abort with the SHIFT-COMMAND-ESCAPE key sequence, you can also set up a preference to specify the maximum time that a loop can run. Choose Preferences from the File menu, then click on the Advanced panel. In this panel you can edit the timeout value directly or you can choose from a set of common timeouts from the popup menu. Choose ∞ if you don’t want a timeout, but rather the option to run endlessly forever.
The trick in specifying this value is that you don’t want to make it onerous to wait for if a loop does get locked up, but you don’t want to make the timeout length so short that legitimate loops get cut short because the timer expires before they finish their work.
So now let’s go back to our endless loop example.
firstrecord loop Name = upper(Name) until info("stopped")
With the timeout preference set to 30 seconds, this loop will run for 30 seconds and then stop with an error, like this.
Note: The loop timeout value is ignored if the disableabort statement has been used, or if early abort has been disabled in the Database Options dialog.
In addition to setting up an overall timeout for all procedures, you can also set a custom timeout specifically for an individual procedure. This is done with the timelimit statement. For example the statement
timelimit 1200 will set the time limit to 20 minutes, which will allow this loop to continue running even if the database has thousands of records.
timelimit 1200 firstrecord loop Name = upper(Name) downrecord until info("eof")
Twenty minutes is a long time, and you might not really be sure how long a loop like this will take. In a situation like this, it might be better to simply set the time limit to zero, which completely disables the timeout (essentially setting it to infinity). This insures that the loop will run all the way to the bottom, no matter how many records there are. (Of course in that case you need to double check your code to make sure the loop will really finish eventually.)
timelimit 0 firstrecord loop Name = upper(Name) downrecord until info("eof")
Note: The timelimit does not apply if the disableabort statement has been used, or if early abort has been disabled in the Database Options dialog.
If a timeout occurs, it is handled like any other error. This means you can trap the error if you wish (see Error Handling) and handle it in some custom manner, for example displaying a custom alert.
timelimit 60 firstrecord try loop Name = upper(Name) downrecord until info("eof") catch message "Your request took too long." endcatch
The timeout does not kick in for slow code in general. For example, suppose you have a large database and sorting by state takes 2 minutes. In that situation, you might think that this program would timeout after the second line.
timelimit 20 field State sortup field City sortupwithin
But this doesn’t happen, because the timeout only applies to loops. In the code above, there is no chance of an endless loop, because there is no loop at all. The program will finish eventually, no matter what. So the timeout limit doesn’t apply in this situation.
|10.2||New||New in this version.|