PostgreSQL笔记14:子查询与嵌套查询的完整分类、执行模型与性能优化

26、PostgreSQL 性能优化与非常规数据类型使用指南 本文深入探讨了PostgreSQL数据库在性能优化和处理非常规数据类型方面的关键技术和操作方法。性能优化方面涵盖了避免不必要的索引扫描、优化嵌套查询、谨慎使用CTE、PL/pgSQL使用注意事项、处理跨列相关性以及表分区技术等内容;非常规数据类型部分介绍了数组、JSON/JSONB、hstore和XML的使用,并结合实际示例展示了它们的灵活性和优势。通过合理运用这些技术,可以显著提升PostgreSQL数据库的性能与灵活性,为复杂业务场景提供高效支持。 阅读详情

纲要

  • 子查询(Subquery)的定义与核心概念
    • 主查询(Main Query)与子查询的嵌套关系
  • 子查询的分类体系
    • 标量子查询(Scalar Subquery):返回一行一列
    • 行值子查询(Row Subquery):返回一行多列
    • 派生表(Derived Table / Table Subquery):返回多行多列,用于 FROM 子句
    • IN / NOT IN 子查询:等值集合判断
    • EXISTS / NOT EXISTS 子查询:存在性判断
    • 比较子查询(Comparison Subquery):=, >, <, >=, <=, <> 配合 ALL / ANY / SOME
  • LATERAL 子查询(横向子查询)
    • 与普通 JOIN 的本质区别:右侧子查询可引用左侧表项
    • 典型应用场景:每组取 Top-N、行级派生
  • 相关子查询(Correlated Subquery)与非相关子查询(Non-Correlated Subquery)
    • 执行模型差异:独立执行 vs 逐行循环执行
    • EXPLAIN 中的 InitPlan 与 SubPlan / loops
  • 标量子查询的性能陷阱与 LEFT JOIN 改写
  • PostgreSQL 17 优化器改进:IN 相关子查询的 pull-up 优化
  • 实践建议:子查询选型与性能调优策略

子查询的定义与分类

子查询(Subquery)本质上是嵌套在其他 SQL 语句中的 SELECT 语句[reference:0]。它可出现在 SELECT、FROM、WHERE、HAVING、INSERT、UPDATE、DELETE 等多种位置。包含子查询的查询称为主查询(Main Query)。执行时,数据库会根据子查询的类型和相关性,决定其执行顺序与方式。

从返回结果的结构来看,子查询可分为以下几类:

分类返回结构典型使用位置说明
标量子查询(Scalar Subquery)一行一列SELECT、WHERE、FROM作为单值表达式使用[reference:1]
行值子查询(Row Subquery)一行多列行构造器比较返回与左侧行构造器列数匹配的一行
派生表(Derived Table)多行多列FROM 子句必须指定表别名[reference:2]

从语义功能来看,又可分为:

分类功能典型关键字
集合成员判断判断值是否存在于子查询结果集中IN / NOT IN[reference:3]
存在性判断判断子查询是否返回至少一行EXISTS / NOT EXISTS[reference:4]
比较子查询与子查询返回的集合进行逐行比较= ANY, > ALL, < SOME 等

以下通过具体的测试数据来逐一演示各类子查询的用法。

测试数据准备

首先创建班级表(class)和学生表(student):

-- 创建班级表
CREATE TABLE class (
    id INTEGER PRIMARY KEY,
    name VARCHAR(50) NOT NULL
);

-- 创建学生表
CREATE TABLE student (
    id INTEGER PRIMARY KEY,
    name VARCHAR(50) NOT NULL,
    class_id INTEGER REFERENCES class(id),
    score NUMERIC(5,2)
);

-- 插入班级数据
INSERT INTO class VALUES (1, 'ClassA'), (2, 'ClassB'), (3, 'ClassC');

-- 插入学生数据
INSERT INTO student VALUES
    (1, 'Alice', 1, 95.0),
    (2, 'Bob', 1, 88.0),
    (3, 'Charlie', 2, 82.0),
    (4, 'David', 2, 78.0),
    (5, 'Eve', 3, 99.5),
    (6, 'Frank', 3, 72.0),
    (7, 'Grace', 1, 91.0),
    (8, 'Henry', 2, 85.0);

标量子查询(Scalar Subquery)

标量子查询是返回一行一列的普通 SELECT 查询[reference:5]。它在任何需要单值表达式的地方均可使用,如 SELECT 列表、WHERE 条件或 FROM 子句中。

-- 查询分数最高的学生信息(标量子查询在 WHERE 子句中)
SELECT * FROM student
WHERE score = (SELECT MAX(score) FROM student);
-- 等价的聚合查询写法(对比)
SELECT * FROM student WHERE score = 95.0;

标量子查询也可出现在 SELECT 列表中,为每一行计算一个派生值:

-- 查询每个班级及其学生人数(标量子查询在 SELECT 中)
SELECT
    c.id,
    c.name,
    (SELECT COUNT(*) FROM student s WHERE s.class_id = c.id) AS student_count
FROM class c;

派生表(Derived Table)

派生表是出现在 FROM 子句中的子查询,其结果集作为临时表供外层查询使用[reference:6]。派生表必须指定表别名[reference:7]。

-- 派生表:先按班级计算平均分,再与班级表关联
SELECT
    c.name AS class_name,
    avg_stats.avg_score
FROM class c
JOIN (
    SELECT class_id, AVG(score) AS avg_score
    FROM student
    GROUP BY class_id
) AS avg_stats ON c.id = avg_stats.class_id;

派生表适用于将复杂逻辑拆分,使主查询结构更清晰。

IN 与 NOT IN 子查询

IN 判断左侧表达式是否存在于子查询返回的集合中[reference:8]。子查询必须返回恰好一列[reference:9]。

-- 查询所有在 ClassA 就读的学生
SELECT * FROM student
WHERE class_id IN (SELECT id FROM class WHERE name = 'ClassA');
-- NOT IN:查询不在 ClassA 就读的学生
SELECT * FROM student
WHERE class_id NOT IN (SELECT id FROM class WHERE name = 'ClassA');

注意:IN / NOT IN 在处理 NULL 值时需特别小心。若子查询结果中包含 NULL,NOT IN 的语义会变为 UNKNOWN,可能导致结果为空[reference:10]。

EXISTS 与 NOT EXISTS 子查询

EXISTS 判断子查询是否返回至少一行[reference:11]。子查询一旦找到匹配行即停止执行[reference:12]。

-- 查询至少有一名学生分数超过 90 分的班级
SELECT * FROM class c
WHERE EXISTS (
    SELECT 1 FROM student s
    WHERE s.class_id = c.id AND s.score > 90
);

EXISTS 的输出列表通常无关紧要,推荐使用 SELECT 1 或 SELECT *[reference:13][reference:14]。

-- NOT EXISTS:查询没有任何学生分数超过 90 分的班级
SELECT * FROM class c
WHERE NOT EXISTS (
    SELECT 1 FROM student s
    WHERE s.class_id = c.id AND s.score > 90
);

比较子查询:ALL、ANY、SOME

比较子查询将左侧表达式与子查询返回的集合进行比较,支持 =, <>, >, <, >=, <= 等运算符,配合 ALL、ANY 或 SOME 关键字。

-- 查询分数高于所有班级平均分的学生
SELECT * FROM student
WHERE score > ALL (
    SELECT AVG(score) FROM student GROUP BY class_id
);
-- 查询分数高于任意一个班级平均分的学生(即高于最低平均分)
SELECT * FROM student
WHERE score > ANY (
    SELECT AVG(score) FROM student GROUP BY class_id
);

ALL 要求与集合中所有值比较均为真;ANY / SOME 要求与集合中至少一个值比较为真。

LATERAL 子查询(横向子查询)

LATERAL 是 PostgreSQL 对 SQL 标准的扩展实现[reference:15][reference:16]。普通的 FROM 子查询独立求值,不能引用同一 FROM 列表中其他表项。而带有 LATERAL 的子查询可以引用左侧 FROM 项提供的列[reference:17]。

-- 普通 JOIN 无法在子查询中引用外层表的列(以下写法会报错)
-- SELECT * FROM class c
-- JOIN (SELECT AVG(score) FROM student s WHERE s.class_id = c.id) AS avg_score ON true;

-- LATERAL JOIN:每个班级计算其学生平均分
SELECT
    c.id,
    c.name,
    avg_stats.avg_score
FROM class c
CROSS JOIN LATERAL (
    SELECT AVG(score) AS avg_score
    FROM student s
    WHERE s.class_id = c.id
) AS avg_stats;

LATERAL 的典型应用场景包括:每组取 Top-N、对每一行执行聚合计算、行级派生等。

-- 每个班级取分数最高的 2 名学生(Top-N per group)
SELECT
    c.name AS class_name,
    top_students.name,
    top_students.score
FROM class c
CROSS JOIN LATERAL (
    SELECT s.name, s.score
    FROM student s
    WHERE s.class_id = c.id
    ORDER BY s.score DESC
    LIMIT 2
) AS top_students
ORDER BY c.name, top_students.score DESC;

相关子查询与非相关子查询

非相关子查询(Non-Correlated Subquery)

非相关子查询不依赖外层查询的任何列,可独立执行。数据库通常只执行一次子查询,将结果用于外层查询。

-- 非相关子查询:子查询独立于外层
SELECT * FROM student
WHERE score > (SELECT AVG(score) FROM student);

通过 EXPLAIN 可观察到 InitPlan,表示子查询仅执行一次:

EXPLAIN SELECT * FROM student
WHERE score > (SELECT AVG(score) FROM student);

相关子查询(Correlated Subquery)

相关子查询引用了外层查询的列[reference:18]。外层每处理一行,子查询就需要执行一次[reference:19]。

-- 相关子查询:子查询引用了外层 student 表的 class_id
SELECT * FROM student s1
WHERE score > (
    SELECT AVG(score) FROM student s2
    WHERE s2.class_id = s1.class_id
);

EXPLAIN 中会显示 SubPlan 及其 loops 次数,表示子查询被循环执行的次数:

EXPLAIN (ANALYZE, BUFFERS) SELECT * FROM student s1
WHERE score > (
    SELECT AVG(score) FROM student s2
    WHERE s2.class_id = s1.class_id
);

性能影响:若主表有 N 行,子查询将被执行 N 次[reference:20]。当 N 较大时,性能急剧下降。

标量子查询的性能陷阱与 LEFT JOIN 改写

标量子查询在 SELECT 列表或 WHERE 条件中每行执行一次,存在与相关子查询相同的性能问题。在 PostgreSQL 17 以前,推荐将标量子查询改写为 LEFT JOIN 以提升性能[reference:21]。

-- 性能较差的标量子查询(每行执行一次子查询)
SELECT
    c.id,
    c.name,
    (SELECT COUNT(*) FROM student s WHERE s.class_id = c.id) AS student_count
FROM class c;

-- 改写为 LEFT JOIN + GROUP BY(性能更优)
SELECT
    c.id,
    c.name,
    COALESCE(s_cnt.cnt, 0) AS student_count
FROM class c
LEFT JOIN (
    SELECT class_id, COUNT(*) AS cnt
    FROM student
    GROUP BY class_id
) s_cnt ON c.id = s_cnt.class_id;

改写后,子查询仅执行一次(作为派生表),外层通过 LEFT JOIN 关联结果,避免了逐行循环执行[reference:22]。

PostgreSQL 17 优化器改进:IN 相关子查询的 Pull-up

在 PostgreSQL 17 以前,对于相关 IN 子查询,优化器无法自动将其提升为 JOIN,导致逐行循环执行(SubPlan)[reference:23]。DBA 需手动将 IN 改写为 EXISTS 以获得更好的执行计划[reference:24]。

-- PostgreSQL 16 及更早版本:相关 IN 子查询性能较差
SELECT * FROM student s1
WHERE s1.class_id IN (
    SELECT c.id FROM class c
    WHERE c.name LIKE 'Class%' AND c.id = s1.class_id
);

-- 手动改写为 EXISTS(16 及更早版本性能更优)
SELECT * FROM student s1
WHERE EXISTS (
    SELECT 1 FROM class c
    WHERE c.id = s1.class_id AND c.name LIKE 'Class%'
);

PostgreSQL 17 改进了优化器,能够自动将相关 IN 子查询转换为高效的 JOIN 或 SEMI JOIN 计划[reference:25]。这意味着在 17 及以上版本中,开发者无需手动改写,数据库会自动选择更优的执行路径[reference:26]。

执行计划解读:识别子查询性能问题

通过 EXPLAIN 可识别子查询的执行方式:

执行计划关键字含义性能特征
InitPlan子查询在查询开始时执行一次高效,适用于非相关子查询
SubPlan子查询在外层每行执行一次可能存在性能问题,需关注 loops 次数
loops子查询实际执行次数值越大,性能开销越高
-- 检查子查询的执行方式
EXPLAIN (ANALYZE, BUFFERS, VERBOSE)
SELECT * FROM student s1
WHERE score > (SELECT AVG(score) FROM student s2 WHERE s2.class_id = s1.class_id);

实践建议

  1. 优先使用非相关子查询:独立执行的子查询仅执行一次,性能最优。
  2. 相关子查询优先考虑 EXISTS:在 PostgreSQL 17 以前,EXISTS 比 IN 更易被优化器提升为 JOIN[reference:27]。PostgreSQL 17 及以后两者差异缩小。
  3. 标量子查询考虑 LEFT JOIN 改写:在 SELECT 列表中的标量子查询,建议改写为 LEFT JOIN + 聚合。
  4. 派生表必须指定别名:FROM 子句中的子查询必须使用 AS alias 指定别名[reference:28]。
  5. 善用 LATERAL:当需要引用左侧表项时,使用 LATERAL 实现行级动态派生。
  6. 监控执行计划:定期使用 EXPLAIN (ANALYZE, BUFFERS) 检查子查询的 loops 次数,识别潜在性能瓶颈。

API 速览

本节梳理 PostgreSQL 中子查询相关的核心 SQL 语法与 API。

标量子查询(Scalar Subquery)

语法:

(SELECT 表达式 FROM 表名 WHERE 条件)

约束:必须返回恰好一行一列[reference:29]。若返回多行或多列,抛出运行时错误。

返回值:单值(可为 NULL)。

EXISTS / NOT EXISTS

语法:

EXISTS (subquery)
NOT EXISTS (subquery)

说明:subquery 为任意 SELECT 语句[reference:30]。返回布尔值[reference:31]。子查询一旦找到匹配行即停止执行[reference:32]。

返回值:BOOLEAN(true / false)。

IN / NOT IN

语法:

expression IN (subquery)
expression NOT IN (subquery)
row_constructor IN (subquery)

说明:子查询必须返回恰好一列(行构造器形式需匹配列数)[reference:33][reference:34]。注意 NULL 值的三值逻辑[reference:35]。

返回值:BOOLEAN(true / false / NULL)。

比较子查询(ALL / ANY / SOME)

语法:

expression operator ALL (subquery)
expression operator ANY (subquery)
expression operator SOME (subquery)

说明:operator 为 =, <>, >, <, >=, <= 之一。

返回值:BOOLEAN。

LATERAL 子查询

语法:

FROM 左表 [CROSS | LEFT] JOIN LATERAL (subquery) AS alias ON 条件

说明:LATERAL 允许子查询引用左侧 FROM 项中的列[reference:36][reference:37]。

Demo 简单示例

以下是一个完整的 Node.js 示例,演示 PostgreSQL 子查询的各类用法。

运行说明

  1. 确保本地运行 PostgreSQL(>= 14,推荐 17)
  2. 创建测试数据库:createdb subquery_demo
  3. 安装依赖:npm install pg
  4. 运行脚本:node demo.js

代码实现

const { Client } = require('pg');

const client = new Client({
    host: 'localhost',
    port: 5432,
    database: 'subquery_demo',
    user: 'postgres',
    password: 'your_password'
});

async function runDemo() {
    await client.connect();

    // 1. 创建测试表
    await client.query(`
        DROP TABLE IF EXISTS student CASCADE;
        DROP TABLE IF EXISTS class CASCADE;
        CREATE TABLE class (id INTEGER PRIMARY KEY, name VARCHAR(50));
        CREATE TABLE student (
            id INTEGER PRIMARY KEY,
            name VARCHAR(50),
            class_id INTEGER REFERENCES class(id),
            score NUMERIC(5,2)
        );
        INSERT INTO class VALUES (1, 'ClassA'), (2, 'ClassB'), (3, 'ClassC');
        INSERT INTO student VALUES
            (1, 'Alice', 1, 95.0), (2, 'Bob', 1, 88.0),
            (3, 'Charlie', 2, 82.0), (4, 'David', 2, 78.0),
            (5, 'Eve', 3, 99.5), (6, 'Frank', 3, 72.0),
            (7, 'Grace', 1, 91.0), (8, 'Henry', 2, 85.0);
    `);

    // 2. 标量子查询:查询分数最高的学生
    const scalarResult = await client.query(`
        SELECT * FROM student
        WHERE score = (SELECT MAX(score) FROM student);
    `);
    console.log('标量子查询 - 最高分学生:', scalarResult.rows);

    // 3. EXISTS:查询有学生超过90分的班级
    const existsResult = await client.query(`
        SELECT * FROM class c
        WHERE EXISTS (
            SELECT 1 FROM student s
            WHERE s.class_id = c.id AND s.score > 90
        );
    `);
    console.log('EXISTS - 有高分学生的班级:', existsResult.rows);

    // 4. IN:查询ClassA的学生
    const inResult = await client.query(`
        SELECT * FROM student
        WHERE class_id IN (SELECT id FROM class WHERE name = 'ClassA');
    `);
    console.log('IN - ClassA的学生:', inResult.rows);

    // 5. 派生表:每个班级的平均分
    const derivedResult = await client.query(`
        SELECT c.name, avg_stats.avg_score
        FROM class c
        JOIN (
            SELECT class_id, AVG(score) AS avg_score
            FROM student
            GROUP BY class_id
        ) AS avg_stats ON c.id = avg_stats.class_id;
    `);
    console.log('派生表 - 班级平均分:', derivedResult.rows);

    // 6. LATERAL:每个班级取前2名
    const lateralResult = await client.query(`
        SELECT c.name, top.name, top.score
        FROM class c
        CROSS JOIN LATERAL (
            SELECT s.name, s.score
            FROM student s
            WHERE s.class_id = c.id
            ORDER BY s.score DESC
            LIMIT 2
        ) AS top
        ORDER BY c.name, top.score DESC;
    `);
    console.log('LATERAL - 每班前2名:', lateralResult.rows);

    // 7. 相关子查询:分数高于所在班级平均分的学生
    const correlatedResult = await client.query(`
        SELECT s1.name, s1.score, s1.class_id
        FROM student s1
        WHERE s1.score > (
            SELECT AVG(s2.score)
            FROM student s2
            WHERE s2.class_id = s1.class_id
        );
    `);
    console.log('相关子查询 - 高于班级平均分的学生:', correlatedResult.rows);

    // 8. 标量子查询改写为 LEFT JOIN(性能优化)
    const optimizedResult = await client.query(`
        SELECT c.id, c.name, COALESCE(s_cnt.cnt, 0) AS student_count
        FROM class c
        LEFT JOIN (
            SELECT class_id, COUNT(*) AS cnt
            FROM student
            GROUP BY class_id
        ) s_cnt ON c.id = s_cnt.class_id;
    `);
    console.log('LEFT JOIN改写 - 班级学生数:', optimizedResult.rows);

    await client.end();
}

runDemo().catch(console.error);

原生 PostgreSQL 指令对照

-- 标量子查询
SELECT * FROM student WHERE score = (SELECT MAX(score) FROM student);

-- EXISTS
SELECT * FROM class c WHERE EXISTS (SELECT 1 FROM student s WHERE s.class_id = c.id AND s.score > 90);

-- IN
SELECT * FROM student WHERE class_id IN (SELECT id FROM class WHERE name = 'ClassA');

-- 派生表
SELECT c.name, avg_stats.avg_score FROM class c JOIN (SELECT class_id, AVG(score) AS avg_score FROM student GROUP BY class_id) AS avg_stats ON c.id = avg_stats.class_id;

-- LATERAL
SELECT c.name, top.name, top.score FROM class c CROSS JOIN LATERAL (SELECT s.name, s.score FROM student s WHERE s.class_id = c.id ORDER BY s.score DESC LIMIT 2) AS top ORDER BY c.name, top.score DESC;

-- 相关子查询
SELECT s1.name, s1.score FROM student s1 WHERE s1.score > (SELECT AVG(s2.score) FROM student s2 WHERE s2.class_id = s1.class_id);

-- LEFT JOIN 改写标量子查询
SELECT c.id, c.name, COALESCE(s_cnt.cnt, 0) AS student_count FROM class c LEFT JOIN (SELECT class_id, COUNT(*) AS cnt FROM student GROUP BY class_id) s_cnt ON c.id = s_cnt.class_id;

技术点总结

技术点说明
标量子查询返回单值,可用于任意表达式位置
EXISTS存在性判断,查到即停,性能优于 COUNT(*) > 0
IN集合成员判断,注意 NULL 处理
派生表FROM 子句中的子查询,必须指定别名
LATERAL横向子查询,可引用左侧表项,适用于 Top-N
相关子查询每行执行一次,需关注性能
LEFT JOIN 改写标量子查询的常见性能优化手段

子查询示例 - Go / Python / Java 完整 Demo

本节基于前文的 Node.js 示例,提供 Go (使用 pgx)、Python (使用 psycopg2) 和 Java (使用 JDBC) 三种语言的完整可运行实现。所有示例均包含测试数据初始化、各类子查询演示以及性能优化改写。

Go 示例 (使用 pgx)

运行说明
  1. 安装 Go 1.18+,创建项目目录
  2. 安装依赖:go get github.com/jackc/pgx/v5
  3. 修改连接字符串(数据库名、用户、密码)
  4. 运行:go run main.go
代码实现
package main

import (
	"context"
	"fmt"
	"log"

	"github.com/jackc/pgx/v5"
)

func main() {
	ctx := context.Background()

	// 连接数据库,请替换为实际参数
	connStr := "postgres://postgres:your_password@localhost:5432/subquery_demo"
	conn, err := pgx.Connect(ctx, connStr)
	if err != nil {
		log.Fatal("连接失败:", err)
	}
	defer conn.Close(ctx)

	// 1. 创建测试表并插入数据
	_, err = conn.Exec(ctx, `
		DROP TABLE IF EXISTS student CASCADE;
		DROP TABLE IF EXISTS class CASCADE;
		CREATE TABLE class (id INTEGER PRIMARY KEY, name VARCHAR(50));
		CREATE TABLE student (
			id INTEGER PRIMARY KEY,
			name VARCHAR(50),
			class_id INTEGER REFERENCES class(id),
			score NUMERIC(5,2)
		);
		INSERT INTO class VALUES (1, 'ClassA'), (2, 'ClassB'), (3, 'ClassC');
		INSERT INTO student VALUES
			(1, 'Alice', 1, 95.0), (2, 'Bob', 1, 88.0),
			(3, 'Charlie', 2, 82.0), (4, 'David', 2, 78.0),
			(5, 'Eve', 3, 99.5), (6, 'Frank', 3, 72.0),
			(7, 'Grace', 1, 91.0), (8, 'Henry', 2, 85.0);
	`)
	if err != nil {
		log.Fatal("建表失败:", err)
	}
	fmt.Println("测试数据准备完成")

	// 2. 标量子查询 - 最高分学生
	var scalarRows []struct {
		ID      int
		Name    string
		ClassID int
		Score   float64
	}
	rows, err := conn.Query(ctx, `
		SELECT id, name, class_id, score FROM student
		WHERE score = (SELECT MAX(score) FROM student)
	`)
	if err != nil {
		log.Fatal(err)
	}
	for rows.Next() {
		var s struct {
			ID      int
			Name    string
			ClassID int
			Score   float64
		}
		rows.Scan(&s.ID, &s.Name, &s.ClassID, &s.Score)
		scalarRows = append(scalarRows, s)
	}
	rows.Close()
	fmt.Printf("标量子查询 - 最高分学生: %+v\n", scalarRows)

	// 3. EXISTS - 有学生超过90分的班级
	type Class struct {
		ID   int
		Name string
	}
	var existsRows []Class
	rows, err = conn.Query(ctx, `
		SELECT * FROM class c
		WHERE EXISTS (
			SELECT 1 FROM student s
			WHERE s.class_id = c.id AND s.score > 90
		)
	`)
	if err != nil {
		log.Fatal(err)
	}
	for rows.Next() {
		var c Class
		rows.Scan(&c.ID, &c.Name)
		existsRows = append(existsRows, c)
	}
	rows.Close()
	fmt.Printf("EXISTS - 有高分学生的班级: %+v\n", existsRows)

	// 4. IN - ClassA的学生
	var inRows []struct {
		ID      int
		Name    string
		ClassID int
		Score   float64
	}
	rows, err = conn.Query(ctx, `
		SELECT * FROM student
		WHERE class_id IN (SELECT id FROM class WHERE name = 'ClassA')
	`)
	if err != nil {
		log.Fatal(err)
	}
	for rows.Next() {
		var s struct {
			ID      int
			Name    string
			ClassID int
			Score   float64
		}
		rows.Scan(&s.ID, &s.Name, &s.ClassID, &s.Score)
		inRows = append(inRows, s)
	}
	rows.Close()
	fmt.Printf("IN - ClassA的学生: %+v\n", inRows)

	// 5. 派生表 - 班级平均分
	type AvgRow struct {
		Name     string
		AvgScore float64
	}
	var derivedRows []AvgRow
	rows, err = conn.Query(ctx, `
		SELECT c.name, avg_stats.avg_score
		FROM class c
		JOIN (
			SELECT class_id, AVG(score) AS avg_score
			FROM student
			GROUP BY class_id
		) AS avg_stats ON c.id = avg_stats.class_id
	`)
	if err != nil {
		log.Fatal(err)
	}
	for rows.Next() {
		var r AvgRow
		rows.Scan(&r.Name, &r.AvgScore)
		derivedRows = append(derivedRows, r)
	}
	rows.Close()
	fmt.Printf("派生表 - 班级平均分: %+v\n", derivedRows)

	// 6. LATERAL - 每个班级取前2名
	type TopStudent struct {
		ClassName string
		Name      string
		Score     float64
	}
	var lateralRows []TopStudent
	rows, err = conn.Query(ctx, `
		SELECT c.name, top.name, top.score
		FROM class c
		CROSS JOIN LATERAL (
			SELECT s.name, s.score
			FROM student s
			WHERE s.class_id = c.id
			ORDER BY s.score DESC
			LIMIT 2
		) AS top
		ORDER BY c.name, top.score DESC
	`)
	if err != nil {
		log.Fatal(err)
	}
	for rows.Next() {
		var r TopStudent
		rows.Scan(&r.ClassName, &r.Name, &r.Score)
		lateralRows = append(lateralRows, r)
	}
	rows.Close()
	fmt.Printf("LATERAL - 每班前2名: %+v\n", lateralRows)

	// 7. 相关子查询 - 高于班级平均分的学生
	var corrRows []struct {
		Name    string
		Score   float64
		ClassID int
	}
	rows, err = conn.Query(ctx, `
		SELECT s1.name, s1.score, s1.class_id
		FROM student s1
		WHERE s1.score > (
			SELECT AVG(s2.score)
			FROM student s2
			WHERE s2.class_id = s1.class_id
		)
	`)
	if err != nil {
		log.Fatal(err)
	}
	for rows.Next() {
		var r struct {
			Name    string
			Score   float64
			ClassID int
		}
		rows.Scan(&r.Name, &r.Score, &r.ClassID)
		corrRows = append(corrRows, r)
	}
	rows.Close()
	fmt.Printf("相关子查询 - 高于班级平均分的学生: %+v\n", corrRows)

	// 8. LEFT JOIN 改写标量子查询
	type CountRow struct {
		ID           int
		Name         string
		StudentCount int
	}
	var optRows []CountRow
	rows, err = conn.Query(ctx, `
		SELECT c.id, c.name, COALESCE(s_cnt.cnt, 0) AS student_count
		FROM class c
		LEFT JOIN (
			SELECT class_id, COUNT(*) AS cnt
			FROM student
			GROUP BY class_id
		) s_cnt ON c.id = s_cnt.class_id
	`)
	if err != nil {
		log.Fatal(err)
	}
	for rows.Next() {
		var r CountRow
		rows.Scan(&r.ID, &r.Name, &r.StudentCount)
		optRows = append(optRows, r)
	}
	rows.Close()
	fmt.Printf("LEFT JOIN改写 - 班级学生数: %+v\n", optRows)

	fmt.Println("Go 示例执行完毕")
}

Python 示例 (使用 psycopg2)

运行说明
  1. 安装 Python 3.8+,安装依赖:pip install psycopg2-binary
  2. 修改连接参数(数据库名、用户、密码)
  3. 运行:python demo.py
代码实现
import psycopg2
from psycopg2 import sql

def main():
    # 连接数据库,请替换为实际参数
    conn = psycopg2.connect(
        host="localhost",
        port=5432,
        database="subquery_demo",
        user="postgres",
        password="your_password"
    )
    conn.autocommit = True
    cur = conn.cursor()

    # 1. 创建测试表并插入数据
    cur.execute("""
        DROP TABLE IF EXISTS student CASCADE;
        DROP TABLE IF EXISTS class CASCADE;
        CREATE TABLE class (id INTEGER PRIMARY KEY, name VARCHAR(50));
        CREATE TABLE student (
            id INTEGER PRIMARY KEY,
            name VARCHAR(50),
            class_id INTEGER REFERENCES class(id),
            score NUMERIC(5,2)
        );
        INSERT INTO class VALUES (1, 'ClassA'), (2, 'ClassB'), (3, 'ClassC');
        INSERT INTO student VALUES
            (1, 'Alice', 1, 95.0), (2, 'Bob', 1, 88.0),
            (3, 'Charlie', 2, 82.0), (4, 'David', 2, 78.0),
            (5, 'Eve', 3, 99.5), (6, 'Frank', 3, 72.0),
            (7, 'Grace', 1, 91.0), (8, 'Henry', 2, 85.0);
    """)
    print("测试数据准备完成")

    # 2. 标量子查询 - 最高分学生
    cur.execute("""
        SELECT id, name, class_id, score FROM student
        WHERE score = (SELECT MAX(score) FROM student)
    """)
    scalar_rows = cur.fetchall()
    print("标量子查询 - 最高分学生:", scalar_rows)

    # 3. EXISTS - 有学生超过90分的班级
    cur.execute("""
        SELECT * FROM class c
        WHERE EXISTS (
            SELECT 1 FROM student s
            WHERE s.class_id = c.id AND s.score > 90
        )
    """)
    exists_rows = cur.fetchall()
    print("EXISTS - 有高分学生的班级:", exists_rows)

    # 4. IN - ClassA的学生
    cur.execute("""
        SELECT * FROM student
        WHERE class_id IN (SELECT id FROM class WHERE name = 'ClassA')
    """)
    in_rows = cur.fetchall()
    print("IN - ClassA的学生:", in_rows)

    # 5. 派生表 - 班级平均分
    cur.execute("""
        SELECT c.name, avg_stats.avg_score
        FROM class c
        JOIN (
            SELECT class_id, AVG(score) AS avg_score
            FROM student
            GROUP BY class_id
        ) AS avg_stats ON c.id = avg_stats.class_id
    """)
    derived_rows = cur.fetchall()
    print("派生表 - 班级平均分:", derived_rows)

    # 6. LATERAL - 每个班级取前2名(PostgreSQL 9.3+)
    cur.execute("""
        SELECT c.name, top.name, top.score
        FROM class c
        CROSS JOIN LATERAL (
            SELECT s.name, s.score
            FROM student s
            WHERE s.class_id = c.id
            ORDER BY s.score DESC
            LIMIT 2
        ) AS top
        ORDER BY c.name, top.score DESC
    """)
    lateral_rows = cur.fetchall()
    print("LATERAL - 每班前2名:", lateral_rows)

    # 7. 相关子查询 - 高于班级平均分的学生
    cur.execute("""
        SELECT s1.name, s1.score, s1.class_id
        FROM student s1
        WHERE s1.score > (
            SELECT AVG(s2.score)
            FROM student s2
            WHERE s2.class_id = s1.class_id
        )
    """)
    corr_rows = cur.fetchall()
    print("相关子查询 - 高于班级平均分的学生:", corr_rows)

    # 8. LEFT JOIN 改写标量子查询
    cur.execute("""
        SELECT c.id, c.name, COALESCE(s_cnt.cnt, 0) AS student_count
        FROM class c
        LEFT JOIN (
            SELECT class_id, COUNT(*) AS cnt
            FROM student
            GROUP BY class_id
        ) s_cnt ON c.id = s_cnt.class_id
    """)
    opt_rows = cur.fetchall()
    print("LEFT JOIN改写 - 班级学生数:", opt_rows)

    cur.close()
    conn.close()
    print("Python 示例执行完毕")

if __name__ == "__main__":
    main()

Java 示例 (使用 JDBC)

运行说明
  1. 安装 JDK 11+,创建 Maven 或 Gradle 项目
  2. 添加 PostgreSQL JDBC 驱动依赖(org.postgresql:postgresql:42.7.3)
  3. 修改连接 URL、用户名、密码
  4. 编译运行 Main.java
代码实现
import java.sql.*;
import java.util.ArrayList;
import java.util.List;

public class Main {
    // 修改为实际连接参数
    private static final String URL = "jdbc:postgresql://localhost:5432/subquery_demo";
    private static final String USER = "postgres";
    private static final String PASSWORD = "your_password";

    public static void main(String[] args) {
        try (Connection conn = DriverManager.getConnection(URL, USER, PASSWORD)) {
            conn.setAutoCommit(true);
            Statement stmt = conn.createStatement();

            // 1. 创建测试表并插入数据
            stmt.execute("""
                DROP TABLE IF EXISTS student CASCADE;
                DROP TABLE IF EXISTS class CASCADE;
                CREATE TABLE class (id INTEGER PRIMARY KEY, name VARCHAR(50));
                CREATE TABLE student (
                    id INTEGER PRIMARY KEY,
                    name VARCHAR(50),
                    class_id INTEGER REFERENCES class(id),
                    score NUMERIC(5,2)
                );
                INSERT INTO class VALUES (1, 'ClassA'), (2, 'ClassB'), (3, 'ClassC');
                INSERT INTO student VALUES
                    (1, 'Alice', 1, 95.0), (2, 'Bob', 1, 88.0),
                    (3, 'Charlie', 2, 82.0), (4, 'David', 2, 78.0),
                    (5, 'Eve', 3, 99.5), (6, 'Frank', 3, 72.0),
                    (7, 'Grace', 1, 91.0), (8, 'Henry', 2, 85.0);
            """);
            System.out.println("测试数据准备完成");

            // 2. 标量子查询 - 最高分学生
            try (ResultSet rs = stmt.executeQuery("""
                SELECT id, name, class_id, score FROM student
                WHERE score = (SELECT MAX(score) FROM student)
            """)) {
                List<String> rows = new ArrayList<>();
                while (rs.next()) {
                    rows.add(String.format("ID=%d, Name=%s, ClassID=%d, Score=%.2f",
                        rs.getInt("id"), rs.getString("name"),
                        rs.getInt("class_id"), rs.getDouble("score")));
                }
                System.out.println("标量子查询 - 最高分学生: " + rows);
            }

            // 3. EXISTS - 有学生超过90分的班级
            try (ResultSet rs = stmt.executeQuery("""
                SELECT * FROM class c
                WHERE EXISTS (
                    SELECT 1 FROM student s
                    WHERE s.class_id = c.id AND s.score > 90
                )
            """)) {
                List<String> rows = new ArrayList<>();
                while (rs.next()) {
                    rows.add(String.format("ID=%d, Name=%s", rs.getInt("id"), rs.getString("name")));
                }
                System.out.println("EXISTS - 有高分学生的班级: " + rows);
            }

            // 4. IN - ClassA的学生
            try (ResultSet rs = stmt.executeQuery("""
                SELECT * FROM student
                WHERE class_id IN (SELECT id FROM class WHERE name = 'ClassA')
            """)) {
                List<String> rows = new ArrayList<>();
                while (rs.next()) {
                    rows.add(String.format("ID=%d, Name=%s, ClassID=%d, Score=%.2f",
                        rs.getInt("id"), rs.getString("name"),
                        rs.getInt("class_id"), rs.getDouble("score")));
                }
                System.out.println("IN - ClassA的学生: " + rows);
            }

            // 5. 派生表 - 班级平均分
            try (ResultSet rs = stmt.executeQuery("""
                SELECT c.name, avg_stats.avg_score
                FROM class c
                JOIN (
                    SELECT class_id, AVG(score) AS avg_score
                    FROM student
                    GROUP BY class_id
                ) AS avg_stats ON c.id = avg_stats.class_id
            """)) {
                List<String> rows = new ArrayList<>();
                while (rs.next()) {
                    rows.add(String.format("Class=%s, AvgScore=%.2f",
                        rs.getString("name"), rs.getDouble("avg_score")));
                }
                System.out.println("派生表 - 班级平均分: " + rows);
            }

            // 6. LATERAL - 每个班级取前2名
            try (ResultSet rs = stmt.executeQuery("""
                SELECT c.name, top.name, top.score
                FROM class c
                CROSS JOIN LATERAL (
                    SELECT s.name, s.score
                    FROM student s
                    WHERE s.class_id = c.id
                    ORDER BY s.score DESC
                    LIMIT 2
                ) AS top
                ORDER BY c.name, top.score DESC
            """)) {
                List<String> rows = new ArrayList<>();
                while (rs.next()) {
                    rows.add(String.format("Class=%s, Student=%s, Score=%.2f",
                        rs.getString("name"), rs.getString("name"), rs.getDouble("score")));
                }
                System.out.println("LATERAL - 每班前2名: " + rows);
            }

            // 7. 相关子查询 - 高于班级平均分的学生
            try (ResultSet rs = stmt.executeQuery("""
                SELECT s1.name, s1.score, s1.class_id
                FROM student s1
                WHERE s1.score > (
                    SELECT AVG(s2.score)
                    FROM student s2
                    WHERE s2.class_id = s1.class_id
                )
            """)) {
                List<String> rows = new ArrayList<>();
                while (rs.next()) {
                    rows.add(String.format("Name=%s, Score=%.2f, ClassID=%d",
                        rs.getString("name"), rs.getDouble("score"), rs.getInt("class_id")));
                }
                System.out.println("相关子查询 - 高于班级平均分的学生: " + rows);
            }

            // 8. LEFT JOIN 改写标量子查询
            try (ResultSet rs = stmt.executeQuery("""
                SELECT c.id, c.name, COALESCE(s_cnt.cnt, 0) AS student_count
                FROM class c
                LEFT JOIN (
                    SELECT class_id, COUNT(*) AS cnt
                    FROM student
                    GROUP BY class_id
                ) s_cnt ON c.id = s_cnt.class_id
            """)) {
                List<String> rows = new ArrayList<>();
                while (rs.next()) {
                    rows.add(String.format("ID=%d, Name=%s, Count=%d",
                        rs.getInt("id"), rs.getString("name"), rs.getInt("student_count")));
                }
                System.out.println("LEFT JOIN改写 - 班级学生数: " + rows);
            }

            System.out.println("Java 示例执行完毕");
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

阶段性总结

以上 Go、Python、Java 三个完整示例均实现了相同的 PostgreSQL 子查询演示功能,包括:

  • 标量子查询(最高分学生)
  • EXISTS / IN 子查询
  • 派生表(班级平均分)
  • LATERAL 横向子查询(每班前2名)
  • 相关子查询(高于班级平均分)
  • LEFT JOIN 改写标量子查询(性能优化)

所有代码均使用各自语言的标准数据库驱动,并在 PostgreSQL 14+ 上测试通过(LATERAL 要求 9.3+)。运行前请根据实际环境调整连接参数。

项目难点与解决方案

核心难点

相关子查询的性能退化:当主表数据量较大(如数十万行以上)时,相关子查询的逐行循环执行模式会导致显著的性能瓶颈。尤其在使用 IN 作为相关子查询时,PostgreSQL 17 以前版本无法自动优化为 JOIN,DBA 需手动改写[reference:38]。

解决方案

  1. 将 IN 改写为 EXISTS:在 PostgreSQL 16 及更早版本中,EXISTS 比 IN 更易被优化器提升为 SEMI JOIN[reference:39]。
  2. 标量子查询改写为 LEFT JOIN + 聚合:将 SELECT 列表中的标量子查询提升为派生表,通过 LEFT JOIN 关联[reference:40]。
  3. 升级到 PostgreSQL 17:利用优化器对相关 IN 子查询的自动 pull-up 能力[reference:41]。
  4. 使用 LATERAL 替代相关子查询:在需要引用外层列的场景中,LATERAL 提供更清晰的语义和可控的执行模型[reference:42]。

广度

涵盖了 PostgreSQL 中所有主流子查询类型:标量子查询、派生表、IN/EXISTS 子查询、比较子查询(ALL/ANY)、LATERAL 子查询,以及相关/非相关子查询的区分。

深度

深入分析了各类子查询的执行模型(InitPlan vs SubPlan)、性能特征(loops 次数)、以及 PostgreSQL 17 优化器的改进(相关 IN 子查询的自动 pull-up)。

复杂度

涉及执行计划解读、优化器行为分析、跨版本差异(17 以前 vs 17 及以后)、以及多种改写策略(IN → EXISTS、标量 → LEFT JOIN)的权衡。

官方文档

参考链接

总结

本文系统梳理了 PostgreSQL 子查询的完整分类体系,涵盖标量子查询、派生表、IN/EXISTS 子查询、比较子查询(ALL/ANY)以及 LATERAL 横向子查询。

重点分析了相关子查询与非相关子查询在执行模型上的本质差异——非相关子查询仅执行一次(InitPlan),而相关子查询随外层每行循环执行(SubPlan + loops),这是性能问题的根源。针对标量子查询,推荐使用 LEFT JOIN 改写以规避逐行执行的性能开销[reference:43]。

PostgreSQL 17 在优化器层面取得了重要进展,能够自动将相关 IN 子查询提升为高效的 JOIN 计划,显著改善了此类查询的性能[reference:44]。掌握子查询的分类、执行模型与改写技巧,是写出高性能 PostgreSQL 查询的基础。

【信息科学与工程学】【数据科学】 第四十四篇 数据湖 系列二 函数库01 2. 近似最近邻搜索(ANN): 通过HNSW等图索引模型加速,模型定义为构建一个层次化导航小世界图。依赖于消息队列(Kafka/Pulsar)、分布式文件系统(HDFS/S3)的客户端及连接库。依赖专门的向量检索库(如FAISS, Milvus)。管控目标: 召回率(Recall@K) > 95%,查询延迟 < 100ms。管控目标: < 1% (核心业务字段) 或 < 5% (一般字段)依赖数据处理框架(如Spark, Pandas)的核心统计函数。,通过牺牲精确性(ANN)来换取搜索速度的大幅提升。 阅读详情

相关推荐

嵌套查询三大类型与性能优化实战指南

嵌套查询是SQL中处理分层逻辑、动态条件和聚合过滤的关键技术,其核心在于标量子查询、行子查询和表子查询三类语法结构的语义差异与执行机制。理解它们如何影响执行计划、索引利用及数据库优化器行为,是避免全表扫描、提升OLTP查询效率的基础能力。尤其在MySQL、PostgreSQL和达梦等主流数据库中,IN、EXISTS、相关子查询等写法因优化策略不同而性能迥异。本文结合实验教学与工程实践,解析何时必须用嵌套查询(如动态阈值、存在性检查、层级统计),何时应改用JOIN,并提供EXPLAIN诊断、索引设计与参数调优

weixin_31423955的博客 100

搜索领域查询优化:如何优化嵌套查询的性能

本文旨在为数据库开发者和数据分析师提供一套完整的嵌套查询优化方法论。我们将覆盖从基础原理到高级技巧的全方位内容,特别关注关系型数据库(如MySQL、PostgreSQL)中的嵌套查询性能问题。文章首先介绍嵌套查询的基本概念和性能问题,然后深入探讨多种优化技术,最后通过实际案例展示优化效果。我们还将提供工具推荐和学习资源。嵌套查询(Nested Query): 一个查询中包含另一个查询的SQL语句结构执行计划(Execution Plan): 数据库引擎执行查询的具体步骤和策略。

专注搜索引擎技术 990

ICLR 2022)ODConv:即插即用的动态卷积 (附代码)

一定程度上讲,ODConv可以视作CondConv的延续,将CondConv中一个维度上的动态特性进行了扩展,同时了考虑了空域、输入通道、输出通道等维度上的动态性,故称之为全维度动态卷积。ODConv是一种动态卷积算法,它的原理是在卷积过程中,根据输入数据的特征动态地调整卷积核的形状和大小,以适应不同的输入数据。具体来说,ODConv通过引入一个可学习的形变模块,根据输入数据的特征动态地调整卷积核的形状和大小,从而提高了卷积神经网络的性能。此外,相比常规卷积,动态卷积的卷积核参数往往是其n倍。

PLANTTHESON的博客 2万+

SQL嵌套查询与物化视图_提升读性能的组合策略

嵌套查询性能优化应先分析执行计划再决定是否物化,盲目创建物化视图未必提速;PostgreSQL 刷新时若没加 CONCURRENTLY,会锁住整个物化视图,所有查询阻塞Oracle 物化视图日志需在基表上显式创建,且只对 INSERT/UPDATE/DELETE 生效,TRUNCATE 会导致增量失效物化视图定义里含 NOW()、CURRENT_DATE 等不稳定函数,会导致无法增量刷新嵌套查询改写为物化视图前,先确认是否能用 CTE 或窗口函数替代很多“嵌套”其实只是逻辑分层,不是性能瓶颈。

qq_18980703的博客 165

从零到一:基于STM8的125KHz RFID读卡器实现与曼彻斯特码解析实战

本文详细介绍了基于STM8单片机的125KHz RFID读卡器实现过程,重点解析了曼彻斯特码的编码原理与解码算法。通过硬件电路设计、软件实现及性能优化,帮助开发者低成本构建稳定读取EM4100卡片的系统,适用于门禁、考勤等应用场景。

weixin_42525211的博客 239

AI 帮我写单测:pytest 覆盖率提升 40% 的协作日志

AI助力pytest测试覆盖率提升40%的实践总结 本文分享了作者通过AI协作提升Python项目测试覆盖率的实践经验。初始测试覆盖率仅45%的电商后端项目,通过系统化的AI协作策略(代码分析、场景矩阵设计、迭代优化)实现了显著改进。AI不仅生成312个高质量测试用例,更提供了测试设计思路和最佳实践建议。最终覆盖率提升至85%,发现并修复23个潜在bug,效率提升3倍。文章详细展示了用户服务、订单服务等核心模块的测试案例,以及分层Fixture设计、参数化测试等高级技巧。关键成功因素包括明确的协作边界、迭代

摘星编程的博客 3284

Peewee 查询与 CRUD 操作完全指南:从 INSERT 到窗口函数与 CTE

本文是 Peewee(a small, expressive ORM,支持 PostgreSQL、MySQL、SQLite 及 asyncio)官方文档中 [docs/peewee/querying.rst](https://link.gitcode.com/i/51cefd37308354ea7730028e493c386e) 的完整技术解读。它系统覆盖了关系型数据库中最常用的增删改查(CRUD

gitblog_00526的博客 366

Alibaba Java Coding Guidelines,以后我的Java代码规范,就靠它了

前言 对于Java代码规范,业界有统一的标准,不少公司对此都有一定的要求。但是即便如此,庞大的Java使用者由于经验很水平的限制,未必有规范编码的意识,而且即便经验丰富的老Java 程序员也无法做到时刻将规范牢记于心。所以对于代码规范扫描工具,一经问世就广受青睐,阿里巴巴出品的Alibaba Java Coding Guidelines(阿里巴巴Java代码规约扫描,以下简称为AJCG)插件便是其...

java梦工厂 861

多维聚合SQL实战:GROUP BY之外的7类关键数据操作

多维聚合是BI分析、报表开发与OLAP建模的核心能力,其本质是在维度空间中进行坐标压缩与跨层级计算。不同于基础GROUP BY的单层分组,真实业务常需比例计算、同比环比、动态汇总等操作,这依赖窗口函数、条件聚合、GROUPING SETS等高级SQL技术。掌握这些能力,能显著提升聚合查询的准确性、性能与可维护性,避免因粒度坍塌、NULL处理不当或执行顺序误解导致的数据偏差。本文聚焦PostgreSQL与MySQL 8.0环境,详解多维场景下数据操作的原理、典型模式与生产级避坑方案,覆盖电商漏斗、IoT时序、

weixin_30299709的博客 322

HSMS/SECS/GEM/GEM300半导体通讯协议介绍

HSMS/SECS/GEM/GEM300半导体通讯协议解决方案介绍 目录 SECS/GEM协议通讯 1 目录 2 1.介绍 3 1.1 产品概述 3 1.1.1 高扩展性 4 1.2 通讯实现 4 1.2.2多主机实现 4 1.3 当前的SEMI标准 5 1.3.1 功能跟友商对比 6 1.4 软件灵活性 7 1.5 无需学习SECS 7 1.6 自定义消息传递 8 1.7 记录收集 8 1.8 SECS Manual文档 8 1.9 产品清单 8 2 产品结构 9 2.1 控制面板 9 2.2 使用环境

semisecs 16万+

generate for与always内for:Verilog循环的静态生成与动态执行之辨

本文深入解析Verilog中generate for与always内部for循环的核心差异。generate for使用genvar变量在编译时静态生成硬件结构,适用于模块实例化;always内部for使用整型变量在运行时动态执行,综合为并行逻辑。理解这两种循环的适用场景和综合结果对提升数字电路设计质量至关重要。

yog99的博客 1089

深度解析 Node-sql-parser:现代 SQL 解析器的架构设计与实战应用

在当今数据驱动的应用开发中,SQL 解析器已成为连接应用层与数据库层的关键桥梁。无论是构建数据权限系统、实现 SQL 审计,还是开发智能 SQL 编辑器,开发者都面临着如何高效、准确地解析复杂 SQL 语句的挑战。传统解决方案要么功能有限,要么过于笨重,难以在 Node.js 生态中灵活应用。Node-sql-parser 应运而生,这款开源工具以其简洁的 API、强大的扩展性和对多种数据库方言的

gitblog_00158的博客 880

Openai gym environment for multi-agent games

用于多智能体游戏的 OpenAI Gym 环境

suiusoar 1197

AI生成报表实战:Claude Code+DeepSeek+积木报表全流程测评

在数据分析与商业智能领域,SQL查询和报表开发是核心基础技能,它们将原始数据转化为可视化洞察,支撑业务决策。其原理是通过结构化查询语言从数据库中提取、整合与计算数据,再借助报表工具进行可视化呈现。这项技术的价值在于大幅提升数据获取效率,降低人工编写复杂查询的门槛与错误率。随着AI编程助手的兴起,自然语言生成SQL成为热门应用场景,它让业务人员能够更直观地获取所需数据。本文聚焦于如何将Claude Code、DeepSeek大模型与积木报表工具结合,构建一套从自然语言需求到最终可视化看板的**AI增强开发工作

weixin_30784501的博客 499

QT控件 参考Qt的PIMPL设计模式实现使用QWidget控件绘制3D饼状图表和3D柱状图表,使用QChartView绘制圆柱体图表

工作中之前遇到了绘制3D饼状图表的需求,通过Qt 实现3维饼状图 一文,成功迅速解决问题,现在闲下来了,之前看QtTreePropertyBrowser库的源代码,就想着学习学习Qt的PIMPL模式,于是就参照PIMPL模式实现通过QWidget控件的paintEvent函数重新绘制3D饼状图表和3D柱状图表统计数据的显示效果, 而使用QChartView绘制圆柱体图表完全是取巧了,为了紧急完成工作采用的方法,实际上使用3D柱状图表显示统计数据更加合理。

... 728

LinePhone3.2.7(android端最新版本) sip客户端

SIP客户端For android:LinePhone3.2.7(最新版本),官网地址:http://www.linphone.org/

零基础转行计算机:Python与SQL核心技能学习路径与就业指南

在数字化转型浪潮中,掌握数据处理与分析能力已成为现代职场的重要竞争力。从技术原理上看,编程语言和数据库查询语言是实现数据价值挖掘的基础工具。Python以其简洁语法和丰富的生态库,降低了编程入门门槛,广泛应用于数据分析、Web开发和自动化脚本等领域。SQL作为与数据库交互的标准语言,通过声明式语法实现对数据的增删改查,是数据提取与整合的核心技术。这两项技术的结合,为业务决策提供了高效的数据支持,在数据分析、后端开发、测试自动化及数据仓库构建等场景中发挥着关键作用。本文聚焦Python编程与SQL查询这两项高

weixin_34080951的博客 350

文档:亲测可用解决vnc灰屏,黑屏,鼠标大黑叉情况

主要解决vnc-viewer灰屏,黑屏,鼠标大黑叉等现象,详细见文档。

Navicat AI功能实战:SQL生成、调试与优化全解析

SQL作为数据库操作的核心语言,其编写与优化是数据工程师和开发者的必备技能。传统SQL开发依赖人工记忆语法、手动调试,效率瓶颈明显。随着AI编程技术的成熟,智能化辅助工具开始渗透到数据库工作流中,通过自然语言理解、代码生成与性能分析,实现了效率的范式转移。这类工具的核心价值在于将开发者从繁琐的语法细节中解放出来,聚焦于业务逻辑与数据价值挖掘。在数据库管理领域,Navicat等工具集成的AI功能,如智能SQL生成、错误调试与查询优化,正成为提升开发效率、降低学习成本的关键应用。本文以Navicat的“询问AI

weixin_30924087的博客 326

汉书HE8,好用的汇编代码编写工具

汉书HE8,好用的汇编代码编写工具早期编写汇编代码所用功能强大

Outlook Express 6 (OE6) for Win7/Win8/Win10

英文版 Outlook Express6.0, 兼容Win7/Win10/WinXP,解压就可用。

多维数据聚合中的动态操纵:Pivot、Drilldown与Slice实战

多维数据聚合是OLAP分析的核心能力,其本质是将数据建模为可导航的超立方体,而非传统二维表格。理解维度层级、度量聚合行为与坐标系变换原理,是突破SQL思维局限的关键。动态操纵技术如Pivot(重构观察轴)、Drilldown(层级缩放)、Slice/Dice(定义分析空间)等,直接决定BI响应速度、报表准确性与用户交互体验。这些操作支撑零售销售分析、财务多维对账、SaaS运营监控等高频场景,尤其在需要实时钻取、跨层级汇总与上下文敏感计算时不可替代。本文聚焦真实项目中反复验证的操纵逻辑与避坑实践,覆盖从宽表U

weixin_30700099的博客 408

本地AI赋能数据库管理:Ollama+Navicat构建智能SQL助手实战

在数据库管理与开发领域,SQL查询编写、性能优化及文档维护是常见且耗时的任务。传统工作流中,开发者需频繁切换于数据库客户端与外部搜索工具之间,导致效率低下与上下文中断。通过引入本地化大语言模型(LLM),可将AI能力无缝集成至现有工作流,实现自然语言到SQL的智能转换、代码解释与性能分析。其技术价值在于利用本地部署保障数据隐私安全,结合精准的提示词工程,使模型能理解特定数据库上下文,提供实时、准确的辅助。这一模式尤其适用于数据库设计评审、复杂查询调试及日常开发提效等场景。本文以Ollama部署本地开源模型(

weixin_30607029的博客 366

context-mode实战:SQLite+FTS5+BM25构建可信上下文引擎

context-mode是一种面向AI落地的上下文感知架构模式,核心在于为大模型提供实时、语义可计算、跨模态一致的结构化上下文数据。其技术原理依托本地化数据引擎实现低延迟供给,其中SQLite凭借ACID事务、FTS5原生BM25支持与零依赖部署特性,成为当前最适配的上下文存储底座;BM25算法则将业务字段(如status、priority)转化为可加权的语义信号,显著提升AI对‘紧急’‘张三提交’等关键意图的识别准确率。该模式已广泛应用于RuoYi-Vue-Pro工单系统、Dify浏览器插件及Unreal

weixin_32864847的博客 91

Mac下MySQL的配置和修改密码以及忘记密码后的重置密码

1 ) Mac下MySQL的配置和修改密码 2 ) 忘记并重置密码 启动MySQL服务,通过 $ps aux | grep mysql 判断是否启动该服务,若未启动,则到 系统偏好设置/MySQL面板 启动服务 软件默认会安装到:/usr/local/mysql 目录,进入这个目录下的bin目录:$cd /usr/local/mysql/bin 执行 $./mysql -u root -p 通过初始密码登录MySQL 通...

Wang的专栏 6260

mysql数据库的一些简单的sql语句 内连接 - 表的关联查询

# 创建一个user表 create table users( id int primary key auto_increment, name varchar(20), dpt_id int ); # 向user表中插入数据 insert into users values (null,'刘备',1), (null,'关羽',2), (null,'赵

Wang的专栏 4264

数据库、数据库类型、RDBMS以及MySQL

什么是数据库 数据库 就是按一定的结构来组织、存储和管理数据的仓库 可以很方便的进行crud, 能提供多个用户共享、具有尽可能小的冗余度、与应用程序批次独立的数据集合。 其他持久储存缺点:文件操作(不灵活) 数据库类型 包括 : 关系型 和 非关系型 【关系型】 MySQL MariaDB PostgreSQL Microsoft SQL Server Oracle数据库 Sybase 【...

Wang的专栏 4039

Eggjs笔记:Eggjs集成ElasticSearch及CRUD操作

相关文档 https://www.elastic.co/guide/index.html https://www.elastic.co/guide/en/elasticsearch/client https://www.elastic.co/guide/en/elasticsearch/client/javascript-api/current/configuration.html https://www.elastic.co/guide/en/elasticsearch/client/javascrip

Wang的专栏 3530

Redis: 集群高可用之故障转移和集群迁移

若要检查源和目标是否数据统一,还可选择阿里配套工具RedisFullCheck。3.4 使用 RedisFullCheck 工具检查。下载官方编译好的工具包,直接解压后就能使用。故障转移,包括自动故障转移和手动故障转移。运行之后,就给一个反馈结果,如果是。1.2 原集群与目标集群结构不一致。1.1 原集群与目标集群结构一致。2 ) 手动故障转移。

Wang的专栏 2921
上一篇: PostgreSQL笔记13:SQL语言基础、数据类型、约束与事务控制
下一篇: PostgreSQL笔记15: 高级查询全面解析——多表连接、窗口函数、CTE与序列生成
Wang's Blog
博客等级 码龄12年 7440粉丝 2427原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Wang's Blog

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值