count 订阅
英文词,理解为:古代的一种贵族称号;或者是一种电脑计算机内部的数学函数的名字。 展开全文
英文词,理解为:古代的一种贵族称号;或者是一种电脑计算机内部的数学函数的名字。
信息
作    用
一种电脑计算机内部的数学函数
语    法
COUNT(value1,value2, ...)
性    质
一种电脑计算机内部的数学函数
外文名
Count
Count定义
计算参数列表中的数字项的个数
收起全文
精华内容
下载资源
问答
  • count
    千次阅读
    2021-06-01 15:02:41

    一、执行效果:


    1.  count(1) and count(*)

    当表的数据量大些时,对表作分析之后,使用count(1)还要比使用count(*)用时多了! 
    从执行计划来看,count(1)和count(*)的效果是一样的。 但是在表做过分析之后,count(1)会比count(*)的用时少些(1w以内数据量),不过差不了多少。 
     
    如果count(1)是聚索引,id,那肯定是count(1)快。但是差的很小的。 
    因为count(*),自动会优化指定到那一个字段。所以没必要去count(1),用count(*),sql会帮你完成优化的 因此: count(1)和count(*)基本没有差别! 
     
    2. count(1) and count(字段)
    两者的主要区别是
    (1) count(1) 会统计表中的所有的记录数, 包含字段为null 的记录
    (2) count(字段) 会统计该字段在表中出现的次数,忽略字段为null 的情况。即 不统计字段为null 的记录。  
    转自:http://www.cnblogs.com/Dhouse/p/6734837.html


    二、count(*) 和 count(1)和count(列名)区别  

    执行效果上 :  
    count(*)包括了所有的列,相当于行数,在统计结果的时候, 不会忽略列值为NULL  
    count(1)包括了忽略所有列,用1代表代码行,在统计结果的时候, 不会忽略列值为NULL  
    count(列名)只包括列名那一列,在统计结果的时候,会忽略列值为空(这里的空不是只空字符串或者0,而是表示null)的计数, 即某个字段值为NULL时,不统计

    执行效率上:  
    列名为主键,count(列名)会比count(1)快  
    列名不为主键,count(1)会比count(列名)快  
    如果表多个列并且没有主键,则 count(1) 的执行效率优于 count(*)  
    如果有主键,则 select count(主键)的执行效率是最优的  
    如果表只有一个字段,则 select count(*)最优。
    转自:http://eeeewwwqq.iteye.com/blog/1972576


    实例分析

    mysql> create table counttest(name char(1), age char(2));
    Query OK, 0 rows affected (0.03 sec)
     
    mysql> insert into counttest values
        -> ('a', '14'),('a', '15'), ('a', '15'), 
        -> ('b', NULL), ('b', '16'), 
        -> ('c', '17'),
        -> ('d', null), 
        ->('e', '');
    Query OK, 8 rows affected (0.01 sec)
    Records: 8  Duplicates: 0  Warnings: 0
     
    mysql> select * from counttest;
    +------+------+
    | name | age  |
    +------+------+
    | a    | 14   |
    | a    | 15   |
    | a    | 15   |
    | b    | NULL |
    | b    | 16   |
    | c    | 17   |
    | d    | NULL |
    | e    |      |
    +------+------+
    8 rows in set (0.00 sec)
     
    mysql> select name, count(name), count(1), count(*), count(age), count(distinct(age))
        -> from counttest
        -> group by name;
    +------+-------------+----------+----------+------------+----------------------+
    | name | count(name) | count(1) | count(*) | count(age) | count(distinct(age)) |
    +------+-------------+----------+----------+------------+----------------------+
    | a    |           3 |        3 |        3 |          3 |                    2 |
    | b    |           2 |        2 |        2 |          1 |                    1 |
    | c    |           1 |        1 |        1 |          1 |                    1 |
    | d    |           1 |        1 |        1 |          0 |                    0 |
    | e    |           1 |        1 |        1 |          1 |                    1 |
    +------+-------------+----------+----------+------------+----------------------+
    5 rows in set (0.00 sec)


    额外参考资料:http://blog.csdn.net/lihuarongaini/article/details/68485838
     

    更多相关内容
  • MySQL中count是怎样执行的?———count(1),count(id),count(非索引列),count(二级索引列)的分析

    1. 前言

      相信在此之前,很多人都只是记忆,没去理解,只知道count(*)count(1)包括了所有行,在统计结果的时候,不会忽略列值为NULLcount(列名)只统计列名那一列,在统计结果的时候,会忽略列值为NULL的记录。

      下面就从原理上给大家分析一下。


    2. 建表

    和前面一样,用的同一个表,表中有将近10W条数据

    CREATE TABLE demo_info(
        id INT NOT NULL auto_increment,
        key1 VARCHAR(100),
        key2 INT,
        key3 VARCHAR(100),
        key_part1 VARCHAR(100),
        key_part2 VARCHAR(100),
        key_part3 VARCHAR(100),
        common_field VARCHAR(100),
        PRIMARY KEY (id),
        KEY idx_key1 (key1),
        UNIQUE KEY uk_key2 (key2),
        KEY  idx_key3 (key3),
        KEY idx_key_part(key_part1, key_part2, key_part3)
    )ENGINE = INNODB CHARSET=utf8mb4;
    

    3. count是怎么样执行的?

    经常会看到这样的例子:
    当你需要统计表中有多少数据的时候,会经常使用如下语句

    SELECT COUNT(*) FROM demo_info;
    

      由于聚集索引和非聚集索引中的记录是一一对应的,而非聚集索引记录中包含的列(索引列+主键id)是少于聚集索引(所有列)记录的,所以同样数量的非聚集索引记录比聚集索引记录占用更少的存储空间。如果我们使用非聚集索引执行上述查询,即统计一下非聚集索引uk_key2中共有多少条记录,是比直接统计聚集索引中的记录数节省很多I/O成本。所以优化器会决定使用非聚集索引uk_key2执行上述查询

    注意:这里已经验证过了,uk_key2比其他索引成本更低。 详情可见MySQL查询为什么选择使用这个索引?——基于MySQL 8.0.22索引成本计算

    分析一下执行计划

    在执行上述查询时,server层会维护一个名叫count的变量,然后:

    • server层向InnoDB要第一条记录。

    • InnoDB找到uk_key2的第一条二级索引记录,并返回给server层(注意:由于此时只是统计记录数量,所以并不需要回表)。

    • 由于count函数的参数是*MySQL会将*当作常数0处理。由于0并不是NULLserver层给count变量加1

    • server层向InnoDB要下一条记录。

    • InnoDB通过二级索引记录的next_record属性找到下一条二级索引记录,并返回给server层。

    • server层继续给count变量加1

    • 重复上述过程,直到InnoDBserver层返回没记录可查的消息。

    • server层将最终的count变量的值发送到客户端。


    4. count(1),count(id),count(非索引列),count(二级索引列)的分析

    来看看count(1)

    SELECT COUNT(1) FROM demo_info;
    

    执行计划和count(*)一样

      对于count(*)count(1)或者任意的count(常数)来说,读取哪个索引的记录其实并不重要,因为server层只关心存储引擎是否读到了记录,而并不需要从记录中提取指定的字段来判断是否为NULL。所以优化器会使用占用存储空间最小的那个索引来执行查询

    再看一下count(id)

    explain SELECT COUNT(id) FROM demo_info;
    

      对于count(id)来说,由于id是主键,不论是聚集索引记录,还是任意一个二级索引记录中都会包含主键字段,所以其实读取任意一个索引中的记录都可以获取到id字段,此时优化器也会选择占用存储空间最小的那个索引来执行查询

    再看一下count(非索引列)

    explain select count(common_field) from demo_info
    

      对于count(非索引列)来说,优化器选择全表扫描,说明只能在聚集索引的叶子结点顺序扫描。

    请确认你理解了全表扫描,它是顺序扫描聚集索引的所有叶子结点并判断。

      而对于其他二级索引列,count(二级索引列),优化器只能选择包含我们指定的列的索引去执行查询,只能去指定非聚集索引的B+树扫描 ,可能导致优化器选择的索引扫描代价并不是最小。

    综上所述:
      对于count(*)count(常数)count(主键)形式的count函数来说,优化器可以选择扫描成本最小的索引执行查询,从而提升效率,它们的执行过程是一样的,只不过在判断表达式是否为NULL时选择不同的判断方式,这个判断为NULL的过程的代价可以忽略不计,所以我们可以认为count(*)count(常数)count(主键)所需要的代价是相同的。

      而对于count(非索引列)来说,优化器选择全表扫描,说明只能在聚集索引的叶子结点顺序扫描。

      count(二级索引列)只能选择包含我们指定的列的索引去执行查询,可能导致优化器选择的索引执行的代价并不是最小。

      其实上述这些区别就是因为非聚集索引记录比聚集索引记录占用更少的存储空间,减少更多I/O成本,所以优化器才有了不同索引的选择,仅此而已。



    欢迎一键三连~

    有问题请留言,大家一起探讨学习

    ----------------------Talk is cheap, show me the code-----------------------
    展开全文
  • MySQL的COUNT语句--count(*)、 count(常量)、 count(列名)

    千次阅读 多人点赞 2019-10-21 10:22:20
    MySQL的COUNT语句–count(*)、 count(常量)、 count(列名) 数据库查询相信很多人都不陌生,所有经常有人调侃程序员就是CRUD专员,这所谓的CRUD指的就是数据库的增删改查。 在数据库的增删改查操作中,使用最频繁的...

    MySQL的COUNT语句–count(*)、 count(常量)、 count(列名)

    数据库查询相信很多人都不陌生,所有经常有人调侃程序员就是CRUD专员,这所谓的CRUD指的就是数据库的增删改查。

    在数据库的增删改查操作中,使用最频繁的就是查询操作。 而在所有查询操作中,统计数量操作更是经常被用到。

    关于数据库中行数统计,无论是MySQL还是Oracle,都有一个函数可以使用,那就是COUNT

    但是,就是这个常用的COUNT函数,却暗藏着很多玄机,尤其是在面试的时候,一不小心就会被虐。 不信的话请尝试回答下以下问题:

    1、COUNT有几种用法?

    2、COUNT(字段名)和COUNT(*)的查询结果有什么不同?

    3、COUNT(1)和COUNT(*)之间有什么不同?

    4、COUNT(1)和COUNT(*)之间的效率哪个更高?

    5、为什么《阿里巴巴Java开发手册》建议使用COUNT(*)

    6、MySQL的MyISAM引擎对COUNT(*)做了哪些优化?

    7、MySQL的InnoDB引擎对COUNT(*)做了哪些优化?

    8、上面提到的MySQL对COUNT(*)做的优化,有一个关键的前提是什么?

    9、SELECT COUNT(*) 的时候,加不加where条件有差别吗?

    10、COUNT(*)、COUNT(1)和COUNT(字段名)的执行过程是怎样的?

    以上10道题,如果您可以全部准确无误的回答的话,那说明你真的很了解COUNT函数了,如果有哪些知识点是不了解的,那么本文正好可以帮你答疑解惑。

    1、认识COUNT

    关于COUNT函数,在MySQL官网中有详细介绍:

    简单翻译一下:

    1、COUNT(expr) ,返回SELECT语句检索的行中expr的值不为NULL的数量。 结果是一个BIGINT值。

    2、如果查询结果没有命中任何记录,则返回0

    3、但是,值得注意的是, COUNT(*) 的统计结果中,会包含值为NULL的行数。

    create table t_count(id int,id2 int);
    insert into t_count values(null,null);
    insert into t_count values(1,null);
    insert into t_count values(null,1);
    insert into t_count values(1,null);
    insert into t_count values(null,1);
    insert into t_count values(1,null);
    insert into t_count values(null,null);
    select count(*),count(id),count(id2),count(1) from t_count;
    

    即以下表记录

    root@localhost[lhrdb]> create table t_count(id int,id2 int);
    Query OK, 0 rows affected (0.36 sec)
    root@localhost[lhrdb]> insert into t_count values(null,null);
    Query OK, 1 row affected (0.07 sec)
    
    root@localhost[lhrdb]> insert into t_count values(1,null);
    Query OK, 1 row affected (0.06 sec)
    
    root@localhost[lhrdb]> insert into t_count values(null,1);
    Query OK, 1 row affected (0.08 sec)
    
    root@localhost[lhrdb]> insert into t_count values(1,null);
    Query OK, 1 row affected (0.03 sec)
    
    root@localhost[lhrdb]> insert into t_count values(null,1);
    Query OK, 1 row affected (0.05 sec)
    
    root@localhost[lhrdb]> insert into t_count values(1,null);
    Query OK, 1 row affected (0.03 sec)
    
    root@localhost[lhrdb]> insert into t_count values(null,null);
    Query OK, 1 row affected (0.08 sec)
    
    root@localhost[lhrdb]> 
    root@localhost[lhrdb]> select * from t_count;
    +------+------+
    | id   | id2  |
    +------+------+
    | NULL | NULL |
    |    1 | NULL |
    | NULL |    1 |
    |    1 | NULL |
    | NULL |    1 |
    |    1 | NULL |
    | NULL | NULL |
    +------+------+
    7 rows in set (0.00 sec)
    
    

    使用语句count(*),count(id),count(id2)查询结果如下:

    root@localhost[lhrdb]> select count(*),count(id),count(id2),count(1),count(2) from t_count;
    
    +----------+-----------+------------+----------+----------+
    | count(*) | count(id) | count(id2) | count(1) | count(2) |
    +----------+-----------+------------+----------+----------+
    |        7 |         3 |          2 |        7 |        7 |
    +----------+-----------+------------+----------+----------+
    
    1 row in set (0.00 sec)
    

    除了 COUNT(id) 和 COUNT() 以外,还可以使用 COUNT(常量) (如 COUNT(1) )来统计行数,那么这三条SQL语句有什么区别呢? 到底哪种效率更高呢? 为什么《阿里巴巴Java开发手册》中强制要求不让使用 COUNT(列名) 或 COUNT(常量) 来替代 COUNT() 呢?

    COUNT(列名)、COUNT(常量)和COUNT(*)之间的区别
    前面我们提到过 COUNT(expr) 用于做行数统计,统计的是expr不为NULL的行数,那么 COUNT(列名) 、 COUNT(常量) 和 COUNT(*) 这三种语法中,expr分别是 列名 、 常量 和 * 。

    那么 列名 、 常量 和 * 这三个条件中, 常量 是一个固定值,肯定不为NULL。 * 可以理解为查询整行,所以肯定也不为NULL,那么就只有 列名 的查询结果有可能是NULL了。

    所以, COUNT(常量) 和 COUNT(*)表示的是直接查询符合条件的数据库表的行数。而 COUNT(列名)表示的是查询符合条件的列的值不为NULL的行数。

    除了查询得到结果集有区别之外, COUNT() 相比 COUNT(常量) 和 COUNT(列名) 来讲, COUNT()是SQL92定义的标准统计行数的语法,因为他是标准语法,所以MySQL数据库对他进行过很多优化。

    SQL92,是数据库的一个ANSI/ISO标准。它定义了一种语言(SQL)以及数据库的行为(事务、隔离级别等)。

    COUNT(*)的优化
    前面提到了 COUNT(*) 是SQL92定义的标准统计行数的语法,所以MySQL数据库对他进行过很多优化。 那么,具体都做过哪些事情呢?

    这里的介绍要区分不同的执行引擎。 MySQL中比较常用的执行引擎就是InnoDB和MyISAM。

    MyISAM和InnoDB有很多区别,其中有一个关键的区别和我们接下来要介绍的 COUNT(*) 有关,那就是 MyISAM不支持事务,MyISAM中的锁是表级锁; 而InnoDB支持事务,并且支持行级锁。

    因为MyISAM的锁是表级锁,所以同一张表上面的操作需要串行进行,所以, MyISAM做了一个简单的优化,那就是它可以把表的总行数单独记录下来,如果从一张表中使用COUNT(*)进行查询的时候,可以直接返回这个记录下来的数值就可以了,当然,前提是不能有where条件。

    MyISAM之所以可以把表中的总行数记录下来供COUNT(*)查询使用,那是因为MyISAM数据库是表级锁,不会有并发的数据库行数修改,所以查询得到的行数是准确的。

    但是,对于InnoDB来说,就不能做这种缓存操作了,因为InnoDB支持事务,其中大部分操作都是行级锁,所以可能表的行数可能会被并发修改,那么缓存记录下来的总行数就不准确了。

    但是,InnoDB还是针对COUNT(*)语句做了些优化的。

    在InnoDB中,使用COUNT(*)查询行数的时候,不可避免的要进行扫表了,那么,就可以在扫表过程中下功夫来优化效率了。

    从MySQL 8.0.13开始,针对InnoDB的 SELECT COUNT(*) FROM tbl_name 语句,确实在扫表的过程中做了一些优化。 前提是查询语句中不包含WHERE或GROUP BY等条件。

    我们知道,COUNT(*)的目的只是为了统计总行数,所以,他根本不关心自己查到的具体值,所以,他如果能够在扫表的过程中,选择一个成本较低的索引进行的话,那就可以大大节省时间。

    我们知道,InnoDB中索引分为聚簇索引(主键索引)和非聚簇索引(非主键索引),聚簇索引的叶子节点中保存的是整行记录,而非聚簇索引的叶子节点中保存的是该行记录的主键的值。

    所以,相比之下,非聚簇索引要比聚簇索引小很多,所以 MySQL会优先选择最小的非聚簇索引来扫表。 所以,当我们建表的时候,除了主键索引以外,创建一个非主键索引还是有必要的。

    至此,我们介绍完了MySQL数据库对于COUNT(*)的优化,这些优化的前提都是查询语句中不包含WHERE以及GROUP BY条件。

    COUNT(*)和COUNT(1)
    介绍完了 COUNT(*) ,接下来看看 COUNT(1) ,对于,这二者到底有没有区别,网上的说法众说纷纭。

    有的说 COUNT(*) 执行时会转换成 COUNT(1) ,所以COUNT(1)少了转换步骤,所以更快。

    还有的说,因为MySQL针对 COUNT() 做了特殊优化,所以 COUNT() 更快。

    那么,到底哪种说法是对的呢? 看下MySQL官方文档是怎么说的:

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

    画重点: same way , no performance difference 。 所以,对于COUNT(1)和COUNT(*),MySQL的优化是完全一样的,根本不存在谁比谁快!

    那既然 COUNT(*) 和 COUNT(1) 一样,建议用哪个呢?

    建议使用 COUNT(*) ! 因为这个是SQL92定义的标准统计行数的语法,而且本文只是基于MySQL做了分析,关于Oracle中的这个问题,也是众说纷纭的呢。

    COUNT(字段)
    最后,就是我们一直还没提到的COUNT(字段),他的查询就比较简单粗暴了,就是进行全表扫描,然后判断指定字段的值是不是为NULL,不为NULL则累加。

    相比 COUNT() , COUNT(字段) 多了一个步骤就是判断所查询的字段是否为NULL,所以他的性能要比 COUNT() 慢。

    总结
    本文介绍了COUNT函数的用法,主要用于统计表行数。主要用法有 COUNT(*) 、 COUNT(字段) 和 COUNT(1) 。

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

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

    因为 COUNT() 是SQL92定义的标准统计行数的语法,并且效率高,所以请直接使用 COUNT() 查询表的行数!

    参考资料:

    https://dev.mysql.com/doc/refman/8.0/en/group-by-functions.html#function_count

    About Me
    ——————————————————————————————————————————
    ● 本文作者:小麦苗,部分内容整理自网络,若有侵权请联系小麦苗删除
    ● 本文在itpub、博客园、CSDN和个人微信公众号( xiaomaimiaolhr)上有同步更新
    ● 本文itpub地址: http://blog.itpub.net/26736162
    ● 本文博客园地址: http://www.cnblogs.com/lhrbest
    ● 本文CSDN地址: https://blog.csdn.net/lihuarongaini
    ● 本文pdf版、个人简介及小麦苗云盘地址: http://blog.itpub.net/26736162/viewspace-1624453/
    ● 数据库笔试面试题库及解答: http://blog.itpub.net/26736162/viewspace-2134706/
    ● DBA宝典今日头条号地址: http://www.toutiao.com/c/user/6401772890/#mid=1564638659405826
    ——————————————————————————————————————————
    ● QQ群号: 230161599 、618766405
    ● 微信群:可加我微信,我拉大家进群,非诚勿扰
    ● 联系我请加QQ好友 ( 646634621 ),注明添加缘由
    ● 于 2019-10-01 06:00 ~ 2019-10-31 24:00 在西安完成
    ● 最新修改时间:2019-10-01 06:00 ~ 2019-10-31 24:00
    ● 文章内容来源于小麦苗的学习笔记,部分整理自网络,若有侵权或不当之处还请谅解
    ● 版权所有,欢迎分享本文,转载请保留出处
    ——————————————————————————————————————————
    小麦苗的微店https://weidian.com/s/793741433?wfr=c&ifr=shopdetail
    小麦苗出版的数据库类丛书http://blog.itpub.net/26736162/viewspace-2142121/
    小麦苗OCP、OCM、高可用网络班http://blog.itpub.net/26736162/viewspace-2148098/
    小麦苗腾讯课堂主页https://lhr.ke.qq.com/
    ——————————————————————————————————————————
    使用微信客户端扫描下面的二维码来关注小麦苗的微信公众号( xiaomaimiaolhr
    及QQ群(DBA宝典)、添加小麦苗微信, 学习最实用的数据库技术。
    在这里插入图片描述
    ——————————————————————————————————————————

    展开全文
  • MySql统计函数COUNT详解

    千次阅读 2022-05-09 14:02:14
    MySql统计函数COUNT详解1. COUNT()函数概述2. COUNT()参数说明3. COUNT()使用场景4. COUNT()阿里开发规范 1. COUNT()函数概述 COUNT() 是一个聚合函数,返回指定匹配条件的行数。开发中常用来统计表中数据,全部数据...

    1. COUNT()函数概述

    COUNT() 是一个聚合函数,返回指定匹配条件的行数。开发中常用来统计表中数据,全部数据,不为NULL数据,或者去重数据。

    2. COUNT()参数说明

    COUNT(1):统计不为NULL 的记录。
    COUNT(*):统计所有的记录(包括NULL)。

    COUNT(字段):统计该"字段"不为NULL 的记录。
    1.如果这个字段是定义为not null的话,一行行地从记录里面读出这个字段,判断不能为null,按行累加。
    2.如果这个字段定义允许为null的话,判断到有可能是null,还要把值取出来在判断一下,不是null才累加。

    COUNT(DISTINCT 字段):统计该"字段"去重且不为NULL 的记录。

    -- MySql统计函数count测试
    -- 创建用户表,新增测试数据
    CREATE TABLE `user` (
      `id` bigint(20) unsigned NOT NULL AUTO_INCREMENT COMMENT 'ID主键',
      `name` varchar(64) DEFAULT NULL COMMENT '姓名',
      `sex` varchar(8) DEFAULT NULL COMMENT '性别',
      `age` int(4) DEFAULT NULL COMMENT '年龄',
      `born` date DEFAULT NULL COMMENT '出生日期',
      PRIMARY KEY (`id`)
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 ROW_FORMAT=DYNAMIC COMMENT='用户表';
    
    INSERT INTO `category`.`user`(`id`, `name`, `sex`, `age`, `born`) VALUES (1, '%张三%', '男', 22, '2022-04-22');
    INSERT INTO `category`.`user`(`id`, `name`, `sex`, `age`, `born`) VALUES (2, '李四', '女', 12, '2022-04-01');
    INSERT INTO `category`.`user`(`id`, `name`, `sex`, `age`, `born`) VALUES (3, '王小二', '女', 12, '2022-04-28');
    INSERT INTO `category`.`user`(`id`, `name`, `sex`, `age`, `born`) VALUES (4, '赵四', '男', 23, '2022-04-28');
    INSERT INTO `category`.`user`(`id`, `name`, `sex`, `age`, `born`) VALUES (5, '', '女', 23, '2022-04-28');
    INSERT INTO `category`.`user`(`id`, `name`, `sex`, `age`, `born`) VALUES (6, NULL, '女', 60, '2022-04-28');
    INSERT INTO `category`.`user`(`id`, `name`, `sex`, `age`, `born`) VALUES (7, NULL, '女', 61, '2022-04-28');
    
    select * from user;
    
    -- 统计数据:7条数据,统计所有的记录(包括NULL)。
    select count(*) from user;
    
    -- 统计数据:7条数据,统计不为NULL 的记录。
    select count(1) from user;
    
    -- 统计数据:5条数据,COUNT(字段):统计该"字段"不为NULL 的记录,注意是null不是空''字符串
    select count(name) from user;
    
    -- 统计数据:5条数据,COUNT(DISTINCT 字段):统计该"字段"去重且不为NULL 的记录。
    select count(distinct name) from user;
    

    3. COUNT()判断存在

    SQL不再使用count,而是改用LIMIT 1,让数据库查询时遇到一条就返回,不要再继续查找还有多少条了,业务代码中直接判断是否非空即可。
    select 1 from emp LIMIT 1;效率是最高的,尤其是需要limit限制行数,很容易忽略。

    -- SQL查找是否"存在"
    -- 员工表,存在则进行删除
    drop table if EXISTS emp;
    create table emp(
        id int unsigned primary key auto_increment,
        empno mediumint unsigned not null default 0,
        empname varchar(20) not null default "",
        job varchar(9) not null default "",
        mgr mediumint unsigned not null default 0,
        hiredate datetime not null,
        sal decimal(7,2) not null,
        comn decimal(7,2) not null,
        depno mediumint unsigned not null default 0
    );
    
    -- 新增cehsi数据
    测试数据:https://blog.csdn.net/m0_37583655/article/details/124385347
    
    -- cahxun 
    select * from emp ;
    
    -- 时间:1.082s,数据:5000000
    explain select count(*) from emp;
    
    id	select_type	table	partitions	type	possible_keys	key	key_len	ref	rows	filtered	Extra
    1	  SIMPLE																																						Select tables optimized away
    
    -- 时间:1.129s,数据:5000000
    explain select count(1) from emp;
    id	select_type	table	partitions	type	possible_keys	key	key_len	ref	rows	filtered	Extra
    1	  SIMPLE																																						Select tables optimized away
    
    -- 时间:1.695s,数据:5000000
    explain select 1 from emp;
    id	select_type	table	partitions	type	possible_keys	key	          key_len	ref	rows	  filtered	Extra
    1	  SIMPLE			emp																		idx_emp_depno		3					4981060		100.00	Using index
    
    -- SQL不再使用count,而是改用LIMIT 1,让数据库查询时遇到一条就返回,不要再继续查找还有多少条了,业务代码中直接判断是否非空即可
    -- 时间:0.001s,数据:5000000
    explain select 1 from emp LIMIT 1;
    id	select_type	table	partitions	type	possible_keys	key	          key_len	ref	rows	  filtered	Extra
    1	  SIMPLE			emp																		idx_emp_depno		3					4981060		100.00	Using index
    
    

    4. COUNT()阿里开发规范

    1.【强制】不要使用 count(列名)或 count(常量)来替代 count(),count()是 SQL92 定义的标 准统计行数的语法,跟数据库无关,跟 NULL 和非 NULL 无关. 说明:count(*)会统计值为 NULL 的行,而 count(列名)不会统计此列为 NULL 值的行.

    2.【强制】count(distinct col) 计算该列除 NULL 之外的不重复行数,注意 count(distinct col1, col2) 如果其中一列全为 NULL,那么即使另一列有不同的值,也返回为 0.

    在这里插入图片描述

    展开全文
  • 当我们对一张数据表中的记录进行统计的时候,习惯都会使用 count 函数来统计,但是 count 函数传入的参数有很多种,比如 count(1)、count(*)、count(字段) 等。 到底哪种效率是最好的呢?是不是 count(*) 效率最差?...
  • 如何理解count=count++,count的值不变

    千次阅读 多人点赞 2021-05-14 18:09:47
    能进来的朋友肯定跟我一样对于count = count++的结果很不解,希望看完你有收获。 先看一段代码 public class CountTest { public static void main(String[]args) { int count = 0; //初始化count为0 ...
  • MySQL的count(*)、count(1) 和count(字段)的区别以及count()查询优化手段。
  • count(1)这里面的1是什么意思

    千次阅读 2021-04-20 01:58:38
    回答:其实1就你这个的表里的第一个字段这里用1,也是为了方便,当然如果数据量较大的话,也可以提度,因为写count(*)的话有列,这里用1的话或者用字段名的话,只你写的那个列顺便给你扩展下count(*)和count(字段名...
  • 1、COUNT(expr) ,返回SELECT语句检索的行中expr的值不为NULL的数量。结果是一个BIGINT值; 2、如果查询结果没有命中任何记录,则返回0; 3、但是,值得注意的是,COUNT(*)的统计结果中,会包含值为NULL的行数。
  • 1.应用场景 能适合场景地使用更加合适搞高效的sql 2.学习/操作 ... 并可查看mysql手册-->...COUNT(DISTINCT) 3.问题 TBD 4.参考 http://kimi.it/156.html 后续补充 ... ...
  • count(*)、count(1)、count(字段)的区别和联系
  • count函数详细介绍

    千次阅读 2021-05-20 19:05:51
    select count(字段) from 表名; #得到字段中is not null的行数select count(*)from 表名; #任何列,只要有一个非null就会被统计上。全为null(不会出现该情况)则不被统计。用于统计表的行数select count(1) from ...
  • count(1)和count(*)的区别?

    千次阅读 多人点赞 2021-03-17 21:50:29
    今天前,我一直觉得count(1)优先于count(*),但是,今天想知道其缘由,查了一下百度,闪瞎我的双眼。 从执行结果来说: count(1)和count(*)之间没有区别,因为count(*)count(1)都不会去过滤空值, 但...
  •   ...一:Count(*)、Count(1)、Count(543)或者无论Count(‘anything’)只要在Count中指定非NULL表达式,结果没有任何区别。因此当你指定Count(*)或者Coun... 博文 来自: qq_27127145的...
  • count(字段),count(*)和count(1)的区别

    千次阅读 2022-03-12 23:05:39
    很多人认为count(1)执行的效率会比count()高,原因是count()会存在全表扫描,而count(1)可以针对一个字段进行查询。其实不然,count(1)和count(*)都会对全表进行扫描,统计所有记录的条数,包括那些为null的记录,...
  • Select count(*)、Count(1)、Count(0)的区别和执行效率比较   前言       记得很早以前就听说,在使用count的时候要用count(1)而不要用count(*),因为使用count(*)的时候会对所有的...
  • 深入理解RabbitMQ中的prefetch_count参数

    千次阅读 2020-10-17 14:03:44
    前提在某一次用户标签服务中大量用到异步流程,使用了RabbitMQ进行解耦。其中,为了提高消费者的处理效率针对了不同节点任务的消费者线程数和prefetch_count参数都做了调整和测...
  • 文章目录count(可空字段)count(非空字段)与count(主键 id)count(1)count(\*)性能对比结论 注:下面的讨论和结论是基于 InnoDB 引擎的。 首先要弄清楚 count() 的语义。count() 是一个聚合函数,对于返回的结果集,一...
  • mysql count详解及函数实例代码

    千次阅读 2021-01-21 03:27:53
    mysql count详解count函数是用来统计表中或数组中记录的一个函数,下面我来介绍在mysql中count函数用法。count(*) 它返回检索行的数目, 不论其是否包含 NULL值。SELECT 从一个表中检索,而不检索其它的列,并且没有...
  • MySQL中的COUNT函数,你理解多少

    千次阅读 2021-01-19 21:18:30
    前言:COUNT函数相比大家都不陌生,接触过数据库的兄弟们想必都用过,但是,就是这个常用的COUNT函数,却暗含许多玄机。1、COUNT简介看看官网对COUNT的简介大致意思是:COUNT(expr)返回SELECT语句中expr值不为NULL的...
  • 本篇博客将更新count、distinct、count(distinct)这几个新学到的Elasticsearch关于查询的方法。 1. Count计算 在项目中,count也算是一个比较常用的方法。之前项目中有需要用到,都是基于查询所有的方法,直接取...
  • count(*)和count(1)的区别

    千次阅读 2022-01-08 15:34:28
    使用count函数,当要统计的数量比较大时,发现count(*)花费的时间比较多,相对来说count(1)花费的时间比较少。 1、如果你的数据表没有主键,那么count(1)比count(*)快 ;如果有主键的话,那主键(联合主键)作为...
  • 关于数据库中行数统计,无论是MySQL还是Oracle,都有一个函数可以使用,那就是COUNTCOUNT MySQL官网给出的解释是: 1、COUNT(expr) ,返回SELECT语句检索的行中expr的值不为NULL的数量。结果是一个BIGINT值。 ...
  • Mysql中使用count加条件统计

    万次阅读 多人点赞 2019-06-02 10:34:26
    最近发现在处理Mysql问题时,count()函数频繁上镜,常常出现在分组统计的情景下,但是有时候并不是使用group by分好组就可以直接统计了,比如说一个常见的需求,统计每个班级男生所占的比例,这种情况一般会按照班级...
  • MybatisPlus调用count函数

    千次阅读 2021-12-22 17:07:22
    mybatisPlus如何调用count函数
  • Python中这个count用法是啥

    千次阅读 2021-04-30 01:39:32
    Python中这个count用法是啥意思count 在这里只是一个变量名,你把它换成adict就很好理解了:关于python的一段代码,谁给具体解析一下,特别是 count+=number,在下初中生,理解def total(initial=5,*numbers,**...
  • 区别:count(1) 和 count(*)和count(列名)

    千次阅读 2021-02-17 18:40:17
    执行效果上: count(*)包括了所有的列,相当于行数,在统计结果的时候,不会忽略列值...所以呢,count(1)和count(*)之间没有区别,因为他们两个都不会过滤空值,但count(列名)就有区别了,因为count(列名)会去过滤空值
  • MySQL中count(1)、count(*) 与 count(列名) 的执行区别

    万次阅读 多人点赞 2019-11-04 20:13:01
    1、count(1) and count(*) 当表的数据量大些时,对表作分析之后,使用count(1)还要比使用count()用时多了! 从执行计划来看,count(1)和count()的效果是一样的。但是在表做过分析之后,count(1)会比count(*)的用时少...
  • Column count doesn't match value count at row 1; Column count doesn't match value count at row 1; 原因: 插入时的数据个数与表中的字段个数不一致,问题基本都出在Insert语句中 以 LOL 结构表为测试表为例...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,705,049
精华内容 1,482,019
关键字:

count

友情链接: fuzzy逼近未知函数.zip