Posts Tagged ‘Les instructions’

h1

Protégé : Qui a la priorité : RETAIN ou SET ?

mars 30, 2010

Cet article est protégé par un mot de passe. Pour le lire, veuillez saisir votre mot de passe ci-dessous :

h1

Protégé : Windows et ODS, stopper la fenêtre pop-up

février 1, 2010

Cet article est protégé par un mot de passe. Pour le lire, veuillez saisir votre mot de passe ci-dessous :

h1

Protégé : L’option NOTSORTED de l’instruction BY : A quoi cela sert-il ?

janvier 24, 2010

Cet article est protégé par un mot de passe. Pour le lire, veuillez saisir votre mot de passe ci-dessous :

h1

Quelle est la différence entre un RUN et un QUIT ?

septembre 12, 2009

Aujourd’hui, je voulais vous parler de la différence entre les instructions RUN et QUIT.  Toby Dunn a écrit une explication très bien faite sur le forum anglophone SAS-L. Voici une traduction possible.

1. L’instruction RUN

L’instruction RUN dit à SAS d’exécuter les instructions précédentes (c’est-à-dire l’étape data qui vient d’être compilée ou la procédure). C’est un délimiteur d’étape qui dit : « c’est la fin de l’étape ou de la procédure. Maintenant exécute le code. ».

Vous n’avez pas besoin d’utiliser l’instruction RUN, le début d’une autre étape data ou d’une procédure feront le boulot aussi. Cependant utiliser une instruction RUN nettoiera votre log.

2. L’instruction QUIT

L’instruction QUIT est aussi un délimiteur d’étape. Quelques procédures (par exemple PROC DATASETS, PROC CATALOG) permettent de soumettre plusieurs étapes à l’intérieur d’une procédure sans avoir à terminer la procédure. Dans ces cas là, vous ajoutez une instruction RUN pour terminer une étape dans cette procédure et une instruction QUIT pour terminer la procédure.

3. Le cas particulier de PROC SQL

SQL est un peu l’exception qui confirme la règle car cette procédure nécessite une instruction QUIT et toute instruction RUN sera ignorée. Ceci est dû au fait qu’elle exécute chaque instruction automatiquement. Il n’y a donc aucun besoin d’une exécution par groupe avec RUN mais un réel besoin d’un délimiteur de fin d’étape.

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

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

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

Un texte de 32 767 caractères passé au crible

septembre 1, 2008

La quantité d’espace alloué pour une observation dans un data set SAS peut aller jusqu’à 32 767 octets (byte en anglais). Pour m’amuser, j’ai voulu tester. Pour ce faire, j’ai procédé en trois étapes :

  • J’ai créé une variable de 32 767 caractères et j’ai imprimé sa seule valeur dans un fichier .TXT.
  • Puis, j’ai voulu voir comment se déroulait le passage de 32 767 caractères d’un fichier .TXT dans une seule observation d’un data set SAS.
  • Enfin, pour visualiser le tout, j’ai imprimé cette observation dans un fichier .RTF.

Note : La longueur (length) est le mot utilisé en SAS pour parler de la quantité d’espace alloué à une observation. Seules les variables de type caractères (character) peuvent avoir jusqu’à 32 767 octets. Les variables numériques en ont, en effet, 8 au maximum.  Un octet permet de stocker un caractère d’une variable texte. Pour plus de précisions sur l’octet, reportez-vous à l’article « 9 points autour de la notion d’octet« .

Note : La longueur allouée est identique pour toutes les observations d’une même variable. Si la longueur de la variable n’est pas explicitement donné, SAS utilise la longueur de la première observation. Avec un input file, seuls 8 octets sont attribués (SAS Online Doc. : SAS Variable Attributes »). 

data one;
   input x $;
   datalines;
ABC
ABCDEFGHIJKLMN
;
run;

data two;
   x=‘ABC’;
   output;
   x=‘ABCDEFGHIJKLMN’;
   output;
run;

data three;
x=‘ABCDEFGHIJKLMN’;
output;
x=‘ABC’;
output;
run;

Dans le premier exemple, la longueur sera de 8. La seconde observation sera donc coupée.

ABC
ABCDEFGH

Dans le second exemple, la longueur est définie par la première observation. Il s’agit donc d’une longueur de 3. La seconde observation est coupée et ne garde que les trois premiers caractères.

ABC
ABC

Dans le troisème exemple, la longueur est également définie par la première observation. Elle est donc cette fois de 14. Aucune des deux observations n’est coupée.

ABCDEFGHIJKLMN
ABCDEFGHIJKLMN

Cette valeur est changeable. Il s’agit de modifier l’attribut LENGTH d’une variable donnée dans un data step. La valeur est définie soit à l’instruction LENGTH, soit à l’instruction ATTRIB.

1. Imprimer 32 767 caractères dans un fichier .TXT

Dans l’exemple ci-dessous, un fichier .TXT est créé. Il contient 32 767 caractères venant d’une seule et même observation.

Une instruction LENGTH définissant le type et la longueur de la variable : Dans cet exemple, une variable TEST_VAR est créée. Il s’agit d’une variable caractère. Une longueur de 32 767 lui est assignée avec l’instruction LENGTH. Elle pourra donc contenir jusqu’à 32 767 octets par record.

Taper plus de 32 000 caractères, c’est long mais il y a la fonction REPEAT pour nous sauver : La valeur prise par le premier record de la variable TEST_VAR est donnée. J’ai choisi de répéter la lettre a 32 766 fois. Je dis bien 32 766 fois et non 32 765 fois car la fonction REPEAT ajoute à la valeur initiale ‘a’ 32 765 autres ‘a’, soit 32 765 + 1.

Ajouter un dernier caractère à notre valeur : A ces 32 766 lettres ‘a’, j’ai ajouté la lettre ‘b’ en faisant une concaténation grâce aux deux barres verticales. De cette manière, il sera possible de visualiser l’absence de coupure faite par SAS.

filename lgth_max ‘C:/sasref/lgth_max.txt’;
data _null_;
   file lgth_max;
   length test_var $ 32767;
   test_var=repeat(‘a’,32765)||‘b’;
   put test_var;
run;

filename lgth_max clear;

Ecrire le contenu de la variable dans un fichier externe : pour écrire les 32 767 caractères dans un fichier externe, SAS a besoin de trois instructions.

  • Ecrire du texte avec l’instruction PUT : L’instruction PUT est exécutée pour chaque observation de la variable TEST_VAR, c’est-à-dire une fois dans notre cas.
  • Diriger un texte vers une autre destination que la log avec l’instruction FILE : La valeur prise par la variable TEST_VAR est écrite dans un autre fichier. Cet autre fichier est désigné de manière indirecte dans l’instruction FILE. Je dis de manière indirecte car seul un nom figure dans l’instruction FILE, un nom désignant un fichier préalablement défini. On parle de FILEREF.
  • Caractériser un fichier de destination avec l’instruction FILENAME : Le FILEREF désignant la destination du texte à imprimer est défini dans l’instruction FILENAME. A la fin du programme, ce nom servant d’intermédiaire est supprimé pour pouvoir resservir et ainsi désigner un autre fichier ou chemin d’accès.

Pas besoin de créer un data set SAS ici : Dans le cas présent, nous avons besoin d’une étape DATA pour exécuter ce code mais nous n’avons pas besoin de créer un data set. Pour épargner la tâche de création d’un data set, le nom _NULL_ remplace le nom d’un data set.

2. Créer un data set SAS

Lire les données contenues dans un fichier externe : Une variable TEST_NEW est créée dans un data set nommé TEST_DS. Elle est de type caractère comme l’indique le symbole dollar ($) présent dans l’instruction INPUT.

Avant d’entrer une valeur dans cette variable, la longueur maximale autorisée est définie dans l’instruction LENGTH. Comme il s’agit d’une variable caractère, il faut ajouter le dollar.

Au lieu de saisir manuellement les valeurs dans le data step en introduisant le mot DATALINES, une instruction INFILE désigne le fichier où sont stockées les données.

data test_ds;
   infile ‘C:/sasref/lgth_max.txt’;
   length test_new $ 32767;
   input test_new $;
run;

Vérifier la valeur prise par l’attribut LENGTH de la variable TEST_NEW :  La procédure PROC CONTENTS donnera un aperçu des caractéristiques des variables du data set TEST. Bref, cette procédure donnera accès aux méta données (metadata ou données sur les données). Cela comprend la longueur allouée à la variable TEST_NEW et le type de la variable (caractère dans ce cas précis).

proc contents data=test_ds;
run;

3. Visualiser le data set dans un fichier .RTF

Seuls les 128 premiers caractères sont imprimables dans la fenêtre OUTPUT. Par contre, vous pouvez envisager d’autres destinations comme un fichier .RTF. Dans l’exemple, on joue avec les instructions ODS (Output Delivery System).

  • D’une part, la redirection vers la fenêtre output est stoppée le temps de l’impression, via les instructions ODS LISTING.
  • D’autre part, les 32 767 caractères sont envoyés dans un fichier .RTF grâce aux instructions ODS RTF.

ods listing close;
ods rtf file=‘C:/sasref/lgth_max.rtf’;
proc print data=test_ds;
run;
ods rtf close;
ods listing;

Pours les curieux : Changez la longueur pour 32 768 et expérimentez en direct les limites de SAS.

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

Empiler des data sets

mai 22, 2008

Ajouter des lignes à un data set en utilisant celles d’un autre data set, c’est possible avec SAS. Selon les particularités du data set, une ou plusieurs méthodes sont disponibles. Trois data sets en fin d’articles sont disponibles pour tester les différentes méthodes.

1.  L’instruction SET dans un data step offre probablement le plus de flexibilité 

Groupées les données : La souplesse de l’instruction SET vient notamment de l’instruction BY. Sans cette instruction, toutes les données du premier data set sont lues et ajoutée au data set final. Puis, seulement après les données du data set suivant sont ajoutées. Si on veut que les lignes apparaissent dans un ordre précis défini par une instruction BY, les données doivent être préalablement triées dans cet ordre. 

Deux data sets et plus : en outre, plus de deux data sets peuvent êtes mis bout à bout. Les premières données qui s’afficheront seront celles du premier data set listé dans l’instruction SET.

Autorise un nombre de variables différent : A l’exception des variables listées dans une instruction BY, les data sets n’ont pas besoin d’avoir les même variables. La variable présente dans seulement certains data sets sera présente au final. Des valeurs manquantes seront ajoutées si besoin.

Même longueur et type pour les variables communes : Il est néanmoins important que certains attributs des variables présentes dans plusieurs data sets soient identiques.

  • Longueur : SAS utilisera la longueur de la première variable lue. Si la longueur de la seconde variable est plus grande, les valeurs, textes notamment, seront tronquées.
  • Type numérique ou caractère: L’attribut sur le type de la variable est aussi essentiel. SAS aura des problèmes en lisant à la fois des variables numériques et caractères du même nom.
  • Nom de variable : Si les variables ont des noms différents. Il est possible de les renommer préalablement avec l’option RENAME.

Un nom de data set au choix : par ailleurs, on peut donner un nouveau nom au data set créé

La syntaxe du data set toujours disponible : enfin, les mêmes manipulations qu’avec une instruction SET avec un seul data set peuvent êtes effectuées. Les options (IN=) sont disponibles pour établir des conditions basées sur le data set source.

data seq_all;
   set seq1 seq2 seq3;
run;

SAS Online Doc : The SET Statement

2. La procédure DATASETS (et PROC APPEND) peut s’avérer plus performante

La procédure DATASETS dispose de l’instruction APPEND. Cette procédure est plus récente que sa jumelle PROC APPEND. Elle propose d’autres instructions fortement utiles comme COPY et DELETE.

  • Nombre de data sets d’entrée: Ici, il est impératif d’avoir deux et seulement deux data sets pour une jointure donnée.
  • Structure des data sets d’entrée : Chaque data set doit avoir les mêmes variables.
  • Nom du data set de sortie : Le data set final portera le nom du data set listé dans la base.
  • Performances : APPEND pourra s’avérer plus performant si le data set défini dans la base est large. En effet, dans ce dernier cas, seul les observations du deuxième data set sont lues intégralement.

Priorité dans l’usage des bibliothèques : Dans l’exemple suivant, le data set SEQ1, SEQ2 et SEQ3 sont dans la bibliothèque WORK. Si aucune bibliothèque n’est donnée dans l’instruction APPEND, SAS utilise celle définie dans l’instruction PROC DATA SETS. Et comme aucune n’y est précisée, cela revient à utiliser la bibliothèque temporaire (WORK le plus souvent).

proc datasets;*lib=work;
   append base=seq1 data=seq2;
   *append base=work.seq1 data=work.seq2;
   append base=seq1 data=seq3;
run;

Voici la même manipulation avec PROC APPEND.

proc append base=seq1 data=seq2;
*proc append base=work.seq1 data=work.seq2;
run;
proc append base=seq1 data=seq3;
run;

Vous pouvez vous reporter à la documentation SAS :The DATASETS Procedure et consulter l’instruction APPEND. On y rappelle notamment quand le data set de la base (BASE=), les options DROP, KEEP et RENAME ne sont pas exécutées.

3. Au final pas de doublons avec l’UNION d’une PROC SQL

Important : L’UNION de deux data sets avec une PROC SQL enlèvera les doublons. Il est donc important de savoir s’il y a des doublons qui sont à enlever ou non.

Ici, on peut faire l’union de plus de deux data sets. Ils devront néanmoins tous avoir les mêmes variables.

proc sql;
   create table seq_all as
      select * from seq1
   union
      select * from seq2
   union
      select * from seq3;
quit;

4. Insérer de nouvelles observations extraites d’un autre data set

Il est possible aussi d’ajouter les observations avec l’instruction INSERT INTO. Le data set d’origine est alors actualisé. Dans l’exemple ci-dessous on ajoute seulement les observations des data sets SEQ2 et SEQ3 s’il si le test mesure la pression systolique (Systolic Blood Pressure, SBP).

NOTE : Il est important de sélectionner les observations à ajouter d’un data set différent de celui à mettre à jour. Sinon, SAS risque de rencontrer des problèmes. Voir la SAS Online Doc: INSERT Statement pour plus de précisions.

proc sql;
  insert into seq1
     select *
     from seq2
     where test_nom=‘SBP’;
  insert into seq1
     select *
     from seq3
     where test_nom=‘SBP’;
quit;

Annexe :

data seq1;
   length test_nom $3 test_unit $4;
   input test_nom $ test_seq test_val test_unit $;
   datalines;
SBP 1 120 mmHg
DBP 1 80 mmHg
DBP 1 80 mmHg
;
run;

data seq2;
   length test_nom $3 test_unit $4;
   input test_nom $ test_seq test_val test_unit $;
   datalines;
SBP 2 115 mmHg
DBP 2 85 mmHg
;
run;

data seq3;
   length test_nom $3 test_unit $4;
   input test_nom $ test_seq test_val test_unit $;
   datalines;
SBP 3 117 mmHg
DBP 3 81 mmHg
;
run;

h1

9 points pour personnaliser ses titres

mars 28, 2008

silhouettes

Ajouter un titre à vos tableaux et graphiques est simple avec l’instruction TITLE. Je vous rappelle la différence entre les guillemets simples et doubles. Je vous parle des méthodes pour aligner vos titres, etc. Vous saurez ensuite comment supprimer vos titres. Pour rendre vos titres un peu plus flexibles, je vous donne un tuyau (l’option NOBYLINE). Pour ce qui est d’un titre de tableau avec ODS RTF, je vous parle de l’option BODYTITLE. Et pour un titre de graphique, on parlera de l’option NOGTITLE. Bonne lecture.

1. Créer un titre : l’instruction globale TITLE permet d’ajouter un titre. Pour cela, on fait suivre le mot-clé du titre entre guillemets.

title ‘Mon titre’;

2. Créer plusieurs titres : SAS autorise jusqu’à 10 lignes servant de titre. Pour les distinguer, un numéro a été ajouté au mot-clé TITLE1-TITLE10. Ainsi TITLE est équivalent de TITLE1.

title1 ‘Mon premier titre’;
title2 ‘Mon second titre’;

title10 ‘Mon dixième titre’;

3. Supprimer un titre : Par défaut, SAS inscrit « The SAS System » comme titre de vos sorties. Pour l’enlever, vous pouvez soit réécrire dessus ou l’enlever définitivement avec une instruction TITLE vide. Notez que pas seulement le premier titre sera supprimé mais l’intégralité des titres définis.

title ;

4. Un titre sur une seule page d’éditeur : votre titre est long et vous avez besoin d’utiliser la barre de défilement horizontale de votre éditeur SAS pour le lire en entier. La solution est de couper votre titre.

title ‘Ma première partie’
      ‘Ma deuxième partie’
;

5. Guillemets simples ou doubles : pour alléger le programme, utilisez de préférence des guillemets simples. Dans certains cas, cependant, vous aurez besoin de guillemets doubles :

  • Résoudre une macro variable
  • Avoir un titre avec des apostrophes

title « Etude : &numero_etude. »;
title « Don’t do it »;

Une autre solution pour traiter les apostrophes est de mettre deux apostrophes simples l’une à coter de l’autre.

title ‘Don »t do it’;

6. Changer l’alignement : votre titre sera par défaut centré. Pour aligner à gauche, vous pouvez suspendre temporairement l’option globale de centrage (options nocenter; /*votre programme*/ options center). Vous pouvez aussi utiliser l’option pour justifier (j=). Celle-ci peut prendre trois valeurs :

  • j=l (left) pour aligner à gauche,
  • j=c (center) pour centrer,
  • j=r (right) pour aligner à droite.

7. Un texte à gauche et un texte à droite : vous pouvez aussi avoir sur une seule ligne plusieurs éléments à positionner : un à gauche, un à droite et un au milieu.

L’ancienne méthode : l’ancienne méthode consiste à assembler le texte de gauche, x blancs, le texte du milieu, y blancs et le texte de droite. Le tout faisant la largeur de la page. Pour cela un petit calcul s’impose.

  • On prend le nombre total de caractères sur la ligne (linesize).
  • La longueur des trois morceaux de texte y est soustraite.
  • Le reste est divisé par deux. Si on a un nombre impair, les deux textes blancs auront un espace de différence.

La nouvelle méthode : avec SAS 8.2 il existait une alternative, temporairement indisponible sous SAS 9.1.3 mais qui devrait redevenir disponible sous SAS 9.2 (cette année !).

title j=l ‘Mon texte de gauche (left)’
      j=c ‘Mon texte du milieu (center)’
      j=r‘Mon texte de droite (right)’;

En fait, l’option ‘justifié’ (j=) est toujours disponible sous SAS 9.1.3 mais seul le dernier est pris en considération par SAS. D’ici là, il ne vous reste plus que l’ancienne méthode.

8. Personnaliser son titre avec la valeur d’une BY variable : l’option globale BYLINE permet d’ajouter automatiquement un titre pour précisez la valeur d’une valeur BY variable. Par exemple, vous construisez un proc report…; by pop;… D’un côté vous avez la forme automatique avec BYLINE (Par Protocol). De l’autre, vous pouvez personnaliser votre titre (Population : Par Protocol).  Pour cela, on désactive l’option avec NOBYLINE (options nobyline;). Puis on utilise #byvar() et ou #byval() dans le titre. Soit on souhaite faire apparaître le nom de la BY variable soir la valeur de la BY variable. Dans le second cas, cette valeur est rendue parlante avec un format.

title ‘Population : #byval(pop)’;proc report …;
  by pop;
  …;
  format pop pop.;
run;

9. ODS RTF : lorsqu’on crée des documents RTF lisibles par Word, il faut pouvoir adapter les options par défaut des titres pour répondre à ses besoins.

Un titre de tableau dans le corps du document : par défaut les titres d’un tableau sont inclus dans les entêtes du document RTF. Pour qu’il fasse partie intégrante du corps du document, on ajoute l’option BODYTITLE.

Un titre de graphique dans le corps du document : par défaut les titres des graphiques sont inclus dans l’image graphique générée par SAS. Pour que cela ne soit plus le cas, on ajoute l’option NOGTITLE dans l’instruction ODS RTF.

h1

Faire des petits avec l’instruction OUTPUT

mars 1, 2008

bouchons_fr.jpg 

Imaginez devoir créer plusieurs fois le même tableau avec des fréquences, des tests statistiques, etc. Pourquoi plusieurs fois ? Parce que chaque tableau inclus une population différente.

1. Une observation par tableau

Dans le cas le plus simple, chaque observation n’apparaît que dans un seul des tableaux à produire. Une variable identifie le tableau auquel l’observation est allouée et l’instruction BY utilise cette variable avec la procédure report ou autre.

Voici un exemple où les données sont publiées par pays dans des tableaux distincts. L’utilisation d’une valeur numérique pour le pays est optionnelle mais ajoute de la flexibilité pour trier les données.

proc format;
value cntry
1=’Chine’
2=’Malaisie’;
run;

proc report data=lab;
by cntry;
columns test cnt;

format cntry cntry.;

run;

2. Plusieurs tableaux pour une observation

Exemple : maintenant voici deux exemples des essais cliniques pour lesquels une observation peut servir à plusieurs tableaux.

  • Construire un tableau pour la population ‘per protocol’, un pour ‘intent-to-treat’ et un pour ‘safety’ : un patient valide par protocole est aussi pour l’analyse de sûreté mais tous les patients valides pour la sûreté ne répondent pas forcément aux critères du protocole.
  • créer un tableau par zone géographique : un tableau pour tous les pays couverts par l’étude clinique, un tableau par pays et un par centre dans un pays donné.

Dans ces deux cas, une observation peut être utilisée par plusieurs tableaux. La méthode précédente n’est plus suffisante. Voici la solution que je vous propose :

  • 1er tableau : extraire les observations correspondant au premier tableau en utilisant une condition listant le critère de sélection si besoin.
  • rendre ces observations uniques en ajoutant une nouvelle variable avec un numéro unique
  • sauvegarder ces observations dans un jeu de données
  • 2ème tableau : extraire les observations pour le second tableau
  • donner un numéro différent à ces observations
  • ajouter ces observations à celles précédemment sélectionnées
  • 3ème tableau : etc.

Dans l’exemple qui suit, quatre tableaux différents sont à produits. On intercalera le code suivant entre les procédures format et report mentionnées précédemment.

data lab;
set lab;
grp=1;
output;
if cntry=’CN’ then
do;
grp=2;
output;
end;
else if cntry=’MY’ then
do;
grp=3;
output;
end;
if cntr=1 and cntry=’CN’ then
do;
grp=4;
output;
end;
run;

3. Créer plusieurs jeux de données

L’instruction OUTPUT dirige, par défaut, les données vers le jeu de données nommé dans l’instruction DATA. Parfois, il faut créer plusieurs data sets à partir à partir d’un seul jeu de données. Par exemple, on créera un data set contenant les patients inclus dans l’étude et un autre ceux exclus. Pour cela, il suffit de nommer les nouveaux jeux de données dans l’instruction DATA et de rappeler leur nom dans chaque instruction OUTPUT.

data incl excl;
set pat_lst;
if missing (randomno) then output excl;
else output incl;
run;

4. Créer une variable numérique avec des valeurs continues

En combinaison avec une boucle, l’instruction OUTPUT permet de générer des nombres. Par exemple, j’ai eu besoin de tester une macro via un data set listant toutes les valeurs ASCII imprimables. Ces valeurs ont un numéro allant de 32 à 126. La fonction BYTE retrouve la valeur ASCII avec ces numéros.

data ascii (drop=i);
do i=31 to 126;
ascii=byte(i);
output;
end;
run;

Autres lectures : vous pouvez étendre votre lecture sur l’instruction DO et DELETE. L’instruction DO dispose d’un mot-clé BY. L’instruction DELETE est, quant à elle, l’inverse de l’OUTPUT.

h1

Ecrire un texte avec l’instruction PUT

février 24, 2008

pen_fr.jpg 

Faire apparaître un message d’erreur dans la log ; afficher la valeur de variables dans la log lors du développement d’un programme ; générer plusieurs programmes similaires : voici autant d’applications de l’instruction PUT, propre au data step, qui affiche, par défaut, le texte dans la log.

1. Taper du texte brut : en mettant votre texte entre guillemets dans l’instruction PUT, celui-ci apparaîtra dans la log.

Couper l’instruction PUT : lorsqu’une instruction PUT devient longue, on doit se déplacer sur plusieurs écrans pour voir l’intégralité du programme. En coupant le texte, la lisibilité du programme et le confort du programmeur se trouvent améliorés et le texte reste continue dans la sortie LOG ou autre.

Ecrire des guillemets : pour afficher une guillemet simple, celle-ci devra apparaître dans des guillemets doubles et inversement. Pour afficher deux guillemets simples, il faudra les séparer dans deux jeux de guillemets doubles. Par défaut, on privilégiera les guillemets simples pour alléger le programme.

Ajouter un saut de ligne : à chaque nouvelle instruction PUT, SAS crée un saut de ligne. Les barres inclinées (slash /) ajoutent autant de sauts de ligne supplémentaires que désirés.

Ajouter des espaces : en écrivant une procédure SQL, on fait utile des indentations améliorant la lisibilité du code. Soit ces espaces de début de ligne sont ajoutés manuellement entre les guillemets, soit un arobas suivi du nombre d’espaces précède les guillemets (@6 crée une indentation de six espaces). 

Enlever l’espace créé par défaut avant un début de guillemets : plusieurs jeux de guillemets sont fréquemment utilisés pour insérer entre les deux le nom d’une variable. Au final, il est parfois important que la valeur de la variable et le texte qui suit se suivent sans espace. Pour cela, il faut faire reculer le curseur d’un espace en ajoutant  +(-1) avant le début de la guillemet.

2. Afficher les valeurs des variables d’un jeu de données

Afficher la valeur de la variable : pour voir la valeur des variables, il faut lister leur nom dans l’instruction PUT sans guillemet. C’est très pratique pour générer un code variant uniquement par la valeur de variables.

Afficher la valeur d’une variable et son nom : lorsqu’il s’agira de débugger un programme, vous repérerez plus rapidement dans la log vos valeurs si le nom de la variable apparaît également. Pour ce faire, vous avez deux options plus ou moins rapide.

  • Utiliser les guillemets vous obligera à écrire le nom de la variable deux fois : une fois entre guillemets et une fois sans guillemet.
  • Plus simplement, le nom de la variable est suivi du signe égal.

Lectures complémentaires : l’instruction PUT trouve tout son potentiel en combinaison avec d’autres instructions : 

  • Pas de jeu de données (DATA _NULL) : l’instruction PUT est propre au data step. Quand vous ne voudrez pas créer un jeu de données SAS dans ce data step, vous aurez besoin du DATA _NULL_.
  • Changer de destination (FILE/FILENAME) : Pour diriger votre texte vers une autre sortie que la log, vous aurez besoin de l’instruction FILE. Selon que cette sortie sera vers un fichier externe ou vers la fenêtre OUTPUT de SAS, vous aurez besoin de l’instruction globale FILENAME ou non.
  • Alterner selon les valeurs des variables (BY/FIRST/LAST) : pour générer des codes variant selon la valeur de variables, il y a l’instruction BY en combinaison avec FIRST et LAST.
  • Début et fin de texte (_N_/END=) : pour afficher un texte unique en début et en fin, on peut faire référence à la variable automatique _N_ (if _N_=1) et à une variable définie avec l’option END= de l’instruction SET.