PostgreSQL

![](/media/202509/2025-09-12_205857_4146940.6377809625826508.png)

## 概述

PostgreSQL是一个功能强大的、开源的、面向对象的**关系型数据库管理系统**（ORDBMS）。它起源于加州大学伯克利分校的 POSTGRES 项目，1986 年首次发布，经过数十年发展，已成为企业级应用、数据仓库、科研等场景的首选数据库之一，以其**高度的可靠性**、**功能完整性**和**对标准 SQL 的严格遵循**而闻名。

官网地址：官方网站：https://www.postgresql.org/（提供完整文档、下载、社区资源）

**默认端口**：5432（可在配置文件 postgresql.conf 中通过 port 参数修改），若同一服务器部署多个 PostgreSQL 实例，需指定不同端口（如 5433、5434）。

**默认超级用户**：postgres（类似 MySQL 的 root，拥有最高权限）。

**默认数据库**：

- postgres：默认管理员数据库，postgres 用户登录时的默认数据库。
- template0 和 template1：模板数据库，新建数据库时默认以 template1 为模板复制结构（template0 为纯净模板，用于创建与模板无关的数据库）。
- postgres 数据库通常作为管理入口，实际业务数据需创建新数据库存储。

## 核心

| 特性                 | 说明                                                         |
| -------------------- | ------------------------------------------------------------ |
| **完全 ACID 兼容**   | 严格支持事务的原子性（Atomicity）、一致性（Consistency）、隔离性（Isolation）、持久性（Durability），确保数据可靠性。 |
| **强大的 SQL 支持**  | 全面兼容 SQL 标准（SQL:2016），支持复杂查询、子查询、窗口函数、CTE（公用表表达式）等高级语法。 |
| **丰富的数据类型**   | 除基础类型（int、varchar、date 等）外，支持： - 复杂类型：数组（array）、JSON/JSONB（二进制 JSON，支持索引）、枚举（enum）、地理信息（geometry/geography，需 PostGIS 插件）； - 自定义类型：可通过 CREATE TYPE 定义业务专属类型。 |
| **高级索引功能**     | 支持 B-tree（默认）、Hash、GiST（空间索引）、GIN（JSON / 数组索引）、BRIN（大数据块范围索引）等，优化各种查询场景。 |
| **并发控制（MVCC）** | 采用多版本并发控制（Multi-Version Concurrency Control），读写不阻塞（读不加锁，写不影响读），高并发场景性能优异。 |
| **可扩展性**         | 支持自定义函数（用 SQL、PL/pgSQL、Python、Java 等语言编写）、操作符、存储过程、触发器，以及大量插件（如 PostGIS 地理信息、pg_trgm 模糊查询）。 |
| **安全性**           | 支持行级安全策略（RLS）、列级权限控制、SSL 加密传输、密码哈希存储、LDAP/Kerberos 认证集成等。 |
| **高可用与复制**     | 内置流复制（Stream Replication）实现主从架构，支持同步 / 异步复制；结合 Patroni、PgBouncer 等工具可实现自动故障转移和连接池管理。 |
| **数据分区**         | 支持范围分区（Range）、列表分区（List）、哈希分区（Hash），将大表拆分到多个子表，提升查询效率。 |

## 数据库操作

可通过PostgreSQL 自带命令行工具（psql）连接：

```bash
# 本地连接（默认用户 postgres，默认数据库 postgres）
psql -U postgres -d postgres

# 远程连接（指定主机、端口、用户、数据库）
psql -h 192.168.1.100 -p 5432 -U username -d dbname
```

**创建数据库**

语法：
```sql
CREATE DATABASE 数据库名
  [WITH OWNER = 用户名]  -- 指定数据库所有者
  [ENCODING = '编码']   -- 字符编码（如 UTF8）
  [LC_COLLATE = '排序规则']  -- 字符串排序规则（如 zh_CN.UTF-8）
  [LC_CTYPE = '字符分类']    -- 字符分类（如 zh_CN.UTF-8）
  [TABLESPACE = 表空间名];  -- 指定表空间（可选）

```

示例：
```sql
-- 创建一个名为 shop_db 的数据库，所有者为 user1，UTF8 编码
CREATE DATABASE shop_db
  WITH OWNER = user1
  ENCODING = 'UTF8'
  LC_COLLATE = 'zh_CN.UTF-8'
  LC_CTYPE = 'zh_CN.UTF-8';
```

**查看数据库**

```sql
-- 查看所有数据库
\l  -- psql 元命令（非 SQL 标准）
-- 或 SQL 标准查询
SELECT datname FROM pg_database;

-- 切换当前数据库
\c shop_db  -- psql 元命令，切换到 shop_db

```

**修改数据库**

语法：
```sql
ALTER DATABASE 数据库名
  [RENAME TO 新数据库名]  -- 重命名
  [OWNER TO 新所有者]    -- 变更所有者
  [SET TABLESPACE 新表空间]  -- 变更表空间
  [SET 参数 = 值];  -- 临时修改数据库级参数（如 SET work_mem = '16MB'）
```

示例：
```sql
-- 将 shop_db 重命名为 ecommerce_db
ALTER DATABASE shop_db RENAME TO ecommerce_db;

-- 变更数据库所有者为 admin_user
ALTER DATABASE ecommerce_db OWNER TO admin_user;

```

**删除数据库**

语法：
```sql
DROP DATABASE [IF EXISTS] 数据库名;  -- IF EXISTS 避免删除不存在的数据库时报错
```

示例：
```sql
-- 删除 ecommerce_db（确保无连接，否则需先断开）
DROP DATABASE IF EXISTS ecommerce_db;
```

## 表操作

**创建表**

语法：

```sql
CREATE TABLE 表名 (
  列名 数据类型 [约束],
  ...
  [表级约束]
);
```

常见约束：PRIMARY KEY（主键）、FOREIGN KEY（外键）、NOT NULL（非空）、UNIQUE（唯一）、CHECK（条件检查）。

示例：创建用户表 users 和订单表 orders（含外键关联）。

```sql
-- 创建用户表
CREATE TABLE users (
  id SERIAL PRIMARY KEY,  -- SERIAL 自动增长整数（类似 AUTO_INCREMENT）
  username VARCHAR(50) NOT NULL UNIQUE,  -- 用户名唯一且非空
  email VARCHAR(100) NOT NULL UNIQUE,
  age INT CHECK (age >= 0),  -- 年龄不能为负数
  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP  -- 默认当前时间
);

-- 创建订单表（外键关联 users.id）
CREATE TABLE orders (
  id SERIAL PRIMARY KEY,
  user_id INT NOT NULL,
  total_amount NUMERIC(10, 2) NOT NULL CHECK (total_amount >= 0),  -- 金额保留2位小数，非负
  status VARCHAR(20) NOT NULL DEFAULT 'pending',
  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
  -- 外键约束：订单所属用户必须存在于 users 表
  FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE  -- 级联删除：用户删除时，其订单也删除
);
```

**查看表**

```sql
-- 查看当前数据库所有表
\dt  -- psql 元命令

-- 查看表结构
\d users  -- psql 元命令，查看 users 表结构

-- SQL 标准查询表信息
SELECT column_name, data_type, is_nullable 
FROM information_schema.columns 
WHERE table_name = 'users';
```

**修改表**

语法：

```sql
ALTER TABLE 表名
  [ADD COLUMN 列名 数据类型 [约束]]  -- 添加列
  [ALTER COLUMN 列名 数据类型]  -- 修改列类型
  [RENAME COLUMN 旧列名 TO 新列名]  -- 重命名列
  [DROP COLUMN 列名]  -- 删除列
  [ADD CONSTRAINT 约束名 约束定义]  -- 添加约束
  [DROP CONSTRAINT 约束名];  -- 删除约束
```

示例：
```sql
-- 向 users 表添加 phone 列
ALTER TABLE users ADD COLUMN phone VARCHAR(20) UNIQUE;

-- 修改 users 表的 age 列类型为 SMALLINT（节省空间）
ALTER TABLE users ALTER COLUMN age TYPE SMALLINT;

-- 重命名 orders 表的 total_amount 列为 amount
ALTER TABLE orders RENAME COLUMN total_amount TO amount;

-- 向 orders 表添加索引（优化查询）
ALTER TABLE orders ADD CONSTRAINT idx_orders_user_id INDEX (user_id);

```

**删除表**

语法：
```sql
DROP TABLE [IF EXISTS] 表名 [CASCADE];  -- CASCADE 级联删除依赖该表的对象（如外键关联的表）
```

示例：

```sql
-- 删除 orders 表（若有外键依赖，需先删除依赖或用 CASCADE）
DROP TABLE IF EXISTS orders CASCADE;

-- 删除 users 表
DROP TABLE IF EXISTS users;

```

## 数据操作

**插入数据**

语法：
```sql
INSERT INTO 表名 (列1, 列2, ...) VALUES (值1, 值2, ...);
-- 批量插入
INSERT INTO 表名 (列1, 列2, ...) VALUES (值1, 值2, ...), (值3, 值4, ...);

```

示例：
```sql
-- 插入单条用户数据
INSERT INTO users (username, email, age) 
VALUES ('zhangsan', 'zhangsan@example.com', 25);

-- 批量插入订单数据
INSERT INTO orders (user_id, amount, status)
VALUES 
  (1, 99.99, 'paid'),
  (1, 159.50, 'pending'),
  (2, 299.00, 'paid');  -- 假设 user_id=2 已存在

```

**查询数据**

语法：

```sql
SELECT [DISTINCT] 列1, 列2, ...  -- DISTINCT 去重
FROM 表名
[WHERE 条件]  -- 筛选行
[GROUP BY 列]  -- 分组
[HAVING 分组条件]  -- 筛选分组
[ORDER BY 列 [ASC|DESC]]  -- 排序（ASC升序，DESC降序）
[LIMIT 数量 OFFSET 偏移量];  -- 限制结果数量（分页）
```

示例：

```sql
-- 基础查询：查询所有用户
SELECT * FROM users;

-- 条件查询：年龄 > 20 且邮箱含 'example.com' 的用户
SELECT username, age, email 
FROM users 
WHERE age > 20 AND email LIKE '%example.com%';

-- 排序与分页：按创建时间降序，取前2条
SELECT username, created_at 
FROM users 
ORDER BY created_at DESC 
LIMIT 2 OFFSET 0;  -- OFFSET 0 表示从第1条开始

-- 分组统计：按订单状态分组，统计每个状态的订单数和总金额
SELECT 
  status, 
  COUNT(*) AS order_count, 
  SUM(amount) AS total_amount 
FROM orders 
GROUP BY status 
HAVING SUM(amount) > 100;  -- 只保留总金额>100的分组

-- 连接查询：查询用户及其订单（内连接）
SELECT 
  u.username, 
  o.id AS order_id, 
  o.amount, 
  o.status 
FROM users u
INNER JOIN orders o ON u.id = o.user_id;
```

**更新数据**

语法：

```sql
UPDATE 表名
SET 列1 = 值1, 列2 = 值2, ...
[WHERE 条件];  -- 若不写 WHERE，将更新表中所有行（谨慎！）
```

示例：
```sql
-- 更新用户年龄
UPDATE users 
SET age = 26 
WHERE username = 'zhangsan';

-- 批量更新订单状态（将 pending 改为 paid）
UPDATE orders 
SET status = 'paid', updated_at = CURRENT_TIMESTAMP  -- 假设已添加 updated_at 列
WHERE status = 'pending' AND created_at < '2024-01-01';

```

**删除数据**

```sql
DELETE FROM 表名
[WHERE 条件];  -- 若不写 WHERE，将删除表中所有行（谨慎！）
```

示例：
```sql
-- 删除指定用户的订单
DELETE FROM orders 
WHERE user_id = 1 AND status = 'pending';

-- 删除年龄 > 100 的用户（假设业务上不可能存在）
DELETE FROM users 
WHERE age > 100;
```

## 特有功能

**JSON/JSONB类型操作**

PostgreSQL 对 JSON 数据支持强大，尤其是 JSONB（二进制存储，支持索引，查询更快）。

```sql
-- 创建含 JSONB 字段的表
CREATE TABLE products (
  id SERIAL PRIMARY KEY,
  info JSONB NOT NULL  -- 存储商品详情（如名称、价格、标签）
);

-- 插入 JSONB 数据
INSERT INTO products (info)
VALUES 
  ('{"name": "笔记本电脑", "price": 5999, "tags": ["电子", "办公"], "stock": 100}'),
  ('{"name": "机械键盘", "price": 299, "tags": ["外设", "游戏"], "stock": 200}');

-- 查询 JSONB 字段（-> 取JSON对象，->> 取文本值）
SELECT 
  info->>'name' AS product_name,  -- 取 name 的文本值
  (info->'price')::NUMERIC AS price  -- 取 price 并转为数字
FROM products;

-- 条件查询（JSONB 字段中的标签包含 "游戏"）
SELECT info->>'name' 
FROM products 
WHERE info->'tags' ? '游戏';  -- ? 检查数组是否包含元素

-- 为 JSONB 字段创建索引（优化查询）
CREATE INDEX idx_products_info_tags ON products USING GIN (info->'tags');
```

**数组类型操作**

PostgreSQL 支持数组类型，可直接存储多个值。

```sql
-- 创建含数组字段的表
CREATE TABLE posts (
  id SERIAL PRIMARY KEY,
  title VARCHAR(100) NOT NULL,
  tags TEXT[] NOT NULL  -- 标签数组（TEXT类型）
);

-- 插入数组数据
INSERT INTO posts (title, tags)
VALUES 
  ('PostgreSQL 入门', '{数据库, PostgreSQL, 教程}'),  -- 数组语法1
  ('Python 数据分析', ARRAY['Python', '数据分析', 'Pandas']);  -- 数组语法2

-- 查询数组包含指定元素的记录
SELECT title 
FROM posts 
WHERE 'PostgreSQL' = ANY(tags);  -- ANY 检查数组是否包含元素

-- 查询数组长度
SELECT title, array_length(tags, 1) AS tag_count  -- 1 表示一维数组
FROM posts;

-- 更新数组（添加元素）
UPDATE posts 
SET tags = array_append(tags, '数据库入门')  -- array_append 向数组添加元素
WHERE title = 'PostgreSQL 入门';
```

**窗口函数**

窗口函数用于对一组行执行计算（类似聚合），但不会合并行，适合排名、分组内计算等场景。

```sql
-- 按用户分组，计算每个用户的订单金额排名（组内排序）
SELECT 
  user_id,
  id AS order_id,
  amount,
  ROW_NUMBER() OVER (PARTITION BY user_id ORDER BY amount DESC) AS rank_in_user  -- 按用户分组，金额降序排名
FROM orders;

-- 计算所有订单的累计金额（全局排序）
SELECT 
  id AS order_id,
  amount,
  SUM(amount) OVER (ORDER BY created_at) AS cumulative_total  -- 按创建时间累计求和
FROM orders;
```

## 用户与权限管理

**创建用户**

```sql
-- 创建用户（带密码）
CREATE USER user1 WITH PASSWORD 'user1_password';

-- 创建超级用户（谨慎！）
CREATE USER admin WITH PASSWORD 'admin_password' SUPERUSER;

```

**授权权限**

```sql
-- 授予 user1 对 ecommerce_db 数据库的所有权限
GRANT ALL PRIVILEGES ON DATABASE ecommerce_db TO user1;

-- 授予 user1 对 users 表的查询和插入权限
GRANT SELECT, INSERT ON TABLE users TO user1;

-- 授予 user1 对 orders 表的所有权限（包括删除、更新）
GRANT ALL PRIVILEGES ON TABLE orders TO user1;

```

**撤销权限**

```sql
-- 撤销 user1 对 orders 表的删除权限
REVOKE DELETE ON TABLE orders FROM user1;
```

## 权限体系

PostgreSQL 的权限管理基于 **RBAC（基于角色的访问控制）** 模型，所有权限通过 “角色” 分配，用户本质上是可登录的角色。

权限查询需依托 PostgreSQL 内置的系统视图（如 pg_roles、information_schema 系列视图），而权限审计则需结合内置日志或第三方扩展（如 pgAudit）实现。

**角色类型**：

- 登录角色（Login Role）：可通过客户端连接数据库（对应 “用户”），需设置 LOGIN 属性。
- 组角色（Group Role）：不可登录，用于批量管理权限（类似 “用户组”），通过 IN ROLE 关联其他角色。

**权限类型**：

- 系统权限：管理数据库实例的权限（如 SUPERUSER、CREATEROLE、CREATEDB、REPLICATION）。
- 对象权限：操作数据库对象的权限（如对表的 SELECT/INSERT、对函数的 EXECUTE、对数据库的 CONNECT）。
- 继承权限：角色默认继承所属组角色的权限（可通过 NOINHERIT 关闭）。

## 权限查询

PostgreSQL 提供了 **系统视图** 和 **psql 快捷命令**，可覆盖 “角色权限”“对象权限”“成员关系” 等核心查询场景。

**psql 快捷命令**

psql（PostgreSQL 自带客户端）提供了简化的权限查询命令，适合快速查看：

| 命令             | 用途                                    | 示例结果说明                         |
| ---------------- | --------------------------------------- | ------------------------------------ |
| \du [角色名]     | 查看所有 / 指定角色的系统权限与成员关系 | 显示角色的 SUPERUSER/CREATEDB 等属性 |
| \dp [对象名]     | 查看指定对象（表 / 视图）的权限分配     | 显示 “哪个角色对该表有哪些权限”      |
| \l+ [数据库名]   | 查看数据库的权限（如 CONNECT）          | 显示角色对数据库的连接 / 创建权限    |
| \z [模式名.表名] | 同 \dp，更详细的对象权限列表            | 包含列级权限（若存在）               |

**系统视图：精细化权限查询**

若需自定义查询条件（如 “查询所有有表修改权限的角色”），需直接查询系统视图。核心视图包括：

- pg_roles：存储所有角色的系统权限（如 rolsuper、rolcreaterole）。
- information_schema.table_privileges：存储表 / 视图的对象权限。
- information_schema.column_privileges：存储列级权限（细化到表的某一列）。
- pg_auth_members：存储角色间的成员关系（谁属于哪个组角色）。

查询当前登录角色的权限：

```sql
-- 1. 查看当前角色的系统权限（如是否为超级用户）
SELECT rolname, rolsuper, rocreaterole, rocreatedb, rolinherit
FROM pg_roles
WHERE rolname = CURRENT_USER; -- CURRENT_USER 表示当前登录角色

-- 2. 查看当前角色可访问的数据库（需 CONNECT 权限）
SELECT datname, datallowconn
FROM pg_database
WHERE has_database_privilege(CURRENT_USER, datname, 'CONNECT');

-- 3. 查看当前角色在当前数据库中的表权限
SELECT table_name, privilege_type
FROM information_schema.table_privileges
WHERE grantee = CURRENT_USER -- grantee 是权限被授予者
  AND table_catalog = CURRENT_DATABASE(); -- 限定当前数据库

```

查询指定角色的权限与成员关系：
```sql
-- 1. 查询角色 app_user 的所有系统权限
SELECT rolname, 
       rolsuper AS "超级用户",
       rocreaterole AS "可创建角色",
       rocreatedb AS "可创建数据库",
       rotreplication AS "可复制"
FROM pg_roles
WHERE rolname = 'app_user';

-- 2. 查询角色 app_user 所属的组角色（即继承哪个组的权限）
SELECT pg_get_userbyid(member) AS "成员角色",
       pg_get_userbyid(roleid) AS "组角色"
FROM pg_auth_members
WHERE member = (SELECT oid FROM pg_roles WHERE rolname = 'app_user');

-- 3. 查询角色 app_admin 拥有的表权限（含继承的组权限）
SELECT table_schema || '.' || table_name AS "表名",
       privilege_type AS "权限类型",
       grantor AS "授权者"
FROM information_schema.table_privileges
WHERE grantee = 'app_admin'
  OR grantee IN (-- 包含组角色的权限（因角色继承）
    SELECT pg_get_userbyid(roleid) 
    FROM pg_auth_members 
    WHERE member = (SELECT oid FROM pg_roles WHERE rolname = 'app_admin')
  );

```

查询对象（表 / 列 / 函数）的权限分配：

```sql
-- 1. 查询表 public.user_info 的所有权限分配
SELECT grantee AS "被授权角色",
       privilege_type AS "权限",
       is_grantable AS "是否可转授（WITH GRANT OPTION）"
FROM information_schema.table_privileges
WHERE table_name = 'user_info'
  AND table_schema = 'public'; -- 模式名（默认 public）

-- 2. 查询表 public.user_info 的列级权限（如仅部分列允许更新）
SELECT column_name AS "列名",
       grantee AS "被授权角色",
       privilege_type AS "权限"
FROM information_schema.column_privileges
WHERE table_name = 'user_info'
  AND table_schema = 'public';

-- 3. 查询函数 public.get_user(INT) 的执行权限
SELECT proname AS "函数名",
       pg_get_userbyid(proowner) AS "所有者",
       has_function_privilege(proname, oid, 'EXECUTE') AS "当前角色是否可执行"
FROM pg_proc
WHERE proname = 'get_user'
  AND pg_get_function_arguments(oid) = 'integer'; -- 匹配函数参数（避免同名）

```

## 权限审计

权限审计的核心是 **记录 “谁在何时执行了权限相关操作”**（如 GRANT/REVOKE、角色创建 / 删除、登录失败等）。

PostgreSQL 本身无内置审计模块，需通过 **日志配置** 或 **pgAudit 扩展** 实现。

**通过 PostgreSQL 内置日志**

PostgreSQL 的 postgresql.conf 配置文件可记录基础权限相关操作，适合轻量审计需求。

步骤1：修改日志配置（postgresql.conf）
```ini
# 1. 启用日志（默认可能关闭，需设置为 csvlog 或 stderr）
log_destination = 'csvlog' -- 推荐 csvlog，便于后续分析
logging_collector = on
log_directory = 'pg_log' -- 日志存储目录（需PostgreSQL有权限写入）
log_filename = 'postgresql-%Y-%m-%d_%H%M%S.log' -- 日志文件名格式

# 2. 记录权限相关操作（关键配置）
log_statement = 'ddl' -- 记录所有 DDL 操作（含 CREATE ROLE、GRANT、REVOKE）
log_connections = on -- 记录所有登录成功的连接
log_disconnections = on -- 记录所有断开连接的操作
log_failed_auth = on -- 记录登录失败（如密码错误、无 CONNECT 权限）
log_line_prefix = '%t [%p]: [%c-1] user=%u,db=%d,app=%a,client=%h ' -- 日志前缀（含时间、用户、数据库、客户端IP）

```

步骤2：生效配置与查看日志

- 重启 PostgreSQL 或执行 SELECT pg_reload_conf(); 使配置生效。
- 日志文件位于 data/pg_log/（data 是 PostgreSQL 数据目录），可直接查看或用工具（如 pgBadger）分析。

```text
2024-05-20 14:30:00 UTC [1234]: [1-1] user=postgres,db=postgres,app=psql,client=192.168.1.100 LOG:  statement: GRANT SELECT ON public.user_info TO app_user;
```

**使用 pgAudit 扩展**

pgAudit 是 PostgreSQL 官方推荐的审计扩展，支持细粒度审计（如指定审计某角色、某表的操作），功能远超内置日志。

步骤 1：安装 pgAudit

- 源码安装：从 [pgAudit 官网](https://github.com/pgaudit/pgaudit) 下载源码，编译后复制 pgaudit.so 到 PostgreSQL 的 lib 目录。
- 包管理安装（如 Ubuntu/Debian）

```bash
apt install postgresql-15-pgaudit # 15 是 PostgreSQL 版本
```

步骤 2：配置 pgAudit（postgresql.conf）

```ini
# 1. 加载 pgAudit 扩展（需重启 PostgreSQL）
shared_preload_libraries = 'pgaudit' -- 新增，多个扩展用逗号分隔

# 2. 配置审计策略（核心参数）
pgaudit.log = 'ddl, permissions' -- 审计 DDL 和权限操作（GRANT/REVOKE）
pgaudit.log_catalog = off -- 不审计系统目录（避免日志冗余）
pgaudit.log_parameter = on -- 记录操作中的参数（如 GRANT 中的角色名）
pgaudit.log_level = 'log' -- 审计日志级别（同普通日志）
pgaudit.log_role = 'audit_admin' -- 仅审计角色 audit_admin 执行的操作（可选，细粒度控制）
```

步骤 3：创建审计扩展与测试

```sql
-- 1. 在目标数据库中创建 pgAudit 扩展（需超级用户权限）
CREATE EXTENSION IF NOT EXISTS pgaudit;

-- 2. 执行权限操作（触发审计）
GRANT UPDATE ON public.user_info TO app_user;

-- 3. 查看审计日志（位于 pg_log 目录）
-- 示例审计日志（含详细权限操作信息）：
2024-05-20 14:45:00 UTC [5678]: [2-1] user=postgres,db=app_db,app=psql,client=192.168.1.100 AUDIT:  OBJECT,1,1,GRANT,UPDATE,TABLE,public.user_info,postgres,app_user,

```