Archive for the ‘proc sql’ Category

h1

Empiler des data sets

mai 22, 2008

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

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

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

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

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

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

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

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

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

data seq_all;
   set seq1 seq2 seq3;
run;

SAS Online Doc : The SET Statement

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

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

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

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

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

Voici la même manipulation avec PROC APPEND.

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

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

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

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

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

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

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

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

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

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

Annexe :

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

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

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

h1

Repérer les 1ers/derniers records (FIRST/LAST)

mai 6, 2008

Repérer la première et/ou la dernière observation d’un jeu de données ou d’un sous-ensemble de ce jeu, c’est possible sous SAS avec les mots-clés FIRST et LAST dans un data step. On se sert de cette information sous forme de condition. Si la première observation est rencontrée, on fait ceci, sinon on fait cela. Cela sert pour créer une variable compteur ou pour générer plusieurs programmes via un DATA _NULL_, programmes variant par quelques valeurs listées dans un fichier de référence.

1. Le raisonnement FIRST/LAST en langage humain

Dans l’exemple ci-dessous, on a tout d’abord deux variables MEMNAME et NAME qui sont triées. Ensuite sont ajoutées plusieurs variables.

Les variables FRST_DSN/LST_DSN

  • S’il s’agit de la première fois que l’on lit la valeur de la variable MEMNAME, alors on donne une value de 1 à FRST_DSN, sinon on donne une valeur de 0.
  • Si au contraire, il s’agit de la dernière valeur avant de changer, LST_DSN prend la valeur 1, sinon il prend la valeur 0.

Dans l’exemple, on remarque que FRST_DSN et LST_DSN sont toutes les deux égale à 1 quand MEMNAME=DSN2, car il n’y a qu’une observation pour ce MEMNAME. La première observation est donc également la dernière,

memname  name  frst_dsn lst_dsn frst_var lst_var
    dsn1       var1          1          0           1          0
    dsn1       var1          0          0           0          0
    dsn1       var1          0          0           0          1
    dsn1       var2          0          0           1          1
    dsn1       var3          0          1           1          1    
    dsn2       var1          1          1           1          1    

    dsn3       var1          1          0           1          1
    dsn3       var2          0          0           1          1
    dsn3       var3          0          0           1          1
    dsn3       var4          0          1           1          1    
    dsn4       var1          1          0           1          1
    dsn4       var2          0          1           1          1       

FRST_VAR/LST_VAR : une fois dans un groupe (DSN1, DSN2, DSN3 ou DSN4), on regarde la seconde variable NAME.

  • Si on a la première fois la valeur dans ce groupe, FRST_VAR=1 sinon FRST_VAR=0.
  • Si au contraire, il s’agit de la dernière fois qu’on l’observe dans ce group, LST_VAR=1, 0 autrement.

Dans l’exemple, seul le DSN1 a plusieurs fois une VAR1 associée. C’est donc le seul moment où FRST_VAR n’est pas égal à LST_VAR.

NOTE, choix de l’auteur : entendez FRST pour rappeler le mot FIRST (premier), LST le mot LAST (dernier) et DSN le mot DATA SET NAME (nom du jeu de données).

2. Le raisonnement FIRST/LAST en langage SAS

SAS lie les données d’un jeu de données ligne par ligne. On rassemble les données par groupe en les triant. On rappelle cet ordre avec une instruction BY.

Ici les variables MEMNAME et NAME sont extraites de la bibliothèque SASHELP grâce au dictionnaire COLUMN.

proc sql;
   create table lst_dsn_var as
   select memname, name
   from dictionary.columns
   where upcase(libname)=’SASHELP’;
quit;

Puis, chacune des variables FRST_DSN, LST_DSN, FRST_VAR et LST_VAR sont crées. Ces variables prennent une valeur de 1, si la condition est vrai (s’il s’agit bien de la première ou de la dernière observation), 0 sinon. Bien sûr, on peut choisir de leur donner la valeur que l’on veut.

data _null_;
   set lst_dsn_var;
   by memname name;
   if first.memname then frst_dsn=1;
   else frst_dsn=0;
   if last.memname then lst_dsn=1;
   else lst_dsn=0;
   if first.name then frst_var=1;
   else frst_var=0;
   if last.name then lst_var=1;
   else lst_var=0;
run;

NOTE : SAS se base sur les données d’origine pour dire si oui ou non, il s’agit de la première/dernière observation. Dès lors, si le jeu d’origine est altéré (suppression de lignes), SAS ne redéfinira pas une première/dernière observation parmi celles restantes. On peut donc ne plus avoir l’observation considérée par SAS comme première/dernière. Il choisira si besoin de faire les deux opérations dans des data steps distincts.

3. La première et la dernière observation d’un data set

Vous n’aurez pas toujours une variable prenant la même valeur pour toutes les observations et ainsi retrouver la première et la dernière observation. On peut soit en créer une avec un RETAIN par exemple ou plus simplement utiliser

  • la variable automatique _N_ pour la première observation et
  • la variable assignée avec l’option END= dans l’instruction SET pour la dernière observation.

data _null_;
   set lst_dsn_var end=eof;
   if _N_=1 then …;
   if eof then…;
run;

NOTE : Par habitude, on donne ici le nom EOF (End Of File) comme nom à la variable qui prend une valeur 1 s’il s’agit de la dernière observation, 0 autrement. Comme la variable automatique _N_, EOF n’apparaît pas dans le data set final, s’il est créé.

h1

Combien d’observations dans mon data set ?

avril 14, 2008

Savoir trouver le nombre d’observations dans un data set SAS : tel est le sujet d’aujourd’hui. Connaître le nombre d’observations dans un jeu de données présente plusieurs avantages. En voici deux :

  • Définir une condition pour qu’un code soit exécuté.
  • Définir une boucle pour exécuter un code autant de fois qu’il y a d’observations dans le data set d’origine.

Dans les deux cas, on choisi ici de sauvegarder ce nombre dans une macro variable. Quelles sont les méthodes à disposition pour trouver ce nombre ? Je vous en propose d’en détailler six. Celles-ci fonctionnent également lorsque le data set est vide d’observations.

Exemples illustrés avec le data set ORIG : pour illustrer les différentes méthodes, j’utilise un jeu de données nommé ORIG ne contenant pas d’observations.

data orig;
x=1;

*if x=1 then output;
if x=1 then delete;
run;

L’instruction %PUT permet de voir la valeur de mes macro variables dans la LOG.

1. La fonction COUNT dans PROC SQL : la procédure SQL et sa fonction COUNT permettent de retrouver le nombre total d’observations dans le data set lu, si on n’utilise pas de GROUP BY. L’étoile signifie « TOUTES LES OBSERVATIONS », indépendamment de la variable. Si le nombre d’observations est stocké dans une variable, la valeur s’affiche pour chaque observation. Comme cette valeur est la même pour toutes les observations, on peut n’en afficher qu’une seule via DISTINCT. On peut sauvegarder cette information dans une macro variable via INTO:. Si le DISTINCT n’est pas utilisé, seule la première valeur sera sauvegardé dans la macro variable. DISTINCT est donc optionnel dans ce cas précis.

proc sql noprint;
select distinct count(*) into: methode1
from orig;
quit;

%put METHOD 1 = &methode1. ;


2. SQLOBS, une macro variable automatique à utiliser avec précaution : lorsqu’un data set est créé avec une procédure SQL, on peut, juste après, retrouver l’information avec la macro variable automatique &SQLOBS. Il faut bien faire attention de ne pas inclure d’autres data sets entre temps, lors d’une mise à jour par exemple. SQLOBS récupère le nombre d’observations du dernier jeu de données quelque soit son nom.

proc sql ;
create table methode2 as
select *
from orig;
quit;

%put METHODE 2 = &sqlobs. ;

3. Les métadonnées des dictionnaires SAS : le dictionnaire TABLES liste tous les data sets de toutes les bibliothèques et des informations supplémentaires les caractérisant. Ainsi la variable NOBS contient le nombre d’observations dans le data set. Ici on choisi INTO: pour sauvegarder ce nombre dans une macro variable.

proc sql noprint;
select nobs into: methode3
from dictionary.tables
where upcase(libname)=’WORK’ and
upcase(memname)=’ORIG’;
quit;

%put METHODE 3 = &methode3. ;

4. ATTRN comme « SAS Component Language » ou SCL : le SCL nommé ATTRN permet d’accéder au nombre d’observations. Pour cela, le nom du data set en question et le mot clé NOBS sont données. Ce SCL est accessible via %SYSFUNC. Pour lire le data set et extraire cette information, il faut au préalable, l’ouvrir et ensuite le fermer pour éviter des bugs, via les SCL OPEN et CLOSE. On réfère donc au data set via la macro variable DSID ouvrant le data set.

%let dsid     = %sysfunc(open(work.orig,in));
%let methode4 = %sysfunc(attrn(&dsid,nobs));
%if &dsid. > 0 %then %let rc = %sysfunc(close(&dsid));

%put METHODE 4 = &methode4. ;

5. La variable automatique _N_ : dans un data step, une variable nommée _N_ est créée automatique. Elle contient le nombre total d’itérations effectuées par SAS. Ainsi, si aucune donnée n’est lue, _N_=1. Une fois la lecture d’une observation faite par exemple, SAS revient juste après l’instruction DATA et _N_ est incrémenté de 1. Le nombre d’observations dans le data set est donc _N_-1. Ce nombre est sauvegardé ici dans une macro variable appelée METHODE5 créée via une instruction CALL SYMPUTX.

data_null_;
call symputx(‘methode5’,_N_-1);
set orig;
run;

%put METHODE 5 = &methode5. ;

6.  L’option NOBS de l’instruction SET : en précisant un nom après l’option NOBS= de l’instruction SET, la valeur de NOBS est sauvegardée dans une variable. Ici, elle s’appelle METHODE6. L’instruction CALL SYMPUTX permet de sauvegarder cette valeur dans une macro variable. La manière dont SAS traite le code est très importante ici.  Les explications d’Alain vous sont données plus bas.

data _null_;
if 0 then set orig nobs=methode6;
call symputx(‘methode6’,methode6);
stop;
run;

Le « IF 0 » est une instruction toujours fausse, donc l’exécution de l’instruction
conditionnée ne sera jamais réalisée. La récupération du nombre d’observations
depuis le dictionnaire du data set se fait au moment de la compilation par le SAS DATA
COMPILER, qui stocke dans une variable qui est forcément temporaire citée avec
l’option « NOBS= ».

L’instruction STOP ne permet pas d’écourter le temps de lecture des données car il
n’y pas d’exécution de lecture. Alors que se passe-t-il ?

L’étape DATA étant une boucle automatique dès qu’une instruction de lecture (Set ,
Merge, Modify, Update, …) de data set est détectée par le Superviseur SAS et par
compilateur de l’étape DATA , l’exécution de la boucle est automatique à cause de la
détection de l’instruction « SET » et SAS va vérifier si le test
induit par l’instruction « IF 0 » (comprendre if 0 =1) n’est pas devenu vrai !
D’où la nécessité de poser l’instruction SAS « STOP », pour éviter la boucle de
l’étape DATA.

 

(SUPERVISEUR SAS : Agent pivot qui distribue le code soumis par PARSING, soit au
DATASTEP COMPILER, PROCEDURE PARSER ou au Compilateur MACRO)

h1

Produit cartésien : un notion pas si barbare !

mars 13, 2008

jeu_fr.jpg

Enfant, vous avez peut-être joué à ce jeu où les mots d’une colonne sont à relier avec les mots d’une autre colonne. Pour s’amuser, on peut tracer toutes les combinaisons possibles. Avec 4 valeurs à gauche et 3 valeurs à droite, 12 traits sont tracés. 

Le produit cartésien c’est la même chose : créer toutes les combinaisons possibles. Ce mot fait parti du vocabulaire pour combiner deux bases de données.

Proc SQL ou data step ? : Seule la procédure SQL permet de faire cette manipulation occasionnelle. Le MERGE du data step ne peut pas.

1. Un exemple : dans l’exemple ci-dessous, le premier jeu de données a trois lignes d’observations et le second en a deux.

–ONE–
x     y
1    11
2    22
3    33

—–TWO—–
 a    b    c
 9    8    3
99    5    2

Pour chaque ligne du premier jeu, on veut les deux observations du second jeu. Cela donne un nouveau data set avec 3*2 lignes d’observations.

x  y  a b c
1 11  9 8 3
1 11 99 5 2
2 22  9 8 3
2 22 99 5 2
3 33  9 8 3
3 33 99 5 2

2. Une procédure SAS : la procédure SQL liste les variables des deux jeux de données. Le nom des deux data sets  sont séparés pas une virgule.


proc sql;;
   select x, y, a, b, c
   from one, two;
quit;

h1

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

mars 6, 2008

Etagères

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;

pour une liste des vues de SASHELP et des dictionnaires SAS, vous pouvez consulter la feuille résumée suivante : www.codecraftersinc.com/pdf/DictionaryTablesRefCard.pdf.

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.

h1

Envoyez un email via SAS

février 11, 2008

Envoyer 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;
h1

3 méthodes pour construire des macros variables sans macro

février 7, 2008

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.