精华内容
下载资源
问答
  • MySQL小数数据类型

    2020-06-14 20:26:19
    单精度(只能精确到小数位7位)的浮点(小数)数据类型 float(M,D) unsigned zerofill# M最大255位,含小数30位# D最大30位 4 double 单精度(只能精确到小数位15位)的浮点(小数)数据类型 double(M,D) unsigned zerofill...

    第1章 小数类型和测试环境说明

    1.1 小数数据类型有哪些

    从官方网站上看

    https://dev.mysql.com/doc/refman/5.7/en/numeric-types.html

    1

    自己整理的

    类型 说明 格式 占用存储(字节bytes)
    float 近似值(浮点)小数数据类型,小数位只能精确到7位 float(M,D) unsigned zerofill
    # M最大255位,含小数30位
    # D最大30位
    4
    double 近似值(浮点)小数数据类型,小数位只能精确到15位 double(M,D) unsigned zerofill
    # M最大255位,含小数30位
    # D最大30位
    8
    decimal 准确值(定点)小数数据类型,小数位完全精确 decimal(M,D) unsigned zerofill
    # M最大65位,含小数30位
    # D最大30位
    每个小数位占用1个字节
    numeric 准确值(定点)小数数据类型,小数位完全精确 numeric(M,D) unsigned zerofill
    # M最大65位,含小数30位
    # D最大30位
    每个小数位占用1个字节

    PS:decimal和numeric是一样的,只不过名字不一样,官方的说法:在MySQL中,NUMERIC实现为DECIMAL

    1.2 实践环境基本的说明

    ##### 数据库版本和默认的存储引擎
    mysql> select @@version,@@default_storage_engine;
    +------------+--------------------------+
    | @@version  | @@default_storage_engine |
    +------------+--------------------------+
    | 5.7.28-log | InnoDB                   |
    +------------+--------------------------+
    1 row in set (0.00 sec)
     
    
    ##### 事务的提交方式是自动的(主要是针对DML语句)
    mysql> select @@autocommit,@@global.autocommit;
    +--------------+---------------------+
    | @@autocommit | @@global.autocommit |
    +--------------+---------------------+
    |            1 |                   1 |
    +--------------+---------------------+
    1 row in set (0.00 sec)
    
    
    ##### 创建chenliang库,并进入到chenliang库下面
    mysql> create database if not exists chenliang character set utf8 collate utf8_general_ci;
    Query OK, 1 row affected (0.03 sec)
     
    mysql> use chenliang;
    Database changed
     
    mysql> select database();
    +------------+
    | database() |
    +------------+
    | chenliang  |
    +------------+
    1 row in set (0.01 sec)
    


    第2章 小数数据类型float

    2.1 float的总结性说明

    ##### 格式
    id        float(M,D)            unsigned                zerofill
    字段名     数据类型(要指定M和D)     无符号(只针对整数位)       无符号(只针对整数位,但整数位不会前导零填充显示)
    
    
    ##### float的M和D说明和示例
    M:表示"整数位""小数位"共多少位,M最大255位(包含小数位在内,小数30位);所以整数位最大长度是225;
    D:表示"小数位"最大多少位,最大30位;
    示例1:float(255,30)   # 整数位最大长度225位,小数位最大长度30位;
    示例2:float(50,20)    # 整数位最大长度30位,小数位最大长度20位;
    
    
    ##### float数据类型默认的小数位精确度(只能精确到第7位)
    字段定义:f float(255,30)   # 没有加unsigned和zerofill是因为它们都是针对整数位,而这里讨论的是小数位,跟他们没关系
    插入数据:insert into test12(f) values(1.555555555555555555555555555555);
    插入说明:往test12表中的f字段插入的数据是(整数位是1,小数位是30个5)
    显示结果:1.555555582046508800000000000000
    结果说明:可以看出小数位到第8位就不准确了(小数位只准确到了第7位)
    
    
    ##### 关于小数位的说明
    01:若插入数据的小数位长度没有达到指定的小数位长度,则会在小数后面用零填充显示(跟zerofill无关哈);
    02:若插入数据的小数位长度刚好达到指定的小数位长度,则不会用零填充,也不会四舍五入;
    03:若插入数据的小数位长度已经超过指定的小数位长度,则会进行四舍五入;
    
    
    ##### 生产环境下当字段指定的数据类型为 float(5,2) 的举例说明
    -- 加了unsigned属性
    	A:sql_mode开启了严格模式(sql_mode包含strict_trans_tables)
    	   插入1751.2    # 直接报错,因为开了严格模式,且指定的整数位最大长度是3
    	   插入-175.2    # 直接报错,因为开了严格模式,且加了unsigned属性(无符号,针对整数位),
    	   插入17.2      # 成功,整数位长度没超过指定长度3,显示的数据是17.20(小数位不够2位)
    	   插入17.245    # 成功,整数位长度没超过指定长度3,显示的是17.25(小数位超过长度,四舍五入)
    	
    	B:sql_mode未开启严格模式(sql_mode不包含strict_trans_tables)
    	   插入1751.2    # 成功且警告,虽然整数位超过了指定长度,但未开严格模式,到表中的数据是 999.99
    	   插入-175.2    # 成功且警告,虽然加了unsigned属性(针对整数位),但未开严格模式,到表中数据是 0.00
    	   插入17.2      # 成功,整数位长度没超过指定长度3,显示的数据是17.20(小数位不够2位)
    	   插入17.245    # 成功,整数位长度没超过指定长度3,显示的是17.25(小数位超过长度,四舍五入)
    
    
    -- 加了zerofill属性
    	A:sql_mode开启了严格模式(sql_mode包含strict_trans_tables)
    	   插入1751.2    # 直接报错,因为开了严格模式,且指定的整数位最大长度是3
    	   插入-175.2    # 直接报错,因为开了严格模式,且加了zerofill属性(无符号,针对整数位),
    	   插入17.2      # 成功,整数位长度没超过指定长度3,显示的数据是17.20(小数位不够2位)
    	   插入17.245    # 成功,整数位长度没超过指定长度3,显示的是17.25(小数位超过长度,四舍五入)
    	
    	B:sql_mode未开启严格模式(sql_mode不包含strict_trans_tables)
    	   插入1751.2    # 成功且警告,虽然整数位超过了指定长度,但未开严格模式,到表中的数据是 999.99
    	   插入-175.2    # 成功且警告,虽然加了unsigned属性(针对整数位),但未开严格模式,到表中数据是 00.00
    	   插入17.2      # 成功,整数位长度没超过指定长度3,显示的数据是17.20(小数位不够2位)
    	   插入17.245    # 成功,整数位长度没超过指定长度3,显示的是17.25(小数位超过长度,四舍五入)
    
    
    -- 没有加unsigned/zerofill属性
    	A:sql_mode开启了严格模式(sql_mode包含strict_trans_tables)
    	   插入1751.2    # 直接报错,因为开了严格模式,且指定的整数位最大长度是3;
    	   插入-175.2    # 成功,因为没加unsigned或zerofill属性,且整数位没超过长度;
    	   插入17.2      # 成功,整数位长度没超过指定长度3,显示的数据是17.20(小数位不够2位)
    	   插入17.245    # 成功,整数位长度没超过指定长度3,显示的是17.25(小数位超过长度,四舍五入)
    	
    	B:sql_mode未开启严格模式(sql_mode不包含strict_trans_tables)
    	   插入1751.2    # 成功且警告,虽然整数位超过了指定长度,但未开严格模式,到表中的数据是999.99
    	   插入-175.2    # 成功,因为没加unsigned或zerofill属性,且整数位没超过长度
    	   插入17.2      # 成功,整数位长度没超过指定长度3,显示的数据是17.20(小数位不够2位)
    	   插入17.245    # 成功,整数位长度没超过指定长度3,显示的是17.25(小数位超过长度,四舍五入)
    

    2.2 float数据类型小数位的默认精确度

    总结

    字段定义:f float(255,30)   # 没有加unsigned和zerofill是因为它们都是针对整数位,而这里讨论的是小数位,跟他们没关系
    插入数据:insert into test12(f) values(1.555555555555555555555555555555);
    插入说明:往test12表中的f字段插入的数据是(整数位是1,小数位是30个5)
    显示结果:1.555555582046508800000000000000
    结果说明:可以看出小数位到第8位就不准确了(小数位只准确到了第7位)
    

    实践

    #### 创建test22表
    create table if not exists test22(
    	f float(255,30)
    )engine=innodb character set utf8 collate utf8_general_ci;
    
        # f字段没有加unsigned和zerofill属性,因为我们讨论的是float的精确度
        # 整数位的最大长度是255,小数位的最大长度是30
    
    #### 查看tst22表的表结构
    mysql> desc test22;
    +-------+---------------+------+-----+---------+-------+
    | Field | Type          | Null | Key | Default | Extra |
    +-------+---------------+------+-----+---------+-------+
    | f     | float(255,30) | YES  |     | NULL    |       |
    +-------+---------------+------+-----+---------+-------+
    1 row in set (0.00 sec)
    
    
    #### 插入测试数据
    mysql> insert into test22(f) values(1.555555555555555555555555555555);
    Query OK, 1 row affected (0.01 sec)
    
    mysql> select * from test22;
    +----------------------------------+
    | f                                |
    +----------------------------------+
    | 1.555555582046508800000000000000 |
    +----------------------------------+
    1 row in set (0.00 sec)
    

    2.3 测试unsigned属性

    注意:unsigned表示无符号,它只针对数值的整数位

    sql_mode开启了严格模式,即sql_mode参数中包含strict_trans_tables变量

    #### 设置当前会话模式下,sql_mode开启严格模式,DML语句自动提交
    set session autocommit=on;
    set session sql_mode="strict_trans_tables";
    
    
    #### 创建test23_1表,并查看表的表结构
    create table if not exists test23_1(
    	f float(5,2) unsigned
    )engine=innodb character set utf8 collate utf8_general_ci;
    
       # f字段整数位的最大长度是3,小数位的最大长度是2;
       # 加了unsigned属性,那么整数位只能是正整数;
       # 若插入数据的小数位长度没有达到指定的小数位长度,则会在小数后面用零填充显示;
       # 若插入数据的小数位长度刚好达到指定的小数位长度,则不会用零填充,也不会四舍五入;
       # 若插入数据的小数位长度已经超过指定的小数位长度,则会进行四舍五入;
       
    mysql> desc test23_1;
    +-------+---------------------+------+-----+---------+-------+
    | Field | Type                | Null | Key | Default | Extra |
    +-------+---------------------+------+-----+---------+-------+
    | f     | float(5,2) unsigned | YES  |     | NULL    |       |
    +-------+---------------------+------+-----+---------+-------+
    1 row in set (0.00 sec)
    
    
    #### 插入数据进行测试
    insert into test23_1(f) values(1751.2);
    		# 直接报错,因为插入数值的整数位超过了指定的长度3位,且开启了严格模式
    		# 数据不会到达表中
    
    insert into test23_1(f) values(-175.2);
    		# 直接报错,因为加了unsigned,整数位只能是正整数,且sql_mode开启了严格模式,
    		# 数据不会到达表中
    
    insert into test23_1(f) values(17.2);
            # 成功,插入到表中的数据是17.2,显示的时候是17.20,因为小数位长度不够2位,
            # 会在后面用零填充显示;
    
    insert into test23_1(f) values(17.245);
            # 成功,到表中的数据不是17.245,因为小数位超过指定的长度2了,会进行四舍五入
            # 最后到表中的数据是17.25,显示的时候也是17.25
    
    mysql> select * from test23_1;
    +--------+
    | f      |
    +--------+
    | 17.20  |
    | 17.25  |
    +--------+
    2 rows in set (0.00 sec)
    

    sql_mode未开启严格模式,即sql_mode参数中不包含strict_trans_tables变量

    #### 设置当前会话模式下,sql_mode未开启严格模式,DML语句自动提交
    set session autocommit=on;
    set session sql_mode="";
    
    
    #### 创建test23_2表,并查看表的表结构
    create table if not exists test23_2(
    	f float(5,2) unsigned
    )engine=innodb character set utf8 collate utf8_general_ci;
    
       # f字段整数位的最大长度是3,小数位的最大长度是2
       # 加了unsigned属性,那么整数位只能是正整数
       # 若插入数据的小数位长度没有达到指定的小数位长度,则会在小数后面用零填充显示
       # 若插入数据的小数位长度刚好达到指定的小数位长度,则不会用零填充,也不会四舍五入
       # 若插入数据的小数位长度已经超过指定的小数位长度,则会进行四舍五入;
       
    mysql> desc test23_2;
    +-------+---------------------+------+-----+---------+-------+
    | Field | Type                | Null | Key | Default | Extra |
    +-------+---------------------+------+-----+---------+-------+
    | f     | float(5,2) unsigned | YES  |     | NULL    |       |
    +-------+---------------------+------+-----+---------+-------+
    1 row in set (0.01 sec)
    
    
    #### 插入数据进行测试
    insert into test23_2(f) values(1751.2);
    		# 成功且有警告,按理说,整数位已经超过指定的长度3了,但sql_mode未开严格模式
    		# 数据会到达表中,到表中的数据是999.99
    
    insert into test23_2(f) values(-175.2);
    		# 成功且有警告,按理说,整数位应该是正整数,因为字段加了unsigned属性,但示开严格模
    		# 式,数据会到达表,到表中的数据是0.00
    
    insert into test23_2(f) values(17.2);
            # 成功,插入到表中的数据是175.2,显示的时候是175.20,因为小数位长度不够2位,
            # 会在后面用零填充显示;
    
    insert into test23_2(f) values(17.245);
            # 成功,到表中的数据不是17.245,因为小数位超过指定的长度2了,会进行四舍五入
            # 最后到表中的数据是17.25,显示的时候也是17.25
    
    mysql> select * from test23_2;
    +--------+
    | f      |
    +--------+
    | 999.99 |
    |   0.00 |
    | 17.20  |
    | 17.25  |
    +--------+
    4 rows in set (0.00 sec)
    

    2.4 测试zerofill属性

    注意:zerofill表示无符号,因为它包含unsigned属性,针对整数位,但不会进行前导0填充

    sql_mode开启了严格模式,即sql_mode参数中包含strict_trans_tables变量

    #### 设置当前会话模式下,sql_mode开启严格模式,DML语句自动提交
    set session autocommit=on;
    set session sql_mode="strict_trans_tables";
    
    
    #### 创建test24_1表,并查看表的表结构
    create table if not exists test24_1(
    	f float(5,2) zerofill
    )engine=innodb character set utf8 collate utf8_general_ci;
    
       # f字段整数位的最大长度是3,小数位的最大长度是2
       # 加了zerofill属性,那么整数位只能是正整数(且显示时会前导师零填充显示)
       # 若插入数据的小数位长度没有达到指定的小数位长度,则会在小数后面用零填充显示
       # 若插入数据的小数位长度刚好达到指定的小数位长度,则不会用零填充,也不会四舍五入
       # 若插入数据的小数位长度已经超过指定的小数位长度,则会进行四舍五入;
       
    mysql> desc test24_1;
    +-------+------------------------------+------+-----+---------+-------+
    | Field | Type                         | Null | Key | Default | Extra |
    +-------+------------------------------+------+-----+---------+-------+
    | f     | float(5,2) unsigned zerofill | YES  |     | NULL    |       |
    +-------+------------------------------+------+-----+---------+-------+
    1 row in set (0.00 sec)
    
    
    #### 插入数据进行测试
    insert into test24_1(f) values(1751.2);
    		# 直接报错,因为插入的数值的整数位超过了指定的长度3位,且sql_mode开启了严格模式,数据不会到达表中
    
    insert into test24_1(f) values(-175.2);
    		# 直接报错,因为加了zerofill,整数位只能是正整数,且sql_mode开启了严格模式,数据不会到达表中
    
    insert into test24_1(f) values(17.2);
    		# 成功,数据会到达表中,到表中的数据是17.2,最终显示的数据是17.20
    		# 整数位不够长度,不会前导0填充显示,即使加了zerofill属性
    		# 小数位不够长度,会后导0填充显示,这个和zerofill属性无关
    
    insert into test24_1(f) values(17.245);
    		# 成功,到表中的数据是17.25,显示的时候是17.25
    		# 整数位不够长度,不会前导0填充显示,即使加了zerofill属性
    		# 小数位超过长度,会四舍五入
    
    mysql> select * from test24_1;
    +-------+
    | f     |
    +-------+
    | 17.20 |
    | 17.25 |
    +-------+
    2 rows in set (0.00 sec)
    

    sql_mode未开启严格模式,即sql_mode参数中不包含strict_trans_tables变量

    #### 设置当前会话模式下,sql_mode未开启严格模式,DML语句自动提交
    set session autocommit=on;
    set session sql_mode="";
    
    
    #### 创建test24_2表,并查看表的表结构
    create table if not exists test24_2(
    	f float(5,2) zerofill
    )engine=innodb character set utf8 collate utf8_general_ci;
    
       # f字段整数位的最大长度是3,小数位的最大长度是2
       # 加了zerofill属性,那么整数位只能是正整数(且显示时会前导师零填充显示)
       # 若插入数据的小数位长度没有达到指定的小数位长度,则会在小数后面用零填充显示
       # 若插入数据的小数位长度刚好达到指定的小数位长度,则不会用零填充,也不会四舍五入
       # 若插入数据的小数位长度已经超过指定的小数位长度,则会进行四舍五入;
       
    mysql> desc test24_2;
    +-------+------------------------------+------+-----+---------+-------+
    | Field | Type                         | Null | Key | Default | Extra |
    +-------+------------------------------+------+-----+---------+-------+
    | f     | float(5,2) unsigned zerofill | YES  |     | NULL    |       |
    +-------+-------------------------------------------------------------+
    
    #### 插入数据进行测试
    insert into test24_2(f) values(1751.2);
    		# 成功且有警告,虽然整数位超过了指定长度3,但sql_mode未开严格模式
    		# 所以到表中的数据是999.99
    
    insert into test24_2(f) values(-175.2);
    		# 成都且有警告,虽然整数位不能是负整数,但sql_mode未开严格模式
    		# 所以到表中的数据是00.00
    
    insert into test24_2(f) values(17.2);
    		# 成功,数据会到达表中,到表中的数据是17.2,最终显示的数据是17.20
    		# 整数位不够长度,不会前导0填充显示,即使加了zerofill属性
    		# 小数位不够长度,会后导0填充显示,这个和zerofill属性无关
    
    insert into test24_2(f) values(17.245);
    		# 成功,到表中的数据是17.25,显示的时候是17.25
    		# 整数位不够长度,不会前导0填充显示,即使加了zerofill属性;
    		# 小数位超过长度,会四舍五入;
    
    mysql> select * from test24_2;
    +--------+
    | f      |
    +--------+
    | 999.99 |
    |  00.00 |
    |  17.20 |
    |  17.25 |
    +--------+
    4 rows in set (0.00 sec)
    

    2.5 测试不加unsigned/zerofill属性

    注意:不加unsigned和zerofill属性,这样数值的整数位就可以是正整数或者负整数了

    sql_mode开启了严格模式,即sql_mode参数中包含strict_trans_tables变量

    #### 设置当前会话模式下,sql_mode开启严格模式,DML语句自动提交
    set session autocommit=on;
    set session sql_mode="strict_trans_tables";
    
    
    #### 创建test25_1表,并查看其表结构
    create table if not exists test25_1(
      f float(5,2)
    )engine=innodb character set utf8 collate utf8_general_ci;
    
       # f字段整数位的最大长度是3,小数位的最大长度是2;
       # 没有加unsigned/zerofill属性,那么整数位可以是正整数和负整数
       # 若插入数据的小数位长度没有达到指定的小数位长度,则会在小数后面用零填充显示;
       # 若插入数据的小数位长度刚好达到指定的小数位长度,则不会用零填充,也不会四舍五入;
       # 若插入数据的小数位长度已经超过指定的小数位长度,则会进行四舍五入;
    
    mysql> desc test25_1;
    +-------+------------+------+-----+---------+-------+
    | Field | Type       | Null | Key | Default | Extra |
    +-------+------------+------+-----+---------+-------+
    | f     | float(5,2) | YES  |     | NULL    |       |
    +-------+------------+------+-----+---------+-------+
    1 row in set (0.00 sec)
    
    
    #### 插入测试数据进行测试
    insert into test25_1(f) values(1751.2);
    		# 直接报错,因为插入数值的整数位超过了指定的长度3位,且开启了严格模式
    		# 数据不会到达表中
    
    insert into test25_1(f) values(-175.2);
    		# 成功,因为没加unsigned/zerofill,整数位可以是负正整数,数据会到达表中
    
    insert into test25_1(f) values(17.2);
            # 成功,插入到表中的数据是17.2,显示的时候是17.20,因为小数位长度不够2位,
            # 会在后面用零填充显示;
    
    insert into test25_1(f) values(17.245);
            # 成功,到表中的数据不是17.245,因为小数位超过指定的长度2了,会进行四舍五入
            # 最后到表中的数据是17.25,显示的时候也是17.25
    
    mysql> select * from test25_1;
    +---------+
    | f       |
    +---------+
    | -175.20 |
    |   17.20 |
    |   17.25 |
    +---------+
    3 rows in set (0.00 sec)
    

    sql_mode未开启严格模式,即sql_mode参数中不包含strict_trans_tables变量

    #### 设置当前会话模式下,sql_mode未开启严格模式,DML语句自动提交
    set session autocommit=on;
    set session sql_mode="";
    
    
    #### 创建test26_2表,并查看其表结构
    create table if not exists test25_2(
      f float(5,2)
    )engine=innodb character set utf8 collate utf8_general_ci;
    
       # f字段整数位的最大长度是3,小数位的最大长度是2;
       # 没有加unsigned/zerofill属性,那么整数位可以是正整数和负整数
       # 若插入数据的小数位长度没有达到指定的小数位长度,则会在小数后面用零填充显示;
       # 若插入数据的小数位长度刚好达到指定的小数位长度,则不会用零填充,也不会四舍五入;
       # 若插入数据的小数位长度已经超过指定的小数位长度,则会进行四舍五入;
    
    mysql> desc test25_2;
    +-------+------------+------+-----+---------+-------+
    | Field | Type       | Null | Key | Default | Extra |
    +-------+------------+------+-----+---------+-------+
    | f     | float(5,2) | YES  |     | NULL    |       |
    +-------+------------+------+-----+---------+-------+
    1 row in set (0.00 sec)
    
    
    #### 插入测试数据进行测试
    insert into test25_2(f) values(1751.2);
    		# 成功且警告,整数位超过长度3,但未开启严格模式;数据到表中是999.99
    
    insert into test25_2(f) values(-175.2);
    		# 成功,因为没加unsigned/zerofill,整数位可以是负正整数,数据会到达表中;
    
    insert into test25_2(f) values(17.2);
            # 成功,插入到表中的数据是17.2,显示的时候是17.20,因为小数位长度不够2位,
            # 会在后面用零填充显示;
    
    insert into test25_2(f) values(17.245);
            # 成功,到表中的数据不是17.245,因为小数位超过指定的长度2了,会进行四舍五入
            # 最后到表中的数据是17.25,显示的时候也是17.25
    
    mysql> select * from test25_2;
    +---------+
    | f       |
    +---------+
    |  999.99 |
    | -175.20 |
    |   17.20 |
    |   17.25 |
    +---------+
    4 rows in set (0.00 sec)
    


    第3章 小数数据类型double

    3.1 double的总结性说明

    ## 格式
    id      double(M,D)         unsigned            zerofill
    字段名    数据类型(要指定M和D)    无符号(只针对整数位)    无符号(只针对整数位,但整数位不会前导零填充显示)
    
    
    ## double的M和D说明和示例
    M:表示"整数位""小数位"共多少位,M最大255位(包含小数位在内,小数30位);所以整数位最大长度是225;
    D:表示"小数位"最大多少位,最大30位;
    示例1:double(255,30)   # 整数位最大长度225位,小数位最大长度30位;
    示例2:double(50,20)    # 整数位最大长度30位,小数位最大长度20位;
    
    
    ## 关于小数位的说明
    01:若插入数据的小数位长度没有达到指定的小数位长度,则会在小数后面用零填充显示(跟zerofill无关哈);
    02:若插入数据的小数位长度刚好达到指定的小数位长度,则不会用零填充,也不会四舍五入;
    03:若插入数据的小数位长度已经超过指定的小数位长度,则会进行四舍五入;
    
    
    ## 关于double数据类型小数位的精确度说明
    字段定义:d double(255,30)  # 整数位最大长度225位,小数位最大长度30位
    定义说明:没加unsigned和zerofill是因它们都是针对整数位,而这里讨论的是小数位,跟他们没关系 
    插入数据:insert into test12(d) values(1.555555555555555555555555555555);
    插入说明:往test12表中的d字段插入的数据是(整数位是1,小数位是30个5)
    显示结果:1.555555555555555600000000000000
    结果说明:可以看出小数位到第16位就不准确了(小数位只准确到了第16位)
    
    
    ## 生产环境下当字段指定的数据类型为 double(5,2) 的举例说明
    -- 加了unsigned属性
    	A:sql_mode开启了严格模式(sql_mode包含strict_trans_tables)
    	   插入1751.2    # 直接报错,因为开了严格模式,且指定的整数位最大长度是3
    	   插入-175.2    # 直接报错,因为开了严格模式,且加了unsigned属性(无符号,针对整数位),
    	   插入17.2      # 成功,整数位长度没超过指定长度3,显示的数据是17.20(小数位不够2位)
    	   插入17.245    # 成功,整数位长度没超过指定长度3,显示的是17.25(小数位超过长度,四舍五入)
    	
    	B:sql_mode未开启严格模式(sql_mode不包含strict_trans_tables)
    	  插入1751.2     # 成功且警告,虽然整数位超过了指定长度,但未开严格模式,到表中的数据是999.99
    	   插入-175.2    # 成功且警告,虽然加了unsigned属性(针对整数位),但未开严格模式,到表中数据是0.00
    	   插入17.2      # 成功,整数位长度没超过指定长度3,显示的数据是17.20(小数位不够2位)
    	   插入17.245    # 成功,整数位长度没超过指定长度3,显示的是17.25(小数位超过长度,四舍五入)
    
    -- 加了zerofill属性
    	A:sql_mode开启了严格模式(sql_mode包含strict_trans_tables)
    	   插入1751.2    # 直接报错,因为开了严格模式,且指定的整数位最大长度是3
    	   插入-175.2    # 直接报错,因为开了严格模式,且加了zerofill属性(无符号,针对整数位),
    	   插入17.2      # 成功,整数位长度没超过指定长度3,显示的数据是17.20(小数位不够2位)
    	   插入17.245    # 成功,整数位长度没超过指定长度3,显示的是17.25(小数位超过长度,四舍五入)
    	
    	B:sql_mode未开启严格模式(sql_mode不包含strict_trans_tables)
    	   插入1751.2    # 成功且警告,虽然整数位超过了指定长度,但未开严格模式,到表中的数据是999.99
    	   插入-175.2    # 成功且警告,虽然加了unsigned属性(针对整数位),但未开严格模式,到表中数据是00.00
    	   插入17.2      # 成功,整数位长度没超过指定长度3,显示的数据是17.20(小数位不够2位)
    	   插入17.245    # 成功,整数位长度没超过指定长度3,显示的是17.25(小数位超过长度,四舍五入)
    
    -- 没加unsigned/zerofill属性
    	A:sql_mode开启了严格模式(sql_mode包含strict_trans_tables)
    	   插入1751.2    # 直接报错,因为开了严格模式,且指定的整数位最大长度是3
    	   插入-175.2    # 成功,因为没加unsigned或zerofill属性,且整数位没超过长度
    	   插入17.2      # 成功,整数位长度没超过指定长度3,显示的数据是17.20(小数位不够2位)
    	   插入17.245    # 成功,整数位长度没超过指定长度3,显示的是17.25(小数位超过长度,四舍五入)
    	
    	B:sql_mode未开启严格模式(sql_mode不包含strict_trans_tables)
    	   插入1751.2    # 成功且警告,虽然整数位超过了指定长度,但未开严格模式,到表中的数据是999.99
    	   插入-175.2    # 成功,因为没加unsigned或zerofill属性,且整数位没超过长度
    	   插入17.2      # 成功,整数位长度没超过指定长度3,显示的数据是17.20(小数位不够2位)
    	   插入17.245    # 成功,整数位长度没超过指定长度3,显示的是17.25(小数位超过长度,四舍五入)
    

    3.2 double数据类型小数位的默认精确度

    总结

    字段定义:d double(255,30)  
    插入数据:insert into test13(f) values(1.555555555555555555555555555555);
    结果显示:1.555555555555555600000000000000
    结果总结:可以看出小数位的第16位就不准确了,只准确到了第15位小数位;
    

    实践

    #### 创建test32表
    create table if not exists test32(
    	d double(255,30)
    )engine=innodb character set utf8 collate utf8_general_ci;
    
    	# f字段没有加unsigned和zerofill属性,因为我们讨论的是float的精确度
    	# 整数位的最大长度是255,小数位的最大长度是30
    
    
    #### 查看test32表的表结构
    mysql> desc test32;
    +-------+---------------+------+-----+---------+-------+
    | Field | Type          | Null | Key | Default | Extra |
    +-------+---------------+------+-----+---------+-------+
    | d     | double(255,30)| YES  |     | NULL    |       |
    +-------+---------------+------+-----+---------+-------+
    1 row in set (0.00 sec)
    
    
    #### 插入测试数据
    mysql> insert into test32(d) values(1.555555555555555555555555555555);
    Query OK, 1 row affected (0.01 sec)
    
    mysql> select * from test32;
    +----------------------------------+
    | d                                |
    +----------------------------------+
    | 1.555555555555555600000000000000 |
    +----------------------------------+
    1 row in set (0.00 sec)
    

    3.3 测试unsigned属性

    注意:unsigned表示无符号,它只针对数值的整数位

    sql_mode开启了严格模式,即sql_mode参数中包含strict_trans_tables变量

    #### 设置当前会话模式下,sql_mode开启严格模式,DML语句自动提交
    set session autocommit=on;
    set session sql_mode="strict_trans_tables";
    
    
    #### 创建test33_1表,并查看表的表结构
    create table if not exists test33_1(
    	d double(5,2) unsigned
    )engine=innodb character set utf8 collate utf8_general_ci;
    
       # f字段整数位的最大长度是3,小数位的最大长度是2;
       # 加了unsigned属性,那么整数位只能是正整数;
       # 若插入数据的小数位长度没有达到指定的小数位长度,则会在小数后面用零填充显示;
       # 若插入数据的小数位长度刚好达到指定的小数位长度,则不会用零填充,也不会四舍五入;
       # 若插入数据的小数位长度已经超过指定的小数位长度,则会进行四舍五入;
       
    mysql> desc test33_1;
    +-------+---------------------+------+-----+---------+-------+
    | Field | Type                | Null | Key | Default | Extra |
    +-------+---------------------+------+-----+---------+-------+
    | d     | double(5,2) unsigned| YES  |     | NULL    |       |
    +-------+---------------------+------+-----+---------+-------+
    1 row in set (0.00 sec)
    
    
    #### 插入数据进行测试
    insert into test33_1(d) values(1751.2);
    		# 直接报错,因为插入数值的整数位超过了指定的长度3位,且开启了严格模式
    		# 数据不会到达表中
    
    insert into test33_1(d) values(-175.2);
    		# 直接报错,因为加了unsigned,整数位只能是正整数,且sql_mode开启了严格模式,
    		# 数据不会到达表中
    
    insert into test33_1(d) values(17.2);
            # 成功,插入到表中的数据是17.2,显示的时候是17.20,因为小数位长度不够2位,
            # 会在后面用零填充显示;
    
    insert into test33_1(d) values(17.245);
            # 成功,到表中的数据不是17.245,因为小数位超过指定的长度2了,会进行四舍五入
            # 最后到表中的数据是17.25,显示的时候也是17.25
    
    mysql> select * from test33_1;
    +--------+
    | d      |
    +--------+
    | 17.20  |
    | 17.25  |
    +--------+
    2 rows in set (0.00 sec)
    

    sql_mode未开启严格模式,即sql_mode参数中不包含strict_trans_tables变量

    #### 设置当前会话模式下,sql_mode未开启严格模式,DML语句自动提交
    set session autocommit=on;
    set session sql_mode="";
    
    
    #### 创建test33_2表,并查看表的表结构
    create table if not exists test33_2(
    	d double(5,2) unsigned
    )engine=innodb character set utf8 collate utf8_general_ci;
    
       # f字段整数位的最大长度是3,小数位的最大长度是2
       # 加了unsigned属性,那么整数位只能是正整数
       # 若插入数据的小数位长度没有达到指定的小数位长度,则会在小数后面用零填充显示
       # 若插入数据的小数位长度刚好达到指定的小数位长度,则不会用零填充,也不会四舍五入
       # 若插入数据的小数位长度已经超过指定的小数位长度,则会进行四舍五入;
       
    mysql> desc test33_2;
    +-------+----------------------+------+-----+---------+-------+
    | Field | Type                 | Null | Key | Default | Extra |
    +-------+----------------------+------+-----+---------+-------+
    | d     | double(5,2) unsigned | YES  |     | NULL    |       |
    +-------+----------------------+------+-----+---------+-------+
    1 row in set (0.01 sec)
    
    
    #### 插入数据进行测试
    insert into test33_2(d) values(1751.2);
    		# 成功且有警告,按理说,整数位已经超过指定的长度3了,但sql_mode未开严格模式
    		# 数据会到达表中,到表中的数据是999.99
    
    insert into test33_2(d) values(-175.2);
    		# 成功且有警告,按理说,整数位应该是正整数,因为字段加了unsigned属性,但示开严格模
    		# 式,数据会到达表,到表中的数据是0.00
    
    insert into test33_2(d) values(17.2);
            # 成功,插入到表中的数据是175.2,显示的时候是175.20,因为小数位长度不够2位,
            # 会在后面用零填充显示;
    
    insert into test33_2(d) values(17.245);
            # 成功,到表中的数据不是17.245,因为小数位超过指定的长度2了,会进行四舍五入
            # 最后到表中的数据是17.25,显示的时候也是17.25
    
    mysql> select * from test33_2;
    +--------+
    | d      |
    +--------+
    | 999.99 |
    |   0.00 |
    | 17.20  |
    | 17.25  |
    +--------+
    4 rows in set (0.00 sec)
    

    3.4 测试zerofill属性

    注意:zerofill表示无符号,因为它包含unsigned属性,针对整数位,但不会进行前导0填充

    sql_mode开启了严格模式,即sql_mode参数中包含strict_trans_tables变量

    #### 设置当前会话模式下,sql_mode开启严格模式,DML语句自动提交
    set session autocommit=on;
    set session sql_mode="strict_trans_tables";
    
    
    #### 创建test34_1表,并查看表的表结构
    create table if not exists test34_1(
    	d double(5,2) zerofill
    )engine=innodb character set utf8 collate utf8_general_ci;
    
       # f字段整数位的最大长度是3,小数位的最大长度是2
       # 加了zerofill属性,那么整数位只能是正整数(且显示时会前导师零填充显示)
       # 若插入数据的小数位长度没有达到指定的小数位长度,则会在小数后面用零填充显示
       # 若插入数据的小数位长度刚好达到指定的小数位长度,则不会用零填充,也不会四舍五入
       # 若插入数据的小数位长度已经超过指定的小数位长度,则会进行四舍五入;
    
    mysql> desc test34_1;
    +-------+-------------------------------+------+-----+---------+-------+
    | Field | Type                          | Null | Key | Default | Extra |
    +-------+-------------------------------+------+-----+---------+-------+
    | d     | double(5,2) unsigned zerofill | YES  |     | NULL    |       |
    +-------+-------------------------------+------+-----+---------+-------+
    1 row in set (0.00 sec)
    
    
    #### 插入数据进行测试
    insert into test34_1(d) values(1751.2);
    		# 直接报错,因为插入的数值的整数位超过了指定的长度3位,数据不会到达表中
    
    insert into test34_1(d) values(-175.2);
    		# 直接报错,因为加了zerofill,整数位只能是正整数,且sql_mode开启了严格模式,
    		# 数据不会到达表中
    
    insert into test34_1(d) values(17.2);
    		# 成功,数据会到达表中,到表中的数据是17.2,最终显示的数据是17.20
    		# 整数位不够长度,不会前导0填充显示,即使加了zerofill属性
    		# 小数位不够长度,会后导0填充显示,这个和zerofill属性无关
    
    insert into test34_1(d) values(17.245);
    		# 成功,到表中的数据是17.25,显示的时候是17.25
    		# 整数位不够长度,不会前导0填充显示,即使加了zerofill属性
    		# 小数位超过长度,会四舍五入
    
    mysql> select * from test34_1;
    +-------+
    | d     |
    +-------+
    | 17.20 |
    | 17.25 |
    +-------+
    2 rows in set (0.00 sec)
    

    sql_mode未开启严格模式,即sql_mode参数中不包含strict_trans_tables变量

    #### 设置当前会话模式下,sql_mode未开启严格模式,DML语句自动提交
    set session autocommit=on;
    set session sql_mode="";
    
    
    #### 创建test34_2表,并查看表的表结构
    create table if not exists test34_2(
    	d double(5,2) zerofill
    )engine=innodb character set utf8 collate utf8_general_ci;
      
       # f字段整数位的最大长度是3,小数位的最大长度是2
       # 加了zerofill属性,那么整数位只能是正整数(且显示时会前导师零填充显示)
       # 若插入数据的小数位长度没有达到指定的小数位长度,则会在小数后面用零填充显示
       # 若插入数据的小数位长度刚好达到指定的小数位长度,则不会用零填充,也不会四舍五入
       # 若插入数据的小数位长度已经超过指定的小数位长度,则会进行四舍五入;
       
    mysql> desc test34_2;
    +-------+------------------------------ +------+-----+---------+-------+
    | Field | Type                          | Null | Key | Default | Extra |
    +-------+-------------------------------+------+-----+---------+-------+
    | d     | double(5,2) unsigned zerofill | YES  |     | NULL    |       |
    +-------+-------------------------------+------+-----+---------+-------+
    
    #### 插入数据进行测试
    insert into test34_2(d) values(1751.2);
    		# 成功且有警告,虽然整数位超过了指定长度3,但sql_mode未开严格模式
    		# 所以到表中的数据是999.99
    
    insert into test34_2(d) values(-175.2);
    		# 成都且有警告,虽然整数位不能是负整数,但sql_mode未开严格模式
    		# 所以到表中的数据是00.00
    
    insert into test34_2(d) values(17.2);
    		# 成功,数据会到达表中,到表中的数据是17.2,最终显示的数据是17.20
    		# 整数位不够长度,不会前导0填充显示,即使加了zerofill属性
    		# 小数位不够长度,会后导0填充显示,这个和zerofill属性无关
    
    insert into test34_2(d) values(17.245);
    		# 成功,到表中的数据是17.25,显示的时候是17.25
    		# 整数位不够长度,不会前导0填充显示,即使加了zerofill属性;
    		# 小数位超过长度,会四舍五入;
    
    mysql> select * from test34_2;
    +--------+
    | d      |
    +--------+
    | 999.99 |
    |  00.00 |
    |  17.20 |
    |  17.25 |
    +--------+
    4 rows in set (0.00 sec)
    

    3.5 测试不加unsigned/zerofill属性

    注意:不加unsigned和zerofill属性,这样数值的整数位就可以是正整数或者负整数了

    sql_mode开启了严格模式,即sql_mode参数中包含strict_trans_tables变量

    #### 设置当前会话模式下,sql_mode开启严格模式,DML语句自动提交
    set session autocommit=on;
    set session sql_mode="strict_trans_tables";
    
    
    #### 创建test35_1表,并查看其表结构
    create table if not exists test35_1(
      d double(5,2)
    )engine=innodb character set utf8 collate utf8_general_ci;
    
       # f字段整数位的最大长度是3,小数位的最大长度是2;
       # 没有加unsigned/zerofill属性,那么整数位可以是正整数和负整数
       # 若插入数据的小数位长度没有达到指定的小数位长度,则会在小数后面用零填充显示;
       # 若插入数据的小数位长度刚好达到指定的小数位长度,则不会用零填充,也不会四舍五入;
       # 若插入数据的小数位长度已经超过指定的小数位长度,则会进行四舍五入;
    
    mysql> desc test35_1;
    +-------+-------------+------+-----+---------+-------+
    | Field | Type        | Null | Key | Default | Extra |
    +-------+-------------+------+-----+---------+-------+
    | d     | double(5,2) | YES  |     | NULL    |       |
    +-------+-------------+------+-----+---------+-------+
    1 row in set (0.00 sec)
    
    
    #### 插入测试数据进行测试
    insert into test35_1(d) values(1751.2);
    		# 直接报错,因为插入数值的整数位超过了指定的长度3位,且开启了严格模式
    		# 数据不会到达表中
    
    insert into test35_1(d) values(-175.2);
    		# 成功,因为没加unsigned/zerofill,整数位可以是负正整数,数据会到达表中是-175.20
    
    insert into test35_1(d) values(17.2);
            # 成功,插入到表中的数据是17.2,显示的时候是17.20,因为小数位长度不够2位,
            # 会在后面用零填充显示;
    
    insert into test35_1(d) values(17.245);
            # 成功,到表中的数据不是17.245,因为小数位超过指定的长度2了,会进行四舍五入
            # 最后到表中的数据是17.25,显示的时候也是17.25
    
    mysql> select * from test35_1;
    +---------+
    | d       |
    +---------+
    | -175.20 |
    |   17.20 |
    |   17.25 |
    +---------+
    3 rows in set (0.00 sec)
    

    sql_mode未开启严格模式,即sql_mode参数中不包含strict_trans_tables变量

    #### 设置当前会话模式下,sql_mode未开启严格模式,DML语句自动提交
    set session autocommit=on;
    set session sql_mode="";
    
    
    #### 创建test35_2表,并查看其表结构
    create table if not exists test35_2(
      d double(5,2)
    )engine=innodb character set utf8 collate utf8_general_ci;
    
       # f字段整数位的最大长度是3,小数位的最大长度是2;
       # 没有加unsigned/zerofill属性,那么整数位可以是正整数和负整数
       # 若插入数据的小数位长度没有达到指定的小数位长度,则会在小数后面用零填充显示;
       # 若插入数据的小数位长度刚好达到指定的小数位长度,则不会用零填充,也不会四舍五入;
       # 若插入数据的小数位长度已经超过指定的小数位长度,则会进行四舍五入;
    
    mysql> desc test35_2;
    +-------+-------------+------+-----+---------+-------+
    | Field | Type        | Null | Key | Default | Extra |
    +-------+-------------+------+-----+---------+-------+
    | d     | double(5,2) | YES  |     | NULL    |       |
    +-------+-------------+------+-----+---------+-------+
    1 row in set (0.00 sec)
    
    
    #### 插入测试数据进行测试
    insert into test35_2(d) values(1751.2);
            # 成功且警告,整数位超过长度3,但未开启严格模式;数据到表中是999.99
    
    insert into test35_2(d) values(-175.2);
    		# 成功,因为没加unsigned/zerofill,整数位可以是负正整数,数据会到达表中,-175.20
    
    
    insert into test35_2(d) values(17.2);
            # 成功,插入到表中的数据是17.2,显示的时候是17.20,因为小数位长度不够2位,
            # 会在后面用零填充显示;
    
    insert into test35_2(d) values(17.245);
            # 成功,到表中的数据不是17.245,因为小数位超过指定的长度2了,会进行四舍五入
            # 最后到表中的数据是17.25,显示的时候也是17.25
    
    mysql> select * from test35_2;
    +---------+
    | d       |
    +---------+
    |  999.99 |
    | -175.20 |
    |   17.20 |
    |   17.25 |
    +---------+
    4 rows in set (0.00 sec)
    


    第4章 小数数据类型decimal

    4.1 decimal的总结性说明

    注意:numeric只是decimal的一个同意词

    #### 格式
    id    decimal(M,D)      unsigned            zerofill
    字段名  数据类型(要指定的哈)   无符号(只针对整数位)   无符号(包含unsigned,只针对整数位,会前导0填充)
    
    
    #### decimal的M和D的最大值说明和示例
    M:"整数位""小数位"共多少位,最大65位(含小数在内,小数30位);所以整数位最大长度是35;
    D:表示"小数位"最大多少位,最大30位;
    示例1:decimal(65,30)    # 整数位最大长度35位,小数位最大长度30位;
    示例2:decimal(50,20)    # 整数位最大长度30位,小数位最大长度20位;
    
    
    #### 关于小数位的说明
    01:若插入数据的小数位长度没有达到指定的小数位长度,则会在小数后面用零填充显示(跟zerofill无关哈);
    02:若插入数据的小数位长度刚好达到指定的小数位长度,则不会用零填充,也不会四舍五入;
    03:若插入数据的小数位长度已经超过指定的小数位长度,则会进行四舍五入;
    
    
    #### 关于decimal数据类型小数位的精确度说明
    字段定义:decimal(65,30)  # 整数位最大长度35位,小数位最大长度30位
    定义说明:没加unsigned和zerofill是因它们都是针对整数位,而这里讨论的是小数位,跟他们没关系
    插入数据:insert into test12(d) values(1.555555555555555555555555555555);
    插入说明:往test12表中的d字段插入的数据是(整数位是1,小数位是30个5)
    显示结果:1.555555555555555555555555555555  <== 小数位精确度到了30位
    
    
    #### 生产环境下当字段指定的数据类型为 decimal(5,2) 的举例说明
    -- 加了unsigned属性
    	A:sql_mode开启了严格模式(sql_mode包含strict_trans_tables)
    	   插入1751.2   # 直接报错,因开了严格模式,且整数位超过指定的最大长度3
    	   插入-175.2   # 直接报错,因开了严格模式,且加了unsigned属性
    	   插入17.2     # 成功,整数位长度没超过指定长度3,显示的数据是17.20(小数位不够2位)
    	   插入17.245   # 成功,整数位长度没超过指定长度3,小数位超过长度会四舍五入,结果:17.25
    	
    	B:sql_mode未开启严格模式(sql_mode不包含strict_trans_tables)
    	   插入1751.2   # 成功且警告,虽然整数位超过了指定长度,但未开严格模式,到表中的数据是999.99
    	   插入-175.2   # 成功且警告,虽然加了unsigned属性(针对整数位),但未开严格模式,到表中数据是0.00
    	   插入17.2     # 成功,整数位长度没超过指定长度3,小数位不够长度,用0填充,最终结果:17.20
    	   插入17.245   # 成功,整数位长度没超过指定长度3,小数位超过长度,四舍五入,最终结果:17.25
    
    
    -- 加了zerofill属性
    	A:sql_mode开启了严格模式(sql_mode包含strict_trans_tables)
    	   插入1751.2    # 直接报错,因开了严格模式,且整数位超过指定的最大长度是3
    	   插入-175.2    # 直接报错,因为开了严格模式,且加了zerofill属性,整数位只能插入正整数;
    	   插入17.2      # 成功,整数位长度没超过指定长度3,小数位长度不够,用0填充,结果:017.20
    	   插入17.245    # 成功,整数位长度没超过指定长度3,小数位长度超过,四舍五入,结果:017.25
    	
    	B:sql_mode未开启严格模式(sql_mode不包含strict_trans_tables)
    	   插入1751.2    # 成功且警告,虽然整数位超过了指定长度,但未开严格模式,到表中的数据是999.99
    	   插入-175.2    # 成功且警告,虽然加了zerofill属性(针对整数位),但未开严格模式,到表中数据是000.00
    	   插入17.2      # 成功,整数位长度没超过指定长度3,小数位长度不够,用0填充,结果:017.20
    	   插入17.245    # 成功,整数位长度没超过指定长度3,小数位长度超过,四舍五入,结果:017.25
    
    
    -- 没加unsigned/zerofill属性
    	A:sql_mode开启了严格模式(sql_mode包含strict_trans_tables)
    	   插入1751.2    # 直接报错,因为开了严格模式,且指定的整数位最大长度是3
    	   插入-175.2    # 成功,因为没加unsigned或zerofill属性,且整数位没超过长度
    	   插入17.2      # 成功,整数位长度没超过指定长度3,小数位长度不够,用0填充,结果:17.20
    	   插入17.245    # 成功,整数位长度没超过指定长度3,小数位长度超过,四舍五入,结果:17.25
    	
    	B:sql_mode未开启严格模式(sql_mode不包含strict_trans_tables)
    	   插入1751.2    # 成功且警告,虽然整数位超过了指定长度,但未开严格模式,到表中的数据是999.99
    	   插入-175.2    # 成功,因为没加unsigned或zerofill属性,且整数位没超过长度
    	   插入17.2      # 成功,整数位长度没超过指定长度3,小数位长度不够,用0填充,结果:17.20
    	   插入17.245    # 成功,整数位长度没超过指定长度3,小数位长度超过,四舍五入,结果:17.25
    

    4.2 decimal数据类型的默认小数位精确度

    总结

    字段定义:decimal(65,30)  # 整数位最大长度35位,小数位最大长度30位
    定义说明:没加unsigned和zerofill是因它们都是针对整数位,而这里讨论的是小数位,跟他们没关系
    插入数据:insert into test12(d) values(1.555555555555555555555555555555);
    插入说明:往test12表中的d字段插入的数据是(整数位是1,小数位是30个5)
    显示结果:1.555555555555555555555555555555    <== 小数位精确度到了30位
    

    实践

    #### 创建test42表,并查看其表结构
    create table if not exists test42(
      d decimal(65,30)
    )engine=innodb character set utf8 collate utf8_general_ci;
    
    mysql> desc test42;
    +-------+----------------+------+-----+---------+-------+
    | Field | Type           | Null | Key | Default | Extra |
    +-------+----------------+------+-----+---------+-------+
    | d     | decimal(65,30) | YES  |     | NULL    |       |
    +-------+----------------+------+-----+---------+-------+
    1 row in set (0.00 sec)
    
    
    #### 插入测试数据
    mysql> insert into test42(d) values(1.555555555555555555555555555555);
    Query OK, 1 row affected (0.00 sec)
    
    mysql> select * from test42;
    +----------------------------------+
    | d                                |
    +----------------------------------+
    | 1.555555555555555555555555555555 |
    +----------------------------------+
    1 row in set (0.00 sec)
    

    4.3 测试unsigned属性

    注意:加了unsigned属性,那么整数位就只能是正整数

    sql_mode开启了严格模式,即sql_mode参数中包含strict_trans_tables

    #### 当前会话模式下,sql_mode开启严格模式,DML语句自动提交
    set session autocommit=on;
    set session sql_mode="strict_trans_tables";
    
    
    #### 创建test43_1表,并查看其表结构
    create table if not exists test43_1(
      d decimal(5,2) unsigned
    )engine=innodb character set utf8 collate utf8_general_ci;
       # f字段整数位的最大长度是3,小数位的最大长度是2;
       # 加了unsigned属性,那么整数位只能是正整数;
       # 若插入数据的小数位长度没有达到指定的小数位长度,则会在小数后面用零填充显示;
       # 若插入数据的小数位长度刚好达到指定的小数位长度,则不会用零填充,也不会四舍五入;
       # 若插入数据的小数位长度已经超过指定的小数位长度,则会进行四舍五入;
       
    mysql> desc test43_1;
    +-------+-----------------------+------+-----+---------+-------+
    | Field | Type                  | Null | Key | Default | Extra |
    +-------+-----------------------+------+-----+---------+-------+
    | d     | decimal(5,2) unsigned | YES  |     | NULL    |       |
    +-------+-----------------------+------+-----+---------+-------+
    1 row in set (0.00 sec)
    
    
    #### 插入测试数据
    insert into test43_1(d) values(1751.2);
    		# 直接报错,因为插入数值的整数位超过了指定的长度3位,且开启了严格模式
    		# 数据不会到达表中
    
    insert into test43_1(d) values(-175.2);
    		# 直接报错,因为加了unsigned,整数位只能是正整数,且sql_mode开启了严格模式,
    		# 数据不会到达表中
    
    insert into test43_1(d) values(17.2);
            # 成功,插入到表中的数据是17.2,显示的时候是17.20,因为小数位长度不够2位,
            # 会在后面用零填充显示; 最终的结果是:17.20
    
    insert into test43_1(d) values(17.245);
            # 成功,到表中的数据不是17.245,因为小数位超过指定的长度2了,会进行四舍五入
            # 最后到表中的数据是17.25,显示的时候也是17.25
    
    mysql> select * from test43_1;
    +---------+
    | d       |
    +---------+
    |   17.20 |
    |   17.25 |
    +---------+
    3 rows in set (0.00 sec)
    

    sql_mode未开启严格模式,即sql_mode参数中不包含strict_trans_tables

    #### 当前会话模式下,sql_mode不开启严格模式,DML语句自动提交
    set session autocommit=on;
    set session sql_mode="";
    
    
    #### 创建test43_2表,并查看其表结构
    create table if not exists test43_2(
      d decimal(5,2) unsigned
    )engine=innodb character set utf8 collate utf8_general_ci;
    
       # f字段整数位的最大长度是3,小数位的最大长度是2;
       # 加了unsigned属性,那么整数位只能是正整数;
       # 若插入数据的小数位长度没有达到指定的小数位长度,则会在小数后面用零填充显示;
       # 若插入数据的小数位长度刚好达到指定的小数位长度,则不会用零填充,也不会四舍五入;
       # 若插入数据的小数位长度已经超过指定的小数位长度,则会进行四舍五入;
       
    mysql> desc test43_2;
    +-------+-----------------------+------+-----+---------+-------+
    | Field | Type                  | Null | Key | Default | Extra |
    +-------+-----------------------+------+-----+---------+-------+
    | d     | decimal(5,2) unsigned | YES  |     | NULL    |       |
    +-------+-----------------------+------+-----+---------+-------+
    1 row in set (0.00 sec)
    
    
    #### 插入测试数据
    insert into test43_2(d) values(1751.2);
    		# 成功且有警告,按理说,整数位已经超过指定的长度3了,但sql_mode未开严格模式
    		# 数据会到达表中,到表中的数据是999.99
    
    insert into test43_2(d) values(-175.2);
    		# 成功且有警告,按理说,整数位应该是正整数,因为字段加了unsigned属性,但示开严格模
    		# 式,数据会到达表,到表中的数据是0.00
    
    insert into test43_2(d) values(17.2);
            # 成功,插入到表中的数据是17.2,显示的时候是17.20,因为小数位长度不够2位,
            # 会在后面用零填充显示;
    
    insert into test43_2(d) values(17.245);
            # 成功,到表中的数据不是17.245,因为小数位超过指定的长度2了,会进行四舍五入
            # 最后到表中的数据是17.25,显示的时候也是17.25
    
    mysql> select * from test43_2;
    +--------+
    | d      |
    +--------+
    | 999.99 |
    |   0.00 |
    |  17.20 |
    |  17.25 |
    +--------+
    4 rows in set (0.00 sec)
    

    4.4 测试zerofill属性

    注意:加上zerofill会把unsigned也给带上,它针对整数位(只能插入正整数),会前导0填充

    sql_mode开启了严格模式,即sql_mode参数中包含strict_trans_tables

    #### 当前会话模式下,sql_mode开启严格模式,DML语句自动提交
    set session autocommit=on;
    set session sql_mode="strict_trans_tables";
    
    
    #### 创建test44_1表,并查看其表结构
    create table if not exists test44_1(
      d decimal(5,2) zerofill
    )engine=innodb character set utf8 collate utf8_general_ci;
    
       # f字段整数位的最大长度是3,小数位的最大长度是2;
       # 加了unsigned属性,那么整数位只能是正整数;
       # 若插入数据的小数位长度没有达到指定的小数位长度,则会在小数后面用零填充显示;
       # 若插入数据的小数位长度刚好达到指定的小数位长度,则不会用零填充,也不会四舍五入;
       # 若插入数据的小数位长度已经超过指定的小数位长度,则会进行四舍五入;
       
    mysql> desc test44_1;
    +-------+--------------------------------+------+-----+---------+-------+
    | Field | Type                           | Null | Key | Default | Extra |
    +-------+--------------------------------+------+-----+---------+-------+
    | d     | decimal(5,2) unsigned zerofill | YES  |     | NULL    |       |
    +-------+--------------------------------+------+-----+---------+-------+
    1 row in set (0.00 sec)
    
    
    #### 插入测试数据
    insert into test44_1(d) values(1751.2);
    		# 直接报错,因为插入数值的整数位超过了指定的长度3位,且开启了严格模式
    		# 数据不会到达表中
    
    insert into test44_1(d) values(-175.2);
    		# 直接报错,因为加了zerofill,整数位只能是正整数,且sql_mode开启了严格模式,
    		# 数据不会到达表中
    
    insert into test44_1(d) values(17.2);
            # 成功,插入到表中的数据是17.2,显示的时候是017.20,因为小数位长度不够2位,
            # 会在后面用零填充显示;显示的结果是017.20
    
    insert into test44_1(d) values(17.245);
            # 成功,到表中的数据不是17.245,因为小数位超过指定的长度2了,会进行四舍五入
            # 最后到表中的数据是17.25,显示的时候是017.25
    
    mysql> select * from test44_1;
    +---------+
    | d       |
    +---------+
    |  017.20 |
    |  017.25 |
    +---------+
    3 rows in set (0.00 sec)
    

    sql_mode未开启严格模式,即sql_mode参数中不包含strict_trans_tables

    #### 当前会话模式下,sql_mode不开启严格模式,DML语句自动提交
    set session autocommit=on;
    set session sql_mode="";
    
    
    #### 创建test15_1表,并查看其表结构
    create table if not exists test44_2(
      d decimal(5,2) zerofill
    )engine=innodb character set utf8 collate utf8_general_ci;
    
       # f字段整数位的最大长度是3,小数位的最大长度是2;
       # 加了unsigned属性,那么整数位只能是正整数;
       # 若插入数据的小数位长度没有达到指定的小数位长度,则会在小数后面用零填充显示;
       # 若插入数据的小数位长度刚好达到指定的小数位长度,则不会用零填充,也不会四舍五入;
       # 若插入数据的小数位长度已经超过指定的小数位长度,则会进行四舍五入;
    
    mysql> desc test44_2;
    +-------+--------------------------------+------+-----+---------+-------+
    | Field | Type                           | Null | Key | Default | Extra |
    +-------+--------------------------------+------+-----+---------+-------+
    | d     | decimal(5,2) unsigned zerofill | YES  |     | NULL    |       |
    +-------+--------------------------------+------+-----+---------+-------+
    1 row in set (0.00 sec)
    
    
    #### 插入测试数据
    insert into test44_2(d) values(1751.2);
    		# 成功且有警告,按理说,整数位已经超过指定的长度3了,但sql_mode未开严格模式
    		# 数据会到达表中,到表中的数据是999.99
    
    insert into test44_2(d) values(-175.2);
    		# 成功且有警告,按理说,整数位应该是正整数,因为字段加了unsigned属性,但示开严格模
    		# 式,数据会到达表,到表中的数据是000.00
    
    insert into test44_2(d) values(17.2);
            # 成功,插入到表中的数据是17.2,显示的时候是017.20,因为小数位长度不够2位,
            # 会在后面用零填充显示;最终显示的结果是:017.20
    
    insert into test44_2(d) values(17.245);
            # 成功,到表中的数据不是17.245,因为小数位超过指定的长度2了,会进行四舍五入
            # 最后到表中的数据是17.25,显示的时候也是017.25
    
    mysql> select * from test44_2;
    +--------+
    | d      |
    +--------+
    | 999.99 |
    | 000.00 |
    | 017.20 |
    | 017.25 |
    +--------+
    4 rows in set (0.00 sec)
    

    4.5 测试不加unsigned/zerofill属性

    注意:不加unsigned/zerofill属性,整数位就可以是正整数和负整数

    sql_mode开启了严格模式,即sql_mode参数中包含strict_trans_tables

    #### 当前会话模式下,sql_mode开启严格模式,DML语句自动提交
    set session autocommit=on;
    set session sql_mode="strict_trans_tables";
    
    
    #### 创建test45_1表,并查看其表结构
    create table if not exists test45_1(
      d decimal(5,2)
    )engine=innodb character set utf8 collate utf8_general_ci;
    
       # f字段整数位的最大长度是3,小数位的最大长度是2;
       # 没有加unsigned/zerofill属性,那么整数位可以是正整数和负整数
       # 若插入数据的小数位长度没有达到指定的小数位长度,则会在小数后面用零填充显示;
       # 若插入数据的小数位长度刚好达到指定的小数位长度,则不会用零填充,也不会四舍五入;
       # 若插入数据的小数位长度已经超过指定的小数位长度,则会进行四舍五入;
    
    mysql> desc test45_1;
    +-------+--------------+------+-----+---------+-------+
    | Field | Type         | Null | Key | Default | Extra |
    +-------+--------------+------+-----+---------+-------+
    | d     | decimal(5,2) | YES  |     | NULL    |       |
    +-------+--------------+------+-----+---------+-------+
    1 row in set (0.00 sec)
    
    
    #### 插入测试数据进行测试
    insert into test45_1(d) values(1751.2);
    		# 直接报错,因为整数位超过了指定的长度3位,且开启了严格模式
    		# 所以会直接报错,数据不会到达表中
    
    insert into test45_1(d) values(-175.2);
    		# 成功,因为没加unsigned/zerofill属性,整数位是可以插入正整数和负整数的
    		# 整数位达到了指定长度,小数位没有达到指定长度(后面0填充)
    		# 最终的结果是:-175.20
    
    insert into test45_1(d) values(17.2);
            # 成功,因为没加unsigned/zerofill属性,整数位是可以插入正整数和负整数的
            # 整数位在指定长度范围内,小数位没有达到指定长度(后面0填充)
            # 最终的显示结果是:17.20
    
    insert into test45_1(d) values(17.245);
            # 成功,因为没加unsigned/zerofill属性,整数位是可以插入正整数和负整数的
            # 整数位在指定长度范围内,小数位超过了指定长度会四舍五入
            # 最终的结果是:17.25
    
    mysql> select * from test45_1;
    +---------+
    | d       |
    +---------+
    | -175.20 |
    |   17.20 |
    |   17.25 |
    +---------+
    3 rows in set (0.00 sec)
    

    sql_mode未开启严格模式,即sql_mode参数中不包含strict_trans_tables

    #### 当前会话模式下,sql_mode不开启严格模式,DML语句自动提交
    set session autocommit=on;
    set session sql_mode="";
    
    
    #### 创建test45_2表,并查看其表结构
    create table if not exists test45_2(
      d decimal(5,2)
    )engine=innodb character set utf8 collate utf8_general_ci;
    
       # f字段整数位的最大长度是3,小数位的最大长度是2;
       # 没有加unsigned/zerofill属性,那么整数位可以是正整数和负整数
       # 若插入数据的小数位长度没有达到指定的小数位长度,则会在小数后面用零填充显示;
       # 若插入数据的小数位长度刚好达到指定的小数位长度,则不会用零填充,也不会四舍五入;
       # 若插入数据的小数位长度已经超过指定的小数位长度,则会进行四舍五入;
    
    mysql> desc test45_2;
    +-------+--------------+------+-----+---------+-------+
    | Field | Type         | Null | Key | Default | Extra |
    +-------+--------------+------+-----+---------+-------+
    | d     | decimal(5,2) | YES  |     | NULL    |       |
    +-------+--------------+------+-----+---------+-------+
    1 row in set (0.00 sec)
    
    
    #### 插入测试数据进行测试
    insert into test45_2(d) values(1751.2);
    		# 成功且有警告,因为没加unsigned/zerofill属性,整数是可以插入正整数和负整数的
    		# 整数位超过了指定长度,但未开启严格模式
    		# 所以最终的结果是:999.99
    
    insert into test45_2(d) values(-175.2);
    		# 成功,因为没加unsigned/zerofill属性,整数位是可以插入正整数和负整数的
    		# 整数位达到了指定长度,小数位没有达到指定长度(后面0填充)
    		# 最终的结果是:-175.20
    
    insert into test45_2(d) values(17.2);
            # 成功,因为没加unsigned/zerofill属性,整数位是可以插入正整数和负整数的
            # 整数位在指定长度范围内,小数位没有达到指定长度(后面0填充)
            # 最终的显示结果是:17.20
    
    insert into test45_2(d) values(17.245);
            # 成功,因为没加unsigned/zerofill属性,整数位是可以插入正整数和负整数的
            # 整数位在指定长度范围内,小数位超过了指定长度会四舍五入
            # 最终的结果是:17.25
    
    mysql> select * from test45_2;
    +---------+
    | d       |
    +---------+
    |  999.99 |
    | -175.20 |
    |   17.20 |
    |   17.25 |
    +---------+
    4 rows in set (0.00 sec)
    
    展开全文
  • XSD 小数数据类型

    千次阅读 2007-04-06 14:51:00
    Decimal data types are ...小数数据类型用于定义数值Decimal Data Type小数数据类型The decimal data type is used to specify a numeric value.小数数据类型用于指定一个数值The following is an example of a decima

    Decimal data types are used for numeric values.
    小数数据类型用于定义数值


    Decimal Data Type
    小数数据类型

    The decimal data type is used to specify a numeric value.
    小数数据类型用于指定一个数值

    The following is an example of a decimal declaration in a schema:
    下面是在schema(XML公式)里关于小数声明的例子

    <xs:element name="prize" type="xs:decimal"/>

    An element in your document might look like this:
    你文档中的一个元素也许会像这样:

    <prize>999.50</prize>

    Or it might look like this:
    或者会像这样:

    <prize>+999.5450</prize>

    Or it might look like this:
    又或者像这样:

    <prize>-999.5230</prize>

    Or it might look like this:
    也可能这样:

    <prize>0</prize>

    Or it might look like this:
    当然,也会是这样:

    <prize>14</prize>

    Note: The maximum number of decimal digits you can specify is 18.
    注意:可以指定的小数位数最多是18位。


    Integer Data Type
    整数数据类型

    The integer data type is used to specify a numeric value without a fractional component.
    整数数据类型用于指定没有小数部分的数值。

    The following is an example of an integer declaration in a schema:
    下面是的关于整数在schema里的声明方法的例子。

    <xs:element name="prize" type="xs:integer"/>

    An element in your document might look like this:
    你文档中也许有这样的元素:

    <prize>999</prize>

    Or it might look like this:
    或许是这样:

    <prize>+999</prize>

    Or it might look like this:
    也可能是这样:

    <prize>-999</prize>

    Or it might look like this:
    当然也会是这样:

    <prize>0</prize>


    Numeric Data Types
    数字数据类型

    Note that all of the data types below derive from the Decimal data type (except for decimal itself)!
    要注意的是下面所有的数据类型都是从小数数据类型里派生出来的(除了小数自身)

    Name
    名称
    Description
    解释
    byte A signed 8-bit integer
    最大8位的带符号整数
    decimal A decimal value
    小数数值
    int A signed 32-bit integer
    最大32位的带符号整数
    integer An integer value
    整数值
    long A signed 64-bit integer
    最大64位的带符号整数
    negativeInteger An integer containing only negative values ( .., -2, -1.)
    含有负值的整数 ( .., -2, -1.)
    nonNegativeInteger An integer containing only non-negative values (0, 1, 2, ..)
    含有非负值的整数 (0, 1, 2, ..)
    nonPositiveInteger An integer containing only non-positive values (.., -2, -1, 0)
    含有非正值的整数 (.., -2, -1, 0)
    positiveInteger An integer containing only positive values (1, 2, ..)
    只含有正值的整数(1, 2, ..)
    short A signed 16-bit integer
    最大16位的带符号整数
    unsignedLong An unsigned 64-bit integer
    最大64位的不带符号整数
    unsignedInt An unsigned 32-bit integer
    最大32位的不带符号整数
    unsignedShort An unsigned 16-bit integer
    最大16位的不带符号整数
    unsignedByte An unsigned 8-bit integer
    最大8位的不带符号整数


    Restrictions on Numeric Data Types
    对字数据类型的约束

    Restrictions that can be used with Numeric data types:
    可用于约束的数字数据类型:

    • enumeration
      列举
    • fractionDigits
      小数位数
    • maxExclusive
       除去最大值
    • maxInclusive
      包括最大值
    • minExclusive
      除去最小值
    • minInclusive
      包括最小值
    • pattern
      式样类型
    • totalDigits
      总的数字位数
    • whiteSpace
      空白部分

     
    展开全文
  • 小数数据类型double

    2020-05-06 14:39:48
    1.1 double的总结 #### 格式 ...字段名 数据类型(建表地要指定M和D,根据你的业务) 无符号(整数位只能是正整数) 无符号(含unsigned,整数位不会前导0填充显示) #### double的M和D说明和示例 M:表示"整数...

    1.1 double的总结

    1

    #### 格式
    id      double(M,D)                       unsigned                zerofill
    字段名  数据类型(建表地要指定M和D,根据你的业务)  无符号(整数位只能是正整数)  无符号(含unsigned,整数位不会前导0填充显示)
    
    #### double的M和D说明和示例
    M:表示"整数位""小数位"共多少位,M最大255位(包含小数位在内,小数30位);所以整数位最大长度是225;
    D:表示"小数位"最大多少位,最大30位;
    示例1:double(255,30)   # 整数位最大长度225位,小数位最大长度30位;
    示例2:double(50,20)    # 整数位最大长度30位,小数位最大长度20位;
    
    #### double关于小数的四舍五入(最大精度)
    例1:f double(255,30)  
    插入数据:insert into test12(f) values(1.555555555555555555555555555555);
              # 结果是:1.555555555555555600000000000000
              # 可以看出小数位的第16位就不准确了,只准确到了第15位小数位;
    
    ####  unsigned/zerofill实践(且为double指定整数位和小数位长度)
    例1:f double(5,2) unsigned      例2:f double(5,2) zerofill
    说明点一:double(5,2)
    01:f字段的值的"整数位"最大长度是3位,"小数位"的长度最大是2位;
    02:只要"整数位"的长度超过3位(sql_mode严格模式,直接报错;sql_mode未严格,警告,到表中的数据是999.99)
    03:若只有"小数位"的长度超过2位(小数会根据第3位进行四舍五入,但小数最终只显示2位,不管你的sql_mode是否开启严格模式)
    04:若"小数位"的长度不够2位时,在"小数位"后面用0填充来显示
    
    说明点二:unsigned和zerofill
    01:表示f字段的值的"整数位"只能是"正整数"
    02:当有zerofill时,不管sql_mode有没有开启严格模式,"整数位"的长度都不会前导师0填充
    
    ####  无unsigned/zerofill(且为float指定整数位和小数位长度)
    例1:f double(5,2)
    说明点一:double(5,2)
    01:f字段的值的"整数位"最大长度是3位,"小数位"的长度最大是2位;
    02:只要"整数位"的长度超过3位(sql_mode严格模式,直接报错;sql_mode未严格,警告,到表中的数据是999.99)
    03:若只有"小数位"的长度超过2位(小数会根据第3位进行四舍五入,但小数最终只显示2位,不管你的sql_mode是否开启严格模式)
    04:若"小数位"的长度不够2位时,在"小数位"后面用0填充来显示
    
    说明点二:无unsigned和zerofill
    表示f字段的值的"整数位"可以是"正整数""负整数"
    

    1.2 实践一(看一看double的小数位精度)

    总结

    字段定义:f double(255,30)  
    插入数据:insert into test13(f) values(1.555555555555555555555555555555);
             # 结果是:1.555555555555555600000000000000
             # 可以看出小数位的第16位就不准确了,只准确到了第15位小数位;
    

    实践

    ## 创建test12表
    create table if not exists test12(
    	f double(255,30)
    )engine=innodb character set utf8 collate utf8_general_ci comment"测试表12";
    
    ## 查看tst12表的表结构
    mysql> desc test13;
    +-------+---------------+------+-----+---------+-------+
    | Field | Type          | Null | Key | Default | Extra |
    +-------+---------------+------+-----+---------+-------+
    | f     | double(255,30)| YES  |     | NULL    |       |
    +-------+---------------+------+-----+---------+-------+
    1 row in set (0.00 sec)
    
    ## 插入测试数据
    mysql> insert into test12(f) values(1.555555555555555555555555555555);
    Query OK, 1 row affected (0.01 sec)
    
    mysql> select * from test12;
    +----------------------------------+
    | f                                |
    +----------------------------------+
    | 1.555555555555555600000000000000 |
    +----------------------------------+
    1 row in set (0.00 sec)
    

    1.3 实践二(double指定M和D,且加unsigned)

    SQL_MODE开启了严格模式

    ## 设置当前会话模式下sql_mode包含严格模式(即包含STRICT_TRANS_TABLES变量)
    mysql> set session sql_mode="STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_AUTO_CREATE_USER,NO_ENGINE_SUBSTITUTION";
    Query OK, 0 rows affected (0.00 sec)
    
    mysql> select @@sql_mode\G
    *************************** 1. row ***************************
    @@sql_mode: STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_AUTO_CREATE_USER,NO_ENGINE_SUBSTITUTION
    1 row in set (0.00 sec)
    
    ## 创建test13_1表
    create table if not exists test13_1(
      f double(5,2) unsigned
    )engine=innodb character set utf8 collate utf8_general_ci comment"测试表13_1";
    
        ## 说明点一:double(5,2)
        01:f字段指定了double(5,2),"整数位"最大长度最大3位,"小数位"最大长度2位
        02:当整数位的长度不够3位长度时,不会前导0填充进行显示,加zerofill也不会前导0填充
        03:当小数位的长度不够2位长度时,不会前导0填充进行显示,会在小数后用0补充来显示;
    
        04:只要整数位的长度超过3时,会直接报错(因为sql_mode开启了严格模式),数据不会到表中
        05:若只有小数位的长度超过2时,会根据小数位的第3位进行四舍五入,但最终显示的还是2位
    
        ## 说明点二:unsigned
        因为加了无符号(unsigne)限制,所以f字段的值的整数位只能是"正整数";
    
    ## 查看test13_1表的表结构
    mysql> desc test13_1;
    +-------+---------------------+------+-----+---------+-------+
    | Field | Type                | Null | Key | Default | Extra |
    +-------+---------------------+------+-----+---------+-------+
    | f     | double(5,2) unsigned | YES  |     | NULL    |       |
    +-------+---------------------+------+-----+---------+-------+
    1 row in set (0.00 sec)
    
    ## 插入数据测试"说明点一"和"说明点二"
    insert into test13_1(f) values(17.5);    # 结果:17.50
    insert into test13_1(f) values(170.50);  # 结果:170.50
    insert into test13_1(f) values(170.56);  # 结果:170.56
    insert into test13_1(f) values(170.566); # 结果:170,57(小数位第3位的6四舍五入)
    insert into test13_1(f) values(1777.56); # 报错(sql_mode开启了严格模式),数据不会到表中
    
    ## 查看test13_1表中的所有数据
    mysql> select * from test13_1;
    +--------+
    | f      |
    +--------+
    |  17.50 |
    | 170.50 |
    | 170.56 |
    | 170.57 |
    +--------+
    4 rows in set (0.00 sec)
    

    sql_mode未开启严格模式

    ## 设置当前会话模式下sql_mode不包含严格模式(即不包含STRICT_TRANS_TABLES变量)
    mysql> set session sql_mode="NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_AUTO_CREATE_USER,NO_ENGINE_SUBSTITUTION";
    Query OK, 0 rows affected (0.00 sec)
    
    mysql> select @@sql_mode\G
    *************************** 1. row ***************************
    @@sql_mode: NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_AUTO_CREATE_USER,NO_ENGINE_SUBSTITUTION
    1 row in set (0.00 sec)
    
    ## 创建test13_2表
    create table if not exists test13_2(
      f double(5,2) unsigned
    )engine=innodb character set utf8 collate utf8_general_ci comment"测试表13_2";
    
        ## 说明点一:double(5,2)
        01:f字段指定了float(5,2),"整数位"最大长度最大3位,"小数位"最大长度2位
        02:当整数位的长度不够3位长度时,不会前导0填充进行显示,加zerofill也不会前导0填充
        03:当小数位的长度不够2位长度时,不会前导0填充进行显示,会在小数后用0补充来显示;
        04:若要整数位的长度超过3时,不会直接报错(因为sql_mode未开启了严格模式),最终到表中的数据是999.99
        05:若只有小数位的长度超过2时,会根据小数位的第3位进行四舍五入,但最终显示的还是2位
    
        ## 说明点二:unsigned
        因为加了无符号(unsigne)限制,所以f字段的值的整数位只能是"正整数";
      
    ## 查看test13_2表的表结构
    mysql> desc test13_2;
    +-------+---------------------+------+-----+---------+-------+
    | Field | Type                | Null | Key | Default | Extra |
    +-------+---------------------+------+-----+---------+-------+
    | f     | double(5,2) unsigned | YES  |     | NULL    |       |
    +-------+---------------------+------+-----+---------+-------+
    1 row in set (0.00 sec)
    
    ## 插入数据测试"说明点二"和"说明点三"
    insert into test13_2(f) values(17.5);     # 结果:17.50
    insert into test13_2(f) values(170.50);   # 结果:170.50
    insert into test13_2(f) values(170.56);   # 结果:170.56
    insert into test13_2(f) values(170.566);  # 结果:170,57(小数位第3位的6四舍五入)
    insert into test13_2(f) values(1777.56);  # 警告(sql_mode未开启了严格模式),到表中的数
    # 据为999.99
    
    ## 查看test13_2表中的所有数据
    mysql> select * from test13_2;
    +--------+
    | f      |
    +--------+
    |  17.50 |
    | 170.50 |
    | 170.56 |
    | 170.57 |
    | 999.99 |
    +--------+
    5 rows in set (0.00 sec)
    

    1.4 实践三(double指定M和D,且加zerofill)

    SQL_MODE开启了严格模式

    ## 设置当前会话模式下sql_mode包含严格模式(即包含STRICT_TRANS_TABLES变量)
    mysql> set session sql_mode="STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_AUTO_CREATE_USER,NO_ENGINE_SUBSTITUTION";
    Query OK, 0 rows affected (0.00 sec)
    
    mysql> select @@sql_mode\G
    *************************** 1. row ***************************
    @@sql_mode: STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_AUTO_CREATE_USER,NO_ENGINE_SUBSTITUTION
    1 row in set (0.00 sec)
    
    ## 创建test14_1表
    create table if not exists test14_1(
      f double(5,2) zerofill
    )engine=innodb character set utf8 collate utf8_general_ci comment"测试表14_1";
    
        ## 说明点一:double(5,2)
        01:f字段指定了double(5,2),"整数位"最大长度最大3位,"小数位"最大长度2位
        02:当整数位的长度不够3位长度时,不会前导0填充进行显示,加zerofill也不会前导0填充
        03:当小数位的长度不够2位长度时,不会前导0填充进行显示,会在小数后用0补充来显示;
    
        04:只要整数位的长度超过3时,会直接报错(因为sql_mode开启了严格模式),数据不会到表中
        05:若只有小数位的长度超过2时,会根据小数位的第3位进行四舍五入,但最终显示的还是2位
    
        ## 说明点二:unsigned
        因为加了无符号(unsigne)限制,所以f字段的值的整数位只能是"正整数";
    
    ## 查看test14_1表的表结构
    mysql> desc test14_1;
    +-------+-------------------------------+------+-----+---------+-------+
    | Field | Type                          | Null | Key | Default | Extra |
    +-------+-------------------------------+------+-----+---------+-------+
    | f     | double(5,2) unsigned zerofill | YES  |     | NULL    |       |
    +-------+-------------------------------+------+-----+---------+-------+
    1 row in set (0.00 sec)
    
    
    ## 插入数据测试"说明点一"和"说明点二"
    insert into test14_1(f) values(17.5);    # 结果:17.50
    insert into test14_1(f) values(170.50);  # 结果:170.50
    insert into test14_1(f) values(170.56);  # 结果:170.56
    insert into test14_1(f) values(170.566); # 结果:170,57(小数位第3位的6四舍五入)
    insert into test14_1(f) values(1777.56); # 报错(sql_mode开启了严格模式),数据不会到表中
    
    ## 查看test14_1表中的所有数据
    mysql> select * from test14_1;
    +--------+
    | f      |
    +--------+
    |  17.50 |
    | 170.50 |
    | 170.56 |
    | 170.57 |
    +--------+
    4 rows in set (0.00 sec)
    

    SQL_MODE未开启严格模式

    ## 设置当前会话模式下sql_mode不包含严格模式(即不包含STRICT_TRANS_TABLES变量)
    mysql> set session sql_mode="NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_AUTO_CREATE_USER,NO_ENGINE_SUBSTITUTION";
    Query OK, 0 rows affected (0.00 sec)
    
    mysql> select @@sql_mode\G
    *************************** 1. row ***************************
    @@sql_mode: NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_AUTO_CREATE_USER,NO_ENGINE_SUBSTITUTION
    1 row in set (0.00 sec)
    
    ## 创建test14_2表
    create table if not exists test14_2(
      f double(5,2) zerofill
    )engine=innodb character set utf8 collate utf8_general_ci comment"测试表14_2";
    
        ## 说明点一:double(5,2)
        01:f字段指定了float(5,2),"整数位"最大长度最大3位,"小数位"最大长度2位
        02:当整数位的长度不够3位长度时,不会前导0填充进行显示,加zerofill也不会前导0填充
        03:当小数位的长度不够2位长度时,不会前导0填充进行显示,会在小数后用0补充来显示;
        04:若要整数位的长度超过3时,不会直接报错(因为sql_mode未开启了严格模式),最终到表中的数据是999.99
        05:若只有小数位的长度超过2时,会根据小数位的第3位进行四舍五入,但最终显示的还是2位
    
        ## 说明点二:unsigned
        因为加了无符号(unsigne)限制,所以f字段的值的整数位只能是"正整数";
      
    ## 查看test14_2表的表结构
    mysql> desc test14_2;
    +-------+-------------------------------+------+-----+---------+-------+
    | Field | Type                          | Null | Key | Default | Extra |
    +-------+-------------------------------+------+-----+---------+-------+
    | f     | double(5,2) unsigned zerofill | YES  |     | NULL    |       |
    +-------+-------------------------------+------+-----+---------+-------+
    1 row in set (0.00 sec)
    
    ## 插入数据测试"说明点二"和"说明点三"
    insert into test14_2(f) values(17.5);     # 结果:17.50
    insert into test14_2(f) values(170.50);   # 结果:170.50
    insert into test14_2(f) values(170.56);   # 结果:170.56
    insert into test14_2(f) values(170.566);  # 结果:170,57(小数位第3位的6四舍五入)
    insert into test14_2(f) values(1777.56);  # 警告(sql_mode未开启了严格模式),到表中的数据为999.99
    
    ## 查看test14_2表中的所有数据
    mysql> select * from test14_2;
    +--------+
    | f      |
    +--------+
    |  17.50 |
    | 170.50 |
    | 170.56 |
    | 170.57 |
    | 999.99 |
    +--------+
    5 rows in set (0.00 sec)
    
    展开全文
  • 小数数据类型float

    2020-05-06 14:30:51
    文章目录1.1 float的总结1.2 实践一(看一看float的小数位精确度)1.3 实践二(float指定M和D,加unsigned)1.4 实践三(float指定M和D,加zerofill)) 1.1 float的总结 #### 格式 id float(M,D) unsigned zerofill 字段...

    1.1 float的总结

    1

    #### 格式
    id     float(M,D)                         unsigned                 zerofill
    字段名  数据类型(建表地要指定M和D,根据你的业务)  无符号(整数位只能是正整数)   无符号(包含unsigned,整数位    不会前导0填充)
    
    #### float的M和D说明和示例
    M:表示"整数位""小数位"共多少位,M最大255位(包含小数位在内,小数30位),所以整数位最大长度是225;
    D:表示"小数位"最大多少位,最大30位;
    示例1:float(255,30)   # 整数位最大长度225位,小数位最大长度30位;
    示例2:float(50,20)    # 整数位最大长度30位,小数位最大长度20位;
    
    
    #### float关于小数的四舍五入(看一看小数位的最大精度)
    例1:f float(255,30)  例2:f float(255,30) unsigned  例3:f float(255,30) zerofill
    插入数据:insert into test12(f) values(1.555555555555555555555555555555);
            # 结果是:1.555555582046508800000000000000
            # 可以看出小数位的第8位就不准确了,只准确到了第7位小数位;
    
    ####  unsigned/zerofill实践(且为float指定整数位和小数位长度)
    例1:f float(5,2) unsigned      例2:f float(5,2) zerofill
    说明点一:float(5,2)
    01:f字段的值的"整数位"最大长度是3位,"小数位"的长度最大是2位;
    02:只要"整数位"的长度超过3位(sql_mode严格模式,直接报错;sql_mode未严格,警告,到表中的数据是999.99)
    03:若只有"小数位"的长度超过2位(小数会根据第3位进行四舍五入,但小数最终只显示2位,不管你的sql_mode是否开启严格模式)
    04:若"小数位"的长度不够2位时,在"小数位"后面用0填充来显示
    
    说明点二:unsigned和zerofill
    01:表示f字段的值的"整数位"只能是"正整数"
    02:当有zerofill时,不管sql_mode有没有开启严格模式,"整数位"的长度都不会前导0填充显示
    
    
    ####  无unsigned/zerofill(且为float指定整数位和小数位长度)
    例1:f float(5,2)
    说明点一:float(5,2)
    01:f字段的值的"整数位"最大长度是3位,"小数位"的长度最大是2位;
    02:只要"整数位"的长度超过3位(sql_mode严格模式,直接报错;sql_mode未严格,警告,到表中的数据是999.99)
    03:若只有"小数位"的长度超过2位(小数会根据第3位进行四舍五入,但小数最终只显示2位,不管你的sql_mode是否开启严格模式)
    04:若"小数位"的长度不够2位时,在"小数位"后面用0填充来显示
    
    说明点二:无unsigned和zerofill
    表示f字段的值的"整数位"可以是"正整数""负整数"
    

    1.2 实践一(看一看float的小数位精确度)

    总结

    字段定义:f float(255,30)  
    插入数据:insert into test13(f) values(1.555555555555555555555555555555);
              # 结果是:1.555555582046508800000000000000
              # 可以看出小数位的第8位就不准确了,只准确到了第7位小数位;
    

    实践

    ## 创建test12表
    create table if not exists test12(
    	f float(255,30)
    )engine=innodb character set utf8 collate utf8_general_ci comment"测试表12";
    
    ## 查看tst12表的表结构
    mysql> desc test12;
    +-------+---------------+------+-----+---------+-------+
    | Field | Type          | Null | Key | Default | Extra |
    +-------+---------------+------+-----+---------+-------+
    | f     | float(255,30) | YES  |     | NULL    |       |
    +-------+---------------+------+-----+---------+-------+
    1 row in set (0.00 sec)
    
    ## 插入测试数据
    mysql> insert into test12(f) values(1.555555555555555555555555555555);
    Query OK, 1 row affected (0.01 sec)
    
    mysql> select * from test12;
    +----------------------------------+
    | f                                |
    +----------------------------------+
    | 1.555555582046508800000000000000 |
    +----------------------------------+
    1 row in set (0.00 sec)
    

    1.3 实践二(float指定M和D,加unsigned)

    SQL模式开启了严格模式

    ## 设置当前会话模式下sql_mode包含严格模式(即包含STRICT_TRANS_TABLES变量)
    mysql> set session sql_mode="STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_AUTO_CREATE_USER,NO_ENGINE_SUBSTITUTION";
    Query OK, 0 rows affected (0.00 sec)
    
    mysql> select @@sql_mode\G
    *************************** 1. row ***************************
    @@sql_mode: STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_AUTO_CREATE_USER,NO_ENGINE_SUBSTITUTION
    1 row in set (0.00 sec)
    
    ## 创建test13_1表
    create table if not exists test13_1(
      f float(5,2) unsigned
    )engine=innodb character set utf8 collate utf8_general_ci comment"测试表13_1";
    
       ## 说明点一:float(5,2)
        01:f字段指定了float(5,2),"整数位"最大长度最大3位,"小数位"最大长度2位
        02:当整数位的长度不够3位长度时,不会前导0填充进行显示,加zerofill也不会前导0填充
        03:当小数位的长度不够2位长度时,不会前导0填充进行显示,会在小数后用0补充来显示;
    
        04:只要整数位的长度超过3时,会直接报错(因为sql_mode开启了严格模式),数据不会到表中
        05:若只有小数位的长度超过2时,会根据小数位的第3位进行四舍五入,但最终显示的还是2位
    
        ## 说明点二:unsigned
        因为加了无符号(unsigne)限制,所以f字段的值的整数位只能是"正整数";
    
    ## 查看test13_1表的表结构
    mysql> desc test13_1;
    +-------+---------------------+------+-----+---------+-------+
    | Field | Type                | Null | Key | Default | Extra |
    +-------+---------------------+------+-----+---------+-------+
    | f     | float(5,2) unsigned | YES  |     | NULL    |       |
    +-------+---------------------+------+-----+---------+-------+
    1 row in set (0.00 sec)
    
    
    ## 插入数据测试"说明点一"和"说明点二"
    insert into test13_1(f) values(17.5);    # 结果:17.50
    insert into test13_1(f) values(170.50);  # 结果:170.50
    insert into test13_1(f) values(170.56);  # 结果:170.56
    insert into test13_1(f) values(170.566); # 结果:170,57(小数位第3位的6四舍五入)
    insert into test13_1(f) values(1777.56); # 报错(sql_mode开启了严格模式),数据不会到表中
    
    ## 查看test13_1表中的全部数据
    mysql> select * from test13_1;
    +--------+
    | f      |
    +--------+
    |  17.50 |
    | 170.50 |
    | 170.56 |
    | 170.57 |
    +--------+
    4 rows in set (0.00 sec)
    

    SQL_MODE未开启严格模式

    ## 设置当前会话模式下sql_mode不包含严格模式(即不包含STRICT_TRANS_TABLES变量)
    mysql> set session sql_mode="NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_AUTO_CREATE_USER,NO_ENGINE_SUBSTITUTION";
    Query OK, 0 rows affected (0.00 sec)
    
    mysql> select @@sql_mode\G
    *************************** 1. row ***************************
    @@sql_mode: NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_AUTO_CREATE_USER,NO_ENGINE_SUBSTITUTION
    1 row in set (0.00 sec)
    
    ## 创建test13_2表
    create table if not exists test13_2(
      f float(5,2) unsigned
    )engine=innodb character set utf8 collate utf8_general_ci comment"测试表13_2";
    
        ## 说明点一:float(5,2)
        01:f字段指定了float(5,2),"整数位"最大长度最大3位,"小数位"最大长度2位
        02:当整数位的长度不够3位长度时,不会前导0填充进行显示,加zerofill也不会前导0填充
        03:当小数位的长度不够2位长度时,不会前导0填充进行显示,会在小数后用0补充来显示;
    
        04:若要整数位的长度超过3时,不会直接报错(因为sql_mode未开启了严格模式),最终到表中的数据是999.99
        05:若只有小数位的长度超过2时,会根据小数位的第3位进行四舍五入,但最终显示的还是2位
    
        ## 说明点二:unsigned
        因为加了无符号(unsigne)限制,所以f字段的值的整数位只能是"正整数";
      
    ## 查看test13_2表的表结构
    mysql> desc test13_2;
    +-------+---------------------+------+-----+---------+-------+
    | Field | Type                | Null | Key | Default | Extra |
    +-------+---------------------+------+-----+---------+-------+
    | f     | float(5,2) unsigned | YES  |     | NULL    |       |
    +-------+---------------------+------+-----+---------+-------+
    1 row in set (0.00 sec)
    
    ## 插入数据测试"说明点二"和"说明点三"
    insert into test13_2(f) values(17.5);     # 结果:17.50
    insert into test13_2(f) values(170.50);   # 结果:170.50
    insert into test13_2(f) values(170.56);   # 结果:170.56
    insert into test13_2(f) values(170.566);  # 结果:170,57(小数位第3位的6四舍五入)
    insert into test13_2(f) values(1777.56);  # 警告(sql_mode未开启了严格模式),到表中的数
    # 据为999.99
    
    ## 查看test13_2表中的全部数据
    mysql> select * from test13_2;
    +--------+
    | f      |
    +--------+
    |  17.50 |
    | 170.50 |
    | 170.56 |
    | 170.57 |
    | 999.99 |
    +--------+
    5 rows in set (0.00 sec)
    

    1.4 实践三(float指定M和D,加zerofill))

    SQL_MODE开启了严格模式

    ## 设置当前会话模式下sql_mode包含严格模式(即包含STRICT_TRANS_TABLES变量)
    mysql> set session sql_mode="STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_AUTO_CREATE_USER,NO_ENGINE_SUBSTITUTION";
    Query OK, 0 rows affected (0.00 sec)
    
    mysql> select @@sql_mode\G
    *************************** 1. row ***************************
    @@sql_mode: STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_AUTO_CREATE_USER,NO_ENGINE_SUBSTITUTION
    1 row in set (0.00 sec)
    
    ## 创建test14_1表
    create table if not exists test14_1(
      f float(5,2) zerofill
    )engine=innodb character set utf8 collate utf8_general_ci comment"测试表14_1";
    
        ## 说明点一:float(5,2)
        01:f字段指定了float(5,2),"整数位"最大长度最大3位,"小数位"最大长度2位
        02:当整数位的长度不够3位长度时,不会前导0填充进行显示,加zerofill也不会前导0填充
        03:当小数位的长度不够2位长度时,不会前导0填充进行显示,会在小数后用0补充来显示;
    
        04:只要整数位的长度超过3时,会直接报错(因为sql_mode开启了严格模式),数据不会到表中
        05:若只有小数位的长度超过2时,会根据小数位的第3位进行四舍五入,但最终显示的还是2位
    
         ## 说明点二:unsigned
        因为加了无符号(unsigne)限制,所以f字段的值的整数位只能是"正整数";
    
    ## 查看test14_1表的表结构
    mysql> desc test14_1;
    +-------+------------------------------+------+-----+---------+-------+
    | Field | Type                         | Null | Key | Default | Extra |
    +-------+------------------------------+------+-----+---------+-------+
    | f     | float(5,2) unsigned zerofill | YES  |     | NULL    |       |
    +-------+------------------------------+------+-----+---------+-------+
    1 row in set (0.00 sec)
    
    
    ## 插入数据测试"说明点一"和"说明点二"
    insert into test14_1(f) values(17.5);    # 结果:17.50
    insert into test14_1(f) values(170.50);  # 结果:170.50
    insert into test14_1(f) values(170.56);  # 结果:170.56
    insert into test14_1(f) values(170.566); # 结果:170,57(小数位第3位的6四舍五入)
    insert into test14_1(f) values(1777.56); # 报错(sql_mode开启了严格模式),数据不会到表中
    
    ## 查看test14_1表中的全部数据
    mysql> select * from test14_1;
    +--------+
    | f      |
    +--------+
    |  17.50 |
    | 170.50 |
    | 170.56 |
    | 170.57 |
    +--------+
    4 rows in set (0.00 sec)
    

    SQL_MODE未开启严格模式

    ## 设置当前会话模式下sql_mode不包含严格模式(即不包含STRICT_TRANS_TABLES变量)
    mysql> set session sql_mode="NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_AUTO_CREATE_USER,NO_ENGINE_SUBSTITUTION";
    Query OK, 0 rows affected (0.00 sec)
    
    mysql> select @@sql_mode\G
    *************************** 1. row ***************************
    @@sql_mode: NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_AUTO_CREATE_USER,NO_ENGINE_SUBSTITUTION
    1 row in set (0.00 sec)
    
    ## 创建test14_2表
    create table if not exists test14_2(
      f float(5,2) zerofill
    )engine=innodb character set utf8 collate utf8_general_ci comment"测试表14_2";
    
        ## 说明点一:float(5,2)
        01:f字段指定了float(5,2),"整数位"最大长度最大3位,"小数位"最大长度2位
        02:当整数位的长度不够3位长度时,不会前导0填充进行显示,加zerofill也不会前导0填充
        03:当小数位的长度不够2位长度时,不会前导0填充进行显示,会在小数后用0补充来显示;
    
        04:若要整数位的长度超过3时,不会直接报错(因为sql_mode未开启了严格模式),最终到表中的数据是999.99
        05:若只有小数位的长度超过2时,会根据小数位的第3位进行四舍五入,但最终显示的还是2位
    
        ## 说明点二:unsigned
        因为加了无符号(unsigne)限制,所以f字段的值的整数位只能是"正整数";
      
    ## 查看test14_2表的表结构
    mysql> desc test14_2;
    +-------+------------------------------+------+-----+---------+-------+
    | Field | Type                         | Null | Key | Default | Extra |
    +-------+------------------------------+------+-----+---------+-------+
    | f     | float(5,2) unsigned zerofill | YES  |     | NULL    |       |
    +-------+------------------------------+------+-----+---------+-------+
    1 row in set (0.00 sec)
    
    ## 插入数据测试"说明点二"和"说明点三"
    insert into test14_2(f) values(17.5);     # 结果:17.50
    insert into test14_2(f) values(170.50);   # 结果:170.50
    insert into test14_2(f) values(170.56);   # 结果:170.56
    insert into test14_2(f) values(170.566);  # 结果:170,57(小数位第3位的6四舍五入)
    insert into test14_2(f) values(1777.56);  # 警告(sql_mode未开启了严格模式),到表中的数
    # 据为999.99
    
    ## 查看test14_2表中的全部数据
    mysql> select * from test14_2;
    +--------+
    | f      |
    +--------+
    |  17.50 |
    | 170.50 |
    | 170.56 |
    | 170.57 |
    | 999.99 |
    +--------+
    5 rows in set (0.00 sec)
    
    展开全文

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 11,280
精华内容 4,512
关键字:

小数数据类型