Discussion :

[le Daoud]

Bonjour,

J'ai une requete "SELECT" qui peut être appelée lors de la mise à jour de deux champs dans mon IHM. Cependant cette requête est très longue (jusqu'à 30 secondes). J'aimerais donc pouvoir l'interrompre par exemple si l'utilisateur met à jour un champ alors qu'elle est encore en cours de traitement suite à modification d'un autre champ. Actuellement, si je modifie un champ, la requête se lance, je peux modifier un autre champ, ce qui n'arrête pas la fin de l'exécution de la première méthode et bloque le rafraichissement de l'IHM. Cela est-il possible ou n'ai je comme solution que de bloquer l'ihm pendant le traitement ?

Merci

[ohnerom]

Ben , maleureusement, je vois pas comment sauf peut etre en faisant un thread comme contexte d'execution de ta requete SQL , tu pourras donc gerer un timeout "applicatif" ou alors en t'appuyant sur ton driver JDBC s'il a une notion de timeout. Désolé , c'est pas terrible

[@ldehan]

il te reste encore la solution de ohnerom mais tout depends de l'appli et de la charge que supporte la base parce que jouer avec les timeout, ca peut vite devenir dangereux...

le rafraichissement doit-il se faire dès la mise d'un seul des 2 champs ?

meme si c'est le cas, tu peux toujours jouer avec les threads effectivement pour ne pas bloquer ton ihm. et tu fais un truc du genre : s'il une modif d'un des champs survient avant la fin de la requete, tu ouvres un nouveau thread pour relancer la requete avec ts nouveaux parametres, tu ne fais l'affichage que lorsque la requete abouti sans modif des champs. Cela dit, ce ne sera pas tres esthétique a mon avis....

l'autre solution : "veuillez patienter, traitement en cours...."

[adiGuba]

Salut,


Pour arrêter une requête SQL tu as deux solutions :

• Spécifier un timeout avant de lancer la requête avec la méthode setQueryTimeout(int) de ton Statement. Si la requête est trop longue cela provoquera a une exception. Cette solution est toute simple à mettre en oeuvre, mais assez limité (impossible de demander confirmation de l'utilisateur avant de stopper la requête)
• Lancer la requête dans un thread séparé et utiliser la méthode cancel() pour stopper la requête depuis le thread principal. Cette solution est un peu moins évidente car il faut manipuler des données entres deux threads. Heureusement la package java.util.concurrent de Java 5.0 facilite le travail. Cela pourrait donner :

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
public class Main {
    
    private ResultSet executeQuery(final Statement st, final String query, int timeout) throws SQLException {
        
        // Creation de l'élément Callable qui exécutera la requête dans un thread séparé
        Callable<ResultSet> callable = new Callable<ResultSet>() {
            // Méthode call() qui sera exécuté dans un autre thread.
            public ResultSet call() throws SQLException {
                return st.executeQuery(query);
            }
        };
        
        // On lance l'exécution du thread
        Future<ResultSet> future = Executors.newSingleThreadExecutor().submit(callable);
        
        try {
            // On attend que le thread soit terminé (pendant 'timeout' secondes)
            // pour récupérer le ResultSet renvoyé par la méthode call() :
            return future.get(timeout, TimeUnit.SECONDS);
        } catch (ExecutionException e) {
            // En cas d'exception retourné lors de l'exécution de la méthode call(),
            // on récupère l'exception en cause et on la renvoit :
            Throwable cause = e.getCause();
            final SQLException sqlE;
            
            if (cause instanceof SQLException) {
                // Sous forme d'SQLException si c'en est une :
                sqlE = (SQLException) cause;
            } else {
                // Ou bien on l'englobe dans une SQLException :
                sqlE = new SQLException( "Exception occured : " + cause.getClass().getSimpleName() );
                sqlE.initCause(cause);
            }
            throw sqlE;
        } catch (Exception e) {
            // Pour toutes les autres exceptions (normalement TimeoutException et InterruptedExcepton),
           // on annule le traitement :
            st.cancel();
            // et on renvoit l'exception englobé dans une SQLException
            SQLException sqlE = new SQLException("Statement interrupted due to " + e.getClass().getSimpleName());
            sqlE.initCause(e);
            throw sqlE;
        }
        
    }
    
    public void requeteLongue() throws SQLException {
    
        // Ouverture de la connection
        Connection conn = DriverManager.getConnection("__ Tes info de Connection__");
        try {
            // Creation du statement
            Statement st = conn.createStatement();
            try {
                // Execution de la requete SQL
                ResultSet rs = executeQuery(st, "__ta requete SQL__", 30);
                try {
                    // Copie des elements du ResultSet dans une List
                    while (rs.next()) {
                        
                        // ...
                        // Traitement sur le ResultSet
                        // ...
                        
                    }
                    
                } finally {
                    // Fermeture du ResultSet...
                    rs.close();
                }
                
            } finally {
                // Fermeture du Statement...
                st.close();
            }
        } finally {
            //Fermeture de la Connection...
            conn.close();
        }
    }

    

    public static void main(String[] args) throws Exception {
        
        Class.forName("__ton Driver JDBC ici__");
        
        Main m = new Main();
        m.requeteLongue();
        
    }

}

a++

[@ldehan]

je ne pense pas qu'on puisse arreter l'execution d'une requete je suis désolé.

mais 30 secondes c'est vraiment long, n'y a-t-il pas moyen d'optimiser un peu la requete ?

[le Daoud]

je ne pense pas qu'on puisse arreter l'execution d'une requete je suis désolé.

mais 30 secondes c'est vraiment long, n'y a-t-il pas moyen d'optimiser un peu la requete ?

hélas non, c'est le dba qui m'a fourni la requête, car je n'ai pas le schéma de la base, et d'après lui le temps est normal car il y a beaucoup d'enregistrements.