#

| Chapter 3 The PL/SQL Development Spiral |

## 3.10 Choosing the Best Performer

If there is a difference in execution time between the performance of my two string-repeaters, it will not be a big one. I will need to execute the functions many times to compare the cumulative difference. The best way to calculate the elapsed time of PL/SQL code execution is with the GET_TIME function of the DBMS_UTILITY builtin package. I have encapsulated GET_TIME inside the PLVtmr package (PL/Vision TiMeR) to make it easier to use. Example 3.9 shows the kind of script I used.[4]

> [4] By the way, this code was for the most part generated for me with the PLVgen package to compare the performance of `repeated`, `rep_rpad`, and also the recursion-based implementation of `repeated` (see sidebar).

This SQL*Plus script (stored in the file timerep.sql on the disk) takes three arguments. The first, &1, accepts the number of times to execute each function. The second, &2, accepts a string that is to be duplicated. The third, &3, accepts the number of repetitions of the string. I ran the script several times as shown below:

>     SQL> @timerep 100 abc 1
>     duprpad Elapsed: .77 seconds. Factored: .0077 seconds.
>     duploop Elapsed: .66 seconds. Factored: .0066 seconds.
>     recrep Elapsed: .71 seconds. Factored: .0071 seconds.

>     SQL> @timerep 100 abc 10
>     duprpad Elapsed: .71 seconds. Factored: .0071 seconds.
>     duploop Elapsed: .99 seconds. Factored: .0099 seconds.
>     recrep Elapsed: 1.54 seconds. Factored: .0154 seconds.

I ran each of these tests several times to allow the numbers to stabilize. The results are very interesting and certainly reinforce the need for a careful test plan. When repeating the string just once, the recursion-based implementation is superior. Upon reflection, this should not be a surprise. It handles a single repetition as a special case: an unmediated concatenation of two strings. The loop-based implementation comes in second, but all of the timings are very close. When we move to multiple repetitions of the string, however, the recrep function becomes extremely slow; again, I would expect that behavior because of the extra work performed by the PL/SQL runtime engine to manage a recursive program. The big news from this round, however, is that the RPAD implementation of `repeated` establishes itself clearly as the fastest technique.

#### Example 3.9: A Performance Comparison Script

>     DECLARE
>        a VARCHAR2(100) := '&2';
>        aa VARCHAR2(10000);
>     BEGIN
>        PLVtmr.set_factor (&1);
>        PLVtmr.capture;
>        FOR rep IN 1 .. &1
>        LOOP
>           aa := rep_rpad (a, 'UL', &3);
>        END LOOP;
>        PLVtmr.show_elapsed ('duprpad');

>        PLVtmr.set_factor (&1);
>        PLVtmr.capture;
>        FOR rep IN 1 .. &1
>        LOOP
>           aa := repeated (a, 'UL', &3);
>        END LOOP;
>        PLVtmr.show_elapsed ('duploop');

>        PLVtmr.set_factor (&1);
>        PLVtmr.capture;
>        FOR rep IN 1 .. &1
>        LOOP
>           aa := recrep (a, 'UL', &3);
>        END LOOP;
>        PLVtmr.show_elapsed ('recrep');
>     END;
>     /

Of course, I also need to compare the performance for different kinds of strings. I ran the same `timer` script as follows to see how each function handled NULL values:

>     SQL> @timerep 200 null 10
>     duprpad Elapsed: 1.59 seconds. Factored: .00795 seconds.
>     duploop Elapsed: 2.03 seconds. Factored: .01015 seconds.
>     recrep Elapsed: 2.91 seconds. Factored: .01455 seconds.

In this scenario, the RPAD implementation was considerably faster than the loop and recursion techniques (though, once again, I found that if the number of repetitions was set to 1, the `recrep` function was faster). Finally, I greatly increased the number of string repetitions and then all became clear:

>     SQL> @timerep 100 abc 100
>     duprpad Elapsed: .77 seconds. Factored: .0077 seconds.
>     duploop Elapsed: 4.28 seconds. Factored: .0428 seconds.
>     recrep Elapsed: 5.22 seconds. Factored: .0522 seconds.

The conclusion I draw from my tests is that the RPAD technique offers a much more stable solution than that based on the FOR loop. Regardless of the number of repetitions, RPAD takes about the same amount of time. With the FOR loop and recursion approaches, as the repetitions increase, the performance degrades. That is not the sign of a healthy algorithm.

Given the results, it would make sense to implement the `repeated` function using the RPAD technique. You could possibly optimize further by using the FOR loop approach for small numbers of repetitions, and then switch to RPAD for larger repetitions. The gain with the FOR loop for minimal repetitions is, however, minimal -- it's probably not worth the trouble.

I was glad to see that the RPAD approach is faster. You should always use a builtin if it exists, rather than build your own. The FOR loop technique arose quite naturally from the way I expanded the scope of the twice function. It turned out, however, that it was not the path to the optimal solution. As for recursion, well, it is always an interesting phenomenon to watch and puzzle out, but it rarely offers the best implementation (except when it is the only implementation feasible).

#### Example 3.10: The Code for the Recursive Implementation of repeated

>     CREATE OR REPLACE FUNCTION recrep
>        (string_in IN VARCHAR2,
>         action_in IN VARCHAR2 := NULL,
>         num_in IN INTEGER := 1)
>        RETURN VARCHAR2
>     IS
>        v_action VARCHAR2(10) := UPPER (action_in);
>        initval VARCHAR2(32767);
>        nextval VARCHAR2(32767);
>        v_retval VARCHAR2(32767);

>     BEGIN
>        assert
>           (v_action IN ('UL', 'LU', 'N'),
>            'Please enter UL LU or N');
>        assert
>           (num_in >= 0, 'Duplication count must be at least 0.');

>        IF v_action = 'UL'
>        THEN
>           initval := UPPER (string_in);
>           nextval := LOWER (string_in);
>        ELSIF v_action = 'LU'
>        THEN
>           initval := LOWER (string_in);
>           nextval := UPPER (string_in);
>        ELSE
>           initval := string_in;
>           nextval := string_in;
>        END IF;

>        IF num_in = 1
>        THEN
>           RETURN initval || nextval;
>        ELSE
>           /* No more case conversions performed... */
>           RETURN (initval || repeated (nextval, 'N' , num_in-1));
>        END IF;
>     END recrep;
>     /

3.9 Considering Implementation Options |  | 3.11 Don't Forget Backward Compatibility

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