MySQL: ¿Cuál es la diferencia entre float y double?

Al verificar la nueva estructura de la base de datos, vi que alguien cambió un campo de flotante a doble. Preguntándome por qué, revisé la documentación de mysql, pero honestamente no entendí cuál es la diferencia.

¿Alguien puede explicarlo?

Ambos representan números de coma flotante. A FLOATes para DOUBLEnúmeros de precisión simple, mientras que a es para números de precisión doble.

MySQL usa cuatro bytes para valores de precisión simple y ocho bytes para valores de precisión doble.

Existe una gran diferencia entre los números de coma flotante y los números decimales (numéricos), que puede utilizar con el DECIMALtipo de datos. Esto se usa para almacenar valores de datos numéricos exactos, a diferencia de los números de coma flotante, donde es importante preservar la precisión exacta, por ejemplo, con datos monetarios.

Quizás este ejemplo podría explicarlo.

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

Tenemos una mesa como esta:

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

Para la primera diferencia, intentamos insertar un registro con '1.2' en cada campo:

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

La tabla que se muestra así:

SELECT * FROM `test`;

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

¿Ver la diferencia?

Intentamos con el siguiente ejemplo:

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

¡Hola! Podemos encontrar la diferencia así:

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

Los dobles son como flotadores, excepto por el hecho de que son dos veces más grandes. Esto permite una mayor precisión.

Que me gustaría añadir mi propio ejemplo, que me ayudó a ver la diferencia con el valor 1.3al añadir o multiplicando con otro float, decimaly double.

1.3flotador AÑADIDO a 1.3de diferentes tipos:

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

1.3flotador MULTIPLICADO por 1.3de diferentes tipos:

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

Esto está usando MySQL 6.7

Consulta:

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

Crear tabla e insertar datos:

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 almacena números de punto flotante con precisión de hasta ocho lugares y tiene cuatro bytes, mientras que DOUBLE almacena números de punto flotante con precisión de hasta 18 lugares y tiene ocho bytes.

Float tiene 32 bits (4 bytes) con una precisión de 8 lugares. Double tiene 64 bits (8 bytes) con una precisión de 16 lugares.

Si necesita una mayor precisión, use Double en lugar de Float .