Créer autant de tables qu'il n'y a de modalités d'une variable : le nombre de modalités étant évolutif

[ludo35]

Bonjour.

Voila mon problème: ma table contient plusieurs variables dont celle qui nous interesse ici "sdeliverycode".

exemple de sdeliverycode:

abc-de-27042010-azert
abc-de-27032010-azert
abc-de-27022010-qsdfg
......

je souhaite crée une table pour chaque "groupe" (ici premier groupe "azert" deuxieme "qsdfg"

Pour cela, j'utilise un substr:

Code :

1
2
attrib label FORMAT=$72.;
label=substr(sdeliverycode,17,5);

mais voila, je ne sais pas comment faire une boucle pour créer autant de table qu'il n'y a de "groupe" dans la table.
En gros il faudrait dire que si label est different de label-1, alors on créer un nouveau groupe/une nouvelle table, etc...

je sais pas si j'ai été assez claire

merci de votre aide!

[Manoutz]

Voici un moyen de sélectionner les différents valeurs prises par ta sous-chaine de caractère.

Code :

1
2
3
4
5
proc sql;
CREATE TABLE severalstring AS
SELECT DISTINCT substr(sdeliverycode,17,5) AS substring
FROM tableorig;
quit;

reste à voir ce que tu veux en faire; la syntaxe peut évoluer.

Quel est le but de la boucle?

[ludo35]

merci de ton aide.

Le but est d'avoir une table par sdeliverycode semblables (même fin de code).

Pour revenir a mon exemple il faudrait une table contenant:
abc-de-27042010-azert
abc-de-27032010-azert

une autre contenant:
abc-de-27022010-qsdfg

La table à partir de laquelle je travaille est évolutive donc si de nouveaux individus sont ajoutés il faut que de nouvelles tables soient créées à chaque fois (pour les groupes qui n'existent pas déjà), par exemple:
abc-de-07112010-yuiop

Y a-t-il possibilité de faire cela?

[Manoutz]

Oui, c'est possible. Lorsque tu as une mise à jour, les données sont elles ajoutées à la table contenant déjà les informations ou s'agit-il d'une nouvelle table?

[ludo35]

Lors d'une mise à jour, les données sont ajoutées à la table contenant déjà les informations !

[olivier.decourt]

Bonjour Ludo.
Il y a deux solutions (au minimum) : soit avec du langage macro (récupérer les valeurs distinctes comme propose Manoutz + les mettre en macro-variables avec CALL SYMPUT + boucle macro pour générer toutes les tables), soit avec un hash table, ce qui suppose une programmation incompréhensible comme ci-dessous.

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
PROC SORT DATA=sashelp.shoes OUT=work.shoes ;
  BY product ;
RUN ;
DATA _NULL_ ;
	DECLARE HASH hid (ORDERED: "A") ; /* les données sont triées */
	hid.DEFINEKEY ("_N_") ; /* l'identifiant est le n° de ligne. Aucun intérêt mais il en faut un */
	hid.DEFINEDATA ("region", "subsidiary", "sales", "stores", "inventory", "returns") ; 
	/* variables conservées dans le résultat */
	hid.DEFINEDONE () ;
	DO _N_ = 1 BY 1 UNTIL ( LAST.product ) ;
		SET work.shoes ;
		BY product ; /* on lit les données par bloc */
	    hid.ADD() ;
	END ;
	hid.OUTPUT (DATASET: "work."!!TRANSLATE(STRIP(product),"____"," '.-")) ; 
	/* on crée une table en sortie qui s'appelle comme la valeur de PRODUCT, modulo l'élimination des caractères spéciaux */
RUN ;

A toi de voir à quel endroit et à quel niveau tu veux de la difficulté : longueur du code ou clarté des opérations ?
Bon courage.
Olivier

[Manoutz]

La version "classique":

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
DATA  tableorig;
input  sdeliverycode $50.;
cards;
abc-de-27042010-azert
abc-de-27032010-azert
abc-de-27022010-qsdfg
abc-de-07112010-yuiop
;run;
proc sql noprint; 
SELECT DISTINCT substr(sdeliverycode,17,5) INTO :listtab separated BY " "
FROM tableorig;
CREATE TABLE listtab AS
SELECT DISTINCT substr(sdeliverycode,17,5) AS code
FROM tableorig;
quit;
 
DATA _null_;
SET listtab;
call symput("code"||compress(put(_n_,3.)), code);
call symput("nbcode",put(_n_,3.));
run;
%macro manageoutput;
DATA &listtab ;
SET tableorig;
%do i=1 %TO  &nbcode.;
IF substr(sdeliverycode,17,5)="&&code&i." then output &&code&i.;
%end;
run;
 
%mend manageoutput;
%manageoutput;

Tu peux expliquer le principe Olivier?

[s_a_m]

je ne sais pas si t'es familiarisé avec la technique de hachage:

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
 
DATA test;
	INFILE cards;
	input var $22.;
	var1=scan(var,-1,'-');
	cards;
abc-de-27042010-azert
abc-de-27032010-azert
abc-de-27022010-qsdfg
abc-de-27042010-azert
abc-de-27032010-azert
abc-de-27022010-qsdfg
abc-de-27042010-azert
abc-de-27032010-azert
abc-de-27022010-qsdfg
abc-de-27042010-rtyyi
abc-de-27032010-khjhl
abc-de-27022010-okjiy
;
run;
 
proc Sort DATA =test;
	BY var1;
run;
 
DATA _null_;
	dcl hash hh   (             );
	hh.definekey  ('k'          );
	hh.definedata ('var1', 'var');
	hh.definedone ();
 
	do k = 1 BY 1 until ( last.var1 );
		SET test;
		BY var1;
		hh.ADD ();
	end;
 
	hh.output (dataset: var1);
run;

[s_a_m]

Ops!! Olivier a déjà répondu.

[Manoutz]

Alors, qui se lance dans une petite explication du hash?

[olivier.decourt]

Allez, je m'y colle : le principe de la table "de hachage" (hash table, la traduction est de toute façon difficile) est de charger des données en mémoire vive (toute une série d'observations à la fois) de manière à pouvoir se balader dedans de manière instantanée ou presque. On évite avec cet objet la lecture séquentielle d'un SET.
Ca rejoint l'idée de lire une table indexée (SET KEY) d'autant que l'objet hash doit avoir une clé d'accès (l'équivalent de la variable indexée : SAS sait où trouver chaque valeur de cette clé).
Par rapport à un SET KEY, l'avantage est qu'on peut appliquer à cet objet la méthode OUTPUT dont l'argument (le nom d'une table SAS dans laquelle on déverse tout le contenu de la table de hachage) peut être calculé sur le vif. On peut donc piloter le nom de la table créée en fonction des valeurs d'une variable en les découvrant au fur et à mesure.

A ce concept un peu spécial de table de hachage s'ajoute la boucle autour du SET, qui n'est qu'une autre manière d'écrire une lecture par blocs. Voici la version plus classique où on voit mieux les initialisations, les ajouts au hash et l'écriture dans la table en sortie.

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
PROC SORT DATA=sashelp.shoes OUT=work.shoes ;
  BY product ;
RUN ;
DATA _NULL_ ;
    SET work.shoes ;
    BY product ; /* on lit les données par bloc */
	RETAIN id ;
	IF FIRST.product THEN DO ;
	  id=0 ;
      DECLARE HASH hid (ORDERED: "A") ; /* les données sont triées */
      hid.DEFINEKEY ("id") ; /* l'identifiant est le n° de ligne. Aucun intérêt mais il en faut un */
      hid.DEFINEDATA ("region", "subsidiary", "sales", "stores", "inventory", "returns") ;
      /* variables conservées dans le résultat */
      hid.DEFINEDONE () ;
    END ;
	id = id + 1 ;
    hid.ADD() ;
	IF LAST.product THEN
    hid.OUTPUT (DATASET: "work."!!TRANSLATE(STRIP(product),"____"," '.-")) ;
    /* on crée une table en sortie qui s'appelle comme la valeur de PRODUCT, modulo l'élimination des caractères spéciaux */
RUN ;

PS : Je peux dézipper encore un peu mon propos s'il reste des points obscurs.

[s_a_m]

Envoyé par Manoutz

Alors, qui se lance dans une petite explication du hash?

Manoutz, le fonctionnement a le même principe que les array ( tableux ou victeurs), c'est de travailler en memoire.
Je te laisse jeter un coup d'oeil sur les liens suivant:
French : http://www.monsug.ca/event12/Hash%20object.pdf

English:

http://support.sas.com/rnd/base/data...-tip-sheet.pdf
http://analytics.ncsu.edu/sesug/2006/SC19_06.PDF
http://www.sas.com/offices/NA/canada...s_Function.pdf

http://www2.sas.com/proceedings/sugi30/236-30.pdf

et si vous permettez, j'ajoutes cette sollution, assez simple mais qui permet d'éviter le problème de longueur de macro variable récupérer avec l'INTO de la proc sql; je suppose ici que ludo35

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
 a un nombre assez important de groupes et donc de TABLES en sortie. Enfin pas raisonable mais bon.:aie:
 
 
 
DATA test;
INFILE cards;
input var $22.;	 var1=scan(var,-1,'-');
cards;
abc-de-27042010-azert
abc-de-27032010-azert
abc-de-27022010-qsdfg
abc-de-27042010-azert
abc-de-27032010-azert
abc-de-27022010-qsdfg
abc-de-27042010-azert
abc-de-27032010-azert
abc-de-27022010-qsdfg
abc-de-27042010-rtyyi
abc-de-27032010-khjhl
abc-de-27022010-okjiy
;
run;
 
 
%macro decouper(grp);
  DATA tab_&grp;
    SET test(WHERE=(var1="&grp"));
  run;
%mend decouper;
%macro appel;
  proc sort DATA=test(keep=var1) out=groupes nodupkey;
    BY var1;
  run;
  %LOCAL i nbr_grp;
  DATA _null_;
    SET groupes end=fin;
    call symput("condition"||LEFT(_n_),var1);
    IF fin then call symput("nbr_grp",_N_);
  run;
  %do i=1 %TO &nbr_grp;
    %decouper(&&condition&i) ;
  %end;
%mend ;
%appel;

[MEGAMIND2]

Bonjour,
Je te propose une autre approche avec des macros

Code :

1
2
3
4
5
6
7
8
9
10
11
12
DATA tab;
input var $50.;
new_var=scan(compress(var),-1,"-");
cards;
abc-de-27042010-azert
abc-de-27032010-azert
abc-de-27022010-qsdfg
;
run; 
proc sort DATA=tab nodupkey out=out;
BY new_var;
run;

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
%MACRO MYMACRO;				
	DATA _NULL_;
		SET OUT END =EOF;
		IF EOF THEN CALL SYMPUT("nb_tab",_n_);
		CALL SYMPUT("new_var"!!LEFT(_n_),new_var);
	RUN;	
	%DO i=1 %TO &nb_tab.;
		DATA &&new_var&i.;
			SET tab;
			IF new_var="&&new_var&i";
			DROP new_var;
		RUN; 
	%END;	 
%MEND MYMACRO; 
%MYMACRO;

ps: même idée que Sam, oops

[olivier.decourt]

Juste une variante des solutions de SAM et Brice : comme dans le programme de Manoutz, on ne lit qu'une fois la table d'origine pour créer les X nouvelles tables. Il faut déjà la lire une fois pour récupérer les valeurs distinctes, alors si elle est de grande taille, autant éviter de repasser dedans en permanence.
Ici, on tire parti d'un tri préalable des valeurs par fréquence décroissante pour optimiser les conditions de ventilation des observations dans les nouvelles tables avec un SELECT WHEN.
Dernière chose : dans le cas de Ludo, la variable à tester est de type caractère, mais ici on prévoit aussi le cas d'une variable numérique, histoire d'avoir un code robuste.

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
%MACRO explose (TABLE, variable) ;
	ODS EXCLUDE ALL ;
	ODS OUTPUT oneWayFreqs=work.valeurs ;
	PROC FREQ DATA=&TABLE ORDER=FREQ ;
	  TABLES &variable ;
	RUN ;
	ODS SELECT ALL ;
	DATA _NULL_ ;
	  SET work.valeurs NOBS=n ;
	  IF _N_=1 THEN CALL SYMPUTX("nbVal",n) ;
	  IF VTYPE(&variable)="C" THEN DO ;
		  CALL SYMPUTX(CATS("val",_N_), QUOTE(STRIP(&variable))) ;
		  CALL SYMPUTX(CATS("tab",_N_), "work."!!TRANSLATE(STRIP(&variable),"___"," '-")) ;
	  END ;
	  ELSE DO ;
		  CALL SYMPUTX(CATS("val",_N_), &variable) ;
		  CALL SYMPUTX(CATS("tab",_N_), "work._"!!STRIP(&variable)) ;
	  END ;
	RUN ;
	DATA %DO i=1 %TO &nbVal ; &&tab&i %END ; ;
	  SET &TABLE ;
	  SELECT (&variable) ;
	   %DO i=1 %TO &nbVal ;
	     WHEN (&&val&i) OUTPUT &&tab&i ;
	   %END ;
	   OTHERWISE ;
	  END ;
	RUN ;
%MEND explose ;

A tester par exemple avec

Code :

1
2
%explose (sashelp.class, sex) ;
%explose (sashelp.class, age) ;

[MEGAMIND2]

Trop compliqué pour moi,

[ludo35]

Merci à tous pour vos solutions.

J'ai utilisé la méthode proposée par Manoutz et ça marche.

Cependant, je suis maintenant confronté à un autre problème:
Les tables créées se nomment par exemple "azert" ou "qsdfg"
(cf exemple premier post).

Ce que je voudrais maintenant, c'est qu'elles se nomment par exemple "abcazert", "defgsdfg", ... en fonction d'une variable "catégorie" de la même table d'origine contenant :
abc
def
(on ne trouvera pas de "abcgsdfg" par exemple, chaque catégorie contient des codes différents)


La variable "catégorie" contient quatre modalités:
abc
def
ghi
jkl

[Manoutz]

J'en déduit qu'a chaque code correspond une unique variable "catégorie".

remplace tout simplement substr(sdeliverycode,17,5) par substr(sdeliverycode,1,3)||substr(sdeliverycode,17,5)

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
DATA  tableorig;
input  sdeliverycode $50.;
cards;
abc-de-27042010-azert
abc-de-27032010-azert
abc-de-27022010-qsdfg
abc-de-07112010-yuiop
;run;
proc sql noprint; 
SELECT DISTINCT substr(sdeliverycode,1,3)||substr(sdeliverycode,17,5) INTO :listtab separated BY " "
FROM tableorig;
CREATE TABLE listtab AS
SELECT DISTINCT substr(sdeliverycode,1,3)||substr(sdeliverycode,17,5) AS code
FROM tableorig;
quit;
 
DATA _null_;
SET listtab;
call symput("code"||compress(put(_n_,3.)), code);
call symput("nbcode",put(_n_,3.));
run;
%macro manageoutput;
DATA &listtab ;
SET tableorig;
%do i=1 %TO  &nbcode.;
IF substr(sdeliverycode,1,3)||substr(sdeliverycode,17,5)="&&code&i." then output &&code&i.;
%end;
run;
 
%mend manageoutput;
%manageoutput;

[ludo35]

parfait , ça fonctionne

derniere étape, maintenant que j'ai toutes mes tables bien comme il faut:

les tables contiennent des colonnes de chiffres sur lesquelles je veux ajouter la somme en dernière ligne, pour cela je passe par une proc sql:

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
proc sort DATA=abcazert;
	BY tsbroadstart;
run;
 
PROC SQL;
CREATE TABLE somme AS SELECT SUM(itodeliver) AS itodeliver, 
								SUM(iprocessed) AS iprocessed, 
								SUM(isuccess) AS isuccess,
								((SUM(isuccess)/SUM(iprocessed))*100) AS successpourcent,
								SUM(irecipientopen) AS irecipientopen,
								((SUM(irecipientopen)/SUM(isuccess))*100) AS ouverturespourcent,
								SUM(itotalrecipientopen) AS itotalrecipientopen,
								SUM(ioptout) AS ioptout,
								((SUM(ioptout)/SUM(isuccess))*100) AS desinscriptionspourcent,
								SUM(ipersonclick) AS ipersonclick,
								((SUM(ipersonclick)/SUM(isuccess))*100) AS clicsdistinctspourcent,
								SUM(itotalrecipientclick) AS itotalrecipientclick,
								((SUM(ipersonclick)/SUM(irecipientopen))*100) AS reactivite,
								SUM(ireject) AS ireject,
								SUM(inewquarantine) AS inewquarantine,
								((SUM(inewquarantine)/SUM(isuccess))*100) AS quarantainepourcent,
								SUM(imirrorpage) AS imirrorpage,
								((SUM(imirrorpage)/SUM(isuccess))*100) AS mirroirpourcent,
								SUM(iforward) AS iforward,
								((SUM(iforward)/SUM(isuccess))*100) AS transfertspourcent
FROM abcazert;
QUIT;
 
 
DATA tableauavecsommeabcazert;
SET abcazert somme;
IF sdeliverycode="" then sdeliverycode="Totaux";
run;

Comment faire pour qu'il le fasse pour toutes les tables ? (macro et boucle sans doute...mais j'ai du mal)

[Manoutz]

pourquoi pas proc univariate ou proc means?

[ludo35]

parce que j'ai des variables caractères à garder...mais peut-être que c'est quand même possible avec proc means ou proc univariate ?