← SASnRLAG: Access the Previous Row's Value

Introduction

Clinical programming often needs the value from the previous row — change-from-baseline, visit-over-visit differences, and shift tables all depend on it.
SAS provides the LAG() function, but it has a well-known trap: LAG always advances its internal queue, even when called inside a conditional IF. This lesson shows the bug and the fix.
In R tidyverse, dplyr::lag() inside mutate() does the same job without the conditional gotcha.
Base R builds the shifted vector manually with c(NA, head(x, -1)).
We use a small dataset of 3 subjects with 3 visits each and a numeric analysis value (AVAL) to demonstrate all three approaches.

LAG: Access the Previous Row's Value

SAS (Base SAS)+

*==============================================================================;
* Sample data: 3 subjects, 3 visits each, with numeric AVAL scores
*==============================================================================;

data advs;
  infile datalines dlm='|' dsd missover;
  input USUBJID : $7. VISITNUM PARAMCD : $6. AVAL;
  datalines4;
101-001|1|SYSBP|130
101-001|2|SYSBP|125
101-001|3|SYSBP|120
101-002|1|SYSBP|145
101-002|2|SYSBP|140
101-002|3|SYSBP|138
101-003|1|SYSBP|118
101-003|2|SYSBP|122
101-003|3|SYSBP|119
;;;;
run;

proc sort data=advs;
  by USUBJID VISITNUM;
run;

*==============================================================================;
* WRONG WAY: LAG inside a conditional IF
*==============================================================================;
* The LAG queue advances every time the DATA step executes the LAG() call.
* Placing LAG inside IF means it only advances on rows where the IF is true,
* so the "previous" value is not actually the previous row.
*------------------------------------------------------------------------------;

data wrong;
  set advs;
  by USUBJID VISITNUM;
  if VISITNUM > 1 then do;
    prev_aval = lag(AVAL);
    change    = AVAL - prev_aval;
  end;
run;

*==============================================================================;
* RIGHT WAY: call LAG before any conditional logic
*==============================================================================;
* We call LAG unconditionally so the queue advances on every row.
* Then we use the stored value only when we need it.
*------------------------------------------------------------------------------;

data correct;
  set advs;
  by USUBJID VISITNUM;
  prev_aval = lag(AVAL);
  if first.USUBJID then do;
    prev_aval = .;
    change    = .;
  end;
  else change = AVAL - prev_aval;
run;

proc print data=correct noobs;
run;

We start with ADVS sorted by USUBJID and VISITNUM so each subject's visits appear in order.
LAG(AVAL) returns the value of AVAL from the previous time the LAG function was called — not necessarily the previous row in the dataset.
In the WRONG example, lag(AVAL) sits inside if VISITNUM > 1. On VISITNUM = 1 the LAG call never executes, so the internal queue does not advance. On VISITNUM = 2, LAG returns the value from the last time it ran — which was the previous subject's last visit, not the current subject's baseline.
In the RIGHT example, we call prev_aval = lag(AVAL) unconditionally on every row, so the queue always moves forward one step.
We then use first.USUBJID to blank out prev_aval and change on the first row of each subject, because lagging across subjects is meaningless.
The else branch computes change = AVAL - prev_aval only for visits after baseline.
This unconditional-LAG-then-guard pattern is the standard safe approach in clinical SAS programming.

R (tidyverse)+

library(dplyr)

# ==============================================================================
# Sample data: 3 subjects, 3 visits each, with numeric AVAL scores
# ==============================================================================

advs <- tibble(
  USUBJID  = rep(c("101-001", "101-002", "101-003"), each = 3),
  VISITNUM = rep(1:3, times = 3),
  PARAMCD  = "SYSBP",
  AVAL     = c(130, 125, 120, 145, 140, 138, 118, 122, 119)
)

# ==============================================================================
# lag() inside group_by — no conditional gotcha
# ==============================================================================

correct <- advs %>%
  arrange(USUBJID, VISITNUM) %>%
  group_by(USUBJID) %>%
  mutate(
    prev_aval = lag(AVAL),
    change    = AVAL - prev_aval
  ) %>%
  ungroup()

print(correct)

We load dplyr and build the same ADVS tibble with 3 subjects and 3 visits each.
arrange(USUBJID, VISITNUM) sorts the data so visits are in order within each subject.
group_by(USUBJID) tells dplyr to treat each subject as a separate group — lag() will not cross group boundaries.
lag(AVAL) inside mutate() returns the previous row's AVAL within the group. The first row of each subject gets NA automatically.
R's lag() does not have the SAS conditional-queue gotcha. It always looks at position n−1 in the current group, regardless of any surrounding if or case_when logic.
We compute change = AVAL - prev_aval directly; rows where prev_aval is NA produce NA for change, which is correct.
After running, we confirm that each subject's VISITNUM 1 has NA for prev_aval and change, while later visits show the difference from the previous visit.

Happy learning!

Search lessons

Introduction

LAG: Access the Previous Row's Value