SAS 在 DO 直到循环中集成 RETAIN 和计算新变量

Question

I have been struggling with some code. I have clinical data where each row represents one admission. I would like to restructure the data so that each row represents one patients. However, there is a number of tasks I would like to conduct during the process:

1. Patients specific information is mostly, but now always contained in the first admission. For example gender is always on the first admission, but the date of death (deathdate) can be in the row of any admission. That's why I would like to retain the value of deathdate when not missing !

2. I would like to keep some specific data from the first admission always such as tumor stage.

3. I would like to conduct some operations between values from different admissions for example: calculate the difference in duration between the two admission dates.

How can I do this most efficiently with the lowest number of new variables created, smallest number of DATA, DROP and RENAME statements?

Please find examples of the data I have and what I want further.

I used to use DO loop like this

data want;
    do until (Last.ID);
set have;
by ID;
    select (admission);
        when ('1') do; GenderNew = Gender; StageNew = stage; deathdate1 = deathdate; admission_date1 = admission_date; end;
        when ('2') do; deathdate2 = deathdate; admission_date2 = admission_date; end;
    otherwise;
    end;
end;
drop admission gender stage deathdate admission_date;
run;

data want; set want;
format deathdate ddmmyy10.;
rename GenderNew = Gender StageNew = Stage;
Duration = admission_date2 - admission_date1;
deathdate = max(deathdate2, deathdate1);
drop admission_date1 admission_date2 deathdate1 deathdate2;
run;

However, my method is annoying. Specially, that I need to create many new variables from the first observation instead of retaining them somehow. I have about 100 variables that I need to keep and it does not makes sense to make 100 new variables.

Is there a more efficient way?

Thanks in forward.

Data example:

data have;
input id admission gender $ stage admission_date deathdate;
format deathdate ddmmyy10.;
cards;
1 1 m 2 5000 .
1 2 . . 5100 6500
2 1 f 1 5600 6600
2 2 . . 5900 .
3 1 f 4 5627 .
3 2 . 3 5830 7000
3 3 . 1 6000 .
;
run;

data want;
input id gender stage Duration deathdate;
format deathdate ddmmyy10.;
cards;
1 m 2 100 6500
2 f 1 300 6600
3 f 4 373 7000
;
run;

Answer 1

My favorite way to "flatten" datasets is the self-update.

data want;
  update have(obs=0) have;
  by id;
  keep id gender stage deathdate;
run;
  

Now, this doesn't calculate duration, but that's not hard to add.

data want;
  update have(obs=0) have;
  by id;
  retain first_stage;
  rename first_stage = stage;
  keep id gender first_stage duration deathdate;
  duration = admission_date-lag(admission_date);
  if first.id then first_stage = stage;
run;
  

This will only be actually saved for the last record on each case; if they all have 2 (or more) then you don't need to qualify it, otherwise add another line after if first.id then call missing(duration); (which doesn't hurt in any event, just don't put the if around the duration calculation as then lag doesn't work properly).

This may not solve your other issue, though, as I don't know why you'd have 100s of variables. The other simple option is proc transpose and then work with what you get out of that.

Answer 2

I propose the following scalable solution.

It is scalable because you don't need to create copies of the 100 variables you mention... Instead you just need to list the variables whose value to keep should be the value of the first record by ID, and the variables whose value to keep should be the last non-missing value.

Note: The code where you create the have and want datasets is copied here with two fixes: (i) respective $ symbols were added to the two input statements to state that gender is character; (ii) the calculation of Duration for id = 2 in the want dataset was fixed to the correct value of 300 .

data have;
input id admission gender $ stage admission_date deathdate;
format deathdate ddmmyy10.;
cards;
1 1 m 2 5000 .
1 2 . . 5100 6500
2 1 f 1 5600 6600
2 2 . . 5900 .
3 1 f 4 5627 .
3 2 . 3 5830 .
;
run;

data want;
input id gender $ stage Duration deathdate;
format deathdate ddmmyy10.;
cards;
1 m 2 100 6500
2 f 1 300 6600
3 f 4 203 .
;
run;


/* PARAMETER DEFINITION
Define the variables to keep from first record by ID and the variables to keep
from last non-missing occurrence.

Note that we need to separate the CHAR variables from the NUMERIC variables
because the variables are listed in an ARRAY below and ARRAY variables must all 
be of the same type.

The same should be done for the last non-missing value to keep if there happen
to be both CHAR and NUMERIC variables (which is not the case here).

The code below assumes that there is at least ONE variable for each of the
concerned variables.
If this is not always the case, appropriate %IF statements could be added to
check if the number of variables is equal to 0 before defining their respective
array and updating them. Search for SAS macro programming.
*/

* Variables to keep from first record by ID;
%let keep_from_first_record_char = gender;
%let keep_from_first_record_num = id stage;

* Variables to keep from last non-missing occurrence;
%let keep_last_non_missing = deathdate;

* Number of variables in each group (used when defining the arrays below);
%let n_keep_from_first_record_char = %sysfunc(countw(&keep_from_first_record_char));
%let n_keep_from_first_record_num = %sysfunc(countw(&keep_from_first_record_num));
%let n_keep_last_non_missing = %sysfunc(countw(&keep_last_non_missing));


/* DATA PROCESS
Flatten the input dataset to one record per ID
*/

* The dataset is assumed to be sorted by ID;
data flattened;
    format id gender stage Duration deathdate;
    keep id gender stage Duration deathdate;
    set have;

    * Array definition of permanent variables;
    array arr_keep_from_first_record_char(*) $ &keep_from_first_record_char;
    array arr_keep_from_first_record_num(*) &keep_from_first_record_num;
    array arr_keep_last_non_missing(*) &keep_last_non_missing;

    * Array definition of temporary variables;
    array tmp_keep_from_first_record_char(&n_keep_from_first_record_char) $ _ctmp1-_ctmp&n_keep_from_first_record_char;
    array tmp_keep_from_first_record_num(&n_keep_from_first_record_num) _ntmp1-_ntmp&n_keep_from_first_record_num;
    array tmp_keep_last_non_missing(&n_keep_last_non_missing) _TEMPORARY_;
    * Retain the variables that store the first observed value by ID;
    retain _ctmp1-_ctmp&n_keep_from_first_record_char;
    retain _ntmp1-_ntmp&n_keep_from_first_record_num;

    * ID variable that groups the records;
    by id;

    * 1) Store first observed value for keep_from_first and set to missing keep_last_non_missing;
    if first.id then do;
        do i = 1 to dim(arr_keep_from_first_record_char);
            tmp_keep_from_first_record_char(i) = arr_keep_from_first_record_char(i);
        end;
        do i = 1 to dim(arr_keep_from_first_record_num);
            tmp_keep_from_first_record_num(i) = arr_keep_from_first_record_num(i);
        end;
        do i = 1 to dim(arr_keep_last_non_missing);
            call missing(tmp_keep_last_non_missing(i));
        end;
    end;

    * 2) Store last non-missing value found;
    do i = 1 to dim(arr_keep_last_non_missing);
        if not missing(arr_keep_last_non_missing(i)) then
            tmp_keep_last_non_missing(i) = arr_keep_last_non_missing(i);
    end;

    * 3) Compute other variables;
    admission_date_prev = lag(admission_date);
    if not first.id then
        Duration = admission_date - lag(admission_date);

    * 4) Set values of variables to output for this ID;
    if last.id then do;
        do i = 1 to dim(arr_keep_from_first_record_char);
            arr_keep_from_first_record_char(i) = tmp_keep_from_first_record_char(i);
            put i= arr_keep_from_first_record_char(i) tmp_keep_from_first_record_char(i);
        end;
        do i = 1 to dim(arr_keep_from_first_record_num);
            arr_keep_from_first_record_num(i) = tmp_keep_from_first_record_num(i);
        end;
        do i = 1 to dim(arr_keep_last_non_missing);
            arr_keep_last_non_missing(i) = tmp_keep_last_non_missing(i);
        end;
        output;
    end;

    drop i;
run;

* Check if flattened = want;
proc compare base=want compare=flattened; run;