SQLServer 高级SQL特性

高级SQL特性概述

SQLServer提供了丰富的高级SQL特性，这些特性可以帮助开发者编写更高效、更简洁的SQL代码，处理复杂的数据查询和操作。本文将介绍SQLServer中常用的高级SQL特性，包括子查询、公共表表达式（CTE）、窗口函数、递归查询、透视和逆透视、MERGE语句、批量操作、动态SQL、JSON支持等。

子查询

子查询是嵌套在其他SQL语句中的SELECT语句，用于从一个或多个表中检索数据。子查询可以嵌套在SELECT、INSERT、UPDATE、DELETE语句或其他子查询中。

基本语法

sql

SELECT column1, column2, ...
FROM table1
WHERE column1 IN (SELECT column1 FROM table2 WHERE condition);

子查询类型

标量子查询

标量子查询返回单个值，通常用于比较操作。

示例：

sql

-- 查询工资高于平均工资的员工
SELECT EmployeeName, Salary 
FROM Employees 
WHERE Salary > (SELECT AVG(Salary) FROM Employees);

行子查询

行子查询返回一行数据，通常用于比较多个列。

示例：

sql

-- 查询与张三同部门且同工资的员工
SELECT EmployeeName, DepartmentID, Salary 
FROM Employees 
WHERE (DepartmentID, Salary) = (SELECT DepartmentID, Salary FROM Employees WHERE EmployeeName = '张三');

表子查询

表子查询返回多行多列数据，通常用于FROM子句或JOIN操作。

示例：

sql

-- 查询每个部门工资最高的员工
SELECT e.EmployeeName, e.DepartmentID, e.Salary 
FROM Employees e 
JOIN (
    SELECT DepartmentID, MAX(Salary) AS MaxSalary 
    FROM Employees 
    GROUP BY DepartmentID
) t ON e.DepartmentID = t.DepartmentID AND e.Salary = t.MaxSalary;

子查询最佳实践

尽量使用JOIN代替相关子查询，提高查询性能
对于复杂子查询，考虑使用CTE或临时表
限制子查询的返回结果集大小
使用EXISTS或NOT EXISTS代替IN或NOT IN，提高查询性能

公共表表达式（CTE）

公共表表达式（CTE）是一个临时命名的结果集，仅在单个SQL语句中有效。CTE可以提高SQL代码的可读性和可维护性，特别适合处理复杂的查询。

基本语法

sql

WITH cte_name (column1, column2, ...)
AS (
    SELECT column1, column2, ...
    FROM table_name
    WHERE condition
)
SELECT * FROM cte_name;

示例

示例1：简单CTE

sql

-- 使用CTE查询每个部门的平均工资
WITH AvgSalaryByDept AS (
    SELECT DepartmentID, AVG(Salary) AS AvgSalary 
    FROM Employees 
    GROUP BY DepartmentID
)
SELECT d.DepartmentName, a.AvgSalary 
FROM Departments d 
JOIN AvgSalaryByDept a ON d.DepartmentID = a.DepartmentID;

示例2：多级CTE

sql

-- 使用多级CTE查询工资高于部门平均工资的员工
WITH AvgSalaryByDept AS (
    SELECT DepartmentID, AVG(Salary) AS AvgSalary 
    FROM Employees 
    GROUP BY DepartmentID
),
HighSalaryEmployees AS (
    SELECT e.EmployeeName, e.DepartmentID, e.Salary, a.AvgSalary 
    FROM Employees e 
    JOIN AvgSalaryByDept a ON e.DepartmentID = a.DepartmentID 
    WHERE e.Salary > a.AvgSalary
)
SELECT d.DepartmentName, h.EmployeeName, h.Salary, h.AvgSalary 
FROM Departments d 
JOIN HighSalaryEmployees h ON d.DepartmentID = h.DepartmentID;

CTE vs 临时表

特性	CTE	临时表
作用域	单个SQL语句	当前会话
性能	通常更好，因为不需要写入磁盘	可能需要写入磁盘，性能较低
可读性	更好，代码更简洁	较差，需要额外的CREATE和DROP语句
递归支持	支持递归查询	不支持递归查询

窗口函数

窗口函数是对一组行（称为窗口）执行计算的函数，返回多个结果。窗口函数可以用于计算排名、累计值、移动平均值等，而不需要使用GROUP BY子句。

基本语法

sql

SELECT column1, column2, ...
       window_function(expression) OVER (
           [PARTITION BY column1, column2, ...]
           [ORDER BY column1, column2, ... ASC|DESC]
           [ROWS/RANGE BETWEEN frame_start AND frame_end]
       ) AS result_column
FROM table_name;

常用窗口函数

排名函数

ROW_NUMBER()：为每一行分配一个唯一的连续整数
RANK()：为每一行分配一个排名，相同值的行具有相同的排名，后续排名会跳过
DENSE_RANK()：为每一行分配一个排名，相同值的行具有相同的排名，后续排名不会跳过
NTILE(n)：将结果集分为n个桶，为每一行分配一个桶号

示例：

sql

-- 使用排名函数查询员工工资排名
SELECT EmployeeName, DepartmentID, Salary,
       ROW_NUMBER() OVER (ORDER BY Salary DESC) AS RowNum,
       RANK() OVER (ORDER BY Salary DESC) AS Rank,
       DENSE_RANK() OVER (ORDER BY Salary DESC) AS DenseRank,
       NTILE(3) OVER (ORDER BY Salary DESC) AS Bucket
FROM Employees;

-- 按部门查询员工工资排名
SELECT EmployeeName, DepartmentID, Salary,
       ROW_NUMBER() OVER (PARTITION BY DepartmentID ORDER BY Salary DESC) AS DeptRowNum,
       RANK() OVER (PARTITION BY DepartmentID ORDER BY Salary DESC) AS DeptRank
FROM Employees;

聚合函数

可以将聚合函数作为窗口函数使用，计算窗口内的聚合值。

示例：

sql

-- 使用窗口聚合函数查询累计工资
SELECT EmployeeName, DepartmentID, Salary,
       SUM(Salary) OVER (ORDER BY EmployeeID) AS CumulativeSalary,
       SUM(Salary) OVER (PARTITION BY DepartmentID ORDER BY EmployeeID) AS DeptCumulativeSalary,
       AVG(Salary) OVER (ORDER BY EmployeeID ROWS BETWEEN 2 PRECEDING AND CURRENT ROW) AS MovingAvg
FROM Employees;

偏移函数

LAG()：返回当前行之前指定行数的行的值
LEAD()：返回当前行之后指定行数的行的值
FIRST_VALUE()：返回窗口内的第一行的值
LAST_VALUE()：返回窗口内的最后一行的值

示例：

sql

-- 使用偏移函数查询员工工资变化
SELECT EmployeeName, DepartmentID, HireDate, Salary,
       LAG(Salary, 1, 0) OVER (PARTITION BY DepartmentID ORDER BY HireDate) AS PrevSalary,
       LEAD(Salary, 1, 0) OVER (PARTITION BY DepartmentID ORDER BY HireDate) AS NextSalary,
       Salary - LAG(Salary, 1, 0) OVER (PARTITION BY DepartmentID ORDER BY HireDate) AS SalaryChange,
       FIRST_VALUE(Salary) OVER (PARTITION BY DepartmentID ORDER BY HireDate) AS FirstDeptSalary,
       LAST_VALUE(Salary) OVER (PARTITION BY DepartmentID ORDER BY HireDate ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING) AS LastDeptSalary
FROM Employees;

窗口函数最佳实践

合理使用PARTITION BY子句，减少窗口大小
对于大数据集，考虑使用ROWS/RANGE子句限制窗口大小
避免在窗口函数中使用复杂表达式
优先使用内置窗口函数，而不是自定义函数

递归查询

递归查询是一种特殊的CTE，用于处理具有层次结构或递归关系的数据，如组织结构、产品分类、树形结构等。

基本语法

sql

WITH recursive_cte (column1, column2, ...)
AS (
    -- 锚点成员：初始查询，返回基础结果集
    SELECT column1, column2, ...
    FROM table_name
    WHERE condition
    UNION ALL
    -- 递归成员：引用CTE本身，返回递归结果集
    SELECT t.column1, t.column2, ...
    FROM table_name t
    JOIN recursive_cte r ON t.parent_id = r.child_id
    WHERE condition
)
SELECT * FROM recursive_cte;

示例

示例1：组织结构查询

假设我们有一个组织结构表，包含员工ID、员工姓名和上级ID：

sql

CREATE TABLE Organization (
    EmployeeID INT PRIMARY KEY,
    EmployeeName VARCHAR(50) NOT NULL,
    ManagerID INT NULL
);

INSERT INTO Organization VALUES
(1, 'CEO', NULL),
(2, 'CTO', 1),
(3, 'CFO', 1),
(4, '开发经理', 2),
(5, '测试经理', 2),
(6, '财务经理', 3),
(7, '开发工程师1', 4),
(8, '开发工程师2', 4),
(9, '测试工程师1', 5),
(10, '财务专员1', 6);

-- 查询所有员工及其层级关系
WITH OrgHierarchy AS (
    -- 锚点成员：查询CEO
    SELECT EmployeeID, EmployeeName, ManagerID, 1 AS Level, CAST(EmployeeName AS VARCHAR(MAX)) AS Path
    FROM Organization
    WHERE ManagerID IS NULL
    UNION ALL
    -- 递归成员：查询下属
    SELECT o.EmployeeID, o.EmployeeName, o.ManagerID, oh.Level + 1 AS Level, CAST(oh.Path + ' > ' + o.EmployeeName AS VARCHAR(MAX)) AS Path
    FROM Organization o
    JOIN OrgHierarchy oh ON o.ManagerID = oh.EmployeeID
)
SELECT * FROM OrgHierarchy ORDER BY Path;

示例2：计算斐波那契数列

sql

-- 计算前10个斐波那契数
WITH Fibonacci AS (
    SELECT 1 AS N, 0 AS Previous, 1 AS Current
    UNION ALL
    SELECT N + 1, Current, Previous + Current
    FROM Fibonacci
    WHERE N < 10
)
SELECT N, Current AS FibonacciNumber FROM Fibonacci;

递归查询最佳实践

始终使用锚点成员和递归成员
使用UNION ALL而不是UNION，提高性能
设置MAXRECURSION选项，防止无限递归
对于大数据集，考虑使用迭代方法替代递归查询

透视和逆透视

透视（PIVOT）用于将行数据转换为列数据，逆透视（UNPIVOT）用于将列数据转换为行数据。这两个操作通常用于生成报表或数据分析。

透视（PIVOT）

基本语法

sql

SELECT column1, column2, ...
FROM (
    SELECT column1, column2, pivot_column, value_column
    FROM table_name
    WHERE condition
) AS SourceTable
PIVOT (
    aggregate_function(value_column)
    FOR pivot_column IN (value1, value2, ...)
) AS PivotTable;

示例：

sql

-- 按部门和月份透视销售数据
SELECT DepartmentID, [1] AS Jan, [2] AS Feb, [3] AS Mar, [4] AS Apr, [5] AS May, [6] AS Jun
FROM (
    SELECT DepartmentID, MONTH(SalesDate) AS Month, Amount
    FROM Sales
    WHERE YEAR(SalesDate) = 2023
) AS SourceTable
PIVOT (
    SUM(Amount)
    FOR Month IN ([1], [2], [3], [4], [5], [6])
) AS PivotTable;

逆透视（UNPIVOT）

基本语法

sql

SELECT column1, column2, pivot_column, value_column
FROM PivotTable
UNPIVOT (
    value_column FOR pivot_column IN (value1, value2, ...)
) AS UnpivotTable;

示例：

sql

-- 创建透视表
CREATE TABLE MonthlySales (
    DepartmentID INT,
    Jan DECIMAL(10,2),
    Feb DECIMAL(10,2),
    Mar DECIMAL(10,2)
);

INSERT INTO MonthlySales VALUES
(1, 10000, 12000, 15000),
(2, 8000, 9000, 11000);

-- 逆透视月度销售数据
SELECT DepartmentID, Month, Amount
FROM MonthlySales
UNPIVOT (
    Amount FOR Month IN (Jan, Feb, Mar)
) AS UnpivotTable;

MERGE语句

MERGE语句用于合并数据，可以同时执行INSERT、UPDATE和DELETE操作，根据源数据和目标数据的匹配情况执行不同的操作。

基本语法

sql

MERGE target_table AS target
USING source_table AS source
ON (target.key_column = source.key_column)
WHEN MATCHED AND condition THEN
    UPDATE SET target.column1 = source.column1, target.column2 = source.column2, ...
WHEN NOT MATCHED BY TARGET THEN
    INSERT (column1, column2, ...) VALUES (source.column1, source.column2, ...)
WHEN NOT MATCHED BY SOURCE AND condition THEN
    DELETE;

示例

示例：同步产品库存数据

sql

-- 目标表：产品库存
CREATE TABLE ProductInventory (
    ProductID INT PRIMARY KEY,
    ProductName VARCHAR(50) NOT NULL,
    Stock INT NOT NULL,
    LastUpdated DATETIME NOT NULL
);

-- 源表：新的库存数据
CREATE TABLE NewInventory (
    ProductID INT PRIMARY KEY,
    ProductName VARCHAR(50) NOT NULL,
    Stock INT NOT NULL
);

-- 插入初始数据
INSERT INTO ProductInventory VALUES
(1, '产品1', 100, GETDATE()),
(2, '产品2', 50, GETDATE()),
(3, '产品3', 20, GETDATE());

INSERT INTO NewInventory VALUES
(1, '产品1', 120),
(2, '产品2', 45),
(4, '产品4', 80);

-- 使用MERGE同步库存数据
MERGE ProductInventory AS target
USING NewInventory AS source
ON (target.ProductID = source.ProductID)
WHEN MATCHED THEN
    UPDATE SET target.Stock = source.Stock, target.LastUpdated = GETDATE()
WHEN NOT MATCHED BY TARGET THEN
    INSERT (ProductID, ProductName, Stock, LastUpdated) 
    VALUES (source.ProductID, source.ProductName, source.Stock, GETDATE())
WHEN NOT MATCHED BY SOURCE THEN
    DELETE;

-- 查询合并结果
SELECT * FROM ProductInventory;

MERGE最佳实践

始终使用ON子句指定唯一键或主键
避免在MERGE语句中使用复杂条件
使用OUTPUT子句捕获MERGE操作的结果
对于大数据量，考虑分批处理

动态SQL

动态SQL是指在运行时构建和执行的SQL语句，通常用于处理不确定的查询条件或表名。

基本语法

sql

-- 使用EXEC或sp_executesql执行动态SQL
DECLARE @sql NVARCHAR(MAX);
SET @sql = N'SELECT * FROM Employees WHERE DepartmentID = @DeptID';
EXEC sp_executesql @sql, N'@DeptID INT', @DeptID = 1;

示例

示例1：动态查询表数据

sql

-- 动态查询指定表的数据
DECLARE @TableName NVARCHAR(50) = N'Employees';
DECLARE @sql NVARCHAR(MAX);

SET @sql = N'SELECT TOP 10 * FROM ' + QUOTENAME(@TableName);
EXEC sp_executesql @sql;

示例2：动态搜索

sql

-- 动态搜索员工信息
DECLARE @EmployeeName NVARCHAR(50) = N'张%';
DECLARE @DepartmentID INT = NULL;
DECLARE @MinSalary DECIMAL(10,2) = 5000;
DECLARE @sql NVARCHAR(MAX);

SET @sql = N'SELECT EmployeeName, DepartmentID, Salary FROM Employees WHERE 1=1';

IF @EmployeeName IS NOT NULL
    SET @sql = @sql + N' AND EmployeeName LIKE @EmployeeName';

IF @DepartmentID IS NOT NULL
    SET @sql = @sql + N' AND DepartmentID = @DepartmentID';

IF @MinSalary IS NOT NULL
    SET @sql = @sql + N' AND Salary >= @MinSalary';

EXEC sp_executesql @sql, 
    N'@EmployeeName NVARCHAR(50), @DepartmentID INT, @MinSalary DECIMAL(10,2)',
    @EmployeeName = @EmployeeName, @DepartmentID = @DepartmentID, @MinSalary = @MinSalary;

动态SQL最佳实践

使用sp_executesql代替EXEC，提高性能和安全性
使用QUOTENAME函数处理对象名，防止SQL注入
限制动态SQL的复杂度
对输入参数进行验证和过滤
避免在循环中执行动态SQL

JSON支持

SQLServer 2016及以上版本提供了强大的JSON支持，可以解析、生成、查询和修改JSON数据。

JSON函数

生成JSON

FOR JSON AUTO：根据查询结果自动生成JSON格式
FOR JSON PATH：使用路径表达式自定义JSON格式
FOR JSON ROOT：为JSON添加根节点

示例：

sql

-- 使用FOR JSON AUTO生成JSON
SELECT EmployeeID, EmployeeName, DepartmentID, Salary
FROM Employees
WHERE DepartmentID = 1
FOR JSON AUTO;

-- 使用FOR JSON PATH生成自定义JSON
SELECT EmployeeID AS id, EmployeeName AS name, DepartmentID AS deptId, Salary AS salary
FROM Employees
WHERE DepartmentID = 1
FOR JSON PATH, ROOT('employees');

解析JSON

OPENJSON：将JSON字符串转换为表格格式
JSON_VALUE：从JSON字符串中提取标量值
JSON_QUERY：从JSON字符串中提取对象或数组
JSON_MODIFY：修改JSON字符串中的值

示例：

sql

-- 使用OPENJSON解析JSON
DECLARE @json NVARCHAR(MAX) = N'[
    {"id": 1, "name": "张三", "deptId": 1, "salary": 5000},
    {"id": 2, "name": "李四", "deptId": 1, "salary": 6000}
]';

SELECT * FROM OPENJSON(@json) 
WITH (
    id INT '$.id',
    name NVARCHAR(50) '$.name',
    deptId INT '$.deptId',
    salary DECIMAL(10,2) '$.salary'
);

-- 使用JSON_VALUE提取值
SELECT JSON_VALUE(@json, '$[0].name') AS FirstEmployeeName;

-- 使用JSON_QUERY提取对象
SELECT JSON_QUERY(@json, '$[0]') AS FirstEmployee;

-- 使用JSON_MODIFY修改JSON
SET @json = JSON_MODIFY(@json, '$[0].salary', 5500);
SELECT @json;

JSON最佳实践

对于频繁查询的JSON数据，考虑使用计算列或索引
合理设计JSON结构，避免过深的嵌套
使用NVARCHAR(MAX)存储JSON数据
对JSON数据进行验证，确保格式正确

版本差异

SQLServer 2008及以上版本

支持基本的CTE和递归查询
支持MERGE语句
支持PIVOT和UNPIVOT操作

SQLServer 2012及以上版本

引入窗口函数
支持OFFSET FETCH子句用于分页
支持FORMAT函数用于格式化数据

SQLServer 2016及以上版本

引入JSON支持
支持STRING_SPLIT函数
支持DROP IF EXISTS语句
增强了MERGE语句的功能

SQLServer 2017及以上版本

支持STRING_AGG函数用于字符串聚合
支持CONCAT_WS函数用于带分隔符的字符串连接
支持TRANSLATE函数用于字符替换
增强了JSON函数的功能

SQLServer 2019及以上版本

支持Batch Mode on Rowstore，提高行存储表的查询性能
支持近似查询处理
增强了窗口函数的性能

实际生产场景

场景1：生成组织架构图

业务需求：

查询公司的组织结构，包括员工及其直接和间接上级
显示每个员工的层级关系和汇报路径

实现方案：

使用递归CTE查询组织架构
添加层级和路径信息
生成可视化的组织架构图

示例代码：

sql

WITH OrgHierarchy AS (
    -- 锚点成员：查询CEO
    SELECT EmployeeID, EmployeeName, ManagerID, 1 AS Level, 
           CAST(EmployeeName AS VARCHAR(MAX)) AS Path,
           CAST('' AS VARCHAR(MAX)) AS Indent
    FROM Organization
    WHERE ManagerID IS NULL
    UNION ALL
    -- 递归成员：查询下属
    SELECT o.EmployeeID, o.EmployeeName, o.ManagerID, oh.Level + 1 AS Level,
           CAST(oh.Path + ' > ' + o.EmployeeName AS VARCHAR(MAX)) AS Path,
           CAST(oh.Indent + '  ' AS VARCHAR(MAX)) AS Indent
    FROM Organization o
    JOIN OrgHierarchy oh ON o.ManagerID = oh.EmployeeID
)
SELECT Indent + EmployeeName AS EmployeeName, Level, Path
FROM OrgHierarchy
ORDER BY Path;

场景2：生成月度销售报表

业务需求：

生成月度销售报表，按部门和月份显示销售额
显示月度销售额、累计销售额和月度增长率

实现方案：

使用PIVOT操作将行数据转换为列数据
使用窗口函数计算累计销售额和月度增长率
生成可视化的销售报表

示例代码：

sql

WITH MonthlySales AS (
    SELECT DepartmentID, MONTH(SalesDate) AS Month, SUM(Amount) AS SalesAmount
    FROM Sales
    WHERE YEAR(SalesDate) = 2023
    GROUP BY DepartmentID, MONTH(SalesDate)
),
SalesWithGrowth AS (
    SELECT DepartmentID, Month, SalesAmount,
           SUM(SalesAmount) OVER (PARTITION BY DepartmentID ORDER BY Month) AS CumulativeSales,
           LAG(SalesAmount, 1, 0) OVER (PARTITION BY DepartmentID ORDER BY Month) AS PrevMonthSales,
           CASE 
               WHEN LAG(SalesAmount, 1, 0) OVER (PARTITION BY DepartmentID ORDER BY Month) = 0 THEN 0
               ELSE (SalesAmount - LAG(SalesAmount, 1, 0) OVER (PARTITION BY DepartmentID ORDER BY Month)) * 100.0 / 
                    LAG(SalesAmount, 1, 0) OVER (PARTITION BY DepartmentID ORDER BY Month)
           END AS GrowthRate
    FROM MonthlySales
)
SELECT * FROM SalesWithGrowth
PIVOT (
    SUM(SalesAmount) FOR Month IN ([1], [2], [3], [4], [5], [6])
) AS PivotTable;

常见问题（FAQ）

Q1：CTE和临时表有什么区别？

A：CTE是一个临时命名的结果集，仅在单个SQL语句中有效，不需要写入磁盘，性能通常更好；临时表是存储在tempdb中的表，在当前会话中有效，可能需要写入磁盘，性能较低。

Q2：什么时候应该使用窗口函数？

A：窗口函数适用于需要对一组行执行计算而不需要使用GROUP BY子句的场景，如排名、累计值、移动平均值等。

Q3：递归查询的最大递归深度是多少？

A：SQLServer默认的最大递归深度是100，可以通过OPTION (MAXRECURSION n)选项修改，最大值为32767。

Q4：MERGE语句有什么优势？

A：MERGE语句可以同时执行INSERT、UPDATE和DELETE操作，减少了多次数据操作的开销，提高了代码的可读性和可维护性。

Q5：如何防止动态SQL中的SQL注入？

A：防止SQL注入的方法包括：

使用sp_executesql代替EXEC，传递参数化查询
使用QUOTENAME函数处理对象名
对输入参数进行验证和过滤
限制数据库用户的权限

Q6：JSON数据适合存储哪些类型的数据？

A：JSON数据适合存储半结构化数据、配置数据、日志数据等，不适合存储需要频繁查询或更新的结构化数据。

Q7：如何优化窗口函数的性能？

A：优化窗口函数性能的方法包括：

合理使用PARTITION BY子句，减少窗口大小
使用ROWS/RANGE子句限制窗口大小
避免在窗口函数中使用复杂表达式
优先使用内置窗口函数

Q8：什么时候应该使用子查询，什么时候应该使用JOIN？

A：对于简单查询，子查询和JOIN都可以使用；对于复杂查询，JOIN通常比相关子查询性能更好；对于需要将子查询结果作为表使用的场景，使用表子查询或CTE更合适。

总结

SQLServer提供了丰富的高级SQL特性，这些特性可以帮助开发者编写更高效、更简洁的SQL代码，处理复杂的数据查询和操作。在实际应用中，需要根据业务需求和数据特点选择合适的高级SQL特性，并遵循最佳实践，以提高查询性能和代码可维护性。

随着SQLServer版本的不断更新，新的高级SQL特性不断涌现，数据库开发人员需要不断学习和掌握这些新特性，以适应业务发展的需求。同时，需要注意不同版本之间的差异，确保代码的兼容性和可移植性。

SQLServer 高级SQL特性 ​

高级SQL特性概述 ​

子查询 ​

基本语法 ​

子查询类型 ​

标量子查询 ​

行子查询 ​

表子查询 ​

相关子查询 ​

子查询最佳实践 ​

公共表表达式（CTE） ​

基本语法 ​

示例 ​

CTE vs 临时表 ​

窗口函数 ​

基本语法 ​

常用窗口函数 ​

排名函数 ​

聚合函数 ​

偏移函数 ​

窗口函数最佳实践 ​

递归查询 ​

基本语法 ​

示例 ​

递归查询最佳实践 ​

透视和逆透视 ​

透视（PIVOT） ​

基本语法 ​

逆透视（UNPIVOT） ​

基本语法 ​

MERGE语句 ​

基本语法 ​

示例 ​

MERGE最佳实践 ​

动态SQL ​

基本语法 ​

示例 ​

动态SQL最佳实践 ​

JSON支持 ​

JSON函数 ​

生成JSON ​

解析JSON ​

JSON最佳实践 ​

版本差异 ​

SQLServer 2008及以上版本 ​

SQLServer 2012及以上版本 ​

SQLServer 2016及以上版本 ​

SQLServer 2017及以上版本 ​

SQLServer 2019及以上版本 ​

实际生产场景 ​

场景1：生成组织架构图 ​

场景2：生成月度销售报表 ​

常见问题（FAQ） ​

Q1：CTE和临时表有什么区别？ ​

Q2：什么时候应该使用窗口函数？ ​

Q3：递归查询的最大递归深度是多少？ ​

Q4：MERGE语句有什么优势？ ​

Q5：如何防止动态SQL中的SQL注入？ ​

Q6：JSON数据适合存储哪些类型的数据？ ​

Q7：如何优化窗口函数的性能？ ​

Q8：什么时候应该使用子查询，什么时候应该使用JOIN？ ​

总结 ​

SQLServer 高级SQL特性

高级SQL特性概述

子查询

基本语法

子查询类型

标量子查询

行子查询

表子查询

相关子查询

子查询最佳实践

公共表表达式（CTE）

基本语法

示例

CTE vs 临时表

窗口函数

基本语法

常用窗口函数

排名函数

聚合函数

偏移函数

窗口函数最佳实践

递归查询

基本语法

示例

递归查询最佳实践

透视和逆透视

透视（PIVOT）

基本语法

逆透视（UNPIVOT）

基本语法

MERGE语句

基本语法

示例

MERGE最佳实践

动态SQL

基本语法

示例

动态SQL最佳实践

JSON支持

JSON函数

生成JSON

解析JSON

JSON最佳实践

版本差异

SQLServer 2008及以上版本

SQLServer 2012及以上版本

SQLServer 2016及以上版本

SQLServer 2017及以上版本

SQLServer 2019及以上版本

实际生产场景

场景1：生成组织架构图

场景2：生成月度销售报表

常见问题（FAQ）

Q1：CTE和临时表有什么区别？

Q2：什么时候应该使用窗口函数？

Q3：递归查询的最大递归深度是多少？

Q4：MERGE语句有什么优势？

Q5：如何防止动态SQL中的SQL注入？

Q6：JSON数据适合存储哪些类型的数据？

Q7：如何优化窗口函数的性能？

Q8：什么时候应该使用子查询，什么时候应该使用JOIN？

总结