Discussion :

[samgratt]

RE-bonjour.
Je vais aujourd'hui vous soumettre un petit problème de CASE, dans sa partie que j'appellerais "SWITCH/CASE". Je m'esssssplique ; nous savons qu'il est possible d'utiliser les case de différentes manières, notament en externailsant la condition (à la manière d'un switch donc) ;

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
CASE <VALEUR>
WHEN '1' THEN ...
WHEN '2' THEN ...
...
WHEN N THEN ...
END AS <ALIAS>

Il est possible d'imbriquer des CASE entre eux de la même manière ;

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
CASE <VALEUR>
WHEN '1' THEN 
         (CASE <AUTREVALEUR> 
          WHEN 
          WHEN 
          ... 
          WHEN N THEN ...
          END)
WHEN '2' THEN ...
...
WHEN N THEN ...
END AS <ALIAS>

Mais ce que je ne parvient pas à faire c'est ;

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
CASE <VALEUR>
WHEN '1' OR '2' OR '3' THEN ...
WHEN '2' THEN ...
...
WHEN N THEN ...
END AS <ALIAS>

J'ai essayé tout ça ;

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
WHEN '1' OR '2' OR '3' THEN ...
WHEN IN ('1','2','3') THEN ...
WHEN '1','2','3' THEN

...

Mais rien ne semble fonctionner.
Auriez vous une idée ?

[Cybher]

salut,

comme ceci par exemple ?:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
case
when <valeur> in (1,2) then ...
when <valeur> in (3,4) then ...
else ....
end

[samgratt]

Tout à fait, le problème que je rencontre (qui n'est pas vraiment un problème puisqu'en attendant de trouver mieux j'utilise la solution que tu décris et qui fonctionne) c'est que <valeur> est un ensemble de REPLACE de NVL de TRIM de RPAD et d'une fonction perso qui n'est pas des plus légères on va dire ...
En gros, c'est long.
En terme de "charge" de calcul j'en déduis que

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
CASE <VALEUR CALCULEE> ...
WHEN ...
WHEN ...
WHEN ...
...
END
est plus performant/léger que 
CASE WHEN <VALEUR CALCULEE> THEN ...
WHEN <VALEUR CALCULEE> THEN ...
WHEN <VALEUR CALCULEE> THEN ...
...
END

Non ?

[pacmann]

Salut !

Tout à fait.
D'ailleurs, un petit test (je suppose que tu es sous Oracle, vu le nvl)
...

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
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
45
46
47
48
49
50
 
SQL> set autot traceonly statistics
SQL> select case (select count(*) from dba_objects a cross join dba_objects b)
  2                when 1 then 1 when 2 then 1
  3                when 4 then 2 when 5 then 2
  4                when 10 then 3 when 20 then 3
  5                when 30 then 4 when 60 then 4
  6                when 1000 then 5 when 20000 then 5
  7              else 0
  8        end
  9  from dual;
 
 
Statistics
----------------------------------------------------------
         14  recursive calls
          0  db block gets
  137199131  consistent gets
          0  physical reads
          0  redo size
        573  bytes sent via SQL*Net to client
        499  bytes received via SQL*Net from client
          2  SQL*Net roundtrips to/from client
          0  sorts (memory)
          0  sorts (disk)
          1  rows processed
 
SQL> select case when (select count(*) from dba_objects a cross join dba_objects b) in (1, 2) then 1
  2              when (select count(*) from dba_objects a cross join dba_objects b) in(4, 5) then 2
  3              when (select count(*) from dba_objects a cross join dba_objects b) in(10, 20) then 3
  4              when (select count(*) from dba_objects a cross join dba_objects b) in(30, 60) then 4
  5              when (select count(*) from dba_objects a cross join dba_objects b) in(1000, 20000) then 5
  6              else 0
  7        end
  8  from dual;
 
 
Statistics
----------------------------------------------------------
         70  recursive calls
          0  db block gets
  685995645  consistent gets
         30  physical reads
          0  redo size
        654  bytes sent via SQL*Net to client
        499  bytes received via SQL*Net from client
          2  SQL*Net roundtrips to/from client
          0  sorts (memory)
          0  sorts (disk)
          1  rows processed

Maintenant, on est bien d'accord que les deux formes sont équivalentes :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
CASE valeur WHEN 1 THEN ...
	WHEN 2 THEN 
	WHEN 3 THEN...
END

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
CASE WHEN valeur IN (1, 2, 3) THEN ...
END

Maintenant, si tu trouves vraiment un exemple où tu ne peux faire autrement et que c'est vraiment handicapant pour les perfs, tu peux factoriser le calcul :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
WITH t AS
(SELECT /*+materialize*/ id, CalculQuiTue as val
FROM TaTable
WHERE ...)
SELECT CASE WHEN CalculQuitue IN ... END
FROM TaTable a join t ON a.id = t.id

[samgratt]

Désolé de ne pas être venu depuis tout ce temps là sur le forum.
J'avais du désactiver l'alerte par mail en cas de réponse sans doute ...
Bref, merci.
Effectivement, j'ai utilisé la méthode qui détaille les 150 000 possibilités ;
au lieu de faire des IN (), je décompose en autant de When qu'il y a de valeurs dans le in ...
Ça fonctionne, et en regardant ta solution je m'interpelle, je dois être un mauvais SQL man, parce que j'ai même pas pensé à cette solution.

Ah et aussi, désolé de ne pas avoir mis RESOLU.