In SAS, wie Sie Zusammenbruch mehrere Zeilen in eine Zeile basierend auf einem ID-variable?

Gewissem Maße die gewünschte Effizienz dieser bestimmt die beste Lösung.

Zum Beispiel, vorausgesetzt, Sie wissen, die maximale sinnvolle Anzahl von fill-Daten, könnten Sie Folgendes verwenden, um sehr schnell eine transponierte Tabelle - wahrscheinlich der Schnellste Weg, das zu tun - aber um den Preis, dass eine große Menge von post-processing, wie es ausgegeben wird eine Menge von Daten, die Sie nicht wirklich wollen.

proc summary data=have nway;
class id sex race;
output out=want (drop=_:) 
        idgroup(out[5] (drug dose filldate)=) /autoname;
run;

Auf der anderen Seite der Dinge, die vertikale-und-Transposition ist die "beste" Lösung in Bezug auf die nicht erfordert zusätzliche Schritte; obwohl es möglicherweise langsam.

data have_t;
  set have;
  by id sex race drug dose notsorted;
  length varname value $64; *some reasonable maximum, particularly for the drug name;
  if first.ID then do;
    drugcounter=0;
  end;     
  if first.dose then do;
    drugcounter+1; 
    fillcounter=0;
    varname = cats('Drug',drugcounter);
    value   = drug;
    output;
    varname = cats('DrugDose',drugcounter);
    value = dose;
    output;
  end;
  call missing(value);
  fillcounter+1;
  varname=cats('Filldate',drugcounter,'_',fillcounter);
  value_n = filldate;
  output;
run;
proc transpose data=have_t(where=(not missing(value))) out=want_c;
  by id sex race ;
  id varname;
  var value;
run;
proc transpose data=have_t(where=(not missing(value_n))) out=want_n;
  by id sex race ;
  id varname;
  var value_n;
run;

data want;
  merge want_c want_n;
  by id sex race;
run;

Es ist nicht verrückt langsam, wirklich, und Chancen sind, es ist gut für Ihre 50k-IDs (obwohl Sie nicht sagen wie viele Drogen). 1 oder 2 GB Daten funktioniert Prima hier, vor allem, wenn Sie nicht brauchen, um Sie zu Sortieren.

Schließlich gibt es einige andere Lösungen, die sind in zwischen. Sie konnten den transpose ganz mit arrays in die Daten Schritt für einen, der vielleicht der beste Kompromiss; Sie haben, im Voraus zu bestimmen, die maximale Schranken für die arrays, aber das ist nicht das Ende der Welt.

Es hängt alles von Ihren Daten, aber das ist wirklich das beste. Ich würde wahrscheinlich versuchen, die Daten Schritt/transpose ersten: das ist die einfachste, und die meisten anderen Programmierer gesehen haben, so ist es wahrscheinlich die beste Lösung, es sei denn, es ist extrem langsam.

Hier ist mein Versuch, eine array-basierte Lösung:

/*  Import data */
 data have; 
 input @2 ID  @9 Sex $1. @18 Race $5. @31 Drug $11. @44 Dose $5. @58 FillDate mmddyy8.;
 format filldate yymmdd10.;
 cards;
 1      M        White        ziprosidone  100mg         10/01/98     
 1      M        White        ziprosidone  100mg         10/15/98
 1      M        White        ziprosidone  100mg         10/29/98
 1      M        White        ambien       20mg          01/07/99
 1      M        White        ambien       20mg          01/14/99
 2      F        Asian        telaprevir   500mg         03/08/92
 2      F        Asian        telaprevir   500mg         03/20/92
 2      F        Asian        telaprevir   500mg         04/01/92
 ;
 run;


/* Calculate array bounds - SQL version  */
proc sql _method noprint;
    select DATES into :MAX_DATES_PER_DRUG trimmed from 
        (select count(ID) as DATES from have group by ID, drug, dose)
        having DATES = max(DATES);
    select max(DRUGS) into :MAX_DRUGS_PER_ID trimmed from 
        (select count(DRUG) as DRUGS from 
            (select distinct DRUG, ID from have)
            group by ID
        )
    ;       
quit;

/* Calculate array bounds - data step version */
data _null_;
    set have(keep = id drug) end = eof;
    by notsorted id drug;
    retain max_drugs_per_id max_dates_per_drug;
    if first.id   then drug_count = 0;
    if first.drug then do;
        drug_count + 1;
        date_count = 0;
    end;
    date_count + 1;
    if last.id      then max_drugs_per_id   = max(max_drugs_per_id,     drug_count);
    if last.drug    then max_dates_per_drug = max(max_dates_per_drug,   date_count);
    if eof then do;
        call symput("max_drugs_per_id"  ,cats(max_drugs_per_id));
        call symput("max_dates_per_drug",cats(max_dates_per_drug));     
    end;
run;


/* Check macro vars */
%put MAX_DATES_PER_DRUG = "&MAX_DATES_PER_DRUG";
%put MAX_DRUGS_PER_ID   = "&MAX_DRUGS_PER_ID";

/* Transpose */
data want;
    if 0 then set have;
    array filldates[&MAX_DRUGS_PER_ID,&MAX_DATES_PER_DRUG] 
    %macro arraydef;
        %local i;
        %do i = 1 %to &MAX_DRUGS_PER_ID;
            filldates&i._1-filldates&i._&MAX_DATES_PER_DRUG
        %end;
    %mend arraydef;
    %arraydef;
    array drugs[&MAX_DRUGS_PER_ID] $11;
    array doses[&MAX_DRUGS_PER_ID] $5;
    drug_count = 0;
    do until(last.id);
        set have;
        by ID drug dose notsorted;
        if first.drug then do;
            date_count = 0;
            drug_count + 1;
            drugs[drug_count] = drug;
            doses[drug_count] = dose;
        end;
        date_count + 1;
        filldates[drug_count,date_count] = filldate;
    end;
    drop drug dose filldate drug_count date_count;
    format filldates: yymmdd10.;
run;

Den data-Schritt-code für die Berechnung der array-Grenzen, ist wahrscheinlich effizienter als SQL-version, aber es ist auch etwas Ausführlicher. Auf dem anderen hand, mit der SQL-version müssen Sie auch trim whitespace von der makro-vars. Behoben - vielen Dank Tom!

Die zur Umsetzung der Daten Schritt ist wahrscheinlich auch auf die effizientere Ende der Skala im Vergleich zu den proc transpose /proc sql Optionen in den anderen Antworten, da macht es nur 1 weiterer Durchlauf durch den Datenbestand, aber wieder, es ist auch ziemlich Komplex.