Archive for the ‘Par Niveau Certification’ Category

h1

Combien de contrats ai-je au total ? (2/5) RETAIN

novembre 3, 2008

Après un premier article faisant appel à la procédure SQL pour identifier le nombre total de contrats d’un type donné à partir d’un data set SAS, voici comment un compteur dans une étape data peut résoudre le problème.

1. Renommer des variables

  • Avoir les mêmes noms en entrée et en sortie : Dans le cas présent, il faut définir de nouvelles variables ayant un nom différent de ceux existant. Pour avoir quand même au final le même nom qu’au départ, j’ai choisi de renommer mes variables d’origines rendant leur ancien nom de nouveau disponible.
  • Quel nom pour les variables ? Ces variables portent un nom commençant par un tiret bas (underscore). Cela permet d’avoir un nom toujours parlant et de les supprimer rapidement avec _: (supprimer toutes les variables commençant par un tiret bas).
data solution2 (drop=_: );
   set contrats (rename=(tel=_tel
                         habitat=_habitat);
   *...;
run;

D’autres variables sont supprimées :

  • La variable CLIENT disparaît dès de départ car il ne sert pas dans notre cas.
  • La variable NB_CNTR disparaît seulement à la fin car elle va servir pour faire nos calculs.
data solution2 (drop=_: nb_contr);
   set contrats (drop=client
                 rename=(tel=_tel
                         habitat=_habitat);
   *...;
run;

2. Créer un compteur

Une fois les variables d’origine renommées, les variables TEL et HABITAT sont initialisées à 0 avec un RETAIN. Cela veut dire que pour toutes les observations, ces variables ont dans un premier temps la valeur 0. SAS lit les observations les une après les autres. A chaque fois qu’une valeur de TEL est changée toutes celles qui suivent le sont aussi. C’est le principe du RETAIN.

data solution2 ;*(...);
   set contrats ;*(...);
   retain tel 0
          habitat 0;
   tel     = tel     + nb_cntr * _tel;
   habitat = habitat+  nb_cntr * _habitat;
run;

SAS initialise les variable TEL et HABITAT : Tout d’abord TEL=0 et HABITAT=0.

nb_cntrt _tel _habitat tel habitat
    5      1      0     0     0
    1      1      0     0     0
    2      0      1     0     0
    1      1      0     0     0
    3      0      1     0     0
    2      1      0     0     0

SAS lit la première ligne du data set : A la lecture de la première ligne du data set CONTRATS, la variable TEL est mise à jour. Sachant que pour la première observation, il a 5 contrats (NB_CNTRT=5 et _TEL=1), la première valeur de TEL est égale à 5 et toutes celles qui suivent aussi.

nb_cntrt _tel _habitat tel habitat
    5      1      0     5     0
    1      1      0     5     0
    2      0      1     5     0
    1      1      0     5     0
    3      0      1     5     0
    2      1      0     5     0

SAS lit la seconde ligne du data set : A la lecture de la seconde observation, on ajoute 1*1 à 5. Le résultat (la valeur 6) se répercute sur toutes les observations de la variable TEL.

nb_cntrt _tel _habitat tel habitat
    5      1      0     5     0
    1      1      0     6     0
    2      0      1     6     0
    1      1      0     6     0
    3      0      1     6     0
    2      1      0     6     0

SAS lit la troisième ligne du data set : A la lecture de la troisième observation, la valeur de TEL ne change pas car on ajoute zéro (0+2*0). Par contre, celle d’HABITAT change.

nb_cntrt _tel _habitat tel habitat
    5      1      0     5     0
    1      1      0     6     0
    2      0      1     6     2
    1      1      0     6     2
    3      0      1     6     2
    2      1      0     6     2

A la fin : Au final, le data set a cette forme. Ce qui nous intéresse ici ce sont les valeurs 9 et 5 de la dernière ligne d’observations.

nb_cntrt _tel _habitat tel habitat
    5      1      0     5     0
    1      1      0     6     0
    2      0      1     6     2
    1      1      0     7     2
    3      0      1     7     5
    2      1      0     9     5

3. Garder la dernière observation

A présent, il s’agit de ne garder que la dernière observation. On commence par créer une variable EOF par l’intermédiaire de l’option END= dans l’instruction SET. Le nom de la variable ici fait référence à l’expression End of File. Mais vous êtes libre de choisir le nom qui vous convient.

  • Une option sans parenthèses : On notera que END= est une option de l’instruction SET et non une option du data set CONTRATS. C’est la raison pour laquelle elle n’apparaît pas entre parenthèses.
  • Une option en fin d’instruction : Les options du data set listées entre parenthèses doivent suivre immédiatement le nom du data set. L’option END= ne peut être ajoutée qu’après.

Cette variable (EOT) a deux particularités :

  • Une variable temporaire : D’une part, elle ne sera pas conservée dans le data set final SOLUTION2 ;
  • Une variable binaire : D’autre part, la variable est binaire ; elle prend la valeur 1 pour la dernière observation, 0 autrement.
data solution2 (...);
   set contrats (...) end=eof;
   *retain ...;
   *tel=...;
   *habitat=...;
   if eof then output;
   *if eof=1 then output;
run;

La condition : Dans la condition qui suit, seule la dernière observation d’EOT a la valeur 1. C’est donc la seule qui est retenue dans la condition. Le « =1 » est implicite dans la condition. C’est pour cela que les deux instructions, celle active et celle en commentaire, sont identiques.

L’action basée sur la condition : Le mot OUTPUT redirige la ligne sélection avec la condition dans le data set final SOLUTION2.

A dans huit jours, pour retrouver une solution avec PROC MEANS.

Annexe : Rappel sur les données et l’étape data dans son ensemble :

data contrats;
   input client $ nb_cntr tel habitat;
   datalines;
a 5 1 0
b 1 1 0
c 2 0 1
d 1 1 0
e 3 0 1
f 2 1 0
;
run;

data solution2 (drop=_: nb_cntr);
   set contrats (drop=client
                 rename=(tel=_tel
                         habitat=_habitat)
                 end=eof;
   retain tel 0
          habitat 0;
   tel     = tel     + nb_cntr * _tel;
   habitat = habitat + nb_cntr * _habitat;
   if eof then output;
run;
h1

Mettre à jour un data set à partir d’un autre

octobre 30, 2008

Si vous avez déjà utilisé un peu SAS, vous connaissez probablement les instructions SET et MERGE. Aujourd’hui, voici un article sur l’instruction UPDATE pour mettre à jour un data set. Cette instruction de l’étape DATA doit être utilisée en gardant en tête deux notions importantes expliquées ici.

Pour réviser ou découvrir les instructions SET et MERGE, reportez-vous aux articles suivants :

1. Un data set de base et un autre contenant des informations nouvelles

Dans notre exemple nous avons deux data sets YEAR_2007_FRST et YEAR_2007_EXTRA.

Le premier data set YEAR_2007_FRST est le data set à mettre à jour : il contient

  • 4 observations et
  • 3 variables numériques : MONTH (month pour mois), CRIT (criteria pour critère), VAL (value pour valeur).
data year_2007_frst;
   input month crit val;
   datalines;
1 2 3
4 5 6
9 9 9
10 10 10
;
run;

Le second data set YEAR_2007_EXTRA contient des informations à ajouter au premier data set. Il est composé de :

  • 5 observations : certaines lignes d’observations du premier data set sont présentes mais pas toutes. Il y a aussi des lignes d’observations en plus. Parfois la valeur de la variable MONTH est identique mais par forcément celle des autres variables.
  • 4 variables numériques : il y a les variables déjà présentes auparavant et une nouvelle variable.
data year_2007_extra;
   input month crit val val2;
   datalines;
1 2 3 4
1 4 5 6
7 8 9 10
9 9 . 9
10 10 .A 10
;
run;

2. Choisir une ou plusieurs variable clés

Avec l’instruction UPDATE, il faut définir une liste de variables clés. Lorsque la combinaison est présente dans les deux fichiers, les autres variables sont mises à jour. Sinon, une nouvelle ligne d’observations est ajoutée.

Ici, je choisis de désigner une ligne avec la variable MONTH et seulement la variable MONTH. Lorsque la variable MONTH du premier et du second data sets coïncident, les autres observations sont mises à jour en se servant du deuxième fichier (YEAR_2007_EXTRA).

data year_2007_frst;
   update year_2007_frst
          year_2007_extra;
   by month;
run;

Ajouter de nouvelles observations : Avec l’exemple de l’article, la ligne où MONTH = 7 n’est pas présente dans le premier data set. Elle est ajoutée.

Ajouter de nouvelles variables : La variable VAL2 est également nouvelle et ajoutée.

3. Une seule ligne d’observation par clé dans le fichier additionnel

Lorsque le fichier additionnel (WEAR_2007_EXTRA) contient plusieurs observations, seule une est gardée. Il est donc préférable d’avoir un fichier avec une seule ligne d’observation par variable clé.

Dans notre exemple, le fichier servant pour la mise à jour a deux lignes d’observations avec MONTH égales à 1. SAS utilisera, dans un premier temps, la première pour mettre à jour le fichier. Puis réécrira dessus avec la seconde ligne d’observation.

  • Avant :MONTH=1, CRIT=2, VAL=3
  • Après : MONTH=1, CRIT=4, VAL=5 et VAL2=6.

4. Ignorer les valeurs manquantes du fichier de mise à jour

Si dans votre fichier de mise à jour il y a des valeurs manquantes alors que dans le fichier d’origine ce n’était pas le cas, SAS n’effacera pas la valeur sauf si la nouvelle valeur est une valeur manquante particulière (special missing).

Dans notre exemple,

  • quand MONTH=9, VAL=9 avant et après, même si dans le data set additionnel, VAL était manquant (symbole point).
  • quand MONTH=10, VAL=10 avant et VAL=.A après, car la nouvelle valeur est une valeur qualifiée par SAS de valeur manquante spéciale.

Au final le nouveau fichier YEAR_2007_FRST, auquel un autre nom aurait pu être donné, se présente ainsi :

month crit val val2
  1     4   5    6
  4     5   6    .
  7     8   9   10
  9     9   9    9
  10   10  .A   10

5. Avoir une seule ligne par BY variable dans le fichier à mettre à jour

Après avoir noté que SAS ne remplace pas les valeurs existantes par des valeurs manquantes, je tenais à souligner une seconde particularité du UPDATE. SAS estime que la variable clé devrait identifier de manière unique une ligne d’observations dans le fichier à mettre à jour.

Dans notre exemple, SAS que la variable clé est MONTH. Il estime que chaque valeur de MONTH se doit d’être unique dans le fichier à actualiser (YEAR_2007_FRST).

Je vais donc ajouter une ligne pour que MONTH=1 apparaisse deux fois et voir la gestion qu’en fait SAS.

data year_2007_frst;
   input month crit val;
   datalines;
1 2 3
1 9 9
4 5 6
9 9 9
10 10 10
;
run;

Si ce n’est pas le cas deux choses se passe :

  • D’une part, un WARNING apparaît dans la log.
  • D’autre part, parmi les lignes ayant les mêmes valeurs clés, seule la première ligne sera actualisée.

Ici, la log contiendra le WARNING suivant :

  • WARNING: The MASTER data set contains more than one observation for a  BY group.

Et notre fichier final, lorsque la variable MONTH =1, seule aura

month crit val val2
  1     4   5    6
  1     9   9    .
  4     5   6    .
  7     8   9   10
  9     9   9    9
  10   10  .A   10

En résumé, avec une instruction UPDATE, il est important de garder à l’esprit trois notions :

  • les valeurs manquantes simples n’effacent pas les données d’origine.
  • le data set avec les données actualisées contiendra une seule ligne d’observation par variable clé et des conséquences si ce n’est pas le cas.
  • le data set à actualiser doit contenir une seule ligne d’observation par variable clé et ainsi respecter la définition de la syntaxe.

Vous trouverez dans la documentation en ligne une page sur UPDATE Statement pour compléter votre lecture.

h1

Combien de contrats ai-je au total ? (1/5) PROC SQL

octobre 27, 2008

Sur le forum www.commentcamarche.net, j’ai rencontré une question pour laquelle une série d’articles seront rédigés et ainsi pour présenter différentes solutions. Je commence aujourd’hui avec une procédure SQL précédée d’une introduction sur les données. Les quatre prochains articles utiliseront les compteurs, les procédures PROC MEANS, PROC FREQ et PROC TABULATE.

1. Les données

On part d’un fichier contenant une liste de clients et deux types de contrats : téléphone (tel) et habitation (habitat).

  • Une variable TEL indique si oui ou non le client a un contrat de téléphone peu importe qu’il s’agisse d’une ligne fixe, d’un téléphone portable personnel. Une variable NB_CNTR précise le nombre de contrats de ce type le client a signé.
  • Une variable HABITAT indique si oui ou non le client a un contrat en relation avec son habitat qu’il s’agisse de sa maison principale, sa maison secondaire ou d’un contrat de location pour ses enfants partis étudiés, etc. La variable NB_CNTR précise comme précédemment le nombre de contrats de ce type souscrit par le client.
data contrats;
   input client $ nb_cntr tel habitat;
   datalines;
a 5 1 0
b 1 1 0
c 2 0 1
d 1 1 0
e 3 0 1
f 2 1 0
;
run;

Objectif : Le but du jeu est de retrouver le nombre total de contrats téléphoniques et de contrats d’habitation, soit 9 dans le premier cas (5+1+1+2) et 5 dans le second cas (2+3).

2. La procédure SQL

Dans cet exemple, un data set, appelé SOLUTION1, est créé à partir du fichier CONTRATS.

Créer une nouvelle variable TEL : SAS créé une nouvelle variable TEL.

  • Nombre de contrats par client : Pour chaque ligne d’observation, SAS multiplie le nombre de contrat par la variable binaire TEL pour retrouver le nombre de contrats téléphonique par client.
a 5 1 0 => 5*1 = 5
b 1 1 0 => 1*1 = 1
c 2 0 1 => 2*0 = 0
d 1 1 0 => 1*1 = 1
e 3 0 1 => 3*0 = 0
f 2 1 0 => 2*1 = 2
  • Puis, il fait la somme de tous les nombres (5+1+0+1+0+2) pour connaître le nombre total de contrats téléphoniques. Ce nombre est répété pour chaque observation.
a 5 1 0 => 9
b 1 1 0 => 9
c 2 0 1 => 9
d 1 1 0 => 9
e 3 1 0 => 9
f 2 0 1 => 9

Créer une nouvelle variable HABITAT : De la même manière, une nouvelle variable HABITAT est créée.

  • Nombre de contrat par client : Pour chaque ligne d’observation, SAS multiplie le nombre de contrats par la variable binaire HABITAT pour retrouver le nombre de contrats liés à l’habitation par client.
a 5 1 0 => 5*0 = 0
b 1 1 0 => 1*0 = 0
c 2 0 1 => 2*1 = 2
d 1 1 0 => 1*0 = 0
e 3 0 1 => 3*1 = 3
f 2 1 0 => 2*0 = 0
  • Nombre total de contrats : Puis, il fait la somme de tous les nombres (0+0+2+0+3+0) pour connaître le nombre total de contrats d’habitation. Ce nombre est répété pour chaque observation.
a 5 1 0 => 5
b 1 1 0 => 5
c 2 0 1 => 5
d 1 1 0 => 5
e 3 0 1 => 5
f 2 1 0 => 5

Ne souhaitant pas afficher le nom des clients (variable CLIENT), il est possible d’extraire une seule ligne pour les nouvelles variables TEL et HABITAT en ajoutant le mot-clé DISTINCT. Comme toutes les lignes ont les valeurs 9 et 5, une seule sera conservée.

proc sql;
   create table solution1 as
      select distinct sum(nb_cntr*tel) as tel,
                      sum(nb_cntr*habitat) as habitat
      from contrats;
quit;

Je vous donne rendez-vous tous les lundi pour présenter une nouvelle solution à commencer par lundi prochain dans une étape data, basée sur la notion de variable compteur générée à partir d’un RETAIN.

h1

Afficher 7h30 du matin sous la forme 07:30

octobre 24, 2008

Les heures, minutes et secondes sont enregistrables sous SAS sous la forme d’un seul chiffre exprimant cette durée en seconde. On parle d’heure SAS (SAS time). A l’affichage, il y a le format TIME5. pour représenter les heures et les minutes uniquement à partir de 5 caractères au maximum. Mais ce format omet le zéro de début pour les heures à un chiffre comme 9h00. Voici donc dans cet article plusieurs solutions pour contourner le problème allant d’un format avec PICTURE, en passant par les fonctions RIGHT et TRANWORD.

1. Le data set servant d’exemple

Pour présenter les variantes, un data set NEWTIME est créé. Il contient une variable SEC avec 4 valeurs exprimant le temps en secondes et une valeur manquante.

  • 7h30 : prenons 7h30m00s ou 27000 secondes (7x60x60*60) pour exprimer 7h30 du matin
  • 15h : prenons maintenant 15h00m00s ou 54000 secondes pour obtenir 15h
  • 14h59 : pour désigner 14h59, des valeurs entre 14h59m00s (53940 sec) et 14h59m59s (53999 sec) sont possibles. Dans l’exemple, ces deux extrêmités sont choisies.
data newtime;
   input sec;
   datalines;
27000
54000
53940
53999
.
;
run;

2. Un format créé avec l’instruction PICTURE

La solution la plus flexible est probablement de créer un nouveau format. De cette manière, la valeur d’origine en seconde est encore disponible. Ce format peut aussi servir à convertir une variable caractère en heure SAS.

L’instruction PICTURE : Le format SASREF est construit à partir de l’instruction PICTURE dans une procédure PROC FORMAT. Le symbole %H réfère à des heures allant de 0h à 23h. Le symbole %M désigne des minutes allant de 0min à 59min. Le zéro intercalé ajoutera un zéro pour les valeurs inférieures à 10.

Documentation : Vous pouvez consulter la documentation en ligne pour connaître tous les symbole comme %M, %H disponible avec l’instruction PICTURE : PICTURE Statement.

proc format;
   picture sasref other='%0H:%0M' (datatype=time);
run;

Dans cet exemple, une variable caractère TIME_C est créée à partir de la fonction PUT et du format SASREF affichant 5 caractères.

Vous pouvez aussi exécuter l’instruction FORMAT pour appliquer le format SASREF5. à la variable SEC.

data newtime;
   set newtime;
   time_c=put(sec,sasref5.);
   *format sec sasref5.;
run;

3. Ajouter une condition pour traiter les valeurs manquantes

Une seconde variable TIME_C2 applique une contrainte particulière pour les valeurs manquantes. En effet, le format SASREF renvoie le mot ERROR si la valeur d’origine est manquante.

data newtime;
   set newtime;
   if not missing (sec) then time_c2=put(t1,sasref5.);
run;

4. Passer d’une valeur texte 7:30 à une valeur 07:30 avec les fonctions RIGHT et TRANWRD

Une troisième variable TIME_C3 est construite en deux étapes. Voyons donc l’interprétation faite pour une heure comme 7:30.

  • Fonction PUT et format TIME5 pour créer une valeur 7:30 : Tout d’abord, la fonction PUT combinée au format TIME5. crée une variable caractère de la forme 7:30 avec une longueur de 5. Par défaut, le texte est aligné à gauche. Le blanc est donc situé en 5ème position.
  • Fonctions RIGHT et TRANWORD pour ajouter un blanc en tête : Ensuite, une variable caractère 7:30 est convertie en 07:30, etc. Dans un premier temps, la fonction RIGHT aligne le texte à droite. Le blanc est en première position. Dans un second temps, la fonction TRANWRD remplace le blanc par un zéro.
data newtime;
   set newtime;
   if not missing (sec) 
   then time_c3=tranwrd(right(put(sec,time5.),' ','0');
run;

LA documentation en ligne propose une page sur les fonctions TRANWORD et RIGHT.

  • TRANWORD Function
  • RIGHT Function

Vous pouvez aussi consultez l’article sur la fonction PUT :

5. Aperçu des données

Voici un aperçu des différentes variables après :

sec     time_c time_c2 time_c3

27000   07:30   07:30   07:30
53940   14:59   14:59   14:59
53999   14:59   14:59   14:59
54000   15:00   15:00   15:00
    .   ERROR
h1

Ajouter des indentations dans un tableau

octobre 20, 2008

Avec PROC REPORT et PROC TABULATE, SAS crée des tableaux à partir d’un jeu de donnée (SAS data set). Dans certains cas, la lisibilité de ces tableaux est améliorée en ajoutant des indentations au texte (to indent). Nous verrons donc ici deux approches possibles : l’option INDENT de PROC TABULATE et le caractère hexadécimal pour les blancs dans PROC REPORT.

1. Un exemple pour illustrer la syntaxe sur les indentations

Dans les essais cliniques, trois types de tableaux/listings sont produits :

  • Démographie (demography) : descriptif des patients en terme d’âge, de sexe, de pays, etc.
  • Efficacité (efficacy) : l’efficacité du médicament par rapport à un autre ou par rapport à un effet placebo (le patient prend en médicament en pensant qu’il est actif alors qu’il ne l’est pas).
  • Sécurité (safety) : ces tableaux permettent l’analyse des effets secondaires d’un médicament.

Je vais prendre la cas d’un tableau démographique version réduite (trois colonnes) pour présenter la syntaxe sur les indentations.

  • La première colonne contient les caractéristiques démographiques (sexe et pays),
  • la seconde colonne compte le nombre de patients (N) pour chaque caractéristique
  • la troisième colonne donnera la répartition des patients en pourcentage (%).
---------------------------------
|                   |  N  |  %  |
|-------------------------------|
|Gender             |           |
|   Male            |   12| 48 %|
|   Female          |   13| 52 %|
|Country            |           |
|   France          |    6| 24 %|
|   Belgium         |   10| 40 %|
|   Luxemburg       |    9| 36 %|
---------------------------------

Des variables numériques pour ordonner les valeurs : Pour faciliter le tri des données, j’ai choisi d’avoir des variables numériques dans mon data set SAS sur lesquelles j’applique des formats.

  • Ainsi la premier variable (GRP) réfère à l’intitulé des caractéristiques démographiques : Gender (1) Country (2).
  • La seconde variable (SUBGRP) est l’ordre pour chaque caractéristique. J’aurais pu choisir des valeurs de 1 à 5 mais j’ai préféré que chaque chiffre des décimal corresponde à la variable GRP.
data patient_info;
   input grp subgrp cnt_n pct_n;
   datalines;
1 11 12 0.48
1 12 13 0.52
2 21  6 0.24
2 22 10 0.40
2 23  9 0.36
;
run;

Je choisi de créer des formats du même nom (GRP et SUBGRP) :

proc format;
   value grp     1='Gender'
                 2='Country';
   value subgrp 11='Male'
                12='Female'
                21='France'
                22='Belgium'
                23='Luxemburg';
run;

En outre, je crée un format avec PICTURE pour l’affichage des pourcentages. La raison est la suivante : par défaut, deux chiffres après la virgules apparaissent avec PROC TABULATE. De plus, je souhaite voir le symbole % s’afficher pour chaque pourcentage.

Un format BEST5. est ajouté pour des fréquences composées jusqu’à 5 chiffres sans décimale. De plus, il remplace les points par des blancs. Cela servira pour PROC REPORT.

proc format;
   picture pct (round) .     = ''
                       other = '099 %' (multiplier=100);
   value cnt           .     = ' '
                       other = [best5.];
run;

Dans les deux exemples qui suivent une indentation est formée de trois blancs.

2. L’option INDENT de PROC TABULATE

Dans l’exemple suivant, les deux variables GRP et SUBGRP sont traitées comme des variables textuelles.

L’instruction TABLE contient l’option INDENT= et précise ainsi le nombre de blancs pour décaler les valeurs de la variable SUBGRP vers la droite. Le résultat a été donné en début d’article.

proc tabulate data=patient_info noseps;
   class grp subgrp;
   table grp=''*subgrp='', cnt_n='N'*sum=' '*f=5.
                           pct_n='%'*sum=' '*f=pct.
         / rts=20 indent=3;
   format grp grp. subgrp subgrp.;
run;

Les options NO=SEPS et RTS= sont là pour personnaliser la mise en forme. Pour plus de précisions sur ces options, vous pouvez consulter la documentation en ligne :

  • NOSEPS sur la page « PROC TABULATE Statement »
  • RTS= sur la page « TABLE Statement »

3. Créer des variables alphanumériques (caractères) avec PROC REPORT

Ajouter une ligne pour chacune des caractéristiques : Toutes les informations sont créées manuellement. Ainsi, il y a en plus une ligne pour chaque groupe dans le data set SAS. Au lieu d’avoir 5 lignes, on en aura 7. Pour chaque nouveau GRP, la variable SUBGRP prendre la valeur du GRP + un zero afin d’apparaître en premier dans le rapport après un tri.

proc sort data = patient_info 
          out  = patient_report;
   by grp subgrp;
run;
data patient_report;
   set patient_report;
   by grp subgrp;
   output;
   if first.grp then
      do;
         subgrp=grp*10;
         cnt_n=.;
         pct_n=.;
      end;
run;

Trier par SUBGRP pour afficher les données dans l’ordre voulu.

proc sort data=patient_report;
   by grp subgrp;
run;

Une fois triées les données sont toujours numériques.

grp subgrp cnt_n pct_n

  1    10     .     .
  1    11    12  0.48
  1    12    13  0.52
  2    20     .     .
  2    21     6  0.24
  2    22    10  0.40
  2    23     9  0.36

Créer des variables caractères : la variable DSPLAY nouvellement créée peut contenir jusqu’à 15 caractères. Elle est composée des variables GRP et SUBGRP converties avec la fonction PUT.

Des hexadécimales pour créer des blancs : Les espaces sont créés à partir de valeurs hexadécimales. On répète ici trois fois A0 entre guillemets pour créer trois espaces. La lettre x qui suit précise à SAS qu’il s’agit d’hexadécimales. Ces trois blancs sont concaténés au résultat de la fonction PUT grâce aux deux barres.

data patient_report;
   length dsplay $15;
   set patient_report;
   if subgrp=0 then dsplay=put(grp,grp.);
   else dsplay='A0A0A0'x || put (subgrp,subgrp.);
   cnt_c=put(cnt_n,cnt.);
   pct_c=put(pct_n,pct.);
run;

Trier les données : La variable SUBGRP sert uniquement à définir l’ordre d’affichage des données mais n’apparaît pas dans le tableau final (option NOPRINT dans l’instruction DEFINE).

Enlever le titre de la colonne : La variable DSPLAY contient les caractéristiques démographiques. Aucun nom n’apparaîtra dans le titre de la colonne. Si les guillemets vides ne sont pas précisés, le nom de la variable est affiché.

Aligner à droite : Les variables caractères CNT_C et PCT_C sont affichées en tant que texte (DISPLAY) et leurs observations sont alignées à droite plutôt que d’être centrées (option RIGHT).

proc report data=patient_report;
   columns subgrp dsplay cnt_c pct_c;
   define subgrp / noprint order order=data;
   define dsplay / ' ' display;
   define cnt_c  / 'N' display right;
   define pct_c  / '%' display right;
run;

Dans ce cas, la sortie se présente sans ligne autour du cadre :

                     N      %
Gender
   Male             12   48 %
   Female           13   52 %
Country
   France            6   24 %
   Belgium          10   40 %
   Luxemburg         9   36 %

Sur le blog, vous trouverez d’autres articles sur les notions abordées ici :

h1

Copier la structure d’un data set et se séparer des données

octobre 16, 2008

Sous SAS, comment récupérer les caractéristiques d’un data set dans un autre data set sans les données et ainsi s’épargner un travail occasionnel mais qui peut vite devenir fastidieux ? Le nom des variables, leur position dans le data set et leurs autres attributs (type, longueur, format, informat) forme la structure d’un data set. Pour les récupérer, deux notations sont offertes : l’option OBS= dans une étape data et le mot LIKE dans une procédure SQL.

1. Créer le data set servant d’exemple

Pour illustrer les deux notations, nous partirons d’un data set nommé CLASS contenant une ligne d’observations et trois variables :

  • le nom de l’élève (NAME),
  • la date de début du cursus (SDT pour starting date) et
  • la date de fin du cursus (EDT pour ending date).

data class;
attrib name length=$15 label=‘Nom’
sdt informat=date9. format=date9. label=‘Starting Date’
edt informat=date9. format=date9. label=‘Ending Date’;
input name $ sdt edt;
datalines;
Charline 06OCT2006 15JUN2007
;
run;

Un PROC CONTENTS résumera les attributs des variables de la manière suivante :

proc contents data=class;
run;

# Variable Type Len Pos Format Informat Label

3 edt Num 8 8 DATE9. DATE9. Ending Date
1 name Char 15 16 Nom
2 sdt Num 8 0 DATE9. DATE9. Starting Date

1. Créer un data set vide

Dans cette première partie, un data set SQL_SOLUTION et ETAPE_DATA sont créés. Les deux ont la même structure

La procédure SQL : Au lieu de désigner toutes les variables à garder après un AS SELECT, on passe directement au data set de référence en l’introduisant avec le mot LIKE.

proc sql;
create table sql_solution like class;
quit;

L’étape data : L’option data set OBS= sur le fichier d’entrée précise qu’aucune observation ne sera lue. Seul le ‘header’ du data set contenant les caractéristiques sont lues par SAS et sauvegardées dans le data set de sortie ETAPE_DATA.

data etape_data;
set class (obs=0);
run;

SAS ira un peu plus vite avec une instruction STOP.

data etape_data;
set class;
stop;
run;

3. Ajouter des observations au data set vide

Une fois le data set copié sans les observations deux lignes sont ajoutées. La première désigne Jean-Pierre qui a début en janvier 2006. Christophe est nommé en second. Il a début le 7 octobre 2005 et terminé le 18 juin 2007.

La procédure SQL : Dans la PROC SQL, je vous propose d’ajouter les observations manuellement grâce à l’instruction INSERT INTO.

proc sql;
create table sql_solution like class;
insert into sql_solution
set name=‘Jean-Pierre’, sdt=’10JAN2006′d
set name=‘Christophe’, sdt=’07OCT2005′d, edt=’18JUN2007′d;
quit;

L’étape data : Dans un data step, les nouvelles observations sont sauvegardées dans un autre data set et sont ajoutées au moyen de l’instruction SET.

data add;
name=‘Jean-Pierre’;
sdt=’10JAN2006′d;
output;
name=‘Christophe’;
sdt=’07OCT2005′d;
edt=’18JUN2007′d;
output;
run;

data etape_data;
set class (obs=0)
add;
run;

Note : Dans ce cas, il faut que le data set contenant la structure apparaissent en premier. SAS sauvegarde toujours la première variable qu’il rencontre avec ses attributs. Proposer une autre variable du même nom avec des attributs différents ensuite n’alternera pas celles sauvegardées en premier.

h1

Renommer une variable (RENAME)

octobre 14, 2008

Pour renommer une variable SAS dispose d’une option RENAME applicable dans une étape data et dans une procédure. De plus, l’instruction RENAME de l’étape data et le mot-clé AS de la PROC SQL sont disponibles. Voici donc une présentation de ces différentes notations.

La base des exemples :

Pour illustrer le propos, le data set CLASS de la bibliothèque SASHELP aura deux variables à renommer : la variable NAME deviendra la variable NOM et la variable HEIGHT s’appellera TAILLE.

Une observation seulement sera gardée : celle concernant ‘Barbara’. Selon que les variables sont renommées dans le fichier d’entrée ou le fichier de sortie, la variable NAME ou NOM sera utilisée pour définir la condition.

Quel ordre ? : Qu’il s’agisse d’une option ou d’une instruction RENAME, il faut utiliser le signe égal (=) avec :

  • en premier, à gauche le nom actuel de la variable
  • en dernier, à droite le nouveau nom.

Pour s’en souvenir, vous pouvez imaginer une forme de flèche. A=>B symbole alors variable A donne/devient variable B).

1. Les options du data step en solitaire

Après avoir donné le nom d’un data set dans une étape data ou dans une procédure comme PROC SORT ou PROC TRANSPOSE, il est possible de lister des options entre parenthèses parmi lesquelles on trouve RENAME. L’option s’applique donc au data set nommé juste avant.

Dans une étape data, il est possible d’appliquer l’option RENAME sur les data sets à lire ou sur les data sets créés. Voici deux exemples avec des instructions SET. Cela marche aussi avec d’autres instructions nommant un data set comme MERGE.

Dans ce premier exemple, les variables NAME et HEIGHT du data set d’entrée (SASHELP.CLASS) sont renommées. Une fois cela fait, SAS effectue les étapes suivantes à savoir garder les observations se référant à Barbara. C’est pour cela que la condition s’applique sur la variable NOM.

data opt_in;
set sashelp.class (rename=(name=nom height=taille));
if nom=‘Barbara’ then output;
run;

Dans ce second exemple, l’option RENAME est appliquée sur le fichier de sortie. La condition est donc traitée par SAS avant que les variables soient renommées. Il faut désigner la variable avec son nom d’origine (NAME) dans la condition.

data opt_out (rename=(name=nom height=taille));
set sashelp.class;
if name=‘Barbara’ then output;
run;

Les deux data sets OPT_IN et OPT_OUT donnent le même fichier final.

nom Sex Age taille Weight

Barbara F 13 65.3 98

2. Les procédures

De la même manière, l’option RENAME peut s’appliquer sur le fichier d’entrée (sauf PROC SQL) et de sortie d’une procédure. Voici deux exemples avec les procédures PROC SORT et PROC SQL.

proc sort data=sashelp.class
out=class (rename=(name=nom height=taille));
by age;
run;

proc sql;
create table opt_out (rename=(name=nom height=taille)) as
select *
from sashelp.class;
quit;

La procédure SQL dispose du mot-clé AS pour renommer une variable en particulier parmi celles énumérées.

proc sql;
create table sql_as as
select name as nom, sex, age, height as taille, weight
from sashelp.class;
quit;

3. L’instruction RENAME du data step

Il existe une instruction RENAME s’appliquant uniquement à l’étape data. Il est important dans ce cas particulier de se rappeler que les variables sont renommées seulement une fois le data set final (INSTRUCT) créé. Le processus de SAS est donc le même qu’avec l’option sur le fichier OPT_OUT.

data instruct;
set sashelp.class;
rename name=nom height=taille;
if name=‘Barbara’ then output;
run;

4. L’option RENAME combinée avec d’autres options du data step

L’option RENAME n’est qu’une des options du data set SAS. Parmi les autres options les plus courantes, citons KEEP, DROP, WHERE, FIRSTOBS et OBS.

Dans ce dernier exemple, on pourra remarquer que l’option WHERE utilise la variable sur l’âge une fois celle-ci renommée. Tandis que l’option KEEP désigne la variable âge d’origine.

data class;
set sashelp.class (keep=age where=(_age=12) rename=(age=_age));
run;

h1

Mon petit doigt me dit que… le mot commence en position 2 (Fonction INDEX)

octobre 10, 2008

Pour savoir si un mot est présent dans une chaîne de caractère, il y a la fonction INDEX. Celle-ci retourne la position d’un « mot » dans une chaîne de caractère. Parmi les fonctions qui lisent les observations textuelles sous SAS, la fonction INDEX fait probablement partie du top 10 des fonctions les plus usuelles.

1. Deux paramètres de base

La chaîne de caractères à analyser est le premier paramètre de la fonction INDEX. Comme toute fonction, elle définie au choix par :

  • le texte entre guillemets
  • la variable caractère contenant toutes les observations à traiter.

Le texte à trouver est le second paramètre de la fonction INDEX. On le donne généralement entre  guillemets.

2. Que retourne la fonction ?

La fonction retourne un nombre : le nombre généré par la fonction INDEX représente la position de la première lettre du mot recherché. Si plusieurs mots sont disponibles dans la chaînes, SAS s’arrête au premier.

Et si aucun mot n’est présent ? Dans le cas où le mot n’est trouvé, la fonction INDEX retourne la valeur zéro. Ainsi si INDEX retourne une valeur supérieure à zéro, le mot est présent dans la chaîne de caractère, sinon il est absent.

3. Minuscules ou majuscules

La lettre A (majuscule) et a (minuscule) ne sont pas identiques. La fonction est sensible à la case.

Si la case de la chaîne de caractère vous importe peu, considérez la chaîne de caractères mise en majuscule (par exemple) avec la fonction UPCASE.

4. Un exemple

Dans l’exemple ci-dessous, le data set ONE a une ligne d’observation et trois variables X, Y et Z.

La variable Y retourne la position du mot ‘de’ (minuscule) dans la chaîne de caractères ‘ABC def DEG’. Il s’agit donc de la position 5.

La variable Z retourne la position du mot ‘DE’ (majuscule) dans la chaîne de caractères ‘ABC def DEG’. Il s’agit donc de la position 9.

data one;
x=‘ABC def DEG’;
y=index(x,’de’);
z=index(x,’DE’);
run;

h1

Supprimer un data set SAS en 6 points (PROC DATASETS)

octobre 6, 2008

Supprimer un data set SAS est une des fonctionnalités de la procédure PROC DATASETS. Voici donc quelques détails sur la syntaxe.

Les options de l’instruction PROC DATASETS donnent la possibilité de supprimer, dans une bibliothèque donnée, tous les fichiers sans distinction de nom (KILL). Certains options réduisent la sélection à certains types de fichiers (MEMTYPE). L’affichage par défaut dans les fenêtres OUTPUT et LOG est contrôlable avec d’autres options (NOLIST et NOWARN). Pour ajouter un peu de flexibilité, il est possible de nommer les fichiers à supprimer ou à garder dans des instructions complémentaires (DELETE et SAVE).

1. Un option pour supprimer tous les fichiers quelque soit leur nom, KILL : Pour supprimer tous les fichiers SAS contenu dans une bibliothèque temporaire, il suffit d’ajouter l’option KILL à l’instruction PROC DATASETS.

2. Par défaut, supprimer tous les types de fichiers MEMTYPE=ALL : En effet, l’option MEMTYPE est par défaut égale à tout (MEMTYE=ALL). Cela comprend 3 types de fichiers :

  • data sets (MEMTYPE=DATA),
  • vues (MEMTYPE=VIEW) ou
  • catalogues (MEMTYPE=CATALOG),

Cela veut dire que les formats, qui sont toujours sauvegardés dans un CATALOG, sont également supprimés.

3. Par défaut, supprimer les fichiers de la bibliothèque temporaire, LIB=WORK : De plus, par défaut, la bibliothèque est temporaire (LIB=WORK) est concernée.

Un premier exemples : Les deux procédures suivantes donnent le même résultat.

proc datasets kill;
quit;

proc datasets lib=work
memtype=all
kill;
quit;

4. Supprimer l’affichage dans la fenêtre OUTPUT avec l’option NOLIST : Pour éviter un affichage dans la fenêtre OUTPUT, vous pouvez ajouter l’option NOLIST ou encadrer la procédure entre deux instructions ODS :

  • ODS LISTING CLOSE : stopper la redirection par défaut vers la fenêtre OUTPUT
  • ODS LISTING : réactiver la redirection vers la fenêtre OUTPUT

5. Désigner les fichiers à garder ou supprimer par leur nom

Deux instructions, soit DELETE, soit SAVE permettent de se concentrer sur quelques fichiers en particulier à supprimer ou non quand l’option KILL n’est pas présente.

Si le type d’un fichier est différent de la majorité des fichiers listés dans l’instruction DELETE (ou SAVE), le type est à définir entre parenthèse avec le mot-clé MEMTYPE= après son nom.

Un second exemple en deux parties

Dans l’exemple qui suit, deux formats  (GENDER et GRP) créés dans la bibliothèque SASREF et tous les data sets de la bibliothèque SASHELP incluant le data set CLASS y sont également copiés.

libname sasref ‘C:/sasref/blog’;

proc format lib=sasref;
value gender 1=‘Male’
2=‘Female’;
value grp    1=‘Per Protocol (PP)’
2=‘Intent to Treat (ITT)’
3=‘Safety’;
run;

proc copy in=sashelp out=sasref memtype=data;
run;

Par défaut, tous les data sets listés dans l’instruction DELETE sont supprimés. A cela s’ajoute le catalogue contenant le format GRP. Il restera donc le format GENDER et tous les data sets sauf CLASS dans la bibliothèque SASREF.

proc datasets lib=sasref
memtype=DATA;
delete class grp (memtype=catalog);
run;

6. Supprimer un fichier qui n’existe pas

Dans certains cas, le nom des fichiers créés dans un programme varie. A la phase de suppression, le fichier manquant sera assortie d’une note dans la LOG:

NOTE: The file SASREF.GENDRE (MEMTYPE=CATALOG) was not found but appear on a DELETE statement.

Deux options s’offrent à vous pour l’éviter :

  • Ajouter l’option NOWARN : dans l’instruction PROC DATASETS, l’option empêchera l’affichage de la note sur les fichiers manquants.
  • Exécuter l’instruction conditionnellement : identifier les fichiers à supprimer au préalable via les dictionnaires et les stocker dans une macro variable.

NOTE : Sachez que PROC COPY a son équivalent dans la procédure PROC DATASETS. Cela dépasse cependant l’objet de cet article.

h1

Créer un data set à partir de données brutes (Line input)

septembre 25, 2008

Pour créer un data set SAS de but en blanc, il est possible de saisir des données manuellement ou de lire un fichier .TXT dans une étape DATA. Selon la structure des données 4 approches sont envisageables de manière distincte ou en combinaison. Lorsque chaque observation est séparée par des espaces, on parle de l’approche LINE INPUT. Cet article donne les rudiments de la syntaxe pour LINE INPUT.

1. Un premier exemple

Dans ce premier exemple, un data set nommé ONE est créé dans la bibliothèque WORK.

4 variables : Le data set ONE contient 4 variables, 3 numériques (NUM1-NUM3) et une texte (CHAR1). Les variables NUM1 et NUM apparaissent en premier. Elles sont suivies en troisième position de la variable CHAR1 et enfin de la variable NUM3. L’ordre d’affichage des variable est fonction de l’ordre dans lequel SAS rencontre la variable pour la première fois.

2 lignes d’observations : chacune des 4 variables contient deux observations.

Le symbole dollar : Dans ce premier exemple, on notera la présence d’un symbole dollar ($) après le nom de la variable texte CHAR1. Le symbole dollar permet donc de préciser que la variable qui le précède est une variable texte.

Datalines : Pour saisir les données dans l’étape data même, il faut commencer par ajouter une instruction DATALINES. Son ancien petit nom rencontré dans les documentations plus anciennes est CARD.

Important, le point-virgule : Il est important de noter qu’un point virgule terminant l’énumération des données se situe sur une ligne séparées des données.

data one;
input num1 num2 char1 $ num3;
datalines;
1 2 A 3
4 5 AA 6
;
run;

2. Ajouter des attributs

Dans ce second exemple, une variable texte (CHAR2) et une variable numérique (NUM4) sont ajoutées.

Préciser la longueur de la variable CHAR2 : Par défaut, les observations de plus de 8 caractères sont coupées. Ainsi United-Kingdom devient United-K.Lorsqu’une nouvelle variable texte est créée, il est important de préciser sa longueur.

A quel moment définir la longueur ? : Dans le cas présent, la longueur est à définir avant l’instruction INPUT. Sinon, SAS assignera une longueur de 8 par défaut et cette valeur ne pourra pas être changée. Cela veut dire que la variable CHAR2 sera la première variable rencontrée par SAS et qu’elle apparaîtra donc en premier dans le data set. Si vous voulez changer cet ordre, définissez explictement par exemple la longueur des autres variables. Pour plus de précisions pour changer  l’ordre d’affichage des variables, reportez-vous à l’article « Changer la séquence d’affichage des variables« .

Une instruction LENGTH : Pour définir une longueur de 20 octets représentant 20 caractères pour les données textes, l’instruction LENGTH est utilisée dans l’exemple. Comme il s’agit d’une variable caractère, il est important de le préciser en ajouter un symbole dollar avant le nombre 20.

data two;
length char2 $ 20;
input num1 num2 char1 $ char2 $ num3 num4;
informat num4 date9.;
format num4 date9.;
datalines;
1 2 A United-Kingdom 3 21MAR2009
4 5 AA France 6 31JAN2010
;
run;

Un informat pour interpréter les données à l’entrée dans un data set SAS : La variable NUM4 doit contenir des nombres représentant le nombre de jours écoulés depuis le 1er janvier 1960. Pour que SAS convertisse nos données, qui ont une structure de la forme JJMMMAAAA, on lui dit avec un INFORMAT.

La structure DATE9 : Dans notre cas, les 2 premier chiffres sont les jours, les 3 lettres qui suivent représentent les trois premières lettres du mois version anglaise et les 4 derniers chiffres sont l’année. Cette structure est appelée DATE9.

Un format pour interpréter les données d’un data set SAS : pour faciliter la lecture, il est possible d’afficher la date SAS (ce nombre « abstrait ») sous la structure DATE9. Pour cela, on applique un format à la variable NUM4. La valeur formatée apparaîtra par défaut dans un PROC PRINT.

3. Lire un fichier .TXT ou .DAT

Losque le nombre de données est important, il est préférable de stocker les données dans un fichier externe contenant des données brutes (.txt, .dat). Dans l’exemple qui suit, les données sont sauvegardées dans un fichier exemple_infile.txt.

L’instruction DATALINES n’est plus nécessaire à moins que vous souhaitiez ajouter des données à celles présentes dans le fichier externe.

Désigner le fichier dans un INFILE : L’instruction INFILE sert à désigner la source des données à lire. Dans cet exemple, le chemin complet d’accès au fichier est donné directement dans l’instruction INFILE entre guillemets.

data three;
infile ‘C:/sasref/exemple_infile.txt’;
length char2 $ 20;
input num1 num2 char1 $ char2 $ num3 num4;
informat num4 date9.;
format num4 date9.;
run;

Passer par un FILEREF : Il est aussi possible de donner un nom au chemin d’accès à ce fichier externe et de pointer ce fichier avec ce nom (FILEREF). Il faut alors ajouter une instruction FILENAME. En fin de programme, ce FILEREF est libéré pour une possible autre utilisation.

filename sasref ‘C:/sasref/exemple_infile.txt’;

data four;
infile sasref;
length char2 $ 20;
input num1 num2 char1 $ char2 $ num3 num4;
informat num4 date9.;
format num4 date9.;
run;

filename sasref clear;

h1

Trier les données par ordre croissant et décroissant

septembre 23, 2008

Pour trier (to sort en anglais) les données d’un tableau SAS dans un ordre croissant ou décroissant, il existe sous SAS deux approches : la première consiste à faire appel à la procédure PROC SORT sur un data set existant, la seconde consiste à ordonner les données sélectionnées dans une procédure PROC SQL.

1. L’exemple

Dans l’exemple ci-dessous, les données du data set CLASS situé dans la bibliothèque SASHELP sont triées selon les valeurs des variables SEX, AGE et NAME.

  1. Variable SEX, ordre croissant : Les données de la variable SEX sont d’abord triées par ordre croissant (increasing order). Les femmes (F pour Female) apparaissent en premier, les hommes (M pour Male) apparaissent en second.
  2. Variable AGE, ordre décroissant : Dans chacun des groupes, les données sont ensuite triées par ordre décroissant d’âge (descreasing order). Les femmes les plus âgées apparaissent en premier et les hommes les plus jeunes en dernier.
  3. Variable NAME, ordre décroissant : Enfin quand plusieurs personnes du même sexe et du même âge appaissent, les données sont triées par ordre alphabétique inverse.

2. Trier par ordre décroissant

Deux mots-clés différents : Pour trier les données par ordre décroissant, chaque variable doit être accompagnée d’un mot-clé. Il s’agit de DESCENDING avec PROC SORT et DESC avec PROC SQL.

Deux mot-clés situés à des endroits différents : Dans le cas de PROC SORT, ce mot DESCDENDING apparaît avant le nom de la variable. Dans le cas de la PROC SQL, DESC suit la variable

3. La procédure PROC SORT

Les data sets de la bibliothèque SASHELP sont des données figées par SAS. Elles ne peuvent donc pas être modifiées. C’est pourquoi dans l’exemple, un nouveau data set CLASS est créé dans la bibliothèque WORK grâce à OUT=.

proc sort data=sashelp.class out=class;
by sex descending age descending name;
run;

Un PROC PRINT suffira pour afficher les trois variables ou toutes les variables triées. NOOBS enlèvera le numéro des observations qui appraissent par défaut.

proc print data=class noobs;
*var sex age name;
run;

4. La procédure SQL

proc sql;
select sex, age, name
from sashelp.class
order by sex, age desc, name desc;
quit;

Rappel : Pour afficher toutes les variables remplacées la liste de SELECT par une étoile (*). Pour créer un data set, ajoutez CREATE TABLE class AS.

5. Le résultat

sex  age  name

F   15   Mary
F   15   Janet
F   14   Judy
F   14   Carol
F   13   Barbara
F   13   Alice
F   12   Louise
F   12   Jane
F   11   Joyce
M   16   Philip
M   15   William
M   15   Ronald
M   14   Henry
M   14   Alfred
M   13   Jefrrey
M   12   Robert
M   12   John
M   12   James
M   11   Thomas

h1

4 étapes de base pour créer un data set avec PROC SQL

septembre 18, 2008

La procédure SQL disponible sous SAS est une alternative à l’étape data (data step en anglais) dans de nombreuses situations. La syntaxe est dérivée du langage SQL abbréviation de Structured Query Language. Il s’agit donc de faire une requête (query) auprès de SAS pour extraire une information à partir d’un ou plusieurs jeux de données.

Voici donc ici l’occasion de voir la syntaxe de base pour créer un data set à partir d’un autre data set.

1. Début et fin : les instructions PROC SQL et QUIT.

Pour débuter une procédure SQL, il faut taper une instruction commençant par PROC SQL et finir avec une instruction QUIT (et non RUN). Entre ces deux instructions, une nouvelle instruction créera le nouveau data set.

Il est possible d’avoir autant d’instructions entre PROC SQL et QUIT que voulu. Dans la suite, seul un data set sera créé. Il n’y aura q’une seule instruction.

proc sql;
*instruction 1: créer un premier data set par exemple;
*instruction 2 : créer un second data set par exemple;

quit;

2. Lister les variables après SELECT

Un mot introductif, SELECT : l’instruction centrale débute avec le mot-clé SELECT. A la suite figurent toutes les variables à garder.

La virgule comme délimiteur : A la différence d’un data step, la procédure SQL utilise la virgule et uniquement la virgule comme délimiteur entre les noms de variables.

proc sql;
select age, height, weight
from sashelp.class;
quit;

Renommer une variable avec AS : Au stade de la sélection des variables, il est possible d’assigner un nom différent de celui d’origine en se servant du mot AS.

Dans l’exemple ci-dessous, la variable d’origine s’appelle HEIGHT. Après cette variable s’appelle TAILLE.

proc sql;
select height as taille
from sashelp.class;
quit;

Ajouter des attributs : Dans un data step, les instructions ATTRIB, LABEL, FORMAT, INFORMAT et LENGTH sont disponibles pour définir les attributs d’une variables. Avec PROC SQL, les attributs sont à donner après le nom de chaque variable.

Exemple : Dans cet exemple, toutes les variables reçoivent un label. De plus, la longueur des variables NAME (caractère) et AGE (numérique) sont redéfinies.

proc sql;
select name length=15 label=‘Nom’,
age length=4,
height label=‘Taille’,
weight label=‘Poids’
from sashelp.class;
quit;

Note : Dans un data step, un symbole dollar ($) est obligatoire pour définir la longueur des variables caractères, alors qu’avec PROC SQL, ce symbole n’est pas demandé.

Lister toutes les variables : pour lister toutes les variables du data set source rapidement, le symbole étoile (asterik) fera le travail. Rien n’empêche d’ajouter d’autres variables à la suite.

Exemple : Dans l’exemple ci-dessous, toutes les variables du data set CLASS situé dans la bibliothèque SASHELP sont gardées. De plus, pour chaque observation, une variable EXTRA prend la valeur ‘TEST’.

proc sql;
select *, ‘TEST’ as extra
from sashelp.class;
quit;

3. Définir le data set source avec le mot-clé FROM

Dans chacun des exemples ci-dessus, un data set source a été introduit pas le mot-clé FROM.

4. Assigner un nom de data set avec CREATE

Par défaut aucun data set n’est créé : Avec un data step, il faut dans un premier temps créer le data set pour pouvoir ensuite l’imprimer. Avec PROC SQL, les informations sont automatiquement envoyées dans la fenêtre de destination (OUTPUT par exemple) si aucun nom de data set n’est donné avant la sélection des variables.

La structure de début de l’instruction centrale : Pour donner un nom de data set, il faut commencer l’instruction centrale par :

CREATE TABLE mon_nom_de_table AS…

Pourquoi un mot-clé TABLE ? : La présence du mot-clé TABLE se justifie par le fait que SAS est capable de créer plusieurs types de fichiers : les SAS data sets appelés aussi TABLE, et les VIEW. Pour débuter seules les TABLES nous intéressent, l’usage des VIEW étant beaucoup plus occasionnel.

Par ailleurs, sachez que les options du data set vues dans un data step (DROP, KEEP, RENAME, WHERE…)  s’appliquent également dans la PROC SQL mais seulement une fois le nouveau data set créé. Pour les curieux, il y a l’article « Je garde ou je jette ? les variables« .

proc sql;
create table class (drop=age) as
select *, ‘TEST’ as extra
from sashelp.class;
quit;

Depuis la version SAS 9, SAS demande explicitement d’éviter de créer un data set portant le même nom que le data set source. Si vous le faites, un message apparaîtra dans la log.

WARNING: This CREATE TABLE statement recursively references the target table. A consequence of this is a possible data integrity problem.

h1

Je garde ou je jette? les variables

août 25, 2008

Pour garder ou supprimer sous SAS des variables, il y a les mots-clés KEEP (garder) et DROP (enlever). Sélectionner les variables nécessaires par la suite et seulement celles-ci est très important. Cela fait partie des outils pour améliorer la performance d’un programme tant en terme de temps d’exécution que le volume demandé pour stocker les data sets. Voici plus en détails, et avec des exemples, l’utilisation de ce vocabulaire qui s’applique au data step, aux procédures et à la syntaxe de l’ODS OUTPUT.

1. L’option dans un data step

Les mots KEEP et DROP servent principalement en tant qu’option appliquée à un data set donné. Elles sont alors listées juste après le nom du data set entre parenthèses et sont suivies du signe égal :

  • Keep= Data Set Option : nom_du_dataset (keep=nom_var1 nom_var2 etc)
  • Drop= Data Set Option : nom_du_dataset (drop=nom_var1 nom_var2 etc)

Exemple 1 : une instruction SET

data class (drop=weight: height:);
   set sashelp.class (keep=name weight height);
   weight_kg = weight*0.45359237;
   height_m  = height*0.0254;
   bmi       = weight_kg/height_m**2;
run;

Dans le cas présent, les variables NAME (nom), WEIGHT (poids) et HEIGHT (taille) sont lues dans le fichier d’origine SASHELP.CLASS et gardées. De nouvelles variables sont calculées pour avoir un poids en kilogramme (WIEGHT_KG) et une taille en mètres (HEIGHT_M). A partir du poids et de la taille, l’indicateur de masse corporelle (BMI) est calculé. Les variables, dont le nom commence par WEIGHT et HEIGHT, ne sont plus nécessaires par la suite. Elles sont donc supprimée dans le data set final appelé CLASS.

Soit le mot KEEP, soit le mot DROP est donné en option mais pas les deux afin d’éviter les confusions. Le choix entre KEEP et DROP dépend souvent du nombre de variables à lister par la suite. C’est donc un choix purement pratique.

Note, Indice de masse corporelle : L’indice de masse corporel (Body Mass Index, BMI) est égal au poids divisé par la taille au carré (poids/taille2). Le site de l’Organisation Mondiale de la Santé (World Health Organisation, WHO) donne des précisions sur le sujet.

Note, Conversion des unités de mesures (source Wikipedia) : je suppose que la taille donnée dans le fichier SASHELP.CLASS est exprimée en pouces (inches) et que le poids est exprimé en livres (pounds). Sachant qu’un pouce est égal à 2,54 cm et qu’une livre est égale à 0,45359237 kg, les tailles et poids du premier exemple ont pu être convertis en mètres et kilos.

Exemple 2 : une instruction MERGE

data age_ae;
   merge ae      (in=ref keep=name ae_id ae_sev)
         patient (keep=name age);
   by name;
   if ref;
run;

Dans ce second exemple, les patients ayant eu un effet secondaire (adverse event, AE) sont enregistrés dans le data set AE. Chaque effet secondaire est identifié de manière unique par les variables NAME et AE_ID. La sévérité de l’effet secondaire nous intéresse dans le data set AE.

A cette information, est ajouté l’âge du patient disponible dans la variable AGE du data set PATIENT.

La variable commune aux deux data sets est NAME. Il faut donc qu’elle reste dans les deux data sets. Seuls les patients ayant eu un effet secondaire sont sélectionnés grâce à l’option IN.

Pour tester l’exemple, vous trouverez en fin d’article un code créant les fichiers PATIENT et AE.

NOTE : Une variable utilisée par une autre option du data set comme RENAME ou WHERE ne pourra pas être supprimée au même moment.

2. Quelques exemples de procédures

Dans une procédure, elles suivent le nom du data set d’entrée et/ou du data set de sortie. Aucun autre mot ne doit être inséré entre le nom du data set et les options entre parenthèses.

  • proc sort data=… () out=…();
  • proc print data=… () width=min;
  • proc transpose data=…() out=…() prefix=visit;
  • proc freq data=…();
  • proc report data=…() split=’#’;
  • proc tabulate data=…()
  • proc gplot data=…()
  • proc boxplot data=…()
  • proc univariate data=…()
  • proc ttest data=…()
  • etc.

La procédure SQL liste les variables à garder après le mot SELECT. Il n’y a pas à ce stade d’option pour supprimer les variables. Par contre, on peut affiner la sélection après que le data set final soit créé. Bien sûr, le temps de lecture est augmenté puisque toutes les variables sont lues pour créer le data set et non un sous-ensemble.

proc sql;
   create table test (drop=ae_sdt ae_edt) as
      select a.*, age
      from ae a
      left join
           patient b
      on a.name=b.name;
quit;

NOTE : L’option WHERE est très pratique lorsqu’on en peut faire une sélection que sur le résultat de la fusion.

proc sql;
   create table test (where=(ae_sev=1 or age=12)) as
      select a.*, age
      from (select name, ae_id, ae_sev
            from ae) a
      left join
           (select name, age
            from patient) b
      on a.name=b.name;
quit;

3. L’option dans l’ODS OUTPUT

Les sorties générées par une procédure sont redirigeables vers un data set via l’instruction ODS OUTPUT. Le nom de la sortie est alors suivi du signe égal et du nom du data set de destination. Après ce nom les options sont ajoutables.

ods exclude all;
ods output onewayfreqs=exemple_ods (keep=age frequency percent);
proc freq data=sashelp.class;
   table age;
run;
ods output clear;
ods exclude none;

Deux articles sur l’ODS OUTPUT sont déjà à votre disposition

4. Les instructions KEEP et DROP dans un data step

En plus des options KEEP et DROP, il existe les instructions KEEP (KEEP Statement) et DROP (Drop Statement) pouvant être exécutées dans un data step. L’important ici est de se souvenir que l’instruction s’applique à la fin du data step, une fois que le data set final est créé. Ainsi il n’est pas possible de supprimer une variable en milieu de programme pour ensuite créer une autre variable du même nom.

data class (drop=i);
   do i=0 to 3;
      output;
   end;
   do i=10 to 12;
      output;
   end;
run;

data class;
   do i=0 to 3;
      output;
   end;
   drop i;
   do i=10 to 12;
      output;
   end;
run;

Les deux exemples ci-dessus font le même travail. La variable I n’apparaîtra pas dans le data set final car elle est supprimée en fin de programme.

Lectures complémentaires : Outre les options KEEP et DROP, le programmeur utilisera souvent les options RENAME et WHERE et de temps en temps les options FIRSTOBS et OBS. Pour une liste complète des options, consultez la documentation en ligne : SAS Data Set Option.

Après savoir comment supprimer les variables et donc les colonnes d’un data set SAS, vous serez peut-être intéressé de savoir comment supprimer ou garder certaines lignes d’un data set avec les mots-clés DELETE (DELETE Statement) et OUTPUT (OUTPUT Statement).

Annexe : Créer les data sets PATIENT et AE pour tester l’exemple avec MERGE.

data patient;
   set sashelp.class;
run;

data ae;
   set sashelp.class (keep=name);
   if name=‘Thomas’ then
      do;
         ae_id  = 1;
         ae_sdt = ’21MAR2007’d;
         ae_edt = ’28APR2007’d;
         ae_sev = 3;
         output;
         ae_id  = 2;
         ae_sdt = ’03JUN2007’d;
         ae_edt = ’19JUN2007’d;
         ae_sev = 1;
         output;
      end;
run;

h1

Supprimer des formats

août 7, 2008

Après avoir présenté dans l’article « 2 méthodes pour de nouveaux formats » comment créer un format de manières temporaire et permanente, nous allons voir comment les supprimer.

Rappel : les formats SAS sont sauvegardés dans un fichier nommé catalogue pour les formats (format catalog). Il peut exister plusieurs fichiers ayant des noms différents selon l’information donnée lors de la création dans l’option LIB= de PROC FORMAT. Si aucun nom en particulier n’a été donné lors de la création, alors le catalogue pour les formats s’appelle FORMATS et est sauvegardé temporairement dans la bibliothèque WORK.

1. Créer deux formats pour l’exemple

Dans un premier temps, pour illustrer le code, trois formats sont créés dans le catalogue nommé FORMATS de la bibliothèque WORK. Ces formats s’appellent NY, SEX et GENDER. Les deux premiers sont numériques, le troisième s’applique à des variables caractères.

Dans cet exemple les éléments mis en commentaire sont les valeurs implicites, celles que SAS utilise par défaut.

proc format; *lib=work.formats;
   value ny        1 = ‘NO’
                   2 = ‘YES’;
   value sex       1 = ‘Male’
                   2 = ‘Female’;
   value $ gender ‘M’ = ‘Male’
                  ‘F’ = ‘Female’;
run;

2. Supprimer un à un les formats du catalog

Avec la procédure PROC CATALOG, les formats NY et GENDER sont supprimés du catalogue FORMATS. Il restera le format SEX dans le catalogue. Il est impératif ici de nommer le nom du catalogue (FORMATS) et la bibliothèque où il est sauvegardé avec l’option CATALOG=.

Dans l’instruction DELETE figurent le nom des formats à supprimer. Le type d’entrée (entry type ou ET) est à préciser.

  • Dans le premier cas, les formats NY et GENDER sont de type différent. Chacun d’eux est suivi du type de l’entrée entre parenthèses. L’un est numérique (ET=FORMAT) et l’autre est caractère (ET=FORMATC).
  • Si tous les formats listés sont du même type, il est possible d’utiliser l’option ET= après une barre inclinée. Les formats AGE et SEX sont tous les deux numériques. L’option ET=FORMAT suffit.

proc catalog catalog=work.formats;
   delete ny (et=format) gender (et=formatc);
   *delete age sex / et=format;
run;

3. Supprimer le catalogue en entier avec tous ces formats

La procédure PROC DATASETS permet de supprimer un catalogue contenant des formats. Pour se faire, il faut d’abord préciser le type de fichier avec l’option MEMTYPE, la valeur par défaut étant DATA. Par défaut SAS recherchera le catalogue dans la bibliothèque WORK à moins de préciser une autre bibliothèque. Le nom du fichier catalogue contenant les formats est donné dans l’instruction DELETE

proc datasets memtype=catalog;*lib=work;
   delete formats;
run;

Annexe : cet exemple est le même que précédemment à une exception près.

  • D’une part, le format catalogue est maintenant permanent puisqu’il est sauvegardé dans la bibliothèque SASREF et non WORK.
  • D’autre part, il est sauvegardé avec un nom choisi par le programmeur (VERO) et non FORMATS.

libname sasref ‘C:/sasref’;

proc format lib=sasref.vero;
   value ny        1 = ‘NO’
                   2 = ‘YES’;
   value sex       1 = ‘Male’
                   2 = ‘Female’;
   value $ gender ‘M’ = ‘Male’
                  ‘F’ = ‘Female’;
run;

proc catalog catalog=sasref.vero;
   delete ny (et=format);
run;

proc datasets lib=sasref memtype=catalog;
   delete vero;
run;

h1

2 suggestions pour grouper les valeurs d’une variable

juillet 21, 2008

Sous SAS, lorsqu’une variable contient plusieurs valeurs à regrouper pour n’en former qu’une seule, il existe plusieurs options. Voici deux suggestions : une basée sur la notion de RETAIN et FIRST/LAST, l’autre sur PROC TRANSPOSE et ARRAY.

Pour illustrer le propos un data set liste plusieurs actions pour un patient à une visite donnée. Il s’agit de regrouper ces actions par patient et visite dans un seul record.

Le data set avant

pat_id  visit_dt rec_id action

   1   02APR2007    1   RAYON X
   1   02APR2007    2   ULTRASON
   1   02APR2007    3   SCANNER
   2   15NOV2007    2   RAYON X
   2   15NOV2007    1   ULTRASON

Le data set après : une nouvelle variable caractère est créée ACTION_LST. On lui donnera une longueur de 200. Chaque action y est séparée par une barre. Les variables REC_ID (identifiant du record) et ACTION sont supprimées.

pat_id  visit_dt action_lst

   1   02APR2007 RAYON X | ULTRASON | SCANNER
   2   15NOV2007 ULTRASON | RAYON X

1. La force du RETAIN

Pour débuter une variable ACTION_LST de longueur 200 est créée. Elle ne contient à la base aucune valeur.

data final; *(drop = rec_id action);
   set orig;
   by pat_id visit_dt;
   length action_lst $200;
   retain action_lst ‘ ‘;
   if first.visit_dt then action_lst=action;
   else action_lst=catx(‘ | ‘,action_lst,action);
   *if last.visit_dt then output;
run;

Pour chaque nouvelle visite de chaque patient, ACTION_LST est initialisée. Elle prend la valeur de la variable ACTION.

Du fait de la présence de l’instruction RETAIN, cette première valeur est maintenue pour tous les records d’une même visite. A chaque nouvelle lecture d’un record, une nouvelle action est ajoutée.

La fonction CATX permet de concaténer les valeurs d’ACTION_LST et ACTION, et d’ajouter la barre comme délimiteur.

Voici donc le résultat intermédiaire, avant l’activation du code mis en commentaires.

pat_id  visit_dt action_lst

   1   02APR2007 RAYON X
   1   02APR2007 RAYON X | ULTRASON
   1   02APR2007 RAYON X | ULTRASON | SCANNER
   2   15NOV2007 ULTRASON
   2   15NOV2007 ULTRASON | RAYON X

A présent, il s’agit de garder seulement le dernier record de chaque visite par patient avec LAST.VISIT_DT et à supprimer les variables REC_ID et ACTION.

2. Rotation de données (PROC TRANSPOSE) et lecture en boucle (ARRAY)

Avec cette seconde approche, le travail est découpé en deux étapes à commencer.

Dans un premier temps, un PROC TRANSPOSE pour faire pivoter les données. Le data set n’a alors plus qu’une ligne par visite de patient. Chaque action apparaît dans une colonne donnée.

proc transpose data=orig out=final2 (drop=_name_);
   by pat_id visit_dt;
   var action;
run;

pat_id  visit_dt  COL1      COL2      COL3

   1   02APR2007  RAYON X   ULTRASON  SCANNER
   2   15NOV2007  ULTRASON  RAYON X

Dans un second temps un ARRAY nommé _ACTION est défini. Il contient toutes les variables commençant par COL. A chaque nouvelle lecture d’une variable COL, sa valeur est ajoutée à celle de la variable ACTION_LST.

data final2 (drop=i col:);
   set final2;
   length action_lst $200;
   array _action {*} col:;
   do i=1 to dim(_action);
      action_lst = catx(‘ | ‘,action_lst,_action{i});
   end;
run;

Annexe : Création du data set utilisé pour l’exemple.

data orig;
   input pat_id visit_dt date9. rec_id action $15.;
   format visit_dt date9.;
   datalines;
1 02APR2007 1 RAYON X
1 02APR2007 2 ULTRASON
1 02APR2007 3 SCANNER
2 15NOV2007 2 RAYON X
2 15NOV2007 1 ULTRASON
;
run;

proc sort data=orig;
   by pat_id visit_dt;
run;

h1

Identifier et supprimer les doublons

juillet 14, 2008

Identifier et supprimer les doublons dans un data set fait partie des compétences de base du programmeur SAS. Trois approches sont envisageables : PROC SQL, PROC SORT et un compteur dans un data step.

Qu’appelle-t-on doublon ? des lignes complètement identiques ou seulement des lignes ayant quelques variables communes ? Il est important de savoir si deux records ayant des observations communes sont considérés comme doublons ou s’il faut que toutes les observations soient identiques. Si seules quelques variables sont considérées, il faut savoir quelle ligne est conservée et lesquelles sont supprimées.

Le data set utilisé pour l’exemple est composé de trois variables CNTRY (country), PAT_ID (patient ID) et VAL (value). Le patient 2 de Chine a trois lignes d’observations dont deux strictement identiques.

cntry    pat_id    val

 CN        1        A
 CN        2        B
 CN        2        C
 CN        2        C
 HK        3        E 

1. PROC SQL

Avec la procédure SQL, il est possible de faire des calculs et de baser sa sélection d’observations sur ce calcul. En d’autres termes, il est possible de compter le nombre de fois qu’une valeur apparaît. Pour identifier les records avec doublons, on prend ceux comptés plus d’une fois.

Première présentation : Voici, tout d’abord, une présentation de PROC SQL décomposable en deux étapes.

proc sql;
   create table two (where=(cnt_pat > 1)) as
      select cntry, pat_id, val, count(*) as cnt_pat
      from one
      group by cntry, pat_id;
quit;

Dans un premier temps, une variable donne le nombre de records par patient dans un pays donné (CNT_PAT) grâce à la syntaxe GROUP BY et la fonction COUNT. A ce stade, on obtient le data set suivant :

cntry pat_id val cnt_pat

  CN     1    A     1
  CN     2    C     3
  CN     2    B     3
  CN     2    C     3
  HK     3    E     1

Dans un second temps, seules les observations ayant des doublons sont gardées, une fois le nouveau data set créé, grâce à l’option WHERE=.

Deuxième présentation : Au lieu de créer la variable CNT_PAT et de faire une sélection ultérieure, la fonction COUNT peut être  ajoutée dans une condition introduite par le mot HAVING et faisant toujours appel à la fonction COUNT.

Pour ne voir qu’une des lignes multiples, il suffit d’ajouter DISTINCT.

proc sql;
   create table two_bis as
   select /*distinct*/ cntry, pat_id, val
   from one
   group by cntry, pat_id
   having count(*) > 1;
quit;

A l’inverse, pour ne sélectionner que les observations n’apparaissant qu’une fois, « >1 » sera remplacé par « =1 ». Seules les observations ayant exactement une occurrence sont sélectionnées.

Le DISTINCT s’applique à l’intégralité des observations. Cela permet de ne garder que des lignes uniques.

Il n’est pas possible de garder la première ligne parmi les doublons définis par des variables précises (CNTRY et PAT_ID dans l’exemple) avec cette méthode.

2. Les options de la procédure PROC SORT (NODUP/NODUPRECS, NODUPKEY)

Il existe deux options dans la procédure PROC SORT pour supprimer les doublons selon qu’ils s’appliquent

  • à toute une ligne d’observation (NODUPRECS dont l’alias est NODUP) ou
  • à une liste de variables précises données dans l’instruction BY (NODUPKEY).

Au choix, le nouveau data set sans doublons remplace l’ancien ou est sauvegardé dans un dataset différent introduit par OUT=.

Les observations ayant été exclues peuvent être sauvegardées dans un nouveau data set dont le nom est défini par DUPOUT=.

proc sort data=one out=three nodupkey dupout=three_bis;
   by cntry pat_id;
run;

proc sort data=one out=four noduprecs /*nodup*/ dupout=four_bis;
   by cntry pat_id;
run;

3. Appliquer une variable compteur

Enfin, après PROC SQL et PROC SORT, une troisième possibilité pour identifier et supprimer les doublons, est d’ajouter une variable compteur.

Dans l’exemple ci-dessous, la variable compteur est nommée CNT. Pour la première observation d’un patient d’un pays donné, le compteur est initialisé à 1. Pour chaque nouveau record du patient, le compteur est incrémenté de 1. Quand la variable CNT est égale à 1, le record est ajouté dans le data set FIVE. Sinon il est ajouté dans le data set FIVE_BIS. A la fin, la variable compteur est supprimée.

Ainsi le data set FIVE contient les records sans doublons. Dans le cas du patient doublonné (patient 2), c’est la première observation qui est conservée.

Dans le data set FIVE_BIS, les records exclus de la première sélection sont conservés.

data five (drop=cnt) five_bis (drop=cnt);
   set one;
   by cntry pat_id val;
   if first.pat_id then cnt=1;
   else cnt+1;
   if cnt = 1 then output five;
   else output five_bis;
run;

Annexe :

data one;
   input cntry $ pat_id $ val $;
   datalines;
CN 1 A
CN 2 B
CN 2 C
CN 2 C
HK 3 E
;
run;

h1

Faire pivoter un data set (un 1er exemple de PROC TRANSPOSE)

juillet 10, 2008

La transposition de jeux de données sous SAS est une étape fréquente dans le processus de programmation. Voici pour débuter un premier exemple pour se familiariser avec la syntaxe de base.

1. Les données d’origine

Le data set illustrant le sujet est composé de trois variables :

  • le numéro du patient (PAT_ID)
  • le numéro de la visite (VISIT) prenant les valeurs 18 pour début de visite, 50 pour fin de visite et 70 pour suivi
  • la date de cette visite (VISIT_DT).

En fin d’article, vous trouverez le code pour créer ce data set.

pat_id visit visit_dt

   1     18  25MAR2007
   1     70  15OCT2007
   1     50  01JUL2007
   2     18  14APR2007
   2     50  08AUG2007
   3     50  16OCT2007

2. Le minimum

Pour afficher une ligne par patient, il faut faire appel à la procédure PROC TRANSPOSE.

Dans le cas présent, on a choisi d’afficher la date de la visite (VAR VISIT_DT) pour chaque patient (BY PAT_ID). Le numéro de la visite est perdu dans cette transposition.

Le minimum de la syntaxe requiert la création d’un nouveau data set introduit par le mot-clé OUT=. Ce data set peut avoir le même nom que le data set d’origine. Il faut au moins lister une variable.

proc transpose data=one out=two;
   by pat_id;
   var visit_dt;
run;

pat_id  _NAME_    COL1      COL2      COL3

   1   visit_dt 25MAR2007 15OCT2007 01JUL2007
   2   visit_dt 14APR2007 08AUG2007         .
   3   visit_dt 16OCT2007         .         .

3. Les options et instructions supplémentaires

3.1 Des variables automatiques supprimées avec l’option DROP= : Le nom de la variable utilisée pour créer les colonnes COL1-COL3 est donné de manière automatique par SAS. Cette information est sauvegardée dans la variable _NAME_. Elle peut dont être supprimée avec l’option DROP attachée au data set de sortie nommé TWO.

proc transpose data=one out=two (drop=_name_);
   by pat_id;
   var visit_dt;
run;

pat_id         COL1         COL2         COL3

   1      25MAR2007    15OCT2007    01JUL2007
   2      14APR2007    08AUG2007            .
   3      16OCT2007            .            .

3.2 Une colonne propre à une visite donnée grâce à l’instruction ID : On remarque que pour le premier patient, la visite du 15 octobre est citée avant celle du 1er juillet. En d’autres termes, une colonne donnée ne correspond pas à une visite donnée mais à l’ordre des données dans le fichier source. De la même manière, la deuxième visite du troisième patient apparaît dans la première colonne.

Pour que chaque colonne corresponde à un numéro de visite donné, on fait appel à l’instruction ID suivie du nom de la variable définissant la colonne. Dans notre cas, il s’agit de la variable VISIT.

proc transpose data=one out=two (drop=_name_);
   by pat_id;
   var visit_dt;
   id visit;
run;

pat_id          _18          _70          _50

   1      25MAR2007    15OCT2007    01JUL2007
   2      14APR2007            .    08AUG2007
   3              .            .    16OCT2007

3.3 Des noms de colonnes personnalisés grâce à PREFIX = : Maintenant chaque colonne correspond à une visite en particulier. Comme les numéros de visites sont des nombres et que les variables de SAS ne peuvent commencer par un chiffre, SAS ajoute automatiquement un tiret bas devant. Pour donner un nom un peu plus parlant, on peut ajouter un préfixe à ces noms de colonne.

proc transpose data=one out=two (drop=_name_) prefix=VISIT;
   by pat_id;
   var visit_dt;
   id visit;
run;

pat_id      VISIT18      VISIT70      VISIT50

   1      25MAR2007    15OCT2007    01JUL2007
   2      14APR2007            .    08AUG2007
   3              .            .    16OCT2007 

3.4 Lister toutes les variables commençant par un nom donné

Avoir une série de variables commençant par le même préfixe présente des avantages car SAS permet d’y référer très simplement.

La syntaxe SAS : Pour lister toutes ces variables, il suffit de faire suivre le préfixe de deux points. Dans notre exemple, toutes les variables commençant par le mot VISIT sont listées avec VISIT:.

Voici quelques exemples d’applications de cette syntaxe :

  • un PROC TRANSPOSE : lister les variables à transposer
  • une option KEEP/DROP : lister les variables à garder ou à supprimer
  • un ARRAY : lister les variables définissant l’array.

Annexe :

data one;
   input pat_id visit visit_dt date9.;
   format visit_dt date9.;
   datalines;
1 18 25MAR2007
1 70 15OCT2007
1 50 01JUL2007
2 18 14APR2007
2 50 08AUG2007
3 18 16OCT2007
;
run;

h1

Penser conditionnel (2/3) : SELECT

juin 26, 2008

Pour dire à SAS quelles actions sont à mener si des critères sont remplis, nous avons vu la syntaxe IF/THEN/ELSE (voir article). Dans un data step, l’alternative à cette syntaxe, SELECT WHEN, fait l’objet du présent article.

1. La syntaxe de base

Toutes les conditions sont englobées entre l’instruction SELECT et l’instruction END.  Chaque condition est introduite par l’instruction WHEN. Les observations non sélectionnées avant la fin sont traités par l’instruction OTHERWISE.

A la différence de la syntaxe IF/THEN :

  • Les conditions sont listées entre parenthèses et aucun mot-clé n’introduit l’action.
  • Si toutes les conditions se basent sur une seule variable, celle-ci peut-être citée une seule fois et ce en tout début dans l’instruction SELECT. Mais il faut aussi que les valeurs prises par la variable soient toutes listées. Ainsi <5 ne marche pas mais 0,1,2,3,4 marche.

De la même manière que IF/THEN :

  • Seuls les records non sélectionnés pas un précédent WHEN sont considérées par les conditions suivantes. C’est le même principe que le ELSE IF.
  • Si plusieurs actions sont planifiées, celles-ci sont listées entre un DO et un END.

select  <nom_variable, optionnel> ;
when (<condition>)
do;
<action 1>;
<action 2>;
*etc;
end;
when (<condition>)  <action>;
otherwise <action>;
end;

2. Le caractère unique du SELECT WHEN

Pas d’action s’il vous plaît : Lorsqu’il n’y a aucune action pour une condition donnée, il est possible d’écrire une instruction WHEN sans donner de détails après la parenthèse. On parle d’instruction nulle.

OTHERWISE est parfois obligatoire : Si aucune condition n’est rempli pour un data set donné, il est important d’avoir une instruction OTHERWISE. Celle-ci peut rester vide d’action.

3. Illustration par un exemple

Premier exemple : les trois caractéristiques de ce premier exemple sont les suivantes.

  • La condition est basée sur une seule variable. On choisit dont de nommer une seule fois cette variable dans l’instruction SELECT.
  • Il y a plusieurs actions (DO/END) pour certaines conditions.
  • Dans le cas où aucune des conditions précédentes ne serait remplie, l’instruction OTHERWISE est ajoutée.

Les records incluant un âge manquant sont sauvegardées dans le data set nommé MISS_AGE et la  date de création d’une requête (query) pour clarifier le record est ajoutée dans une variable QUERY_SDT (Query Starting Date). Les autres records, traitant des moins de 5 ans, sont sauvegardés dans le data set YOUNG.

data miss_age young ;
set sashelp.class;
select (age);
when (.)
do;
query_sdt=mdy(3,26,2008);
output miss_age;
end;
when (0,1,2,3,4) output young;
otherwise;
end;
run;

Second exemple : cet exemple se distingue sur trois aspects.

  • La condition est basée sur plusieurs variables. Il faut dont les lister à chaque nouvelle instruction WHEN.
  • Une seule action n’est donnée à chaque fois voir moins. L’action porte sur la valeur de la variable POP. Il n’y a pas d’action quand l’âge n’est pas une valeur connue ou que le sexe n’est pas défini par les lettres majuscules F (female) ou M (male).
  • Les valeurs restantes se rapportent aux hommes ayant une valeur pour leur âge. C’est notre troisième population.

data pop;
set sashelp.class;
select;
when (age > 13 and sex=‘F’) pop = 1;
when (age >= 0 and sex=‘F’) pop = 2;
when (age < 0 or sex not in (‘F’,‘M’));
otherwise pop = 3;
end;
run;

A dans huit jours pour une présentation du CASE WHEN de la procédure SQL.

h1

Penser conditionnel (1/3) : La base du IF

juin 19, 2008

Selon que des variables aient certaines valeurs ou non, le programmeur peut décider de créer une nouvelle variable, extraire une ligne d’observation, etc.

SAS propose plusieurs syntaxes pour exprimer ces conditions.

  • Dans le data step et la procédure SQL, pour extraire un sous ensemble de records sans autre action le WHERE est probablement le plus adapté. De plus, dans d’autres cas que le data step et la PROC SQL l’option WHERE est aussi utilisable (PROC SORT, PROC FREQ, ODS OUTPUT…).
  • Sinon, dans un data step, on rencontre le IF et le SELECT et dans une procédure SQL, CASE WHEN est disponible.

Ce sujet sera divisé en 3 articles à commencer par la syntaxe du IF. Dans huit jours, le prochain rendez-vous sera consacré au SELECT. Enfin le dernier article de la série s’intéressera au CASE WHEN.

1. Le minimum ou presque

« S’il pleut, alors je prend mon parapluie, sinon, je le laisse au bureau. » Dans cette phrase, on repère trois mots : si, alors, sinon. Traduisez par IF, THEN, ELSE. C’est trois mots, version anglaise, forme la syntaxe de base.

Dans l’exemple suivant, on considère les variables AGE et SEX pour créer la variable PP_NY (per protocol population, no/yes) : « Si ma variable âge est supérieure à 13 et qu’il s’agit d’hommes alors ma variable pp_ny=1, sinon pp_ny=0. »

data class;
set sashelp.class;
if age > 13 and sex=‘M’ then pp_ny=1;
else pp_ny=0;
run;

On remarquera l’usage de l’instruction finale ELSE pour inclure tous les cas non pris en compte précédemment.

2. Multiplier les combinaisons

Dans ce second exemple, une instruction ELSE IF a été ajoutée. Ainsi tous les hommes de 13 ans ou moins pour lesquels on connaît l’âge sont sélectionnés dans cette seconde instruction. Enfin, les valeurs restantes correspondent aux lignes d’observations où l’âge est manquant ou concernant les femmes.

data class;
set sashelp.class;
if age > 13 and sex=‘M’ then pp_ny=1;
else if age > .z and sex=‘M’ then pp_ny=0;
else pp_ny=.;
run;

 

ELSE IF : il est préférable d’utiliser le ELSE IF, plutôt que le IF pour des raisons de performance et pour éviter des erreurs d’étourderie.

  • Par performance j’entends : seules les observations qui ne sont pas valides dans la première condition sont lues pour évaluer la condition suivante. C’est un temps très précieux quand on traite une grosse base de données.
  • Par erreur j’entends : en aucun cas, des observations peuvent-être sélectionnées par deux instructions. Ainsi si PP_NY=1, il n’y a aucune chance qu’il devienne PP_NY=0 après exécution de la seconde instruction.

Important : dans l’exemple précédent, j’ai volontairement choisi de lister plus d’une variable pour définir ma condition. En effet, si vous avez une seule variable en entrée et une seule variable en sortie, un informat suffit. Plusieurs avantages se cachent derrière :

  • le programme est allégé
  • l’accès aux valeurs est plus évident puisque les formats font partie des informations données en début de programme.

Voici ce que cela donnerait si on ne considérerait que la variable AGE pour définir la variable PP_NY.

proc format;
   invalue age_pp
   ._.z    = .
low-13   = 0
   13
<-high = 1;
run;

data class;
   set sashelp.class;
pp_ny=input(age,age_pp.);
run;

3. Parenthèse sur les valeurs manquantes 

On a fait très attention de ne pas inclure les âges manquants pour définir PP_NY=1/0. La valeur .z est une valeur manquante spéciale « special missing ». SAS en compte 27.

L’intérêt des valeurs manquantes spéciales : le but des special missings est d’offrir d’un éventail de valeurs pour distinguer les valeurs manquantes. Prenez le cas d’une variable indiquant le contraceptif médicamenteux pris par le patient. S’il s’agit d’une femme et que l’information n’est pas fournie, on mettra manquant (un point). Par contre, s’il s’agit d’un homme, on marquera .A pour « non applicable ». Un format permettra ensuite de représenter . par MISSING et .A par N/A.

L’ordre des valeurs manquantes : l’ordre des missings et special missings est important à connaître. Cela vous expliquera pourquoi j’ai utiliser .z et non . dans l’exemple précédent. Vous pouvez vous reporter à la Online Doc : Missing Values. En résumé cela donne :

  • ._ pour le plus petit,
  • . juste après,
  • .A
  • .Z pour le plus grand des special missings
  • valeurs négatives
  • valeurs positives

Alternative avec la fonction MISSING : sachez qu’une autre solution pour exclure toutes les valeurs manquantes (missing et special missing), c’est d’utiliser la fonction MISSING qui a pour autre avantage de s’appliquer autant aux valeurs textes qu’aux valeurs numériques. C’est très pratique quand on ne connaît pas à l’avance le type de la variable. Dans la PROC SQL, WHERE… il y a aussi « WHERE x IS MISSING ».

4. Plusieurs actions quand une condition est remplie (DO-END)

Si une condition est remplie, il peut s’avérer nécessaire de faire plusieurs choses. Par exemple, on peut à la fois créer une nouvelle variable et sortir la ligne d’observations.

Dans l’exemple ci-dessous, la variable SEX ne prend que les valeurs ‘M’ et ‘F’. Dans ce cas précis, au final, il y a plus de records à la fin. Tout d’abord, tous les records sont extraits et POP est défini comme étant égal à 1. Ensuite, pour les records masculins, les records sont sortis une deuxième fois et notre variable POP est alors égale à 2.

data class;
set sashelp.class;
pop=1;
output;
if sex=‘M’ then
do;
pop=2;
output;
end;
run;