Créer un fichier .sas automatiquement

Il est très courant en SAS de créer un programme à partir d’une instruction FILENAME et d’une étape data. Souvent les informations contenues dans un fichier de référence servent à faire varier quelques lignes de code.

1. Le data set pour l’exemple

Dans cet exemple, il est demandé de renommer toutes les variables commençant pas z_ de manière automatique car le nom et le nombre de ces variables peut varier.

data lab;
   input patient z_test1 $ test1_val z_test2 $ test2_val;
   datalines;
1 TEMP 38 HR 80
;
run;

Si deux variables seulement seraient à renommer et si elles s’appelaient toujours Z_TEST1 et Z_TEST2, le code serait tout simplement.

data lab;
   set lab (rename=(z_test1=test1 z_test=test2));
run;

Ou

data lab;
   set lab;
   rename z_test1=test1
          z_test2=test2;
run;

Ou

data lab;
   set lab;
   rename z_test1=test1;
   rename z_test2=test2;
run;

C’est cette dernière forme qui nous intéressera de reproduire de manière automatique.

2. Créer le fichier de référence

La liste de toutes les variables commençant pas Z_ du data set temporaire LAB, est sauvegardée dans le data set REF et plus particulièrement dans la variable OLD_NAME. On choisit en plus d’ajouter une seconde variable NEW_NAME contenant les noms sans les Z_.

Dans notre exemple, vu qu’il y a 2 variables à renommer, le data set REF contient deux observations dans la variable NAME.

proc sql;
   create table ref as
      select name as old_name,
             subst(old_name,3) as new_name
      from dictionary.columns
      where upcase(libname)='WORK' and
            upcase(memname)='LAB' and
            upcase(name) like 'Z_%';
quit;

3. Créer un fichier .sas avec une instruction filename et une étape data

Dans un second temps, l’emplacement et le nom du programme SAS à créer sont à donner. C’est le rôle de l’instruction FILENAME. Pour y faire ensuite référence, il suffit d’utiliser le surnom donné dans l’instruction. Ici, il s’agit du surnom SASREF.

filename sasref 'C:/sasref/rename_z.sas';

Les instructions FILENAME et LIBNAME ont des similarités. Dans une instruction LIBNAME, le nom de la bibliothèque s’appelle le LIBREF. Ici on parle de FILEREF. Tous les deux (LIBREF et FILEREF) doivent avoir une longueur de 8 au maximum et ne doit pas commencer par un chiffre.

4. Une étape data

Dans un troisème temps, une étape data est donnée pour écrire le programme.

1. Ne pas créer de data set, DATA  _NULL_ : Comme, il n’y a pas besoin de créer de data set, le nom du data set est remplacé par le mot _NULL_.
2. Désigner le nom du fichier .sas à créer, FILE: Puis, on précise où les informations contenues dans lesinstructions PUT seront copiées.
3. Lire les données du fichier de référence, SET : Après, il faut désigner notre data set REF contenant les observations dans l’instruction SET.
4. Utiliser la variable automatique _N_=1 pour désigner la première boucle autour de l’étape data et donc ici la première observation : Lors de la lecture de la première observation du data set REF les instructions DATA LAB et SET LAB seront écrites dans le programme.
5. Ajouter autant d’instruction RENAME que d’observations dans le ficihier REF : Pour chacune des observations de REF, une instruction RENAME sera écrite. Le contenu variera en fonctions des valeurs contenues dans les variables OLD_NAME et NEW_NAME.
6. Utiliser l’option END= pour désigner la dernière observation du data set REF : Enfin à la lecture de la dernière observation, une instruction RUN est ajoutée. Pour désigner la dernière observation, on fait appel à l’option END= de l’instruction SET qui nous permet d’introduire une nouvelle variable nommée EOF. Celle variable prend la valeur 0 pour toutes les observations du data set REF sauf la dernière qui prend la valeur 1.

data _null_;
   file sasref;
   set ref end=eof;
   if _N_=1 then
      do;
         put 'data lab;';
         put '    set lab;';
      end;
   put '   rename '  old_name '=' new_name ' ;';
   if eof then put 'run;';
run;

5. Exécuter le programme

Pour terminer il est possible d’appeler le programme avec une instruction %INCLUDE et d’enlever le lien qui existe entre SASREF et le fichier (desassign the filename reference)

Appeler le programme :

%include sasref;

Couper le lien entre le FILEREF et le programme RENAME_Z.SAS :

filename sasref clear;

Pour vous entraîner, vous pouvez faire varier le code et essayer de retrouver les autres syntaxes pour renommer les variables citées en première partie.

Les 2 dictionnaires SAS les plus utilisés: TABLES et COLUMNS

Les données caractérisant un data set ou ses variables sont appelées des métadonnées. Les dictionnaires SAS stockent ce type d’information. Il s’agit ni plus ni moins que de tableaux contenant une ligne par data set ou une ligne par variable. Pour accéder aux dictionnaires, il faut passer par une PROC SQL et consulter les tableaux TABLES et COLUMNS de la bibliothèque DICTIONARY.

Note sur d’autres sources d’informations : Sachez, par ailleurs, qu’il existe d’autres moyens que la bibliothèque DICTIONARY pour accéder aux métadonnées.

• Reconstituées les data sets de référence avec des VIEWS : Les données peuvent être reconstituées à partir de vues (VIEWS) stockées dans la bibliothèque SASHELP. La procédure SQL ainsi que le data step peuvent s’en servir.
• Passer par une procédure : la procédure PROC DATASETS dispose de l’instruction CONTENTS syntaxe plus récente que le PROC CONTENTS.

La documentation SAS sur le sujet fait partie de Concepts : SQL Procedure.

1. Le dictionnaire décrivant les data sets : DICTIONARY.TABLES

Le dictionnaire TABLES contient une ligne par data set. Parmi les informations caractérisant un data set, celles qui me servent le plus souvent sont :

• La variable LIBNAME : le nom de la bibliothèque (library) sauvegardé dans la variable LIBNAME (library name)
• La variable MEMNAME : le nom du data set sauvegardé dans la variable MEMNAME. Entendez par là member name.

et de temps en temps

• La variable MEMTYPE : le type de fichier dans les dictionnaires TABLES et COLUMNS est soit DATA ou VIEW. DATA reste le type de fichier le plus fréquemment utilisé.
• La variable NOBS : le nombre d’observations dans le data set est sauvegardé dans la variable NOBS.

Liste de toutes les variables avec leur label :

• Library Name (libname)
• Member Name (memname)
• Member Type (memtype)
• Dataset Label (memlabel)
• Dataset Type (typemem)
• Date Created (crdate)
• Date Modified (modate)
• Number of Observations (nobs)
• Observation Length (obslen)
• Number of Variables (nvar)
• Password Protection (protected)
• Compression Routing (compress)
• Encryption (encrypt)
• Number of Pages (npage)
• Percent Compression (pcompress)
• Reuse Space (reuse)
• Bufsize (bufsize)
• Deleted Observations (delobs)
• Type of Indexes (indxtype)
• Data Representation (datarep)
• Requirements Vector (reqvector)

2. Le dictionnaire décrivant les variables : DICTIONARY.COLUMNS

Le dictionnaire COLUMNS contient une ligne par variable.

Les informations sur le fichier source : Comme précédemment, le nom du data set (MEMNAME) contenant la variable et sa bibliothèque (LIBNAME) sont des informations très importantes. Le MEMTYPE dest aussi fourni.

Le nom de la variable (NAME) : Le nom de la variable est sauvegardé dans la variable NAME. Les valeurs sont soient en minuscule, soit en majuscule, soit un mélange des deux.

Cela dépend de la manière dont le nom a été saisi la première fois lors de la création de la variable.

Les détails les plus usuels : je consulte le plus souvent le type de la variable : pour les variables texte, la variable TYPE prend la valeur « char » et pour les variables numériques, elle prend la valeur « num ». C’est différent de la sortie d’un PROC CONTENTS qui prend des valeurs numériques.

Les détails occasionnels : Après viennent par exemple :

• la longueur de la variable (LENGTH)
• le format de la variable (FORMAT)
• le label de la variable (LABEL)
• le numéro de la variable dans le data set (VARNUM)

Liste de toutes les variables dans DICTIONARY.COLUMNS avec leur label :

• Library Name (libname)
• Member Name (memname)
• Member Type (memtype)
• Column Name (name)
• Column Type (type)
• Column Length (length)
• Column Position (npos)
• Column Number in Table (varnum)
• Column Label (label)
• Column Format (format)
• Column Informat (informat)
• Column Index Twpe (idxusage)

3. Majuscule ou minuscule

Dans le dictionaire DICTIONARY.TABLES et dans le dictionnaire DICTIONARY.COLUMNS, le nom de la bibliothèque (LIBNAME) et le nom du data set (MEMNAME) sont sauvegardés en majuscule.

Le nom des variables varie dans un dictionnaire selon la première saisie faite du nom lors de sa création.

Pour éviter des erreurs, il est donc plus simple de faire des comparaisons après avoir mis les valeurs contenues dans les dictionnaires dans la même style : tout majuscule ou tout minuscule ou seul la première lettre en majuscule. Vous pouvez consulter l’article « Majuscule ou minuscule sous SAS« .

4. Deux exemples

Dans ce premier exemple tous les data sets SAS de la bibliothèque SASHELP sont listés.

proc sql;
select libname, memname
from dictionary.tables
where upcase(libname)=‘SASHELP’ and
upcase(memtype)=‘DATA’;
quit;

Dans ce second exemple, toutes les variables caractères du data set CLASS stocké dans la bibliothèque SASHELP sont affichées avec leur position.

proc sql;
select name, varnum
from dictionary.columns
where upcase(libname)=‘SASHELP’ and
upcase(memname)=‘CLASS’ and
upcase(type)=‘CHAR’;
quit;

5. Lister toutes les variables

Lister toutes les variables grâce au symbole étoile : La liste des variables contenues dans les dictionnaires TABLES and COLUMNS ici n’est pas exhaustive. Vous pouvez remplacer le nom des variables à garder par une étoile (*) afin de les voir toutes.

Afficher le nom des variables et non les labels en changeant l’option globale : Par défaut, le nom des variables n’apparaît pas dans l’OUTPUT mais le nom de leur label. Pour afficher le nom de la variable, il suffira de remplacer l’option globale label.

Afficher sur une ligne : Enfin, le nombre de variables contenues dans un dictionnaire peut ne pas s’afficher sur une seule ligne.

• Changer le nombre de caractères imprimables sur la page. Ce nombre varie entre 64 et 256.
• Donner une largueur d’affichage identique pour toutes les variables. L’option FLOW= de l’instruction PROC SQL limite le nombre de caractères disponibles pour l’affichage des variables.

options nolabel ls=255;

proc sql flow=10;
…
quit;

options label;

 

Quand compilation et exécution font la différence, un exemple

SAS effectue plusieurs lectures d’un programme. A la première lecture, c’est la compilation. A la seconde, c’est l’exécution. Connaître ces notions vous aidera à comprendre les exemples ci-dessous : pourquoi le premier code proposé ne fonctionne pas alors que les autres passent. Les fonctions PUT, VVALUE, le dictionnaire DICTIONARY.COLUMNS et le DATA _NULL_ serviront dans les exemples.

1. Un premier exemple avec la fonction PUT

Rappel sur la fonction PUT : Une fonction PUT permet de convertir une variable numérique en variable texte ou une variable texte en une autre variable texte. Elle est composée de deux paramètres. D’un côté, il y a la variable d’origine. De l’autre côté, il y a le format à appliquer sur cette variable d’origine. C’est donc la valeur sous forme formatée qui devient une valeur texte. Reportez vous à l’article « Convertir une variable caractère en numérique et inversement » pour plus de détails.

La phase de compilation : A la compilation, SAS  vérifie que la variable d’origine et le format associé sont tous les deux du même type. Il faut qu’une variable numérique est un format qui s’applique à une variable numérique. De manière identique, il faut un format caractère pour une variable texte.

La phase d’exécution : Si on ne connaît pas à l’avance le type de la variable, on peut avoir envie de définir une condition : si la variable est numérique applique tel format, sinon applique tel autre format. Hors une condition IF/THEN n’est visible par SAS qu’à la phase d’exécution.

En d’autres termes, SAS tentera d’appliquer un format numérique à une variable numérique avant de regarder si la fonction PUT est définie dans une condition.

data import_excel;
   retain type ‘CHAR’;
   study = ‘999’;
   output;
   study = ‘888’;
   output;
run;

data study_new;
   set import_excel;
   if type=‘NUM’ then study_new=put(study,best.);
   else study_new=study;
run;

Le résultat : Dans l’exemple, un format numérique (BEST.) est appliqué à une variable texte (STUDY). La première partie de la condition ne s’applique pas car le type de la variable n’est pas égal à NUM. Mais SAS cherche un format $BEST. qui n’existe pas. Il est obligé de s’arrêter là.

28 data study_new;
29 set ref;
30 if upcase(type)=’NUM’ then study_new=put(study,best.);
                                                  —–
                                                  48
ERROR 48-59: The format $BEST was not found or could not be loaded.

31 else study_new=study;
32 run;

NOTE: The SAS System stopped processing this step because of errors.
WARNING: The data set WORK.STUDY_NEW may be incomplete.
When this step was stopped there were 0 observations and 3 variables.

Un exemple où le type de la variable est inconnu : en important un fichier EXCEL (PROC IMPORT/MIXED=YES), le type de la variable sous SAS peut-être inconnu. La variable sera caractère si une cellule contient du texte. Sinon, elle sera numérique.

2. Une solution rapide

Une fonction Vxxx: la fonction VVALUE retourne une valeur texte. Elle utilise le format associé à la variable en interne pour construire la valeur sous forme formatée. La nouvelle variable aura une longueur de 200.

data study_new;
   set ref;
   if type=’NUM’ then study_new=vvalue(study);
   else study_new=study;
run;

3. Une solution plus lourde mais pouvant s’appliquer à plusieurs variables

Une autre solution est de générer le code à exécuter. Si la variable est numérique, c’est l’instruction avec PUT qui apparaîtra, sinon c’est l’autre instruction. Cette approche fait appel à la notion de dictionnaire et de DATA _NULL_.

3.1 Créer un data set contenant le nom des variables et leur type à partir du dictionnaire (dictionary) appelé COLUMNS

La première étape consiste à créer un data set, nommé DICT_REF, contenant la variable STUDY et son type.

Choix du dictionnaire : Le dictionnaire (dictionary) COLUMNS est un data set de référence, créé de manière automatique par SAS. Il répertorie toutes les variables contenues dans tous les data sets de toutes les bibliothèques actives. Il contient donc une ligne par variable.

Chaque ligne du dictionnaire contient plusieurs informations caractérisant cette variable dont :

• la bibliothèque d’origine (variable LIBNAME)
• le data set d’origine (variable MEMNAME)
• le nom de la variable (variable NAME)
• le type de la variable (variable TYPE).

Prendre un sous-ensemble du dictionnaire : Ici seule la variable STUDY est utile. Elle provient du data set EXCEL_IMPORT sauvegardé de manière temporaire dans la bibliothèque WORK.

Mettre en majuscule : Le type de la variable est soit « num » soit « char », toujours en minuscule. Le nom de la variable peut avoir un mélange de majuscules et minuscules selon la manière dont est saisi le nom lors de sa création. Pour éviter des surprises, le nom de la variable et le type sont mis en majuscule grâce à la fonction UPCASE. L’avantage des dictionnaires, c’est qu’ils peuvent lister plus d’une variable.

proc sql;
   create table dict_ref as
      select upcase(name) as name,
             upcase(type) as type
      from dictionary.columns
      where upcase(libname) = ‘WORK’ and
            upcase(memname) = ‘EXCEL_IMPORT’ and
            upcase(name)    = ‘STUDY’;
quit;

3.2 Ecrire le code et l’appeler

La deuxième étape consiste à créer un programme nommé TMP_STUD.SAS donc le nom et l’emplacement est défini dans l’instruction FILENAME. Pour écrire dans ce fichier, l’instruction FILE est ajoutée dans le DATA _NULL_. Pour plus de précisions sur l’instruction PUT, reportez-vous à l’article « Ecrire un texte avec l’instruction PUT« .

filename stud ‘C:/sasref/tmp_stud.sas’;

data _null_;
   set dict_ref;
   file stud;
   put ‘data study_new;’;
   put @3 ‘set excel_import;’;
   if type=‘NUM’ then put @3 ‘study_new=put(‘ name ‘,9.);’;
   else put @3 ‘study_new=’ name ‘;’;
   put ‘run;’;
run;

%include stud;
filename stud;

L’écriture du programme est fonction des informations contenues dans le DICT_REF. Si plus d’une variable est sélectionnée, il faudrait préciser deux choses :

• Les instructions DATA et SET ne sont à écrire qu’une fois. Elles sont ajoutées lors de la première boucle fait en interne autour de l’étape DATA via « if _N_=1 ».
• L’instruction RUN apparaît une fois en fin de programme. Il faut donc l’ajouter une fois le dernier record du fichier de référence atteint. L’option END= de l’instruction SET crée une variable interne prenant la valeur 0 pour tous les records sauf le dernier où elle prend la valeur 1. La condition est donc basée sur cette variable.

filename stud ‘C:/sasref/tmp_stud.sas’;

data _null_;
   set dict_ref end=eof;
   file stud;
   if _N_=1 then
      do;
         put ‘data study_new;’;
         put @3 ‘set excel_import;’;
      end;
   if type=‘NUM’ then put @3 ‘study_new=put(‘ name ‘,9.);’;
   else put @3 ‘study_new=’ name ‘;’;
   if eof then put ‘run;’;
run;

%include stud;
filename stud;

Le code sauvegardé dans le fichier TMP_STUD.SAS se présente donc ainsi, vu que la variable STUDY est de type caractère.

data study_new;
   set excel_import;
   study_new=STUDY ;
run;

L’instruction %INCLUDE permet l’exécution de ce code.

Répéter une action sur plusieurs variables avec le langage macro

Sous SAS, deux possibilités sont envisageables pour répéter une action sur plusieurs variables. Dans le cas d’un data step, la syntaxe de l’ARRAY est tout à fait appropriée. Dans d’autres cas, le langage macro peut s’avérer plus pertinent. Voici donc une présentation de l’approche via le langage macro.

1. L’exemple

Pour illustrer le propos, le programme aura pour but de définir un PROC REPORT contenant toutes les variables du data set SASHELP.CLASS. Si on connaît le nom des variables, la syntaxe se résume de la manière suivante.

proc report data=sashelp.class;
   columns name age sex weight height;
   define name   / display;
   define age    / display;
   define sex    / display;
   define weight / display;
   define height / display;
run;

Mais si on ne connaît pas le nom des variables par avance, il faut automatiser la tâche.

2. Remplacer le nom des variables par des macros variables

Dans l’exemple suivant, le nom de chaque variable est sauvegardé dans une macro variable. Ces macros variables ont une structure particulière :

un préfixe commun + un nombre

%let class1 = name;
%let class2 = age;
%let class3 = sex;
%let class4 = weight;
%let class5 = height;

proc report data=sashelp.class;
   columns name age sex weight height;
   define &class1. / display;
   define &class2. / display;
   define &class3. / display;
   define &class4. / display;
   define &class5. / display;
run;

3. Répéter l’instruction DEFINE grâce à une boucle

Grâce à cette structure particulière, une boucle peut être envisagée. L’instruction DEFINE est alors répétée autant de fois qu’il y a de variables. La boucle est définie par une macro variable « I » qui prend des valeurs allant de 1 à 5. La partie nombre de la macro variable est donc remplacée par la valeur de la macro variable « I ».

NOTE : Pour résoudre la macro variable lors de la première boucle, SAS effectue deux lectures. A la première lecture, les deux perluètes (ampersand) && se transforment en un seul ; &i. se transforme en 1. On a donc &CLASS1. A la deuxième lecture, SAS résout la macro variable &CLASS1. comme précédemment.

%macro test;
   proc report data=sashelp.class;
   columns name age sex weight height;
   %do i=1 %to 5
      define &&class&i. / display;
   %end;
   run;
%mend test;
%test;

4. Créer les macros variables de manière automatique

Pour créer les macros variables automatiquement, il faut agir en deux étapes.

1. Enregistrer chacune des noms de variables du data set choisi dans PROC REPORT (SASHELP.CLASS) dans un nouveau data set (LST_VAR) et plus particulière dans une variable (NAME).
2. Associer un numéro à chaque nom de variable (compteur) et convertir l’information en macro variable (CALL SYMPUT).

proc sql;
   create table lst_var as
      select name
      from dictionary.columns
      where upcase(libname)=‘SASHELP’ and
            upcase(memname)=‘CLASS’;
quit;

data _null_;
   set lst_var;
   cnt+1;
   call symput (cats(‘CLASS’,put(cnt,best.)),name);
run;

5. Compter le nombre de variables de manière automatique

Si le nombre de variable dans le data set n’est pas connu à l’avance, il faut le retrouver. Cette information est ensuite sauvegardée dans une macro variable, disons MAX_VAR, et remplacera notre nombre 5. L’article « 3 méthodes pour construire des macro variables sans macro » vous donnera plus de précisions concernant la création d’une macro variable.

Obtenir rapidement le nombre de variables dans un data set : Un moyen pour trouver le nombre de variables est de faire appel au dictionnaire de SAS intitulé TABLES.

proc sql noprint;
   select nvar into : max_var
   from dictionary.tables
   where upcase(libname)=‘SASHELP’ and
         upcase(memname)=‘CLASS’;
quit;

Plus de flexibilité sur la liste des variables concernées : Un autre moyen pour compter le nombre de variables est d’agir en deux étapes.

• Enregistrer dans un variable d’un nouveau data set chacune des noms de variables de SASHELP.CLASS.
• Compter le nombre d’observations dans ce data set. Vous pouvez vous reporter à l’article « Combien d’observations dans mon data set » pour plus de précisions sur les différentes alternatives.

Dans notre exemple, il s’agit de créer le data set LST_VAR pour la première étape. Le code de la section 4 est tout à fait suffisant pour cela. Ensuite, CALL SYMPUTX peut servir à sauvegarder l’information dans une macro variable.

data _null_ ;
   call symputx(‘max_var’,_N_-1);
   set lst_var;
run;

Pourquoi vous ai-je proposé cette alternative ?  Ici, toutes les variables sont sélectionnées. Mais si seulement quelques une sont choisies, seule la seconde alternative marche. Voici quelques sous-sélections possibles.

• Sélectionner toutes les variables numériques,
• Sélectionner toutes les variables finissant pas _X,
• etc.

En résumé : En résumé, le code se décompose en 2 étapes : créer les macros variables et utiliser ces macros variables pour définir une boucle.

*1. Créer les macros variables CLASS1 à CLASS5, MAX_VAR.;

*1.1 Créer le data set LST_VAR servant de fichier de référence.;

proc sql;
   create table lst_var as
      select name
      from dictionary.columns
      where upcase(libname)=‘SASHELP’ and
            upcase(memname)=‘CLASS’;
quit;

*1.2 Créer les macro variables CLASS1-CLASS5 en se basant sur le data set LST_VAR créé précédemment.;

data _null_;
   set lst_var;
   cnt+1;
   call symput (cats(‘CLASS’,put(cnt,best.)),name);
run;

*1.3 Créer la macro variable VAR_MAX en se basant sur le data set LST_VAR créé précédemment.;

data _null_ ;
   call symputx(‘max_var’,_N_-1);
   set lst_var;
run;

*2. Reporting : appeler les différentes macro variables pour créer la boucle autour de l’instruction DEFINE.;

%macro test;
proc report data=sashelp.class;
   columns name age sex weight height;
   %do i=1 %to &max_var.;
      define &&class&i. / display;
   %end;
run;
%mend test;
%test;

Changer la séquence d’affichage des variables

Pour changer l’ordre des variables dans un jeu de données, il faut demander à SAS de relire l’intégralité des données dans l’ordre souhaité. Deux méthodes sont disponibles : un data step ou une procédure SQL. Dans le cas particulier où les variables sont à afficher par ordre alphabétique, on pourra extraire la liste des variables des dictionnaires SAS et la sauvegarder dans une macro variable.

Je vous propose donc de voir l’approche avec le data step, puis celle avec la PROC SQL et enfin d’ajouter un exemple particulier utilisant en plus les dictionnaires.

1. Définir la séquence des variables dans un data step : l’ordre de lecture des noms de variables déterminera l’ordre d’apparition dans le jeu de données.

1.1 Une instruction INPUT : Dans l’exemple ci-dessous, où seule l’instruction INPUT est utilisée, la variable YR02 apparaît en premier suivie de YR00, YR99 et YR01. 

data one;
  input yr02 1–9 date9. yr00 11–20 date9. yr99 yr01 $;
  datalines;
02APR2002 21FEB2001 3.52 C
;
run;

1.2 Les instructions RETAIN, FORMAT, INFORMAT, LABEL, ATTRIB : maintenant, on ajoute avant l’instruction INPUT des instructions RETAIN, FORMAT, INFORMAT, LABEL et ATTRIB. Ainsi, on voit que ces instructions affectent l’ordre d’apparition des variables : YR98, YR99,… YR02.

data one;
  retain yr98 ‘REF’;
  format yr99 best.;
  informat yr00 date9.;
  label yr01=‘Annee 2001’;
  attrib yr02 format=date9.
              informat=date9.
              label=‘Annee 2002’;
  input yr02 yr00 yr99 yr01 $;
  datalines;
02APR2002 21FEB2001 3.52 C
;
run;

1.3 L’instruction SET : de la même manière, l’instruction SET défini l’ordre d’apparition des variables pas encore mentionnées.

2. Lister les variables dans une procédure SQL.

2.1 Lister les variables manuellement : les variables du jeu de données SASHELP.CLASS apparaissent dans l’ordre suivant : NOM, SEX, AGE, HEIGHT et WEIGHT. Pour changer cet ordre, avec une procédure SQL, il faut les lister individuellement. Dans l’exemple qui suit, les variables apparaissent par ordre alphabétique.

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

2.2 Automatiser la démarche : Si vous avez plus de 300 variables à lister, cela devient vite très contraignant. Pour rendre la tâche plus simple, on sauvegarde la liste des variables par ordre alphabétique dans une macro variable. Le nom de toutes les variables est disponible dans le dictionnaire TABLES.

proc sql noprint;
  select name into : var_lst separated by ‘, ‘
     from dictionary.columns
     where upcase(libname)=‘SASHELP’ and
           upcase(memname)=‘CLASS’
     order by name;
  create table class as
     select &var_lst.
     from sashelp.class;
quit;

Et par magie mon jeu de données a disparu (LIBNAME)

Une des premières choses à comprendre en SAS est la notion de temporaire et permanent qui s’appliquent aux fichiers. Pour cela, il faut introduire la notion de bibliothèque (library). Ici, je vous propose plus particulièrement de voir les jeux de données SAS, communément appelés data sets.

Un data set c’est quoi ? Un data set SAS est un fichier SAS contenant un tableau. Chaque colonne a un nom et fait référence à une variable, chaque ligne correspond aux observations. Ce type de fichier est créé par SAS via un data set pour une procédure SQL.

Un nom de data set sans extension dans un programme SAS : un jeu de données a un nom pouvant suivant quelques règles de notation :

• longueur de 32 caractères,
• nom commençant par une lettre ou un trait bas,
• caractères suivant pouvant aussi être des chiffres

Une extension (ex. : .sas7bdat) n’est visible que dans une arborescence comme Windows Explorer. Pour le nommer dans un programme, le nom sans l’extension est utilisé. Mais comment SAS sait-il où ce fichier est sauvegarder ?

1. Sauvegarde temporaire 

Un répertoire vidé automatiquement : par défaut, SAS assumera que le data set est sauvegardé dans un répertoire défini lors de l’installation du logiciel. Ce répertoire est vidé à chaque fermeture du logiciel. Dans le cas d’un travail en mode batch (par opposition au mode interactif), ce répertoire est vidé à la fin de chaque soumission de programme.

Pour les curieux : si vous êtes curieux de savoir l’emplacement de votre répertoire temporaire, utilisez la procédure option. La réponse est située dans la fenêtre LOG de SAS. A priori cette information ne vous servira pas pour votre travail de programmation sauf cas exceptionnel (après plusieurs années de SAS, je n’en ai toujours pas eu besoin).

proc options option=work;
run;

WORK ? C’est le petit nom pour parler de ce répertoire au contenu temporaire : l’accès à ce répertoire a un petit nom ! WORK. Le mot WORK est optionnel : ainsi si on veut écrire dans un programme le nom d’un data set dans son intégralité, il suffira d’ajouter WORK avant le nom du jeu de donné et d’utiliser un point comme séparateur. Comme WORK est la valeur par défaut, un data set nommé DEMO et sauvegardé sous WORK sera référencé indifféremment DEMO ou WORK.DEMO. Lors de la fermeture du logiciel SAS, le fichier DEMO sera supprimé. C’est pour cela que l’on parle de fichier temporaire. Du coup, comment créer un data set qui puisse survivre à une session SAS ?

2. Des data sets qui survivent

Une ‘library’ fait référence à un espace de stockage : le répertoire temporaire, WORK, fait partie de la catégorie des bibliothèques. Et en anglais bibliothèque se traduit… ? library. Pour faire référence à un autre répertoire, qui lui ne sera pas vidé automatique par SAS, il faut de définir dans une instruction LIBNAME (LIB comme notre LIBRARY de tout à l’heure et NAME, donc nom de bibliothèque). Une convention similaire au nom de data set à part la longueur. Comme pour WORK, il faut donner un petit nom au chemin d’accès à ce répertoire. On parle de LIBREF.

• 8 caractères sont autorisés au maximum.
• Comme un nom de data set, il commencera par une lettre ou un trait bas.
• Pour les autres caractères les chiffres sont aussi valides.

Trois composants principaux pour l’instruction LIBNAME : l’instruction LIBNAME est composée du mot-clé LIBNAME, du petit nom et du chemin d’accès entre guillemets.

libname origin ‘C:\sasref\origine’;
libname propre ‘C:\sasref\propre’;

Désactiver une bibliothèque : par défaut, la bibliothèque sera valide jusqu’à la fin de la session en mode interactif. Pour désactiver la bibliothèque plus tôt, il suffit de la nommer sans préciser le chemin d’accès et en ajoutant clear. Si on veut les désassigner toutes, le nom de la bibliothèque sera remplacée par le mot-clé _all_ (SAS Online Doc: The Libname Statement Syntax for Relational Databases).

libname origin clear;
libname propre clear;
libname _all_ clear;

Consulter la vue SASHELP.VSLIB pour connaître les bibliothèques actives : les vues sont des fichiers contenant un code. Lors de la lecture de ce fichier, le code est soumis. Cela permet de retrouver en temps réel l’information, la dernière. On trouve notamment la vue VSLIB sauvegardés dans le répertoire permanent de SASHELP. Grâce à cette vue vous découvrirez également les autres bibliothèques créées lors de l’installation de SAS (MAP, SASHELP,SASUSER) qui ne sont pas vidées en fin de session et dans lesquelles on ne modifie rien, on lit seulement.

proc sql;
   select *
   from sashelp.vslib;
quit;

L’instruction LIBNAME a plusieurs options. Mais étant utilisés de manières sporadique pour des cas bien particulier, cela ne relève pas d’un article pour débutant en SAS.

Majuscule ou minuscule sous SAS

Les mots majuscule et minuscule sont traduits en anglais par uppercase et lowercase. Lorsqu’un langage de programmation est sensible aux différences entre les deux, on dit qu’il est case-sensitive. Ce vocabulaire vous sera utile pour comprendre la suite de cet article.

1. SAS n’est pas sensible au changement entre majuscules et minuscules la plupart du temps : SAS ne fera pas la différence entre les textes tantôt écrits en majuscules, tantôt en minuscules dans de nombreux cas. Voici quelques exemples :

• les mots de syntaxe propre à SAS (data, proc, do, if, filename, etc.),
• le nom des bibliothèques (libname orig_data « c:/ »; data demo; set Orig_DATA.demo; run;),
• le nom des jeux de données SAS (data demo; set DEmo;run;),
• le nom des variables (age, Age, AGE).

Illustration : en consultant les métadonnées via les dictionnaires ou la procédure proc contents, on note que tous les noms des bibliothèques sont standardisées quelque soit la notation d’origine. Notez cependant le cas particulier des noms de variables qui continuent d’apparaître comme lors de la saisie initiale dans les métadonnées mais peuvent être référencées indifféremment de la case (if test=’ID’; if Test=’ID’;).

Conseil : la lecture des minuscules est plus facile. Je vous conseille de les privilégier pour écrire votre code. Vous réserverez ainsi les majuscules pour les cas particuliers, et pourrez ainsi les repérer plus facilement lors de la lecture de votre programme.

2. Les valeurs définies entre guillemets sont sensibles à la case : voici trois exemples de données sensibles aux majuscules :

• les données des variables caractères (cntry=’FR’;),
• le label des variables (label cntry=’Pays’;),
• le label des data sets (data demo (label=’Panel Démographie’);).

Ces trois chaînes de caractères sont définies entre guillemets. Donc ici cntry=’FR’ est différent de cntry=’Fr’.

3. Deux fonctions pour évitez des erreurs, UPCASE et LOWCASE : pour vérifiez les valeurs d’une variable quelque soit sa case, pensez à faire une comparaison sur les valeurs standardisées (tout majuscule ou tout minuscule), au risque de perdre, sinon, des observations. Pour cela vous avez les fonctions UPCASE() et LOWCASE().

4. Exemple d’utilisation des fonctions UPCASE et LOWCASE avec les dictionnaires : personnellement je fais beaucoup appel à ces fonctions pour récupérer une partie des informations des dictionnaires. Voici un exemple où toutes les données du dictionnaire TABLE faisant appel à la bibliothèque temporaire WORK sont récupérées :

proc sql ;
    select *
    from dictionary.tables
    where upcase(libname)='WORK';
quit;

NOTE : La fonction PROPCASE met la première lettre de chaque mot en majuscule et le reste en minuscule. Pour les acronymes où les lettres sont séparées par un point, toutes les lettres sont mises en majuscule.

Plus de détails sur ces fonctions sont disponibles dans la documentation en ligne : UPCASE Function, LOWCASE Function et PROPCASE Function.