PostgreSQL 18 从新手到大师：实战指南 - 1.6 SQL高级查询

1.6.1 SQL高级查询概述

SQL高级查询是指在基础SQL（SELECT/INSERT/UPDATE/DELETE）之上的复杂查询操作，包括JOIN操作、子查询、聚合函数、窗口函数等。掌握SQL高级查询是PostgreSQL开发和管理的核心技能，能够帮助用户从数据库中获取更复杂、更有价值的数据。

PostgreSQL 18在SQL查询方面提供了强大的支持，包括对SQL:2023标准的扩展支持，以及众多性能优化特性。

1.6.2 JOIN操作

1.6.2.1 JOIN类型

JOIN用于连接两个或多个表，根据它们之间的关系查询数据。PostgreSQL支持多种JOIN类型：

JOIN类型	描述
INNER JOIN	返回两个表中匹配的行
LEFT JOIN	返回左表所有行，以及右表中匹配的行
RIGHT JOIN	返回右表所有行，以及左表中匹配的行
FULL JOIN	返回左表和右表所有行，匹配的行合并，不匹配的行用NULL填充
CROSS JOIN	返回两个表的笛卡尔积
NATURAL JOIN	根据同名同类型的列自动连接表
SELF JOIN	表与自身连接

1.6.2.2 JOIN语法

SELECT column1, column2, ...
FROM table1
JOIN_TYPE table2
ON table1.column = table2.column;

1.6.2.3 JOIN示例

假设有以下两个表：

• users表：存储用户信息
• orders表：存储订单信息

-- 创建users表
CREATE TABLE users (
    user_id SERIAL PRIMARY KEY,
    username VARCHAR(50) NOT NULL,
    email VARCHAR(100) NOT NULL
);

-- 创建orders表
CREATE TABLE orders (
    order_id SERIAL PRIMARY KEY,
    user_id INTEGER REFERENCES users(user_id),
    order_date DATE NOT NULL,
    total_amount NUMERIC(10,2) NOT NULL
);

-- 插入测试数据
INSERT INTO users (username, email) VALUES 
('张三', 'zhangsan@example.com'),
('李四', 'lisi@example.com'),
('王五', 'wangwu@example.com');

INSERT INTO orders (user_id, order_date, total_amount) VALUES 
(1, '2025-01-01', 100.00),
(1, '2025-01-02', 200.00),
(2, '2025-01-03', 150.00),
(3, '2025-01-04', 300.00),
(NULL, '2025-01-05', 50.00);

1.6.2.3.1 INNER JOIN示例

-- 查询所有有订单的用户及其订单信息
SELECT u.user_id, u.username, o.order_id, o.order_date, o.total_amount
FROM users u
INNER JOIN orders o ON u.user_id = o.user_id;

1.6.2.3.2 LEFT JOIN示例

-- 查询所有用户及其订单信息，包括没有订单的用户
SELECT u.user_id, u.username, o.order_id, o.order_date, o.total_amount
FROM users u
LEFT JOIN orders o ON u.user_id = o.user_id;

1.6.2.3.3 RIGHT JOIN示例

-- 查询所有订单及其用户信息，包括没有关联用户的订单
SELECT u.user_id, u.username, o.order_id, o.order_date, o.total_amount
FROM users u
RIGHT JOIN orders o ON u.user_id = o.user_id;

1.6.2.3.4 FULL JOIN示例

-- 查询所有用户和所有订单，包括没有订单的用户和没有关联用户的订单
SELECT u.user_id, u.username, o.order_id, o.order_date, o.total_amount
FROM users u
FULL JOIN orders o ON u.user_id = o.user_id;

1.6.2.3.5 SELF JOIN示例

-- 假设users表中有manager_id字段，表示上级用户
ALTER TABLE users ADD COLUMN manager_id INTEGER REFERENCES users(user_id);

-- 更新测试数据
UPDATE users SET manager_id = 1 WHERE user_id = 2;
UPDATE users SET manager_id = 1 WHERE user_id = 3;

-- 查询用户及其上级信息
SELECT u.username AS user_name, m.username AS manager_name
FROM users u
LEFT JOIN users m ON u.manager_id = m.user_id;

1.6.3 子查询

子查询是指嵌套在其他SQL语句中的查询。子查询可以用于SELECT、INSERT、UPDATE和DELETE语句中，以及WHERE、FROM、HAVING和JOIN子句中。

1.6.3.1 子查询类型

子查询类型	描述
标量子查询	返回单个值的子查询
行子查询	返回一行数据的子查询
列子查询	返回一列数据的子查询
表子查询	返回多行多列数据的子查询

1.6.3.2 子查询示例

1.6.3.2.1 WHERE子句中的子查询

-- 查询订单金额大于平均订单金额的订单
SELECT * FROM orders 
WHERE total_amount > (SELECT AVG(total_amount) FROM orders);

-- 查询有订单的用户
SELECT * FROM users 
WHERE user_id IN (SELECT DISTINCT user_id FROM orders WHERE user_id IS NOT NULL);

-- 查询没有订单的用户
SELECT * FROM users 
WHERE user_id NOT IN (SELECT DISTINCT user_id FROM orders WHERE user_id IS NOT NULL);

-- 查询与张三有相同邮箱域名的用户
SELECT * FROM users 
WHERE email LIKE (SELECT SUBSTRING(email FROM POSITION('@' IN email)) FROM users WHERE username = '张三');

1.6.3.2.2 FROM子句中的子查询

-- 查询每个用户的订单数量和总金额
SELECT u.username, o.order_count, o.total_spent
FROM users u
JOIN (
    SELECT user_id, COUNT(*) AS order_count, SUM(total_amount) AS total_spent
    FROM orders
    GROUP BY user_id
) o ON u.user_id = o.user_id;

1.6.3.2.3 HAVING子句中的子查询

-- 查询订单数量大于平均订单数量的用户
SELECT user_id, COUNT(*) AS order_count
FROM orders
WHERE user_id IS NOT NULL
GROUP BY user_id
HAVING COUNT(*) > (SELECT AVG(order_count) FROM (
    SELECT user_id, COUNT(*) AS order_count
    FROM orders
    WHERE user_id IS NOT NULL
    GROUP BY user_id
) AS sub);

1.6.3.2.4 EXISTS子查询

-- 查询有订单的用户（使用EXISTS）
SELECT * FROM users u
WHERE EXISTS (
    SELECT 1 FROM orders o WHERE o.user_id = u.user_id
);

-- 查询没有订单的用户（使用NOT EXISTS）
SELECT * FROM users u
WHERE NOT EXISTS (
    SELECT 1 FROM orders o WHERE o.user_id = u.user_id
);

1.6.4 聚合函数

聚合函数用于对一组值进行计算并返回单个值，常用的聚合函数包括COUNT、SUM、AVG、MAX、MIN等。

1.6.4.1 基本聚合函数示例

-- 统计订单总数
SELECT COUNT(*) AS total_orders FROM orders;

-- 统计有用户关联的订单数
SELECT COUNT(user_id) AS orders_with_user FROM orders;

-- 计算订单总金额
SELECT SUM(total_amount) AS total_revenue FROM orders;

-- 计算平均订单金额
SELECT AVG(total_amount) AS avg_order_amount FROM orders;

-- 计算最大订单金额
SELECT MAX(total_amount) AS max_order_amount FROM orders;

-- 计算最小订单金额
SELECT MIN(total_amount) AS min_order_amount FROM orders;

1.6.4.2 GROUP BY和HAVING

GROUP BY用于将数据分组，然后对每组数据应用聚合函数。HAVING用于过滤分组后的结果。

-- 按用户分组，统计每个用户的订单数量和总金额
SELECT user_id, COUNT(*) AS order_count, SUM(total_amount) AS total_spent
FROM orders
WHERE user_id IS NOT NULL
GROUP BY user_id;

-- 按用户分组，统计订单数量大于1的用户
SELECT user_id, COUNT(*) AS order_count, SUM(total_amount) AS total_spent
FROM orders
WHERE user_id IS NOT NULL
GROUP BY user_id
HAVING COUNT(*) > 1;

-- 按日期分组，统计每天的订单数量和总金额
SELECT order_date, COUNT(*) AS order_count, SUM(total_amount) AS daily_revenue
FROM orders
GROUP BY order_date
ORDER BY order_date;

1.6.4.3 ROLLUP和CUBE

ROLLUP和CUBE用于生成分组的小计和总计。

-- 使用ROLLUP生成小计和总计
SELECT user_id, order_date, COUNT(*) AS order_count, SUM(total_amount) AS total_amount
FROM orders
WHERE user_id IS NOT NULL
GROUP BY ROLLUP (user_id, order_date);

-- 使用CUBE生成所有可能的分组组合
SELECT user_id, order_date, COUNT(*) AS order_count, SUM(total_amount) AS total_amount
FROM orders
WHERE user_id IS NOT NULL
GROUP BY CUBE (user_id, order_date);

1.6.5 窗口函数

窗口函数是PostgreSQL 18的强大特性之一，它允许对一组相关行执行计算，而不会减少结果集中的行数。窗口函数常用于计算排名、累计和、移动平均值等。

1.6.5.1 窗口函数语法

FUNCTION_NAME() OVER (
    [PARTITION BY partition_expression]
    [ORDER BY sort_expression [ASC|DESC]]
    [ROWS frame_clause]
)

1.6.5.2 常用窗口函数

窗口函数	描述
ROW_NUMBER()	为每行分配一个唯一的序号
RANK()	计算排名，相同值排名相同，下一个排名跳过
DENSE_RANK()	计算排名，相同值排名相同，下一个排名连续
NTILE(n)	将结果集分为n个桶，为每行分配桶号
SUM()	计算累计和
AVG()	计算移动平均值
MAX()	计算移动最大值
MIN()	计算移动最小值
LEAD()	获取下一行的值
LAG()	获取上一行的值
FIRST_VALUE()	获取窗口内第一行的值
LAST_VALUE()	获取窗口内最后一行的值

1.6.5.3 窗口函数示例

1.6.5.3.1 排名函数

-- 按订单金额降序排名
SELECT order_id, user_id, total_amount,
       ROW_NUMBER() OVER (ORDER BY total_amount DESC) AS row_num,
       RANK() OVER (ORDER BY total_amount DESC) AS rank_num,
       DENSE_RANK() OVER (ORDER BY total_amount DESC) AS dense_rank_num
FROM orders;

-- 按用户分组，对每个用户的订单按金额降序排名
SELECT order_id, user_id, order_date, total_amount,
       ROW_NUMBER() OVER (PARTITION BY user_id ORDER BY total_amount DESC) AS user_order_rank
FROM orders
WHERE user_id IS NOT NULL;

1.6.5.3.2 累计和

-- 计算订单金额的累计和
SELECT order_id, order_date, total_amount,
       SUM(total_amount) OVER (ORDER BY order_date) AS cumulative_total
FROM orders;

-- 按用户分组，计算每个用户订单金额的累计和
SELECT order_id, user_id, order_date, total_amount,
       SUM(total_amount) OVER (PARTITION BY user_id ORDER BY order_date) AS user_cumulative_total
FROM orders
WHERE user_id IS NOT NULL;

1.6.5.3.3 移动平均

-- 计算订单金额的3天移动平均值
SELECT order_date, total_amount,
       AVG(total_amount) OVER (ORDER BY order_date ROWS BETWEEN 2 PRECEDING AND CURRENT ROW) AS 3day_moving_avg
FROM orders;

1.6.5.3.4 LEAD和LAG函数

-- 获取当前订单的下一个和上一个订单金额
SELECT order_id, order_date, total_amount,
       LEAD(total_amount) OVER (ORDER BY order_date) AS next_order_amount,
       LAG(total_amount) OVER (ORDER BY order_date) AS prev_order_amount
FROM orders;

1.6.5.3.5 FIRST_VALUE和LAST_VALUE

-- 获取每个用户的第一个和最后一个订单金额
SELECT order_id, user_id, order_date, total_amount,
       FIRST_VALUE(total_amount) OVER (PARTITION BY user_id ORDER BY order_date) AS first_order_amount,
       LAST_VALUE(total_amount) OVER (PARTITION BY user_id ORDER BY order_date ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING) AS last_order_amount
FROM orders
WHERE user_id IS NOT NULL;

1.6.6 Common Table Expressions (CTE)

Common Table Expressions (CTE)是一种临时结果集，可以在SELECT、INSERT、UPDATE或DELETE语句中引用。CTE使用WITH子句定义，使复杂查询更加清晰和易于维护。

1.6.6.1 CTE语法

WITH cte_name (column1, column2, ...)
AS (
    -- CTE查询
    SELECT column1, column2, ...
    FROM table
    WHERE condition
)
-- 主查询
SELECT * FROM cte_name;

1.6.6.2 CTE示例

1.6.6.2.1 基本CTE

-- 使用CTE查询每个用户的订单数量和总金额
WITH user_order_stats AS (
    SELECT user_id, COUNT(*) AS order_count, SUM(total_amount) AS total_spent
    FROM orders
    WHERE user_id IS NOT NULL
    GROUP BY user_id
)
SELECT u.username, o.order_count, o.total_spent
FROM users u
JOIN user_order_stats o ON u.user_id = o.user_id;

1.6.6.2.2 递归CTE

递归CTE用于处理层次结构数据，如组织架构、树形结构等。

-- 查询用户及其所有下属（递归）
WITH RECURSIVE user_hierarchy AS (
    -- 锚点成员：查询根用户
    SELECT user_id, username, manager_id, 0 AS level
    FROM users
    WHERE manager_id IS NULL
    
    UNION ALL
    
    -- 递归成员：查询下属用户
    SELECT u.user_id, u.username, u.manager_id, uh.level + 1 AS level
    FROM users u
    JOIN user_hierarchy uh ON u.manager_id = uh.user_id
)
SELECT * FROM user_hierarchy ORDER BY level, user_id;

1.6.6.2.3 多个CTE

-- 使用多个CTE
WITH 
    -- 第一个CTE：查询用户订单统计
    user_order_stats AS (
        SELECT user_id, COUNT(*) AS order_count, SUM(total_amount) AS total_spent
        FROM orders
        WHERE user_id IS NOT NULL
        GROUP BY user_id
    ),
    -- 第二个CTE：查询活跃用户
    active_users AS (
        SELECT user_id, username
        FROM users
        WHERE manager_id IS NOT NULL
    )
-- 主查询：查询活跃用户的订单统计
SELECT au.username, uos.order_count, uos.total_spent
FROM active_users au
JOIN user_order_stats uos ON au.user_id = uos.user_id;

1.6.7 复杂查询实践

1.6.7.1 电商数据分析示例

假设我们有一个完整的电商数据库，包含以下表：

• users：用户表
• products：产品表
• orders：订单表
• order_items：订单详情表

-- 创建products表
CREATE TABLE products (
    product_id SERIAL PRIMARY KEY,
    product_name VARCHAR(100) NOT NULL,
    category VARCHAR(50) NOT NULL,
    price NUMERIC(10,2) NOT NULL
);

-- 创建order_items表
CREATE TABLE order_items (
    item_id SERIAL PRIMARY KEY,
    order_id INTEGER REFERENCES orders(order_id),
    product_id INTEGER REFERENCES products(product_id),
    quantity INTEGER NOT NULL,
    unit_price NUMERIC(10,2) NOT NULL
);

-- 插入测试数据
INSERT INTO products (product_name, category, price) VALUES 
('笔记本电脑', '电子产品', 5000.00),
('智能手机', '电子产品', 3000.00),
('耳机', '电子产品', 500.00),
('T恤', '服装', 100.00),
('牛仔裤', '服装', 200.00);

INSERT INTO order_items (order_id, product_id, quantity, unit_price) VALUES 
(1, 1, 1, 5000.00),
(1, 3, 2, 500.00),
(2, 2, 1, 3000.00),
(3, 4, 3, 100.00),
(3, 5, 2, 200.00),
(4, 1, 1, 5000.00),
(4, 2, 1, 3000.00),
(4, 3, 1, 500.00);

1.6.7.1.1 查询每个产品的销售数量和总金额

SELECT p.product_name, p.category,
       SUM(oi.quantity) AS total_quantity,
       SUM(oi.quantity * oi.unit_price) AS total_sales
FROM products p
JOIN order_items oi ON p.product_id = oi.product_id
GROUP BY p.product_id, p.product_name, p.category
ORDER BY total_sales DESC;

1.6.7.1.2 查询每个用户的购买行为

WITH user_purchase_stats AS (
    SELECT u.user_id, u.username,
           COUNT(DISTINCT o.order_id) AS total_orders,
           COUNT(oi.item_id) AS total_items,
           SUM(oi.quantity * oi.unit_price) AS total_spent,
           MIN(o.order_date) AS first_purchase_date,
           MAX(o.order_date) AS last_purchase_date
    FROM users u
    JOIN orders o ON u.user_id = o.user_id
    JOIN order_items oi ON o.order_id = oi.order_id
    GROUP BY u.user_id, u.username
)
SELECT *, 
       AGE(last_purchase_date, first_purchase_date) AS customer_lifetime,
       total_spent / NULLIF(total_orders, 0) AS avg_order_value
FROM user_purchase_stats
ORDER BY total_spent DESC;

1.6.7.1.3 查询每个类别的销售趋势

SELECT DATE_TRUNC('month', o.order_date) AS month,
       p.category,
       COUNT(DISTINCT o.order_id) AS order_count,
       SUM(oi.quantity) AS total_quantity,
       SUM(oi.quantity * oi.unit_price) AS total_sales
FROM orders o
JOIN order_items oi ON o.order_id = oi.order_id
JOIN products p ON oi.product_id = p.product_id
GROUP BY month, p.category
ORDER BY month, total_sales DESC;

1.6.7.1.4 查询Top 5产品

SELECT p.product_name, p.category,
       SUM(oi.quantity) AS total_quantity,
       SUM(oi.quantity * oi.unit_price) AS total_sales
FROM products p
JOIN order_items oi ON p.product_id = oi.product_id
GROUP BY p.product_id, p.product_name, p.category
ORDER BY total_sales DESC
LIMIT 5;

1.6.8 SQL高级查询最佳实践

1. 使用适当的JOIN类型：根据需求选择合适的JOIN类型，避免不必要的笛卡尔积
2. 优化子查询：复杂子查询可以考虑使用CTE或临时表替代
3. 合理使用窗口函数：窗口函数功能强大，但也会带来性能开销，应合理使用
4. 使用EXPLAIN分析查询计划：对于复杂查询，使用EXPLAIN ANALYZE分析查询性能
5. 添加适当的索引：根据查询模式添加索引，提高查询性能
6. 避免在WHERE子句中使用函数：这会导致索引失效
7. 使用参数化查询：避免SQL注入攻击
8. 简化复杂查询：将复杂查询拆分为多个简单查询或使用CTE
9. 定期更新统计信息：帮助查询优化器生成更好的查询计划
10. 使用事务：对于多个相关操作，使用事务确保数据一致性

1.6.9 PostgreSQL vs SQL Server 2019+ vs MySQL 8.0+：SQL高级查询对比

为了帮助你建立更全面的SQL高级查询知识体系，本节将对比PostgreSQL 18、SQL Server 2019+和MySQL 8.0+在SQL高级查询方面的主要差异。

1.6.9.1 JOIN操作差异

JOIN特性	PostgreSQL 18	SQL Server 2019+	MySQL 8.0+
FULL JOIN	支持	支持	支持（8.0+）
NATURAL JOIN	支持	支持	支持
SELF JOIN	支持	支持	支持
CROSS JOIN	支持	支持	支持
JOIN ON条件	支持	支持	支持
JOIN USING条件	支持	支持	支持
多表JOIN性能	优秀，优化器强大	优秀，企业级优化器	良好，适合中小规模数据

1.6.9.2 子查询差异

子查询特性	PostgreSQL 18	SQL Server 2019+	MySQL 8.0+
标量子查询	支持	支持	支持
行子查询	支持	支持	支持
列子查询	支持	支持	支持
表子查询	支持	支持	支持
相关子查询	支持	支持	支持
子查询优化	优秀，支持多种优化策略	优秀，企业级优化器	良好，8.0+优化明显提升
IN/NOT IN子查询	支持	支持	支持
EXISTS/NOT EXISTS子查询	支持	支持	支持

1.6.9.3 聚合函数差异

聚合函数特性	PostgreSQL 18	SQL Server 2019+	MySQL 8.0+
基本聚合函数	支持COUNT、SUM、AVG、MAX、MIN	支持COUNT、SUM、AVG、MAX、MIN	支持COUNT、SUM、AVG、MAX、MIN
ROLLUP	支持	支持	支持（8.0+）
CUBE	支持	支持	支持（8.0+）
GROUPING SETS	支持	支持	支持（8.0+）
FILTER子句	支持 AGG_FUNC() FILTER (WHERE condition)	不直接支持，需使用CASE语句	不直接支持，需使用CASE语句
DISTINCT聚合	支持 COUNT(DISTINCT column)	支持 COUNT(DISTINCT column)	支持 COUNT(DISTINCT column)

1.6.9.4 窗口函数差异

窗口函数特性	PostgreSQL 18	SQL Server 2019+	MySQL 8.0+
ROW_NUMBER()	支持	支持	支持（8.0+）
RANK()	支持	支持	支持（8.0+）
DENSE_RANK()	支持	支持	支持（8.0+）
NTILE()	支持	支持	支持（8.0+）
LEAD()/LAG()	支持	支持	支持（8.0+）
FIRST_VALUE()/LAST_VALUE()	支持	支持	支持（8.0+）
累计聚合	支持 SUM() OVER (ORDER BY ...)	支持 SUM() OVER (ORDER BY ...)	支持 SUM() OVER (ORDER BY ...)（8.0+）
移动聚合	支持 AVG() OVER (ORDER BY ... ROWS BETWEEN ...)	支持 AVG() OVER (ORDER BY ... ROWS BETWEEN ...)	支持 AVG() OVER (ORDER BY ... ROWS BETWEEN ...)（8.0+）
PARTITION BY	支持	支持	支持（8.0+）
窗口函数丰富度	最丰富，支持自定义窗口函数	丰富，企业级支持	良好，基础功能齐全（8.0+）

1.6.9.5 CTE差异

CTE特性	PostgreSQL 18	SQL Server 2019+	MySQL 8.0+
基本CTE	支持	支持	支持（8.0+）
递归CTE	支持 WITH RECURSIVE	支持 WITH RECURSIVE	支持 WITH RECURSIVE（8.0+）
多CTE	支持多个CTE定义	支持多个CTE定义	支持多个CTE定义（8.0+）
CTE在UPDATE/DELETE中使用	支持	支持	支持（8.0+）
CTE性能	优秀，优化器处理良好	优秀，企业级优化	良好，8.0+优化明显提升
CTE可重用性	支持在同一查询中多次引用	支持在同一查询中多次引用	支持在同一查询中多次引用（8.0+）

1.6.9.6 高级查询语法差异

高级查询特性	PostgreSQL 18	SQL Server 2019+	MySQL 8.0+
LIMIT/OFFSET	支持 LIMIT 5 OFFSET 10	使用 TOP 5 OFFSET 10 ROWS FETCH NEXT 5 ROWS ONLY	支持 LIMIT 5 OFFSET 10
FETCH FIRST	支持 FETCH FIRST 5 ROWS ONLY	支持 FETCH NEXT 5 ROWS ONLY	支持 FETCH FIRST 5 ROWS ONLY（8.0+）
TABLESAMPLE	支持（数据采样）	支持（TABLESAMPLE SYSTEM）	不直接支持
VALUES列表作为表	支持 SELECT * FROM (VALUES (1), (2)) AS t(n)	支持 SELECT * FROM (VALUES (1), (2)) AS t(n)	支持 SELECT * FROM (VALUES (1), (2)) AS t(n)（8.0+）
横向连接LATERAL	支持 LATERAL	支持 CROSS APPLY/OUTER APPLY	支持 LATERAL（8.0.14+）
JSON路径查询	支持 jsonb_path_query	支持 OPENJSON	支持 JSON_EXTRACT/JSON_VALUE

1.6.10 总结

SQL高级查询是PostgreSQL开发和管理的核心技能，包括JOIN操作、子查询、聚合函数、窗口函数和CTE等。掌握这些高级查询技术，能够帮助用户从数据库中获取更复杂、更有价值的数据，满足各种业务需求。

PostgreSQL 18在SQL查询方面提供了强大的支持，特别是窗口函数和CTE特性，使复杂查询更加高效和易于编写。通过与SQL Server 2019+和MySQL 8.0+的对比，我们可以看到：

1. PostgreSQL 在窗口函数、CTE和高级查询特性方面最为丰富，适合复杂数据分析和企业级应用。
2. SQL Server 拥有强大的优化器和企业级支持，适合大型企业和复杂业务场景。
3. MySQL 在8.0版本后高级查询能力显著提升，适合中小规模应用和Web开发。

在实际应用中，应根据具体需求选择合适的查询技术和数据库，并遵循SQL最佳实践，确保查询的性能和可维护性。

建议读者通过实际练习来巩固所学知识，例如创建一个完整的电商数据库，并尝试编写各种复杂查询来分析数据，这将帮助你更好地掌握SQL高级查询技术。

1.6.11 思考与练习

1.6.11.1 思考问题

1. JOIN操作有哪些类型？它们的区别是什么？
2. 什么是子查询？子查询有哪些类型？
3. 聚合函数和窗口函数的区别是什么？
4. 什么是CTE？CTE有哪些优势？
5. 比较PostgreSQL 18与SQL Server 2019+和MySQL 8.0+在SQL高级查询方面的差异。

1.6.11.2 练习题

1. 简述各种JOIN类型的用途和差异。
2. 编写SQL语句，使用不同类型的JOIN查询数据。
3. 编写SQL语句，使用子查询查询数据。
4. 编写SQL语句，使用聚合函数和GROUP BY查询数据。
5. 编写SQL语句，使用窗口函数查询数据。
6. 编写SQL语句，使用CTE查询数据。
7. 编写SQL语句，使用递归CTE查询层次结构数据。
8. 编写SQL语句，分析电商数据库中的销售数据。
9. 比较不同数据库在SQL高级查询方面的差异。
10. 简述SQL高级查询的最佳实践。

1.6.12 参考资源

• PostgreSQL官方文档：高级SQL特性
• PostgreSQL中文社区：SQL高级查询
• 《SQL高级编程》：Itzik Ben-Gan著
• 《PostgreSQL实战》：谭峰著
• SQL Server官方文档：高级查询技术
• MySQL官方文档：高级SQL特性