Besoin fonctionnel simple mais néanmoins possible, on souhaite par exemple dans une entreprise du secteur assurance automobile éliminer toutes les lignes d’une table des assurés dont le numéro de police, variable alphanumérique, contient au moins une lettre. Cas par exemple des assurances de type x plus.

Le programme SAS ci-dessous vous fournit une des possibilités offerte par la programmation SAS dans une étape DATA.


/* Résultats dans la LOG */
data _null_;
 a="2";
 b="k44k";
 if ifn(a > 0,1,0) then put "a OK !";
 else                   put "a KO !";
 if ifn(b > 0,1,0) then put "b OK !";
 else                   put "b KO !";
run;


/* Contenu de la log */

   a OK !
   b KO !

Le but ici est de vous fournir un programme simple pour vous permettre de rechercher les doublons que vous pourriez avoir dans une de vos table SAS.  

Nous utilisons pour cela la proc SQL de SAS.  

On commence par afficher les informations de la table avec deux petites particularités :  

On regroupe les observations sur un critère que vous devez déterminer, ici on à choisi : « Nom, prenom, ville, region, pays » c’est l’objet de la partie GROUP BY.  

Ensuite on demande à SAS de nous retourner toutes les lignes aggrégées de la table dont le nombre de tuples « Nom, prenom, ville, region, pays » est supérieur à 1. C’est la clause HAVING.   

Le résultat renverra toutes les lignes possédant au moins un doublon, l’ensemble des variables de la table plus le « nombre » d’occurences pour chaque tuple.


/* ****************************************** */
/* Site : http://www.formations-sas.fr - 2010 */
/*                                            */
/* PGM = Détection des doublons sur Table SAS */
/*                                            */
/* Auteur : Pascal MAUBERT                    */
/* ****************************************** */

proc sql;
   title ‘Recherche des doublons’;
   select *, count(*) as nombre
      from table_double_sas
      group by Nom, prenom, ville, region, pays
      having count(*) > 1;
quit;

Dans la série optimisation et tuyaux, voici le premier d’une série de conseil pour l’optimisation de vos programme SAS.

Pour des raisons de simplification et de méconnaissance du produit SAS, nous avons tous débuté en créant une multitude d’étape data inutiles. Ces étapes sont coûteuses aussi bien en terme de CPU qu’en terme d’I/O (accès disques entrée/sorties ou Input/Output).

Quand une table est d’une grande volumétrie, essayez de ne la lire qu’une seule fois et de créer toutes les tables dépendantes en un seul passage, vous gagnerez toutes les lectures successives de cette table SAS.

/* ****************************************** */
/* Site : http://www.formations-sas.fr - 2009 */
/*                                            */
/* Tuyaux - Performances, Optimisation SAS    */
/* GAIN : CPU - IO                            */
/*                                            */
/* Auteur : Pascal MAUBERT                    */
/* ****************************************** */

/* ACCEPTABLE */
data tablea;
 set db.master;
 if flag1;
run;

data tableb;
 set db.master;
 if flag1 and age < 21;
run;

data tablec;
 set db.master;
 if flag1 and age >= 21;
run;

/* PLUS EFFICACE */
data tablea tableb tablec;
 set db.master;
 if flag1 then do;
    output tablea;
    if age < 21 then output tableb;
    else             output tablec;
 end;

run;

/* ****************************************** */
/* Site : http://www.formations-sas.fr - 2009 */
/* Auteur : Pascal MAUBERT                    */
/* ****************************************** */

Avant Propos.

Le but de cet article n’est pas de se substituer à une formation appliquée de SAS SPDE, mais de présenter ce fabuleux produit, même si les techniciens SAS avancés seront surement capable de s’en contenter pour comprendre, assimiler et utiliser SAS SPDE.

Cet article ne prétends pas non plus à se substituer à la documentation officielle de SAS Institute sur SAS SPDE, un lien vers celle-ci (documentation en anglais) se trouve en bas de la page.

Description générale de SAS SPDE

SAS SPDE est un moteur de gestion de données SAS, SAS SPDS est un serveur à part entière de gestion des données et au fonctionnant proche de SAS SPDE. SAS SPDE est intégré au module SAS Base comme moteur de gestion des données .

Aujourd’hui intégré au produit / module SAS Base, son nom à été changé en SAS SPDE.

Ce moteur de données SAS offre des performances exceptionnelles et trouve sa raison d’être dans le besoin de performances accrues lors de requêtes sur des tables de très gros volumes. C’est à dire des tables allant de 512 méga à plusieurs terra octets.

En synthèse, si on souhaite pouvoir lancer une requête contenant plusieurs critères sur une table de plusieurs terra octets et obtenir une réponse en quelques secondes, alors la solution SAS SPDE  est une solution appropriée.

SAS SPDE est donc l’un des procédé d’optimisation, il en existe bien d’autre,  pour l’accès à des données décisionnelles, données d’entreprise, de fortes volumétrie et nécessitant des performances accrues en terme de temps de réponse à des requêtes.

Description technique de SAS SPDE

Pourquoi SAS SPDE est encore plus rapide que SAS Base, qui déjà offre des performance hors du commun ?

Le principe de fonctionnement du moteur SAS SPDE tire profit des architectures SMP (Symmetric Multiprocessing). Dans cette architecture, les processeurs partagent le bus d’accès à la mémoire vive, communiquent entre eux et peuvent travailler en parallèle.

Et enfin ajoutons également une batterie de disque dur rapide sur lesquels seront réparti un partitionnement des grosses table SAS.

Simplification et synthèse :

Pour effectuer une requête sur une table de 4 terra-octets, sur une machine possédant 16 processeurs et 9 disques durs :

SAS SPDE, avec les doigts de l’administrateur partitionne la table (partie donnée) en 6 blocs et implémente chacun de ces blocs sur un disque dur différent, crée un descripteur nommé méta-data sur un autre disque dur, qui contiendra les informations sur la table et enfin utilisera les deux derniers disques durs afin d’y stocker les fichiers d’index.

Un choix de la taille du partitionnement, par exemple 128 Mo, donnera un total de 32 blocs poue cette table de 4 terra-octets, et ces blocs seront répartit sur les 6 disques durs prévue à cet effet via l’allocation faite lors du libname.

Ensuite lors de la requête 1 ou 2 des CPU travailleront sur les fichiers d’index, une dizaine sur les blocs de donnée, 1 sur les méta-data et le reste sur le tri automatique à la volée sur l’éventuelle classification induite par des group by.

SAS SPDE ne nécessite plus l’utilisation de la PROC SORT, en effet, les données sont triées automatiquement à la volée en cas de besoin.

Tout ce petit monde travaillera en parallèle et communiquera ensemble afin de fournir un résultat très rapide et cohérent à l’utilisateur.

Programme SAS d’exemple sur SAS SPDE

Se programme à pour vocation et vous fournir des informations synthétique sur la syntaxe générale à utiliser lors d’un travail sur des données à faire gérer par le moteur de donnée SAS SPDE.

Le programme ci dessous proposé, ne prétend pas vous fournir toutes les informations sur le produit SAS SPDE, mais une base sérieuse afin de vous permettre de commencer à travailler avec SAS SPDE. Attention toutefois, lors de l’utilisation de SAS SPDE, les performances ne peuvent être significative que si votre machine possède plusieurs processeurs et plusieurs disques durs. La connexion à ces derniers via fibre optique est un plus.

Cet exemple de programme SAS, utilise les modules SAS : SAS Base, SAS SPDE, SAS SQL et SAS MACRO.

/* Options d'otimisation et de conte rendu */
options fullstimer bufno=16 bufsize=16384;

/* Exemple d'utilisation du moteur SAS SPDE */
/* définition et mise en place de l'accès via LIBNAME */

libname mon_spde spde "D:\SAS Divers\SAS_SPDE/disk1/metadata"
 datapath  = ("D:\SAS Divers\SAS_SPDE/disk2/userdata"
 "D:\SAS Divers\SAS_SPDE/disk3/userdata")
 indexpath = ("D:\SAS Divers\SAS_SPDE/disk4/userindexes"
 "D:\SAS Divers\SAS_SPDE/disk5/userindexes")
 ;  /* temp=yes; Attention ! Cette option vide les libnames
 de SPDE à la fin de la session SAS. */

/* MACRO itérative pour la création d'une table SAS
 de 400 variables et d'environ 80 000 observations */
options nomprint nosymbolgen;
/* Définition, compilation et stockage temporaire */
%macro test(deb=1,fin=200);
 data mon_spde.test_spde(index=(total /unique)asyncindex=yes partsize=24);
 %do i = &deb %to &fin;
 %do inc = 1 %to 399;
 a&inc = &i * &inc;
 total=sum(of a:);
 output;
 %end;
 %end;
 run;
%mend test;

/* Appel de la macro pour création de la table */
%test ;

/* Requête de création d'une table via une
 selection d'observations sur critères .. */
proc sql;
create table mon_spde.select_spde as
 select * from mon_spde.test_spde
 where total between 400000 and 5000000
 and a1 >= 5 and a1 <= 63;
quit;

/* MACRO Itérative exemple en SAS Base */
options nomprint nosymbolgen;
%macro test(deb=1,fin=200);
 data toto(index=(total /unique));
 %do i = &deb %to &fin;
 %do inc = 1 %to 399;
 a&inc = &i * &inc;
 total=sum(of a:);
 output;
 %end;
 %end;
 run;
%mend test;

%test ;

proc sql;
create table select_toto as
 select * from toto
 where total between 400000 and 5000000
 and a1 >= 5 and a1 <= 63;
quit;

/* Copie  d'une table de SAS base vers SAS SPDE */
proc copy in = work out = mon_spde;
 select toto;
run;
/* Copie  d'une table de SAS base vers SAS SPDE,
 bien plus performant que la PROC COPY */
proc append base=mon_spde.toto(asyncindex=yes partsize=24)
 data=work.toto;
run;

/* Compte rendu du contenu d'une biblithèque SAS SPDE */
proc contents data=mon_spde._all_;
run;

Note :

A noter que la PROC APPEND offres des performances accrues par rapport à la PROC COPY de l’ordre de facteur 10, toutefois pour la copie de beaucoup de table se trouvant sur la même bibliothèque, l’écriture de la PROC COPY est beaucoup plus simple. Mais comme toujours en SAS il existe des solutions à tout problème et ici nous pourrions, par exemple, encapsuler la proc append dans une macro et automatiser le transfert de toutes les tables contenues dans un libname x d’un moteur SAS Base vers un Moteur SAS SPDE.

Documentation :

Pour les longs discours et pour plus de détails sur SAS SPDE, voir la documentation officielle de SAS Institute, version SAS 9.2 : Scalable Data Performance Engine

Copyright de l’article © P.Maubert 2009

Ce problème est un problème très simple, il est souvent rencontré lors des développements en SAS. Les informations nécessaires sont généralement fournies lors des formations SAS AVC1 (avancé I) et bien souvent oubliées par les stagiaires.

Donc voici un rappel de la méthode « propre », du changement d’une variable de type caractère en variable de type numérique.

Utilisation pour la démonstration, d’une table SAS « COMPANY » fournie en standard dans le libname « SASHELP » : sashelp.company.

Nous allons changer ici la variable « DEPTHEAD » de type caractère et de longueur 15 en une variable de type numérique et d’une longueur de 3, sans changement du nom de la variable.

Par défaut une variable numérique en SAS fait 8 de longueur et cela n’est pas toujours nécessaire, aussi si vous avez beaucoup de variable numérique et un nombre d’observation important, il est de bon ton, pour des raisons d’optimisation, de dimensionner correctement les variables numériques.

L’instruction length permet d’effectuer cela.

Théoriquement impossible, nous allons voir que la solution est assez facile à mettre en œuvre.

/* ****************************************** */
/* Site : http://www.formations-sas.fr - 2009 */
/* SAS V9                                     */
/*                                            */
/* Comment convertir une variable caractère   */
/* en numérique.                              */
/*                                            */
/* Procéder en trois étapes :                 */
/* 1 Utilisez l'option dataset RENAME         */
/* 2 Utilisez la fonction de changement de    */
/*   type                                     */
/* 3 Supprimez la variable intermédiaire      */
/*                                            */
/* Auteur : Pascal MAUBERT                    */
/* ****************************************** */

data test_change_type(drop=new_var);
 set sashelp.company(rename=(DEPTHEAD=new_var));
 length DEPTHEAD 3.;
 DEPTHEAD=input(new_var,$15.);
run;

/* ****************************************** */
/* Site : http://www.formations-sas.fr - 2009 */
/* Auteur : Pascal MAUBERT                    */
/* ****************************************** */

Ce problème est un problème très simple, il est souvent rencontré lors des développements en SAS. Les informations nécessaires sont généralement fournies lors des formations SAS AVC1 et bien souvent oublié par les stagiaires.

Donc voici un rappel de la méthode « propre », du changement d’une variable de type numérique en variable de type caractère.

Utilisation pour la démonstration, d’une table SAS « COMPANY » fournie en standard dans le libname « SASHELP » : sashelp.company.

Nous allons changer ici la variable « N » de type numérique et de longueur 8 en une variable de type caractère et d’une longueur de 12, sans changement du nom de la variable.

Théoriquement impossible, nous allons voir que la solution est assez facile à mettre en œuvre.

/* ****************************************** */
/* Site : http://www.formations-sas.fr - 2009 */
/* SAS V9                                     */
/*                                            */
/* Comment convertir une variable numérique   */
/* en caractère ?                             */
/*                                            */
/* Procéder en trois étapes :                 */
/* 1 Utilisez l'option dataset RENAME         */
/* 2 Utilisez la fonction de changement de    */
/*   type                                     */
/* 3 Supprimez la variable intermédiaire      */
/*                                            */
/* Auteur : Pascal MAUBERT                    */
/* ****************************************** */

data test_change_type(drop=new_var);
 set sashelp.company(rename=(n=new_var));
 n=put(new_var,12.);
run;

/* ****************************************** */
/* Site : http://www.formations-sas.fr - 2009 */
/* Auteur : Pascal MAUBERT                    */
/* ****************************************** */

Avant propos

Cet article à pour de présenter une démarche d’optimisation pour un traitement de type Transaction pour l’ajout ou la mise à jour de données SAS.

Ce genre de problématique étant récurrent, il m’a semblé utile de vous fournir l’exemple détaillé ci-dessous.

Cet exemple se base sur des faits réels rencontrés lors d’une mission d’optimisation pour le compte du client « La Redoute », lors de mon passage au service Consulting de chez SAS Institute. Le chiffres fournis sont approximatifs et n’engage en rien la responsabilité de qui que ce soit.

Problème :

Redoute : 25 000 000 de lignes de commandes par jour et un temps de traitement sous SAS MVS avoisinant les 22 heures.

Bien sur, panique et demande d’intervention pour un audit d’optimisation.

Étude cynématique : par téléphone, par courrier et par internet réception des lignes de commande stockées dans DB2. La nuit Unload DB2 vers un fichier plat pour incorporation dans SAS. Lecture des lignes de commandes, tentative de mise à jour de la base SAS avec les lignes de commandes et en cas de rejet ajout de celles-ci dans la base SAS. Temps de traitement abominable.

Synthèse des Solutions

Deux cas se présentent :

1. On connait sous DB2 la nature de la transaction « ligne de commande » ajout ou modification
2. On ne la connait pas

Dans ces deux cas une solution performante existe.

La première la plus simple, ne sera pas détaillé dans cet article, simplement on transmet issu de DB2 dans l’unload une variable de type flag avec A pour ajout et M pour mise à jour. Sous SAS on éclate le fichier en deux tables SAS une pour les ajouts qui seront traités par la PROC APPEND et l’autre pour les mises à jour qui seront traités avec une étape DATA / MERGE.

Pour le deuxième cas un peu plus pointu, voici ci-dessous un exemple de programme fournissant une solution optimisée pour ces traitements transactions AJOUT / MAJ.

Plutôt que le programme SAS, je vous fournit le compte rendu d’exécution sur une machine de base et exécuté sous Windows Vista SAS V9.

Machine : Sans marque AMD 7750 x2, RAM 4 Go, HD SATA 500 Go, Windows Vista 64 bits SAS V 9.00.

Attention les temps d’exécution peuvent paraître excellent, mais la machine n’est pas partagée et les tables d’exemple sont petites et surtout elles n’ont que 6 variables, dans la vraie vie c’est plutôt de 200 à 500 variables.

Toutefois, La Redoute avec cette solution à ramenée son temps de traitement de 22 à moins de 3 heures.

Tables d’exemple :

• Base : toto1 – 5 000 000 de lignes et 6 variables
• Transaction : toto2 – 525 000 lignes et 6 variables
• TP – MAJ : maj – 175 001 lignes et 6 variables
• TP – Ajout : add – 349 999 lignes et 6 variables
• Temps d’exécution total réel (elaps) : 9.53 secondes

Extrait de la Log :

379  /* ****************************************** */
380  /* Site : http://www.formations-sas.fr - 2009 */
381  /* SAS V9 : Optimisation                      */
382  /*                                            */
383  /* Comment optimiser un traitement de         */
384  /* transaction en SAS.                        */
385  /*                                            */
386  /* Auteur : Pascal MAUBERT                    */
387  /* ****************************************** */
388
389  options compress=no bufno=8 bufsize=9220 fullstimer msglevel=i;
390
391  /* Création de la table de base exemple */
392  data toto1(index=(i /unique));
393   do i = 1 to 5000000;
394      j=i*2;
395      y=j*3.14;
396      orig='A';
397      k=i*j;
398      total=sum(of i j y k);
399      output;
400   end;
401  run;

Note: La table WORK.TOTO1 a 5000000 observations et 6 variables.
Note: Index simple i défini.
Note: L'étape DATA used (Total process time):
 temps réel                   3.96 secondes
 temps processeur utilisateur 2.48 secondes
 temps processeur système     0.99 secondes
 Mémoire                            68348k

402
403  /* Création de la table de Transaction exemple */
404  data toto2(index=(i /unique));
405   do i = 1500000 to 12000000 - 1 by 20;
406      aj=i*2/2;
407      ay=aj*3.14/3.14;
408      aorig='B';
409      ak=i*aj/aj;
410      total=sum(of i aj ay ak);
411      output;
412   end;
413  run;

Note: La table WORK.TOTO2 a 525000 observations et 6 variables.
Note: Index simple i défini.
Note: L'étape DATA used (Total process time):
 temps réel                   0.32 secondes
 temps processeur utilisateur 0.23 secondes
 temps processeur système     0.09 secondes
 Mémoire                            12940k

414
415  /*  Début du traitement hebdomadaire, chez vous sur les unload DB2 */
416  /*  Création des tables MAJ et ADD */
417  data maj
418       add(rename=(aj=j aorig=orig ay=y ak=k));
419   merge toto1(in=a keep=i)
420         toto2(in=b);
421   by i;
422   if b and a     then output maj;
423   if b and not a then output add;
424   else delete;
425  run;

INFO : Index i sélectionné pour traitement de la clause BY.
INFO : Index i sélectionné pour traitement de la clause BY.
Note:  5000000 observations copiées de la table WORK.TOTO1.
Note:  525000 observations copiées de la table WORK.TOTO2.
Note: La table WORK.MAJ a 175001 observations et 6 variables.
Note: La table WORK.ADD a 349999 observations et 6 variables.
Note: L'étape DATA used (Total process time):
 temps réel                   3.89 secondes
 temps processeur utilisateur 3.58 secondes
 temps processeur système     0.29 secondes
 Mémoire                            268k

426
427  /* Traitement de la table MAJ */
428  data toto1;
429   set maj(drop=aj ay ak); /* Le drop si Variables non MAJ */
430   modify toto1 key=i /unique ;
431   i=i;
432   *j=aj;
433   *y=ay;
434   orig=aorig;
435   *k=ak;
436   if _iorc_=0 then replace;
437   else do; _error_=0; output; end;
438  run;

Note:  175001 observations copiées de la table WORK.MAJ.
Note: Table WORK.TOTO1 mise à jour.  175001 observations recopiées, 0 observations ajoutées et 0 observations supprimées.
Note: L'étape DATA used (Total process time):
 temps réel                   0.90 secondes
 temps processeur utilisateur 0.60 secondes
 temps processeur système     0.26 secondes
 Mémoire                            151k

439
440  /*  Traitement de la table ADD */
441  Proc append data=add base=toto1;
442  run;

Note: Ajout de WORK.ADD to WORK.TOTO1.
INFO : Processus d'ajout rapide d'un moteur en cours d'utilisation.
INFO: la méthode de lecture par bloc du moteur est en cours d'utilisation.
INFO: la méthode d'écriture par bloc du moteur est en cours d'utilisation.
Note:  349999 observations copiées de la table WORK.ADD.
Note: 349999 observations added.
Note: La table WORK.TOTO1 a 5349999 observations et 6 variables.
Note: La procédure APPEND used (Total process time):
 temps réel                   0.46 secondes
 temps processeur utilisateur 0.31 secondes
 temps processeur système     0.15 secondes
 Mémoire                            8639k

443
444  /* ****************************************** */
445  /* Site : http://www.formations-sas.fr - 2009 */
446  /* Auteur : Pascal MAUBERT                    */
447  /* ****************************************** */

Et maintenant selon la formule consacrée : A vos claviers

Dans la problématique d’optimisation des applications SAS, des traitements et de la charge machine, nous sommes parfois amené à effectuer des recherches afin d’optimiser les programmes SAS et les bases de données SAS.

Un des points important est la volumétrie que représentent ces données. En effet, lorsque des bases de données stockent de grande quantité de données, des dizaines voire des centaines de millions de lignes, il devient très rentable et judicieux de se pencher sur l’optimisation des traitements, programmes SAS, mais également sur les bases de données SAS.

Or si SAS nous fournit une gestion simplifiée de la création et de la gestion de ses tables, il n’en demeure pas moins, qu’un peu de travail d’optimisation reste à la charge du concepteur de l’architecture des données. Cela devient encore plus vrai dans le monde du décisionnel, monde dans lequel les données, stockées sous forme de data Warehouse ou de datamarts, atteignent des volumes très important et ou le temps d’analyse est conséquent.

Hormis les problématiques de bien fondé de telle ou telle variable dans une table, de la normalisation des tables qui n’est pas envisageable dans le BI ou le décisionnel, il nous reste un point important d’optimisation, c’est la longueur de stockage des variables.

Par défaut, les variables SAS, n’ont pas besoin d’être définies, déclarées, leur création est automatiquement effectuée lors de leur assignation de valeur.

Dans le cas d’une définition automatique d’une variable numérique, SAS attribue une longueur par défaut de 8 positions numérique. Or comme vous pouvez le voir ci-dessous dans le tableau présenté (plate-forme MVS/Z/OS), il est bien rare d’avoir besoin d’une si grande longueur de variable.

Table 10.1 Variable Length and Largest Exact Integer Length in Bytes

Significant Digits Retained Largest Integer Represented Exactly

2          2          256

3          4          65,536

4          7          16,777,216

5          9          4,294,967,296

6          12        1,099,511,627,776

7          14        281,474,946,710,656

8          16        72,057,594,037,927,936

SAS nous fournit en standard, via le module SAS Base, un grand nombre de fonctions, telles que : Fonctions de tableaux, fonctions de caractères, fonctions de devises, fonctions de dates et de temps, fonctions de statistiques, fonctions de gestion de fichiers, fonctions financières, fonctions de macro, fonctions mathématiques, fonctions de probabilité de quantile, fonctions aléatoires, fonctions de trigonométrie, fonctions de variable, fonctions de Web …

Or si il est facile pour les variables de type caractères, de connaître la longueur utilisée d’une variable à l’aide de la fonction chaine LENGTH(), il n’en est pas de même pour les variables de type numérique.

Toutefois nous n’allons pas en rester là, et ce que SAS n’a pas fait pour nous, nous allons le faire nous même. Avant de vous donner notre solution, nous allons nous mettre dans un cas d’école simple afin de rappeler le contexte à nos amis débutant en SAS.

Les informaticiens maîtrisant déjà SAS, nous vous conseillons de passer directement à la solution.

Pour les autres, afin de vous aider à mieux comprendre voici un petit programme qui crée une table SAS nommée test_var, en environnement SAS MS Windows.

data test_var;
  a=1;
  dt='27dec2008'd;
  b="un  deux";
  c=scan(b,1)!!"  / "!!scan(b,2)!!".";
run;

Alors à la lecture de ce programme SAS, il serait plausible de penser que :

a : variable numérique longueur 1

dt : variable numérique longueur 9

b : variable alphanumérique longueur 7

c : variable alphanumérique longueur 11, soit b + blanc / blanc et point.

Soit un total pour les lignes de la table de 28 octets, bytes, positions, digit, c …

Eh bien NON !

La longueur totale de la ligne est de 427 c.

Et elle pourrait être réduite à 25 c.

Soit un différentiel de 402 c, ce qui ne représente rien ou pas grand chose pour une table de 200 000 lignes avec si peu de variables, multipliez par 20 le nombre de variable, par 100 le nombre de ligne et alors le gain sera colossale, non seulement en volumétrie, mais lors des traitements de ces données SAS par des programmes, vous économiserez sur le temps de lecture, sur le temps de transfert sur le réseau, sur le volume de mémoire nécessaire, le temps CPU, le temps d’analyse et enfin le temps pour l’écriture des données si vous écrivez une table en sortie.

Voici les explications correspondantes à cette longueur surprenante de 427 c.

data test_var2;
  length  a 3 dt 4 b $ 7 c $ 11;
  a=1;
  dt='27dec2008'd;
  b="un deux";
  c=scan(b,1)!!"  / "!!scan(b,2)!!".";
run;

b n’est définit dans l’instruction length, que pour garder l’ordre des variables SAS dans la table test_var2 par rapport à test_var.

Les fonctions : trim(), left(), compress() ne fonctionnement pas pour ce problème (scan). Essayez-le par vous même pour vérifier.

Bien vous vous doutez bien qu’en général, une table SAS ne possède pas qu’une ligne et connue par vous, il va donc falloir mettre au point un petit programme afin de déterminer la longueur maximale utilisée dans notre table.

Pour cela nous allons utiliser la procédure SAS SQL.

Commençons par le plus simple, déterminer la plus grande longueur utilisée d’une variable de type caractère, soit alphanumérique dans une table SAS.

PROC SQL;
  select max(length(b))  as lg_b,  max(length(c)) as lg_c
  from  test_var2 ;
Quit ;

Il nous reste maintenant à atteindre le but de cet article d’optimisation SAS, faire la même chose sur les variables numériques, sachant que SAS ne nous proposent pas l’équivalent de LENGTH().

L’astuce est la suivante, calculer le logarithme népérien base 10 des variables et arrondir à l’entier supérieur le résultat obtenu et bien sur ne retenir que la valeur maximale trouvée dans la table. Ajoutons encore une variable à notre table de départ.

data test_var3;
  length  a 3 dt 4 b $ 7 c $ 11;
  a=11;
  dt='27dec2008'd;
  b="un deux";
  c=scan(b,1)!!"  / "!!scan(b,2)!!".";
  d=123456789;
run;

Et maintenant calculons le résultat :

PROC SQL;
  select max(ceil(log10(a))) as lg_a, max(ceil(log10(dt))) as lg_dt, max(ceil(log10(d))) as lg_d
  from  test_var3 ;
Quit ;

Ici dans notre exemple, la fonction MAX() n’est pas utile, mais elle devient indispensable dans une table de plus d’une ligne.

Le résultat est : 2, 5, 9.

Aidé du tableau des longueurs, dans le companion de votre environnement, vous avez tout pour optimiser les longueur de variable.

A vous de jouer avec SAS!

Au fil du temps et selon notre disponibilité, nous mettrons à votre disposition ces quelques exemples que nous fournissons lors de nos formations SAS.

Parmi les nouvelles fonctions en SAS V9.

SAS V9 – Les fonctions de concaténation.

Habitué en SAS, dans les étapes DATA, à utiliser les opérateurs de concaténation « !! » ou encore « || », (les seconds n’étant pas portables sur toutes les plate-formes SAS, par exemple sur MVS, Z/OS …, nous vous déconseillons leur usage), le Système SAS change la donne en nous offrrant aujourd’hui une série de trois nouvelles « fonction de concaténation » de chaîne de caractère, appelées : « CAT, CATS, CATX« .

Plus riche et permettant une gestion plus élaborée de la concaténation de variable, ces nouvelles fonctions, en SAS V9, permettent même d’ajouter des caractères séparateur entre les variables concaténées.

Plutôt qu’un long discours, voici un ensemble de portions de code SAS, mettant en scène les différentes possibilitées offertes en terme de concaténation de variables de type caractère avec le Système SAS V9.

Dans les exemples qui vous sont proposés ci-dessous, vous trouverez quatre cas d’utilisation de chacune des fonctions de concaténation, systématiquement, la quatrième (a4), présente le résultat qui serait obtenu lors de l’utilisation des trois précédentes (a1, a2, a3). Cette approche vous permettra de voir plus rapidement le résultat qui sera produit par les instructions SAS V9 sans devoir exécuter le code ci-dessous.

/* ****************************************** */
/* Site : http://www.formations-sas.fr - 2009 */
/* SAS V9                                     */
/* Fonctions de concaténation de chaines de   */
/* caractères.                                */
/*                                            */
/* Fonctions : CAT, CATS, CATX                */
/*                                            */
/* Auteur : Pascal MAUBERT                    */
/* ****************************************** */

/* Tronc Commun */

data test_cat;
 length cas $ 10 a1 a2 a3 a4 $ 45 x y z $ 15;
 x="Pays";
 y="FR";
 z="2009";
/* Exemple d'utilisation des nouvelles fonctions SAS de concaténation */
 /* SAS Version 9 */
 /* portions de code par groupe de 4 instructions équivalentes,
 la 4 a pour but de montrer le résultat */

 a1 = trim(x) !! ' ' !! trim(y) !! ' ' !! z ;
 a2 = 'Pays' !! '  FR  ' !! '2009';
 a3 = 'Pays ' !! trim(y) !! ' ' !! z ;
 a4 = 'Pays FR 2009';
 cas="Cas 1";
 output;

/* le symbole "!!" peut remplacer le "||", toutefois cela est déconseillé,
 si vous avez des besoins de portabilité, par exemple, pouvoir utiliser
 votre code sous MVS ou Z/OS */
/* Sans blanc aux extrémités */
/* Concatenates character strings and removes leading and trailing blanks  */

 a1 = cats(x,y,z) ;
 a2 = cats('Pays','  FR  ','2009');
 a3 = cats('Pays',y,z);
 a4 = 'PaysFR2009';
 cas="Cas 2";
 output;

/* Ajouter un séparateur et supprimer les blancs de début et de fin de chaine */
/* Concatenates character strings, removes leading and trailing blanks,
 and inserts separators */

 a1 = catx('-',x,y,z) ;
 a2 = catx('-','Pays','  FR  ','2009');
 a3 = catx('-','Pays',y,z);
 a4 = 'Pays-FR-2009';
 cas="Cas 3";
 output;

/* Garder tous les blancs */
/* Concatenates character strings without removing leading or trailing blanks  */

 a1 = cat(x,y,z) ;
 a2 = cat('Pays','  FR  ','2009');
 a3 = cat('Pays',y,z);
 a4 = 'Pays  FR  2009';
 cas="Cas 4";
 output;

/* Enlever les blancs de fin uniquement */
/* Concatenates character strings and removes trailing blanks  */

 a1 = catt(x,y,z) ;
 a2 = catt('Pays','  FR  ','2009');
 a3 = catt('Pays',y,z);
 a4 = 'Pays  FR2009';
 cas="Cas 5";
 output;
run;

/* ****************************************** */
/* Site : http://www.formations-sas.fr - 2009 */
/* Auteur : Pascal MAUBERT                    */
/* ****************************************** */

A vos claviers !

Ou copier / coller directement dans votre fenêtre programme SAS.

Programme Exemple SAS : Extraction Aléatoire sans Doublon

La problématique est la suivante, réaliser une pannélisation, pour des raisons de performance.

Afin d’appliquer un modèle prédictif sur une représentation limitée de population, ou afin d’optimiser les performance lors de l’écriture de programme SAS en effectuant des tests sur une petite portion d’une base de données, nous avons la possibilité avec le système SAS de réaliser très simplement une extraction de données, de type aléatoire et bien sur, cerise sur le gâteau : sans doublons.

Dans le programme SAS suivant, il vous suffit de renseigner les macros variables, entre le signe ‘=’ et le signe ‘;’ : PCT, contenant le pourcentage de lignes de la table à extraire et DS1, donnez lui le nom complet de la table SAS source, soit libname.tablename, ensuite lancer le programme SAS et voilà c’est tout.

Programme exemple SAS : Extraction aléatoire sans doublon.


/***  Pourcentage d'observations à garder ***/
* - - - - - - - - - - A modifier - - - - - - - - *
%let pct=20;	           /***  <=== PCT A modifier       ***/
%let ds1=ia.employee_data; /***  <=== Table SAS A modifier ***/
* - - - - - - - - - - A garder - - - - - - - - - *
data extraction(drop=nombre_aleatoire indice_depl nb_ligne_out d1 pct nb rc);
/* Combien d'observations dans la table sas. */
  if _n_ = 1 then do;
    d1=open("&ds1");
    nb=attrn(d1,'nobs');
    if d1 then rc=close(d1);
  end;

/* Préparation à l'extraction des données SAS */
  pct=input(symget('pct'),2.2);
  pointer=0;
  nb_ligne_out=nb * pct;

/* Boucle d'extraction */
  do while(nb_ligne_out > 0);
    pointer+1;
    nombre_aleatoire=ranuni(0);
    indice_depl=nb_ligne_out / (nb - pointer);
    if nombre_aleatoire < indice_depl then do;
      set &ds1 point=pointer;
      output;
      nb_ligne_out=nb_ligne_out-1;
    end;
  end;
stop;
run;

Ce code SAS, peut être utilisé avec SAS BASE, avec SAS Macro, avec SAS enterprise Guide (SEG). Des exemples (outils) comme celui-ci sont fournis lors de nos formations/stages.