FAQ JDBCConsultez toutes les FAQ

Nombre d'auteurs : 8, nombre de questions : 162, dernière mise à jour : 3 juin 2015  Ajouter une question

 

Cette FAQ a été réalisée à partir des questions fréquemment posées sur les forums de http://www.developpez.com et de l'expérience personnelle des auteurs.

Nous tenons à souligner que cette FAQ ne garantit en aucun cas que les informations qu'elle propose sont correctes. Les auteurs font leur maximum, mais l'erreur est humaine. Cette FAQ ne prétend pas non plus être complète. Si vous trouvez une erreur, ou que vous souhaitez nous aider en devenant rédacteur, lisez ceci.


SommaireLes RowSetLes FilteredRowSet (3)
précédent sommaire suivant
 

Les FilteredRowSet permettent de filtrer facilement les données, sans passer par des commandes SQL complexes. Ce genre de filtres peuvent être particulièrement utiles pour gérer l'affichage des données sans faire de multiples requêtes vers la base. Pour filtrer les données, il faut créer une classe implémentant Predicate. Dans celle-ci il suffira de définir la méthode evaluate qui renvoie un boolean indiquant si une ligne donnée doit apparaître ou non. Par exemple :

Code java : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
public class MonPredicat implements Predicate{ 
   public boolean evaluate(RowSet rowset){ 
      try{ 
         String nom = rowset.getString("nom"); 
         //on ne garde ici que les personnes dont le nom commence par A 
         if(nom.startsWith("A")){return true;} 
         else{return false;} 
      }catch(SQLException sqle){ 
         return false; 
      } 
   } 
   //etc. 
}
Il ne reste plus qu'à indiquer au FilteredRowSet le prédicat qu'il doit utiliser.

Code java : Sélectionner tout
1
2
3
4
5
6
7
8
FilteredRowSet rowset = new FilteredRowSetImpl(); 
//mise en place des propriétés 
rowset.setCommand("SELECT * FROM Annuaire"); 
rowset.setPredicate(new MonPredicat()); 
rowset.execute(); 
while(rowset.next()){ 
   //seulement les lignes répondant favorablement au prédicat sont visibles 
}

Mis à jour le 11 avril 2013 Ioan

On peut facilement spécifier plusieurs colonnes et ensembles de valeurs pour le filtrage de FilteredRowSet. Voici le Predicate utilisé :

Code java : Sélectionner tout
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
public class MonPredicat implements Predicate{ 
   public Comparable[] valMin, valMax; 
   public int[] col; 
   public String[] nomCol; 
   public MonPredicat(Comparable[] valeursMinimales, Comparable[] valeursMaximales, 
    int[] colonnes, String[] nomsColonnes){ 
      valMin = valeursMinimales; 
      valMax = valeursMaximales; 
      col = colonnes; 
      nomCol = nomsColonnes; 
   } 
   public boolean evaluate(Object value,int column) throws SQLException{ 
      Comparable valeurMinimum = valMin[column]; 
      Comparable valeurMaximum = valMax[column]; 
      return (valeurMinimum.compareTo(value)<=0) 
                                     &&((valeurMaximum.compareTo(value)>=0)); 
   } 
   public boolean evaluate(Object value, String columnName) throws SQLException{ 
     int column = Arrays.asList(nomCol).indexOf(columnName); 
      Comparable valeurMinimum = valMin[column]; 
      Comparable valeurMaximum = valMax[column]; 
      return (valeurMinimum.compareTo(value)<=0) 
                                     &&((valeurMaximum.compareTo(value)>=0)); 
   } 
   public boolean evaluate(RowSet rowset){ 
     try{ 
         boolean ok = true; 
         int nombreColonnes = (col!=null)?col.length:nomCol.length; 
         for(int i=0;i<nombreColonnes && ok;i++){ 
         if(col != null){ 
         ok &= evaluate(rowset.getObject(col[i]),col[i]); 
         }else{ 
             ok &= evaluate(rowset.getObject(nomCol[i]),nomCol[i]); 
         } 
        } 
         return ok; 
      }catch(SQLException sqle){ 
         return false; 
      } 
   } 
}
Ce prédicat prend en arguments quatre tableaux. Les deux premiers définissent les minimums et maximums. Ce sont les ensembles de valeurs acceptées par le filtre. Les deux derniers indiquent les colonnes sur lesquelles il faut appliquer le filtre. Un seul de ces paramètres doit être spécifié. C'est-à-dire que l'on identifie les colonnes en fonction de leur index ou en fonction de leur nom. Voici un exemple d'utilisation :

Code java : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
String url = "jdbc:mysql://localhost/test"; 
String user = "user"; 
String password = "pass"; 
String command = "SELECT * FROM Annuaire"; 
FilteredRowSet rowset = new FilteredRowSetImpl(); 
rowset.setUrl(url); 
rowset.setUsername(user); 
rowset.setPassword(password); 
rowset.setCommand(command); 
String[] nomsColonnes = new String[]{"id","nom","prenom"}; 
Comparable[] minimums = new Comparable[]{new Integer("200"),"a","b"}; 
Comparable[] maximums = new Comparable[]{new Integer("12360"),"f","c"}; 
Predicate predicat = new MonPredicat(minimums,maximums,null,nomsColonnes); 
rowset.setFilter(predicat); 
rowset.execute(); 
while(rowset.next()){ 
   //dans ce cas seulement les tuples vérifiant les conditions suivantes sont affichés :  
   // - id (int) compris entre 200 et 12 360 
   // - nom (String) : les noms compris entre a et f 
   // - prenom (String) : les prénoms compris entre b et c 
}

Mis à jour le 11 avril 2013 Ioan

Il n'existe pas de mécanisme disponible pour spécifier plusieurs filtres à un FilteredRowSet. Par contre, on peut facilement créer un gestionnaire de filtres. Celui-ci nous permettrait d'utiliser plusieurs filtres simples et de combiner leurs effets. L'avantage de cette manipulation est le fait de pouvoir facilement changer les « vues » de nos données. Voici un exemple utilisant plusieurs filtres sous forme de clauses (ET logique) :

Code java : Sélectionner tout
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
class GestionnairePredicats implements Predicate{ 
   public Map<String,Predicate> filtres; 
   public GestionnairePredicats(){ 
      filtres = new HashMap<String, Predicate>(); 
   } 
   public Map<String, Predicate> getFiltres(){return filtres;} 
   public void setFiltres(Map<String, Predicate> lesFiltres){ 
      filtres = lesFiltres; 
   } 
   public void addFiltre(String nom, Predicate filtre){ 
      filtres.put(nom,filtre); 
   } 
   public void removeFiltre(String nom){ 
      filtres.remove(nom); 
   } 
   public boolean evaluate(RowSet rowset){ 
     boolean ok = true; 
     for(Predicate predicate : filtres.values()){ 
     ok &= predicate.evaluate(rowset); 
     } 
     return ok; 
   } 
   public boolean evaluate(Object value,int column) throws SQLException{ 
     boolean ok = true; 
     for(Predicate predicate : filtres.values()){ 
     ok &= predicate.evaluate(value,column); 
     } 
     return ok; 
   } 
   public boolean evaluate(Object value, String columnName) throws SQLException{ 
     boolean ok = true; 
     for(Predicate predicate : filtres.values()){ 
     ok &= predicate.evaluate(value,columnName); 
     } 
     return ok; 
   } 
}
L'utilisation du gestionnaire est simple et ressemble à ceci :

Code java : Sélectionner tout
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
String url = "jdbc:mysql://localhost/maBase"; 
String user = "user"; 
String password = "pass"; 
String command = "SELECT * FROM Annuaire"; 
FilteredRowSet rowset = new FilteredRowSetImpl(); 
rowset.setUrl(url); 
rowset.setUsername(user); 
rowset.setPassword(password); 
rowset.setCommand(command); 
GestionnairePredicats gestionnaire = new GestionnairePredicats(); 
rowset.setFilter(gestionnaire); 
rowset.execute(); 
System.out.println("#################################################"); 
while(rowset.next()){ 
   //par défaut toutes les lignes sont visibles 
   System.out.println(rowset.getObject("nom")+" , "+rowset.getObject("prenom")); 
} 
gestionnaire.addFiltre("filtre 1", new MonPredicat()); 
gestionnaire.addFiltre("filtre 2", new MonPredicat2()); 
rowset.beforeFirst(); 
System.out.println("#################################################"); 
while(rowset.next()){ 
   //les deux filtres sont appliqués 
   System.out.println(rowset.getObject("nom")+" , "+rowset.getObject("prenom")); 
} 
gestionnaire.removeFiltre("filtre 1"); 
rowset.beforeFirst(); 
System.out.println("#################################################"); 
while(rowset.next()){ 
   //seulement le second filtre est appliqué 
   System.out.println(rowset.getObject("nom")+" , "+rowset.getObject("prenom")); 
}
On peut facilement améliorer cet exemple en définissant toutes les possibilités de la logique des prédicats.

Mis à jour le 11 avril 2013 Ioan

Proposer une nouvelle réponse sur la FAQ

Ce n'est pas l'endroit pour poser des questions, allez plutôt sur le forum de la rubrique pour ça


Réponse à la question

Liens sous la question
précédent sommaire suivant
 

Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright © 2017 Developpez Developpez LLC. Tous droits réservés Developpez LLC. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents et images sans l'autorisation expresse de Developpez LLC. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.

 
Responsables bénévoles de la rubrique Java : Mickael Baron - Robin56 -