Cara menggunakan mysql float

Saya pikir saya akan menambahkan contoh saya sendiri yang membantu saya melihat perbedaan menggunakan nilai 1.3 saat menambahkan atau mengalikan dengan float, decimal, dan double lainnya.

1.3 float TAMBAH ditambahkan ke 1.3 dari berbagai jenis:

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

1.3 float DILIPATI oleh 1.3 dari berbagai jenis:

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

Ini menggunakan MySQL 6.7

Pertanyaan:

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

Buat Tabel dan Sisipkan Data:

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
    );

Tipe Titik Apung (Nilai Perkiraan) - FLOAT, GANDA

Tipe FLOAT dan DOUBLE mewakili perkiraan nilai data numerik. MySQL menggunakan empat byte untuk nilai presisi tunggal dan delapan byte untuk nilai presisi ganda.

Untuk FLOAT, standar SQL memungkinkan spesifikasi opsional dari presisi (tetapi bukan kisaran eksponen) dalam bit mengikuti kata kunci FLOAT dalam tanda kurung. MySQL juga mendukung spesifikasi presisi opsional ini, tetapi nilai presisi hanya digunakan untuk menentukan ukuran penyimpanan. Ketelitian dari 0 hingga 23 menghasilkan kolom FLOAT presisi tunggal 4-byte. Sebuah presisi dari 24 hingga 53 menghasilkan kolom DOUBLE presisi ganda 8-byte.

MySQL mengizinkan sintaksis tidak standar: FLOAT (M, D) atau REAL (M, D) atau PRECISION GANDA (M, D). Di sini, "(M, D)" berarti daripada nilai-nilai dapat disimpan dengan total hingga M digit, di mana angka D mungkin setelah titik desimal. Misalnya, kolom yang didefinisikan sebagai FLOAT (7,4) akan terlihat seperti -999.9999 saat ditampilkan. MySQL melakukan pembulatan saat menyimpan nilai, jadi jika Anda memasukkan 999.00009 ke dalam kolom FLOAT (7,4), hasil perkiraannya adalah 999.0001.

Karena nilai floating-point adalah perkiraan dan tidak disimpan sebagai nilai yang tepat, upaya untuk memperlakukannya sebagai tepat dalam perbandingan dapat menyebabkan masalah. Mereka juga tergantung pada platform atau dependensi implementasi.

Untuk portabilitas maksimum, kode yang membutuhkan penyimpanan perkiraan nilai data numerik harus menggunakan FLOAT atau DOUBLE PRECISION tanpa spesifikasi presisi atau jumlah digit.

https://dev.mysql.com/doc/refman/5.5/en/floating-point-types.html

Masalah dengan Nilai Floating-Point

Angka floating-point terkadang menyebabkan kebingungan karena mereka perkiraan dan tidak disimpan sebagai nilai yang tepat . Nilai floating-point sebagaimana ditulis dalam pernyataan SQL mungkin tidak sama dengan nilai yang diwakili secara internal. Upaya untuk memperlakukan nilai floating-point sebagai perbandingan yang tepat dapat menyebabkan masalah. Mereka juga tergantung pada platform atau dependensi implementasi. Tipe data FLOAT dan DOUBLE tunduk pada masalah ini. Untuk kolom DECIMAL, MySQL melakukan operasi dengan ketepatan 65 angka desimal, yang seharusnya memecahkan masalah ketidaktepatan paling umum.

Contoh berikut menggunakan DOUBLE untuk menunjukkan bagaimana perhitungan yang dilakukan dengan menggunakan operasi titik-mengambang tunduk pada kesalahan titik-mengambang.

mysql> CREATE TABLE t1 (i INT, d1 DOUBLE, d2 DOUBLE);
mysql> INSERT INTO t1 VALUES (1, 101.40, 21.40), (1, -80.00, 0.00),
    -> (2, 0.00, 0.00), (2, -13.20, 0.00), (2, 59.60, 46.40),
    -> (2, 30.40, 30.40), (3, 37.00, 7.40), (3, -29.60, 0.00),
    -> (4, 60.00, 15.40), (4, -10.60, 0.00), (4, -34.00, 0.00),
    -> (5, 33.00, 0.00), (5, -25.80, 0.00), (5, 0.00, 7.20),
    -> (6, 0.00, 0.00), (6, -51.40, 0.00);

mysql> SELECT i, SUM(d1) AS a, SUM(d2) AS b
    -> FROM t1 GROUP BY i HAVING a <> b;

+------+-------+------+
| i    | a     | b    |
+------+-------+------+
|    1 |  21.4 | 21.4 |
|    2 |  76.8 | 76.8 |
|    3 |   7.4 |  7.4 |
|    4 |  15.4 | 15.4 |
|    5 |   7.2 |  7.2 |
|    6 | -51.4 |    0 |
+------+-------+------+

Hasilnya benar. Meskipun lima catatan pertama terlihat seperti mereka tidak harus memenuhi perbandingan (nilai a dan b tampaknya tidak berbeda), mereka dapat melakukannya karena perbedaan antara angka muncul di sekitar desimal kesepuluh atau lebih, tergantung pada faktor. seperti arsitektur komputer atau versi kompiler atau tingkat optimisasi. Sebagai contoh, CPU yang berbeda dapat mengevaluasi angka floating-point secara berbeda.

Jika kolom d1 dan d2 telah didefinisikan sebagai DECIMAL daripada DOUBLE, hasil dari query SELECT hanya akan berisi satu baris — yang terakhir ditunjukkan di atas.

Cara yang benar untuk melakukan perbandingan angka floating-point adalah pertama-tama memutuskan toleransi yang dapat diterima untuk perbedaan antara angka-angka dan kemudian melakukan perbandingan terhadap nilai toleransi. Sebagai contoh, jika kita sepakat bahwa angka floating-point harus dianggap sama jika mereka sama dalam presisi satu dalam sepuluh ribu (0,0001), perbandingan harus ditulis untuk menemukan perbedaan yang lebih besar daripada nilai toleransi:

mysql> SELECT i, SUM(d1) AS a, SUM(d2) AS b FROM t1
    -> GROUP BY i HAVING ABS(a - b) > 0.0001;
+------+-------+------+
| i    | a     | b    |
+------+-------+------+
|    6 | -51.4 |    0 |
+------+-------+------+
1 row in set (0.00 sec)

Sebaliknya, untuk mendapatkan baris dengan angka yang sama, tes harus menemukan perbedaan dalam nilai toleransi:

mysql> SELECT i, SUM(d1) AS a, SUM(d2) AS b FROM t1
    -> GROUP BY i HAVING ABS(a - b) <= 0.0001;
+------+------+------+
| i    | a    | b    |
+------+------+------+
|    1 | 21.4 | 21.4 |
|    2 | 76.8 | 76.8 |
|    3 |  7.4 |  7.4 |
|    4 | 15.4 | 15.4 |
|    5 |  7.2 |  7.2 |
+------+------+------+
5 rows in set (0.03 sec)

Nilai floating-point tunduk pada ketergantungan platform atau implementasi. Misalkan Anda menjalankan pernyataan berikut:

CREATE TABLE t1(c1 FLOAT(53,0), c2 FLOAT(53,0));
INSERT INTO t1 VALUES('1e+52','-1e+52');
SELECT * FROM t1;

Pada beberapa platform, pernyataan SELECT mengembalikan inf dan -inf. Pada yang lain, ia mengembalikan 0 dan -0.

Implikasi dari masalah sebelumnya adalah bahwa jika Anda mencoba untuk membuat budak replikasi dengan membuang konten tabel dengan mysqldump pada master dan memuat kembali file dump ke dalam slave, tabel yang berisi kolom titik-mengambang mungkin berbeda antara dua host.

https://dev.mysql.com/doc/refman/5.5/en/problems-with-float.html

Apa perbedaan antara tipe float dan double?

Jelaskan apa yang dimaksud dengan tipe data float?

Apakah yang dimaksud dengan tipe data decimal?

Tipe tipe data apa saja yang disediakan oleh MySQL?