Coup de pouce pour faire une requête

Version imprimable

11/04/2012, 13h49
Rymaya

Coup de pouce pour faire une requête
Bonjour,

voilà je reviens vers vous afin de m'aider à trouver une solution,je rencontre un soucis qui me bloque:
J'ai une table sous ce format
```
AVT   INDEX  LOGIC_CODE   CODE
---- ------ ----------- ------
AVT1      1           &      9
AVT2      1           &     10
AVT3      1           &     11
AVT1      2           &     12
AVT2      2           &     13
AVT2      3           |     14
```
Par défaut, le champ "INDEX" est renseigné à « 1 » lorsqu’il n’y a qu’un seul déclencheur, ce champ est incrémenté de 1 à chaque fois qu’un nouveau déclencheur.
Le champs LOGIC_CODE pourra être sois « & » : opérateur logique ET ou
« | » : opérateur logique OU
Le champs code c'est le code de déclencheur
alors nous avons : AVT1 a deux déclencheurs : 9 & 12
AVT2 a troix déclencheurs: 10 & 13 | 14
AVT3 a un seul déclencheur :11

je voudrais faire une requête qui me permet d'avoir mes données sous ce format
```
AVT     9  LO1    10  LO2  11  LO3  12  LO4  13  LO5  14  LO6
-----   --- ---- --- ---- --- ---- ---  ----   ---  ---- --- ----
AVT1    1    &     0     0    0     0     1     0     0     0    0     0                                         
AVT2    0    0     1     &    0     0     0    0     1     |    1     0                                        
AVT3    0    0     0     0    1     0     0    0     0     0    0     0                                                    
```
je sais pas quoi faire? avez vous une idée?
Merci d'avance.

Vous pouvez faire une jointure et un pivot.
Par contre, ça ne fonctionne pas de manière dynamique :

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
With MaTable (AVT, IDX, LOGIC_CODE, CODE) as
(
select 'AVT1', 1, '&',  9 from dual union all
select 'AVT2', 1, '&', 10 from dual union all
select 'AVT3', 1, '&', 11 from dual union all
select 'AVT1', 2, '&', 12 from dual union all
select 'AVT2', 2, '&', 13 from dual union all
select 'AVT2', 3, '|', 14 from dual
)
  select t1.AVT
       , coalesce(max(case t1.CODE when  9 then '1'           end), '0') as "9"
       , coalesce(max(case t1.CODE when  9 then t2.LOGIC_CODE end), '0') as LO1
       , coalesce(max(case t1.CODE when 10 then '1'           end), '0') as "10"
       , coalesce(max(case t1.CODE when 10 then t2.LOGIC_CODE end), '0') as LO2
       , coalesce(max(case t1.CODE when 11 then '1'           end), '0') as "11"
       , coalesce(max(case t1.CODE when 11 then t2.LOGIC_CODE end), '0') as LO3
       , coalesce(max(case t1.CODE when 12 then '1'           end), '0') as "12"
       , coalesce(max(case t1.CODE when 12 then t2.LOGIC_CODE end), '0') as LO4
       , coalesce(max(case t1.CODE when 13 then '1'           end), '0') as "13"
       , coalesce(max(case t1.CODE when 13 then t2.LOGIC_CODE end), '0') as LO5
       , coalesce(max(case t1.CODE when 14 then '1'           end), '0') as "14"
       , coalesce(max(case t1.CODE when 14 then t2.LOGIC_CODE end), '0') as LO6
    from MaTable t1
         left outer join MaTable t2
           on t2.avt = t1.avt
          and t2.idx = t1.idx + 1
group by t1.AVT
order by t1.AVT asc;
 
AVT  9 LO1 10 LO2 11 LO3 12 LO4 13 LO5 14 LO6
---- - --- -- --- -- --- -- --- -- --- -- ---
AVT1 1 &   0  0   0  0   1  0   0  0   0  0   
AVT2 0 0   1  &   0  0   0  0   1  |   1  0   
AVT3 0 0   0  0   1  0   0  0   0  0   0  0

Un début d'aide car le résultat est différent (différencier les cas uniques, les cas de début de clause et de fin de clause [le 1& de avt1 est différent du |1 du avt3])

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
WITH t AS (SELECT 'AVT1' avt, 1 INDX, '&' logic_code,  9 code FROM dual
UNION ALL SELECT 'AVT2' avt, 1 INDX, '&' logic_code, 10 code FROM dual
UNION ALL SELECT 'AVT3' avt, 1 INDX, '&' logic_code, 11 code FROM dual
UNION ALL SELECT 'AVT1' avt, 2 INDX, '&' logic_code, 12 code FROM dual
UNION ALL SELECT 'AVT2' avt, 2 INDX, '&' logic_code, 13 code FROM dual
UNION ALL SELECT 'AVT2' avt, 3 INDX, '|' logic_code, 14 code FROM dual)
SELECT avt, 
		MAX(DECODE(code, 9, 1, 0)) I9, NVL(MAX(DECODE(code, 9, logic_code, '')),'0') LO1,
     MAX(DECODE(code, 10, 1, 0)) I10, NVL(MAX(DECODE(code, 10, logic_code, '')),'0') LO2,
     MAX(DECODE(code, 11, 1, 0)) I11, NVL(MAX(DECODE(code, 11, logic_code, '')),'0') LO3,
     MAX(DECODE(code, 12, 1, 0)) I12, NVL(MAX(DECODE(code, 12, logic_code, '')),'0') LO4,
     MAX(DECODE(code, 13, 1, 0)) I13, NVL(MAX(DECODE(code, 13, logic_code, '')),'0') LO5,
     MAX(DECODE(code, 14, 1, 0)) I14, NVL(MAX(DECODE(code, 14, logic_code, '')),'0') LO6
FROM t
GROUP BY avt

Code:

1
2
3
4
AVT	I9	LO1	I10	LO2	I11	LO3	I12	LO4	I13	LO5	I14	LO6
AVT1	1	&	0	0	0	0	1	&	0	0	0	0
AVT2	0	0	1	&	0	0	0	0	1	&	1	|
AVT3	0	0	0	0	1	&	0	0	0	0	0	0

11/04/2012, 15h43
Rymaya

Merci infiniment pour vos réponses.

je voudrais le faire dynamiquement,que puis je faire?
11/04/2012, 16h17
al1_24

Il faut générer la requête à partir d'un langage applicatif... qui peut être du SQL procédural.
11/04/2012, 16h45
Scriuiw

Comme al1_24, tu peux faire une génération dynamique de la requête SQL de Waldar et/ou MCM et l'exécuter via du PL/SQL
11/04/2012, 17h44
Rymaya

Avez vous un exemple ?
11/04/2012, 18h38
skuatamad

Un exemple sur scott avec 2 techniques, une en 11gr2 (listagg) et l'autre pour les versions précédentes :
http://www.developpez.net/forums/d11...g/#post6206926
Et le même exemple mais avec création d'une procédure stockée :
http://www.developpez.net/forums/d11...g/#post6310887
12/04/2012, 09h31
Rymaya

Merci beaucoup :)