Discussion :

[mnitu]

Ca serait le mieux. Mais la problématique des roundtrip / arraysize n'est-elle pas déjà un bon indice ?
Même si tu augmentes l'arraysize, la limite réelle que tu atteins correspond à des problématiques concrète lié au SGBD, et non à du transfert réseau pur.


Au temps pour moi (j'avais une autre idée derrière la tête : pas tant les roundtrips entre client et server, mais entre server et server (distant))

Tout transite par le réseau en utilisant TCP/IP ou autre protocole.

La communication du serveur à serveur dans ce cas c'est un appel client-serveur dans lequel le client serveur A demande au serveur B les données.

Si vous analysez le fichier de trace ce qu’on voit c’est :
Le client serveur A demande des données et il attente.
Il attente
Il attente
Il attente
Il les reçoit il les traite, il redemande et il attente
Il attente
Il attente
Il attente
Il les reçoit il les trait il redemande et il attente …
Pourquoi ce comportement : parce que l’autre serveur n’arrive pas lui fournir plus vite les données. C’est ça qui coince et c’est ça qu’il faut optimiser.

Je suis très curieux dans combien de temps on arrive à faire cette opération sur le serveur B, quelque chose de type

Code :

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

1
2
 
create table T  as select ... from lavue

[Waldar]

J’ai du mal à vous suivre :
Le "problème complexe" :

Code :

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

insert into table select … from table@viadblink

Le "problème simple" :

• Créez un fichier à partir de la requête Select … from table
• Transferer ce fichier via ftp sur l'autre macine
• Charger la table via sqlloader

Complexe au sens multiple (comme les nombres complexes) et simple au sens unitaire.

Code :

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

insert into table select … from table@viadblink

La requête est longue, on voit que les temps d'attente sont longs.
Est-ce du à l'exécution sur la base distante ou à l'architecture du réseau ?

On ne sait pas sur les machines sont côte à côte sur un commutateur Infiniband ou bien sur un VPN avec une distance réelle de 5000 Km et lien dédié à 512 kb/s.

[cornnery]

Hi All ,

merci beaucoup pour vos précieux conseils .

@Mohamed ,

Un merci particulier , car en effet j'ai suivi la piste du

BULK collect

.

Et mes performances se sont "exponentiellement" améliorées le script qui courait indéfiniment me fait environ 40 à 50 minutes pour une insertion d'environ deux millions et quelques lignes.
Ci-dessous mon script final:

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
 
CREATE OR REPLACE PROCEDURE FACTS.proc_fact_moc_mtn AS
--DECLARE
msg        varchar(10000);
p1   varchar(100);
ecode NUMBER;
emesg VARCHAR2(10000);
--TYPE TYP_TAB_EMP IS TABLE OF EMP%Rowtype ;
type type_tab_fact_moc is table of fact_moc%rowtype ;
v_inst_fact_moc type_tab_fact_moc ;
Cursor get_data_from_dblink IS
select /*+ parallel(3) */
	msisdn,
    trafic_date,
    destination,
    traffic_type,
    vas_service,
    account_id,
    total_calls,
    total_revenu_appel,
    total_duree_appel,
    total_volume,
    apn_info,
    extension_code,
    service_class_id,
    location_number,
    service_offerings,
    cell_identity,
    country_code
	from v_fact_moc_mtn@DWS.CG.NET ;
BEGIN
 
----first insertion MTN to MTN
	msg := 'Start first insertion of MTN to MTN traffic in FACT table';
    insert into facts_data_log values('v_fact_moc_mtn',sysdate,msg,0);
	commit;
Open get_data_from_dblink;
loop
Fetch get_data_from_dblink bulk collect INTO v_inst_fact_moc LIMIT 500;
for i in 1..v_inst_fact_moc.count loop
insert /*+ append */ into fact_moc
    (
	msisdn,
	trafic_date,
	destination,
	traffic_type,
	vas_service,
	account_id,
	total_calls,
	total_revenu_appel,
	total_duree_appel,
	total_volume,
	apn_info,
	extension_code,
	service_class_id,
	location_number,
	service_offerings,
	cell_identity,
	country_code
    )
values
(
	v_inst_fact_moc(i).msisdn,
    v_inst_fact_moc(i).trafic_date,
    v_inst_fact_moc(i).destination,
    v_inst_fact_moc(i).traffic_type,
    v_inst_fact_moc(i).vas_service,
    v_inst_fact_moc(i).account_id,
    v_inst_fact_moc(i).total_calls,
    v_inst_fact_moc(i).total_revenu_appel,
    v_inst_fact_moc(i).total_duree_appel,
    v_inst_fact_moc(i).total_volume,
    v_inst_fact_moc(i).apn_info,
    v_inst_fact_moc(i).extension_code,
    v_inst_fact_moc(i).service_class_id,
    v_inst_fact_moc(i).location_number,
    v_inst_fact_moc(i).service_offerings,
    v_inst_fact_moc(i).cell_identity,
    v_inst_fact_moc(i).country_code
);
exit when get_data_from_dblink%notfound;
commit;
end loop;
end loop ;
msg := 'End of first insertion of MTN to MTN traffic in FACT table';
insert into facts_data_log values('v_fact_moc_mtn', sysdate, msg, 0);
commit;
EXCEPTION WHEN OTHERS THEN
ecode := SQLCODE;
emesg := SQLERRM;
ROLLBACK;
	 msg :='An error has occured during the insertion in FACT_MOC from v_fact_moc_mtn ';
	 msg := msg ||': '||TO_CHAR(ecode) || '-' || emesg ;
     insert into facts_data_log values('v_fact_moc_mtn',sysdate,msg,0);
     commit;
end ;
/

Je peux marquer la discussion Résolu :

[mnitu]

...
On ne sait pas sur les machines sont côte à côte sur un commutateur Infiniband ou bien sur un VPN avec une distance réelle de 5000 Km et lien dédié à 512 kb/s.

Waldar si la situation sera telle que vous la décrivez le nombre et le temps d'attente des événements de type SQL*Net message to/from dblink devrait être plus important.
D'autre part transférer un fichier de 2 million des enregistrements va prendre du temps aussi dans ces conditions.

[mnitu]

...
Et mes performances se sont "exponentiellement" améliorées le script qui courait indéfiniment me fait environ 40 à 50 minutes pour une insertion d'environ deux millions et quelques lignes.
...

Bref, comme je l'ai déjà dit cette solution peut dans le meilleur des cases égaler Insert Into ... Select From ... mais pas faire plus.

Mais, comme c'est résolu on ne se prends plus la tête ... jusqu'à la prochaine fois.

[Mohamed.Houri]

Et mes performances se sont "exponentiellement" améliorées le script qui courait indéfiniment me fait environ 40 à 50 minutes pour une insertion d'environ deux millions et quelques lignes.

Bravo pour votre assiduité et persévérance à vouloir résoudre votre problème. Je vous conseille néanmoins d’écrire un document qui résume votre besoin initial, les difficultés rencontrées, les étapes franchies dans la recherche de la solution et enfin la solution de votre problème. La documentation est primordiale dans le processus d’acquisition des connaissances.

J’ai deux remarques concernant votre nouveau script

Le hint /*+ append */ est silencieusement ignoré car il ne fonctionne pas dans une instruction insert /values. Une des conditions pour que ce hint ne soit pas ignoré silencieusement c’est qu’il doit intervenir lors d'un insert/select. Vous auriez été en 11g, je vous aurai conseillé d’utiliser le hint /*+ append_values */ qui lui fonctionne avec l’instruction insert/values. C’est pour cette raison que je vous ai conseillé d’utiliser des types SQL (create type) et non des types PL/SQL comme vous l’avez fait. En effet, on ne peut pas sélectionner un type PL/SQL alors qu’on peut le faire sur un type SQL

Ma deuxième remarque concerne le commit dans la loop ; avez-vous essayé de commiter en dehors de la loop ? Ceci dit je pense sans l’avoir essayé que dans le cas où vous changez votre code pour que le hint /*+ append */ fonctionne vous seriez obligé de commiter après chaque insert afin d’éviter l’erreur ORA-12840 : cannot access a remote table after parallel/insert direct load txn

[Rams7s]

Au lieu du

Code :

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

1
2
3
4
FOR i IN 1..v_inst_fact_moc.count loop
INSERT /*+ append */ INTO fact_moc
...
end loop;

Essayez donc de mettre un

Code :

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

1
2
forall i in v_inst_fact_moc
insert into fact_moc...

[mnitu]

Voilà un test comparatif de ces deux méthodes

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
 
CREATE OR REPLACE Procedure ins_dblink1
As
  l_start pls_integer := dbms_utility.get_cpu_time;
Begin
  insert into big (
      owner,
      object_name,
      subobject_name,
      object_id,
      data_object_id,
      object_type,
      created,
      last_ddl_time,
      timestamp,
      status,
      temporary,
      generated,
      secondary
    )
    Select owner,
          object_name,
          subobject_name,
          object_id,
          data_object_id,
          object_type,
          created,
          last_ddl_time,
          timestamp,
          status,
          temporary,
          generated,
          secondary
     From big@dbl;
  --
  dbms_output.put_line('Elapsed: '||To_Char(dbms_utility.get_cpu_time - l_start));
  --
  Commit;
End;

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
 
CREATE OR REPLACE Procedure ins_dblink2
As
  l_start         pls_integer := dbms_utility.get_cpu_time;
  l_Limit         pls_integer := 1000;
  Type big_va Is Varray(1000) Of big%Rowtype;
  l_big           big_va;
  --
  Cursor crs_big Is
    Select owner,
          object_name,
          subobject_name,
          object_id,
          data_object_id,
          object_type,
          created,
          last_ddl_time,
          timestamp,
          status,
          temporary,
          generated,
          secondary
     From big@dbl;
  --
Begin
  Open crs_big;
  Loop
    Fetch crs_big Bulk Collect Into l_Big Limit l_Limit;
    ForAll i In 1..l_Big.count
      insert into big 
      Values l_Big(i);
    Exit When l_Big.Count < l_Limit;
  End Loop;
  --
  dbms_output.put_line('Elapsed: '||To_Char(dbms_utility.get_cpu_time - l_start));
  --
  Commit;
End;

et voilà le résultat de la deuxième exécution

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
 
SQL> truncate table big;
 
Table tronquée.
 
SQL> exec ins_dblink1
Elapsed: 1164
 
Procédure PL/SQL terminée avec succès.
 
SQL> truncate table big;
 
Table tronquée.
 
SQL> exec ins_dblink2
Elapsed: 1363
 
Procédure PL/SQL terminée avec succès.
 
SQL>