MySQL--HAVING子句的力量

最新推荐文章于 2021-11-16 10:51:38 发布
最新推荐文章于 2021-11-16 10:51:38 发布
阅读量313 收藏
点赞数 1
分类专栏： MySQL学习笔记 文章标签： MySQL学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yj_445324989/article/details/102606928
版权

本文根据《SQL进阶教程》（[日]MICK/著 吴炎昌/译）所写笔记。

寻找缺失的编号

现在有一张表seqtbl，虽然编号那一列叫做连续编号，但实际上编号并不是连续的，缺失4和7.我们现在要做的就是查找是否有缺失值：

CREATE TABLE SeqTbl
(seq  INTEGER PRIMARY KEY,
 name VARCHAR(16) NOT NULL);

INSERT INTO SeqTbl VALUES(1,	'迪克');
INSERT INTO SeqTbl VALUES(2,	'安');
INSERT INTO SeqTbl VALUES(3,	'莱露');
INSERT INTO SeqTbl VALUES(5,	'卡');
INSERT INTO SeqTbl VALUES(6,	'玛丽');
INSERT INTO SeqTbl VALUES(8,	'本');

mysql> select * from seqtbl;
+-----+--------+
| seq | name   |
+-----+--------+
|   1 | 迪克   |
|   2 | 安     |
|   3 | 莱露   |
|   5 | 卡     |
|   6 | 玛丽   |
|   8 | 本     |
+-----+--------+

-- 查找是否有缺失值
mysql> select '存在缺失值的编号' as gap
    -> from seqtbl
    -> having count(*)<>max(seq);
+--------------------------+
| gap                      |
+--------------------------+
| 存在缺失值的编号         |
+--------------------------+

如果这个查询结果只有一行，说明存在缺失的编号，如果一行都没有，说明不存在缺失的编号。大家会注意到，上面的语句没有group by子句，此时整张表会被聚合为一行。这种情况下HAVING子句也是可以使用的。HAVING子句是可以单独使用的。不过这种情况下，就不能在select子句里引用原来的表里的列了，要么就得像实例里一样使用常量，要么就像select count(*)这样使用聚合函数。

现在，我们已经知道表中存在缺失值了，那么如何求出缺失的编号是多少呢？

-- 查询缺失编号的最小值
mysql> select min(seq+1) as gap from seqtbl
    -> where (seq+1) not in (select seq from seqtbl);
+------+
| gap  |
+------+
|    4 |
+------+

-- 查询全部缺失值
mysql> select seq+1 as gap from seqtbl
    -> where (seq+1) not in (select seq from seqtbl);
+-----+
| gap |
+-----+
|   4 |
|   7 |
|   9 |
+-----+

用HAVING子句进行子查询：求众数

下面有一张graduates 表，我们求一下众数（方法一，使用谓词。方法二，使用极值函数）：

CREATE TABLE Graduates
(name   VARCHAR(16) PRIMARY KEY,
 income INTEGER NOT NULL);

INSERT INTO Graduates VALUES('桑普森', 400000);
INSERT INTO Graduates VALUES('迈克',     30000);
INSERT INTO Graduates VALUES('怀特',   20000);
INSERT INTO Graduates VALUES('阿诺德', 20000);
INSERT INTO Graduates VALUES('史密斯',     20000);
INSERT INTO Graduates VALUES('劳伦斯',   15000);
INSERT INTO Graduates VALUES('哈德逊',   15000);
INSERT INTO Graduates VALUES('肯特',     10000);
INSERT INTO Graduates VALUES('贝克',   10000);
INSERT INTO Graduates VALUES('斯科特',   10000);

mysql> select * from graduates;
+-----------+--------+
| name      | income |
+-----------+--------+
| 劳伦斯    |  15000 |
| 史密斯    |  20000 |
| 哈德逊    |  15000 |
| 怀特      |  20000 |
| 斯科特    |  10000 |
| 桑普森    | 400000 |
| 肯特      |  10000 |
| 贝克      |  10000 |
| 迈克      |  30000 |
| 阿诺德    |  20000 |
+-----------+--------+

-- 求众数
-- 方法一：使用谓词
mysql> select income,count(*) as cnt
    -> from graduates
    -> group by income
    -> having count(*) >=all(select count(*) from graduates group by income);
+--------+-----+
| income | cnt |
+--------+-----+
|  10000 |   3 |
|  20000 |   3 |
+--------+-----+

--方法二：使用极值函数
mysql> select income,count(*) as cnt
    -> from graduates
    -> group by income
    -> having count(*) >= (select max(cnt) from (select count(*) as cnt from graduates group by income)tmp);
+--------+-----+
| income | cnt |
+--------+-----+
|  10000 |   3 |
|  20000 |   3 |
+--------+-----+

用HAVING子句进行自连接：求中位数（没看懂）

如果集合中的元素个数为偶数，则取中间两个元素的平均值作为中位数。做法是，将集合里的元素按照大小分为上半部分和下半部分两个子集，同时让这2个子集共同拥有集合正中间的元素。

mysql> SELECT AVG(DISTINCT income)
    ->   FROM (SELECT T1.income
    ->           FROM Graduates T1, Graduates T2
    ->       GROUP BY T1.income
    ->                /* S1的条件 */
    ->         HAVING SUM(CASE WHEN T2.income >= T1.income THEN 1 ELSE 0 END)
    ->                    >= COUNT(*) / 2
    ->                /* S2的条件 */
    ->            AND SUM(CASE WHEN T2.income <= T1.income THEN 1 ELSE 0 END)
    ->                    >= COUNT(*) / 2 ) TMP;
+----------------------+
| AVG(DISTINCT income) |
+----------------------+
|           17500.0000 |
+----------------------+

查询不包含null的集合

count函数的使用方法有count(*)和count(列名)两种，他们的区别有两个：第一个是性能上的区别，第二个是count(*)可以用于null，而count（列名）与其他聚合函数一样，要先排除掉null的行再进行统计。
下面我们用一张nulltbl表来看一下区别：

mysql> create table nulltbl
    -> (col_1 char(4));
mysql> insert into nulltbl values(null);
Query OK, 1 row affected (0.04 sec)

mysql> insert into nulltbl values(null);
Query OK, 1 row affected (0.02 sec)

mysql> insert into nulltbl values(null);
Query OK, 1 row affected (0.04 sec)

mysql> select * from nulltbl;
+-------+
| col_1 |
+-------+
| NULL  |
| NULL  |
| NULL  |
+-------+

mysql> select count(*),count(col_1) from nulltbl;
+----------+--------------+
| count(*) | count(col_1) |
+----------+--------------+
|        3 |            0 |
+----------+--------------+

例如：这里有一张存储了学生调教报告的日期的表students,学生提交报告后，“提交日期”会被写入到日期，而提交之前是null。现在我们需要从这张表里找出哪些学院的学生全部都提交了报告（即理学院、经济学院）。如果只是用where sbmt_date is not null这样的条件查询，文学院也会被包含进来。正确的做法是以“学院”为group by 的列生成子集。

CREATE TABLE Students
(student_id   INTEGER PRIMARY KEY,
 dpt          VARCHAR(16) NOT NULL,
 sbmt_date    DATE);

INSERT INTO Students VALUES(100,  '理学院',   '2005-10-10');
INSERT INTO Students VALUES(101,  '理学院',   '2005-09-22');
INSERT INTO Students VALUES(102,  '文学院',   NULL);
INSERT INTO Students VALUES(103,  '文学院',   '2005-09-10');
INSERT INTO Students VALUES(200,  '文学院',   '2005-09-22');
INSERT INTO Students VALUES(201,  '工学院',   NULL);
INSERT INTO Students VALUES(202,  '经济学院', '2005-09-25');

mysql> select * from students;
+------------+--------------+------------+
| student_id | dpt          | sbmt_date  |
+------------+--------------+------------+
|        100 | 理学院       | 2005-10-10 |
|        101 | 理学院       | 2005-09-22 |
|        102 | 文学院       | NULL       |
|        103 | 文学院       | 2005-09-10 |
|        200 | 文学院       | 2005-09-22 |
|        201 | 工学院       | NULL       |
|        202 | 经济学院     | 2005-09-25 |
+------------+--------------+------------+

-- 查询“提交日期”列内不包含null的学院：使用count函数
mysql> select dpt from students
    -> group by dpt
    -> having count(*)=count(sbmt_date);
+--------------+
| dpt          |
+--------------+
| 理学院       |
| 经济学院     |
+--------------+

-- 查询“提交日期”列内不包含null的学院：使用case表达式
mysql> select dpt from students
    -> group by dpt
    -> having count(*)=sum(case when sbmt_date is not null
    ->                          then 1 else 0 end);
+--------------+
| dpt          |
+--------------+
| 理学院       |
| 经济学院     |
+--------------+

case表达式将“提交日期”不是null的行标记为1，将“提交日期”为null的行标记为0.

用关系除法运算进行购物篮分析

有两张表，全国连锁折扣店的商品表items，以及各个店铺的库存管理表shopitems。

CREATE TABLE Items
(item VARCHAR(16) PRIMARY KEY);
 
CREATE TABLE ShopItems
(shop VARCHAR(16),
 item VARCHAR(16),
    PRIMARY KEY(shop, item));

INSERT INTO Items VALUES('啤酒');
INSERT INTO Items VALUES('纸尿裤');
INSERT INTO Items VALUES('自行车');

INSERT INTO ShopItems VALUES('仙台',  '啤酒');
INSERT INTO ShopItems VALUES('仙台',  '纸尿裤');
INSERT INTO ShopItems VALUES('仙台',  '自行车');
INSERT INTO ShopItems VALUES('仙台',  '窗帘');
INSERT INTO ShopItems VALUES('东京',  '啤酒');
INSERT INTO ShopItems VALUES('东京',  '纸尿裤');
INSERT INTO ShopItems VALUES('东京',  '自行车');
INSERT INTO ShopItems VALUES('大阪',  '电视');
INSERT INTO ShopItems VALUES('大阪',  '纸尿裤');
INSERT INTO ShopItems VALUES('大阪',  '自行车');

mysql> select * from items;
+-----------+
| item      |
+-----------+
| 啤酒      |
| 纸尿裤    |
| 自行车    |
+-----------+
mysql> select * from shopitems;
+--------+-----------+
| shop   | item      |
+--------+-----------+
| 东京   | 啤酒      |
| 东京   | 纸尿裤    |
| 东京   | 自行车    |
| 仙台   | 啤酒      |
| 仙台   | 窗帘      |
| 仙台   | 纸尿裤    |
| 仙台   | 自行车    |
| 大阪   | 电视      |
| 大阪   | 纸尿裤    |
| 大阪   | 自行车    |
+--------+-----------+

我们要查询的是囊括了表items中所有商品的店铺（仙台和东京）。大阪店没有啤酒，所以不是我们的目标。用一下语句查询结果是错误的：

mysql> select distinct shop
    -> from shopitems
    -> where item in (select item from items);
+--------+
| shop   |
+--------+
| 东京   |
| 仙台   |
| 大阪   |
+--------+

这是因为，在where子句里指定的条件只对表里的某一行数据有效。谓词in的条件其只是指定了“店内有啤酒或者纸尿裤或者自行车的店铺”，所以店铺只要有这三种商品中的任何一种就会出现在查询结果中。
正确的SQL语句应该这样写：

mysql> select si.shop
    -> from shopitems si,items i
    -> where si.item=i.item
    -> group by si.shop
    -> having count(si.item)=(select count(item) from items);
+--------+
| shop   |
+--------+
| 东京   |
| 仙台   |
+--------+

having子句的子查询select count(item) from items的返回结果是常量3.因此，对商品表和店铺的库存管理表进行连接操作后结果是3行的店铺会被选中。而仙台店则因（仙台，窗帘）的行在表连接时会被排除掉，所以也会被选中。东京店连接后的结果时3也会被选中。
但是需要注意的是，如果把having子句改写成having count(si.item)=count(i.item)，结果就不对了。仙台、东京、大阪3个店都会被选中。这是因为受到操作的影响，count(i.item)的值和表items原本的行数不一样了。

-- count(i.item)的值已经不一定是3了
mysql> select si.shop,count(si.item),count(i.item)
    -> from shopitems si,items i
    -> where si.item=i.item
    -> group by si.shop;
+--------+----------------+---------------+
| shop   | count(si.item) | count(i.item) |
+--------+----------------+---------------+
| 东京   |              3 |             3 |
| 仙台   |              3 |             3 |
| 大阪   |              2 |             2 |
+--------+----------------+---------------+

接下来，我们看看如何排除掉仙台店（仙台店的仓库存在“窗帘”，但商品表里没有窗帘），让结果只出现京东店。这类问题被称为“精确关系除法”，即只选择没有剩余商品的店铺（与此相对，前一个问题被称为“带余除法”。解决这一问题，我们使用外联结：

mysql> select si.shop
    -> from shopitems si left outer join items i
    -> on si.item=i.item
    -> group by si.shop
    -> having count(si.item)=(select count(item) from items)   -- 条件1
    ->    and count(i.item)=(select count(item) from items);   -- 条件2
+--------+
| shop   |
+--------+
| 东京   |
+--------+

以表shopitems为主表进行外连接后，结果如下：

mysql> select si.shop,si.item,i.item
    -> from shopitems si left outer join items i
    -> on si.item=i.item;
+--------+-----------+-----------+
| shop   | item      | item      |
+--------+-----------+-----------+
| 东京   | 啤酒      | 啤酒      |
| 东京   | 纸尿裤    | 纸尿裤    |
| 东京   | 自行车    | 自行车    |
| 仙台   | 啤酒      | 啤酒      |
| 仙台   | 窗帘      | NULL      |
| 仙台   | 纸尿裤    | 纸尿裤    |
| 仙台   | 自行车    | 自行车    |
| 大阪   | 电视      | NULL      |
| 大阪   | 纸尿裤    | 纸尿裤    |
| 大阪   | 自行车    | 自行车    |
+--------+-----------+-----------+

执行下面语句：

mysql> select si.shop
    -> ,count(si.item),count(i.item)
    -> from shopitems si left outer join items i
    -> on si.item=i.item
    ->  group by si.shop;
+--------+----------------+---------------+
| shop   | count(si.item) | count(i.item) |
+--------+----------------+---------------+
| 东京   |              3 |             3 |
| 仙台   |              4 |             3 |
| 大阪   |              3 |             2 |
+--------+----------------+---------------+

显然，只有东京符合。

本节小结

  1. 表不是文件，记录也没有顺序，所以SQL不进行排序
  2. SQL不是面向过程语言，没有循环、条件分支、赋值操作
  3. SQL通过不断生成子集来求得目标集合。SQL不像面向过程语言那用通过画流程图来思考问题。而是通过画集合的关系图来思考。
  4. group by子句可以用来生成子集。
  5. where子句用来调查集合元素的性指，而having子句用来调查集合本身的性质。

习题1：
在“寻找缺失编号”部分，将SQL语句修改成始终返回一行结果，即存在缺失编号时返回“存在缺失编号”，不存在缺失编号时返回“不存在缺失编号”。

-- 法一：使用union
mysql> select '存在缺失编号' as gap
    -> from seqtbl
    -> having count(*) <> max(seq)
    -> union all
    -> select '不存在缺失编号' as gap
    -> from seqtbl
    -> having count(*) =max(seq);
+--------------------+
| gap                |
+--------------------+
| 存在缺失编号       |
+--------------------+

-- 法二：使用case
mysql> select case when count(*)<>max(seq)
    ->             then '存在缺失编号'
    ->             else '不存在缺失编号' end as gap
    -> from seqtbl;
+--------------------+
| gap                |
+--------------------+
| 存在缺失编号       |
+--------------------+
-- 使用两条case
mysql> select case when count(*)<>max(seq)
    ->             then '存在缺失编号'
    ->             when count(*)=max(seq)
    ->             then '不存在缺失编号'
    ->             else 0 end as gap
    -> from seqtbl;
+--------------------+
| gap                |
+--------------------+
| 存在缺失编号       |
+--------------------+

习题2：
使用students表，查询“全体学生都在9月份提交了报告的学院”，即满足条件的只有经济学院。
首先我使用的是下面的代码，执行结果是错误的：

mysql> select dpt
    -> from students
    -> where sbmt_date between '2005-09-01' and '2005-09-30'
    -> group by dpt
    -> having count(*)=count(sbmt_date);
+--------------+
| dpt          |
+--------------+
| 文学院       |
| 理学院       |
| 经济学院     |
+--------------+

使用case表达式，把在9月份提交完成的学生记为1，否则为0.如果这个case表达式的合计值与集合全体元素的数目一致，就说明该学院的所有学生都在9月份提交完了。所以将代码改写为如下：

mysql> select dpt
    -> from students
    -> group by dpt
    -> having count(*) =sum(case when sbmt_date between '2005-09-01' and '2005-09-30'
    ->                           then 1 else 0 end);
+--------------+
| dpt          |
+--------------+
| 经济学院     |
+--------------+

习题3：
在“用关系除法运算进行购物篮分析”部分，返回结果只选择了满足条件的店铺。下面我们希望对于没有备齐全部商品类型的店铺，我们希望返回的一览表能展示这些店铺缺失多少种商品。my_item_cnt是店铺的现有库存商品种类，diff_cnt是不足商品的商品种类数

mysql> select si.shop,count(si.item) as my_item_cnt,
    ->        (select count(item) from items)-count(si.item) as diff_cnt
    -> from shopitems si,items i
    -> where si.item=i.item
    -> group by si.shop;
+--------+-------------+----------+
| shop   | my_item_cnt | diff_cnt |
+--------+-------------+----------+
| 东京   |           3 |        0 |
| 仙台   |           3 |        0 |
| 大阪   |           2 |        1 |
+--------+-------------+----------+
或是深海
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
《Oracle编程自学与面试指南》16-03：Having子句
西安极客联盟
08-10 567
HAVING 子句过滤分组结果集。 HAVING 相当于WHERE，与WHERE的唯一区别是，当查询语句中有聚合函数的时候，只能用HAVING。
HAVING 子句的力量 和 HAVING 子句又回来了
炫的博客
03-23 8925
HAVING 子句的力量 和 HAVING 子句又回来了
mysql having子句_mysql having子句学习
weixin_28695161的博客
02-07 260
在用到having子句的地方，出现最多的往往是sql的聚合函数，例如SUM, COUNT, MAX, AVG等。这些函数和其它函数的根本区别就是它们一般作用在多条记录上。示例：SELECT SUM(population) FROM bbc返回总人口数。通过使用GROUP BY 子句，可以让SUM 和 COUNT 这些函数对属于一组的数据起作用。当你指定 GROUP BY region 时， 属于同...
mysql中having的例子_有关mysql中having子句对组记录进行筛选的例子
weixin_29593445的博客
02-18 424
mysql中having的用法having字句，筛选成组后的各种数据，where字句在聚合前先筛选记录，即它作用在group by和having字句前，而 having子句在聚合后对组记录进行筛选。来看一些具体的例子吧。一、显示每个地区的总人口数和总面积复制代码 代码如下:SELECT region, SUM(population), SUM(area) FROM bbc GROUP BY reg...
mysql 查询奇偶数
We get old too soon and wise too late
07-31 406
https://blog.csdn.net/linshichen/article/details/51702151
《sql进阶教程》之HAVING 子句
uzong
11-24 511
本文是《sql进阶教程》阅读笔记，感兴趣可以阅读该书对应章节，这本适合有一定sql基础的同学阅读。另外作者《sql基础教程》也值得一看。 一、HAVING 子句 HAVING 子句是 SQL 里一个非常重要的功能；但其价值并没有被人们深刻地认识到。另外，它还是理解 SQL 面向集合这一本质的关键，应用范围非常广泛。本节，我们将学习 HAVING 子句的用法，进而理解面向集合语言的第二个特性——以集...
MySQL数据库：HAVING子句.pptx
05-29
MySQL数据库：HAVING子句.pptx
MySQL--视图的定义
05-26
4. 包含HAVING子句。 5. 使用UNION或UNION ALL合并多个查询结果。 #### 视图的作用 - **简化操作**：视图可以将复杂的查询封装起来，简化用户的操作。 - **安全性增强**：通过定义视图，可以限制用户对敏感数据的...
---Mysql---
03-07
3. DQL（Data Query Language）：用于查询数据，SELECT语句是其核心，可以通过WHERE子句筛选数据，使用GROUP BY进行分组，HAVING进行分组后的条件过滤，ORDER BY进行排序，LIMIT用于限制返回结果的数量。 三、索引...
mysql 数据库 5.5 mysql-5.5.37-win32
最新发布
10-17
- `SELECT`语句用于查询数据，可以结合`WHERE`、`GROUP BY`、`HAVING`、`ORDER BY`和`LIMIT`子句进行复杂查询。 5. **备份与恢复**： - `mysqldump`工具用于备份数据库，可以通过`--single-transaction`选项获取...
mysql中where和having子句的区别和具体用法
avsclxw015772714的博客
09-26 2457
1.mysql中的where和having子句的区别 having的用法 having字句可以让我们筛选成组后的各种数据，where字句在聚合前先筛选记录，也就是说作用在group by和having字句前。而 having子句在聚合后对组记录进行筛选。 SQL实例： 1.1.显示每个地区的总人口数和总面积． SELECT region, SUM(population), S...
11、MySQL算术运算符
you can you up up up的博客
10-12 646
算术运算符是 SQL 中最基本的运算符，MySQL 支持的运算符包括加、减、乘、除和取余运算，它们是最常用、最简单的一类运算符。下表列出了这些运算符的作用和使用方法。 示例 1 创建表 temp，定义数据类型为 INT 的字段 num，并插入值 64，对 num 值进行算术运算。 创建 temp 表语法如下： CREATE TABLE temp(num INT); 向字段 num 插入数据 64，语法如下。 INSERT INTO temp VALUE (64); 对 num 的值进行加法和减法运算：
SQL进阶：HAVING子句
博风_刺耳的博客
06-18 227
1、查询缺失的编号 -- 查询是否存在缺失的编号 select '存在缺失编号' from bs_visit HAVING count(*) <> MAX(id); -- 查询最小的缺失编号 SELECT min(id + 1) FROM bs_visit WHERE id + 1 NOT IN (SELECT id FROM bs_visit) 2、查询众数（数量最多的值）： SELECT dm_desc2, count(*) FROM bs_visit GRO.
MyBatis-Plus 通过updateById方法更新日期date类型的字段为null
可还记得你我的誓言
11-16 1787
需求： 有时候会有将前端日期重新赋值空的需求，但是字段传值为null，后台会不更新这个字段 解决方法： 对应的实体类的属性加以下注解 @TableField(updateStrategy = FieldStrategy.IGNORED) private Date xxx; ...
sql count用法_SQL进阶5感受having的力量
weixin_39614546的博客
12-06 768
HAVING是SQL中一个非常重要的功能，本文中将会介绍SQL中HAVING子句的用法。SQL语句顺序SQL语句执行顺序selectfromwheregroup byhavingorder by(desc是降序)从上面的顺序中可以看出来，HAVING子句是在group by 分组之后再执行的案例1-寻找缺失的编号需求下面的数据中缺少4和7判断是否缺失select '存在缺失的编号' as...
mysql having用法研究
weixin_30723433的博客
08-09 2043
having的用法 having字句可以让我们筛选成组后的各种数据，where字句在聚合前先筛选记录，也就是说作用在group by和having字句前。而 having子句在聚合后对组记录进行筛选。 SQL实例： 一、显示每个地区的总人口数和总面积． SELECT region, SUM(population), SUM(area) FROM bbc GROUP BY regio...
mysql中使用除法
热门推荐
weixin_30646505的博客
07-23 2万+
TRUNCATE(10/100) select TRUNCATE(10/100) from tb; 转载于:https://www.cnblogs.com/yxj9536/p/11229900.html
MySQL 中 having的用法
qq_43679405的博客
09-14 2万+
Mysql中HAVING的相关使用方法 having字句可以让我们筛选分组之后的各种数据，where字句在聚合前先筛选记录，也就是说作用在group by和having字句前。 而having子句在聚合后对组记录进行筛选。我的理解就是真实表中没有此数据，这些数据是通过一些函数产生的。 1.根据type查看总共有多少用户 **mysql> select type,count(*) from ts_user group by type;** 先以type把返回记录分成多个组，这就是GROUP BY的字
mysql 算整除_MySQL查询中的除法
weixin_39663933的博客
12-22 1541
I have 2 different query which will return values : 1502.00 and 6SELECT replace(CURRENT_VALUE,'$','') curValFROM form_attributes_valuesWHERE TEST_ID=2AND ATTRIBUTE_ID = (SELECT ATTRIBUTE_IDFROM form_a...
MySQL数据库分组过滤与HAVING子句解析
"本资源主要介绍了MySQL数据库中的分组过滤功能，强调了HAVING子句在过滤分组时的重要性，并对比了HAVING子句与WHERE子句的区别。同时，还简述了MySQL数据库的基本特点、历史背景、安装过程以及服务的启动与停止操作...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值