深入浅出MYSQL float,double和decimal

 假如我们有一张表，用来存储用户的积分，表定义如下：

CREATE TABLE `f` (  `f1` float(10,2) DEFAULT NULL) ENGINE=InnoDB DEFAULT CHARSET=utf-8
然后向这个表里插入131072.32的积分值，如下所示

mysql> insert into f value (131072.32);Query OK, 1 row affected (0.00 sec)
mysql> select * from f;
+-----------+
| f1        |
+-----------+
| 131072.31 |
+-----------+

create table test(
   t_float float,
   t_double double
)

insert into test.test (t_float) values(123456);-- 正常
insert into test.test (t_float) values(1234567);-- 四设五入 1234570
insert into test.test (t_float) values(12345678901);-- 失真 12345700352

insert into test.test (t_float) values(12345.6); -- 正常
insert into test.test (t_float) values(12345.62); -- 四设五入 12345.6
insert into test.test (t_float) values(123.123); -- 正常
insert into test.test (t_float) values(12.1234); -- 正常
insert into test.test (t_float) values(1.12345); -- 正常
insert into test.test (t_float) values(1234.1234); -- 四设五入 1234.12

-- double
insert into test.test (t_double) values(1234567890123456);-- 正常
insert into test.test (t_double) values(12345678901234567);-- 四设五入 12345678901234568
insert into test.test (t_double) values(123.12345678901);-- 正常
insert into test.test (t_double) values(1234567890.123456);-- 正常

 
 CREATE TABLE `test_decimal` (
  `TOTAL` decimal(20,6) DEFAULT NULL,
  `MONERY` decimal(10,2) DEFAULT NULL,
  `ID` int NOT NULL AUTO_INCREMENT,
  PRIMARY KEY (`ID`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

insert into dba.test_decimal (TOTAL,MONERY) VALUES(99999999999999.88,70000000.09);
insert into dba.test_decimal (TOTAL,MONERY) VALUES(-99999999999999.88,-70000000.09);
SELECT * FROM dba.test_decimal;

# TOTAL                 MONERY       ID
99999999999999.880000 70000000.09    1
-99999999999999.880000 -70000000.09   2

/*
  Restores decimal from its binary fixed-length representation

  SYNOPSIS
    bin2decimal()
      from    - value to convert
      to      - result
      precision/scale - see decimal_bin_size() below
      keep_prec do not trim leading zeros

  NOTE
    see decimal2bin()
    the buffer is assumed to be of the size decimal_bin_size(precision, scale)
    If the keep_prec is true, the value will be read and returned as is,
    without precision reduction. This is used to read DECIMAL values that
    are to be indexed by multi-valued index.

  RETURN VALUE
    E_DEC_OK/E_DEC_TRUNCATED/E_DEC_OVERFLOW
*/

int bin2decimal(const uchar *from, decimal_t *to, int precision, int scale,
                bool keep_prec) 
  {
  int error = E_DEC_OK, intg = precision - scale, intg0 = intg / DIG_PER_DEC1,
      frac0 = scale / DIG_PER_DEC1, intg0x = intg - intg0 * DIG_PER_DEC1,
      frac0x = scale - frac0 * DIG_PER_DEC1, intg1 = intg0 + (intg0x > 0),
      frac1 = frac0 + (frac0x > 0);
  dec1 *buf = to->buf, mask = (*from & 0x80) ? 0 : -1;
  const uchar *stop;
  uchar *d_copy;
  int bin_size = decimal_bin_size_inline(precision, scale);

  sanity(to);
  d_copy = (uchar *)my_alloca(bin_size);
  memcpy(d_copy, from, bin_size);
  d_copy[0] ^= 0x80;
  from = d_copy;

  FIX_INTG_FRAC_ERROR(to->len, intg1, frac1, error);
  if (unlikely(error)) {
    if (intg1 < intg0 + (intg0x > 0)) {
      from += dig2bytes[intg0x] + sizeof(dec1) * (intg0 - intg1);
      frac0 = frac0x = intg0x = 0;
      intg0 = intg1;
    } else {
      frac0x = 0;
      frac0 = frac1;
    }
  }

  to->sign = (mask != 0);
  to->intg = intg0 * DIG_PER_DEC1 + intg0x;
  to->frac = frac0 * DIG_PER_DEC1 + frac0x;

  if (intg0x) {
    int i = dig2bytes[intg0x];
    dec1 x = 0;
    switch (i) {
      case 1:
        x = mi_sint1korr(from);
        break;
      case 2:
        x = mi_sint2korr(from);
        break;
      case 3:
        x = mi_sint3korr(from);
        break;
      case 4:
        x = mi_sint4korr(from);
        break;
      default:
        assert(0);
    }
    from += i;
    *buf = x ^ mask;
    if (((ulonglong)*buf) >= (ulonglong)powers10[intg0x + 1]) goto err;
    if (buf > to->buf || *buf != 0 || keep_prec)
      buf++;
    else
      to->intg -= intg0x;
  }
  for (stop = from + intg0 * sizeof(dec1); from < stop; from += sizeof(dec1)) {
    assert(sizeof(dec1) == 4);
    *buf = mi_sint4korr(from) ^ mask;
    if (((uint32)*buf) > DIG_MAX) goto err;
    if (buf > to->buf || *buf != 0 || keep_prec)
      buf++;
    else
      to->intg -= DIG_PER_DEC1;
  }
  assert(to->intg >= 0);
  for (stop = from + frac0 * sizeof(dec1); from < stop; from += sizeof(dec1)) {
    assert(sizeof(dec1) == 4);
    *buf = mi_sint4korr(from) ^ mask;
    if (((uint32)*buf) > DIG_MAX) goto err;
    buf++;
  }
  if (frac0x) {
    int i = dig2bytes[frac0x];
    dec1 x = 0;
    switch (i) {
      case 1:
        x = mi_sint1korr(from);
        break;
      case 2:
        x = mi_sint2korr(from);
        break;
      case 3:
        x = mi_sint3korr(from);
        break;
      case 4:
        x = mi_sint4korr(from);
        break;
      default:
        assert(0);
    }
    *buf = (x ^ mask) * powers10[DIG_PER_DEC1 - frac0x];
    if (((uint32)*buf) > DIG_MAX) goto err;
    buf++;
  }

  /*
    No digits? We have read the number zero, of unspecified precision.
    Make it a proper zero, with non-zero precision.
    Note: this is valid only if scale == 0, otherwise frac is always non-zero
  */
  if (to->intg == 0 && to->frac == 0) decimal_make_zero(to);
  return error;

err:
  decimal_make_zero(to);
  return (E_DEC_BAD_NUM);
}