MySQL实战45讲学习笔记：第十四讲

1、引子

在开发系统的时候，你可能常常须要计算一个表的行数，好比一个交易系统的全部变动记录总数。这时候你可能会想，一条 select count(*) from t 语句不就解决了吗？

可是，你会发现随着系统中记录数愈来愈多，这条语句执行得也会愈来愈慢。而后你可能就想了，MySQL 怎么这么笨啊，记个总数，每次要查的时候直接读出来，不就行了吗。

那么今天，咱们就来聊聊 count(*) 语句究竟是怎样实现的，以及 MySQL 为何会这么实现。而后，我会再和你说说，若是应用中有这种频繁变动并须要统计表行数的需求，业务
设计上能够怎么作。

2、count(*) 的实现方式

你首先要明确的是，在不一样的 MySQL 引擎中，count(*) 有不一样的实现方式

一、MyISAM 表虽然 count(*) 很快，可是不支持事务；

1. MyISAM 引擎把一个表的总行数存在了磁盘上，所以执行 count(*) 的时候会直接返回这个数，效率很高；
2. 而 InnoDB 引擎就麻烦了，它执行 count(*) 的时候，须要把数据一行一行地从引擎里面读出来，而后累积计数。

这里须要注意的是，咱们在这篇文章里讨论的是没有过滤条件的 count(*)，若是加了where 条件的话，MyISAM 表也是不能返回得这么快的。

在前面的文章中，咱们一块儿分析了为何要使用 InnoDB，由于不管是在事务支持、并发能力仍是在数据安全方面，InnoDB 都优于 MyISAM。我猜你的表也必定是用了 InnoDB
引擎。这就是当你的记录数愈来愈多的时候，计算一个表的总行数会愈来愈慢的缘由。

二、show table status 命令虽然返回很快，可是不许确；

若是你用过 show table status 命令的话，就会发现这个命令的输出结果里面也有一个TABLE_ROWS 用于显示这个表当前有多少行，这个命令执行挺快的，那这个
TABLE_ROWS 能代替 count(*) 吗？

你可能还记得在第 10 篇文章《 MySQL 为何有时候会选错索引？》中我提到过，索引统计的值是经过采样来估算的。实际上，TABLE_ROWS 就是从这个采样估算得来的，因
此它也很不许。有多不许呢，官方文档说偏差可能达到 40% 到 50%。因此，show tablestatus 命令显示的行数也不能直接使用。

三、InnoDB 表直接 count(*) 会遍历全表，虽然结果准确，但会致使性能问题

那为何 InnoDB 不跟 MyISAM 同样，也把数字存起来呢？

这是由于即便是在同一个时刻的多个查询，因为多版本并发控制（MVCC）的缘由，InnoDB 表“应该返回多少行”也是不肯定的。这里，我用一个算 count(*) 的例子来为你
解释一下。

假设表 t 中如今有 10000 条记录，咱们设计了三个用户并行的会话。

咱们假设从上到下是按照时间顺序执行的，同一行语句是在同一时刻执行的。

MyISAM 引擎把一个表的总行数存在了磁盘上，所以执行 count(*) 的时候会直接返回这个数，效率很高；

而 InnoDB 引擎就麻烦了，它执行 count(*) 的时候，须要把数据一行一行地从引擎里面读出来，而后累积计数。

1. 会话 A 先启动事务并查询一次表的总行数；
2. 会话 B 启动事务，插入一行后记录后，查询表的总行数；
3. 会话 C 先启动一个单独的语句，插入一行记录后，查询表的总行数。

图 1 会话 A、B、C 的执行流程

你会看到，在最后一个时刻，三个会话 A、B、C 会同时查询表 t 的总行数，但拿到的结果却不一样。

这和 InnoDB 的事务设计有关系，可重复读是它默认的隔离级别，在代码上就是经过多版本并发控制，也就是 MVCC 来实现的。每一行记录都要判断本身是否对这个会话可见，因
此对于 count(*) 请求来讲，InnoDB 只好把数据一行一行地读出依次判断，可见的行才可以用于计算“基于这个查询”的表的总行数。

备注：若是你对 MVCC 记忆模糊了，能够再回顾下第 3 篇文章《事务隔离：为何你改了我还看不见？》和第 8 篇文章《事务究竟是隔离的仍是不隔离的？》中的相关内容。

固然，如今这个看上去笨笨的 MySQL，在执行 count(*) 操做的时候仍是作了优化的。

你知道的，InnoDB 是索引组织表，主键索引树的叶子节点是数据，而普通索引树的叶子节点是主键值。因此，普通索引树比主键索引树小不少。对于 count(*) 这样的操做，遍历
哪一个索引树获得的结果逻辑上都是同样的。所以，MySQL 优化器会找到最小的那棵树来遍历。在保证逻辑正确的前提下，尽可能减小扫描的数据量，是数据库系统设计的通用法则之一。

到这里咱们小结一下：

1. MyISAM 表虽然 count(*) 很快，可是不支持事务；
2. show table status 命令虽然返回很快，可是不许确；
3. InnoDB 表直接 count(*) 会遍历全表，虽然结果准确，但会致使性能问题。

那么，回到文章开头的问题，若是你如今有一个页面常常要显示交易系统的操做记录总数，到底应该怎么办呢？答案是，咱们只能本身计数。

接下来，咱们讨论一下，看看本身计数有哪些方法，以及每种方法的优缺点有哪些。

这里，我先和你说一下这些方法的基本思路：你须要本身找一个地方，把操做记录表的行数存起来。

3、用缓存系统保存计数

对于更新很频繁的库来讲，你可能会第一时间想到，用缓存系统来支持。

你能够用一个 Redis 服务来保存这个表的总行数。这个表每被插入一行 Redis 计数就加1，每被删除一行 Redis 计数就减 1。这种方式下，读和更新操做都很快，但你再想一下这种方式存在什么问题吗？

没错，缓存系统可能会丢失更新。

Redis 的数据不能永久地留在内存里，因此你会找一个地方把这个值按期地持久化存储起来。但即便这样，仍然可能丢失更新。试想若是刚刚在数据表中插入了一行，Redis 中保
存的值也加了 1，而后 Redis 异常重启了，重启后你要从存储 redis 数据的地方把这个值读回来，而刚刚加 1 的这个计数操做却丢失了。

固然了，这仍是有解的。好比，Redis 异常重启之后，到数据库里面单独执行一次count(*) 获取真实的行数，再把这个值写回到 Redis 里就能够了。异常重启毕竟不是常常
出现的状况，这一次全表扫描的成本，仍是能够接受的。

但实际上，将计数保存在缓存系统中的方式，还不仅是丢失更新的问题。即便 Redis 正常工做，这个值仍是逻辑上不精确的。

你能够设想一下有这么一个页面，要显示操做记录的总数，同时还要显示最近操做的 100条记录。那么，这个页面的逻辑就须要先到 Redis 里面取出计数，再到数据表里面取数据记录。
咱们是这么定义不精确的：

1. 一种是，查到的 100 行结果里面有最新插入记录，而 Redis 的计数里还没加 1；
2. 另外一种是，查到的 100 行结果里没有最新插入的记录，而 Redis 的计数里已经加了1。

这两种状况，都是逻辑不一致的。咱们一块儿来看看这个时序图。

图 2 会话 A、B 执行时序图

图 2 中，会话 A 是一个插入交易记录的逻辑，往数据表里插入一行 R，而后 Redis 计数加 1；会话 B 就是查询页面显示时须要的数据。

在图 2 的这个时序里，在 T3 时刻会话 B 来查询的时候，会显示出新插入的 R 这个记录，可是 Redis 的计数还没加 1。这时候，就会出现咱们说的数据不一致。

你必定会说，这是由于咱们执行新增记录逻辑时候，是先写数据表，再改 Redis 计数。而读的时候是先读 Redis，再读数据表，这个顺序是相反的。那么，若是保持顺序同样的
话，是否是就没问题了？咱们如今把会话 A 的更新顺序换一下，再看看执行结果。

图 3 调整顺序后，会话 A、B 的执行时序图

你会发现，这时候反过来了，会话 B 在 T3 时刻查询的时候，Redis 计数加了 1 了，但还查不到新插入的 R 这一行，也是数据不一致的状况。

在并发系统里面，咱们是没法精确控制不一样线程的执行时刻的，由于存在图中的这种操做序列，因此，咱们说即便 Redis 正常工做，这个计数值仍是逻辑上不精确的。

4、在数据库保存计数

根据上面的分析，用缓存系统保存计数有丢失数据和计数不精确的问题。那么，若是咱们把这个计数直接放到数据库里单独的一张计数表 C 中，又会怎么样呢？

首先，这解决了崩溃丢失的问题，InnoDB 是支持崩溃恢复不丢数据的。

备注：关于 InnoDB 的崩溃恢复，你能够再回顾一下第 2 篇文章《日志系统：一条 SQL 更新语句是如何执行的？》中的相关内容。

而后，咱们再看看能不能解决计数不精确的问题。

你会说，这不同吗？无非就是把图 3 中对 Redis 的操做，改为了对计数表 C 的操做。只要出现图 3 的这种执行序列，这个问题仍是无解的吧？

这个问题还真不是无解的。

咱们这篇文章要解决的问题，都是因为 InnoDB 要支持事务，从而致使 InnoDB 表不能把count(*) 直接存起来，而后查询的时候直接返回造成的。

所谓以子之矛攻子之盾，如今咱们就利用“事务”这个特性，把问题解决掉。

图 4 会话 A、B 的执行时序图

咱们来看下如今的执行结果。虽然会话 B 的读操做仍然是在 T3 执行的，可是由于这时候更新事务尚未提交，因此计数值加 1 这个操做对会话 B 还不可见。

所以，会话 B 看到的结果里， 查计数值和“最近 100 条记录”看到的结果，逻辑上就是一致的。

5、不一样的 count 用法

在前面文章的评论区，有同窗留言问到：在 select count(?) from t 这样的查询语句里面，count(*)、count(主键 id)、count(字段) 和 count(1) 等不一样用法的性能，有哪些差
别。今天谈到了 count(*) 的性能问题，我就借此机会和你详细说明一下这几种用法的性能差异。

须要注意的是，下面的讨论仍是基于 InnoDB 引擎的。

这里，首先你要弄清楚 count() 的语义。count() 是一个聚合函数，对于返回的结果集，一行行地判断，若是 count 函数的参数不是 NULL，累计值就加 1，不然不加。最后返回累计值。

因此，count(*)、count(主键 id) 和 count(1) 都表示返回知足条件的结果集的总行数；而count(字段），则表示返回知足条件的数据行里面，参数“字段”不为 NULL 的总个数。

至于分析性能差异的时候，你能够记住这么几个原则：

• 1. server 层要什么就给什么；
• 2. InnoDB 只给必要的值；
• 3. 如今的优化器只优化了 count(*) 的语义为“取行数”，其余“显而易见”的优化并无作。

这是什么意思呢？接下来，咱们就一个个地来看看。

对于 count(主键 id) 来讲，InnoDB 引擎会遍历整张表，把每一行的 id 值都取出来，返回给 server 层。server 层拿到 id 后，判断是不可能为空的，就按行累加。

对于 count(1) 来讲，InnoDB 引擎遍历整张表，但不取值。server 层对于返回的每一行，放一个数字“1”进去，判断是不可能为空的，按行累加。

单看这两个用法的差异的话，你能对比出来，count(1) 执行得要比 count(主键 id) 快。由于从引擎返回 id 会涉及到解析数据行，以及拷贝字段值的操做。

对于 count(字段) 来讲：

• 1. 若是这个“字段”是定义为 not null 的话，一行行地从记录里面读出这个字段，判断不能为 null，按行累加；
• 2. 若是这个“字段”定义容许为 null，那么执行的时候，判断到有多是 null，还要把值取出来再判断一下，不是 null 才累加。

也就是前面的第一条原则，server 层要什么字段，InnoDB 就返回什么字段。

count(*) 是例外

可是 count(*) 是例外，并不会把所有字段取出来，而是专门作了优化，不取值。count(*) 确定不是 null，按行累加。

看到这里，你必定会说，优化器就不能本身判断一下吗，主键 id 确定非空啊，为何不能按照 count(*) 来处理，多么简单的优化啊。

固然，MySQL 专门针对这个语句进行优化，也不是不能够。可是这种须要专门优化的状况太多了，并且 MySQL 已经优化过 count(*) 了，你直接使用这种用法就能够了。

因此结论是：按照效率排序的话，count(字段)<count(主键 id)<count(1)≈count(*)，因此我建议你，尽可能使用 count(*)。

6、小结

今天，我和你聊了聊 MySQL 中得到表行数的两种方法。咱们提到了在不一样引擎中count(*) 的实现方式是不同的，也分析了用缓存系统来存储计数值存在的问题。

其实，把计数放在 Redis 里面，不可以保证计数和 MySQL 表里的数据精确一致的缘由，是这两个不一样的存储构成的系统，不支持分布式事务，没法拿到精确一致的视图。而把计
数值也放在 MySQL 中，就解决了一致性视图的问题。

InnoDB 引擎支持事务，咱们利用好事务的原子性和隔离性，就能够简化在业务开发时的逻辑。这也是 InnoDB 引擎备受青睐的缘由之一。

最后，又到了今天的思考题时间了。

在刚刚讨论的方案中，咱们用了事务来确保计数准确。因为事务能够保证中间结果不被别的事务读到，所以修改计数值和插入新记录的顺序是不影响逻辑结果的。可是，从并发系
统性能的角度考虑，你以为在这个事务序列里，应该先插入操做记录，仍是应该先更新计数表呢？

你能够把你的思考和观点写在留言区里，我会在下一篇文章的末尾给出个人参考答案。感谢你的收听，也欢迎你把这篇文章分享给更多的朋友一块儿阅读。

7、上期问题时间

上期我给你留的问题是，何时使用 alter table t engine=InnoDB 会让一个表占用的空间反而变大。

在这篇文章的评论区里面，你们都提到了一个点，就是这个表，自己就已经没有空洞的了，好比说刚刚作过一次重建表操做。

在 DDL 期间，若是恰好有外部的 DML 在执行，这期间可能会引入一些新的空洞。

@飞翔 提到了一个更深入的机制，是咱们在文章中没说的。在重建表的时候，InnoDB 不会把整张表占满，每一个页留了 1/16 给后续的更新用。也就是说，其实重建表以后不
是“最”紧凑的。

假如是这么一个过程：

1. 将表 t 重建一次；
2. 插入一部分数据，可是插入的这些数据，用掉了一部分的预留空间；
3. 这种状况下，再重建一次表 t，就可能会出现问题中的现象。

8、经典留言

一、阿健

从并发系统性能的角度考虑，应该先插入操做记录，再更新计数表。

知识点在《行锁功过：怎么减小行锁对性能的影响？》
由于更新计数表涉及到行锁的竞争，先插入再更新能最大程度地减小了事务之间的锁等待，提高了并发度。

做者回复:

好几个同窗说对，你第一个标明出处

二、果真如此

1、请问计数用这个MySQL+redis方案如何：
1.开启事务（程序中的事务）
2.MySQL插入数据
3.原子更新redis计数
4.若是redis更新成功提交事务，若是redis更新失败回滚事务。

2、.net和java程序代码的事务和MySQL事务是什么关系，有什么相关性？

做者回复:

1. 好问题，不会仍是没解决咱们说的一致性问题。若是在三、4之间插入了 Session B的逻辑呢2. 我估计就是启动事务（执行begin),结束时提交（执行commit)吧，没有了解过全部框架，不肯定哈