架构视界
主页
企业架构
  • 方案总览
  • 业财一体
  • 企业中台
  • 组织与绩效
  • 流程治理
数据收集与分析
  • 转型总览
  • 信息化阶段
  • 数字化解决方案
  • 智数化解决方案
  • 智能化解决方案
  • 产品设计
  • 项目管理
全栈软件工程
AI 原生软件工程
方法论
博客
  • 资源导航
  • 效率工具
  • 展示专区
主页
企业架构
  • 方案总览
  • 业财一体
  • 企业中台
  • 组织与绩效
  • 流程治理
数据收集与分析
  • 转型总览
  • 信息化阶段
  • 数字化解决方案
  • 智数化解决方案
  • 智能化解决方案
  • 产品设计
  • 项目管理
全栈软件工程
AI 原生软件工程
方法论
博客
  • 资源导航
  • 效率工具
  • 展示专区
  • 标签索引
  • 2024年

    • 勇闯大A:美债与美元周期
    • 勇闯大A:交易纪律与自我管理
    • 勇闯大A:交易系统分层
    • 勇闯大A:买卖点与止损规则
    • 勇闯大A:债券与资金流向
    • 勇闯大A:微观、宏观与周期
    • Mac 开发环境:新机配置清单
    • 勇闯大A:内外盘与换手率
    • 会计管理:财报阅读与管理报表
    • 会计基础:记账原理与分录
    • 财务入门:财务体系全景
  • 2023年

    • 境外投资:泰国 BOI 申请实务
  • 2022年

    • 企业架构:故障管理与分级响应
    • 企业架构:技术债务的识别、度量与偿还
  • 2021年

    • Python 数据分析:员工分布可视化
    • Python 数据分析:IP 访问折线图
    • Python 数据分析:IP 词云图
    • Redis:RediSearch 全文检索
    • Rust 基础:第一个 CLI 程序
    • Rust 基础:所有权机制
    • Rust 基础:函数与控制流
    • Rust 基础:变量与数据类型
    • Rust 基础:入门与开发环境
    • 企业架构:分布式系统设计
    • 企业架构:编程式权限设计
    • JVM 调优:启动参数与 GC 日志
    • MyBatis 批量插入:三种写法对比
    • 测试:Spring Boot 分层 Mock
    • Redis:布隆过滤器判断元素存在
    • Jenkins:安装配置与应用部署
    • WebClient:非阻塞 HTTP 客户端
    • Drone:Docker 部署轻量 CI
    • Spring AOP:操作审计日志落库
    • Redisson:分布式锁与 RedLock
    • MyBatis 拦截器:雪花算法主键
    • Netty:线程模型与网络编程
    • Redis:SCAN 游标遍历大键空间
    • Jenkins:单机部署与升级脚本
    • Mac:Neo4j 与 Jupyter 安装
    • JavaFX:OpenJDK 11 环境配置
    • Mac:用 jenv 管理 JDK 版本
    • Redis:有序集合实现延时队列
    • Spring Boot 日志:MDC 串联链路
    • 定时任务:Spring 调度与 Cron
    • GoAccess:Nginx 日志分析
    • MyBatis 拦截器:慢 SQL 分析
    • Lucene:倒排索引与中文分词
    • 分布式锁:三种实现方案对比
    • 学习技巧:减少学习排斥心理
    • 动态数据源:多租户数据路由
    • Compose:Spring Boot 三件套
    • Java 阻塞队列:源码与用法
    • Redis:Docker Compose 哨兵
    • Redis:Docker Compose 主从
    • 网络通信:TCP/IP 与 HTTP 基础
  • 2020年

    • 延时队列:DelayQueue 与 Redis 实现
    • MySQL 基础:员工库导入实践
    • 雪花算法:分布式 ID 生成
    • Redis:地理位置查询
    • 抓包:Wireshark 与 Tcpdump
    • SPI:JDK 与 Spring 扩展机制
    • ZooKeeper:概念与集群搭建
    • Spring Boot:集成 JMH 基准测试
    • Wireshark:抓包工具入门
    • Compose:Redis 与 MySQL
    • CentOS 7:Docker 安装部署
    • Netty:源码阅读环境搭建
    • MySQL 基础:SQL 常见用法
    • CentOS 7:Selenium 运行环境
    • Nginx:HTTPS 证书配置
    • JMH:基准测试与 Spring Boot 集成
    • Spring Boot:指定 Tomcat 版本
    • Eureka:实例上下线告警
    • 钉钉告警:应用异常与实例上下线
    • JVM:内存布局、类加载与调优
    • Git:rebase 合并多次提交
    • CentOS 7:OpenResty 部署
  • 2019年

    • Redis CLI:macOS 安装与使用
    • Nginx:访问日志格式
    • 工程规范:可维护代码的写法
    • IntelliJ IDEA:常用插件
    • SkyWalking:源码阅读环境搭建
    • Spring Boot:Redis 超时配置
    • gRPC:ProtoBuf 定义与代码生成
    • Arthas:Java 线上问题诊断
    • Redis:缓存穿透与击穿防护
    • Docker 部署:Elasticsearch
    • Docker 部署:MySQL 5.7 单机
    • Spring Redis:字符串命令封装
    • Docker 部署:ZooKeeper 运行
    • Docker 部署:Redis 单机运行
    • Dubbo:Spring Boot 微服务集成
    • CentOS 7:CMake 源码编译安装
    • 性能度量:吞吐量与 QPS 指标
    • Java 递归:从笔试题到经典问题
    • CentOS 7:ELK 日志平台部署
    • CentOS 7:SonarQube 部署
    • Selenium:Chrome 浏览器自动化
    • JJWT:令牌生成与解析测试
    • Spring 源码:阅读环境搭建
    • JUnit 4:注解、断言与参数化
    • JWT:令牌结构与签名机制
    • FastDFS:架构与文件存取机制
    • XPath:XML 文档节点定位
    • Redis 基础:锁、队列与事务
    • Redis 基础:数据类型与命令
    • MyBatis:Slf4j 日志接入
    • MyBatis:H2 单元测试与 SQL 日志
    • 源码阅读:开源项目环境搭建
    • Git 配置:命令清单与作用域
    • Java 核心:面向对象与基础类型
    • Java 核心:关键字、异常与反射
    • Java 核心:多线程基础
    • Java 核心:同步关键字与线程池
    • Java 核心:锁与并发工具
    • Java 核心:语言基础与并发
    • Dubbo:远程调用与服务治理
    • Java 集合:框架总览与实现对比
    • Maven:生命周期与常用命令
    • MyBatis:执行流程与插件机制
    • Spring:IoC 容器与依赖注入
    • Spring:AOP 与自动装配
    • Spring:事务与启动流程
    • Spring:IoC、AOP 与事务
    • Spring MVC:请求分发与注解
    • MySQL:架构与索引
    • MySQL:事务、锁与 MVCC
    • MySQL:日志与 SQL 优化
    • MySQL:架构、事务与优化
    • Redis 基础:持久化与线程模型
  • 2018年

    • Java HashMap:扩容机制与哈希冲突
    • Java 集合:HashSet 去重原理
    • Java 基础:交换两个变量的值
    • Spring MVC:零 web.xml 改造
    • Mac 开发环境:新机配置清单
    • Log4j:日志分级与按业务拆分
    • Modbus:工业通信协议与 RTU 帧
    • MySQL 基础:子查询与连接查询
    • MySQL 基础:库与表操作
    • MySQL 基础:表操作与查询
    • MySQL 基础:约束、引擎与数据类型
    • MySQL 基础:库表、约束与类型
    • Java 集合:Vector 与 Stack
    • Java 集合:Vector 与 Stack
    • RabbitMQ:CentOS 7 单机部署
    • Redis:CentOS 7 单机部署
    • MongoDB:CentOS 7 单机部署
    • Linux:常用系统与运维命令
    • 注册中心:Eureka 与 ZooKeeper
    • MySQL:CentOS 7 单机部署
    • Git 分支:主分支与临时分支
    • CentOS 7:Java 开发环境部署
    • Java 集合:LinkedList 双向链表
    • Java 集合:ArrayList 动态数组
    • Spring AOP:注解方式实现切面
← 返回博客

MySQL 基础:约束、引擎与数据类型

2018年4月29日 #数据与存储 #MySQL

系列文章:MySQL 基础:库表、约束与类型 的第 3 篇。

约束

实际上分为两种,表约束和列约束。列属性的约束上面已经讲述了,现在来讲述下表约束。

列约束

  • 在之前的插入表数据(一)中已经演示了5种常用的约束,下面主要介绍表之前的约束。

外键约束

  1. 父表和子表必须使用相同的存储引擎,而且禁止使用临时表。
  2. 数据表的存储引擎只能是InnoDB。
  3. 外键列和参照列必须具有相同的数据类型,其中数字的长度或是否有符号UNSIGNED必须一致;而字符的长度可以不同。
  4. 外键列和参照列必须创建索引,如果没有创建Mysql也会自动创建。

由于本人开发中,使用外键的场景比较少,所以这里最后在补充。

数据库存储引擎

数据库默认的存储引擎可以在 my.cnf 中设置。

default-storage-engine=INNODB
  • Mysql可以将数据以不同的技术存储在文件(内存)中,这种技术就成为存储引擎。

  • 每一种存储引擎使用不同的存储机制、索引技巧、锁定水平,最终提供广泛且不同的功能。

  • 引擎类型

    • MyISAM
    • InnoDB
    • Memory
    • CSV
    • Archive
  • 而确定使用那种引擎取决与引用场景。

    • 并发控制:当多个连接对记录经行修改时候,保证数据的一致性和完整性
    • 锁:共享锁(读锁)、排它锁(写锁)。
      • 读锁同一个时间内,多个用户可以读取同一个资源,读取过程中数据不会发生任何变化。
      • 写锁在任何时候只能有一个用户能写入资源,当其他写锁时会阻塞其他读锁或则写锁操作。
      • 锁颗粒
        • 表锁(开销很小的锁策略)、行锁(开销很大的锁策略)。
    • 事务(ACID):保证数据库的完整性
      • 原子性
      • 一致性
      • 隔离性
      • 持久性
    • 索引
特点MyISAMInnoDBMemoryArchive
存储限制256TB64TB有无
事务安全-支持--
支持索引支持支持支持-
锁颗粒表锁行锁表锁行锁
数据压缩支持--支持
支持外键-支持--

看到这张表很清楚了,这就是为什么InnoDB用的很广泛的原因。

Mysql数据类型

数据类型是指列、存储过程参数、表达式和局部变量的数据特征,它们决定了数据存储的格式,代表了不同的数据信息类型。我们的计算都是二进制来存储数据的,当然这还牵扯到一个问题就是正数和负数。

数据类型思维导图

数据类型存储范围说明

所谓的无符号就是unsigned,这样会使大小翻倍。

整型

  • TINYINT 迷你整数型
    • 字节:1
  • SMALLINT 小整型
    • 字节:2
  • MEDIUMINT 中整型
    • 字节:3
  • INT 标准整型
    • 字节:4
  • BIGINT 大整型
    • 字节:8

用Java代码测试下。

public static void main(String[] args) {
        System.out.println("采用移位运算所以次方所以相比次方的数值会减一");

        System.out.println("TINTITN 有符号 "+ (-2L << 6) + " 到 " +((2L << 6) - 1));
        System.out.println("TINTITN 无符号 0 到 "+(Math.pow(2L,8) - 1));

        System.out.println("SMALLINT 有符号 "+ (-2L << 14) + " 到 " +((2L << 14) - 1));
        System.out.println("SMALLINT 无符号 0 到 "+((2L << 14) - 1));

        System.out.println("MEDIUMINT 有符号 "+ (-2L << 22) + " 到 " +((2L << 22) - 1));
        System.out.println("MEDIUMINT 无符号 0 到 "+((2L << 23) - 1));

        System.out.println("INT 有符号 "+ (-2L << 30) + " 到 " +((2L << 30) - 1));
        System.out.println("INT 无符号 0 到 "+((2L << 31) - 1));

        System.out.println("BIGINT 有符号 "+ (-2L << 62) + " 到 " +((2L << 62) - 1));
        System.out.println("BIGINT 无符号 0 到 "+ ((2L << 63) - 1));
    }

输出

采用移位运算所以次方所以相比次方的数值会减一
TINTITN 有符号 -128 到 127
TINTITN 无符号 0 到 255.0
SMALLINT 有符号 -32768 到 32767
SMALLINT 无符号 0 到 32767
MEDIUMINT 有符号 -8388608 到 8388607
MEDIUMINT 无符号 0 到 16777215
INT 有符号 -2147483648 到 2147483647
INT 无符号 0 到 4294967295
BIGINT 有符号 -9223372036854775808 到 9223372036854775807
BIGINT 无符号 0 到-1
# 这里可以看到BIGINT 无符号Java long数据类型已经满足不了了。

在数据优化的原则上,合理的选择存储数据类型。而不是盲目的选择数据类型大。比如我们的年龄用TINTINT 就够了。也就说在指定数据类型的时候,一般是采用从小原则,这样会对MYSQL的效率提高很多。当然做好设计。

SQL测试

# 创建int类型的表看看。
[root@localhost][Demo]> CREATE TABLE test_int(
    -> id TINYINT UNSIGNED PRIMARY KEY AUTO_INCREMENT ,
    -> int_1 TINYINT ,
    -> int_2 SMALLINT ,
    -> int_3 MEDIUMINT ,
    -> int_4 INT ,
    -> int_5 BIGINT
    -> );
Query OK, 0 rows affected (0.07 sec)
# 查看表结构。
[root@localhost][Demo]> SHOW COLUMNS FROM test_int;
+-------+---------------------+------+-----+---------+----------------+
| Field | Type                | Null | Key | Default | Extra          |
+-------+---------------------+------+-----+---------+----------------+
| id    | tinyint(3) unsigned | NO   | PRI | NULL    | auto_increment |
| int_1 | tinyint(4)          | YES  |     | NULL    |                |
| int_2 | smallint(6)         | YES  |     | NULL    |                |
| int_3 | mediumint(9)        | YES  |     | NULL    |                |
| int_4 | int(11)             | YES  |     | NULL    |                |
| int_5 | bigint(20)          | YES  |     | NULL    |                |
+-------+---------------------+------+-----+---------+----------------+
6 rows in set (0.00 sec)

#插入测试1,整型插入。成功。
[root@localhost][Demo]> INSERT INTO test_int VALUES(NULL,1,2,3,4,5);
Query OK, 1 row affected (0.01 sec)

#插入测试2,用单引号包裹数字。竟然成功了。
[root@localhost][Demo]> INSERT INTO test_int VALUES(NULL,'1','2','3','4','5');
Query OK, 1 row affected (0.01 sec)

#插入测试3,用字符串测试。肯定是插入不成功。
[root@localhost][Demo]> INSERT INTO test_int VALUES(NULL,'a','b','c','d','e');
ERROR 1366 (HY000): Incorrect integer value: 'a' for column 'int_1' at row 1

#测试下有符号的情况,这里提示int_1 超过范围了。
[root@localhost][Demo]> INSERT INTO test_int VALUES(NULL,-200,2,3,4,5);
ERROR 1264 (22003): Out of range value for column 'int_1' at row 1

#修改参数试试,成功了。TINYINT 有符号 是 -128 到 127。
[root@localhost][Demo]> INSERT INTO test_int VALUES(NULL,-128,2,3,4,5);
Query OK, 1 row affected (0.00 sec)

#修改 int_1 的属性 修改成UNSIGNED。无符号。注意在修改字段属性的时候,如果已经存在数据请确认存在的数据是否有不合法的。
[root@localhost][Demo]> ALTER TABLE test_int MODIFY int_1 TINYINT UNSIGNED;
ERROR 1264 (22003): Out of range value for column 'int_1' at row 3

#为了继续测试,删除掉表中数据。
[root@localhost][Demo]> DELETE FROM test_int;
Query OK, 4 rows affected (0.03 sec)

#重新修改表字段结构。
[root@localhost][Demo]> ALTER TABLE test_int MODIFY int_1 TINYINT UNSIGNED;
Query OK, 0 rows affected (0.13 sec)
Records: 0  Duplicates: 0  Warnings: 0

# 检查是否修改成功。可以看到 int_1 添加了UNSIGNED属性约束了。
[root@localhost][Demo]> SHOW COLUMNS FROM test_int;
+-------+---------------------+------+-----+---------+----------------+
| Field | Type                | Null | Key | Default | Extra          |
+-------+---------------------+------+-----+---------+----------------+
| id    | tinyint(3) unsigned | NO   | PRI | NULL    | auto_increment |
| int_1 | tinyint(3) unsigned | YES  |     | NULL    |                |
| int_2 | smallint(6)         | YES  |     | NULL    |                |
| int_3 | mediumint(9)        | YES  |     | NULL    |                |
| int_4 | int(11)             | YES  |     | NULL    |                |
| int_5 | bigint(20)          | YES  |     | NULL    |                |
+-------+---------------------+------+-----+---------+----------------+
6 rows in set (0.00 sec)
# 插入TINYINT 最大值试试,OK这里是成功的。
[root@localhost][Demo]> INSERT INTO test_int VALUES(NULL,255,2,3,4,5);
Query OK, 1 row affected (0.00 sec)

# 当超过TINYINT UNSIGNED最大的时候就会抛出异常信息。
[root@localhost][Demo]> INSERT INTO test_int VALUES(NULL,256,2,3,4,5);
ERROR 1264 (22003): Out of range value for column 'int_1' at row 1

这里就演示TINYINT存储范围的情况了,实际上其它证书型基本类似。

实际上有一点需要注意就是TYPE中的花括弧中的数字是干嘛的

# 这个3个是干嘛的呢?
tinyint(3) unsigned

这实际上是显示宽度的意思。当显示的宽度不够的时候可以使用0来填充,使用zreofuill进行零填充,而且零填充会直接导致该数值变成服务号。

# 演示修改表结构,将int_1字段再次修改。
[root@localhost][Demo]> ALTER TABLE test_int MODIFY int_1 TINYINT UNSIGNED ZEROFILL;
Query OK, 0 rows affected (0.02 sec)
Records: 0  Duplicates: 0  Warnings: 0

#检查表结构是否发生变化
[root@localhost][Demo]> SHOW COLUMNS FROM test_int;
+-------+------------------------------+------+-----+---------+----------------+
| Field | Type                         | Null | Key | Default | Extra          |
+-------+------------------------------+------+-----+---------+----------------+
| id    | tinyint(3) unsigned          | NO   | PRI | NULL    | auto_increment |
| int_1 | tinyint(3) unsigned zerofill | YES  |     | NULL    |                |
| int_2 | smallint(6)                  | YES  |     | NULL    |                |
| int_3 | mediumint(9)                 | YES  |     | NULL    |                |
| int_4 | int(11)                      | YES  |     | NULL    |                |
| int_5 | bigint(20)                   | YES  |     | NULL    |                |
+-------+------------------------------+------+-----+---------+----------------+
6 rows in set (0.00 sec)

# 插入新的数据
[root@localhost][Demo]> INSERT test_int VALUES(NULL,1,2,3,4,5);
Query OK, 1 row affected (0.01 sec)

# 刚才插入的int_1位置的值已经发生了变化。
[root@localhost][Demo]> SELECT * FROM test_int;
+----+-------+-------+-------+-------+-------+
| id | int_1 | int_2 | int_3 | int_4 | int_5 |
+----+-------+-------+-------+-------+-------+
|  5 |   255 |     2 |     3 |     4 |     5 |
|  6 |   001 |     2 |     3 |     4 |     5 |
+----+-------+-------+-------+-------+-------+
2 rows in set (0.00 sec)

填充零的含义更多的就是保证数据的格式。

浮点型

  • FLOAT 单精度浮点型
    • 字节:4
  • DOUBLE 双精度浮点型
    • 字节:8

在SQL中,将小数型分配两种浮点型和定点型两种。

  • 浮点型使用注意事项,如果直接使用float,则标识没有小数部分,如果用了float(M,D),其中M代表长度,D代表小数部分长度,M-D则为整数部分长度。

SQL测试

# 创建测试表test_float
[root@localhost][Demo]> CREATE TABLE test_float(
    -> id TINYINT UNSIGNED AUTO_INCREMENT PRIMARY KEY ,
    -> float_1 float,
    -> float_2 float(6,2),
    -> float_3 float(4,1)
    -> );
Query OK, 0 rows affected (0.07 sec)

# 检查表结构
[root@localhost][Demo]> SHOW COLUMNS FROM test_float;
+---------+---------------------+------+-----+---------+----------------+
| Field   | Type                | Null | Key | Default | Extra          |
+---------+---------------------+------+-----+---------+----------------+
| id      | tinyint(3) unsigned | NO   | PRI | NULL    | auto_increment |
| float_1 | float               | YES  |     | NULL    |                |
| float_2 | float(6,2)          | YES  |     | NULL    |                |
| float_3 | float(4,1)          | YES  |     | NULL    |                |
+---------+---------------------+------+-----+---------+----------------+
4 rows in set (0.00 sec)

#插入模拟数据
[root@localhost][Demo]> INSERT INTO test_float VALUES(NULL,2.1534,11,888.1);
Query OK, 1 row affected (0.00 sec)

#这里需要注意的时候 float(4,2)实际标识的整数位小于4,而不是小于等于。测试下
[root@localhost][Demo]> INSERT INTO test_float VALUES(NULL,2.1534,11,8888.1);
ERROR 1264 (22003): Out of range value for column 'float_3' at row 1
# 结果很明显,8888.1 插入失败。所以插入的时候也需要注意。

定点型

  • DECIMAL 定点数
    • 字节:3

定点型数据,绝对的保证整数部分不会被四舍五入,也就是说不会损失经度,但是小数部分有可能损失精度,虽然理论上小数部分也不会丢失精度。

SQL测试

# 与float比较,看看是否会四舍五入。
[root@localhost][Demo]> CREATE TABLE test_decimal(
    -> id TINYINT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
    -> float_1 float(10,2),
    -> decimal_1 decimal(10,2)                                                                         
    -> );
Query OK, 0 rows affected (0.09 sec)

# 测试模拟数据
[root@localhost][Demo]> INSERT test_decimal VALUES(NULL,99999999.99 , 99999999.99);
Query OK, 1 row affected, 1 warning (0.00 sec)

# 果然啊,float的被四舍五入了,而decimal保留的小数位。
[root@localhost][Demo]> SELECT * FROM test_decimal;
+----+--------------+-------------+
| id | float_1      | decimal_1   |
+----+--------------+-------------+
|  2 | 100000000.00 | 99999999.99 |
+----+--------------+-------------+
1 row in set (0.00 sec)

日期类型

  • YEAR 年份
    • 字节:1
  • TIME 时间
    • 字节:3
  • DATE 日期
    • 字节:3
  • DATETIME 日期时间
    • 字节:8
  • TIMESTAMP 时间戳
    • 字节:4

由于存在跨时区的问题,所以一般都是存数字日期,日期类型用的相对会比较少。

  • 补充类型概况
    • DATATIME:日期时间,其格式为yyyy-MM-dd HH:mm:ss,表示的范围是从 1000 年到 9999 年,有零值,即0000-00-00 0000:00;
    • DATA:日期,就是datetime的date部分;
    • TIME:时间,或者说是时间段,为指定的某个时间区间之间,包含正负时间;
    • TIMESTAMP :时间戳,但并不是真正意义上的时间戳,其是从1970年开始计算的,格式和datetime一致;
    • YEAR :年份,共有两种格式,分别为year(2)和year(4).

SQL测试

# 创建一日期测试表 test_date
[root@localhost][Demo]> CREATE TABLE test_date(
    -> id TINYINT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
    -> date_1 DATETIME,
    -> date_2 DATE,
    -> date_3 TIME,
    -> date_4 YEAR,
    -> date_5 TIMESTAMP
    -> );
Query OK, 0 rows affected (0.04 sec)

#检查表结构
[root@localhost][Demo]> SHOW COLUMNS FROM test_date;
+--------+---------------------+------+-----+-------------------+-----------------------------+
| Field  | Type                | Null | Key | Default           | Extra                       |
+--------+---------------------+------+-----+-------------------+-----------------------------+
| id     | tinyint(3) unsigned | NO   | PRI | NULL              | auto_increment              |
| date_1 | datetime            | YES  |     | NULL              |                             |
| date_2 | date                | YES  |     | NULL              |                             |
| date_3 | time                | YES  |     | NULL              |                             |
| date_4 | year(4)             | YES  |     | NULL              |                             |
| date_5 | timestamp           | NO   |     | CURRENT_TIMESTAMP | on update CURRENT_TIMESTAMP |
+--------+---------------------+------+-----+-------------------+-----------------------------+
6 rows in set (0.00 sec)

# 添加测试数据
[root@localhost][Demo]> INSERT INTO test_date VALUES(NULL,'2017-05-06 13:15:00','2017-05-06','13:15:00',2018,'2017-05-06 13:15:00');
Query OK, 1 row affected (0.00 sec)

# 检查数据结果
[root@localhost][Demo]> SELECT * FROM test_date;
+----+---------------------+------------+----------+--------+---------------------+
| id | date_1              | date_2     | date_3   | date_4 | date_5              |
+----+---------------------+------------+----------+--------+---------------------+
|  1 | 2017-05-06 13:15:00 | 2017-05-06 | 13:15:00 |   2018 | 2017-05-06 13:15:00 |
+----+---------------------+------------+----------+--------+---------------------+
1 row in set (0.01 sec)

# 验证下时间戳是否会自动更新。
[root@localhost][Demo]> UPDATE test_date SET date_4 = 2017 WHERE id = 1;
Query OK, 1 row affected (0.01 sec)
Rows matched: 1  Changed: 1  Warnings: 0

# 检查下结果
[root@localhost][Demo]> SELECT * FROM test_date;
+----+---------------------+------------+----------+--------+---------------------+
| id | date_1              | date_2     | date_3   | date_4 | date_5              |
+----+---------------------+------------+----------+--------+---------------------+
|  1 | 2017-05-06 13:15:00 | 2017-05-06 | 13:15:00 |   2017 | 2018-05-02 04:36:31 |
+----+---------------------+------------+----------+--------+---------------------+
1 row in set (0.00 sec)
# 这里可以看到 date_5 已经发生了变化。

字符型

  • CHAR(M)
    • 字节:M个字节,0 <= M <= 255
  • VARCHAR(M)
    • 字节:L + 1个字节 , 其中L <= M 且 0 <= M <= 65535
  • TINYTEXT
    • 字节:L + 1个字节, 其中L < 2^8。
  • TEXT
    • 字节:L + 2个字节,其中L < 2^16。
  • MEDIUMTEXT
    • 字节:L + 3个字节,其中L < 2^24。
  • LONGTEXT
    • 字节:L + 4个字节,其中 L < 2^32。
  • ENMU('value1','value2')
    • 字节:1或者2字节,取决与枚举值的个数(最多65535个值)。
  • SET('value1','value2')
    • 字节:1、2、3、4或者8字节,取决与Set成员的数目(最多64个成员)

这里涉及到定长和变长,比如说CHAR(M),如果存储的是ABC但是没有达到指定的长度就会在ABC后面添加空格直至满足长度大小。

字符串分类

  • 定长:CHAR
  • 变长:VARCHAR
  • 文本:TINYTEXT、TEXT、MEDIUMTEXT、LONGTEXT
  • 枚举:ENMU
  • 集合:SET

小结

主键唯一且非空,外键维护引用完整性;整型按范围选宽度,金额用 decimal,日期与字符类型按精度和排序规则取舍。

最近更新: 2026/11/20 22:35
Contributors: 庆峰
Prev
MySQL 基础:表操作与查询
Next
MySQL 基础:库表、约束与类型