Bonjour.

Nous utilisons Firebird depuis sa version 1.5 et nous n'avons jamais rencontré de problème jusqu'il y a peu.
Si un client distant se connecte sur un serveur via un réseau ayant un faible débit, nous avons des lenteurs sur les reqûetes.

Après avoir ,tourné le problème dans tous les sens, je vous livre l'aboutissement de mon analyse.

Test réalisé en mode client / serveur sur un poste ayant un débit réduit à 128k sous Firebird 2.5 client et serveur.

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
 
CREATE TABLE TEST (
    ROW1  VARCHAR(255),
    ROW2  INTEGER
);
 
INSERT INTO TEST (ROW1, ROW2) VALUES ('value1', 1);
INSERT INTO TEST (ROW1, ROW2) VALUES ('value2', 2);
INSERT INTO TEST (ROW1, ROW2) VALUES ('value3', 3);
INSERT INTO TEST (ROW1, ROW2) VALUES ('value4', 4);
.....
 
Requête select 1: SELECT ROW1 FROM TEST;
 
Requête select 2: SELECT ROW2 FROM TEST;
Résultats des requêtes select dans le moniteur SQL d'Ibexpert:
Requête select 1:1.5 sec
Requête select 2:5.3 sec

La requête 2 mets trois fois plus de temps à s'exécuter !!!!!


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
 
 
[13/05/2015 17:50:50] - [IB API call : isc_dsql_free_statement]
select ROW2 FROM TEST
 
.....
 
[13/05/2015 17:50:50] - [IB API call : isc_dsql_free_statement]
select f.rdb$field_name,
f.rdb$field_source,
f.rdb$null_flag,
f.rdb$default_source,
fs.rdb$null_flag,
fs.rdb$field_name,
fs.rdb$field_type,
fs.rdb$field_length,
fs.rdb$field_scale,
fs.rdb$field_sub_type,
fs.rdb$segment_length,
fs.rdb$dimensions,
d.rdb$dimension,
d.rdb$lower_bound,
d.rdb$upper_bound,
fs.rdb$character_set_id,
f.rdb$collation_id,
cr.rdb$character_set_name,
co.rdb$collation_name,
f.rdb$field_position,
fs.rdb$computed_source,
fs.rdb$character_length,
fs.rdb$default_source,
f.rdb$description,
fs.rdb$collation_id
,fs.rdb$field_precision
from rdb$relation_fields f
left join rdb$fields fs on fs.rdb$field_name = f.rdb$field_source
left join rdb$field_dimensions d on d.rdb$field_name = fs.rdb$field_name
left join rdb$character_sets cr on fs.rdb$character_set_id = cr.rdb$character_set_id
left join rdb$collations co on ((f.rdb$collation_id = co.rdb$collation_id) and
(fs.rdb$character_set_id = co.rdb$character_set_id))
where f.rdb$relation_name = 'TEST'
order by f.rdb$field_position, d.rdb$dimension
 
[13/05/2015 17:50:54] - [IB API call : isc_start_multiple]
...
[13/05/2015 17:50:55] - [Commit]
Transaction ID: 2953
Il mets 4 secondes à exécuter la requête ci-dessus.

Pour info, si je requête sur ROW 1 la requête équivalente est la suivante:

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
 
 
select RDB$FIELD_SOURCE from RDB$RELATION_FIELDS
where (RDB$RELATION_NAME = 'TEST') and
(RDB$FIELD_NAME = 'ROW1')
Elle est quasi instantanée.

Question, pourquoi une requête sur un champ de type entier prends 3 fois plus de temps que sur un varchar ??

J'en perds mon latin.

Merci.