This note is about a surprising performance difference between the lead() and lag() analytic functions (which31 turns out to be due to the behaviour of the nth_value() function) when the option to “ignore nulls” is included in their use (jump to conclusion). The detail I’ll be writing about was highlighted in a thread on the Oracle developer forum about a requirement to add a number of analytic columns to a dataset of 156 million rows using a statement of the following shape:
create table tb_target_ignore
as
select
pat_id,
visit_date_dt,
ed_ucc_dt,
lag (ed_ucc_dt ignore nulls, 1) over (partition by pat_id order by visit_date_dt) as prev_ed_ucc_dt,
lead(ed_ucc_dt ignore nulls, 1) over (partition by pat_id order by visit_date_dt) as next_ed_ucc_dt,
row_number() over (partition by pat_id order by visit_date_dt) as row_num
from
tb_source
;
You’ll notice that I’ve introduced a row_number(), and both a lead() and a lag() of a column called ed_ucc_dt. All three analytic columns use the same partitioning and ordering, though, so Oracle will only be doing one “window sort” in the execution plan. Part of the performance problem, of course, was that with 156M rows of a couple of dozen existing columns and adding a dozen new columns, the workload due to sorting was bound to be very large, so there were various suggestions of how to minimise that part of the workload.
However Solomon Yakobson pointed out that the code was using the “ignore nulls” option and there was a bug in 11g that made lead() and lag() very slow when this option was used. He subsequently reported that this defect was still present in 19c, restricted it to just the lag() function, and cited a MOS document ID referencing the problem: LAG Function is slow when using ignore nulls (Doc ID 2811596.1). The implication of the MOS note is that we shouldn’t expect this to change.
A follow-up posting by User_H3J7U gave us a reason for the slowness of the lag() function by running a sample query through dbms_utility.expand_sql(). Oracle rewrites the query to use variants of the nth_value() function when you use “ignore nulls”, but rewrites it to use variants of first_value() when you aren’t using the “ignore nulls” option. This isn’t a complete explanation of why lag() should be slow while lead() is not – but it’s a significant pointer towards a possible implementation issue and is a good clue about working around the problem. So let’s build a model of the situation.
The basic model
rem
rem Script: lag_ignore_nulls.sql
rem Author: Jonathan Lewis / Sam P
rem Dated: May 2022
rem Purpose:
rem
rem Last tested
rem 19.11.0.0
rem
create table tb_source (
pat_id,
visit_date_dt,
ed_ucc_dt
)
as
with generator as (
select rownum id
from dual
connect by
level <= 1e4 --> comment to avoid wordpress format issue
)
select
g1.id,
to_date('01-Apr-2022') + dbms_random.value(0,100),
to_date('01-Apr-2022') + dbms_random.value(5,105)
-- to_date(null)
from
generator g1,
generator g2
where
g2.id <= 20 --> comment to avoid wordpress format issue
order by
dbms_random.value
/
spool lag_ignore_nulls.lst
set serveroutput off
set timing on
prompt ======================
prompt Without "ignore nulls"
prompt (My time 0.61 seconds)
prompt ======================
create table tb_target_no_ignore
as
select
pat_id,
visit_date_dt,
ed_ucc_dt,
lag (ed_ucc_dt, 1) over (partition by pat_id order by visit_date_dt) as prev_ed_ucc_dt,
lead(ed_ucc_dt, 1) over (partition by pat_id order by visit_date_dt) as next_ed_ucc_dt,
row_number() over (partition by pat_id order by visit_date_dt) as row_num
from
tb_source
;
prompt ======================
prompt With "ignore nulls"
prompt (My time 0.88 seconds)
prompt ======================
create table tb_target_ignore
as
select
pat_id,
visit_date_dt,
ed_ucc_dt,
lag (ed_ucc_dt ignore nulls, 1) over (partition by pat_id order by visit_date_dt) as prev_ed_ucc_dt,
lead(ed_ucc_dt ignore nulls, 1) over (partition by pat_id order by visit_date_dt) as next_ed_ucc_dt,
row_number() over (partition by pat_id order by visit_date_dt) as row_num
from
tb_source
;
I’ve created a source table with 200,000 rows, consisting of 10,000 pat_id values, and 20 rows per pat_id. The 20 rows for a pat_id (probably) each have a different visit_date_dt and a different ed_ucc_dt.
After creating the data set I’ve created two more tables using the lead() and lag() functions to generate a previous (lag) and next (lead) ed_ucc_dt for each row, partitioning by pat_id, ordering by visit_date_dt. One statement includes the “ignore nulls” option the other doesn’t and, as you can see, the time to create the “no ignore” table was 0.61 seconds while the time to create the “ignore null” table was 0.88 seconds.
The variation isn’t dramatic – but this is just 200,000 rows, in memory, with only a few columns and only two columns added through lead and lag.
After the baseline test I tweaked the statement that created the table with the “ignore nulls” option to get three more times.
- With neither lead() nor lag() the time was 0.29 seconds
- With just the lead() column the time was 0.46 seconds – an increase of 0.17 seconds
- With just the lag() column the time was 0.71 seconds – an increase of 0.42 seconds
You might note that 0.29 + 0.17 + 0.42 = 0.88 (the time I got for adding both columns) – it’s a little lucky that it looks like a perfect match, but even matching within a couple of hundredths of a second would be have been a nice detail. It certainly seems that lag() – with my test data – consumes more resources than lead() for a pair of operationd that look as if they should produce the same workloads.
Internal Rewrite
The next step was to check what the internal rewrite of the code looked like, so I passed the select part of the statements (the procedure won’t accepts “create as select”) through dbms_utility.expand_sql() and reformatted the results. Here are the two rewritten statements – first without “ignore nulls”:
select
a1.pat_id pat_id,
a1.visit_date_dt visit_date_dt,
a1.ed_ucc_dt ed_ucc_dt,
decode(
count(*) over (
partition by a1.pat_id order by a1.visit_date_dt
rows between 1 preceding and 1 preceding
),a
1, first_value(a1.ed_ucc_dt) over (
partition by a1.pat_id order by a1.visit_date_dt
rows between 1 preceding and 1 preceding
),
null
) prev_ed_ucc_dt,
decode(
count(*) over (
partition by a1.pat_id order by a1.visit_date_dt
rows between 1 following and 1 following
),a
1, first_value(a1.ed_ucc_dt) over (
partition by a1.pat_id order by a1.visit_date_dt
rows between 1 following and 1 following
),
null
) next_ed_ucc_dt,
row_number() over (partition by a1.pat_id order by a1.visit_date_dt) row_num
from
test_user.tb_source a1
The code looks a little long and messy, but that’s mainly because just about everything it does happens twice. The lag() function (prev column) turns into a first_value() function that looks at the row preceding the current row in the partition (rows between 1 preceding and 1 preceding). However it first has to count over the same clause to see if a row exists, and then either report its value or report a null – hence the structure decode(count(), 1, first_value(), null)
Note: the full lag() function call is: “lag(expression, offset, default)” where the offset (number of rows to lag) defaults to 1 and the default is the value you want reported when there is no matching row, and defaults to null.
The call to lead() basically does the same thing, but uses (rows between 1 following and 1 following) to access the next row in the partition.
On the other hand this is the SQL that Oracle generates when we include the “ignore nulls” clause (which means Oracle can’t restrict the row range to just one preceding or following row):
select
a1.pat_id pat_id,
a1.visit_date_dt visit_date_dt,
a1.ed_ucc_dt ed_ucc_dt,
nvl(
nth_value(a1.ed_ucc_dt, 1) from last ignore nulls over (
partition by a1.pat_id order by a1.visit_date_dt
rows between unbounded preceding and 1 preceding
),
null
) prev_ed_ucc_dt,
nvl(
nth_value(a1.ed_ucc_dt, 1) ignore nulls over (
partition by a1.pat_id order by a1.visit_date_dt
rows between 1 following and unbounded following
),
null
) next_ed_ucc_dt,
row_number() over (partition by a1.pat_id order by a1.visit_date_dt) row_num
from
test_user.tb_source a1
Both lag() and lead() turn into nth_value() with a second parameter of 1 (i.e. nth == 1st … which makes you wonder why Oracle isn’t using first_value()), and we can also see the “ignore nulls” still being used.
The lag() call now uses the range (rows between unbounded preceding and 1 preceding) i.e. everything from the start of partition to the previous row, while the lead() call uses the range (rows between 1 following and unbounded following) i.e. from the next row to the end of partition.
The other important detail to note is that the translation of the lag() call also includes the clause “from last” – in other words we want the first row when reading the partition in reverse order, and that might have something to do with the extra time it takes to operate the (translated) lag() function.
Workaround
Oracle is using a generic nth_value() to translate a generic lead()/lag(), but we’re in the special case where we know n = 1, which means we (and Oracle) could use first_value()/last_value(). It’s perfectly reasonable for Oracle’s internal code to avoid special cases if it makes no difference to performance, of course, but maybe in this case we could imitate Oracle’s rewrite to get some benefit.
- Step 1 – change nth_value() to the appropriate first/last.
- Step 2 – get rid of the “from last” which won’t be needed with last_value()
- Step 3 – move the “ignore nulls” to the spot that Oracle wants to see it with first/last
Here’s the resulting SQL – I’ve left the nvl(count, expression, null) in place, but if you wanted a null as the default return value for the original lead()/lag() calls you could simplify the code a little further.
create table tb_target
as
select
a1.pat_id pat_id,
a1.visit_date_dt visit_date_dt,
a1.ed_ucc_dt ed_ucc_dt,
nvl(
last_value(a1.ed_ucc_dt ignore nulls) over (
partition by a1.pat_id order by a1.visit_date_dt
rows between unbounded preceding and 1 preceding
),
null
) prev_ed_ucc_dt,
nvl(
first_value(a1.ed_ucc_dt ignore nulls) over (
partition by a1.pat_id order by a1.visit_date_dt
rows between 1 following and unbounded following
),
null
) next_ed_ucc_dt,
row_number() over (partition by a1.pat_id order by a1.visit_date_dt) row_num
from
test_user.tb_source a1
/
- Run-time: 0.61 seconds.
- Run-time with just last_value() / preceding: 0.47 seconds
- Run time with just first_value() / following: 0.43 seconds
There still seems to be a little discrepancy between accessing to the preceding data compared to accessing the following data but there’s a much better balance than before.
One more edit – taking out the nvl() construct because the original lead()/lag() calls didn’t have a non-null default supplied:
create table tb_target
as
select
a1.pat_id pat_id,
a1.visit_date_dt visit_date_dt,
a1.ed_ucc_dt ed_ucc_dt,
--
last_value(a1.ed_ucc_dt ignore nulls) over (
partition by a1.pat_id order by a1.visit_date_dt
rows between unbounded preceding and 1 preceding
) prev_ed_ucc_dt,
--
first_value(a1.ed_ucc_dt ignore nulls) over (
partition by a1.pat_id order by a1.visit_date_dt
rows between 1 following and unbounded following
) next_ed_ucc_dt,
--
row_number() over (partition by a1.pat_id order by a1.visit_date_dt) row_num
from
test_user.tb_source a1
/
With this simplification the time dropped by a further couple of hundredths of a second hovering between 0.57 and 0.58 seconds.
There was one last detail about the test code that should be mentioned – do the changes in code still produce the same results? As a quick and dirty check I ran the following query after each variant of creating the tb_target table (tb_target_ignore is the table created using the original lead()/lag() code with “ignore nulls”):
select *
from (
select * from tb_target minus select * from tb_target_ignore
union all
select * from tb_target_ignore minus select * from tb_target
)
/
The result was always zero rows.
Hypothesis
I raised the idea that the difference in timing for the lead() and lag() functions might have something to do with the volume of data that Oracle could be processing to find the one row it needed.
My thinking was that for the lead() rewrite – the call to nth_value(ed_ucc_dt,1) – would simply be looking at the next row in the partition (if it existed) because my data has no nulls that neeed to be ignored, while the rewrite of the lag() function with its “from last” requirement could be making Oracle re-read the entire preceding section of the partition before starting to process it backwards.
As a possible check to see if this was a viable hypothesis I ran one more test – visible in the initial declaration of tb_source – I created the data with ed_ucc_dt set to null in every single row, so that Oracle would be forced to process from the current position to whichever end of the partition was relevant regardless of whether it was calling lead() or lag().
With this change in place the timing for the lead() only and lag() only statements were nearly identical – which is a weak support for the hypothesis.
And once I’d done that test the next obvious test was to see what happened if I increased size of each partition (using non-null values for ed_ucc_dt) to see if larger partitions would increase the difference between the forward and backward tests. To do this I changed the script to create the tb_source table to produce 5,000 pat_id value with 40 rows per pat_id by changing the where clause to:
where
g2.id <= 40 --> comment to avoid wordpress format issue
and g1.id <= 5e3 --> comment to avoid wordpress format issue
With this change in place the timings for the original form of the lead()/lag() statement were:
- With both lead() and lag() in place the time was 1.05 seconds
- With neither lead() nor lag() the time was 0.25 seconds
- With just the lead() column the time was 0.41 seconds – an increase of 0.16 seconds
- With just the lag() column the time was 0.98 seconds – an increase of 0.73 seconds
So the lag() time (ballpark figures) nearly doubles as the partition size doubles but the lead() time stays pretty much the same.
The results of these two tests do tend to suggest that the generic nth_value() implementation can do some short-circuiting when working “forwards”, using a mechanism that isn’t available when the “from last” clause requires it to work “backwards”.
Writing the previous paragraph prompted me to do one last test – it wouldn’t produce the same results, of course, but I ought to check the performance when I moved the “from last” clause out of the “prev”/lag() column expression into the “next”/lead() column expression in Oracle’s original translation to confirm that the problem was associated with the “from last” and not with the choice of “preceding” or “following” in the row range section of the over() clause. (It was the “from last” that made the difference.)
tl;dr
If you’re using the lag() or lead() functions with “ignore nulls” on a very large dataset you may find that you can rewrite the code with first_value() or last_value() calls that use less CPU. The benefit is probably only significant on fairly large data sets, and may be particularly noticeable for cases where the same over() clause is used many times and the partition sizes are more than a couple of dozen rows each.
The potential for excess CPU usage comes from the effect of a generic internal rewrite using the nth_value() function with the “from last” clause even for the special case where your lead()/lag() have an offset (i.e. n) of 1 which would allow for the use of first_value()/last_value().
To get the correct rewrite you can use dbms_utility.expand_sql() to generate a suitable statement from which you can extract and edit the relevant pieces of text.
Footnote
A further point raised by Solomon Jakobson was that in the generic case (where you can’t use first_value() / last_value() to rewrite the SQL because you want to use an offset greater than one) it’s worth noting that the following two expressions are effectively identical:
nvl(
nth_value(a1.ed_ucc_dt, 2) from last ignore nulls over (
partition by a1.pat_id order by a1.visit_date_dt
rows between unbounded preceding and 1 preceding
),
null
) prev_ed_ucc_dt
nvl(
nth_value(a1.ed_ucc_dt, 2) ignore nulls over (
partition by a1.pat_id order by a1.visit_date_dt desc
rows between 1 following and unbounded following
),
null
) prev_ed_ucc_dt
/
Note particularly that to avoid the issue of scanning the data “from last”, I’ve changed the ordering (in line 11) to descending and I’ve changed the preceding of line 4 to following in line 12 while reversing the positions of 1 and unbounded. (The same strategy can be applied for the lag() function in the original code).
In general it’s likely that lead() is will be more efficient than lag() so this change could make a big difference in performance. It’s worth noting, however, that if you’ve been using both lead() and lag() as my example did then your execution plan will (truthfully) show two “window sort” operations and the second (i.e. lower number in the plan) window sort will also be sorting the columns added by the first window sort. Depending on the nature of your data the additional sort might increase the workload by more than the benefit you get from eliminating a lag().
In an example created by Solomon Jakobson the effect of using lag( ,5) was catastrophic and the change that introduced the extra sort to get a lead( ,5) made a huge difference (40 seconds down to 0.15 seconds – and I haven’t made a mistake in the decimal point there); in my original test case the improvement I got from applying the same strategy was small (0.88 seconds down to 0.86 seconds). The critical difference between the test cases was that one had a single partition of 20,000 rows, the other had (10,000) partitions of only 20 rows.
(Footnote to the footnote – it did cross my mind that if you had a performance catastrophe with the simple lag(,n) and with the extra sort from reversing the order to use a lead(,n) would Oracle do something clever if you found a way to rewrite the query with a cascade of inline-views that all used last_value() – but I decided I wasn’t going to look at that option until someone paid me to. More seriously I did wonder about the option for using match_recognize to bypass the lag() problem, and may get around to thinking about that more carefully at some point.)
Oracle Scratchpad 