찾다

집  >  기사  >  데이터 베이스  >  MySQL COUNT(*)의 성능 원칙은 무엇입니까?

MySQL COUNT(*)의 성능 원칙은 무엇입니까?

王林
王林앞으로
2023-05-27 10:49:37757검색

1.COUNT(1), COUNT(*), COUNT(필드) 중 어느 것이 더 빠릅니까?

실행 효과:

  • COUNT(*)MySQL은 count(*), count(*)를 최적화했습니다. 직접 스캔 기본 키 인덱스 레코드는 모든 필드를 가져오지 않지만 행별로 직접 누적합니다. COUNT(*)MySQL 对count(*)进行了优化，count(*)直接扫描主键索引记录，并不会把全部字段取出来，直接按行累加。

  • COUNT(1)InnoDB引擎遍历整张表，但不取值，server 层对于返回的每一行，放一个数字“1”进去，按行累加。

  • COUNT(字段)如果这个“字段”是定义为NOT NULL，那么InnoDB 引擎会一行行地从记录里面读出这个字段，server 层判断不能为NULL，按行累加;如果这个“字段”定义允许为NULL，那么InnoDB 引擎会一行行地从记录里面读出这个字段，然后把值取出来再判断一下，不是 NULL才累加。

实验分析

本文测试使用的环境：

[root@zhyno1 ~]# cat /etc/system-release
CentOS Linux release 7.9.2009 (Core)

[root@zhyno1 ~]# uname -a
Linux zhyno1 3.10.0-1160.62.1.el7.x86_64 #1 SMP Tue Apr 5 16:57:59 UTC 2022 x86_64 x86_64 x86_64 GNU/Linux

测试数据库采用的是（存储引擎采用InnoDB，其它参数默认）：

(Mon Jul 25 09:41:39 2022)[root@GreatSQL][(none)]>select version();
+-----------+
| version() |
+-----------+
| 8.0.25-16 |
+-----------+
1 row in set (0.00 sec)

实验开始：

#首先我们创建一个实验表

CREATE TABLE test_count (
  `id` int(10) NOT NULL AUTO_INCREMENT PRIMARY KEY,
  `name` varchar(20) NOT NULL,
  `salary` int(1) NOT NULL,
  KEY `idx_salary` (`salary`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

#插入1000W条数据
DELIMITER //
CREATE PROCEDURE insert_1000w()
BEGIN
    DECLARE i INT;
    SET i=1;
    WHILE i<=10000000 DO
        INSERT INTO test_count(name,salary) VALUES(&#39;KAiTO&#39;,1);
        SET i=i+1;
    END WHILE;
END//
DELIMITER ;
#执行存储过程
call insert_1000w();

接下来我们分别来实验一下：

COUNT(1)花费了4.19秒

(Sat Jul 23 22:56:04 2022)[root@GreatSQL][test]>select count(1) from test_count;
+----------+
| count(1) |
+----------+
| 10000000 |
+----------+
1 row in set (4.19 sec)

COUNT(*)花费了4.16秒

(Sat Jul 23 22:57:41 2022)[root@GreatSQL][test]>select count(*) from test_count;
+----------+
| count(*) |
+----------+
| 10000000 |
+----------+
1 row in set (4.16 sec)

COUNT(字段)花费了4.23秒

(Sat Jul 23 22:58:56 2022)[root@GreatSQL][test]>select count(id) from test_count;
+-----------+
| count(id) |
+-----------+
|  10000000 |
+-----------+
1 row in set (4.23 sec)

我们可以再来测试一下执行计划

COUNT(*)

(Sat Jul 23 22:59:16 2022)[root@GreatSQL][test]>explain select count(*) from test_count;
+----+-------------+------------+------------+-------+---------------+------------+---------+------+---------+----------+-------------+
| id | select_type | table      | partitions | type  | possible_keys | key        | key_len | ref  | rows    | filtered | Extra       |
+----+-------------+------------+------------+-------+---------------+------------+---------+------+---------+----------+-------------+
|  1 | SIMPLE      | test_count | NULL       | index | NULL          | idx_salary | 4       | NULL | 9980612 |   100.00 | Using index |
+----+-------------+------------+------------+-------+---------------+------------+---------+------+---------+----------+-------------+
1 row in set, 1 warning (0.01 sec)

(Sat Jul 23 22:59:48 2022)[root@GreatSQL][test]>show warnings;
+-------+------+-----------------------------------------------------------------------+
| Level | Code | Message                                                               |
+-------+------+-----------------------------------------------------------------------+
| Note  | 1003 | /* select#1 */ select count(0) AS `count(*)` from `test`.`test_count` |
+-------+------+-----------------------------------------------------------------------+
1 row in set (0.00 sec)

COUNT(1)

(Sat Jul 23 23:12:45 2022)[root@GreatSQL][test]>explain select count(1) from test_count;
+----+-------------+------------+------------+-------+---------------+------------+---------+------+---------+----------+-------------+
| id | select_type | table      | partitions | type  | possible_keys | key        | key_len | ref  | rows    | filtered | Extra       |
+----+-------------+------------+------------+-------+---------------+------------+---------+------+---------+----------+-------------+
|  1 | SIMPLE      | test_count | NULL       | index | NULL          | idx_salary | 4       | NULL | 9980612 |   100.00 | Using index |
+----+-------------+------------+------------+-------+---------------+------------+---------+------+---------+----------+-------------+
1 row in set, 1 warning (0.00 sec)

(Sat Jul 23 23:13:02 2022)[root@GreatSQL][test]>show warnings;
+-------+------+-----------------------------------------------------------------------+
| Level | Code | Message                                                               |
+-------+------+-----------------------------------------------------------------------+
| Note  | 1003 | /* select#1 */ select count(1) AS `count(1)` from `test`.`test_count` |
+-------+------+-----------------------------------------------------------------------+
1 row in set (0.00 sec)

COUNT(字段)

(Sat Jul 23 23:13:14 2022)[root@GreatSQL][test]>explain select count(id) from test_count;
+----+-------------+------------+------------+-------+---------------+------------+---------+------+---------+----------+-------------+
| id | select_type | table      | partitions | type  | possible_keys | key        | key_len | ref  | rows    | filtered | Extra       |
+----+-------------+------------+------------+-------+---------------+------------+---------+------+---------+----------+-------------+
|  1 | SIMPLE      | test_count | NULL       | index | NULL          | idx_salary | 4       | NULL | 9980612 |   100.00 | Using index |
+----+-------------+------------+------------+-------+---------------+------------+---------+------+---------+----------+-------------+
1 row in set, 1 warning (0.00 sec)

(Sat Jul 23 23:13:29 2022)[root@GreatSQL][test]>show warnings;
+-------+------+-----------------------------------------------------------------------------------------------+
| Level | Code | Message                                                                                       |
+-------+------+-----------------------------------------------------------------------------------------------+
| Note  | 1003 | /* select#1 */ select count(`test`.`test_count`.`id`) AS `count(id)` from `test`.`test_count` |
+-------+------+-----------------------------------------------------------------------------------------------+
1 row in set (0.00 sec)

需要注意的是COUNT里如果是非主键字段的话

(Tue Jul 26 14:01:57 2022)[root@GreatSQL][test]>explain select count(name) from test_count where id <100 ;
+----+-------------+------------+------------+-------+---------------+---------+---------+------+------+----------+-------------+
| id | select_type | table      | partitions | type  | possible_keys | key     | key_len | ref  | rows | filtered | Extra       |
+----+-------------+------------+------------+-------+---------------+---------+---------+------+------+----------+-------------+
|  1 | SIMPLE      | test_count | NULL       | range | PRIMARY       | PRIMARY | 4       | NULL |   99 |   100.00 | Using where |
+----+-------------+------------+------------+-------+---------------+---------+---------+------+------+----------+-------------+
1 row in set, 1 warning (0.00 sec)

实验结果

  • 1.从上面的实验我们可以得出，COUNT(*)和COUNT(1)是最快的，其次是COUNT(id)。

  • 2.count(*)被MySQL查询优化器改写成了count(0)，并选择了idx_salary索引。

  • 3.count(1)和count(id)都选择了idx_salary索引。

实验结论

总结：COUNT(*)=COUNT(1)>COUNT(id)

MySQL的官方文档也有说过：

InnoDB handles SELECT COUNT(*) and SELECT COUNT(1) operations in the same way. There is no performance difference

翻译： InnoDB以相同的方式处理SELECT COUNT（*）和SELECT COUNT（1）操作。没有性能差异

所以说明了对于COUNT(1)或者是COUNT(*)，MySQL的优化其实是完全一样的，没有存在没有性能的差异。

但是建议使用COUNT(*)，因为这是MySQL92定义的标准统计行数的语法。

2.COUNT(*)与TABLES_ROWS

在InnoDB中，MySQL数据库每个表占用的空间、表记录的行数可以打开MySQL的information_schema数据库。在该库中有一个TABLES表，这个表主要字段分别是：

  • TABLE_SCHEMA : 数据库名

  • TABLE_NAME：表名

  • ENGINE：所使用的存储引擎

  • TABLES_ROWS：记录数

  • DATA_LENGTH：数据大小

  • INDEX_LENGTH：索引大小

TABLE_ROWS用于显示这个表当前有多少行，这个命令执行挺快的，那这个TABLE_ROWS能代替count(*)吗？

我们用TABLES_ROWS查询一下表记录条数：

(Sat Jul 23 23:15:14 2022)[root@GreatSQL][test]>SELECT TABLE_ROWS
    -> FROM INFORMATION_SCHEMA.TABLES
    -> WHERE TABLE_NAME = &#39;test_count&#39;;
+------------+
| TABLE_ROWS |
+------------+
|    9980612 |
+------------+
1 row in set (0.03 sec)

可以看到，记录的条数并不准确，因为InnoDB引擎下TABLES_ROWS行计数仅是大概估计值。

3.COUNT(*)是怎么样执行的?

首先要明确的是，MySQL有多种不同引擎，在不同的引擎中，count(*)有不同的实现方式，本文主要介绍的是在InnoDB引擎上的执行流程

在InnoDB存储引擎中，count(*)函数是先从内存中读取表中的数据到内存缓冲区，然后扫描全表获得行记录数的。简单来说就是全表扫描，一个循环解决问题，循环内: 先读取一行，再决定该行是否计入count循环内是一行一行进行计数处理的。

在MyISAM引擎中是把一个表的总行数存在了磁盘上，因此执行count(*)

COUNT(1)InnoDB 엔진은 전체 테이블을 순회하지만 값을 취하지 않습니다. 서버 계층은 반환된 각 행에 숫자 "1"을 넣고 행별로 누적합니다. 열.

🎜🎜COUNT(field)이 "필드"가 NOT NULL로 정의되면 InnoDB 엔진은 레코드에서 이 필드를 한 줄씩 읽고 서버 계층이 판단합니다. NULL이 될 수 없으며, "필드" 정의가 NULL을 허용하는 경우 InnoDB 엔진은 행별로 이 필드를 읽은 다음 값을 꺼내고 NULL이 아닌 경우 다시 판단합니다. 축적될 것입니다. 🎜

실험 분석

🎜🎜이 기사에서 테스트에 사용된 환경: 🎜🎜rrreee🎜🎜테스트 데이터베이스는 (스토리지 엔진은 InnoDB를 사용하며 다른 매개변수는 기본값임) : 🎜🎜rrreee 🎜🎜실험이 시작되었습니다: 🎜🎜rrreee🎜🎜 다음으로 별도로 실험해 보겠습니다. 🎜🎜🎜COUNT(1)는 4.19초가 걸렸습니다🎜rrreee🎜COUNT(*) code> 4.16초 걸렸습니다🎜rrreee🎜<code>COUNT(field)4.23초 걸렸습니다🎜rrreee🎜실행 계획을 다시 테스트할 수 있습니다🎜🎜COUNT(*)🎜rrreee🎜 COUNT(1)🎜rrreee🎜COUNT(field)🎜rrreee🎜🎜COUNT🎜🎜rrreee

실험 결과

🎜🎜🎜1 위 실험에서 COUNT(*)와 COUNT(1)가 가장 빠르며 그 다음은 COUNT(id). 🎜🎜🎜2. count(*)는 MySQL 쿼리 최적화 프로그램에 의해 count(0)로 다시 작성되었으며 idx_salary 인덱스가 선택되었습니다. 🎜🎜🎜3. count(1) 및 count(id) 모두 idx_salary 인덱스를 선택합니다. 🎜

실험적 결론

🎜요약: COUNT(*)=COUNT(1)>COUNT(id)🎜🎜🎜MySQL 공식 문서 It 🎜🎜
🎜InnoDB는 SELECT COUNT(*) 및 SELECT COUNT(1) 작업을 동일한 방식으로 처리합니다. 성능 차이는 없습니다🎜
🎜🎜번역: 🎜 InnoDB가 처리합니다. SELECT COUNT(*) 및 SELECT COUNT(1) 작업은 SELECT COUNT(*) 및 SELECT COUNT(1) 작업을 동일한 방식으로 처리합니다. 성능 차이가 없습니다🎜
🎜그러므로 COUNT(1) 또는 COUNT(*)에 대해 MySQL의 최적화는 실제로 정확히 동일하다는 의미입니다. 성능 차이는 없습니다. 🎜🎜그러나 COUNT(*)를 사용하는 것이 좋습니다. 이는 MySQL92에서 정의한 행 계산의 표준 구문이기 때문입니다. 🎜🎜2.COUNT(*) 및 TABLES_ROWS🎜🎜InnoDB에서는 MySQL information_schema 데이터베이스를 열면 MySQL 데이터베이스의 각 테이블이 차지하는 공간과 테이블에 기록된 행 수를 알 수 있습니다. . 라이브러리에 TABLES 테이블이 있습니다. 이 테이블의 주요 필드는 다음과 같습니다: 🎜🎜🎜🎜🎜🎜TABLE_SCHEMA: 🎜Database name🎜🎜🎜🎜TABLE_NAME: 🎜Table name🎜🎜🎜🎜ENGINE: 🎜사용된 스토리지 엔진🎜🎜🎜🎜TABLES_ROWS: 🎜레코드 수🎜🎜🎜DATA_LENGTH: 데이터 크기🎜🎜🎜INDEX_LENGTH: 인덱스 크기🎜 🎜TABLE_ROWS는 테이블에 현재 있는 행 수를 표시하는 데 사용됩니다. 이 명령은 매우 빠르게 실행됩니다. count(*)를 대체할 수 있습니까? 🎜🎜🎜테이블 레코드 개수를 쿼리하기 위해 TABLES_ROWS를 사용합니다. 🎜🎜rrreee🎜 InnoDB 엔진의 TABLES_ROWS 행 개수는 대략적인 추정일 뿐이므로 레코드 개수가 정확하지 않다는 것을 알 수 있습니다. 🎜🎜3. COUNT(*)는 어떻게 실행되나요? 🎜🎜먼저 분명히 해야 할 점은 MySQL에는 다양한 엔진이 있으며 count(*)는 다양한 구현 방법을 가지고 있다는 것입니다. 주로 InnoDB 엔진의 실행 프로세스를 소개합니다🎜🎜InnoDB 스토리지 엔진에서 count(*) 함수는 먼저 메모리에서 메모리 버퍼로 테이블의 데이터를 읽은 다음 전체 테이블을 스캔합니다. 행 레코드 수를 얻으려면. 간단히 말해서 이는 전체 테이블 스캔입니다. 루프 내에서 먼저 행을 읽은 다음 해당 행이 count에 포함되는지 여부를 결정합니다. 열. 🎜🎜MyISAM 엔진에서는 테이블의 전체 행 수가 디스크에 저장되므로 count(*)가 실행될 때 이 숫자가 직접 반환되므로 매우 효율적입니다. 🎜🎜InnoDB가 MyISAM처럼 숫자를 저장하지 않는 이유는 동시에 여러 쿼리를 수행하더라도 다중 버전 동시성 제어(MVCC)로 인해 InnoDB 테이블이 반환해야 하는 행 수가 불확실하기 때문입니다. InnoDB는 트랜잭션 지원, 동시성 또는 데이터 보안 측면에서 MyISAM보다 성능이 뛰어납니다. 🎜

이에도 불구하고 InnoDB는 count(*) 작업을 최적화했습니다. InnoDB는 인덱스 구성 테이블입니다. 기본 키 인덱스 트리의 리프 노드는 데이터이고 일반 인덱스 트리의 리프 노드는 기본 키 값입니다. 따라서 일반 인덱스 트리는 기본 키 인덱스 트리보다 훨씬 작습니다. count(*)와 같은 작업의 경우 인덱스 트리를 순회하여 얻은 결과는 논리적으로 동일합니다. 따라서 MySQL 최적화 프로그램은 탐색할 가장 작은 트리를 찾습니다. count(*)操作还是做了优化的。InnoDB是索引组织表，主键索引树的叶子节点是数据，而普通索引树的叶子节点是主键值。所以，普通索引树比主键索引树小很多。对于count(*)这样的操作，遍历哪个索引树得到的结果逻辑上都是一样的。因此，MySQL 优化器会找到最小的那棵树来遍历。

需要注意的是我们在这篇文章里讨论的是没有过滤条件的count(*)，如果加了WHERE条件的话，MyISAM引擎的表也是不能返回得这么快的。

4.总结

  • 1.COUNT(*)=COUNT(1)>COUNT(id)

  • 2.COUNT函数的用法，主要用于统计表行数。主要用法有COUNT(*)、COUNT(字段)和COUNT(1)

  • 3.因为COUNT(*)是SQL92定义的标准统计行数的语法，所以MySQL对他进行了很多优化，MyISAM中会直接把表的总行数单独记录下来供COUNT(*)查询，而InnoDB则会在扫表的时候选择最小的索引来降低成本。这些优化的前提是没有进行WHERE和GROUP的条件查询。

  • 4.在InnoDB中COUNT(*)和COUNT(1)实现上没有区别，而且效率一样，但是COUNT(字段)需要进行字段的非NULL判断，所以效率会低一些。

  • 5.因为COUNT(*)是SQL92定义的标准统计行数的语法，并且效率高，所以还是建议使用COUNT(*)查询表的行数。

  • 6.正如前面COUNT(name)

    참고 이 문서에서 논의하는 내용은 필터 조건이 없는 count(*)입니다. WHERE 조건이 추가되면 MyISAM 엔진의 테이블이 또한 그렇게 빨리 돌아갈 수는 없습니다.

    • 4. 요약

    1.COUNT(*)=COUNT(1)>COUNT(id)🎜🎜
  • 🎜2. COUNT 함수의 사용법은 주로 테이블 행 수를 계산하는 데 사용됩니다. 주요 사용법은 COUNT(*), COUNT(field) 및 COUNT(1)🎜🎜
  • 🎜3입니다. 왜냐하면 COUNT(*)가 정의된 표준 통계이기 때문입니다. by SQL92 행 수에 대한 구문이므로 MySQL은 이에 대해 많은 최적화를 수행했습니다. MyISAM은 COUNT(*) 쿼리에 대해 테이블의 총 행 수를 직접 기록하는 반면 InnoDB는 비용을 줄이기 위해 테이블을 스캔할 때 이를 선택하세요. 이러한 최적화의 전제는 WHERE 및 GROUP 조건부 쿼리가 없다는 것입니다. 🎜🎜
  • 🎜4. InnoDB에서는 COUNT(*)와 COUNT(1) 구현에 차이가 없고 효율성은 동일하지만 COUNT(field )는 해당 필드가 NULL인지 판단해야 하므로 효율성이 떨어집니다. 🎜🎜
  • 🎜5. COUNT(*)는 SQL92에서 정의한 행 계산의 표준 구문이고 효율성이 높으므로 COUNT(*)를 사용하는 것이 좋습니다. > 쿼리 테이블의 행 수입니다. 🎜🎜
  • 🎜6. 이전 COUNT(이름) 사용 사례와 마찬가지로 테이블 생성 과정에서도 비즈니스 요구에 따라 고성능 인덱스를 설정해야 하며, 동시에 불필요한 인덱스가 생성되지 않도록 주의해야 합니다. 🎜🎜🎜

위 내용은 MySQL COUNT(*)의 성능 원칙은 무엇입니까?의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!

성명：
이 기사는 yisu.com에서 복제됩니다. 침해가 있는 경우 admin@php.cn으로 문의하시기 바랍니다. 삭제
이전 기사：MySQL 트랜잭션 인스턴스 분석다음 기사：MySQL 트랜잭션 인스턴스 분석

관련 기사

더보기