select 中的DISTINCT用法

   在 使用mysql时，有时需要查询出某个字段不重复的记录，虽然mysql提供有distinct这个关键字来过滤掉多余的重复记录只保留一条，但往往只用 它来返回不重复记录的条数，而不是用它来返回不重记录的所有值。其原因是distinct只能返回它的目标字段，而无法返回其它字段，这个问题让我困扰了 很久，用distinct不能解决的话，我只有用二重循环查询来解决，而这样对于一个数据量非常大的站来说，无疑是会直接影响到效率的。所以我花了很多时 间来研究这个问题，网上也查不到解决方案，期间把容容拉来帮忙，结果是我们两人都郁闷了。。。。。。。。。

下面先来看看例子：

      table
    id name
    1 a
    2 b
    3 c
    4 c
    5 b

库结构大概这样，这只是一个简单的例子，实际情况会复杂得多。

比如我想用一条语句查询得到name不重复的所有数据，那就必须使用distinct去掉多余的重复记录。

select distinct name from table
得到的结果是:

    name
    a
    b
    c

好像达到效果了，可是，我想要得到的是id值呢？改一下查询语句吧:

select distinct name, id from table

结果会是:

    id name
    1 a
    2 b
    3 c
    4 c
    5 b

distinct怎么没起作用？作用是起了的，不过他同时作用了两个字段，也就是必须得id与name都相同的才会被排除。。。。。。。

我们再改改查询语句:

select id, distinct name from table

很遗憾，除了错误信息你什么也得不到，distinct必须放在开头。难到不能把distinct放到where条件里？能，照样报错。。。。。。。

很麻烦吧？确实，费尽心思都没能解决这个问题。没办法，继续找人问。

拉住公司里一JAVA程序员，他给我演示了oracle里使用distinct之后，也没找到mysql里的解决方案，最后下班之前他建议我试试group by。

试了半天，也不行，最后在mysql手册里找到一个用法，用group_concat(distinct name)配合group by name实现了我所需要的功能，兴奋，天佑我也，赶快试试。

报错。。。。。。。。。。。。郁闷。。。。。。。连mysql手册也跟我过不去，先给了我希望，然后又把我推向失望，好狠哪。。。。

再仔细一查，group_concat函数是4.1支持，晕，我4.0的。没办法，升级，升完级一试，成功。。。。。。

终于搞定了，不过这样一来，又必须要求客户也升级了。

突然灵机一闪，既然可以使用group_concat函数，那其它函数能行吗？

赶紧用count函数一试，成功，我。。。。。。。想哭啊，费了这么多工夫。。。。。。。。原来就这么简单。。。。。。

现在将完整语句放出:

select *, count(distinct name) from table group by name

结果:

    id name count(distinct name)
    1 a 1
    2 b 1
    3 c 1

最后一项是多余的，不用管就行了，目的达到。。。。。

唉，原来mysql这么笨，轻轻一下就把他骗过去了，郁闷也就我吧（对了，还有容容那家伙），现在拿出来希望大家不要被这问题折腾。

哦，对，再顺便说一句，group by 必须放在 order by 和 limit之前，不然会报错，差不多了，发给容容放网站上去，我继续忙碌。。。。。。

 

整理：sql server 中sql语句执行顺序

SQL Server 查询处理中的各个阶段(SQL执行顺序)

SQL 不同于与其他编程语言的最明显特征是处理代码的顺序。在大数编程语言中，代码按编码顺序被处理，但是在SQL语言中，第一个被处理的子句是FROM子句，尽管SELECT语句第一个出现，但是几乎总是最后被处理。

      每个步骤都会产生一个虚拟表，该虚拟表被用作下一个步骤的输入。这些虚拟表对调用者（客户端应用程序或者外部查询）不可用。只是最后一步生成的表才会返回 给调用者。如果没有在查询中指定某一子句，将跳过相应的步骤。下面是对应用于SQL server 2000和SQL Server 2005的各个逻辑步骤的简单描述。

(8)SELECT (9)DISTINCT  (11)<Top Num> <select list>
(1)FROM [left_table]
(3)<join_type> JOIN <right_table>
(2)        ON <join_condition>
(4)WHERE <where_condition>
(5)GROUP BY <group_by_list>
(6)WITH <CUBE | RollUP>
(7)HAVING <having_condition>
(10)ORDER BY <order_by_list>

逻辑查询处理阶段简介

1. FROM：对FROM子句中的前两个表执行笛卡尔积（Cartesian product)(交叉联接），生成虚拟表VT1
2. ON：对VT1应用ON筛选器。只有那些使<join_condition>为真的行才被插入VT2。
3. OUTER(JOIN)：如 果指定了OUTER JOIN（相对于CROSS JOIN 或(INNER JOIN),保留表（preserved table：左外部联接把左表标记为保留表，右外部联接把右表标记为保留表，完全外部联接把两个表都标记为保留表）中未找到匹配的行将作为外部行添加到 VT2,生成VT3.如果FROM子句包含两个以上的表，则对上一个联接生成的结果表和下一个表重复执行步骤1到步骤3，直到处理完所有的表为止。
4. WHERE：对VT3应用WHERE筛选器。只有使<where_condition>为true的行才被插入VT4.
5. GROUP BY：按GROUP BY子句中的列列表对VT4中的行分组，生成VT5.
6. CUBE|ROLLUP：把超组(Suppergroups)插入VT5,生成VT6.
7. HAVING：对VT6应用HAVING筛选器。只有使<having_condition>为true的组才会被插入VT7.
8. SELECT：处理SELECT列表，产生VT8.
9. DISTINCT：将重复的行从VT8中移除，产生VT9.
10. ORDER BY：将VT9中的行按ORDER BY 子句中的列列表排序，生成游标（VC10).
11. TOP：从VC10的开始处选择指定数量或比例的行，生成表VT11,并返回调用者。

注：步骤10，按ORDER BY子句中的列列表排序上步返回的行，返回游标VC10.这一步是第一步也是唯一一步可以使用SELECT列表中的列别名的步骤。这一步不同于其它步骤的 是，它不返回有效的表，而是返回一个游标。SQL是基于集合理论的。集合不会预先对它的行排序，它只是成员的逻辑集合，成员的顺序无关紧要。对表进行排序 的查询可以返回一个对象，包含按特定物理顺序组织的行。ANSI把这种对象称为游标。理解这一步是正确理解SQL的基础。

因为这一步不返回表（而是返回游标），使用了ORDER BY子句的查询不能用作表表达式。表表达式包括：视图、内联表值函数、子查询、派生表和共用表达式。它的结果必须返回给期望得到物理记录的客户端应用程序。例如，下面的派生表查询无效，并产生一个错误：

select * 
from(select orderid,customerid from orders order by orderid) 
as d

下面的视图也会产生错误

create view my_view
as
select *
from orders
order by orderid

      在SQL中，表表达式中不允许使用带有ORDER BY子句的查询，而在T—SQL中却有一个例外（应用TOP选项）。

      所以要记住，不要为表中的行假设任何特定的顺序。换句话说，除非你确定要有序行，否则不要指定ORDER BY 子句。排序是需要成本的，SQL Server需要执行有序索引扫描或使用排序运行符。
      推荐一段SQL代码：行列转置
      

/*问题：假设有张学生成绩表(tb)如下:
姓名 课程 分数
张三 语文 74
张三 数学 83
张三 物理 93
李四 语文 74
李四 数学 84
李四 物理 94

想变成(得到如下结果)： 
姓名 语文 数学 物理 
---- ---- ---- ----
李四 74   84   94
张三 74   83   93
-------------------
*/ 

create table tb(姓名 varchar(10),课程 varchar(10),分数 int)
insert into tb values('张三' , '语文' , 74)
insert into tb values('张三' , '数学' , 83)
insert into tb values('张三' , '物理' , 93)
insert into tb values('李四' , '语文' , 74)
insert into tb values('李四' , '数学' , 84)
insert into tb values('李四' , '物理' , 94)
go 

--SQL SERVER 2000 静态SQL,指课程只有语文、数学、物理这三门课程。(以下同)
select 姓名 as 姓名 ,
  max(case 课程 when '语文' then 分数 else 0 end) 语文,
  max(case 课程 when '数学' then 分数 else 0 end) 数学,
  max(case 课程 when '物理' then 分数 else 0 end) 物理
from tb
group by 姓名

====================================================================================================

好像自已在书写 SQL 语句时由于不清楚各个关键字的执行顺序, 往往组织的 SQL 语句缺少很好的逻辑, 凭感觉 "拼凑" ( 不好意思, 如果您的 SQL 语句也经常 "拼凑", 那您是不是得好好反省一下呢?, 呵呵). 
这样做确实是爽了自己, 可苦了机器, 服务器还需要在我们的杂乱无章的 SQL 语句中寻找它下一句需要执行的关键字在哪里. 
效率嘛, 由于我们的感觉神经对秒以下的变化实在不敏感, 暂且就认为自已写的 SQL 顺序无关紧要, "反正没什么变化!", 呵呵.其实服务器对每句 SQL 解析时间都会有详细记录的, 大家可以看一下自已按习惯写的 SQL 和按标准顺序写的SQL解析时间差别有多大. 
因此, 建议大家在平时工作中 SQL 语句按标准顺序写, 一是专业, 二是实用, 呵呵, 不过我觉得最主要的是心里感觉舒服. 
标准的 SQL 的解析顺序为: 
(1).FROM 子句, 组装来自不同数据源的数据 
(2).WHERE 子句, 基于指定的条件对记录进行筛选 
(3).GROUP BY 子句, 将数据划分为多个分组 
(4).使用聚合函数进行计算 
(5).使用 HAVING 子句筛选分组 
(6).计算所有的表达式 
(7).使用 ORDER BY 对结果集进行排序 
举例说明: 在学生成绩表中 (暂记为 tb_Grade), 把 "考生姓名"内容不为空的记录按照 "考生姓名" 分组, 并且筛选分组结果, 选出 "总成绩" 大于 600 分的. 
标准顺序的 SQL 语句为: 
select 考生姓名, max(总成绩) as max总成绩 
from tb_Grade 
where 考生姓名 is not null 
group by 考生姓名 
having max(总成绩) > 600 
order by max总成绩 
在上面的示例中 SQL 语句的执行顺序如下: 
(1). 首先执行 FROM 子句, 从 tb_Grade 表组装数据源的数据 
(2). 执行 WHERE 子句, 筛选 tb_Grade 表中所有数据不为 NULL 的数据 
(3). 执行 GROUP BY 子句, 把 tb_Grade 表按 "学生姓名" 列进行分组 
(4). 计算 max() 聚集函数, 按 "总成绩" 求出总成绩中最大的一些数值 
(5). 执行 HAVING 子句, 筛选课程的总成绩大于 600 分的. 
(7). 执行 ORDER BY 子句, 把最后的结果按 "Max 成绩" 进行排序.

=====================================================================================================

SQLServer2005中查询语句的执行顺序

 

--1.from
--2.on
--3.outer(join)
--4.where
--5.group by
--6.cube|rollup
--7.having
--8.select
--9.distinct
--10.order by
--11.top

1. 逻辑查询处理步骤序号
(8)SELECT (9)DISTINCT (11)<TOP_specification> <select_list>
(1)FROM <left_table>
(3)　<join_type> JOIN <right_table>
(2)　　　 ON <join_condition>
(4)WHERE <where_condition>
(5)GROUP BY <group_by_list>
(6)WITH {CUBE | ROLLUP}
(7)HAVING <having_condition>
(10)ORDER BY <order_by_list>

 

每个步骤产生一个虚拟表，该虚拟表被用作下一个步骤的输入。
只有最后一步生成的表返回给调用者。
如果没有某一子句，则跳过相应的步骤。
1. FROM:
   对FROM子句中的前两个表执行笛卡尔积，生成虚拟表VT1。
2. ON:
   对VT1应用ON筛选器。只有那些使<join_condition>为真的行才被插入VT2。
3. OUTER(JOIN):
   如果指定了OUTER JOIN，保留表中未找到匹配的行将作为外部行添加到VT2，生成VT3。
   如果FROM子句包含两个以上的表，则对上一个联接生成的结果表和下一个表重复执行步骤1到步骤3，直到处理完所有的表为止。
4. 对VT3应用WHERE筛选器。只有使<where_condition>为TRUE的行才被插入VT4。
5. GROUP BY:
   按GROUP BY 子句中的列列表对VT4中的行分组，生成VT5。
6. CUBE|ROLLUP:
   把超组插入VT5，生成VT6。
7. HAVING:
   对VT6应用HAVING筛选器。
   只有使<having_condition>为TRUE的组才会被插入VT7。

   注：having不能单独使用，having子句是对分组后的记录的筛选，所以有having必须要有group by
8. SELECT:
   处理SELECT列表，产生VT8。
9. DISTINCT:
   将重复的行从VT8中移除，产生VT9。
10. ORDER BY:
   将VT9中的行按ORDER BY子句中的列列表排序，生成一个有表(VC10)。
11. TOP:从VC10的开始处选择指定数量或比例的行，生成表VT11,并返回给调用者。

   注：top n可以实现分页

        select top 20 * from 雇员                                                                 ------第一页

 

        select top 20 * from 雇员

        where 身份证号码 not in (select top 20 身份证号码 from 雇员)            ------第二页

 

2. 准备数据

SET NOCOUNT ON;
USE tempdb;
GO
　
IF OBJECT_ID('dbo.Orders') IS NOT NULL
　DROP TABLE dbo.Orders;
GO
IF OBJECT_ID('dbo.Customers') IS NOT NULL
　DROP TABLE dbo.Customers;
GO
　
CREATE TABLE dbo.Customers
(
　customerid CHAR(5)　　　 NOT NULL PRIMARY KEY,
　city　　　　　　 VARCHAR(10) NOT NULL
);
　
INSERT INTO dbo.Customers(customerid,city) VALUES('FISSA', 'Madrid');
INSERT INTO dbo.Customers(customerid,city) VALUES('FRNDO', 'Madrid');
INSERT INTO dbo.Customers(customerid,city) VALUES('KRLOS', 'Madrid');
INSERT INTO dbo.Customers(customerid,city) VALUES('MRPHS', 'Zion');
　
CREATE TABLE dbo.Orders
(
　orderid　　　 INT　　　　 NOT NULL PRIMARY KEY,
　customerid CHAR(5) NULL　　　　 REFERENCES Customers(customerid)
);
　
INSERT INTO dbo.Orders(orderid, customerid) VALUES(1,'FRNDO');
INSERT INTO dbo.Orders(orderid, customerid) VALUES(2,'FRNDO');
INSERT INTO dbo.Orders(orderid, customerid) VALUES(3,'KRLOS');
INSERT INTO dbo.Orders(orderid, customerid) VALUES(4,'KRLOS');
INSERT INTO dbo.Orders(orderid, customerid) VALUES(5,'KRLOS');
INSERT INTO dbo.Orders(orderid, customerid) VALUES(6,'MRPHS');
INSERT INTO dbo.Orders(orderid, customerid) VALUES(7, NULL);

　　执行结果：

3. 查询语句

USE tempdb;
GO
SELECT C.customerid, COUNT(O.orderid) AS numorders
FROM dbo.Customers AS C
　LEFT OUTER JOIN dbo.Orders AS O
　　　 ON C.customerid = O.customerid
WHERE C.city = 'Madrid'
GROUP BY C.customerid
HAVING COUNT(O.orderid) < 3
ORDER BY numorders;

　　执行结果：

4. 逻辑查询处理步骤详解

 

1. 执行笛卡尔乘积，形成VT1。如果左表包含n行，右表包含m行，VT1将包含n×m行。

    执行结果VT1：

 

2. 应用ON　筛选器，只有<join_condition>为TRUE的那些行才会包含在VT2中。

ON C.customerid = O.customerid

　　三值逻辑：

      TRUE、FALSE、UNKNOWN为SQL中逻辑表达式的可能值。

　　UNKNOWN值通常出现在含NULL值的逻辑表达式中，如NULL > 42; NULL = NULL; X + NULL > Y。

　　NOT TRUE 等于 FALSE

　　NOT FALSE 等于TRUE

　　NOT UNKNOWN 等于 UNKNOWN

　　所有的查询筛选器，如ON、WHERE、HAVING把UNKNOWN看作为FALSE处理。

　　CHECK约束中的UNKNOWN值被当作TRUE对待。如果表中含有一个CHECK约束，要求salary列的值必须大于0，则插入salary为NULL的行时可以被接受。

　　UNIQUE约束、排序操作、分组操作认为两个NULL值是相等的。如，表中有一列定义了UNIQUE约束，则无法向表中插入该列值为NULL的两行。GROUP BY子句把所有NULL值分在一组。ORDERB BY子句把所有NULL值排列在一起。

　　对VT1增加ON筛选器的结果VT2：

　　

3. 添加外部行，通过指定LEFT、RIGHT、FULL中的一种OUTER JOIN，可以把左表、右表、所有表标记为保留表。把一个表设为保留表表示返回该表的所有行，即使<join_condition>已经执行过筛选。保留表中的这些行被称为外部行，外部行中非保留表的属性被赋予NULL，最后生成VT3：

　　

4. 应用WHERE筛选器，只有符合<where_condition>的行才会成为VT4的一部分。因为数据还没有被分组，所以不能使用聚合筛选器，例如WHERE orderdate = MAX(orderdate)。也不能饮用SELECT列表中的别名，因为SELECT列表这时还没有被处理，例如SELECT YEAR(orderdate) AS orderyear WHERE orderyear > 2000。

　　对于包含OUTER JOIN子句的查询，如何判断到底是在ON筛选器还是在WHERE筛选器中指定逻辑表达式：ON在添加外部行前被应用，WHERE在外部行添加之后被应用。ON筛选器对保留表中部分行的一处不是最终的，因为还要执行添加外部行的步骤，而WHERE筛选器对这些行的移除是最终的。

　　只有在使用外部联接时，ON和WHERE子句才会存在这种逻辑限制，当使用内部联接时，在那里指定逻辑表达式都无所谓，因为没有上面的步骤3。

WHERE C.city = 'Madrid'

　　生成虚拟表VT4：

　　

5. 分组。GROUP BY子句中列列表的每个唯一的值组合成为一组，生成VT5：

 

Groups	Raw
C.customerid
FISSA
FRNDO
KRLOS

 

　　VT5由两部分组成：Group Section和Raw Section。

　　如果在查询中指定了GROUP BY子句，则后面的所有步骤(如：HAVING、SELECT)只能指定可以为成组得到的标量值的表达式。也就是说，表达式的结果是GROUP BY列表中的列/表达式(如：C.customer)或聚合函数(如：COUNT(O.orderid))。该限制是因为最终的结果集中最多只为每一个组包含一行。

　　这一阶段认为两个NULL是相等的。所有的NULL值会被分配到一组。

　　如果指定GROUP BY ALL，则在WHERE筛选中被移除的组将被添加到VT5中，且原始部分为空集合。在后面的步骤中，对该组应用COUNT聚合函数的结果将为0，应用其他聚合函数的结果为NULL。最好不要使用GROUP BY ALL。

　　

6. 使用CUBE或ROLLUP选项，将创建超组并把它添加到上一步返回的虚拟表中，生成VT6。

　　

7. 应用HAVING 筛选器　，只有符合<having_condition>的组才会成为VT7的一部分。HAVING是唯一的应用到已分组数据的筛选器。

HAVING COUNT(O.orderid) < 3

　　在这里使用了COUNT(O.orderid)，而不是COUNT(*)，所以外部行因为O.orderid为NULL，于是不计入COUNT中。如FISSA这组的COUNT(O.orderid)为0.

　　红色部分为被HAVING筛选掉的分组。

 

Groups	Raw
C.customerid
FISSA
FRNDO
KRLOS

 

　　

8. 处理SELECT列表，为不是基列的表达式应用别名，使其在结果表中有一个名称。在SELECT列表中创建的别名不能再前面的步骤中使用，甚至不能再SELECT列表中使用，只能在ORDER BY中使用。

SELECT C.customerid, COUNT(O.orderid) AS numorders

　　生成VT8：

　　逻辑上，应当假设所有操作同时发生。

　　

9. 应用DISTINCT子句，如果查询中指定了DISTINCT子句，将从上一步返回的虚拟表中移除重复行，并生成虚拟表VT9。使用GROUP BY，再使用DISTINCT是多余的。

　　

10. 应用ORDER BY子句，按照ORDER BY子句中的列列表排序上一步返回的行，返回游标VC10。只有这一步可以使用SELECT别名。如果指定了DISTINCT，ORDER BY子句中的表达式只能访问上一步返回的虚拟表，只能按已经SELECT的列排序。

　　ANSI SQL 1999中增强了ORDER BY的支持，允许访问SELECT阶段的输入虚拟表和输出虚拟表。就是说如果未指定DISTINCT，可以在ORDER BY子句中指定任何可以在SELECT子句中使用的表达式，可以按最后结果集中不存在的表达式排序。

ORDER BY numorders;

　　也可以在ORDER BY子句中指定SELECT列表中结果列的序号：

ORDER BY 2, 1;

　　但是尽量不要这样去做，因为可能改变了SELECT列表却忘记了修改ORDER BY列表，而且当SELECT列表很长时，查序号不是一个好方法。

　　因为这一步不是返回表，而是返回游标，使用了ORDER BY子句的查询不能用作表表达式。表表达式包括：视图、内联表值函数、子查询、派生表和共用表表达式(CTE)。

　　不要为表中的行假定顺序，除非确实需要有序行，否则不要指定ORDER BY子句。排序是需要成本的，SQL Server需要执行有序索引扫描或使用排序运算符。

　　ORDER BY这一步认为两个NULL是相等的，所有的NULL会被排列在一起，ANSI并没有规定NULL比已知值高还是低，而是把这个问题留给了具体实现，在T-SQL中NULL排位比已知值低。

ORDER BY numorders

　　返回的游标VC10：

　

11. 应用TOP选项，从游标的最前面选择指定的行数，生成表VT11并返回给调用者。在SQLServer 2000中，TOP的输入必须为常量，而在2005中可以是任何独立的表达式。

　　如果没有ORDER BY子句或WITH TIES选项，返回的行正好是物理上最先访问的行，可能会产生不同的结果。

　　只有指定了TOP选项，才可以在表表达式中使用带有ORDER BY子句的查询：

SELECT *
FROM (SELECT TOP 100 PERCENT orderid, customerid
　　　　　　　 FROM dbo.Orders
　　　　　　　 ORDER BY orderid) AS D;

 

原文：http://tech.ddvip.com/2009-04/1239449159114603.html