case when multiple

Version imprimable

case when multiple

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:

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:

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:

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:

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 ?

salut,

comme ceci par exemple ?:

Code:

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

OUI !

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:

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 ?

Salut !

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

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
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:

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

Code:

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:

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

17/11/2009, 15h33
samgratt

Muchas gratias !

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.