PostgreSQL笔记63:分区表最佳实践与避坑指南

PostgreSQL分区表实战:原理、策略与性能优化 数据库分区技术是处理海量数据的核心方法之一,通过将大表物理分割为多个小表来提升查询效率。其实现原理是基于分区键的值将数据分布到不同存储区域,同时对应用保持单一表视图。在PostgreSQL中,分区表能显著提升时间序列、电商订单等高增长数据的处理能力,特别是在数据量超过千万行时效果明显。关键技术价值包括查询性能优化、维护效率提升和存储成本控制。典型应用场景包括IoT设备数据管理、电商订单系统和SaaS多租户架构。本文以PostgreSQL分区表为例,详细解析范围分区、列表分区等策略的选择与实践,并分享分区裁剪 阅读详情

纲要

本文围绕 PostgreSQL 原生分区表在生产环境中的最佳实践展开,涵盖以下核心主题:

  • 分区裁剪机制
    • 查询必须带分区键
    • 分区键的函数稳定性影响
  • 分区表的版本演进
    • PG 10 引入原生分区
    • PG 11 功能增强
    • PG 12 性能大幅提升
  • 分区表的限制与注意事项
    • 全局索引缺失
    • 唯一约束必须包含分区键
    • 默认分区的风险
  • 分区表性能陷阱
    • 分区数量膨胀
    • 多级分区的文件句柄压力
    • 锁资源耗尽风险
  • 典型问题与解决方案
    • 子表权限影响执行计划
    • DDL 变更导致表重写
    • 统计信息失效
  • 分区表设计准则
    • 数据均匀分布
    • 合理控制分区数量
    • 避免过度分区

分区裁剪:发挥分区表优势的核心

分区表的最大价值在于 分区裁剪,即查询时数据库优化器能够根据查询条件,只扫描必要的子分区,从而避免全表扫描。

分区裁剪的基本原理

当查询条件中包含分区键时,优化器会基于分区边界值,确定需要访问的子分区集合。例如,按时间分区的表,查询条件为 ts = '2025-01-15',优化器可以直接定位到对应月份的子分区,跳过其余分区。

查询必须带分区键

如果不带分区键,优化器无法确定目标分区,只能扫描所有子分区。此时,分区表不仅没有性能优势,反而因为需要扫描多个物理表(子分区),性能可能劣于普通表。

例如,一张按月份分区的表,总数据量为一亿行,分布在 12 个子分区中:

  • 不带分区键:需要扫描全部 12 个子分区
  • 带分区键:只需扫描 1 个子分区(约 1/12 的数据)

分区键裁剪失败的典型场景

即使查询条件中包含了分区键,也可能因为写法不当导致裁剪失败。最常见的情况是使用非不可变函数。

-- 假设表 csts 按 ts 字段(timestamptz 类型)进行范围分区

-- 裁剪成功:直接指定常量值
SELECT * FROM csts WHERE ts = '2025-01-15 00:00:00+08';

-- 裁剪失败:使用 clock_timestamp(),该函数为 volatile
SELECT * FROM csts WHERE ts = clock_timestamp();

clock_timestamp() 是 volatile 函数,其返回值在事务内也可能变化,优化器无法在规划阶段确定其具体值,因此无法进行分区裁剪。

函数的稳定性级别

PostgreSQL 将函数划分为三个稳定性级别,这直接关系到分区裁剪以及函数索引的创建。

级别关键字行为典型函数
不可变IMMUTABLE入参相同,返回值始终相同,与事务状态无关abs(), substring()
稳定STABLE在同一个事务内,入参相同返回值相同now(), current_timestamp
易变VOLATILE入参相同返回值也可能不同,即使在事务内clock_timestamp(), random()

分区裁剪对函数稳定性的要求

优化器在执行分区裁剪时,需要能够在规划阶段确定分区键的值。因此,只有 IMMUTABLE 和 STABLE 函数的返回值可以被优化器评估,而 VOLATILE 函数的返回值无法在规划阶段确定,会导致裁剪失败。

-- 使用 now(),STABLE 函数,裁剪成功
SELECT * FROM csts WHERE ts = now();

-- 使用 clock_timestamp(),VOLATILE 函数,裁剪失败
SELECT * FROM csts WHERE ts = clock_timestamp();

函数稳定性与函数索引

函数索引要求所使用的函数必须是 IMMUTABLE 的。因为索引条目在创建时计算并存储,后续查询时优化器需要能够使用相同的计算值进行索引扫描,如果函数的返回值可能变化,索引将失去一致性。

PostgreSQL 分区表的版本演进

原生分区支持在 PostgreSQL 的不同版本中经历了显著变化。

版本重要变化说明
PG 10引入原生分区首次支持声明式分区,但功能有限
PG 11功能增强支持默认分区、哈希分区、UPDATE 分区键自动迁移
PG 12性能大幅提升分区裁剪优化,单分区操作不再锁所有分区

PG 12 的关键性能提升

在 PG 12 之前(尤其是 PG 11),即使查询条件明确指定了目标分区,优化器仍然需要访问所有子分区来生成执行计划。对于拥有大量子分区的表,这一过程会导致:

  • 内存消耗急剧上升
  • 执行计划生成时间变长
  • 需要获取所有子分区上的锁,导致并发性能下降

PG 12 引入了重大优化,对于单分区查询,优化器只需要访问目标分区,大幅降低了规划和锁定的开销。

全局索引的缺失与唯一约束限制

PostgreSQL 分区表不支持全局索引。这意味着:

  • 分区表的主键必须包含所有分区键
  • 唯一约束必须包含所有分区键
-- 错误示例:主键不包含分区键 ts
CREATE TABLE csts (
    id SERIAL PRIMARY KEY,
    ts TIMESTAMPTZ NOT NULL,
    data TEXT
) PARTITION BY RANGE (ts);
-- ERROR: unique constraint on partitioned table must include all partitioning columns

正确的做法是,将分区键纳入主键或唯一约束。

-- 正确示例:主键包含分区键
CREATE TABLE csts (
    id SERIAL,
    ts TIMESTAMPTZ NOT NULL,
    data TEXT,
    PRIMARY KEY (id, ts)
) PARTITION BY RANGE (ts);

这一限制源于 PG 的实现机制:唯一性约束在每个子分区内独立维护,无法跨子分区保证全局唯一。如果在不同子分区中存在相同的 id 值,PG 无法阻止,因为每个分区只需保证自身内部的唯一性。

分区表的使用陷阱

锁资源耗尽风险

当分区裁剪未生效(例如使用 VOLATILE 函数),或者使用 enable_partitionwise_join 等优化选项时,PG 可能需要对所有子分区加锁。表级锁数量受限于 max_connections * max_locks_per_transaction 的乘积。超过该值将触发:

ERROR: out of shared memory
HINT: You might need to increase max_locks_per_transaction.

分区数量膨胀

随着分区数量增加,查询性能和 DDL 操作性能都会下降。尤其是在使用列存(如 Greenplum 的 AOCO 表)时,分区表的每个列在每个分区中都是一个独立的文件,分区数量膨胀将导致文件句柄耗尽。

多级分区

多级分区(即分区下再分区)在使用时需要格外谨慎。只有在每一级分区都能有效裁剪查询时,才值得使用多级分区。否则,每一级分区都会增加额外的规划开销。

典型问题与解决方案

子表权限影响执行计划

这是一个在 PG 11 中发现的案例,不同用户执行相同查询可能得到不同的执行计划。

  • 现象:超级用户和普通业务用户执行相同的 SELECT 语句,执行计划不同
  • 根因:优化器在估算行数时,会检查用户对子表的查询权限。业务用户没有子表的显式权限(他们只需要父表权限),导致优化器无法正确估算选择率,生成了次优的执行计划
  • 解决方案:在创建子分区后,显式授予业务用户对子表的 SELECT 权限
GRANT SELECT ON csts_202501 TO app_user;
GRANT SELECT ON csts_202502 TO app_user;
-- ... 对所有子分区执行授权

DDL 变更与表重写

修改表结构时,某些操作会触发表重写(将原数据全部读出并重新写入),在分区表上的行为需要特别注意。

操作普通表分区表
ALTER TABLE t ALTER COLUMN c TYPE varchar(20)(从小改大)不重写不重写
ALTER TABLE t ALTER COLUMN c TYPE varchar(5)(从大改小)重写子表不重写,但索引会重写
DROP COLUMN不重写复合索引失效

对于分区表,需要特别注意:

  1. 修改字段类型时,即使是"从大改小",各子分区表的索引会被重建,如果索引数量较多,会对业务产生明显影响
  2. 删除字段时,该字段上所有复合索引中的列会被移除,可能导致索引失效
  3. 表结构变更后,统计信息(pg_statistic)可能失效,需要手动执行 ANALYZE
-- 修改字段类型后,建议执行 ANALYZE 更新统计信息
ALTER TABLE csts ALTER COLUMN data TYPE varchar(500);
ANALYZE csts;

分区表设计准则

数据均匀分布

分区设计应尽量使数据在分区之间均匀分布,避免产生"木桶效应"——查询性能受限于数据量最大的分区。对于时序数据,如果采用按年分区,可能导致历史数据量远大于近期数据,需结合具体查询模式调整分区粒度。

分区裁剪覆盖率

分区裁剪是关键。在设计分区策略时,应确保绝大多数查询都能利用分区键进行裁剪。

避免过度分区

分区的粒度应基于数据量和业务查询模式进行权衡。对于数据量较小的表(如百万行级别),分区带来的额外开销可能超过收益。

默认分区

PG 没有"全局默认分区"的概念,而是通过创建 DEFAULT 分区来存储不匹配任何现有分区的数据。默认分区在实践中存在风险:

  • 如果分区边界设计不当,大量数据会落入默认分区
  • 默认分区与其他分区没有边界限制,可能影响分区裁剪效率

API 速览

本部分列出 PostgreSQL 分区表相关的系统函数和视图。

pg_partition_tree

返回分区表的层级结构信息。

函数签名:

pg_partition_tree(relid regclass) RETURNS SETOF record

参数:

  • relid:分区表或子分区的 OID 或表名

返回字段:

  • relid:表的 OID
  • parentrelid:父表的 OID
  • isleaf:是否为叶子分区
  • level:层级深度(根为 0)

示例:

SELECT * FROM pg_partition_tree('csts');

pg_get_partkeydef

获取分区表的分区键定义。

函数签名:

pg_get_partkeydef(relid oid) RETURNS text

参数:

  • relid:分区表的 OID

示例:

SELECT pg_get_partkeydef('csts'::regclass);
-- 输出示例:RANGE (ts)

pg_get_partition_constraintdef

获取子分区的约束定义(即分区边界)。

函数签名:

pg_get_partition_constraintdef(relid oid) RETURNS text

参数:

  • relid:子分区的 OID

示例:

SELECT pg_get_partition_constraintdef('csts_202501'::regclass);
-- 输出示例:FOR VALUES FROM ('2025-01-01 00:00:00+08') TO ('2025-02-01 00:00:00+08')

系统视图

视图说明
pg_partitioned_table所有分区表的信息
pg_class.relispartition标识表是否为分区子表
pg_inherits分区表的继承关系

示例:

-- 查询所有分区表及其分区键
SELECT
    c.relname AS table_name,
    pg_get_partkeydef(c.oid) AS partition_key
FROM pg_class c
JOIN pg_partitioned_table p ON p.partrelid = c.oid
WHERE c.relkind = 'p';

-- 查询某个分区表的所有子分区
SELECT
    inhrelid::regclass AS child_table,
    pg_get_partition_constraintdef(inhrelid) AS constraint_def
FROM pg_inherits
WHERE inhparent = 'csts'::regclass;

Demo 完整示例

以下示例使用 Node.js 和 pg 库演示 PostgreSQL 分区表的完整操作流程。

运行说明

  1. 确保本地已安装 PostgreSQL(14 或以上版本)并运行
  2. 创建测试数据库 test_partition
  3. 安装依赖:npm init -y && npm install pg
  4. 运行脚本:node partition_demo.js

代码说明

demo/
├── partition_demo.js   # 主程序
└── package.json        # 项目配置
// partition_demo.js
const { Client } = require('pg');

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

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

    // === 1. 创建分区表(按月分区) ===
    // 等价 SQL:
    // CREATE TABLE orders (
    //     id SERIAL,
    //     order_date TIMESTAMPTZ NOT NULL,
    //     customer_id INT NOT NULL,
    //     amount NUMERIC(10,2),
    //     PRIMARY KEY (id, order_date)
    // ) PARTITION BY RANGE (order_date);
    await client.query(`
        DROP TABLE IF EXISTS orders CASCADE;
        CREATE TABLE orders (
            id SERIAL,
            order_date TIMESTAMPTZ NOT NULL,
            customer_id INT NOT NULL,
            amount NUMERIC(10,2),
            PRIMARY KEY (id, order_date)
        ) PARTITION BY RANGE (order_date);
    `);
    console.log('✅ 主表 orders 创建成功');

    // === 2. 创建子分区 ===
    // 等价 SQL:
    // CREATE TABLE orders_2025_01 PARTITION OF orders
    // FOR VALUES FROM ('2025-01-01') TO ('2025-02-01');
    // CREATE TABLE orders_2025_02 PARTITION OF orders
    // FOR VALUES FROM ('2025-02-01') TO ('2025-03-01');
    await client.query(`
        CREATE TABLE orders_2025_01 PARTITION OF orders
        FOR VALUES FROM ('2025-01-01') TO ('2025-02-01');
        CREATE TABLE orders_2025_02 PARTITION OF orders
        FOR VALUES FROM ('2025-02-01') TO ('2025-03-01');
    `);
    console.log('✅ 子分区创建成功');

    // === 3. 插入测试数据 ===
    // 等价 SQL:
    // INSERT INTO orders (order_date, customer_id, amount)
    // VALUES ('2025-01-15 10:00:00', 1, 100.50);
    await client.query(`
        INSERT INTO orders (order_date, customer_id, amount)
        VALUES
            ('2025-01-15 10:00:00', 1, 100.50),
            ('2025-01-20 14:30:00', 2, 200.00),
            ('2025-02-10 09:00:00', 1, 150.25),
            ('2025-02-15 16:45:00', 3, 300.75);
    `);
    console.log('✅ 测试数据插入成功');

    // === 4. 查询验证:带分区键(裁剪成功) ===
    // 等价 SQL:
    // EXPLAIN (ANALYZE, BUFFERS) SELECT * FROM orders WHERE order_date = '2025-01-15';
    const res1 = await client.query(`
        EXPLAIN (ANALYZE, BUFFERS)
        SELECT * FROM orders WHERE order_date = '2025-01-15 10:00:00';
    `);
    console.log('\n🔍 带分区键查询执行计划(裁剪成功):');
    console.log(res1.rows.map(r => r['QUERY PLAN']).join('\n'));

    // === 5. 查询验证:不带分区键(裁剪失败) ===
    // 等价 SQL:
    // EXPLAIN (ANALYZE, BUFFERS) SELECT * FROM orders WHERE customer_id = 1;
    const res2 = await client.query(`
        EXPLAIN (ANALYZE, BUFFERS)
        SELECT * FROM orders WHERE customer_id = 1;
    `);
    console.log('\n🔍 不带分区键查询执行计划(裁剪失败):');
    console.log(res2.rows.map(r => r['QUERY PLAN']).join('\n'));

    // === 6. 查看分区结构 ===
    // 等价 SQL:
    // SELECT
    //     inhrelid::regclass AS partition_name,
    //     pg_get_partition_constraintdef(inhrelid) AS range_def
    // FROM pg_inherits
    // WHERE inhparent = 'orders'::regclass;
    const res3 = await client.query(`
        SELECT
            inhrelid::regclass AS partition_name,
            pg_get_partition_constraintdef(inhrelid) AS range_def
        FROM pg_inherits
        WHERE inhparent = 'orders'::regclass;
    `);
    console.log('\n📊 分区结构:');
    res3.rows.forEach(row => {
        console.log(`  - ${row.partition_name}: ${row.range_def}`);
    });

    await client.end();
}

run().catch(err => {
    console.error(err);
    process.exit(1);
});

技术点总结

技术点说明
声明式分区使用 PARTITION BY RANGE 定义分区表
子分区创建使用 PARTITION OF ... FOR VALUES FROM ... TO ...
分区裁剪验证通过 EXPLAIN (ANALYZE, BUFFERS) 观察是否只扫描目标分区
元数据查询通过 pg_inherits 和 pg_get_partition_constraintdef 查看分区结构

多语言示例

Go 示例

以下示例使用 Go 语言和 pgx 驱动演示 PostgreSQL 分区表的完整操作流程。

运行说明
  1. 确保本地已安装 PostgreSQL(14 或以上版本)并运行
  2. 创建测试数据库 test_partition
  3. 初始化 Go 模块:go mod init demo && go get github.com/jackc/pgx/v5
  4. 运行脚本:go run partition_demo.go
代码说明
demo-go/
├── partition_demo.go   # 主程序
├── go.mod
└── go.sum
// partition_demo.go
package main

import (
    "context"
    "fmt"
    "log"

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

func main() {
    ctx := context.Background()
    conn, err := pgx.Connect(ctx, "postgres://postgres:postgres@localhost:5432/test_partition")
    if err != nil {
        log.Fatal(err)
    }
    defer conn.Close(ctx)

    // === 1. 创建分区表(按月分区) ===
    // 等价 SQL:
    // CREATE TABLE orders (
    //     id SERIAL,
    //     order_date TIMESTAMPTZ NOT NULL,
    //     customer_id INT NOT NULL,
    //     amount NUMERIC(10,2),
    //     PRIMARY KEY (id, order_date)
    // ) PARTITION BY RANGE (order_date);
    _, err = conn.Exec(ctx, `
        DROP TABLE IF EXISTS orders CASCADE;
        CREATE TABLE orders (
            id SERIAL,
            order_date TIMESTAMPTZ NOT NULL,
            customer_id INT NOT NULL,
            amount NUMERIC(10,2),
            PRIMARY KEY (id, order_date)
        ) PARTITION BY RANGE (order_date);
    `)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("✅ 主表 orders 创建成功")

    // === 2. 创建子分区 ===
    // 等价 SQL:
    // CREATE TABLE orders_2025_01 PARTITION OF orders
    // FOR VALUES FROM ('2025-01-01') TO ('2025-02-01');
    // CREATE TABLE orders_2025_02 PARTITION OF orders
    // FOR VALUES FROM ('2025-02-01') TO ('2025-03-01');
    _, err = conn.Exec(ctx, `
        CREATE TABLE orders_2025_01 PARTITION OF orders
        FOR VALUES FROM ('2025-01-01') TO ('2025-02-01');
        CREATE TABLE orders_2025_02 PARTITION OF orders
        FOR VALUES FROM ('2025-02-01') TO ('2025-03-01');
    `)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("✅ 子分区创建成功")

    // === 3. 插入测试数据 ===
    // 等价 SQL:
    // INSERT INTO orders (order_date, customer_id, amount) VALUES
    // ('2025-01-15 10:00:00', 1, 100.50),
    // ('2025-01-20 14:30:00', 2, 200.00),
    // ('2025-02-10 09:00:00', 1, 150.25),
    // ('2025-02-15 16:45:00', 3, 300.75);
    _, err = conn.Exec(ctx, `
        INSERT INTO orders (order_date, customer_id, amount) VALUES
            ('2025-01-15 10:00:00', 1, 100.50),
            ('2025-01-20 14:30:00', 2, 200.00),
            ('2025-02-10 09:00:00', 1, 150.25),
            ('2025-02-15 16:45:00', 3, 300.75);
    `)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("✅ 测试数据插入成功")

    // === 4. 查询验证:带分区键(裁剪成功) ===
    // 等价 SQL:
    // EXPLAIN (ANALYZE, BUFFERS) SELECT * FROM orders WHERE order_date = '2025-01-15 10:00:00';
    rows, err := conn.Query(ctx, `
        EXPLAIN (ANALYZE, BUFFERS)
        SELECT * FROM orders WHERE order_date = '2025-01-15 10:00:00';
    `)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("\n🔍 带分区键查询执行计划(裁剪成功):")
    for rows.Next() {
        var plan string
        rows.Scan(&plan)
        fmt.Println(plan)
    }
    rows.Close()

    // === 5. 查询验证:不带分区键(裁剪失败) ===
    // 等价 SQL:
    // EXPLAIN (ANALYZE, BUFFERS) SELECT * FROM orders WHERE customer_id = 1;
    rows, err = conn.Query(ctx, `
        EXPLAIN (ANALYZE, BUFFERS)
        SELECT * FROM orders WHERE customer_id = 1;
    `)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("\n🔍 不带分区键查询执行计划(裁剪失败):")
    for rows.Next() {
        var plan string
        rows.Scan(&plan)
        fmt.Println(plan)
    }
    rows.Close()

    // === 6. 查看分区结构 ===
    // 等价 SQL:
    // SELECT
    //     inhrelid::regclass AS partition_name,
    //     pg_get_partition_constraintdef(inhrelid) AS range_def
    // FROM pg_inherits
    // WHERE inhparent = 'orders'::regclass;
    rows, err = conn.Query(ctx, `
        SELECT
            inhrelid::regclass AS partition_name,
            pg_get_partition_constraintdef(inhrelid) AS range_def
        FROM pg_inherits
        WHERE inhparent = 'orders'::regclass;
    `)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("\n📊 分区结构:")
    for rows.Next() {
        var name, def string
        rows.Scan(&name, &def)
        fmt.Printf("  - %s: %s\n", name, def)
    }
    rows.Close()
}
技术点总结
技术点说明
驱动选择使用 pgx 作为 PostgreSQL 驱动,支持上下文和原生类型
声明式分区与 Node.js 示例相同的 DDL 语句
执行计划通过 EXPLAIN (ANALYZE, BUFFERS) 验证分区裁剪
元数据查询使用 pg_inherits 系统表获取分区结构

Python 示例

以下示例使用 Python 语言和 psycopg2 驱动演示 PostgreSQL 分区表的完整操作流程。

运行说明
  1. 确保本地已安装 PostgreSQL(14 或以上版本)并运行
  2. 创建测试数据库 test_partition
  3. 安装依赖:pip install psycopg2-binary
  4. 运行脚本:python partition_demo.py
代码说明
demo-py/
├── partition_demo.py   # 主程序
└── requirements.txt
# partition_demo.py
import psycopg2
from psycopg2 import sql

def main():
    conn = psycopg2.connect(
        host="localhost",
        port=5432,
        user="postgres",
        password="postgres",
        database="test_partition"
    )
    conn.autocommit = True
    cur = conn.cursor()

    # === 1. 创建分区表(按月分区) ===
    # 等价 SQL:
    # CREATE TABLE orders (
    #     id SERIAL,
    #     order_date TIMESTAMPTZ NOT NULL,
    #     customer_id INT NOT NULL,
    #     amount NUMERIC(10,2),
    #     PRIMARY KEY (id, order_date)
    # ) PARTITION BY RANGE (order_date);
    cur.execute("""
        DROP TABLE IF EXISTS orders CASCADE;
        CREATE TABLE orders (
            id SERIAL,
            order_date TIMESTAMPTZ NOT NULL,
            customer_id INT NOT NULL,
            amount NUMERIC(10,2),
            PRIMARY KEY (id, order_date)
        ) PARTITION BY RANGE (order_date);
    """)
    print("✅ 主表 orders 创建成功")

    # === 2. 创建子分区 ===
    # 等价 SQL:
    # CREATE TABLE orders_2025_01 PARTITION OF orders
    # FOR VALUES FROM ('2025-01-01') TO ('2025-02-01');
    # CREATE TABLE orders_2025_02 PARTITION OF orders
    # FOR VALUES FROM ('2025-02-01') TO ('2025-03-01');
    cur.execute("""
        CREATE TABLE orders_2025_01 PARTITION OF orders
        FOR VALUES FROM ('2025-01-01') TO ('2025-02-01');
        CREATE TABLE orders_2025_02 PARTITION OF orders
        FOR VALUES FROM ('2025-02-01') TO ('2025-03-01');
    """)
    print("✅ 子分区创建成功")

    # === 3. 插入测试数据 ===
    # 等价 SQL:
    # INSERT INTO orders (order_date, customer_id, amount) VALUES
    # ('2025-01-15 10:00:00', 1, 100.50),
    # ('2025-01-20 14:30:00', 2, 200.00),
    # ('2025-02-10 09:00:00', 1, 150.25),
    # ('2025-02-15 16:45:00', 3, 300.75);
    cur.execute("""
        INSERT INTO orders (order_date, customer_id, amount) VALUES
            ('2025-01-15 10:00:00', 1, 100.50),
            ('2025-01-20 14:30:00', 2, 200.00),
            ('2025-02-10 09:00:00', 1, 150.25),
            ('2025-02-15 16:45:00', 3, 300.75);
    """)
    print("✅ 测试数据插入成功")

    # === 4. 查询验证:带分区键(裁剪成功) ===
    # 等价 SQL:
    # EXPLAIN (ANALYZE, BUFFERS) SELECT * FROM orders WHERE order_date = '2025-01-15 10:00:00';
    cur.execute("""
        EXPLAIN (ANALYZE, BUFFERS)
        SELECT * FROM orders WHERE order_date = '2025-01-15 10:00:00';
    """)
    print("\n🔍 带分区键查询执行计划(裁剪成功):")
    for row in cur.fetchall():
        print(row[0])

    # === 5. 查询验证:不带分区键(裁剪失败) ===
    # 等价 SQL:
    # EXPLAIN (ANALYZE, BUFFERS) SELECT * FROM orders WHERE customer_id = 1;
    cur.execute("""
        EXPLAIN (ANALYZE, BUFFERS)
        SELECT * FROM orders WHERE customer_id = 1;
    """)
    print("\n🔍 不带分区键查询执行计划(裁剪失败):")
    for row in cur.fetchall():
        print(row[0])

    # === 6. 查看分区结构 ===
    # 等价 SQL:
    # SELECT
    #     inhrelid::regclass AS partition_name,
    #     pg_get_partition_constraintdef(inhrelid) AS range_def
    # FROM pg_inherits
    # WHERE inhparent = 'orders'::regclass;
    cur.execute("""
        SELECT
            inhrelid::regclass AS partition_name,
            pg_get_partition_constraintdef(inhrelid) AS range_def
        FROM pg_inherits
        WHERE inhparent = 'orders'::regclass;
    """)
    print("\n📊 分区结构:")
    for name, defn in cur.fetchall():
        print(f"  - {name}: {defn}")

    cur.close()
    conn.close()

if __name__ == "__main__":
    main()
技术点总结
技术点说明
驱动选择使用 psycopg2 作为 PostgreSQL 驱动,成熟稳定
事务控制通过 autocommit=True 简化 DDL 操作
执行计划与 Node.js 示例相同的 EXPLAIN 分析方式
元数据查询使用相同的系统表查询分区结构

Java 示例

以下示例使用 Java 语言和 JDBC 驱动(postgresql)演示 PostgreSQL 分区表的完整操作流程。

运行说明
  1. 确保本地已安装 PostgreSQL(14 或以上版本)并运行
  2. 创建测试数据库 test_partition
  3. 使用 Maven 或 Gradle 引入依赖(见下方 pom.xml)
  4. 编译并运行:mvn compile exec:java -Dexec.mainClass="com.demo.PartitionDemo"
代码说明
demo-java/
├── src/main/java/com/demo/PartitionDemo.java
└── pom.xml
// pom.xml
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
         http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.demo</groupId>
    <artifactId>partition-demo</artifactId>
    <version>1.0-SNAPSHOT</version>
    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.postgresql</groupId>
            <artifactId>postgresql</artifactId>
            <version>42.7.2</version>
        </dependency>
    </dependencies>
</project>
// PartitionDemo.java
package com.demo;

import java.sql.Connection;
import java.sql.DriverManager;
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/test_partition";
        String user = "postgres";
        String password = "postgres";

        try (Connection conn = DriverManager.getConnection(url, user, password);
             Statement stmt = conn.createStatement()) {

            // === 1. 创建分区表(按月分区) ===
            // 等价 SQL:
            // CREATE TABLE orders (
            //     id SERIAL,
            //     order_date TIMESTAMPTZ NOT NULL,
            //     customer_id INT NOT NULL,
            //     amount NUMERIC(10,2),
            //     PRIMARY KEY (id, order_date)
            // ) PARTITION BY RANGE (order_date);
            stmt.execute("""
                DROP TABLE IF EXISTS orders CASCADE;
                CREATE TABLE orders (
                    id SERIAL,
                    order_date TIMESTAMPTZ NOT NULL,
                    customer_id INT NOT NULL,
                    amount NUMERIC(10,2),
                    PRIMARY KEY (id, order_date)
                ) PARTITION BY RANGE (order_date);
            """);
            System.out.println("✅ 主表 orders 创建成功");

            // === 2. 创建子分区 ===
            // 等价 SQL:
            // CREATE TABLE orders_2025_01 PARTITION OF orders
            // FOR VALUES FROM ('2025-01-01') TO ('2025-02-01');
            // CREATE TABLE orders_2025_02 PARTITION OF orders
            // FOR VALUES FROM ('2025-02-01') TO ('2025-03-01');
            stmt.execute("""
                CREATE TABLE orders_2025_01 PARTITION OF orders
                FOR VALUES FROM ('2025-01-01') TO ('2025-02-01');
                CREATE TABLE orders_2025_02 PARTITION OF orders
                FOR VALUES FROM ('2025-02-01') TO ('2025-03-01');
            """);
            System.out.println("✅ 子分区创建成功");

            // === 3. 插入测试数据 ===
            // 等价 SQL:
            // INSERT INTO orders (order_date, customer_id, amount) VALUES
            // ('2025-01-15 10:00:00', 1, 100.50),
            // ('2025-01-20 14:30:00', 2, 200.00),
            // ('2025-02-10 09:00:00', 1, 150.25),
            // ('2025-02-15 16:45:00', 3, 300.75);
            stmt.execute("""
                INSERT INTO orders (order_date, customer_id, amount) VALUES
                    ('2025-01-15 10:00:00', 1, 100.50),
                    ('2025-01-20 14:30:00', 2, 200.00),
                    ('2025-02-10 09:00:00', 1, 150.25),
                    ('2025-02-15 16:45:00', 3, 300.75);
            """);
            System.out.println("✅ 测试数据插入成功");

            // === 4. 查询验证:带分区键(裁剪成功) ===
            // 等价 SQL:
            // EXPLAIN (ANALYZE, BUFFERS) SELECT * FROM orders WHERE order_date = '2025-01-15 10:00:00';
            try (ResultSet rs = stmt.executeQuery("""
                    EXPLAIN (ANALYZE, BUFFERS)
                    SELECT * FROM orders WHERE order_date = '2025-01-15 10:00:00';
                """)) {
                System.out.println("\n🔍 带分区键查询执行计划(裁剪成功):");
                while (rs.next()) {
                    System.out.println(rs.getString(1));
                }
            }

            // === 5. 查询验证:不带分区键(裁剪失败) ===
            // 等价 SQL:
            // EXPLAIN (ANALYZE, BUFFERS) SELECT * FROM orders WHERE customer_id = 1;
            try (ResultSet rs = stmt.executeQuery("""
                    EXPLAIN (ANALYZE, BUFFERS)
                    SELECT * FROM orders WHERE customer_id = 1;
                """)) {
                System.out.println("\n🔍 不带分区键查询执行计划(裁剪失败):");
                while (rs.next()) {
                    System.out.println(rs.getString(1));
                }
            }

            // === 6. 查看分区结构 ===
            // 等价 SQL:
            // SELECT
            //     inhrelid::regclass AS partition_name,
            //     pg_get_partition_constraintdef(inhrelid) AS range_def
            // FROM pg_inherits
            // WHERE inhparent = 'orders'::regclass;
            try (ResultSet rs = stmt.executeQuery("""
                    SELECT
                        inhrelid::regclass AS partition_name,
                        pg_get_partition_constraintdef(inhrelid) AS range_def
                    FROM pg_inherits
                    WHERE inhparent = 'orders'::regclass;
                """)) {
                System.out.println("\n📊 分区结构:");
                while (rs.next()) {
                    System.out.printf("  - %s: %s%n", rs.getString(1), rs.getString(2));
                }
            }

        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}
技术点总结
技术点说明
驱动选择使用官方 JDBC 驱动 org.postgresql:postgresql
连接管理使用 try-with-resources 自动释放资源
多语句执行JDBC 支持在 execute() 中一次执行多条 SQL
执行计划与 Node.js 示例相同的 EXPLAIN 查询方式

多语言对比表格

维度Node.js (pg)Go (pgx)Python (psycopg2)Java (JDBC)
驱动/库pgpgx/v5psycopg2-binarypostgresql:42.7.2
连接方式连接字符串DSN 连接字符串关键字参数JDBC URL
连接管理Client 对象pgx.Connectconnect()DriverManager
上下文支持原生异步回调支持 context.Context无(但支持游标)无(但可取消)
执行多语句query() 支持Exec() 支持execute() 支持execute() 支持(JDBC 4.2+)
结果处理行数组或异步迭代Rows.Next() 扫描fetchall() 元组列表ResultSet.next()
错误处理try-catch返回 errortry-excepttry-catch
事务支持使用 BEGIN/COMMIT使用 BeginTx自动提交或显式 cursor默认自动提交,可关闭
依赖管理npmgo modpip / requirements.txtMaven / Gradle
适用场景快速开发、原型高性能服务、并发数据科学、脚本企业应用、微服务
性能特点异步非阻塞极低开销、高并发成熟稳定、易用标准接口、可移植

共同技术要点:

  • 所有示例使用相同的 DDL 语句创建分区表和子分区
  • 通过 EXPLAIN (ANALYZE, BUFFERS) 验证分区裁剪效果
  • 通过 pg_inherits 和 pg_get_partition_constraintdef 查询分区结构
  • 均支持带分区键查询和不带分区键查询的对比演示

项目难点与解决方案

核心难点

分区表在实际生产中面临的核心矛盾是:分区裁剪带来的性能收益 vs 分区管理带来的复杂性和风险。具体表现为:

  1. 规划阶段的开销:大量分区时,优化器的规划时间和内存消耗都会增加
  2. 锁管理复杂性:分区表 DDL 操作涉及的锁数量远高于普通表
  3. 全局约束缺失:无法在分区表上建立真正的全局唯一约束

解决方案

  1. 规划阶段开销:升级到 PG 12 及以上版本,利用分区裁剪优化;控制分区数量(建议不超过 1000 个);使用多级分区时确保每级都能有效裁剪
  2. 锁管理复杂性:在业务低峰期执行 DDL 操作;监控 max_locks_per_transaction 使用情况;避免在 DDL 操作中使用 enable_partitionwise_join
  3. 全局约束缺失:在设计层面接受"分区内唯一"而非"全局唯一";或使用触发器 + 辅助表在应用层实现全局唯一性校验

深度

分区表优化的本质是通过空间换时间的策略,利用物理隔离(分文件存储)来减少每次查询需要扫描的数据量。但这种收益伴随着管理复杂度和资源消耗(文件句柄、内存、锁)的提升。理解这一权衡是正确使用分区表的关键。

复杂度

  • 设计复杂度:需要根据业务查询模式选择合适的分区键和分区粒度
  • 运维复杂度:需要定期维护分区(创建新分区、归档旧分区、清理过期数据)
  • 故障排查复杂度:分区裁剪失效、执行计划异常、锁竞争等问题定位难度较高

官方文档

参考链接

总结

本文系统梳理了 PostgreSQL 分区表的核心机制与实践要点。分区裁剪是发挥分区表性能优势的基础,查询中必须使用分区键,并避免使用 VOLATILE 函数导致裁剪失效。

PG 12 在分区表规划效率上实现了大幅提升,建议生产环境使用 PG 12 或以上版本。同时需要注意全局索引缺失带来的唯一约束限制、锁资源消耗风险以及 DDL 操作可能触发的表重写问题。

分区表的设计应遵循数据均匀分布、合理控制分区数量、确保裁剪覆盖率等核心原则,避免过度分区和默认分区的误用。

PostgreSQL表名63字节限制的坑:静默截断与命名规范 在数据库设计与开发中,标识符长度限制是一个容易被忽视却影响深远的底层约束。PostgreSQL作为主流关系型数据库,其默认的63字节标识符上限(由NAMEDATALEN决定)与MySQL的字符计数机制不同,导致许多开发者在迁移或建表时遭遇“表名被截断”的诡异问题。更棘手的是,PostgreSQL会静默截断超长对象名而不报错,进而引发关系已存在、查询失败、ORM元数据错乱、数据迁移不一致等一系列连锁故障。通过查询pg_class、pg_constraint等系统表,可以快速定位实际落库的截断名称;而建立统一的 阅读详情

相关推荐

PostgreSQL Schema设计:核心挑战与最佳实践

在关系型数据库设计中,Schema作为数据组织的逻辑容器,直接影响系统的可维护性和查询性能。PostgreSQL的Schema设计需要解决命名冲突、权限管理和查询优化等核心问题。通过采用领域驱动命名规范和分层Schema策略,可以有效提升团队协作效率和数据隔离安全性。在企业级应用中,合理的Schema设计能够显著降低技术债务,特别是在微服务架构和多租户系统中。本文结合金融、电商等真实案例,详解如何通过命名规范、垂直分层和动态管理来优化PostgreSQL Schema设计,实现高性能与高可用的数据架构。

weixin_29224529的博客 223

PostgreSQL 分区表——范围分区SQL实践

文本基于PostgreSQL原生分区能力,以创建时间作为分区键进行水平分表验证,要想发挥分区表的优势,多需要带上`分区键`进行操作,例如上文的删除以及更新操作中,带上分区键比未带分区键操作,性能存在10倍左右差异,但是进行`大批量`的操作,分区表的优势`不明显`,甚至有些场景还会非常慢。

qq_41725131的博客 1673

一种解决STM32多串口同时收发的方法

在做项目中,遇到了同时调用串口通信时程序崩溃的问题,在项目中,串口1用作调试串口,串口2用作MQTT通信串口,串口3用作下位机通信串口, 串口1重定向以后,用库函数自带的printf函数打印字符串 串口2使用自己写的u2_printf函数,即va_list这套变参宏定义后使用vsprintf函数打印字符串 串口3刚开始使用串口2一样的打印方式,程序在调试调用到串口3打印函数时直接崩溃,后续将串口3改用dma转存输出,仍然无法正常调用 多次研究以后,采用三个串口都使用重定向后的库函数自带的printf

Zxp0605的博客 8797

PostgreSQL分区表在云原生环境中的应用与挑战

本文深入探讨了PostgreSQL分区表在云原生环境中的创新应用与优化策略。通过动态资源调配、智能分层存储和分布式查询优化等核心技术,云原生环境显著提升了分区表的性能与可扩展性。文章结合电商平台等实际案例,展示了分区表在TB级数据处理中的卓越表现,并提供了多级分区、智能剪枝等关键优化方案,助力企业实现高效数据管理。

blue42的博客 853

CDO批量处理nc文件:5分钟搞定CMIP6数据双线性插值(附完整代码)

本文详细介绍了如何使用CDO工具链中的`remapbil`命令,快速实现CMIP6数据的批量双线性插值处理。通过环境配置、核心操作步骤、高级优化技巧及典型报错解决方案,帮助科研人员高效处理大规模nc文件,显著提升气象数据处理效率。

weixin_29267307的博客 296

电力电子技术(13)——大功率可控整流电路

目录引言2.6.1 带平衡电抗器的双反星形可控整流电路电路结构的特点接平衡电抗器的原因平衡电抗器使得两组三相半波整流电路同时导电的原理分析谐波分析2.6.2 多重化整流电路概述原理目标1)移相多重联结2)多重联结电路的顺序控制3重晶闸管整流桥顺序控制带平衡电抗器的双反星形可控整流电路(是多重化整流电路的重要形式之一)的特点:适用于低电压、大电流的场合。多重化整流电路的特点:绕组的极性相反的目的:消除直流磁通势如图所示,虽然两组相电流的瞬时值不同,但是平均电流相等而绕组的极性相反,所以直流安匝(电流*匝数)互

weixin_45589295的博客 1万+

分区表维护革命:PostgreSQL 18的精准运维哲学

PostgreSQL 18引入的`ONLY`关键字彻底改变了分区表维护方式,实现从全量处理到精准运维的范式转移。通过元数据分离和定向维护,TB级分区表的VACUUM和ANALYZE操作效率提升高达98%,特别适合时序数据和电商系统等大规模应用场景。

salt9的博客 491

Xilinx PCIe IP核示例工程仿真流程与关键任务解析

本文详细解析了Xilinx PCIe IP核示例工程的仿真流程与关键任务。通过搭建仿真环境、解读初始化日志,并深入剖析TSK_TX_MEMORY_WRITE_32等核心任务的TLP报文生成与交互过程,帮助开发者掌握PCIe IP核的仿真调试方法,为实际硬件设计提供可靠的验证基础。

weixin_28314575的博客 510

PostgreSQL分区表避坑指南:从普通表迁移到自动化分区的完整流程

本文详细解析了将PostgreSQL普通表平滑迁移至自动化分区表的完整实战流程。内容涵盖迁移前的战略评估、自动化分区管理框架的构建、零停机数据迁移方案,以及迁移后的性能调优与监控,旨在帮助DBA和开发者避开常见陷阱,实现高效、稳定的数据库架构演进。

o5p6q的博客 348

Ferry工单平台部署

ferry工单平台部署

运维求生之路 1897

【Halcon-2D测量】add_metrology_object_rectangle2_measure 函数功能(用于向2D计量模型中添加旋转矩形(rectangle2类型)计量对象)

HALCON算子add_metrology_object_rectangle2_measure解析摘要 该算子是HALCON 2D计量模块的核心算子,用于添加旋转矩形计量对象并配置测量参数。主要功能包括:定义旋转矩形几何轮廓(中心坐标、主轴角度、长短半长);生成垂直于矩形边界的测量区域;设置边缘提取预处理参数(高斯平滑、振幅阈值)。关键注意事项:MeasureLength1必须小于矩形长短半长;角度参数Phi需使用弧度单位;多线程需同步模型句柄。该算子适用于方形螺母、PCB板边框等矩形零件的精密测量,需与a

weixin_45590420的博客 1225

PostgreSQL技术解析:标识符最大长度限制为63字节

PostgreSQL技术解析:标识符最大长度限制为63字节 【免费下载链接】til :memo: Today I Learned 项目地址: https://gitcode.com/gh_mirrors/ti/til ...

gitblog_01108的博客 525

YOLOv13改进策略【多YAML融合】| HWD + DSC3k2_PConv + Detect_MBConv

本文记录的是利用HWD + DSC3k2_PConv + Detect_MBConv改进YOLOv13,分别涉及骨干、颈部和检测头部分的改进。一方面按照此配置,其工作量及创新程度能够满足论文发表的需求,另一方面是一些难以融合多个YAML的举例,以帮助大家理解如何将多个YAML整合到一个YAML中。小波下采样:一个简单但有效的语义分割下采样模块。块由两个主要块组成:无损特征编码块和特征表示学习块。HWD模块与其他下采样模块对比:保留信息能力:传统的下采样方法(如最大池化、平均池化和步幅卷积等)会导致信息丢失,

Limiiiing的博客 500

postgresql分妺_PostgreSQL 10分区表详解及性能测试报告__PostgreSQL资深专家同时也是社区志愿者阿弟,通过详细的操作过程,带领大家领略一下即将发布的PostgreSQL1...

postgres=# delete from order_range_fdw;DELETE 1postgres=# insert into order_range_fdw (id,userid,product,createdate) values(1,(random()::numeric(7,6)*1000000)::integer,md5(random()::text),('2016-01-01...

weixin_39781326的博客 432

YOLO26涨点改进 | 小目标损失函数独家改进篇 | TGRS 2025 | 引入AdaFocalLoss损失函数,改进小目标检测,自适应聚焦小目标与样本分布不平衡,提升检测精度与训练稳定性

目录一、前言:YOLO26原生损失函数在小目标检测中的核心痛点(涨点瓶颈)1.1 小目标权重不足,聚焦能力薄弱1.2 样本分布不平衡适配性差,正负样本权重失衡1.3 训练不稳定,易出现梯度消失/震荡1.4 未区分小目标与背景的冗余干扰,误检率高二、TGRS 2025顶刊灵感解析:自适应聚焦损失的核心逻辑三、全网独家创新:AdaFocalLoss损失函数设计与YOLO26适配(核心重点,可复现)3.1 AdaFocalLoss函数整体设计(独家设计,清晰可复现)3.2 各核心模块详细设计(独家创新,可直接复现

qq_36130719的博客 204

WINCC7.3破解文件

WINCC7.3硬件够破解文件,有需要的下载!WINCC7.3硬件够破解文件,有需要的下载!

PostgreSQL分区管理利器:pg_partman完整指南

pg_partman是PostgreSQL生态中备受推崇的分区管理扩展插件,专门用于简化和自动化基于时间或数值范围的分区表维护工作。它为DBA和开发人员提供了一整套强大的工具,让大规模分区表的管理变得轻松高效。 ## 核心特性 ### 声明式分区支持 pg_partman 5.0+版本全面拥抱PostgreSQL 14+的声明式分区,彻底告别触发器方式。声明式分区性能更优,是官方推荐的最佳实

gitblog_00694的博客 961

win10 跳过U8环境检测的IE WebControls.rar

win10 安装u8的时候 提示IE WebControls 不通过,这个工具可以欺骗u8的检查。 跳过U8环境检测的IE WebControls。提示导入失败后,重新检测通过。

PostgreSQL 10 分区表探密

PostgreSQL 10 分区表探密 分区介绍 PostgreSQL的分区需要先建立主表,然后再建立子表,使用继承的特性,但不需要手动写触发器/规则了,目前支持range、list分区,10 正式版发布时不知道会不会有其他的,后面我会介绍我基于10 Beta2添加的has...

551

android 蓝牙通讯demo

android 下蓝牙通讯demo,实现了发现蓝牙,使能蓝牙,通过蓝牙发送消息。

假人有限元模型

假人模型,车辆碰撞假人有限元模型,适合做乘员安全的研究者利用

PostgreSQL标识符长度限制不能超过63字节

PostgreSQL里面限制标识符(库名、表名等)长度不能超过63个字节,虽然这个参数可以在编译时修改,但是一般都不会去修改(63其实已经够用了,相当于6个长的单词,如果这都说不清楚,那么建议用简称+comment的模式)。

荷塘月色 830

PostgreSQL 为已有外键约束添加 ON DELETE CASCADE 的两步操作指南

本篇技术指南讲解如何在 PostgreSQL 中为**已经存在**的外键约束补上 `ON DELETE CASCADE` 行为。PostgreSQL 的 `ALTER TABLE` 无法直接修改现有约束的引用动作,必须通过"先删除约束、再以新定义重建约束"两步完成,并借助事务保证数据一致性。读完本文你将掌握这条标准迁移流程,以及与之配套的约束命名、孤儿数据排查与低锁添加约束等实战技巧。 ## 为

gitblog_00065的博客 653

PostgreSQL表名被悄悄截断?63字节标识符限制引发的分区建表故障排查

在数据库设计和日常运维中,标识符(表名、列名、索引名等)的长度限制是容易被忽视却影响深远的底层规则。PostgreSQL通过编译期常量NAMEDATALEN将标识符长度硬限制为63字节,且按字节而非字符计算,这意味着中文、emoji等字符会占用更多空间。当标识符超长时,PostgreSQL不会报错,而是静默截断,导致看似不同的名字在系统目录中变成同一个,进而引发“relation already exists”的诡异报错,尤其在声明式分区、自动化和ETL场景中频繁爆发。本文从这一原理出发,深入解析静默截断的

weixin_33326218的博客 252

PostgreSQL分区管理利器:pg_partman深度解析

pg_partman是PostgreSQL的一个扩展插件,专门用于简化基于时间或ID范围的分区表管理工作。它提供了自动化分区创建、维护和清理功能,让DBA和开发人员能够轻松管理大规模分区表。 ## 核心特性 ### 1. 声明式分区支持 pg_partman 5.0+版本仅支持PostgreSQL 14+的声明式分区,不再支持触发器方式的分区实现。声明式分区性能更好,是PostgreSQL官...

gitblog_00001的博客 1085

java的获取pg分区表的api,Postgresql-9.5第三方分区表管理工具pg_partman测试

第三方分区表管理工具pg_partman。[postgres@db2 ~] unzip pg_partman-2.6.2.zip[postgres@db2 ~]cd pg_partman-2.6.2[postgres@db2 ~] make install[postgres@db2 ~]$ psql -d tankpsql (9.5.5)Type "help" for help.tank=# CR...

weixin_33687939的博客 379

Azure Terraform实战指南:从零部署VM、PostgreSQL与AKS

基础设施即代码(IaC)是现代云运维的基础范式,其核心在于将资源定义转化为可版本控制、可协作、可审计的声明式配置。Terraform作为主流IaC工具,在Azure平台上通过Azurerm Provider实现对虚拟机、数据库、容器服务等资源的统一编排。其技术价值不仅在于自动化部署,更在于通过状态管理、模块化设计和防误删机制(如lifecycle.prevent_destroy)保障生产环境稳定性与合规性。典型应用场景包括快速构建开发测试环境、实施多环境隔离(dev/staging/prod)、集成CI/C

weixin_30561425的博客 315

Odoo服务器搭建避坑指南:Ubuntu+PostgreSQL+Python深度配置

Odoo并非开箱即用的单体应用,而是一个依赖操作系统内核、数据库引擎、运行时环境与Web服务协同工作的企业级ERP框架。其核心原理在于Ubuntu系统层(如locale、swappiness、file-max)、PostgreSQL(shared_buffers、pg_hba.conf、连接池)、Python3(版本锁定、venv隔离)与pip3(源加速、wheel缓存清理)四者必须严格对齐。这种强耦合带来高稳定性,也导致常见‘一键安装’失败——本质是环境链断裂。技术价值体现在生产就绪性:规避内存抖动、DN

weixin_34302561的博客 481

GORM PostgreSQL 驱动实战指南:从 DSN 连接到源码级配置解析

本篇技术指南以 GORM 官方 PostgreSQL 驱动(`gorm.io/driver/postgres`)为核心,系统讲解其快速接入方式、`postgres.Config` 全部配置项、DSN 底层解析机制、类型映射与自动迁移能力,并结合当前仓库(Sliver Adversary Emulation Framework)中服务端数据库层的真实调用代码,说明该驱动在生产项目中的落地方式。读完本

gitblog_00670的博客 394

EMQX PostgreSQL 数据桥接:将 MQTT 物联网数据写入 PostgreSQL 的完整指南

> **导读**:本文以 EMQX 开源仓库中的 `apps/emqx_bridge_pgsql` 应用为核心,系统讲解 EMQX 与 PostgreSQL 之间的数据桥接能力——如何通过 EMQX 规则引擎把 MQTT 消息实时写入 PostgreSQL 关系型数据库,实现 IoT 数据的持久化存储与分析。阅读完本文,你将掌握 PostgreSQL 桥接的架构原理(连接器 + 动作两层模型)、S

gitblog_01196的博客 889
上一篇: PostgreSQL笔记62: 分区表维护最佳实践——默认分区、锁策略与性能调优
下一篇: PostgreSQL笔记64:分区插件生态与扩展查询协议深度解析
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、付费专栏及课程。

余额充值