Insertion en SQL de la valeur Float 999 999.999 ?

Version imprimable

03/05/2009, 20h36
ghohm

Insertion en SQL de la valeur Float 999 999.999 ?

Bonsoir à tous,

Je suis sûr que cela vient du format Float, mais je ne peux me l'expliquer ...

Lorsque j'insère "999 999.999" en SQL, je me retrouve avec "1 000 000" en DB ?! :aie:

Pire, lorsque j'insère 9 999 999.999" en DB j'ai 1.0E10 ... et du coup ma requête plante !!!

Apache Tomcat/5.5.26 - Rapport d'erreurEtat HTTP 500 -

type Rapport d'exception
message
description Le serveur a rencontré une erreur interne () qui l'a empêché de satisfaire la requête.
exception
javax.servlet.ServletException: Après 2 tentatives, la requête suivante a échoué : INSERT INTO BDD.MATABLE (CHAMP1, CHAMP2, CHAMP3, CHAMP4, CHAMP5, CHAMP6) VALUES ('545563443', '432432423', 1.0E10, 1.0E10, '4444', '101') : [SQL0406] Erreur de conversion pendant l'affectation d'une valeur à CHAMP3. org.apache.struts.chain.ComposableRequestProcessor.process(ComposableRequestProcessor.java:286) org.apache.struts.action.ActionServlet.process(ActionServlet.java:1913) org.apache.struts.action.ActionServlet.doPost(ActionServlet.java:462) javax.servlet.http.HttpServlet.service(HttpServlet.java:710) javax.servlet.http.HttpServlet.service(HttpServlet.java:803) [...]

Je suis sûr que vous avez la solution ... moi je ne l'ai pas trouvé !

Gôm
03/05/2009, 22h30
tchize_

on peux voir ton code qui génère ta requete SQL?

Citation:

Envoyé par tchize_

on peux voir ton code qui génère ta requete SQL?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
    /**
     * @param val1
     * @param val2
     * @param val3
     * @param val4
     * @param qteSaisie
     */
    public void saisieInventaire(String val1, String val2,
            String val3, String val4, float qteSaisie) {
 
        String sql = null;
 
        sql = "INSERT INTO "
                + schema
                + ".INVLOT4 (codearticle, emplacement, qte, qte2, numero, depot) VALUES ('"
                + val3 + "', '" + val4 + "', " + qteSaisie + ", "
                + qteSaisie + ", '" + val2 + "', '" + val1 + "')";
 
        cnx.executeUpdate(sql);
        logger.debug(sql);
    }

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
    /**
     * Execute une requête Insert ou Update
     *
     * @param query
     *            La requête à executer
     */
    public void executeUpdate(String query) {
        try {
            statement.executeUpdate(query);
        } catch (SQLException e) {
            // Si il y a eu echec, c'est peut être que la base
            // a été redémarrée, il faut donc réinitialiser une connexion
            // et retenter la requête
            try {
                logger.info("La requête suivante a échoué : " + query);
                logger
                        .info("Tentative de reconnexion au cas où la base a été redémarrée.");
                createConnection();
                logger.info("Deuxième tentative de la requête ayant échouée.");
                statement.executeUpdate(query);
            } catch (Exception e1) {
                throw new DaoException(e1,
                        "Après 2 tentatives, la requête suivante a échoué : "
                                + query);
            }
        }
    }

Je vois trois problèmes.

Le premier, tu utilise un float, hors dans la précision des float, 999999.999 et 1000000 son stocké binairement exactement de la même façon (voir code plus bas). Pour une meilleure précision, utiliser donc un double. Si t'a beson d'une précision absolue (15 chiffres devant la virgule et trois chiffres derrière par exemple) utilise un Long (qui sera des "millièmes" dans ce cas ci) ou un bigdecimal.

Deuxièmement, tu utilise "+" pour fair ton formatage. La doc de java stipule dans Float.toString() que les nombre au dela de de 10 exposant 7 sont affiché par toString en notation scientifique. Pour palier à ce problème, tu peux utiliser la classe DecimalFormat (voir code plus bas)

Troisièmement, préfère l'utilisation de requetes sql paramétrée, ca t'évitera ce genre d'ennui (formattage des nombres) à l'avenir bien que ca ne t'aidera pas à circonvenir la précision des floats.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 public class FloatTest { /** * @param args */ public static void main(String[] args) { float monFloat = 999999.999f; System.out.println("float: "+new DecimalFormat("###########.################").format(monFloat)); System.out.println("float: "+monFloat); System.out.println("1000000-999999.999 en float: "+new DecimalFormat("###########.################").format(1000000.0f-monFloat)); System.out.println("1000000 == 999999.999 en float? "+(1000000.0f == monFloat)); double monDouble = 999999.999; System.out.println("double: "+new DecimalFormat("###########.################").format(monDouble)); System.out.println("double: "+monDouble); System.out.println("1000000-999999.999 en double: "+new DecimalFormat("###########.################").format(1000000.0-monDouble)); System.out.println("1000000 == 999999.999 en double? "+(1000000.0 == monDouble)); } }
résultat:
Code:

1 2 3 4 5 6 7 8 float: 1000000 float: 1000000.0 1000000-999999.999 en float: 0 1000000 == 999999.999 en float? true double: 999999,999 double: 999999.999 1000000-999999.999 en double: 0,0010000000474975 1000000 == 999999.999 en double? false