Bonjour,

j'ai besoin d'aide et de conseil concernant cette aimable clause having tout à fait spéciale. Pour partir sur une base commune :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
CREATE TABLE TABLE_TEST(ID NUMBER, GROUPEMENT VARCHAR2(30), INDICATEUR NUMBER, INDICE NUMBER);
 
INSERT INTO TABLE_TEST VALUES(1,'A',10,1);
INSERT INTO TABLE_TEST VALUES(2,'A',20,1);
INSERT INTO TABLE_TEST VALUES(3,'A',30,1);
INSERT INTO TABLE_TEST VALUES(4,'A',40,1);
INSERT INTO TABLE_TEST VALUES(5,'B',100,1);
INSERT INTO TABLE_TEST VALUES(6,'B',200,2);
INSERT INTO TABLE_TEST VALUES(7,'B',300,1);
INSERT INTO TABLE_TEST VALUES(8,'B',400,2);
INSERT INTO TABLE_TEST VALUES(9,'C',1000,1);
INSERT INTO TABLE_TEST VALUES(10,'C',2000,2);
INSERT INTO TABLE_TEST VALUES(11,'C',3000,3);
INSERT INTO TABLE_TEST VALUES(12,'C',4000,4);

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
SQL> select * from TABLE_TEST;
 
        ID GROUPEMENT                     INDICATEUR     INDICE
---------- ------------------------------ ---------- ----------
         1 A                                      10          1
         2 A                                      20          1
         3 A                                      30          1
         4 A                                      40          1
         5 B                                     100          1
         6 B                                     200          2
         7 B                                     300          1
         8 B                                     400          2
         9 C                                    1000          1
        10 C                                    2000          2
        11 C                                    3000          3
        12 C                                    4000          4
L'idée de base est de calculer des agregats de INDICATEUR en fonction des valeurs de GROUPEMENT.
La requête de base serait :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
SQL> select GROUPEMENT, sum(INDICATEUR) from TABLE_TEST group by GROUPEMENT;
 
GROUPEMENT                     SUM(INDICATEUR)
------------------------------ ---------------
A                                          100
B                                         1000
C                                        10000
Cependant les lignes sont marquées par un indicateur de cohérence, le champ INDICE. Ce champ permet de savoir à quel "lot" appartiennent les différentes lignes et donc à ne pas mélanger les lignes entre des lots. L'idée est donc de ne calculer la valeur d'INDICATEUR que pour les groupes qu'on peut qualifier de fiables, donc qui n'ont qu'UNE SEULE valeur d'indice.

Evidemment certains me diront qu'il suffit de faire ça :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
SQL> select GROUPEMENT,INDICE, sum(INDICATEUR) from TABLE_TEST group by GROUPEMENT, INDICE;
 
GROUPEMENT                         INDICE SUM(INDICATEUR)
------------------------------ ---------- ---------------
A                                       1             100
B                                       1             400
B                                       2             600
C                                       1            1000
C                                       2            2000
C                                       3            3000
C                                       4            4000
et qu'on a toutes les sommes par GROUPEMENT et par INDICE, mais je ne vois pas comment, sans rajouter de sur-requête on peut arriver à ce résultat là:
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
SQL> select GROUPEMENT, sum(INDICATEUR) from TABLE_TEST group by GROUPEMENT having count(distinct INDICE)=1;
 
GROUPEMENT                     SUM(INDICATEUR)
------------------------------ ---------------
A                                          100
C'est à dire, ne retourner la somme de INDICATEUR que pour les groupes qui ne possèdent qu'UNE valeur UNIQUE d'INDICE. En effet en regardant les données on s'apperçoit que le GROUPEMENT A est le seul à possèder une valeur unique d'INDICE qui est 1. Les autres REGROUPEMENT possèdent 2 ou 3 valeurs différentes pour INDICE (2 valeurs distinctes d'INDICE pour B et 4 valeurs distinctes d'INDICE pour C).

Alors mon problème maintenant, j'aimerais réaliser la même chose mais sans sur ou sous requêtes, sans having count (distinct) mais avec une sur-couche PL/SQL.

Des idées ? Merci.