PostgreSQL笔记12:PGDATA 数据目录结构与核心文件深度解析

PostgreSQL数据库重启失败排查指南:从权限到数据恢复的完整解决方案 数据库启动流程是数据库管理系统的基础运行机制,它涉及进程初始化、内存分配、配置加载和数据恢复等多个关键环节。理解这一原理对于保障数据库服务的持续可用性至关重要,尤其在应对非计划停机时能快速定位问题根源。从技术价值角度看,掌握系统性的故障排查方法不仅能缩短服务恢复时间,更能提升运维体系的健壮性。在实际应用场景中,数据库重启异常常由权限配置、端口冲突、WAL日志恢复或数据文件损坏等问题引发。本文聚焦PostgreSQL重启异常处理,通过分层排查模型,结合日志分析和pg_ctl等工具,提供从环境检查到数据恢复的实 阅读详情

纲要

  • PGDATA:数据目录环境变量与默认路径
  • base/:默认表空间数据目录,按数据库 OID 组织
  • OID(对象标识符)与 relfilenode 的区别
  • pg_database、pg_class:核心系统表
  • _fsm(空闲空间映射)与 _vm(可见性映射)辅助文件
  • pg_wal/:预写式日志目录(WAL)
  • pg_tblspc/:表空间符号链接目录
  • pg_commit_ts/ 与 pg_xact/(原 pg_clog/):事务提交时间戳与事务状态
  • pg_stat/ 与 pg_stat_tmp/:统计信息存储
  • postgresql.conf:主配置文件
  • postgresql.auto.conf:ALTER SYSTEM 自动生成的配置文件(优先级更高)
  • pg_hba.conf:客户端认证配置文件(首次匹配原则)
  • postmaster.pid:运行锁文件,防止实例重复启动
  • Unix Domain Socket 与 TCP/IP 通信方式
  • CREATE TABLESPACE 与 ALTER SYSTEM 管理命令

一、PGDATA 数据目录概述

PostgreSQL 集群的所有运行状态、配置参数、预写式日志(WAL)、数据库表文件等均存放在数据目录(Data Directory)下。该目录由环境变量 PGDATA 指向,是整个数据库集群的“家目录”。理解其层级结构与各文件职责,是进行故障排查、备份恢复及高可用部署的必要基础。

数据目录的默认位置取决于安装方式:

安装方式默认 PGDATA 路径
RPM / YUM 安装/var/lib/pgsql/data
源码编译安装由 initdb -D 参数指定

环境变量 PGDATA 和 PGPORT 可简化日常管理命令。例如,执行 pg_ctl start 时若未指定 -D,系统将自动读取 PGDATA;psql 连接时若未指定 -p,则会使用 PGPORT。

# 设置环境变量(通常写入 .bashrc 或 .bash_profile)
export PGDATA=/var/lib/pgsql/17/data
export PGPORT=5433

# 之后即可直接使用 pg_ctl
pg_ctl start
pg_ctl stop

二、PGDATA 根目录结构

进入 PGDATA 目录(示例:/var/lib/pgsql/17/data),通过 ls -l 可看到以下核心子目录与文件:

PGDATA/
├── PG_VERSION                # 主版本号
├── base/                     # 按数据库 OID 组织的子目录
├── global/                   # 集群级全局系统表
├── pg_commit_ts/             # 事务提交时间戳(需开启 track_commit_timestamp)
├── pg_dynshmem/              # 动态共享内存文件
├── pg_logical/               # 逻辑解码状态数据
├── pg_multixact/             # 多事务状态数据
├── pg_notify/                # LISTEN/NOTIFY 状态数据
├── pg_replslot/              # 复制槽数据
├── pg_serial/                # 可串行化事务信息
├── pg_snapshots/             # 导出的快照
├── pg_stat/                  # 统计信息永久存储
├── pg_stat_tmp/              # 统计信息临时文件
├── pg_subtrans/              # 子事务状态数据
├── pg_tblspc/                # 表空间符号链接
├── pg_twophase/              # 预备事务状态文件
├── pg_wal/                   # 预写式日志(WAL)文件
├── pg_xact/                  # 事务提交状态数据(9.3 前为 pg_clog)
├── postgresql.conf           # 主配置文件
├── postgresql.auto.conf      # ALTER SYSTEM 写入的配置文件(高优先级)
├── pg_hba.conf               # 客户端认证配置
├── pg_ident.conf             # 用户名映射文件
├── postmaster.pid            # 进程锁文件(运行时存在)
├── postmaster.opts           # 上次启动的命令行选项
└── current_logfiles          # 当前正在写入的日志文件

三、核心数据子目录详解

3.1 base/ —— 默认表空间数据目录

base/ 是 PGDATA 中最核心的目录。在未创建额外表空间的情况下,所有数据库的表、索引等数据文件均存放于此。

base/ 下的子目录以对应数据库的 OID(Object Identifier) 命名。OID 是 PostgreSQL 内部用于唯一标识数据库对象(如数据库、表、索引)的整型标识符。

-- 查询所有数据库的 OID
SELECT oid, datname FROM pg_database ORDER BY oid;

每个数据库目录下,存放着该库所有表与索引的数据文件。文件名依据 pg_class.relfilenode,而非直接使用 OID:

-- 查询表的 relfilenode
SELECT relname, relfilenode, oid FROM pg_class WHERE relname = 'your_table';

重要:relfilenode 与 OID 通常一致,但某些操作(如 TRUNCATE、REINDEX、CLUSTER、部分 ALTER TABLE)会改变 relfilenode 而保留 OID。因此不应假设文件名与 OID 始终相同。

辅助文件:FSM 与 VM

在每个表的数据文件旁,可能存在两个辅助文件:

后缀全称作用
_fsmFree Space Map记录每个数据页的空闲空间,供 INSERT 快速定位可容纳新行的页面
_vmVisibility Map标记哪些数据页中所有元组对所有事务可见,帮助 VACUUM 跳过这些页面
# 示例:表 test 的数据文件及辅助文件
$ ls -la base/16384/
-rw------- 1 postgres postgres 8192 16552
-rw------- 1 postgres postgres 8192 16552_fsm
-rw------- 1 postgres postgres 8192 16552_vm

当表或索引超过 1GB 时,PostgreSQL 会自动将其拆分为多个段文件(segment):

-rw------- 1 postgres postgres 1073741824 16552
-rw------- 1 postgres postgres 1073741824 16552.1
-rw------- 1 postgres postgres  52428800 16552.2

3.2 global/ —— 集群级全局系统表

global/ 目录存放集群范围内共享的系统表,如 pg_database、pg_control 等。这些文件为所有数据库共用,不隶属于任何特定数据库。

3.3 pg_tblspc/ —— 表空间符号链接

pg_tblspc/ 目录包含指向用户定义表空间实际位置的符号链接。每个链接以表空间的 OID 命名:

$ ls -la $PGDATA/pg_tblspc/
lrwxrwxrwx 1 postgres postgres 36 16385 -> /data/tablespace/my_tablespace

创建表空间时,PostgreSQL 在 pg_tblspc/ 下创建符号链接,指向 CREATE TABLESPACE 中指定的物理路径:

-- 创建表空间
CREATE TABLESPACE fast_space LOCATION '/ssd/postgres/tablespace';

-- 在指定表空间上创建表
CREATE TABLE test(id int) TABLESPACE fast_space;

表空间的核心应用场景是实现冷热数据分离:将频繁访问的热数据置于高速 SSD,将历史冷数据迁移至廉价大容量 HDD,从而优化存储成本与访问性能。

3.4 pg_wal/ —— 预写式日志

pg_wal/(早期版本为 pg_xlog)存放 WAL 段文件,这是 PostgreSQL 崩溃恢复和流复制的基础。

WAL 原理:在对数据文件进行任何修改之前,先将修改操作记录到 WAL 日志中。数据库崩溃后重启时,通过重放 WAL 日志将数据恢复至一致性状态。在流复制中,主节点持续将 WAL 记录发送至备节点,备节点重放日志以保持同步。

$ ls -la $PGDATA/pg_wal/
-rw------- 1 postgres postgres 16777216 000000010000000000000001
-rw------- 1 postgres postgres 16777216 000000010000000000000002

默认每个 WAL 段文件为 16MB(可通过 initdb --wal-segsize 调整)。

3.5 pg_commit_ts/ —— 事务提交时间戳(9.5+)

pg_commit_ts/ 记录每个事务的提交时间戳。该功能默认关闭,需启用参数 track_commit_timestamp = on。

-- 启用(需重启)
ALTER SYSTEM SET track_commit_timestamp = on;
-- 或编辑 postgresql.conf 后重启

-- 查询事务提交时间
SELECT pg_xact_commit_timestamp(12345);

3.6 pg_xact/ —— 事务提交状态

pg_xact/(9.3 及更早版本为 pg_clog/)存储事务的提交状态(已提交、已中止、进行中)。这是 PostgreSQL MVCC 机制的核心组成部分。

3.7 其他辅助目录

目录用途引入版本
pg_notify/LISTEN/NOTIFY 状态数据所有版本
pg_dynshmem/动态共享内存文件(并行查询)9.4+
pg_multixact/多事务状态数据(共享行锁)8.3+
pg_subtrans/子事务状态数据所有版本
pg_serial/已提交的可串行化事务信息9.1+
pg_snapshots/导出的快照9.2+
pg_twophase/预备事务(PREPARE TRANSACTION)状态所有版本
pg_replslot/复制槽数据9.4+
pg_logical/逻辑解码状态数据9.4+
pg_stat/ 和 pg_stat_tmp/统计信息(永久和临时)所有版本

四、核心配置文件

4.1 postgresql.conf —— 主配置

postgresql.conf 包含所有 GUC 参数,按功能模块组织(内存、日志、复制等),每个参数均有详细注释。

# 查看关键内存参数
$ grep -E "shared_buffers|work_mem" $PGDATA/postgresql.conf
shared_buffers = 128MB
work_mem = 4MB

4.2 postgresql.auto.conf —— ALTER SYSTEM 配置

postgresql.auto.conf 由 ALTER SYSTEM 命令自动维护。请勿手动编辑,文件头部明确提示:

# Do not edit this file manually!
# It will be overwritten by the ALTER SYSTEM command.

优先级:postgresql.auto.conf 的优先级高于 postgresql.conf。启动时先读取 postgresql.conf,再读取 auto.conf,后者覆盖前者同名参数。

-- 动态修改参数
ALTER SYSTEM SET work_mem = '32MB';
SELECT pg_reload_conf();  -- 重载配置

-- 查看当前生效值
SHOW work_mem;

同一文件内规则:若同一参数出现多次,以最后一次出现的值为准。

4.3 pg_hba.conf —— 客户端认证

pg_hba.conf(Host-Based Authentication)控制哪些客户端可以连接,以及认证方式。

匹配顺序:采用从上到下的首次匹配原则。匹配到第一条符合条件的规则后即停止,不再继续。

# pg_hba.conf 示例
# TYPE  DATABASE  USER  ADDRESS       METHOD
local   all       all                 peer
host    all       all   127.0.0.1/32  scram-sha-256
host    all       all   0.0.0.0/0     reject

4.4 pg_ident.conf —— 用户名映射

pg_ident.conf 用于将操作系统用户名映射为数据库用户名,与 ident 或 peer 认证方法配合使用。

五、运行时状态文件

postmaster.pid

该文件在数据库运行时存在,内容包含:

  1. 主进程 PID(可通过 ps -ef | grep <PID> 验证)
  2. 数据目录路径
  3. 启动时间戳(Epoch 格式)
  4. 监听端口
  5. Unix Domain Socket 目录(通常为 /tmp)
  6. 共享内存 Key(操作系统级 IPC 标识)
  7. 实例状态(通常为 ready)

重要:该文件用于防止同一数据目录被多个实例同时启动,避免数据损坏。严禁在数据库运行时手动删除。

$ cat $PGDATA/postmaster.pid
31546
/var/lib/pgsql/17/data
1640995200
5433
/tmp
5432001
ready

Unix Domain Socket 与 TCP/IP

PostgreSQL 支持两种通信方式:

  • Unix Domain Socket:仅限本机进程间通信,基于文件系统路径(默认 /tmp),性能更高,不占用网络端口。
  • TCP/IP Socket:支持跨主机通信,需配置 listen_addresses 和 port。
# 通过 Unix Domain Socket 连接
psql -h /tmp -p 5433 -U postgres

# 查看当前连接详情
psql -c "SELECT pid, usename, application_name, client_addr FROM pg_stat_activity;"

六、API 速览

系统表与函数

API / 函数所属模块描述示例
pg_database系统表存储数据库元信息(含 OID)SELECT oid, datname FROM pg_database;
pg_class系统表存储表/索引元信息(含 relfilenode)SELECT oid, relfilenode FROM pg_class WHERE relname = 'test';
pg_xact_commit_timestamp(xid)系统函数查询事务提交时间戳(需启用 track_commit_timestamp)SELECT pg_xact_commit_timestamp('12345'::xid);
pg_reload_conf()系统函数重载配置文件,无需重启SELECT pg_reload_conf();
pg_relation_filepath(rel)系统函数返回表或索引的数据文件路径SELECT pg_relation_filepath('test_table');
pg_current_xact_id()系统函数返回当前事务 IDSELECT pg_current_xact_id();

管理命令

命令 / SQL所属模块描述示例
initdb -D <dir>初始化工具创建新数据目录initdb -D /pgdata/17
pg_ctl -D <dir> start控制工具启动实例pg_ctl -D $PGDATA start
CREATE TABLESPACE ... LOCATIONSQL创建表空间CREATE TABLESPACE fast LOCATION '/ssd/data';
ALTER SYSTEM SETSQL动态修改 GUC 参数ALTER SYSTEM SET max_connections = 200;
SHOW <param>SQL查看参数当前值SHOW shared_buffers;

七、Demo 简单示例

以下完整 Node.js 示例演示了连接 PostgreSQL,查询 OID、relfilenode,创建表空间,动态修改参数,并获取事务提交时间戳。该示例融合了博客核心知识点。

环境准备

# 初始化数据目录(假设已安装 PostgreSQL 17)
initdb -D ~/pgdemo_data

# 启动数据库(使用 Unix Domain Socket,默认端口 5432)
pg_ctl -D ~/pgdemo_data -l ~/pgdemo.log start

# 创建测试数据库
createdb demo_db

Node.js 完整代码

import { Client } from 'pg';
import * as fs from 'fs';
import * as path from 'path';

// 连接配置(使用 Unix Domain Socket)
const config = {
    host: '/tmp',          // Unix socket 目录
    database: 'demo_db',
    port: 5432,
    user: process.env.USER || 'postgres',
};

const client = new Client(config);

async function runDemo() {
    try {
        await client.connect();
        console.log('=== 1. 查询数据库 OID ===');
        const dbRes = await client.query(
            `SELECT oid, datname FROM pg_database WHERE datname = 'demo_db';`
        );
        console.log(dbRes.rows[0]);

        // 2. 创建表空间(需要目录存在)
        const tblspcPath = path.join(process.env.HOME || '/tmp', 'pg_demo_tblspc');
        if (!fs.existsSync(tblspcPath)) {
            fs.mkdirSync(tblspcPath, { recursive: true });
        }
        await client.query(
            `CREATE TABLESPACE IF NOT EXISTS demo_tblspc LOCATION '${tblspcPath}';`
        );
        console.log('表空间 demo_tblspc 创建成功');

        // 3. 创建表并指定表空间
        await client.query(`
            CREATE TABLE IF NOT EXISTS test_data (
                id SERIAL PRIMARY KEY,
                content TEXT
            ) TABLESPACE demo_tblspc;
        `);
        console.log('表 test_data 创建成功(位于 demo_tblspc)');

        // 4. 查询该表的 relfilenode
        const relRes = await client.query(
            `SELECT oid, relname, relfilenode FROM pg_class WHERE relname = 'test_data';`
        );
        console.log('=== 表的 relfilenode ===');
        console.log(relRes.rows[0]);

        // 5. 通过 ALTER SYSTEM 修改 work_mem
        await client.query(`ALTER SYSTEM SET work_mem = '16MB';`);
        await client.query(`SELECT pg_reload_conf();`);
        const showRes = await client.query(`SHOW work_mem;`);
        console.log(`当前 work_mem: ${showRes.rows[0].work_mem}`);

        // 6. 插入数据并获取事务提交时间(需开启 track_commit_timestamp)
        await client.query(`INSERT INTO test_data (content) VALUES ('Hello PostgreSQL')`);
        const xidRes = await client.query(`SELECT pg_current_xact_id();`);
        const xid = xidRes.rows[0].pg_current_xact_id;
        console.log(`当前事务 ID: ${xid}`);

        // 尝试查询提交时间戳
        try {
            const tsRes = await client.query(
                `SELECT pg_xact_commit_timestamp(${xid});`
            );
            console.log(`事务提交时间戳: ${tsRes.rows[0].pg_xact_commit_timestamp}`);
        } catch (err) {
            console.log('track_commit_timestamp 未开启,无法获取提交时间');
        }

        // 7. 查看数据文件路径(利用 pg_relation_filepath)
        const filePathRes = await client.query(
            `SELECT pg_relation_filepath('test_data');`
        );
        console.log('数据文件相对路径:', filePathRes.rows[0].pg_relation_filepath);

    } catch (err) {
        console.error('执行出错:', err);
    } finally {
        await client.end();
    }
}

runDemo();

运行说明

  1. 安装依赖:npm install pg
  2. 确保 PostgreSQL 已启动,且 demo_db 数据库存在。
  3. 执行脚本(使用 ts-node 或编译为 JS 后运行)。
  4. 观察控制台输出,验证 OID、relfilenode、参数修改及提交时间戳等结果。

技术点总结

该 Demo 演示了以下核心内容:

  • 通过 pg_database 查询数据库 OID;
  • 使用 pg_class 获取表的 relfilenode;
  • CREATE TABLESPACE 的创建与表空间分配;
  • ALTER SYSTEM 动态修改 GUC 参数及 pg_reload_conf() 热加载;
  • SHOW 命令验证参数生效;
  • 获取当前事务 ID 及可选的事务提交时间戳;
  • 使用 pg_relation_filepath 获取数据文件相对路径(关联 base/ 目录结构)。

PostgreSQL笔记: 多语言连接与操作示例(Node.js / Go / Python / Java)

纲要

  • 数据库连接配置(Unix Domain Socket 与 TCP/IP)
  • 查询数据库 OID 与表的 relfilenode
  • 创建表空间与指定表空间建表
  • 通过 ALTER SYSTEM 动态修改参数并热加载
  • 获取当前事务 ID 与提交时间戳(可选)
  • 使用 pg_relation_filepath 获取数据文件路径
  • 各语言驱动与 ORM 选型对比

背景与前提

本文基于前一篇关于 PostgreSQL 数据目录结构的深度解析,提供四种主流编程语言(Node.js、Go、Python、Java)的完整代码示例。这些示例演示了如何通过程序化方式操作数据库元数据、管理表空间、动态调整配置参数,并验证数据文件与事务状态。

所有示例均假设:

  • PostgreSQL 数据库已安装并运行(端口 5432,使用 Unix Domain Socket 位于 /tmp)
  • 已创建测试数据库 demo_db
  • 具有 postgres 超级用户权限(用于 ALTER SYSTEM)

各语言驱动版本:

  • Node.js: pg (^8.11.0)
  • Go: github.com/lib/pq (v1.10.9)
  • Python: psycopg2 (2.9.9) 或 psycopg2-binary
  • Java: org.postgresql:postgresql (42.6.0)

环境准备

# 初始化数据目录(若尚未执行)
initdb -D ~/pgdemo_data

# 启动数据库
pg_ctl -D ~/pgdemo_data -l ~/pgdemo.log start

# 创建测试数据库
createdb demo_db

# 设置环境变量(可选)
export PGDATA=~/pgdemo_data
export PGPORT=5432

核心操作流程

每个语言的示例均包含以下步骤:

  1. 连接数据库:使用 Unix Domain Socket(host=/tmp)提高本地通信效率。
  2. 查询数据库 OID:从 pg_database 获取 demo_db 的 OID。
  3. 创建表空间:在用户目录下创建目录,并执行 CREATE TABLESPACE。
  4. 创建表并指定表空间:在新建表空间上创建 test_data 表。
  5. 查询表的 relfilenode:从 pg_class 获取该表的文件节点。
  6. 动态修改参数:使用 ALTER SYSTEM SET work_mem = '16MB',然后 SELECT pg_reload_conf() 热加载。
  7. 验证参数生效:SHOW work_mem。
  8. 插入数据并获取事务 ID:插入一行数据,通过 pg_current_xact_id() 获取当前事务 ID。
  9. 尝试获取事务提交时间戳:若 track_commit_timestamp 已开启,则查询。
  10. 获取数据文件路径:通过 pg_relation_filepath('test_data') 获取相对路径(对应 base/ 下的文件)。

各语言实现

Node.js(使用 pg 驱动)

import { Client } from 'pg';
import * as fs from 'fs';
import * as path from 'path';

const config = {
    host: '/tmp',
    database: 'demo_db',
    port: 5432,
    user: process.env.USER || 'postgres',
};

const client = new Client(config);

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

        // 1. 查询数据库 OID
        const dbRes = await client.query(
            `SELECT oid, datname FROM pg_database WHERE datname = 'demo_db';`
        );
        console.log('Database OID:', dbRes.rows[0]);

        // 2. 创建表空间目录
        const tblspcPath = path.join(process.env.HOME || '/tmp', 'pg_demo_tblspc');
        if (!fs.existsSync(tblspcPath)) fs.mkdirSync(tblspcPath, { recursive: true });

        await client.query(
            `CREATE TABLESPACE IF NOT EXISTS demo_tblspc LOCATION '${tblspcPath}';`
        );
        console.log('Tablespace created');

        // 3. 创建表
        await client.query(`
            CREATE TABLE IF NOT EXISTS test_data (
                id SERIAL PRIMARY KEY,
                content TEXT
            ) TABLESPACE demo_tblspc;
        `);

        // 4. 查询 relfilenode
        const relRes = await client.query(
            `SELECT oid, relname, relfilenode FROM pg_class WHERE relname = 'test_data';`
        );
        console.log('relfilenode:', relRes.rows[0]);

        // 5. ALTER SYSTEM 修改参数
        await client.query(`ALTER SYSTEM SET work_mem = '16MB';`);
        await client.query(`SELECT pg_reload_conf();`);
        const showRes = await client.query(`SHOW work_mem;`);
        console.log('work_mem:', showRes.rows[0].work_mem);

        // 6. 插入并获取事务 ID
        await client.query(`INSERT INTO test_data (content) VALUES ('Hello Node.js')`);
        const xidRes = await client.query(`SELECT pg_current_xact_id();`);
        const xid = xidRes.rows[0].pg_current_xact_id;
        console.log('Transaction ID:', xid);

        // 7. 提交时间戳(需启用 track_commit_timestamp)
        try {
            const tsRes = await client.query(
                `SELECT pg_xact_commit_timestamp(${xid});`
            );
            console.log('Commit timestamp:', tsRes.rows[0].pg_xact_commit_timestamp);
        } catch (e) {
            console.log('track_commit_timestamp not enabled');
        }

        // 8. 数据文件路径
        const fpRes = await client.query(
            `SELECT pg_relation_filepath('test_data');`
        );
        console.log('File path:', fpRes.rows[0].pg_relation_filepath);

    } catch (err) {
        console.error(err);
    } finally {
        await client.end();
    }
}

runDemo();

Go(使用 lib/pq 驱动)

package main

import (
    "database/sql"
    "fmt"
    "log"
    "os"
    "path/filepath"

    _ "github.com/lib/pq"
)

func main() {
    // 连接字符串(Unix Domain Socket)
    connStr := "host=/tmp dbname=demo_db user=postgres sslmode=disable"
    db, err := sql.Open("postgres", connStr)
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()

    // 1. 查询 OID
    var oid int
    var datname string
    err = db.QueryRow(
        `SELECT oid, datname FROM pg_database WHERE datname = 'demo_db'`,
    ).Scan(&oid, &datname)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("Database OID: %d, name: %s\n", oid, datname)

    // 2. 创建表空间目录
    home := os.Getenv("HOME")
    if home == "" {
        home = "/tmp"
    }
    tblspcPath := filepath.Join(home, "pg_demo_tblspc")
    if _, err := os.Stat(tblspcPath); os.IsNotExist(err) {
        os.MkdirAll(tblspcPath, 0755)
    }

    _, err = db.Exec(
        fmt.Sprintf("CREATE TABLESPACE IF NOT EXISTS demo_tblspc LOCATION '%s'", tblspcPath),
    )
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("Tablespace created")

    // 3. 创建表
    _, err = db.Exec(`
        CREATE TABLE IF NOT EXISTS test_data (
            id SERIAL PRIMARY KEY,
            content TEXT
        ) TABLESPACE demo_tblspc
    `)
    if err != nil {
        log.Fatal(err)
    }

    // 4. 查询 relfilenode
    var reloid, relfilenode int
    var relname string
    err = db.QueryRow(
        `SELECT oid, relname, relfilenode FROM pg_class WHERE relname = 'test_data'`,
    ).Scan(&reloid, &relname, &relfilenode)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("relfilenode: %d (oid=%d)\n", relfilenode, reloid)

    // 5. ALTER SYSTEM 修改参数
    _, err = db.Exec(`ALTER SYSTEM SET work_mem = '16MB'`)
    if err != nil {
        log.Fatal(err)
    }
    _, err = db.Exec(`SELECT pg_reload_conf()`)
    if err != nil {
        log.Fatal(err)
    }
    var workMem string
    err = db.QueryRow(`SHOW work_mem`).Scan(&workMem)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("work_mem:", workMem)

    // 6. 插入并获取事务 ID
    _, err = db.Exec(`INSERT INTO test_data (content) VALUES ('Hello Go')`)
    if err != nil {
        log.Fatal(err)
    }
    var xid uint64
    err = db.QueryRow(`SELECT pg_current_xact_id()`).Scan(&xid)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("Transaction ID:", xid)

    // 7. 提交时间戳
    var ts *string
    err = db.QueryRow(
        fmt.Sprintf("SELECT pg_xact_commit_timestamp(%d)", xid),
    ).Scan(&ts)
    if err != nil {
        fmt.Println("track_commit_timestamp not enabled or error:", err)
    } else if ts != nil {
        fmt.Println("Commit timestamp:", *ts)
    }

    // 8. 数据文件路径
    var filepath string
    err = db.QueryRow(
        `SELECT pg_relation_filepath('test_data')`,
    ).Scan(&filepath)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("File path:", filepath)
}

Python(使用 psycopg2)

import os
import psycopg2
from psycopg2 import sql

def main():
    # 连接(Unix Domain Socket)
    conn = psycopg2.connect(
        host='/tmp',
        dbname='demo_db',
        user='postgres'
    )
    conn.autocommit = True
    cur = conn.cursor()

    # 1. 查询 OID
    cur.execute(
        "SELECT oid, datname FROM pg_database WHERE datname = 'demo_db'"
    )
    oid, datname = cur.fetchone()
    print(f"Database OID: {oid}, name: {datname}")

    # 2. 创建表空间目录
    home = os.environ.get('HOME', '/tmp')
    tblspc_path = os.path.join(home, 'pg_demo_tblspc')
    os.makedirs(tblspc_path, exist_ok=True)

    cur.execute(
        sql.SQL("CREATE TABLESPACE IF NOT EXISTS demo_tblspc LOCATION {}")
        .format(sql.Literal(tblspc_path))
    )
    print("Tablespace created")

    # 3. 创建表
    cur.execute("""
        CREATE TABLE IF NOT EXISTS test_data (
            id SERIAL PRIMARY KEY,
            content TEXT
        ) TABLESPACE demo_tblspc
    """)

    # 4. 查询 relfilenode
    cur.execute(
        "SELECT oid, relname, relfilenode FROM pg_class WHERE relname = 'test_data'"
    )
    reloid, relname, relfilenode = cur.fetchone()
    print(f"relfilenode: {relfilenode} (oid={reloid})")

    # 5. ALTER SYSTEM 修改参数
    cur.execute("ALTER SYSTEM SET work_mem = '16MB'")
    cur.execute("SELECT pg_reload_conf()")
    cur.execute("SHOW work_mem")
    work_mem = cur.fetchone()[0]
    print(f"work_mem: {work_mem}")

    # 6. 插入并获取事务 ID
    cur.execute("INSERT INTO test_data (content) VALUES ('Hello Python')")
    cur.execute("SELECT pg_current_xact_id()")
    xid = cur.fetchone()[0]
    print(f"Transaction ID: {xid}")

    # 7. 提交时间戳
    try:
        cur.execute(
            "SELECT pg_xact_commit_timestamp(%s)", (xid,)
        )
        ts = cur.fetchone()[0]
        if ts:
            print(f"Commit timestamp: {ts}")
    except psycopg2.Error as e:
        print("track_commit_timestamp not enabled or error:", e)

    # 8. 数据文件路径
    cur.execute("SELECT pg_relation_filepath('test_data')")
    filepath = cur.fetchone()[0]
    print(f"File path: {filepath}")

    cur.close()
    conn.close()

if __name__ == "__main__":
    main()

Java(使用 JDBC 驱动)

import java.sql.*;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.io.File;

public class PostgresDemo {
    public static void main(String[] args) {
        String url = "jdbc:postgresql://localhost:5432/demo_db";
        // 使用 Unix Domain Socket 需额外配置,此处使用 TCP/IP 本地回环
        // 注意:JDBC 默认不支持 Unix Domain Socket,若需使用请改用 `jdbc:postgresql:///demo_db?host=/tmp`
        // 但为通用性,此处使用 localhost:5432(需确保 postgresql.conf 中 listen_addresses 包含 '*' 或 'localhost')
        // 若坚持 Unix Socket,可配置连接参数 socketFactory=org.newsclub.net.unix.AFUNIXSocketFactory$FactoryArg
        // 此处采用 TCP/IP 以便演示,但主题仍一致。
        String user = "postgres";
        String password = ""; // 若未设置密码则留空

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

            // 1. 查询 OID
            ResultSet rs = stmt.executeQuery(
                "SELECT oid, datname FROM pg_database WHERE datname = 'demo_db'"
            );
            if (rs.next()) {
                int oid = rs.getInt("oid");
                String dbname = rs.getString("datname");
                System.out.println("Database OID: " + oid + ", name: " + dbname);
            }
            rs.close();

            // 2. 创建表空间目录
            String home = System.getenv("HOME");
            if (home == null) home = "/tmp";
            String tblspcPath = home + "/pg_demo_tblspc";
            Files.createDirectories(Paths.get(tblspcPath));

            stmt.execute(
                "CREATE TABLESPACE IF NOT EXISTS demo_tblspc LOCATION '" + tblspcPath + "'"
            );
            System.out.println("Tablespace created");

            // 3. 创建表
            stmt.execute(
                "CREATE TABLE IF NOT EXISTS test_data (" +
                "id SERIAL PRIMARY KEY, " +
                "content TEXT) TABLESPACE demo_tblspc"
            );

            // 4. 查询 relfilenode
            rs = stmt.executeQuery(
                "SELECT oid, relname, relfilenode FROM pg_class WHERE relname = 'test_data'"
            );
            if (rs.next()) {
                int reloid = rs.getInt("oid");
                String relname = rs.getString("relname");
                int relfilenode = rs.getInt("relfilenode");
                System.out.println("relfilenode: " + relfilenode + " (oid=" + reloid + ")");
            }
            rs.close();

            // 5. ALTER SYSTEM 修改参数
            stmt.execute("ALTER SYSTEM SET work_mem = '16MB'");
            stmt.execute("SELECT pg_reload_conf()");
            rs = stmt.executeQuery("SHOW work_mem");
            if (rs.next()) {
                System.out.println("work_mem: " + rs.getString(1));
            }
            rs.close();

            // 6. 插入并获取事务 ID
            stmt.execute("INSERT INTO test_data (content) VALUES ('Hello Java')");
            rs = stmt.executeQuery("SELECT pg_current_xact_id()");
            long xid = 0;
            if (rs.next()) {
                xid = rs.getLong(1);
                System.out.println("Transaction ID: " + xid);
            }
            rs.close();

            // 7. 提交时间戳
            try {
                rs = stmt.executeQuery(
                    "SELECT pg_xact_commit_timestamp(" + xid + ")"
                );
                if (rs.next()) {
                    Timestamp ts = rs.getTimestamp(1);
                    System.out.println("Commit timestamp: " + ts);
                }
                rs.close();
            } catch (SQLException e) {
                System.out.println("track_commit_timestamp not enabled or error: " + e.getMessage());
            }

            // 8. 数据文件路径
            rs = stmt.executeQuery("SELECT pg_relation_filepath('test_data')");
            if (rs.next()) {
                System.out.println("File path: " + rs.getString(1));
            }
            rs.close();

            stmt.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

运行与验证

各语言运行方式:

语言依赖安装运行命令
Node.jsnpm install pgts-node demo.ts 或 node demo.js
Gogo mod init demo && go get github.com/lib/pqgo run demo.go
Pythonpip install psycopg2-binarypython demo.py
Java下载 postgresql-42.6.0.jar 并加入 classpathjavac PostgresDemo.java && java -cp .:postgresql-42.6.0.jar PostgresDemo

执行后,各程序会输出类似以下结果:

Database OID: 16384, name: demo_db
Tablespace created
relfilenode: 16552 (oid=16552)
work_mem: 16MB
Transaction ID: 12345
Commit timestamp: 2026-08-14 10:30:00.123456+00
File path: base/16384/16552

技术点总结(多语言视角)

  • 连接方式:Node.js 与 Python 原生支持 Unix Domain Socket;Go 的 lib/pq 同样支持;Java JDBC 默认支持 TCP/IP,需额外配置才能使用 Unix Socket,但可通过参数调整。
  • 元数据查询:所有语言均通过标准 SQL 查询系统表,无语言差异。
  • DDL 操作:CREATE TABLESPACE 和 CREATE TABLE ... TABLESPACE 在所有驱动中均以字符串拼接或参数化方式执行(注意路径注入风险,建议使用参数化或 sql.SQL 包装)。
  • 动态配置:ALTER SYSTEM 和 pg_reload_conf() 在所有语言中执行方式一致。
  • 事务 ID 与提交时间戳:使用系统函数,注意 track_commit_timestamp 开启的必要性。
  • 文件路径:pg_relation_filepath 返回相对路径,可直接对应 PGDATA/base/ 下的文件,便于诊断数据文件位置。

阶段性总结

上面提供了 Node.js、Go、Python 和 Java 四种语言操作 PostgreSQL 数据目录相关功能的完整示例,涵盖 OID 查询、表空间创建、relfilenode 获取、动态参数修改、事务 ID 与提交时间戳获取,以及数据文件路径定位。

各语言实现逻辑一致,差异仅在于驱动 API 和连接字符串的配置方式。这些示例为开发者快速集成 PostgreSQL 高级特性提供了可运行的模板,有助于理解数据库元数据与文件系统之间的映射关系,并为跨语言项目的数据库层开发提供参考。

项目难点与解决方案

核心难点

  • 数据目录损坏恢复:意外断电或磁盘故障可能导致 WAL 与数据文件不一致,需掌握 pg_resetwal 及 PITR 恢复流程。
  • 配置文件优先级混淆:在多配置源(postgresql.conf、auto.conf、ALTER SYSTEM)下确定最终生效值较为复杂。
  • 表空间在线迁移:生产环境中将表从旧表空间迁移至新表空间,需考虑锁时间与业务连续性。

解决方案

  • WAL 归档与备份策略:启用 archive_mode 和 archive_command,将 WAL 备份至远程存储,配合基础备份实现任意时间点恢复。
  • 使用 pg_settings 视图:查询 pg_settings 的 source、pending_restart 列,精准追溯参数来源。
  • 增量迁移:利用 pg_repack 或逻辑复制工具,实现零停机或极短停机窗口的表空间迁移。

广度

  • 涉及操作系统文件系统、磁盘 I/O、内存管理;
  • 涵盖网络安全(pg_hba.conf)、数据安全(备份恢复)、高可用(流复制);
  • 包含性能调优(FSM、VM、统计信息)与存储规划(表空间)。

深度

  • 深入剖析数据页结构与行版本管理;
  • WAL 日志物理格式与 Redo 操作原理;
  • 可见性判断机制(Hint Bits 与 pg_clog 协同工作)。

复杂度

  • 数据目录包含数十种子目录与文件类型,各版本间有演进(如 pg_xlog -> pg_wal);
  • 系统表之间依赖关系复杂,需理解元数据存储逻辑;
  • 生产环境中的并发、归档、监控增加了运维复杂性。

官方文档

参考链接

总结

本文深入解析了 PostgreSQL 数据目录(PGDATA)的完整结构,从默认表空间的 base/ 目录到事务日志 pg_wal/,从表空间符号链接到配置文件优先级策略。重点阐述了 OID 与 relfilenode 的映射关系、空闲空间映射(FSM)与可见性映射(VM)在性能优化中的作用,以及 postmaster.pid 防止实例重复启动的关键意义。

同时,详细对比了 postgresql.conf 与 postgresql.auto.conf 的加载顺序,以及 pg_hba.conf 的首次匹配规则。配套的 Node.js 演示代码完整展示了如何通过程序化方式操作上述功能,将理论落地于实践,为后续深入 PostgreSQL 内核架构与运维优化奠定坚实基础。

PostgreSQL数据目录结构详解:从PGDATA到base目录的完整解析 本文深入解析PostgreSQL数据目录结构,从PGDATA核心目录到base子目录的详细组成,揭示数据库物理存储的奥秘。通过实战案例展示如何利用目录结构进行空间管理、性能优化和数据恢复,特别包含查询Schema和表大小的实用技巧,帮助DBA高效管理PostgreSQL数据库。 阅读详情

相关推荐

PostgreSQL目录结构与核心配置参数深度解析

数据库管理系统作为现代应用的核心组件,其性能与稳定性直接取决于底层架构与配置机制。PostgreSQL作为一款开源关系型数据库,通过其精密的目录结构和配置文件实现数据存储、事务管理与查询优化。理解PGDATA目录的组织原理,掌握base、pg_wal等核心子目录的功能,是进行数据库运维与性能调优的基础。在配置层面,postgresql.conf文件作为数据库的“中枢神经系统”,通过shared_buffers、work_mem等内存参数控制资源分配,借助synchronous_commit、wal_leve

weixin_31240035的博客 332

PostgreSQL数据库目录文件详解

usr/local/postgresql/log路径自定义,可在此配置数据库的各种日志,配置了数据库启动关闭记录日志。相当于oracle的 /app/oracle 软件安装目录,psql、pg_ctl等软件可执行的一些命令都在这下面。相当于oracle建库时指定的数据目录,数据库所需的参数文件,数据文件等均在这下面。在Linux系统安装完PostgreSQL数据库之后,从环境变量里看它涉及的目录。

Auspicious航的博客 3703

PostgreSQL核心配置与目录结构深度解析:从原理到生产环境调优实践

数据库性能调优与稳定性保障是后端开发与运维的核心课题,其基础在于深入理解数据库系统的内部架构与运行机制。PostgreSQL作为一款功能强大的开源关系型数据库,其性能表现高度依赖于合理的配置参数与清晰的目录结构管理。从原理层面看,配置文件(如postgresql.conf)充当着数据库的“调控中枢”,通过调整内存分配、连接管理、WAL(预写式日志)等参数,直接影响查询效率与系统稳定性;而数据目录(如PGDATA)则如同数据库的“身体结构”,存储着表数据、事务日志等核心文件,其组织方式关系到数据安全与运维效率

weixin_33600816的博客 292

postgresql|数据库|pg数据库的文件系统详解---最全面的解析

postgresql是一个非常成熟的开源的功能强大的关系型数据库,总体来说,该数据库安装简单,使用复杂,复杂度在多个维度都会有所体现,比如,SQL语法的复杂(语法和MySQL,oracle等基本是一致的,这就比较友好了,虽然什么左联查,右联查,函数,触发器,约束等等内容非常多),文件系统的复杂(配置文件,标识文件,数据库文件等等),维护的复杂(备份和恢复工具比较多,需要根据自己的需求来仔细甄别,挑选,使用),优化的复杂(通常,数据库能跑起来是一件事,能高效率的,稳定的运行是另一回事) OK,那么,post

zsk_john的技术分享专用博客 3777

PostgreSQL存储结构全解析:从数据目录到表文件的命名规则

本文深度解析PostgreSQL存储结构,从数据目录的组织、表空间的设计逻辑,到数据文件命名规则(OID与relfilenode)的详细解读。通过剖析文件扩展机制与页、元组等微观存储单元,帮助DBA和开发者深入理解数据库物理存储,为性能调优、故障排查和存储规划提供坚实依据。

weixin_29231263的博客 219

Ubuntu 18.04下PostgreSQL数据目录迁移全指南

PostgreSQL数据目录迁移并非简单文件复制,而是涉及配置、权限与服务管理的系统级操作。其核心原理在于`data_directory`配置项与`-D`启动参数的优先级关系,以及systemd对服务单元的硬编码约束。技术价值体现在规避磁盘空间瓶颈、提升存储可维护性,并强化对Linux服务生命周期的理解。典型应用场景包括Ubuntu 18.04生产环境扩容、数据库运维调优及DevOps自动化部署。本文聚焦`postgresql.conf`配置同步与`systemctl`覆盖机制,详解如何通过drop-in片

weixin_30493401的博客 634

postgresql文件结构

postgresql文件结构

lltfjsy的博客 1649

CentOS 8 安装 PostgreSQL 的元数据与 systemd 深度解析

PostgreSQL 是一款开源关系型数据库,其在 CentOS 等基于 RPM 的 Linux 发行版中依赖严格的包管理与服务初始化机制。理解 AppStream 仓库的元数据同步原理、GPG 签名校验逻辑及 systemd 单元加载顺序,是解决 'cannot update repo appstream' 和 'failed to start postgresql.service' 等高频问题的关键。CentOS 8 彻底转向模块化仓库架构与 systemd 原生管理,导致传统 yum/chkconfi

weixin_33806914的博客 408

PostgreSQL数据库目录文件及其功能的详解

3. 日志文件(Log files):日志文件(通常以 .log 扩展名结尾)用于记录数据库的事务和故障恢复信息。7. 其他系统文件:除了以上文件和目录外,还有一些与 PostgreSQL 相关的其他系统文件,如 PID 文件(记录 PostgreSQL 服务器进程的进程 ID)、锁文件(用于控制并发访问)等。2. 数据文件(Data files):数据目录中的数据文件(通常以 .dat 扩展名结尾)包含了数据库中的实际数据。在 PostgreSQL 中,数据库的数据和元数据存储在各种文件和目录中。

Auspicious航的博客 4544

CentOS 7.6下PostgreSQL-12.0源码编译与生产环境部署指南

PostgreSQL作为企业级开源关系型数据库,凭借其完善的ACID特性和高度可扩展性,在OLTP和数据分析场景中广泛应用。源码编译安装方式相比二进制包能实现深度性能调优,特别是在高并发写入场景下,通过定制WAL日志段大小、内存分配等核心参数可显著提升吞吐量。本指南以CentOS 7.6为例,详细演示从开发工具链准备、编译参数优化到systemd服务集成的完整流程,重点解析shared_buffers、work_mem等关键参数的配置原则,并给出独立WAL目录部署、pg_stat_statements监控等

weixin_33743880的博客 512

从梯度泄露到数据复原:DLG与iDLG算法实战解析

本文深入解析了DLG与iDLG算法在梯度泄露与数据复原中的实战应用,揭示了联邦学习中的隐私风险。通过详细代码示例和实验数据,展示了如何从梯度中复原原始训练数据,并探讨了梯度压缩、差分隐私等防御措施。文章特别强调了iDLG算法在标签破解中的高效性,为AI安全领域提供了重要参考。

weixin_30552811的博客 193

【PostgreSQL】从零开始:(六)PostgreSQL-数据库目录文件结构及作用说明

总体上,FSM采用3-4级多叉树的结构组织FSM page,单个FSM page内部采用完全二叉树的结构进行管理,高级别FSM page的叶子节点关联低级别的FSM page,低级别FSM Page的叶子节点存储着heap、index page的可用空间数目,而非叶子结点依次存储叶子节点的最大可用空间数目,每个节点占用1个字节。PG 10及之后的高版本改目录名为pg_xact,10之前目录名称是pg_clog。1.首先,扫描WAL段文件所写入的目录,并发现最新完成的段文件,作为下一个段文件的开始的起始点。

圈小圈DBA的博客 1908

字符集的选择

字符集的选择 一:背景介绍 DICOM特定字符集(0008,0005) 此标签获得不同的值就代表使用不同的语言进行解码。 以下为多家CT厂商的(0008,0005)取值: 字符集: unicode是字符集,ASCII、GB2312、GBK、GB18030既是字符集也是编码方式,UTF-8只是编码方式。 二:中文字符集介绍 世界通用字符集——UTF 中文字符集——GB2312、GBK、GB18030 字符集的详细介绍 一:UTF-8 程序是把一个字节一个字节的来读取,然后再根据字节中开头的bit

qq_41972968的博客 1521

PostgreSQL 修改数据存储路径

PostgreSQL 修改数据存储路径

ideal-lingyun 7446

shopro 商城,2025年新申请的微信支付提示失败,支付提示 Get Wechat Public Cert Error 问题的修复办法

shopro 商城,最近新申请的微信支付商户 支付提示 Get Wechat Public Cert Error 问题的修复办法

行走的卡路里 1245

SAP CO-PA数据传送避坑指南:销售开票与FI/MM记账的日常配置实操(含KEKF/KE4I/KEI2)

本文深入解析SAP CO-PA数据传送中的常见配置问题,特别是销售开票与FI/MM记账环节的实操避坑指南。通过KEKF/KE4I/KEI2等关键配置点的详细说明,帮助用户避免数据失真和重复记录,提升获利能力分析的准确性。文章结合实战案例,揭示官方文档未提及的'数据黑洞'形成机制,为SAP顾问提供实用的排雷手册。

weixin_26905487的博客 391

postgresql数据库备份

根据备份文件类型可分为物理备份和逻辑备份根据备份时数据库状态可分为在线备份和离线备份根据备份数据量可分为全量备份和增量备份。

weixin_51262054的博客 4313

ENVI中Landsat8大气校正法实现地表温度精准反演

本文详细介绍了在ENVI软件中,利用大气校正法对Landsat8热红外数据进行地表温度反演的完整流程。该方法通过辐射定标、大气参数获取、发射率估算及温度转换四个核心步骤,精准剔除大气干扰,还原地表真实温度,是城市热岛效应监测、农业旱情分析等应用的关键技术。

weixin_29292535的博客 151

干货 | PostgreSQL数据表文件底层结构布局分析

1. 表文件 PostgreSQL提供了可靠、稳定、有序的数据存储、检索管理。即使在不知道其背后运行原理的情况下,也没有多大关系,因为我们只需要按部就班地执行建库、建表然后插入数据结构这几个流程,就可以如愿以偿地实现将我们的数据持久化于PostgreSQL数据库中。于是我们不得不好奇,这些数据最终落盘于磁盘上的哪个位置?又是以什么样的形式存储?存储的格式又是什么?在这几个疑问的驱动下,本文将通过源码结合数据入库实践操作的方式,来详细地对PostgreSQL底层数据的存储方式进行详细的解读。 Postgr

MyySophia的博客 3557

PySpark 本地开发环境搭建与实践

本文详细介绍了 PySpark 本地开发环境的搭建过程,包括 JDK、Hadoop、Anaconda、PySpark 的安装以及 Pycharm 工程的创建。同时,深入讲解了代码编写、本地开发案例(如 WordCount、处理特殊分隔符、读取 hdfs 数据、获取外部变量)、Spark 程序的监控和 local 模式下结果文件数量问题等内容。通过掌握这些知识和技能,读者可以在 Windows 本地环境中高效地进行 PySpark 开发,处理大规模数据,解决实际业务中的数据分析和处理问题。

天冬忘忧的博客 3016

编程_三大编程思想:POP、OOP、AOP

简单介绍POP、OOP、AOP三大编程思想的区别和优缺点~

mikimo的博客 3900

Ubuntu下安全迁移PostgreSQL数据目录到/mnt/pgdata完整指南

PostgreSQL数据目录是数据库集群的物理锚点,其位置直接影响性能隔离、存储扩展与安全策略落地。理解PGDATA的本质——即WAL日志、全局目录、表空间及事务状态的统一根路径——是安全迁移的前提。基于rsync的原子性同步与AppArmor的路径白名单机制,构成Ubuntu平台迁移的双重技术保障:前者通过-aHAX参数确保硬链接、ACL和扩展属性零丢失,后者以精确的rwk权限规则赋予新路径合法访问权。该方案广泛适用于SSD/NVMe磁盘升级、LVM快照备份、云服务器多盘挂载等生产场景,尤其解决/var分

435

17.6 LangSmith 私有化部署实战指南:企业级AI应用的安全基石

LangSmith 私有化部署, 企业级AI开发平台, 数据隐私合规, 混合云架构, 模型监控与审计。

yonggeit的博客 3780

PostgreSQL运维实战:日志与数据目录管理核心命令

数据库运维中,日志管理与数据目录监控是保障稳定性的关键技术。PostgreSQL作为企业级开源数据库,其WAL日志机制通过LSN(日志序列号)实现事务一致性,而数据目录结构则承载着表空间、事务日志等核心组件。合理配置日志轮转策略(如log_rotation_age参数)和监控数据目录空间使用(通过pg_total_relation_size函数),能有效预防存储溢出风险。本文详解通过du、ls命令组合实现日志文件分析,结合pg_wal_lsn_diff函数监控主从延迟,这些方法在金融交易、物联网等高并发场景

weixin_32705179的博客 258

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

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

OV9734 DATASHEET,完整规格书

OV9734完整规格书,包括电气参数,尺寸规格,寄存器配置表等

PostgreSQL 存储原理全解:从页面结构到 MVCC 的深度解析

对于 DBA、后端开发者以及数据库内核爱好者来说,PostgreSQL 的存储层是整个系统的基石。不论是进行性能调优、容量规划、故障排查,还是设计高可用的流复制架构,对数据如何在磁盘上布局、多版本如何创建与清理、WAL 如何保障一致性的透彻理解,都会直接决定你解决问题的速度和方案的可靠性。PostgreSQL 官方文档的“Database Physical Storage”章节以及源代码中和的注释为本文提供了最权威的依据。

m0_73669661的博客 946

VC中sqlite的使用

在VC中对sqlite的使用,实现数据库大批数据的快速插入,读取数据库中的数据在ListCtrl中显示

PostgreSQL 工程化部署深度解析

本文档是PostgreSQL工程化部署的深度解析,主要包含以下核心内容: 架构设计:采用Docker容器化部署,实现数据与计算分离,确保容器可销毁重建而不丢失数据。 部署全流程解析: 从环境准备(Docker验证、国内镜像源配置) 到Compose声明式部署(详解docker-compose.yml每个配置项) 再到连接验证与管理维护 关键设计理念: 声明式配置管理 最小权限原则(非root运行) 完善的监控与健康检查机制 完整的备份恢复方案 深度技术解析: 逐行拆解所有配置命令和参数 阐明每个操作的技术原

A1063348628的博客 465

ET2012新版免狗免安装绿色软件

ET2012新版免狗免安祖昂绿色软件。,新界面,新视觉,

上一篇: PostgreSQL笔记11:安装部署阶段常见问题排查与解决方案
下一篇: PostgreSQL笔记13:SQL语言基础、数据类型、约束与事务控制
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、付费专栏及课程。

余额充值