Discussion :

[purity]

Salut tout le monde

j'ai une table dans ma base de données oracle nommée "supervision" qui a la structure suivante:

Code :

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

1
2
3
4
5
6
7
8
DATE_
OPERATEUR
SENS
SERVICE
NB_APPELS
DUREE
MONTANT 
TYPE

j'ai une interface Java(Swing) qui permet à l'utilisateur de choisir une 'Date de début' et une 'Date de fin' et stocke les données comprises entre ces deux dates quelque part ...
Voici ma requête:

Code :

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

1
2
SELECT * FROM SUPERVISION 
WHERE DATE_ BETWEEN date_debut AND date_fin ORDER BY DATE_, OPERATEUR;

1)-Si vous avez des idées où je peut placer les données comprise entre date début et date fin pour les manipuler par la suite (les données ne sont pas de même type donc je peut pas utiliser les tableaux ou les collections)

les données que je doit recevoir après cette requête sont de la formebien sur j'ai des milliers d'enregistrements et les autres champs de la table c'est juste un simple exemple)


Date OPERATEUR DUREE ........................
2013-01-01 operateur1 200 ........................
2013-01-01 operateur1 300 ........................
2013-01-01 operateur1 3 ........................
2013-01-01 operateur2 2 ......................
2013-01-01 operateur2 3 ........................
2013-01-01 operateur2 800 ........................
2013-01-01 operateur3 200 .......................
2013-01-01 operateur3 100 ........................
...............


2)-je veut recevoir un rapport me disant comme quoi pour operateur1 il y'a une durée anormale: 3 car elle est très petite par rapport à 200 et 300, et pour oprateur2 la valeur anormale c'est 800 car elle est très grande par rapport à 2 et 3 .... et ainsi de suite jusqu'à ce qu'il parcourt toute la table(bien sur ces valeurs seront détectées à l'aide d'une formule mathématique).

mon souci est: comment dire à mon algorithme que je veut appliquer une formule mathématique aux DUREE correspondantes à chaque opérateur à part et pas à l'ensemble des durées ? (c'est à dire détecter toutes les valeurs anormales pour operateur1 les sotcker quelque part puis passer vers l'opérateur suivant et ainsi de suite) et comment accéder au DUREE en gardant la correspondance avec les autres champs genre je reçoit un rapport contenant toute la ligne ou se trouve la DUREE anormale détectée par ma formule

voilà où je suis bloquée et j'ai mal à la tête à cause de ça

je suis désolée pour ce LONG sujet et je vous remercie pour l'intérêt que vous porterez à mon problème

[joel.drigo]

Salut

1)
tu peux tout simplement créer une classe qui réprésente chaque enregistrement

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
public class Supervision {
 
   private Date date;
   private String operteur;
   private long duree;
   ... etc 
 
   public Supervision() {
   }
 
   public void setDate(Date date) {
        this.date=date;
   }
 
   public Date getDate() {
        return date;
   }
 
   ... etc...
 
}

quand tu lis ton ResultSet résultant de ta requête, tu construit autant de Supervision que tu as d'enregistrement en injectant les valeurs de du résultat dans ton instance de Supervision

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
List<Supervision> supervisions = new ArrayList<Supervision>();
ResultSet rs = stmt.executeQuery("'Select DATE_, OPERATEUR, DUREE from supervision"); 
            // Display all the data in the table.
            while (rs.next()) {
                Supervision supervision = new Supervision();
                supervision.setDate(rs.getDate(1));
                supervision.setOperateur(rs.getString(2));
                supervision.setDuree(rs.getLong(3));
                supervisions.add(supervision);
            }

2)
comme tu as besoin de regrouper les valeurs pour lesquels tu a une valeur petite, au lieu d'utiliser une List<Supervision> tu peux utiliser une Map<String, List<Supervision>> ou ta clé est ton opérateur

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
 
Map<String, List<Supervision>> supervisions = new HashMap<String,List<Supervision>>();
ResultSet rs = stmt.executeQuery("'Select DATE_, OPERATEUR, DUREE from supervision"); 
            // Display all the data in the table.
            while (rs.next()) {
                Supervision supervision = new Supervision();
                supervision.setDate(rs.getDate(1));
                supervision.setOperateur(rs.getString(2));
                supervision.setDuree(rs.getLong(3));
                List<Supervision> operateurSupervisions = supervisions.get(supervision.getOperateur());
               if ( operateurSupervision==null ) {
                   operateurSupervisions = new ArrayList<Supervision>();
                   supervisions.put(supervision.getOperateur(),operateurSupervisions);
               }
              operateurSupervisions.add(supervision);
            }

ensuite, quand tu as chargé tout tes enregistrements, tu peux parcourir ta map :

Code :

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

1
2
3
for(Map.Entry<String,List<Supervision>> entry : supervisions.entrySet<String,List<Supervision>>) {
       chercheAnomalie(entry.getKey(),entry.getValue());
}

avec

Code :

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

1
2
3
public void checherAnomalie(String operateur, List<Supervision> data) {
...
}

maintenant si tu as des milliers d'enregistrement en résultat, cette solution à l'inconvénient de charger la mémoire : il faudrait s'orienter vers une solution ou le traitement de regroupement, voire de detection se fasse dans le serveur

on peut imaginer une requête de regroupement (avec un GROUP BY sur OPERATEUR) qui te ramène la plus petite des valeurs et la moyenne des valeurs, ou l'écart type, ce qui devrait de permettre savoir s'il existe une valeur vraiment anormale

tu peux faire une une procédure stockée en PLSQL aussi qui te fait le regroupement et la détection de ta valeur anormale : elle peut même ne sélectionner que les opérateur qui ont une valeur anormale

[purity]

Merci pour ta réponse,
j'ai bien réfléchi et j'ai cherché un peu sur google, j'ai trouvé que avec les ArrayList ça va me consommer plus de mémoire et la procédure sera très lente vu que j'ai une base de données volumineuse
j'ai pensé à la deuxième solution (PL/SQL) mais je ne sais pas vraiment et ce que je peut faire le traitement de mes données je n'ai aucune idée comment grouper les données par opérateur et faire le traitement pour chaque opérateur à part

[joel.drigo]

pour groupe en sql, utilise GROUP BY

par exemple, la requête suivante te donne les opérateurs avec la moyenne de la durée par opérateur

Code :

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

select OPERATEUR, AVG(DUREE) FROM supervision GROUP BY OPERATEUR

ton problème est déterminer si une valeur est "anormale",
tout dépend de ce qu'on appelle une valeur "anormale"

on peut par exemple dire que la durée la plus éloignée de la moyenne est anormale, et chercher les opérateurs qui ont cette durée au carrée éloignée de plus de l'ecart-type

pour sélectionner ces opérateurs, on ne peut pas utiliser le where parce qu'on utiliser des aggrégats (moyenne, ecart-type...), on utilise HAVING à la place

par exemple :

Code :

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

select OPERATEUR FROM supervision GROUP BY OPERATEUR HAVING power(DUREE - AVG(DUREE),2)>stddev(DUREE)(

ou quelque chose comme ça (ça fait super longtemps que j'ai pas fait de sql)

[purity]

En fait, la requête ne doit pas me retourner les opérateurs, elle doit me retourner les durées anormales pour un opérateur donné, car chaque opérateur à plusieurs durées et je doit déterminer celles les plus éloignés soit à l'aide de la formule que vous m'avez donné, j'ai testé la dernière requête elle ne marche pas
je vais chercher à améliorer cette requête et si c'est résolu je vais poster le résultat

[joel.drigo]

j'ai testé la dernière requête elle ne marche pas résultat

c'est peut être juste à cause de la parenthèse à la fin qui devrait être un point-virgule :

Code :

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

select OPERATEUR FROM supervision GROUP BY OPERATEUR HAVING power(DUREE - AVG(DUREE),2)>stddev(DUREE)(;

[joel.drigo]

En fait, la requête ne doit pas me retourner les opérateurs, elle doit me retourner les durées anormales pour un opérateur donné

si la requête retourne la liste des opérateurs avec la valeur anormale, tu peux avoir la valeur anormale pour un opérateur on ajoutant un where

ce n'est pas la peine que la requête retourne plusieurs durées si la durée retournée est présente dans la requête :

Code :

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

select OPERATEUR, DUREE ...