MySQL: Quelle est la différence entre float et double?

En vérifiant la nouvelle structure de la base de données, j'ai vu que quelqu'un avait changé un champ de float en double. Je me demande pourquoi, j'ai vérifié la documentation mysql, mais honnêtement, je n'ai pas compris quelle était la différence.

Quelqu'un peut-il expliquer?

Ils représentent tous deux des nombres à virgule flottante. A FLOATest pour la simple précision, tandis que a DOUBLEest pour les nombres à double précision.

MySQL utilise quatre octets pour les valeurs en simple précision et huit octets pour les valeurs en double précision.

Il existe une grande différence entre les nombres à virgule flottante et les nombres décimaux (numériques), que vous pouvez utiliser avec le DECIMALtype de données. Ceci est utilisé pour stocker des valeurs de données numériques exactes, contrairement aux nombres à virgule flottante, où il est important de préserver la précision exacte, par exemple avec des données monétaires.

Peut-être que cet exemple pourrait expliquer.

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

Nous avons une table comme celle-ci:

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

Pour la première différence, nous essayons d'insérer un enregistrement avec '1,2' dans chaque champ:

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

Le tableau montrant comme ceci:

SELECT * FROM `test`;

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

Regarde la différence?

Nous essayons de l'exemple suivant:

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

Hola! Nous pouvons trouver la différence comme ceci:

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

Les doubles sont comme des flotteurs, à l'exception du fait qu'ils sont deux fois plus grands. Cela permet une plus grande précision.

Je pensais que voudrais ajouter mon propre exemple qui m'a aidé à voir la différence en utilisant la valeur 1.3lors de l' ajout ou la multiplication avec un autre float, decimalet double.

1.3flotteur AJOUTÉ à 1.3de différents types:

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

1.3float MULTIPLIED par 1.3de différents types:

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

Ceci utilise MySQL 6.7

Requete:

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

Créer un tableau et insérer des données:

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 stocke les nombres à virgule flottante avec une précision jusqu'à huit places et a quatre octets tandis que DOUBLE stocke les nombres à virgule flottante avec une précision jusqu'à 18 places et a huit octets.

Float a 32 bits (4 octets) avec une précision de 8 places. Double a 64 bits (8 octets) avec une précision de 16 places.

Si vous avez besoin d'une meilleure précision, utilisez Double au lieu de Float .