Passer de CLASS CLAS à « CLASS » « CLAS » dans une macro variable

Mettre toutes les mots contenus dans une macro variable entre guillemets (quote en anglais) est un tâche plus fréquente qu’elle n’y paraît.
Une vois le code écrit, il est souvent plus rapide de faire du copier/coller et ensuite de modifier. Voici un exemple où DSN=CLASS CLAS sert à créer DSN_QUOTE= »CLASS » « CLAS ».

1. Exemple dans une macro

Dans l’exemple, la macro est PRINTDSN. Elle a pour tâche d’imprimer dans la log tous les datasets présents dans la bibliothèque SASHELP qui sont cités dans le paramètre de macro DSN, s’ils existent.

%macro printdsn (dsn=);

%let dsn      =%upcase(&dsn.);
%let dsn_quote=%sysfunc(tranwrd(%nrstr(%")&dsn.%nrstr(%"),%str( ),%str(" ")));

proc sql;
 create table ref as
 select memname
 from dictionary.tables
 where upcase(libname)='SASHELP' and
       upcase(memname) in (&dsn_quote.);
quit;

data _null_;
 set ref;
 call execute ('proc print data=sashelp.' || memname || ';');
 call execute ('run;');
run;
%mend printdsn;
%printdsn(dsn=class clas);

Pour ma part j’ai pris l’habitude de mettre le contenu des macros paramètres en majuscule, et ce dès le début du programme, sauf besoin spécifique contraire. Ceci explique la ligne %let dsn=upcase(&dsn.);

De plus j’ai pris l’habitude de rajouter le suffixe _quote au nom de la macro variable. Dans notre exemple il y a la macro variable DSN mise en majuscule. Cette variable est ensuite mise entre guillemets.

La macro fonction %sysfunc() permet d’utiliser la fonction tranwrd dans une expression macro. La fonction tranwrd est composée de trois paramètres :

1. le texte d’origine entre guillemets
2. le partie de texte à remplacer dans cette chaîne de caractères
3. le texte de remplacement

2. Le même exemple sans macro

L’exemple est présenté dans une macro. Pour tester le code, un simple %let et %put feront l’affaire. Le résultat s’affiche alors dans la log.

%let dsn=CLASS CLAS;
%let dsn_quote=%sysfunc(tranwrd(%nrstr(%")&dsn.%nrstr(%"),%str( ),%str(" ");
%put &dsn_quote.;

Une petite histoire de macro : compter le nombre de mots dans un paramètre de macro

Il est courant de devoir compter le nombre de mots dans un paramètre de macro. Il est par exemple possible de vouloir créer une boucle pour travailler chacun des termes contenu dans cette macro de manière séparée.

Voici donc l’histoire d’une mini macro qu’on nommera CNT_WRD qui crée une macro variable TOT_WRD renvoyant le nombre de mots contenu dans le paramètre TXT.

Ceci est pour vous l’occasion de voir ou revoir un raisonnement possible dans la construction d’une macro sous SAS.

1. Préciser ses besoins, une rapide « spécification »

La macro CNT_WRD composée d’un seul paramètre retournera dans une macro variable TOT_WRD le nombre de mots contenus dans le texte donné dans le paramètre de macro.

Ici on considérera comme mot, tout terme séparé par au moins un blanc.

Si le paramètre de macro est vide, la macro ne devra pas afficher de message d’erreur et la macro variable TOT_WRD sera égale à 1. Par défaut, aucune valeur ne sera entrée dans le paramètre TXT.

La macro variable doit pouvoir être utilisable à l’extérieur de la macro (macro variable globale).

2. Tester la fonction COUNT dans une étape data

La fonction COUNT permet de comptabiliser certains caractères et donc de répondre à ce type de besoin. En fait, cette fonction ne compte pas le nombre de mots mais compte le nombre de caractères définis par le second élément dans la fonction; dans notre cas, elle comptera le nombre de blancs. Il faut donc ajouter 1 au total.

Voici un exemple dans une étape data.

data _null_;
tot_wrd=1+count(‘mot1 mot2’,‘ ‘);
put tot_wrd=;
run;

Dans la log, vous pouvez voir que cnt_wrd=2.

Mais cela ne suffit pas pour gérer les blancs multiples et les blancs aux extrémités. Car si vous avez plus d’un blanc entre chaque mot, chacun sera compté. Il faut donc les enlever au préalable (avec la fonction COMPBL ici). Les blancs de début et fin peuvent s’enlever au moyen de la fonction STRIP.

data _null_;
tot_wrd=1+count(strip(compbl(‘ mot1 mot2 ‘)),‘ ‘);
put tot_wrd=;
run;

Mais que ce passe t-il si notre texte à compter est vide ? TOT_WRD sera égal à 1. Il faut donc ajouter le 1 au total que si le texte à analyser n’est pas vide.

data _null_;
length txt $200;
txt=;
if txt ne ‘ ‘ then tot_wrd=1+count(strip(compbl(txt)),‘ ‘);
put tot_wrd=;
run;

3. Créer la macro

Comme indiqué dans le dernier point, on travaille ici de manière conditionnelle. Si le paramètre de macro TXT est vide, la macro variable CNT_WRD nouvellement créée prend la valeur zéro. Sinon, On passe par la fonction COUNT.

Comme il n’existe pas d’équivalent aux fonctions COUNT et COMPBL en langage macro, il faut encadrer chacune d’elle dans une fonction macro SYSFUNC.

Ici on notera que la fonction STRIP n’apparaît pas. Les blancs de début et de fin en langage macro n’ont aucun impact.

%macro cnt_wrd(txt=);

%global tot_word;

%if &txt.= %then %let tot_wrd=0;
%else %let tot_wrd=%eval(1+%sysfunc(count(%sysfunc(compbl(&txt.)),%str( ))));

%mend cnt_wrd;

Pour représenter un blanc dans une étape data, il suffit d’utiliser des guillemets. En langage macro, on fait appel à la fonction %STR(). Il faudra ne pas oublier d’ajouter un blanc entre les parenthèses.

Afin d’ajouter 1 au résultat de la fonction COUNT, il faut utiliser la macro fonction %EVAL. Le contenu des macro variables sont sinon tous interprétés comme du texte, qu’il s’agisse de nombres ou pas.

Enfin, pour que cette macro variable TOT_WRD soit utilisable en dehors de la macro, il faut qu’elle soit globale. Hors par défaut, une macro variable créée dans une macro est locale, c’est-à-dire n’existe que le temps de la macro. L’instruction %GLOBAL TOT_WRD; résouds le problème.

4. Tester la macro dans le cadre de sa validation

Que se passe t-il quand on ne change pas la valeur par défaut du paramètre de macro ?

%cnt_wrd;
%put Valeur de TOT_WRD: &tot_wrd;

Que se passe t-il quand le paramètre de macro TXT est vide de texte ?
%put Valeur de TOT_WRD: &tot_wrd;

%cnt_wrd(txt=);
%put Valeur de TOT_WRD: &tot_wrd;

Que se passe t-il lorsqu’il n’y a qu’un mot?

%cnt_wrd(txt=mot1);
%put Valeur de TOT_WRD: &tot_wrd;

Que se passe t-il quand il y a plusieurs mots ?

%cnt_wrd(txt=mot1 mot2 mot3);
%put Valeur de TOT_WRD: &tot_wrd;

Que se passe t-il quand il y a des blancs multiples entre les mots, en début et à la fin ?

%cnt_wrd(txt= mot1 mot2 mot3 );
%put Valeur de TOT_WRD: &tot_wrd;

Que se passe t-il quand il y a des blancs multiples entre les mots, en début et à la fin ?

%cnt_wrd(txt=mot1 mot2);
%put Valeur de TOT_WRD: &tot_wrd;

Que se passe t-il quand la macro est appelée plusieurs fois ?

%cnt_wrd(txt=mot1 mot2);
%put Valeur de TOT_WRD: &tot_wrd;
%cnt_wrd(txt=mot1);
%put Valeur de TOT_WRD: &tot_wrd;

Lecture complémentaire

• Fini le Moyen-Age pour compter les mots
• 4 fonctions pour enlever les blancs !
• 3 méthodes pour construire des macros variables sans macro
• Additionner deux macros variables, la fonction %EVAL

Une fonction LIBREF au résultat inattendu

La fonction LIBREF vérifie l’existence d’une bibliothèque. Vu que la réponse attentue est oui ou non, on pourrait s’attendre à une résultat binaire avec zéro pour non et un pour oui. Dans les faits, cette fonction retourne zéro pour oui et toute autre valeur signifie non.

Voici un exemple.

1.  Contexte, exemple

Vous cherchez à savoir si le chemin d’accès défini dans un  paramètre de macro peut servir de bibliothèque. Une solution est de tenter de créer la bibliothèque et ensuite de vérifier si la bibliothèque a été créée ou non.

2. Le programme

Dans l’exemple qui suit, une macro TEST est créée. Elle a un paramètre DSNPATH=. Le chemin d’accès donné dans ce paramètre est utilisé pour créé la bibliothèque INLIB.

Ensuite pour les besoins de l’exemple, un message est ajouté dans la log au moyen des instructions %PUT.

• Tout d’abord, est indiqué dans la log la valeur prise par le paramètre de macro DSNPATH.
• Puis, la valeur prise par la fonction LIBREF est affiché dans la log.

Afin de pouvoir utiliser cette fonction hors d’une étape data ou d’une procédure PROC SQL, il faut l’englober dans une macro fonction %SYSFUNC().

En fin de macro la référence à la bibliothèque est supprimée.

%macro test(dsnpath=);
libname inlib « &dsnpath. »;
%put MESSAGE: DSNPATH= &dsnpath.;
%put MESSAGE: Voir le résultat de la fonction LIBREF dans la log: %sysfunc(libref(inlib));
libname inlib;
%mend test;

Le premier appel de macro se fait avec un chemin d’accès valid. Tandis que le second appel de macro utilise un chemin d’accès erroné.

%test (dsnpath=C:/sasref);
%test (dsnpath=C:/sasre);

3. La log

Lorsque le chemin d’accès est correct, la fonction LIBREF retourne la valeur 0.

Quand le chemin d’accès n’est pas correct, la fonction LIBREF retourne une valeur différente de zéro. Dans l’exemple, il s’agit de la valeur -70008.

Lectures complémentaires

Autres articles sur %SYSFUNC

• Récupérer la valeur d’une option système, %SYSFUNC(GETOPTION())
• Evaluer le critère performance TEMPS d’un programme (%SYSFUNC, %SYSEVALF)
• Ajouter une date dans un nom de fichier Excel, Word…
• Combien d’observations dans mon data set ?

SAS Online Doc

• Summary Descriptions and Syntax
• LIBREF Function

Protégé : Newsletter Mars : solution

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

Mot de passe :

Valeur formatée utilisée pour définir la macro variable. Attention !

Vous imaginez qu’un format ne sert qu’à l’affichage des données et que lorsque vous faîtes une opérations sur les données vous travaillez sur les données brutes. Et pourtant, avec les macro variables vous pouvez avoir des surprises. Démonstration.

1. L’exemple qui marche comme prévu

Dans un premier temps, le data set (ONE) est créé. Il a une variable numérique x. Dans ce data set, il n’y a qu’une observation x=123456789012 soit une seule valeur composée de 12 chiffres. Un format 12. est appliqué à la variable.

data one;
x=123456789012;
format x 12.;
run;

Dans un second temps une macro variable est créée.

proc sql;
select x into : x
from one;
quit;

Dans un troisième temps,ne sont sélectionnées que les observations où x=123456789012.

data two;
set one (where=(x=&x.));
run;

Le data set TWO a alors toujours une observation.

2. Le détail qui fait la différence

Maintenant enlevé le format permanent 12. ou mettez à la place un format x8.

data one;
x=123456789012;
*format x 12.;
format x 8.;
run;

C’est la valeur formatée de x qui est sauvegardée dans la macro variable et non la valeur interne. Comme un format de 8. ne suffit pas pour afficher l’intégralité du nombre, la valeur est transformée et ne peut plus être précisément égale à la valeur initiale. Donc attention !

proc sql;
select x into : x
from one;
quit;

Cette fois-ci, la seule observation de data set est perdue.

data two;
set one (where=(x=&x.));
run;

Appeler une macro d’un catalogue permanent

Dans l’article « Sauvegarder une macro au delà d’une session« , vous avez vu comment créer un catalogue permanent pour macro. Ici, je vous propose d’appeler une macro contenue dans un de ces catalogues.

1. Rappel : ajouter une entrée dans un catalogue pour macro

libname sasref ‘C:/sasref’;
options sasmstore=sasref mstored;

%macro perm_macro /store;
proc print data=sashelp.class;
run;
%mend perm_macro;

2. Appeler une macro compilée

Les options globales qui indique la position d’un catalogue pour macros sont MSTORED et SASMSTORE= où SASMSTORE est suivi du nom de la bibliothèque.

libname sasref ‘C:/sasref’;
options mstored sasmstore=sasref;
%perm_macro;

Lectures complémentaires

• Sauvegarder une macro au delà d’une session

Lire le contenu d’un catalogue pour macros

Dans l’article « Sauvegarder une macro au delà d’une session« , vous avez vu comment créer un macro catalogue permanent. Ici, je vous propose de voir comment savoir quelles macros sont contenues dans ce fichier.

1. Rappel : ajouter une entrée dans un catalogue pour macros

Dans l’étape qui suit, la macro PERM_MACRO a été sauvée dans un catalogue pour macro. Le nom par défaut d’un catalogue pour macro est SASMACR. Celui-ci a été sauvegardé dans la bibliothèque SASREF.

libname sasref ‘C:/sasref’;

options sasmstore=sasref mstored;

%macro perm_macro /store;
proc print data=sashelp.class;
run;
%mend perm_macro;

2. Voir le contenu d’un catalogue pour macro

A présent, la procédure catalogue et plus particulièrement l’instruction CONTENTS permet de lire le contenu de SASMACR.

La procédure CATALOG  peut être composée de plusieurs étapes. Pour voir le résultat en séquence de ces étapes une instruction RUN est ajoutée entre chacune d’elle. Un QUIT en fin de procédure permet de clore la procédure.

Ici comme une seule étape est requise, seul un RUN apparaît. Il est donc possible, dans ce cas précis de se contenter d’un QUIT.

• Avec RUN et QUIT, REAL et CPU times sont de 0.01 secondes.
• Avec seulement QUIT, REAL TIME=0.04 secondes et CPU TIME=0.00 secondes.

libname sasref ‘C:/sasref’;

proc catalog catalog=sasref.sasmacr;
contents;
run;
quit;

Ce contenu est affiché dans la fenêtre OUTPUT de SAS. Voir le résultat :

Lectures complémentaires

• Sauvegarder une macro au delà d’une session
• Quelle est la différence entre un RUN et un QUIT ?

Protégé : Newsletter Juin : Exercice

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

Mot de passe :

Plusieurs mots d’un paramètre de macro à mettre entre guillemets (%QSYSFUNC, %STR(), TRANWRD)

Mettre entre guillemets les mots contenus dans une macro variable SAS et les séparer par des virgules est possible au moyen des fonction %STR(), %QSYSFUNC et TRANWRD. Dans quel cas est-ce utile ? Comment se décompose cette syntaxe ?

1. Dans quel cas a-t-on besoin d’ajouter des guillemets et virgules ?

Lors de l’écriture d’une macro, vous pouvez avoir besoin d’autoriser plus d’un mot dans un des paramètres.

options mprint;

%macro test (multival=);

…

%mend test;

%test (multival=Alfred William);

Note : l’option MPRINT de l’instruction OPTIONS permettra de voir la résolution de la macro dans la log.

Ensuite, le contenu de ce paramètre traité comme une macro variable peut être appelé dans une condition. Dans l’exemple qui suit « Alfred », »William » sera remplacée par la macro variable mise à jour.

proc print data=sashelp.class (where=(name = (« Alfred », »William »));

run;

Il faut pour cela mettre la macro variable à jour en ajoutant des guillemets et la virgule comme séparateur.

2. Comment ajouter guillemets et virgules ?

2.1 Un mot

Dans le cas d’un paramètre avec un mot, on peut ajouter %str(% ») devant et derrière. Le symbole % permet d’introduire les caractères spéciaux comme le guillemet.

%let multival=%str(% »)&multival.%str(% »);

La macro donne alors :

%macro test (multival=);

%let multival=%str(% »)&multival.%str(% »);

proc print data=sashelp.class (where=(name = &multival.));

run;

%mend test;

%test (multival=Alfred);

2.2 Plus d’un mot

Pour mettre entre guillemets plus d’un mot, l’espace entre les mots sera remplacé par « , » (guillemet, virgule, guillemet) au moyen de la fonction TRANWRD.

%qsysfunc(tranwrd(&multival.,%str( ),%str(% »,% »)))

Pour exécuter cette fonction, qui n’a pas d’équivalent dans les macros fonctions, il faut englober le tout dans %SYSFUNC/%QSYSFUNC. La présence de la virgule oblige dans notre cas à utiliser %QSYSFUNC.

%macro test (multival=);

%let multival=%str(% »)%qsysfunc(tranwrd(&multival.,%str( ),%str(% »,% »)))%str(% »);

proc print data=sashelp.class (where=(name in (&multival.));

run;

%mend test;

%test (multival=Alfred William);

2.3 Plus d’un mot mis en majuscule

Enfin, pour ne pas tenir compte de la case, le texte peut être mis en majuscule au moyen de la fonction %UPCASE.

where=(upcase(name) in (%upcase(&multival.))

Cela donne :

%macro test (multival=);

%let multival=%str(% »)%qsysfunc(tranwrd(&multival.,%str( ),%str(% »,% »)))%str(% »);

proc print data=sashelp.class (where=(upcase(name) in (%upcase(&multival.))));

run;

%mend test;

%test (multival=Alfred William);

Lectures complémentaires

• Autres usages de la fonction %SYSFUNC
• Autres usages de la fonction TRANWRD

Evaluer le critère performance TEMPS d’un programme (%SYSFUNC, %SYSEVALF)

Un critère pour évaluer la performance d’un programme est de connaître son temps d’exécution. La fonction système %SYSFUNC permettra de récupérer le temps à un instant donné et la fonction  %SYSEVALF servira à calculer la différence entre deux temps pré-enregistrés. Voici un exemple en 4 étapes.

1. Récupérer le temps en début de programme

Dans un premier temps, le temps de début est sauvegardé dans une macro variable TEMPS_DEBUT. Il est extrait au moyen de la fonction TIME() et est donc exprimé en secondes.

%let temps_debut = %sysfunc(time());

2. Exécuter la partie principale du programme

Pour l’exemple un simple PROC PRINT est ajouté comme partie principale du programme.

proc print data=sashelp.class;
run;

3. Récupérer le temps en fin de programme

Dans un troisième temps, le temps en fin de programme est sauvagardé dans la macro variable TEMPS_FIN. Comme précédemment; la fonction TIME() est utilisée.

%let temps_fin = %sysfunc(time());

4. Evalutation et affichage de la durée écoulée

La durée écoulé entre le début et la fin du programme est sauvegardée dans la macro variable DUREE. Cette durée est ensuite affichée dans la log au moyen de l’instruction %PUT.

Sur le même principe qu’une fonction %EVAL dans une macro, la fonction %SYSEVALF permet de considérer les deux variables TEMPS_DEBUT/TEMPS_FIN comme des nombres le temps du calcul de la différence.

%let duree = %sysevalf(&temps_fin.-&temps_debut.);
%put Durée d’exécution : &duree.;

Lectures complémentaires

www.sasreference.fr

• Ajouter une date dans le nom de fichier Word, Excel,…
• Combien d’observations dans mon data set
• Additionner deux macros variables : la fonction %EVAL
• Créer une date SAS de 3 manières

SAS Online Doc

• Using SAS Language Functions in the Data Step and Macro Facility
• %SYSFUNC and %QSYSFUNC Functions
• Summary Descriptions and Syntax
• %EVAL Function
• %SYSEVALF Function
• How the macro processor evaluates Arithmetic Expressions
• TIME Function

Les anniversaires, cela se fête avec SAS

Aujourd’hui étant mon anniversaire, je fais la paresseuse et vous communique un petit fichier SAS, reçu ce jour (merci Alex), à faire tourner sous Windows, écouteurs en place, pour la prochaine fois qu’un collègue ou pote qui connaît SAS soufflera ses bougies. Amusez-vous bien !

%let pc=1;

%macro sasreference_fr(note,octave,length);

select(&note.);
when (‘A’) call sound (55*(2**&octave.),&length.*160*&pc.);
when (‘A#’) call sound (58*(2**&octave.),&length.*160*&pc.);
when (‘Bb’) call sound (58*(2**&octave.),&length.*160*&pc.);
when (‘B’) call sound (62*(2**&octave.),&length.*160*&pc.);
when (‘C’) call sound (65*(2**&octave.),&length.*160*&pc.);
when (‘C#’) call sound (69*(2**&octave.),&length.*160*&pc.);
when (‘Db’) call sound (69*(2**&octave.),&length.*160*&pc.);
when (‘D’) call sound (73.5*(2**&octave.),&length.*160*&pc.);
when (‘D#’) call sound (73.5*(2**&octave.),&length.*160*&pc.);
when (‘Eb’) call sound (78*(2**&octave.),&length.*160*&pc.);
when (‘E’) call sound (82*(2**&octave.),&length.*160*&pc.);
when (‘F’) call sound (87*(2**&octave.),&length.*160*&pc.);
when (‘F#’) call sound (92.5*(2**&octave.),&length.*160*&pc.);
when (‘Gb’) call sound (92.5*(2**&octave.),&length.*160*&pc.);
when (‘G’) call sound (98*(2**&octave.),&length.*160*&pc.);
when (‘G#’) call sound (104*(2**&octave.),&length.*160*&pc.);
when (‘Ab’) call sound (104*(2**&octave.),&length.*160*&pc.);
when (‘R’) call sleep((&length./3)*&pc.,1);
otherwise;
end;
%mend sasreference_fr;

data _null_;
%sasreference_fr(‘C’,3,1);
%sasreference_fr(‘C’,3,1);
%sasreference_fr(‘D’,3,2);
%sasreference_fr(‘C’,3,2);
%sasreference_fr(‘F’,3,2);
%sasreference_fr(‘E’,3,4);

%sasreference_fr(‘R’,3,2);

%sasreference_fr(‘C’,3,1);
%sasreference_fr(‘C’,3,1);
%sasreference_fr(‘D’,3,2);
%sasreference_fr(‘C’,3,2);
%sasreference_fr(‘G’,3,2);
%sasreference_fr(‘F’,3,4);

%sasreference_fr(‘R’,3,2);

%sasreference_fr(‘C’,3,1);
%sasreference_fr(‘C’,3,1);
%sasreference_fr(‘C’,4,2);
%sasreference_fr(‘A’,4,2);
%sasreference_fr(‘F’,3,1);
%sasreference_fr(‘F’,3,1);
%sasreference_fr(‘E’,3,2);
%sasreference_fr(‘D’,3,4);

%sasreference_fr(‘R’,3,2);

%sasreference_fr(‘Bb’,4,1);
%sasreference_fr(‘Bb’,4,1);
%sasreference_fr(‘A’,4,2);
%sasreference_fr(‘F’,3,2);
%sasreference_fr(‘G’,3,2);
%sasreference_fr(‘F’,3,4);
run;

Pour les curieux, je vous invite à consulter les programmes des chansons suivantes suggérées sur le forum de developpez.com :

Les plus téméraires s’intéresserons à la publication « Making Music in SAS« . Vos créations pourront être publiées sur le blog.

A lire aussi www.sasreference.fr :

• Penser conditionnel (3/3) : Case When

Mettre à jour une table SAS à partir des métadonnées

Les métadonnées (metadata) peuvent se présenter sous la forme de tables SAS (data sets). Elles donnent une description d’une table SAS.

Si un data set existe déjà, vous pouvez retrouver des métadonnées dans le dictionnaire COLUMNS ou avec un PROC CONTENTS : nom de variable, position, type, longueur, format, etc.

Mais ce qui est intéressant est de préparer ce descriptif à l’avance pour créer ou actualiser un jeu de données.

Ici, nous verrons comment définir des métadonnées et les appliquer sur un data set existant.

1. Créer un data set de base pour l’exemple

Le data set AE contient la variable SASREF qui prend la valeur 1.

data ae;
   sasref=1;
run;

proc contents data=ae varnum;
run;

2. Créer les métadonnées pour l’exemple

Le data set contenant les métadonnées est composé de six variables :

• La position des variables (MYVARNUM)
• Le nom des variables (MYNAME)
• Leur libellé (MYLABEL)
• Leur type (numérique ou alphanumérique) (MYTYPE)
• La longueur des variables (MYLENGTH)
• Leur format (MYFORMAT)

data meta_ae;
   length myvarnum 8 myname $8 mylabel $14 mytype $1 mylength 8 myformat $11;
   input myvarnum myname mylabel 12–25 mytype mylength myformat;
   datalines;
1 SUJECTID Subject Number C 10 10.
2 RECID    Record ID      N 8 10.
3 AETERM   Term           C 60 60.
4 AE_SD    Starting Day   N 8 2.
5 AE_SM    Starting Month N 8 2.
6 AE_SY    Starting Year  N 8 4.
7 AE_SDAT  Starting Date  N 8 DATE9.
8 AESEV    Severity       N 8 AESEV.
;
run;

3. Créer le format AESEV pour l’exemple

Dans les métadonnées, le format AESEV s’applique à la variable sur la gravité (severity) de l’effet secondaire (adverse event).

proc format;
   value aesev 1=‘Severe’
               2=‘Mild’;
run;

4. Objectif

Le but est de construire une étape data où les instructions ATTRIB sont listées avant de lire les données de AE. Ces ATTRIB servent à définir les variables du data set AE dans l’ordre indiqué par MYVARNUM dans les métadonnées avec leur libellé, type, longueur et format.

De plus, seules les variables listées dans les métadonnées seront gardées. La variable SASREF devra disparaître.

5. Lister les variables à garder dans une macro variable

Afin de ne garder que les variables présentent dans les métadonnées, une liste en est faite. Elle est sauvegardée dans la macro variable MYNAME_LST. Cette liste sera ensuite appelée dans une option KEEP=.

proc sql noprint;
   select distinct myname into : myname_lst separated by ‘ ‘
   from meta_ae;
quit;

6. Générer le programme

Le programme est généré au moyen d’un DATA _NULL_.

Un tri préalable des métadonnées : L’ordre dans lequel les instructions ATTRIB seront listées affectera l’ordre d’apparition des variables. L’instruction PROC SORT s’assure que ces instructions apparaîtront dans l’ordre donnée dans les métadonnées par la variable MYVARNUM.

proc sort data=meta_ae;
   by myvarnum;
run;

Un catalogue pour écrire le programme : J’ai choisi ici de sauvegarder le programme généré dans un catalogue pointé dans l’étape data sous le nom SASREF. Ce nom est précédemment défini au moyen de l’instruction FILENAME.

Après exécution du programme (%INCLUDE),

• le FILENAME désignant ce catalogue est désactivé (instruction FILENAME) et
• le catalogue lui-même est supprimé (PROC DATASETS).

Vous pouvez choisir d’utiliser un simple nom de fichier à supprimer ensuite manuellement ou avec une commande Unix/Windows (cf instruction FILENAME en vert).

filename sasref catalog ‘work.sasref.meta.source’;
*filename sasref ‘C:/sasref/attrib_meta.sas’;

L’activation de l’instruction *FILE PRINT; à la place de FILE SASREF vous permettra de voir votre code dans la fenêtre OUTPUT lors du développement du code.

Des outils optionnels : Les arobases @ et +(-1) sont simplement là pour l’apparence du programme mais n’affecte en aucun cas l’exécution du code. Ils sont donc optionnels.

• Les arobases font débuter le texte à la position donnée par le nombre qui suit.
• Les +(-1) permettent de revenir d’une position en arrière avant de continuer à taper le texte. Ainsi le blanc créé automatiquement avec PUT  n’existe plus.

Distinguer les variables numériques des variables alphanumériques : Un symbole dollar $ est obligatoire pour définir la longueur et le format des variables. Il est donc de faire varier le texte en fonction du type (variable MYTYPE=N ou C).

data _null_;
   set meta_ae end=eof;
   *file print;
   file sasref;
   if _N_=1 then put ‘data ae (keep= &myname_lst.);’;
   put @4 ‘attrib ‘ myname @23 « label = ‘ » mylabel +(-1) « ‘ » ;
   if mytype=‘N’ then
      do;
         put @23 ‘length = ‘ mylength;
         put @23 ‘format = ‘ myformat +(-1)’;’;
      end;
   else if mytype=‘C’ then
      do;
         put @23 ‘length = $’ mylength;
         put @23 ‘format = $’ myformat +(-1) ‘;’;
      end;
   if eof then
      do;
         put @3 ‘set ae;’;
         put ‘run;’;
      end;
run;

%include sasref;
filename sasref;

proc datasets memtype=catalog ;
   delete sasref;
run;

7. Le résultat

Au final, le data set AE contient les variables listées dans les métadonnées et seulement ces variable

proc contents data=ae varnum;
run;

Lectures complémentaires :

• Les deux dictionnaires SAS les plus utilisés : TABLES et COLUMNS
• Créer un fichier .sas automatiquement
• Changer la séquence d’affichage des variables
• Ecrire un texte avec l’instruction PUT

Sauvegarder une résolution de macro dans un fichier externe (l’option MFILE)

Le programme SAS généré par un appel de macro peut être sauvegardé dans un fichier externe grâce à l’option globale MFILE. Quel est l’intérêt ? Comment concrètement cela se programme t-il ?A quoi ressemble le résultat ? C’est ce que je vous propose de découvrir dans cet article.

1. Quel est l’intérêt de sauvegarder le code généré par une macro?

• La résolution d’une macro dans la log avec l’option globale MPRINT est agrémenté d’information cachant le cœur du programme. Un accès au programme seul facilite la lisibilité.
• Extraire le code permet de l’exécuter morceau par morceau afin de s’assurer que la demande faite à SAS correspond à ses attentes et éventuellement trouver la cause d’un problème (to debug).

Le même type d’approche est possible avec un programme généré dans un DATA _NULL_.

2. Un exemple pour créer une étape data avec six instructions similaires

Dans cet exemple, le langage macro est utilisé pour générer six instructions dans une étape data au moyen d’une boucle.

A chaque nouvelle instruction une nouvelle variable est créée.

• Elle contient un nombre aléatoire extrait au moyen de la fonction RANUNI et sa racine variant de 1 à 6.
• Cette valeur est multipliée par 49 dans un premier temps.
• La valeur entière inférieure est gardée dans un second temps au moyen de la fonction FLOOR.

options mprint mfile;
filename mprint 'C:/sasref/eg_mfile.sas';
%macro eg_mfile;
   data test;
      %do i=1 %to 6;
      var&i. = floor(ranuni(&i.)*49);
      %end;
   run;
%mend eg_mfile;
%eg_mfile;

2 points à respecter : On prendra bien soin de garder l’option MPRINT dans l’instruction OPTIONS et d’utiliser MPRINT comme nom de FILENAME.

3. Visualiser le contenu du fichier EG_MFILE.SAS

Le fichier EG_MFILE.SAS contient le contenu suivant :

data test;
var1 = floor(ranuni(1)*49);
var2 = floor(ranuni(2)*49);
var3 = floor(ranuni(3)*49);
var4 = floor(ranuni(4)*49);
var5 = floor(ranuni(5)*49);
var6 = floor(ranuni(6)*49);
run;

 Alors que la log, elle, contient des informations supplémentaires exploitables beaucoup moins rapidement.

MPRINT(EG_MFILE):   data test;
MPRINT(EG_MFILE):   var1 = floor(ranuni(1)*49);
MPRINT(EG_MFILE):   var2 = floor(ranuni(2)*49);
MPRINT(EG_MFILE):   var3 = floor(ranuni(3)*49);
MPRINT(EG_MFILE):   var4 = floor(ranuni(4)*49);
MPRINT(EG_MFILE):   var5 = floor(ranuni(5)*49);
MPRINT(EG_MFILE):   var6 = floor(ranuni(6)*49);
MPRINT(EG_MFILE):   run;

Source : redscope.info/node/584 (ce site n’existe plus)

Additionner deux macros variables, la fonction %EVAL

En langage macro sous SAS, la distinction entre les macro variables numériques et les macros variables caractères n’est pas faite. En fait, toutes les macros variables sont de type caractère. Du coup, comment faire l’addition de deux macros variables contenant des nombres ?

1. La fonction %EVAL

La fonction %EVAL indique à SAS de gérer les indications qu’elles contient comme une opération mathématique. Il est alors possible de faire la soustraction, l’addition, la multiplication et la division de n’importe quelle macro variable contenant des nombres.

2. Deux data sets pour l’exemples : PATH_AE et PATH_PID

Pour illustrer cette macro fonction très simple du langage de programmation SAS, je vous propose ce petit exemple. A la base, il y a deux data sets :

• PATH_AE (AE: Adverse Events ou effets secondaires) et
• PATH_PID (PID: Patient Identifier ou identifiant du patient).

Chacun des deux data sets a une variable les chemins d’accès à des répertoires contenant respectivement les fichiers AE et PID. C’est le genre de data set qu’on peut obtenir à partir d’une commande Unix et une étape data.

Combien d’observations dans chaque data set ? : Le data set PATH_AE contient deux observations et le data set PATH_PID en a trois. Vous pouver activer les conditions WHERE pour que chacun des data sets soient vides et ainsi voir le changement qu’il implique dans la suite du programme.

data path_ae ;*(where=(substr(path_ae,1,1) ne 'c'));
   length path_ae $200;
   input path_ae;
   datalines;
c:/project_d15/study145
c:/project_d66/study234
;
run;

data path_pid ;*(where=(substr(path_ae,1,1) ne 'c'));
   length path_pid $200;
   input path_pid;
   datalines;
c:/project_a99/study133
c:/project_a99/study532
c:/project_b01/study012
;
run;

3. Créer des macros variables

Le code qui suit extrait le nombre d’observations de chacun de nos data sets dans des macro variables. C’est une approche alternative à l’utilisation des dictionnaires qui a le mérite de pouvoir indifféremment extraire des données au niveau du data set qu’au niveau des variables.

La macro variable CNT_AE

1. Ouvrir le data set PATH_AE de la bibliothèque WORK.
2. Y extraire le nombre total d’observations et le sauvegarder dans la macro variable CNT_AE.
3. Fermer le data set PATH_AE.

%let dsid_ae = %sysfunc(open(work.path_ae,in));
%let cnt_ae = %sysfunc(attrn(&dsid_ae.,nobs));
%let rc_ae   = %sysfunc(close(&dsid_ae.));

La macro variable CNT_PID : de manière similaire, le nombre d’observations contenues dans le data set PATH_PID est sauvegardé dans la macro variable CNT_PID.

%let dsid_pid = %sysfunc(open(work.path_ae,in));
%let cnt_pid = %sysfunc(attrn(&dsid_ae.,nobs));
%let rc_pid   = %sysfunc(close(&dsid_ae.));

D’autres %SYSFUNC pourraient au besoin être ajoutées entre l’ouverture et la fermeture du data set.

4. Une petite vérification

A présent, voyons dans la log la valeur prise par la somme des deux macros variables.

%let check= %eval(&cnt_ae.+&cnt_pid.);
%put SASREF Macro Variable Check: &check.;

Si les options WHERE restent en commentaires, CHECK=5 puisque qu’on fait la somme de 2 (observations dans le data set PATH_AE) et 3 (observations dans le data set PATH_PID.

Par contre, si les options WHERE sont inclues, les deux data sets sont vide et CHECK=0.

5. Utiliser la macro fonction %EVAL() dans une macro

Dans le programme suivant, si aucun des deux data sets ne contiennent de données, un message est ajouté dans la log et SAS va directement au point d’encrage donné par PGM_END et donc ici en fin du programme. Tout programme intermédiaire est alors ignoré par SAS.

%macro test;
  *Here additional Program code can be included;
   %if %eval(&cnt_ae.+&cnt_pid.)=0 %then
      %do;
         %put NOTE_TEST_EVAL=--------------------------------;
         %put NOTE_TEST_EVAL= 1. Check data;
         %put NOTE_TEST_EVAL= 1.1 Check AE and PID data sets;
         %put NOTE_TEST_EVAL=--------------------------------;
         %put NOTE_TEST_EVAL= No AE or PID data set has been selected;
         %goto pgm_end;
      %end;
   *Here additional Program code can be included;
%pgm_end;
%mend test;
%test;

Pour un autre exemple de GOTO, vous pouvez vous reporte à la troisième partie de l’article intitulé « Mon paramètre de macro est-il rempli ? « .

Répéter une procédure plusieurs fois avec du langage macro

Alors qu’il existe les arrays pour répéter une action sur plusieurs variables, la méthode pose ses limites lorsqu’il s’agit de répéter des procédures en changeant seulement quelques noms de variables. Dans ce cas, il est possible d’utiliser le langage macro ou d’automatiser l’écriture du programme dans un DATA _NULL_.

Quand vous avez beaucoup de code à exécuter le langage macro sera beaucoup plus lisible que le DATA _NULL_ allourdi par les instructions PUT. De plus vous pourrez continuer à utiliser le DATA _NULL_ à d’autres fins dans la macro. Voici une illustration de cette méthode très puissante qu’est le langage macro.

1. Créer des macros variables

Créer une macro variable par valeur à faire varier dans la macro : Le but du jeu est de créer une macro variable pour chacune des variables contenues dans le data set SASHELP.CLASS. Ces macros variables auront un nom bien particulier VAR + un numéro allant de 1 à 5 (nombre total de variables dans le data set: NAME, AGE, SEX, HEIGHT, WEIGHT). En d’autres termes, on aura :

• &VAR1.=NAME
• &VAR2.=AGE
• &VAR3=SEX
• &VAR4=HEIGHT
• &VAR5=WEIGHT

Connaître le nombre total de variables pour définir une boucle : Le but sera ensuite de remplacer dans une boucle (loop), le nombre. Afin de définir cette boucle, il faut extraire la valeur de fin (5). On la sauvegardera dans une macro variable :

• &TOT.=5

data _null_;
   set sashelp.vcolumn (keep  = libname memname name
                        where = (upcase(libname)='SASHELP' and
                                 upcase(memname)='CLASS'))
                       end=eof;
   call symput(compress('var' || put(_N_,best.)),name);
   if eof then call symputx('tot',_N_);
run;

Voir les valeurs prises par toutes les macro variables : Pour voir ces macro variables et leur valeurs dans la log, utilisez l’instruction %PUT.

%put _all_;

Créer une macro variable : CALL SYMPUT (et CALL SYMPUTX) est une des trois méthodes pour créer une macro variable. Vous pouvez vous reporter à l’article « 3 méthodes pour construire des macro variables sans macro » pour approfondir le sujet.

Accéder aux méta données (metadata) : Ici, j’ai choisi d’utiliser le dictionnaire COLUMN en passant par une vue afin d’y accéder directement à partir d’une étape data. Pour plus d’informations, sur son équivant DICTIONARY.COLUMNS, consultez l’article « Les 2 dictionnaires SAS les plus utilisés : TABLES et COLUMNS« .

2. Créer la macro

A présent, notre macro TEST contient une boucle allant de 1 à 5. A chaque exécution de la procédure PROC PRINT une variable différente sera donnée.

%macro test;
   %do i=1 %to &tot.;
      proc print data=sashelp.class;
      var &&var&i.;
      run;
    %end;
%mend test;
%test;

3. A vous de jouer

De la même manière vous pouvez imprimer les données du data set SASHELP.CLASS pour chacun des valeurs des noms des étudiants (variable NAME). A vous d’essayer.

Sauvegarder une macro au delà d’une session SAS

Par défaut, une macro est créée le temps d’une session. En effet, elle est sauvegardée dans le catalogue réservé aux macros (macro catalog) de la bibliothèque WORK. Comment changer la bibliothèque en vue d’une utilisation ultérieure de la macro ?

1. Par défaut, créer une macro temporaire

Dans un premier temps, une macro appelée TMP_MACRO est créée. Cette macro est sauvegardée dans un fichier appelé un macro catalog de la bibliothèque WORK.

%macro tmp_macro;
proc print data=sashelp.class;
run;
%mend tmp_macro;

2. Sauvegarder de manière permanente la macro

A présent, il s’agit de sauvegarder la macro PERM_MACRO dans la biblioht`que SASREF. Comme précédemment, elle sera sauvegardée dans un catalogue ne pouvant contenir que des macro. Ce catalog s’appelle toujours SASMACR.

Grâce aux options SASMSTORED= et MSTORE, on précise à SAS que les macros à conserver (to store) seront à diriger dans la bibliothèque SASREF.

Ensuite, lors de la définition de la macro PERM_MACRO, on indique à SAS que cette macro fait partie des macros à conserver au delà de la session SAS. Elle sera donc sauvegardée dans la bibliothèque SASREF.

libname sasref 'C:/sasref';
options sasmstore=sasref mstored;

%macro perm_macro /store;
proc print data=sashelp.class;
run;
%mend perm_macro;

L’option STORE maintient la bibliothèque SASREF en activité. Il est alors impossible de désassigner la bibliothèque SASREF. Si vous avez une solution à ce problème, n’hésitez pas à nous la faire partager.

*libname sasref;

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;

Mon paramètre de macro est-il rempli ?

Une macro sous SAS peut dans certains cas être comparée à un questionnaire. A chaque question (parameter) correspond plusieurs réponses possibles (parameter value). Certains réponses peuvent êtes obligatoires, d’autres facultatives. Dans le cas où la réponse est impérative mais n’est pas fournie par l’utilisateur, il faut pouvoir l’avertir : arrêter l’exécution du programme de manière propre et l’informer des éléments à fournir. Trois notions de programmation aideront à construire cette vérification (check).

1. Passer un message

Une condition en langage macro : ici, une macro est définie. Des instructions globales sont exécutées, si le paramètre de la macro est vide. Cette condition est donc définie avec une instruction du langage macro %IF … %THEN … %DO; …; %END;

Un message dans la log : l’objectif est d’informer l’utilisateur sur la nécessité d’une valeur pour le paramètre INPUT_VAL. Pour faire apparaître ce texte d’ERREUR dans la log, l’instruction du langage macro %PUT fera le travail.

Pas besoin de guillemets avec %IF ou %PUT : le paramètre d’une macro est une forme de macro variable. Pour retrouver sa valeur, son nom est donc entouré d’un symbole & et d’un point. Si cette valeur doit apparaître dans une chaîne de caractères entre guillemets, il faut impérativement utiliser des guillemets doubles. Dans le cas contraire, comme ici dans une instruction %IF ou %PUT, on se passe de guillemets pour résoudre la macro variable.

%macro test_param (input_val=,output_val=);
%if &input_val. = %then
   %do;
      %put ERREUR: Le macro paramètre INPUT_VAL= est obligatoire;
   %end;
*suite du programme;
%mend test_param;
%test_param (input_val=,output_val=);

Personnaliser son message : quand SAS rencontre une erreur, il utilise le mot ERROR dans la log. Pour distinguer ce message des votre, vous pouvez ajouter un mot-clé comme le nom de la macro. Par exemple : « ERROR – TEST_PARAM: the INPUT_VAL= macro parameter is mandatory. ».

2. Gérer les caractères spéciaux : il est fréquent d’avoir des valeurs autres que les chiffres et les lettres de l’alphabet comme valeur pour un paramètre de macro. Vous aurez souvent besoin de définir l’emplacement des données sources et celui où les outputs seront sauvegardées. Pour cela, les paramètres auront des valeurs du type c:/mon_projet/mesdonnees ou encore c:/mon_projet/mes_resultats. Il existe des macros fonctions : %BQUOTE et %NBRQUOTE pour tenir compte de la barre inclinée (slash) et d’autres caractères spéciaux.

• %BQUOTE : les symboles suivants sont gérés avec la fonction %BQUOTE() : ‘  » ( ) + – * / < > = ¬ ^ ~ ; , blanc AND OR NOT EQ NE LE LT GE GT
• %NBRQUOTE : si, en plus, vous avez les symboles & (et) et % (pourcentage), il faudra faire appel à la macro fonction %NBRQUOTE().

SAS online DOC :

• %BQUOTE et %NBRQUOTE Functions
• Using the %BQUOTE and %NBRQUOTE Functions

3. Enjamber un programme

Si la condition n’est pas remplie, on peut demander à SAS d’ignorer une partie du code grâce à la syntaxe de %GOTO. Il était également possible de demander à SAS d’arrêter son exécution en plein milieu. Certes, enjamber le code permet d’avoir une log plus propre, puisque seuls nos messages apparaissent. Mais surtout, cela permet de poursuivre l’exécution du programme. Ainsi, si un appel de macro ne fonctionne pas, rien n’empêche de continuer la soumission d’autres appels de cette macro.

Dans un premier temps, il s’agit de définir une balise. A partir de cette position, SAS pourra continuer son exécution. Ici, la balise s’appelle FIN_PGM. Elle est ajoutée juste avant la fin du la macro.

Dans un second temps, si le paramètre est vide, SAS est prié d’ignorer le code qui suit jusqu’à la balise. Pour cela, dans la condition, l’instruction %GOTO est ajoutée.

%macro test_param (input_val=,output_val=);
%if &input_val. = %then
   %do;
      %put ERREUR: Le macro paramètre INPUT_VAL= est obligatoire;
      %goto fin_pgm;
   %end;
*suite du programme;
%fin_pgm:
%mend test_param;
%test_param (input_val=,output_val=);

3 angles de vue sur les commentaires

Il existe trois notations différentes pour écrire des commentaires dans un programme SAS. Chacune à ses avantages et ses limites. En en prenant connaissance ici, vous pourrez faire des choix stratégiques.

1. Désactiver une instruction : un commentaire entre une étoile et un point virgule est la plus rapide des notations. Celle-ci fait usage de la particularité de la syntaxe SAS. En effet, chaque instruction se termine par un point-virgule. En ajoutant une étoile (asterisk) en tête, l’instruction est désactivée.

Lors du développement d’un programme, on est amené à suspendre certaines instructions ou à en activer ponctuellement. C’est le cas la procédure PROC PRINT, qui permet d’avoir un aperçu du contenu d’un jeu de donné. 

*proc print data=cnt_pct;
*run;

Note : On n’utilisera pas cette syntaxe étoile/point-virgule :

• pour suspendre un large bloc de texte
• si les guillemets ne sont pas fermés dans le commentaire
• entre deux instructions PUT ou deux instructions CALL EXECUTE.

2. Désactiver un bloc de texte plus globales : L’étoile/point-virgule  peut-être incluse dans d’autres  commentaires plus larges définis pas /* */. Ainsi on peut choisir d’annoter des titres de rubriques d’un programme avec *; . Ainsi on pourra englober ces titres dans une zone de désactivation plus grande.

/*
*Calcul des fréquences;
proc freq…;
run;

*Générer une table;
proc report…;
run;
*/

Note : On pourra choisir de fermer le bloc par /***/ au lieu de */. Ainsi, en enlevant seulement le /* en début de commentaire, l’intégralité du code est réactivée et fonctionne sans que la notation de fin soit impérativement supprimée.

3. Les commentaires et le langage macro :

Les différences entre les instructions à l’intérieur et la l’extérieur d’une définition de macro : les instructions macro doivent avoir l’étoile après le symbole pourcentage à l’intérieur d’une définition de macro. On continuera à mettre l’étoile avant si l’instruction est à l’extérieur de la définition de macro. La notation /**/ ne rencontre pas de difficulté particulière.

%macro commentaires;
%*IF….;
%mend;
*%commentaires;

Le cas particulier des conditions : seul le /**/  peut-être utilisé entre un %if et un %else.

%macro commentaire;
   %IF … %THEN %DO; … %END;
 /* l’autre notation n’est pas possible ici*/ 
  %ELSE …
%mend commentaire;

Une macro sans nom : la troisième méthode pour écrire un commentaire est de créer une macro sans nom.

%macro;
Mon texte est inactif ici.
%mend;

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.