MySQL: qual è la differenza tra float e double?

Controllando la nuova struttura del database ho visto che qualcuno ha cambiato un campo da float a double. Chiedendomi perché, ho controllato la documentazione di mysql, ma onestamente non ho capito qual è la differenza.

Qualcuno può spiegare?

Entrambi rappresentano numeri in virgola mobile. A FLOATè per i DOUBLEnumeri a precisione singola, mentre a è per i numeri a doppia precisione.

MySQL utilizza quattro byte per valori a precisione singola e otto byte per valori a precisione doppia.

C'è una grande differenza tra i numeri in virgola mobile e i numeri decimali (numerici), che puoi usare con il DECIMALtipo di dati. Viene utilizzato per memorizzare valori numerici esatti, a differenza dei numeri in virgola mobile, dove è importante preservare la precisione esatta, ad esempio con i dati monetari.

Forse questo esempio potrebbe spiegare.

CREATE TABLE `test`(`fla` FLOAT,`flb` FLOAT,`dba` DOUBLE(10,2),`dbb` DOUBLE(10,2)); 

Abbiamo una tabella come questa:

+-------+-------------+
| Field | Type        |
+-------+-------------+
| fla   | float       |
| flb   | float       |
| dba   | double(10,2)|
| dbb   | double(10,2)|
+-------+-------------+

Per prima differenza, proviamo a inserire un record con "1.2" in ogni campo:

INSERT INTO `test` values (1.2,1.2,1.2,1.2);

La tabella che mostra in questo modo:

SELECT * FROM `test`;

+------+------+------+------+
| fla  | flb  | dba  | dbb  |
+------+------+------+------+
|  1.2 |  1.2 | 1.20 | 1.20 |
+------+------+------+------+

Vedi la differenza?

Proviamo al prossimo esempio:

SELECT fla+flb, dba+dbb FROM `test`;

Hola! Possiamo trovare la differenza in questo modo:

+--------------------+---------+
| fla+flb            | dba+dbb |
+--------------------+---------+
| 2.4000000953674316 |    2.40 |
+--------------------+---------+

I doppi sono proprio come i galleggianti, tranne per il fatto che sono due volte più grandi. Ciò consente una maggiore precisione.

Il pensiero che vorrei aggiungere il mio esempio, che mi ha aiutato a vedere la differenza con il valore 1.3quando si aggiungono o moltiplicando con un altro float, decimale double.

1.3galleggiante AGGIUNTO a 1.3di diversi tipi:

|float              | double | decimal |
+-------------------+------------+-----+
|2.5999999046325684 | 2.6    | 2.60000 |

1.3float MOLTIPLICATO da 1.3di diversi tipi:

| float              | double             | decimal      |
+--------------------+--------------------+--------------+
| 1.6899998760223411 | 1.6900000000000002 | 1.6900000000 |

Questo sta usando MySQL 6.7

Query:

SELECT 
    float_1 + float_2 as 'float add',
    double_1 + double_2 as 'double add',
    decimal_1 + decimal_2 as 'decimal add',

    float_1 * float_2 as 'float multiply',
    double_1 * double_2 as 'double multiply',
    decimal_1 * decimal_2 as 'decimal multiply'
FROM numerics

Crea tabella e inserisci dati:

CREATE TABLE `numerics` (
  `float_1` float DEFAULT NULL,
  `float_2` float DEFAULT NULL,
  `double_1` double DEFAULT NULL,
  `double_2` double DEFAULT NULL,
  `decimal_1` decimal(10,5) DEFAULT NULL,
  `decimal_2` decimal(10,5) DEFAULT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

INSERT INTO `_numerics` 
    (
        `float_1`,
        `float_2`,
        `double_1`,
        `double_2`,
        `decimal_1`,
        `decimal_2`
    )
VALUES
    (
        1.3,
        1.3,
        1.3,
        1.3,
        1.30000,
        1.30000
    );

FLOAT memorizza i numeri in virgola mobile con una precisione fino a otto posizioni e ha quattro byte, mentre DOUBLE memorizza i numeri in virgola mobile con una precisione fino a 18 posizioni e ha otto byte.

Float ha 32 bit (4 byte) con 8 posizioni di precisione. Double ha 64 bit (8 byte) con una precisione di 16 posizioni.

Se hai bisogno di una maggiore precisione, usa Double invece di Float .