T-SQL朝花夕拾(一) group by,distinct,子查询

搜罗了网上的资料，加上自己测试的sql。

1. GROUP BY 是分组查询, 一般 GROUP BY 是和聚合函数配合使用

group by 有一个原则,就是 select 后面的所有列中,没有使用聚合函数的列,必须出现在 group by 后面

2. Having

where 子句的作用是在对查询结果进行分组前，将不符合where条件的行去掉，即在分组之前过滤数据，条件中不能包含聚组函数，使用where条件显示特定的行。

having 子句的作用是筛选满足条件的组，即在分组之后过滤数据，条件中经常包含聚组函数，使用having 条件显示特定的组，也可以使用多个分组标准进行分组。

having 子句被限制子已经在SELECT语句中定义的列和聚合表达式上。通常，你需要通过在HAVING子句中重复聚合函数表达式来引用聚合值，就如你在SELECT语句中做的那样。

3.子查询是一个 SELECT 语句，它嵌套在一个 SELECT、SELECT...INTO 语句、INSERT...INTO 语句、DELETE 语句、或 UPDATE 语句或嵌套在另一子查询中。

em:

-- group by,having, where
select top  10  userid,count( * )  as  psize from produce group by userid order by psize desc   -- 从大到小查询产品表 >> 发布产品最多的公司
select  *  from produce  where  userid = 755
select top  10  userid ,procpic,count( * )  as  psize from produce group by userid, procpic order by psize desc
select top  10000   userid,count( * )  as  psize from produce group by userid having userid >= 700  order by psize desc 
select  userid,count( * )  as  psize from produce  where  userid >= 700  group by userid order by count( * ) desc 
select  userid,count( * )  as  psize from produce  group by userid having userid >= 700  order by count( * ) desc 
select top  1000    *  from  userinfo 
select top  1000    *  from  produce
select userid,count( * ) from 
select  *  From bizservice Where bizservicetype = ' 101 '
select top  10  userid,count( * )  as  psize from produce group by userid having count( * )  > 900  order by psize desc  -- having用于过滤分组
select top  10  userid,count( * )  as  psize from produce  where   userid  > 900  group by userid  order by psize desc   -- where  用于过滤字段 

select top  100   *  from produce
-- 子查询
select  *  from dbo.BizServiceType1
select  *  from dbo.BizServiceType2
select  *  from  userinfo  where  id = 2627
select top  10    *  from BizService  where  bizservicetype   in  (select TypeId from BizServiceType2)  
select  *  from bizinfo  where  userid = (select id from userinfo  where  userid = ' food20090729041156 ' )   

select distinct userpwd from userinfo

 有个比使用HAVING语句更好的方法来限制查询。通常，HAVING不如WHERE有效，因为HAVING是在数据分组之后才限制结果集，WHERE则是先进行限制。下面这个例子错误的使用了HAVING语句。

--bad sql

select userinfo.id,userinfo.userid ,count(*) as usersize
from userinfo
group by userinfo.id,userinfo.userid
having userinfo.id>100

正确的方法应该是在WHERE语句 中列出查询的过滤标准，如下：

select userinfo.id,userinfo.userid ,count(*) as usersize
from userinfo
where userinfo.id>100
group by userinfo.id,userinfo.userid

（T-SQL权威指南）

 

distinct 和 group by 使用对比

 

t3表的结构如下：
 
Select * FROM t3
id edu        age
1   本           20       
2   本           25       
3   本           30       
4   本           30       
5   本           25       
6   中           15       
7   中           20       
8   中           20       
9   专           20       
10 专           20       
11 专           20       
12 专           30       
13 专           30       
--------------------------------------
Select distinct edu,age
FROM t3
order by age
 
edu        age
中           15       
本           20       
中           20       
专           20       
本           25       
本           30       
专           30      
 
小结：1、distinct edu,age 是将edu,age两个字段看成一体，只要edu,age这两个字段相同，
         就将其视为重复记录;
      2、在Select中只能用一次distinct或all;
      3、在Select中用了distinct就不能用ALL；用了ALL就不能用distinct;不能同时存在；
      4、如果指定了SELECT DISTINCT，那么ORDER BY 子句中的项就必须出现在选择列表中;
---------------------------------------
select edu,age,count(*) as '人数'
--into
from t3
--where id<10
--where 分组前记录的过滤条件
group by edu,age
--having 分组后对组的过滤条件
order by age
 
edu        age         人数
中           15           1
本           20           1
中           20           2
专           20           3
本           25           2
本           30           2
专           30           2
 
小结：1、distinct edu,age 是将edu,age两个字段看成一体，只要edu,age这两个字段相同，
         就将其视为同组;
      2、SELECT子句中的列名必须为分组列或列函数；
      3、where子句中的列名可以为表中任意字段；
      4、having子句中的列名必须为分组列或列函数；

 

 

 

转载于:https://www.cnblogs.com/qixuejia/archive/2010/04/20/1716266.html