Les 2 visages de la fonction SUBSTR

 

Définir une nouvelle variable à partir de x caractères d’une autre variable. Substituer, dans une variable texte, les x caractères à partir du z^ème. Ces deux thématiques fortes différentes sont traitées avec la même fonction SUBSTR. Selon qu’elle soit placée à gauche ou à droite de l’égalité, la fonction répond à un besoin différent.  

1. Créer une nouvelle variable à partir d’un sous-ensemble d’une autre : l’application la plus courante de la fonction SUBSTR consiste à conserver un sous-ensemble d’une chaîne de caractères, en se référant à sa position de départ et à sa longueur, pour définir une nouvelle variable.

Notation : la fonction est composée de trois paramètres

• le nom de la variable d’origine, 
• la position du premier caractère qui nous intéresse,
• le nombre total de caractères à partir du point de départ (optionnel).

Exemple : dans l’exemple suivant, imaginez une variable TESTCASE. Les tests tc0101, tc0102 appartiennent au même groupe, tandis que tc0201 appartient à un groupe différent. Les deux premiers chiffres font référence au groupe. Pour sauvegarder ces chiffres dans une variable GRP, on utilise la fonction SUBSTR.

grp=substr(testcase,3,2);

Note : Si le nombre de caractères à retenir n’est pas précisé par un troisième paramètre, c’est tout le reste de la chaîne à partir de la position donnée en second paramètre qui est conservé.

grp=substr(testcase,3);

2. Remplacer une partie d’une chaîne de caractères : pour actualiser une variable dans un data step, la démarche sous SAS est fastidieuse. Dans un cas particulier, cependant, on peut l’éviter : changer un sous-ensemble d’une variable texte défini par sa position dans la chaîne et sa longueur.

Rappel, actualiser une variable dans un data step : dans un premier, la variable est renommée. Cette variable contient les valeurs d’origine, celle qui nous intéressent. On peut ainsi définir une nouvelle variable portant le nom d’origine puisque ce nom n’existe plus. Cette nouvelle variable prendra nos valeurs d’origine, plus les nouveautés voulues via une addition, une concaténation ou autre.

Exemple : on reprend l’exemple de la première section avec notre variable TESTCASE. La chaîne  ’tc’ commençant en position 1 et longues de 2 est remplacée par les caractères ‘AB’.

substr(testcase,1,2)=‘AB’;

Notez que la valeur de substitution doit être de la même longueur. Si elle est plus grande, les caractères seront ignorés. Si elle est plus petite, des blancs remplaceront les espaces manquants.  De plus, on ne peut substituer que parmi les caractères existants, blancs de début et fin de chaîne compris.

Ecrire un texte avec l’instruction PUT

 

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.

Le monde du programmeur SAS en pharma

 

L’environnement professionnel du programmeur SAS dans le secteur pharmaceutique et plus précisément dans la partie essais cliniques peut ressembler à une boîte noire. Hors SAS est un standard dans ce secteur et les besoins en programmeurs y sont récurrents. Il est donc fort enrichissant d’avoir une connaissance de ce milieu.

Pour une immersion dans l’univers des essais cliniques, je vous propose l’article sur le sujet a été écrit par Sy Truong, Meta-Xceed : Clinical Trials Terminology for SAS Programmers. Voici une traduction du résumé et de l’introduction pour vous donner un avant goût de cet article.

“Le processus de développement des médicaments/drogues est un processus clinique qui a son propre langage. La fonction des programmeurs SAS n’a pas besoin d’être MD ou expert de la réglementation mais une connaissance des terminologies professionnelles est importante pour être efficace. Cet article couvrira le processus de développement d’une drogue de la découverte à la phase IV. Il expliquera le large éventail d’acronymes comme IND, NDA, GCP et MedDRA. Il décrira également certaines terminologies utilisées dans le processus des essais cliniques lorsqu’une drogue est développée et soumise au FDA. Cela donnera aux programmeurs SAS une perspective plus large et un contexte à leur travail durant l’analyse et le rapport de données d’essais cliniques.”

“Cet article va vous raconter une histoire fictive concernant un diplômé de l’enseignement supérieur nommé James qui commence un nouvel emploi dans une entreprise pharmaceutique. Chaque nouveau terme que James rencontre est présenté en gras et en italique pour le faire ressortir. En entrant dans un nouvel cercle professionnel, il rencontre beaucoup de personnes et apprend de nouveaux processus remplis de vocabulaires et d’acronymes non familiers. Au fur et à mesure que James s’immerge dans son nouveau job en tant que programmeur SAS, il apprend le sens des terminologies et devient plus productif au travail.”

Pour faire face à un vocabulaire technique en anglais, je vous conseille vivement le dictionnaire français-anglais du site québécois www.granddictionnaire.com.

Fini le Moyen-Age pour compter les mots

 

Vous avez une variable composée d’un ou plusieurs mots pour chaque observation, le tout séparé par des espaces, des virgules ou autre. Et vous voulez savoir combien il y a de mots. Avec SAS 9, il est très rapide de trouver le nombre de mots. Avec SAS 8.2, il faut pallier à l’absence de la fonction COUNT. Dans les deux cas, l’idée est la même : on compte les délimiteurs et on ajoute 1.

Prenons le cas des espaces. Dans un premier temps, on enlève les blancs de début et de fin de chaîne. Puis on enlève les doublons entre les mots. Enfin on compte les espaces restants. Il faudra aussi tenir compte du fait qu’une observation puisse ne contenir aucune valeur.

Voici les données qui serviront d’exemple :

data ds_orig;
   x=‘ AB CD GH ‘;
   output;
   x=‘ ‘;
   output;
   x=‘AB ‘;
   output;
run;

1. Avec SAS 9, un calcul rapide : il faudra faire appel à:

• la fonction STRIP pour les blancs aux extrémités,
• la fonction COMPBL pour enlever les blancs doublons,
• la fonction COUNT  pour compter le nombre d’occurrence d’un caractère donné,
• la fonction MISSING ou un simple = ‘ ‘ pour savoir si la chaîne est vide.

Voici un exemple avec des espaces pour délimiteur.

data sas9 ;
   set ds_orig;
   if x = ‘ ‘ then nb_mots = 0;
   else nb_mots=count(compbl(strip(x)),‘ ‘) + 1;
run;

2. Avec SAS 8.2, il faut contourner l’absence de la fonction COUNT: il existe plusieurs options dont celle-ci utilisant une boucle DO WHILE: 

• Les fonctions TRIM et LEFT remplacent la fonction STRIP.
• Les fonctions COMPLB et MISSING restent valide.
• Une boucle remplacera la fonction COUNT.

On extrait le 1er mot de la chaîne, puis le 2nd, etc. via la fonction SCAN. Si la valeur trouvée est une valeur manquante, alors le nombre de mots est égal au nombre du boucles sans valeur manquante, c’est-à-dire le nombre de boucles actuel moins 1. Le compteur, ici nommé i, est réinitialisé pour arrêter la boucle DO WHILE.

data sas8_2;
   set ds_orig;
   if missing(x)then cnt_mots=0;
   else
      do;
         z=compbl(trim(left(x)));
         i=1;
         do until (i=0);
         if missing(scan(z,i,‘ ‘))then
            do;
               cnt_mots=i-1;i=->1;
               end;
               i=i+1;
            end;
         drop i z;
   end;
run;

Le luxe des macros, B.A.BA de la syntaxe

 

Pour répéter un même programme SAS avec quelques nuances, trois possibilités s’offrent à vous :

1. la macro,
2. le data _null_,
3. le call execute.

Aujourd’hui, je vous propose de voir la notation de base pour la création d’une macro. Pour pouvoir ensuite développer vos propres macros, vous devrez savoir comment résoudre une macro variable.

1. Définition et appel : le minimum

1.1 Encadrer votre programme entre les instructions %MACRO et %MEND : une des caractéristiques du langage macro est l’utilisation du signe pourcentage (%) devant des mots-clés. Ceux qui créent une macro n’échappent pas à la règle. On trouve le %MACRO pour annoncer le début de la définition et le %MEND pour arrêter la définition. Pourquoi le mot %MEND ? M est la référence au mot MACRO et END est le mot FIN en anglais.

%macro;
*mon programme SAS;
%mend;

Important : on s’assurera que la définition de la macro est terminée avant d’en commencer une nouvelle.

1.2 Un nom pour ma macro : il faudra aussi donner un nom à la macro pour pouvoir l’identifier par la suite.

%macro monlisting;
*mon programme SAS;
%mend monlisting;

L’utilisation du nom de la macro en clôture n’est pas obligatoire mais c’est un bon repère dans votre programme.

1.3 Appel de macro : pour appeler votre macro, il vous suffit ensuite de faire précéder le nom de la macro du signe pourcentage.

%monlisting;

2. Imaginez un questionnaire en ligne avec des champs à remplir : parfois une valeur est inscrite par défaut, parfois le texte à remplir est libre ou réduit à un éventail de proposition. Dans notre cas, le champ est un paramètre de la macro. Derrière chacun de ces champs se cache un nom. Il faudra donc donner un nom à ce paramètre. Et enfin, la valeur d’origine est optionnelle. Ces paramètres, qui permettent de nuancer le programme, sont définis dans l’instruction %macro :

%macro monlisting(annee=ALL,imprimer=NO,patient=);

2.1 Utiliser les valeurs par défaut : pour appeler la macro en utilisant les paramètres par défaut, on écrira soit la macro sans paramètres, ou on pourra rappeler les valeurs d’origine pour améliorer la lisibilité, si besoin est.

%monlisting;
%monlisting(annee=ALL,imprimer=NO,patient=);

2.2 Changer les valeurs des paramètres : pour appeler la macro avec une option d’impression différente, le paramètre imprimer sera ajouté :

%monlisting (imprimer=YES);

Important : ici j’ai fait le choix de vous présenter la notation la plus pratique, mais ce n’est pas la seule. Le signe égal est indiqué même si tous les paramètres n’ont pas de valeur par défaut. Ainsi lors de l’appel de macro, on pourra agir sur les paramètres :

• plus besoin de lister tous les paramètres
• plus besoin de respecter l’ordre d’origine des paramètres

3. Utiliser les valeurs des paramètres dans le programme : les paramètres d’une macro sont considérés comme des macros variables et rappelés dans le programme comme tels.

J’additionne des valeurs manquantes

Une simple somme de deux nombres et vous obtenez un résultat différent de vos attentes. C’est possible avec SAS lorsque des valeurs manquantes (missing et special missing) sont incluses. Je vous propose de découvrir la différence entre les opérateurs mathématiques et les fonctions de calcul au travers de la fonction SUM.

Voici la règle : les fonctions de calcul SAS ignorent les valeurs manquantes. Ainsi avec la fonction SUM, la somme de 2 et d’une valeur manquante est 2, alors qu’il est valeur manquante avec l’opérateur + d’addition : 2 +. = .

A présent, voyons les trois notations de la fonction SUM.

1. Lister les valeurs comme autant de paramètres de la fonction SUM : les paramètres d’une fonction SAS se séparent par une virgule. Pour faire la somme de plusieurs valeurs, vous pourrez les lister les unes à la suite des autres dans les parenthèses de la fonction SUM en les séparant par une virgule :

newvar = sum(2,3,.);

Mais soyons honnête, vous aurez plus souvent l’occasion de faire référence aux valeurs par de l’intermédiaire de variables qu’en listant des données brutes :

newvar = sum(x,y,z);

2. Le mot-clé OF pour lister les valeurs à additionner sans virgule : pour lister sans virgule les données à additionner dans la fonction SUM, il faut absolument ajoutez le mot-clé OF :

newvar = sum (of 2 3 .) ;

newvar = sum(of test2 test3 test4);

3. Le mot-clé OF c’est aussi un moyen de lister de nombreuses variables au nom proche : dans l’exemple précédent, les variables portent des noms ayant une base commune et un nombre entier toujours incrémenté de 1. En définissant un intervalle listant les première et dernière variables séparées par un trait d’union, vous vous épargnerez un travail qui devient vite fastidieux avec un nombre de variables qui augmente.

newvar = sum(of test2-test4);

Cette notation n’est pas propre à la fonction SUM. Elle s’applique dans de nombreux contextes : une option KEEP, DROP, un ARRAY, etc.

Important : notez ici l’importance de ne pas oublier le mot-clé OF. Dans l’exemple précédent, SAS soustrairait la variable test4 à la variable test2 si le mot-clé OF n’apparaissait pas. La fonction SUM n’aurait alors qu’une valeur.

Autres lectures : les fonctions MIN et MAX et leur corollaires >< et <> fonctionnent sur le même principe que la fonction SUM et l’opérateur + lorsqu’ils traitent des valeurs manquantes.

Proc Format : 7 points forts de VALUE

Dans un article précédent, nous avons vu les deux notations pour écrire de nouveaux formats : via un jeu de données, via l’instruction VALUE de PROC format. A présent je vous propose des précisions sur l’instruction VALUE, afin de pouvoir mettre le même texte sur plusieurs valeurs.

1. Virgules pour des données fixes : énumérer les valeurs les unes après les autres en les séparant par des virgules : -1,-2, 1, 2.

proc format;
   value in_ex
      -1,-2,1,2 = 'Inclus'
      0         = 'Exclus';
run;

2. Trait d’union pour les intervalles : fournir un intervalle entre deux valeurs fixes, bornes incluses, avec un trait d’union : 0-1 pour les valeurs entre zéro et un, ou encore -5 – -1 pour les valeurs négatives entre moins cinq et moins un.

proc format;
   value intrvl
      0-1    = 'Entre 0 et 1, bornes inclus'
   value neg_pos
      -5--1  = 'Valeurs négatives'
      0      = 'Zéro'
      1-5    = 'Valeurs positives';
run;

3. Signe inférieur pour exclure les bornes d’un intervalle : fournir un intervalle entre deux valeurs fixes et exclure les bornes en utilisant le signe inférieur : 0 < – < 1.

proc format;
   value intrvl
      0 <- <1 = 'Entre 0 et 1, bornes exclus';
run;

4. LOW pour définir la borne inférieure d’un intervalle : prendre toutes les valeurs en dessous d’une valeur donnée grâce au mot-clé low : low-60.

proc format;
   value inf_lim
      low-0    = 'Inférieur ou égal à zéro';
run;

5. HIGH pour définir la borne supérieure d’un intervalle : prendre toutes les valeurs en dessus d’une valeur donnée avec high : 0-high

proc format;
   value sup_lim
      0-high    = 'Supérieur ou égal à zéro';
run;

6. OTHER pour lister les valeurs restantes : enfin il vous reste le mot-clé other pour les données restantes.

proc format;
   value autre
      0-1   = 'Negative values'
      other = 'Pas dans l'intervalle';
run;

7. Définir un format à partir d’un autre format : le mot-clé OTHER en combinaison avec les crochets [] permet de créer un format à partir d’un format existant. Notez que vous pouvez lister autant d’instructions value que vous le souhaitiez dans une seule procédure format.

proc format;
   value ny
   0     ='NO'
   1     ='YES;
   value nybis
   .     = 'MISSING'
   .A    = 'Not Applicable'
   other = [ny.];
 run;

2 méthodes pour de nouveaux formats

Deux méthodes sont disponibles pour créer des formats sous SAS :

• entrée les données manuellement dans une instruction value d’une part ;
• réutiliser les données stockées dans un SAS data set.

Chacune des méthodes à un champ d’action privilégié.

• On préférera l’entrée manuelle pour un format ayant peu de valeurs et qui ne soit pas un standard pour plusieurs projets.
• Dans le cas contraire, de nombreuses valeurs ou des valeurs récurrentes entre études, l’utilisation d’un data set sera plus appropriée.

Dans les deux cas, la procédure format sert. Le nom du format ne doit pas déjà exister parmi les formats actifs. Chaque valeur à convertir ne doit apparaître qu’une fois. Quatre informations sont requises avec les deux méthodes :

1. Le nom du format
2. La valeur d’origine
3. La nouvelle valeur
4. Le type de données pouvant recevoir ce format (caractère ou numérique).

Deux précisions :

• Par défaut le type est numérique. Il n’est donc pas obligatoire de le préciser. Seul un changement explicite peut le modifier.
• Le nom du format ne doit pas avoir plus de 32 caractères, voir 31 pour les formats destinées aux variables caractères, l’espace restant étant réservé au symbole dollar. Sous SAS 8.2, il ne fallait pas plus de 8 et 7 caractères respectivement. De plus, le format ne doit pas se terminer par un chiffre.

1. Le cas du data set transformé en format : en créant un data set avec ces 4 informations, vous pouvez créer un format. Ces variables seront toutes caractères et s’appelleront respectivement :

1. FMTNAME pour le nom du format,
2. START pour la valeur d’origine (la valeur stockée dans SAS),
3. LABEL pour la nouvelle valeur (celle qui sera affichée)
4. TYPE avec C pour un format s’appliquant à des données caractères et N pour un format numérique.

Le type n’aura besoin d’être précisé que dans le cas de données caractères. Sans précision de votre part, SAS choisira TYPE=N.

Dans l’instruction PROC FORMAT, le mot CNTLIN= introduit le nom du jeu de données.

proc format cntlin=grp;
run;

2. Le cas des données saisies manuellement : après le mot-clé on précisera

• le type du format via le symbole dollar ($) si caractère seulement
• le nom du format

Puis sont listées chacune des valeurs d’origine suivies de la nouvelle valeur entre guillemets. Chaque rapprochement est présenté sous forme d’égalité. Les valeurs d’origines seront entre guillemets si elles sont caractères.

Conseil : par soucis de lisibilité, les différentes valeurs du format seront mises l’une en dessous de l’autre.

proc format;
   value grp 10 = ‘Per Protocol’
             11 = ‘Modified Per Protocol’
             20 = ‘Intent-to-Treat’
             21 = ‘Modified Intent-to-Treat’;
   value $ grp ‘PP’   = ‘Per Protocol’
               ‘mPP’  = ‘Modified Per Protocol’
               ‘ITT’  = ‘Intent-to-Treat’
               ‘mITT’ = ‘Modified Intent-to-Treat’;
run;

Pour plus d’informations sur la notation de l’instruction VALUE, reportez vous à l’article intitulé “Proc Format : 7 points forts de VALUE“.

Créer des formats permanents via l’option LIBRARY : jusqu’à présent les formats ne seront valables que le temps de l’exécution de votre programme (batch mode) ou le temps de la session SAS (interactive mode). Pour les sauvegarder sur votre disque dur, et donc de manière permanente, précisez l’endroit via un nom de bibliothèque en tant qu’option LIB= de l’instruction proc format. Par défaut, il s’agit de la bibliothèque temporaire WORK. L’appel d’un format, qu’il soit temporaire ou permanent, dépasse le sujet d’aujourd’hui.

libname sasref ‘C:/sasref’;

proc format lib=sasref;
   *…;
run;

Les formats du bibliothèque donnée sont regroupés dans un fichier nommé CATALOG SAS. Le nom de ce catalogue s’appelle FORMATS à moins qu’un autre nom soit donné dans l’option LIB=. Par exemple, lib=sasref.std créera un fichier et plus particulière un catalogue pour les formats nommé STD et ce catalogue sera sauvegardé dans la bibliothèque LIB.

Envoyez un email via SAS

Lorsque vous écrivez un programme devant être exécuté de manière régulière, disons une routine pour faire un transfert de base de données, vous pouvez communiquer par email à votre collègue, en charge de la base, toute incohérence détectée. Je vous invite à essayer l’exemple détaillé plus loin, qui fait appel au jeu de données CLASS, disponible dans la bibliothèque SASHELP de SAS. Avec lui, un email est envoyé si un élève répertorié a 15 ans. Mais auparavant, je vous propose de comprendre le mécanisme pour envoyer un email.

1. Ecrire son message : vous écrivez via un DATA _NULL_ et des instructions (statement) PUT votre message.

2. Préciser la destination du message : puis vous indiquez vers quelle la destination votre message doit être envoyé, via le FILE statement. Si aucune incohérence n‘est détectée, vous ferez une sortie classique vers le listing (file print;). Sinon vous l’adresserez vers une référence extérieure, qu’on appellera dans notre exemple MEMO (file memo;), définie dans le FILENAME statement.

3. Créer un data set de référence : pour savoir si une incohérence existe, vous vous référerez à un data set, qui contiendra la liste des incohérences, via l’instruction SET. Lorsqu’il est vide, aucun message ne sera envoyé.

4. Alternez entre vos deux sorties via une macro variable : par défaut, il n’y aura pas d’email envoyé (file print;). Pour alterner entre les deux sorties possibles du message, on utilisera une macro variable définie dans un premier temps égal à PRINT (%let email_out=print;). Puis on changera cette valeur si besoin dans une procédure SQL avec INTO :.

5. Définir l’entête de votre email via deux mots-clés : le FILENAME statement contiendra un nom de référence. J’ai choisi MEMO ici. Puis l’email du destinataire après le mot-clé EMAIL sera listé entre guillemets. Et enfin, on ajoutera l’objet du mail via SUBJECT=’ ‘.

%let email_out=print ; 

proc sql noprint;
   create table incoherences as
      select *, 'memo' as outp
      from sashelp.class
      where age=15
      order by name;
   select distinct outp into :ema_out
      from incoherence;
quit; 

filename memo email 'veronique.bourcier@sasreference.fr'
              subject = 'Exemple de programme '; 

data _null_ ;
   set incoherences ;
   file &email_out. ;
   if _N_=1 then
      do;
         put 'Dear Administrator ';
         put // 'The SASHELP.CLASS table has ages equal to 15.';
         put // 'Records are listed below. ';
         put // 'Kind Regards, ';
         put /;
      end;
  put / NAME=;
run;

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.

3 méthodes pour construire des macros variables sans macro

Les macro-variables peuvent être créées soit à l’intérieur d’une macro, soit à l’extérieur. Ici je vous propose de voir comment les créer indépendamment d’une macro. Pour une valeur brute indépendante du reste de votre programme, je vous propose le statement %let. Pour des macros variables définies à partir d’autres informations disponibles dans un jeu de données, vous aurez le choix entre le statement ‘CALL SYMPUT’ dans un data step et le mot clé ‘INTO :’ dans une procédure SQL.

1. Assigner une valeur manuellement : L’instruction %LET sert à définir une macro variable quand vous connaissez la valeur à donner à votre macro variable à l’avance et qu’elle n’est pas fonction de vos données. Tapez la valeur de votre macro-variable. Pour chaque %LET statement une macro variable est créée. Faites suivre %LET du nom de la variable et saisissez sa valeur après le signe égal.

%let projet=53269 ;

2. Créer une macro variable dans un data step : pourquoi vouloir passez par un data step ? Voici deux exemples : assigner la valeur d’une variable automatique comme _N_ ; créer une boucle pour créer autant de macros variables qu’il y a de valeurs distinctes dans une variable.

2.1 La distinction entre CALL SYMPUT et CALL SYMPUTX : les arguments de CALL SYMPUT sont le nom de la macro variable dans un premier temps, et sa valeur dans un second temps. Jusqu’à SAS 8.2, on devait convertir les valeurs numériques en valeur caractères, via la fonction PUT, pour créer la macro variable. Depuis SAS 9, on peut directement utiliser la valeur numérique avec CALL SYMPUTX.

data _null_ ;
   set demo;
   call symputx(‘Nb_boucle’,_N_);
run;

Pourquoi cette nouveauté si tardive ? Parce que la valeur d’une macro variable est toujours caractère. Dans un macro statement tel %if…, vous aurez besoin d’une macro fonction pour faire la somme de deux macro variables. En dehors, vous devrez écrire la macro variable entre double guillemets.

2.2 Un seul CALL SYMPUT(X) et plusieurs macros variables : si vous avez un jeu de données avec deux variables : une contenant le nom de vos futures macro-variables et l’autre leur valeur, vous pouvez avec un seul CALL SYMPUT/SYMPUTX créer toutes les macro-variables. Pour cela, il vous suffit de mettre le nom des deux variables dans les paramètres. Cette fois-ci il n’y a plus de guillemets.

Niveau	Dose
Dose1	50
Dose2	100
Dose3	150

call symputx (niveau,dose);

3. Créer une macro variable dans une procédure SQL : Vous pouvez répondre à trois besoins avec PROC SQL : 1) sauvegarder une valeur unique dans une macro variable, comme le nombre total d’observations dans un jeu de données ; 2) sauvegarder toutes les valeurs prises par une variable dans une seule macro variable, en jouant avec SEPARATED BY. 3) créer autant de macro variable qu’il y a de valeurs sélectionnées.

3.1 Une macro variable ayant une seule valeur : pour sauvegarder le nombre d’observations d’un data set dans une variable CNT, vous écririez select count(*) as cnt from demo ; Pour sauvegarder cette information dans une macro variable CNT vous remplacerez ‘AS’ par ‘INTO :’

proc sql;
   select count(*) into : cnt
      from sashelp.class ;
quit;

3.3 Plusieurs macros variables à partir de plusieurs valeurs: la syntaxe suivante permet de créer plusieurs macros variables à partir de plusieurs calculs extraits d’un même data set.

proc sql;
   select distinct count(age), count(*)
              into : cnt_age,
                   : cnt_rec
       from sashelp.class;  
quit;

Si les noms de variables ont un nom schématique (base + nombre incrémenté par 1), la syntaxe suivante peut être appliquée.

proc sql;
   select distinct age into : pop1-:pop6
      from sashelp.class;
quit;

3.4 Plusieurs valeurs dans une seule macro variable: vous pouvez aussi décider de sauvegarder ces cinq valeurs dans une seule macro variable. Ne listez alors qu’un nom. Au moment d’appeler votre macro vous observerez que seule la première valeur apparaît si vous n’avez pas précisez un délimiteur comme un espace ou une virgule entre les observations via SEPARATED BY. Par défaut, le délimiteur est en effet un passage à la ligne. Voici deux exemples :

proc sql;
   select distinct age into : age_space
                            separated by ‘ ‘
      from sashelp.class;
   select distinct age into : age_comma
                           separated by ‘,’
      from sashelp.class;
quit;
 
3.5 La macro variable automatique SQLOBS : Enfin sachez qu’il existe une macro variable automatique SQLOBS qui sauvegarde le nombre d’observation de la dernière procédure SQL. Cette fonction peut s’avérer pratique à condition de bien garder à l’esprit qu’il ne faudra pas par la suite intercaler d’autres SQL statement qui changeraient la valeur de cette macro variable automatique.

3.6 Extra

L’option NOPRINT : Par défaut, les valeurs d’un select statement sont affichées dans la log, si aucun jeu de données n’est crée. Si vous ne souhaitez pas voir la valeur des macros variables s’afficher dans votre log arrêter via l’option NOPRINT :

   proc sql noprint;
      *ma sélection;
   quit;

Important: si aucun record n’est sélectionné avec la PROC SQL, la macro variable n’est pas créée. Dans l’exemple ci-dessous, la macro variable MAX_AGE n’apparaît pas dans la liste des variables de l’utilisateur disponible dans la log.

proc sql noprint;
   select max(age) into : max_age
   from sashelp.class
   where age > 18;
quit;

%put _user_;

4. Supprimer une macro variable globale

Les macros variables globales sont disponibles tout le long de la session. On peut choisir d’écraser la valeur en créant une nouvelle macro variable portant le même nom ou choisir de la supprimer. Dans la version 9.1.3, l’instruction globale %SYMDEL fait supprime les macros variables globales pour vous. Pour ce qui est des variables locales, il n’y a pas d’instructions pour la simple raison que la valeur de la macro variable ne peut pas être rappelée en dehors de la macro.

%symdel cnt cnt_age cnt_rec pop1 pop2 pop3 pop4 pop5 pop6 age_space age_comma;

NOTE : Pour définir une condition basée sur une macro variable, il faut qu’elle existe. Si une macro variable n’est pas créée, faute de valeur à assigner, il est conseillé de définir au préalable une valeur par défaut avec un %LET par exemple. Elle pourra ensuite être actualisée par une des trois méthodes mentionnées ci-dessus. Une autre solution est de s’assurer de l’existence de la macro variable avec la fonction %SYMEXIST.

Quel chemin prendre sous Unix?

Lors de l’utilisation des commandes Unix, vous avez le choix entre deux notations pour désigner le chemin d’accès à un dossier ou à un fichier.

1. La distinction entre un chemin relatif et un chemin absolu : pour désigner un répertoire ou un fichier deux possibilités s’offrent à vous :

• Soit vous précisez l’intégralité de son chemin d’accès (chemin absolu).
• Soit vous entrez le chemin d’accès à partir de l’endroit où vous vous situez actuellement (chemin relatif).

Prenez l’exemple suivant : vous avez un chemin à cinq niveaux c:/monprojet/monetude/dm/test. Si vous vous situez au niveau 2 (monprojet) et voulez vous déplacer au niveau 4 (dm), vous utiliserez au choix

• le chemin absolu c:/monprojet/monetude/dm ou
• le chemin relatif monetude/dm.

2. L’avantage du chemin relatif : un même programme peut tourner depuis plusieurs endroits. Voici quelques exemples.

• Dans une entreprise, le développement du programme est fait sur un serveur dédié au test. La version finale est ensuite mise sur un serveur dit de production.
• Un étudiant pourra travailler à la fois sur les ordinateurs en réseau de l’université et sur son ordinateur personnel à son domicile.

Les répertoires supérieurs (répertoires parents) varient donc. Les sous-répertoires (répertoires enfants), quant à eux, restent identiques. Les chemins relatifs évitent les mises à jour des chemins d’accès lors de l’utilisation du programme de différents endroits.

3 options pour un aperçu de vos données brutes (PROC PRINT)

Lors de l’écriture de votre programme, vous aurez une idée de l’état de votre jeu de données. En confrontant cet a priori avec un aperçu de vos données, vous agirez en sécurité et de manière professionnelle. La procédure d’impression (proc print) sera souvent suffisante pour avoir une vue rapide de vos données, concentrée sur les valeurs brutes compressées, sans label voir sans format.

1. Affichez le maximum d’information sur une page : en enlevant les blancs de fin de chaîne de caractère et les éventuels labels activés pour l’option label au niveau global, vous pourrez concentrer un plus grand nombre d’informations sur une page.

• Pour un affichage minimum sans label, optez pour l’option WIDTH et la valeur minimum.

proc print data=demograph width=min;
run;

• Pour seulement désactiver les labels le temps de la procédure, ajoutez l’option NOLABEL.

proc print data=demograph nolabel;
run;

2. Enlevez la variable “N° d’observation” : par défaut, la numérotation des observations avec un proc print apparaît. Ajoutez l’option NOOBS en référence à l’anglais “No observation”.

proc print data=demograph noobs;
run;

3. Visionnez les valeurs brutes : par défaut, les formats restent affichés. Pour les ôter les temps de la procédure, insérez le statement format dans la procédure. Deux options d’offrent à vous :

• Lister chaque variable concernée

proc print data=demograph;
format mavar1 mavar2;
run;

• Avec le mot-clé _all_ enlever le format de toutes les variables.

proc print data=demograph;
format _all_;
run;

4. Agrandissez la largeur de la page : dans le cas où un grand nombre de données sont à afficher mais pas à imprimer, vous pouvez agrandir la largeur de la page, appelée line size en anglais. Sinon, celles-ci apparaîtront sur plusieurs lignes rendant la lecture périlleuse.

options ls=250;

5. Affichez quelques observations : voir plusieurs centaines d’enregistrements n’apportera pas forcément plus d’information pour le développement de votre programme. L’impression des premières observations sera déjà une mine d’information. A la suite du nom du jeu de données, ajoutez entre parenthèses le numéro de la dernière observation via l’option OBS. Vous pouvez aussi changer la première observation par défaut avec FIRSTOBS.

proc print data=demograph (firstobs=100 obs=129);
run;

6. Pensez au copier/coller de Word : si vous envisagez de copier votre output sous Word, enlevez l’option pour centrer. SAS rajoute, en effet, des espaces pour centrer son texte qui s’avère contraignant dans un éditeur de texte.

options nocenter;

Dans le cas de la lecture des dictionnaires SAS, vous pouvez faire usage de la procédure SQL.