ODBC

Version imprimable

Bonjour,

Je suis en train de passer une application VB6 se connectant à MySQL par une connexion ODBC en une application Java se connectant par le JDBC...

J'étais donc parti bien confiant, et j'ai voulu faire un test de rapidité !

Une simple requête SELECT sur une table qui renvoie quelques 40000 enregistrements, la base étant sur un serveur distant avec ma connexion internet pourrie de 1M.

Stupeur :
- par mon vieux programme VB6, 16 sec d'exécution
- par mon beau programme JAVA, 1 minute !!!!

:aie:

Là j'ai vraiment du mal à comprendre... :roll:
JDBC serait-il si lent ?!

Voici comment je me suis connecté :
Code:

1 2 3 4 5 6 7 8 9 10 11 Statement st = null; ResultSet rs = null; clear(); try { st = Kernel.getConnexion().createStatement(); rs = st.executeQuery(requete); while ( rs.next() ) {
J'ai donc mis des points d'arrêt sur la creation du statement, du resultset et le while : les temps "chronométrés" sont bien sur le executeQuery...

Y-a-til quelque chose à faire ?
Faut-il abandonner Java dès qu'on fait du MySQL ?!
VB6 plus fort que JAVA ?!!

Merci de vos suggestions.

17/01/2010, 11h57
slim_java

salut.
pour bien mener ton teste , il sera mieux de tester l'exécution avec une base de données LOCALE et essaye d'utiliser PreparedStatement à la place de Statement
18/01/2010, 14h13
kimausoleil

Citation:

Envoyé par slim_java

salut.
pour bien mener ton teste , il sera mieux de tester l'exécution avec une base de données LOCALE et essaye d'utiliser PreparedStatement à la place de Statement

En ce qui concerne le local (sur le réseau interne), il n'y a pas de problèmes !
Très rapide, même plus rapide quavec une base access locale à mon PC...

Après pour un PreparedStatement, il faut que j'essaie pour voir...

merci pour ta réponse.
03/02/2010, 10h20
kimausoleil

Finalement, ça ne change rien...

Néanmoins, si on passe l'application en applet, là les connexions sont très rapides ?

Bizarre, non ? :roll:
03/02/2010, 10h38
OButterlin

Il faudrait plus d'infos, peux-tu montrer la totalité de ta classe de test avec les imports ?
03/02/2010, 10h42
ttttnht

Peux-tu nous montrer ton code complet? (connection, statement)

Quel IDE que tu utilises pour ton test?

Grille :D

Ok... je vais essayer de vous présenter cela simplement :

Je charge une ArrayList comme cela :

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
 
    /**
     * Chargement de la liste selon la reqête passée en paramètre
     * @param requete
     */
    protected void load(String requete) {
 
        PreparedStatement st = null;
//        Statement st = null;
        ResultSet rs = null;
 
        clear();
        try {
 
            long beginTime = System.currentTimeMillis();
 
            st = Kernel.getConnexion().prepareStatement(requete);
            rs = st.executeQuery();
 
//            st = Kernel.getConnexion().createStatement();
//            rs = st.executeQuery(requete);
 
            long endTime = System.currentTimeMillis();
            System.out.println(String.valueOf(beginTime) + " -> " +  String.valueOf(endTime) + " : " +  String.valueOf(endTime-beginTime) );
 
            Adresse adresse;
            while ( rs.next() ) {
 
                adresse = buildAdresse(rs);
 
            //  on ajoute l'adresse à la collection !
                add(adresse);
 
            //  on déclenche l'appel aux listeners... (pratique pour la progressbar)
                fireListeChanged();
 
            }
 
        } catch (Exception ex) {
            System.out.println("Impossible de charger la liste des adresses : " + ex.getMessage());
        } finally {
            try {
                if (rs != null) rs.close();
                if (st != null) st.close();
                rs = null;
                st = null;
            } catch (SQLException ex) {}
        }
 
    }

Donc vous pouvez remarquer que je me suis "amusé" à chronométrer le temps d'exécution de ma requête... preparedStatement ou pas !

Par ailleurs voici ma classe Kernel (précédemment initialisée) me renvoyant la connexion :

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
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
106
107
108
109
110
111
112
113
114
115
116
 
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.Properties;
 
 
 
 
/**
 * Classe gérant la connexion avec le serveur MySQL ou ACCESS
 * @author chris
 */
public class Kernel {
 
 
    private Connection connexion;
 
    private String host;
    private String dataBase;
    private String user;
    private String pwd;
 
    private String fichier;
 
 
 
    /**
     * Création d'une connexion avec Mysql
     * @param host
     * @param dataBase
     * @param user
     * @param pwd
     * @throws DBConnectorException
     */
    public Kernel(String host, String dataBase, String user, String pwd) throws DBConnectorException {
 
        if ( connexion==null ) {
 
            try {
 
                Class.forName("com.mysql.jdbc.Driver").newInstance();
                connexion = DriverManager.getConnection("jdbc:mysql://" + host + "/" + dataBase, user, pwd);
 
                this.host = host;
                this.dataBase = dataBase;
                this.user = user;
                this.pwd = pwd;
 
            } catch (Exception ex) {
                throw new DBConnectorException("Impossible d'établir une connexion avec MySQL !\n" + ex.getMessage());
            }
 
        }
 
    }
 
 
 
    /**
     * Création d'une connexion avec ACCESS
     * @param fichier
     * @param user
     * @param pwd
     * @throws DBConnectorException
     */
    public Kernel(String fichier) throws DBConnectorException {
 
        if ( connexion==null ) {
 
            try {
 
                Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
 
                String url = "jdbc:odbc:Driver={Microsoft Access Driver (*.mdb)};DBQ=" + fichier;
                Properties props = new Properties();
                props.put ("charSet", "ISO-8859-15");       //sinon problèmes des accents en lisant base access
 
                connexion = DriverManager.getConnection(url, props);
 
                this.fichier = fichier;
 
            } catch (Exception ex) {
                throw new DBConnectorException("Impossible d'établir une connexion avec ACCESS !\n" + ex.getMessage());
            }
 
        }
 
    }
 
 
 
    /**
     * Déconnexion du serveur MySQL
     */
    public void deconnect() {
 
        try {
            if ( connexion!=null )  connexion.close();
        } catch (SQLException ex) {
            System.out.println("Erreur à la déconnexion : \n" + ex.getMessage());
        }
 
    }
 
 
 
    /**
     * Renvoie la connexion initialisée
     * @return
     */
    public static Connection getConnexion() throws DBConnectorException {
       if ( connexion==null )
            throw new DBConnectorException("Connexion à la base de données non initialisée !");
       return connexion;
    }

Pour résumer, j'ai initialisé au lancement de mon application ma connexion à la base MySQL par le connecteur de type 4 :

Code:

1
2
3
4
5
6
 
kernel = new Kernel(
                        Config.getProperty(MYSQL_HOST),
                        Config.getProperty(MYSQL_DB),
                        Config.getProperty(MYSQL_USER),
                        Config.getProperty(MYSQL_PWD));

Voilà !

Donc j'ai refais mes tests hier soir sur une requête qui me renvoie 12000 enregistrements :

Code:

SELECT * FROM adresse

Donc vraiment rien de plus simple... et en voilà les temps d'exécution :
- ~6 sec par Vb6
- ~30 sec par application Java
- ~30 sec par applet Java (oui, en fait, dans mes précédents tests, l'applet était en connexion avec ma base access locale au lieu de mysql).

Alors ma question est donc : pourquoi l'exécution de requêtes sur un serveur distant est plus rapide avec une application VB6 qu'avec une application Java ?

:roll:

04/02/2010, 10h16
OButterlin

Regarde du côté de setFetchSize(...) sur l'objet Statement (ou PreparedStatement), je pense que par défaut, ODBC traite des blocs d'enregistrements... à tester en tout cas ;)

Citation:

Regarde du côté de setFetchSize(...) sur l'objet Statement (ou PreparedStatement), je pense que par défaut, ODBC traite des blocs d'enregistrements... à tester en tout cas

Je viens de regarder, et ça me plaisait bien cette solution... mais ça n'a eu aucune incidence ! :?

Alors, j'ai réfléchi par rapport à VB6...
Mon application Java utilise actuellement le connector MySQL de type 4 !
Dans la FAQ JDBC, type 4 est donc plus portable, respecte les spécif jdbc3.0, mais semble plus lent que un type 1...

Donc j'essaie la connexion avec un type 1 celui que j'utilise pour ma connexion java/access, avec cette fois-ci le drivers que j'utilise dans VB6 :
Code:

1 2 3 4 5 6 7 8 9 10 11 // Class.forName("com.mysql.jdbc.Driver").newInstance(); // connexion = DriverManager.getConnection("jdbc:mysql://" + host + "/" + dataBase, user, pwd); Class.forName("sun.jdbc.odbc.JdbcOdbcDriver"); String url = "jdbc:odbc:Driver={MySQL ODBC 3.51 Driver};Server=" + host.substring(0, host.indexOf(":")) + ";Port=" + host.substring(host.indexOf(":")+1) + ";Database=" + dataBase + ";UID=" + user + ";Password=" + pwd + ";Option=" + String.valueOf(1 + 2 + 8 + 32 + 2048 + 16384); Properties props = new Properties(); props.put ("charSet", "ISO-8859-15"); //sinon problèmes des accents connexion = DriverManager.getConnection(url, props);
et j'ai refait mes tests :) ...
Temps d'exécution : ~6à8sec quasi identique qu'avec VB6 !
8-)

En gros, la connexion de type 4 c'est bien en local... sinon, faut utiliser un type 1 (avec ses inconvénients).

Néanmoins, j'ai remarqué un truc ! Comme je fais défiler ma progressbar, je vois le temps de lecture de mon resultset (mes 12000 enregistrements).

Avec type 1 : très lent !!! +de 12 sec pour faire défiler la barre
Avec type 4 : très très rapide !!! à peine 1sec !

:roll:

Bien... en définitive :
- Jdbc type 1 de Sun : requête rapide, mais parcours du resultset lent
- Jdbc type 4 de MySQL : requête lente (voire très lente), mais parcours du resultset très rapide !

Donc existe-t-il un type 4 qui concilierait les 2 ? :P