SQL Server温故系列(3)：SQL 子查询 & 公用表表达式 CTE

时间  2020-05-13
标签 sql server 温故 系列 查询 公用 表达式 cte 栏目 SQL 繁體版
原文   原文链接

<h2 id="1">一、子查询 Subqueries</h2> 子查询是一个嵌套在 SELECT、INSERT、UPDATE 或 DELETE 语句或其余子查询中的查询。通俗来说，子查询就是嵌套在大“查询”中的小查询。子查询也称为内部查询或内部选择，而包含子查询的语句也称为外部查询或外部选择。html

从概念上说，子查询结果会代入外部查询（尽管这不必定是 SQL Server 实际处理带有子查询的 T-SQL 语句的方式）。因此子查询会在其父查询以前执行，以即可以将内部查询的结果传递给外部查询。程序员

比较常见的子查询有：单行子查询、多行子查询、相关子查询、嵌套子查询等。然而并无一种泾渭分明的子查询分类方法，换句话说，有可能某个子查询既是多行子查询，也是相关子查询，同时仍是嵌套子查询。sql

<h4 id="11">1.一、单行子查询</h4> 顾名思义，单行子查询就是只查询一行数据的内部查询。若是单行子查询仅返回单一值，就能够称之为**标量子查询**。标量子查询也是最多见的单行子查询。示例以下：express

-- 查询年龄最小的学生
SELECT * FROM T_Students WHERE Birthday = (SELECT MAX(Birthday) FROM T_Students);

-- 第 1 次课程 1 考试的成绩高于学生 12 的成绩
SELECT StudentId,Scores FROM T_ExamResults 
WHERE Counts = 1 AND CourseId = 1 AND Scores > (
    SELECT Scores FROM T_ExamResults WHERE Counts = 1 AND CourseId = 1 AND StudentId = 12);

-- 历次课程 1 考试的平均分高于学生 12 的成绩
SELECT StudentId,AVG(Scores) AvgScore,COUNT(1) ExamCount FROM T_ExamResults 
WHERE CourseId = 1 
GROUP BY StudentId 
HAVING AVG(Scores) > (SELECT AVG(Scores) FROM T_ExamResults WHERE CourseId = 1 AND StudentId = 12);

<h4 id="12">1.二、多行子查询</h4> 相较于单行子查询，多行子查询就是会返回多行的内部查询。示例以下：oracle

-- 查询有女生的班级里的学生
SELECT * FROM T_Students WHERE ClassId IN(SELECT ClassId FROM T_Students WHERE Gender = 0);

-- 查询有女生的班级以外的全部班级的学生
SELECT * FROM T_Students WHERE ClassId NOT IN(SELECT ClassId FROM T_Students WHERE Gender = 0);

-- 查询有 2003 年及之后出生的学生的班级
SELECT * FROM T_Classes WHERE Id IN(SELECT ClassId FROM T_Students WHERE Birthday >= '2003-01-01');

<h4 id="13">1.三、相关子查询</h4> 相关子查询是指查询条件引用了外部查询中字段的内部查询。相反的，若是外部查询的字段没有出如今内部查询的条件中即为非相关子查询。相关子查询的内部查询得依靠外部查询得到值，这意味着内部查询是重复执行的，为外部查询选择的每一行都要执行一次，所以相关子查询也被称之为重复子查询。示例以下：性能

-- 查询在三(1)班和三(2)班的学生
SELECT * FROM T_Students t1 WHERE EXISTS(
    SELECT Id FROM T_Classes t2 WHERE t2.Id = t1.ClassId AND t2.Name IN('三(1)班','三(2)班'));

-- 查询不在三(1)班和三(2)班的学生
SELECT * FROM T_Students t1 WHERE NOT EXISTS(
    SELECT Id FROM T_Classes t2 WHERE t2.Id = t1.ClassId AND t2.Name IN('三(1)班','三(2)班'));

-- 查询第 1 次考试的课程及参加了的学生
SELECT (SELECT t2.Name FROM T_Courses t2 WHERE t2.Id=t1.CourseId) CourseName,
       (SELECT t3.Name FROM T_Students t3 WHERE t3.Id=t1.StudentId) StudentName 
FROM T_ExamResults t1 WHERE t1.Counts = 1;

<h4 id="14">1.四、嵌套子查询</h4> 嵌套子查询是指查询内部嵌套一个或多个子查询的内部查询。一个 T-SQL 语句中能够嵌套任意数量的子查询，尽管一般来讲没有这种必要。示例以下：code

-- 查询参加了第 1 次课程 1 考试的学生
SELECT * FROM T_Students t3 WHERE t3.Id IN(
    SELECT t2.StudentId FROM T_ExamResults t2 WHERE t2.Counts = 1 AND t2.CourseId = (
        SELECT t1.Id FROM T_Courses t1 WHERE t1.Name = '英语'));

-- 查询西湖区所在的城市的全部学生
SELECT t3.* FROM T_Students t3 WHERE SUBSTRING(t3.Code,2,6) IN(
    SELECT t2.Code FROM T_Districts t2 WHERE t2.ParentId = (
        SELECT t1.ParentId FROM T_Districts t1 WHERE t1.Name = '西湖区'));

<h4 id="15">1.五、子查询小结及性能问题</h4> 上文主要讲述了查询语句中的子查询，其实在增删改语句中也同样可以使用子查询。任何能使用表达式的地方均可以使用子查询，只要它返回的是单个值便可。不少包含子查询的语句均可以改写成链接查询。示例以下：orm

-- 更新语句（子查询写法）
UPDATE T_Students SET Remark='考过满分' 
WHERE Id IN(SELECT t.StudentId FROM T_ExamResults t WHERE t.Scores = 100);

-- 更新语句（链接写法）
UPDATE T_Students SET Remark='考过满分' 
FROM T_Students t1 JOIN T_ExamResults t2 ON t1.Id = t2.StudentId AND t2.Scores = 100;

-- 删除语句（子查询写法）
DELETE T_ExamResults WHERE Counts = 10 AND StudentId = (
    SELECT t.Id FROM T_Students t WHERE t.Code = 'S330104010');

-- 删除语句（链接写法）
DELETE T_ExamResults FROM T_ExamResults t1 
JOIN T_Students t2 ON t1.StudentId = t2.Id AND t1.Counts = 10 AND t2.Code = 'S330104010';

在 T-SQL 中，包含子查询的语句和语义上等效的不包含子查询的语句在性能上一般是没有差异的。但在一些须要为外部查询的每一个结果都执行内部查询的状况下，使用链接写法会产生更好的性能（若是数据不多，这种差异也很难体现出来），如某些非必须的相关子查询。示例以下：server

-- 查询全部学生第 1 次课程 2 考试的成绩（子查询写法）
SELECT (SELECT t2.Name FROM T_Students t2 WHERE t2.Id = t1.StudentId) StudentName,Scores 
FROM T_ExamResults t1 
WHERE t1.Counts = 1 AND t1.CourseId = 2;

-- 查询全部学生第 1 次课程 2 考试的成绩（链接写法）
SELECT t2.Name StudentName,Scores 
FROM T_ExamResults t1 
JOIN T_Students t2 ON t1.StudentId=t2.Id 
WHERE t1.Counts = 1 AND t1.CourseId = 2;

<h2 id="2">二、公用表表达式 CTE</h2> 在 T-SQL 中，WITH 语句用于指定临时命名的结果集，这些结果集被称为公用表表达式(Common Table Expression，简称 CTE)。基本语法以下：htm

WITH cte-name (column-names) AS (cte-query) [,...]

参数释义以下：

  • cte-name 表明公用表表达式的有效标识符。相似于子查询的别名，在一个语句中不能出现重复的 cte-name，但能够与 CTE 引用的基表名称相同。引用 CTE 中的任何字段都得用 cte-name 来限定，而不能使用字段本来所属的基表来限定。
  • column-names 表明公用表表达式的字段名列表，只要 column-name 的个数与 cte-query 中定义字段数相同便可。若是为 cte-query 中的全部字段都提供了不一样的名称，那么 column-names 就是可选的了（通常你们都这么干，毕竟有谁会喜欢不必的繁琐呢？）。
  • cte-query 表明一个公用表表达式的查询语句，能够是任意合法的 SELECT 语句。

<h4 id="21">2.一、普通公用表表达式</h4> CTE 可在单条 INSERT、DELETE、UPDATE 或 SELECT 语句的执行范围内定义。

CTE & INSERT 如要把 2000 年以前出生的女生信息插入到好学生表中，用 CTE 定义女生数据，示例以下：

WITH temp AS(
    SELECT t.Id,t.Name,t.Gender,t.Birthday FROM T_Students t WHERE t.Gender = 0
)
INSERT INTO T_GoodStudents(Id,Name,Gender,Birthday) 
SELECT * FROM temp WHERE Birthday < '2000-01-01';

CTE & DELETE 如要把姓名和性别都是空的学生信息删除，用 CTE 定义姓名为空的数据，示例以下：

WITH t AS(
    SELECT t.* FROM T_GoodStudents t WHERE t.Name IS NULL
)
DELETE FROM t WHERE t.Gender IS NULL;

CTE & UPDATE 如要把历次语文成绩的平均分更新到学生备注中，用 CTE 定义学平生均分数据，示例以下：

WITH temp AS(
    SELECT t.StudentId,t.CourseId,AVG(t.Scores) AvgScore 
    FROM T_ExamResults t 
    GROUP BY t.StudentId,t.CourseId
)
UPDATE T_Students SET Remark = t1.AvgScore 
FROM temp t1 
JOIN T_Courses t2 ON t1.CourseId = t2.Id 
WHERE T_Students.Id = t1.StudentId AND t2.Name = '语文';

CTE & SELECT（屡次引用同一个 CTE）如要查询前 3 次考试的总成绩及平均成绩，用 CTE 定义各次的成绩数据，示例以下：

WITH temp AS(
    SELECT t.StudentId,t.Counts,SUM(t.Scores) SumScore 
    FROM T_ExamResults t 
    WHERE t.Counts IN(1,2,3) 
    GROUP BY t.StudentId,t.Counts
)
SELECT t1.Code,t1.Name,
    t2.SumScore FirstSumScore,t3.SumScore SecondSumScore,t4.SumScore ThirdSumScore,
    (t2.SumScore + t3.SumScore + t4.SumScore)/3 AvgSumScore 
FROM T_Students t1 
JOIN temp t2 ON t1.Id = t2.StudentId AND t2.Counts = 1 
JOIN temp t3 ON t1.Id = t3.StudentId AND t3.Counts = 2 
JOIN temp t4 ON t1.Id = t4.StudentId AND t4.Counts = 3;

CTE & SELECT（一个 WITH 定义多个 CTE）如要查询男生们前 3 次课程 1 的考试成绩，用 CTE 定义各次的成绩数据，示例以下：

WITH t1 AS(
    SELECT t.StudentId,t.Scores FROM T_ExamResults t WHERE t.CourseId = 1 AND t.Counts = 1
),
t2 AS(
    SELECT t.StudentId,t.Scores FROM T_ExamResults t WHERE t.CourseId = 1 AND t.Counts = 2
),
t3 AS(
    SELECT t.StudentId,t.Scores FROM T_ExamResults t WHERE t.CourseId = 1 AND t.Counts = 3
)
SELECT t4.Code,t4.Name,t1.Scores FirstScore,t2.Scores SecondScore,t3.Scores ThirdScore 
FROM T_Students t4 
JOIN t1 ON t4.Id = t1.StudentId 
JOIN t2 ON t4.Id = t2.StudentId 
JOIN t3 ON t4.Id = t3.StudentId 
WHERE t4.Gender = 1;

<h4 id="22">2.二、递归公用表表达式</h4> CTE 能够包含对自身的引用，这种表达式被称为递归公用表表达式。一个递归 CTE 中至少要包含两个查询定义，一个定位点成员和一个递归成员，递归成员的 FROM 子句只能引用一次 CTE。另外，定位点成员和递归成员两者的字段数必须相同，字段的数据类型也须要保持一致。

从上到下递归，如要查询浙江省及如下各级别的行政区，示例以下：

WITH temp AS(
    SELECT t1.Id,t1.Name FROM T_Districts t1 WHERE t1.Code = '330000' 
    UNION ALL 
    SELECT t2.Id,t2.Name FROM T_Districts t2,temp t1 WHERE t2.ParentId = t1.Id 
)
SELECT temp.Name FROM temp;

从下到上递归，如要查询西湖区及其全部上级行政区，示例以下：

WITH temp AS(
    SELECT t1.ParentId,t1.Name FROM T_Districts t1 WHERE t1.Code = '330106' 
    UNION ALL 
    SELECT t2.ParentId,t2.Name FROM T_Districts t2,temp t1 WHERE t2.Id = t1.ParentId 
)
SELECT temp.Name FROM temp;

能够定义多个定位点成员和递归成员，但必须将全部定位点成员查询定义置于第一个递归成员定义以前。在起点成员之间能够用任意集合运算符，而在最后一个定位点成员和第一个递归成员之间，以及多个递归成员之间，必须用 UNION ALL 来链接。示例以下（查询卢小妹的全部祖先）：

WITH temp(Id) AS(
    SELECT t1.Father FROM T_Persons t1 WHERE t1.Name = '卢小妹' 
    UNION 
    SELECT t2.Mother FROM T_Persons t2 WHERE t2.Name = '卢小妹' 
    UNION ALL 
    SELECT t3.Father FROM T_Persons t3,temp WHERE t3.Id = temp.Id 
    UNION ALL 
    SELECT t4.Mother FROM T_Persons t4,temp WHERE t4.Id = temp.Id 
)
SELECT t1.Id,t1.Name,t1.Father,t1.Mother 
FROM T_Persons t1,temp 
WHERE t1.Id=temp.Id;

递归运算必定要有出口，不然就是死循环了！SQL Server 提供了一个 MAXRECURSION 提示来限制递归级数，以防止出现无限循环。但我我的以为应该尽量的经过 WHERE 条件或业务逻辑来定义更合理的出口。例如要显示的限定只返回某一递归级别的数据，示例以下（查询浙江省下全部县一级的行政区）：

WITH temp AS(
    SELECT t1.Id,t1.Name,t1.Code,t1.Level 
    FROM T_Districts t1 
    WHERE t1.Code = '330000' 
    UNION ALL 
    SELECT t2.Id,t2.Name,t2.Code,t2.Level 
    FROM T_Districts t2,temp 
    WHERE t2.ParentId = temp.Id
)
SELECT temp.Code,temp.Name,temp.Level FROM temp WHERE temp.Level = 3;

尽管看上去很简单，但在实际开发中极可能并无相似 Level 这种标识级别的字段可用。若是是这样，那咱们还能够经过递归成员的递归次数来实现一样的过滤效果。示例以下：

WITH temp AS(
    SELECT t1.Id,t1.Name,t1.Code,t1.Level,0 Step 
    FROM T_Districts t1 
    WHERE t1.Code = '330000' 
    UNION ALL 
    SELECT t2.Id,t2.Name,t2.Code,t2.Level,temp.Step + 1 
    FROM T_Districts t2,temp 
    WHERE t2.ParentId = temp.Id
)
SELECT temp.Code,temp.Name,temp.Level FROM temp WHERE temp.Step = 2;

<h2 id="3">三、本文小结</h2> 本文主要介绍了 T-SQL 中最多见的几种子查询以及公用表表达式 CTE。本文还专门说明了递归 CTE，它能够实现相似于 PL/SQL 中的 CONNECT BY 层次查询。

本文参考连接：

去导航目录篇下载建立本系列博文通用库表及数据的 SQL 语句

本文连接：http://www.cnblogs.com/hanzongze/p/tsql-subquery.html 版权声明：本文为博客园博主 韩宗泽 原创，做者保留署名权！欢迎经过转载、演绎或其它传播方式来使用本文，但必须在明显位置给出做者署名和本文连接！我的博客，能力有限，如有不当之处，敬请批评指正，谢谢！

原文出处：https://www.cnblogs.com/hanzongze/p/tsql-subquery.html

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程