MySQL之常用数据类型
Posted 蚂蚁小哥
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了MySQL之常用数据类型相关的知识，希望对你有一定的参考价值。
一：MySQL中基本数据类型
MySQL数据库表中的每一列都必须具有名称和数据类型。据类型是一个标签，它可以告知存储什么类型的数据，它也标识了SQL如何与存储的数据进行交互。MySQL数据库支持所有标准SQL数值数据类型，涉及大概11种类MySQL数据类型。
整数类型：TINYINT、SMALLINT、MEDIUMINT、INT(或INTEGER)、BIGINT(相当JAVA中LONG类型)
浮点类型：FLOAT、DOUBLE
定点数类型：DECIMAL
位类型：BIT
日期时间类型：YEAR、TIME、DATE、DATETIME、TIMESTAMP
文本字符串类型：CHAR、VARCHAR、TINYTEXT、TEXT、MEDIUMTEXT、LONGTEXT
枚举类型：ENUM
集合类型：SET
二进制字符串类型：BINARY、VARBINARY、TINYBLOB、BLOB、MEDIUMBLOB、LONGBLOB
JSON类型：JSON对象、JSON数组
空间数据类型（了解）：
单值类型：GEOMETRY、POINT、LINESTRING、POLYGON；
集合类型：MULTIPOINT、MULTILINESTRING、MULTIPOLYGON、GEOMETRYCOLLECTION
二：整数类型
整数类型一共有 5 种，包括 TINYINT、SMALLINT、MEDIUMINT、INT（INTEGER）和 BIGINT。
| 数据类型 | 字节 | 有符号数取值范围 | 无符号数取值范围 |
| TINYINT | 1 |
-128~127
|
0~255
|
| SMALLINT | 2 |
-32768~32767
|
0~65535
|
| MEDIUMINT | 3 |
-8388608~8388607
|
0~16777215
|
| INT或INTEGER | 4 |
-2147483648~2147483647
|
0~4294967295
|
| BIGINT | 5 |
-9223372036854775808~9223372036854775807
|
0~18446744073709551615
|
1：创建整数类型表及测试
CREATE DATABASE IF NOT EXISTS type_demo CHARACTER SET utf8mb4;
CREATE TABLE IF NOT EXISTS type_demo.table_int_demo1(
column1 TINYINT COMMENT \'迷你整型\',
column2 SMALLINT COMMENT \'小整型\',
column3 MEDIUMINT COMMENT \'中整型\',
column4 INT COMMENT \'标准整型\',
column5 BIGINT COMMENT \'大整型\');
DESC type_demo.table_int_demo1;
+
| Field | Type | Null | Key | Default | Extra |
+
| column1 | tinyint(4) | YES | | NULL | |
| column2 | smallint(6) | YES | | NULL | |
| column3 | mediumint(9) | YES | | NULL | |
| column4 | int(11) | YES | | NULL | |
| column5 | bigint(20) | YES | | NULL | |
+
INSERT INTO type_demo.table_int_demo1 VALUES
(127,32767,8388607,2147483647,9223372036854775807),
(-128,-32768,-8388608,-2147483648,-9223372036854775808);
插入提示（已插入2条记录）：Records: 2 Duplicates: 0 Warnings: 0
INSERT INTO type_demo.table_int_demo1 VALUES
(999,99999,9999999,9999999999,9999999999999999999),
(-999,-99999,-9999999,-9999999999,-9999999999999999999);
插入提示（已插入2条记录）：Records: 2 Duplicates: 0 Warnings: 10
注：这里虽然插入了2条记录，但是每个字段插入的值都是警告
SELECT * FROM type_demo.table_int_demo1
+
| column1 | column2 | column3 | column4 | column5 |
+
| 127 | 32767 | 8388607 | 2147483647 | 9223372036854775807 |
| -128 | -32768 | -8388608 | -2147483648 | -9223372036854775808 |
| 127 | 32767 | 8388607 | 2147483647 | 9223372036854775807 |
| -128 | -32768 | -8388608 | -2147483648 | -9223372036854775808 |
+
注：这时候我们看到有四条记录；1，2两条是我们第一次插入不报警告的；3，4两条超出
边界值的数据也插入成功了，但报了警告，而且插入的数据被自动更改位当前前数据类型的边界值，
所以得出结论：插入超过类型最大值时，会默认取这个字段类型的边界值，但在MySQL8.0则直接报错
2：可选属性【数据显示宽度、无符号、零填充】
在MySQL整型中有三个可选的属性，分别是数据显示宽度、无符号(UNSIGNED)、零填充(ZEROFILL)
Ⅰ：数据显示宽度 M：表示显示宽度，M的取值范围是(0,255)。 例如 INT(5)： 当数据宽度小于5位的时候在数字前面需要用字符填满宽度。 该项功能需要配合“ZEROFILL”使用，表示用“0”填满宽度，单独指定数据显示宽度则无效。 注意： 如果设置了显示宽度，那么插入的数据宽度超过显示宽度限制，不会对插入的数据有任何影响，还是按照类型的实际宽度进行保存，即显示宽度
与类型可以存储的值范围无关。但从MySQL 8.0.17开始，整数数据类型不推荐使用显示宽度属性。 但是MySQL8.0.17之前的版本中，整型类型可以在定义表结构时指定所需要的显示宽度，如果不指定，则系统为每一种类型指定默认的宽度值 默认宽度： TINYINT(4)，SMALLINT(6)，MEDIUMINT(9)，INT(11)，BIGINT(20) 为什么会显示这些默认宽度： 以有符号SMALLINT(6)来说，我们可以看出他的取值是-32768~32767，那么我们32768+32767=65535 那么这个65535宽度是5，因为没有被无符号修饰，所以在加上一个负号 \'-\' 位数，可以得出为 6 以有符号MEDIUMINT(9)来说，我们可以看出他的取值是-8388608~8388607， 那么我们8388608+8388607=16777215，那么这个16777215宽度是8，因为没有被无符号修饰， 所以在加上一个负号 \'-\' 位数，可以得出为 9，若是有符号则就不用加\'-\'，宽度直接为8 具体BIGINT(20)为什么有符号是20我不是太了解 基本案例： CREATE DATABASE IF NOT EXISTS type_demo CHARACTER SET utf8mb4; CREATE TABLE IF NOT EXISTS type_demo.table_int_demo2( column1 TINYINT(10) COMMENT \'迷你整型\', column4 INT(15) COMMENT \'标准整型\'); DESC type_demo.table_int_demo2; + | Field | Type | Null | Key | Default | Extra | + | column1 | tinyint(10) | YES | | NULL | | | column4 | int(15) | YES | | NULL | | + 这时候我们创建2个字段并设置类型宽度，如果不加其它属性，那么它的宽度是无效的 INSERT INTO type_demo.table_int_demo2 VALUES(20,987); SELECT * FROM type_demo.table_int_demo2; + | column1 | column4 | + | 20 | 987 | + 这里我们看不出任何宽度问题 Ⅱ：无符号(UNSIGNED) 无符号类型（非负），所有的整数类型都有一个可选的属性UNSIGNED（无符号属性），无符号整数类型的最小取值为0。所以，
如果需要在MySQL数据库中保存非负整数值时，可以将整数类型设置为无符号类型。 例如： int类型默认显示宽度为int(11)，无符号int类型默认显示宽度为int(10)。并且数据范围0~4294967295 基本案例： CREATE DATABASE IF NOT EXISTS type_demo CHARACTER SET utf8mb4; CREATE TABLE IF NOT EXISTS type_demo.table_int_demo3( column2 INT UNSIGNED COMMENT \'无符号标准整型\', column3 INT COMMENT \'标准整型\'); DESC type_demo.table_int_demo3; + | Field | Type | Null | Key | Default | Extra | + | column2 | int(10) unsigned | YES | | NULL | | | column3 | int(11) | YES | | NULL | | + INSERT INTO type_demo.table_int_demo3 VALUES(4294967295,4294967295); Query OK, 1 row affected, 1 warning (0.37 sec) （有一条警告，因为column3最大支持存储2147483647，而插入4294967295超出） SELECT * FROM type_demo.table_int_demo3; + | column2 | column3 | + | 4294967295 | 2147483647 | + Ⅲ：零填充(ZEROFILL) 零填充,（如果某列是ZEROFILL，那么MySQL会自动为当前列添加UNSIGNED属性），如果指定了ZEROFILL只是表示不够M位时，
用0在左边填充，如果超过M位，只要不超过数据存储范围即可。 说明： 之前在 int(M) 中，M 的值跟 int(M) 所占多少存储空间并无任何关系。 int(3)、int(4)、int(8) 在磁盘上都 是占用 4 bytes 的存储空间。也就是说，int(M)，必须和UNSIGNED ZEROFILL一起使用才有意义。如果整 数值超过M位，就按照实际位数存储。只是无须再用字符 0 进行填充。 演示： CREATE DATABASE IF NOT EXISTS type_demo CHARACTER SET utf8mb4; CREATE TABLE IF NOT EXISTS type_demo.table_int_demo4( column1 TINYINT(10) UNSIGNED ZEROFILL COMMENT \'迷你整型\', column4 INT(15) ZEROFILL COMMENT \'标准整型\'); DESC type_demo.table_int_demo4; + | Field | Type | Null | Key | Default | Extra | + | column1 | tinyint(10) unsigned zerofill | YES | | NULL | | | column4 | int(15) unsigned zerofill | YES | | NULL | | + INSERT INTO type_demo.table_int_demo4 VALUES(12,7894); SELECT * FROM type_demo.table_int_demo4; + | column1 | column4 | + | 0000000012 | 000000000007894 | +
3：如何选择整型类型
在评估用哪种整数类型的时候，你需要考虑 存储空间 和 可靠性 的平衡问题：用占用字节数少的整数类型可以节省存储空间；但是为了节省存储空间，使用的整数类型取值范围太小，一旦遇到超出取值范围的情况，就可能引起系统错误，影响可靠性。
如果使用SMALLINT类型，虽然占用字节数比 INT 类型的整数少，但是却不能保证数据不会超出范围65535。但使用 INT就能确保有足够大的取值范围，不用担心数据超出范围影响可靠性的问题。你要注意的是，在实际工作中，系统故障产生的成本远远超过增加几个字段存储空间所产生的成本。因此，建议首先确保数据不会超过取值范围，在这个前提之下，再去考虑如何节省存储空间。
三：浮点类型（浮点数）
浮点数和定点数类型的特点是可以处理小数，你可以把整数看成小数的一个特例。因此，浮点数和定点数的使用场景，比整数大多了。MySQL支持的浮点数类型，分别是 FLOAT、DOUBLE、REAL。
| 数据类型 | 字节 | 有符号数取值范围 | 无符号数取值范围 |
| FLOAT（单精度） | 4 |
(-3.402823466E+38 ~ 1.175494351E-38),0, |
0,(1.175494351E-38~3.402823466E+38) |
| DOUBLE（双精度） | 8 |
(-1.7976931348623157E+308 ~ |
0,(2.2250738585072014E-308 ~ |
REAL默认就是DOUBLE。如果你把SQL模式设定为启用 "REAL_AS_FLOAT"，那么，MySQL就认为REAL是FLOAT。如果要启用“REAL_AS_FLOAT”，可以通过 SET SESSION sql_mode = \'REAL_AS_FLOAT\' 修改；（具体看配置文件my.ini里配置的sql_mode）
1：创建浮点类型（浮点数）及测试
说明1：FLOAT占用字节数少，取值范围小；DOUBLE占用字节数多，取值范围也大；
说明2：浮点数类型的无符号数取值范围，只相当于有符号数取值范围的一半，也就是只相当于有符号数取值范围大于等于零的部分，是因为MySQL存储浮点数的格式为：符号(S)、尾数(M)和阶码(E)。所以有没有符号，MySQL的浮点数都会存储表示符号的部分。所以无符号数取值范围，其实就是有符号数取值范围大于等于零的部分。
Ⅰ：精度说明（5.7版本）： 对于浮点类型，在MySQL中单精度值使用 4 个字节，双精度值使用 8 个字节。 ①：MySQL允许使用非标准语法（其他数据库未必支持，因此如果涉及到数据迁移，则最好不要这么用）： FLOAT(M,D) 或 DOUBLE(M,D)。这里M称为精度，D称为标度。 (M,D)中 M=整数位+小数位，D=小数位。 M不可大于255（包含255），D不可大于30（包含30） 例如：定义为FLOAT(5,2)的一个列可以显示为-999.99-999.99。如果超过这个范围会出问题。 ②：FLOAT和DOUBLE类型在不指定(M,D)时，默认会按照实际的精度（由实际的硬件和操作系统决定）来显示。 ③：浮点类型，也可以加 UNSIGNED，但是不会改变数据范围，例如：FLOAT(3,2) UNSIGNED仍然只能表示0-9.99的范围。 ④：不管是否显式设置了精度(M,D)，这里MySQL的处理方案如下： >：如果存储时，整数部分超出了范围，MySQL就会存储当前的最大值 >：如果存储时，小数点部分若超出范围，就分以下情况： #：若四舍五入后，整数部分没有超出范围，则只警告，但能成功操作并四舍五入删除多余 的小数位后保存。例如在FLOAT(5,2)列内插入999.009，近似结果是999.01。 #：若四舍五入后，整数部分超出范围，则MySQL则会保存自己的最大值和最小值 如：FLOAT(5,2)存储55646.6666 则最终会保存为999.99 注：从MySQL 8.0.17开始，FLOAT(M,D)和DOUBLE(M,D)用法在官方文档中已经明确不推荐使用，将来可能被移除。另外，
关于浮点型FLOAT和DOUBLE的UNSIGNED也不推荐使用了，将来也可能被移除。 CREATE TABLE IF NOT EXISTS type_demo.table_fd_demo1( column1 FLOAT COMMENT \'默认单位的float\', column2 FLOAT(5,2) COMMENT \'带范围的float\', column3 FLOAT(5,2) UNSIGNED COMMENT \'带范围的无符号float\', column4 DOUBLE COMMENT \'默认单位的double\', column5 DOUBLE(5,2) COMMENT \'带范围的double\'); + | Field | Type | Null | Key | Default | Extra | + | column1 | float | YES | | NULL | | | column2 | float(5,2) | YES | | NULL | | | column3 | float(5,2) unsigned | YES | | NULL | | | column4 | double | YES | | NULL | | | column5 | double(5,2) | YES | | NULL | | + INSERT INTO type_demo.table_fd_demo1 VALUES(123.456, 123.456, 123.456, 222.456, 222.456); INSERT INTO type_demo.table_fd_demo1 VALUES(0, 999.994, 999.994, 0, 0); + | column1 | column2 | column3 | column4 | column5 | + | 123.456 | 123.46 | 123.46 | 222.456 | 222.46 | | 0 | 999.99 | 999.99 | 0 | 0.00 | + column2和column3和column5设置了类型范围，所以会把超出的小数四舍五入 INSERT INTO type_demo.table_fd_demo1 VALUES(0, 155566.995, 1678777.995, 0, 0); 会显示警告：Query OK, 1 row affected, 2 warnings (0.38 sec) + | column1 | column2 | column3 | column4 | column5 | + | 0 | 999.99 | 999.99 | 0 | 0.00 | + Ⅱ：精度误差说明 浮点数类型有个缺陷，就是不精准。下面我来重点解释一下为什么 MySQL 的浮点数不够精准。比如，我 们设计一个表，有f1这个字段，插入值分别为0.47,0.44,0.19，我们期待的运行结果是：0.47 + 0.44 + 0.19 = 1.1
CREATE TABLE IF NOT EXISTS type_demo.table_fd_demo2(f1 DOUBLE); INSERT INTO type_demo.table_fd_demo2 VALUES(0.47),(0.44),(0.19); SELECT SUM(f1) FROM type_demo.table_fd_demo2; + | SUM(f1) | + | 1.0999999999999999 | + 查询结果是 1.0999999999999999，虽然误差很小，但确实有误差。你也可以尝试把数据类型改成 FLOAT，然后运行求和查询，
得到的是：1.0999999940395355。显然，误差更大了。那么，为什么会存在这样的误差呢？问题还是出在 MySQL 对浮点类型
数据的存储方式上。 MySQL 用 4 个字节存储 FLOAT 类型数据，用 8 个字节来存储 DOUBLE 类型数据。无论哪个，都是采用二进制的方式来进行存储的。
比如 9.625，用二进制来表达，就是 1001.101，或者表达成 1.001101×2^3。如果尾数不是 0 或 5（比如 9.624），你就无法用
一个二进制数来精确表达。进而，就只好在取值允许的范围内进行四舍五入。 在编程中，如果用到浮点数，要特别注意误差问题，因为浮点数是不准确的，所以我们要避免使用“=”来判断两个数是否相等。同时，
在一些对精确度要求较高的项目中，千万不要使用浮点数，不然会导致结果错误，甚至是造成不可挽回的损失。那么，MySQL 要精准的
数据类型就选择定点数据类型：DECIMAL 。
四：浮点类型（定点数）
| 数据类型 | 字节数 | 含义 |
| DECIMAL(M,D), DEC, NUMERIC | 取决与M和D | 有效范围由M和D决定 |
定点类型： 使用DECIMAL(M,D)的方式表示高精度小数。其中，M被称为精度，D被称为标度。M最大取值65，D最大取值30，M得比D大。 例如，定义DECIMAL(5,2)的类型，表示该列取值范围是-999.99~999.99。 DECIMAL(M,D)的最大取值范围与DOUBLE类型一样，但是有效的数据范围是由M和D决定的。但DECIMAL的存储空间并不是固定的， 由M和D一起决定的存储空间大小。也就是说，在一些对精度要求不高的场景下，比起占用同样字节长度的定点数，浮点数表达的数 值范围可以更大一些。 定点数在MySQL内部是以字符串的形式进行存储，这就决定了它一定是精准的。当DECIMAL类型不指定精度和标度时， 其默认为DECIMAL(10,0)。当数据的精度超出了定点数类型的精度范围时，则MySQL同样会进行四舍五入处理。 浮点数和定点数区别： 浮点数：浮点数相对于定点数的优点是在长度一定的情况下，浮点类型取值范围大，但是不精准，适用 于需要取值范围大，又可以容忍微小误差的科学计算场景。 定点数：定点数类型取值范围相对小，但是精准，没有误差，适合于对精度要求极高的场景（比如金额计算） 为什么说DECIMAL(M,D)类型精确： 比如说使用DECIMAL类型存储了一个 13.254 的这个小数；其实在存储时是对数据进行拆分成两个十进制数存储的，所以就变为了一个 13的整数和一个254的整数，使用这种方式就达到数据的精确 如何计算DECIMAL(M,D)实际占用字节： 如：DECIMAL(36,6) 代表可以存储 30位整数和6位小数 然后对这范围进行分组计算空间，如小数点左边为30的个十进制位，右边为6个十进制位 000000000000000000000000000000.000000 然后对其分组，以小数点为起点往左分组和以小数点为起点往右分组，九个位为一组（如后面不足9位则分为一组） 000 000000000 000000000 000000000 . 000000 对照表：（十进制的数字位数不同，存储空间的大小也不同） 分组中包含 1~2 位十进制数 占用存储空间 1字节 分组中包含 3~4 位十进制数 占用存储空间 2字节 分组中包含 5~6 位十进制数 占用存储空间 3字节 分组中包含 7~9 位十进制数 占用存储空间 4字节 这时我们就可以计算出来了 000 000000000 000000000 000000000 . 000000 2 + 4 + 4 + 4 + 3 = 17字节大小 示例：如存储了 1.222222 的小数显示的16进制数为： 80 00 00 00 00 00 00 00 00 00 00 00 00 01 03 64 0E 占用17个字节大小 其中：80 00 00 00 00 00 00 00 00 00 00 00 00 01 为整数 1；最前面的80代表正数符号位 其中：03 64 0E 为小数222222 CREATE TABLE IF NOT EXISTS type_demo.table_de_demo1( column1 DEC COMMENT \'定点类型M=10，D=0\', column2 NUMERIC COMMENT \'定点类型M=10，D=0\', column3 DECIMAL COMMENT \'定点类型M=10，D=0\', column4 DECIMAL(5,2) COMMENT \'定点类型M=5,D=2\'); DESC table_de_demo1; （默认长度10，0） + | Field | Type | Null | Key | Default | Extra | + | column1 | decimal(10,0) | YES | | NULL | | | column2 | decimal(10,0) | YES | | NULL | | | column3 | decimal(10,0) | YES | | NULL | | | column4 | decimal(5,2) | YES | | NULL | | + INSERT INTO type_demo.table_de_demo1 VALUES(999999999,999999999,999999999,999.99); SELECT * FROM type_demo.table_de_demo1; + | column1 | column2 | column3 | column4 | + | 999999999 | 999999999 | 999999999 | 999.99 | + INSERT INTO type_demo.table_de_demo1 VALUES(0,0,0,999.995); INSERT INTO type_demo.table_de_demo1 VALUES(0,0,0,99999.99599); SELECT * FROM type_demo.table_de_demo1; + | column1 | column2 | column3 | column4 | + | 999999999 | 999999999 | 999999999 | 999.99 | | 0 | 0 | 0 | 999.99 | | 0 | 0 | 0 | 999.99 | +
五：位类型
BIT类型中存储的是二进制，类似1010010这样数值
| 二进制字符串类型 | 长度 | 长度范围 | 占用空间 |
| BIT(M) | M | 1<=M<=64 | 约为 (M+7)/8 个字节 |
BIT类型: 如果没有指定(M)，默认是1位。这个1位，表示只能存1位的二进制值。这里(M)是表示二进制的位数，位数最小值为1，最大值为64。 注存储范围：当BIT(64)时则可以存储最大 -9223372036854775808 ~ 9223372036854775807 ；在64位为符号位，存负号 CREATE TABLE IF NOT EXISTS type_demo.table_bit_demo1( column1 BIT COMMENT \'位类型 长度为1\', column2 BIT(5) COMMENT \'位类型 长度为5\', column3 BIT(64) COMMENT \'位类型 长度为64\'); DESC table_bit_demo1; + | Field | Type | Null | Key | Default | Extra | + | column1 | bit(1) | YES | | NULL | | | column2 | bit(5) | YES | | NULL | | | column3 | bit(64) | YES | | NULL | | + INSERT INTO type_demo.table_bit_demo1 VALUES(1,25,-9223372036854775808); INSERT INTO type_demo.table_bit_demo1 VALUES(1,12,9223372036854775807); 使用SELECT命令查询位字段时，可以用 BIN() 或 HEX() 函数进行读取 使用b+0查询数据时，可以直接查询出存储的十进制数据的值 SELECT column1+0, column2+0, column3+0 FROM type_demo.table_bit_demo1; SELECT BIN(column1), BIN(column2), BIN(column3) FROM type_demo.table_bit_demo1; SELECT HEX(column1), HEX(column2), HEX(column3) FROM type_demo.table_bit_demo1;
六：日期与时间类型
日期和时间在我们的系统中，几乎所有的数据表都用得到。原因是客户需要知道数据的时间标签，从而进行数据查询、统计和处理。在MySQL有多种表示日期和时间的数据类型，不同的版本可能有所差异；MySQL5.7和8.0版本支持的日期和时间类型主要有：YEAR类型、TIME类型、DATE类型、DATETIME类型和TIMESTAMP类型。
YEAR： 类型通常用来表示 年
DATE： 类型通常用来表示 年、月、日
TIME： 类型通常用来表示 时、分、秒
DATETIME： 类型通常用来表示 年、月、日、时、分、秒
TIMESTAMP： 类型通常用来表示 带时区的年、月、日、时、分、秒
| 类型 | 名称 | 字节 | 日期格式 | 最小值 | 最大值 |
| YEAR | 年 | 1 | YYYY或YY | 1901 | 2155 |
| TIME | 时间 | 3 | HH:MM:SS | -838:59:59 | 838:59:59 |
| DATE | 日期 | 3 | YYYY-MM-DD | 1000-01-01 | 9999-12-03 |
| DATETIME |
日期时间 |
8 | YYYY-MM-DD HH:MM:SS | 1000-01-01 00:00:00 | 9999-12-31 23:59:59 |
| TIMESTAMP |
日期时间 |
4 | YYYY-MM-DD HH:MM:SS | 1970-01-01 00:00:00 UTC | 2038-01-19 03:14:07 UTC |
1：YEAR类型
YEAR类型用来表示年份，在所有的日期时间类型中所占用的存储空间最小，只需要1个字节的存储空间。
在MySQL中YEAR有两种存储格式：
①：以2位字符串或数字格式表示YEAR类型，其格式为YY，最小值为00，最大值为99
注：以两位存储时取值有特点规范
当取值为01到69时，表示2001到2069；
当取值为70到99时，表示1970到1999；
②：以4位字符串或数字格式表示YEAR类型，其格式为YYYY，最小值为1901，最大值为2155（推荐方式）
注：当取值整数的0或00添加的话，那么是0000年；
注：当取值是日期（如now()函数）/字符串的\'0\'添加的话，是2000年。
从MySQL5.5.27开始，2位格式的YEAR已经不推荐使用。YEAR默认格式就是“YYYY”，没必要写成YEAR(4)
从MySQL8.0.19开始，不推荐使用指定显示宽度的YEAR(4)数据类型。
注：YEAR只支持YEAR(4)或者YEAR方式，两位不是YEAR(2)，而是两位字符（取值范围01~99）
CREATE TABLE IF NOT EXISTS type_demo.table_year_demo1(
column1 YEAR COMMENT \'基本YEAR类型（默认YEAR(4)）\',
column2 YEAR(4) COMMENT \'YEAR类型\');
DESC type_demo.table_year_demo1;
+
| Field | Type | Null | Key | Default | Extra |
+
| column1 | year(4) | YES | | NULL | |
| column2 | year(4) | YES | | NULL | |
+
INSERT INTO type_demo.table_year_demo1 VALUES(\'22\',\'71\'),(0,\'0\');
SELECT * FROM type_demo.table_year_demo1;
+
| column1 | column2 |
+
| 2022 | 1971 |
| 0000 | 2000 |
+
2：DATE类型
DATE类型表示日期，没有时间部分，格式为YYYY-MM-DD，其中YYYY表示年份，MM表示月份，DD表示日期。需要3个字节的存储空间。 在向DATE类型的字段插入数据时，同样需要满足一定的格式条件： ①：以YYYY-MM-DD格式或者YYYYMMDD格式表示的字符串日期，其最小取值为1000-01-01，最大取值为9999-12-31（因为0000-00-00和
0000-01-01日期没意义）。YYYYMMDD格式会被转化为YYYY-MM-DD格式。 ②：以YY-MM-DD格式或者YYMMDD格式表示的字符串日期，此格式中，年份为两位数值或字符串时，那么它就和YEAR类型（具体看YEAR类型）
一样，当年份取值为00到69时，会被转化为2000到2069；当年份取值为70到99时，会被转化为1970到1999。 ③：使用 CURRENT_DATE() 或者 NOW() 函数，会插入当前系统的日期。
CREATE TABLE IF NOT EXISTS type_demo.table_date_demo1(
column1 DATE COMMENT \'基本DATE类型\');
DESC type_demo.table_date_demo1;
+
| Field | Type | Null | Key | Default | Extra |
+
| column1 | date | YES | | NULL | |
+
INSERT INTO type_demo.table_date_demo1 VALUES
(\'2022-09-13\'),(\'2022/11/14\'),(\'20221115\'),(20221116);
INSERT INTO type_demo.table_date_demo1 VALUES
(\'00-01-01\'),(\'22/11/14\'),(\'700101\'),(991231);
SELECT * FROM type_demo.table_date_demo1;
+
| column1 |
+
| 2022-09-13 |
| 2022-11-14 |
| 2022-11-15 |
| 2022-11-16 |
| 2000-01-01 |
| 2022-11-14 |
| 1970-01-01 |
| 1999-12-31 |
+
INSERT INTO type_demo.table_date_demo1 VALUES(\'9999-12-32\'),(\'99-12-32\');
+
| column1 |
+
| 0000-00-00 |
| 0000-00-00 |
+
3：TIME类型
TIME类型用来表示时间，不包含日期部分。在MySQL中需要3个字节的存储空间来存储TIME类型的数据，可以使用“HH:MM:SS”格式来表示TIME类型，
其中HH表示小时，MM表示分钟，SS表示秒。
在MySQL中，向TIME类型的字段插入数据时，也可以使用几种不同的格式：
①：可以使用带有冒号的字符串，比如\'D HH:MM:SS\'、\'HH:MM:SS\'、\'HH:MM\'、\'D HH:MM\'、\'D HH\'或\'SS\'格式，都能被正确地插入TIME类型
的字段中。其中D表示天，其最小值为0，最大值为34。如果使用带有D格式的字符串插入TIME类型的字段时，D会被转化为小时，
计算格式为D*24+HH。当使用带有冒号并且不带D的字符串表示时间时，表示当天的时间，比如12:10表示12:10:00，而不是00:12:10。
②：可以使用不带有冒号的字符串或者数字，格式为\'HHMMSS\'或者HHMMSS。如果插入一个不合法的字符串或者数字，MySQL在存储数据时，会将其
自动转化为00:00:00进行存储。比如1210，MySQL会将最右边的两位解析成秒，表示00:12:10，而不是12:10:00。
③：使用 CURRENT_TIME() 或者 NOW() ，会插入当前系统的时间。
CREATE TABLE IF NOT EXISTS type_demo.table_time_demo1(
column1 TIME COMMENT \'基本time类型\');
DESC type_demo.table_time_demo1;
+
| Field | Type | Null | Key | Default | Extra |
+
| column1 | time | YES | | NULL | |
+
INSERT INTO type_demo.table_time_demo1 VALUES(\'2 22:32:14\'),(\'15:36:22\'),(\'12:18\'),(\'2 12:42\'),(\'3 06\'),(\'42\');
SELECT * FROM type_demo.table_time_demo1;
+
| column1 |
+
| 70:32:14 | (这70:32:14 由 2 * 24 +22 :32 14 得来)
| 15:36:22 |
| 12:18:00 |
| 60:42:00 |
| 78:00:00 |
| 00:00:42 |
+
INSERT INTO type_demo.table_time_demo1 VALUES(223214),(\'153622\'),(1218),(NOW());
+
| column1 |
+
| 22:32:14 |
| 15:36:22 |
| 00:12:18 |
| 16:59:23 |
+
4：DATETIME类型
DATETIME类型在所有的日期时间类型中占用的存储空间最大，总共需要8个字节的存储空间。在格式上为DATE类型和TIME类型的组合， 可以表示为YYYY-MM-DD HH:MM:SS，其中YYYY表示年份，MM表示月份，DD表示日期，HH表示小时，MM表示分钟，SS表示秒。 在向DATETIME类型的字段插入数据时，同样需要满足一定的格式条件： ①：以YYYY-MM-DD HH:MM:SS格式或者YYYYMMDDHHMMSS格式的字符串插入DATETIME类型的字段时，最小值为1000-01-01 00:00:00，
最大值为9999-12-31 23:59:59。 以YYYYMMDDHHMMSS格式的数字插入DATETIME类型的字段时，会被转化为YYYY-MM-DD HH:MM:SS格式 ②：以YY-MM-DD HH:MM:SS格式或者YYMMDDHHMMSS格式的字符串插入DATETIME类型的字段时，两位数的年份规则符合YEAR类型的规则，
00到69表示2000到2069；70到99表示1970到1999。 ③：使用函数CURRENT_TIMESTAMP()和 NOW()，可以向DATETIME类型的字段插入系统的当前日期和时间。
CREATE TABLE IF NOT EXISTS type_demo.table_datetime_demo1(
column1 DATETIME COMMENT \'基本datetime类型\');
DESC type_demo.table_datetime_demo1;
+
| Field | Type | Null | Key | Default | Extra |
+
| column1 | datetime | YES | | NULL | |
+
INSERT INTO type_demo.table_datetime_demo1 VALUES
(\'2021-01-01 06:50:30\'), (\'20210101065030\');
INSERT INTO type_demo.table_datetime_demo1 VALUES
(\'99-01-01 00:00:00\'),(\'990101000000\'),(\'20-01-01 00:00:00\'),(\'200101000000\');
INSERT INTO type_demo.table_datetime_demo1 VALUES
(20200101000000), (200101000000), (19990101000000), (990101000000);
INSERT INTO type_demo.table_datetime_demo1 VALUES (CURRENT_TIMESTAMP()), (NOW());
SELECT * FROM type_demo.table_datetime_demo1;
+
| column1 |
+
| 2021-01-01 06:50:30 |
| 2021-01-01 06:50:30 |
| 1999-01-01 00:00:00 |
| 1999-01-01 00:00:00 |
| 2020-01-01 00:00:00 |
| 2020-01-01 00:00:00 |
| 2020-01-01 00:00:00 |
| 2020-01-01 00:00:00 |
| 1999-01-01 00:00:00 |
| 1999-01-01 00:00:00 |
| 2022-11-13 17:36:52 |
| 2022-11-13 17:36:52 |
+百万年薪python之路 -- MySQL数据库之 常用数据类型
MySQL常用数据类型
一. 常用数据类型概览
# 1. 数字:
整型: tinyint int bigint
小数: float: 在位数比较短的情况下不精确
double: 在位数比较长的情况下不精确
0.000001230123123123
存成: 0.000001230000
decimal: (如果用小数,则推荐使用decimal)
精准
内部原理是以字符串形式去存
# 2. 字符串:
char(10): 简单粗暴,浪费空间,存取速度快.
root存成root000000
varchar: 精准,节省空间,存取速度慢
sql优化: 创建表时,定长的类型往前放,变长的往后放
比如性别 比如地址或描述信息
>255个字符,超过了就把文件路径存放到数据库中.
比如图片,视频等找一个文件服务器,数据库中只存放路径或url.
# 3. 时间类型
常用的: datatime data time
# 4. 枚举类型与集合类型
二. 数值类型
1. 整数类型
? 整数类型: tinyint, smallint, mediumint, int, bigint
? 作用: 存储年龄, 等级, id , 各种号码等.
? 整数类型分类
tinyint[(m)] [unsigned] [zerofill]
小整数，数据类型用于保存一些范围的整数数值范围：
有符号：
-128 ～ 127
无符号：
0 ～ 255
PS： MySQL中无布尔值，使用tinyint(1)构造。
int[(m)][unsigned][zerofill]
整数，数据类型用于保存一些范围的整数数值范围：
有符号：
-2147483648 ～ 2147483647
无符号：
0 ～ 4294967295
bigint[(m)][unsigned][zerofill]
大整数，数据类型用于保存一些范围的整数数值范围：
有符号：
-9223372036854775808 ～ 9223372036854775807
无符号：
0 ～ 18446744073709551615
? 整数类型范围验证
有符号和无符号tinyint
1.tinyint默认为有符号
mysql> create table t1(x tinyint); #默认为有符号，即数字前有正负号
mysql> desc t1;
mysql> insert into t1 values
-> (-129),
-> (-128),
-> (127),
-> (128);
mysql> select * from t1;
+------+
| x |
+------+
| -128 | #-129存成了-128
| -128 | #有符号，最小值为-128
| 127 | #有符号，最大值127
| 127 | #128存成了127
+------+
2.设置无符号tinyint
mysql> create table t2(x tinyint unsigned);
mysql> insert into t2 values
-> (-1),
-> (0),
-> (255),
-> (256);
mysql> select * from t2;
+------+
| x |
+------+
| 0 | -1存成了0
| 0 | #无符号，最小值为0
| 255 | #无符号，最大值为255
| 255 | #256存成了255
+------+
有符号和无符号int
1.int默认为有符号
mysql> create table t3(x int); #默认为有符号整数
mysql> insert into t3 values
-> (-2147483649),
-> (-2147483648),
-> (2147483647),
-> (2147483648);
mysql> select * from t3;
+-------------+
| x |
+-------------+
| -2147483648 | #-2147483649存成了-2147483648
| -2147483648 | #有符号，最小值为-2147483648
| 2147483647 | #有符号，最大值为2147483647
| 2147483647 | #2147483648存成了2147483647
+-------------+
2.设置无符号int
mysql> create table t4(x int unsigned);
mysql> insert into t4 values
-> (-1),
-> (0),
-> (4294967295),
-> (4294967296);
mysql> select * from t4;
+------------+
| x |
+------------+
| 0 | #-1存成了0
| 0 | #无符号，最小值为0
| 4294967295 | #无符号，最大值为4294967295
| 4294967295 | #4294967296存成了4294967295
+------------+
有符号和无符号bigint
1.有符号bigint
mysql> create table t6(x bigint);
mysql> insert into t5 values
-> (-9223372036854775809),
-> (-9223372036854775808),
-> (9223372036854775807),
-> (9223372036854775808);
mysql> select * from t5;
+----------------------+
| x |
+----------------------+
| -9223372036854775808 |
| -9223372036854775808 |
| 9223372036854775807 |
| 9223372036854775807 |
+----------------------+
2.无符号bigint
mysql> create table t6(x bigint unsigned);
mysql> insert into t6 values
-> (-1),
-> (0),
-> (18446744073709551615),
-> (18446744073709551616);
mysql> select * from t6;
+----------------------+
| x |
+----------------------+
| 0 |
| 0 |
| 18446744073709551615 |
| 18446744073709551615 |
+----------------------+
用zerofill测试整数类型的显示宽度
mysql> create table t7(x int(3) zerofill);
mysql> insert into t7 values
-> (1),
-> (11),
-> (111),
-> (1111);
mysql> select * from t7;
+------+
| x |
+------+
| 001 |
| 011 |
| 111 |
| 1111 | #超过宽度限制仍然可以存
+------+
整数类型范围验证
? 注意：对于整型来说，数据类型后面的宽度并不是存储长度限制，而是显示限制，假如：int(8)，那么显示时不够8位则用0来填充，够8位则正常显示，通过zerofill来测试，存储长度还是int的4个字节长度。默认的显示宽度就是能够存储的最大的数据的长度，比如：int无符号类型，那么默认的显示宽度就是int(10)，有符号的就是int(11)，因为多了一个符号，所以我们没有必要指定整数类型的数据，没必要指定宽度，因为默认的就能够将你存的原始数据完全显示
int的存储宽度是4个Bytes，即32个bit，即2**32
无符号最大值为：4294967296-1
有符号最大值：2147483648-1
有符号和无符号的最大数字需要的显示宽度均为10，而针对有符号的最小值则需要11位才能显示完全，所以int类型默认的显示宽度为11是非常合理的
最后：整形类型，其实没有必要指定显示宽度，使用默认的就ok
说到这里我想提一下MySQL的mode设置，看这篇博客：https://www.cnblogs.com/clschao/articles/9962347.html，看完博客应该就能理解MySQL的mode了。
2. 浮点型
? 定点数类型: dec, 等同于decimal
? 浮点数类型: float, double
? 作用: 存储薪资,身高,温度,体重,体质参数等
1.FLOAT[(M,D)] [UNSIGNED] [ZEROFILL]
定义：
单精度浮点数（非准确小数值），m是整数部分+小数部分的总个数，d是小数点后个数。m最大值为255，d最大值为30，例如：float(255,30)
有符号：
-3.402823466E+38 to -1.175494351E-38,
1.175494351E-38 to 3.402823466E+38
无符号：
1.175494351E-38 to 3.402823466E+38
精确度：
**** 随着小数的增多，精度变得不准确 ****
2.DOUBLE[(M,D)] [UNSIGNED] [ZEROFILL]
定义：
双精度浮点数（非准确小数值），m是整数部分+小数部分的总个数，d是小数点后个数。m最大值也为255，d最大值也为30
有符号：
-1.7976931348623157E+308 to -2.2250738585072014E-308
2.2250738585072014E-308 to 1.7976931348623157E+308
无符号：
2.2250738585072014E-308 to 1.7976931348623157E+308
精确度：
****随着小数的增多，精度比float要高，但也会变得不准确 ****
3.decimal[(m[,d])] [unsigned] [zerofill]
定义：
准确的小数值，m是整数部分+小数部分的总个数（负号不算），d是小数点后个数。 m最大值为65，d最大值为30。比float和double的整数个数少，但是小数位数都是30位
精确度：
**** 随着小数的增多，精度始终准确 ****
对于精确数值计算时需要用此类型
decimal能够存储精确值的原因在于其内部按照字符串存储。
精度从高到低：decimal、double、float
decimal精度高，但是整数位数少
float和double精度低，但是整数位数多
float已经满足绝大多数的场景了，但是什么导弹、航线等要求精度非常高，所以还是需要按照业务场景自行选择，如果又要精度高又要整数位数多，那么你可以直接用字符串来存。
浮点型测试
mysql> create table t1(x float(256,31));
ERROR 1425 (42000): Too big scale 31 specified for column 'x'. Maximum is 30.
mysql> create table t1(x float(256,30));
ERROR 1439 (42000): Display width out of range for column 'x' (max = 255)
mysql> create table t1(x float(255,30)); #建表成功
Query OK, 0 rows affected (0.02 sec)
mysql> create table t2(x double(255,30)); #建表成功
Query OK, 0 rows affected (0.02 sec)
mysql> create table t3(x decimal(66,31));
ERROR 1425 (42000): Too big scale 31 specified for column 'x'. Maximum is 30.
mysql> create table t3(x decimal(66,30));
ERROR 1426 (42000): Too-big precision 66 specified for 'x'. Maximum is 65.
mysql> create table t3(x decimal(65,30)); #建表成功
Query OK, 0 rows affected (0.02 sec)
mysql> show tables;
+---------------+
| Tables_in_db1 |
+---------------+
| t1 |
| t2 |
| t3 |
+---------------+
3 rows in set (0.00 sec)
mysql> insert into t1 values(1.1111111111111111111111111111111); #小数点后31个1
Query OK, 1 row affected (0.01 sec)
mysql> insert into t2 values(1.1111111111111111111111111111111);
Query OK, 1 row affected (0.00 sec)
mysql> insert into t3 values(1.1111111111111111111111111111111);
Query OK, 1 row affected, 1 warning (0.01 sec)
mysql> select * from t1; #随着小数的增多，精度开始不准确
+----------------------------------+
| x |
+----------------------------------+
| 1.111111164093017600000000000000 |
+----------------------------------+
1 row in set (0.00 sec)
mysql> select * from t2; #精度比float要准确点，但随着小数的增多，同样变得不准确
+----------------------------------+
| x |
+----------------------------------+
| 1.111111111111111200000000000000 |
+----------------------------------+
1 row in set (0.00 sec)
mysql> select * from t3; #精度始终准确,d为30，于是只留了30位小数
+----------------------------------+
| x |
+----------------------------------+
| 1.111111111111111111111111111111 |
+----------------------------------+
1 row in set (0.00 sec)
3. 位类型(了解,基本用不到)
bit(M)可以用来存放多位二进制数，M范围从1~64，如果不写默认为1位。
注意：对于位字段需要使用函数读取
bin()显示为二进制
hex()显示为十六进制
mysql> create table t9(id bit);
mysql> desc t9; #bit默认宽度为1
+-------+--------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+-------+--------+------+-----+---------+-------+
| id | bit(1) | YES | | NULL | |
+-------+--------+------+-----+---------+-------+
mysql> insert into t9 values(8);
mysql> select * from t9; #直接查看是无法显示二进制位的
+------+
| id |
+------+
| |
+------+
mysql> select bin(id),hex(id) from t9; #需要转换才能看到
+---------+---------+
| bin(id) | hex(id) |
+---------+---------+
| 1 | 1 |
+---------+---------+
mysql> alter table t9 modify id bit(5);
mysql> insert into t9 values(8);
mysql> select bin(id),hex(id) from t9;
+---------+---------+
| bin(id) | hex(id) |
+---------+---------+
| 1 | 1 |
| 1000 | 8 |
+---------+---------+
三. 日期类型
? 类型: data, time, datatime, timestamp, year
? 作用: 存储用户注册时间,文章发布时间, 员工入职时间, 出生时间, 过期时间等.
year:
YYYY（范围：1901/2155）2018
data:
YYYY-MM-DD（范围：1000-01-01/9999-12-31）例：2018-01-01
time:
HH:MM:SS（范围：'-838:59:59'/'838:59:59'）例：12:09:32
datatime:
YYYY-MM-DD HH:MM:SS（范围：1000-01-01 00:00:00/9999-12-31 23:59:59 Y）例： 2018-01-01 12:09:32
timestamp:
YYYY-MM-DD HH:MM:SS（范围：1970-01-01 00:00:00/2037 年某时）
日期类型测试
year：
mysql> create table t10(born_year year); #无论year指定何种宽度，最后都默认是year(4)
mysql> insert into t10 values
-> (1900),
-> (1901),
-> (2155),
-> (2156);
mysql> select * from t10;
+-----------+
| born_year |
+-----------+
| 0000 |
| 1901 |
| 2155 |
| 0000 |
+-----------+
date,time,datetime:
mysql> create table t11(d date,t time,dt datetime);
mysql> desc t11;
+-------+----------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+-------+----------+------+-----+---------+-------+
| d | date | YES | | NULL | |
| t | time | YES | | NULL | |
| dt | datetime | YES | | NULL | |
+-------+----------+------+-----+---------+-------+
mysql> insert into t11 values(now(),now(),now());
mysql> select * from t11;
+------------+----------+---------------------+
| d | t | dt |
+------------+----------+---------------------+
| 2017-07-25 | 16:26:54 | 2017-07-25 16:26:54 |
+------------+----------+---------------------+
timestamp：
mysql> create table t12(time timestamp);
mysql> insert into t12 values();
mysql> insert into t12 values(null);
mysql> select * from t12;
+---------------------+
| time |
+---------------------+
| 2017-07-25 16:29:17 |
| 2017-07-25 16:30:01 |
+---------------------+
============注意啦，注意啦，注意啦===========
1. 单独插入时间时，需要以字符串的形式，按照对应的格式插入
2. 插入年份时，尽量使用4位值
3. 插入两位年份时，<=69，以20开头，比如50, 结果2050
>=70，以19开头，比如71，结果1971
mysql> create table t12(y year);
mysql> insert into t12 values
-> (50),
-> (71);
mysql> select * from t12;
+------+
| y |
+------+
| 2050 |
| 1971 |
+------+
============综合练习===========
mysql> create table student(
-> id int,
-> name varchar(20),
-> born_year year,
-> birth date,
-> class_time time,
-> reg_time datetime);
mysql> insert into student values
-> (1,'sb1',"1995","1995-11-11","11:11:11","2017-11-11 11:11:11"),
-> (2,'sb2',"1997","1997-12-12","12:12:12","2017-12-12 12:12:12"),
-> (3,'sb3',"1998","1998-01-01","13:13:13","2017-01-01 13:13:13");
mysql> select * from student;
+------+------+-----------+------------+------------+--------------------+
| id | name | born_year | birth | class_time | reg_time |
+------+------+-----------+------------+------------+--------------------+
| 1 | sb1 | 1995 | 1995-11-11 | 11:11:11 | 2017-11-11 11:11:11 |
| 2 | sb2 | 1997 | 1997-12-12 | 12:12:12 | 2017-12-12 12:12:12 |
| 3 | sb3 | 1998 | 1998-01-01 | 13:13:13 | 2017-01-01 13:13:13 |
+------+------+-----------+------------+------------+--------------------+
mysql的日期格式对字符串采用的是‘放松‘政策，可以以字符串的形式插入。
在实际应用的很多场景中，MySQL的这两种日期类型(datatime,timestamp)都能够满足我们的需要，存储精度都为秒，但在某些情况下，会展现出他们各自的优劣。下面就来总结一下两种日期类型的区别。
1.DATETIME的日期范围是1001——9999年，TIMESTAMP的时间范围是1970——2038年。
2.DATETIME存储时间与时区无关，TIMESTAMP存储时间与时区有关，显示的值也依赖于时区。在mysql服务器，操作系统以及客户端连接都有时区的设置。
3.DATETIME使用8字节的存储空间，TIMESTAMP的存储空间为4字节。因此，TIMESTAMP比DATETIME的空间利用率更高。
4.DATETIME的默认值为null；TIMESTAMP的字段默认不为空（not null）,默认值为当前时间（CURRENT_TIMESTAMP），如果不做特殊处理，并且update语句中没有指定该列的更新值，则默认更新为当前时间。
工作中一般都用datetime就可以了。
对上面的datatime与timestamp的区别的第四条的验证
mysql> create table t1(x datetime not null default now()); # 需要指定传入空值时默认取当前时间
Query OK, 0 rows affected (0.01 sec)
mysql> create table t2(x timestamp); # 无需任何设置，在传空值的情况下自动传入当前时间
Query OK, 0 rows affected (0.02 sec)
mysql> insert into t1 values();
Query OK, 1 row affected (0.00 sec)
mysql> insert into t2 values();
Query OK, 1 row affected (0.00 sec)
mysql> select * from t1;
+---------------------+
| x |
+---------------------+
| 2018-07-07 01:26:14 |
+---------------------+
1 row in set (0.00 sec)
mysql> select * from t2;
+---------------------+
| x |
+---------------------+
| 2018-07-07 01:26:17 |
+---------------------+
1 row in set (0.00 sec)
四. 字符串类型
类型: char, varchar
作用: ,名字, 信息等等
#官网：https://dev.mysql.com/doc/refman/5.7/en/char.html
#注意：char和varchar括号内的参数指的都是字符的长度
#char类型：定长，简单粗暴，浪费空间，存取速度快
字符长度范围：0-255（一个中文是一个字符，是utf8编码的3个字节）
存储：
存储char类型的值时，会往右填充空格来满足长度
例如：指定长度为10，存>10个字符则报错(严格模式下)，存<10个字符则用空格填充直到凑够10个字符存储
检索：
在检索或者说查询时，查出的结果会自动删除尾部的空格，如果你想看到它补全空格之后的内容，除非我们打开pad_char_to_full_length SQL模式（SET sql_mode = 'strict_trans_tables,PAD_CHAR_TO_FULL_LENGTH';）
#varchar类型：变长，精准，节省空间，存取速度慢
字符长度范围：0-65535（如果大于21845会提示用其他类型 。mysql行最大限制为65535字节，字符编码为utf-8：https://dev.mysql.com/doc/refman/5.7/en/column-count-limit.html）
存储：
varchar类型存储数据的真实内容，不会用空格填充，如果'ab ',尾部的空格也会被存起来
强调：varchar类型会在真实数据前加1-2Bytes的前缀，该前缀用来表示真实数据的bytes字节数（1-2Bytes最大表示65535个数字，正好符合mysql对row的最大字节限制，即已经足够使用）
如果真实的数据<255bytes则需要1Bytes的前缀（1Bytes=8bit 2**8最大表示的数字为255）
如果真实的数据>255bytes则需要2Bytes的前缀（2Bytes=16bit 2**16最大表示的数字为65535）
检索：
尾部有空格会保存下来，在检索或者说查询时，也会正常显示包含空格在内的内容
下面我们来进行一些测试，在测试之前，我们需要学一下mysql给我们提供的两个方法：
? length(字段)：查看该字段数据的字节长度
char_length(字段)：查看该字段数据的字符长度
char和varchar测试
创建一个t1表，包含一个char类型的字段
create table t1(id int,name char(4));
超过长度：
严格模式下(报错)：
mysql> insert into t1 values('xiaoshabi');
ERROR 1406 (22001): Data too long for column 'name' at row 1
非严格模式下(警告)：
mysql> set sql_mode='NO_ENGINE_SUBSTITUTION';
Query OK, 0 rows affected (0.00 sec)
mysql> create table t1(id int,name char(4));
Query OK, 0 rows affected (0.40 sec)
mysql> insert into t2 values('xiaoshabi');
Query OK, 1 row affected, 1 warning (0.11 sec)
查看一下结果：
mysql> select * from t1;
+------+------+
| id | name |
+------+------+
| 1 | xiao | #只有一个xiao
+------+------+
1 row in set (0.00 sec)
varchar类型和上面的效果是一样的，严格模式下也会报错。
如果没有超过长度，那么char类型时mysql会使用空格来补全自己规定的char(4)的4个字符，varchar不会，我们来做个对比
例如：
#再创建一个含有varchar类型的表t2
然后插入几条和t1里面相同的数据
mysql>insert into t1 values(2,'a'),(3,'bb'),(4,'ccc'),(5,'d');
mysql>create table t2(id int,name varchar(4));
mysql> insert into t2 values(1,'xiao'),(2,'a'),(3,'bb'),(4,'ccc'),(5,'d');
查看一下t1表和t2表的内容
mysql> select * from t1;
+------+------+
| id | name |
+------+------+
| 1 | xiao |
| 2 | a |
| 3 | bb |
| 4 | ccc |
| 5 | d |
+------+------+
5 rows in set (0.00 sec)
mysql> select * from t2;
+------+------+
| id | name |
+------+------+
| 1 | xiao |
| 2 | a |
| 3 | bb |
| 4 | ccc |
| 5 | d |
+------+------+
5 rows in set (0.00 sec)
好，两个表里面数据是一样的，每一项的数据长度也是一样的，那么我们来验证一下char的自动空格在后面补全的存储方式和varchar的不同
通过mysql提供的一个char_length()方法来查看一下所有数据的长度
mysql> select char_length(name) from t1;
+-------------------+
| char_length(name) |
+-------------------+
| 4 |
| 1 |
| 2 |
| 3 |
| 1 |
+-------------------+
5 rows in set (0.00 sec)
mysql> select char_length(name) from t2;
+-------------------+
| char_length(name) |
+-------------------+
| 4 |
| 1 |
| 2 |
| 3 |
| 1 |
+-------------------+
5 rows in set (0.00 sec)
通过查看结果可以看到，两者显示的数据长度是一样的，不是说好的char会补全吗，我设置的字段是char(4)，那么长度应该都是4才对啊？这是因为mysql在你查询的时候自动帮你把结果里面的空格去掉了，如果我们想看到它存储数据的真实长度，需要设置mysql的模式，通过一个叫做PAD_CHAR_TO_FULL_LENGTH的模式，就可以看到了，所以我们把这个模式加到sql_mode里面：
mysql> set sql_mode='PAD_CHAR_TO_FULL_LENGTH';
Query OK, 0 rows affected (0.00 sec)
然后我们在查看一下t1和t2数据的长度：
mysql> select char_length(name) from t1;
+-------------------+
| char_length(name) |
+-------------------+
| 4 |
| 4 |
| 4 |
| 4 |
| 4 |
+-------------------+
5 rows in set (0.00 sec)
mysql> select char_length(name) from t2;
+-------------------+
| char_length(name) |
+-------------------+
| 4 |
| 1 |
| 2 |
| 3 |
| 1 |
+-------------------+
5 rows in set (0.00 sec)
通过结果可以看到，char类型的数据长度都是4，这下看到了两者的不同了吧，至于为什么mysql会这样搞，我们后面有解释的，先看现象就可以啦。
现在我们再来看一个问题，就是当你设置的类型为char的时候，我们通过where条件来查询的时候会有一个什么现象：
mysql> select * from t1 where name='a';
+------+------+
| id | name |
+------+------+
| 2 | a |
+------+------+
1 row in set (0.00 sec)
ok，结果没问题，我们在where后面的a后面加一下空格再来试试：
mysql> select * from t1 where name='a ';
+------+------+
| id | name |
+------+------+
| 2 | a |
+------+------+
1 row in set (0.00 sec)
ok，能查到，再多加一些空格试试，加6个空格，超过了设置的char(4)的4：
mysql> select * from t1 where name='a ';
+------+------+
| id | name |
+------+------+
| 2 | a |
+------+------+
1 row in set (0.00 sec)
ok，也是没问题的
总结：通过>,=,>=,<,<=作为where的查询条件的时候，char类型字段的查询是没问题的。
但是，当我们将where后面的比较符号改为like的时候，(like是模糊匹配的意思，我们前面见过，show variables like '%char%';来查看mysql字符集的时候用过)
其中%的意思是匹配任意字符(0到多个字符都可以匹配到)，还有一个符号是_(匹配1个字符)，这两个字符其实就像我们学的正则匹配里面的通配符，那么我们通过这些符号进行一下模糊查询，看一下，char类型进行模糊匹配的时候，是否还能行，看例子：
mysql> select * from t1 where name like 'a';
Empty set (0.00 sec)
发现啥也没查到，因为char存储的数据是4个字符长度的，不满4个是以空格来补全的，你在like后面就只写了一个'a'，是无法查到的。
我们试一下上面的通配符来查询：
mysql> select * from t1 where name like 'a%';
+------+------+
| id | name |
+------+------+
| 2 | a |
+------+------+
1 row in set (0.00 sec)
这样就能看到查询结果了
试一下_是不是匹配1个字符：
mysql> select * from t1 where name like 'a_';
Empty set (0.00 sec)
发现一个_果然不行，我们试试三个_。
mysql> select * from t1 where name like 'a___';
+------+------+
| id | name |
+------+------+
| 2 | a |
+------+------+
1 row in set (0.00 sec)
发现果然能行，一个_最多匹配1个任意字符。
如果多写了几个_呢？
mysql> select * from t1 where name like 'a_____';
Empty set (0.00 sec)
查不到结果，说明_匹配的是1个字符，但不是0-1个字符。
测试结果总结：
针对char类型，mysql在存储的时候会将不足规定长度的数据使用后面(右边补全)补充空格的形式进行补全，然后存放到硬盘中，但是在读取或者使用的时候会自动去掉它给你补全的空格内容，因为这些空格并不是我们自己存储的数据，所以对我们使用者来说是无用的。
char和varchar性能对比：
以char(5)和varchar(5)来比较，加入我要存三个人名：sb，ssb1，ssbb2
char：
优点：简单粗暴，不管你是多长的数据，我就按照规定的长度来存，5个5个的存，三个人名就会类似这种存储：sb ssb1 ssbb2，中间是空格补全，取数据的时候5个5个的取，简单粗暴速度快
缺点：貌似浪费空间，并且我们将来存储的数据的长度可能会参差不齐
varchar：
varchar类型不定长存储数据，更为精简和节省空间
例如存上面三个人名的时候类似于是这样的：sbssb1ssbb2，连着的，如果这样存，请问这三个人名你还怎么取出来，你知道取多长能取出第一个吗？
不知道从哪开始从哪结束，遇到这样的问题，你会想到怎么解决呢？还记的吗？想想？socket？tcp？struct？把数据长度作为消息头。
所以，varchar在存数据的时候，会在每个数据前面加上一个头，这个头是1-2个bytes的数据，这个数据指的是后面跟着的这个数据的长度，1bytes能表示2 ** 8=256，两个bytes表示2**16=65536，能表示0-65535的数字，所以varchar在存储的时候是这样的：1bytes+sb+1bytes+ssb1+1bytes+ssbb2，所以存的时候会比较麻烦，导致效率比char慢，取的时候也慢，先拿长度，再取数据。
优点：节省了一些硬盘空间，一个acsii码的字符用一个bytes长度就能表示，但是也并不一定比char省，看一下官网给出的一个表格对比数据，当你存的数据正好是你规定的字段长度的时候，varchar反而占用的空间比char要多。
| Value | CHAR(4) |
Storage Required | VARCHAR(4) |
Storage Required |
|---|---|---|---|---|
‘‘ |
‘ ‘ |
4 bytes | ‘‘ |
1 byte |
‘ab‘ |
‘ab ‘ |
4 bytes | ‘ab‘ |
3 bytes |
‘abcd‘ |
‘abcd‘ |
4 bytes | ‘abcd‘ |
5 bytes |
‘abcdefgh‘ |
‘abcd‘ |
4 bytes | ‘abcd‘ |
5 bytes |
缺点：存取速度都慢
总结：
所以需要根据业务需求来选择用哪种类型来存
其实在多数的用户量少的工作场景中char和varchar效率差别不是很大，最起码给用户的感知不是很大，并且其实软件级别的慢远比不上硬件级别的慢，所以你们公司的运维发现项目慢的时候会加内存、换nb的硬盘，项目的效率提升的会很多，但是我们作为专业人士，我们应该提出来这样的技术点来提高效率。
但是对于InnoDB数据表，内部的行存储格式没有区分固定长度和可变长度列（所有数据行都使用指向数据列值的头指针），因此在本质上，使用固定长度的CHAR列不一定比使用可变长度VARCHAR列性能要好。因而，主要的性能因素是数据行使用的存储总量。由于CHAR平均占用的空间多于VARCHAR，因此使用VARCHAR来最小化需要处理的数据行的存储总量和磁盘I/O是比较好的。
所以啊，两个选哪个都可以，如果是大型并发项目，追求高性能的时候，需要结合你们服务器的硬件环境来进行测试，看一下char和varchar哪个更好，这也能算一个优化的点吧~~~~
其他的字符串类型：BINARY、VARBINARY、BLOB、TEXT
其他类型简单介绍:
BINARY 和 VARBINARY 类似于 CHAR 和 VARCHAR，不同的是它们包含二进制字符串而不要非二进制字符串。也就是说，它们包含字节字符串而不是字符字符串。这说明它们没有字符集，并且排序和比较基于列值字节的数值值。
BLOB 是一个二进制大对象，可以容纳可变数量的数据。有 4 种 BLOB 类型：TINYBLOB、BLOB、MEDIUMBLOB 和 LONGBLOB。它们区别在于可容纳存储范围不同。
有 4 种 TEXT 类型：TINYTEXT、TEXT、MEDIUMTEXT 和 LONGTEXT。对应的这 4 种 BLOB 类型，可存储的最大长度不同，可根据实际情况选择。
BLOB：
1._BLOB和_text存储方式不同，_TEXT以文本方式存储，英文存储区分大小写，而_Blob是以二进制方式存储，不分大小写。
2._BLOB存储的数据只能整体读出。
3._TEXT可以指定字符集，_BLO不用指定字符集。
五. 枚举类型与集合类型
? 字段的值只能在给定范围中选择，如单选框，多选框，如果你在应用程序或者前端不做选项限制，在MySQL的字段里面也能做限制
enum 单选 只能在给定的范围内选一个值，如性别 sex 男male/女female
set 多选 在给定的范围内可以选择一个或一个以上的值（爱好1,爱好2,爱好3...）
枚举类型（enum）
An ENUM column can have a maximum of 65,535 distinct elements. (The practical limit is less than 3000.)
示例：
CREATE TABLE shirts (
name VARCHAR(40),
size enum('x-small', 'small', 'medium', 'large', 'x-large')
);
INSERT INTO shirts (name, size) VALUES ('dress shirt','large'), ('t-shirt','medium'),('polo shirt','small');
集合类型（set）
A SET column can have a maximum of 64 distinct members.
示例：
CREATE TABLE myset (col SET('a', 'b', 'c', 'd'));
INSERT INTO myset (col) VALUES ('a,d'), ('d,a'), ('a,d,a'), ('a,d,d'), ('d,a,d');
枚举类型与集合类型测试
mysql> create table consumer(
-> name varchar(50),
-> sex enum('male','female'),
-> level enum('vip1','vip2','vip3','vip4','vip5'), #在指定范围内，多选一
-> hobby set('play','music','read','study') #在指定范围内，多选多
-> );
mysql> insert into consumer values
-> ('xiaogui','male','vip5','read,study'),
-> ('taibai','female','vip1','girl');
mysql> select * from consumer;
+------+--------+-------+------------+
| name | sex | level | hobby |
+------+--------+-------+------------+
| xiaogui | male | vip5 | read,study |
| taibai | female | vip1 | |
+------+--------+-------+------------+
以上是关于MySQL之常用数据类型的主要内容，如果未能解决你的问题，请参考以下文章