Bonjour à tous,

j'aimerais optimiser une requête qui prend énormément de temps, environ 30 minutes alors qu'elle n'insère que 120 000 enregistrements. Voilà la requête en question :

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
 
insert into int_session (id_session, dat_deb, heure_deb, minute_deb, dat_crea,
                         origine_session, id_interne_individu, IP, ORI_IP)
   (select Id_session,trunc(min(date_hit),'dd'),to_char(min(date_hit), 'HH24'),
           to_char(min(date_hit),'MI'), max(sysdate),max(origine_session),
           max(nvl(id_interne_individu,0)),max(a.IP),999
      from imp_navigation a
        where status='N'
         and exists (select '*' from int_individu e
                     where nvl(a.id_interne_individu,0) = e.id_interne_individu and e.flag_supp = 0)
         and not exists (select '*' from int_session b where a.id_session = b.id_session)
         and not exists (select '*' from INT_ORI_IP b where a.IP = b.IP )
       group by id_session);
Je pense donc que le temps perdu se situe au niveau de l'insert. Pourtant sémantiquement c'est mieux de faire un insert de 1000 lignes que 1000 inserts d'une ligne.

Au niveau des volumétries :
* imp_navigation :~1Million
* int_session : ~5Millions
* int_individu : ~220 000
* INT_ORI_IP : 7

Au niveau des index j'ai :
* imp_navigation (status)
* - int_session(id_session)
- int_session(origine_session, id_session)
- int_session(date_deb, id_interne_individu, id_session)
* INT_ORI_IP(ip)
* int_individu(id_interne_individu, flag_supp)

J'ai également essayer de changer ma requête sans faire de sous requetes mais des left outer join, mais le gain est nul :'(. Voici la requête modifiée :
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
 
select
   a.Id_session,
   trunc(min(a.date_hit),'dd'),
   to_char(min(a.date_hit), 'HH24'),
   to_char(min(a.date_hit),'MI'),
   max(sysdate),
   max(a.origine_session),
   max(nvl(id_interne_individu,0)),
   max(a.ip),
   999
  from
   imp_navigation a
  left outer join int_individu e on
   e.id_interne_individu = nvl(a.id_interne_individu, 0) and
   e.flag_supp = 0
  left outer join int_session b on
   b.id_session = a.id_session
  left outer join int_ori_ip c on
   c.ip = a.ip
  where
   a.status='N' and
   e.id_interne_individu is not null and
   b.id_session is null and
   c.ip is null
  group by
    a.id_session
Bref, je sèche complètement et je pense qu'une requête de 30 minutes doit pouvoir être optimisée (surtout pour n'insérer que 120000 lignes). Existe t'il une méthode afin d'améliorer la vitesse d'insertion ?

Merci d'avance à tous

EDIT: M -> Million