概述 
传统的集合运算 （并，差，交，笛卡尔积） 
专门的关系运算

并（Union）

R和S
具有相同的目n（即两个关系都有n个属性）
相应的属性取自同一个域

R∪S 
仍为n目关系，由属于R或属于S的元组组成
             R∪S = { t|t  R∨t S }

 
1
2
3
4
5
6
7
8
 
1
2
3
4
5
6
7
8

差（Difference）

R和S
具有相同的目n
相应的属性取自同一个域

R - S 
仍为n目关系，由属于R而不属于S的所有元组组成
                R -S = { t|tR∧tS }

 
1
2
3
4
5
6
7
8
 
1
2
3
4
5
6
7
8

交（Intersection）

R和S
具有相同的目n
相应的属性取自同一个域

R∩S
仍为n目关系，由既属于R又属于S的元组组成
                    R∩S = { t|t  R∧t S }
              R∩S = R –(R-S）

 
1
2
3
4
5
6
7
8
9
 
1
2
3
4
5
6
7
8
9

笛卡尔积（Cartesian Product）

R: n目关系，k1个元组
S: m目关系，k2个元组
R×S 
列：（n+m）列元组的集合
元组的前n列是关系R的一个元组
后m列是关系S的一个元组
行：k1×k2个元组
R×S = {tr ts |tr R ∧ tsS }

 
1
2
3
4
5
6
7
8
9
10
 
1
2
3
4
5
6
7
8
9
10

专门的关系运算

先引入几个记号

（1） R，tR，t[Ai]
         设关系模式为R(A1，A2，…，An)
         它的一个关系设为R
          tR表示t是R的一个元组
          t[Ai]则表示元组t中相应于属性Ai的一个分量 
 
1
2
3
4
5
 
1
2
3
4
5

（2） A，t[A]， A
   若A={Ai1，Ai2，…，Aik}，其中Ai1，Ai2，…，Aik是A1，A2，…，An中的一部分，则A称为属性列或属性组。
   t[A]=(t[Ai1]，t[Ai2]，…，t[Aik])表示元组t在属性列A上诸分量的集合。
   A则表示{A1，A2，…，An}中去掉{Ai1，Ai2，…，Aik}后剩余的属性组。 

 
1
2
3
4
5
 
1
2
3
4
5

（3） tr ts
    R为n目关系，S为m目关系。
    tr R，tsS， tr ts称为元组的连接。
    tr ts是一个n + m列的元组，前n个分量为R中的一个n元组，后m个分量为S中的一个m元组。 

 
1
2
3
4
5
 
1
2
3
4
5

（4）象集Zx
  给定一个关系R（X，Z），X和Z为属性组。
  当t[X]=x时，x在R中的象集（Images Set）为：
               Zx={t[Z]|t R，t[X]=x}
    它表示R中属性组X上值为x的诸元组在Z上分量的集合 

 
1
2
3
4
5
6
 
1
2
3
4
5
6

选择操作：感觉是数据库当中最简单的一种操作了，其定义如下： 
σF(R)=t|t∈R∧F(t)=true  
F是我们的选择条件，就是选出符合条件的元素。

投影操作： 
就是从R中选择出若干属性组成新的关系。 
πA(R)= {t[A]|t  ∈R }$

连接

1）连接也称为θ连接
2）连接运算的含义
从两个关系的笛卡尔积中选取属性间满足一定条件的元组
     R         S = {          | tr  R∧ts S∧tr[A]θts[B] }

A和B：分别为R和S上度数相等且可比的属性组
θ：比较运算符 
    连接运算从R和S的广义笛卡尔积R×S中选取（R关系）在A属性组上的值与（S关系）在B属性组上值满足比较关系θ的元组 

 
1
2
3
4
5
6
7
8
9
 
1
2
3
4
5
6
7
8
9

3）两类常用连接运算
等值连接（equijoin） 
什么是等值连接
θ为“＝”的连接运算称为等值连接 
等值连接的含义
从关系R与S的广义笛卡尔积中选取A、B属性值相等的那些元组，即等值连接为：
        R    S = {          | tr R∧ts S∧tr[A] = ts[B] }  

 
1
2
3
4
5
6
7
8
 
1
2
3
4
5
6
7
8

自然连接（Natural join） 
自然连接是一种特殊的等值连接
两个关系中进行比较的分量必须是相同的属性组（同名同域:必须具有相同的属性名，并且出自相同的域集）
在结果中把重复的属性列去掉
自然连接的含义
    R和S具有相同的属性组B
        R   S = {         | tr R∧ts S∧tr[B] = ts[B] }  
一般的连接操作是从行的角度进行运算。
        自然连接还需要取消重复列，所以是同时从行和列的角度进行运算。 

 
1
2
3
4
5
6
7
8
9
10
 
1
2
3
4
5
6
7
8
9
10

外连接
在做自然连接时，如果把舍弃的元组也保存在结果关系中，而在其他属性上填空值(Null)，这种连接就叫做外连接（OUTER JOIN）。
左外连接
在做自然连接时，如果只把左边关系R中要舍弃的元组保留就叫做左外连接(LEFT OUTER JOIN或LEFT JOIN)
右外连接
在做自然连接时，如果只把右边关系S中要舍弃的元组保留就叫做右外连接(RIGHT OUTER JOIN或RIGHT JOIN)。 

 
1
2
3
4
5
6
7
 
1
2
3
4
5
6
7

除（Division）

给定关系R (X，Y) 和S (Y，Z)，其中X，Y，Z为属性组。
R中的Y与S中的Y可以有不同的属性名，但必须出自相同的域集。
R与S的除运算得到一个新的关系P(X)，
P是R中满足下列条件的元组在 X 属性列上的投影：
元组在X上分量值x的象集Yx包含S在Y上投影的集合，记作：
       R÷S = {tr [X] | tr  R∧πY (S)  Yx }
       Yx：x在R中的象集，x = tr[X]

 
1
2
3
4
5
6
7
8
 
1
2
3
4
5
6
7
8

在关系R中，A可以取四个值{a1，a2，a3，a4}
    a1的象集为 {(b1，c2)，(b2，c3)，(b2，c1)}
    a2的象集为 {(b3，c7)，(b2，c3)}
    a3的象集为 {(b4，c6)}
    a4的象集为 {(b6，c6)}
S在(B，C)上的投影为
           {(b1，c2)，(b2，c1)，(b2，c3) }
只有a1的象集包含了S在(B，C)属性组上的投影
     所以     R÷S ={a1} 

除法比较难理解点，所以就详细的说说。。

设关系R除以关系S的结果为关系T，则T包含所有在R但不在S中的属性及其值，且T的元组与S的元组的所有组合都在R中。

所以结合着例子，对于定义进行理解吧：

首先呢给出关系R和关系S

1、定义中说，T包含所有在R但不在S中的属性，所以呢 R 所包含的属性有{A，B，C}，S中所包含的属性有{B，C，D}，显而易见，关系T中应该只包含

 一个属性---A；

2、及其值，只考虑关系R中A属性的值{a1，a2，a3，a4}，关系T属性A的元素应该是{a1，a2，a3，a4}的子集；

3、且T的元组与S的元组的所有组合都在R中，很明显，S中的需要考虑的只是属性B和属性C，所以

所以符合定义要求的值只有a1了。

从而得出：

转载：https://blog.csdn.net/zgcr654321/article/details/82077809

正文如下：

各种运算符如下：

数据库中每行就是一个元组，每列就是一个属性。

数据库的传统集合运算包括：并、差、交、笛卡尔积运算。这四种运算都与数学上的同名运算概念相似。

并：

差：

交：

笛卡尔积：

广义笛卡尔积（Extended Cartesian Product）：两个分别为n目和m目关系R和S的广义笛卡尔积是一个（n+m）列的元组的集合，元组的前n列是关系R的一个元组，后m列是关系S的一个元组。若R有k1个元组，S有k2个元组，则关系R和关系S的广义笛卡尔积有k1*k2个元组，记作：R×S={tr⌒ts| tr∈R∧ts∈S}或记做R×S={(r1,…,rn ,s1,…,sm)∣((r1,…,rn)∈R∧(s1,…,sm)∈S)。

r,s为R和S中的相应分量。

简单来说，就是把R表的第一行与S表第一行组合写在一起，作为一行。然后把R表的第一行与S表第二行依此写在一起，作为新一行。以此类推。当S表的每一行都与R表的第一行组合过一次以后，换R表的第二行与S表第一行组合，以此类推，直到R表与S表的每一行都组合过一次，则运算完毕。如果R表有n行，S表有M行，那么笛卡尔积R×S有n×M行。

下面举一个例子：

关系表R和S如下图所示：

R并S、R减S、R交S、选择、R与S的笛卡尔积结果如下所示：

选择B>'4'（R），即选择语句的条件，对R的关系做水平分割，选择R中符合条件的元组。

数据库的专门关系运算有：选择（对关系进行水平分割）、投影（对关系进行垂直分割）、连接、自然连接（关系的结合）、除运算等。

选择（selection）：

选择就是"筛选行"。选择一般要对一张表选择符合条件的行（但包含所有列）。

举例：

投影（projection）：

投影就是"筛选列"。一个数据库表，如仅希望得到其一部分的列的内容（但全部行），就是投影。

举例：

除法（division）：

记为R÷S，它是笛卡尔积的逆运算。设关系R和S分别有r列和s列（r>s，且s≠0），那么R÷S的结果有（r-s）个列，并且是满足下列条件的最大的表：其中每行与S中的每行组合成的新行都在R中。注意有时关系之间的除法也有"余数"，可能S×T的结果为R的一部分（最大的一部分），R中的多余部分为"余数"。

举例：

运算过程：

 C, D是关系S中的两个属性, 故在R集合中对除了C, D的属性, 即A, B两属性进行投影, 得到a, b; b, c; e, d;这三组, 然后用这个结果与关系S进行笛卡尔积运算, 发现b c c d这组在关系R中没有, 其余a, b; e, d; 做的运算在R中存在. 因此最后结果为a, b; e, d。

连接（join）：

两表笛卡尔积的结果比较庞大，实际应用中一般仅选取其中一部分的行，选取两表列之间满足一定条件的行，就是关系之间的连接。

根据连接条件的种类不同，关系之间的连接分为等值连接、大于连接、小于连接、自然连接。

条件是类似于"B列=D列"的"某列=某列"的条件，就是等值连接；

条件是"某列>某列"的，就是大于连接；

条件是"某列<某列"的，就是小于连接。

自然连接是不提出明确的连接条件，但"暗含"着一个条件，就是"列名相同的值也相同"。在自然连接的结果表中，往往还要合并相同列名的列。当对关系R和S进行自然连接时，要求R和S含有一个或者多个共有的属性。

举一个等值连接的例子：

关系R和S如下图所示：

对关系R、S按条件"R表的B列=S表的B列"进行连接的结果（等值连接）：

小于连接的结果（B<D）：

自然连接的结果（自然连接暗含的条件是R.B=S.B且R.C=S.C，因为R、S中有同名的2列B、C）：

多个条件之间可用"∧"表示"且"，即两边的条件必须同时成立。

如"C>4∧D>3"，表示"C列值>4，且D列值>3"，二者需同时满足。

用"∨"表示"或"，即两边的条件有一个成立即可。

例如"性别='女'∨年龄<20"表示"性别为'女'或者年龄在20岁以下"。
--------------------- 
作者：一骑走烟尘 
来源：CSDN 
原文：https://blog.csdn.net/zgcr654321/article/details/82077809 
版权声明：本文为博主原创文章，转载请附上博文链接！

本系列【T-SQL基础】主要是针对T-SQL基础的总结。

概述：

本篇主要是对集合运算中并集、交集、差集运算基础的总结。

集合运算包含三种：

　　1.并集运算

　　2.交集运算

　　3.差集运算

下面是集合运算的思维导图：

在阅读下面的章节时，我们可以先把环境准备好，以下的SQL脚本可以帮助大家创建数据库，创建表，插入数据。

下载脚本文件：TSQLFundamentals2008.zip

一、集合运算

1.集合运算

（1）对输入的两个集合或多集进行的运算。

（2）多集：由两个输入的查询生成的可能包含重复记录的中间结果集。

（3）T-SQL支持三种集合运算：并集（UNION）、交集（INTERSECT)、差集（EXCEPT）

2.语法

集合运算的基本格式：

输入的查询1

<集合运算符>

输入的查询2

[ORDER BY]

3.要求

（1）输入的查询不能包含ORDER BY字句；

（2）可以为整个集合运算结果选择性地增加一个ORDER BY字句；

（3）每个单独的查询可以包含所有逻辑查询处理阶段（处理控制排列顺序的ORDER BY字句）；

（4）两个查询 必须包含相同的列数；

（5）相应列必须具有兼容的数据类型。兼容个的数据类型：优先级较低的数据类型必须能隐式地转换为较高级的数据类型。比如输入的查询1的第一列为int类型，输入的查询2的第一列为float类型，则较低的数据类型int类型可以隐式地转换为较高级float类型。如果输入的查询1的第一列为char类型，输入的查询2的第一列为datetime类型，则会提示转换失败：从字符串转换日期和/或时间时，转换失败；

（6）集合运算结果中列名由输入的查询1决定，如果要为结果分配结果列，应该在输入的查询1中分配相应的别名；

（7）集合运算时，对行进行进行比较时，集合运算认为两个NULL相等；

（8）UNION支持DISTINCT和ALL。不能显示指定DISTINCT字句，如果不指定ALL，则默认使用DISTINCT；

（9）INTERSET和EXCEPT默认使用DISTINCT，不支持ALL。

二、UNION（并集）集合运算

1.并集的文氏图

并集：两个集合的并集是一个包含集合A和B中所有元素的集合。

图中阴影区域代表集合A与集合B的并集

2.UNION ALL集合运算

（1）假设Query1返回m行，Query2返回n行，则Query1 UNION ALL Query2返回（m+n）行；

（2）UNION ALL 不会删除重复行，所以它的结果就是多集，而不是真正的集合；

（3）相同的行在结果中可能出现多次。

3.UNION DISTINCT集合运算

（1）假设Query1返回m行，Query2返回n行，Query1和Query2有相同的h行，则Query1 UNION Query2返回（m+n-h）行；

（2）UNION 会删除重复行，所以它的结果就是集合；

（3）相同的行在结果中只出现一次。

（4）不能显示指定DISTINCT字句，如果不指定ALL，则默认使用DISTINCT。

（5）当Query1与Query2比较某行记录是否相等时，会认为取值为NULL的列是相等的列。

三、INTERSECT（交集）集合运算

1.交集的文氏图

交集：两个集合（记为集合A和集合B）的交集是由既属于A，也属于B的所有元素组成的集合。

图中阴影区域代表集合A与集合B的交集

2.INTERSECT DISTINCT集合运算

（1）假设Query1返回 m 行，Query2返回 n 行，Query1和Query2有相同的 h 行，则Query1 INTERSECT Query2返回 h 行；

（2）INTERSECT集合运算在逻辑上首先删除两个输入多集中的重复行（把多集变为集合），然后返回只在两个集合中都出现的行；

（3）INTERSECT 会删除重复行，所以它的结果就是集合；

（4）相同的行在结果中只出现一次。

（5）不能显示指定DISTINCT字句，如果不指定ALL，则默认使用DISTINCT。

（6）当Query1与Query2比较某行记录是否相等时，会认为取值为NULL的列是相等的列。

（7）用内联接或EXISTS谓词可以代替INTERSECT集合运算，但是必须对NULL进行处理，否则这两种方法对NULL值进行比较时，比较结果都是UNKNOWN，这样的行会被过滤掉。

3.INTERSECT ALL集合运算

（1）ANSI SQL支持带有ALL选项的INTERSECT集合运算，但SQL Server2008现在还没有实现这种运算。后面会提供一种用于T-SQL实现的替代方案；

（2）假设Query1返回 m 行，Query2返回 n 行，如果行R在Query1中出现了x次，在Query2中出现了y次，则行R应该在INTERSECT ALL运算之后出现minimum(x，y)次。

下面提供用于T-SQL实现的INTERSECT ALL集合运算：公用表表达式 + 排名函数

      WITH    INTERSECT_ALL          
      AS (
                SELECT   ROW_NUMBER() OVER ( PARTITION BY country, region, city ORDER BY ( SELECT
                                                              0
                                                              ) ) AS rownum ,
                        country ,
                        region ,
                        city
               FROM     HR.Employees
               INTERSECT
               SELECT   ROW_NUMBER() OVER ( PARTITION BY country, region, city ORDER BY ( SELECT
                                                              0
                                                              ) ) AS rownum ,
                        country ,
                        region ,
                        city
               FROM     Sales.Customers
             )
      SELECT  country ,
              region ,
              city
      FROM    INTERSECT_ALL

结果如下：

         

         

其中UK NULL London有四个重复行，

在排序函数的OVER字句中使用 ORDER BY ( SELECT <常量> )可以告诉SQL Server不必在意行的顺序。

四、EXCEPT（差集）集合运算

1.差集的文氏图

差集：两个集合（记为集合A和集合B）的由属于集合A，但不属于集合B的所有元素组成的集合。

图中阴影区域代表集合A与集合B的差集

2.EXCEPT DISTINCT集合运算

（1）假设Query1返回 m 行，Query2返回 n 行，Query1和Query2有相同的 h 行，则Query1 INTERSECT Query2返回 m - h 行,而Query2 INTERSECT Query1 返回 n - h 行

（2）EXCEPT集合运算在逻辑上先删除两个输入多集中的重复行（把多集转变成集合），然后返回只在第一个集合中出现，在第二个集合众不出现所有行。

（3）EXCEPT 会删除重复行，所以它的结果就是集合；

（4）EXCEPT是不对称的，差集的结果取决于两个查询的前后关系。

（5）相同的行在结果中只出现一次。

（6）不能显示指定DISTINCT字句，如果不指定ALL，则默认使用DISTINCT。

（7）当Query1与Query2比较某行记录是否相等时，会认为取值为NULL的列是相等的列。

（8）用左外联接或NOT EXISTS谓词可以代替INTERSECT集合运算，但是必须对NULL进行处理，否则这两种方法对NULL值进行比较时，比较结果都是UNKNOWN，这样的行会被过滤掉。

3.EXCEPT ALL集合运算

（1）ANSI SQL支持带有ALL选项的EXCEPT集合运算，但SQL Server2008现在还没有实现这种运算。后面会提供一种用于T-SQL实现的替代方案；

（2）假设Query1返回 m 行，Query2返回 n 行，如果行R在Query1中出现了x次，在Query2中出现了y次,且x>y，则行R应该在EXCEPT ALL运算之后出现 x - y 次。

下面提供用于T-SQL实现的EXCEPT ALL集合运算：公用表表达式 + 排名函数   

WITH    INTERSECT_ALL
AS (
　　　　　　　　　SELECT   ROW_NUMBER() OVER ( PARTITION BY country, region, city ORDER BY ( SELECT
                                                              0
                                                              ) ) AS rownum ,
                        country ,
                        region ,
                        city
               FROM     HR.Employees
               EXCEPT
               SELECT   ROW_NUMBER() OVER ( PARTITION BY country, region, city ORDER BY ( SELECT
                                                              0
                                                              ) ) AS rownum ,
                        country ,
                        region ,
                        city
               FROM     Sales.Customers
             )
SELECT  country ,
             region ,
             city
FROM    INTERSECT_ALL

结果如下：

           

五、集合运算的优先级

1.INTERSECT>UNION=EXCEPT

2.首先计算INTERSECT,然后从左到右的出现顺序依次处理优先级的相同的运算。

3.可以使用圆括号控制集合运算的优先级，它具有最高的优先级。

六、特殊处理

1.只有ORDER BY能够直接应用于集合运算的结果；

2.其他阶段如表运算符、WHERE、GROUP BY、HAVING等，不支持直接应用于集合运算的结果，这个时候可以使用表表达式来避开这一限制。如根据包含集合运算的查询定义个表表达式，然后在外部查询中对表表达式应用任何需要的逻辑查询处理；

3.ORDER BY字句不能直接应用于集合运算中的单个查询，这个时候可以TOP+ORDER BY字句+表表达式来避开这一限制。如定义一个基于该TOP查询的表表达式，然后通过一个使用这个表表达式的外部查询参与集合运算。　

七、练习题

1.写一个查询，返回在2008年1月有订单活动，而在2008年2月没有订单活动的客户和雇员。

期望结果：

方案一：EXCEPT

（1）先用查询1查询出2008年1月份有订单活动的客户和雇员

（2）用查询2查询2008年2月份客户的订单活动的客户和雇员

（3）用差集运算符查询2008年1月有订单活动而2008年2月没有订单活动的客户和雇员

SELECT  custid ,
        empid
FROM    Sales.Orders
WHERE   orderdate >= '20080101'
        AND orderdate < '20080201'
EXCEPT
SELECT  custid ,
        empid
FROM    Sales.Orders
WHERE   orderdate >= '20080201'
        AND orderdate < '20080301'

方案二：NOT EXISTS

必须保证custid，empid不能为null，才能用NOT EXISTS进行查询，如果custid或empid其中有null值存在，则不能用NOT EXISTS进行查询，因为比较NULL值的结果是UNKNOWN，这样的行用NOT EXISTS查询返回的子查询的行会被过滤掉，所以最后的外查询会多出NULL值的行，最后查询结果中会多出NULL值的行。

SELECT  custid , empid
FROM    Sales.Orders AS O1
WHERE   orderdate >= '20080101'
        AND orderdate < '20080201'
        AND NOT EXISTS ( SELECT *
                         FROM   Sales.Orders
                         WHERE  orderdate >= '20080201'
                                AND orderdate < '20080301'
                                AND custid = o1.custid
                                AND empid = o1.empid )
ORDER BY O1.custid , O1.empid

如果我往Sales.Orders表中插入两行数据：

插入cutid=NULL,empid=1,orderdate='20080101'

插入cutid=NULL,empid=1,orderdate='20080201'

用方案一查询出来结果为50行，会把cutid=NULL,empid=1的行过滤掉

用方案二查询出来结果为51行，不会把cutid=NULL,empid=1的行过滤掉

用下面的方案可以解决上面的问题，需要处理cutid=NULL,或者empid=null的情况。返回50行

SELECT  custid ,
        empid
FROM    Sales.Orders AS O1
WHERE   orderdate >= '20080101'
        AND orderdate < '20080201'
        AND NOT EXISTS ( SELECT *
                     FROM   Sales.Orders
                     WHERE  orderdate >= '20080201'
                            AND orderdate < '20080301'
                            AND ( isnull(custid,'') = isnull(o1.custid,'')
                                  AND isnull(empid,'') = isnull(o1.empid,'')
                                )
                            )

2.写一个查询，返回在2008年1月和在2008年2月都有订单活动的客户和雇员。

期望结果：

 

方案一：INTERSECT

（1）先用查询1查询出2008年1月份有订单活动的客户和雇员

（2）用查询2查询2008年2月份客户的订单活动的客户和雇员

（3）用交集运算符查询2008年1月和2008年2月都有订单活动的客户和雇员

SELECT  custid , empid
FROM    Sales.Orders
WHERE   orderdate >= '20080101'
        AND orderdate < '20080201'
INTERSECT
SELECT  custid ,
        empid
FROM    Sales.Orders
WHERE   orderdate >= '20080201'
        AND orderdate < '20080301'

方案二：EXISTS

必须保证custid，empid不能为null，才能用EXISTS进行查询，如果custid或empid其中有null值存在，则不能用EXISTS进行查询，因为比较NULL值的结果是UNKNOWN，这样的行用EXISTS查询返回的子查询的行会被过滤掉，所以最后的外查询会少NULL值的行，最后查询结果中会少NULL值的行。

SELECT  custid ,
        empid
FROM    Sales.Orders AS O1
WHERE   orderdate >= '20080101'
        AND orderdate < '20080201'
        AND EXISTS ( SELECT *
                     FROM   Sales.Orders
                     WHERE  orderdate >= '20080201'
                            AND orderdate < '20080301'
                            AND custid = o1.custid
                            AND empid = o1.empid )
ORDER BY O1.custid , O1.empid

如果我往Sales.Orders表中插入两行数据：

插入cutid=NULL,empid=1,orderdate='20080101'

插入cutid=NULL,empid=1,orderdate='20080201'

用方案一查询出来结果为6行，不会把cutid=NULL,empid=1的行过滤掉

用方案二查询出来结果为5行，会把cutid=NULL,empid=1的行过滤掉

 

用下面的方案可以解决上面的问题，需要处理cutid=NULL,或者empid=null的情况。返回6行。

SELECT  custid ,
        empid
FROM    Sales.Orders AS O1
WHERE   orderdate >= '20080101'
        AND orderdate < '20080201'
        AND EXISTS ( SELECT *
                     FROM   Sales.Orders
                     WHERE  orderdate >= '20080201'
                            AND orderdate < '20080301'
                            AND ( isnull(custid,'') = isnull(o1.custid,'')
                                  AND isnull(empid,'') = isnull(o1.empid,'')
                                )                            
                            )

3.写一个查询，返回在2008年1月和在2008年2月都有订单活动，而在2007年没有订单活动的客户和雇员

期望结果：

方案一：INTERSECT + EXCEPT

SELECT  custid ,
        empid
FROM    Sales.Orders
WHERE   orderdate >= '20080101'
        AND orderdate < '20080201'
INTERSECT
SELECT  custid ,
        empid
FROM    Sales.Orders
WHERE   orderdate >= '20080201'
        AND orderdate < '20080301'
EXCEPT
SELECT  custid ,
        empid
FROM    Sales.Orders
WHERE   orderdate >= '20070101'
        AND orderdate < '20080101'

方案二：EXISTS + NOT EXISTS

SELECT  custid , empid
FROM    Sales.Orders AS O1
WHERE   orderdate >= '20080101'

参考资料：

《SQL2008技术内幕：T-SQL语言基础》

 原文来自：详解SQL集合运算

作　　者： Jackson0714 
出　　处：http://www.cnblogs.com/jackson0714/ 
关于作者：专注于微软平台的项目开发。如有问题或建议，请多多赐教！ 
版权声明：本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文链接。 
特此声明：所有评论和私信都会在第一时间回复。也欢迎园子的大大们指正错误，共同进步。或者直接私信我 
声援博主：如果您觉得文章对您有帮助，可以点击文章右下角【推荐】一下。您的鼓励是作者坚持原创和持续写作的最大动力！