Discussion :

[pazair16]

Bonjour, j'ai un problème sur une requête SQL, en effet dans la clause Where me pose problème avec les champs NULL

Mon where ressemble à ça :

Code :

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

Where type <> 'type1' AND type <> 'type2'

Donc je demande que la requête me retourne toute les lignes différente de type1 et type2, le problème est que ça m'exclu également les lignes ou la valeur de Type est vide (NULL) et bien sur j'ai besoin de ces lignes dans mes resultats.

Merci de votre aide.

[lola06]

Bonjour,

Je te conseillerai d'utiliser le NOT IN ici et de rajouter une condition :

Code :

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

1
2
WHERE type NOT IN ('type1','type2')
OR type IS NULL

Par contre j'espère que ton nom de colonne n'est pas type car c'est un mot réservé SQL.

[pazair16]

Non ce n'est pas type mais TYPE_DE_LIEU_1 c'était pour faire cours ^^

Bref j'avais pas mis le Or type is null, mais j'avais trouvé le

Code :

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

Where type NOT IN ('type1','type2')

du coup ça fonctionne parfaitement maintenant, merci beaucoup.

Je passe en résolu

[ojo77]

La solution est en effet de mettre or type is null. par contre je ne suis pas convaincu par les autres arguments :

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
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
SQL> with t1 as ( select 'type1' type, 'toto' c2 from dual
  2     union all select 'type2', 'titi' from dual
  3     union all select 'type3', 'tutu' from dual
  4     union all select null, 'tata' from dual)
  5  select * from t1
  6  where type <> 'type1' AND type <> 'type2' or type is null
  7  /
 
TYPE  C2
----- ----
type3 tutu
      tata
 
 
Plan d''execution
----------------------------------------------------------
Plan hash value: 111080046
 
-------------------------------------------------------------------------
| Id  | Operation        | Name | Rows  | Bytes | Cost (%CPU)| Time     |
-------------------------------------------------------------------------
|   0 | SELECT STATEMENT |      |     4 |    52 |     4   (0)| 00:00:01 |
|   1 |  VIEW            |      |     4 |    52 |     4   (0)| 00:00:01 |
|   2 |   UNION-ALL      |      |       |       |            |          |
|*  3 |    FILTER        |      |       |       |            |          |
|   4 |     FAST DUAL    |      |     1 |       |     2   (0)| 00:00:01 |
|*  5 |    FILTER        |      |       |       |            |          |
|   6 |     FAST DUAL    |      |     1 |       |     2   (0)| 00:00:01 |
|   7 |    FAST DUAL     |      |     1 |       |     2   (0)| 00:00:01 |
|   8 |    FAST DUAL     |      |     1 |       |     2   (0)| 00:00:01 |
-------------------------------------------------------------------------
 
Predicate Information (identified by operation id):
---------------------------------------------------
 
   3 - filter(NULL IS NOT NULL)
   5 - filter(NULL IS NOT NULL)
 
 
Statistiques
----------------------------------------------------------
          0  recursive calls
          0  db block gets
          0  consistent gets
          0  physical reads
          0  redo size
          0  bytes sent via SQL*Net to client
          0  bytes received via SQL*Net from client
          0  SQL*Net roundtrips to/from client
          0  sorts (memory)
          0  sorts (disk)
          2  rows processed
 
SQL> with t1 as ( select 'type1' type, 'toto' c2 from dual
  2     union all select 'type2', 'titi' from dual
  3     union all select 'type3', 'tutu' from dual
  4     union all select null, 'tata' from dual)
  5  select * from t1
  6  where type not in ( 'type1','type2' ) or type is null
  7  /
 
TYPE  C2
----- ----
type3 tutu
      tata
 
 
Plan d''execution
----------------------------------------------------------
Plan hash value: 111080046
 
-------------------------------------------------------------------------
| Id  | Operation        | Name | Rows  | Bytes | Cost (%CPU)| Time     |
-------------------------------------------------------------------------
|   0 | SELECT STATEMENT |      |     4 |    52 |     4   (0)| 00:00:01 |
|   1 |  VIEW            |      |     4 |    52 |     4   (0)| 00:00:01 |
|   2 |   UNION-ALL      |      |       |       |            |          |
|*  3 |    FILTER        |      |       |       |            |          |
|   4 |     FAST DUAL    |      |     1 |       |     2   (0)| 00:00:01 |
|*  5 |    FILTER        |      |       |       |            |          |
|   6 |     FAST DUAL    |      |     1 |       |     2   (0)| 00:00:01 |
|   7 |    FAST DUAL     |      |     1 |       |     2   (0)| 00:00:01 |
|   8 |    FAST DUAL     |      |     1 |       |     2   (0)| 00:00:01 |
-------------------------------------------------------------------------
 
Predicate Information (identified by operation id):
---------------------------------------------------
 
   3 - filter(NULL IS NOT NULL)
   5 - filter(NULL IS NOT NULL)
 
 
Statistiques
----------------------------------------------------------
          0  recursive calls
          0  db block gets
          0  consistent gets
          0  physical reads
          0  redo size
          0  bytes sent via SQL*Net to client
          0  bytes received via SQL*Net from client
          0  SQL*Net roundtrips to/from client
          0  sorts (memory)
          0  sorts (disk)
          2  rows processed

[lola06]

J'utilise personnellement NOT IN pour plusieurs raisons :

- plus lisible et maintenable (avis perso)
--> principale raison pour moi.

- plus optimisé pour mes requêtes
--> attention plus optimisé pour moi ne veux pas forcément dire que c'est pareil pour lui. Ça dépend de beaucoup de choses :
- index
- volume de données
- SGBD
- configuration
- ...

[ojo77]

Je ne suis toujours pas convaincu par l'efficacité en termes de performance, par contre sur la lisibilité je suis parfaitement d'accord avec vous.

En 11.1 :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
drop table t1;
create table t1 ( col1 number, col2 number, col3 number );
 
insert /*+ APPEND */ into t1
select ROWNUM col1
     , decode(MOD(dbms_random.random,1000),1,null,1+ABS(MOD(dbms_random.random,150))) col2
from sys.dual
connect by rownum <=1E5 ;
 
commit;
 
create index t1_idx on t1(col2) ;
exec dbms_stats.gather_table_stats(user, 'T1') ;

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
SQL> set autot traceonly
SQL> select * from t1 where col2 not in ( 1, 3, 5, 7) ;

97211 ligne(s) sÚlectionnÚe(s).


Plan d''exÚcution
----------------------------------------------------------
Plan hash value: 3617692013

--------------------------------------------------------------------------
| Id  | Operation         | Name | Rows  | Bytes | Cost (%CPU)| Time     |
--------------------------------------------------------------------------
|   0 | SELECT STATEMENT  |      | 97173 |   759K|    53   (4)| 00:00:01 |
|*  1 |  TABLE ACCESS FULL| T1   | 97173 |   759K|    53   (4)| 00:00:01 |
--------------------------------------------------------------------------

Predicate Information (identified by operation id):
---------------------------------------------------

   1 - filter("COL2"<>1 AND "COL2"<>3 AND "COL2"<>5 AND "COL2"<>7)


Statistiques
----------------------------------------------------------
          0  recursive calls
          0  db block gets
          0  consistent gets
          0  physical reads
          0  redo size
          0  bytes sent via SQL*Net to client
          0  bytes received via SQL*Net from client
          0  SQL*Net roundtrips to/from client
          0  sorts (memory)
          0  sorts (disk)
      97211  rows processed

Donc dans ce cas de figure le "NOT IN" est transformé an "AND" par le parser.