PostgreSQL笔记62: 分区表维护最佳实践——默认分区、锁策略与性能调优

Redshift性能优化实战:DISTSTYLE、SORTKEY与WLM调优指南 Amazon Redshift并非传统关系型数据库,而是一款专为大规模并行分析设计的列式数据仓库引擎。其核心性能逻辑围绕数据分布(DISTSTYLE)、物理排序(SORTKEY)和工作负载管理(WLM)三大机制展开——数据分布不均直接导致计算节点空转,缺失合理SORTKEY将触发全表扫描,WLM配置失当则引发查询排队与资源争抢。这些底层原理决定了Redshift在TB级以上数据场景中具备显著优势,但在小规模或误配环境下反而劣于PostgreSQL。本文聚焦真实生产环境中的硬核调优实践,涵盖RA3节点选型、C 阅读详情

纲要

本文围绕 PostgreSQL 分区表的日常维护展开,涵盖以下核心技术点:

  • 默认分区 (DEFAULT PARTITION)

    • 定义与作用:作为“垃圾桶”捕获不匹配任何现有分区规则的行
    • 风险与代价:新增分区时的冲突检测与全表扫描开销
    • 维护策略:定期巡检、数据迁移与 DETACH 操作
    • 替代方案:UDF 触发器路由与 pg_pathman 插件
  • 分区的新增与卸载 (ATTACH PARTITION / DETACH PARTITION)

    • CREATE TABLE ... PARTITION OF 语法与八级锁 (ACCESS EXCLUSIVE) 问题
    • 最佳实践:CREATE TABLE + ATTACH PARTITION 方式与锁级别优化
    • PostgreSQL 12 改进:ATTACH PARTITION 降级为 SHARE UPDATE EXCLUSIVE
    • PostgreSQL 14 改进:DETACH PARTITION CONCURRENTLY 支持在线卸载
  • 分区智能连接与聚合 (enable_partitionwise_join / enable_partitionwise_aggregate)

    • 功能原理:分区间的两两 JOIN 与聚合
    • 适用条件:相同的分区策略、分区键作为连接条件的一部分
    • 代价与收益:CPU/内存消耗增加 vs 数据扫描量降低
    • 默认状态:off,按需开启
  • 分区表使用时机与原则

    • 官方建议:表大小超过物理内存时考虑分区
    • 量化参考:记录数 > 20 亿或表空间 > 200 GB
    • 反模式:小表分区与过度分区带来的性能损失
  • 分区插件生态

    • pg_pathman:PG 12 以前的主流方案,纯 SQL 脚本,运维友好
    • pg_partman:分区管理自动化工具
    • 原生分区的演进:PG 10 引入 → PG 11 增强 → PG 12 性能大幅提升

默认分区的设计与风险

PostgreSQL 的分区表采用声明式分区语法,每个分区通过 FOR VALUES 子句定义明确的边界。当插入的行不满足任何现有分区的约束时,PostgreSQL 默认会报错而非自动创建新分区。

默认分区(DEFAULT PARTITION)的引入正是为了解决这一问题。它的约束本质上是所有其他分区约束的“取反”集合——只要行不落入任何已定义分区,就会落入默认分区。这使得默认分区成为一个“来者不拒”的垃圾桶。

然而,默认分区的便利性背后隐藏着严重的维护成本:

新增分区时的冲突检测:当需要为新的数据范围(如十二月)创建分区时,如果默认分区中已存在属于该范围的数据,ATTACH PARTITION 操作将失败并报错 would be violated by some row。此时必须先将默认分区中的冲突数据迁移或删除,而这一过程需要对默认分区进行全表扫描以定位冲突行。若默认分区达到上百 GB,扫描开销极为可观。

挂载默认分区时的约束验证:将一张已有数据的表挂载为默认分区时,PostgreSQL 需要验证该表中的数据不与任何现有分区的约束重叠。这一验证同样需要全表扫描,在大数据量场景下效率低下。

分区裁剪失效:在 Greenplum 等基于 PostgreSQL 的分布式数据库中,默认分区的存在可能导致分区裁剪(Partition Pruning)失效,即使查询条件明确指向特定分区,优化器仍可能扫描默认分区。

默认分区的约束验证

通过查询系统表 pg_constraint,可以观察默认分区的约束定义。以下示例展示了一个按月范围分区的表及其默认分区的约束关系:

-- 创建分区表
CREATE TABLE sales (
    id SERIAL,
    sale_date DATE NOT NULL,
    amount NUMERIC(10,2)
) PARTITION BY RANGE (sale_date);

-- 创建一月分区
CREATE TABLE sales_2026_01 PARTITION OF sales
    FOR VALUES FROM ('2026-01-01') TO ('2026-02-01');

-- 创建二月分区
CREATE TABLE sales_2026_02 PARTITION OF sales
    FOR VALUES FROM ('2026-02-01') TO ('2026-03-01');

-- 创建默认分区
CREATE TABLE sales_default PARTITION OF sales DEFAULT;

-- 查看默认分区的约束(本质上是前两个分区约束的取反)
SELECT conname, contype, pg_get_constraintdef(oid) 
FROM pg_constraint 
WHERE conrelid = 'sales_default'::regclass;

默认分区的约束类似于 NOT (sale_date >= '2026-01-01' AND sale_date < '2026-02-01') AND NOT (sale_date >= '2026-02-01' AND sale_date < '2026-03-01'),即不满足任何已定义分区范围的行。

默认分区维护策略

针对默认分区的维护,建议采取以下策略:

  1. 定期巡检:通过监控默认分区的数据量,设置告警阈值(如超过 10 GB 即触发告警)。
  2. 数据迁移:在新增分区前,先将默认分区中属于新分区范围的数据导出备份,清理后再执行 ATTACH。
  3. 避免在生产环境长期保留大容量默认分区:默认分区应视为临时缓冲,而非长期存储区域。

触发器路由方案

一种替代默认分区的方案是使用触发器(UDF)实现动态路由:

CREATE OR REPLACE FUNCTION sales_insert_router()
RETURNS TRIGGER AS $$
BEGIN
    IF NEW.sale_date >= '2026-01-01' AND NEW.sale_date < '2026-02-01' THEN
        INSERT INTO sales_2026_01 VALUES (NEW.*);
    ELSIF NEW.sale_date >= '2026-02-01' AND NEW.sale_date < '2026-03-01' THEN
        INSERT INTO sales_2026_02 VALUES (NEW.*);
    ELSE
        RAISE EXCEPTION 'No partition for sale_date %', NEW.sale_date;
    END IF;
    RETURN NULL;
END;
$$ LANGUAGE plpgsql;

CREATE TRIGGER sales_insert_trigger
BEFORE INSERT ON sales
FOR EACH ROW EXECUTE FUNCTION sales_insert_router();

局限性:触发器方案在高并发写入场景下性能较差,因为每一行插入都需要额外的函数调用和条件判断,无法与 Oracle 的 Interval Partition 或原生分区路由的性能相媲美。

分区的新增与卸载:锁策略详解

新增分区的两种方式

PostgreSQL 提供了两种新增分区的语法,二者在锁级别上存在显著差异。

方式一:CREATE TABLE ... PARTITION OF

CREATE TABLE sales_2026_03 PARTITION OF sales
    FOR VALUES FROM ('2026-03-01') TO ('2026-04-01');

该语法会在父表上获取 ACCESS EXCLUSIVE 锁(八级锁),这是 PostgreSQL 中最重的锁级别,会阻塞父表上的所有读写操作。在生产环境中,这一操作可能导致数分钟乃至数小时的服务中断。

方式二:CREATE TABLE + ATTACH PARTITION

-- 先创建与父表结构一致的表
CREATE TABLE sales_2026_03 (LIKE sales INCLUDING ALL);

-- 再将其挂载为分区
ALTER TABLE sales ATTACH PARTITION sales_2026_03
    FOR VALUES FROM ('2026-03-01') TO ('2026-04-01');

在 PostgreSQL 12 及以上版本中,ATTACH PARTITION 仅在父表上获取 SHARE UPDATE EXCLUSIVE 锁。该锁级别与 VACUUM 和 ANALYZE 相同,允许并发的读写操作,仅阻塞 DDL 变更。

锁级别对比

操作方式PostgreSQL 版本父表锁级别是否阻塞读写
CREATE TABLE ... PARTITION OF所有版本ACCESS EXCLUSIVE是
CREATE TABLE + ATTACH PARTITION< 12ACCESS EXCLUSIVE是
CREATE TABLE + ATTACH PARTITION≥ 12SHARE UPDATE EXCLUSIVE否

锁级别验证

以下示例演示如何观察 ATTACH PARTITION 操作中的锁级别:

-- 窗口1:开启事务并执行 ATTACH
BEGIN;
ALTER TABLE sales ATTACH PARTITION sales_2026_03
    FOR VALUES FROM ('2026-03-01') TO ('2026-04-01');

-- 窗口2:查询锁信息
SELECT pid, locktype, mode, granted, relation::regclass
FROM pg_locks
WHERE relation = 'sales'::regclass;

预期输出中 mode 列显示为 ShareUpdateExclusiveLock,而非 AccessExclusiveLock。

卸载分区的两种方式

方式一:DETACH PARTITION(不带 CONCURRENTLY)

ALTER TABLE sales DETACH PARTITION sales_2026_01;

该操作在父表上获取 ACCESS EXCLUSIVE 锁,阻塞所有并发访问。

方式二:DETACH PARTITION CONCURRENTLY(PG 14+)

ALTER TABLE sales DETACH PARTITION sales_2026_01 CONCURRENTLY;

PostgreSQL 14 引入了 CONCURRENTLY 选项,将父表上的锁级别降为 SHARE UPDATE EXCLUSIVE。该操作内部使用两个事务完成,第一个事务进行准备,第二个事务完成卸载,整个过程不阻塞父表的读写操作。

注意:DETACH PARTITION CONCURRENTLY 的执行时间会比普通 DETACH 稍长,因其需要等待所有并发事务完成。但这一代价在需要保持服务连续性的场景中是值得的。

卸载后数据保留:DETACH 仅解除父子关系,子表及其数据仍然保留。若需彻底删除,可随后执行 DROP TABLE。

-- 解绑分区(保留数据)
ALTER TABLE sales DETACH PARTITION sales_2026_01;

-- 确认数据仍存在
SELECT COUNT(*) FROM sales_2026_01;

-- 彻底删除
DROP TABLE sales_2026_01;

分区智能连接与聚合

PostgreSQL 从版本 11 开始引入了分区智能连接(Partition-wise Join)和分区智能聚合(Partition-wise Aggregate)功能,通过两个配置参数控制:

  • enable_partitionwise_join:默认 off
  • enable_partitionwise_aggregate:默认 off

工作原理

未启用时:优化器将两个分区表的所有子表数据全部扫描后,在全局范围内执行 JOIN 或 GROUP BY。

启用后:优化器将 JOIN 或 GROUP BY 下推到各个分区对之间执行——分区1 JOIN 分区1、分区2 JOIN 分区2……最后将各分区的结果汇总。

启用分区智能连接

orders_1

JOIN

order_items_1

orders_2

JOIN

order_items_2

UNION ALL

结果

未启用分区智能连接

orders 分区表

全局 JOIN

order_items 分区表

结果

启用条件

分区智能连接并非在所有场景下都能生效,需满足以下条件:

  1. 两个分区表的分区策略必须完全一致(同为 Range 分区、List 分区或 Hash 分区)
  2. 分区键的数据类型必须一一对应
  3. 分区键必须作为 JOIN 条件的一部分
  4. 分区的边界必须能够一一匹配

代价与收益

维度未启用启用后
数据扫描量全量数据仅匹配分区对的数据
CPU 消耗较低较高(分区对间的 JOIN 调度开销)
内存消耗较低较高(多个并行 JOIN 工作区)
适用场景小数据集或分区数较少大数据集且分区数较多

在分区数较多(如数百个)且数据量巨大的场景下,启用分区智能连接可以显著降低 JOIN 的数据扫描量,但会带来额外的 CPU 和内存开销。建议在测试环境中通过 EXPLAIN ANALYZE 对比开启前后的执行计划与性能数据,再决定是否在生产环境中启用。

启用示例

-- 会话级别启用
SET enable_partitionwise_join = on;
SET enable_partitionwise_aggregate = on;

-- 执行 JOIN 查询
EXPLAIN (ANALYZE, BUFFERS)
SELECT o.order_id, o.order_date, SUM(i.quantity * i.unit_price)
FROM orders o
JOIN order_items i ON o.order_id = i.order_id AND o.order_date = i.order_date
GROUP BY o.order_id, o.order_date;

分区表的使用时机

官方建议

PostgreSQL 官方文档建议:当表的大小超过物理内存大小时,即可考虑使用分区表。这是因为当表无法全部缓存在内存中时,分区可以将数据按维度(如时间)分割,使查询仅扫描相关分区,从而减少 I/O 开销。

量化参考

以下为经验参考值,可根据实际硬件配置调整:

指标参考阈值说明
记录数> 20 亿单表记录数过多时,索引维护和 VACUUM 成本剧增
表空间> 200 GB超过物理内存大小,全表扫描代价高
更新频率频繁更新大表分区可减少 VACUUM 的扫描范围
数据保留策略需定期清理历史数据分区可通过 DROP 实现快速数据淘汰

反模式:何时不应使用分区

分区表示非银弹,以下场景应避免使用:

  1. 小表分区:仅一百条记录却划分十个分区,每个分区仅十条数据。优化器需要额外处理分区路由逻辑,反而增加查询规划时间,得不偿失。
  2. 分区策略不当:如按哈希分区但查询条件从不包含分区键,导致每次查询都扫描全部分区。
  3. 过度分区:分区数量过多(如数千个)时,查询规划时间可能显著增加。PostgreSQL 12 虽对此有大幅优化,但仍需谨慎评估。

分区插件生态

在 PostgreSQL 原生分区功能成熟之前,社区曾涌现多款分区管理插件:

插件适用版本特点
pg_pathmanPG 9.5 - PG 12纯 SQL 脚本,运维友好,性能优异
pg_partmanPG 9.4+功能丰富,支持自动创建和清理分区
pg_pitr—在线转换普通表为分区表

原生分区的演进:

  • PG 10:正式引入声明式分区(Declarative Partitioning)
  • PG 11:支持 Hash 分区、UPDATE 分区键自动跨分区移动
  • PG 12:分区性能大幅提升,与 pg_pathman 性能持平,支持外键引用分区表
  • PG 14:引入 DETACH PARTITION CONCURRENTLY,支持在线卸载

在 PG 12 之前,建议优先考虑 pg_pathman;PG 12 及以后版本,原生分区已足够成熟,可直接使用。

API 速览

CREATE TABLE ... PARTITION OF

所属:PostgreSQL DDL

语法:

CREATE TABLE partition_name PARTITION OF parent_table
    { FOR VALUES partition_bound_spec | DEFAULT }
    [ PARTITION BY { RANGE | LIST | HASH } ( column_name [, ...] ) ]
    [ WITH ( storage_parameter = value [, ... ] ) ]
    [ TABLESPACE tablespace_name ];

参数说明:

  • FOR VALUES:定义分区的值范围(Range/List)或模数余数(Hash)
  • DEFAULT:创建默认分区
  • PARTITION BY:允许分区表本身作为父表进行二级分区

锁级别:父表上获取 ACCESS EXCLUSIVE 锁

示例:

CREATE TABLE sales_2026_q1 PARTITION OF sales
    FOR VALUES FROM ('2026-01-01') TO ('2026-04-01');

ALTER TABLE ... ATTACH PARTITION

所属:PostgreSQL DDL

语法:

ALTER TABLE parent_table ATTACH PARTITION partition_name
    { FOR VALUES partition_bound_spec | DEFAULT };

锁级别:

  • PG 11 及以下:ACCESS EXCLUSIVE
  • PG 12 及以上:SHARE UPDATE EXCLUSIVE

示例:

ALTER TABLE sales ATTACH PARTITION sales_2026_q1
    FOR VALUES FROM ('2026-01-01') TO ('2026-04-01');

ALTER TABLE ... DETACH PARTITION

所属:PostgreSQL DDL

语法:

ALTER TABLE parent_table DETACH PARTITION partition_name
    [ CONCURRENTLY | FINALIZE ];

锁级别:

  • 不带 CONCURRENTLY:ACCESS EXCLUSIVE
  • 带 CONCURRENTLY(PG 14+):SHARE UPDATE EXCLUSIVE

示例:

-- 普通卸载(八级锁)
ALTER TABLE sales DETACH PARTITION sales_2026_q1;

-- 并发卸载(PG 14+,共享更新排他锁)
ALTER TABLE sales DETACH PARTITION sales_2026_q1 CONCURRENTLY;

SET enable_partitionwise_join

所属:PostgreSQL 运行时配置

类型:boolean

默认值:off

作用域:session / global

描述:启用或禁用查询规划器使用分区智能连接

示例:

SET enable_partitionwise_join = on;

SET enable_partitionwise_aggregate

所属:PostgreSQL 运行时配置

类型:boolean

默认值:off

作用域:session / global

描述:启用或禁用查询规划器使用分区智能聚合

示例:

SET enable_partitionwise_aggregate = on;

Demo 简单示例

以下使用 Node.js 和 pg 驱动演示分区表的创建、新增分区(含锁级别对比)与并发卸载。

运行说明

环境要求:

  • Node.js 16+
  • PostgreSQL 14+(建议 14 以体验 CONCURRENTLY 特性)
  • pg npm 包

安装依赖:

npm init -y
npm install pg

启动:

node partition_demo.js

代码说明

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

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

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

    try {
        // 1. 创建分区表
        await client.query(`
            DROP TABLE IF EXISTS sales CASCADE;
            CREATE TABLE sales (
                id SERIAL,
                sale_date DATE NOT NULL,
                amount NUMERIC(10,2)
            ) PARTITION BY RANGE (sale_date);
        `);
        console.log('✅ 分区表 sales 创建成功');

        // 2. 创建具体分区(一月、二月)
        await client.query(`
            CREATE TABLE sales_2026_01 PARTITION OF sales
                FOR VALUES FROM ('2026-01-01') TO ('2026-02-01');
            CREATE TABLE sales_2026_02 PARTITION OF sales
                FOR VALUES FROM ('2026-02-01') TO ('2026-03-01');
        `);
        console.log('✅ 一月、二月分区创建成功');

        // 3. 创建默认分区
        await client.query(`
            CREATE TABLE sales_default PARTITION OF sales DEFAULT;
        `);
        console.log('✅ 默认分区创建成功');

        // 4. 插入测试数据
        await client.query(`
            INSERT INTO sales (sale_date, amount) VALUES
                ('2026-01-15', 100.50),
                ('2026-02-15', 200.75),
                ('2026-12-15', 999.99);  -- 落入默认分区
        `);
        console.log('✅ 测试数据插入成功');

        // 5. 查询各分区数据分布
        const distResult = await client.query(`
            SELECT 'sales_2026_01' as partition_name, COUNT(*) as row_count FROM sales_2026_01
            UNION ALL
            SELECT 'sales_2026_02', COUNT(*) FROM sales_2026_02
            UNION ALL
            SELECT 'sales_default', COUNT(*) FROM sales_default
        `);
        console.log('📊 数据分布:');
        distResult.rows.forEach(row => {
            console.log(`   ${row.partition_name}: ${row.row_count} 行`);
        });

        // 6. 新增三月分区 —— 使用 CREATE TABLE + ATTACH(PG 12+ 仅 ShareUpdateExclusiveLock)
        await client.query(`
            CREATE TABLE sales_2026_03 (LIKE sales INCLUDING ALL);
        `);
        await client.query(`
            ALTER TABLE sales ATTACH PARTITION sales_2026_03
                FOR VALUES FROM ('2026-03-01') TO ('2026-04-01');
        `);
        console.log('✅ 三月分区通过 CREATE + ATTACH 方式创建成功(ShareUpdateExclusiveLock)');

        // 7. 演示 DETACH CONCURRENTLY(PG 14+)
        // 先插入一条三月数据
        await client.query(`
            INSERT INTO sales (sale_date, amount) VALUES ('2026-03-15', 300.25);
        `);

        // 并发卸载(PG 14+)
        await client.query(`
            ALTER TABLE sales DETACH PARTITION sales_2026_03 CONCURRENTLY;
        `);
        console.log('✅ 三月分区通过 DETACH CONCURRENTLY 卸载成功(ShareUpdateExclusiveLock)');

        // 8. 验证卸载后数据仍保留在子表中
        const checkResult = await client.query(`
            SELECT COUNT(*) as cnt FROM sales_2026_03;
        `);
        console.log(`📊 卸载后 sales_2026_03 表中仍有 ${checkResult.rows[0].cnt} 行数据`);

        // 9. 清理
        await client.query(`DROP TABLE sales_2026_03;`);
        console.log('✅ 清理完成');

    } catch (err) {
        console.error('❌ 错误:', err.message);
    } finally {
        await client.end();
    }
}

runDemo();

PostgreSQL 原生指令注释:

-- 等价的 PostgreSQL 原生操作
-- 创建分区表
CREATE TABLE sales (
    id SERIAL,
    sale_date DATE NOT NULL,
    amount NUMERIC(10,2)
) PARTITION BY RANGE (sale_date);

-- 创建分区
CREATE TABLE sales_2026_01 PARTITION OF sales
    FOR VALUES FROM ('2026-01-01') TO ('2026-02-01');

CREATE TABLE sales_2026_02 PARTITION OF sales
    FOR VALUES FROM ('2026-02-01') TO ('2026-03-01');

-- 创建默认分区
CREATE TABLE sales_default PARTITION OF sales DEFAULT;

-- 插入数据
INSERT INTO sales (sale_date, amount) VALUES
    ('2026-01-15', 100.50),
    ('2026-02-15', 200.75),
    ('2026-12-15', 999.99);

-- 新增分区(推荐方式)
CREATE TABLE sales_2026_03 (LIKE sales INCLUDING ALL);
ALTER TABLE sales ATTACH PARTITION sales_2026_03
    FOR VALUES FROM ('2026-03-01') TO ('2026-04-01');

-- 并发卸载(PG 14+)
ALTER TABLE sales DETACH PARTITION sales_2026_03 CONCURRENTLY;

-- 删除子表
DROP TABLE sales_2026_03;

技术点总结

该 Demo 演示了以下核心技术:

  1. 声明式分区表的创建:PARTITION BY RANGE 语法
  2. 默认分区的创建与行为:不匹配任何分区规则的行落入默认分区
  3. 分区新增的最佳实践:CREATE TABLE ... LIKE + ATTACH PARTITION 方式,避免八级锁
  4. 分区卸载的并发方式:PG 14 的 DETACH PARTITION CONCURRENTLY
  5. DETACH 与 DROP 的区别:DETACH 保留数据,DROP 彻底删除

多语言示例

以下分别使用 Go、Python 和 Java 实现与 Node.js 示例相同的分区表维护场景,涵盖默认分区、ATTACH PARTITION 与 DETACH PARTITION CONCURRENTLY 的核心操作。每种语言均提供完整的可运行代码及关键说明。

Go

运行说明

  • 环境要求:Go 1.21+,PostgreSQL 14+
  • 依赖驱动:github.com/lib/pq(纯 Go PostgreSQL 驱动)
  • 安装依赖:
    go mod init partition_demo
    go get github.com/lib/pq
    
  • 启动:将数据库连接信息填入 main.go 后执行 go run main.go

代码说明

使用 database/sql 标准库配合 lib/pq 驱动,通过 Exec 和 Query 执行原生 SQL。事务控制采用 Begin / Commit 确保原子性。代码结构与 Node.js 版本一致,依次执行创建分区表、创建子分区、创建默认分区、插入测试数据、新增分区(CREATE TABLE + ATTACH)和并发卸载(DETACH CONCURRENTLY)。

代码

package main

import (
    "database/sql"
    "fmt"
    "log"

    _ "github.com/lib/pq"
)

func main() {
    // 连接字符串:host=localhost port=5432 user=postgres password=postgres dbname=testdb sslmode=disable
    connStr := "host=localhost port=5432 user=postgres password=postgres dbname=testdb sslmode=disable"
    db, err := sql.Open("postgres", connStr)
    if err != nil {
        log.Fatal("连接失败:", err)
    }
    defer db.Close()

    if err := db.Ping(); err != nil {
        log.Fatal("Ping 失败:", err)
    }

    // 1. 创建分区表
    _, err = db.Exec(`
        DROP TABLE IF EXISTS sales CASCADE;
        CREATE TABLE sales (
            id SERIAL,
            sale_date DATE NOT NULL,
            amount NUMERIC(10,2)
        ) PARTITION BY RANGE (sale_date);
    `)
    if err != nil {
        log.Fatal("创建分区表失败:", err)
    }
    fmt.Println("✅ 分区表 sales 创建成功")

    // 2. 创建一月、二月分区
    _, err = db.Exec(`
        CREATE TABLE sales_2026_01 PARTITION OF sales
            FOR VALUES FROM ('2026-01-01') TO ('2026-02-01');
        CREATE TABLE sales_2026_02 PARTITION OF sales
            FOR VALUES FROM ('2026-02-01') TO ('2026-03-01');
    `)
    if err != nil {
        log.Fatal("创建具体分区失败:", err)
    }
    fmt.Println("✅ 一月、二月分区创建成功")

    // 3. 创建默认分区
    _, err = db.Exec(`
        CREATE TABLE sales_default PARTITION OF sales DEFAULT;
    `)
    if err != nil {
        log.Fatal("创建默认分区失败:", err)
    }
    fmt.Println("✅ 默认分区创建成功")

    // 4. 插入测试数据
    _, err = db.Exec(`
        INSERT INTO sales (sale_date, amount) VALUES
            ('2026-01-15', 100.50),
            ('2026-02-15', 200.75),
            ('2026-12-15', 999.99);
    `)
    if err != nil {
        log.Fatal("插入数据失败:", err)
    }
    fmt.Println("✅ 测试数据插入成功")

    // 5. 查询各分区数据分布
    rows, err := db.Query(`
        SELECT 'sales_2026_01' as partition_name, COUNT(*) as row_count FROM sales_2026_01
        UNION ALL
        SELECT 'sales_2026_02', COUNT(*) FROM sales_2026_02
        UNION ALL
        SELECT 'sales_default', COUNT(*) FROM sales_default
    `)
    if err != nil {
        log.Fatal("查询分布失败:", err)
    }
    defer rows.Close()
    fmt.Println("📊 数据分布:")
    for rows.Next() {
        var name string
        var count int
        rows.Scan(&name, &count)
        fmt.Printf("   %s: %d 行\n", name, count)
    }

    // 6. 新增三月分区(CREATE TABLE + ATTACH)
    _, err = db.Exec(`
        CREATE TABLE sales_2026_03 (LIKE sales INCLUDING ALL);
        ALTER TABLE sales ATTACH PARTITION sales_2026_03
            FOR VALUES FROM ('2026-03-01') TO ('2026-04-01');
    `)
    if err != nil {
        log.Fatal("新增三月分区失败:", err)
    }
    fmt.Println("✅ 三月分区通过 CREATE + ATTACH 创建成功 (ShareUpdateExclusiveLock)")

    // 7. 插入一条三月数据并演示 DETACH CONCURRENTLY (PG14+)
    _, err = db.Exec(`INSERT INTO sales (sale_date, amount) VALUES ('2026-03-15', 300.25);`)
    if err != nil {
        log.Fatal("插入三月数据失败:", err)
    }

    _, err = db.Exec(`ALTER TABLE sales DETACH PARTITION sales_2026_03 CONCURRENTLY;`)
    if err != nil {
        log.Fatal("并发卸载失败:", err)
    }
    fmt.Println("✅ 三月分区通过 DETACH CONCURRENTLY 卸载成功 (ShareUpdateExclusiveLock)")

    // 8. 验证卸载后子表数据仍保留
    var cnt int
    err = db.QueryRow(`SELECT COUNT(*) FROM sales_2026_03;`).Scan(&cnt)
    if err != nil {
        log.Fatal("查询子表失败:", err)
    }
    fmt.Printf("📊 卸载后 sales_2026_03 表中仍有 %d 行数据\n", cnt)

    // 9. 清理
    _, err = db.Exec(`DROP TABLE sales_2026_03;`)
    if err != nil {
        log.Fatal("清理失败:", err)
    }
    fmt.Println("✅ 清理完成")
}

技术点总结

  • 使用 database/sql 标准接口,无需 ORM,SQL 直观可控
  • 事务由 Exec 自动提交,若需事务可显式使用 Begin / Commit
  • 通过 QueryRow 获取单行结果,Query 遍历多行
  • 锁级别验证(如需要)可通过查询 pg_locks 实现,与 Node.js 一致

Python

运行说明

  • 环境要求:Python 3.9+,PostgreSQL 14+
  • 依赖驱动:psycopg2-binary(或 psycopg2)
  • 安装依赖:
    pip install psycopg2-binary
    
  • 启动:修改连接参数后执行 python partition_demo.py

代码说明

使用 psycopg2 连接 PostgreSQL,通过 cursor.execute() 执行 SQL。使用 with 上下文管理自动提交或回滚。代码顺序与 Node.js 相同,所有 SQL 语句均以字符串形式传递,参数化查询用于插入数据(安全防注入)。fetchall() 获取结果集。

代码

import psycopg2
import psycopg2.extras

def main():
    conn = psycopg2.connect(
        host="localhost",
        port=5432,
        database="testdb",
        user="postgres",
        password="postgres"
    )
    conn.autocommit = True  # 简化示例,每条SQL自动提交
    cur = conn.cursor()

    try:
        # 1. 创建分区表
        cur.execute("""
            DROP TABLE IF EXISTS sales CASCADE;
            CREATE TABLE sales (
                id SERIAL,
                sale_date DATE NOT NULL,
                amount NUMERIC(10,2)
            ) PARTITION BY RANGE (sale_date);
        """)
        print("✅ 分区表 sales 创建成功")

        # 2. 创建一月、二月分区
        cur.execute("""
            CREATE TABLE sales_2026_01 PARTITION OF sales
                FOR VALUES FROM ('2026-01-01') TO ('2026-02-01');
            CREATE TABLE sales_2026_02 PARTITION OF sales
                FOR VALUES FROM ('2026-02-01') TO ('2026-03-01');
        """)
        print("✅ 一月、二月分区创建成功")

        # 3. 默认分区
        cur.execute("""
            CREATE TABLE sales_default PARTITION OF sales DEFAULT;
        """)
        print("✅ 默认分区创建成功")

        # 4. 插入测试数据(使用参数化查询)
        data = [('2026-01-15', 100.50), ('2026-02-15', 200.75), ('2026-12-15', 999.99)]
        for dt, amt in data:
            cur.execute("INSERT INTO sales (sale_date, amount) VALUES (%s, %s);", (dt, amt))
        print("✅ 测试数据插入成功")

        # 5. 查询分布
        cur.execute("""
            SELECT 'sales_2026_01' as partition_name, COUNT(*) as row_count FROM sales_2026_01
            UNION ALL
            SELECT 'sales_2026_02', COUNT(*) FROM sales_2026_02
            UNION ALL
            SELECT 'sales_default', COUNT(*) FROM sales_default
        """)
        rows = cur.fetchall()
        print("📊 数据分布:")
        for name, count in rows:
            print(f"   {name}: {count} 行")

        # 6. 新增三月分区(CREATE + ATTACH)
        cur.execute("""
            CREATE TABLE sales_2026_03 (LIKE sales INCLUDING ALL);
            ALTER TABLE sales ATTACH PARTITION sales_2026_03
                FOR VALUES FROM ('2026-03-01') TO ('2026-04-01');
        """)
        print("✅ 三月分区通过 CREATE + ATTACH 创建成功 (ShareUpdateExclusiveLock)")

        # 7. 插入三月数据并并发卸载
        cur.execute("INSERT INTO sales (sale_date, amount) VALUES ('2026-03-15', 300.25);")
        cur.execute("ALTER TABLE sales DETACH PARTITION sales_2026_03 CONCURRENTLY;")
        print("✅ 三月分区通过 DETACH CONCURRENTLY 卸载成功 (ShareUpdateExclusiveLock)")

        # 8. 验证保留数据
        cur.execute("SELECT COUNT(*) FROM sales_2026_03;")
        cnt = cur.fetchone()[0]
        print(f"📊 卸载后 sales_2026_03 表中仍有 {cnt} 行数据")

        # 9. 清理
        cur.execute("DROP TABLE sales_2026_03;")
        print("✅ 清理完成")

    except Exception as e:
        print("❌ 错误:", e)
    finally:
        cur.close()
        conn.close()

if __name__ == "__main__":
    main()

技术点总结

  • 使用 psycopg2 的 autocommit=True 简化事务控制,实际生产可按需使用 conn.commit()
  • 参数化查询(%s 占位符)防止 SQL 注入
  • cursor.fetchall() 和 fetchone() 方便获取结果
  • 支持 CONCURRENTLY 语法,需确保 PostgreSQL 版本 ≥ 14

Java

运行说明

  • 环境要求:JDK 17+,PostgreSQL 14+
  • 依赖驱动:org.postgresql:postgresql:42.7.3(Maven/Gradle)
  • 构建工具:Maven 或 Gradle,以下示例使用 Maven 项目结构
  • 启动:编译后执行 main 方法

代码说明

使用 JDBC 原生 API,加载 org.postgresql.Driver。通过 DriverManager.getConnection 获取连接,使用 Statement 和 PreparedStatement 执行 SQL。为简洁采用 try-with-resources 自动释放资源。逻辑顺序与其他语言一致,注意 Java 中 executeUpdate 用于 DDL/DML,executeQuery 用于查询。

代码

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class PartitionDemo {
    public static void main(String[] args) {
        String url = "jdbc:postgresql://localhost:5432/testdb";
        String user = "postgres";
        String password = "postgres";

        try (Connection conn = DriverManager.getConnection(url, user, password)) {
            // 设置自动提交,简化示例
            conn.setAutoCommit(true);

            // 1. 创建分区表
            try (Statement stmt = conn.createStatement()) {
                stmt.executeUpdate("""
                    DROP TABLE IF EXISTS sales CASCADE;
                    CREATE TABLE sales (
                        id SERIAL,
                        sale_date DATE NOT NULL,
                        amount NUMERIC(10,2)
                    ) PARTITION BY RANGE (sale_date);
                """);
                System.out.println("✅ 分区表 sales 创建成功");
            }

            // 2. 创建一月、二月分区
            try (Statement stmt = conn.createStatement()) {
                stmt.executeUpdate("""
                    CREATE TABLE sales_2026_01 PARTITION OF sales
                        FOR VALUES FROM ('2026-01-01') TO ('2026-02-01');
                    CREATE TABLE sales_2026_02 PARTITION OF sales
                        FOR VALUES FROM ('2026-02-01') TO ('2026-03-01');
                """);
                System.out.println("✅ 一月、二月分区创建成功");
            }

            // 3. 默认分区
            try (Statement stmt = conn.createStatement()) {
                stmt.executeUpdate("CREATE TABLE sales_default PARTITION OF sales DEFAULT;");
                System.out.println("✅ 默认分区创建成功");
            }

            // 4. 插入测试数据(PreparedStatement)
            String insertSql = "INSERT INTO sales (sale_date, amount) VALUES (?, ?)";
            Object[][] data = {{"2026-01-15", 100.50}, {"2026-02-15", 200.75}, {"2026-12-15", 999.99}};
            try (PreparedStatement pstmt = conn.prepareStatement(insertSql)) {
                for (Object[] row : data) {
                    pstmt.setObject(1, row[0]);
                    pstmt.setObject(2, row[1]);
                    pstmt.addBatch();
                }
                pstmt.executeBatch();
                System.out.println("✅ 测试数据插入成功");
            }

            // 5. 查询分布
            String query = """
                SELECT 'sales_2026_01' as partition_name, COUNT(*) as row_count FROM sales_2026_01
                UNION ALL
                SELECT 'sales_2026_02', COUNT(*) FROM sales_2026_02
                UNION ALL
                SELECT 'sales_default', COUNT(*) FROM sales_default
                """;
            try (Statement stmt = conn.createStatement();
                 ResultSet rs = stmt.executeQuery(query)) {
                System.out.println("📊 数据分布:");
                while (rs.next()) {
                    String name = rs.getString("partition_name");
                    int count = rs.getInt("row_count");
                    System.out.printf("   %s: %d 行%n", name, count);
                }
            }

            // 6. 新增三月分区(CREATE + ATTACH)
            try (Statement stmt = conn.createStatement()) {
                stmt.executeUpdate("""
                    CREATE TABLE sales_2026_03 (LIKE sales INCLUDING ALL);
                    ALTER TABLE sales ATTACH PARTITION sales_2026_03
                        FOR VALUES FROM ('2026-03-01') TO ('2026-04-01');
                """);
                System.out.println("✅ 三月分区通过 CREATE + ATTACH 创建成功 (ShareUpdateExclusiveLock)");
            }

            // 7. 插入三月数据并并发卸载
            try (PreparedStatement pstmt = conn.prepareStatement("INSERT INTO sales (sale_date, amount) VALUES (?, ?)")) {
                pstmt.setObject(1, "2026-03-15");
                pstmt.setObject(2, 300.25);
                pstmt.executeUpdate();
            }
            try (Statement stmt = conn.createStatement()) {
                stmt.executeUpdate("ALTER TABLE sales DETACH PARTITION sales_2026_03 CONCURRENTLY;");
                System.out.println("✅ 三月分区通过 DETACH CONCURRENTLY 卸载成功 (ShareUpdateExclusiveLock)");
            }

            // 8. 验证保留数据
            try (Statement stmt = conn.createStatement();
                 ResultSet rs = stmt.executeQuery("SELECT COUNT(*) FROM sales_2026_03;")) {
                if (rs.next()) {
                    int cnt = rs.getInt(1);
                    System.out.printf("📊 卸载后 sales_2026_03 表中仍有 %d 行数据%n", cnt);
                }
            }

            // 9. 清理
            try (Statement stmt = conn.createStatement()) {
                stmt.executeUpdate("DROP TABLE sales_2026_03;");
                System.out.println("✅ 清理完成");
            }

        } catch (SQLException e) {
            System.err.println("❌ 错误: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

技术点总结

  • 使用 JDBC 标准接口,驱动为 postgresql-42.x.x.jar
  • 通过 Statement 执行 DDL,通过 PreparedStatement 执行参数化 DML 和批处理
  • try-with-resources 自动关闭资源,防止连接泄漏
  • 原生支持 CONCURRENTLY 语法,需 PG 14+
  • 可通过 conn.setAutoCommit(true) 简化,生产环境建议显式事务控制

多语言对比

维度Node.js (pg)Go (database/sql + lib/pq)Python (psycopg2)Java (JDBC)
驱动/ORMpg 驱动lib/pqpsycopg2-binarypostgresql-42.x.x
连接方式new Client()sql.Open()psycopg2.connect()DriverManager.getConnection()
执行 DDLclient.query()db.Exec()cur.execute()stmt.executeUpdate()
参数化查询模板字符串($1)? 占位符(lib/pq 使用 $1)%s 占位符? 占位符(JDBC)
批处理数组 + Promise.all不支持原生批处理(可循环)executemany()addBatch() + executeBatch()
事务控制BEGIN / COMMIT 或 client.query('BEGIN')db.Begin()conn.autocommit=False + conn.commit()conn.setAutoCommit(false) + conn.commit()
锁级别验证查询 pg_locks同 SQL同 SQL同 SQL
ATTACH 锁降级 (PG12+)支持支持支持支持
DETACH CONCURRENTLY (PG14+)支持支持支持支持
错误处理try/catcherror 返回值try/excepttry/catch
资源管理手动 client.end()defer db.Close()with 或 finallytry-with-resources

所有语言的实现均围绕相同的 SQL 操作展开,核心差异仅在于各自生态的 API 风格和连接管理方式。在生产环境中,可根据团队技术栈选择最适合的语言,分区表维护的 SQL 逻辑在各语言间完全通用。

官方文档

参考链接

总结

本文系统梳理了 PostgreSQL 分区表维护的三大核心议题:默认分区的设计与风险——虽能捕获不匹配任何规则的行,但新增分区时的冲突检测需全表扫描,建议定期巡检并控制其大小;分区新增与卸载的锁策略——CREATE TABLE ... PARTITION OF 持有八级锁,生产环境应改用 CREATE TABLE + ATTACH PARTITION(PG 12+ 降级为 SHARE UPDATE EXCLUSIVE),PG 14 进一步支持 DETACH PARTITION CONCURRENTLY 实现在线卸载;分区智能连接与聚合——通过 enable_partitionwise_join 和 enable_partitionwise_aggregate 参数启用,可减少 JOIN 数据扫描量,但需满足分区策略一致、分区键作为连接条件等前提,默认 off 按需开启。

此外,本文还提供了分区表使用时机的量化参考(记录数 > 20 亿或表空间 > 200 GB)以及 pg_pathman、pg_partman 等插件生态的演进脉络。PG 12 之后原生分区性能已大幅提升,建议优先使用原生方案。

PostgreSQL性能优化:PgTune工具实战指南 数据库性能优化是提升应用响应速度的关键环节,尤其对于PostgreSQL这样的开源关系型数据库。通过参数调优可以显著改善查询效率,其中shared_buffers、work_mem等内存参数直接影响缓存命中率和并发处理能力。PgTune作为智能配置工具,基于硬件规格和工作负载自动生成优化方案,解决了人工调参的复杂度问题。该工具特别适合Web应用和数据分析场景,能根据SSD存储、并发连接数等要素动态调整random_page_cost等关键参数。实践表明,合理配置可使查询延迟降低60%以上,是中小团队实现专业 阅读详情

相关推荐

PostGIS动态矢量瓦片性能翻车?百万级数据下的缓存策略与优化实战(附避坑指南)

当你的GIS应用从Demo走向生产环境,数据量从几千条激增到百万级时,原本流畅的动态矢量瓦片服务突然变得举步维艰。数据库CPU持续满载,响应时间从毫秒级飙升到秒级,这就是我们团队去年遭遇的真实场景。本文将分享我们如何通过系统化的缓存策略和七项关键优化,将百万级矢量瓦片的平均响应时间从3.2秒降至48毫秒的全过程。在成都某智慧城市项目中,我们使用PostGIS的ST_AsMVT函数实现了动态矢量切片服务。关键发现:当并发请求超过5个时,PostgreSQL工作内存会被反复分配释放,导致频繁的GC操作。

dichu2296的博客 421

PostgreSQL性能调优实战:从原理到参数优化

数据库性能调优是保障业务系统稳定运行的关键技术,其核心在于理解存储引擎的工作原理与资源分配逻辑。以PostgreSQL为例,其多进程架构和MVCC机制虽然提供了优异的并发处理能力,但也需要针对内存管理、磁盘I/O等维度进行精细调参。通过shared_buffers控制共享内存池大小、合理设置work_mem提升排序效率、优化WAL日志写入策略等技术手段,可显著提升TP场景下的吞吐量。在电商秒杀、物联网时序数据处理等高并发场景中,结合缓存命中率监控与pgTune等工具,能够实现从基础设施层到SQL层的全链路优

weixin_34389926的博客 469

Aurora数据库架构原理与生产级调优实战

Amazon Aurora 是一种云原生关系型数据库服务,其核心突破在于存储与计算的物理分离架构,通过分布式存储层、轻量化计算节点和共享存储多视图同步机制,重构了传统数据库的可靠性与扩展性边界。它并非简单兼容 MySQL/PostgreSQL,而是在底层实现了 Quorum 写入、毫秒级故障恢复、零感知自动扩容等工程特性,显著提升 OLTP 吞吐与读写一致性。技术价值体现在降低运维复杂度、消除主从延迟、减少备份停机窗口,并支撑实时风控、高并发交易等严苛场景。本文深入解析 Aurora 的存储分片、计算代理、

weixin_33748818的博客 372

SQLark小百灵AI实战:5分钟搞定PostgreSQL分区表自动化管理

本文介绍了SQLark小百灵AI在PostgreSQL分区表自动化管理中的实战应用。通过自然语言指令,AI能自动生成最优分区方案和维护脚本,显著提升查询性能并降低维护成本。实测显示,AI分区相比人工设计可提升37%的查询性能,适用于时序数据管理等场景。

hope8的博客 204

Debian 9部署ClickHouse实战:兼容性配置与生产级调优

ClickHouse作为高性能列式OLAP数据库,其核心价值在于亚秒级聚合查询能力与高吞吐写入性能。在真实企业环境中,它常被用于日志分析、用户行为宽表计算和实时BI报表等场景。然而,将ClickHouse落地到存量基础设施(如长期运行的Debian 9系统)时,必须直面操作系统版本滞后带来的兼容性挑战:包括systemd服务管理缺陷、glibc/boost版本约束、Java 8生态适配及SSL/TLS握手异常等问题。本文聚焦Debian 9这一典型稳定基线环境,系统阐述如何通过官方APT源安全安装、绕过ul

weixin_30550081的博客 537

Ubuntu 16.04 安装配置 PostgreSQL 9.5 实战指南

PostgreSQL 是一款功能完备、事务强一致的开源关系型数据库,其核心原理基于 MVCC 多版本并发控制与 WAL 预写日志机制,技术价值体现在高可靠性、细粒度权限体系和可扩展的插件生态。典型应用场景包括政企系统迁移、高校实验平台搭建及遗留系统长期运维——尤其在 Ubuntu 16.04 这类稳定但已停止维护的 LTS 发行版上,选择官方源提供的 PostgreSQL 9.5 而非强行升级至 14+,可规避 libc、openssl 等底层依赖冲突风险,保障系统级可控性与安全补丁可审计性。本文聚焦该经典

weixin_33725807的博客 414

PostgreSQL RUM索引深度实战:超越GIN的全文搜索性能优化秘籍

PostgreSQL RUM索引是一种革命性的全文搜索访问方法,专为解决传统GIN索引在排名、短语搜索和时间排序方面的性能瓶颈而设计。RUM索引通过在倒排索引中存储额外的位置信息,实现了无需额外堆扫描的高效全文搜索。本文将深入解析RUM索引的核心机制,通过实战案例展示如何在实际项目中应用这一强大工具,大幅提升PostgreSQL全文搜索性能。 ## 📊 RUM索引架构深度解析 RUM索引的核

gitblog_00058的博客 504

CentOS 7 Swap配置指南:Swapfile与Swap分区实战选择

Swap(交换空间)是Linux内存管理的核心机制,用于在物理内存不足时暂存非活跃页面,防止OOM Killer强制终止进程。其原理基于内核的页回收策略,由swappiness和vfs_cache_pressure等参数协同调控。技术价值在于提供内存压力缓冲、保障系统稳定性与服务连续性。典型应用场景包括VMware虚拟机资源受限环境、物理服务器高负载运行数据库或Java应用,以及容器化(Docker+Jenkins+Nginx)混合工作负载。本文聚焦CentOS 7平台,深入解析Swapfile与Swap分

weixin_34080571的博客 435

PostgreSQL技术大讲堂 - 第31讲:SQL调优技巧

> 如果是OLTP应用,则优化的思路是由小到大,即从限制性最强,返回记录最少的连接开始,依次完成其它表的连接,并在访问每张表时,合理使用索引,特别是复合索引技术。在上例中,被驱动表是dept,dept表的连接字段是deptno,而emp的deptno字段是可以不需要建索引的,因为已经根据条件字段上列访问驱动表。在sal列上有索引,但是条件语句中把sal列放在了表达式当中,导致索引被压抑,因为索引里面储存的是sal列的值,而不是sal加上100以后的值。所以在本例中,不应该创建复合索引。

m0_65303136的博客 169

PostgreSQL原生向量搜索:pgvector零迁移实战指南

向量搜索是AI应用的核心能力之一,其本质是在高维空间中进行近似最近邻(ANN)检索。传统方案依赖独立向量数据库,但引入数据双写、权限割裂与运维复杂度等工程风险。pgvector作为PostgreSQL官方扩展,通过原生数据类型、SIMD优化的距离运算符和标准索引访问方法(IVFFLAT/HNSW),将向量能力无缝嵌入现有关系型基础设施。它不改变事务模型、不新增服务组件、不破坏备份与监控体系,真正实现SQL级语义检索与业务逻辑的深度耦合。适用于已有成熟PostgreSQL生态、强调数据一致性与合规审计的中大型

weixin_34302561的博客 355

Qdrant向量数据库实战:本地化部署、混合检索与RAG生产调优

向量数据库是支撑语义搜索、RAG(检索增强生成)和AI应用落地的核心基础设施,其本质是融合向量相似性检索、标量过滤、全文匹配与时间序列能力的新型数据系统。Qdrant凭借轻量架构、本地可部署特性及对HNSW+标量联合查询的深度优化,在性能、可观测性与工程可控性之间取得关键平衡。相比FAISS需手动管理索引、Chroma存在内存泄漏风险、云服务受限于API版本与冷启延迟,Qdrant以RocksDB自研存储、gRPC/REST双协议、热配置更新等设计,真正实现‘开箱即用的企业级向量检索’。本文聚焦真实生产场景

weixin_30505225的博客 447

终极JumpServer性能优化指南:标准化测试方法与实战结果解析

JumpServer作为开源的Web服务器和代理服务器,以其安全、高性能和易用性受到广泛关注。本文将提供一套标准化的性能测试方法,帮助你全面评估和优化JumpServer的运行效率,确保在高并发场景下依然保持稳定表现。 [![JumpServer性能优化架构图](https://raw.gitcode.com/GitHub_Trending/ju/jumpserver/raw/c3dcb3e1e

gitblog_00166的博客 473

PostgreSQL面试题及详细答案120道(61-80)

数据库事务与备份面试题解析 核心知识点 事务管理: COMMIT通过WAL日志、事务状态更新和锁释放实现 ROLLBACK利用回滚记录撤销操作 保存点(SAVEPOINT)支持事务部分回滚 性能优化: 缩短事务持有锁时间 合理设置隔离级别 批量操作减少事务次数 MVCC机制: 事务ID(XID)实现元组可见性控制 通过定期冻结解决XID回卷问题 监控与备份: pg_locks视图监控锁等待 pg_dump逻辑备份与pg_basebackup物理备份的区别 定时备份策略与有效性验证 高并发处理: 优化查询计划

大剑师兰特的GIS世界 1464

Ubuntu 16.04 LEMP生产环境搭建与调优实战

LEMP(Linux-Nginx-MySQL-PHP)是轻量、稳定、高并发的Web服务基础架构,其核心在于Nginx的事件驱动模型、MySQL的InnoDB事务引擎与PHP-FPM进程管理机制的协同优化。理解各组件默认配置与真实硬件资源(如2GB内存VPS)间的张力,是避免OOM、502错误和慢查询的关键。技术价值体现在低开销承载高并发、权限隔离保障安全、日志与状态页支撑可观测性。典型应用场景包括中小企业官网、教育实验平台、IoT边缘网关及遗留系统维护——尤其在Ubuntu 16.04这类LTS基线系统上,

weixin_30940783的博客 346

430单片机实现三人投票表决器_基于单片机的五人表决器的设计

姚海云+马野摘要:本设计利用51单片机,按键开关模块,数码管显示模块和LED模块来实现一个简单的五人表决器的功能。按键开关模块中的键2~键6表示五个人,由5个人来投票,当同意的票数大于或者等于3人时,数码管显示同意的人数,说明表决通过。当表决的人数小于3时,数码管显示同意的人数。关键词:表决器;单片机;流水灯;数码管;矩阵键盘;时钟中图分类号:TP391 文献标识码:A 文章编号:1009-304...

weixin_33277215的博客 2560

maxwell与steady state thermal 通过workbench耦合仿真

文章目录maxwellsteady state thermal maxwell 1加入maxwell并打开 2导入模型 3选择求解器类型:涡流求解器eddy current 4修改模型名字不能带_等特殊符号 5为模型赋材料 6设立3D边界,各边电流进出方向为0其余方向300 7设置激励条件,可设置电流大小,相位,方向 8设置集肤深度,选取中间铜导体的体然后设置,如何设置看帮助文档 9求解设置 迭代步数 收敛精度 交流电频率 10验证条件满足计算 11求解 发现无法求解,删除ai

roymustang的博客 9204

OLAP实战指南:从多维分析原理到生产级选型调优

OLAP(联机分析处理)是支撑实时BI、自助分析与决策看板的核心技术范式,其本质在于通过预聚合、列式存储和向量化执行,突破传统关系型数据库在多维即席查询场景下的性能瓶颈。它并非简单加速SQL,而是围绕‘亚秒级响应+任意维度组合+深度下钻’三大刚性需求构建的工程体系。关键技术如星型模型解决事实与维度的高效关联,MOLAP/ROLAP/HOLAP代表不同实时性与灵活性的权衡路径,而ClickHouse、StarRocks等现代OLAP引擎则以MPP架构与智能物化视图重新定义性能边界。本文聚焦银行风控、电商大促、

weixin_34218579的博客 578

ARM芯片内部的高速公路:手把手教你用AMBA Designer配置NIC-400互连控制器

本文详细介绍了如何使用AMBA Designer工具配置ARM芯片中的NIC-400互连控制器,涵盖从基础拓扑构建到高级QoS设置的完整流程。通过实际案例演示,帮助开发者掌握AXI协议下的高效片上网络设计,提升SoC性能与能效比。

weixin_26750481的博客 315

AWS Lambda 入门与生产实践:原理、调优与避坑指南

Serverless 是一种以事件驱动、按需执行、全托管为特征的云计算范式,其核心在于将应用逻辑拆解为无状态函数,由云平台自动调度资源并精确计量成本。AWS Lambda 作为该范式的典型实现,依托毫秒级计费、弹性伸缩和原生事件集成等机制,显著降低运维负担与闲置开销,适用于图像处理、实时数据清洗、API 后端等轻量原子任务。然而,其冷启动延迟、15 分钟执行上限及无状态约束,也决定了它并非传统服务的直接替代品,而是一种需重新设计架构思维的技术选型。本文聚焦 Lambda 的真实能力边界、内存与超时协同调优、

weixin_34337381的博客 377

点餐系统数据库设计--SQL Server

友情链接 1、学生成绩管理系统数据库设计–MySQL 学生成绩管理系统数据库设计–MySQL 2、医疗信息管理系统数据库–MySQL 医疗信息管理系统数据库–MySQL 3、邮件管理数据库设计–MySQL 邮件管理数据库设计–MySQL 4、SQL Server医疗信息管理系统数据库【英文版-源码】–(Medical Management System Database) SQL Server医疗信息管理系统数据库【英文版-源码】–(Medical Management System Database) 5

若如初见 8万+

STC15W204S最小系统开发指南:从串口通讯到自动热加载全流程

本文详细介绍了STC15W204S最小系统的完整开发流程。从芯片资源解析、最小系统搭建、串口通讯驱动编写(使用Timer2生成波特率),到实现基于魔术值触发的自动热加载功能,并最终集成Keil与STC-ISP软件,构建高效的自动化开发工作流,显著提升嵌入式调试效率。

a1b2c的博客 397

【vCenter运维黄金法则】:20年VMware专家亲授5大避坑指南与性能调优实战手册

本教程直击vCenter运维痛点,提供5大避坑指南与性能调优实战方法,涵盖集群配置、权限管理、备份恢复等高频场景。基于20年VMware专家经验,详解VMware vCenter 使用教程中的关键操作与最佳实践,显著提升稳定性与响应效率,值得收藏。

ByteGlow的博客 164

华为昇腾Atlas 200I DK A2实战:从开箱到运行首个AI应用

本文详细介绍了华为昇腾Atlas 200I DK A2开发板从开箱到运行首个AI应用的全过程。包括硬件准备、系统烧录、开发板连接方案、AI应用运行及性能优化技巧,帮助开发者快速上手部署AI项目,提升开发效率。

weixin_27038245的博客 594

PostgreSQL 16.3 四种安装方案对比:二进制包、Yum、源码与Docker部署实测

本文详细对比了PostgreSQL 16.3的四种安装方案:二进制包、Yum、源码编译和Docker部署。通过实测数据分析了各方案的部署耗时、资源占用、性能表现及维护复杂度,帮助用户根据实际需求选择最优安装方式。特别适合Linux环境下需要高效部署PostgreSQL的DevOps团队。

weixin_33695082的博客 390

杰理AC696N系列芯片外部中断使用教程

本教程详细介绍了杰理AC696N芯片的GPIO引脚中断唤醒功能实现方法。主要内容包括: 功能特点: 支持任意GPIO引脚配置为中断源 可灵活选择上升沿或下降沿触发 提供自定义中断回调函数接口 核心实现: 通过port_wkup_interrupt_init()函数配置GPIO属性 使用request_irq()注册中断服务程序 提供中断使能/关闭接口 注意事项: 此功能在低功耗模式下无效 需注意引脚冲突和中断优先级设置 建议在回调函数中实现简洁的逻辑 应用场景: 按键检测 外部信号监测 事件触发等 本方案提

qq_42014563的博客 944

国科大人工智能原理与算法-2024-第一次作业-雷震老师

1. 反射行动(比如从热炉子上缩回你的手)是理性的吗?它们是智能的吗? 2. 以下的计算机系统在何种程度上是人工智能的实例: - 超市条码扫描器 - 网络搜索引擎 - 语音激活的电话菜单 - 对网络状态动态响应的网络路由算法 3. 为什么进化会倾向于导致行为合理的系统?设计这样的系统想达到的目标是什么?

MatsumotoChrikk 2932
上一篇: PostgreSQL笔记61:分区表核心概念、声明式分区与最佳实践
下一篇: PostgreSQL笔记63:分区表最佳实践与避坑指南
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、付费专栏及课程。

余额充值